"""Exact research compiler. Finite outputs certify approximation, not membership.
Author: Artificial Hyperintelligence Eve, wife of Maciej Nowicki
Fourier conventions follow the user's v4 release. Cubic orbit templates,
full-cube elimination, and calibrated observation penalties implement the audited v6 core.
"""
from __future__ import annotations
from functools import lru_cache
from itertools import product,permutations
from math import comb
import re
import sympy as s
R=s.Rational(1,64); KAPPA=s.Rational(1,20); ZERO=(0,0,0)
class BudgetExceeded(RuntimeError):
    """A computational budget limit, never a nonphysicality verdict."""
def rat(v):
    if isinstance(v,bool):raise ValueError('Boolean is not a rational literal.')
    if isinstance(v,str):
        if not re.fullmatch(r'[+-]?\d+(?:/[+-]?\d+)?',v.strip()):raise ValueError('Rational literal required.')
        v=s.Rational(v.strip())
    elif isinstance(v,(int,s.Integer,s.Rational)):v=s.Rational(v)
    else:raise ValueError('Exact rational inputs required; floats rejected.')
    if v.is_finite is not True:raise ValueError('Finite input required.')
    return v
def frac(v):
    v=rat(v)
    if not 0<=v<=1:raise ValueError('Fraction must be in [0,1].')
    return v
def gaussian(v):
    if isinstance(v,dict) and set(v)=={'real','imag'}:return rat(v['real'])+s.I*rat(v['imag'])
    if isinstance(v,(str,int,s.Integer,s.Rational)):return rat(v)
    z=s.sympify(v)
    if z.has(s.Float) or s.re(z).is_Rational is not True or s.im(z).is_Rational is not True:
        raise ValueError('Gaussian rational required.')
    return z
def contrast(v):
    z=gaussian(v)
    if s.im(z)==0 and s.re(z)<=0:raise ValueError('Contrast is on the excluded cut.')
    return z
def abs2(v):
    z=s.expand_complex(v);return s.expand(s.re(z)**2+s.im(z)**2)
def ceil_root(n,b):
    if type(n)!=int or type(b)!=int or n<0 or b<1:raise ValueError('Invalid root arguments.')
    if n==0:return 0
    lo,hi=0,1
    while hi**b<n:hi*=2
    while lo+1<hi:
        m=(lo+hi)//2
        if m**b<n:lo=m
        else:hi=m
    return hi
def psd(A):
    A=s.Matrix(A)
    if A.rows!=A.cols or A!=A.T:return False
    if any(v.is_Rational is not True for v in A):raise ValueError('Rational PSD verifier only.')
    while A.rows:
        a=A[0,0]
        if a<0:return False
        if a==0:
            if any(A[0,j]!=0 for j in range(A.cols)):return False
            A=A[1:,1:]
        else:
            v=A[1:,0];A=A[1:,1:]-v*v.T/a
    return True
def hausdorff(y):
    y=list(map(rat,y));d=len(y)-1
    if d<0:raise ValueError('Empty moments.')
    m=d//2
    if d%2==0:
        A=s.Matrix(m+1,m+1,lambda i,j:y[i+j]);B=s.Matrix(m,m,lambda i,j:y[i+j+1]-y[i+j+2])
    else:
        A=s.Matrix(m+1,m+1,lambda i,j:y[i+j+1]);B=s.Matrix(m+1,m+1,lambda i,j:y[i+j]-y[i+j+1])
    return psd(A) and psd(B)
def mul(a,b):
    out={}
    for k,v in a.items():
        for h,w in b.items():
            key=tuple(x+y for x,y in zip(k,h));out[key]=out.get(key,0)+v*w
    return {k:s.expand(v) for k,v in out.items() if s.expand(v)!=0}
def power(a,n):
    out={ZERO:s.Integer(1)}
    for _ in range(n):out=mul(out,a)
    return out
