"""O1-v1 table-only admission screen; never runs a partition or transport solve.""" import argparse from collections import Counter from decimal import Decimal, ROUND_CEILING import hashlib import json from pathlib import Path import resource import time import csv import numpy as np def digest(path): return hashlib.sha256(Path(path).read_bytes()).hexdigest() def admission_for_k(nodes, k): if not isinstance(nodes,int) or nodes<=0 or not isinstance(k,int) or k<8: raise ValueError('Positive integer node count and K>=8 required') reasons=[] if k>512: reasons.append('K_exceeds_512') if nodes<200*k: reasons.append('nodes_per_group_below_200') return dict(K=k,nodes_per_group=nodes/k,status='not admitted under O1-v1' if reasons else 'admitted under O1-v1',reasons=reasons) def from_region_table(nodes, table): total=float(table['total_volume_raw']); volumes=np.asarray(table['region_volumes_raw'],float) if volumes.ndim!=1 or len(volumes)!=table['regions'] or not len(volumes) or not np.isfinite(volumes).all() or np.any(volumes<=0) or not np.isfinite(total) or total<=0: raise ValueError('Incomplete or nonpositive region table') if not np.isclose(volumes.sum(),total,rtol=1e-10,atol=0): raise ValueError('Region mass is not conserved') if np.any(volumes < total/512*(1-1e-12)): raise ValueError('Table violates frozen cleaning rule') # Decimal conversion of recorded values prevents silently rounding an over-bound ratio down. k_scale=int((Decimal(str(total))/Decimal(str(float(volumes.min())))).to_integral_value(rounding=ROUND_CEILING)) return dict(**admission_for_k(nodes,max(k_scale,8)),K_scale=k_scale,J_count=len(volumes),total_volume=total,min_region_volume=float(volumes.min()),min_region_fraction=float(volumes.min()/total)) def stats(v): a=np.asarray(v,float) return dict(count=len(a),min=float(a.min()) if len(a) else None,median=float(np.median(a)) if len(a) else None,p95=float(np.quantile(a,.95)) if len(a) else None,max=float(a.max()) if len(a) else None) def run(out): start=time.monotonic();contract=json.loads((out/'execution_contract.json').read_text()) for p,h in contract['input_sha256'].items(): if digest(p)!=h: raise ValueError('Changed input '+p) with (out/'screen.started.json').open('x') as f: json.dump(dict(contract_sha256=digest(out/'execution_contract.json')),f) census=json.loads(Path(contract['census']).read_text()) assert census['cases']==624 and len(census['rows'])==624 available={} for path in contract['region_sources']: r=json.loads(Path(path).read_text()); case=r['case']; assert case not in available assert r['contract']['minimum_fraction']==1/512 assert r['contract']['K_floor']==8 assert np.isclose(r['cleanup']['minimum_region_volume_raw'],r['cleaned_regions']['total_volume_raw']/512,rtol=1e-12) available[case]=(r,path) rows=[]; used=[] for entry in census['rows']: case=entry['case']; mixed=set(entry['types'])!={'10'} row=dict(case=case,N_nodes=entry['points'],tetra_cells=entry['types'].get('10',0),mixed_topology=mixed, tetra_domain_nodes_if_mixed=next((v['nodes'] for v in entry.get('details',[]) if v['type']==10),None), K=None,K_scale=None,J_count=None,nodes_per_group=None,min_region_fraction=None, status='pending region table',reasons=['missing_cleaned_region_table'],region_source=None) if case in available: r,path=available[case] if mixed: raise ValueError('Mixed table needs an explicit reviewed domain/node mapping') decision=from_region_table(int(entry['points']),r['cleaned_regions']);row.update(decision);row['region_source']=path used.append(dict(case=case,source=path,source_sha256=digest(path),cleaned_regions=r['cleaned_regions'],cleanup=r['cleanup'],original_scale_contract=r['contract'],new_decision=decision)) rows.append(row) assert len({r['case'] for r in rows})==624 and len(used)==len(available) known=[r for r in rows if r['K'] is not None]; admitted=[r for r in known if not r['reasons']] pending=[r for r in rows if r['K'] is None]; rejected=[r for r in known if r['reasons']] missing_nodes=sum(r['N_nodes'] for r in pending) calibrations=[] for path in contract['distance_timing_sources']: r=json.loads(Path(path).read_text()) calibrations.append(dict(case=r['case'],nodes=r['nodes'],query_seconds=r['query_seconds'],seconds_per_total_node=r['query_seconds']/r['nodes'],source=path)) coefficients=[r['seconds_per_total_node'] for r in calibrations] result=dict(status='PARTIAL_SCREEN_AND_PREPARATION_COMPLETE_FULL_624_SCREEN_NOT_COMPLETE',corpus_N=624, regions_available=len(known),regions_missing=len(pending),admitted_known=len(admitted),not_admitted_known=len(rejected), all_corpus_admitted_fraction=None,available_table_admitted_fraction=len(admitted)/len(known) if known else None, table_coverage_fraction=len(known)/624,admitted_fraction_bounds=[len(admitted)/624,(len(admitted)+len(pending))/624], bounds_meaning='Logical limits from missing results, not confidence intervals or corpus estimates.', K_distribution_available=stats([r['K'] for r in known]),K_distribution_admitted=stats([r['K'] for r in admitted]), failure_reason_counts=dict(Counter(reason for r in rejected for reason in r['reasons'])), pending_mixed_count=sum(r['mixed_topology'] for r in pending),known_decisions=known, preparation=dict(missing_cases=len(pending),missing_nodes_reported=missing_nodes,missing_tetra_cells=sum(r['tetra_cells'] for r in pending), validated_geometry_caches=contract['geometry_cache_count'],missing_geometry_caches=624-contract['geometry_cache_count'], distance_calibrations=calibrations, distance_only_linear_extrapolation_hours=[missing_nodes*min(coefficients)/3600,missing_nodes*max(coefficients)/3600], estimate_limit='Historical serial query time per total node extrapolated only for planning; not a measured full-corpus runtime, bound, or service promise. Geometry, graph construction, tensor/cleanup, validation and IO are additional. Surface complexity and mixed topology may change cost.', ready_tool='tools/prepare_o1_region_table.py: validated cached pure-tetra geometry + matching cached distance -> unchanged 3-hop proxy and cleanup -> complete J table. Prepared and unit-tested; not executed on new real parts.', mixed_requirement='Seven mixed cases require explicit tetra-domain old/new node mapping and retained triangle-domain metadata before preparation; never silently strip triangles.', seed_status='Not generated. Later graph-distance FPS with one fixed RNG and shared seeds across arms; prior K38 Euclidean seeds/quota are not reused.'), execution=dict(wall_seconds=time.monotonic()-start,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,new_real_region_tables=0,new_distance_queries=0,LP_solves=0,training=False,O2_rerun=False)) for name,value in [('screen_result.json',result),('all_624_rows.json',rows),('reused_region_tables.json',used)]: (out/name).write_text(json.dumps(value,indent=2,allow_nan=False)+'\n') fields=['case','N_nodes','tetra_cells','mixed_topology','tetra_domain_nodes_if_mixed','J_count','K_scale','K','nodes_per_group','min_region_fraction','status','reasons','region_source'] with (out/'all_624_rows.csv').open('w',newline='') as f: writer=csv.DictWriter(f,fieldnames=fields,extrasaction='ignore');writer.writeheader() writer.writerows({**r,'reasons':';'.join(r['reasons'])} for r in rows) print(json.dumps(result,indent=2)) if __name__=='__main__': p=argparse.ArgumentParser();p.add_argument('output',type=Path);run(p.parse_args().output)