research/code/verify_critical.py

#!/usr/bin/env python3
"""Critical rank-one-bright microstructure crossover: numerical verification.

The full three-component pressure problem has one bright direction and two
dark directions. Frequencies 2*pi*n and 4*pi*n are coupled by C_n=r_n S.
At rho=tau*n^2 the candidate/proved accompanying effective potential is
V_tau=S^dagger diag(tau/(tau+omega_j^2)) S, omega_j=2*pi*j.

Diagonal S uses the independently shipped exact constant-transfer algorithm.
Non-diagonal S uses time-dependent short-cell transfer integration and stable
Riccati composition, plus a separate Gaussian-quadrature Cartesian nodal FEM
in the rotating frame. The program checks implementations and limiting
behavior; it does not itself prove the asymptotic theorem or scientific novelty.
"""
from __future__ import annotations

import argparse
import importlib.util
import json
from pathlib import Path

import numpy as np
from numpy.polynomial.legendre import leggauss
from scipy import sparse
from scipy.integrate import solve_ivp
from scipy.linalg import expm
from scipy.sparse.linalg import splu


LENGTH=1.0
OMEGA=2*np.pi*np.arange(1,3,dtype=float)
PI=np.diag([0.,0.,1.]).astype(complex)
DIAGONAL_S=np.diag(np.sqrt([.7,1.8])).astype(complex)
MIXED_S=np.array([[1.,.3],[.3,1.4]],dtype=complex)


def baseline_diagonal_solver():
    """Prefer the unchanged sibling verifier when the release bundles it.

    The embedded implementation below remains a self-contained fallback.
    No workspace-absolute or parent-release path is required.
    """
    filename=Path(__file__).parent/'verify_microstructure.py'
    if not filename.is_file():
        return diagonal_transfer_response
    spec=importlib.util.spec_from_file_location('critical_diagonal_baseline',filename)
    module=importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    spec.loader.exec_module(module)
    return module.full_admittance


def diagonal_transfer_response(n,rho,step_multiplier=1):
    """The read-only release3 constant-transfer algorithm, included locally.

    Keeping this short implementation here makes the verifier self-contained
    when the new release is extracted independently of release3.
    """
    cc=np.sqrt([.7,1.8])[None,:]
    base=np.block([[np.zeros((2,2)),-cc.T],[cc,np.zeros((1,1))]]).astype(complex)
    jj=base+np.diag(-2j*np.pi*n*np.array([1.,2.,0.]))
    op=np.block([[-jj,np.eye(3)],[rho*PI,-jj]])
    cells=step_multiplier*max(100,int(np.ceil(2*np.sqrt(rho))),int(np.ceil(4*np.pi*n)))
    tr=expm(op/cells)
    t11,t12,t21,t22=tr[:3,:3],tr[:3,3:],tr[3:,:3],tr[3:,3:]
    tail=np.linalg.solve(t12,t11)
    for _ in range(cells-1):
        tail=np.linalg.solve(t22+tail@t12,t21+tail@t11)
    response=tail[:2,:2]
    err=float(np.linalg.norm(response-response.conj().T))
    assert err<2e-8
    return (response+response.conj().T)/2,dict(exact_transfer_cells=cells,raw_hermitian_error=err)


def coupling(y,ss):
    row=np.exp(1j*OMEGA*y)[None,:]@ss
    return row


def frame_generator(y,ss):
    cc=coupling(y,ss)
    return np.block([[np.zeros((2,2),complex),-cc.conj().T],
                     [cc,np.zeros((1,1),complex)]])


def effective_potential(ss,tau):
    weights=tau/(tau+OMEGA**2)
    return ss.conj().T@np.diag(weights)@ss


def matrix_target_response(vv):
    ev,uu=np.linalg.eigh(vv)
    ev=np.maximum(0.,ev)
    root=np.sqrt(ev)
    response=np.ones_like(ev)/LENGTH
    np.divide(root,np.tanh(root*LENGTH),out=response,where=root>1e-14)
    return (uu*response[None,:])@uu.conj().T


def serialize_matrix(xx):
    return dict(real_part=xx.real.tolist(),imaginary_part=xx.imag.tolist(),
                eigenvalues=np.linalg.eigvalsh((xx+xx.conj().T)/2).tolist())