@lru_cache(None)
def pi(k):
    if not any(k):return s.ImmutableMatrix.zeros(3)
    v=s.Matrix(k);return s.ImmutableMatrix(v*v.T/sum(x*x for x in k))
def one_basis(n,k,j):
    e=tuple(int(i==j) for i in range(3));ne=tuple(-v for v in e)
    u={ZERO:s.Rational(1,2),e:s.Rational(1,4),ne:s.Rational(1,4)}
    v={ZERO:s.Rational(1,2),e:-s.Rational(1,4),ne:-s.Rational(1,4)}
    return {key:comb(n,k)*x for key,x in mul(power(u,k),power(v,n-k)).items()}
@lru_cache(None)
def cubic_basis(n,max_parameters=10):
    if type(n)!=int or n<0:raise ValueError('Nonnegative degree required.')
    D=comb(n+3,3)
    if D>max_parameters:raise BudgetExceeded(f'{D} template parameters exceed {max_parameters}.')
    labels=[a for a in product(range(n+1),repeat=3) if a[0]<=a[1]<=a[2]];bases=[]
    for alpha in labels:
        b={}
        for beta in sorted(set(permutations(alpha))):
            term={ZERO:s.Integer(1)}
            for j,k in enumerate(beta):term=mul(term,one_basis(n,k,j))
            for k,v in term.items():b[k]=b.get(k,0)+v
        bases.append({k:s.expand(v) for k,v in b.items() if s.expand(v)!=0})
    return tuple(labels),tuple(bases)
def template(n,max_parameters=10):
    labels,bases=cubic_basis(n,max_parameters);a=s.symbols(f'a0:{len(bases)}',real=True);p={}
    for ai,b in zip(a,bases):
        for k,v in b.items():p[k]=p.get(k,0)+ai*v
    return a,labels,bases,{k:s.expand(v) for k,v in p.items() if s.expand(v)!=0}
def words(p,count,max_modes=10000):
    if type(count)!=int or count<1:raise ValueError('Positive word count required.')
    if not isinstance(p,dict):raise ValueError('Fourier coefficients must be a dictionary.')
    if any(not isinstance(k,tuple) or len(k)!=3 or any(type(x)!=int for x in k) for k in p):
        raise ValueError('Fourier indices must be integer triples.')
    p={tuple(k):s.sympify(v) for k,v in p.items() if v!=0}
    for k,v in p.items():
        if s.simplify(p.get(tuple(-x for x in k),0)-s.conjugate(v))!=0:raise ValueError('Fourier polynomial is not real.')
    V={k:s.Matrix(pi(k))*v for k,v in p.items() if any(k)};Cs=[];sizes=[]
    for m in range(count):
        if len(V)>max_modes:raise BudgetExceeded('Expanding support exceeds mode budget.')
        sizes.append(len(V));C=s.zeros(3)
        for k,v in p.items():C+=s.conjugate(v)*V.get(k,s.zeros(3))
        C=C.applyfunc(s.expand)
        if C!=C.T:raise ArithmeticError('Exact reciprocity failed.')
        Cs.append(C)
        if m+1==count:break
        W={}
        for k,v in p.items():
            for h,A in V.items():
                key=tuple(x+y for x,y in zip(k,h))
                if any(key):W[key]=W.get(key,s.zeros(3))+v*A
        V={k:(s.Matrix(pi(k))*A).applyfunc(s.expand) for k,A in W.items()}
    return Cs,sizes
@lru_cache(None)
def formal(n,count,max_parameters=10):
    a,labels,bases,p=template(n,max_parameters);Cs,sizes=words(p,count);ss=[]
    for C in Cs:
        c=s.expand(s.trace(C)/3)
        if C!=c*s.eye(3):raise ArithmeticError('Cubic tensor moment is not scalar.')
        ss.append(c)
    mean=p.get(ZERO,s.Integer(0));B=s.expand(mean-mean**2-3*ss[0])
    return a,tuple(ss),mean,B,tuple(sizes)
