Prove stable joint-bank Gram spectral obstruction (no new κ)

research/p104-joint-spectral-obstruction/PROOF.md

@@ -0,0 +1,166 @@
+# A persistent joint code cannot spectrally normalize the Gram pair
+
+This contribution was produced by Nick Petalas. It is a scoped written proof
+with finite exact corroboration. It gives no new kappa or physical call tariff.
+
+## Contract and cited premises
+
+Let R = Z[i,1/2]. Chris R / Clear1nsight's
+[PR #3979](https://github.com/CrocSwap/integer-mult-bounds/pull/3979), at
+`a8a1d744811cd7d1f9c43ec7ccbae85ef9695b61`, supplies the P104 Gram matrix A,
+of size n = 104, and the premises
+
+```
+A² = 13A,       rank(A modulo 13, i -> 5) = r = 8.
+```
+
+The exact cited text is pinned in SOURCES.json at the canonical base. These
+premises, the original code and its invoice are not rechecked here. The new
+argument begins with the complete two-stage operator. The predecessor excludes
+bank-separate codes for the same spectral target. Its proof explicitly leaves
+general bank mixing outside that obstruction.
+
+Put B = A tensor I_n and C = I_n tensor A. On the two banks define
+
+```
+F = upper(-C) lower(B) = [ I-CB  -C ].
+                           [ B      I ]
+```
+
+Let P be the coordinate rank-r projector, P_r = P tensor I_n and
+P_c = I_n tensor P. The proposed spectral endpoint is
+
+```
+T = upper(-alpha P_c) lower(beta P_r),     alpha,beta in R,
+alpha beta = 169.
+```
+
+The allowed code is one arbitrary Q in GL_(2n²+h)(R), for any finite h >= 0.
+It may mix both data banks and all scratch coordinates. The same code is used
+at entry and exit. Scratch has arbitrary initial data and must return exactly,
+so the endpoints compared are F direct-sum I_h and T direct-sum I_h. Different
+entry and exit codes, interleaved new operations, and a changed scratch return
+are outside this contract.
+
+## Complete-pair invariant
+
+Reduce through the ring map R -> F_13 given by i -> 5 and 1/2 -> 7. An
+R-invertible code stays invertible after reduction. Bars are omitted in this
+section. Now A² = 0 and rank A = r. Hence B² = C² = 0, BC = CB, and
+
+```
+rank B = rank C = nr,       D = BC = A tensor A,       rank D = r².
+N = F-I = [ -D  -C ],       N² = [ -D   0 ],           N³ = 0.
+          [  B   0 ]            [  0  -D ]
+```
+
+To compute the first rank without an inequality, N(x,y) = 0 implies Bx = 0.
+Then Dx = CBx = 0, so also Cy = 0. The converse holds. Thus
+ker N = ker B direct-sum ker C, and
+
+```
+rank N = 2nr,       rank N² = 2r²,       rank N³ = 0.
+```
+
+These identities hold over every field for a square-zero A. In particular,
+r <= n/2. The nilpotent Jordan multiplicities are
+
+```
+size 3: 2r²;       size 2: 2r(n-2r);       size 1: 2(n-r)².
+```
+
+For the cited P104 premises, the new complete-pair invariants are
+
+```
+dimension 21632;       ranks 1664, 128, 0;
+Jordan multiplicities 128 blocks of size 3,
+                      1408 blocks of size 2,
+                      18432 blocks of size 1.
+```
+
+The Jordan facts used here are standard nilpotent linear algebra. Their
+application to this complete Gram pair and the following stable obstruction
+are the new step.
+
+## Joint codes and restored scratch still fail
+
+Since alpha beta reduces to zero in a field, at least one coefficient reduces
+to zero. Therefore T-I reduces to a single off-diagonal square-zero block,
+or to zero. Its rank is nr if exactly one coefficient survives, and zero if
+both vanish. In particular its rank is at most nr, strictly below 2nr when
+r > 0.
+
+Conjugacy preserves rank after subtracting the identity. Adding I_h adds
+only zero blocks to that difference. Consequently
+
+```
+Q (F direct-sum I_h) Q^-1 != T direct-sum I_h
+```
+
+for every code and finite restored scratch allowed by the contract. This
+removes the bank-separate restriction from this particular free-normalization
+exclusion. It does not exclude arbitrary joint programs or every decoder.
+
+## The correction rank and its precise sharpness
+
+Write E = Q(F direct-sum I_h)Q^-1 - (T direct-sum I_h). The rank inequality
+rank(X-Y) >= rank X - rank Y, applied after subtracting the identity, gives
+
+```
+rank_F13 E >= nr = 832,
+rank_F13 E >= 2nr = 1664 if both coefficients vanish modulo 13.
+```
+
+The second case includes alpha = beta = 13. A nonzero minor over F_13 comes
+from a nonzero minor over Q(i). Thus the same lower bounds hold for the
+characteristic-zero rank of any R-valued E. Rank is an endpoint matrix rank,
+not a number of native children or a complete paid invoice.
+
+The bounds are exact in the modular relaxation, even without scratch. In
+Jordan coordinates N has 2r(n-r) nontrivial chains. This is at least nr.
+Select one arrow in each of nr different chains, and let M retain just these
+arrows. Then M² = 0, rank M = nr, and rank(N-M) = 2nr-nr = nr. Distinct
+Jordan arrows have distinct row and column indices, so the last equality
+follows by counting the remaining arrows.
+
+Every square-zero matrix of this dimension and rank nr is similar over the
+field to M. Hence this construction attains the lower bound for every modular
+target with exactly one surviving coefficient. When neither survives, the
+target is the identity and rank N = 2nr attains the other bound. The verifier
+enumerates all 21632 Jordan coordinates and an explicit permutation matching
+the 832 projector arrows to the selected arrows. Existence of the Jordan
+basis follows from the written argument, not a reconstruction of the original
+P104 matrix.
+
+This is sharpness over F_13. No exact dyadic rank-832 correction or lift of
+the entire corrected endpoint is constructed or claimed.
+
+## Finite corroboration and boundaries
+
+The verifier multiplies the literal two shears for each tensor pair of a
+size-two nilpotent block or a size-one zero block. Exact elimination checks
+their ranks and cubes in five prime fields. It enumerates the direct-sum
+components and all Jordan coordinates for n = 104, r = 8. Small stable
+fixtures mix data and restored scratch and cover every coefficient residue
+pair whose product is zero. They are finite checks of the new formulas,
+not independent verification of the predecessor's Gram premises.
+
+An exact rational control uses A = [[13,1],[0,0]] and
+S = [[1,1/13],[0,1]]. Here SAS^-1 = diag(13,0). The two-axis code built from
+S tensor S does perform the spectral normalization. Its forbidden denominator
+shows why the coefficient-ring hypothesis matters. A separate scratch control
+can move the nontrivial endpoint entirely into an unreturned scratch bank.
+That is why an identity return on the whole scratch space is required.
+
+No selected native, caller, compiler, precision, stock, tape or analytic replay
+is needed for this algebraic side result, and none is claimed. Independent
+human and formal proof-kernel review are unclaimed.
+
+## Open next questions
+
+Can an exact R-valued correction attain rank 832 for this spectral target?
+Start with n = 2, r = 1 and the displayed integral A; require one common
+R-invertible code and an exact endpoint. A modular witness alone cannot
+answer this lifting question. A useful physical implementation must then price
+access, native maps and complete restoration. A different producer/consumer
+boundary must state which common-code hypothesis it changes.

research/p104-joint-spectral-obstruction/README.md

@@ -0,0 +1,91 @@
+# Joint bank mixing does not remove the dyadic Gram spectral obstruction
+
+This contribution was produced by Nick Petalas. It is a scoped written proof
+with finite exact corroboration. No new kappa is claimed.
+
+Chris R / Clear1nsight's [PR #3979](https://github.com/CrocSwap/integer-mult-bounds/pull/3979)
+leaves joint bank mixing outside its exclusion of a free spectral split of the
+P104 Gram pair. The new result closes that particular escape when one persistent
+Gaussian-dyadic invertible code is used at both endpoints. The code can mix both
+banks and any finite number of arbitrary scratch coordinates, provided all
+scratch returns identically.
+
+For the complete pair F = upper(-I tensor A) lower(A tensor I), reduction modulo
+13 gives ranks 1664, 128 and zero for F-I, its square and its cube. Its nilpotent
+Jordan blocks have sizes 3, 2 and 1 with multiplicities 128, 1408 and 18432.
+A spectral-projector pair with coefficients alpha beta = 169 has rank at most
+832 after subtracting the identity. Similarity and identity scratch preserve
+the discrepancy.
+
+Every exact Gaussian-dyadic endpoint correction consequently has matrix rank
+at least 832, or at least 1664 when both coefficients vanish modulo 13, including
+alpha = beta = 13. Both bounds are attained in the modular relaxation. An exact
+dyadic attaining correction is not supplied. Matrix rank is not a native-call
+tariff or a complete recursive invoice.
+
+[PROOF.md](PROOF.md) gives the general n,r statement, the kernel calculation,
+the stable obstruction and the exact modular sharpness argument. The predecessor
+premises n = 104, A² = 13A and rank(A modulo 13) = 8 are cited and source-bound.
+Its original code, counts and proofs are not replayed or audited here.
+
+## Reproduce
+
+From the repository root, using CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/p104-joint-spectral-obstruction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/p104-joint-spectral-obstruction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/p104-joint-spectral-obstruction
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/p104-joint-spectral-obstruction --check-source-history --check-modes
+```
+
+Another CPython 3.12 executable may replace the local path. Direct output is a
+generated JSON receipt bound to package and premise-file hashes, followed by
+`PASS_P104_JOINT_SPECTRAL_OBSTRUCTION modular_repair=832 balanced=1664 no_new_kappa`.
+The launcher also checks metadata and exact source pins.
+
+The finite checks cover 20 literal atomic tensor pairs over five prime fields,
+80 small direct-sum assemblies, all 9216 canonical P104 components and all 21632
+Jordan coordinates. An explicit coordinate permutation matches the 832 projector
+arrows to the attaining modular repair. Seventy-five stable fixtures cover every
+zero-product coefficient residue pair with zero, one and three restored scratch
+coordinates. Controls retain a rational normalization using 1/13, an omitted
+stage, unreturned scratch and invalid square-zero source parameters.
+
+The program reads one pinned premise file. It builds no dense matrix larger
+than 32 by 32; the full canonical witness uses bounded coordinate dictionaries.
+Python allocates managed objects during the finite run. These explicit size
+bounds replace a fixed-allocation implementation. Every function is below
+60 lines, and the registered commands enable warnings as errors and exercise
+normal and optimized execution. No external static analyzer is required.
+
+## Limits
+
+One common code at entry and exit, the Gaussian-dyadic coefficient ring and
+identity return of the entire scratch space are essential. New interleaved
+operations, distinct endpoint codes, other spectral targets and odd-denominator
+codes are not excluded. No physical producer/consumer implementation or paid
+rank conversion follows from this endpoint invariant.
+
+No selected native, caller, compiler, precision, storage, tape or analytic replay
+was run. Independent human and formal proof-kernel review are unclaimed. The
+selected frontier and frozen predecessors are unchanged.
+
+## Open next questions
+
+Can an exact Gaussian-dyadic correction attain rank 832? Start with the displayed
+n = 2, r = 1 integral matrix in the proof and require the same dyadic-invertible
+code at both endpoints. A modular solution alone does not establish a lift.
+Only after an exact endpoint exists should its native access and complete paid
+restoration costs be priced. [TASK.json](TASK.json) records the question and
+blocker explicitly.
+
+## Predecessor credit
+
+Chris R / Clear1nsight owns PR3979's tensor code, original bank-separate
+obstruction, scalar words and invoice. PR3961 supplies the preceding code
+mismatch; PR3882, PR3940, PR3943 and PR3954 retain the caller lineage. ToikY's
+literal-word audit and the native, geometry and compiler authors credited by
+PR3979 retain their contributions. No predecessor construction credit is claimed.
+Nilpotent Jordan classification and rank inequalities are classical. New work
+is under Apache-2.0.

research/p104-joint-spectral-obstruction/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "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/p104-tensor-code/PROOF.md",
+      "usage": "input",
+      "git_blob": "b570c8bdf5acec263c63562ddb5e384ff3616c3f",
+      "sha256": "259ba7b0926dd6db4e7c45ff7ccb10659dee06aef0a573547236c994ad304756"
+    }
+  ]
+}