Count rank-one lifts over residue-field extensions (no new κ)

research/right-vector-extension-residue/PROOF.md

@@ -0,0 +1,146 @@
+# Rank-one lifts with a smaller base field
+
+Let K=F_q be a subfield of L=F_Q. Let R be a finite-dimensional associative
+unital L-algebra, with L central, Jacobson radical J, and canonical residue
+R/J=L. Thus R=L direct-sum J as a K-vector space. Put z=|J|. Neither
+commutativity nor J squared zero is assumed.
+
+Use two roles. Paid factors are I+u v^T with u in R^2 and v in K^2.
+Arbitrary GL_2(K) maps are free anywhere. The cost is the least number of
+paid factors. Fix a rank-one matrix A in M_2(L), and consider all z^4
+lifts M=A+N with N in M_2(J).
+
+For a K-line D in K^2, call D eligible when A v belongs to K^2 minus {0}
+for one, equivalently every, nonzero v in D. Let t(A) count these lines.
+
+## Theorem
+
+The eligible-line count belongs to {0,1,q}. For each fixed residue A,
+
+```text
+cost 1: C_A = 0                    if t(A)=0,
+             1+t(A)*(z^2-1)        if t(A)>0;
+cost 2: z^4-C_A.
+```
+
+There are no cost-zero targets in these fibers and none needs a third paid
+factor. Among all rank-one residues in M_2(L), the exact counts by t are
+
+```text
+N_q = (q+1)*(q^2-1),
+N_1 = (q+1)*(q^2-1)*(Q-q),
+N_0 = (Q+1)*(Q^2-1) - N_q - N_1.
+```
+
+Consequently the complete rank-one-residue lift census has
+
+```text
+cost 1: N_q*(q*z^2-q+1) + N_1*z^2
+      = (q+1)*(q^2-1)*(Q*z^2-q+1);
+cost 2: (Q+1)*(Q^2-1)*z^4 - cost_1.
+```
+
+When Q=q this specializes to #4770. When Q>q, the cost distribution depends
+on the residue. The new contribution is this extension-field classification
+and its exact lift and residue counts. The one-factor criterion and unit-pivot
+upper bound below are cited predecessor results, not new claims.
+
+## The predecessor criteria
+
+Nick Petalas's #4276, Theorems A and D, and the specialization in #4770 give
+
+```text
+cost(M)<=1 iff Mv=w for some nonzero v,w in K^2.
+```
+
+This criterion holds for any central K-algebra. Our R qualifies even though
+its residue is larger than K. Reducing M=A+N modulo J shows that it becomes
+
+```text
+cost(M)<=1 iff some eligible v satisfies Nv=0.
+```
+
+The split decomposition is essential here: Av is in L^2 and Nv is in
+J times J, so Mv lies in K^2 minus {0} exactly when Av lies there and Nv=0.
+
+Every such M has a unit entry because A is nonzero. The unit-pivot two-factor
+bound from #4276 therefore applies. A free GL_2(K) target has invertible
+residue over L, so our rank-one residues exclude cost zero. These facts
+give exact costs one and two after counting the one-factor lifts.
+
+## Why only zero, one, or q lines occur
+
+Write A=a r with nonzero column a in L^2 and nonzero row r over L.
+If the L-image line La contains no nonzero K-vector, there is no eligible
+line. Otherwise rescale a so a belongs to K^2 minus {0}. Then
+
+```text
+Av belongs to K^2  iff rv belongs to K.
+```
+
+Indeed one nonzero coordinate of a lies in K and can be inverted in K.
+Let U={v in K^2:rv in K} and V={v in K^2:rv=0}. These are K-subspaces,
+V is contained in U, and eligible lines are precisely the lines of U outside V.
+Put k=dim_K U and h=dim_K V. Since r is nonzero, h<=1. The induced map
+U/V into K is injective, so k-h<=1. The only positive possibilities are
+(k,h)=(1,0) and (2,1), giving respectively
+
+```text
+t=(q^k-q^h)/(q-1)=1 or q.
+```
+
+If t=q, U=K^2, so both entries of r lie in K. Thus A itself has K entries
+and rank one over K. Conversely every rank-one K-matrix has q eligible
+lines. This proves the trichotomy and identifies the q-line class.
+
+## Count the lifts above each residue
+
+For each eligible line D, let E_D={N in M_2(J):Nv=0 for v in D}.
+Choose a K-basis of K^2 beginning with v. The action of N on that first
+basis vector is fixed at zero; its action on the second is arbitrary in
+J times J. Hence |E_D|=z^2. If D and D' are distinct, they span K^2,
+so E_D intersects E_D' only in N=0.
+
+When t=0 the union is empty. When t>0 its size is 1+t*(z^2-1). The zero
+noise belongs to every nonempty family of events but not to an empty one.
+This proves C_A, including J=0. No radical multiplication enters the count.
+
+## Count the three residue classes
+
+Over a field of order s there are (s^2-1)^2/(s-1)=(s+1)*(s^2-1)
+rank-one 2-by-2 matrices. Count their nonzero outer products and divide by
+the s-1 rescalings of either factor. Applying this with s=q gives N_q.
+
+Double-count pairs (A,D) with A rank one over L and D an eligible K-line.
+Fix D and use a GL_2(K) change of input coordinates to make D=K e_1.
+The first column w=Ae_1 may be any of the q^2-1 nonzero vectors in K^2.
+Rank one over L then forces the second column to be c w for a unique
+c in L, giving Q choices. There are q+1 input lines, so
+
+```text
+sum_A t(A) = (q+1)*(q^2-1)*Q = N_1 + q*N_q.
+```
+
+Solve for N_1 and subtract N_1+N_q from the total number of rank-one
+L-matrices to obtain N_0. Multiplying by the per-fiber lift counts proves
+the aggregate formula. The projective-line and finite-field counting tools
+are classical; their application here is the stated scoped result.
+
+## First example
+
+Let K=F2, L=F4, and R=L[e]/e^2, so Q=4 and z=4. Of the 75 rank-one
+residues, 9 have t=2, 18 have t=1 and 48 have t=0. Each such residue has
+256 lifts. Their respective one-factor counts are 31,16,0. In total,
+567 lifts cost one and 18,633 cost two.
+
+If alpha belongs to F4 minus F2, the matrices
+
+```text
+[[1,0],[0,0]],  [[1,alpha],[0,0]],  [[alpha,0],[0,0]]
+```
+
+have t=2,1,0 respectively. With L-valued right vectors and GL_2(L) free
+maps instead, #4770's formula gives 4,575 one-factor lifts over these same
+75 residues. The smaller base field therefore changes a concrete cost count.
+
+Produced by Nick Petalas. Predecessor credit and scope are in README.md.

