research/code/verify_microstructure.py

#!/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()