Prove q² coupled optima for two resonant Jordan blocks (no κ)

research/coupled-resonant-jordan-pair/PROOF.md

@@ -0,0 +1,143 @@
+# Coupling two individually rigid resonant Jordan blocks
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+Claim type: scoped mathematical proof. The finite verifier corroborates the
+argument; independent human and formal proof-kernel review are unclaimed.
+
+## Statement
+
+Let F_q be any finite field. Choose nonzero lambda_1, lambda_2 with
+lambda_i^2=1, and put
+
+    P = diag(J_2(lambda_1), J_2(lambda_2)),
+    J_2(lambda) = [[lambda,1],[0,lambda]].
+
+Use precisely the ordinary wrapper of Nicholas Stone's #5556, on arbitrary
+H,D in F_q^4, with chronological operations
+
+    D -= H; F_P; D += H; F_Q; D = -D; D += H,
+    F_T(H,D) = (T D, T^-1 H).
+
+Require Q invertible. Optimality means least rank of the difference between
+this wrapper and the interchange (H,D) -> (D,H), with this P fixed.
+
+**Theorem.** In characteristic two the unique optimum is Q=P. In odd
+characteristic there are exactly q^2 optimal Q, all with determinant one.
+Exactly q^2-1 have rank(Q-P)=1. In coordinates 0,1,2,3, the complete list is
+
+    Q = P + U D S V,                    S^2=0,
+    U = [e_0 e_2],   V = [e_1^T; e_3^T],
+    D = diag(2 lambda_1, 2 lambda_2).
+
+Here S is an arbitrary two-by-two matrix over F_q. The parameterization is
+injective in odd characteristic. The minimum wrapper error rank is two in
+odd characteristic and zero in characteristic two. Thus odd-characteristic
+optimal wrappers agree with interchange on exactly q^6 of the q^8 input pairs.
+
+Each individual J_2(lambda_i) has a unique optimum by #5556. Their direct
+sum has q^2 optima in odd characteristic. Multiplying individual counts
+would give one and misses all q^2-1 new coupled maps.
+
+## Credited starting point
+
+Nicholas Stone's [#5556](https://github.com/CrocSwap/integer-mult-bounds/pull/5556),
+`research/jordan-second-callee-count/PROOF.md`, gives the fixed-wrapper
+error reduction. Write A=P^2-I and R=Q-P. For invertible P and Q, the
+wrapper error rank is
+
+    rank M,   M = [[A,R],[R,0]].                         (1)
+
+The minimum is rank A, attained by R=0. The error identity and optimum are
+used as inherited statements, not re-audited here. They originate in Jerry
+Chen / CubeJerry's #2950 and Nick Petalas's #5228. The latter gives a general
+equality characterization for arbitrary P. The argument below specializes
+(1) directly to the new coupled pair and counts its complete solution set.
+It does not claim the general characterization as new.
+
+Nick Petalas's #6406 counts regular J_3(lambda), where P^2-I is invertible.
+Our P has singular P^2-I. The block-coupling question appears in #5556's
+Open next questions. No predecessor executable is used.
+
+## The support forced by equality
+
+In odd characteristic, each block of P has square
+I+2 lambda_i N, where N=[[0,1],[0,0]]. Therefore
+
+    A=U D V,    rank A=2,    V U=0,
+    im A=span(e_0,e_2),    ker A=span(e_0,e_2).
+
+If rank M=rank A, its top block row [A R] cannot have rank greater than A.
+Thus im R is contained in im A. The first block column [A; R] likewise
+forces ker A contained in ker R. These two containments say exactly that
+
+    R=U T V                                                  (2)
+
+for a unique two-by-two T. In particular the only possible nonzero entries
+of R are at (0,1),(0,3),(2,1),(2,3). No candidate is discarded on a clean-input
+assumption. These are consequences of equality for the entire error map.
+
+Substitute (2) into M and delete its identically zero rows and columns.
+Permuting the remaining rows and columns yields
+
+    [[D,T],[T,0]].
+
+Since D is invertible, block elimination gives
+
+    rank M = 2 + rank(T D^-1 T).
+
+Put T=D S. Then T D^-1 T=D S^2, so equality is equivalent to S^2=0.
+Since U has independent columns, V has independent rows and D is invertible,
+different S yield different R and hence different Q.
+
+## The invertibility filter accepts every parameter
+
+Order the coordinates as (0,2,1,3). In this order P+U D S V is
+
+    [[Lambda, I_2+D S], [0,Lambda]],
+    Lambda=diag(lambda_1,lambda_2).
+
+It is invertible for every S, with determinant
+(lambda_1 lambda_2)^2=1. Invertibility is proved before counting; no singular
+second maps are counted as optima. This remains true when the two signs differ.
+
+## Count and perturbation ranks
+
+The square-zero two-by-two matrices over any field are exactly
+
+    S=[[a,b],[c,-a]],    a^2+bc=0.                           (3)
+
+This elementary parameterization, including characteristic two, is recorded
+in #5556. For c=0, the equation forces a=0 and permits any b, giving q choices.
+For each of the q-1 nonzero c, any a determines the unique b=-a^2/c,
+again giving q choices. Thus (3) gives q+(q-1)q=q^2 parameters.
+One is zero; every other one has rank one because im S is contained in ker S.
+The injective left/right maps in U D S V preserve that rank. This proves
+the count and the stated rank distribution.
+
+For a concrete coupled optimum take S=E_01. Then R has the single nonzero
+entry R_03=2 lambda_1. Both diagonal two-by-two blocks of Q remain unchanged,
+yet Q differs from the independent-block optimum P.
+
+Finally, a rank-two linear error map on the eight-dimensional input space
+has a six-dimensional kernel, hence q^6 agreeing inputs.
+
+## Characteristic two
+
+The equation lambda_i^2=1 over a field of characteristic two implies
+lambda_i=1. Each J_2(1) squares to I, so A=0. Equation (1) then has rank
+2 rank R. Its minimum zero is attained exactly when R=0. Consequently Q=P
+is the unique optimum. The odd-characteristic count cannot be transferred
+to this case because D is zero.
+
+## Scope and open next questions
+
+This settles one coupled finite-field equality/counting problem. The first
+verified pair ended the investigation. No larger block family, selected
+assumption, physical implementation or cost advantage is proved. Native
+coefficients, movement, restoration, precision, stock, compiler and outer
+costs remain unpriced. No new kappa, selected frontier, exact interchange in
+odd characteristic, or complete multiplication theorem is claimed.
+
+Further questions and their first steps are in TASK.json. Classical block
+elimination, rank-nullity and finite-field counting are not claimed as new.

