"""Frozen O2-A: six new estimates and two source-verified reused estimates. No reference integration, optimization, training, or change of numerical gates. """ import argparse import csv import hashlib import json import os from pathlib import Path import resource import time import numpy as np from scipy.spatial import cKDTree if __package__: from .run_volume_quadrature_trial import initial_field, volume_samples, integrate, region_masks from .projector_remesh_probe import voxel_mesh, grouped from .analyze_support_capacity_conditions import center_oracle else: from run_volume_quadrature_trial import initial_field, volume_samples, integrate, region_masks from projector_remesh_probe import voxel_mesh, grouped from analyze_support_capacity_conditions import center_oracle MIRROR = np.diag([-1., 1., 1.]) RULES = ('lumped_vertex', 'tetra_four_point') def sha(path): return hashlib.sha256(Path(path).read_bytes()).hexdigest() def write_json(path, value): Path(path).write_text(json.dumps(value, indent=2, allow_nan=False)+'\n') def stats(values): v = np.asarray(values) return dict(count=int(v.size), minimum=float(v.min()) if v.size else None, median=float(np.median(v)) if v.size else None, p95=float(np.quantile(v, .95)) if v.size else None, maximum=float(v.max()) if v.size else None) def mirror_points(points): return points @ MIRROR + np.array([.2, 0., 0.]) def mirror_map(anchors): distances, ids = cKDTree(anchors).query(mirror_points(anchors)) if distances.max() > 1e-10 or len(np.unique(ids)) != len(ids): raise ValueError('Mirror does not bijectively map fixed anchors') return ids def mesh(nx, mirrored): x, tet, _ = voxel_mesh([np.linspace(0, .2, nx+1), np.linspace(0, .2, nx+1), np.linspace(0, 8, 49)], 'six_tets') return (mirror_points(x) if mirrored else x), tet def diagnostics(tensor): val, vec = np.linalg.eigh(tensor) scale = np.maximum(val[:, 2], 1e-12) gaps = np.stack(((val[:, 2]-val[:, 1])/scale, (val[:, 1]-val[:, 0])/scale), axis=1) axis = vec[:, :, 0] axis_p = axis[:, :, None]*axis[:, None, :] planar = np.linalg.eigvalsh(tensor[:, :2, :2]) signed = np.stack((tensor[:, 0, 0]-tensor[:, 1, 1], 2*tensor[:, 0, 1]), axis=1) return dict(eigenvalues_descending=val[:, ::-1], normalized_gaps=gaps, split=val[:, 2]-val[:, 1], xy_split=planar[:, 1]-planar[:, 0], signed=signed, axis_projector=axis_p, axis_eligible=(val.sum(1)>1e-10)&(gaps[:, 1]>.1), axis_error=np.linalg.norm(axis_p-np.diag([0., 0., 1.]), axis=(1, 2))) def pair_summary(a, b, masks): da, db = diagnostics(a['tensor']), diagnostics(b['tensor']) fa, fb = grouped(a['tensor'], .1), grouped(b['tensor'], .1) qa, qb = a['support_resolved'] & a['quadrature_quality'], b['support_resolved'] & b['quadrature_quality'] both = qa & qb same = fa['code'] == fb['code'] grouped_ok = both & same & np.isin(fa['code'], [1, 2]) axis_ok = both & da['axis_eligible'] & db['axis_eligible'] pe = np.linalg.norm(fa['projector']-fb['projector'], axis=(2, 3)).max(1) ae = np.linalg.norm(da['axis_projector']-db['axis_projector'], axis=(1, 2)) result = {} for name, m in masks.items(): result[name] = dict(N=int(m.sum()), support_quality_A=int((m & qa).sum()), support_quality_B=int((m & qb).sum()), support_quality_both=int((m & both).sum()), all_mode_flips=int((m & ~same).sum()), qualified_mode_flips=int((m & both & ~same).sum()), grouped_projector_difference=stats(pe[m & grouped_ok]), axis_and_complement_plane_projector_difference=stats(ae[m & axis_ok]), all_tensor_difference=stats(np.linalg.norm(a['tensor']-b['tensor'], axis=(1, 2))[m])) return result def analyze(out, contract): anchors = np.load(out/'fixed_anchors.npz')['query'] masks = region_masks(anchors) center = np.flatnonzero(np.linalg.norm(anchors-[.1,.1,4.], axis=1)<1e-12) assert len(center)==1 c = int(center[0]); masks['center'] = np.arange(len(anchors))==c estimates, arrays, regional_rows, endpoint_rows, center_rows = {}, {}, [], [], [] for spec in contract['estimates']: name = spec['name'] a = dict(np.load(out/(name+'.npz'))); arrays[name] = a assert np.array_equal(a['query'], anchors) d = diagnostics(a['tensor']); f = grouped(a['tensor'], .1) assert np.array_equal(a['mode'], f['code']) qa = a['support_resolved'] & a['quadrature_quality'] regions = {} for region, mask in masks.items(): entry = dict(N=int(mask.sum()), support=int((mask&a['support_resolved']).sum()), quality=int((mask&a['quadrature_quality']).sum()), both=int((mask&qa).sum()), axis_eligible_and_both=int((mask&qa&d['axis_eligible']).sum()), mode_counts={str(k):int((mask&(f['code']==k)).sum()) for k in [-1,0,1,2,3]}, full_spectral_split=stats(d['split'][mask]), xy_block_split=stats(d['xy_split'][mask]), axis_projector_error=stats(d['axis_error'][mask&qa&d['axis_eligible']]), kernel_mass_relative_error=stats(a['relative_kernel_mass_error'][mask]), effective_layers=stats(a['effective_axial_layers'][mask])) regions[region] = entry regional_rows.append(dict(estimate=name, region=region, N=entry['N'], support=entry['support'], quality=entry['quality'], both=entry['both'], split_median=entry['full_spectral_split']['median'], split_p95=entry['full_spectral_split']['p95'], xy_split_median=entry['xy_block_split']['median'], xy_split_p95=entry['xy_block_split']['p95'], axis_valid_N=entry['axis_eligible_and_both'], axis_P95=entry['axis_projector_error']['p95'])) oracle, _ = center_oracle(a['tensor'][c]) t = a['tensor'][c] decomposition = dict(planar_mean_bias_squared=float(2*(np.trace(t[:2,:2])/2-.5)**2), planar_split_squared_over_two=float(d['xy_split'][c]**2/2), axial_squared=float(t[2,2]**2), cross_squared=float(2*np.sum(t[:2,2]**2))) assert np.isclose(sum(decomposition.values()), oracle['tensor_frobenius_error_to_analytic']**2, atol=1e-14) oracle.update(full_spectral_split=float(d['split'][c]), xy_block_split=float(d['xy_split'][c]), signed_anisotropy=d['signed'][c].tolist(), tensor=t.tolist(), frobenius_squared_decomposition=decomposition) center_rows.append(dict(estimate=name, split=oracle['full_spectral_split'], xy_split=oracle['xy_block_split'], frobenius=oracle['tensor_frobenius_error_to_analytic'], axis_error=oracle['axis_projector_error_to_analytic'], Txx_minus_Tyy=float(d['signed'][c,0]), two_Txy=float(d['signed'][c,1]))) ends = masks['end'] endpoint = dict(eigenvalues_descending=[stats(d['eigenvalues_descending'][ends,i]) for i in range(3)], normalized_gaps=[stats(d['normalized_gaps'][ends,i]) for i in range(2)], support_quality=regions['end']) for i in np.flatnonzero(ends): endpoint_rows.append(dict(estimate=name, anchor=int(i), x=float(anchors[i,0]), y=float(anchors[i,1]), z=float(anchors[i,2]), lambda1=float(d['eigenvalues_descending'][i,0]), lambda2=float(d['eigenvalues_descending'][i,1]), lambda3=float(d['eigenvalues_descending'][i,2]), gap12=float(d['normalized_gaps'][i,0]), gap23=float(d['normalized_gaps'][i,1]), support=bool(a['support_resolved'][i]), quality=bool(a['quadrature_quality'][i]), mode=int(f['code'][i]))) np.savez_compressed(out/(name+'_diagnostics.npz'), query=anchors, **d) estimates[name] = dict(spec=spec, center=oracle, regions=regions, endpoint=endpoint) comparisons, mirror_checks, rates = {}, {}, {} ids = mirror_map(anchors) for rule in RULES: for lo, hi in [(12,24),(24,48)]: first, second = f'xy{lo}_standard_{rule}', f'xy{hi}_standard_{rule}' comparisons[f'{lo}_to_{hi}_{rule}'] = pair_summary(arrays[first], arrays[second], masks) a, b = arrays[f'xy24_standard_{rule}'], arrays[f'xy24_mirror_{rule}'] predicted = MIRROR @ a['tensor'][ids] @ MIRROR cov_error = np.linalg.norm(b['tensor']-predicted, axis=(1,2)) da, db = diagnostics(a['tensor']), diagnostics(b['tensor']) mirror_checks[rule] = dict(covariance_error=stats(cov_error), center_signed_standard=da['signed'][c].tolist(), center_signed_mirror=db['signed'][c].tolist(), signed_reflection_rule='(Txx-Tyy,2Txy) maps to (Txx-Tyy,-2Txy) at reflected physical anchors; no arbitrary eigvector signs', signed_covariance_max=float(abs(db['signed']-da['signed'][ids]*[1,-1]).max()), same_physical_anchor_comparison=pair_summary(a,b,masks)) rows = [estimates[f'xy{n}_standard_{rule}'] for n in [12,24,48]] rate = {} for metric, values in [('center_split',[r['center']['full_spectral_split'] for r in rows]), ('center_Frobenius',[r['center']['tensor_frobenius_error_to_analytic'] for r in rows]), ('interior_split_median',[r['regions']['interior']['full_spectral_split']['median'] for r in rows]), ('interior_split_p95',[r['regions']['interior']['full_spectral_split']['p95'] for r in rows])]: rate[metric] = dict(values=values, observed_log2_ratios=[float(np.log2(values[i]/values[i+1])) if values[i]>0 and values[i+1]>0 else None for i in range(2)], interpretation='Observed reduction in this statistic; not proven continuum error order, particularly off-center.') rates[rule] = rate for name, rows in [('regions.csv',regional_rows),('centers.csv',center_rows),('endpoints.csv',endpoint_rows)]: with (out/name).open('w') as stream: writer=csv.DictWriter(stream,fieldnames=list(rows[0])); writer.writeheader(); writer.writerows(rows) result=dict(estimates=estimates, refinement_comparisons=comparisons, mirror=mirror_checks, observed_rates=rates, caveats=['Interior off-center plane splitting may reflect box/kernel geometry; no new continuum reference exists in O2-A.', 'A gap near 0.1 is not an exact repeated root.', 'Unresolved or bad-quality anchors are excluded only from conditional projector comparisons, retained in all-anchor counts and splits.', 'Old nz24 endpoint support failures remain outside this experiment; their bilateral qualified denominator remains zero.']) write_json(out/'O2A_result.json',result) return result def main(): p=argparse.ArgumentParser(); p.add_argument('output',type=Path); p.add_argument('--analyze-only',action='store_true'); args=p.parse_args() out=args.output; contract=json.loads((out/'execution_contract.json').read_text()) if args.analyze_only: analyze(out,contract); return for path,digest in contract['input_sha256'].items(): assert sha(path)==digest, path started=time.monotonic() with (out/'O2A.started.json').open('x') as stream: json.dump(dict(pid=os.getpid(),contract_sha256=sha(out/'execution_contract.json'),started_unix=time.time()),stream) old=Path(contract['reuse_directory']); base=contract['numerics'] anchors=np.load(base['anchor_source'])['query'] assert len(anchors)==2197 ref=dict(np.load(old/'kernel_mass_reference.npz')); assert np.array_equal(anchors,ref['query']) reference_ok=ref['relative_agreement']<=base['quadrature_quality']['reference_relative_agreement_max'] np.savez_compressed(out/'fixed_anchors.npz', query=anchors, mirror_index=mirror_map(anchors), **{k:v for k,v in region_masks(anchors).items()}) records=[] for spec in contract['estimates']: if not spec['reuse']: continue source=old/f"z48_{spec['rule']}.npz" # Byte-for-byte reuse includes arrays and original modes/gates, never regenerate. (out/(spec['name']+'.npz')).write_bytes(source.read_bytes()) records.append(dict(**spec,source=str(source),sha256=sha(source),wall_seconds_this_run=0.,timing_scope='Reused; original timing in source companion JSON')) for nx, mirrored in [(24,False),(48,False),(24,True)]: tick=time.monotonic(); print('MESH',nx,'mirror',mirrored,flush=True) x,tet=mesh(nx,mirrored) assert cKDTree(x).query(anchors)[0].max()<1e-10 raw,volume,meta=initial_field(x,tet) assert np.isclose(volume,.32,rtol=1e-12) mesh_seconds=time.monotonic()-tick mesh_digest=hashlib.sha256(x.tobytes()+tet.tobytes()).hexdigest() raw_digest=hashlib.sha256(raw.tobytes()).hexdigest() for rule in RULES: name=f'xy{nx}_{"mirror" if mirrored else "standard"}_{rule}' tick=time.monotonic(); print('INTEGRATE',name,flush=True) sx,sm,st=volume_samples(x,tet,raw,rule) assert np.all(np.isfinite(sm)) and np.all(sm>0) and np.isclose(sm.sum(),volume) a=integrate(anchors,sx,sm,st,8/48,base,ref['order48'],reference_ok) assert np.all(np.isfinite(a['tensor'])) a['mode']=grouped(a['tensor'],.1)['code'] np.savez_compressed(out/(name+'.npz'),query=anchors,**a) record=dict(name=name,reuse=False,nx=nx,nz=48,mirrored=mirrored,rule=rule,nodes=len(x),tets=len(tet),samples=len(sx),volume=volume,mesh_sha256=mesh_digest,raw_field_sha256=raw_digest,initial_field=meta,shared_mesh_and_field_seconds=mesh_seconds,quadrature_seconds=time.monotonic()-tick,peak_rss_kib_so_far=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) write_json(out/(name+'.json'),record); records.append(record) print('DONE',name,'seconds',record['quadrature_seconds'],flush=True) del sx,sm,st,a del x,tet,raw analyze(out,contract) write_json(out/'work_receipt.json',dict(status='COMPLETED',pid=os.getpid(),wall_seconds=time.monotonic()-started,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,records=records,new_estimates=6,reused_estimates=2,training=False,new_reference_integration=False)) print('COMPLETE',time.monotonic()-started,flush=True) if __name__=='__main__': main()