def periodic_transfer_response(ss,n,tau,refinement=1):
    """Full model, not the effective 2x2 equation.

    In y=n*x and scaled covariant momentum m=(z_x+K_n z)/n,
    z_y=m-K(y)z/n, m_y=tau*Pi*z-K(y)m/n. Short-cell transfers
    cover one period. Their exact Riccati action is repeated over n periods.
    """
    cells=refinement*max(40,int(np.ceil(4*np.sqrt(tau))))
    widths=1./cells
    transfers=[]
    omega_form=np.block([[np.zeros((3,3)),np.eye(3)],[-np.eye(3),np.zeros((3,3))]])
    max_symplectic=0.
    for j in range(cells):
        lo,hi=j*widths,(j+1)*widths
        def rhs(y,flat):
            kk=frame_generator(y,ss)/n
            op=np.block([[-kk,np.eye(3)],[tau*PI,-kk]])
            return (op@flat.reshape(6,6)).ravel()
        sol=solve_ivp(rhs,(lo,hi),np.eye(6,dtype=complex).ravel(),
                      method='DOP853',rtol=1.5e-12,atol=1e-13)
        if not sol.success:raise RuntimeError(sol.message)
        transfer=sol.y[:,-1].reshape(6,6)
        transfers.append(transfer)
        max_symplectic=max(max_symplectic,float(np.linalg.norm(transfer.conj().T@omega_form@transfer-omega_form)))
    last=transfers[-1]
    tail=np.linalg.solve(last[:3,3:],last[:3,:3])
    for index in range(n*cells-2,-1,-1):
        tr=transfers[index%cells]
        t11,t12,t21,t22=tr[:3,:3],tr[:3,3:],tr[3:,:3],tr[3:,3:]
        tail=np.linalg.solve(t22+tail@t12,t21+tail@t11)
    response=n*tail[:2,:2]
    hermitian=float(np.linalg.norm(response-response.conj().T))
    assert hermitian<2e-8,hermitian
    response=(response+response.conj().T)/2
    return response,dict(period_subcells=cells,total_riccati_cells=n*cells,
                         maximum_cell_symplectic_defect=max_symplectic,
                         raw_hermitian_error=hermitian)


def rotating_frame_fem(ss,n,tau,cells,quadrature=8):
    """Independent original-x energy FEM: ∫|z'+K_n z|²+rho|z_b|²."""
    dim=3;rho=tau*n*n;width=LENGTH/cells
    nodes=np.linspace(0,LENGTH,cells+1)
    pts,wts=leggauss(quadrature)
    local=np.zeros((cells,6,6),complex)
    identity=np.eye(3,dtype=complex)
    for gp,gw in zip(pts,wts):
        phi=np.array([(1-gp)/2,(1+gp)/2])
        locations=nodes[:-1]+width*(gp+1)/2
        kk=np.stack([frame_generator(n*x,ss) for x in locations])
        b1=-identity[None,:,:]/width+phi[0]*kk
        b2= identity[None,:,:]/width+phi[1]*kk
        bb=np.concatenate([b1,b2],axis=2)
        local+=(width*gw/2)*np.einsum('nki,nkj->nij',bb.conj(),bb)
        for a in range(2):
            for b in range(2):
                local[:,a*3:(a+1)*3,b*3:(b+1)*3]+=(width*gw/2)*rho*phi[a]*phi[b]*PI
    ids=3*np.arange(cells)[:,None]+np.arange(6)[None,:]
    rr=np.broadcast_to(ids[:,:,None],local.shape).ravel()
    cc=np.broadcast_to(ids[:,None,:],local.shape).ravel()
    matrix=sparse.coo_matrix((local.ravel(),(rr,cc)),shape=(3*(cells+1),3*(cells+1))).tocsc()
    boundary=np.arange(2)
    free=np.arange(3,3*cells)
    mff=matrix[free,:][:,free].tocsc()
    mfb=matrix[free,:][:,boundary].toarray()
    mbb=matrix[boundary,:][:,boundary].toarray()
    xx=splu(mff).solve(mfb)
    response=mbb-mfb.conj().T@xx
    residual=float(np.linalg.norm(mff@xx-mfb)/max(np.linalg.norm(mfb),1.))
    response=(response+response.conj().T)/2
    return response,residual


