108 lines
6.5 KiB
Python
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')
|