"""Postprocess frozen tensors and region volumes; no mesh, estimator or solver run.""" import argparse import csv import hashlib import json from pathlib import Path import numpy as np if __package__: from .projector_remesh_probe import grouped from .physical_support_probe import statistics else: from projector_remesh_probe import grouped from physical_support_probe import statistics def funnel(ta, tb, mask): a, b = grouped(ta, .1), grouped(tb, .1) ga, gb = np.isin(a['code'], [1, 2]), np.isin(b['code'], [1, 2]) same = a['code'] == b['code'] n = int(mask.sum()) counts = dict(A_emit=int(np.sum(mask & ga)), B_emit=int(np.sum(mask & gb)), both_emit_same_mode=int(np.sum(mask & ga & gb & same)), both_emit_different_mode=int(np.sum(mask & ga & gb & ~same)), A_only=int(np.sum(mask & ga & ~gb)), B_only=int(np.sum(mask & ~ga & gb)), neither=int(np.sum(mask & ~ga & ~gb)), all_mode_flips=int(np.sum(mask & ~same))) assert sum(counts[k] for k in ['both_emit_same_mode', 'both_emit_different_mode', 'A_only', 'B_only', 'neither']) == n selected = mask & ga & gb & same error = np.linalg.norm(a['projector']-b['projector'], axis=(2, 3)).max(1) modes = [-1, 0, 1, 2, 3] matrix = [[int(np.sum(mask & (a['code'] == i) & (b['code'] == j))) for j in modes] for i in modes] assert np.sum(matrix) == n return dict(queries=n, counts=counts, rates={key: value/n if n else None for key, value in counts.items()}, both_emit_rate=(counts['both_emit_same_mode']+counts['both_emit_different_mode'])/n if n else None, projector_difference_both_emit_same_mode=statistics(error[selected]), mode_order=modes, mode_transition_counts=matrix) def center_oracle(tensor): value, vectors = np.linalg.eigh(tensor) scale = max(value[-1], 1e-12) gate = bool(value.sum() > 1e-10 and (value[1]-value[0])/scale > .1) projector = np.outer(vectors[:, 0], vectors[:, 0]) ideal = np.diag([.5, .5, 0.]) return dict(eigenvalues_ascending=value.tolist(), mode=int(grouped(tensor[None], .1)['code'][0]), axis_gap_pass=gate, tensor_frobenius_error_to_analytic=float(np.linalg.norm(tensor-ideal)), eigenvalue_max_error_to_analytic=float(np.max(abs(value-np.array([0., .5, .5])))), axis_projector_error_to_analytic=float(np.linalg.norm(projector-np.diag([0., 0., 1.]))) if gate else None), projector def main(): parser = argparse.ArgumentParser() parser.add_argument('output', type=Path) out = parser.parse_args().output out.mkdir(parents=True, exist_ok=True) if (out/'capacity_count_conditions.json').exists() or (out/'eligibility_funnels.json').exists(): raise FileExistsError('Preserve existing postprocessing') source = Path('artifacts/physical-support-2026-11-14') summary = json.loads((source/'physical_support_results.json').read_text()) rows, centers, sources = [], [], [] for r in summary['rows']: p = source/f"{r['shape']}_{r['resolution']}_paired_fields.npz" saved = np.load(p) sources.append(dict(path=str(p), sha256=hashlib.sha256(p.read_bytes()).hexdigest())) for arm in r['arms']: a, b = saved[arm+'_tensor_A'], saved[arm+'_tensor_B_common'] for region in ['all', 'interior', 'wall_end', 'junction']: mask = np.ones(len(a), bool) if region == 'all' else saved['region'] == region rows.append(dict(shape=r['shape'], resolution=r['resolution'], arm=arm, region=region, **funnel(a, b, mask))) if r['shape'] == 'square_rod': ids = np.flatnonzero(np.linalg.norm(saved['query']-[.1, .1, 4.], axis=1) < 1e-12) assert len(ids) == 1 qa, pa = center_oracle(a[ids[0]]) qb, pb = center_oracle(b[ids[0]]) centers.append(dict(resolution=r['resolution'], arm=arm, query=[.1, .1, 4.], A=qa, B=qb, axis_projector_difference_both_pass=float(np.linalg.norm(pa-pb)) if qa['axis_gap_pass'] and qb['axis_gap_pass'] else None)) (out/'eligibility_funnels.json').write_text(json.dumps(dict( emit_gate='Trace>1e-10 and hard-gap=0.1 code in {1,2}; numerical two-cluster emission, NOT physical accuracy or quadrature convergence.', denominator='All shared anchors in each region, including failures and mode flips; conditional errors never replace full denominator.', center_axis_gate='At the square-rod center, use smallest-eigenvalue axis and its gap from the next eigenvalue; never choose an axis inside the transverse degenerate plane.', rows=rows, square_rod_center_oracle=centers, sources=sources), indent=2, allow_nan=False)+'\n') with (out/'eligibility_funnels.csv').open('w') as stream: writer = csv.writer(stream) writer.writerow(['shape','resolution','arm','region','N','A_emit_rate','B_emit_rate','both_emit_rate','all_mode_flip_rate','both_emit_same_mode_N','conditional_Pmax','conditional_P95']) for r in rows: e = r['projector_difference_both_emit_same_mode'] writer.writerow([r['shape'],r['resolution'],r['arm'],r['region'],r['queries'],r['rates']['A_emit'],r['rates']['B_emit'],r['both_emit_rate'],r['rates']['all_mode_flips'],e['count'],e['maximum'],e['p95']]) diagnosis = json.loads((source/'shape_850_diagnosis.json').read_text()) table = diagnosis['type_region_table'] volume = np.array([r['volume'] for r in table]) anchors = np.array([r['seeds'] for r in table]) S = diagnosis['scale_contract']['S_realized_raw'] k = diagnosis['scale_contract']['K'] lo, hi = .95*S, 1.05*S lower, upper = np.ceil(volume/hi).astype(int), np.floor(volume/lo).astype(int) quota = np.floor(volume/S).astype(int) order = np.lexsort((np.arange(len(volume)), -(volume/S-quota))) quota[order[:k-int(quota.sum())]] += 1 assert quota.sum() == k and anchors.sum() == k def pressure(n): incoming = np.maximum(n*lo-volume, 0).sum()/volume.sum() outgoing = np.maximum(volume-n*hi, 0).sum()/volume.sum() return dict(import_lower_bound_fraction=float(incoming), export_lower_bound_fraction=float(outgoing), total_cross_region_mass_lower_bound_fraction=float(max(incoming, outgoing))) condition = dict(case=diagnosis['case'], K=k, S=S, lower_capacity=lo, upper_capacity=hi, interval_formula='ceil(Vj/V+) <= nj <= floor(Vj/V-)', interpretation='Necessary for zero crossing. Nonempty intervals plus sum lower<=K<=sum upper suffice ONLY for scalar continuously divisible mass with free anchor placement, not graph-connected seeded partitions.', regions=[dict(region=int(r['region']), volume_over_S=float(volume[i]/S), minimum_pieces=int(lower[i]), maximum_pieces=int(upper[i]), interval_nonempty=bool(lower[i] <= upper[i]), fixed_anchors=int(anchors[i]), fixed_anchors_in_interval=bool(lower[i] <= anchors[i] <= upper[i]), proposed_quota_not_executed=int(quota[i])) for i,r in enumerate(table)], sum_minimum_pieces=int(lower.sum()), sum_maximum_pieces=int(upper.sum()), zero_crossing_scalar_feasible=bool(np.all(lower<=upper) and lower.sum()<=k<=upper.sum()), existing_anchor_pressure=pressure(anchors), proposed_quota_pressure=pressure(quota), proposed_quota_rule='Largest remainder of Vj/S, stable region-ID tie-break; arithmetic proposal only, no new anchors or partition solves.', minimum_anchor_relocations_for_proposed_quota=int(np.maximum(anchors-quota,0).sum()), no_sufficiency_claim='Reduced unavoidable mass-exchange lower bound is neither a feasible partition nor a shape guarantee.') # A scalar-feasible but indivisible-node-infeasible example guards the interpretation. masses=np.array([.6,.6,.6,.2]) totals=np.array([sum(masses[i] for i in range(4) if bits & (1<=.95)&(totals<=1.05)) condition['indivisibility_counterexample']=dict(node_masses=masses.tolist(), K=2, capacity=[.95,1.05], scalar_count_pass=True, feasible_subsets=0) (out/'capacity_count_conditions.json').write_text(json.dumps(condition, indent=2, allow_nan=False)+'\n') print(json.dumps({'regional_funnels':len(rows),'center_diagnostics':len(centers),'count_interval_sums':[int(lower.sum()),int(upper.sum())],'K':k,'zero_crossing_feasible':condition['zero_crossing_scalar_feasible'],'anchor_moves_proposed':condition['minimum_anchor_relocations_for_proposed_quota']},indent=2)) if __name__ == '__main__': main()