File size: 6,834 Bytes
a5568e0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | """High-precision checks of interval response, minimax degree and collision cost."""
import json
from pathlib import Path
import mpmath as mp
from spectral_control import (two_mode, MomentProblem, polyval, flat_polynomial_coeffs,
flat_error, interval_error, polynomial_jets)
ROOT=Path(__file__).resolve().parents[1]
def s(x):
return mp.nstr(x,45)
def main():
mp.mp.dps=110
checks=[]
def check(name,condition,detail=None):
if not condition:
raise AssertionError(name+': '+str(detail))
checks.append({'name':name,'passed':True,'detail':detail})
# Exact polynomial profiles, including high-order extrapolation.
rc=(mp.sqrt(2)-1)/2
profile=[]
for radius in [mp.mpf('.1'),rc,mp.mpf('.25'),mp.mpf('.4')]:
for m in [0,1,2,4,8,16,32,64]:
A=flat_error(m,radius)
B=interval_error(m,radius)
profile.append({'m':m,'radius':s(radius),'flat_error':s(A),'interval_error':s(B)})
for radius in [mp.mpf('.1'),rc,mp.mpf('.25'),mp.mpf('.4')]:
m=512
g=radius*(1+radius)
asymp=4*g/(mp.sqrt(mp.pi)*(1+2*radius)*mp.sqrt(m))*(4*g)**m
ratio=flat_error(m,radius)/asymp
check('Laplace_asymptotic_r'+s(radius),abs(ratio-1)<mp.mpf('.006'),s(ratio))
# Fixed-m response tends to the Hermite polynomial; remainder is a bound
# at every sampled point (the proof, not sampling, gives the continuum bound).
convergence=[]
points=[mp.mpf(k)/8 for k in range(-2,11)] # y=-.25,...,1.25
for m in [0,1,2]:
H=flat_polynomial_coeffs(m)
previous=None
for gap in ['.08','.04','.02','.01']:
problem=two_mode(m,gap,dps=110)
delta=mp.mpf(gap)
errors=[]; bound_ratios=[]
for y in points:
F=problem.response(2+delta*(y-mp.mpf('.5')))
err=abs(F-polyval(H,y))
bound=problem.hermite_remainder_bound(y,[0,1],delta)
if bound:
check(f'Hermite_bound_m{m}_gap{gap}_y{s(y)}',err<=bound*(1+mp.mpf('1e-65')),s(err/bound))
bound_ratios.append(err/bound)
else:
check(f'nodal_value_m{m}_gap{gap}_y{s(y)}',err<mp.mpf('1e-65'),s(err))
errors.append(err)
maxerr=max(errors)
if previous is not None:
check(f'profile_convergence_m{m}_gap{gap}',maxerr<previous,s(maxerr/previous))
previous=maxerr
check(f'linear_residual_m{m}_gap{gap}',problem.solve_residual<mp.mpf('1e-65'),s(problem.solve_residual))
convergence.append({'m':m,'gap':gap,'energy':s(problem.energy),
'scaled_energy':s(problem.energy*delta**(4*m+2)),
'profile_max_error':s(maxerr),'max_bound_fraction':s(max(bound_ratios))})
# Analytically optimal cubic at radius1/4. It is not the flat cubic.
P=[0,-mp.mpf(26)/9,0,mp.mpf(32)/9]
cubic=[]
for gap in ['.08','.04','.02','.01','.001','.0001']:
delta=mp.mpf(gap)
jets=polynomial_jets(P,[-mp.mpf('.5'),mp.mpf('.5')],delta,1)
p=MomentProblem([2-delta/2,2+delta/2],1,jets=jets)
f=two_mode(1,gap,dps=110)
# Uniform bound: |(x+.5)^2(x-.5)^2| is maximal at the outer edge.
maxprod=(mp.mpf('.75')**2-mp.mpf('.5')**2)**2
bound=delta**4*maxprod*p.moment_norm(4)*mp.sqrt(p.energy)/mp.factorial(4)
certified=mp.mpf(1)/3+bound
samples=[-mp.mpf('.75')+mp.mpf(k)/200 for k in range(101)]
samples+= [mp.mpf('.25')+mp.mpf(k)/200 for k in range(101)]
worst=max(abs(p.response(2+delta*x)-(1 if x<0 else -1)) for x in samples)
check('cubic_finite_gap_bound_'+gap,worst<=certified,s(certified))
cubic.append({'gap':gap,'energy':s(p.energy),'flat_energy':s(f.energy),
'energy_ratio':s(p.energy/f.energy),'sampled_worst_error':s(worst),
'uniform_error_upper_bound':s(certified),'uniform_remainder_bound':s(bound),
'tolerance_0_4_certified':bool(certified<mp.mpf('.4'))})
check('cubic_asymptotic_energy_ratio',abs(mp.mpf(cubic[-1]['energy_ratio'])-mp.mpf(64)/81)<mp.mpf('1e-5'))
check('cubic_continuum_tolerance_certificate',any(x['tolerance_0_4_certified'] for x in cubic))
# Leading coefficient constants, independent of extrapolation tests.
constants=[]
for m in [0,1,2]:
n=2*m+1
# Leading coefficient in centered x is unchanged by the shift y=x+.5.
hn=(-1)**(m+1)*2*mp.binomial(2*m,m)
jets=[[0]*(n+1)]
jets[0][n]=mp.factorial(n)*hn
limit=MomentProblem([2],n,jets=jets).energy
final=[v for v in convergence if v['m']==m][-1]
ratio=mp.mpf(final['scaled_energy'])/limit
check(f'leading_constant_m{m}',abs(ratio-1)<mp.mpf('.003'),s(ratio))
constants.append({'m':m,'limit_constant':s(limit),'finite_gap_ratio':s(ratio)})
# Unequal collision speeds: orders4 and6 instead of one universal order4.
multiscale=[]
for target,exponent in [([0,0,1],6),([1,0,0],4),([1,1,1],0)]:
vals=[]
for gap in ['.08','.04','.02','.01']:
eps=mp.mpf(gap)
p=MomentProblem([2,2+eps,2+eps+eps**2],0,jets=[[v] for v in target])
vals.append({'epsilon':gap,'energy':s(p.energy),'scaled_energy':s(p.energy*eps**exponent)})
slope=mp.log(mp.mpf(vals[-1]['energy'])/mp.mpf(vals[-2]['energy']))/mp.log(mp.mpf('.5'))
check('multiscale_slope_'+str(target),abs(slope+exponent)<mp.mpf('.12'),s(slope))
multiscale.append({'target':target,'expected_exponent':exponent,'slope':s(slope),'data':vals})
# One independently integrated difficult case and a precision replication.
p=two_mode(1,'.04',dps=90)
quadrature=p.direct_residual()
check('independent_adaptive_quadrature',quadrature<mp.mpf('1e-55'),s(quadrature))
E90=p.energy
p=two_mode(1,'.04',dps=140)
difference=abs(E90/p.energy-1)
check('precision_90_vs_140',difference<mp.mpf('1e-60'),s(difference))
report={'status':'PASS','precision_digits':110,'assertions':len(checks),'checks':checks,
'critical_radius':s(rc),'polynomial_profiles':profile,'response_convergence':convergence,
'cubic_comparison':cubic,'leading_constants':constants,'multiscale':multiscale,
'independent_quadrature_residual':s(quadrature),'precision_relative_difference':s(difference),
'limitations':'High precision is not directed-rounding interval arithmetic. Continuum bounds follow from proved formulas; response grids are illustrations.'}
path=ROOT/'results/resolution_report.json'
path.write_text(json.dumps(report,indent=2),encoding='utf-8')
print(f'PASS: {len(checks)} numerical assertions; {path.name}')
if __name__=='__main__':
main()
|