verify-cyclic-polarization.py

#!/usr/bin/env python3
"""Exact cyclic transport, symbolic degrees, and two decisive controls.

No slope or triangulation census. Gaussian integer coefficients and Fraction
exponents are exact; every series cutoff has a quadratic tail bound.
"""
from fractions import Fraction as F
from functools import lru_cache
from math import isqrt
from pathlib import Path
import json

ROOT=Path(__file__).resolve().parent
checks,tails=[],[]
def check(name,value):
    assert value,name
    checks.append(name)
def dot(x,y):return sum(a*b for a,b in zip(x,y))
def addv(x,y):return tuple(a+b for a,b in zip(x,y))
def sv(c,x):return tuple(c*a for a in x)
def omega(x,y):
    n=len(x)//2
    return dot(x[n:],y[:n])-dot(x[:n],y[n:])
def C(x):
    n=len(x)//2
    return tuple(-a for a in x[n:])+tuple(a-b for a,b in zip(x[:n],x[n:]))
def gw(x):return sum(x[len(x)//2:])
def ga(a,b):return (a[0]+b[0],a[1]+b[1])
def gm(a,b):return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0])
def ipow(k):return ((1,0),(0,1),(-1,0),(0,-1))[k%4]

# Quantum Laurent polynomial coefficients are indexed by (root vector,A degree).
def qa(*ps):
    out={}
    for p in ps:
        for k,c in p.items():out[k]=ga(out.get(k,(0,0)),c)
    return {k:c for k,c in out.items() if c!=(0,0)}
def qm(p,q):
    out={}
    for (u,a),c in p.items():
        for (v,b),d in q.items():
            k=(addv(u,v),a+b+F(omega(u,v),2))
            out[k]=ga(out.get(k,(0,0)),gm(c,d))
    return {k:c for k,c in out.items() if c!=(0,0)}
def mon(u,a=0,c=(1,0)):return {(u,F(a)):c}
def psi(p):
    out={}
    for (u,a),c in p.items():
        k=(C(u),a+gw(u))
        out[k]=ga(out.get(k,(0,0)),gm(ipow(gw(u)),c))
    return {k:c for k,c in out.items() if c!=(0,0)}
f=qa(mon((-2,0)),mon((0,2)),mon((0,0),c=(-1,0)))
check('exact correct-sided tetrahedron transport',psi(f)==qm(mon((0,-2),c=(-1,0)),f))
for u in [(1,0),(0,1),(1,2)]:
    check(f'cyclic order three on root {u}',psi(psi(psi(mon(u))))==mon(u))
check('symplectic root map',omega(C((1,0)),C((0,1)))==omega((1,0),(0,1)))
check('multiplicative Weyl factors',psi(qm(mon((1,0)),mon((0,1))))==qm(psi(mon((1,0))),psi(mon((0,1)))))

# Laurent polynomial identities in d,q,c,a1,a2; p=2q-d,
# t=(1+q*c)/d, r=2t-c, so qr-pt=1 and alpha=(c,0).
NV=5
def pc(c):return {(0,)*NV:F(c)} if c else {}
def var(i,power=1):
    v=[0]*NV;v[i]=power
    return {tuple(v):F(1)}
def pa(*ps):
    out={}
    for p in ps:
        for m,c in p.items():out[m]=out.get(m,0)+c
    return {m:c for m,c in out.items() if c}
def pm(p,q):
    out={}
    for m,c in p.items():
        for n,d in q.items():
            k=tuple(a+b for a,b in zip(m,n))
            out[k]=out.get(k,0)+c*d
    return {m:c for m,c in out.items() if c}
def ps(c,p):return pm(pc(c),p)
def pdot(x,y):return pa(*(pm(a,b) for a,b in zip(x,y)))
d,q,c,a1,a2=[var(j) for j in range(NV)]
id_=var(0,-1)
p=pa(ps(2,q),ps(-1,d))
t=pm(pa(pc(1),pm(q,c)),id_)
r=pa(ps(2,t),ps(-1,c))
check('generic native Bezout relation',pa(pm(q,r),ps(-1,pm(p,t)),pc(-1))=={})
diag=ps(-2,pm(q,id_));off=pm(p,id_)
def T(x):return (pa(pm(diag,x[0]),pm(off,x[1])),pa(pm(off,x[0]),pm(diag,x[1])))
def Q(x):return pa(pdot(x,x),ps(-1,pdot(x,T(x))))
alpha=(c,pc(0));beta=(ps(-2,t),r)
delta=tuple(pa(b,ps(-1,u)) for b,u in zip(beta,T(alpha)))
check('generic transported fractional defect',delta==(ps(-2,id_),ps(2,id_)))
v=(ps(4,id_),ps(-4,id_))
check('native insertion scalar makes complete-square constant zero',pa(ps(2,pdot(alpha,delta)),pdot(v,alpha))=={})
x=tuple(pa(a,ps(-1,b)) for a,b in zip((a1,a2),alpha))
raw=pa(ps(2,Q(x)),ps(2,pa(*x)),ps(-1,pdot(v,x)),
       ps(4,pdot(tuple(pa(a,ps(-1,b)) for a,b in zip(alpha,beta)),x)),
       ps(2,pa(pdot(alpha,alpha),pa(*alpha),ps(-1,pdot(alpha,beta)))))
