Datasets:
Formats:
csv
Languages:
English
Size:
< 1K
Tags:
mathematics
homogenization
spectral-theory
variational-methods
matrix-analysis
scientific-computing
| #!/usr/bin/env python3 | |
| """Rank-one-bright microstructure: noncommuting large-penalty/fast-scale limits. | |
| An exact unitary phase transform reduces the full three-component model to a | |
| constant-coefficient boundary-value problem. Exact short-cell transfers and | |
| stable Riccati composition avoid growing matrix-exponential shooting. | |
| Local projectors are evaluated independently by | |
| stable unitary spectral decomposition. These are numerical checks of the | |
| specified mathematical model, not a priority or physical-realization claim. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| from scipy.integrate import solve_bvp | |
| from scipy.linalg import expm | |
| LENGTH=1.0 | |
| EIGENVALUES=np.array([.7,1.8]) | |
| BRIGHT=np.diag([0.,0.,1.]) | |
| def frame_generator(n): | |
| ss=np.sqrt(EIGENVALUES) | |
| cc=ss[None,:] | |
| base=np.block([[np.zeros((2,2)), -cc.T], | |
| [cc,np.zeros((1,1))]]).astype(complex) | |
| frequencies=2*np.pi*n*np.array([1.,2.,0.]) | |
| omega=np.diag(-1j*frequencies) | |
| return base+omega,base,omega | |
| def unitary_motion(jj,tt,vectors,sign=1.): | |
| """exp(sign*t*J) vectors; J skew Hermitian, using a Hermitian eigensolve.""" | |
| ev,uu=np.linalg.eigh(1j*jj) | |
| coeff=uu.conj().T@vectors | |
| # Return (dim, vector-column, time). | |
| phases=np.exp(-1j*sign*ev[:,None]*np.asarray(tt)[None,:]) | |
| return np.einsum('ab,bct->act',uu,coeff[:,:,None]*phases[:,None,:]) | |
| def projector_checks(n,samples=5001): | |
| jj,base,omega=frame_generator(n) | |
| tt=np.linspace(0,LENGTH,samples) | |
| bright=unitary_motion(jj,tt,np.eye(3)[:,2:])[:,0,:] | |
| overlap=np.abs(bright[2])**2 | |
| opdist=np.sqrt(np.maximum(0.,1-overlap)) | |
| # At test positions check full frame ODE and projector characteristic data. | |
| specerr=0.;odeerr=0.;uniterr=0. | |
| for t in np.linspace(0,LENGTH,41): | |
| unit=unitary_motion(jj,[t],np.eye(3))[:,:,0] | |
| phase=np.diag(np.exp(-np.diag(omega)*t)) | |
| frame=unit@phase | |
| phase_inverse=phase.conj().T | |
| k=phase_inverse@base@phase | |
| derivative=unit@(jj-omega)@phase | |
| odeerr=max(odeerr,float(np.linalg.norm(derivative-frame@k))) | |
| uniterr=max(uniterr,float(np.linalg.norm(frame.conj().T@frame-np.eye(3)))) | |
| bb=frame[:,2] | |
| mm=np.outer(bb,bb.conj()) | |
| specerr=max(specerr,float(np.max(abs(np.linalg.eigvalsh(mm)-[0,0,1])))) | |
| assert max(specerr,odeerr,uniterr)<1e-10 | |
| return dict(n=n,samples=samples,sampled_sup_projector_operator_distance=float(np.max(opdist)), | |
| n_times_sampled_sup_distance=float(n*np.max(opdist)), | |
| projector_spectrum_error=specerr,frame_ode_identity_error=odeerr, | |
| frame_unitarity_error=uniterr) | |
| def full_admittance(n,rho,step_multiplier=1): | |
| """Exact constant-transfer invariant embedding; no growing global shoot. | |
| The transfer is computed on a short cell and composed by its exact | |
| Riccati fractional-linear map. Step doubling changes only numerical | |
| roundoff and matrix-exponential conditioning, not a spatial discretization. | |
| """ | |
| jj,_,_=frame_generator(n) | |
| op=np.block([[-jj,np.eye(3)],[rho*BRIGHT,-jj]]) | |
| steps=step_multiplier*max(100,int(np.ceil(2*np.sqrt(rho)*LENGTH)), | |
| int(np.ceil(4*np.pi*n*LENGTH))) | |
| h=LENGTH/steps | |
| transfer=expm(op*h) | |
| t11,t12,t21,t22=transfer[:3,:3],transfer[:3,3:],transfer[3:,:3],transfer[3:,3:] | |
| tail=np.linalg.solve(t12,t11) | |
| for _ in range(steps-1): | |
| tail=np.linalg.solve(t22+tail@t12,t21+tail@t11) | |
| response=tail[:2,:2] | |
| hermitian_error=float(np.linalg.norm(response-response.conj().T)) | |
| assert hermitian_error<2e-6,hermitian_error | |
| response=(response+response.conj().T)/2 | |
| return response,dict(exact_transfer_cells=steps, | |
| raw_hermitian_error=hermitian_error, | |
| cell_transfer_symplectic_defect=float(np.linalg.norm( | |
| transfer.conj().T@np.block([[np.zeros((3,3)),np.eye(3)],[-np.eye(3),np.zeros((3,3))]])@transfer | |
| -np.block([[np.zeros((3,3)),np.eye(3)],[-np.eye(3),np.zeros((3,3))]])))) | |
| def constrained_admittance(n,tolerance=3e-9): | |
| """Independent target ODE with oscillatory geometric matrix potential.""" | |
| count=max(120,48*n) | |
| tt=np.linspace(0,LENGTH,count+1) | |
| response=np.zeros((2,2),complex) | |
| maxres=0. | |
| for col in range(2): | |
| initial=np.eye(2)[:,col] | |
| complex_guess=np.vstack([(1-tt)[None,:]*initial[:,None], | |
| -np.ones_like(tt)[None,:]*initial[:,None]]).astype(complex) | |
| guess=np.vstack([complex_guess.real,complex_guess.imag]) | |
| def rhs(t,y): | |
| c=np.sqrt(EIGENVALUES)[:,None]*np.exp(2j*np.pi*n*np.arange(1,3)[:,None]*t[None,:]) | |
| pot=np.einsum('it,jt->ijt',c.conj(),c) | |
| yc=y[:4]+1j*y[4:] | |
| value=np.vstack([yc[2:],np.einsum('ijt,jt->it',pot,yc[:2])]) | |
| return np.vstack([value.real,value.imag]) | |
| def bc(left,right): | |
| lc=left[:4]+1j*left[4:] | |
| rc=right[:4]+1j*right[4:] | |
| residual=np.r_[lc[:2]-initial,rc[:2]] | |
| return np.r_[residual.real,residual.imag] | |
| sol=solve_bvp(rhs,bc,tt,guess,tol=tolerance,max_nodes=30000) | |
| if not sol.success:raise RuntimeError(sol.message) | |
| complex_solution=sol.y[:4]+1j*sol.y[4:] | |
| response[:,col]=-complex_solution[2:,0] | |
| maxres=max(maxres,float(np.max(sol.rms_residuals))) | |
| err=np.linalg.norm(response-response.conj().T) | |
| assert err<1e-7 | |
| return (response+response.conj().T)/2,maxres | |
| def matrix_parts(hh): | |
| return dict(real_part=hh.real.tolist(),imaginary_part=hh.imag.tolist(), | |
| eigenvalues=np.linalg.eigvalsh(hh).tolist()) | |
| def run(): | |
| target=np.diag(np.sqrt(EIGENVALUES)/np.tanh(np.sqrt(EIGENVALUES)*LENGTH)) | |
| free=np.eye(2)/LENGTH | |
| rows=[] | |
| for n in (2,4,8,16): | |
| projection=projector_checks(n) | |
| strongrho=float((2*np.pi*n)**4) | |
| constrained,cr=constrained_admittance(n) | |
| weak,wr=full_admittance(n,1.) | |
| subcritical,subr=full_admittance(n,float(n)) | |
| strong,sr=full_admittance(n,strongrho) | |
| row=dict(n=n,projector=projection, | |
| fixed_penalty=dict(penalty=1.,relative_distance_to_free=float(np.linalg.norm(weak-free)/np.linalg.norm(free)), | |
| **matrix_parts(weak),**wr), | |
| joint_weak_penalty=dict(penalty=float(n),relative_distance_to_free=float(np.linalg.norm(subcritical-free)/np.linalg.norm(free)), | |
| **matrix_parts(subcritical),**subr), | |
| strong_penalty=dict(penalty=strongrho,relative_distance_to_target=float(np.linalg.norm(strong-target)/np.linalg.norm(target)), | |
| relative_distance_to_oscillatory_constrained=float(np.linalg.norm(strong-constrained)/np.linalg.norm(constrained)), | |
| **matrix_parts(strong),**sr), | |
| constrained=dict(relative_distance_to_target=float(np.linalg.norm(constrained-target)/np.linalg.norm(target)), | |
| maximum_rms_residual=cr,**matrix_parts(constrained))) | |
| rows.append(row) | |
| assert all(b['projector']['sampled_sup_projector_operator_distance']<a['projector']['sampled_sup_projector_operator_distance'] | |
| for a,b in zip(rows,rows[1:])) | |
| assert rows[-1]['fixed_penalty']['relative_distance_to_free']<rows[0]['fixed_penalty']['relative_distance_to_free']/20 | |
| assert rows[-1]['strong_penalty']['relative_distance_to_target']<rows[0]['strong_penalty']['relative_distance_to_target']/3 | |
| assert rows[-1]['strong_penalty']['relative_distance_to_oscillatory_constrained']<.001 | |
| assert rows[-1]['joint_weak_penalty']['relative_distance_to_free']<rows[0]['joint_weak_penalty']['relative_distance_to_free']/5 | |
| # A zero-penalty gauge-invariance baseline. | |
| hh,baseline=full_admittance(4,0.) | |
| baseline['relative_error_to_free']=float(np.linalg.norm(hh-free)/np.linalg.norm(free)) | |
| assert baseline['relative_error_to_free']<1e-7 | |
| refinements=[] | |
| for rho in (1.,float((2*np.pi*16)**4)): | |
| coarse,cc=full_admittance(16,rho) | |
| fine,fc=full_admittance(16,rho,step_multiplier=2) | |
| change=float(np.linalg.norm(fine-coarse)/np.linalg.norm(fine)) | |
| assert change<2e-8 | |
| refinements.append(dict(n=16,penalty=rho,coarse_cells=cc['exact_transfer_cells'], | |
| fine_cells=fc['exact_transfer_cells'],relative_response_change=change)) | |
| return dict(status='PASS',model='two dark directions, one bright direction, phase-engineered unitary frame', | |
| interval=[0,LENGTH],target_potential_eigenvalues=EIGENVALUES.tolist(), | |
| predicted_iterated_strong_limit=matrix_parts(target),predicted_reversed_limit=matrix_parts(free), | |
| rows=rows,zero_penalty_gauge_baseline=baseline,transfer_step_doubling=refinements, | |
| strong_penalty_sequence='rho_n=(2*pi*n)^4', | |
| full_solver='exact constant-cell transfer and stable 3x3 Riccati composition after exact phase transform', | |
| target_solver='independent oscillatory 2-component constrained BVP', | |
| limitations='Sampled projector distances and numerical boundary solves are evidence; uniform convergence and limit order are mathematical claims requiring the accompanying proof.') | |
| def main(): | |
| parser=argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument('--out',type=Path,default=Path(__file__).resolve().parents[1]/'results/microstructure.json') | |
| args=parser.parse_args() | |
| result=run() | |
| args.out.parent.mkdir(parents=True,exist_ok=True) | |
| args.out.write_text(json.dumps(result,indent=2)+'\n',encoding='utf-8') | |
| print(json.dumps(dict(status=result['status'],output=str(args.out),last=result['rows'][-1]),indent=2)) | |
| if __name__=='__main__':main() | |