Classify exact two-versus-three costs for diagonal cube-zero lifts (no κ)

research/distinct-pencil-quadratic-lifts/PROOF.md

@@ -0,0 +1,137 @@
+# Exact cost of distinct-factor quadratic lifts
+
+Let K be any field, R=K[x,y]/(x,y)^3, and J=(x,y). There are exactly two
+roles. The paid alphabet is P(u,v)=I+u v^T with u in R^2 and v in K^2.
+Arbitrary GL2(K) factors are free anywhere; singular paid factors are allowed.
+The endpoint acts on every input in R^2, with no auxiliary roles.
+
+Write
+
+```
+M = [[a,b],[c,d]] = diag(x,y) + Q,       Q in M2(J^2),
+b = alpha*x^2 + beta*x*y + gamma*y^2,
+c = delta*x^2 + epsilon*x*y + zeta*y^2.
+```
+
+Then the exact minimum number of paid factors is
+
+```
+cost(M) = 2   if gamma=0 or delta=0;
+cost(M) = 3   if gamma and delta are both nonzero.
+```
+
+The contribution is this distinct-factor pencil classification and its
+attaining words. Ali Romman's #5320 asks for another first-order pencil and
+classifies a different, repeated-factor binary pencil. Nick Petalas's #4276,
+Theorem B, supplies the exact two-factor criterion used below. We cite that
+criterion, rather than reprove or scientifically replay its package.
+
+## Three factors always suffice
+
+Set s=alpha*x+beta*y. Since J^3=0,
+
+```
+a*s = alpha*x^2 + beta*x*y,
+c*s = 0,            y*c = 0,            y*d = y^2.
+```
+
+Consequently the following is an exact identity in M2(R):
+
+```
+M = [[1,gamma*y],[0,1]] [[a,0],[c,1]] [[1,s],[0,d]].
+```
+
+The factors are respectively
+
+```
+P((gamma*y,0)^T,e2),
+P((a-1,c)^T,e1),
+P((s,d-1)^T,e2).
+```
+
+Thus all three are legal paid factors, and there are no free endpoint maps
+or preparation assumptions in this formal identity. Multiplication order is
+algebraic; execution on column inputs is from right to left. This proves
+cost at most three for every Q over every field.
+
+If gamma=0, omit the identity first factor to obtain a two-factor word.
+If delta=0, put r=epsilon*x+zeta*y. Then d*r=c and b*r=0, giving instead
+
+```
+M = [[1,b],[0,d]] [[a,0],[r,1]].
+```
+
+These are paid factors with right rows e2 and e1. They prove the stated
+two-factor upper bounds, including their intersection.
+
+## No other lift has a two-factor word
+
+Use #4276's criterion: cost(M)<=2 exactly when some G,H in GL2(K) give
+N=GMH with N12 in N11 R. Suppose this occurs. Let phi be the first row of
+G and t,s the first and second columns of H. There is h in R with
+
+```
+phi*M*s = (phi*M*t)*h.
+```
+
+Write h=lambda+h1, with lambda in K and h1 in J, and put v=s-lambda*t.
+The vector v is nonzero and t,v remain a K-basis. The equation becomes
+
+```
+phi*M*v = (phi*M*t)*h1.
+```
+
+The right side has no linear part. Write phi=(p,q) and v=(v1,v2)^T.
+The linear part of the left side is
+
+```
+p*v1*x + q*v2*y.
+```
+
+The two linear monomials are independent, so p*v1=q*v2=0. Since both phi
+and v are nonzero, exactly one of these cases holds:
+
+1. phi is a nonzero multiple of e1^T and v is a nonzero multiple of e2.
+   Then t1 is nonzero because t,v are independent. The left side is a
+   nonzero K-multiple of b. The linear part of phi*M*t is a nonzero
+   K-multiple of x. Multiplication by h1 can therefore give only an element
+   of xJ=span_K{x^2,xy}. Quadratic parts times h1 vanish. Hence b is in xJ,
+   which is precisely gamma=0.
+2. phi is a nonzero multiple of e2^T and v is a nonzero multiple of e1.
+   Now t2 is nonzero. The same argument places c in
+   yJ=span_K{xy,y^2}, which is precisely delta=0.
+
+Thus the cited criterion excludes every word of cost at most two when
+gamma and delta are nonzero. This argument includes all constant free charts,
+all paid right rows, and factors not aligned with coordinate columns.
+
+Finally, M has zero scalar residue modulo J. A free endpoint has invertible
+residue. A single paid factor has residue I+u0*v^T of rank at least one,
+because it fixes ker(v^T) if v is nonzero and is I if v=0. Free factors
+preserve that rank. Therefore cost is at least two for every Q. Together
+with the constructions, this proves the exact classification.
+
+## Finite-field count
+
+For a finite field K of size q, Q has twelve independent coefficients.
+The cost-three condition makes gamma and delta nonzero and leaves the other
+ten coefficients arbitrary. Therefore, among all q^12 lifts,
+
+```
+number of cost-three lifts = (q-1)^2*q^10,
+number of cost-two lifts   = (2*q-1)*q^10.
+```
+
+For q=2 these counts are 1,024 and 3,072. The total and the classification
+are proved by the preceding argument; the software exhaustively enumerates
+this binary case. It samples F3, F5 and F7 and does not enumerate their
+entire lift spaces or any extension field.
+
+## Limits
+
+This is a scoped theorem in the specified formal alphabet. It does not
+classify arbitrary first-order pencils or all cube-zero radical targets.
+It supplies no native coefficient producer, routing, restoration, precision,
+stock, physical caller or recursive supplier bill. Those obligations are
+unrun and unknown. No new kappa or complete multiplication theorem follows.
+Independent human and formal proof-kernel review are unclaimed.