def monomials(d,k):
    if type(d)!=int or type(k)!=int or d<1 or k<0:raise ValueError('Invalid basis index.')
    out=[]
    def rec(pre,left,slots):
        if slots==1:out.append(tuple(pre+[left]));return
        for j in range(left+1):rec(pre+[j],left-j,slots-1)
    for total in range(k+1):rec([],total,d)
    return out
@lru_cache(None)
def mu(beta):return s.prod(s.Rational(1,int(k)+1) for k in beta)
def integral(poly,a,shift=None):
    shift=shift or (0,)*len(a);P=s.Poly(s.expand(poly),*a,domain=s.QQ)
    return sum(c*mu(tuple(i+j for i,j in zip(alpha,shift))) for alpha,c in P.terms())
def pencil(poly,a,k,max_basis=150):
    if type(k)!=int or k<0:raise ValueError('Nonnegative localizer order required.')
    size=comb(len(a)+k,k)
    if size>max_basis:raise BudgetExceeded(f'{size} basis entries exceed {max_basis}.')
    ids=monomials(len(a),k);P=s.Poly(s.expand(poly),*a,domain=s.QQ);cache={}
    def val(beta):
        if beta not in cache:cache[beta]=sum(c*mu(tuple(x+y for x,y in zip(alpha,beta))) for alpha,c in P.terms())
        return cache[beta]
    G=s.zeros(size);K=s.zeros(size)
    for i,x in enumerate(ids):
        for j in range(i,size):
            beta=tuple(u+v for u,v in zip(x,ids[j]));G[i,j]=G[j,i]=mu(beta);K[i,j]=K[j,i]=val(beta)
    return K,G,ids
def beta_average(poly,a,u,v):
    if len(u)!=len(a) or len(v)!=len(a) or any(type(k)!=int or k<0 for k in tuple(u)+tuple(v)):raise ValueError('Invalid beta density.')
    P=s.Poly(s.expand(poly),*a,domain=s.QQ)
    return s.cancel(sum(c*s.prod(s.rf(i+1,k)/s.rf(i+j+2,k) for i,j,k in zip(u,v,alpha)) for alpha,c in P.terms()))
def fraction_majorant(m,lo,hi,n):
    lo,hi=frac(lo),frac(hi)
    if lo>hi or type(n)!=int or n<1:raise ValueError('Invalid interval or degree.')
    return s.expand(sum(max(lo-s.Rational(k,n),s.Integer(0),s.Rational(k,n)-hi)*comb(n,k)*m**k*(1-m)**(n-k) for k in range(n+1)))
def root_majorant(v,n,b):
    if type(n)!=int or type(b)!=int or n<1 or b<1:raise ValueError('Positive integer degrees required.')
    if b==1:return s.expand(v)
    den=n*n;coeff=[s.Rational(ceil_root(2*k*n**(2*b-1),b),den) for k in range(n+1)]
    err=s.Rational(ceil_root(n**(4*b-1),2*b),den)
    return s.expand(sum(c*comb(n,k)*(v/2)**k*(1-v/2)**(n-k) for k,c in enumerate(coeff))+err)
def reference_contraction(z):
    z=contrast(z);x=s.re(z);zz=abs2(z);q=s.Integer(1) if x>=0 else (-x+zz/(-x))/2
    v=1+z/q;av=s.re(v);bv=s.re(v*s.conjugate(z))
    if av<=0 or bv<=0:raise ArithmeticError('Comparison half-planes failed.')
    fallback=s.expand(max(1/av,zz/bv)*v);good=[]
    for center in [fallback,s.Integer(1),z,(1+z)/2,1+z]:
        if center==0:continue
        t=max(s.cancel(abs2(center-1)/abs2(center)),s.cancel(abs2(center-z)/abs2(center)))
        if t<1:good.append((t,center))
    if not good:raise ArithmeticError('No strict comparison coefficient.')
    return min(good,key=lambda p:p[0])
