"""Read-only diagnosis of saved constrained cuts; no new partition or tolerance.""" import argparse import csv import hashlib import json from pathlib import Path import numpy as np from review_partition_scale import regions, histogram_control def main(): parser = argparse.ArgumentParser() parser.add_argument('output', type=Path) out = parser.parse_args().output target = out / 'shape_850_diagnosis.json' if target.exists(): raise FileExistsError(target) directory = next(Path('artifacts/capacity-projectors-2026-11-13').glob('00000850*')) case = directory.name old = Path('artifacts/routes-review-2026-11-13') / case result = json.loads((directory / 'capacity_result.json').read_text()) prior = json.loads((old / 'result.json').read_text()) config = json.loads((old / 'scale_contract.json').read_text()) assert hashlib.sha256((old / 'scale_contract.json').read_bytes()).hexdigest() == result['contract']['source_scale_contract_sha256'] cache = np.load(old / 'partitions.npz') cuts = np.load(directory / 'candidate_partitions.npz') data = np.load(Path('artifacts/intake-2026-11-13/samples') / (case + '.npz')) x, mass, edges = data['points_raw'], data['node_volume_raw'], data['edges'] kind, seeds = cache['cleaned_type'], cache['seeds'] region, rv, rt = regions(kind, edges, mass) length = np.linalg.norm(x[edges[:, 0]] - x[edges[:, 1]], axis=1) cross_type = kind[edges[:, 0]] != kind[edges[:, 1]] S = config['S_realized_raw'] regional = [] for r in range(len(rv)): ids = np.flatnonzero(region == r) regional.append(dict(region=r, type=int(rt[r]), volume=float(rv[r]), volume_over_S=float(rv[r]/S), below_capacity_lower=bool(rv[r] < .95*S), seeds=int(np.sum(region[seeds] == r)), bounding_box=[x[ids].min(0).tolist(), x[ids].max(0).tolist()], occupied_groups_by_arm={name: len(np.unique(cuts[name][ids])) for name in cuts.files})) arms = {} all_groups = [] for name in cuts.files: labels = cuts[name] weights = length if name == 'generic' else length*(1+int(name.split('_')[1])*cross_type) if name.startswith('control'): weights = histogram_control(weights, length) digest = hashlib.sha256(weights.tobytes()).hexdigest() assert digest == result['records'][name]['cost_hash_before'] == result['records'][name]['cost_hash_after'] previous_name = 'generic_S' if name == 'generic' else name.split('_')[0]+'_S_alpha'+name.split('_')[1] previous_labels = cache[previous_name] groups = [] for g in range(len(seeds)): ids = np.flatnonzero(labels == g) center = np.average(x[ids], axis=0, weights=mass[ids]) delta = x[ids] - center covariance = (delta * mass[ids, None]).T @ delta / mass[ids].sum() eig = np.linalg.eigvalsh(covariance) assert eig[0] > 1e-24 aspect = float(np.sqrt(eig[-1]/eig[0])) assert np.isclose(aspect, result['records'][name]['aspect'][g]) hist = np.bincount(kind[ids], weights=mass[ids], minlength=4) rvol = np.bincount(region[ids], weights=mass[ids], minlength=len(rv)) row = dict(arm=name, group=g, seed_node=int(seeds[g]), seed_region=int(region[seeds[g]]), seed_in_own_group=bool(labels[seeds[g]] == g), nodes=len(ids), volume_over_S=float(mass[ids].sum()/S), center=center.tolist(), covariance_eigenvalues=eig.tolist(), aspect=aspect, effective_mass_nodes=float(mass[ids].sum()**2/np.square(mass[ids]).sum()), dominant_type=int(hist.argmax()), dominant_type_share=float(hist.max()/hist.sum()), dominant_region=int(rvol.argmax()), dominant_region_share=float(rvol.max()/rvol.sum()), regions_touched=int(np.sum(rvol > 0)), type_volume_fractions=(hist/hist.sum()).tolist(), bounding_box=[x[ids].min(0).tolist(), x[ids].max(0).tolist()], capacity_adjustment_symmetric_difference_mass_over_S=float(mass[(labels == g) != (previous_labels == g)].sum()/S)) groups.append(row) all_groups.append(row) aspect = np.array([g['aspect'] for g in groups]) pre_aspect = np.array(prior['records'][previous_name]['aspect']) order = np.argsort(aspect) contributors = {} for quantile in [.1, .5, .9]: position = (len(order)-1)*quantile lo, hi = int(np.floor(position)), int(np.ceil(position)) contributors[str(quantile)] = dict(groups=[int(order[lo]), int(order[hi])], upper_interpolation_weight=position-lo) generic = cuts['generic'] cut = labels[edges[:, 0]] != labels[edges[:, 1]] arms[name] = dict(cost_hash_verified=True, aspect_quantiles=np.quantile(aspect, [.1, .5, .9]).tolist(), pre_capacity_aspect_quantiles=np.quantile(pre_aspect, [.1, .5, .9]).tolist(), log_quantile_change_due_to_capacity=(np.log(np.quantile(aspect, [.1, .5, .9])/np.quantile(pre_aspect, [.1, .5, .9]))).tolist(), q90_interpolation=contributors['0.9'], top_six_aspect_groups=[groups[i] for i in order[-6:][::-1]], all_groups=groups, capacity_changed_mass_fraction=float(mass[labels != previous_labels].sum()/mass.sum()), different_from_generic_mass_fraction=float(mass[labels != generic].sum()/mass.sum()), type_boundary_cut_fraction=float(cut[cross_type].mean()), non_type_boundary_cut_fraction=float(cut[~cross_type].mean()), mean_group_dominant_type_share=float(np.mean([r['dominant_type_share'] for r in groups]))) comparisons = {} for alpha in [4, 16, 64]: comparisons[str(alpha)] = {} for lhs, rhs in [(f'type_{alpha}', 'generic'), (f'control_{alpha}', 'generic'), (f'type_{alpha}', f'control_{alpha}')]: log = np.log(np.array(arms[lhs]['aspect_quantiles'])/arms[rhs]['aspect_quantiles']) comparisons[str(alpha)][lhs+'__'+rhs] = dict(log_ratio_q10_q50_q90=log.tolist(), failing_quantiles=[q for q, value in zip([.1, .5, .9], log) if abs(value) > np.log(1.25)]) target.write_text(json.dumps(dict(case=case, scope='Saved partitions only; no new cuts, remapping, or relaxed tolerances.', scale_contract=config, type_region_table=regional, arms=arms, comparisons=comparisons, capacity_bounds=[.95*S, 1.05*S], numerical_covariance_floor_active=False, causal_limit='These controlled saved arms isolate cost arrangement conditional on fixed seeds and scale. They do not independently identify a better seed rule or a globally feasible shape-constrained partition.', full_acceptance_missing=result['contract']['full_acceptance_missing']), indent=2, allow_nan=False)+'\n') columns=['arm','group','seed_region','nodes','volume_over_S','aspect','effective_mass_nodes','dominant_type','dominant_type_share','dominant_region','dominant_region_share','regions_touched','capacity_adjustment_symmetric_difference_mass_over_S'] with (out/'shape_850_groups.csv').open('w') as stream: writer=csv.DictWriter(stream,fieldnames=columns,extrasaction='ignore') writer.writeheader() writer.writerows(all_groups) print(json.dumps({'regions':len(regional),'below_capacity_lower':sum(r['below_capacity_lower'] for r in regional),'groups_checked':len(all_groups),'comparisons':comparisons},indent=2)) if __name__ == '__main__': main()