| """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}) |
| |
| 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)) |
|
|
| |
| |
| convergence=[] |
| points=[mp.mpf(k)/8 for k in range(-2,11)] |
| 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))}) |
|
|
| |
| 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) |
| |
| 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)) |
|
|
| |
| constants=[] |
| for m in [0,1,2]: |
| n=2*m+1 |
| |
| 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)}) |
|
|
| |
| 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}) |
|
|
| |
| 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() |
|
|
