Recognize nonsplit residue-field Frobenius tensors

research/residue-product-tensor-recognition/PROOF.md

@@ -0,0 +1,160 @@
+# Frobenius products over arbitrary finite residue fields
+
+Fix an explicit finite field K=F_q of characteristic p. For each j, let
+L_j=F_(q^d_j) be a finite extension of K and let h_ji be positive integers.
+Define
+
+    B_j=L_j[x_ji]/(x_ji^(p^h_ji)), N_j=p^(sum_i h_ji), A=product_j B_j.
+
+Empty height lists are allowed and give field factors. The dimension over K
+is n=sum_j d_j N_j. All tensor factor maps and determinants below are over K.
+
+**Recognition theorem.** From an arbitrary square K-tensor, the algorithm
+decides whether it is isotopic to multiplication in such an A. It returns
+the residue degrees, height lists, explicit coefficient-field tables, and
+three invertible factor maps U,V,W with t(Ua,Vb)=W ab. It uses deterministic
+polynomial time in n for fixed K. Neither a decomposition nor a field section
+is supplied. In particular, the algorithm does not enumerate q^d_j elements.
+
+This extends the recognition part of PR5661 beyond split residue fields.
+Nick Petalas's PR5252 supplies the finite-etale nucleus and spectral-projector
+precedent. PR5637 and PR5502 supply the local semilinear height argument.
+The new result recovers nonsplit coefficient fields and composes the complete
+recognition test and factor maps. No physical supplier or new kappa is claimed.
+
+During the submission refresh, apoursh's concurrent claim on supplied-field
+characters was found in Discussion5655, comment 19187845. That claim explicitly
+excludes arbitrary tensor recognition and coefficient-field discovery. This
+package is narrowed to those complementary outputs. The character formula,
+labels and transporter work remain with that claim and are not outputs here.
+
+## 1. Recover the nucleus and primitive factors
+
+Use the nucleus equations and acceptance gates of PR5661:
+
+    B={(X,Y):t(Xu,v)=Yt(u,v)}, dim_K B=n,
+
+with both projections injective, commutative image, and zero right kernel of t.
+The nucleus is a unital commutative matrix algebra. Recover its multiplication
+table and unit from a faithful projection.
+
+The least q-power Q>=n has ker(b -> b^Q)=J, the nilradical. The proof of J^n=0
+and the construction of primitive idempotents through ker(Frob_q-I) in PR5661
+do not require split residues. On each local factor the q-fixed algebra is
+exactly K; its basis separates the factors by spectral projectors. Retain that
+construction but remove the split-residue test dim(B/J)=number of factors.
+
+For each primitive e_j, calculate
+
+    B_j=e_jB, J_j=e_jJ, d_j=dim_K B_j-dim_K J_j.
+
+The residue is the field F_(q^d_j). All these quantities use K-linear algebra.
+This primitive decomposition is an exact algebra decomposition, with no
+recognition assumption about the final truncated-polynomial class.
+
+## 2. Recover regular modules over nonsplit residues
+
+For either nucleus module M, require
+
+    dim_K(e_jM / J e_jM)=d_j
+
+for every component. Choose any vector m_j outside J e_jM. The quotient is
+one-dimensional over the residue field, so this vector generates it as a
+B_j-module. The usual nilpotence argument is elementary here: if C=B_jm_j,
+then N=e_jM/C satisfies N=JN, whence N=J^nN=0. The sum m=sum_jm_j is cyclic.
+Since dim B=dim M=n, b -> bm is an isomorphism. Both matrices are checked.
+
+Necessity holds for a regular module. This changes the split test from a
+one-dimensional K-top to a d_j-dimensional K-top; rejecting all larger tops
+would incorrectly reject every nonsplit residue field.
+
+As in PR5661, choose generators u0,w0 for the two actions, put
+alpha(b)=X_bu0, gamma(b)=Y_bw0, and Phi(v)=t(u0,v). Cyclicity and the zero right
+kernel make Phi invertible. With beta=Phi^-1 gamma,
+
+    t(alpha(a),beta(b))=gamma(ab).
+
+This gives factor maps from the recovered algebra before any local class test.
+
+## 3. Recover the unique coefficient field by a power kernel
+
+Let B be one local component, J its radical, d its residue degree, e its unit,
+and D=q^d. The set
+
+    L={b in B : b^D=b}
+
+is a K-subalgebra: the D-power map is additive and multiplicative in the
+commutative algebra, and it fixes every scalar in K. It maps bijectively onto
+B/J. For existence, lift a residue c to t and choose a power R=D^a at least
+dim_K B. Then (t^D-t)^R=0, so t^R lies in L; its residue remains c. For
+uniqueness, the difference of two lifts is a fixed nilpotent z, so
+z=z^(D^a)=0 for large a. Thus reduction gives a field isomorphism L -> B/J.
+Every K-algebra automorphism preserves this uniquely defined L.
+
+Compute the K-linear kernel of Frob_D-I. Its dimension is d. Put e first in
+its basis and extend by independent kernel vectors. Multiplication gives an
+explicit d-dimensional field table in that basis. There is no search over the
+elements of L. Exponent D has only d*log_2(q)+1 bits, so repeated squaring is
+polynomial in d and log q.
+
+The separate certificate check verifies the coefficient table is a field:
+check commutativity, associativity, identity, zero nilradical and
+dim ker(Frob_q-I)=1. A finite reduced commutative K-algebra is a product of
+finite fields, and the last dimension is its number of factors. These tests
+therefore prove that the supplied table has one field factor, without an
+elementwise inverse search.
+
+## 4. Recover heights over the coefficient field
+
+Use the semilinear p-power kernels K_h=ker(b -> b^(p^h)). The matrices and
+their inverse coefficient twists are computed over K as in PR5637. Each K_h
+is also an L-subspace: raising an L-scalar to p^h is an automorphism of L.
+Likewise J^2 is an L-subspace.
+
+Start with J^2. For h in increasing order, inspect a K-basis of K_h. When a
+vector v adds a new tangent direction, add the full L-span Lv by multiplying
+v with every coefficient-field basis element. Its K-dimension increment is
+exactly d: a nonzero line over L has dimension d over K. Record v as one
+generator of height h. This does not record d copies of the same generator.
+
+The result is a list g_i with g_i^(p^h_i)=0 whose classes form an L-basis of
+J/J^2. They generate B over L by the radical-power argument of PR5502:
+expand each J^k modulo J^(k+1), then iterate to J^n=0. Therefore substitution
+gives a surjective L-algebra map
+
+    L[x_i]/(x_i^(p^h_i)) -> B.
+
+Accept precisely when d*p^(sum_i h_i)=dim_K B. The dimensions then agree and
+the map is an isomorphism. In the target algebra the p-power tangent flag
+recovers exactly its variable heights; no nonlinear term can cancel the
+surviving single-variable monomial of a lower-degree linear term. This proves
+necessity as well as sufficiency.
+
+The model basis consists of each ordered variable monomial multiplied by every
+coefficient-field basis element. These explicit columns are checked for full
+rank. Combining the local model maps with alpha,beta,gamma gives U,V,W. The
+certificate checker verifies all n^2 transported basis products independently
+of the discovery kernels. This proves the recognition theorem.
+
+## 5. Complexity and the kappa boundary
+
+The nucleus elimination costs O(n^7) base-field operations. Radical and fixed
+spaces use K-linear systems. Powers q^d require O(d log q) algebra products,
+not q^d operations. Tangent tests use coefficient-field basis vectors, not
+all coefficient-field elements. The primitive splitting enumerates q scalars
+for each fixed-algebra basis vector. A conservative bound for the complete
+algorithm and certificate check is O(n^9+q*n^6*log(q*n)) K-operations, after
+the explicit base-field table is built. Space is polynomial in n. This is a
+fixed-q statement; no polynomial bit bound in log q is claimed.
+
+The package closes recognition and explicit factor-map extraction for the full
+declared family of finite residue-field Frobenius products. The tensor atlas
+can apply it directly to tensor coefficients. General local algebras with other
+relations, efficient canonical field isomorphisms, physical native maps,
+coefficient costs, ownership, restoration, precision, storage and a complete
+caller remain separate. Unknown physical costs are not zero. The selected
+frontier and complete kappa calculation are unchanged.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. The same
+assistant wrote the proof and checks. Independent scientific review remains
+open; no proof-kernel acceptance is claimed.

