Construct order-17 Gaussian-dyadic Clifford attaining native rank eight (no κ)

research/order-seventeen-clifford/PROOF.md

@@ -0,0 +1,165 @@
+# Order seventeen and the sharp rank-eight response cap
+
+Prepared by apoursh with substantial OpenAI Codex assistance. Apache-2.0.
+The upper bound and Bell-spectator method are credited to Nick Petalas's
+[PR6192](sources/pr6192-PROOF.md), head
+`91df334ccd2a4bc9959e311f118ac8aaf967ffc2`; its Pauli-character step retains
+Ross Richardson's credit. The new contribution is the explicit order-17
+matrix, signed-generator certificate and rank-eight specialization.
+
+## 1. Conventions and the four-qubit construction
+
+Index the computational basis by integers `x=sum_j 2^j x_j`, with bits
+`j=0,1,2,3`. Matrix products act rightmost first. Let
+
+```text
+Hg = (1+i)/2 [[1,1],[1,-1]],  S = diag(1,i),
+A  = [[0,0,0,1], [0,0,1,0], [0,1,0,1], [1,0,1,1]],
+U  = i S_3 CZ_03 CZ_12 CZ_23 Hg^(tensor 4).
+```
+
+All factors are Gaussian-dyadic unitaries normalizing the Pauli group;
+therefore U is a Gaussian-dyadic Clifford. Because `Hg=e^(pi i/4)H`,
+its fourth tensor power is `-H^(tensor 4)`. Consequently every matrix
+entry is given explicitly by
+
+```text
+U[x,y] = (-i/4) i^(x_3)
+         (-1)^(x_0 x_3 + x_1 x_2 + x_2 x_3 + sum_j x_j y_j).
+```
+
+The prefactor `-i` is part of the assertion. Replacing U by iU preserves
+Cliffordness but changes its seventeenth power to iI and destroys Phi17.
+
+Here is a complete integer certificate specification. Set `G=4U`, let
+`P_0=I16` and `P_(j+1)=P_j G`, all over Gaussian integers. Exact
+multiplication gives
+
+```text
+G G* = 16 I16,
+P_17 = 4^17 I16,
+sum_(j=0)^16 4^(16-j) P_j = 0,
+Tr(G) = -4.
+```
+
+These are equalities of all 256 entries, not sampled vectors or floating
+point residuals. `independent.py` evaluates exactly this unreduced integer
+recurrence. `verify.py` separately reduces a common denominator after each
+Gaussian matrix operation, and checks all powers U^j for j=0,...,17.
+It additionally finds denominator four and trace -1 for every j=1,...,16.
+Thus U has exact order 17 and satisfies the actual whole-bank primitive
+relation `Phi17(U)=I+U+...+U^16=0`. Exact order follows because 17 is prime
+and U is not the identity, as its trace is -1 rather than 16.
+
+This is a complete finite certificate backed by explicit arithmetic, not
+a formal-kernel verification or an extrapolation to unknown matrices.
+
+## 2. Signed Pauli action
+
+Use `X^x Z^z` in that order and Hermitian representatives
+`P(x,z)=i^(sum_j x_j z_j) X^x Z^z`. Write binary labels as columns
+`(x_0,...,x_3,z_0,...,z_3)`. Direct conjugation gives
+
+```text
+U X_j U* = Z_j,
+U Z_j U* = i^(A_jj) X_j product_k Z_k^(A_kj).
+```
+
+Each displayed image is the positive Hermitian representative. Both
+checkers verify all eight generator equalities as full complex matrices,
+including their phases. Hence the induced binary symplectic map is
+
+```text
+S_U = [[0,I4],[I4,A]],
+row masks = [16,32,64,128,129,66,164,216].
+```
+
+Its order is 17, its native upper-right block is `I4` of rank four,
+and `rank(S_U-I8)=8`. For the last claim, a vector in its kernel has
+`x=z` and `Ax=0`. A is invertible: `Av=(v3,v2,v1+v3,v0+v2+v3)`
+vanishes only for v=0. Thus the kernel is trivial. These facts are also
+checked over F2 without using floating point ranks.
+
+## 3. Eight-qubit saturation
+
+Let D be the four active qubits and E four identity spectators. Put
+
+```text
+V = (product_(j=0)^3 CNOT(j -> j+4)) (Hg^(tensor 4) tensor I16),
+W = V^-1 (U tensor I16) V.
+```
+
+V and its inverse are Gaussian-dyadic Clifford circuits. Polynomial
+evaluation commutes with tensoring an identity and with conjugation, so
+
+```text
+Phi17(W) = V^-1 (Phi17(U) tensor I16) V = 0.
+```
+
+This identity is on all 256 coordinates; the spectators need not be
+initialized. It does not assert that their state is restored by a caller:
+W generally couples the two registers. The proof avoids an unnecessary
+dense 256-dimensional power computation by using the already certified
+16-dimensional identity and these exact algebraic operations.
+
+To compute the native block, order labels as `(x_D,x_E,z_D,z_E)`.
+For input Z label `(d,e)`, V sends `(0,0,d,e)` to `(d,d,e,e)`.
+The embedded active map sends this to `(e,d,d+Ae,e)`.
+Applying V^-1 gives output X label
+
+```text
+(d+(A+I)e, d+e).
+```
+
+Therefore `B_W=[[I,A+I],[I,I]]`. If it kills `(d,e)`, the second
+equation gives d=e and the first then gives Ae=0, so d=e=0.
+Thus its rank is eight. Both checkers also build V from its individual
+binary Hadamard/CNOT actions, perform the complete conjugation and
+recover this block. The primary checker verifies symplecticity, order
+and defect rank eight. Additional identity spectators preserve both
+the polynomial relation and native rank eight for every M>=8.
+
+## 4. Why eight is the cap
+
+This is the n=17 specialization of Petalas's theorem, not a new general
+upper-bound argument. A whole-bank Gaussian-rational Clifford T on M
+qubits satisfying Phi17(T)=0 has characteristic polynomial `Phi17^t`,
+where `t=2^(M-4)`. Indeed Phi17 is irreducible over Q(i), since
+`[Q(zeta68):Q(i)]=phi(68)/2=16`. Thus M>=4 and `Tr(T)=-2^(M-4)`.
+
+On the fixed space K of its binary Pauli action S_T, the signs of
+Hermitian Pauli conjugation form a character. Their sum is the trace
+of the adjoint action, namely `|Tr(T)|^2=2^(2M-8)>0`. A character
+sum is either zero or |K|, hence `dim K=2M-8` and
+`rank(S_T-I)=8`. The native B block is a submatrix of S_T-I, so
+its rank is at most `min(M,8)`. Section 3 attains eight for every
+M>=8. Four is the least possible active width; eight is the least
+ambient width that can have an 8-by-8 full-rank native block.
+
+The complete cited proof, including the character argument and its
+classical field-degree source, is retained in
+[the predecessor document](sources/pr6192-PROOF.md). Its pending status
+does not imply maintainer acceptance. The concrete identities above
+are checked independently of predecessor executable code.
+
+## 5. Boundaries and failure controls
+
+Finite order alone is insufficient. U tensor U has order 17, but
+
+```text
+Tr(Phi17(U tensor U)) = 16^2 + 16(-1)^2 = 272 != 0.
+```
+
+Other controls show that removing a CZ edge or omitting one polynomial
+term fails Phi17; identity spectators without V leave native rank four;
+an asymmetric proposed phase matrix is not symplectic; and the ordinary
+companion matrix of Phi17 satisfies the polynomial but is not unitary.
+These distinguish actual hypotheses rather than testing only that the
+code can reproduce its own constants.
+
+The displayed W uses 12 H-type factors (including inverse Hg), eight
+CNOTs, three CZs, one S and a scalar phase i. This is only an algebraic
+factor inventory. Whether those factors are native, how they align with
+an actual producer/consumer, and their complete paid and target bill
+are not established. There is no ownership/restoration certificate,
+new supplier, new kappa or full multiplication theorem here.

