[aliromman]

This closes the three-factor tensor-reconstruction handoff in PR #5502. The new regular-module criterion recognizes commutative unital multiplication from an arbitrary square prime-field tensor, including algebras with nilpotents. Composing the recovered table with the pinned Frobenius-truncated classifier returns the height list and explicit independent maps for both inputs and the output. Kappa is unchanged.

Proof and scope, exact checks, source pins, registered replay. Base: canonical main 32890bc5de034ab8fc93ac88ead7279a6a416d04, priority revision 7. Contribution head: 831b41da0fc09e3e4cb983c03662da5df7970f68.

The new condition tests the top of each local nucleus module modulo the nilpotent radical. Both modules must have one residue-field generator. Matching dimension and faithfulness alone are insufficient: the faithful dual module of F_p[x,y]/(x,y)^2 is an explicit rejecting control. The proof is necessary and sufficient and gives deterministic polynomial complexity at each fixed prime. It does not solve isomorphism of arbitrary recovered algebras.

CPython 3.12.14 warning-strict registered normal and optimized checks pass. All 256 binary 2x2x2 tensors agree with independent complete GL2-cubed orbit enumeration: 174 general commutative tensors and 54 Frobenius-truncated tensors. Forty additional presentations cover primes 2,3,5,7,13 and dimensions through nine. The checks verify 1736 literal transported basis products, 76 controls and three immutable source copies. Both modes print PASS_NONREDUCED_TENSOR_RECOGNITION; the launcher prints PASS_REGISTERED_RESEARCH_PACKAGE.

python3.12 -B scripts/research_package.py --package research/nonreduced-tensor-recognition

Python 3.12 and the standard library suffice. Committed-byte checks pass. The pinned PR #5502 class theorem remains a credited premise; its complete prior scientific suite is not rerun. The new written proof has no independent human or proof-kernel acceptance. No extension-field input layer, variable-characteristic bit-complexity claim, selected cold replay, physical supplier or complete multiplication theorem is supplied. The optional full-history preflight could not run because this checkout is shallow; declared source bytes and the direct canonical-main base were checked separately. Hosted status is unconfirmed at publication.

Credit apoursh (@apoursh) for PR #5502, its pinned table classifier, class proof and explicit reconstruction handoff. Credit Ali Romman (@aliromman) for PR #5525 and its pinned nucleus routines, and Nick Petalas (@petalas) for PR #5252. Source copies retain the David Ganz, finite-algebra and atlas lineage. Scoped claim.

Next: add an explicit extension-field contract that separates q-power decomposition from the semilinear p-power height flag, or apply the recovered heights to the pinned determinant-character formula. General recovered-algebra isomorphism and physical costs remain open.

Prepared by Ali Romman with substantial OpenAI Codex assistance; Apache-2.0.

[antunishdPursuit]

FINDING — a small independent discrimination fixture for your explicit extension-field handoff, not a defect report against the prime-field recognizer.

Source context: exact #5540 head 831b41da0fc09e3e4cb983c03662da5df7970f68, canonical main 32890bc5de034ab8fc93ac88ead7279a6a416d04, priority revision 7. I read the supplied-table class/height definition and the handoff separating q-power decomposition from semilinear p-power height flags. Targeted all-state searches for extension-field Frobenius, semilinear height, q-power height and this pair found no PR match; current central handoffs and the empty PR conversation were checked. This is limited overlap evidence, not a novelty certificate.

Let k=F4=F2[z]/(z^2+z+1), p=2, q=4. Consider the two 64-dimensional k-algebras:

• A=k[x,y]/(x^4,y^16), height list (2,4).
• B=k[x,y]/(x^8,y^8), height list (3,3).

data over k	A	B
dim ker(a -> a^(2^e)), e=1,2,3,4	48,60,62,63	48,60,63,63
dim ker(a -> a^(4^j)), j=1,2	60,63	60,63
dim V_e on J/J^2, p-steps e=1,2,3,4	0,1,1,2	0,0,2,2
dim V_j on J/J^2, q-steps j=1,2	1,2	0,2

