"""Exact homogeneous factor and first-partner tests for the Freudenthal seed.

The eight-dimensional grading is reconstructed from the cyclic quadrics.
Each tested homogeneous space is spanned by all coordinate monomials of
its degree and weight, so a negative span test is a nonmembership proof.
Requires SymPy; every calculation is over Q.
"""
from pathlib import Path
import json
from fractions import Fraction
import sympy as sp
from sympy.polys.fields import field
from check_freudenthal_quadrics import VARIABLES, INDEX, rows

HERE=Path(__file__).resolve().parent
NAMES=[f'a{i}' for i in range(18)]+list('hbcdefg')+['r','q','u']
F,*xx=field(' '.join(NAMES),sp.QQ)
z=dict(zip(NAMES,xx));a=[z[f'a{i}'] for i in range(18)]
h,b,c,d,e,f,g,r,q,u=(z[v] for v in list('hbcdefg')+['r','q','u'])
coords={v:F.from_expr(sp.sympify(value,locals={name:sp.Symbol(name) for name in NAMES})) for v,value in json.loads((HERE/'freudenthal_source_coordinates.json').read_text()).items()}
rels=[]
for row in rows():
 mons=list(row)
 for mon in mons[1:]:
  rr=[0]*56
  for i in mon:rr[i]+=1
  for i in mons[0]:rr[i]-=1
  rels.append(rr)
ns=sp.Matrix(rels).nullspace()
assert len(ns)==8
weights={v:tuple(bas[INDEX[v]] for bas in ns) for v in VARIABLES}
assert len(set(weights.values()))==56
add=lambda *ww:tuple(map(sum,zip(*ww)))
sub=lambda v,w:tuple(x-y for x,y in zip(v,w))
zero=(sp.Integer(0),)*8
linear={'h':'x1','b':'x11','c':'x9','d':'y10','e':'x6','f':'x14','g':'x4'}
sw={key:weights[val] for key,val in linear.items()}
sw['r']=add(weights['x17'],weights['y10'])
sw['q']=add(weights['x6'],weights['y13'])
sw['u']=add(weights['x14'],weights['x4'],weights['y7'])
assert sw['r']==add(weights['a17'],weights['x9'])
assert sw['q']==add(weights['a6'],weights['x14'])
assert sw['u']==add(weights['a14'],weights['x4'],weights['x6'])==add(weights['a3'],weights['x14'],weights['x9'])==add(weights['a4'],weights['x14'],weights['y10'])
assert len(set(sw.values()))==10

def space(degree,weight):
 if degree==0:return [('1',F.one)] if weight==zero else []
 if degree==1:return [(v,coords[v]) for v in VARIABLES if weights[v]==weight]
 if degree==2:return [(v+'*'+w,coords[v]*coords[w]) for i,v in enumerate(VARIABLES) for w in VARIABLES[i:] if add(weights[v],weights[w])==weight]
 raise ValueError('Unimplemented degree')

def vector(f):
 assert len(f.denom)==1
 den,co=next(iter(f.denom.items()))
 return {tuple(x-y for x,y in zip(mon,den)):Fraction(str(c))/Fraction(str(co)) for mon,c in f.numer.items()}

def contains(f,basis):
 echelon={}
 def reduce(row):
  while row:
   p=min(row)
   if p not in echelon:return row
   c=row[p]
   for v,a in echelon[p].items():
    row[v]=row.get(v,Fraction(0))-c*a
    if not row[v]:del row[v]
  return row
 for _,g in basis:
  row=reduce(vector(g))
  if row:
   pivot=min(row);c=row[pivot];echelon[pivot]={v:a/c for v,a in row.items()}
 return not reduce(vector(f))

# All coordinate units of the initial Laurent ring with polynomial frozens.
units=[]
for v,value in coords.items():
 if len(value.numer)!=1:continue
 mon=next(iter(value.numer))
 if all(mon[i]==0 for i in range(18)):units.append(v)
assert set(units)==set(linear.values())
tests=[]
for name,degree in [('r',2),('q',2),('u',3)]:
 for denominator in linear:
  wt=sub(sw[name],sw[denominator]);basis=space(degree-1,wt)
  assert not contains(z[name]/z[denominator],basis),(name,denominator)
  tests.append({'function':name+'/'+denominator,'degree':degree-1,'spanning_products':[v for v,_ in basis],'member':False})
print('PASS: 21 homogeneous factor tests for r, q, u.',flush=True)
v=coords
partners={
 'h':v['x2']*q-a[7]*(a[2]*v['x14']+a[1]*v['y13'])-(a[1]*a[6]+a[2]*v['x6'])*v['x12'],
 'b':v['x12'], 'c':v['x4']*v['x8']-a[3]*a[9],
 'd':v['x17'],'e':v['y13'],
 'f':v['x4']*v['y7']-a[4]*v['y10']-a[3]*v['x9'],
 'g':v['x14']*v['y7']-a[14]*v['x6'],
 'r':v['x14']*(v['y2']*v['y7']-v['x3']*v['y10']-v['x1']*v['x8']+a[3]*v['x11'])-v['x6']*(a[13]*v['x1']+a[14]*v['y2']),
 'q':v['x11']*v['y0']-a[11]*v['x1'],
 'u':v['x9']*(v['x1']*v['y16']-a[2]*v['x14']-a[1]*v['y13'])-a[9]*v['x1']*v['x17']
}
input_weights=[weights[name] for name in NAMES[:18]]+[sw[name] for name in NAMES[18:]]
input_degrees=[1]*25+[2,2,3]
for name,partner in partners.items():
 target=partner/z[name];vv=vector(target)
 mon=next(iter(vv))
 wt=tuple(sum(mon[j]*input_weights[j][i] for j in range(28)) for i in range(8))
 deg=sum(mon[j]*input_degrees[j] for j in range(28))
 assert all(tuple(sum(m[j]*input_weights[j][i] for j in range(28)) for i in range(8))==wt for m in vv)
 basis=space(deg,wt)
 assert not contains(target,basis),name
 tests.append({'function':name+"'/"+name,'degree':deg,'spanning_products':[v for v,_ in basis],'member':False})
print('PASS: ten homogeneous first-partner nondivisibility tests.',flush=True)
report={'status':'PASS','grading_rank':8,'distinct_degree_one_weights':56,'prime_factor_tests':21,'first_partner_tests':10,'largest_spanning_set':max(len(t['spanning_products']) for t in tests),'tests':tests,
 'scope':'Homogeneous nonmembership tests, together with the written factoriality and connected-torus arguments. Not ordinary-LPA generation.'}
(HERE/'freudenthal_primes_report.json').write_text(json.dumps(report,indent=2)+'\n')
print(json.dumps({k:v for k,v in report.items() if k!='tests'},indent=2))