research/coupled-resonant-jordan-pair/README.md

@@ -0,0 +1,127 @@
+# Two rigid Jordan blocks have q squared coupled optima
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+For the unchanged ordinary wrapper, fix
+
+    P=diag(J_2(lambda_1),J_2(lambda_2)),   lambda_i^2=1.
+
+Over any odd finite field F_q, there are exactly **q^2** optimal invertible
+second maps Q. In characteristic two, Q=P is the unique optimum. This is a
+scoped written proof with exact finite corroboration, with no new kappa.
+
+Nicholas Stone's [#5556](https://github.com/CrocSwap/integer-mult-bounds/pull/5556)
+proves that either block alone has only one optimum and leaves coupled
+blocks open. The new count shows why multiplying individual counts fails.
+Its fixed-wrapper error reduction and two-dimensional square-zero count
+are cited inputs. No predecessor scientific verifier is replayed.
+
+## Complete parameterization
+
+In odd characteristic, all optima are exactly
+
+    Q=P+U D S V,   S^2=0,
+    U=[e_0 e_2],   V=[e_1^T; e_3^T],
+    D=diag(2 lambda_1,2 lambda_2).
+
+The q^2 square-zero matrices S give distinct Q. Every such Q has determinant
+one; q^2-1 have rank(Q-P)=1. For example S=E_01 adds the single cross-block
+entry Q_03=2 lambda_1 without changing either diagonal Jordan block.
+
+[PROOF.md](PROOF.md) proves completeness by forcing the perturbation into
+the rank-two image/kernel support, then reducing the remaining equality to
+S^2=0. The determinant filter accepts every parameter, including mixed signs.
+The minimum error rank is two in odd characteristic. Agreement with exact
+interchange therefore holds on q^6 of q^8 inputs, rather than on every input.
+
+## 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/coupled-resonant-jordan-pair/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/coupled-resonant-jordan-pair/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/coupled-resonant-jordan-pair
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/coupled-resonant-jordan-pair --check-source-history
+```
+
+Another CPython 3.12 path may replace the prefix. The direct marker is
+`PASS_COUPLED_RESONANT_JORDAN_PAIR no_new_kappa`. Each run prints a generated
+JSON receipt bound to SHA256 hashes of all six package files and writes no
+files. There is no handwritten receipt or predecessor executable dependency.
+[VERIFY.json](VERIFY.json) registers normal and optimized commands. Explicit
+exceptions keep every acceptance check active with Python -O.
+
+The verifier builds exact fields of orders 2,3,4,5,7,8,9,11,13 and checks
+their field laws. It enumerates every four-entry perturbation in the forced
+support for every resonant sign pair, compares the complete accepted set
+with a separately enumerated square-zero catalogue, and runs all eight
+original input basis columns of every accepted wrapper. It also enumerates
+all 65,536 binary four-by-four second maps and executes the literal wrapper
+on every invertible one. Rejection controls cover off-support entries,
+non-square-zero couplings and misuse of the odd-characteristic count.
+The extension fields use polynomial coordinates, not composite-modulus
+integer arithmetic.
+
+The finite totals are 27 field/sign contexts, 215,848 supported perturbations
+and 1,819 accepted wrappers. The full binary census has 20,160 invertible
+second maps and exactly one optimum. Together the literal replays check
+175,832 original input basis columns. Fifteen rejection controls and one
+coupled positive control pass. Normal and optimized local runs on CPython
+3.12.15 produce identical receipts.
+
+## Scope and credit
+
+The `formal-interface-lemma` card has changed scope to this algebraic side
+result. No selected assumption is discharged. Native implementation,
+restoration, movement, precision, stock, compiler, complete supplier costs
+and outer use remain unpriced. The selected #7000 frontier is unchanged.
+No larger block family, complete multiplication theorem, independent human
+review or formal proof-kernel acceptance is claimed. Lean, Docker, predecessor
+scientific suites and the selected cold replay are unrun.
+
+Credit Nicholas Stone / #5556 for the multiblock question, Jordan method,
+wrapper reduction and two-dimensional square-zero count; Nick Petalas /
+#5228 for the general equality characterization and #6406 for the distinct
+regular J3 count; Jerry Chen / CubeJerry / #2950 for the wrapper optimum;
+and the retained ordinary/native lineage. Classical block elimination and
+finite-field counting are not claimed as new. [SOURCES.json](SOURCES.json)
+pins predecessor prose, catalogue and selected record as historical provenance.
+The direct verifier imports none of them.
+
+The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19539400)
+records the question. Base is canonical main
+`e54523517d0f03e58352e647c403a5af3e525a57`, priority revision 8. Entry checks
+covered live open PRs, this account's recent work, recent handoffs and local
+reservations, all 10,178 current note records, cached snapshots of 488 open
+PRs and 7,148 Discussion records, and targeted main/merged searches. No
+matching coupled resonant-pair count surfaced. Unpublished work and arbitrary
+historical diffs remain coverage limits.
+
+## Open next questions
+
+- Count one pair with at least one eigenvalue squared different from one.
+  First fix distinct regular eigenvalues over F5 and derive the new quotient
+  and determinant filter. The present singular-support reduction does not
+  classify that problem.
+- Price one explicit coupled map in a physically specified ordinary caller.
+  Its correctness domain, native coefficients and restoration costs must be
+  supplied before optimal agreement can imply a useful implementation.
+
+The structured questions are in [TASK.json](TASK.json). The first proved pair
+ended the investigation.
+
+## Verification constraints
+
+The standalone verifier has no recursion, subprocesses, network calls or
+external scientific imports. Its domains are fixed at q<=13 and matrix sizes
+two, four or eight. Candidate scans stream at most 13^4 tuples per context;
+accepted sets contain at most 169 tuples. The binary scan visits 2^16 matrices.
+Every function is shorter than 60 physical lines. Exceptions enforce matrix,
+field, rank and endpoint invariants in both interpreter modes.
+
+Managed CPython allocation is a Power of Ten rule 3 deviation. Fixed domains
+bound live collections; no fixed-allocation runtime is claimed. Rule 10 uses
+warning-strict execution and AST compilation, plus the registered replay;
+no separate static analyzer is configured. Revisit these bounds before
+accepting variable fields or dimensions. No shared implementation is changed.

research/coupled-resonant-jordan-pair/SOURCES.json

@@ -0,0 +1,42 @@
+{
+  "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"
+    },
+    {
+      "path": "research/jordan-second-callee-count/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "9686b917aa7bfd9a3b59672bec414d68cfae6aad",
+      "sha256": "e267e006f420563548bc5b36817691e3772c8237552f266382b0974f10b2abe5"
+    },
+    {
+      "path": "research/jordan-second-callee-count/README.md",
+      "usage": "provenance",
+      "git_blob": "da13fd8c532ac2494aa5f0b6e959f4fa971a2290",
+      "sha256": "d5370bdc01a7aa8bc8b1b039548ecb8fce09dfa633cf72ca77bc59b780461611"
+    },
+    {
+      "path": "research/jordan-three-callee-count/README.md",
+      "usage": "provenance",
+      "git_blob": "8c5bf956d34ba972a89afd46851e2f942c536a1e",
+      "sha256": "5f37421eeca0a1dc6ffc277ca50a07736b1b32919913a3e4b3d13237042447ae"
+    },
+    {
+      "path": "research/optimal-second-callees/README.md",
+      "usage": "provenance",
+      "git_blob": "01bf464c2cfbf576a089f1cdc5e71b367d7fcf85",
+      "sha256": "99c816abf0a7f0ef25843a7adb3b29b4ab983d108c04506827a622f696a5f33e"
+    }
+  ]
+}