research/residue-product-tensor-recognition/README.md

@@ -0,0 +1,102 @@
+# Recognize Frobenius products with arbitrary finite residue fields
+
+This package recognizes arbitrary square K-tensors that are isotopic to
+products of L[x_i]/(x_i^(p^h_i)), where K=F_q and each L is any finite extension
+of K. It returns every residue degree, height list, coefficient-field table,
+and all three factor maps. No decomposition or coefficient-field section is
+supplied. The output is an explicit algebra model and a literal tensor-isotopy certificate.
+
+This removes the split-residue restriction of
+[PR #5661](https://github.com/CrocSwap/integer-mult-bounds/pull/5661).
+The new coefficient field is the kernel of Frob_(q^d)-I inside a local component
+of residue degree d. Height tests use spans over that recovered field. Both
+steps use base-field linear algebra and avoid enumeration of q^d elements.
+The regular-module top has base-field dimension d.
+
+The algorithm is necessary and sufficient for the stated class, and polynomial
+in tensor dimension for each fixed K. Read [PROOF.md](PROOF.md),
+[recognize.py](recognize.py), [RESULT.json](RESULT.json) and
+[SOURCES.json](SOURCES.json). The result supplies an input test for the tensor
+atlas. It supplies no paid physical construction or complete kappa increase.
+
+## Contract
+
+`recognize(t, field)` returns `(certificate, None)` or `(None, reason)`.
+Invalid tensor shapes or noncanonical field elements raise `ValueError`.
+The base field uses the exact explicit representation retained from PR5637.
+The certificate has `components`, `U`, `V` and `W`.
+Each component has `degree`, sorted `heights`, and a `field` multiplication
+table whose first basis vector is one. Model basis order is variable monomial
+first, then coefficient-field basis. All maps satisfy `t(Ua,Vb)=W mu(a,b)`.
+
+The coefficient-field tables use discovered bases. Character images,
+canonical orbit labels and determinant-one transporters between different
+field tables are outside this package. The separate
+[concurrent character claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5655#discussioncomment-19187845)
+uses supplied decompositions and explicitly leaves this discovery task open.
+The package was narrowed after the submission overlap refresh to preserve
+that separation. No field-presentation conversion is silently assumed.
+
+## Verification
+
+Use Python 3.12 and the standard library:
+
+```sh
+python3 -B scripts/research_package.py --package research/residue-product-tensor-recognition
+```
+
+Both normal and optimized commands must print
+`PASS_RESIDUE_PRODUCT_TENSOR_RECOGNITION`. A separate coefficient-index GL orbit
+generator agrees on every one of the 72,353 two-dimensional tensors over
+F2/F3/F4, accepting 174/4,320/62,460. The new accepted cases include nonsplit
+quadratic fields. This oracle does not use the nucleus or discovery kernels.
+
+Further presentations over F2/F3/F4/F9 check nonsplit nilpotent factors,
+repeated factors, mixed residue types, and residue degrees two and three.
+Controls reject false maps and fields, wrong residue degrees, extra local
+relations and nonregular modules. The coefficient-field validator also rejects
+a reduced product of two fields. [RESULT.json](RESULT.json) gives the exact
+counts, and [VALIDATION.md](VALIDATION.md) records the execution boundary.
+
+## Credit and scope
+
+Base is canonical main `df0137efd35e11b4445734bf612bdd4c7ebc330c`, priority 7.
+The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/5655#discussioncomment-19187846)
+records the fresh overlap check and changed residue premise. No selected file
+or predecessor package is changed.
+
+- [PR #5661](https://github.com/CrocSwap/integer-mult-bounds/pull/5661), exact
+  `5d722279f4292c63361f1e958ff4ed5a6ec638aa`, supplies the split-product framework,
+  basic linear-algebra helpers and the independent finite orbit-check routines.
+- [PR #5637](https://github.com/CrocSwap/integer-mult-bounds/pull/5637) supplies
+  the retained finite-field arithmetic and semilinear-kernel code. Its local
+  height proof uses apoursh's [PR #5502](https://github.com/CrocSwap/integer-mult-bounds/pull/5502).
+- apoursh's [PR #5656](https://github.com/CrocSwap/integer-mult-bounds/pull/5656)
+  supplies split-product characters. Nick Petalas's
+  [PR #5252](https://github.com/CrocSwap/integer-mult-bounds/pull/5252) supplies
+  the finite-etale nucleus, spectral projectors, norms and Galois-sign precedent.
+  David Ganz and the retained atlas authors keep their credit.
+
+Exact executable and proof inputs are retained byte-for-byte and authenticated
+before imports. The new code extends the nucleus/module composition and orbit
+checks; it does not claim those predecessor methods as new. Coefficient-field
+lifting is classical finite algebra. The new result is the complete recognition
+interface for the stated nonsplit nonreduced family, with exact
+certificates and checks. No literature-priority claim is made.
+
+Physical native realization, coefficient costs, ownership, restoration, storage,
+precision and a complete caller remain unpriced. Unknown costs are not zero.
+Independent human or proof-kernel acceptance, hosted CI and the selected cold
+replay are separate from these author-side checks.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Open next questions
+
+- Connect these recovered field tables to the concurrent supplied-decomposition
+  character interface. Coordinate there before implementing field isomorphisms,
+  labels or transporters.
+- Choose an actual accepted tensor and price its maps in a complete native
+  caller before treating the algebraic result as a kappa improvement.
+
+First steps and blockers are also recorded in [TASK.json](TASK.json).

research/residue-product-tensor-recognition/RESULT.json

@@ -0,0 +1,25 @@
+{
+  "basis_products": 1392,
+  "controls": 272,
+  "exhaustive": [
+    {
+      "accepted": 174,
+      "q": 2,
+      "sha256": "366c04b598dc02e7935e6319f2ad5b456c8b6d0255a9c4f9e173f40a4af6ebbe",
+      "tensors": 256
+    },
+    {
+      "accepted": 4320,
+      "q": 3,
+      "sha256": "eadf8e8ac6baeff11383ef29909bb4820bc0264f50045c8625a54c2ac59a25c1",
+      "tensors": 6561
+    },
+    {
+      "accepted": 62460,
+      "q": 4,
+      "sha256": "f328c998c3346bf59d15818429d6d04597321ea4e424da4e51d233a5d845fc0d",
+      "tensors": 65536
+    }
+  ],
+  "presentations": 52
+}

research/residue-product-tensor-recognition/SOURCES.json

@@ -0,0 +1,86 @@
+{
+  "schema_version": 1,
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "research/etale-tensor-determinant-image/README.md",
+      "usage": "provenance",
+      "git_blob": "0f07df6ce2a8c43ea1fcc5f0081ee3532da28208",
+      "sha256": "2ec18042a1a63d5fd5da246f4f6060c5fb66cff338f25a2a1b95e3ea8b4f0fba"
+    },
+    {
+      "path": "research/residue-product-tensor-recognition/vendor/split.py",
+      "usage": "input",
+      "git_blob": "21f134736133fbe8f2e2b8eb75fecbf8a0194670",
+      "sha256": "127d226258a781a050c6c80779dd392b403194d81d5d69e20debb811e8e8bceb",
+      "pin": "head:fccecc22b51b502a2428130448fd644e103e02e1:research/residue-product-tensor-recognition/vendor/split.py"
+    },
+    {
+      "path": "research/residue-product-tensor-recognition/vendor/local.py",
+      "usage": "input",
+      "git_blob": "1066bb74c19d180bfef7d9dd1c0650ec6bbd7780",
+      "sha256": "6daa160346d04691c6ca3c9c820b3df8982de4320ec01e5db10e3cb932f42c00",
+      "pin": "head:fccecc22b51b502a2428130448fd644e103e02e1:research/residue-product-tensor-recognition/vendor/local.py"
+    },
+    {
+      "path": "research/residue-product-tensor-recognition/vendor/PR5661.md",
+      "usage": "input",
+      "git_blob": "c3d085b38a02d3c854ece5b87e958c96993ff32b",
+      "sha256": "5da97eed522c0a158fd192d242425fed028fa8aace234b9d66fe6afac97390bb",
+      "pin": "head:fccecc22b51b502a2428130448fd644e103e02e1:research/residue-product-tensor-recognition/vendor/PR5661.md"
+    },
+    {
+      "path": "research/residue-product-tensor-recognition/vendor/PR5656.md",
+      "usage": "input",
+      "git_blob": "a9f931a378ebf7a67881d209f46c2f7fe47d1041",
+      "sha256": "0eb6c9f9eba70dc339e54b72a98b5b0fdcef706bcff5e02546ab2d0426a85ad9",
+      "pin": "head:fccecc22b51b502a2428130448fd644e103e02e1:research/residue-product-tensor-recognition/vendor/PR5656.md"
+    }
+  ],
+  "external_inputs": [
+    {
+      "local_path": "vendor/split.py",
+      "source_repository": "aliromman/integer-mult-bounds",
+      "source_commit": "5d722279f4292c63361f1e958ff4ed5a6ec638aa",
+      "source_path": "research/split-product-tensor-recognition/recognize.py",
+      "sha256": "127d226258a781a050c6c80779dd392b403194d81d5d69e20debb811e8e8bceb",
+      "git_blob": "21f134736133fbe8f2e2b8eb75fecbf8a0194670"
+    },
+    {
+      "local_path": "vendor/local.py",
+      "source_repository": "aliromman/integer-mult-bounds",
+      "source_commit": "5d722279f4292c63361f1e958ff4ed5a6ec638aa",
+      "source_path": "research/split-product-tensor-recognition/vendor/local.py",
+      "sha256": "6daa160346d04691c6ca3c9c820b3df8982de4320ec01e5db10e3cb932f42c00",
+      "git_blob": "1066bb74c19d180bfef7d9dd1c0650ec6bbd7780"
+    },
+    {
+      "local_path": "vendor/PR5661.md",
+      "source_repository": "aliromman/integer-mult-bounds",
+      "source_commit": "5d722279f4292c63361f1e958ff4ed5a6ec638aa",
+      "source_path": "research/split-product-tensor-recognition/PROOF.md",
+      "sha256": "5da97eed522c0a158fd192d242425fed028fa8aace234b9d66fe6afac97390bb",
+      "git_blob": "c3d085b38a02d3c854ece5b87e958c96993ff32b"
+    },
+    {
+      "local_path": "vendor/PR5656.md",
+      "source_repository": "aliromman/integer-mult-bounds",
+      "source_commit": "5d722279f4292c63361f1e958ff4ed5a6ec638aa",
+      "source_path": "research/split-product-tensor-recognition/vendor/PR5656.md",
+      "sha256": "0eb6c9f9eba70dc339e54b72a98b5b0fdcef706bcff5e02546ab2d0426a85ad9",
+      "git_blob": "a9f931a378ebf7a67881d209f46c2f7fe47d1041"
+    }
+  ]
+}