research/right-vector-extension-residue/README.md

@@ -0,0 +1,154 @@
+# Exact rank-one lift counts over a residue-field extension
+
+This package was produced by Nick Petalas. It answers Open next question 1
+of [#4770](https://github.com/CrocSwap/integer-mult-bounds/pull/4770) with a
+**scoped counting proof and exact finite corroboration**. No new kappa is claimed.
+
+Let K=F_q be a subfield of L=F_Q. Let R be a finite-dimensional central local
+L-algebra with canonical residue R/J=L, and put z=|J|. Paid factors are
+I+u v^T with u in R^2 and v in K^2; arbitrary GL_2(K) maps are free anywhere.
+Fix a rank-one residue A in M_2(L). Among the q+1 lines in K^2, let t(A)
+count those whose nonzero vectors A sends into K^2 minus {0}. Then
+
+```text
+t(A) belongs to {0,1,q}.
+
+For the z^4 lifts of A:
+    cost 1 = 0                         if t(A)=0;
+             1+t(A)*(z^2-1)             otherwise.
+    cost 2 = z^4-cost_1.
+```
+
+The numbers of rank-one residues in these three classes are exactly
+
+```text
+N_q = (q+1)*(q^2-1)
+N_1 = (q+1)*(q^2-1)*(Q-q)
+N_0 = (Q+1)*(Q^2-1)-N_q-N_1
+```
+
+Thus the total number of one-factor lifts is
+`(q+1)*(q^2-1)*(Q*z^2-q+1)`. The remaining rank-one-residue lifts cost two.
+Neither radical multiplication nor its nilpotency index enters this formula.
+The [proof](PROOF.md) classifies the eligible lines, counts their kernel
+fibers, and double-counts eligible residue/line pairs. The one-factor criterion
+and unit-pivot two-factor bound are credited inputs from #4276, specialized
+in #4770; this package does not audit or rerun their verifiers.
+
+The first example is R=F4[e]/e^2 over K=F2. Its 75 rank-one residues split
+into 9,18,48 residues with t=2,1,0 respectively. Their 19,200 lifts have
+exact costs one and two in counts **567** and **18,633**. Allowing F4-valued
+right vectors and free maps instead gives 4,575 one-factor lifts by #4770's
+formula. The field allowed in the alphabet changes a concrete cost count.
+
+## Finite evidence
+
+The standard-library verifier constructs the literal one-factor image
+`{(I+u v^T)G}` from every left vector, projective base-field right vector and
+free endpoint G. It does not use the eligible-line criterion to construct
+this image. It then enumerates every rank-one residue and every lift, comparing
+literal membership counts separately at each residue with the new formulas.
+The resulting cost-two counts use the cited unit-pivot theorem.
+
+The eight fixed fixtures use R=L[e]/e^k, including k=1, when J=0. Their
+exact cost-one/cost-two counts are:
+
+- F4 over F2, k=1: 27 / 48.
+- F4 over F2, k=2: 567 / 18,633.
+- F4 over F2, k=3: 9,207 / 4,905,993.
+- F8 over F2, k=1: 63 / 504.
+- F8 over F2, k=2: 4,599 / 2,317,833.
+- F9 over F3, k=1: 224 / 576.
+- F9 over F3, k=2: 23,264 / 5,225,536.
+- F16 over F4, k=1: 975 / 3,360.
+
+All **12,511,409** lifts are enumerated across these fixtures. The residue
+classification is also checked separately for every residue. Fields are
+polynomial quotients, and F4 inside F16 is identified by a^4=a. Nine controls
+cover the three line classes, the empty-union exception, a scalar kernel with
+zero image, a missing radical-kernel condition, the first example, changing
+the base field, and changing the extension degree.
+
+Every run emits a generated SHA256 receipt for all six package files. It
+writes only to stdout and does not rely on Git, network access, external
+packages, cached data or predecessor executable code. All checks use explicit
+exceptions and remain enabled with optimized Python.
+
+## Reproduction
+
+Run from the repository root with CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B -W error research/right-vector-extension-residue/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -B -W error research/right-vector-extension-residue/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/right-vector-extension-residue
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/right-vector-extension-residue --check-source-history
+```
+
+Any CPython 3.12 interpreter may replace the local absolute path. Both verifier
+commands are registered with a 120-second timeout. The expected final marker
+is `PASS_RIGHT_VECTOR_EXTENSION_RESIDUE`. SOURCES.json pins the mathematical
+predecessors as historical provenance at canonical main
+`624de9dc66858af0945e5f8a0942488d62280d43`. There are no live external inputs.
+
+The current source-binding orientation control passed
+`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`. This is orientation only, not a selected
+operator replay.
+The formal-interface-lemma card is explicitly changed to this algebraic side
+question rather than a proof-assistant or selected-caller obligation. The
+[advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19131534)
+identifies the exact question and credited sources.
+
+## Limits and implementation decisions
+
+The written proof quantifies over every finite-field extension and every
+finite-dimensional central local L-algebra with canonical residue L. The
+software checks only the fixed commutative fixtures. Nonsplit residue maps,
+noncentral coefficient fields, other residue ranks and more than two roles
+are outside the result. Native coefficient preparation, free-map realization,
+routing, restoration, precision, stock and a complete supplier bill are unknown.
+No supplier admission, complete multiplication theorem or selected-frontier
+change is supplied. Independent human and formal proof-kernel review are
+unclaimed. No Lean, Docker or selected-construction replay was run.
+
+The verifier has no recursion, subprocess, solver or variable-size command-line
+input. Field size is at most 16, ring size at most 81, nilpotency length at
+most three, and base-field size at most four. Arithmetic tables have at most
+81^2 entries. A literal image loop has at most
+`180*5*81^2` iterations, conservatively combining the separate enforced bounds.
+A residue loop has at most 16^4 candidates and a noise loop at most 16^4
+candidates per residue. Only one case and one current target are live at a time.
+Each function has fewer than 60 physical lines. Warning-strict ordinary and
+optimized runs provide the diagnostics available without additional packages.
+
+Power of Ten rule 3 has a managed-runtime deviation. Python allocates tuples,
+integers, dictionaries and set entries during the finite computation. Live
+literal targets are bounded by the paid-image loop above, plus the fixed
+arithmetic tables and at most 4,335 residue keys. Each receipt input is capped
+at 1 MiB. No persistent resource or steady service is present. A future larger
+census needs explicit new memory/runtime bounds; no domain expansion is claimed.
+
+## Open next questions
+
+1. What is the one-factor lift distribution above rank-one residues on more
+   than two roles? A one-factor word fixes a base-field hyperplane, so begin
+   with three roles and the intersections of eligible hyperplane kernels.
+   Pairwise intersections need not be just zero; the present line argument
+   does not classify them. This would test whether a comparable residue-only
+   count survives at larger role count.
+2. Can a native producer and consumer realize this restricted alphabet with
+   a favorable complete cost? Specify one source and destination contract,
+   including coefficient preparation, free-map costs and dirty restoration.
+   These unknown physical costs prevent turning the count into a supplier.
+
+Structured questions, first steps and blockers are in TASK.json.
+
+## Credit
+
+Produced by Nick Petalas. Nick Petalas's #4770 supplies the explicit extension
+question and scalar-residue count; #4276 supplies the one-factor and local
+unit-pivot criteria; #4243 supplies the free-map normal form. ToikY's #4334
+and Nick Petalas's #4601/#4749 develop related shared-chart local/semilocal
+interfaces. Wentao Li's #4099 supplies the paid alphabet and column bound,
+following #2513. The finite-field and projective-line tools are classical.
+The new claim is their extension-residue counting application. Apache-2.0.

research/right-vector-extension-residue/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/right-vector-rankone-residue/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "c3964055ed99504484203c7067bc09d1f79fb97b",
+      "sha256": "6fd956e364fb9134fb4408b7e117b2474afd38dce2e92d44299ecf011d65ebf5"
+    },
+    {
+      "path": "research/right-vector-two-factor-criterion/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "71888afa0db63d6d332cbbdc408abf1aa879681c",
+      "sha256": "c1065c51c839d11b0d31bccb8d39ebc07a869eb0f29899038518e3090a58c895"
+    }
+  ]
+}