expected=pa(ps(2,Q((a1,a2))),pm(pa(pc(2),ps(4,id_)),a1),pm(pa(pc(2),ps(-4,id_)),a2))
check('symbolic transported longitude-square degree',raw==expected)
check('symbolic transported unit degree',pa(ps(2,Q((a1,a2))),ps(2,pa(a1,a2)),ps(-1,pdot(v,(a1,a2))))==
      pa(ps(2,Q((a1,a2))),pm(pa(pc(2),ps(-4,id_)),a1),pm(pa(pc(2),ps(4,id_)),a2)))
check('exact cone form',Q((a1,a2))==pa(pm(pa(a1,a2),pa(a1,a2)),ps(2,pm(pm(q,id_),pm(pa(a1,ps(-1,a2)),pa(a1,ps(-1,a2)))))))

h=(2,2,1,1);mu=(1,1,1,0);longitude=(-4,0,-2,0)
hp=C(h)
check('actual cyclic edge row and scalar',hp==(-1,-1,1,1) and gw(h)==2 and 4+gw(sv(-1,h))==2)
check('actual cyclic peripheral rows',C(mu)==(-1,0,0,1) and C(longitude)==(2,0,-2,0))
check('peripheral cyclic scalar cancels exactly',-1+gw(mu)==0 and 2+gw(longitude)==0)

def sa(*ss):
    out={}
    for s in ss:
        for e,c in s.items():out[e]=ga(out.get(e,(0,0)),c)
    return {e:c for e,c in out.items() if c!=(0,0)}
def shift(s,p,phase=(1,0),cap=None):
    return {e+p:gm(phase,c) for e,c in s.items() if cap is None or e+p<=cap}
@lru_cache(None)
def invpoch(indices,cap):
    if cap<0:return {}
    v=[0]*(cap+1);v[0]=1
    for n in indices:
        for j in range(1,n+1):
            for e in range(4*j,cap+1):v[e]+=v[e-4*j]
    return {e:(c,0) for e,c in enumerate(v) if c}