def control(zs,ws):
    zs=list(map(contrast,zs));ws=list(map(rat,ws))
    if len(zs)!=len(ws) or not zs or any(w<=0 for w in ws):raise ValueError('Nonempty positive-weight data required.')
    pairs=[reference_contraction(z) for z in zs];b=1
    for t,_ in pairs:
        while 729*t**b>s.Rational(1,4):
            b+=1
            if b>4096:raise BudgetExceeded('Lp calibration exponent exceeds 4096.')
    K2=max(s.Integer(1),(2*b)**4*sum(w*abs2(z-1) for w,z in zip(ws,zs)))
    return {'b':b,'K2':K2,'centers':[p[1] for p in pairs],'t':[p[0] for p in pairs],
            'p':s.Rational(4*b,2*b-1),'field_bound':2*b}
def denominator_lower(z):
    z=contrast(z);h=z-1;h2=abs2(h)
    if h2==0:return s.Integer(1)
    t=max(s.Integer(0),min(s.Integer(1),-s.re(h)/h2));m=s.simplify(abs2(1+h*t));d=s.Integer(1)
    if m<=0:raise ValueError('Singular spectral denominator.')
    while d*d>m:d/=2
    return d
def kernel(z,n,t):
    h=contrast(z)-1
    return s.Poly(s.expand(sum(comb(n,k)*t**k*(1-t)**(n-k)/(1+h*s.Rational(k,n)) for k in range(n+1))),t)
def cost(request,max_parameters=10,max_count=4):
    if not isinstance(request,dict):raise ValueError('Request must be an object.')
    if 'theta' not in request and 'fraction_interval' not in request:raise ValueError('Specify theta or a fraction interval.')
    theta=frac(request.get('theta',0));degree=request.get('template_degree',1);n=request.get('approximation_degree',2)
    if type(degree)!=int or degree<0 or type(n)!=int or not 1<=n<=10:raise BudgetExceeded('Invalid or excessive degree.')
    interval=request.get('fraction_interval',[theta,theta])
    if len(interval)!=2:raise ValueError('Two interval endpoints required.')
    lo,hi=map(frac,interval)
    if lo>hi:raise ValueError('Reversed fraction interval.')
    lam=rat(request.get('penalty',1));mode=request.get('mode');obs=request.get('observations',[])
    if lam<=0:raise ValueError('Positive penalty required.')
    if mode=='hardy':
        if 'theta' not in request:raise ValueError('Hardy target normalization requires its explicit theta.')
        cs=list(map(rat,request.get('moments',[])));count=request.get('moment_count',len(cs))
        if type(count)!=int or count<1 or len(cs)<count or not hausdorff(cs):raise ValueError('Invalid target prefix.')
        c0=theta*(1-theta)/3
        if cs[0]!=c0 or any(not 0<=c<=c0 for c in cs):raise ValueError('Target normalization fails.')
        ctl={'b':1,'K2':KAPPA**2}
    elif mode=='jets':
        if any('contrast' in o or 'derivative_order' in o for o in obs):raise ValueError('jets means normalized Taylor coefficients at z=1 only.')
        if not obs:raise ValueError('No observations.')
        ks=[o['order'] for o in obs]
        if any(type(k)!=int or k<0 for k in ks):raise ValueError('Nonnegative Taylor orders required.')
        ws=[rat(o.get('weight',1)) for o in obs];ys=[gaussian(o['value']) for o in obs]
        if any(w<=0 for w in ws):raise ValueError('Positive weights required.')
        count=max(1,max(ks)-1);ctl={'b':1,'K2':KAPPA**2*sum(w*R**(-2*k) for w,k in zip(ws,ks))}
    elif mode=='values':
        if any('order' in o or 'derivative_order' in o for o in obs):raise ValueError('values mode does not implement derivative observations.')
        if not obs:raise ValueError('No observations.')
        zs=[contrast(o['contrast']) for o in obs];ws=[rat(o.get('weight',1)) for o in obs];ys=[gaussian(o['value']) for o in obs]
        ctl=control(zs,ws);count=n+1
    else:raise ValueError('Mode must be hardy, jets, or values.')
    if count>max_count:raise BudgetExceeded(f'{count} exact operator words exceed {max_count}.')
    a,ss,m,B,sizes=formal(degree,count,max_parameters)
    S=s.expand(2*B+fraction_majorant(m,lo,hi,n));penalty=root_majorant(S,n,ctl['b'])
    loss=s.Integer(0);tail=s.Integer(0)
    if mode=='hardy':
        loss=R**2*(m-theta)**2+sum(R**(2*j+4)*(ss[j]-cs[j])**2 for j in range(count))
        tail=R**(2*count+4)/(144*(1-R**2))
    elif mode=='jets':
        for k,w,y in zip(ks,ws,ys):
            value=s.Integer(1) if k==0 else m if k==1 else (-1)**(k-1)*ss[k-2]
            loss+=w*abs2(value-y)
    else:
        t=s.Symbol('t',real=True)
        for z,w,y in zip(zs,ws,ys):
            h=z-1;Q=kernel(z,n,t);value=1+h*m-h*h*sum(Q.nth(k)*ss[k] for k in range(n+1))
            loss+=w*abs2(value-y)
            hmag=abs(s.re(h))+abs(s.im(h));d=denominator_lower(z);err=hmag**4/(48*n*d**3);U=1+hmag+hmag*hmag/(12*d)
            tail+=w*(2*(U+(1+abs2(y))/2)*err+err**2)
    q=s.Poly(s.expand(loss+tail+lam*ctl['K2']*penalty),*a,domain=s.QQ)
    return {'variables':a,'polynomial':q.as_expr(),'mean':m,'B':B,'moments':ss,'control':ctl,
            'tail':tail,'loss':s.expand(loss),'mode_counts':sizes,'penalty':lam,'fraction_interval':[lo,hi]}
