Prove exact arithmetic chirp cut spectra and robust bond floors (no κ)

research/arithmetic-chirp-cut-spectrum/PROOF.md

@@ -0,0 +1,185 @@
+# Exact cut spectrum of an arithmetic chirp
+
+This scoped written proof was produced by Nick Petalas. Apache-2.0.
+The finite verifier corroborates identities below; it does not establish their
+unbounded quantifiers or provide independent human or proof-kernel review.
+
+## 1. The endpoint and its declared cut
+
+Let N=L H with positive integers L,H, and let a,b be integers. Define
+
+    U |x> = exp(2 pi i (a x^2+b x)/N) |x>,   0 <= x < N.
+
+Use the tensor identification x=u+L v, where 0<=u<L and 0<=v<H.
+This specifies the physical order. It is not an optimization over reorderings,
+encodings, side information, extra input promises or alternate endpoints.
+
+A transfer representation with bond D at this cut expresses U as a sum of
+at most D products A_j tensor B_j. Position-dependent and width-dependent
+tables are allowed. Thus any lower bound here also applies to the fixed-table
+physical transfer contract of zxv's PR #5441. We do not assume that a small
+bond prices a physical native implementation, tape movement or dirty returns.
+
+Put
+
+    g = gcd(2a,H),   Q = H/g,   L = q Q+t,   0 <= t < Q.
+
+The convention gcd(0,H)=H includes constant and linear phases.
+
+## 2. Complete spectrum
+
+**Theorem.** The nonzero squared operator-Schmidt coefficients of U at this
+cut, before normalization, are
+
+    H(q+1), repeated t times;
+    Hq,     repeated Q-t times, omitting zero values.
+
+In particular its cut rank is exactly min(L,Q). Its squared Hilbert-Schmidt
+norm is N. After division by sqrt(N), the squared coefficients are the
+positive numbers (q+1)/L and q/L with the same multiplicities. All integers
+a,b, all factorizations N=L H, and either sign of a are covered.
+
+**Proof.** In the orthonormal diagonal matrix bases |u><u| and |v><v|, the
+coefficient matrix of U is the L-by-H matrix
+
+    C[u,v] = zeta_N^(a(u+Lv)^2+b(u+Lv)).
+
+All other entries of the operator realignment are zero. Therefore C and
+that realignment have the same nonzero singular values. Expand the square:
+
+    C[u,v] = zeta_N^(a u^2+b u)
+             * omega^(u v)
+             * zeta_N^(a L^2 v^2+b L v),
+    omega = exp(2 pi i 2a/H).
+
+The exterior factors are diagonal unitaries, so they preserve singular
+values. The middle matrix K[u,v]=omega^(u v) has omega of exact order Q.
+Since Q divides H, character orthogonality gives
+
+    (K K*)[u,w] = H if u=w mod Q, and 0 otherwise.
+
+Partition the L rows by their residues r modulo Q. Each nonempty class
+gives H times an all-ones block of size c_r, with one eigenvalue H c_r.
+There are t classes of size q+1 and Q-t classes of size q, omitting empty
+classes. This proves every stated multiplicity and the rank formula.
+The sum of eigenvalues is H sum c_r=H L=N. The coefficient b occurs only
+in the exterior unitary factors and cannot affect the spectrum. End proof.
+
+The proof is also an explicit orthogonal factorization. Write
+
+    K[u,v] = sum_(0<=r<Q) 1_(u=r mod Q) omega^(r v).
+
+The nonzero left vectors have squared norms c_r and disjoint supports.
+The right vectors have squared norms H and are mutually orthogonal.
+Restoring the two exterior phases supplies an attaining rank decomposition.
+This uses classical character orthogonality, not a new Fourier theorem.
+
+## 3. Sharp error at one cut
+
+Let lambda_1>=...>=lambda_R>0 be the normalized squared coefficients in
+Section 2, R=min(L,Q). For 0<=D<=R the least squared relative
+Hilbert-Schmidt error among operators with cut rank at most D is
+
+    E_D^2 = sum_(j>D) lambda_j.
+
+This is the classical best low-rank approximation theorem applied to the
+realignment, which preserves Hilbert-Schmidt norm. The explicit orthogonal
+factorization above attains the bound by retaining the D largest classes.
+It is a statement about one cut. It does not assert simultaneous optimal
+approximation at every cut or optimal operator-norm approximation.
+
+For completeness, the lower bound follows by projecting onto the column
+space of any proposed rank-D approximant. That projection has rank at most
+D and can retain at most the sum of the D largest eigenvalues of C C*.
+The complementary squared norm is the displayed tail. Truncation attains
+it, so no unproved numerical SVD premise enters the argument.
+
+If an N-by-N approximant V instead satisfies ||U-V||_2<=epsilon, then
+
+    ||U-V||_F^2/N <= epsilon^2.
+
+Consequently its cut rank D necessarily satisfies E_D^2<=epsilon^2.
+This necessary operator-norm bound need not be sufficient. No positivity,
+diagonality or unitarity is required of V.
+
+## 4. Binary order has a flat spectrum
+
+Let N=2^n, n>=1. Define the finite integer
+
+    nu = v_2(gcd(2a,2^n)),    1 <= nu <= n.
+
+At the cut after the k least significant bits, including k=0,n,
+
+    Q_k = 2^max(n-k-nu,0),
+    R_k = 2^min(k,max(n-k-nu,0)).
+
+Both L=2^k and Q_k are powers of two. If L<=Q_k every nonempty residue
+class has size one. If L>=Q_k, Q_k divides L and every class has size
+L/Q_k. Thus all R_k normalized squared coefficients equal 1/R_k.
+
+The exact minimum peak bond, among arbitrary position-dependent matrix
+product operators in this bit order, is
+
+    R_peak = 2^floor((n-nu)/2).
+
+Indeed the maximum of min(k,max(n-nu-k,0)) is floor((n-nu)/2).
+Each cut rank is necessary. It is also sufficient simultaneously for an
+exact representation: successive exact singular decompositions of the
+diagonal phase vector give a tensor train with these unfolding ranks.
+Copying each physical bit to equal input/output indices turns that train
+into an MPO with the same bonds. This is the standard exact tensor-train
+factorization argument, and is not a uniform fixed-table construction.
+
+At any one cut, the sharp squared relative Hilbert-Schmidt error is
+
+    E_D^2 = max(0,1-D/R_k).
+
+For every operator-norm error epsilon<1, an MPO therefore needs
+
+    D >= ceil((1-epsilon^2) R_k)
+
+at that cut. The same necessary bound with R_peak applies to its peak bond.
+For odd a, nu=1, so R_peak=2^floor((n-1)/2). Width 65 requires exact
+peak bond 2^32. This example is encoded arithmetic, not a materialized
+2^65-entry computation. Fixed error below one still forces exponential
+growth. Reversing the complete bit order retains the same cuts with their
+sides exchanged. Arbitrary permutations of bits are outside this result.
+
+## 5. Scope and relevance
+
+The new step is the arithmetic chirp's exact spectrum, including nonflat
+mixed-radix cuts and the valuation-sensitive binary consequence. PR #5441
+supplies the repository's transfer contract and earlier robust half-swap
+and binary dot-product examples. Its executables and results are not
+replayed or independently audited here. Crosswhite and Bacon supply the
+classical automata/MPO correspondence. Character orthogonality, exact
+tensor factorization and best low-rank approximation are background facts.
+Global literature priority for chirp Schmidt decompositions is unclaimed.
+
+This result rejects a bounded-bond representation of this particular
+arithmetic phase in the declared order. It does not reject a short circuit
+for the same phase, a different data order, a changed representation or a
+consumer that needs fewer entries. Jon Tyson's operator-Schmidt analysis
+of the QFT is related arithmetic background, and Chen and Lindsey's
+compressible reindexed QFT illustrates why endpoint and order matter.
+
+No selected native primitive or actual all-size caller has been identified
+with this full phase endpoint here. That binding, allowed reorderings,
+the complete paid/productive invoice, coefficient preparation, storage,
+precision, native realization and dirty restoration remain open. No
+selected framework assumption, supplier admission or new kappa follows.
+
+## References
+
+- zxv, [PR #5441](https://github.com/CrocSwap/integer-mult-bounds/pull/5441),
+  `11fedb46fa199283f78282187c10aea432d8b0bb`, retained on the package base.
+  Its README and proof are pinned as provenance in SOURCES.json.
+- Gregory M. Crosswhite and Dave Bacon,
+  [Finite automata for caching in matrix product algorithms](https://arxiv.org/abs/0708.1221).
+- Jon Tyson, [Operator-Schmidt decomposition of the quantum Fourier transform
+  on C^N1 tensor C^N2](https://arxiv.org/abs/quant-ph/0210100).
+- Jielun Chen and Michael Lindsey, [Direct interpolative construction of the
+  discrete Fourier transform as a matrix product operator](https://arxiv.org/abs/2404.03182).
+
+The retained native recipe, physical transfer, compiler and phase lineage
+credited in PR #5441 remains predecessor work. No predecessor credit is changed.

research/arithmetic-chirp-cut-spectrum/README.md

@@ -0,0 +1,109 @@
+# Arithmetic chirps require growing transfer dimension
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+**Claim type:** scoped written proof with exact finite corroboration.
+For the diagonal phase
+
+    U|x> = exp(2 pi i (a x^2+b x)/N)|x>,
+
+the complete cut spectrum is explicit for every integer a,b and every
+factorization N=L H, with the declared order x=u+L v. Put
+
+    Q = H/gcd(2a,H),   L=q Q+t,   0<=t<Q.
+
+The squared operator-Schmidt coefficients are H(q+1), t times, and Hq,
+Q-t times, omitting zeros. The cut rank is min(L,Q). Their sum is N.
+
+For N=2^n, let nu=v_2(gcd(2a,2^n)). In consecutive binary order,
+
+    rank at cut k = 2^min(k,max(n-k-nu,0))
+    minimum exact peak bond = 2^floor((n-nu)/2).
+
+Every nonzero normalized squared coefficient at that cut is 1/rank.
+An operator-norm error epsilon<1 therefore requires bond at least
+ceil((1-epsilon^2) rank) there. The exact optimal squared relative
+Hilbert-Schmidt error at one cut and rank D is max(0,1-D/rank).
+The latter optimum is not claimed for operator norm or for simultaneous
+approximation at every cut.
+
+For odd a at width 65 the exact peak bond is 2^32. This example is an
+encoded formula check, not a materialized 2^65-entry endpoint. In contrast,
+the mixed-radix split N=12,L=4,a=1 has the nonflat squared spectrum (6,3,3).
+[PROOF.md](PROOF.md) supplies the full argument and attaining cut factorization.
+
+## Why this is a separate contribution
+
+[zxv's PR #5441](https://github.com/CrocSwap/integer-mult-bounds/pull/5441)
+supplies the physical transfer contract and earlier half-swap and binary
+dot-product examples. Its open directions motivate source-specific cuts
+and approximation bounds. The new step here is the arithmetic chirp's
+complete spectrum and its coefficient-valuation-dependent binary profile.
+Its predecessor executables and claims are cited, not audited or replayed.
+The full source lineage remains credited there.
+
+The card scope is explicitly changed to an algebraic side result. No
+selected primitive or actual caller is identified with this full endpoint.
+The obstruction can screen a proposed bounded-state arithmetic-phase
+representation; it does not discharge any selected framework assumption.
+The order and demanded endpoint are essential. A short circuit or a changed
+representation may still exist. No physical memory, tape-time, query-price,
+supplier-admission, complete multiplication theorem or new kappa is claimed.
+
+Character orthogonality, low-rank approximation and the matrix-product/
+automata correspondence are classical. The references include Crosswhite
+and Bacon, Tyson's related QFT spectrum and Chen and Lindsey's compressible
+reindexed QFT. Global literature priority is unclaimed. Independent human
+and formal proof-kernel review are unclaimed.
+
+## Reproduction and finite evidence
+
+From the repository root, using CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/arithmetic-chirp-cut-spectrum/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/arithmetic-chirp-cut-spectrum/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/arithmetic-chirp-cut-spectrum
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/arithmetic-chirp-cut-spectrum --check-source-history --check-modes
+```
+
+The direct checker prints `PASS_ARITHMETIC_CHIRP_CUT_SPECTRUM` and a generated
+JSON receipt bound to the six package files. It uses exact integer
+cyclotomic reduction, with no floating-point tolerance or predecessor import.
+It checks all N=1..36, all ordered factorizations and a=0..N-1, at b=0,-3:
+
+- 5,870 phase cases and 567,828 upper-triangular Gram entries;
+- 15,316 truncation values and 492 nonflat cases;
+- 8,256 encoded binary valuation profiles, 715,520 cuts, through width 128;
+- three structural controls, 21 signed/shifted phase controls and four
+  invalid-input rejections.
+
+Finite cases corroborate the written proof. The large binary checks compare
+exact integer formulas and do not materialize their exponential matrices.
+The two source notes are pinned as historical provenance; they are not
+live executable inputs. Direct replay works without Git or those notes.
+No selected cold replay, physical multiplier, Lean or Docker run is included.
+
+## Open next questions
+
+Structured questions with relevance and first steps are in [TASK.json](TASK.json).
+
+1. Bind one actual arithmetic phase request, its permitted order and all
+   demanded outputs to this endpoint before using the obstruction in a caller.
+2. Determine whether a legal bit permutation lowers the peak bond. Natural
+   order and its complete reversal are covered; arbitrary orders are open here.
+3. Determine the optimum operator-norm error at fixed cut rank. The theorem
+   supplies a necessary bound and a sharp Hilbert-Schmidt result only.
+
+## Verifier resource contract
+
+`verify.py` is a finite, no-argument exact checker. All functions are under
+60 lines, loops are bounded by order 36 or width 128, and checks remain active
+under optimized Python. No recursion, subprocess, dynamic evaluation or
+external module loading is used. Python necessarily allocates integers and
+collections during arithmetic. This is a managed-runtime deviation from
+Power of Ten rule 3: materialized matrices have at most 36^2 entries and
+polynomials at most 37 coefficients; encoded arithmetic uses dimensions
+bounded by 2^128. Six fixed local files are read for receipt hashes. If arbitrary
+orders or external files are accepted later, their capacities and boundary
+validation must be designed before expanding this checker.

research/arithmetic-chirp-cut-spectrum/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "3f0152a32eeebac0df11946dbd50cabe5a7f7839",
+  "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"
+    },
+    {
+      "path": "research/finite-memory-lifting/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "36152f9e31555a88ce3636ae59abf07a8058d78d",
+      "sha256": "de4a6b79d480d7718b3d157d2be73b4f45723ccac6719160dd815f8cef40356b"
+    },
+    {
+      "path": "research/finite-memory-lifting/README.md",
+      "usage": "provenance",
+      "git_blob": "5ce4fa86af1d5487f9a639acdc9fa0177c76c192",
+      "sha256": "ca0be421d5cb1835a8814685907db78a7a3ea24b7e1e474f3038c87b0e46498e"
+    }
+  ]
+}