def run():
    diagonal_solver=baseline_diagonal_solver()
    cases=[]
    for label,ss in [('diagonal',DIAGONAL_S),('mixed',MIXED_S)]:
        for tau in (10.,40.,160.,640.):
            potential=effective_potential(ss,tau)
            target=matrix_target_response(potential)
            rows=[]
            for n in (4,8,16,32,64):
                if label=='diagonal':
                    response,metrics=diagonal_solver(n,tau*n*n)
                    method='exact constant-transfer baseline reused from release3, included locally'
                else:
                    response,metrics=periodic_transfer_response(ss,n,tau)
                    method='time-dependent periodic short-cell transfer and Riccati composition'
                error=float(np.linalg.norm(response-target)/np.linalg.norm(target))
                rows.append(dict(n=n,penalty=tau*n*n,relative_error_to_effective_response=error,
                                 response=serialize_matrix(response),solver_metrics=metrics))
            assert all(b['relative_error_to_effective_response']<a['relative_error_to_effective_response']
                       for a,b in zip(rows,rows[1:]))
            assert rows[-1]['relative_error_to_effective_response']<.01
            assert rows[-1]['relative_error_to_effective_response']<rows[0]['relative_error_to_effective_response']/8
            cases.append(dict(kind=label,coupling_matrix=serialize_matrix(ss),tau=tau,
                              effective_potential=serialize_matrix(potential),
                              effective_response=serialize_matrix(target),rows=rows,full_solver=method))
    v10=effective_potential(MIXED_S,10.)
    v640=effective_potential(MIXED_S,640.)
    noncommutator=float(np.linalg.norm(v10@v640-v640@v10))
    assert noncommutator>.001
    refinements=[]
    for label,ss in [('diagonal',DIAGONAL_S),('mixed',MIXED_S)]:
        if label=='diagonal':
            coarse,cm=diagonal_solver(64,640*64**2)
            fine,fm=diagonal_solver(64,640*64**2,step_multiplier=2)
        else:
            coarse,cm=periodic_transfer_response(ss,64,640.)
            fine,fm=periodic_transfer_response(ss,64,640.,refinement=2)
        change=float(np.linalg.norm(fine-coarse)/np.linalg.norm(fine))
        assert change<2e-8
        refinements.append(dict(kind=label,n=64,tau=640.,relative_response_change=change,
                                coarse_metrics=cm,fine_metrics=fm))
    reference,_=periodic_transfer_response(MIXED_S,4,40.)
    fem=[]
    for nn in (800,1600,3200):
        hh,res=rotating_frame_fem(MIXED_S,4,40.,nn)
        error=float(np.linalg.norm(hh-reference)/np.linalg.norm(reference))
        fem.append(dict(cells=nn,relative_error_to_periodic_transfer=error,linear_residual=res))
    assert fem[-1]['relative_error_to_periodic_transfer']<1e-5
    assert fem[-1]['relative_error_to_periodic_transfer']<fem[0]['relative_error_to_periodic_transfer']/10
    baseline,metrics=periodic_transfer_response(MIXED_S,16,0.)
    baseline_error=float(np.linalg.norm(baseline-np.eye(2))/np.sqrt(2))
    assert baseline_error<1e-9
    # Inverse design at a finite critical strength: compensate the filter.
    target_w=np.array([[1.1,.25+.12j],[.25-.12j,.8]],dtype=complex)
    vals,vecs=np.linalg.eigh(target_w)
    sqrt_w=(vecs*np.sqrt(vals)[None,:])@vecs.conj().T
    tau_c=40.
    weights=tau_c/(tau_c+OMEGA**2)
    factor=np.diag(1/np.sqrt(weights))@sqrt_w
    identity_error=float(np.linalg.norm(effective_potential(factor,tau_c)-target_w))
    assert identity_error<1e-12
    design_target=matrix_target_response(target_w)
    design_rows=[]
    for n in (8,16,32,64):
        response,metrics=periodic_transfer_response(factor,n,tau_c)
        error=float(np.linalg.norm(response-design_target)/np.linalg.norm(design_target))
        design_rows.append(dict(n=n,penalty=tau_c*n*n,relative_error_to_prescribed_response=error,
                                response=serialize_matrix(response),solver_metrics=metrics))
    assert all(b['relative_error_to_prescribed_response']<a['relative_error_to_prescribed_response']
               for a,b in zip(design_rows,design_rows[1:]))
    assert design_rows[-1]['relative_error_to_prescribed_response']<.01
    compensation=dict(tau=tau_c,prescribed_potential=serialize_matrix(target_w),
              factor_real_part=factor.real.tolist(),factor_imaginary_part=factor.imag.tolist(),
              effective_potential_identity_error=identity_error,
              prescribed_response=serialize_matrix(design_target),rows=design_rows)
    return dict(status='PASS',model='critical crossover, two dark directions and one bright direction',
                interval=[0,LENGTH],frequencies=OMEGA.tolist(),
                effective_potential_formula='S^dagger diag(tau/(tau+omega_j^2)) S',
                effective_boundary_response_formula='sqrt(V_tau)*coth(sqrt(V_tau)*L)',
                cases=cases,mixed_potential_commutator_norm_tau10_tau640=noncommutator,
                transfer_refinements=refinements,independent_mixed_frame_fem=fem,
                zero_penalty_baseline=dict(n=16,relative_error_to_free=baseline_error,metrics=metrics),
                finite_critical_compensation_design=compensation,
                interpretation='Observed convergence and solver consistency support the separately proved model theorem; these numerical tests do not establish scientific priority.')


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--out',type=Path,default=Path(__file__).resolve().parents[1]/'results/critical.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),
            mixed_noncommutator=result['mixed_potential_commutator_norm_tau10_tau640'],
            last_fem_error=result['independent_mixed_frame_fem'][-1]['relative_error_to_periodic_transfer'],
            last_errors=[dict(kind=c['kind'],tau=c['tau'],relative_error=c['rows'][-1]['relative_error_to_effective_response']) for c in result['cases']]),indent=2))


if __name__=='__main__':main()