"""Half-step population profiles and simultaneous polynomial certificates. Standard-library Decimal arithmetic at 80 digits, not formal interval arithmetic. Population sharpness is for the closure of the finite-label representation (1). The count certificate uses the same eighteen frequencies as affine_certificate. """ from decimal import Decimal as D, localcontext from paired_core import radius, GUARD, serializable from affine_certificate import probe_certificate def power(a, r): return D(0) if a == 0 else (r*a.ln()).exp() def rules(m): a,b,c=m if min(a*c-b*b,(1-a)*(b-c)-(a-b)**2,a,c,1-a,b-c)<=0: raise ValueError('strict interior moment matrices required') d,e=a-b,b-c z=e/d wz=d/(z*(1-z));w1=(a*c-b*b)/(d-e);w0=1-wz-w1 S=(c-a*b)/(b-a*a);p=S*a-b disc=(S*S-4*p).sqrt() r1,r2=(S-disc)/2,(S+disc)/2 g1=(r2-a)/(r2-r1) if not (00): raise ValueError('invalid quadrature nodes or weights') return dict(gauss_nodes=[r1,r2],gauss_weights=[g1,1-g1], lobatto_nodes=[D(0),z,D(1)],lobatto_weights=[w0,wz,w1]) def bounds(rule,x): r=1+2*x G=sum(w*power(t,r) for t,w in zip(rule['gauss_nodes'],rule['gauss_weights'])) L=sum(w*power(t,r) for t,w in zip(rule['lobatto_nodes'],rule['lobatto_weights'])) return min(G,L),max(G,L) def profile(m,w): rule=rules(m) if not m[2]<=w<=m[0]: return None ends=[] for side in (0,1): lo,hi=D(0),D(1) for _ in range(240): mid=(lo+hi)/2 if bounds(rule,mid)[side]>w:lo=mid else:hi=mid ends.append((lo+hi)/2) return ends def solve(matrix,rhs): A=[list(row)+[b] for row,b in zip(matrix,rhs)] for i in range(len(A)): pivot=max(range(i,len(A)),key=lambda k:abs(A[k][i])) A[i],A[pivot]=A[pivot],A[i] z=A[i][i] A[i]=[v/z for v in A[i]] for k in range(len(A)): if k==i:continue z=A[k][i];A[k]=[u-z*v for u,v in zip(A[k],A[i])] return [row[-1] for row in A] def hermite(r,nodes,lobatto=False): def row(t,deriv=False): return [D(0),D(1),2*t,3*t*t] if deriv else [D(1),t,t*t,t*t*t] if lobatto: z=nodes[0] return solve([row(D(0)),row(z),row(z,True),row(D(1))], [D(0),power(z,r),r*power(z,r-1),D(1)]) a,b=nodes return solve([row(a),row(a,True),row(b),row(b,True)], [power(a,r),r*power(a,r-1),power(b,r),r*power(b,r-1)]) def linear_count_certificate(data,x0,eps,gauss_nodes,z): """p<=R^(1+2(x0+eps)), q>=R^(1+2(x0-eps)); fixed half-step.""" if not 0<=eps0 for e in entries), arithmetic='80-digit Decimal; numerical, not formal interval arithmetic') def demonstration(counts_builder): with localcontext() as ctx: ctx.prec=80 rs=[D('.1'),D('.5'),D('.9')] m=[sum(r**k for r in rs)/3 for k in (1,2,3)] rule=rules(m) xs=[D(3)/8,D(1)/8] w=[sum(power(r,1+2*x) for r in rs)/3 for x in xs] intervals=[profile(m,a) for a in w] # Raw weak-source void .8, then anchors are .8*(1,m1,m2,m3). vs=[[D('.8')*a for a in [m[0],v,m[2],D(1),m[1]]] for v in w] data=dict(alpha='.05',contract=dict(step='.5',ratio_error='.1'), groups=[counts_builder(a,n=10**12) for a in vs]) linear=linear_count_certificate(data,D('.25'),D('.1'),rule['gauss_nodes'],D('.5')) old=probe_certificate(data) u=-(m[2]/m[0]).ln();disp=(m[1]/m[0]**2).ln();K=4*(disp.exp()-1) L=u*(w[1]/w[0]).ln();B=u*u.exp()*K/8 # Reflection/closure checks with a genuinely heterogeneous common x. positive=[profile(m,sum(power(r,1+2*x) for r in rs)/3) for x in [D('.3')]*2] return dict(moments=m,rules=rule,intermediate_moments=w,profiles=intervals, gap=intervals[0][0]-intervals[1][1], ratio_budget_threshold=(intervals[0][0]-intervals[1][1])/2, probe_dispersion=disp,variance_budget=K,L=L,B_zero_error=B, old_certificate=old,linear_certificate=linear,fixture=data, common_x_profile=positive)