Files
MeltMind/tools/screen_o1_v1.py
T

106 lines
7.8 KiB
Python

"""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)