"""Independent Cayley-Dickson recursion and finite-field action-algebra closure.
Does not import method A or read its multiplication table/certificate."""
from pathlib import Path
import json
R=Path(__file__).resolve().parent

def add(x,y): return tuple(a+b for a,b in zip(x,y))
def neg(x): return tuple(-a for a in x)
def conj(x): return (x[0],)+tuple(-a for a in x[1:])
def mul(x,y):
    if len(x)==1: return (x[0]*y[0],)
    h=len(x)//2; a,b=x[:h],x[h:]; c,d=y[:h],y[h:]
    return add(mul(a,c),neg(mul(conj(d),b)))+add(mul(d,a),mul(b,conj(c)))
E=[tuple(int(i==j) for i in range(8)) for j in range(8)]
M=[]
for y in E:
    columns=[mul(x,y) for x in E]
    M.append([[columns[j][i] for j in range(8)] for i in range(8)])
for m in M[1:]:
    assert all(sum(m[i][k]*m[k][j] for k in range(8))==-int(i==j) for i in range(8) for j in range(8))

def matmul(a,b,p):
    return [[sum(a[i][k]*b[k][j] for k in range(8))%p for j in range(8)] for i in range(8)]
def closure(p):
    echelon={}; matrices=[]; dimensions=[]
    def insert(m):
        v=[z%p for row in m for z in row]
        for i in sorted(echelon):
            if v[i]:
                t=v[i]; row=echelon[i]
                v=[(a-t*b)%p for a,b in zip(v,row)]
        if not any(v): return False
        i=next(i for i,x in enumerate(v) if x)
        inv=pow(v[i],-1,p); v=[x*inv%p for x in v]
        echelon[i]=v; matrices.append(m)
        return True
    insert(M[0]); start=0
    while start<len(matrices):
        end=len(matrices)
        for a in matrices[start:end]:
            for g in M[1:]: insert(matmul(a,g,p))
        start=end; dimensions.append(len(matrices))
    return len(matrices),dimensions
out={'method':'B: independent recursive Cayley-Dickson right actions, modular algebra closure',
     'coefficient_status':'full residual action + primitive-lattice/Nakayama classification; not brute-force HNF',
     'primes':{}}
for p in (3,5,7):
    rank,dims=closure(p); assert rank==64
    # At level p^m, full action forces the chain O,pO,...,p^mO.
    chain=[]
    for a in range(5):
        diag=[p**a]*8
        index=1
        for d in diag: index*=d
        assert index==p**(8*a)
        chain.append(8*a)
    counts=[sum(k==j for j in chain) for k in range(33)]
    out['primes'][str(p)]={'multiplication_algebra_rank':rank,'dimensions_by_round':dims,
        'counts_k_0_to_32':counts,'local_zero_count':0,
        'local_factor':'1/(1-p^(-8s))','scalar_chain_index_exponents':chain}
(R/'results-B.json').write_text(json.dumps(out,indent=2)+'\n')
print(json.dumps(out,indent=2))
