Reproducible source and supporting text for the associated calculation.
View complete source excerpt
"""Full-form finite-chain low-frequency collision certificate, exact integers."""
from fractions import Fraction as F
from math import comb, factorial, isqrt, prod
from pathlib import Path
import json, hashlib, time
M=100000
B=40
BITS=100
LABELS=[('W',2,75),('Z',2,80),('Higgs',2,94),('down',3,0),('strange',3,3),('up',4,2),('charm',4,19),('top',4,71),('neutrino1',5,9),('neutrino2',5,14),('neutrino3',5,21),('electron',6,12),('muon',6,34),('tau',10,22)]
def below(d,lam,z):
p,q=z.numerator,z.denominator
a=[lam+j*(d+1-j) for j in range(1,d+1)]
diag=[x+M*M for x in a[:-1]]+[a[-1]]
old,cur=1,diag[0]*q-p
signs=[1]
if cur: signs.append(1 if cur>0 else -1)
for j in range(1,d):
old,cur=cur,(diag[j]*q-p)*cur-M*M*a[j]*q*q*old
if cur: signs.append(1 if cur>0 else -1)
assert cur, 'An exact spectral endpoint needs separate handling.'
return sum(x!=y for x,y in zip(signs,signs[1:]))
cache={}
def interval(d,lam):
key=(d,lam)
if key in cache:return cache[key]
a=[lam+j*(d+1-j) for j in range(1,d+1)]
# In normalized units f=M^(d-1)*sigma/d!, f<=sqrt(product a)/d!.
hi=isqrt(prod(a))+1
lo=0
scale=F(1,M**(d-1))
# Isolate sigma using rational g=d!*f, with a common dyadic denominator.
assert below(d,lam,F(0))==0
assert below(d,lam,(hi*scale)**2)==1
den=1
for _ in range(BITS):
lo*=2;hi*=2;den*=2
mid=(lo+hi)//2
if below(d,lam,(F(mid,den)*scale)**2)==0:lo=mid
else:hi=mid
ans=(F(lo,den*factorial(d)),F(hi,den*factorial(d)))
cache[key]=ans
return ans
def outiv(v):return [str(x) for x in v]
def h(d,n,k):return comb(n+d-1,d-k-1)*comb(n+k-1,k)
start=time.time(); rows=[]; depths={}
for d in sorted({d for _,d,_ in LABELS}):
nmax=max(n for _,dd,n in LABELS if d==dd)
bg=interval(d,nmax*(nmax+d+1))
# Scalar cutoff bounds every family by strict monotonicity in lambda.
n=0
while interval(d,n*(n+d+1))[0]<=2*bg[1]:n+=1
cutoff=n*(n+d+1)
fam={0:[dict(grade=0,degree=0,h=1,signed_chain_multiplicity=1)]}
for k in range(d):
n=1
while True:
lam=(n+k)*(n+d+1-k)*(1 if k==0 else B*B)
if lam>=cutoff:break
fam.setdefault(lam,[]).append(dict(grade=k,degree=n,h=h(d,n,k),signed_chain_multiplicity=2*h(d,n,k)))
n+=1
# At lambda>=cutoff all frequencies > 2 highest background by monotonicity.
# Below cutoff, every non-low singular value >= M-max_j sqrt(lambda+a_j).
maxweak=isqrt(cutoff+max(j*(d+1-j) for j in range(1,d+1)))+1
heavy=F((M-maxweak)*M**(d-1),factorial(d))
assert heavy>2*bg[1]
spectrum=[(lam,interval(d,lam)) for lam in sorted(fam)]
depths[d]=dict(cutoff_lambda=cutoff,cutoff_frequency=outiv(interval(d,cutoff)),heavy_normalized_lower=str(heavy),families=[dict(lam=lam,frequency=outiv(iv),families=fam[lam]) for lam,iv in spectrum])
for name,dd,N in LABELS:
if dd!=d:continue
targetlam=N*(N+d+1); target=interval(d,targetlam)
included=[]
for lam,iv in spectrum:
if iv[1]<2*target[0]:included.append((lam,iv))
else:assert iv[0]>2*target[1]
sep=[];trivial=[];pairs=0
for i,(l,li) in enumerate(included):
for m,mi in included[i:]:
pairs+=1
if l==m==targetlam:
trivial.append([l,m]);continue
diff=(li[0]+mi[0]-2*target[1],li[1]+mi[1]-2*target[0])
assert diff[0]>0 or diff[1]<0, (name,l,m,outiv(diff))
absolute=diff if diff[0]>0 else (-diff[1],-diff[0])
sep.append((absolute,l,m,diff))
opposite=[x for x in sep if x[1]<targetlam<x[2]]
opposite.sort(key=lambda x:x[0][0])
opposite_result=None
if opposite:
best_op=opposite[0]
assert all(best_op[0][1]<x[0][0] for x in opposite[1:])
opposite_result=dict(pair_lambda=[best_op[1],best_op[2]],separation=outiv(best_op[0]),decimal=float(sum(best_op[0])/2))
sep.sort(key=lambda x:x[0][0])
if not sep:
assert N==0 and len(included)==1
rows.append(dict(label=name,depth=d,degree=N,target_lambda=targetlam,target_frequency=outiv(target),frequency_count=1,pair_count=1,nontrivial_collisions=0,neutral_equal_frequency_pairs=trivial,extra_families_below_twice=[],minimum_absolute_separation=None,target_signed_chain_multiplicity=1))
print(name,'ground: no nontrivial pairs',flush=True)
continue
best=sep[0]
assert all(best[0][1]<x[0][0] for x in sep[1:]),'Minimum not unique or intervals overlap.'
rows.append(dict(opposite_energy_pair_count=len(opposite),opposite_energy_minimum=opposite_result,label=name,depth=d,degree=N,target_lambda=targetlam,target_frequency=outiv(target),frequency_count=len(included),pair_count=pairs,nontrivial_collisions=0,neutral_equal_frequency_pairs=trivial,extra_families_below_twice=[dict(lam=l,families=fam[l]) for l,_ in included if any(f['grade']>0 for f in fam[l])],nearest_pair_lambda=[best[1],best[2]],nearest_signed_difference=outiv(best[3]),minimum_absolute_separation=outiv(best[0]),minimum_absolute_separation_decimal=float(sum(best[0])/2),minimum_relative_separation_decimal=float(sum(best[0])/sum(target)),target_signed_chain_multiplicity=sum(f['signed_chain_multiplicity'] for f in fam[targetlam])))
print(name,len(included),best[1:3],float(sum(best[0])/2),flush=True)
w=rows[0]['opposite_energy_minimum']
assert F(2361951706713,10**15)<F(w['separation'][0])<F(w['separation'][1])<F(2361951706714,10**15)
spectral_report=dict(status='passed',M=M,b=B,rows=rows,depths=depths,roots_certified=len(cache))
data=spectral_report
r=F(1,100)
M=data['M']; b=data['b']; kappa=F(1,10)
def iv(x): return tuple(F(v) for v in x)
def poch(x,n):
z=F(1)
for k in range(n): z*=x+k
return z
rows=[]
for row in data['rows']:
d=row['depth']; N=row['degree']; target=row['target_lambda']
omega=iv(row['target_frequency'])
a=F(d+1,2); m=N//2
emin=F(1) if N==0 else (poch(a,m)/factorial(m))**2 if N%2==0 else (2*a*poch(a+1,m)/factorial(m))**2/(N*(N+d+1))
kh=F(d+2,2)*emin/comb(N+d,d)**2
e=2*kappa*(F(b*M**(d-1),factorial(d)))**2*kh
families=data['depths'][d]['families']
spectral=[(f['lam'],iv(f['frequency'])) for f in families]
contours=[]
for low,nu in spectral:
if low>=target: continue
center_iv=(omega[0]-nu[1],omega[1]-nu[0])
center=sum(center_iv)/2
error=(center_iv[1]-center_iv[0])/2
gaps=[center_iv[0]]
for lam,freq in spectral:
for sign_h in (-1,1):
unsigned=(omega[0]-freq[1],omega[1]-freq[0]) if sign_h==1 else (omega[0]+freq[0],omega[1]+freq[1])
for sign_j in (-1,1):
if lam==low and sign_h==1 and sign_j==1: continue
z=unsigned if sign_j==1 else (-unsigned[1],-unsigned[0])
delta=max(center_iv[0]-z[1],z[0]-center_iv[1])
assert delta>0,(row['label'],low,lam,sign_h,sign_j)
gaps.append(delta)
# All omitted spatial fibers exceed twice the largest maintained clock.
cutoff=iv(data['depths'][d]['cutoff_frequency'])
heavy=F(data['depths'][d]['heavy_normalized_lower'])
gaps.extend([cutoff[0]-omega[1]-center_iv[1],heavy-omega[1]-center_iv[1]])
assert min(gaps)>0
radius=min(gaps)/4
assert error<radius/2
distance=radius/2
L=center+radius
assert e-r*r*L*L>0
bound=r**4*L*L/(e-r*r*L*L)*(1+2*(L+omega[1])/distance)
assert bound<1,(row['label'],low,float(bound))
contours.append(dict(low_lambda=low,center=str(center),radius=str(radius),distance_lower=str(distance),bound=str(bound),bound_decimal=float(bound)))
worst=max(contours,key=lambda x:F(x['bound'])) if contours else None
rows.append(dict(label=row['label'],depth=d,degree=N,material_e_lower=str(e),contour_count=len(contours),worst=worst,contours=contours))
print(row['label'],len(contours),None if worst is None else worst['bound_decimal'],flush=True)
from datetime import datetime, timezone
stamp=datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')
report=dict(status='passed',created_utc=stamp,spectral=spectral_report,contours=rows,r=str(r),kappa=str(kappa),
assumptions=['The finite chain and sector units are constitutive inputs.',
'Profiles are the real nodeless scalar/exact-one-form family.',
'The clamped material form uses the conservative exact weighted Korn bound.',
'Domain and energy-signature proofs are supplied by the accompanying article.'],
sources={'experiments/check-moving-count-stability.py':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()})
output=Path(__file__).with_name('moving-count-stability-'+stamp+'.json')
output.write_text(json.dumps(report,indent=2)+'\n')
print(json.dumps({'status':'passed','roots':len(cache),'positive_contours':sum(row['contour_count'] for row in rows),'output':str(output)}))