#!/usr/bin/env python3
"""Exact finite v10 diagnostic; no model training. Python 3 + NumPy.
Random convention: seeds 0..19, PCG64, sequential uniform choice from ascending
remaining setting IDs; budgets are prefixes of the same 128-query run.
Run with Python 3.10.12 and NumPy 2.2.6 for the recorded reproduction.
"""
import json,time,platform,argparse,csv
from itertools import combinations,product
from pathlib import Path
import numpy as np
BUDGETS=(8,32,128)
X=np.array(list(product((0,1),repeat=12)),dtype=np.uint8)
E=np.array(list(product((0,1),repeat=10)),dtype=np.uint8)
truth=X[:,0]^X[:,1]
trainmask=X[:,2:].sum(1)<=1
training=X[trainmask]
eligible=np.flatnonzero(E.sum(1)>=2)
patterns=[(m,ids,bs) for m in (2,3,4) for ids in combinations(range(10),m) for bs in product((0,1),repeat=m) if sum(bs)>=2]
sizes=np.array([p[0] for p in patterns])
traps=np.array([np.all(E[:,ids]==bs,axis=1) for m,ids,bs in patterns])
assert len(training)==44 and len(eligible)==1013 and len(patterns)==2835
assert len({row.tobytes() for row in traps})==2835
# Actual full truth tables, including all four useful-switch assignments.
tables=np.array([truth^np.all(X[:,np.array(ids)+2]==bs,axis=1) for m,ids,bs in patterns],dtype=np.uint8)
assert np.all(tables[:,trainmask]==truth[trainmask])
pairs=list(combinations(range(10),2))
assign=np.array([[4*p+2*x[i]+x[j] for p,(i,j) in enumerate(pairs)] for x in E])
basecovered=set(assign[E.sum(1)<=1].ravel().tolist())
assert len(basecovered)==135

def score(alive,queries,newrows):
 ids=np.flatnonzero(alive)
 # Enumerated scoring, only called at budget checkpoints after selection.
 errors=np.mean(tables[ids]!=truth,axis=1) if len(ids) else np.array([])
 result={'queries':queries,'new_rows':newrows,'wrong_survived':len(ids),'missed_share':len(ids)/len(patterns),'worst_error':float(errors.max()) if len(ids) else 0.0,'by_size':{}}
 for m in (2,3,4):
  mask=sizes[ids]==m
  result['by_size'][str(m)]={'wrong_survived':int(mask.sum()),'worst_error':float(errors[mask].max()) if mask.any() else 0.0}
 return result

def run(method,seed=None):
 alive=np.ones(2835,dtype=bool);remaining=list(eligible);covered=set(basecovered)
 rng=np.random.Generator(np.random.PCG64(seed)) if seed is not None else None
 history=[];snapshots={};first_all=None;first_size={str(m):None for m in (2,3,4)}
 predictions=0;selection_seconds=0;start=time.perf_counter()
 for q in range(1,129):
  selection_start=time.perf_counter()
  if method=='one_switch':
   if q>40:break
   # Groups of four useful settings for switch 3, then switch 4, etc.
   e=1<<(9-((q-1)//4));use=(q-1)%4;newrows=0
  else:
   if not alive.any():break
   use=(q-1)%4;newrows=q
   if method=='random':e=int(rng.choice(np.asarray(remaining,dtype=np.int64)))
   elif method=='pair_then_order':
    gain=np.array([sum(int(a) not in covered for a in assign[r]) for r in remaining])
    e=remaining[int(np.argmax(gain))]
   elif method=='disagreement':
    # Include correct rule's prediction as a surviving candidate.
    ones=traps[alive][:,remaining].sum(0)
    counts=int(alive.sum())+1
    gain=np.minimum(ones,counts-ones)
    e=remaining[int(np.argmax(gain))]
    predictions+=counts*len(remaining)
   else:raise ValueError(method)
   remaining.remove(e)
  selection_seconds+=time.perf_counter()-selection_start
  # Correct answer is exposed only now. Rule flips are independent of useful bits.
  rowid=use*1024+e
  alive &= tables[:,rowid]==truth[rowid]
  covered.update(assign[e].tolist())
  history.append({'query':q,'extra_id':e,'useful_id':use,'full_row_id':rowid,'remaining':int(alive.sum())})
  for m in (2,3,4):
   if first_size[str(m)] is None and not np.any(alive & (sizes==m)):first_size[str(m)]=q
  if not alive.any() and first_all is None:first_all=q
  if q in BUDGETS:snapshots[str(q)]=score(alive,q,newrows)
 # Early stop is actual elimination or the exhausted negative control.
 for budget in BUDGETS:
  if str(budget) not in snapshots:snapshots[str(budget)]=score(alive,len(history),0 if method=='one_switch' else len(history))
 return {'method':method,'seed':seed,'snapshots':snapshots,'first_elimination':first_all,'first_by_size':first_size,'candidate_predictions_for_selection':predictions,'selection_seconds':selection_seconds,'selection_and_checkpoint_seconds':time.perf_counter()-start,'history':history}

def reference():
 keep=[]
 for ids in combinations(range(12),2):
  for outputs in product((0,1),repeat=4):
   vals=np.array(outputs)[2*training[:,ids[0]]+training[:,ids[1]]]
   if np.array_equal(vals,training[:,0]^training[:,1]):keep.append((ids,outputs))
 assert keep==[((0,1),(0,1,1,0))]
 return {'surviving_rule_count':1,'rule':'first two switches differ','wrong_survived':0,'worst_error':0,'audit_queries':0}

if __name__=='__main__':
 parser=argparse.ArgumentParser(description=__doc__)
 parser.add_argument('--output-dir',type=Path,default=Path(__file__).resolve().parent)
 args=parser.parse_args();args.output_dir.mkdir(parents=True,exist_ok=True)
 results={'environment':{'python':platform.python_version(),'numpy':np.__version__},'spec':{'seeds':list(range(20)),'budgets':BUDGETS,'training_rows':44,'eligible_extra_settings':1013,'wrong_rules':2835,'full_rows':4096,'random_convention':'Sequential choice from ascending remaining IDs; budget prefixes'},'reference':reference(),'runs':[]}
 for method in ('one_switch','pair_then_order','disagreement'):
  r=run(method);results['runs'].append(r);print(method,{b:r['snapshots'][b]['wrong_survived'] for b in ('8','32','128')},'eliminate',r['first_elimination'],flush=True)
 for seed in range(20):
  r=run('random',seed);results['runs'].append(r);print('random',seed,{b:r['snapshots'][b]['wrong_survived'] for b in ('8','32','128')},flush=True)
 (args.output_dir/'aaronson-diagnostic-results.json').write_text(json.dumps(results,indent=2,default=lambda x:int(x)))
 with (args.output_dir/'aaronson-diagnostic-summary.csv').open('w',newline='') as f:
  writer=csv.writer(f)
  writer.writerow(['method','seed','budget','actual_queries','new_rows','wrong_survived','missed_share','worst_error','size2_remaining','size3_remaining','size4_remaining','elimination_query','selection_seconds','candidate_predictions_for_selection'])
  for r in results['runs']:
   for b in BUDGETS:
    z=r['snapshots'][str(b)]
    writer.writerow([r['method'],r['seed'],b,z['queries'],z['new_rows'],z['wrong_survived'],z['missed_share'],z['worst_error'],*[z['by_size'][str(m)]['wrong_survived'] for m in (2,3,4)],r['first_elimination'],r['selection_seconds'],r['candidate_predictions_for_selection']])
