Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
mathematical-physics
materials-science
homogenization
g-closure
two-phase-conductivity
| """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 | |
| 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()} | |
| 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 | |
| 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 | |
| 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} | |