Prove the exact rational GL3 two-column kernel (no new κ)

research/gl3-rational-two-column-kernel/PROOF.md

@@ -0,0 +1,133 @@
+# The exact two-column kernel over characteristic zero
+
+This is a scoped proof using the finite exact certificate in `verify.py`.
+It concerns the address permutation algebra alone. No complete complex
+unit or multiplication theorem is asserted.
+
+## Statement
+
+Let G=GL_3(F2), let V=Q^{F2^3}, and let P_g e_x=e_{gx}.
+For f>=1 define the algebra homomorphism
+
+    rho_f : Q[G] -> End_Q(V^{tensor f}),
+    rho_f([g]) = P_g^{tensor f}.
+
+Write C_j for the sum of all elements of order j in Q[G], and put
+
+    E = 6[1] - 2 C_2 + 2 C_4 - C_7.
+
+Then
+
+    E^2 = 56 E,
+    ker rho_2 = Q[G] E,
+    dim_Q ker rho_2 = 18,
+    dim_Q image rho_2 = 150.
+
+The same statements hold after extending scalars to C. The map rho_f is
+injective for every f>=3. Thus width three is the smallest single positive
+width that certifies every formal identity in this characteristic-zero
+address algebra. A two-register restored shear realizes a nonidentity
+formal map that is identity at both widths one and two.
+
+## The finite certificate
+
+The verifier constructs G in two ways. First it lists all three nonzero
+binary columns and keeps the invertible matrices. Second it closes the six
+elementary binary row additions, with a bound of 168 visited elements.
+Both constructions give the same 168 address permutations. The multiplication
+table is literal permutation composition, so no presentation or external
+group data are assumed.
+
+Their order populations are
+
+    order 1: 1, order 2: 21, order 3: 56, order 4: 42, order 7: 48.
+
+The verifier forms all coefficients of E^2 by integer convolution and checks
+E^2=56E in all 168 coordinates. It checks centrality against all 168 group
+elements. Centrality also follows because element order is conjugacy invariant.
+It then sums all 168 permutation actions on all 64 point pairs and checks
+that every one of the 4,096 entries of rho_2(E) is zero. These are finite
+integer identities, with no numerical tolerance.
+
+Let A_g be the 64 by 64 matrix P_g^{tensor 2}, viewed as a column of 4,096
+integers. The Gram matrix of these 168 columns has entries
+
+    H[g,h] = <A_g,A_h> = #{x in F2^3 : gx=hx}^2.
+
+The equality holds because a common nonzero entry of two permutation matrices
+is a point pair whose two coordinates have the same images under g and h.
+The verifier constructs H from this formula. Gaussian elimination modulo
+65537 selects 150 row indices and 150 column indices. A second determinant
+calculation on that original integer minor gives a nonzero residue. Trial
+division through 256 proves the modulus prime. The generated receipt records
+the complete indices and determinant residue, so the minor is reproducible.
+Consequently rank_Q H>=150, hence rank_Q rho_2>=150. No inference of a
+rational upper rank from a modular upper rank is used.
+
+## Why this is the entire kernel
+
+Set e=E/56. The checked product identity says that e is an idempotent.
+Left multiplication L_e on Q[G] is therefore an idempotent linear map.
+Every diagonal entry of L_e is the identity coefficient of e, namely 6/56.
+Its trace is
+
+    168 * 6/56 = 18.
+
+An idempotent over Q has eigenvalues zero and one, so its rank equals its
+trace. Since e is central, its image is the two-sided ideal Q[G]e=Q[G]E.
+The checked rho_2(E)=0 puts this 18-dimensional ideal inside ker rho_2.
+It follows that rank_Q rho_2<=168-18=150. The minor proves the opposite
+inequality. Thus the image rank is 150 and this ideal is exactly the kernel.
+Ranks of rational matrices are unchanged by extension to C, which proves
+the complex version as well.
+
+## Why the third column suffices
+
+The tuple (1,2,4) is the ordered standard basis of F2^3. Its images under
+G are all distinct. For a=sum_g a_g[g], the coefficient at (g1,g2,g4) of
+
+    rho_3(a) e_(1,2,4)
+
+is exactly a_g. Hence rho_3 is injective. For any f>3, append zero columns
+to this tuple. All address maps fix zero, so the same regular orbit and
+coefficient recovery apply. This is the standard regular-orbit argument
+already used in the binary-stream predecessor. The new content here is the
+characteristic-zero kernel below it.
+
+## A restored two-register witness
+
+Write E=sum_g c_g[g]. There are 112 nonzero c_g. Start with arbitrary
+independent registers (x,y). For each such g, in lexicographic permutation
+order, execute
+
+    y <- P_g^{tensor f} y
+    x <- x + c_g y
+    y <- (P_g^{-1})^{tensor f} y.
+
+Every term restores the source y exactly. The final map is
+
+    (x,y) -> (x + rho_f(E)y, y).
+
+It is invertible, with inverse obtained by changing every c_g to -c_g.
+It uses no clean scratch, erasure or assumption that either input is zero.
+These address maps and rational scalar additions are free in the stated
+address-only part of the complex engine game. No physical movement or
+precision price follows from that algebraic convention.
+
+At width two the map is identity by rho_2(E)=0. At width one the same
+identity follows by restricting the width-two calculation to pairs (x,0).
+The verifier also executes the chronological word on the complete dirty
+input bases, 16 columns at width one and 128 at width two, and checks source
+restoration after each term. At width three, take x=0 and y=e_(1,2,4).
+The 112 nonzero coefficients of E occur on distinct output basis vectors,
+so the word is not identity. The verifier executes that witness too.
+
+## Limits
+
+The arithmetic identities and nonzero minor are exhaustive finite evidence.
+The linear-algebra deductions above are written proofs, with independent
+human and formal proof-kernel review unclaimed. This package does not classify
+the characteristic-two kernel, arbitrary address dimension, affine maps,
+phase letters, paid C-calls or native precision and tape costs. In particular,
+width three certifies only identities whose coefficients lie in Q[G] or C[G].
+It is not an all-width test for the full complex engine.