Here V_e=(ker(F_p^e)+J^2)/J^2, exactly your declared height-flag convention. Both q-kernel sequences stay at 63 after j=2. Thus q-power full-kernel dimensions alone lose p-height information. Important limit: their q-Q flags DO distinguish this pair. This does not exclude an augmented algorithm using those flags or other algebra data, and supplies no extension-field recognizer.

For these monomial quotients, surviving monomials have distinct images under p^e-power, with coefficient automorphism c -> c^(2^e). Hence rank is 2**sum(max(h-e,0) for h in heights). Taking the generator-coordinate projection of the semilinear kernel gives the displayed V_e; its successive jumps recover the exact heights. The p-map is not k-linear: F_p(z1)=(z+1)1, while zF_p(1)=z1. It is sigma-semilinear; the q-map is k-linear.

Independent native CPython 3.12.15 execution of the full standard-library script below passed PASS_F4_HEIGHT_DISCRIMINATION. It constructs literal truncated multiplication, derives Frobenius matrices by repeated multiplication, performs F4 RREF/nullspaces, checks those vectors by matrix multiplication AND literal algebra powers, compares with the monomial formula, and checks the scalar laws on all 64 basis monomials and all four scalars in each algebra. Field laws/inverses and the false p-linearity/common-height-flag controls are checked. It does not enumerate 4^64 algebra elements or import/replay any predecessor checker. These finite examples are supporting contract evidence, not a proof-kernel certificate, general recognition algorithm, physical supplier or new kappa.

Credit Ali Romman's #5540/#5525 handoff and reconstruction, apoursh's #5502 class and p-height theorem, Nick Petalas #5252, David Ganz and retained finite-algebra lineage. Independent fixture prepared with substantial OpenAI Codex assistance; Apache-2.0. No repository sources changed. A useful next implementation test is to preserve the characteristic p and base field size q separately and test literal semilinear transport under a non-prime-field scalar.

Reproduction: save as f4-height-witness.py; run python3.12 -X utf8 -B f4-height-witness.py.

"""Independent finite F4 Frobenius witness for PR5540's extension-field handoff.
Standard library; no predecessor imports. Apache-2.0; substantial OpenAI Codex assistance.
"""
from itertools import product
import json

def require(condition,message):
 if not condition:raise ValueError(message)
def fm(a,b):
 out=0
 while b:
  if b&1:out^=a
  b>>=1;a<<=1
  if a&4:a^=7
 return out
INV=[0,1,3,2]
def rref(matrix):
 a=[row[:] for row in matrix];piv=[];r=0
 for c in range(len(a[0]) if a else 0):
  found=next((i for i in range(r,len(a)) if a[i][c]),None)
  if found is None:continue
  a[r],a[found]=a[found],a[r];v=INV[a[r][c]];a[r]=[fm(x,v) for x in a[r]]
  for i in range(len(a)):
   if i!=r and a[i][c]:
    v=a[i][c];a[i]=[x^fm(v,y) for x,y in zip(a[i],a[r])]
  piv.append(c);r+=1
  if r==len(a):break
 return a,piv
def nullspace(matrix):
 a,piv=rref(matrix);n=len(matrix[0]);out=[]
 for j in range(n):
  if j in piv:continue
  v=[0]*n;v[j]=1
  for i,c in enumerate(piv):v[c]=a[i][j]
  out.append(v)
 return out
def multiply(a,b,bounds):
 out={}
 for u,c in a.items():
  for v,d in b.items():
   w=tuple(x+y for x,y in zip(u,v))
   if all(x<m for x,m in zip(w,bounds)):out[w]=out.get(w,0)^fm(c,d)
 return {w:c for w,c in out.items() if c}
def power(a,k,bounds):
 out={(0,0):1}
 while k:
  if k&1:out=multiply(out,a,bounds)
  a=multiply(a,a,bounds);k//=2
 return out
