Files
MeltMind/tools/projector_remesh_probe.py

156 lines
12 KiB
Python

"""Grouped spectral projectors on genuinely different tetra mesh constructions.
No unique axes inside grouped eigenspaces. Scalars remain diagnostic outputs.
The existing 3-hop estimator is intentionally held fixed so its errors are measured.
"""
import argparse
import itertools
import json
from pathlib import Path
import time
import numpy as np
from scipy.spatial import Delaunay,cKDTree
if __package__:
from .route_feasibility import graph_from_edges,node_tensor
else:
from route_feasibility import graph_from_edges,node_tensor
def grouped(tensor,tau=.1):
value,basis=np.linalg.eigh(tensor);value=value[:,::-1];basis=basis[:,:,::-1]
trace=value.sum(1);scale=np.maximum(value[:,0],1e-12);gaps=(value[:,:-1]-value[:,1:])/scale[:,None]
# pattern: split bits between ordered eigenvalues; grouping is sign-free.
code=(gaps[:,0]>tau).astype(np.int8)+2*(gaps[:,1]>tau).astype(np.int8)
unsupported=trace<=1e-10;code[unsupported]=-1
pattern={0:[(0,3)],1:[(0,1),(1,3)],2:[(0,2),(2,3)],3:[(0,1),(1,2),(2,3)]}
projector=np.zeros((len(tensor),3,3,3));mean=np.zeros((len(tensor),3));ratio=np.zeros_like(mean);rank=np.zeros_like(mean,dtype=np.int8)
for c,groups in pattern.items():
ids=np.flatnonzero(code==c)
for j,(a,b) in enumerate(groups):
q=basis[ids,:,a:b];projector[ids,j]=q@q.transpose(0,2,1);mean[ids,j]=value[ids,a:b].mean(1);ratio[ids,j]=value[ids,a:b].sum(1)/trace[ids];rank[ids,j]=b-a
return dict(values=value,ratios=value/np.where(trace>1e-10,trace,1)[:,None],projector=projector,group_mean=mean,group_ratio=ratio,rank=rank,code=code,unsupported=unsupported)
def voxel_mesh(axes,variant,is_t=False):
shape=tuple(len(a) for a in axes);base=np.stack(np.meshgrid(*axes,indexing='ij'),axis=-1).reshape(-1,3);points=list(base);tets=[]
for cell in itertools.product(*(range(n-1) for n in shape)):
low=np.array([axes[i][cell[i]] for i in range(3)]);high=np.array([axes[i][cell[i]+1] for i in range(3)]);center=(low+high)/2
if is_t and not (center[1]<.5 or abs(center[0])<.5):continue
ids={bits:int(np.ravel_multi_index(tuple(np.array(cell)+bits),shape)) for bits in itertools.product([0,1],repeat=3)}
if variant=='six_tets':
for perm in itertools.permutations(range(3)):
b=np.zeros(3,dtype=int);corners=[ids[tuple(b)]]
for axis in perm:b=b.copy();b[axis]+=1;corners.append(ids[tuple(b)])
tets.append(corners)
elif variant=='cell_center_twelve':
center_id=len(points);points.append(center)
for fixed in range(3):
other=[i for i in range(3) if i!=fixed]
for side in [0,1]:
face=[]
for u,v in [(0,0),(1,0),(1,1),(0,1)]:
b=[0,0,0];b[fixed]=side;b[other[0]]=u;b[other[1]]=v;face.append(ids[tuple(b)])
tets.extend([[center_id,face[0],face[1],face[2]],[center_id,face[0],face[2],face[3]]])
else:raise ValueError(variant)
points=np.array(points);tets=np.array(tets);used=np.unique(tets);return points[used],np.searchsorted(used,tets),0
def cylinder_mesh(n,variant):
facets=4*n;theta=np.arange(facets)*2*np.pi/facets;points=[]
for z in np.linspace(0,4,n+1):
points.append([0,0,z])
for r in [.05,.1,.15,.2]:points.extend(np.c_[r*np.cos(theta),r*np.sin(theta),np.full(facets,z)])
if variant=='staggered_interior':
for z in (np.arange(n)+.5)*4/n:
for r in [.025,.075,.125,.175]:points.extend(np.c_[r*np.cos(theta+np.pi/facets),r*np.sin(theta+np.pi/facets),np.full(facets,z)])
x=np.array(points);tet=Delaunay(x).simplices
q=x[tet];vol=np.abs(np.linalg.det(q[:,1:]-q[:,:1]))/6
# Qhull can return exactly coplanar cells in this structured point cloud.
valid=vol>1e-14;removed=int((~valid).sum());tet=tet[valid];used=np.unique(tet)
return x[used],np.searchsorted(used,tet),removed
def geometry(name,n,variant):
if name=='circular_rod':return cylinder_mesh(n,variant)
if name=='T_union':
axes=[np.unique(np.concatenate([np.linspace(a,b,n+1) for a,b in zip(bounds,bounds[1:])])) for bounds in [[-2,-.5,.5,2],[-.5,.5,2],[-.5,.5]]]
return voxel_mesh(axes,variant,True)
size={'plate':[10.,6.,.2],'square_rod':[.2,.2,8.]}[name]
return voxel_mesh([np.linspace(0,l,n+1) for l in size],variant)
def exact_distance(points,name):
if name=='circular_rod':return np.maximum(np.minimum(.2-np.linalg.norm(points[:,:2],axis=1),np.minimum(points[:,2],4-points[:,2])),0)
if name=='T_union':
if __package__:from .validate_distance_extensions import t_union
else:from validate_distance_extensions import t_union
_,rect=t_union(1)
return np.array([np.linalg.norm(x-np.clip(x,rect[:,0],rect[:,1]),axis=1).min() for x in points])
length=np.array({'plate':[10.,6.,.2],'square_rod':[.2,.2,8.]}[name])
return np.maximum(np.minimum(points,length-points).min(1),0)
def compute(points,tet,distance):
q=points[tet];v=np.abs(np.linalg.det(q[:,1:]-q[:,:1]))/6
if np.any(v<=0):raise ValueError('Degenerate retained tetrahedron')
mass=np.bincount(tet.ravel(),weights=np.repeat(v/4,4),minlength=len(points))
edgeids=np.array(list(itertools.combinations(range(4),2)));edges=np.unique(np.sort(tet[:,edgeids].reshape(-1,2),axis=1),axis=0)
g=graph_from_edges(len(points),edges,np.linalg.norm(points[edges[:,0]]-points[edges[:,1]],axis=1))
tensor,_,_=node_tensor(points,tet,mass,distance,g)
return tensor,mass,float(v.sum())
def coverage(f,mass):
return dict(unsupported_volume=float(mass[f['code']==-1].sum()/mass.sum()),isotropic_group_volume=float(mass[f['code']==0].sum()/mass.sum()),normal_plus_plane_volume=float(mass[f['code']==1].sum()/mass.sum()),plane_plus_axis_volume=float(mass[f['code']==2].sum()/mass.sum()),three_singletons_volume=float(mass[f['code']==3].sum()/mass.sum()),failure_definition='unsupported OR isotropic group has no identifiable directional projector; three singletons is NOT proof of physical identifiability')
def main():
p=argparse.ArgumentParser();p.add_argument('output',type=Path);a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
target=a.output/'remesh_projectors.json'
if target.exists():raise FileExistsError(target)
contract=dict(primary_gap_threshold=.1,sensitivity_thresholds=[.05,.25],estimator='Existing exact-distance-at-vertices -> tetra gradients -> volume-normalized structure tensor -> 3-hop volume-weighted smoothing. Held unchanged.',emit='Grouped projectors and rank/validity flags only; eigenvalues and ratios are diagnostic, not approved network inputs.',scope='Analytic plate, square rod, circular rod and T union; common spatial vertices. Two genuinely different interior tetra constructions, same boundary geometry within each pair. No new v5 mesh or training.')
(a.output/'projector_contract.json').write_text(json.dumps(contract,indent=2)+'\n')
start=time.monotonic();rows=[]
for name,levels in [('plate',[4,8,12]),('square_rod',[4,8,12]),('circular_rod',[4,8,12]),('T_union',[2,4,6])]:
for n in levels:
variants=['radial_delaunay','staggered_interior'] if name=='circular_rod' else ['six_tets','cell_center_twelve']
meshes=[]
for variant in variants:
x,tet,removed=geometry(name,n,variant);tensor,mass,volume=compute(x,tet,exact_distance(x,name));meshes.append((x,tet,tensor,mass,volume,removed))
x1,tet1,t1,m1,v1,removed1=meshes[0];x2,tet2,t2,m2,v2,removed2=meshes[1]
error,index=cKDTree(x2).query(x1);shared=error<1e-10
if not shared.all():raise ValueError('Missing common query vertices')
if not np.isclose(v1,v2,rtol=1e-10,atol=1e-12):raise ValueError('Different volume domains')
row=dict(shape=name,resolution=n,variants=variants,nodes=[len(x1),len(x2)],tets=[len(tet1),len(tet2)],volumes=[v1,v2],removed_degenerate_tets=[removed1,removed2],common_queries=len(x1),raw_tensor_max_abs_error=float(abs(t1-t2[index]).max()),thresholds={})
for tau in [.1,.05,.25]:
f1=grouped(t1,tau);f2=grouped(t2,tau);same=(f1['code']==f2['code'][index])&(f1['code']>=0)
projector_errors=np.linalg.norm(f1['projector'][same]-f2['projector'][index[same]],axis=(2,3)).max(1) if same.any() else np.array([])
scalars=abs(f1['group_mean'][same]-f2['group_mean'][index[same]])
ratios=abs(f1['group_ratio'][same]-f2['group_ratio'][index[same]])
worst=np.flatnonzero(same)[np.argsort(projector_errors)[-5:]] if same.any() else np.array([],int)
row['thresholds'][str(tau)]=dict(coverage_A=coverage(f1,m1),coverage_B=coverage(f2,m2),pattern_mismatch_query_fraction=float((f1['code']!=f2['code'][index]).mean()),same_supported_pattern_queries=int(same.sum()),projector_frobenius_max=float(projector_errors.max()) if same.any() else None,projector_frobenius_p95=float(np.quantile(projector_errors,.95)) if same.any() else None,group_eigenvalue_mean_max_abs_error=float(scalars.max()) if same.any() else None,group_normalized_mass_max_abs_error=float(ratios.max()) if same.any() else None,all_queries_sorted_eigenvalue_max_abs_error=float(abs(f1['values']-f2['values'][index]).max()),all_queries_sorted_normalized_eigenvalue_max_abs_error=float(abs(f1['ratios']-f2['ratios'][index]).max()),worst_same_pattern_positions=x1[worst].tolist(),unsupported_or_isotropic_positions_A=x1[np.flatnonzero(f1['code']<=0)[:8]].tolist(),comparison_scope='Group-specific errors conditional on same grouping; mismatch fraction is separately mandatory. Coverage is per-mesh volume; pair errors are common-node statistics, not volume-integrated errors.')
by_pattern={}
for code,label in [(1,'normal_plus_plane'),(2,'plane_plus_axis'),(3,'three_singletons')]:
selected=same&(f1['code']==code)
if selected.any():
pe=np.linalg.norm(f1['projector'][selected]-f2['projector'][index[selected]],axis=(2,3)).max(1)
by_pattern[label]=dict(queries=int(selected.sum()),projector_frobenius_max=float(pe.max()),projector_frobenius_p95=float(np.quantile(pe,.95)),group_mean_max_error=float(abs(f1['group_mean'][selected]-f2['group_mean'][index[selected]]).max()),group_ratio_max_error=float(abs(f1['group_ratio'][selected]-f2['group_ratio'][index[selected]]).max()))
else:by_pattern[label]=dict(queries=0)
row['thresholds'][str(tau)]['by_pattern']=by_pattern
center={'plate':[5.,3.,.1],'square_rod':[.1,.1,4.],'circular_rod':[0.,0.,2.],'T_union':[0.,.5,0.]}[name]
i=int(np.argmin(np.linalg.norm(x1-np.array(center),axis=1)));j=int(index[i]);vA,bA=np.linalg.eigh(t1[i]);vB,bB=np.linalg.eigh(t2[j])
center_record=dict(query=x1[i].tolist(),tensor_A=t1[i].tolist(),tensor_B=t2[j].tolist(),eigenvalues_A=vA.tolist(),eigenvalues_B=vB.tolist(),eigenvalue_max_difference=float(abs(vA-vB).max()),normalized_eigenvalue_max_difference=float(abs(vA/vA.sum()-vB/vB.sum()).max()))
if name!='T_union':
axis=-1 if name=='plate' else 0;PA=np.outer(bA[:,axis],bA[:,axis]);PB=np.outer(bB[:,axis],bB[:,axis]);ideal=np.diag([0.,0.,1.])
center_record.update(oracle_axis_projector_difference=float(np.linalg.norm(PA-PB)),oracle_axis_error_A=float(np.linalg.norm(PA-ideal)),oracle_axis_error_B=float(np.linalg.norm(PB-ideal)),scope='Geometrically known axis at this analytic point; diagnostic only, not an axis forced into the gap-grouped feature output')
row['analytic_center']=center_record
rows.append(row);print(name,n,'primary mismatch',row['thresholds']['0.1']['pattern_mismatch_query_fraction'],'Pmax',row['thresholds']['0.1']['projector_frobenius_max'],flush=True)
# Largest real part: new grouping only, no claim of a second mesh.
old=Path('artifacts/routes-2026-11-13');a_path=next(old.glob('00000666*.route_arrays.npz'));old_data=np.load(a_path)
d=np.load(Path('artifacts/intake-2026-11-13/samples')/a_path.name.replace('.route_arrays.npz','.npz'));f=grouped(old_data['tensor'],.1)
largest=dict(case=a_path.stem,coverage=coverage(f,d['node_volume_raw']),remesh_comparison='NOT_AVAILABLE_single_exported_mesh; reused cached tensor only')
result=dict(contract=contract,rows=rows,largest_v5=largest,wall_seconds=time.monotonic()-start,acceptance='No projector/scalar remesh tolerance frozen; numeric diagnostics do not approve scalar features.')
target.write_text(json.dumps(result,indent=2)+'\n');print('Done',result['wall_seconds'],flush=True)
if __name__=='__main__':main()