#!/usr/bin/env python3
"""Prescribed finite audits for original-box affine slices; no source census."""
from concurrent.futures import ProcessPoolExecutor, as_completed
from datetime import datetime, timezone
from fractions import Fraction as Q
from hashlib import sha256
from itertools import product, combinations
from math import gcd, factorial, prod
from pathlib import Path
import json, signal, time

ROOT=Path(__file__).resolve().parents[1]
INPUT=ROOT/'papers/primitive_additive_rigidity_20261118/supplement/inputs/dense_orbit_rigidity_audit_20261025.json'
OUT=ROOT/'results/affine_slice_defect_audit_20261118'

def rref(rows,n):
 a=[[Q(x) for x in row] for row in rows]; piv=[];k=0
 for j in range(n):
  i=next((i for i in range(k,len(a)) if a[i][j]),None)
  if i is None:continue
  a[k],a[i]=a[i],a[k];d=a[k][j];a[k]=[x/d for x in a[k]]
  for i in range(len(a)):
   if i!=k and a[i][j]:
    c=a[i][j];a[i]=[x-c*y for x,y in zip(a[i],a[k])]
  piv.append(j);k+=1
  if k==len(a):break
 return a,piv

def rank(rows,n):return len(rref(rows,n)[1])
def nullspace(rows,n):
 a,piv=rref(rows,n);out=[]
 for j in range(n):
  if j in piv:continue
  v=[Q(0)]*n;v[j]=1
  for i,k in enumerate(piv):v[k]=-a[i][j]
  den=1
  for x in v:den=den*x.denominator//gcd(den,x.denominator)
  v=[int(x*den) for x in v];d=gcd(*v);out.append([x//d for x in v])
 return out

def dot(a,b):return sum(x*y for x,y in zip(a,b))
def det(a):
 n=len(a)
 if not n:return Q(1)
 if n==1:return Q(a[0][0])
 return sum((-1)**j*Q(a[0][j])*det([row[:j]+row[j+1:] for row in a[1:]]) for j in range(n))
def primitive(coeff,c):
 den=1
 for a in coeff:den=den*a.denominator//gcd(den,a.denominator)
 row=[int(a*den) for a in coeff];d=gcd(*row)
 if not d:return None
 return [a//d for a in row],Q(c)*den/d

def word(states,i,j):
 b=o=0
 for k,x in enumerate(states[i:j]):
  if x%2:b=3*b+2**k;o+=1
 d,a=2**(j-i),3**o
 assert d*states[j]-a*states[i]==b
 return d,a,b,d-a

def lattice_worker(k):
 signal.alarm(60);vectors=cases=0;oblique=0;maxrank=0
 patterns={1:[(1,),(-1,),(3,)],2:[(1,1),(1,-1),(1,3),(2,1),(1,17)],3:[(1,1,1),(1,-1,2),(2,4,1),(1,17,33),(3,5,7)]}[k]
 for radius in (1,2,3):
  S=2*radius+2;bound=factorial(k)*S**k;J=bound.bit_length();mod=2**J
  assert mod>bound
  pts=list(product(range(-radius,radius+1),repeat=k))
  for coeff in patterns:
   assert any(a % 2 for a in coeff)  # odd coefficient suffices after clearing an odd denominator
   for c in (-3,0,2):
    selected=[z for z in pts if (dot(coeff,z)-c)%mod==0];vectors+=len(pts);cases+=1
    if selected:
     rho=rank([[a-b for a,b in zip(z,selected[0])] for z in selected[1:]],k)
     assert rho<k
     maxrank=max(maxrank,rho)
     if len(selected)>1 and all(len({z[i] for z in selected})>1 for i in range(k)):oblique+=1
    # Deliberately too-small binary modulus; all diagonal/even grids can have full rank.
 counter=[z for z in product(range(-2,3),repeat=k) if sum(z)%2==0]
 assert rank([[a-b for a,b in zip(z,counter[0])] for z in counter[1:]],k)==k
 return dict(kind='short_lattice',dimension=k,cases=cases,vectors=vectors,oblique_no_coordinate_fixed=oblique,max_affine_rank=maxrank,undersized_modulus_full_rank_control=True)

def actual_case(states,coords,steps,b,g,name):
 n=len(states);r=len(steps)
 assert len(set(states))==n
 assert all(((3*x+1)//2 if x%2 else x//2)==y for x,y in zip(states,states[1:]))
 assert all(b+dot(steps,z)==x for x,z in zip(states,coords))
 radii=[max(abs(z[i]) for z in coords) for i in range(r)];lengths=[2*a+1 for a in radii]
 times=list(range(n));edges=[]
 # Include prescribed consecutive selected visits, plus a sparse selection for g>1.
 if g>1:times=list(range(0,n,g))
 for i,j in zip(times,times[1:]):
  if j-i<=g:
   d,a,B,D=word(states,i,j);e=[d*y-a*x for x,y in zip(coords[i],coords[j])]
   assert dot(steps,e)==B-D*b
   edges.append(dict(i=i,j=j,d=d,a=a,B=B,D=D,e=e))
 if not edges:return None
 u=edges[0];v=next((w for w in edges if u['D']*w['B']-w['D']*u['B']),None)
 delta=None
 if v:
  delta=u['D']*v['B']-v['D']*u['B']
  alpha=[v['B']*x-u['B']*y for x,y in zip(u['e'],v['e'])]
  beta=[u['D']*y-v['D']*x for x,y in zip(u['e'],v['e'])]
  assert dot(steps,beta)==delta and dot(steps,alpha)==-b*delta
  assert all(abs(beta[i])<=4*3**(2*g)*radii[i] for i in range(r))
  defects=[[delta*x-w['D']*a-w['B']*be for x,a,be in zip(w['e'],alpha,beta)] for w in edges]
 else:
  defects=[[u['D']*x-w['D']*y for x,y in zip(w['e'],u['e'])] for w in edges]
 q=12*3**(3*g)
 assert all(dot(steps,d)==0 and all(abs(x)<=q*L for x,L in zip(d,lengths)) for d in defects)
 basis=[]
 for d in defects:
  if rank(basis+[d],r)>len(basis):basis.append(d)
 assert len(basis)<=r-1
 omegas=nullspace(basis+([beta] if v else []),r)
 forms=[]
 for om in omegas:
  if v:coeff,c=om,Q(dot(om,alpha),delta)
  else:coeff,c=[u['D']*x for x in om],Q(dot(om,u['e']))
  pp=primitive(list(map(Q,coeff)),c);assert pp
  coeff,c=pp;assert c.denominator%2
  vals=[dot(coeff,z)-c for z in coords]
  assert all(w['d']*vals[w['j']]==w['a']*vals[w['i']] for w in edges)
  for ell in (1,2,3,4):
   for t in times[:-ell]:
    val=vals[t]*c.denominator;assert val.denominator==1 and val.numerator%2**ell==0
  forms.append(dict(coeff=coeff,constant=str(c),zero_values=sum(x==0 for x in vals)))
 # Check the exact terminal bound whenever two selected points are in the common zero fibre.
 zero=[i for i in times if all(dot(f['coeff'],coords[i])==Q(f['constant']) for f in forms)]
 terminal_pairs=0
 if v and len(zero)>1:
  columns=basis+[beta];m=len(columns)
  choice=next(I for I in combinations(range(r),m) if det([[col[i] for col in columns] for i in I]))
  mat=[[col[i] for col in columns] for i in choice];den=det(mat)
  for i,j in combinations(zero,2):
   diff=[a-bb for a,bb in zip(coords[i],coords[j])]
   repl=[row[:-1]+[diff[k]] for row,k in zip(mat,choice)]
   t=det(repl)/den
   assert dot(steps,diff)==t*delta
   assert abs(t)<=factorial(m)*q**(m-1)*prod(lengths[k] for k in choice)
   terminal_pairs+=1
 return dict(name=name,g=g,states=n,selected=len(times),return_span=2 if v else 1,defect_rank=len(basis),forms=forms,delta=delta,terminal_pairs=terminal_pairs)

def actual_worker():
 signal.alarm(60);rows=json.loads(INPUT.read_text())['rows'];results=[]
 for k,row in enumerate(rows[:4]):
  for mode in ('actual','base'):
   states=row['actual_states'] if mode=='actual' else row.get('base_states',row['actual_states'])
   for chart in ('split','small_digits','redundant'):
    if chart=='split':
     coords=[[x//9,(x%9)//3,x%3] for x in states];steps=[9,3,1]
    elif chart=='small_digits':
     coords=[[x//4,x%4,0] for x in states];steps=[4,1,13]
    else:
     coords=[[x,(-1)**i*(i%3),-(-1)**i*(i%3)] for i,x in enumerate(states)];steps=[1,17,17]
    for g in (1,2,4):
     res=actual_case(states,coords,steps,0,g,f'{k}:{mode}:{chart}')
     if res:results.append(res)
 return dict(kind='actual_defects',cases=len(results),rows=results)

def restriction_worker():
 signal.alarm(60);rows=[]
 for u in (1,3,5,7):
  states=[4*u-1,6*u-1,9*u-1];coords=[[4,0],[6,0],[9,0]]
  for M in (2,4,16,256):
   # Physical x=u*z1-1, homogeneous F=M*z1-z2 on the fixed z2=0 slice.
   vals=[M*z[0]-z[1] for z in coords]
   assert all(2*y==3*x for x,y in zip(vals,vals[1:]))
   assert all(((3*x+1)//2 if x%2 else x//2)==y for x,y in zip(states,states[1:]))
   normalized=[Q(v,M) for v in vals];assert normalized==list(map(Q,[4,6,9]))
   assert normalized[0].numerator%4==0
   rows.append(dict(u=u,M=M,states=states,primitive_values=list(map(str,normalized))))
 return dict(kind='slice_restriction',cases=len(rows),rows=rows,scope='four declared actual controls; no source census')

def job(i):
 if i<3:return lattice_worker(i+1)
 if i==3:return actual_worker()
 return restriction_worker()

def main():
 OUT.mkdir(parents=True,exist_ok=True)
 start=datetime.now(timezone.utc);clock=time.monotonic();rows=[]
 print(json.dumps({'event':'start','at':start.isoformat(),'workers':5}),flush=True)
 with ProcessPoolExecutor(max_workers=5) as pool:
  futures={pool.submit(job,i):i for i in range(5)}
  for f in as_completed(futures):
   r=f.result();rows.append(r)
   print(json.dumps({'event':'worker_complete','worker':futures[f],'kind':r['kind'],'cases':r.get('cases')}),flush=True)
 result=dict(started_at=start.isoformat(),ended_at=datetime.now(timezone.utc).isoformat(),elapsed_seconds=time.monotonic()-clock,workers=5,failures=0,input_sha256=sha256(INPUT.read_bytes()).hexdigest(),source_sha256=sha256(Path(__file__).read_bytes()).hexdigest(),rows=sorted(rows,key=lambda x:(x['kind'],x.get('dimension',0))),scope='prescribed finite lattice and frozen actual-trajectory interface checks; not an asymptotic proof')
 (OUT/'result.json').write_text(json.dumps(result,indent=2)+'\n')
 print(json.dumps({'event':'complete','elapsed_seconds':result['elapsed_seconds'],'failures':0}),flush=True)
if __name__=='__main__':main()