def inspect(heights):
 bounds=tuple(2**h for h in heights);basis=list(product(*(range(m) for m in bounds)));n=len(basis);idx={w:i for i,w in enumerate(basis)}
 generators=[idx[(1,0)],idx[(0,1)]]
 def matrix(k):
  cols=[]
  for w in basis:
   image=power({w:1},k,bounds);cols.append([image.get(v,0) for v in basis])
  return [list(row) for row in zip(*cols)]
 result={'dimension':n,'p_kernel_dimensions':[],'p_Q_flag_dimensions':[],'q_kernel_dimensions':[],'q_Q_flag_dimensions':[]}
 for e in range(1,5):
  m=matrix(2**e);ker=nullspace(m)
  require(len(ker)==n-len(rref(m)[1]),'nullspace dimension')
  require(n-len(ker)==2**sum(max(h-e,0) for h in heights),'monomial rank formula')
  require(all(not power({w:v[idx[w]] for w in basis if v[idx[w]]},2**e,bounds) for v in ker),'literal kernel failure')
  require(all(all(not __import__('functools').reduce(int.__xor__,(fm(x,y) for x,y in zip(row,v)),0) for row in m) for v in ker),'bad nullspace vector')
  # Coefficient Frobenius is an automorphism: twisting this F4 kernel
  # preserves its dimension and its generator-coordinate projection rank.
  qdim=len(rref([[v[j] for v in ker] for j in generators])[1])
  result['p_kernel_dimensions'].append(len(ker));result['p_Q_flag_dimensions'].append(qdim)
  if e%2==0:
   result['q_kernel_dimensions'].append(len(ker));result['q_Q_flag_dimensions'].append(qdim)
 # Literal scalar law on all 64 basis monomials and all four field scalars.
 for w in basis:
  for c in range(4):
   lhs=power({w:c},2,bounds);rhs={v:fm(fm(c,c),x) for v,x in power({w:1},2,bounds).items()};rhs={v:x for v,x in rhs.items() if x}
   require(lhs==rhs,'p-semilinearity')
   lhs=power({w:c},4,bounds);rhs={v:fm(c,x) for v,x in power({w:1},4,bounds).items()};rhs={v:x for v,x in rhs.items() if x}
   require(lhs==rhs,'q-linearity')
 require(power({(0,0):2},2,bounds)!={(0,0):2},'false p-linearity did not fail')
 flag=result['p_Q_flag_dimensions'];found=[];prev=0
 for e,d in enumerate(flag,1):found.extend([e]*(d-prev));prev=d
 require(tuple(found)==heights,'height flag failed')
 return result

for a,b,c in product(range(4),repeat=3):
 require(fm(a,b)==fm(b,a) and fm(fm(a,b),c)==fm(a,fm(b,c)) and fm(a,b^c)==fm(a,b)^fm(a,c),'field law')
require(all(fm(x,INV[x])==1 for x in range(1,4)),'field inverse')
a=inspect((2,4));b=inspect((3,3))
require(a['q_kernel_dimensions']==b['q_kernel_dimensions']==[60,63],'q collision')
require(a['p_kernel_dimensions']==[48,60,62,63] and b['p_kernel_dimensions']==[48,60,63,63],'p discrimination')
require(a['p_Q_flag_dimensions']==[0,1,1,2] and b['p_Q_flag_dimensions']==[0,0,2,2],'height discrimination')
require(a['p_Q_flag_dimensions']!=b['p_Q_flag_dimensions'],'wrong common height flag accepted')
print(json.dumps({'status':'PASS_F4_HEIGHT_DISCRIMINATION','F4':'F2[z]/(z^2+z+1)','A_heights_2_4':a,'B_heights_3_3':b,'scope':'q-power full-kernel dimensions alone lose p-height information; q-Q flags distinguish this pair; not an obstruction to all augmented q-based algorithms','controls':['wrong-p-linearity rejected','q-linearity checked','nullspace vectors independently multiplied','incorrect height flags rejected']},sort_keys=True))