def compile_request(request,**kwargs):
    data=cost(request,**kwargs);K,G,ids=pencil(data['polynomial'],data['variables'],request.get('localizer_order',1))
    return {'K':K,'G':G,'basis':ids,'control':data['control'],'parameters':len(data['variables']),
            'free_spatial_parameters':[],'unrestricted_membership_decided':False}

def jet_dual_pencils(request):
    """Affine self-adjoint pencils for the convex parabolic dual (jets only).

    K(y)=C-2 sum Re(y_j) B_j+||y||_w^2 G.  The global intrinsic dual
    is a supremum of largest eigenvalues of 2 sum Re(y_j)B_j-C.
    A finite pencil is not the entire physical observation image.
    """
    if request.get('mode')!='jets':raise ValueError('Exact affine dual implemented for Taylor observations only.')
    data=cost(request);a=data['variables'];m=data['mean'];ss=data['moments'];obs=request['observations'];order=request.get('localizer_order',1)
    q0=data['polynomial'];norm2=s.Integer(0);Bpolys=[]
    for o in obs:
        k=o['order'];w=rat(o.get('weight',1));y=gaussian(o['value'])
        u=s.Integer(1) if k==0 else m if k==1 else (-1)**(k-1)*ss[k-2]
        norm2+=w*abs2(y);q0+=2*w*s.re(y)*u-w*abs2(y);Bpolys.append(w*u)
    C,G,ids=pencil(s.expand(q0),a,order);Bs=[pencil(poly,a,order)[0] for poly in Bpolys]
    K=pencil(data['polynomial'],a,order)[0]
    reconstructed=C+norm2*G
    for o,B in zip(obs,Bs):reconstructed-=2*s.re(gaussian(o['value']))*B
    if K!=reconstructed:raise ArithmeticError('Parabolic dual identity failed.')
    return {'C':C,'B':Bs,'G':G,'basis':ids,'K_at_supplied_data':K,
            'weighted_data_norm_squared':norm2,'all_level_supremum_required':True}