research/order-seventeen-clifford/README.md

@@ -0,0 +1,149 @@
+# An explicit order-seventeen Gaussian-dyadic Clifford
+
+**Scoped construction and exact finite certificate; no new multiplication bound.**
+
+This answers the order-17 existence question in Nick Petalas's pending
+[PR6192](https://github.com/CrocSwap/integer-mult-bounds/pull/6192), pinned at
+`91df334ccd2a4bc9959e311f118ac8aaf967ffc2`. We give a four-qubit Clifford
+whose actual matrix satisfies `Phi17(U)=0`, then apply that predecessor's
+Bell-spectator method to attain its native `B`-rank cap of eight on eight
+qubits. The construction works over `Z[i,1/2]`, including its global phase.
+
+With little-endian qubits `0,1,2,3`, rightmost factors acting first, set
+
+```text
+Hg = (1+i)/2 [[1,1],[1,-1]],   S = diag(1,i),
+U17 = i S_3 CZ_03 CZ_12 CZ_23 Hg^(tensor 4).
+```
+
+The complete `16 x 16` certificate gives `U17^17=I`, `Phi17(U17)=0`,
+trace `-1`, all eight signed Pauli-generator images, symplectic defect
+rank eight and native `B` rank four. On four added identity spectators,
+let `V` prepare four Bell pairs and put `W=V^-1(U17 tensor I16)V`.
+Then `Phi17(W)=0`, and its native block is
+
+```text
+B_W = [[I, A+I], [I, I]],     A = [[0,0,0,1],
+                                  [0,0,1,0],
+                                  [0,1,0,1],
+                                  [1,0,1,1]].
+```
+
+Since `A` is invertible over `F2`, `B_W` has rank eight. Adding identity
+qubits preserves that rank, so the cap is attained for every ambient
+width `M>=8`. See [PROOF.md](PROOF.md) for conventions, the finite
+certificate, algebraic extension and credited upper-bound argument.
+
+## Evidence and limits
+
+`verify.py` uses exact Gaussian integer numerators with reduced denominators.
+It checks all matrix entries, all sixteen nonidentity powers, all signed
+Pauli-generator images, and the complete binary Bell conjugation. Seven
+controls distinguish wrong phase, an omitted CZ, a truncated polynomial,
+finite order without a primitive response, unused spectators, a nonsymplectic
+prediction and a nonunitary cyclotomic companion.
+
+`independent.py` was written separately, without importing the primary
+checker. It uses unreduced Gaussian integers `G=4U17` and clears denominators
+in the polynomial identity; it independently checks the eight Pauli images
+and constructs the binary Bell circuit. Both checkers use explicit failures
+that remain active under optimized Python. The eight-qubit polynomial
+identity follows by tensoring and conjugation in the written proof; neither
+checker expands all powers of a dense `256 x 256` matrix.
+
+This is an explicit finite algebraic response, not an admitted supplier.
+No source-bound caller, native legal schedule, ownership/dirty restoration,
+complete paid/target invoice or multiplication theorem is supplied. Native
+`B` rank is a binary algebraic invariant, not a physical gate-price receipt.
+The selected conditional `kappa=781451/250000000`, its five framework
+assumptions and selected evidence remain unchanged. No selected cold replay
+was run. Earlier binding-only orientation was reused after confirming its
+1227 bound inputs were unchanged from checkpoint `3f0152a32eeebac0df11946dbd50cabe5a7f7839` to this base;
+that reuse is not a fresh scientific replay.
+
+## Reproduce
+
+From a full Git checkout, with Python 3.12 and no third-party dependencies:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/order-seventeen-clifford --check-only
+python3.12 -B scripts/research_package.py --package research/order-seventeen-clifford
+```
+
+The registered commands run both checkers normally and with `-O`, isolated
+and with warnings treated as errors. Expected markers are
+`PASS_ORDER_SEVENTEEN_CLIFFORD` and `PASS_INDEPENDENT_ORDER17`.
+For a Git-free source export, run these direct commands from its root,
+once normally and once with `-O` added:
+
+```sh
+python3.12 -I -B -W error research/order-seventeen-clifford/verify.py
+python3.12 -I -B -W error research/order-seventeen-clifford/independent.py
+```
+
+[VERIFY.json](VERIFY.json) has no external live inputs: all mathematical
+inputs are defined in the package. [SOURCES.json](SOURCES.json) pins the
+base, original catalogue card and selected record as historical provenance.
+The pending predecessor is not an ancestor dependency: its two cited source
+documents are retained verbatim under `sources/` to make the precise theorem
+and method available in an offline export. [SOURCE-PINS.json](SOURCE-PINS.json)
+records their public source URLs, exact head and SHA256 digests, checked by
+the primary verifier. Their bytes were also compared with the fetched head
+before publication. No predecessor executable is imported or replayed.
+The Git source-history preflight covers declared base provenance; it does
+not authenticate the external predecessor-head label or validate its theorem.
+Package-local changes already select this registered replay.
+
+## Coordination and scope
+
+Canonical main was pulled first at
+`a5bff3bf133e482541c09eba4e773884bdb2b1b7`, priority revision 8.
+The original `joint-query-controller` card is retained in [TASK.json](TASK.json).
+Its scope is explicitly changed to this bounded algebraic subproblem: the
+card's complete source/consumer acceptance gate remains unmet.
+The canonical investigation is [Discussion 1166, comment 19273131](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19273131),
+responding to the predecessor's released
+[handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19272674).
+
+Overlap coverage was bounded: the local helper searched 30 of 8623 package
+notes (8593 absent in this sparse checkout), without a fresh remote cache.
+Live checks read the newest 15 handoff comments and all-state PR searches
+for `Clifford seventeen`, `Phi17` and `order-17`; no competing explicit
+instance was found in those results. This is not an exhaustive novelty audit.
+The stopping rule was the first complete exact order-17 construction and
+its rank certificate, without searching larger orders or proposing a
+supplier-budget change.
+
+## Open next questions
+
+- **Can this response satisfy an actual source/consumer contract?** Its
+  algebraic feasibility removes one uncertainty, but does not remove paid
+  work. Start by identifying one current caller whose required whole-bank
+  action matches this exact matrix, then check native chronology, all
+  retained outputs and restoration. Blocker: no such caller is supplied here.
+- **Can the rank-eight witness be implemented more cheaply than this Bell
+  conjugation in that caller's allowed alphabet?** A cheaper implementation
+  might affect a complete invoice. First establish the matched contract and
+  price the stated circuit, then compare one exactly equivalent circuit.
+  Blocker: without that contract and cost model, an algebraic gate count
+  cannot establish a saving. Do not expand the search before that gate.
+
+The structured questions and blockers are also in [TASK.json](TASK.json).
+
+## Credit
+
+Prepared by **apoursh**, with substantial OpenAI Codex assistance for
+construction, independently written exact checks, proof and packaging.
+Nick Petalas retains credit for PR6192's odd-cyclotomic rank theorem and
+Bell-spectator sharpness method; Ross Richardson retains the earlier
+whole-bank cubic/Pauli-character argument (PR4081). Copied predecessor
+documents retain their attribution and the repository's Apache-2.0 license.
+
+Cyclic Clifford constructions are classical; for example, Oliver Kern,
+Kedar S. Ranade and Ulrich Seyfarth give cyclic MUB constructions in
+power-of-two dimensions in
+[arXiv:0912.4661](https://arxiv.org/abs/0912.4661).
+This package claims a reproducible explicit Gaussian-dyadic instance and
+rank-eight certificate for the repository's handoff, not historical priority
+for cyclic Clifford existence or Bell conjugation. The cited literature is
+context, not a replay dependency. New material is Apache-2.0.

research/order-seventeen-clifford/SOURCE-PINS.json

@@ -0,0 +1,19 @@
+{
+  "source_pr": 6192,
+  "author": "Nick Petalas",
+  "head": "91df334ccd2a4bc9959e311f118ac8aaf967ffc2",
+  "status": "pending predecessor; cited theorem and method, not independently replayed",
+  "license": "Apache-2.0",
+  "files": [
+    {
+      "path": "sources/pr6192-PROOF.md",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/91df334ccd2a4bc9959e311f118ac8aaf967ffc2/research/odd-cyclotomic-response/PROOF.md",
+      "sha256": "324f494b016b4c63573cb6ed3fd14cedc258621cb17a5b9800165d921a1445d0"
+    },
+    {
+      "path": "sources/pr6192-README.md",
+      "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/91df334ccd2a4bc9959e311f118ac8aaf967ffc2/research/odd-cyclotomic-response/README.md",
+      "sha256": "dab05bd081f14224bdbe2a0429b8f4389fb930a2922a7544781b184bd4d0f7ec"
+    }
+  ]
+}

research/order-seventeen-clifford/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "a5bff3bf133e482541c09eba4e773884bdb2b1b7",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    }
+  ]
+}