research/gl3-rational-two-column-kernel/README.md

@@ -0,0 +1,118 @@
+# The exact rational kernel of two-column GL3 tests
+
+For G=GL_3(F2) acting on rational or complex payloads, the action on two
+point columns has image dimension **150** and kernel dimension **18**.
+Its entire kernel is generated by the explicit central element
+
+    E = 6[1] - 2 sum_(order g=2) [g]
+             + 2 sum_(order g=4) [g] - sum_(order g=7) [g].
+
+The exact identities are E^2=56E and ker(rho_2)=Q[G]E, where
+rho_f([g])=P_g^{tensor f}. A restored two-register word is formally
+(x,y) -> (x+E y,y), yet is identity on every input at widths one and two.
+At width three it has an explicit witness with 112 nonzero output entries.
+The third-column regular orbit recovers every formal coefficient.
+
+This is a **scoped algebraic proof with an exhaustive finite certificate**,
+not a complete complex unit, supplier admission or new kappa. The added
+information is the complete characteristic-zero kernel and a literal
+restored witness for the finite-testing interface. [PROOF.md](PROOF.md)
+gives the argument without relying on a character table.
+
+## Why this question matters
+
+Small tensor-width tests can accept a formal endpoint with a hidden cross-role
+coupling. ywz65's [#2599](https://github.com/CrocSwap/integer-mult-bounds/pull/2599)
+proved the sharp stream boundary over F2. Its group norm cancels in
+characteristic two. That norm has value 168 at the fixed zero pair over Q,
+so it is not this characteristic-zero witness. This package determines
+exactly what the two-column Q or C action loses, rather than repeating
+the earlier binary-payload result.
+
+Jacob Alan Sussman's [#4628](https://github.com/CrocSwap/integer-mult-bounds/pull/4628)
+provides the complex small-unit context and the warning that a fixed tensor
+width alone need not certify a uniform program. Woklerx's
+[#1440](https://github.com/CrocSwap/integer-mult-bounds/pull/1440) supplies a
+different support-bound finite quotient criterion. Their results and executables
+are cited, not audited or replayed here. Three-column faithfulness in this
+note concerns only the address algebra, not words containing paid C-calls
+or phase letters.
+
+## Evidence and reproduction
+
+From the repository root, use the available CPython 3.12 interpreter:
+
+```sh
+~/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/gl3-rational-two-column-kernel/verify.py
+~/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/gl3-rational-two-column-kernel/verify.py
+~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/gl3-rational-two-column-kernel
+~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/gl3-rational-two-column-kernel --check-source-history
+```
+
+The first line of direct verifier output is
+
+```text
+PASS_GL3_RATIONAL_TWO_COLUMN_KERNEL group=168 image=150 kernel=18 E_squared=56E support=112 dirty_columns=144 no_new_kappa
+```
+
+The following JSON is a generated receipt binding the six package files by
+SHA256. It records the complete modular minor, exact counts and controls.
+An optional `--receipt /new/path.json` creates that receipt exclusively.
+The verifier otherwise writes nothing and needs only the standard library.
+
+It constructs the group independently from binary columns and elementary
+row additions, checks all 168 convolution coordinates and all 4,096 entries
+of the two-column annihilator, and recomputes a nonzero 150 by 150 minor
+modulo the checked prime 65537. The idempotent trace supplies the matching
+18-dimensional kernel. The chronological shear is replayed on all 144
+dirty input columns at widths one and two and on its width-three witness.
+Omitting each of the four nonzero order classes is rejected. The group norm
+is checked to be visible over Q. The proof does not use a modular upper rank
+as an upper rank over Q.
+
+The base is canonical main `624de9dc66858af0945e5f8a0942488d62280d43`, priority
+revision 7. The card `complex-rank-shape-decoder` changes to this interface
+side result. [TASK.json](TASK.json) records the reason, overlap coverage and
+remaining questions. The catalogue and selected record are historical
+provenance in [SOURCES.json](SOURCES.json), with no external live replay inputs.
+
+## Limitations
+
+No paid-call optimum, phase-letter identity, complete engine test, physical
+movement, precision, restoration price, compiler, stock or outer bound is
+provided. The algebraic word restores arbitrary dirt, but its physical invoice
+is unknown. No Lean build or full selected construction replay was run.
+The selected source-binding orientation command was attempted and stopped
+because the sparse checkout omits `research/fresh-helper-thinned/PROOF.md`.
+That is not a failed scientific check of this package or of its predecessor.
+Independent human and formal proof-kernel review are unclaimed.
+
+The bounded verifier deliberately uses managed Python allocations. All
+collection sizes follow from the fixed 168-element group, matrices of order
+at most 168, and payload replays with at most 512 address rows and 128 input
+columns per register. It has
+no recursion, network access or unbounded search. Invariant failures use
+explicit exceptions and remain enabled under optimization.
+
+## Open next questions
+
+1. Determine the characteristic-zero kernel for three-dimensional affine
+   address maps at their last unfaithful width. This would identify another
+   precise finite-test blind spot. Start with orbit-stabilizer data and an
+   exact permutation Gram minor. The group size and certificate cost grow.
+2. For a fixed small-unit candidate containing paid calls or phases, identify
+   a sufficient tensor width or a formal algebra certificate. Start by pinning
+   the actual generated operator algebra. The GL3 address-only proof does not
+   cover those extra operators.
+
+## Credit
+
+This contribution was produced by Nick Petalas. Credit ywz65 for the binary
+stream faithfulness question and regular-orbit argument, Josie Elliston and
+Hanson Sun for the related GL3 register census context, Gareth Davidson for
+the earlier binary norm alias, woklerx for finite-address certification,
+and Jacob Alan Sussman for the complex small-unit model and width warning.
+Eumemic and Swapnil Jain retain credit for the underlying obstruction
+program cited by Sussman. Regular orbits, idempotent trace and modular-minor
+rank arguments are standard linear algebra. No literature-priority claim
+is made for those methods. New work is Apache-2.0.

research/gl3-rational-two-column-kernel/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "624de9dc66858af0945e5f8a0942488d62280d43",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/binary-stream-faithfulness/README.md",
+      "usage": "provenance",
+      "git_blob": "a471c1ee89c64c8d2eae5fa0f7bfccd8d3d726bb",
+      "sha256": "0b5f45d882980038ced16e66cdd4e7d8869c5ca2032e988a5df636df05cb6b12"
+    },
+    {
+      "path": "research/bit-faithful-finite-address/README.md",
+      "usage": "provenance",
+      "git_blob": "0f3c0ded3e2ec8af5e50d9919784cde88ab29bb4",
+      "sha256": "b4e345bc8e86d069979a57ade7cb381812474ffbb0d7033d5a1283fc99eb16cb"
+    }
+  ]
+}