research/distinct-pencil-quadratic-lifts/README.md

@@ -0,0 +1,113 @@
+# Exact two-versus-three cost for distinct-factor quadratic lifts
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+**Claim type: scoped written proof with exhaustive binary corroboration.**
+For every field K, let R=K[x,y]/(x,y)^3 and J=(x,y). On exactly two roles,
+allow paid factors I+u v^T with u in R^2 and v in K^2, arbitrary free
+GL2(K) maps, and singular paid factors. Write
+
+```
+M = diag(x,y) + Q,   Q in M2(J^2),
+gamma = coefficient of y^2 in Q12,
+delta = coefficient of x^2 in Q21.
+
+cost(M) = 2 if gamma=0 or delta=0, and 3 otherwise.
+```
+
+Every lift is reachable. For a finite field of size q, the exact counts are
+(2q-1)q^10 lifts of cost two and (q-1)^2 q^10 of cost three. For F2 the
+counts are 3,072 and 1,024. No new kappa is claimed.
+
+[PROOF.md](PROOF.md) gives the all-field argument. A radical shear followed
+by two column replacements supplies the upper bound. The cited two-factor
+ideal criterion reduces the lower bound to the two displayed coefficients.
+The exact cost concerns arbitrary inputs in R^2, with no zero-input or
+scratch assumption.
+
+## What this adds
+
+Ali Romman's [#5320](https://github.com/CrocSwap/integer-mult-bounds/pull/5320),
+`research/cube-zero-lift-obstruction`, asks for another first-order pencil.
+It classifies the binary repeated-factor pencil [[x,y],[y,x]], with some
+unreachable lifts. This package settles the distinct-factor pencil diag(x,y)
+over every field, with every lift reachable and some needing a third factor.
+Its proof and computations concern the new pencil only. No predecessor
+scientific verifier or census is imported, replayed or audited.
+
+Nick Petalas's [#4276](https://github.com/CrocSwap/integer-mult-bounds/pull/4276)
+supplies the exact two-factor criterion; #4764 supplies an earlier separate
+pure-quadratic cost-three example. Wentao Li's #4099 following #2513 supplies
+the alphabet, and ToikY's #4334 supplies related common-chart context. Classical
+truncated-polynomial arithmetic and coefficient counting retain their credit.
+
+## Evidence and reproduction
+
+From the repository root, use CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -B -W error research/distinct-pencil-quadratic-lifts/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -B -W error research/distinct-pencil-quadratic-lifts/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/distinct-pencil-quadratic-lifts
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/distinct-pencil-quadratic-lifts --check-source-history
+```
+
+Another CPython 3.12 path may replace the local path. The direct scientific
+marker is `PASS_DISTINCT_PENCIL_QUADRATIC_LIFTS no_new_kappa`. The checker
+writes nothing and emits a generated receipt binding all package files.
+
+The checker enumerates all 4,096 binary lifts. For each, it compares the new
+coefficient test with the cited principal-ideal criterion. It searches free
+GL2(F2) endpoint pairs until a witness is found, and exhausts all 36 pairs
+for each rejection. It replays every attaining word and checks the action on
+all twelve K-basis inputs of R^2. There are 49,152 basis-input comparisons.
+The coefficientwise ring multiplication and packed binary action are separate
+calculation paths. The criterion is a cited theorem; these checks apply it
+to the new targets rather than independently validating that predecessor.
+
+The checker also replays explicit words on 34, 74 and 122 distinct samples
+over F3, F5 and F7. Samples include every single-coordinate perturbation and
+one dense perturbation for every pair (gamma,delta), with exact deduplication.
+Eight rejecting controls cover four omitted/reversed words, an odd-field
+sign error, and three invalid inputs. Ring controls distinguish square-zero
+from cube-zero truncation. Checks stay active under optimized Python.
+Both registered commands were timed separately on CPython 3.12.15 at
+0.33 seconds each. The complete registered launcher also passed.
+
+[SOURCES.json](SOURCES.json) pins the unchanged source prose, catalogue and
+selected record as historical provenance at canonical main
+`e54523517d0f03e58352e647c403a5af3e525a57`. No external runtime input is read.
+The source-binding orientation passed with
+`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`; it is not a selected operator replay.
+
+## Scope and implementation limits
+
+The card formal-interface-lemma is explicitly changed to an algebraic side
+question. This locates one boundary where cubic nilpotence permits a third
+paid update; it does not discharge a selected framework assumption. The
+selected frontier is unchanged. Native preparation, physical movement,
+restoration, precision, stock and the complete recursive invoice remain
+unknown. No native, compiler, Lean, Docker or selected scientific cold replay
+was run. Independent human and formal proof-kernel review are unclaimed.
+
+The offline checker has no recursion, subprocesses or dynamic evaluation.
+All loops have fixed finite domains: six monomials, 64 binary ring elements,
+six binary free matrices, 4,096 binary targets, twelve basis inputs, and at
+most 122 stored samples per odd field. Every function is under sixty physical
+lines. CPython managed allocation is a deviation from fixed allocation,
+bounded by these domains and the 64-by-64 multiplication table. Explicit
+contracts and warning-strict normal/optimized runs provide the available
+runtime diagnostics. No external static analyzer or proof kernel is claimed.
+
+## Open next questions
+
+1. Classify lifts with a rank-one first-order pencil, such as diag(x,0).
+   Start with a three-factor normal form and retain its second-order terms.
+   The present proof uses two independent diagonal linear forms and does
+   not supply the necessary all-word obstruction for that pencil.
+2. Bind an attaining three-factor word to a literal native producer and
+   consumer. First price its radical coefficient shear, overwritten inputs
+   and restoration in one actual caller. Coefficient availability and a
+   complete physical invoice remain the blockers.
+
+Structured next steps and the bounded stop rule are in [TASK.json](TASK.json).

research/distinct-pencil-quadratic-lifts/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "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/cube-zero-lift-obstruction/README.md",
+      "usage": "provenance",
+      "git_blob": "10044ad7c5bdce30e67d756805b790f8fab1f07e",
+      "sha256": "36fc090489e43f8d73355aeeb7eac717d3d3a359b3abdf22530fc51a4068da20"
+    },
+    {
+      "path": "research/right-vector-two-factor-criterion/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "71888afa0db63d6d332cbbdc408abf1aa879681c",
+      "sha256": "c1065c51c839d11b0d31bccb8d39ebc07a869eb0f29899038518e3090a58c895"
+    }
+  ]
+}