Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
mathematics
homogenization
spectral-theory
variational-methods
matrix-analysis
scientific-computing
| #!/usr/bin/env python3 | |
| """EVE-QELTHA: holonomy-gated hyperhorn mathematical verification. | |
| Python 3.10+; requires numpy, scipy, mpmath (only for asymptotic check). | |
| All quantities dimensionless; model is a reduced mathematical transport model, | |
| not a numerical solution of the full Navier-Stokes equations. | |
| Reproduces: | |
| - genuinely noncommuting SU(2) two-loop holonomies; | |
| - spectral formula for the leakage matrix; | |
| - exact Bessel Dirichlet-to-Neumann impedances; | |
| - independent variational finite-volume convergence; | |
| - gauge-covariant inlet dissipation; | |
| - supercritical algebraic divergence and marginal logarithmic divergence. | |
| """ | |
| import csv | |
| from pathlib import Path | |
| import numpy as np | |
| import mpmath as mp | |
| from scipy.linalg import eigh, expm, solve_banded | |
| from scipy.special import kv | |
| HERE = Path(__file__).resolve().parent | |
| SX = np.array([[0, 1], [1, 0]], dtype=complex) | |
| SY = np.array([[0, -1j], [1j, 0]], dtype=complex) | |
| SZ = np.array([[1, 0], [0, -1]], dtype=complex) | |
| E0 = np.array([1.0, 0.0], dtype=complex) | |
| def transport(a, b, second_axis=SZ): | |
| w1 = expm(1j * a * SX) | |
| w2 = expm(1j * b * second_axis) | |
| u, v = w1 @ w2 @ E0, w2 @ w1 @ E0 | |
| M = np.outer(u, u.conjugate()) + np.outer(v, v.conjugate()) | |
| delta = float(1 - abs(np.vdot(u, v)) ** 2) | |
| return w1, w2, u, v, M, max(0.0, min(1.0, delta)) | |
| def geometry(n, p): | |
| assert n >= 3 and (n - 1) * p > 1 and (n - 2) * p <= 1 | |
| alpha_h = 1 + 1.5 * p | |
| nu = (1 - (n - 2) * p) / (2 + 3 * p) | |
| return alpha_h, nu | |
| def impedance(lam, n=4, p=0.4, A=1.0, B=1.0): | |
| if lam <= 0: | |
| return float('inf') | |
| alpha_h, nu = geometry(n, p) | |
| k = np.sqrt(A * B * lam) / alpha_h | |
| return float(np.sqrt(A / (B * lam)) * kv(1 - nu, k) / kv(nu, k)) | |
| def flux(x, lam, n=4, p=0.4, A=1.0, B=1.0): | |
| alpha_h, nu = geometry(n, p) | |
| beta_h = (1 - (n - 2) * p) / 2 | |
| k = np.sqrt(A * B * lam) / alpha_h | |
| x = np.asarray(x, dtype=float) | |
| return x**beta_h * kv(nu, k * x**alpha_h) / kv(nu, k) | |
| def finite_volume_impedance(lam, n=4, p=0.4, A=1, B=1, length=35, N=1000): | |
| """Independent variational discretization of the flux-energy functional. | |
| Boundary values: Q(1)=1; Q(length)=0. Midpoint quadrature of | |
| int R(x)*Q(x)^2 dx + int abs(Q'(x))^2/(G(x)*lam) dx. | |
| Minimization yields a tridiagonal strictly-positive-definite system. | |
| """ | |
| assert lam > 0 and N >= 3 | |
| xs = np.linspace(1, length, N + 1) | |
| h = xs[1] - xs[0] | |
| mid = (xs[:-1] + xs[1:]) / 2 | |
| R = A * mid**((n + 1) * p) | |
| G = B * mid**(-(n - 2) * p) | |
| d = R * h / 2 + 2 / (G * lam * h) | |
| off = R * h / 2 - 2 / (G * lam * h) | |
| # Interior stationarity: (d[j-1]+d[j])*q[j] | |
| # + off[j-1]*q[j-1] + off[j]*q[j+1] = 0. | |
| main = d[:-1] + d[1:] | |
| adjacent = off[1:-1] | |
| ab = np.zeros((3, N - 1)) | |
| ab[0, 1:] = adjacent | |
| ab[1, :] = main | |
| ab[2, :-1] = adjacent | |
| rhs = np.zeros(N - 1) | |
| rhs[0] = -off[0] | |
| sol = solve_banded((1, 1), ab, rhs, check_finite=True) | |
| q = np.concatenate(([1.0], sol, [0.0])) | |
| e = np.sum(R * h * ((q[:-1] + q[1:]) / 2)**2 + | |
| ((q[:-1] - q[1:])**2) / (G * lam * h)) | |
| return float(e) | |
| def high_precision_log10_impedance(b_exp, p='0.4', n=4): | |
| mp.mp.dps = 180 | |
| p = mp.mpf(p) | |
| a_h = 1 + mp.mpf('1.5') * p | |
| nu = (1 - (n - 2) * p) / (2 + 3*p) | |
| b = mp.power(10, -b_exp) | |
| lam = 1 - mp.cos(b) # exact for first SU2 angle a=pi/4, |b|<pi/2 | |
| k = mp.sqrt(lam) / a_h | |
| z = mp.besselk(1-nu, k) / (mp.sqrt(lam)*mp.besselk(nu, k)) | |
| return float(mp.log10(z)) | |
| def run(): | |
| # 1. Noncommutativity, holonomy/observer invariant and spectral identity | |
| a = np.pi / 4 | |
| b = 0.5 | |
| w1,w2,u,v,M,delta = transport(a,b) | |
| assert np.linalg.norm(w1@w2-w2@w1) > 0.1 | |
| assert abs(delta - np.sin(2*a)**2*np.sin(b)**2) < 1e-12 | |
| eigs,U = eigh(M) | |
| spectral_formula = np.array([1 - np.sqrt(1-delta), 1 + np.sqrt(1-delta)]) | |
| assert np.max(np.abs(eigs-spectral_formula)) < 1e-12 | |
| # 2. Individual Wilson-loop eigenvalues cannot resolve the obstruction: | |
| # replace z-axis by x-axis while maintaining eigenvalues of W2. | |
| _,_,_,_,M_parallel,delta_parallel = transport(a,b,second_axis=SX) | |
| assert delta_parallel < 1e-12 | |
| assert abs(np.linalg.eigvalsh(M_parallel)[0]) < 1e-12 | |
| print('Spectral-insufficiency test: identical loop eigenvalues,') | |
| print(' transverse-hole delta=%.10f, commuting-hole delta=%.2e' % (delta,delta_parallel)) | |
| # 3. Energy/impedance operator is covariant under change of local frame | |
| q = np.array([1 + .2j, -.4 + .1j]) | |
| z = np.array([impedance(float(x)) for x in eigs]) | |
| Z = U @ np.diag(z) @ U.conjugate().T | |
| s = expm(1j*.371*SY) | |
| M2 = s @ M @ s.conjugate().T | |
| eigs2,U2 = eigh(M2) | |
| Z2 = U2 @ np.diag([impedance(float(x)) for x in eigs2]) @ U2.conjugate().T | |
| e1 = np.vdot(q,Z@q).real | |
| e2 = np.vdot(s@q,Z2@(s@q)).real | |
| assert abs(e1-e2) < 1e-11 | |
| print('Gauge/frame invariance: %.12f vs %.12f (error %.2e)' % (e1,e2,abs(e1-e2))) | |
| # 4. Independent numerical discretization and convergence | |
| print('Four-dimensional horn: n=4, p=.4, A=B=1; b=0.5') | |
| print(' leakage eigenvalues:', repr(eigs.tolist())) | |
| numerical_errors=[] | |
| for lam in eigs: | |
| exact=impedance(float(lam)) | |
| print(' lambda %.9f exact impedance %.9f:' % (lam,exact)) | |
| for N in (400,800,1600,3200): | |
| num=finite_volume_impedance(float(lam),N=N) | |
| rel=abs(num-exact)/exact | |
| numerical_errors.append(rel) | |
| print(' grid=%4d, discrete energy=%.9f, rel error=%.4g' %(N,num,rel)) | |
| assert rel < 3e-4 | |
| # 5. Conductive vs dark channels; exact four-dimensional predictions | |
| rows=[] | |
| for theta in (np.pi/2,0.8,0.5,0.2,0.1,0.05,0.01,0.001): | |
| _,_,_,_,_,d=transport(a,theta) | |
| low=d/(1+np.sqrt(1-d)) | |
| high=1+np.sqrt(1-d) | |
| zlow,zhi=impedance(low),impedance(high) | |
| rows.append((theta,d,low,high,zlow,zhi)) | |
| with (HERE/'EVE_QELTHA_results.csv').open('w',newline='',encoding='utf-8') as f: | |
| cw=csv.writer(f) | |
| cw.writerow(['relative_SU2_angle_rad','projective_commutator_delta','lambda_dark', | |
| 'lambda_bright','inlet_impedance_dark','inlet_impedance_bright']) | |
| cw.writerows(rows) | |
| print('Holonomy-controlled impedance (dark eigenchannel):') | |
| for theta,d,l,high,zlo,zhi in rows: | |
| print(' beta=%8.5f delta=%10.7f lam=%12.8f Z=%.6g'% (theta,d,l,zlo)) | |
| # 6. Supercritical asymptotic exponent: p=0.4, n=4 => 1.875. | |
| p4=.4 | |
| alpha_h,nu=geometry(4,p4) | |
| pred=2*(1-nu) | |
| z16=high_precision_log10_impedance(16) | |
| z32=high_precision_log10_impedance(32) | |
| z64=high_precision_log10_impedance(64) | |
| s1=(z32-z16)/16 | |
| s2=(z64-z32)/32 | |
| print('Asymptotic critical exponent prediction: %.9f'%pred) | |
| print(' high-precision effective slopes 1e-16 -> 1e-32: %.9f'%s1) | |
| print(' high-precision effective slopes 1e-32 -> 1e-64: %.9f'%s2) | |
| assert abs(s2-pred)<5e-4 | |
| # 7. Marginal case n=4 p=0.5: Z(b)*b^2*log(1/b)->2*alpha_h/B | |
| p_m=.5 | |
| ah_m,_=geometry(4,p_m) | |
| for exponent in (8,16,32,64): | |
| mp.mp.dps=170 | |
| beta=mp.power(10,-exponent) | |
| lam=1-mp.cos(beta) | |
| kt=mp.sqrt(lam)/mp.mpf(ah_m) | |
| zi=mp.besselk(1,kt)/(mp.sqrt(lam)*mp.besselk(0,kt)) | |
| scaled=zi*beta**2*mp.log(1/beta) | |
| print(' marginal beta=1e-%d, Z*b^2*log(1/b)=%.8f; limit=%.8f' % (exponent,float(scaled),2*ah_m)) | |
| if exponent==64: | |
| assert abs(float(scaled)-2*ah_m) / (2*ah_m) < .05 | |
| print('All tests passed. Wrote:', HERE/'EVE_QELTHA_results.csv') | |
| if __name__=='__main__': | |
| run() | |