File size: 14,010 Bytes
639016c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | """Fixed-design finite studies: no network, human data, or downloaded model."""
from __future__ import annotations
import argparse,csv,itertools,json,math,time
from pathlib import Path
import numpy as np
from scipy.special import logsumexp
from scipy.stats import t as student_t
from infinite_players.temporal import signs,trajectory_products,lag_moments
from infinite_players.evidence_tree import EvidenceTree,paired_emission_factors,forward_log_likelihoods
from infinite_players.memory_contract import confusability_graph,exact_coloring,retrospective_memory_lower_bits
from infinite_players.fidelity import policy_iteration,project_improvement,semantic_law,signature_residual,solve_fiber
from infinite_players.arena import make_arena,calibration_fixture
from infinite_players.promotion import budget
SEED=1860317
def save_json(path,value):path.write_text(json.dumps(value,indent=2,sort_keys=True,allow_nan=False)+"\n")
def save_csv(path,rows):
with path.open('w',newline='') as f:
w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
def wilson(correct,n):
p=correct/n;z=1.959963984540054;d=1+z*z/n
mid=(p+z*z/(2*n))/d;half=z*math.sqrt(p*(1-p)/n+z*z/(4*n*n))/d
return mid-half,mid+half
def lag_study(out):
rng=np.random.default_rng(SEED);rows=[];raw=[]
n=64;trials=16000;alpha=.6;beta=.75;rho=.72
for lag in (0,1,2,3,4,6,9):
u=trajectory_products(rng,trials,n,lag,alpha,beta,rho)
scores=u.sum(1);correct=(scores>0)|((scores==0)&(rng.random(trials)<.5))
mean,var,bound=lag_moments(n,lag,alpha*beta,rho);lo,hi=wilson(int(correct.sum()),trials)
rows.append(dict(lag=lag,n=n,trials=trials,correct=int(correct.sum()),accuracy=float(correct.mean()),ci_low=lo,ci_high=hi,mean_score=float(scores.mean()),theory_mean=mean,variance=float(scores.var(ddof=1)),theory_variance=var,error_bound=bound))
raw.extend(dict(lag=lag,trial=i,score=int(s),correct=int(c)) for i,(s,c) in enumerate(zip(scores,correct)))
save_csv(out/'continuous_lag.csv',rows);save_csv(out/'continuous_lag_trials.csv',raw);return rows
def hmm_study(out):
rng=np.random.default_rng(SEED+1);hyp=np.array(list(itertools.product([-1,1],repeat=2)))
rows=[];raw=[];max_difference=0.;pre_diff=0.
for n in (8,16,32):
trials=1000;full_correct=0;replay_correct=0;product_correct=0
for trial in range(trials):
theta,world=signs(rng,0.,2);z=np.empty(n,dtype=np.int8);z[0]=signs(rng,0.,1)[0]
z[1:]=z[0]*np.cumprod(signs(rng,.72,n-1))
a=theta*world*z*signs(rng,.6,n);b=z*signs(rng,.75,n)
factors=paired_emission_factors(a,b,hyp)
tree=EvidenceTree(factors,[str(i) for i in range(n)],model_id="paired-HMM-v1")
prior=tree.posterior([.5,.5]);pre_diff=max(pre_diff,abs(prior[hyp[:,0]==1].sum()-.5))
probe=(hyp[:,1]==world).astype(float);p=tree.posterior([.5,.5],probe=probe)
ll=forward_log_likelihoods(factors,[.5,.5]);ll[hyp[:,1]!=world]=-np.inf;baseline=np.exp(ll-logsumexp(ll))
max_difference=max(max_difference,float(np.max(np.abs(p-baseline))))
prob=float(p[hyp[:,0]==1].sum());tie=1 if rng.random()<.5 else -1
prediction=1 if prob>.5+1e-12 else (-1 if prob<.5-1e-12 else tie)
baseline_prob=float(baseline[hyp[:,0]==1].sum()); replay_prediction=1 if baseline_prob>.5+1e-12 else (-1 if baseline_prob<.5-1e-12 else tie)
score=int(world*np.sum(a.astype(int)*b));product=1 if score>0 else (-1 if score<0 else tie)
hit=int(prediction==theta);replay_hit=int(replay_prediction==theta);hitprod=int(product==theta);full_correct+=hit;replay_correct+=replay_hit;product_correct+=hitprod
raw.append(dict(n=n,trial=trial,theta=int(theta),world=int(world),posterior_positive=prob,tree_correct=hit,full_replay_correct=replay_hit,product_correct=hitprod))
for name,correct in (("operator_tree",full_correct),("full_HMM_replay",replay_correct),("paired_product",product_correct)):
lo,hi=wilson(correct,trials);rows.append(dict(events=n,method=name,trials=trials,correct=correct,accuracy=correct/trials,ci_low=lo,ci_high=hi))
save_csv(out/'sequence_inference.csv',rows);save_csv(out/'sequence_inference_trials.csv',raw)
report=dict(maximum_tree_replay_posterior_error=max_difference,maximum_precalibration_identity_error_from_half=pre_diff,independent_records=3000)
save_json(out/'sequence_inference_audit.json',report);return rows,report
def revision_study(out):
rng=np.random.default_rng(SEED+2);hyp=np.array(list(itertools.product([-1,1],repeat=2)));rows=[];timings=[];raw=[]
for n in (256,2048,16384):
a=signs(rng,0.,n);b=signs(rng,0.,n);factors=paired_emission_factors(a,b,hyp)
begin=time.perf_counter();tree=EvidenceTree(factors,[str(i) for i in range(n)],model_id="m");build=time.perf_counter()-begin
maximum=0.;max_centered_logerror=0.;tree_seconds=0.;replay_seconds=0.
for revision,index in enumerate(rng.choice(n,size=16,replace=False)):
b[index]*=-1;new=paired_emission_factors(a[index:index+1],b[index:index+1],hyp)[0];factors[index]=new
t=time.perf_counter();tree.replace(str(index),new,model_id="m",revision_id=str(revision));tp=tree.posterior([.5,.5],probe=[0,1,0,1]);tree_seconds+=time.perf_counter()-t
t=time.perf_counter();ll=forward_log_likelihoods(factors,[.5,.5]);ll[[0,2]]=-np.inf;fp=np.exp(ll-logsumexp(ll));replay_seconds+=time.perf_counter()-t
err=float(np.max(np.abs(tp-fp)));maximum=max(maximum,err)
tll=tree.log_likelihoods([.5,.5]); fll=forward_log_likelihoods(factors,[.5,.5]); logerr=float(np.max(np.abs((tll-tll[0])-(fll-fll[0])))); max_centered_logerror=max(max_centered_logerror,logerr)
raw.append(dict(events=n,revision=revision,index=int(index),posterior_max_error=err,centered_logscore_error=logerr,tree_compositions=tree.last_update_compositions,forward_steps=n))
depth=(n-1).bit_length()
rows.append(dict(events=n,hypotheses=4,hidden_states=2,revisions=16,tree_compositions_per_revision=depth,replay_steps_per_revision=n,tree_payload_bytes=tree.allocated_array_bytes,raw_two_sign_payload_bytes=2*n,max_posterior_error=maximum,max_centered_logscore_error=max_centered_logerror))
timings.append(dict(events=n,build_seconds=build,tree_16_revisions_seconds=tree_seconds,replay_16_revisions_seconds=replay_seconds,measured_revision_speed_ratio=replay_seconds/tree_seconds))
save_csv(out/'local_revisions.csv',rows);save_csv(out/'local_revision_trials.csv',raw);save_json(out/'runtime_telemetry.json',timings);return rows
def memory_study(out):
rows=[]
for n in range(1,5):
records=np.array(list(itertools.product([0,1],repeat=n)))
for prefix in sorted(set((1,n))):
k,_=exact_coloring(confusability_graph(records[:,:prefix]));rows.append(dict(record_bits=n,queried_coordinates=prefix,records=2**n,minimum_memory_states=k,minimum_fixed_bits=int(math.ceil(math.log2(k)))))
save_csv(out/'memory_graphs.csv',rows)
rng=np.random.default_rng(SEED+3);n=256;trials=16000
d=signs(rng,0.,(trials,n));theta=signs(rng,0.,trials);j=rng.integers(n,size=trials);actual=d[np.arange(trials),j];w=theta*actual;guess=signs(rng,0.,trials);result=[]
for b in (0,8,32,64,128,256):
answer=w*np.where(j<b,actual,guess);correct=int(np.sum(answer==theta));lo,hi=wilson(correct,trials)
result.append(dict(history_bits=n,retained_prefix_bits=b,trials=trials,correct=correct,accuracy=correct/trials,ci_low=lo,ci_high=hi,analytic_accuracy=.5+.5*b/n,evidential_coverage=b/n))
save_csv(out/'retrospective_memory.csv',result);save_json(out/'lossy_memory_bound.json',{"history_bits":n,"bounds":[{"average_error":e,"minimum_bits_lower_bound":retrospective_memory_lower_bits(n,e)} for e in (0,.01,.05,.1,.25,.5)]});return result
def shield_study(out):
rows=[];curves=[];policies=[];horizon_rows=[]
for seed in range(16):
mdp,anchor,targets=make_arena(4100+seed,theta=(-1 if seed%2 else 1));basevalue,_=mdp.evaluate(anchor);reference=semantic_law(mdp,anchor,6)
methods={"source_anchor":anchor};audits={}
for kind,name in (("path","path_shield_LP"),("class","conditional_class_only"),("none","unconstrained")):
pi,v,check=policy_iteration(mdp,targets,kind);methods[name]=pi;audits[name]=check
projected,hist=project_improvement(mdp,anchor,targets,steps=24);methods['nullspace_24_updates']=projected;curves.extend(dict(seed=seed,**x) for x in hist)
for name,pi in methods.items():
v,_=mdp.evaluate(pi);law=semantic_law(mdp,pi,6)
class_error=max(np.max(np.abs(np.array([pi[s,mdp.semantic_action[s]==c].sum() for c in range(mdp.C)])-targets[mdp.semantic_state[s]].sum(axis=1))) for s in range(mdp.S))
rows.append(dict(seed=seed,method=name,discounted_value=float(v.mean()),normalized_value=float((1-mdp.gamma)*v.mean()),normalized_gain=float((1-mdp.gamma)*(v-basevalue).mean()),minimum_state_value_gain=float(np.min(v-basevalue)),class_probability_error=float(class_error),signature_error=signature_residual(mdp,pi,targets),semantic_path_TV_h6=float(np.abs(law-reference).sum()/2)))
if seed<3:policies.append(dict(seed=seed,method=name,policy=pi.tolist(),audit=audits.get(name)))
if seed==0 and name in ('source_anchor','path_shield_LP','conditional_class_only','unconstrained'):
for h in range(1,9):
r=semantic_law(mdp,anchor,h);q=semantic_law(mdp,pi,h);horizon_rows.append(dict(method=name,horizon=h,semantic_path_TV=float(np.abs(r-q).sum()/2)))
summary=[]
for name in dict.fromkeys(x['method'] for x in rows):
subset=[x for x in rows if x['method']==name];g=np.array([x['normalized_gain'] for x in subset]);m=float(g.mean());half=float(student_t.ppf(.975,15)*g.std(ddof=1)/4)
summary.append(dict(method=name,seeds=16,normalized_value=float(np.mean([x['normalized_value'] for x in subset])),normalized_gain=m,paired_gain_ci_low=m-half,paired_gain_ci_high=m+half,semantic_path_TV_h6=float(np.mean([x['semantic_path_TV_h6'] for x in subset])),max_signature_error=float(max(x['signature_error'] for x in subset))))
save_csv(out/'shield_arena.csv',rows);save_csv(out/'shield_summary.csv',summary);save_csv(out/'nullspace_updates.csv',curves);save_csv(out/'semantic_horizons.csv',horizon_rows);save_json(out/'policy_examples.json',policies)
d0,d1,k,reward=calibration_fixture();cal=[]
for name,D,K in (("before_calibration_robust",np.vstack([d0,d1]),np.tile(k,2)),("true_world_0",d0,k),("true_world_1",d1,k)):
pi,a=solve_fiber(reward,D,K);cal.append(dict(stage=name,policy=pi.tolist(),reward=float(reward@pi),rank=int(np.linalg.matrix_rank(D)),nullity=int(3-np.linalg.matrix_rank(D)),audit=a))
mdp,anchor,k=make_arena(781,no_headroom=True);p,v,a=policy_iteration(mdp,k)
report={"calibration":cal,"no_headroom_max_absolute_gain":float(np.max(np.abs(v-mdp.evaluate(anchor)[0])))}
save_json(out/'calibration_unlock.json',report);return summary,report
def approximation_study(out):
rng=np.random.default_rng(SEED+4);rows=[]
for trial in range(1000):
n,H,K=8,4,2;factors=rng.uniform(.01,.7,(n,H,K,K));eps=rng.uniform(.001,.02,n);tilde=factors*np.exp(rng.uniform(-1,1,factors.shape)*eps[:,None,None,None])
initial=rng.dirichlet(np.ones(K));terminal=rng.uniform(.1,1.,(H,K));prior=rng.dirichlet(np.ones(H));probe=np.exp(rng.uniform(-650,0,H))
x=EvidenceTree(factors,[str(i) for i in range(n)],model_id="x");y=EvidenceTree(tilde,[str(i) for i in range(n)],model_id="x")
p=x.posterior(initial,prior,terminal,probe);q=y.posterior(initial,prior,terminal,probe);error=float(np.abs(p-q).sum()/2);bound=math.tanh(float(eps.sum())/2)
if error>bound+1e-12:raise AssertionError("approximation bound violation")
rows.append(dict(trial=trial,log_error_budget=float(eps.sum()),posterior_TV=error,uniform_bound=bound))
save_csv(out/'approximation_trials.csv',rows);result={"trials":1000,"violations":0,"maximum_posterior_TV":max(x['posterior_TV'] for x in rows),"maximum_error_bound_ratio":max(x['posterior_TV']/x['uniform_bound'] for x in rows)};save_json(out/'approximation_summary.json',result);return result
def lifetime_study(out):
rng=np.random.default_rng(SEED+5);trials=10000;versions=40;n=256;delta=.05;rows=[]
for true_gain in (0.,.3):
sums=2*rng.binomial(n,(1+true_gain)/2,(trials,versions))-n;radii=np.sqrt(2*np.log([1/budget(delta,j) for j in range(1,versions+1)])/n);accepted=sums/n>radii[None,:]
any_count=int(np.sum(accepted.any(1)));lo,hi=wilson(any_count,trials)
rows.append(dict(true_gain=true_gain,trials=trials,versions=versions,audit_sessions_per_version=n,lifetime_budget=delta,any_promotion_count=any_count,any_promotion_rate=any_count/trials,ci_low=lo,ci_high=hi,mean_promotions=float(accepted.sum(1).mean())))
save_csv(out/'lifetime_audit.csv',rows);return rows
def main():
p=argparse.ArgumentParser();p.add_argument('--output',type=Path,default=Path('results'));args=p.parse_args();out=args.output;out.mkdir(parents=True,exist_ok=True)
config={"seed":SEED,"scope":"synthetic finite known-model studies","lag_trials_per_lag":16000,"lag_events":64,"hmm_records_per_size":1000,"sizes":[8,16,32],"revision_lengths":[256,2048,16384],"local_corrections":16,"arena_seeds":16,"projection_updates":24,"horizon":6,"positive_circuit_trials":1000,"lifetime_runs_per_condition":10000};save_json(out/'config.json',config)
report={}
for name,fn in [('lag',lag_study),('sequence',hmm_study),('revisions',revision_study),('memory',memory_study),('shield',shield_study),('approximation',approximation_study),('lifetime',lifetime_study)]:
print('RUN',name,flush=True);report[name]=fn(out)
save_json(out/'summary.json',report);print('Finite studies completed',flush=True)
if __name__=='__main__':main()
|