Files
MeltMind/tools/phase2_b6_math.py

108 lines
6.5 KiB
Python

"""FP64 volume-P1 Neumann truncated HKS and weighted partial correlation."""
import numpy as np
from scipy import linalg,sparse
from scipy.sparse.csgraph import connected_components
from scipy.sparse.linalg import LinearOperator,eigsh,splu
CLUSTER_TOL=1e-6
RESIDUAL_TOL=1e-5
ORTHOGONAL_TOL=1e-7
def assemble(points,tetra):
x=np.asarray(points,dtype=np.float64);t=np.asarray(tetra,dtype=np.int64);n=len(x)
if x.ndim!=2 or x.shape[1]!=3 or t.ndim!=2 or t.shape[1]!=4 or not len(t) or not np.isfinite(x).all():raise ValueError('INVALID_MESH')
if t.min()<0 or t.max()>=n:raise ValueError('MESH_INDEX')
K=sparse.csr_matrix((n,n));mass=np.zeros(n)
for start in range(0,len(t),16384):
ids=t[start:start+16384];v=x[ids];J=np.transpose(v[:,1:]-v[:,0,None],(0,2,1));det=np.linalg.det(J)
if not np.isfinite(det).all() or np.any(det==0):raise ValueError('DEGENERATE_TET')
volume=np.abs(det)/6;inv=np.linalg.inv(J);grad=np.concatenate([-inv.sum(axis=1)[:,None,:],inv],axis=1)
ke=volume[:,None,None]*np.einsum('eik,ejk->eij',grad,grad)
K+=sparse.coo_matrix((ke.ravel(),(np.repeat(ids,4,axis=1).ravel(),np.tile(ids,(1,4)).ravel())),shape=(n,n)).tocsr()
np.add.at(mass,ids.ravel(),np.repeat(volume/4,4))
if not np.isfinite(mass).all() or np.any(mass<=0):raise ValueError('NONPOSITIVE_MASS')
# Topology from original tetra membership, never sparsity cancellation in K.
edge=np.concatenate([t[:,[0,1]],t[:,[0,2]],t[:,[0,3]]])
adj=sparse.coo_matrix((np.ones(len(edge)),(edge[:,0],edge[:,1])),shape=(n,n)).tocsr()
nc,labels=connected_components(adj,directed=False)
return K,mass,labels,nc
def truncate(values,exhausted):
values=np.asarray(values)
if not len(values) or np.any(values<=0) or np.any(np.diff(values)<0):raise ValueError('INVALID_POSITIVE_SPECTRUM')
end=min(8,len(values))
while end<len(values) and (values[end]-values[end-1])/max(values[end],values[end-1])<=CLUSTER_TOL:end+=1
if end==len(values) and not exhausted:raise ValueError('UNCONFIRMED_CLUSTER_BOUNDARY')
return end
def component_modes(K,mass):
n=len(mass);d=1/np.sqrt(mass);A=sparse.diags(d)@K@sparse.diags(d)
z=np.sqrt(mass/mass.sum());available=n-1
if available<=0:raise ValueError('NO_POSITIVE_MODES')
if n<=256:
vals,q=linalg.eigh(A.toarray());zero=int(np.argmax(np.abs(q.T@z)))
keep=np.arange(n)!=zero;q=q[:,keep];vals=vals[keep];exhausted=True
else:
# The inverse acts only in the exact physical zero mode's complement.
# No small-positive eigenvalue is removed by an absolute cutoff.
shift=float(np.median(A.diagonal()))*1e-6
if shift<=0:raise ValueError('INVALID_OPERATOR_SCALE')
factor=splu((K+sparse.diags(shift*mass)).tocsc());sqrtm=np.sqrt(mass)
def project(v):return v-z*(z@v)
def mv(v):return project(sqrtm*factor.solve(sqrtm*project(v)))
op=LinearOperator((n,n),matvec=mv,dtype=np.float64)
initial=project(np.random.default_rng(2026111706).normal(size=n));initial/=np.linalg.norm(initial)
_,q=eigsh(op,k=16,which='LA',v0=initial,tol=1e-10,maxiter=2000,ncv=48)
q=q-z[:,None]*(z@q)[None,:]
q,_=np.linalg.qr(q,mode='reduced')
vals,rotation=linalg.eigh(q.T@(A@q));q=q@rotation;exhausted=False
order=np.argsort(vals);vals=vals[order];q=q[:,order];phi=d[:,None]*q
kp=K@phi;mp=mass[:,None]*phi;err=np.linalg.norm(kp-mp*vals,axis=0)/(np.linalg.norm(kp,axis=0)+np.abs(vals)*np.linalg.norm(mp,axis=0))
orth=float(np.linalg.norm(phi.T@mp-np.eye(len(vals))))
zero_error=float(np.linalg.norm(K@np.ones(n))/(np.linalg.norm(K.data)*np.sqrt(n)))
if not np.isfinite(vals).all() or np.any(vals<=0) or not np.isfinite(err).all() or np.max(err)>RESIDUAL_TOL or orth>ORTHOGONAL_TOL or zero_error>1e-10:raise ValueError('SPECTRAL_ACCEPTANCE_FAILURE')
return vals,phi,dict(exhausted=exhausted,residuals=err.tolist(),orthogonality_error=orth,zero_error=zero_error,positive_modes=len(vals))
def hks(points,tetra):
K,mass,labels,nc=assemble(points,tetra);modes=[];diagnostics=[];zero=np.zeros(len(mass));all_complete=True
for component in range(nc):
ids=np.flatnonzero(labels==component);m=mass[ids];zero[ids]=1/m.sum()
values,phi,report=component_modes(K[ids][:,ids],m)
diagnostics.append(dict(component=component,nodes=len(ids),mass=float(m.sum()),**report))
all_complete=all_complete and report['exhausted']
for j,v in enumerate(values):modes.append((float(v),component,j))
diagnostics[-1]['_ids']=ids;diagnostics[-1]['_phi']=phi
modes.sort();values=np.array([v[0] for v in modes]);end=truncate(values,all_complete)
# Each unexhausted component must have a witnessed root beyond the global cut.
for g,r in enumerate(diagnostics):
if not r['exhausted'] and max(v[0] for v in modes if v[1]==g)<=values[end-1]:raise ValueError('UNCONFIRMED_COMPONENT_SPECTRUM')
times=np.array([.1,1.,10.])/values[0];H=np.repeat(zero[:,None],3,axis=1)
for value,g,j in modes[:end]:
r=diagnostics[g];H[r['_ids']]+=r['_phi'][:,j,None]**2*np.exp(-value*times)[None,:]
for r in diagnostics:del r['_ids'],r['_phi']
if not np.isfinite(H).all():raise ValueError('NONFINITE_HKS')
return H,dict(physical_components=nc,components=diagnostics,positive_modes_retained=end,positive_values=values[:end].tolist(),
next_eigenvalue=float(values[end]) if end<len(values) else None,spectrum_exhausted=all_complete,times=times.tolist(),zero_modes=nc,
mass_sum=float(mass.sum()),cluster_relative_tolerance=CLUSTER_TOL,normalization='Phi^T M Phi=I; exact physical component zero modes')
def partial_from_triangular(R):
# R is the TSQR factor of sqrt(w)*[1,X19,y,H3]. Orthogonal left transforms
# preserve all projections and inner products, avoiding a dense full corpus.
X=R[:,:20];Z=R[:,20:];u,s,v=linalg.svd(X,full_matrices=False)
cutoff=np.finfo(float).eps*max(X.shape)*s[0];rank=int(np.sum(s>cutoff));res=Z-u[:,:rank]@(u[:,:rank].T@Z)
norms=np.linalg.norm(res,axis=0);original=np.linalg.norm(Z,axis=0);out=[]
for j in range(1,4):
if norms[0]<=1e-10*max(original[0],1.) or norms[j]<=1e-10*max(original[j],1.):out.append(None)
else:out.append(float(np.clip(res[:,0]@res[:,j]/(norms[0]*norms[j]),-1,1)))
return dict(signed_r=out,design_rank=rank,design_singular_values=s.tolist(),residual_norms=norms.tolist(),undefined=[j for j,r in enumerate(out) if r is None])
def tsqr_update(R,block):
local=np.linalg.qr(block,mode='r')
return local if R is None else np.linalg.qr(np.vstack([R,local]),mode='r')