def Hprime(p,q,u,cap):
    d=2*q-p
    assert d and F(q,d)>=0  # both fixed controls lie in this sufficient cone
    hs=(d,0,-2*q,p)
    def T(x):return (F(-2*q,d)*x[0]+F(p,d)*x[1],F(p,d)*x[0]+F(-2*q,d)*x[1])
    def Q(x):return dot(x,x)-dot(x,T(x))
    alpha=tuple(F(i,2) for i in u[:2]);beta=tuple(F(i,2) for i in u[2:])
    delta=tuple(a-b for a,b in zip(beta,T(alpha)))
    v=(F(4,d),F(-4,d))
    L=tuple(2-vi-4*di for vi,di in zip(v,delta))
    const=2*dot(alpha,delta)+dot(v,alpha)
    # Q(a)=(a1+a2)^2+(2q/d)(a1-a2)^2 >= ||a||^2 on a>=0.
    # Therefore D=2Q+L.a+c >= ||a||^2-||L||^2/4+c.
    bound=max(F(0),cap-const+dot(L,L)/4)
    R=isqrt(bound.numerator//bound.denominator)+1
    tails.append({'p':p,'q':q,'input':u,'cap_A':cap,'radius_squared_bound':str(bound),'square_cutoff':R})
    out={}
    for a1 in range(R+1):
        for a2 in range(R+1):
            a=(a1,a2);x=tuple(a-b for a,b in zip(a,alpha))
            e=-2*x[1];n=2*(x[0]-x[1])/d
            if e.denominator!=1 or n.denominator!=1:continue
            e,n=int(e),int(n)
            lam=addv(sv(e,hp),sv(n,hs))
            assert tuple(F(i,2) for i in lam[:2])==x
            assert tuple(F(i,2) for i in lam[2:])==T(x)
            ds=tuple(a+b for a,b in zip(T(x),beta))
            if any(a.denominator!=1 for a in ds):continue
            degree=2*(dot(a,a)+sum(a)-dot(a,ds))+F(omega(lam,u),2)-2*n
            assert degree==2*Q(a)+dot(L,a)+const and degree.denominator==1
            degree=int(degree)
            if degree<=cap:
                out=sa(out,shift(invpoch(a,cap-degree),degree,ipow(2*(sum(a)-n)),cap))
    return out
def Hnative(p,q,u,cap):
    return shift(Hprime(p,q,C(u),cap-gw(u)),gw(u),ipow(gw(u)),cap)

# Fixed nonmeridional control outside the preceding cone: (-5,1).
P,Q_=-5,1
CAP=48
hs=addv(sv(P,mu),sv(Q_,longitude));b=mu
unit=Hnative(P,Q_,(0,0,0,0),CAP)
longsq=shift(Hnative(P,Q_,sv(2,b),CAP+2),-2,(-1,0),CAP)
vac=sa(unit,shift(longsq,0,(-1,0)))
check('outside old cone, original unit degree zero is unique',unit.get(0)==(1,0) and min(unit)==0)
check('outside old cone, longitude has positive order',longsq and min(longsq)>0)
check('outside old cone, original filled vacuum is detected',vac.get(0)==(1,0) and min(vac)==0)
check('old seed has a negative quadratic ray here',F(1,2)+F(P,8*Q_)<0)
for u in [(0,0,0,0),hs,(0,0,1,1)]:
    for j in range(2):
        uz=list(u);uz[j]-=2
        uw=list(u);uw[j+2]+=2
        check(f'original tetrahedron side, j={j}, input={u}',
          sa(shift(Hnative(P,Q_,tuple(uz),CAP+u[j+2]),-u[j+2],cap=CAP),
             shift(Hnative(P,Q_,tuple(uw),CAP+u[j]),-u[j],cap=CAP),
             shift(Hnative(P,Q_,u,CAP),0,(-1,0)))=={})
    for row,scalar_power,name in [(h,0,'edge1'),(sv(-1,h),4,'edge2'),(hs,-P+2*Q_,'filling')]:
        degree=scalar_power+F(omega(row,u),2)
        assert degree.denominator==1
        degree=int(degree)
        check(f'original native right-multiplied {name}, input={u}',
          sa(shift(Hnative(P,Q_,addv(row,u),CAP-degree),degree,ipow(scalar_power),CAP),
             shift(Hnative(P,Q_,u,CAP-2),2,cap=CAP))=={})
check('native odd-root phase is retained',Hnative(P,Q_,hs,CAP)==
      shift(Hnative(P,Q_,(0,0,0,0),CAP+5),-5,(0,-1),CAP))

# Meridian control. Exact swap proof is in the note; coefficients are a control.
meridian_unit=Hprime(1,0,(0,0,0,0),CAP)
meridian_long=Hprime(1,0,(-4,0,4,0),CAP)
check('meridian transformed average kills the specified vacuum',meridian_unit==meridian_long)
check('meridian detector is not the zero functional',min(meridian_unit)==8 and meridian_unit[8]==(-1,0))
check('meridian graph and full integral even support',C(mu)==(-1,0,0,1) and omega(hp,C(mu))==0)

# Exact normalization in the meridian left-moment quotient, with basis [w1^a w2^b].
def meridian_normal(u):
    z1,z2,w1,w2=u
    k=(w1+z2,w2+z1)
    n=-z1+z2
    degree=F(z1*k[0]+z2*k[1],2)+2*n
    return k,degree,ipow(2*n)
check('meridian vacuum normal form',meridian_normal((-4,0,4,0))==((4,-4),0,(1,0)))
for a,b in [(0,0),(2,-4),(-2,2)]:
    k1,power1,phase1=meridian_normal((-2,0,a,b))
    k2,power2,phase2=meridian_normal((0,-2,a,b))
    check(f'meridian first recurrence normalization at {(a,b)}',k1==(a,b-2) and power1-a==4-2*a and phase1==(1,0))
    check(f'meridian second recurrence normalization at {(a,b)}',k2==(a-2,b) and power2-b==-4-2*b and phase2==(1,0))

# A finite certificate in the actual full-root quantum algebra, not only
# a vanishing numerical pairing. It kills the meridian vacuum in this sector.
zero=(0,0,0,0)
f1=qa(mon((-2,0,0,0)),mon((0,0,2,0)),mon(zero,c=(-1,0)))
f2=qa(mon((0,-2,0,0)),mon((0,0,0,2)),mon(zero,c=(-1,0)))
sp=C(mu)
edge=qa(mon(hp),mon(zero,c=(-1,0)))
moment=qa(mon(sp),mon(zero,2))
vacraw=qa(mon(zero),mon((-4,0,4,0),c=(-1,0)))
# (tetrahedron,centered j,k,A degree,integer coefficient)
terms=[(1,1,1,4,1),(2,2,0,4,-1),(1,1,0,4,-1),
       (1,0,2,4,1),(2,1,1,4,-1),(2,0,1,4,1),
       (1,0,1,0,-1),(2,1,0,0,1)]
G={}
for j,r,s,degree,coefficient in terms:
    left=mon((0,0,2*r+2,2*s-2),degree,(coefficient,0))
    G=qa(G,qm(left,f1 if j==1 else f2))

def normalized(poly):
    out={}
    for (u,degree),coefficient in poly.items():
        k,power,phase=meridian_normal(u)
        out=qa(out,mon((0,0,*k),degree+power,gm(coefficient,phase)))
    return out
check('eight tetrahedron relations give the exact normalized meridian vacuum',normalized(G)==normalized(vacraw))
residual=qa(vacraw,{k:gm((-1,0),v) for k,v in G.items()})

def power_difference_quotient(row,n,chi_power,chi_phase):
    # (W(row)^n-chi^n)/(W(row)-chi), including negative n.
    out={}
    js=range(n) if n>=0 else range(n,0)
    sign=(1,0) if n>=0 else (-1,0)
    for j in js:
        k=n-1-j
        phase=gm(sign,ipow(chi_phase*k))
        out=qa(out,mon(sv(j,row),chi_power*k,phase))
    return out
edge_right,moment_right={},{}
for (u,degree),coefficient in residual.items():
    z1,z2,w1,w2=u
    e,n=-z2,-z1+z2
    k=(0,0,w1+z2,w2+z1)
    lam=addv(sv(e,hp),sv(n,sp))
    assert addv(lam,k)==u
    pref=mon(zero,degree-F(omega(lam,k),2),coefficient)
    he=power_difference_quotient(hp,e,0,0)
    sn=power_difference_quotient(sp,n,2,2)
    edge_right=qa(edge_right,qm(qm(qm(pref,he),mon(sv(n,sp))),mon(k)))
    moment_right=qa(moment_right,qm(qm(pref,sn),mon(k)))
check('full quantum meridian certificate with correct generator sides',
      vacraw==qa(G,qm(edge,edge_right),qm(moment,moment_right)))
check('meridian certificate remains exact under inverse cyclic transport',
      psi(psi(vacraw))==qa(psi(psi(G)),qm(psi(psi(edge)),psi(psi(edge_right))),
                            qm(psi(psi(moment)),psi(psi(moment_right)))))
def exchange(u):return (u[1],u[0],u[3],u[2])
check('reversed meridian generator differs only by the actual edge relation',
      qa(mon(exchange(sp)),mon(sv(-1,sp),c=(-1,0)))==qm(edge,mon(sv(-1,sp))))
reverse_long=(4,0,-4,0)
check('reversed meridian vacuum is the exchanged vacuum modulo the edge',
      addv(exchange((-4,0,4,0)),sv(-1,reverse_long))==sv(4,hp)
      and omega(hp,reverse_long)==0)
def encode_poly(poly):
    return [{'root':list(u),'A_degree':str(degree),'coefficient':list(coefficient)}
            for (u,degree),coefficient in sorted(poly.items())]
(ROOT/'meridian-certificate.json').write_text(json.dumps({
    'scope':'native all-plus central sector only; not a full-six-root zero-vacuum certificate',
    'identity':'1-W(-4,0;4,0)=G+(W(hprime)-1)*edge_right+(W(sprime)+A^2)*moment_right',
    'tetrahedron_left_multipliers':terms,
    'hprime':hp,'sprime':sp,
    'G':encode_poly(G),'edge_right':encode_poly(edge_right),
    'moment_right':encode_poly(moment_right)},indent=2)+'\n')

result={'status':'passed','check_count':len(checks),'checks':checks,
        'symbolic_scope':'one exact blockwise cyclic map and arbitrary d,q,c with p=2q-d, t=(1+qc)/d, r=2t-c',
        'combined_theorem':'all primitive p*mu+q*lambda with q!=0 on the fixed actual datum',
        'native_control_slope':[-5,1],
        'native_control_vacuum_coefficients_A':{str(e):list(c) for e,c in sorted(vac.items())},
        'meridian_detector_unit_coefficients_A':{str(e):list(c) for e,c in sorted(meridian_unit.items())},
        'quadratic_tail_certificates':tails,
        'limits':'Meridian vacuum is zero in the all-plus sector by a finite algebraic certificate; the full-six-root meridian vacuum remains unresolved.'}
(ROOT/'exact-results.json').write_text(json.dumps(result,indent=2)+'\n')
print(f'PASS: {len(checks)} exact checks, with certified quadratic series tails.')
print('Outside-cone vacuum:',sorted(vac.items()))
print('Meridian unit equals longitude square:',sorted(meridian_unit.items()))