Prove exact square-zero radical reachability and binary count (no new κ)

research/square-zero-radical-reachability/README.md

@@ -0,0 +1,190 @@
+# Exact reachability of square-zero radical right-vector targets
+
+This contribution was produced by Nick Petalas. It answers the singular-target
+question in [#4601](https://github.com/CrocSwap/integer-mult-bounds/pull/4601),
+starting with its suggested algebra F₂[x,y]/(x,y)². The main result is a
+**scoped proof**, with exact finite corroboration. No new κ is claimed.
+
+Let K be any field and R = K ⊕ J a unital K-algebra with K central and J² = 0.
+The ideal J may have any dimension. A paid factor is I + u yᵀ with u ∈ R²
+and y ∈ K². Arbitrary GL₂(K) maps are free anywhere in a word. Factors may
+be singular. These are the formal alphabet and free-map convention of
+Wentao Li's #4099 and Nick Petalas's #4243/#4276.
+
+For every radical target M ∈ M₂(J), the exact answer is
+
+```text
+cost(M) = 2       if some nonzero φ ∈ (K²)* and v ∈ K² satisfy φ M v = 0;
+cost(M) = ∞       otherwise.
+```
+
+In particular, a third or later factor never enlarges the reachable radical
+set. This is a theorem for arbitrary finite words, not a bounded search failure.
+It does not classify all singular targets outside M₂(J), nonsplit extensions,
+higher nilpotency or more than two roles.
+
+For K = F₂ and finite d = dim J, write z = 2^d. The exact number of reachable
+radical targets is
+
+```text
+R_d = 9 z³ − 30 z² + 42 z − 20.
+U_d = z⁴ − R_d.
+```
+
+The exact pairs (reachable, unreachable) for d = 0,1,2,3 are
+(1,0), (16,0), (244,12), (3004,1092). The d = 2 value agrees numerically
+with the 12 unreachable targets reported by #4276; it is a calibration point,
+not new credit. The quantified criterion and counting law are the additions.
+
+## Proof of the criterion
+
+All products below use algebraic order; execution on column vectors is from
+right to left. A bar denotes scalar residue modulo J. Every paid factor has
+scalar residue of rank at least one, since it fixes the kernel of its
+base-field right row. Consequently a radical target needs at least two paid
+factors, even when M = 0. Free factors alone have invertible residue.
+
+**Necessity.** Read any realizing word in execution order, including its free
+maps. Start at I. There is a first event where the accumulated scalar residue
+becomes zero. The preceding product P has residue P₀ of rank one. The event
+cannot be a free map. Write its paid factor as
+
+```text
+Q = Q₀ + u₁ yᵀ,      Q₀ = I + u₀ yᵀ,
+P = P₀ + P₁,          P₁ ∈ M₂(J),  u₁ ∈ J × J.
+```
+
+Since Q₀ P₀ = 0 and neither residue is zero, Q₀ has rank one.
+Choose a nonzero row φ annihilating Q₀. Choose a nonzero column v in the
+kernel of the one-row matrix yᵀP₀. The square-zero relation gives
+
+```text
+QP = Q₀P₁ + u₁ yᵀP₀,
+φ(QP)v = 0.
+```
+
+Thus the first radical product has a common bilinear zero. Once the residue
+is zero, later multiplication by Q₀ + Q₁ acts as Q₀ on that radical product,
+because Q₁ times a radical matrix is zero. If Q₀ is invertible, transport φ
+by Q₀⁻¹. If it is rank one, take φ to annihilate its image. A later free map
+is the invertible case. This preserves the existence of a nonzero pair
+(φ,v) at every remaining event, and proves necessity for the final M.
+
+**Sufficiency.** Given φMv = 0, choose G,H ∈ GL₂(K) with first row of G equal
+to φ and second column of H equal to v. Then
+
+```text
+N = GMH = [[a,0],[c,d]],
+C₁ = [[a,0],[c,1]] = I + (a−1,c)ᵀ e₁ᵀ,
+C₂ = [[1,0],[0,d]] = I + (0,d−1)ᵀ e₂ᵀ,
+M = G⁻¹ C₁ C₂ H⁻¹.
+```
+
+Both C₁,C₂ are paid factors. This is the triangular construction behind
+#4276's two-factor criterion. Together with the lower bound it gives cost
+exactly two. The new necessity argument excludes every longer word when no
+common zero exists.
+
+## Proof of the binary counting law
+
+Choose a basis of J and write M = Σ_j A_j ε_j, with A_j ∈ M₂(F₂). Use the
+nondegenerate entrywise pairing on the four-dimensional matrix space. Let
+W = span(A₁,...,A_d) and S = W-perpendicular. The common-zero criterion is
+that S contains a nonzero rank-one tensor φᵀvᵀ, with entries φ_i v_j.
+Thus M is unreachable exactly when every nonzero element of S is invertible.
+
+Such a subspace S has dimension at most two: evaluation T ↦ T e₁ is injective
+on S and takes values in F₂². There is one zero subspace and six allowable
+one-dimensional subspaces, generated by the six invertible 2×2 matrices.
+There are exactly two allowable planes. To count them, normalize any nonzero
+A ∈ S to I by left multiplication. The other generator B must have B and
+I+B invertible, so its characteristic polynomial is x²+x+1. There are exactly
+two such binary matrices: their diagonal entries differ and both off-diagonal
+entries are one. Together with I they form the same normalized plane.
+Therefore each invertible A determines one allowable plane, and each plane
+is counted by its three nonzero elements, giving 6/3 = 2 planes.
+
+For a fixed S of dimension s, the ordered d coefficient matrices must span
+the fixed (4−s)-space W. There are Π_{i=0}^{3−s}(2^d−2^i) such tuples, by
+counting full-row-rank (4−s)-by-d binary matrices. The product is zero when
+d < 4−s. Hence
+
+```text
+U_d = (z−1)(z−2)(z−4)(z−8)
+    + 6(z−1)(z−2)(z−4) + 2(z−1)(z−2).
+```
+
+Expanding and subtracting from z⁴ proves the stated R_d. The rank-metric and
+finite-vector-space counting tools are classical; their application to this
+formal-alphabet reachability question is the scoped contribution.
+
+## Evidence and reproduction
+
+Run from the repository root, with CPython 3.12 and the standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B -W error research/square-zero-radical-reachability/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -B -W error research/square-zero-radical-reachability/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/square-zero-radical-reachability
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/square-zero-radical-reachability --check-source-history
+```
+
+Another CPython 3.12 interpreter may replace the absolute local path. The
+verifier writes nothing. It emits a generated SHA-256 receipt binding all
+package files and declared inputs, then PASS_SQUARE_ZERO_RADICAL_REACHABILITY.
+It compares the entire literal two-factor/free-endpoint image with the
+criterion on all radical targets for d = 0,1,2,3, and reconstructs every
+accepted target by the displayed word. The alphabet enumeration does not use
+the criterion. It independently derives the count polynomial by
+inclusion-exclusion over all 511 nonempty subsets of the nine rank-one
+bilinear forms. It checks all first-zero transitions for d = 1, plus six
+controls for obstruction, separate coefficient charts, reversed/dropped paid
+factors, a changed count coefficient and the dimension bound. Checks remain
+active under optimized Python. This finite evidence corroborates the written
+proof; it is not proof-kernel verification of its quantifiers.
+
+## Limitations and implementation decisions
+
+The algebra must be split with residue exactly K, two roles and J² = 0.
+Free maps and right vectors are common across all radical coordinates. Separate
+charts for each coordinate would wrongly accept the irreducible-pencil control.
+Every paid factor has its full formal price. Native preparation, routing,
+precision, restoration, stock and a complete supplier bill are unknown. No
+physical caller, 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 fixed dimension at most three, at most 766 distinct paid
+factors and at most 4096 radical targets. Functions remain below 60 lines.
+Power-of-ten rule 3 has a bounded managed-runtime deviation: Python allocates
+sets, tuples and integer objects during enumeration. Fixed loop domains bound
+the stored matrix sets by 4096 entries; this offline standard-library checker
+has no steady-state service or persistent resources. A future larger census
+must specify fresh memory/runtime bounds instead of increasing MAX_DIM silently.
+Warning-strict ordinary and optimized replays supply the available diagnostics;
+no separate static analyzer is required by the package environment.
+
+## Open next questions
+
+1. Does the common-zero obstruction lift through a local algebra with J³ = 0,
+   and what additional second-order condition is needed? Start with
+   F₂[x,y]/(x,y)³ and the same residue-first-zero expansion. Products of radical
+   entries no longer vanish, so the present invariant alone does not suffice.
+2. What is the exact finite-field counting law over F_q for q > 2? The criterion
+   already holds. Count subspaces of M₂(F_q) containing no rank-one matrix,
+   including the two-dimensional field-spread case, before any larger census.
+
+These follow-ups are not claimed or investigated here. Structured questions
+and blockers are in TASK.json.
+
+## Credit and source boundary
+
+Produced by Nick Petalas. Nick Petalas's #4276 supplies the exact two-factor
+criterion, its triangular factorization and the 12-target binary calibration;
+#4243 supplies the free-map normal form. ToikY's #4334 develops the shared-chart
+field-product interface. Nick Petalas's #4601 explicitly leaves singular
+reachability open; its invertible-target theorem is not used as a lemma here.
+Wentao Li's #4099 supplies the right-vector alphabet and column bound, building
+on #2513. Exact unchanged main-source pins are in SOURCES.json. The original
+connector-alphabet-change card is explicitly changed to this algebraic side
+question, as in the predecessor right-vector packages. Apache-2.0.

research/square-zero-radical-reachability/SOURCES.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51",
+  "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-two-factor-criterion/PROOF.md",
+      "usage": "input",
+      "git_blob": "71888afa0db63d6d332cbbdc408abf1aa879681c",
+      "sha256": "c1065c51c839d11b0d31bccb8d39ebc07a869eb0f29899038518e3090a58c895"
+    },
+    {
+      "path": "research/right-vector-two-factor-criterion/README.md",
+      "usage": "input",
+      "git_blob": "8952fc9ae8a6e1144e5a0008141121aee66aec69",
+      "sha256": "e00d4352a98b02c5046d8796ba4ef2afd3c6a78d66b4398d23794ebd8147580d"
+    }
+  ]
+}

research/square-zero-radical-reachability/TASK.json

@@ -0,0 +1,68 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 7,
+  "base_commit": "b58ad9ef4d4e861b0eaa5dba41742bdc072dca51",
+  "original_card": {
+    "id": "connector-alphabet-change",
+    "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/universal-connector-boundary/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Construct and charge a legal extra operation on a minimal instance.",
+      "Prove a target-specific bound after adding one specified operation family."
+    ],
+    "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/universal-connector-boundary/verify.py"
+      ],
+      "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY",
+      "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.",
+    "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.",
+    "allowed_variations": [
+      "Choose one additional operation and a small source count for its first counterexample."
+    ],
+    "scope_change_triggers": [
+      "Keeping the alphabet and only increasing the source count; record this as a changed assignment.",
+      "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions."
+    ],
+    "overlap_terms": [
+      "universal connector",
+      "source-toggle",
+      "connector alphabet"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Classify all radical two-role right-vector targets over split square-zero K-algebras; prove exact cost 2 or unreachable and a closed binary count for every radical dimension.",
+  "scope_change_reason": "Take the explicit singular-target open question of PR4601 rather than extend the native connector alphabet. This is a formal-alphabet side result, not supplier admission.",
+  "bottleneck_link": "Separates reachable singular formal interfaces from targets no longer word can implement; native conversion and complete supplier costs remain unknown.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at the first verified common-zero criterion and its count; do not extend to higher nilpotency, more roles or a native implementation.",
+  "outcome": "completed",
+  "evidence": "README proof; complete literal two-factor images for radical dimensions 0..3; independent 511-subset counting polynomial; first-zero transition and rejection controls.",
+  "author": "Nick Petalas",
+  "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.",
+  "open_questions": [
+    {
+      "question": "Which additional obstruction appears when J cubed is zero but J squared is nonzero?",
+      "why_it_matters": "Decides whether longer words enlarge the radical image once first-order truncation fails.",
+      "first_step": "Expand the first zero residue event over F2[x,y]/(x,y)^3.",
+      "blocked_by": "Products of radical entries survive; no second-order invariant is supplied."
+    },
+    {
+      "question": "What is the closed reachability count over every finite field Fq?",
+      "why_it_matters": "Turns the arbitrary-field criterion into an exact distribution beyond binary coefficients.",
+      "first_step": "Count rank-one-free subspaces of M2(Fq) and their ordered spanning tuples.",
+      "blocked_by": "The binary plane count does not classify all higher-field subspaces."
+    }
+  ]
+}

research/square-zero-radical-reachability/VERIFY.json

@@ -0,0 +1,35 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/right-vector-two-factor-criterion/PROOF.md",
+    "research/right-vector-two-factor-criterion/README.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "-W",
+        "error",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact literal radical images, all-dimension binary count, first-zero transitions and rejecting controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-O",
+        "-B",
+        "-W",
+        "error",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Repeat all scientific checks with assertions disabled."
+    }
+  ]
+}