File size: 6,435 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 135 136 137 138 139 140 141 142 | """Exact rational and algebraic certificates. No floating-point pass criteria."""
import json
from pathlib import Path
import sympy as sp
ROOT = Path(__file__).resolve().parents[1]
x, y, e = sp.symbols('x y epsilon', real=True)
checks = []
def check(name, condition, detail=None):
if condition is not True and condition != sp.true:
raise AssertionError(name + ': ' + str(condition))
checks.append({'name':name, 'passed':True, 'detail':detail})
def valuation(f, var):
f = sp.cancel(f)
if f == 0:
return sp.oo
p,q = sp.fraction(f)
def order(poly):
return min(k[0] for k,c in sp.Poly(poly,var).terms() if c != 0)
return order(p)-order(q)
def analytic_energy_certificate(G, data, var):
"""Exact pivoted analytic Schur elimination for rational matrix families.
Positivity and full rank near the puncture are THEOREM HYPOTHESES.
This function checks even pivot orders and positive leading coefficients,
but is not a global positivity verifier for arbitrary user matrices.
"""
G, data = sp.Matrix(G), sp.Matrix(data)
terms, pivots = [], []
while G.rows:
k = min(range(G.rows),key=lambda j:valuation(G[j,j],var))
if G[k,k] == 0:
raise ValueError('Identically singular family')
if k:
G.row_swap(0,k); G.col_swap(0,k); data.row_swap(0,k)
p, z = sp.factor(G[0,0]), sp.factor(data[0])
vp, vz = valuation(p,var), valuation(z,var)
a = sp.limit(p/var**vp,var,0)
if vp % 2 or a <= 0:
raise ValueError('Failed positive analytic Gramian pivot hypothesis')
terms.append(sp.cancel(z*z/p))
pivots.append({'pivot':str(p),'pivot_order':int(vp),
'target':str(z),'target_order':None if vz is sp.oo else int(vz),
'leading_pivot':str(a)})
if G.rows == 1:
break
cross = G[1:,0]
ratios = cross/p
if any(valuation(v,var)<0 for v in ratios):
raise ValueError('Nonanalytic elimination ratio')
data = (data[1:,0]-cross*z/p).applyfunc(sp.cancel)
G = (G[1:,1:]-cross*cross.T/p).applyfunc(sp.cancel)
energy = sp.factor(sum(terms))
ve = valuation(energy,var)
leading = sp.limit(energy/var**ve,var,0) if energy != 0 else 0
return energy, pivots, ve, leading
def main():
polynomials = []
for m in range(7):
invB = sp.factorial(2*m+1)/sp.factorial(m)**2
H = sp.expand(1-2*invB*sp.integrate((x*(1-x))**m,(x,0,y)))
check(f'flat_m{m}_left_value', H.subs(y,0)==1)
check(f'flat_m{m}_right_value', H.subs(y,1)==-1)
for k in range(1,m+1):
check(f'flat_m{m}_jet{k}_both_nodes',
sp.diff(H,y,k).subs(y,0)==0 and sp.diff(H,y,k).subs(y,1)==0)
check(f'flat_m{m}_leading_coefficient',
H.coeff(y,2*m+1)==(-1)**(m+1)*2*sp.binomial(2*m,m))
r=sp.symbols('r', nonnegative=True)
outer=sp.expand(2*invB*sp.integrate((x*(1+x))**m,(x,0,r)))
check(f'flat_m{m}_outer_error',sp.expand((H.subs(y,-r)-1)-(-1)**m*outer)==0)
polynomials.append({'m':m,'H':str(H),'outer_error':str(outer)})
rc=(sp.sqrt(2)-1)/2
check('critical_radius_exact',sp.simplify(4*rc*(1+rc)-1)==0)
# An exact constrained cubic minimax solution on r=1/4 bands.
P=(32*x**3-26*x)/9
check('cubic_nominal_values',P.subs(x,-sp.Rational(1,2))==1 and P.subs(x,sp.Rational(1,2))==-1)
check('cubic_outer_and_inner_equalization',
P.subs(x,sp.Rational(1,4))+1==sp.Rational(1,3) and
P.subs(x,sp.Rational(3,4))+1==sp.Rational(1,3))
c=sp.symbols('c',real=True)
Q=-2*x+c*x*(x*x-sp.Rational(1,4))
EB=1+Q.subs(x,sp.Rational(1,4)); EA=1+Q.subs(x,sp.Rational(3,4))
check('cubic_universal_lower_certificate',sp.simplify((5*EB+EA)/6)==sp.Rational(1,3))
xmin=sp.sqrt(sp.Rational(13,48))
check('cubic_only_positive_critical_point',sp.simplify(sp.diff(P,x).subs(x,xmin))==0)
minimum=sp.simplify(1+P.subs(x,xmin))
check('cubic_interior_error_within_bound',bool(minimum>=-sp.Rational(1,3)) and bool(minimum<=sp.Rational(1,3)))
check('cubic_energy_ratio',sp.simplify((sp.Rational(32,9)/4)**2)==sp.Rational(64,81))
H1=4*x**3-3*x
check('flat_cubic_outer_error',H1.subs(x,sp.Rational(3,4))+1==sp.Rational(7,16))
# Multiscale collision: two of three nodes are separated only by epsilon^2.
nodes=[0,e,e+e**2]
multi=[]
for target,expected in [([0,0,1],3),([1,0,0],2),([1,1,1],0)]:
H=sp.interpolate(list(zip(nodes,target)),x)
poles=max(-valuation(co,e) for co in sp.Poly(H,x).all_coeffs())
check('multiscale_target_'+''.join(map(str,target)),poles==expected)
multi.append({'targets':target,'polynomial':str(sp.factor(H)),'energy_exponent':2*expected})
L=sp.Matrix([[1,0,0],[1+e,1,0],[e**2,2-e,1]])
D=sp.diag(1,e**2,e**6)
G=L*D*L.T
tests=[(sp.Matrix([1,0,0]),0),(sp.Matrix([0,1,0]),-2),
(sp.Matrix([0,0,1]),-6),(sp.Matrix([0,0,e**2]),-2),
(sp.Matrix([0,0,e**3]),0),(sp.Matrix([e,e**2,e**4]),2)]
analytic=[]
for j,(z,order) in enumerate(tests):
data=L*z
energy,pivots,ve,leading=analytic_energy_certificate(G,data,e)
check(f'analytic_case{j}_exact_energy',sp.cancel(energy-(z.T*D.inv()*z)[0])==0)
check(f'analytic_case{j}_valuation',ve==order)
analytic.append({'target':str(data),'energy':str(energy),'order':int(ve),'leading':str(leading),'pivots':pivots})
for a in [1,2,3,4,5]:
Gweak=sp.diag(1,e**2,e**6+e**(2*a))
energy,pivots,ve,leading=analytic_energy_certificate(Gweak,sp.Matrix([0,0,1]),e)
check(f'weak_analytic_power_{a}',ve==-2*min(a,3))
# A hidden zero shared coupling is a true feasibility obstruction.
check('zero_coupling_nonzero_target_obstruction',sp.Matrix([[1,0],[0,0]]).rank()==1)
report={'status':'PASS','arithmetic':'SymPy exact rational/algebraic',
'assertions':len(checks),'checks':checks,'flat_polynomials':polynomials,
'critical_radius':str(rc),'constrained_cubic':str(P),
'cubic_minimum_error_value':str(minimum),'multiscale':multi,'analytic_cases':analytic}
path=ROOT/'results/exact_certificates.json'
path.write_text(json.dumps(report,indent=2),encoding='utf-8')
print(f'PASS: {len(checks)} exact assertions; {path.name}')
if __name__=='__main__':
main()
|