Nhoryun-Omega-III / research /code /verify_sharp_compensation.py
PureOne's picture
Upload Nhoryun Omega III research dataset release 3.0.0
868c741 verified
Raw History Blame Contribute Delete
5.73 kB
#!/usr/bin/env python3
"""Exact rational audit of the sharp two-step compensation counterexample.
Python standard library only. This verifies one concrete four-point transcript,
its smooth and strong interpolation inequalities, and the all-pair jet algebra.
The arbitrary-step construction and Gaussian convolution are justified by the
written proofs. No numerical integration or external replication is claimed.
"""
from fractions import Fraction as F
import argparse
import json
from pathlib import Path
def dot(x, y):
return sum((a*b for a,b in zip(x,y)), F(0))
def sub(x, y):
return tuple(a-b for a,b in zip(x,y))
def encoded(x):
if isinstance(x, F):
return {'numerator': str(x.numerator), 'denominator': str(x.denominator)}
if isinstance(x, (list, tuple)):
return [encoded(z) for z in x]
if isinstance(x, dict):
return {str(k): encoded(v) for k,v in x.items()}
return x
def jet(t):
A=(5-2*t)/(6*(2-t))
u=[F(0),-A,1-A,F(1,3)-A]
v=[F(0),(-9*A*A*t-9*A*A-3*A*t+12*A+6*t-7)/(18*t),
(-A*A*t-A*A+A*t+2*A-1)/(2*t),F(-10)]
w=[F(0),A*A*t/2+A*t/6-2*A/3-t/3+F(7,18),
A*A*t/2+A*A+A*t/6-5*A/3-t/3+F(8,9),
A*A*t/2+2*A*A+7*A*t/6-11*A/3-4*t/3+F(19,9)]
U=[sum(u[:i],F(0)) for i in range(4)]
V=[sum(v[:i],F(0)) for i in range(4)]
J={};K={};P={}
r=1-t/2
for i in range(4):
for j in range(4):
if i==j:
continue
J[i,j]=w[i]-w[j]+t*((i-j)*v[j]+V[i]-V[j]+u[j]*(U[i]-U[j]))-(u[i]-u[j])**2/2
K[i,j]=t*v[j]*(V[i]-V[j])-(v[i]-v[j])**2/2
P[i,j]=(r**i-r**j)**2/2
assert all(z >= 0 for z in J.values())
zeros={(0,1),(0,2),(2,0),(3,1),(3,2)}
assert {ij for ij,z in J.items() if z==0}==zeros
q=(8*t*t-38*t+43)/(108*(2-t))
assert -w[1]+w[3]/3==q<0
return A,u,v,w,U,V,J,K,P,q,r
def concrete():
t=F(93,50)
A,u,v,w,U,V,J,K,P,q,r=jet(t)
c=F(10**10); root_c=F(10**5);e=F(1,10**8)
assert root_c**2==c
assert all(K[ij]+c*P[ij]>0 for ij in K)
x=[(-t*i-t*e**2*V[i],-t*e*U[i],root_c*e**2*2*r**i) for i in range(4)]
g=[(1+e**2*v[i],e*u[i],root_c*e**2*r**i) for i in range(4)]
f=[-t*i+e**2*w[i]+c*e**4*r**(2*i) for i in range(4)]
for i in range(3):
assert x[i+1]==tuple(x[i][j]-t*g[i][j] for j in range(3))
I={};B={}
for i,j in J:
dx=sub(x[i],x[j]);dg=sub(g[i],g[j])
I[i,j]=f[i]-f[j]-dot(g[j],dx)-dot(dg,dg)/2
assert I[i,j]==e**2*J[i,j]+e**4*(K[i,j]+c*P[i,j])>0
B[i,j]=dot(sub(dx,dg),sub(dx,dg))
S=F(2,3)*f[0]-f[1]+f[3]/3
Q=F(2,3)-r*r+r**6/3
assert S==e**2*q+c*e**4*Q<0
a=min(I.values());b=max(B.values());mu=a/(a+b+1)
strong_slacks={ij:I[ij]-mu/(2*(1-mu))*B[ij] for ij in I}
assert 0<mu<1 and all(z>0 for z in strong_slacks.values())
M=1+max(dot(z,z) for z in g)
C=4*M*t+3+6*t*t
delta=-S;sigma=min(F(1),delta/(2*C))
assert C*sigma<=delta/2
kappa=[f[i]-2*f[i+1]+f[i+2] for i in range(2)]
assert 2*kappa[0]+kappa[1]==3*S
assert kappa[0]<0<kappa[1] # this is not adjacent concavity
return dict(step=t,A=A,c=c,e=e,x=x,g=g,f=f,J=J,K=K,P=P,
interpolation_slacks=I,strong_interpolation_slacks=strong_slacks,
min_interpolation_slack=a,mu=mu,sigma=sigma,S=S,
second_differences=kappa,all_checks_passed=True)
def coefficient_and_horizon_checks():
# More than isolated float evaluations: all arithmetic here is exact.
# The proof, not this finite parameter list, establishes the interval.
for t in [F(1859612,10**6),F(185965,10**5),F(18597,10**4),F(18599,10**4),F(93,50)]:
jet(t)
for N in range(1,101):
Bn=2*F(N+1)/(2+F(-1,2)**N)-F(2,3)
lam=[F(N+1)*(2+F(-1,2)**j)/(3*(2+F(-1,2)**N))-F(j+1,3) for j in range(N)]+[F(0)]
assert all(z>=0 for z in lam)
assert 2*lam[0]==Bn
coefs=[F(0)]*(N+2)
for j in range(N):
coefs[j]+=2*lam[j];coefs[j+1]-=lam[j];coefs[j+2]-=lam[j]
coefs[N+1]+=lam[N-1]
assert coefs==[Bn]+[F(-1)]*N+[F(0)]
R=F(-2)**(-(N+1))
d=[(1-R*F(-2)**j)/(1-R) for j in range(N+2)]+[F(0),F(0)]
assert d[0]==1 and d[N+1]==0 and all(z>=0 for z in d)
assert all(2*d[j]>=d[j+1]+d[j+2] for j in range(N+2))
assert sum(d[1:N+1],F(0))==Bn
return {'rational_jet_parameter_checks':5,'scalar_horizon_exact_cases':100,
'all_checks_passed':True}
def main():
parser=argparse.ArgumentParser()
parser.add_argument('--output',type=Path)
args=parser.parse_args()
data=concrete()
results={'certificate':'sharp two-step compensation counterexample',
'arithmetic':'fractions.Fraction',
'concrete_counterexample':data,
'coefficient_and_horizon_checks':coefficient_and_horizon_checks(),
'analytic_smoothing':'explicit scale certified by written error bound; not numerically integrated',
'external_replication':False,'proof_assistant_formalization':False,
'all_checks_passed':True}
if args.output:
args.output.parent.mkdir(parents=True,exist_ok=True)
args.output.write_text(json.dumps(encoded(results),indent=2)+'\n')
print(json.dumps({'all_checks_passed':True,'step':str(data['step']),
'strict_interpolation_inequalities':12,
'S_exact':str(data['S']),'S_decimal':float(data['S']),
'mu_decimal':float(data['mu']),
'sigma_decimal':float(data['sigma']),
'negative_second_difference_followed_by_positive':True,
'scalar_horizons_verified':100},indent=2))
if __name__=='__main__':
main()