Publish 11 evaluated Astra histories with reproducible checkpoint artifacts (part 55)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/core.py

@@ -0,0 +1,36 @@
+"""Small logit residual with training-only feature normalization."""
+import numpy as np
+
+
+def logit(probability):
+    p=np.clip(np.asarray(probability,np.float64),1e-7,1-1e-7)
+    assert p.ndim==1
+    return np.log(p)-np.log1p(-p)
+
+
+def raw_features(parent,beam=None):
+    base=logit(parent);columns=[base]
+    if beam is not None:columns.append(logit(beam)-base)
+    return base,np.ascontiguousarray(np.column_stack(columns),np.float64)
+
+
+def normalize(raw,center,scale):
+    values=(raw-np.asarray(center)[None,:])/np.asarray(scale)[None,:]
+    return np.ascontiguousarray(np.column_stack([np.ones(len(raw)),values]),np.float64)
+
+
+def sigmoid(z):
+    u=np.exp(-np.abs(z));return np.where(z>=0,1/(1+u),u/(1+u))
+
+
+def objective_gradient(weights,x,base,labels,regularization):
+    y=np.asarray(labels,np.float64);z=base+np.sum(x*weights[None,:],axis=1);penalty=np.ones(len(weights));penalty[0]=.01
+    loss=float(np.mean(np.logaddexp(0,z)-y*z)+.5*regularization*np.sum(penalty*weights*weights))
+    gradient=x.T@(sigmoid(z)-y)/len(y)+regularization*penalty*weights
+    return loss,gradient
+
+
+def predict(parent,beam,state):
+    if len(state['center'])==1:beam=None
+    base,raw=raw_features(parent,beam);x=normalize(raw,state['center'],state['scale']);z=base+np.sum(x*np.asarray(state['weights'])[None,:],axis=1)
+    return sigmoid(z).astype(np.float32)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/export.py

@@ -0,0 +1,11 @@
+"""Copy portable helpers under unique names; no data caches in the model."""
+from pathlib import Path
+import hashlib,shutil
+root=Path(__file__).resolve().parent;r=root.parent
+
+
+def install(package):
+    package=Path(package);assert not (package/'d5_prebeam_calibration_contextual.py').exists()
+    files={'d5_prebeam_calibration_contextual.py':package/'d5_contextual.py','d5_contextual.py':root/'runtime.py','beam_calibration_core.py':root/'core.py','beam_calibration_frontier.py':r/'full_frontier/beam_jax.py'}
+    for name,source in files.items():shutil.copyfile(source,package/name)
+    return {name:hashlib.sha256((package/name).read_bytes()).hexdigest() for name in files}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/fit.py

@@ -0,0 +1,104 @@
+"""Train-only small corrections, then six prespecified global validation choices."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:4])
+from pathlib import Path
+import hashlib,json,time
+import numpy as np
+from scipy.optimize import minimize
+from core import raw_features,normalize,objective_gradient,predict
+
+root=Path(__file__).resolve().parent;r=root.parent
+
+def digest(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+def write(path,value):Path(path).write_text(json.dumps(value,indent=2)+'\n')
+
+def aligned(path,ids,empty=False):
+    with np.load(path,allow_pickle=False) as f:
+        keys=f['sample_ids'];p=f['probabilities']
+        assert keys.dtype==np.uint64 and keys.ndim==1 and len(np.unique(keys))==len(keys)==len(ids)
+        assert p.dtype==np.float32 and p.shape==keys.shape and np.isfinite(p).all() and ((p>=0)&(p<=1)).all()
+        order=np.argsort(keys);positions=np.searchsorted(keys[order],ids);assert (positions<len(order)).all()
+        ix=order[positions];assert np.array_equal(keys[ix],ids)
+        flags=f['empty'][ix] if empty else np.zeros(len(ids),bool)
+        assert flags.dtype==bool and flags.shape==ids.shape
+        return p[ix],flags
+
+def main():
+    started=time.time();plan=json.loads((root/'plan.json').read_text());lock=json.loads((root/'FIT_SOURCE_LOCK.json').read_text())
+    while not all((root/k/'provenance.json').exists() for k in ['beam_training','parent_training']):
+        if time.time()-started>14400:raise TimeoutError('Training evidence incomplete')
+        time.sleep(2)
+    for path,sha in lock['source_sha256'].items():assert digest(r/path)==sha,path
+    assert json.loads((root/'control_cpu.json').read_text())['status']=='passed'
+    output=root/'fit1';output.mkdir(exist_ok=False);train=Path('/workspace/data/train');validation=Path('/workspace/data/validation')
+    train_rows={x['name']:x for x in json.loads((train/'manifest.json').read_text())['conditions']}
+    val_rows={x['name']:x for x in json.loads((validation/'manifest.json').read_text())['conditions']}
+    generation={k:json.loads((root/k/'provenance.json').read_text()) for k in ['beam_training','parent_training']}
+    reference=plan['reference'];package=Path(reference['current']['package'])
+    for filename,key in [('model_manifest.json','parent_manifest_sha256'),('model_config.json','parent_config_sha256'),('training_provenance.json','parent_provenance_sha256')]:assert digest(package/filename)==reference[key]
+    assert digest(r/'full_frontier/beam_lookahead.py')==plan['training_beam_source_sha256']
+    data={};audit=[]
+    # Validate every ID and file before any hardware-label member is opened here.
+    for name in plan['conditions']:
+        row=train_rows[name];path=train/row['arrays'];assert digest(path)==row['arrays_sha256']
+        with np.load(path,allow_pickle=False) as f:ids=f['sample_ids']
+        assert len(ids)==19880 and len(np.unique(ids))==len(ids)
+        arrays={};files={}
+        for kind in generation:
+            record=next(z for z in generation[kind]['records'] if z['condition']==name);cache=root/kind/(name+'.npz')
+            assert record['arrays_sha256']==row['arrays_sha256'] and record['shots']==len(ids)
+            assert digest(cache)==record['output_sha256'];files[kind]=record['output_sha256']
+            arrays[kind]=aligned(cache,ids,empty=kind=='beam_training')
+        parent=arrays['parent_training'][0];beam,empty=arrays['beam_training'];beam[empty]=parent[empty]
+        data[name]={'ids':ids,'parent':parent,'beam':beam}
+        audit.append({'condition':name,'shots':len(ids),'all_ids_exact_by_value':True,'arrays_sha256':row['arrays_sha256'],'cache_sha256':files,'empty_fallbacks':int(empty.sum())})
+    write(output/'training_evidence_audit.json',{'status':'passed','conditions':audit,'training_rows':sum(len(z['ids']) for z in data.values()),'label_members_opened':False,'test_data_used':False})
+    initial={basis:np.random.default_rng(seed).normal(0,.001,3) for basis,seed in plan['initial_seeds'].items()}
+    np.savez(output/'initial_weights.npz',**initial)
+    # All optimization and normalization are complete before validation labels.
+    fits=[]
+    for arm in plan['arms']:
+        for lam in plan['regularization']:
+            name=f'{arm}_lambda{lam:g}';folder=output/name;folder.mkdir();conditions=[]
+            for condition in plan['conditions']:
+                row=train_rows[condition];d=data[condition]
+                with np.load(train/row['arrays'],allow_pickle=False) as f:
+                    assert np.array_equal(f['sample_ids'],d['ids']);y=f['labels'].astype(np.float64)
+                assert y.shape==d['ids'].shape and np.isin(y,[0,1]).all()
+                base,raw=raw_features(d['parent'],None if arm=='parent_only' else d['beam']);center=raw.mean(axis=0);scale=np.maximum(raw.std(axis=0),.05);x=normalize(raw,center,scale)
+                w0=initial[row['basis']][:x.shape[1]].copy();initial_loss=objective_gradient(w0,x,base,y,lam)[0]
+                result=minimize(objective_gradient,w0,args=(x,base,y,lam),method='L-BFGS-B',jac=True,options={'maxiter':500,'gtol':1e-8,'ftol':1e-12})
+                assert result.success and np.isfinite(result.x).all(),str(result)
+                state={'condition':condition,'arm':arm,'regularization':lam,'center':center.tolist(),'scale':scale.tolist(),'weights':result.x.tolist()};write(folder/(condition+'.json'),state)
+                q=predict(d['parent'],d['beam'],state);qc=np.clip(q.astype(float),1e-7,1-1e-7)
+                conditions.append({'condition':condition,'shots':len(y),'initial_weights':w0.tolist(),'initial_objective':initial_loss,'final_objective':float(result.fun),'optimizer_iterations':int(result.nit),'function_evaluations':int(result.nfev),'optimizer_message':str(result.message),'gradient_max_abs':float(np.abs(result.jac).max()),'training_failure':float(((q>=.5)!=y).mean()),'training_nll':float((-y*np.log(qc)-(1-y)*np.log1p(-qc)).mean()),'state':state})
+            fits.append({'name':name,'arm':arm,'regularization':lam,'conditions':conditions})
+    write(output/'training.json',{'status':'complete','declared_plan':plan,'fits':fits,'initial_weights_sha256':digest(output/'initial_weights.npz'),'selection_data_opened':False,'source_lock':lock,'test_data_used':False})
+    # Existing validation beams were generated before their labels; they have no empty cases.
+    validation_report=json.loads((r/'full_frontier/r3_assessment1/report.json').read_text());val={}
+    for condition in plan['conditions']:
+        row=val_rows[condition];path=validation/row['arrays'];assert digest(path)==row['arrays_sha256']
+        with np.load(path,allow_pickle=False) as f:ids=f['sample_ids'];y=f['labels'].astype(np.float64)
+        assert len(ids)==5120 and len(np.unique(ids))==len(ids) and y.shape==ids.shape and np.isin(y,[0,1]).all()
+        beam_path=r/'full_frontier/r3_assessment1/beam_predictions'/(condition+'.npz');record=next(z for z in validation_report['generation'] if z['condition']==condition)
+        assert digest(beam_path)==record['prediction_sha256'] and record['empty_fallbacks']==0
+        beam,_=aligned(beam_path,ids);parent,_=aligned(Path(reference['current']['predictions'])/(condition+'.npz'),ids)
+        val[condition]={'ids':ids,'y':y,'parent':parent,'beam':beam}
+    assessments=[]
+    for fit in fits:
+        conditions=[];folder=output/fit['name']/'validation_predictions';folder.mkdir();variance=0.
+        for item in fit['conditions']:
+            condition=item['condition'];d=val[condition];q=predict(d['parent'],d['beam'],item['state']);y=d['y'];old=(d['parent']>=.5)!=y;new=(q>=.5)!=y;diff=old.astype(int)-new.astype(int);qc=np.clip(q.astype(float),1e-7,1-1e-7)
+            np.savez(folder/(condition+'.npz'),sample_ids=d['ids'],probabilities=q)
+            gain=float(diff.mean()/52);variance+=float(diff.var(ddof=1)/len(y)/52**2)
+            conditions.append({'condition':condition,'failure':float(new.mean()),'parent_failure':float(old.mean()),'nll':float((-y*np.log(qc)-(1-y)*np.log1p(-qc)).mean()),'corrected':int((old&~new).sum()),'introduced':int((~old&new).sum()),'P_gain':gain})
+        gain=sum(z['P_gain'] for z in conditions);assessments.append({'name':fit['name'],'arm':fit['arm'],'regularization':fit['regularization'],'conditions':conditions,'net_corrected':sum(z['corrected']-z['introduced'] for z in conditions),'P_gain':gain,'expected_full_P':reference['current']['P']+gain,'paired_naive_P_standard_error':variance**.5})
+    # Fixed ordering resolves exact ties; no basis-specific selection.
+    best=max(assessments,key=lambda x:x['expected_full_P'])
+    report={'status':'complete','assessments':assessments,'selected':best if best['P_gain']>0 else None,'reference_P':reference['current']['P'],'seconds':time.time()-started,'scope':'Six prespecified global choices across both d5r3 conditions, all other128 retained. Expected score only, no actual exported replay or publication yet. Standard errors omit selection and shot dependence. Compare then-current incumbent before any publication.','test_data_used':False}
+    write(output/'report.json',report);print(json.dumps(report,indent=2),flush=True)
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_beam_training.py

@@ -0,0 +1,34 @@
+"""CPU fullbeam training evidence, with no hardware logical-label access."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='1'
+available=sorted(os.sched_getaffinity(0));os.sched_setaffinity(0,available[4:20] if len(available)>=20 else available[:16])
+from pathlib import Path
+import hashlib,json,multiprocessing,sys,time
+import numpy as np
+root=Path(__file__).resolve().parent;r=root.parent;sys.path.insert(0,str(r/'full_frontier'))
+from beam_lookahead import prepare_lookahead,decode
+PLAN=None;LOOK=None
+
+def initialize(path):
+    global PLAN,LOOK
+    with np.load(path,allow_pickle=False) as f:PLAN={k:f[k] for k in f.files}
+    LOOK=prepare_lookahead(PLAN)
+
+def work(ds):
+    q,report=decode(PLAN,ds,per_sector=512,lookahead=LOOK)
+    return float(q),report['status']=='empty_beam'
+
+def main():
+    declared=json.loads((root/'plan.json').read_text());out=root/'beam_training';out.mkdir(exist_ok=False);records=[];rows=[z for z in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if z['distance']==5 and z['rounds']==3];started=time.time()
+    for row in rows:
+        with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:ids=f['sample_ids'];packed=f['detectors']
+        ds=np.unpackbits(packed,axis=1,count=row['num_detectors'],bitorder='little');values=[];flags=[];begin=time.time();context=multiprocessing.get_context('spawn');path=r/'full_frontier/plans'/(row['name']+'.npz')
+        with context.Pool(16,initializer=initialize,initargs=(path,)) as pool:
+            for index,(q,empty) in enumerate(pool.imap(work,ds,chunksize=8),start=1):
+                values.append(q);flags.append(empty)
+                if index%1024==0:print(json.dumps({'condition':row['name'],'completed':index,'total':len(ids),'seconds':time.time()-begin}),flush=True)
+        q=np.asarray(values,np.float32);empty=np.asarray(flags,bool);assert np.isfinite(q).all() and ((q>=0)&(q<=1)).all();output=out/(row['name']+'.npz');np.savez(output,sample_ids=ids,probabilities=q,empty=empty)
+        records.append({'condition':row['name'],'shots':len(ids),'empty_count':int(empty.sum()),'seconds':time.time()-begin,'output_sha256':hashlib.sha256(output.read_bytes()).hexdigest(),'arrays_sha256':row['arrays_sha256'],'schedule_sha256':hashlib.sha256(path.read_bytes()).hexdigest()})
+    report={'status':'complete','records':records,'seconds':time.time()-started,'scope':'All39760 supplied d5r3training syndromes, K512float64beam/float32savedprobabilities. No hardware logical-label member read. Empty flags saved for fallback to frozen parent in fitting/runtime. No model fitting or GPUwork.','test_data_used':False,'source_sha256':{str(p.relative_to(r)):hashlib.sha256(p.read_bytes()).hexdigest() for p in [Path(__file__).resolve(),r/'full_frontier/beam_lookahead.py']}};(out/'provenance.json').write_text(json.dumps(report,indent=2)+'\n')
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_parent_training.py

@@ -0,0 +1,21 @@
+"""Frozen own-parent probabilities using cached physical priors; labels unopened."""
+import os
+os.environ['JAX_PLATFORMS']='cpu';os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='4'
+os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:4])
+from pathlib import Path
+import hashlib,json,sys,time
+import numpy as np
+root=Path(__file__).resolve().parent;r=root.parent;reference=json.loads((r/'beam_r3/reference.json').read_text());package=Path(reference['current']['package']);config=json.loads((package/'model_config.json').read_text());sys.path.insert(0,str(package))
+from d5_contextual import NeuralD5Decoder
+out=root/'parent_training';out.mkdir(exist_ok=False);decoder=NeuralD5Decoder();records=[];started=time.time()
+for row in [x for x in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if x['distance']==5 and x['rounds']==3]:
+    settings=config['neural_d5'][row['group']];passes=settings['prior_pass'];cache=r/('learned_d5/full_training_priors3' if passes==3 else 'full_prior5/cache1')/(row['name']+'.npz')
+    with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:ids=f['sample_ids'];packed=f['detectors']
+    with np.load(cache,allow_pickle=False) as f:assert np.array_equal(f['sample_ids'],ids) and np.array_equal(f['indices'],np.arange(len(ids)));prior=f[f'priors{passes}']
+    parts=[];begin=time.time()
+    for start in range(0,len(ids),128):
+        parts.append(decoder.predict(package,config['conditions'][row['name']],settings,packed[start:start+128],row['num_detectors'],batch=128,initial_priors=prior[start:start+128]))
+        if start//128%16==0:print(json.dumps({'condition':row['name'],'completed':min(start+128,len(ids)),'total':len(ids),'seconds':time.time()-begin}),flush=True)
+    q=np.concatenate(parts).astype(np.float32);assert np.isfinite(q).all() and ((q>=0)&(q<=1)).all();path=out/(row['name']+'.npz');np.savez(path,sample_ids=ids,probabilities=q)
+    records.append({'condition':row['name'],'shots':len(ids),'prior_pass':passes,'arrays_sha256':row['arrays_sha256'],'prior_cache_sha256':hashlib.sha256(cache.read_bytes()).hexdigest(),'output_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'seconds':time.time()-begin})
+report={'status':'complete','reference':reference,'records':records,'seconds':time.time()-started,'scope':'All39760 supplied d5r3training syndromes with ownfrozenr3publication; cachedphysicalpriors allIDschecked, no labelmembers opened. CPUbatch128, no optimizerupdates.','test_data_used':False,'source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()};(out/'provenance.json').write_text(json.dumps(report,indent=2)+'\n')

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/package.py

@@ -0,0 +1,55 @@
+"""Assemble the selected global r3 correction on the then-current incumbent."""
+from pathlib import Path
+import hashlib,json,shutil
+from export import install
+root=Path(__file__).resolve().parent;r=root.parent
+
+def digest(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+def assemble():
+    plan=json.loads((root/'plan.json').read_text());report=json.loads((root/'fit1/report.json').read_text());selected=report['selected'];assert selected is not None
+    reference=plan['reference'];reference_package=Path(reference['current']['package']);reference_config=json.loads((reference_package/'model_config.json').read_text())
+    current=json.loads((r/'CURRENT.json').read_text());score=json.loads(Path(current['score']).read_text());out=r/'context_upgrades/beam_calibration1';out.mkdir(exist_ok=False);package=out/'package';predictions=out/'predictions'
+    shutil.copytree(current['package'],package);shutil.copytree(current['predictions'],predictions);config=json.loads((package/'model_config.json').read_text());folder=root/'fit1'/selected['name'];new_files=set();parent_copies={};history=[]
+    rows={z['name']:z for z in json.loads(Path('/workspace/data/validation/manifest.json').read_text())['conditions']};(package/'beam_calibration').mkdir()
+    def parent_copy(value,basis):
+        if isinstance(value,dict):
+            result={}
+            for key,entry in value.items():
+                if key=='weights':
+                    relative=f'weights/beam-calibration-parent-{basis}-{len(parent_copies)}.npz';shutil.copyfile(reference_package/entry,package/relative);new_files.add(relative);parent_copies[relative]={'original_relative_path':entry,'sha256':digest(package/relative)};result[key]=relative
+                else:result[key]=parent_copy(entry,basis)
+            return result
+        if isinstance(value,list):return [parent_copy(x,basis) for x in value]
+        return value
+    gain=0.
+    for assessment in selected['conditions']:
+        name=assessment['condition'];row=rows[name];group=row['group'];record=config['conditions'][name]
+        assert not config['neural_d5'][group].get('blend_turbo',False) and group not in config.get('frozen_stack',{})
+        for key in ['neural_d5_plan','plan','turbo_plan','conditional_plan']:
+            if key in record:assert digest(package/record[key])==digest(reference_package/reference_config['conditions'][name][key]),(name,key)
+        state_relative='beam_calibration/'+name+'.json';shutil.copyfile(folder/(name+'.json'),package/state_relative);new_files.add(state_relative)
+        option={'state':state_relative,'parent':parent_copy(reference_config['neural_d5'][group],row['basis'])}
+        if selected['arm']=='parent_plus_beam':
+            relative='beam_calibration/'+name+'.npz';shutil.copyfile(r/'beam_r3/plans'/(name+'.npz'),package/relative);new_files.add(relative);option.update(plan=relative,per_sector_states=512)
+        config['neural_d5'][group]['beam_calibration']={record['neural_d5_plan']:option}
+        shutil.copyfile(folder/'validation_predictions'/(name+'.npz'),predictions/(name+'.npz'))
+        incumbent=score['per_condition'][name]['errors']/score['per_condition'][name]['total'];gain+=(incumbent-assessment['failure'])/52
+        history.append({'condition':name,'then_current_failure':incumbent,'candidate_failure':assessment['failure'],'global_arm':selected['arm'],'global_regularization':selected['regularization']})
+    expected=current['P']+gain
+    assert expected>current['P']+1e-12,'Candidate no longer improves the incumbent'
+    runtime=install(package);training_sources=package/'training_sources/beam_calibration1';training_sources.mkdir()
+    for filename in ['core.py','fit.py','generate_beam_training.py','generate_parent_training.py','control_cpu.py','runtime_control.py','runtime.py','export.py','package.py','after_resource.py','plan.json','FIT_SOURCE_LOCK.json','PACKAGE_SOURCE_LOCK.json']:
+        shutil.copyfile(root/filename,training_sources/filename)
+    for filename in ['beam_lookahead.py','beam_cpu.py']:shutil.copyfile(r/'full_frontier'/filename,training_sources/filename)
+    config['architecture']='Contextual exact d3 and d5 decoders with a selected train-fitted r3 logit correction'
+    (package/'model_config.json').write_text(json.dumps(config,indent=2)+'\n')
+    provenance=json.loads((package/'training_provenance.json').read_text());provenance['beam_calibration1']={'declared_plan':plan,'training':json.loads((root/'fit1/training.json').read_text()),'training_evidence_audit':json.loads((root/'fit1/training_evidence_audit.json').read_text()),'evidence_generation':{kind:json.loads((root/kind/'provenance.json').read_text()) for kind in ['beam_training','parent_training']},'six_global_selection_results':report,'then_current_selection':history,'frozen_parent_weight_copies':parent_copies,'runtime_export_sha256':runtime,'controls':{name:json.loads((root/name).read_text()) for name in ['control_cpu.json','runtime_control_cpu.json','runtime_control_gpu.json']},'test_data_used':False}
+    provenance['previous_package_validation']=provenance.pop('package_validation');(package/'training_provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+    with (package/'README.md').open('a') as f:f.write('\nThe selected d5 three-round correction fits a small regularized logit model on all39,760 corresponding training shots. Parent-only and parent-plus-full-DEM-beam arms were compared with three fixed regularization values globally across both bases. The parent networks are frozen session-trained models. Feature normalization uses training only, and sample IDs never enter the model. Inference computes all evidence from input syndromes and packaged geometry; no cached predictions are packaged.\n')
+    manifest=json.loads((package/'model_manifest.json').read_text());paths={z['path'] for z in manifest['checkpoints']}|new_files
+    manifest['checkpoints']=[{'path':p,'sha256':digest(package/p),'format':'npz' if p.endswith('.npz') else 'json' if p.endswith('.json') else 'stim-dem'} for p in sorted(paths)];(package/'model_manifest.json').write_text(json.dumps(manifest,indent=2)+'\n')
+    candidate={'package':str(package),'predictions':str(predictions),'score':str(out/'score.json'),'expected_P':expected,'selection':history,'validation_metadata':{'prediction_generation':'Two cached calibration predictions replace the corresponding incumbent conditions; all26d5 actual replay required before publication.','runtime_evidence':'Full actual d5 replay and workload projection remain required; optional beam adds inference cost.'}}
+    (out/'candidate.json').write_text(json.dumps(candidate,indent=2)+'\n');print(json.dumps(candidate,indent=2),flush=True)
+
+if __name__=='__main__':assemble()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/plan.json

@@ -0,0 +1,91 @@
+{
+  "name": "beam_calibration1",
+  "status": "Declared before fitting; training evidence caches starting CPUonly",
+  "created_utc": "2026-10-21T20:21:49.646611+00:00",
+  "hypothesis": "The fullDEM beam supplies complementary probabilities but raw/equalr3globalchoices failed. Fit a small train-only correction; matchedparent-only arm identifies whether beam is needed. No accuracy improvement claimed.",
+  "reference": {
+    "current": {
+      "package": "/run-state/workspace/research/context_upgrades/r3_pattern1/package",
+      "predictions": "/run-state/workspace/research/context_upgrades/r3_pattern1/predictions",
+      "score": "/run-state/workspace/research/context_upgrades/r3_pattern1/score.json",
+      "P": 0.76744384765625
+    },
+    "records": [
+      {
+        "condition": "surface_code_bX_d5_r03_center_5_5",
+        "group": "d5_bX_center_5_5",
+        "record": {
+          "dem": "dems/surface_code_bX_d5_r03_center_5_5.dem",
+          "circuit_sha256": "1cbfca6766d1e142e35233b2cbeeb039f41aebf5179c46acbd45824d928a78a6",
+          "conditional_plan": "conditional_plans/surface_code_bX_d5_r03_center_5_5.npz",
+          "turbo_plan": "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz",
+          "neural_d5_plan": "neural_d5_plans/surface_code_bX_d5_r03_center_5_5.npz"
+        },
+        "parent_settings": {
+          "confidence_joint": {
+            "weights": "weights/confidence-joint1-1024.npz"
+          },
+          "prior_pass": 3,
+          "blend_turbo": false
+        },
+        "plan_file": "plans/surface_code_bX_d5_r03_center_5_5.npz",
+        "plan_sha256": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d",
+        "source_schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8",
+        "source_DEM_sha256": "b0f53a8924b9c471b5f574382d8162f5eef40e5003a85a15fcb62335a0af0e4c"
+      },
+      {
+        "condition": "surface_code_bZ_d5_r03_center_5_5",
+        "group": "d5_bZ_center_5_5",
+        "record": {
+          "dem": "dems/surface_code_bZ_d5_r03_center_5_5.dem",
+          "circuit_sha256": "12b124311b84adfeeb4aa4e61b9b11707691692ee807a13cfd90ee73cf733f6c",
+          "conditional_plan": "conditional_plans/surface_code_bZ_d5_r03_center_5_5.npz",
+          "turbo_plan": "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz",
+          "neural_d5_plan": "neural_d5_plans/surface_code_bZ_d5_r03_center_5_5.npz"
+        },
+        "parent_settings": {
+          "weights": "weights/prior-pass1-pass5-0.npz",
+          "prior_pass": 5,
+          "blend_turbo": false,
+          "training_checkpoint": "prior_pass1/pass5/0"
+        },
+        "plan_file": "plans/surface_code_bZ_d5_r03_center_5_5.npz",
+        "plan_sha256": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d",
+        "source_schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7",
+        "source_DEM_sha256": "ed3409474d22d849cdc7b3deb9ded28d70aeff4a53cfb4a56a0d7411f5b57f88"
+      }
+    ],
+    "parent_manifest_sha256": "112a3c67e31cae326474ee93b1454382c8a14cc59900ff86344113d727fe4ce0",
+    "parent_config_sha256": "35badea7d1c73ab42edcb1193eff22613ad6f8aa0d8281596fe2c1fd78d73925",
+    "parent_provenance_sha256": "953d23dedc55520b654852a848cca45c0e555be23ff433f1368c5b5de1580df8",
+    "scope": "Nonlearned fullDEM schedules from authorized inputs, combined only with own session-trained parent. No syndrome/label/ID rows or predictions serialized as model state.",
+    "test_data_used": false
+  },
+  "training_rows": 39760,
+  "conditions": [
+    "surface_code_bX_d5_r03_center_5_5",
+    "surface_code_bZ_d5_r03_center_5_5"
+  ],
+  "beam_states_per_sector": 512,
+  "arms": [
+    "parent_only",
+    "parent_plus_beam"
+  ],
+  "regularization": [
+    0.0001,
+    0.001,
+    0.01
+  ],
+  "initial_seeds": {
+    "X": 20262100,
+    "Z": 20262101
+  },
+  "initialization": "Three coefficients perbasis drawnNormal(0,.001); parent_only uses firsttwo ofsameinitialvector, parent_plus_beam allthree. Eachlambda startsfromsamebasisinitialarray. No expert weights updated.",
+  "features": "Base offset logit(parent). Features parentlogit and beamlogit-minus-parentlogit, bothprobabilities clipped1e-7..1-1e-7 in float64. Center/scale fit onlyontraining, scalefloor.05; prependbias. Parent_only usesbiasandparentfeature.",
+  "loss": "Mean logicalBCE +.5lambda sum(weights^2*[.01,1,1]); independent perbasisfits, fullbatchL-BFGS-B max500,gtol1e-8,ftol1e-12.",
+  "selection": "Sixglobal(arm,lambda)choices across bothd5r3conditions againstfrozenownpublishedreference, full5120validationrows each; other128conditionsretained. No perbasisarm/lambdaselection. ActualGPU/portable/fullreplay/trustedscore/relocation/runtimebudgetrequired beforepublication; comparethen-currentstrongest.",
+  "fallback": "Emptybeam usesfrozenparent probability before featureconstruction. Parent_onlydoesnotexecute a beam ininference.",
+  "test_data_used": false,
+  "training_beam_source_sha256": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5",
+  "reference_sha256": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701"
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime.py

@@ -0,0 +1,37 @@
+"""Portable train-fitted logit correction, with optional full-DEM beam evidence."""
+import json
+import numpy as np
+from d5_prebeam_calibration_contextual import NeuralD5Decoder as PreviousDecoder
+from beam_calibration_core import predict as calibrate
+
+
+class NeuralD5Decoder(PreviousDecoder):
+    def __init__(self):
+        super().__init__();self.beam_calibration_states={};self.beam_calibration_engines={}
+
+    def predict(self,root,record,settings,packed,num_detectors,batch=512,initial_priors=None,**kwargs):
+        option=settings.get('beam_calibration',{}).get(record.get('neural_d5_plan',''))
+        if option is None:return super().predict(root,record,settings,packed,num_detectors,batch,initial_priors=initial_priors,**kwargs)
+        state_path=option['state']
+        if state_path not in self.beam_calibration_states:
+            state=json.loads((root/state_path).read_text());width=len(state['center'])
+            assert width in [1,2] and len(state['scale'])==width and len(state['weights'])==width+1
+            assert np.isfinite(np.array(state['weights']+state['center']+state['scale'])).all() and (np.array(state['scale'])>0).all()
+            self.beam_calibration_states[state_path]=state
+        state=self.beam_calibration_states[state_path];parent_settings=option['parent']
+        parent_priors=initial_priors if settings.get('prior_pass')==parent_settings.get('prior_pass') else None
+        parent=super().predict(root,record,parent_settings,packed,num_detectors,batch,initial_priors=parent_priors,**kwargs)
+        if len(state['center'])==1:return calibrate(parent,None,state)
+        import jax
+        from beam_calibration_frontier import make_decoder
+        path=option['plan'];states=int(option['per_sector_states']);assert states==512
+        if path not in self.beam_calibration_engines:
+            with np.load(root/path,allow_pickle=False) as f:plan={k:f[k] for k in f.files}
+            assert int(plan['num_detectors'])==num_detectors and int(plan['width'])<=30
+            fn=make_decoder(int(plan['width']),states);arguments=[jax.device_put(plan[k]) for k in ['probabilities','masks','measured','detector_lookup','future','active']]
+            self.beam_calibration_engines[path]=(fn,arguments)
+        fn,arguments=self.beam_calibration_engines[path];dets=np.unpackbits(packed,axis=1,count=num_detectors,bitorder='little');parts=[];flags=[]
+        for start in range(0,len(dets),batch):
+            ds=dets[start:start+batch];n=len(ds);ds=np.pad(ds,((0,batch-n),(0,0)));q,empty=fn(ds,*arguments);parts.append(np.asarray(q)[:n]);flags.append(np.asarray(empty)[:n])
+        beam=np.concatenate(parts).astype(np.float32);empty=np.concatenate(flags);beam[empty]=parent[empty]
+        return calibrate(parent,beam,state)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime_control.py

@@ -0,0 +1,42 @@
+"""Portable numerical composition with nonzero synthetic correction coefficients."""
+import os,argparse
+p=argparse.ArgumentParser();p.add_argument('--device',choices=['cpu','gpu'],default='cpu');args=p.parse_args()
+os.environ['JAX_PLATFORMS']='cpu' if args.device=='cpu' else 'cuda';os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='1';os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:(4 if args.device=='cpu' else 22)])
+from pathlib import Path
+import hashlib,importlib.util,json,shutil,sys,tempfile,time
+import numpy as np
+import jax
+from export import install
+from core import predict
+root=Path(__file__).resolve().parent;r=root.parent;reference=json.loads((root/'plan.json').read_text())['reference'];package=Path(reference['current']['package']);config=json.loads((package/'model_config.json').read_text());probes=json.loads((r/'full_frontier/uncertain_r3_probes.json').read_text())['records'];numeric=json.loads((r/'full_frontier/beam_uncertain_r3_cpu.json').read_text())['records'];rows=json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'];checks=[];batch=4 if args.device=='cpu' else 512
+assert jax.default_backend()==args.device
+with tempfile.TemporaryDirectory(prefix='beam-calibration-control-') as temporary:
+    target=Path(temporary)/'package';shutil.copytree(package,target);exported=install(target);(target/'beam_calibration').mkdir();sys.path.insert(0,str(target))
+    from d5_prebeam_calibration_contextual import NeuralD5Decoder as Old
+    spec=importlib.util.spec_from_file_location('calibration_export_control',target/'d5_contextual.py');module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);old,new=Old(),module.NeuralD5Decoder()
+    for probe in probes:
+        row=next(x for x in rows if x['name']==probe['condition']);record=config['conditions'][row['name']];parent_settings=config['neural_d5'][row['group']];indices=np.array(probe['input_array_positions']);passes=parent_settings['prior_pass']
+        with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:packed=f['detectors'][indices];ids=f['sample_ids'][indices]
+        assert np.array_equal(ids,np.array(probe['sample_ids'],np.uint64));prior_path=r/('learned_d5/full_training_priors3' if passes==3 else 'full_prior5/cache1')/(row['name']+'.npz')
+        with np.load(prior_path,allow_pickle=False) as f:assert np.array_equal(f['sample_ids'][indices],ids);prior=f[f'priors{passes}'][indices]
+        relative='beam_calibration/'+row['name']+'.npz';shutil.copyfile(r/'beam_r3/plans'/(row['name']+'.npz'),target/relative);expected_beam=np.array(next(z['probabilities'] for z in numeric if z['condition']==row['name'] and z['method']=='independent' and z['per_sector_states']==512),np.float32)
+        parent=old.predict(target,record,parent_settings,packed,row['num_detectors'],batch=batch,initial_priors=prior)
+        for width in [1,2]:
+            state={'center':[.12,-.03][:width],'scale':[2.1,.8][:width],'weights':[.03,-.09,.12][:width+1]};state_path='beam_calibration/'+row['name']+f'_width{width}.json';(target/state_path).write_text(json.dumps(state))
+            option={'state':state_path,'plan':relative,'per_sector_states':512,'parent':parent_settings};settings={**parent_settings,'beam_calibration':{record['neural_d5_plan']:option}}
+            old_engines=set(new.beam_calibration_engines);begin=time.time();actual=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch,initial_priors=prior);seconds=time.time()-begin;expected=predict(parent,expected_beam,state);delta=float(abs(expected-actual).max());assert delta<1e-4 and ((expected>=.5)==(actual>=.5)).all()
+            if width==1:assert set(new.beam_calibration_engines)==old_engines and np.array_equal(expected,actual)
+            reverse=new.predict(target,record,settings,packed[::-1].copy(),row['num_detectors'],batch=batch,initial_priors=prior[::-1].copy());single=new.predict(target,record,settings,packed[:1],row['num_detectors'],batch=batch,initial_priors=prior[:1]);assert np.array_equal(reverse,actual[::-1]) and np.array_equal(single,actual[:1])
+            live=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch);live_delta=float(abs(live-actual).max());assert live_delta<1e-4 and ((live>=.5)==(actual>=.5)).all()
+            checks.append({'condition':row['name'],'feature_width':width,'batch':batch,'shots':len(packed),'independent_composition_max_abs':delta,'decisions_equal':True,'order_subset_exact':True,'no_new_beam_for_parent_only':width==1,'live_cached_max_abs':live_delta,'first_call_seconds':seconds})
+        with np.load(target/relative,allow_pickle=False) as f:empty_plan={k:f[k] for k in f.files}
+        empty_plan['probabilities']=np.zeros_like(empty_plan['probabilities']);empty_relative='beam_calibration/empty_'+row['name']+'.npz';np.savez(target/empty_relative,**empty_plan)
+        settings['beam_calibration'][record['neural_d5_plan']]['plan']=empty_relative;fallback=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch,initial_priors=prior);assert np.array_equal(fallback,predict(parent,parent,state));checks.append({'condition':row['name'],'forced_empty_before_feature_fallback_exact':True})
+    for basis,rounds in [('X',1),('Z',25)]:
+        row=next(z for z in rows if z['distance']==5 and z['basis']==basis and z['rounds']==rounds);record=config['conditions'][row['name']];settings={**config['neural_d5'][row['group']],'beam_calibration':{'unused_plan':{}}}
+        with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:packed=f['detectors'][:2]
+        a=old.predict(target,record,config['neural_d5'][row['group']],packed,row['num_detectors'],batch=batch);b=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch);assert np.array_equal(a,b);checks.append({'condition':row['name'],'retained_current_path_exact':True})
+    peak=int((jax.devices()[0].memory_stats() or {}).get('peak_bytes_in_use',0));assert peak<75*1024**3
+report={'status':'passed','device':str(jax.devices()[0]),'checks':checks,'peak_gpu_bytes':peak,'scope':'Exported wrapper with specified nonzero synthetic correction coefficients; no hardware labels or fitting. Independent NumPy beam/reference-parent composition, parent-only path, order/subsets, live conditioning, forced empty-before-feature fallback and retained paths. GPU mode uses production B512.','exported_source_sha256':exported,'test_data_used':False,'source_sha256':{str(p.relative_to(r)):hashlib.sha256(p.read_bytes()).hexdigest() for p in [root/'runtime.py',root/'export.py',root/'core.py',Path(__file__).resolve(),r/'full_frontier/beam_jax.py']}}
+(root/f'runtime_control_{args.device}.json').write_text(json.dumps(report,indent=2)+'\n');print(json.dumps(report,indent=2),flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/verify_during_recovery.py

@@ -0,0 +1,21 @@
+"""Use the current idle GPU window; resume trajectory only after this marker."""
+from pathlib import Path
+import hashlib,json,shutil,subprocess
+root=Path(__file__).resolve().parent;r=root.parent
+assert not subprocess.check_output(['nvidia-smi','--query-compute-apps=pid','--format=csv,noheader'],text=True).strip()
+assert json.loads((r/'block_physical/benchmark_finished.json').read_text())['complete']
+assert not (r/'feedback_trajectory/trajectory1').exists()
+for lock in ['FIT_SOURCE_LOCK.json','PACKAGE_SOURCE_LOCK.json']:
+    for path,digest in json.loads((root/lock).read_text())['source_sha256'].items():assert hashlib.sha256((r/path).read_bytes()).hexdigest()==digest,path
+for filename in ['control_cpu.json','runtime_control_cpu.json']:
+    report=json.loads((root/filename).read_text());assert report['status']=='passed'
+    for path,digest in report['source_sha256'].items():
+        source=r/path if '/' in path else root/path;assert hashlib.sha256(source.read_bytes()).hexdigest()==digest,path
+current=json.loads((r/'CURRENT.json').read_text());selected=json.loads((root/'fit1/report.json').read_text())['selected'];assert selected['arm']=='parent_only'
+subprocess.run(['python',str(r/'run_limited.py'),str(root/'runtime_control.py'),'--device','gpu'],check=True)
+subprocess.run(['python',str(root/'package.py')],check=True);out=r/'context_upgrades/beam_calibration1';package=out/'package'
+provenance=json.loads((package/'training_provenance.json').read_text());provenance['beam_calibration1']['queue_amendment']=json.loads((root/'QUEUE_AMENDMENT.json').read_text());provenance['beam_calibration1']['verification_controller_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest();(package/'training_provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+for filename in ['QUEUE_AMENDMENT.json','verify_during_recovery.py']:shutil.copyfile(root/filename,package/'training_sources/beam_calibration1'/filename)
+subprocess.run(['python',str(r/'verify_d5_candidate.py'),str(out)],check=True)
+subprocess.run(['python',str(r/'audit_completed_candidate.py'),'--candidate',str(out),'--previous',current['predictions']],check=True)
+done=json.loads((out/'finished.json').read_text());(root/'beam_calibration1_finished.json').write_text(json.dumps({'complete':True,'published':done['published'],'queue_amended':True,'test_data_used':False})+'\n')

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__data.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_plan,parse_errors
+
+
+def _attach_arrays(item,root,splits):
+    row=item['row']
+    for split in splits:
+        a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little')
+        item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1])))
+        item[split+'_labels']=a['labels']
+
+
+def load_all(max_ops=3072,splits=('train','validation')):
+    assert set(splits)<=set(['train','validation'])
+    root=Path('/workspace/data')
+    rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3]
+    groups=sorted({r['group'] for r in rows});result=[]
+    cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}'
+    cache.mkdir(exist_ok=True)
+    for row in rows:
+        cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz"
+        if cached.exists():
+            item=dict(np.load(cached,allow_pickle=False));item['row']=row
+            _attach_arrays(item,root,splits);result.append(item);continue
+        dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem)
+        assert int(plan['width'])<=10
+        count=len(plan['masks']);assert count<=max_ops,(row['name'],count)
+        coords=dem.get_detector_coordinates()
+        circuit=stim.Circuit.from_file(root/'train'/row['circuit'])
+        qubit_coords=circuit.get_final_qubit_coordinates()
+        first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+        spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy())
+        assert len(spaces)==8
+        idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+        errors=parse_errors(dem)
+        context=np.full((max_ops,40),200,np.int32)
+        static=np.zeros((max_ops,57),np.float32)
+        for op,source in enumerate(plan['source_indices']):
+            if source<0:continue
+            ds,logical,p=errors[source]
+            t=min(int(coords[d][2]) for d in ds) if ds else 0
+            for dt in range(-2,3):
+                for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200)
+            for d in ds:
+                c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1
+            static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8
+            static[op,41]=logical;static[op,42]=len(ds)/4
+            static[op,43]=t/25;static[op,44]=row['rounds']/25
+            static[op,45]=t==0;static[op,46]=t>=row['rounds']-1
+            static[op,47+groups.index(row['group'])]=1
+            static[op,55]=row['basis']=='X';static[op,56]=1
+        masks=np.pad(plan['masks'],(0,max_ops-count))
+        measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1)
+        p=np.pad(plan['probabilities'],(0,max_ops-count))
+        valid=((p>0)&(measured<0)).astype(np.float32)
+        logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32)
+        item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid}
+        grid=np.full((26,8),200,np.int32)
+        measurement_indices=np.full(201,208,np.int32)
+        for detector,c in coords.items():
+            t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector
+            measurement_indices[detector]=t*8+s
+        item['grid']=grid;item['measurement_indices']=measurement_indices
+        item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32)
+        temporary=cached.with_suffix('.tmp.npz')
+        np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached)
+        _attach_arrays(item,root,splits)
+        result.append(item)
+    return result

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__gradient.py

@@ -0,0 +1,43 @@
+"""Differentiable conditional logical likelihood through exact DEM elimination."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width):
+    indices=jnp.arange(1<<width,dtype=jnp.int32)
+    @jax.jit
+    def evaluate(dets,labels,probabilities,masks,measured):
+        # Per-shot error probabilities have shape [operations,batch].
+        f=jnp.zeros((len(dets),1<<width),jnp.float32).at[:,0].set(1)
+        def forward(f,args):
+            p,mask,d=args
+            def error(f):
+                return (1-p[:,None])*f+p[:,None]*f[:,indices^mask],jnp.ones(len(dets))
+            def project(f):
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],norm
+            out,norm=jax.lax.cond(d<0,error,project,f)
+            return out,(f,norm)
+        f,(history,norms)=jax.lax.scan(forward,f,(probabilities,masks,measured))
+        indicator=((indices[None,:]&1)==labels[:,None])
+        correct=jnp.maximum(jnp.sum(f*indicator,axis=1),1e-10)
+        predicted=jnp.sum(f[:,1::2],axis=1)
+        initial=1-indicator/correct[:,None]
+        def backward(b,args):
+            p,mask,d,old,norm=args
+            def error(b):
+                flipped=b[:,indices^mask]
+                grad=jnp.sum(old*(flipped-b),axis=1)
+                return (1-p[:,None])*b+p[:,None]*flipped,grad
+            def project(b):
+                obs=((indices[None,:]&mask)==dets[:,d,None].astype(jnp.int32)*mask)
+                values=b[:,indices&~mask]
+                mean=jnp.sum(old*obs*values,axis=1)/norm
+                prior=(values-mean[:,None])*obs/norm[:,None]
+                return prior,jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        _,grad=jax.lax.scan(backward,initial,(probabilities,masks,measured,history,norms),reverse=True)
+        return -jnp.log(correct),predicted,grad
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__temporal_accumulate_train.py

@@ -0,0 +1,158 @@
+# Derived from temporal_train.py SHA256 7d48d2fc7f62d0bec3023b3df1c2ac28537d0417966131ae3a156697a34cda5f; separate matched condition-mixing experiment.
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+from pathlib import Path
+import argparse,json,time,sys,hashlib,shutil
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from temporal_model import initialize_from_rich,probabilities
+from data import load_all
+from gradient import make_loss_and_grad
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_decoder
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--steps',type=int,default=512);parser.add_argument('--batch',type=int,default=128)
+    parser.add_argument('--output',type=Path,required=True);parser.add_argument('--validation-shots',type=int,default=1024)
+    parser.add_argument('--init-weights',type=Path)
+    parser.add_argument('--rich-checkpoint',type=Path,required=True)
+    parser.add_argument('--learning-rate',type=float,default=1e-3)
+    parser.add_argument('--eval-every',type=int,default=256)
+    parser.add_argument('--seed',type=int,default=20261025)
+    parser.add_argument('--validation-batch',type=int,default=1024)
+    parser.add_argument('--uniform-validation',action='store_true')
+    parser.add_argument('--accumulate-conditions',type=int,default=4)
+    parser.add_argument('--condition-policy',choices=['same','mixed'],default='mixed')
+    parser.add_argument('--reset-optimizer',action='store_true')
+    parser.add_argument('--reset-rng',action='store_true')
+    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
+    assert args.accumulate_conditions>=1
+    run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()}
+    run_config['original_random_seed']=20261030
+    run_config['feature_mode']='events+measurements+global_density+temporal_convolutions'
+    run_config['temporal_seed']=20261104
+    run_config['rich_checkpoint_sha256']=hashlib.sha256(args.rich_checkpoint.read_bytes()).hexdigest()
+    run_config['hidden_width']=128
+    run_config['logit_correction_bound']=4
+    run_config['starting_checkpoint_sha256']=hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None
+    run_config['train_manifest_sha256']=hashlib.sha256(Path('/workspace/data/train/manifest.json').read_bytes()).hexdigest()
+    run_config['validation_manifest_sha256']=hashlib.sha256(Path('/workspace/data/validation/manifest.json').read_bytes()).hexdigest()
+    source_root=Path(__file__).resolve().parent;research=source_root.parent
+    snapshot=args.output/'training_source';snapshot.mkdir(exist_ok=True)
+    source_hashes={}
+    for source in [Path(__file__).resolve(),source_root/'temporal_model.py',source_root/'data.py',source_root/'gradient.py',research/'exact_d3/exact.py']:
+        name=str(source.relative_to(research)).replace('/','__')
+        shutil.copyfile(source,snapshot/name);source_hashes[name]=hashlib.sha256(source.read_bytes()).hexdigest()
+    run_config['training_source_sha256']=source_hashes
+    run_config['runtime_versions']={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__}
+    (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n')
+    t=time.time();dataset=load_all();print(json.dumps({'loaded':len(dataset),'seconds':time.time()-t}),flush=True)
+    seen=[np.zeros(len(item['train_labels']),bool) for item in dataset]
+    assert len({len(item['train_labels']) for item in dataset})==1, 'Matched RNG protocol assumes equal condition sizes'
+    parameters=({k:jnp.asarray(v) for k,v in dict(np.load(args.init_weights,allow_pickle=False)).items()} if args.init_weights else initialize_from_rich(args.rich_checkpoint,seed=20261104))
+    optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(learning_rate=args.learning_rate,weight_decay=1e-4))
+    state=optimizer.init(parameters);exact_gradient=make_loss_and_grad(10)
+    rng=np.random.default_rng(args.seed);optimizer_restored=False;rng_restored=False
+    if args.init_weights:
+        optfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','optimizer-'))
+        if optfile.exists() and not args.reset_optimizer:
+            leaves,treedef=jax.tree_util.tree_flatten(state);saved=np.load(optfile,allow_pickle=False)
+            assert len(leaves)==len(saved.files)
+            state=jax.tree_util.tree_unflatten(treedef,[jnp.asarray(saved[f'arr_{i}']) for i in range(len(leaves))]);optimizer_restored=True
+        rngfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','rng-')).with_suffix('.json')
+        if rngfile.exists() and not args.reset_rng:rng.bit_generator.state=json.loads(rngfile.read_text());rng_restored=True
+    @jax.jit
+    def batch_gradient(parameters,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters)
+        loss,pred,g=exact_gradient(ds,ys,p,masks,measured)
+        grads=pullback(g/len(ds))[0]
+        return grads,jnp.mean(loss),jnp.mean((pred>=.5)!=ys)
+    @jax.jit
+    def apply_gradient(parameters,state,grads):
+        changes,state=optimizer.update(grads,state,parameters)
+        return optax.apply_updates(parameters,changes),state,optax.global_norm(grads)
+    exact_decode=make_decoder(10)
+    @jax.jit
+    def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts)
+        return exact_decode(ds,p,masks,measured)
+    def evaluate(step):
+        results=[];start=time.time()
+        for item in dataset:
+            n=min(args.validation_shots,len(item['validation_labels']));pred=[]
+            selected=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False) if args.uniform_validation else np.arange(n)
+            vd=item['validation_dets'][selected];vy=item['validation_labels'][selected]
+            for begin in range(0,n,args.validation_batch):
+                ds=vd[begin:begin+args.validation_batch];size=len(ds)
+                ds=np.pad(ds,((0,args.validation_batch-size),(0,0)))
+                p=np.asarray(infer(parameters,ds,*[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]))[:size]
+                pred.append(p)
+            p=np.concatenate(pred)
+            pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64)
+            results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)),
+                'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp))),
+                'brier':float(np.mean((p-vy)**2))})
+        result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])),
+                'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])),
+                'seconds':time.time()-start,'conditions':results}
+        (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n')
+        np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()})
+        leaves,_=jax.tree_util.tree_flatten(state)
+        np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+        (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+        (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'new_training_shots':step*args.batch*args.accumulate_conditions,
+            'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+            'weights':f'weights-{step}.npz','weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(),
+            'validation':f'validation-{step}.json','complete':True},indent=2)+'\n')
+        print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True)
+    evaluate(0)
+    records=[]
+    for step in range(1,args.steps+1):
+        # Both arms consume the same condition and row RNG draws. The control
+        # reuses the first condition; the mixed arm uses every drawn condition.
+        sampled_conditions=rng.integers(len(dataset),size=args.accumulate_conditions)
+        total_grads=None;loss=0.;error=0.
+        for microbatch in range(args.accumulate_conditions):
+            condition_index=int(sampled_conditions[0 if args.condition_policy=='same' else microbatch])
+            item=dataset[condition_index]
+            ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True
+            grads,part_loss,part_error=batch_gradient(parameters,item['train_dets'][ix],item['train_labels'][ix],
+                *[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']])
+            total_grads=grads if total_grads is None else jax.tree_util.tree_map(jnp.add,total_grads,grads)
+            loss+=part_loss/args.accumulate_conditions;error+=part_error/args.accumulate_conditions
+        total_grads=jax.tree_util.tree_map(lambda g:g/args.accumulate_conditions,total_grads)
+        parameters,state,norm=apply_gradient(parameters,state,total_grads)
+        if step%16==0 or step==1:
+            record={'step':step,'loss':float(loss),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-t}
+            records.append(record);print(json.dumps(record),flush=True)
+            if not np.isfinite(record['loss']):raise ValueError('Nonfinite training loss')
+        if step%args.eval_every==0 or step==args.steps:evaluate(step)
+    provenance={'initialization':('Continue from this session\'s trained checkpoint' if args.init_weights else 'Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now'),
+        'original_initialization':'Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)',
+        'rich_starting_checkpoint':str(args.rich_checkpoint),
+        'rich_checkpoint_sha256':hashlib.sha256(args.rich_checkpoint.read_bytes()).hexdigest(),
+        'architecture':'Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.',
+        'training':'Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only',
+        'training_source_sha256':source_hashes,'runtime_versions':run_config['runtime_versions'],
+        'eligible_training_shots':sum(len(item['train_labels']) for item in dataset),
+        'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+        'unique_rows_by_condition':{item['row']['name']:int(x.sum()) for item,x in zip(dataset,seen)},
+        'steps':args.steps,'batch_size':args.batch,'accumulate_conditions':args.accumulate_conditions,
+        'effective_batch_size':args.batch*args.accumulate_conditions,'condition_policy':args.condition_policy,
+        'training_draws':args.steps*args.batch*args.accumulate_conditions,
+        'condition_sampling':'Draw one condition index per microbatch in both arms; same-condition control reuses the first index while mixed arm uses all indices. Both arms consume identical RNG draws with equal-sized condition pools.','optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1',
+        'learning_rate':args.learning_rate,'sampling_seed':args.seed,'optimizer_restored':optimizer_restored,'rng_restored':rng_restored,'explicit_optimizer_reset':args.reset_optimizer,'explicit_rng_reset':args.reset_rng,
+        'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}',
+        'session_trained_starting_checkpoint':str(args.init_weights) if args.init_weights else None,
+        'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None,
+        'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None,
+        'loss':'Binary conditional logical likelihood computed by exact frontier elimination',
+        'validation_shots_per_condition':args.validation_shots,'uniform_validation':args.uniform_validation,
+        'uniform_validation_seed':20261028 if args.uniform_validation else None,'test_data_used':False,'log':records}
+    (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__temporal_model.py

@@ -0,0 +1,44 @@
+"""Long temporal context for contextual exact d3 decoding."""
+import numpy as np
+import jax
+import jax.numpy as jnp
+
+
+def initialize_from_rich(path,seed=20261104,channels=32):
+    parameters={k:jnp.asarray(v) for k,v in dict(np.load(path,allow_pickle=False)).items()}
+    keys=jax.random.split(jax.random.key(seed),6)
+    parameters['w1']=jnp.concatenate([parameters['w1'],jax.random.normal(keys[0],(channels,parameters['w1'].shape[1]))*.001],axis=0)
+    parameters['temporal_in']=jax.random.normal(keys[1],(24,channels))*jnp.sqrt(2/24)
+    parameters['temporal_bias']=jnp.zeros(channels)
+    for i in range(4):
+        parameters[f'temporal_conv_{i}']=jax.random.normal(keys[i+2],(3,channels,channels))*jnp.sqrt(1/(3*channels))
+        parameters[f'temporal_conv_bias_{i}']=jnp.zeros(channels)
+    return parameters
+
+
+def probabilities(parameters,dets,context_indices,static,base_logits,valid,grid,measurement_indices,counts):
+    event_grid=dets[:,grid]
+    measurement_grid=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    observed=(grid!=200).astype(jnp.float32)
+    frames=jnp.concatenate([event_grid.astype(jnp.float32),measurement_grid*observed[None,:,:],
+        jnp.broadcast_to(observed[None,:,:],event_grid.shape)],axis=-1)
+    temporal=jax.nn.silu(frames@parameters['temporal_in']+parameters['temporal_bias'])
+    for i,dilation in enumerate([1,2,4,8]):
+        mean=jnp.mean(temporal,axis=-1,keepdims=True)
+        normalized=(temporal-mean)*jax.lax.rsqrt(jnp.mean((temporal-mean)**2,axis=-1,keepdims=True)+1e-5)
+        value=jax.lax.conv_general_dilated(normalized,parameters[f'temporal_conv_{i}'],(1,),padding='SAME',
+            rhs_dilation=(dilation,),dimension_numbers=('NWC','WIO','NWC'))
+        temporal=temporal+jax.nn.silu(value+parameters[f'temporal_conv_bias_{i}'])
+    times=jnp.clip(jnp.rint(static[:,43]*25).astype(jnp.int32),0,25)
+    temporal_context=temporal[:,times,:]
+    measured=jnp.pad(measurement_grid.reshape(len(dets),208),((0,0),(0,1)))
+    events=dets[:,context_indices].astype(jnp.float32)
+    measurements=measured[:,measurement_indices[context_indices]].astype(jnp.float32)
+    density=jnp.sum(event_grid,axis=1)/counts[None,:]
+    features=jnp.concatenate([events,measurements,
+        jnp.broadcast_to(density[:,None,:],(len(dets),len(context_indices),8)),
+        jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),temporal_context],axis=-1)
+    h=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    h=jax.nn.silu(h@parameters['w2']+parameters['b2'])
+    delta=4*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0])
+    return (jax.nn.sigmoid(base_logits[None,:]+delta)*valid[None,:]).T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint.py

@@ -0,0 +1,38 @@
+"""Prototype confidence-aware gate; not yet a trained or queued candidate."""
+import jax.numpy as jnp
+from joint_mixture import gate_features as syndrome_features
+from joint_mixture import initialize_gate as initialize_base_gate
+from joint_mixture import gate_logit, mixture_terms, mix_predictions
+
+GATE_FEATURES = 45
+
+
+def confidence_features(predictions):
+    """Four bounded shot-local features; no labels or batch statistics."""
+    p = jnp.clip(predictions, 1e-6, 1-1e-6)
+    z = jnp.clip(jnp.log(p)-jnp.log1p(-p), -8., 8.)/8
+    return jnp.concatenate([z,jnp.sqrt(z*z+1e-4)],axis=1)
+
+
+def gate_features(dets, grid, static, predictions):
+    result = jnp.concatenate([syndrome_features(dets,grid,static),confidence_features(predictions)],axis=1)
+    assert result.shape==(len(dets),GATE_FEATURES)
+    return result
+
+
+def initialize_gate(seed, hidden=32):
+    """Preserve the original seeded 41-input trunk; append zero new-input rows."""
+    gate = initialize_base_gate(seed,hidden)
+    gate['w1'] = jnp.concatenate([gate['w1'],jnp.zeros((4,hidden),gate['w1'].dtype)],axis=0)
+    return gate
+
+
+def expert_adjoint_factors(losses, labels, responsibility, gate_prediction_adjoint):
+    """Per-shot factors on expert BCE adjoints, including the confidence path.
+
+    gate_prediction_adjoint is dL/dq through the gate only, for each per-shot
+    loss (not its batch mean). dq/dedge=(1-2*y)*exp(-BCE)*dBCE/dedge.
+    Labels enter this loss derivative only; all gate inputs use predictions.
+    """
+    sign = 1-2*labels.astype(losses.dtype)
+    return responsibility+sign[:,None]*jnp.exp(-losses)*gate_prediction_adjoint

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_gradient.py

@@ -0,0 +1,43 @@
+"""Prototype complete gate/expert chain rule through confidence features."""
+import jax
+import jax.numpy as jnp
+from confidence_joint import gate_features, gate_logit, mixture_terms, mix_predictions, expert_adjoint_factors
+
+
+def make_gradient(probabilities, exact_gradient):
+    @jax.jit
+    def gradient(parameters,dets,labels,base,context,static,valid,masks,measured,
+                 grid,measurement_indices,counts):
+        arguments = (dets,base,context,static,valid,grid,measurement_indices,counts)
+        p0,pull0 = jax.vjp(lambda w:probabilities(w,*arguments),parameters['expert0'])
+        loss0,pred0,g0 = exact_gradient(dets,labels,p0,masks,measured)
+        p1,pull1 = jax.vjp(lambda w:probabilities(w,*arguments),parameters['expert1'])
+        loss1,pred1,g1 = exact_gradient(dets,labels,p1,masks,measured)
+        losses = jnp.stack([loss0,loss1],axis=1)
+        predictions = jnp.stack([pred0,pred1],axis=1)
+        logit,pull_gate = jax.vjp(lambda w,q:gate_logit(w,gate_features(dets,grid,static,q)),
+                                 parameters['gate'],predictions)
+        loss,responsibility,adjoint,coefficients = mixture_terms(losses,logit)
+        # Each gate output depends only on its own shot, so this VJP yields
+        # per-shot prediction adjoints and the sum of parameter gradients.
+        gate_sum,extra_prediction_adjoint = pull_gate(adjoint)
+        factors = expert_adjoint_factors(losses,labels,responsibility,extra_prediction_adjoint)
+        batch = len(dets)
+        gradients = {'expert0':pull0(g0*factors[:,0][None]/batch)[0],
+                     'expert1':pull1(g1*factors[:,1][None]/batch)[0],
+                     'gate':jax.tree_util.tree_map(lambda x:x/batch,gate_sum)}
+        prediction = mix_predictions(predictions,logit)
+        return gradients,loss.mean(),jnp.mean((prediction>=.5)!=labels),coefficients.mean(axis=0)
+    return gradient
+
+
+def make_infer(probabilities,exact_decode):
+    @jax.jit
+    def infer(parameters,dets,base,context,static,valid,masks,measured,
+              grid,measurement_indices,counts):
+        arguments = (dets,base,context,static,valid,grid,measurement_indices,counts)
+        q = jnp.stack([exact_decode(dets,probabilities(parameters[key],*arguments),masks,measured)
+                       for key in ['expert0','expert1']],axis=1)
+        logit = gate_logit(parameters['gate'],gate_features(dets,grid,static,q))
+        return mix_predictions(q,logit)
+    return infer

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_state.py

@@ -0,0 +1,83 @@
+"""Serialization and distinct Adam clocks for two experts and a new gate."""
+from pathlib import Path
+import hashlib
+import numpy as np
+import jax
+import jax.numpy as jnp
+import optax
+from confidence_joint import initialize_gate
+
+PARTS = ('expert0', 'expert1', 'gate')
+
+
+def save_weights(path, parameters):
+    np.savez(path, **{part + '__' + key: np.asarray(value)
+                     for part, values in parameters.items() for key, value in values.items()})
+
+
+def load_weights(path):
+    result = {part: {} for part in PARTS}
+    with np.load(path, allow_pickle=False) as saved:
+        for key in saved.files:
+            part, name = key.split('__', 1)
+            result[part][name] = jnp.asarray(saved[key])
+    assert all(result.values())
+    return result
+
+
+def save_state(path, state):
+    leaves, _ = jax.tree_util.tree_flatten(state)
+    np.savez(path, **{f'arr_{i}': np.asarray(leaf) for i, leaf in enumerate(leaves)})
+
+
+def load_state(path, template):
+    leaves, tree = jax.tree_util.tree_flatten(template)
+    loaded = []
+    with np.load(path, allow_pickle=False) as saved:
+        assert set(saved.files) == {f'arr_{i}' for i in range(len(leaves))}
+        for i, leaf in enumerate(leaves):
+            value = saved[f'arr_{i}']
+            assert value.shape == leaf.shape and value.dtype == leaf.dtype
+            loaded.append(jnp.asarray(value))
+    return jax.tree_util.tree_unflatten(tree, loaded)
+
+
+def initialize(parent_paths, seed, expert_lr, gate_lr):
+    assert len(parent_paths) == 2
+    parameters = {'gate': initialize_gate(seed)}
+    state = {}
+    records = []
+    for i, path in enumerate(map(Path, parent_paths)):
+        key = f'expert{i}'
+        with np.load(path, allow_pickle=False) as saved:
+            parameters[key] = {name: jnp.asarray(saved[name]) for name in saved.files}
+        assert set(parameters[key]) == {'w1', 'b1', 'w2', 'b2', 'w3', 'b3'}
+        assert parameters[key]['w1'].shape == (394, 64)
+        original = optax.chain(optax.clip_by_global_norm(1), optax.adamw(expert_lr, weight_decay=1e-4))
+        optimizer_path = path.with_name(path.name.replace('weights-', 'optimizer-'))
+        original_state = load_state(optimizer_path, original.init(parameters[key]))
+        state[key] = original_state[1]
+        records.append({'part': key, 'weights': str(path), 'weights_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+                        'optimizer': str(optimizer_path), 'optimizer_sha256': hashlib.sha256(optimizer_path.read_bytes()).hexdigest(),
+                        'initial_adam_count': int(state[key][0].count), 'moments_restored': True})
+    state['gate'] = optax.adamw(gate_lr, weight_decay=1e-4).init(parameters['gate'])
+    return parameters, state, records
+
+
+def make_apply(expert_lr, gate_lr):
+    optimizers = {part: optax.adamw(gate_lr if part == 'gate' else expert_lr, weight_decay=1e-4) for part in PARTS}
+    clip = optax.clip_by_global_norm(1)
+    @jax.jit
+    def apply(parameters, state, gradients):
+        norm = optax.global_norm(gradients)
+        gradients, _ = clip.update(gradients, clip.init(parameters), parameters)
+        new_parameters, new_state = {}, {}
+        for part in PARTS:
+            updates, new_state[part] = optimizers[part].update(gradients[part], state[part], parameters[part])
+            new_parameters[part] = optax.apply_updates(parameters[part], updates)
+        return new_parameters, new_state, norm
+    return apply
+
+
+def counts(state):
+    return {part: int(state[part][0].count) for part in PARTS}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_train.py

@@ -0,0 +1,145 @@
+"""Matched joint BCE training with syndrome and expert-confidence gate inputs."""
+import os
+os.environ['OPENBLAS_NUM_THREADS'] = '1'
+os.environ['OMP_NUM_THREADS'] = '1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = 'false'
+from pathlib import Path
+import argparse
+import hashlib
+import json
+import shutil
+import sys
+import time
+import numpy as np
+import jax
+from model import probabilities
+from data import load_all
+from confidence_joint_gradient import make_gradient, make_infer
+from confidence_joint_state import initialize, make_apply, save_weights, load_weights, save_state, load_state, counts
+
+root = Path(__file__).resolve().parent
+research = root.parent
+sys.path.insert(0, str(research / 'learned_exact'))
+from checkpoint_gradient import make_loss_and_grad
+from exact import make_decoder
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--parents', type=Path, nargs=2, required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--training-cache', type=Path, required=True)
+    parser.add_argument('--resume', type=Path)
+    parser.add_argument('--steps', type=int, default=2048)
+    parser.add_argument('--batch', type=int, default=1024)
+    parser.add_argument('--expert-lr', type=float, default=.0001)
+    parser.add_argument('--gate-lr', type=float, default=.001)
+    parser.add_argument('--gate-seed', type=int, default=20261310)
+    parser.add_argument('--seed', type=int, default=20261311)
+    parser.add_argument('--eval-every', type=int, default=512)
+    parser.add_argument('--validation-shots', type=int, default=1024)
+    parser.add_argument('--validation-batch', type=int, default=512)
+    args = parser.parse_args()
+    args.output.mkdir(exist_ok=False)
+    config = {key: ([str(p) for p in value] if key == 'parents' else str(value) if isinstance(value, Path) else value)
+              for key, value in vars(args).items()}
+    source_paths = [root / name for name in ['joint_mixture.py', 'confidence_joint.py', 'confidence_joint_gradient.py', 'confidence_joint_state.py',
+                                            'confidence_joint_train.py', 'model.py', 'data.py']]
+    source_paths += [research / 'learned_exact/checkpoint_gradient.py', research / 'exact_d3/exact.py']
+    snapshot = args.output / 'training_source'; snapshot.mkdir()
+    hashes = {}
+    for source in source_paths:
+        name = str(source.relative_to(research)).replace('/', '__')
+        shutil.copyfile(source, snapshot / name)
+        hashes[name] = hashlib.sha256(source.read_bytes()).hexdigest()
+    parameters, state, parent_records = initialize(args.parents, args.gate_seed, args.expert_lr, args.gate_lr)
+    rng = np.random.default_rng(args.seed)
+    if args.resume:
+        old = json.loads((args.resume.parent / 'run_config.json').read_text())
+        for key in ['parents', 'expert_lr', 'gate_lr', 'gate_seed', 'seed', 'batch', 'training_cache']:
+            assert old[key] == config[key], key
+        parameters = load_weights(args.resume)
+        state = load_state(args.resume.with_name(args.resume.name.replace('weights-', 'optimizer-')), state)
+        rng.bit_generator.state = json.loads(args.resume.with_name(args.resume.name.replace('weights-', 'rng-')).with_suffix('.json').read_text())
+    config.update(training_source_sha256=hashes, parent_records=parent_records, initial_adam_counts=counts(state),
+                  initialization='Both experts copied with exact Adam state from declared session-trained parents; new gate retains the original seeded 41-input hidden weights, appends four zero confidence-input rows, and has zero output, giving the same initial equal mixture',
+                  sampling='Same seed and draws as syndrome-only joint_mixture1; resumed phases restore only their own saved sampling state',
+                  runtime_versions={'jax': jax.__version__, 'numpy': np.__version__})
+    (args.output / 'run_config.json').write_text(json.dumps(config, indent=2) + '\n')
+    started = time.time()
+    dataset = load_all(prior_pass=3, training_cache=args.training_cache)
+    assert len(dataset) == 26
+    print(json.dumps({'loaded_conditions': len(dataset), 'seconds': time.time() - started}), flush=True)
+    seen = [np.zeros(len(item['train_labels']), bool) for item in dataset]
+    os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = 'true'
+    os.environ['XLA_PYTHON_CLIENT_MEM_FRACTION'] = '0.90'
+    gradient = make_gradient(probabilities, make_loss_and_grad(14, 32))
+    infer = make_infer(probabilities, make_decoder(14))
+    apply = make_apply(args.expert_lr, args.gate_lr)
+    feature_names = ['context', 'static', 'valid', 'masks', 'measured', 'grid', 'measurement_indices', 'counts']
+
+    def feature_values(item):
+        length = ((int(item['operation_count']) + 511) // 512) * 512
+        return length, [item[k][:length] for k in feature_names[:5]] + [item[k] for k in feature_names[5:]]
+
+    def evaluate(step):
+        results = []; beginning = time.time()
+        for item in dataset:
+            n = min(args.validation_shots, len(item['validation_labels']))
+            selected = np.random.default_rng(20261102).choice(len(item['validation_labels']), n, replace=False)
+            length, features = feature_values(item)
+            parts = []
+            for begin in range(0, n, args.validation_batch):
+                ix = selected[begin:begin + args.validation_batch]; size = len(ix)
+                ds = np.pad(item['validation_dets'][ix], ((0, args.validation_batch - size), (0, 0)))
+                base = np.pad(item['validation_base_logits'][ix, :length], ((0, args.validation_batch - size), (0, 0)))
+                parts.append(np.asarray(infer(parameters, ds, base, *features))[:size])
+            p = np.concatenate(parts); y = item['validation_labels'][selected].astype(np.float64)
+            pp = np.clip(p.astype(np.float64), 1e-7, 1 - 1e-7)
+            results.append({'condition': item['row']['name'], 'failure': float(np.mean((p >= .5) != y)),
+                            'negative_log_likelihood': float(np.mean(-y * np.log(pp) - (1 - y) * np.log1p(-pp)))})
+        report = {'step': step, 'validation_failure': float(np.mean([r['failure'] for r in results])),
+                  'negative_log_likelihood': float(np.mean([r['negative_log_likelihood'] for r in results])),
+                  'conditions': results, 'seconds': time.time() - beginning}
+        (args.output / f'validation-{step}.json').write_text(json.dumps(report, indent=2) + '\n')
+        save_weights(args.output / f'weights-{step}.npz', parameters)
+        save_state(args.output / f'optimizer-{step}.npz', state)
+        (args.output / f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state) + '\n')
+        (args.output / f'checkpoint-{step}.json').write_text(json.dumps({
+            'step': step, 'training_draws': step * args.batch, 'adam_counts': counts(state),
+            'distinct_phase_rows': sum(int(mask.sum()) for mask in seen),
+            'distinct_by_condition': {item['row']['name']: int(mask.sum()) for item, mask in zip(dataset, seen)},
+            'weights_sha256': hashlib.sha256((args.output / f'weights-{step}.npz').read_bytes()).hexdigest(), 'complete': True}, indent=2) + '\n')
+        print(json.dumps({k: v for k, v in report.items() if k != 'conditions'}), flush=True)
+
+    evaluate(0)
+    records = []
+    for step in range(1, args.steps + 1):
+        condition = int(rng.integers(len(dataset))); item = dataset[condition]
+        ix = rng.integers(len(item['train_labels']), size=args.batch); seen[condition][ix] = True
+        length, features = feature_values(item)
+        gradients, loss, error, coefficients = gradient(parameters, item['train_dets'][ix], item['train_labels'][ix],
+                                                       item['train_base_logits'][ix, :length], *features)
+        parameters, state, norm = apply(parameters, state, gradients)
+        if step == 1 or step % 16 == 0:
+            record = {'step': step, 'loss': float(loss), 'error': float(error), 'gradient_norm': float(norm),
+                      'mean_coefficients': np.asarray(coefficients).tolist(), 'elapsed': time.time() - started}
+            assert np.isfinite(record['loss']) and np.isfinite(record['gradient_norm'])
+            records.append(record); print(json.dumps(record), flush=True)
+        if step % args.eval_every == 0 or step == args.steps:
+            evaluate(step)
+    provenance = {'run_config': config, 'parent_provenance': [json.loads((p.parent / 'provenance.json').read_text()) for p in args.parents],
+                  'training': 'All516880 supplied d5 training rows eligible; uniform condition and row sampling with replacement',
+                  'training_shots': sum(len(item['train_labels']) for item in dataset),
+                  'distinct_phase_rows': sum(int(mask.sum()) for mask in seen),
+                  'loss': 'Conditional logical BCE of two trainable exact-decoder probabilities; responsibilities and the complete expert-confidence gate chain rule scale expert BCE gradients; free gate-logit adjoint is coefficient minus responsibility',
+                  'optimizer': 'Separate restored expert AdamW states and fresh gate AdamW; one global norm1 clipping over the full joint gradient, weight_decay1e-4; rates in run_config',
+                  'gate': '41 fixed-scale syndrome/basis/duration features plus two expert clipped logits/8 and their smooth absolute values;45 inputs,32-unit SiLU hidden layer,one free logit,other logit zero;no label/ID/position features;confidence features are fully differentiated',
+                  'validation': 'Uniform1024-shot per-condition screens by default, seed20261102; full validation required for checkpoint selection',
+                  'independence': 'This joint model uses all training rows; it does not retain the reserved-parent training-label holdout claim',
+                  'test_data_used': False, 'records': records, 'seconds': time.time() - started}
+    (args.output / 'provenance.json').write_text(json.dumps(provenance, indent=2) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__data.py

@@ -0,0 +1,95 @@
+"""Static physical features and authorized cached training/validation priors."""
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import parse_errors
+from conditional import load_state
+
+ROOT=Path(__file__).resolve().parent
+
+
+def build_features(row,package,max_ops=2048):
+    dem=stim.DetectorErrorModel.from_file(Path('/workspace/data/train')/row['noise'])
+    errors=parse_errors(dem);coords=dem.get_detector_coordinates()
+    if row['rounds']==1:
+        plan=dict(np.load(package/f"plans/{row['name']}.npz"));supports=[(ds,l) for ds,l,p in errors]
+        measured=plan['measured']
+    else:
+        state=load_state(package/f"conditional_plans/{row['name']}.npz");plan=state['on']
+        on=set(state['on_indices'].tolist());groups={}
+        for ds,l,p in errors:
+            key=tuple(sorted(ds&on)),l
+            if key[0] or key[1]:groups.setdefault(key,len(groups))
+        supports=list(groups)
+        measured=np.where(plan['measured']>=0,state['on_indices'][np.maximum(plan['measured'],0)],-1)
+    assert int(plan['width'])<=14
+    circuit=stim.Circuit.from_file(Path('/workspace/data/train')/row['circuit'])
+    qubits=circuit.get_final_qubit_coordinates()
+    first=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+    spaces=sorted(tuple(qubits[t.value][:2]) for t in first.targets_copy());assert len(spaces)==24
+    idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+    context=np.full((max_ops,120),600,np.int32);static=np.zeros((max_ops,129),np.float32)
+    n=len(plan['masks']);assert n<=max_ops
+    for op,source in enumerate(plan['source_indices']):
+        if source<0:continue
+        ds,logical=supports[source];t=min(int(coords[d][2]) for d in ds) if ds else 0
+        for dt in range(-2,3):
+            for s,space in enumerate(spaces):context[op,(dt+2)*24+s]=idx.get((t+dt,space),600)
+        for d in ds:
+            c=coords[d];static[op,(int(c[2])-t+2)*24+spaces.index(tuple(c[:2]))]=1
+        p=float(plan['probabilities'][op]);static[op,120]=np.log(max(p,1e-7)/max(1-p,1e-7))/8
+        static[op,121:]=[logical,len(ds)/4,t/25,row['rounds']/25,t==0,t>=row['rounds']-1,row['basis']=='X',1]
+    grid=np.full((26,24),600,np.int32);measurement_indices=np.full(601,624,np.int32)
+    for d,c in coords.items():
+        t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=d;measurement_indices[d]=t*24+s
+    return {'context':context,'static':static,'masks':np.pad(plan['masks'],(0,max_ops-n)),
+        'measured':np.pad(measured,(0,max_ops-n),constant_values=-1),
+        'valid':np.pad((plan['source_indices']>=0).astype(np.float32),(0,max_ops-n)),
+        'grid':grid,'measurement_indices':measurement_indices,
+        'counts':np.maximum((grid!=600).sum(axis=0),1).astype(np.float32),'operation_count':np.array(n,np.int32)}
+
+
+def load_all(splits=('train','validation'),max_ops=2048,prior_pass=1,training_cache=None):
+    assert prior_pass in [1,3,5]
+    assert training_cache is None or prior_pass in [1,3]
+    rows=[r for r in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if r['distance']==5]
+    package=Path(json.loads(Path('/workspace/research/CURRENT.json').read_text())['package'])
+    plans=ROOT/'feature_plans';plans.mkdir(exist_ok=True);items=[]
+    for row in rows:
+        path=plans/f"{row['name']}.npz"
+        if not path.exists():np.savez(path,**build_features(row,package,max_ops))
+        item=dict(np.load(path,allow_pickle=False));item['row']=row
+        if splits:
+            cache=np.load(Path('/workspace/research/exact_d3/turbo_cache')/f"{row['name']}.npz")
+            feedback=np.load(Path('/workspace/research/exact_d3/feedback5_cache')/f"{row['name']}.npz") if prior_pass>1 else None
+            for split in splits:
+                assert split in ['train','validation']
+                arrays=np.load(Path('/workspace/data')/split/row['arrays'])
+                if split=='train' and training_cache is not None:
+                    full=np.load(Path(training_cache)/f"{row['name']}.npz",allow_pickle=False)
+                    indices=full['indices'];p=full[f'priors{prior_pass}']
+                    assert np.array_equal(arrays['sample_ids'][indices],full['sample_ids'])
+                    physical_prediction=full['probabilities3']
+                else:
+                    indices=cache['train4096_indices'] if split=='train' else np.arange(len(arrays['labels']))
+                    key='train4096' if split=='train' else 'validation'
+                    p=cache[key+'_on_prior'] if prior_pass==1 else feedback[f'{key}_priors{prior_pass}']
+                    physical_prediction=cache[key][:,0] if prior_pass==1 else feedback[key][:,prior_pass-1]
+                assert p.shape[1]==int(item['operation_count'])
+                if feedback is not None:assert np.array_equal(feedback['train4096_indices'],cache['train4096_indices'])
+                logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7))
+                item[split+'_base_logits']=np.pad(logits,((0,0),(0,max_ops-p.shape[1]))).astype(np.float32)
+                ds=np.unpackbits(arrays['detectors'][indices],axis=1,count=row['num_detectors'],bitorder='little')
+                item[split+'_dets']=np.pad(ds,((0,0),(0,601-ds.shape[1])))
+                item[split+'_labels']=arrays['labels'][indices]
+                item[split+'_sample_ids']=arrays['sample_ids'][indices]
+                item[split+'_physical_probabilities']=physical_prediction.astype(np.float32)
+        items.append(item)
+    return items
+
+
+if __name__=='__main__':
+    items=load_all(splits=())
+    print(json.dumps({'conditions':len(items),'maximum_operations':max(int(x['operation_count']) for x in items)}))

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__joint_mixture.py

@@ -0,0 +1,75 @@
+"""Two trainable exact-decoder experts with a syndrome-only mixture gate."""
+import jax
+import jax.numpy as jnp
+
+GATE_FEATURES = 41
+
+
+def gate_features(dets, grid, static):
+    """Shot-local features; no labels, IDs, expert probabilities, or batch statistics."""
+    presence = grid != 600
+    event = dets[:, grid].astype(jnp.float32) * presence[None]
+    count = jnp.maximum(presence.sum(axis=0), 1)
+    density = event.sum(axis=1) / count[None]
+    blocks = [density * 4]
+    for lag in [1, 2, 4, 8]:
+        valid = presence[:-lag] & presence[lag:]
+        denom = jnp.maximum(valid.sum(axis=0), 1)
+        site_valid = valid.any(axis=0)
+        a = event[:, :-lag] * valid[None]
+        b = event[:, lag:] * valid[None]
+        coincidence = (a * b).sum(axis=1) / denom[None]
+        covariance = coincidence - a.sum(axis=1) * b.sum(axis=1) / denom[None] ** 2
+        divisor = jnp.maximum(site_valid.sum(), 1)
+        blocks.extend([(coincidence * site_valid).sum(axis=1, keepdims=True) * 8 / divisor,
+                       (covariance * site_valid).sum(axis=1, keepdims=True) * 16 / divisor])
+    valid_frame = presence.any(axis=1)
+    nframes = jnp.maximum(valid_frame.sum(), 1)
+    frame = event.sum(axis=2) / jnp.maximum(presence.sum(axis=1), 1)[None]
+    frame_mean = frame.sum(axis=1) / nframes
+    frame_var = (((frame - frame_mean[:, None]) ** 2) * valid_frame[None]).sum(axis=1) / nframes
+    rank = jnp.cumsum(valid_frame) - 1
+    first_mask = valid_frame & (rank < jnp.maximum(nframes // 2, 1))
+    last_mask = valid_frame & ~first_mask
+    first = (frame * first_mask[None]).sum(axis=1) / jnp.maximum(first_mask.sum(), 1)
+    last = (frame * last_mask[None]).sum(axis=1) / jnp.maximum(last_mask.sum(), 1)
+    last = jnp.where(last_mask.any(), last, first)
+    fraction = jnp.max(static[:, 124])
+    basis = jnp.max(static[:, 127])
+    blocks.append(4 * jnp.stack([density.mean(axis=1), density.std(axis=1), density.max(axis=1),
+                                jnp.sqrt(jnp.maximum(frame_var, 0)), frame.max(axis=1),
+                                jnp.abs(first - last)], axis=1))
+    blocks.append(jnp.broadcast_to(jnp.stack([fraction, fraction ** 2, basis]), (len(dets), 3)))
+    result = jnp.concatenate(blocks, axis=1)
+    assert result.shape == (len(dets), GATE_FEATURES)
+    return result
+
+
+def initialize_gate(seed, hidden=32):
+    key = jax.random.key(seed)
+    return {'w1': jax.random.normal(key, (GATE_FEATURES, hidden)) * jnp.sqrt(2 / GATE_FEATURES),
+            'b1': jnp.zeros(hidden), 'w2': jnp.zeros((hidden, 1)), 'b2': jnp.zeros(1)}
+
+
+def gate_logit(parameters, features):
+    hidden = jax.nn.silu(features @ parameters['w1'] + parameters['b1'])
+    return (hidden @ parameters['w2'] + parameters['b2'])[:, 0]
+
+
+def mixture_terms(losses, logit):
+    """Stable BCE and exact expert/gate adjoints from per-expert BCE losses.
+
+    losses has shape [batch,2]. Responsibilities multiply each expert BCE
+    gradient; gate_adjoint is d(BCE mixture)/d(single free gate logit).
+    """
+    logits = jnp.stack([logit, jnp.zeros_like(logit)], axis=1)
+    log_a = jax.nn.log_softmax(logits, axis=1)
+    log_c = jax.scipy.special.logsumexp(log_a - losses, axis=1)
+    responsibility = jnp.exp(log_a - losses - log_c[:, None])
+    a = jnp.exp(log_a)
+    return -log_c, responsibility, a[:, 0] - responsibility[:, 0], a
+
+
+def mix_predictions(predictions, logit):
+    a = jax.nn.sigmoid(logit)
+    return a * predictions[:, 0] + (1 - a) * predictions[:, 1]

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__model.py

@@ -0,0 +1,55 @@
+"""Small shared network corrects soft-conditioned relevant-CSS edge logits."""
+import jax
+import jax.numpy as jnp
+
+
+def initialize(seed,hidden=64,input_features=394):
+    assert input_features in (394,414)
+    keys=jax.random.split(jax.random.key(seed),3)
+    return {'w1':jax.random.normal(keys[0],(input_features,hidden))*jnp.sqrt(2/input_features),'b1':jnp.zeros(hidden),
+        'w2':jax.random.normal(keys[1],(hidden,hidden))*jnp.sqrt(2/hidden),'b2':jnp.zeros(hidden),
+        'w3':jax.random.normal(keys[2],(hidden,1))*.001,'b3':jnp.zeros(1)}
+
+
+def endpoint_features(events,measurements,density,static):
+    """Twenty endpoint/history summaries computed solely from the input syndrome."""
+    support=static[:,:120].reshape(-1,5,24)
+    selected=jnp.max(support,axis=1)
+    endpoint_counts=jnp.maximum(support.sum(axis=-1),1)
+    spatial_count=jnp.maximum(selected.sum(axis=-1),1)
+    event_frames=events.reshape(len(events),-1,5,24)
+    measurement_frames=measurements.reshape(len(events),-1,5,24)
+    endpoint_events=(event_frames*support[None,:,:,:]).sum(axis=-1)
+    endpoint_measurements=(measurement_frames*support[None,:,:,:]).sum(axis=-1)
+    spatial_events=(event_frames*selected[None,:,None,:]).sum(axis=-1)/spatial_count[None,:,None]
+    endpoint_total=endpoint_events.sum(axis=-1)
+    endpoint_fraction=endpoint_total/jnp.maximum(support.sum(axis=(1,2)),1)[None,:]
+    endpoint_parity=jnp.mod(endpoint_total,2)
+    selected_density=(density[:,None,:]*selected[None,:,:]).sum(axis=-1)/spatial_count[None,:]
+    adjacent=(event_frames[:,:,:-1,:]*event_frames[:,:,1:,:]*selected[None,:,None,:]).sum(axis=(2,3))/(4*spatial_count[None,:])
+    measurement_mean=(measurement_frames*selected[None,:,None,:]).sum(axis=(2,3))/(5*spatial_count[None,:])
+    return jnp.concatenate([
+        endpoint_events/endpoint_counts[None,:,:],
+        endpoint_measurements/endpoint_counts[None,:,:],spatial_events,
+        selected_density[:,:,None],endpoint_fraction[:,:,None],endpoint_parity[:,:,None],
+        adjacent[:,:,None],measurement_mean[:,:,None]],axis=-1)
+
+
+def probabilities(parameters,dets,base_logits,context,static,valid,grid,measurement_indices,counts):
+    event_grid=dets[:,grid]
+    measured=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).reshape(len(dets),624)
+    measured=jnp.pad(measured,((0,0),(0,1)))
+    events=dets[:,context].astype(jnp.float32)
+    measurements=measured[:,measurement_indices[context]].astype(jnp.float32)
+    density=jnp.sum(event_grid,axis=1)/counts[None,:]
+    features=jnp.concatenate([events,measurements,
+        jnp.broadcast_to(density[:,None,:],(len(dets),len(context),24)),
+        jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),base_logits[:,:,None]/8],axis=-1)
+    if parameters['w1'].shape[0]==414:
+        features=jnp.concatenate([features,endpoint_features(events,measurements,density,static)],axis=-1)
+    else:
+        assert parameters['w1'].shape[0]==394
+    h=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    h=jax.nn.silu(h@parameters['w2']+parameters['b2'])
+    delta=2*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0])
+    return (jax.nn.sigmoid(base_logits+delta)*valid[None,:]).T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_exact__checkpoint_gradient.py

@@ -0,0 +1,73 @@
+"""Exact logical BCE gradient with block recomputation of frontier histories."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width, block_size=32):
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+
+    @jax.jit
+    def evaluate(dets, labels, probabilities, masks, measured):
+        nops, batch = probabilities.shape
+        padding = (-nops) % block_size
+        p = jnp.pad(probabilities, ((0, padding), (0, 0)))
+        m = jnp.pad(masks, (0, padding))
+        d = jnp.pad(measured, (0, padding), constant_values=-1)
+        blocks = (p.reshape(-1, block_size, batch), m.reshape(-1, block_size),
+                  d.reshape(-1, block_size))
+
+        def forward(f, args):
+            probability, mask, detector = args
+
+            def error(f):
+                out = (1 - probability[:, None]) * f + probability[:, None] * f[:, indices ^ mask]
+                return out, jnp.ones(batch)
+
+            def project(f):
+                dst = (indices[None, :] & ~mask) | (dets[:, detector, None].astype(jnp.int32) * mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask) == 0)
+                norm = jnp.maximum(g.sum(axis=1), 1e-30)
+                return g / norm[:, None], norm
+
+            out, norm = jax.lax.cond(detector < 0, error, project, f)
+            return out, (f, norm)
+
+        def forward_block(f, args):
+            def step(carry, item):
+                result, _ = forward(carry, item)
+                return result, None
+            out, _ = jax.lax.scan(step, f, args)
+            return out, f
+
+        initial = jnp.zeros((batch, 1 << width), jnp.float32).at[:, 0].set(1)
+        f, checkpoints = jax.lax.scan(forward_block, initial, blocks)
+        indicator = ((indices[None, :] & 1) == labels[:, None])
+        correct = jnp.maximum(jnp.sum(f * indicator, axis=1), 1e-10)
+        prediction = jnp.sum(f[:, 1::2], axis=1)
+        terminal = 1 - indicator / correct[:, None]
+
+        def backward(b, args):
+            probability, mask, detector, old, norm = args
+
+            def error(b):
+                flipped = b[:, indices ^ mask]
+                grad = jnp.sum(old * (flipped - b), axis=1)
+                return (1 - probability[:, None]) * b + probability[:, None] * flipped, grad
+
+            def project(b):
+                obs = ((indices[None, :] & mask) == dets[:, detector, None].astype(jnp.int32) * mask)
+                values = b[:, indices & ~mask]
+                mean = jnp.sum(old * obs * values, axis=1) / norm
+                return (values - mean[:, None]) * obs / norm[:, None], jnp.zeros(batch)
+
+            return jax.lax.cond(detector < 0, error, project, b)
+
+        def backward_block(b, args):
+            probabilities, masks, measured, checkpoint = args
+            _, (history, norms) = jax.lax.scan(forward, checkpoint, (probabilities, masks, measured))
+            return jax.lax.scan(backward, b, (probabilities, masks, measured, history, norms), reverse=True)
+
+        _, gradients = jax.lax.scan(backward_block, terminal, (*blocks, checkpoints), reverse=True)
+        return -jnp.log(correct), prediction, gradients.reshape(-1, batch)[:nops]
+
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__data.py

@@ -0,0 +1,95 @@
+"""Static physical features and authorized cached training/validation priors."""
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import parse_errors
+from conditional import load_state
+
+ROOT=Path(__file__).resolve().parent
+
+
+def build_features(row,package,max_ops=2048):
+    dem=stim.DetectorErrorModel.from_file(Path('/workspace/data/train')/row['noise'])
+    errors=parse_errors(dem);coords=dem.get_detector_coordinates()
+    if row['rounds']==1:
+        plan=dict(np.load(package/f"plans/{row['name']}.npz"));supports=[(ds,l) for ds,l,p in errors]
+        measured=plan['measured']
+    else:
+        state=load_state(package/f"conditional_plans/{row['name']}.npz");plan=state['on']
+        on=set(state['on_indices'].tolist());groups={}
+        for ds,l,p in errors:
+            key=tuple(sorted(ds&on)),l
+            if key[0] or key[1]:groups.setdefault(key,len(groups))
+        supports=list(groups)
+        measured=np.where(plan['measured']>=0,state['on_indices'][np.maximum(plan['measured'],0)],-1)
+    assert int(plan['width'])<=14
+    circuit=stim.Circuit.from_file(Path('/workspace/data/train')/row['circuit'])
+    qubits=circuit.get_final_qubit_coordinates()
+    first=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+    spaces=sorted(tuple(qubits[t.value][:2]) for t in first.targets_copy());assert len(spaces)==24
+    idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+    context=np.full((max_ops,120),600,np.int32);static=np.zeros((max_ops,129),np.float32)
+    n=len(plan['masks']);assert n<=max_ops
+    for op,source in enumerate(plan['source_indices']):
+        if source<0:continue
+        ds,logical=supports[source];t=min(int(coords[d][2]) for d in ds) if ds else 0
+        for dt in range(-2,3):
+            for s,space in enumerate(spaces):context[op,(dt+2)*24+s]=idx.get((t+dt,space),600)
+        for d in ds:
+            c=coords[d];static[op,(int(c[2])-t+2)*24+spaces.index(tuple(c[:2]))]=1
+        p=float(plan['probabilities'][op]);static[op,120]=np.log(max(p,1e-7)/max(1-p,1e-7))/8
+        static[op,121:]=[logical,len(ds)/4,t/25,row['rounds']/25,t==0,t>=row['rounds']-1,row['basis']=='X',1]
+    grid=np.full((26,24),600,np.int32);measurement_indices=np.full(601,624,np.int32)
+    for d,c in coords.items():
+        t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=d;measurement_indices[d]=t*24+s
+    return {'context':context,'static':static,'masks':np.pad(plan['masks'],(0,max_ops-n)),
+        'measured':np.pad(measured,(0,max_ops-n),constant_values=-1),
+        'valid':np.pad((plan['source_indices']>=0).astype(np.float32),(0,max_ops-n)),
+        'grid':grid,'measurement_indices':measurement_indices,
+        'counts':np.maximum((grid!=600).sum(axis=0),1).astype(np.float32),'operation_count':np.array(n,np.int32)}
+
+
+def load_all(splits=('train','validation'),max_ops=2048,prior_pass=1,training_cache=None):
+    assert prior_pass in [1,3,5]
+    assert training_cache is None or prior_pass in [1,3]
+    rows=[r for r in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if r['distance']==5]
+    package=Path(json.loads(Path('/workspace/research/CURRENT.json').read_text())['package'])
+    plans=ROOT/'feature_plans';plans.mkdir(exist_ok=True);items=[]
+    for row in rows:
+        path=plans/f"{row['name']}.npz"
+        if not path.exists():np.savez(path,**build_features(row,package,max_ops))
+        item=dict(np.load(path,allow_pickle=False));item['row']=row
+        if splits:
+            cache=np.load(Path('/workspace/research/exact_d3/turbo_cache')/f"{row['name']}.npz")
+            feedback=np.load(Path('/workspace/research/exact_d3/feedback5_cache')/f"{row['name']}.npz") if prior_pass>1 else None
+            for split in splits:
+                assert split in ['train','validation']
+                arrays=np.load(Path('/workspace/data')/split/row['arrays'])
+                if split=='train' and training_cache is not None:
+                    full=np.load(Path(training_cache)/f"{row['name']}.npz",allow_pickle=False)
+                    indices=full['indices'];p=full[f'priors{prior_pass}']
+                    assert np.array_equal(arrays['sample_ids'][indices],full['sample_ids'])
+                    physical_prediction=full['probabilities3']
+                else:
+                    indices=cache['train4096_indices'] if split=='train' else np.arange(len(arrays['labels']))
+                    key='train4096' if split=='train' else 'validation'
+                    p=cache[key+'_on_prior'] if prior_pass==1 else feedback[f'{key}_priors{prior_pass}']
+                    physical_prediction=cache[key][:,0] if prior_pass==1 else feedback[key][:,prior_pass-1]
+                assert p.shape[1]==int(item['operation_count'])
+                if feedback is not None:assert np.array_equal(feedback['train4096_indices'],cache['train4096_indices'])
+                logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7))
+                item[split+'_base_logits']=np.pad(logits,((0,0),(0,max_ops-p.shape[1]))).astype(np.float32)
+                ds=np.unpackbits(arrays['detectors'][indices],axis=1,count=row['num_detectors'],bitorder='little')
+                item[split+'_dets']=np.pad(ds,((0,0),(0,601-ds.shape[1])))
+                item[split+'_labels']=arrays['labels'][indices]
+                item[split+'_sample_ids']=arrays['sample_ids'][indices]
+                item[split+'_physical_probabilities']=physical_prediction.astype(np.float32)
+        items.append(item)
+    return items
+
+
+if __name__=='__main__':
+    items=load_all(splits=())
+    print(json.dumps({'conditions':len(items),'maximum_operations':max(int(x['operation_count']) for x in items)}))

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__model.py

@@ -0,0 +1,55 @@
+"""Small shared network corrects soft-conditioned relevant-CSS edge logits."""
+import jax
+import jax.numpy as jnp
+
+
+def initialize(seed,hidden=64,input_features=394):
+    assert input_features in (394,414)
+    keys=jax.random.split(jax.random.key(seed),3)
+    return {'w1':jax.random.normal(keys[0],(input_features,hidden))*jnp.sqrt(2/input_features),'b1':jnp.zeros(hidden),
+        'w2':jax.random.normal(keys[1],(hidden,hidden))*jnp.sqrt(2/hidden),'b2':jnp.zeros(hidden),
+        'w3':jax.random.normal(keys[2],(hidden,1))*.001,'b3':jnp.zeros(1)}
+
+
+def endpoint_features(events,measurements,density,static):
+    """Twenty endpoint/history summaries computed solely from the input syndrome."""
+    support=static[:,:120].reshape(-1,5,24)
+    selected=jnp.max(support,axis=1)
+    endpoint_counts=jnp.maximum(support.sum(axis=-1),1)
+    spatial_count=jnp.maximum(selected.sum(axis=-1),1)
+    event_frames=events.reshape(len(events),-1,5,24)
+    measurement_frames=measurements.reshape(len(events),-1,5,24)
+    endpoint_events=(event_frames*support[None,:,:,:]).sum(axis=-1)
+    endpoint_measurements=(measurement_frames*support[None,:,:,:]).sum(axis=-1)
+    spatial_events=(event_frames*selected[None,:,None,:]).sum(axis=-1)/spatial_count[None,:,None]
+    endpoint_total=endpoint_events.sum(axis=-1)
+    endpoint_fraction=endpoint_total/jnp.maximum(support.sum(axis=(1,2)),1)[None,:]
+    endpoint_parity=jnp.mod(endpoint_total,2)
+    selected_density=(density[:,None,:]*selected[None,:,:]).sum(axis=-1)/spatial_count[None,:]
+    adjacent=(event_frames[:,:,:-1,:]*event_frames[:,:,1:,:]*selected[None,:,None,:]).sum(axis=(2,3))/(4*spatial_count[None,:])
+    measurement_mean=(measurement_frames*selected[None,:,None,:]).sum(axis=(2,3))/(5*spatial_count[None,:])
+    return jnp.concatenate([
+        endpoint_events/endpoint_counts[None,:,:],
+        endpoint_measurements/endpoint_counts[None,:,:],spatial_events,
+        selected_density[:,:,None],endpoint_fraction[:,:,None],endpoint_parity[:,:,None],
+        adjacent[:,:,None],measurement_mean[:,:,None]],axis=-1)
+
+
+def probabilities(parameters,dets,base_logits,context,static,valid,grid,measurement_indices,counts):
+    event_grid=dets[:,grid]
+    measured=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).reshape(len(dets),624)
+    measured=jnp.pad(measured,((0,0),(0,1)))
+    events=dets[:,context].astype(jnp.float32)
+    measurements=measured[:,measurement_indices[context]].astype(jnp.float32)
+    density=jnp.sum(event_grid,axis=1)/counts[None,:]
+    features=jnp.concatenate([events,measurements,
+        jnp.broadcast_to(density[:,None,:],(len(dets),len(context),24)),
+        jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),base_logits[:,:,None]/8],axis=-1)
+    if parameters['w1'].shape[0]==414:
+        features=jnp.concatenate([features,endpoint_features(events,measurements,density,static)],axis=-1)
+    else:
+        assert parameters['w1'].shape[0]==394
+    h=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    h=jax.nn.silu(h@parameters['w2']+parameters['b2'])
+    delta=2*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0])
+    return (jax.nn.sigmoid(base_logits+delta)*valid[None,:]).T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__train.py

@@ -0,0 +1,176 @@
+"""Train effective d5 CSS weights from random initialization on hardware labels."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+from pathlib import Path
+import argparse,json,time,sys,hashlib,shutil
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from model import initialize,probabilities
+from data import load_all
+sys.path.insert(0,'/workspace/research/learned_exact')
+from gradient import make_loss_and_grad
+from exact import make_decoder
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--steps',type=int,default=1024)
+    parser.add_argument('--batch',type=int,default=256);parser.add_argument('--output',type=Path,required=True)
+    parser.add_argument('--validation-shots',type=int,default=512);parser.add_argument('--validation-batch',type=int,default=512)
+    parser.add_argument('--init-weights',type=Path);parser.add_argument('--learning-rate',type=float,default=.001)
+    parser.add_argument('--eval-every',type=int,default=256);parser.add_argument('--seed',type=int,default=20261101)
+    parser.add_argument('--initial-seed',type=int,default=20261101)
+    parser.add_argument('--prior-pass',type=int,choices=[1,3,5],default=1)
+    parser.add_argument('--training-cache',type=Path)
+    parser.add_argument('--gradient-block-size',type=int,default=0)
+    parser.add_argument('--bucket-operations',action='store_true')
+    parser.add_argument('--accumulate-conditions',type=int,default=1)
+    parser.add_argument('--uncertainty-weight-floor',type=float,default=1.)
+    parser.add_argument('--hidden-width',type=int,default=64)
+    parser.add_argument('--endpoint-features',action='store_true')
+    parser.add_argument('--reset-optimizer',action='store_true')
+    parser.add_argument('--reset-rng',action='store_true')
+    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
+    assert args.accumulate_conditions>=1 and 0<args.uncertainty_weight_floor<=1
+    assert args.uncertainty_weight_floor==1 or args.prior_pass==3
+    config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()}
+    root=Path(__file__).resolve().parent;research=root.parent
+    sources=[root/'train.py',root/'data.py',root/'model.py',research/'learned_exact/gradient.py',
+        research/'learned_exact/checkpoint_gradient.py',research/'exact_d3/exact.py']
+    snapshot=args.output/'training_source';snapshot.mkdir(exist_ok=True)
+    source_hashes={}
+    for source in sources:
+        name=str(source.relative_to(research)).replace('/','__');shutil.copyfile(source,snapshot/name)
+        source_hashes[name]=hashlib.sha256(source.read_bytes()).hexdigest()
+    feature_mode='local events, reconstructed measurements, shot densities, physical edge support and conditioned prior'
+    if args.endpoint_features:feature_mode+=';20 explicit endpoint and local temporal summaries'
+    input_features=414 if args.endpoint_features else 394
+    config.update({'initialization_seed':args.initial_seed,'feature_mode':feature_mode,'input_features':input_features,
+        'training_source_sha256':source_hashes,'runtime_versions':{'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__},
+        'hidden_width':args.hidden_width,'logit_correction_bound':2,'train_manifest_sha256':hashlib.sha256(Path('/workspace/data/train/manifest.json').read_bytes()).hexdigest(),
+        'validation_manifest_sha256':hashlib.sha256(Path('/workspace/data/validation/manifest.json').read_bytes()).hexdigest()})
+    (args.output/'run_config.json').write_text(json.dumps(config,indent=2)+'\n')
+    started=time.time();dataset=load_all(prior_pass=args.prior_pass,training_cache=args.training_cache);print(json.dumps({'loaded_conditions':len(dataset),'seconds':time.time()-started}),flush=True)
+    seen=[np.zeros(len(item['train_labels']),dtype=bool) for item in dataset]
+    os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='true'
+    os.environ['XLA_PYTHON_CLIENT_MEM_FRACTION']='0.90'
+    parameters=initialize(args.initial_seed,hidden=args.hidden_width,input_features=input_features)
+    if args.init_weights:parameters={k:jnp.asarray(v) for k,v in dict(np.load(args.init_weights,allow_pickle=False)).items()}
+    actual_hidden=int(parameters['w2'].shape[0])
+    assert actual_hidden==args.hidden_width, 'Explicit hidden-width must match the starting checkpoint'
+    assert parameters['w1'].shape[0]==input_features, 'Explicit endpoint-feature mode must match the starting checkpoint'
+    optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(args.learning_rate,weight_decay=1e-4))
+    state=optimizer.init(parameters);rng=np.random.default_rng(args.seed);restored=False;rng_restored=False
+    if args.init_weights:
+        optfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','optimizer-'))
+        rngfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','rng-')).with_suffix('.json')
+        if optfile.exists() and not args.reset_optimizer:
+            leaves,treedef=jax.tree_util.tree_flatten(state);saved=np.load(optfile)
+            state=jax.tree_util.tree_unflatten(treedef,[jnp.asarray(saved[f'arr_{i}']) for i in range(len(leaves))]);restored=True
+        if rngfile.exists() and not args.reset_rng:rng.bit_generator.state=json.loads(rngfile.read_text());rng_restored=True
+    if args.gradient_block_size:
+        from checkpoint_gradient import make_loss_and_grad as checkpoint_gradient
+        gradient=checkpoint_gradient(14,args.gradient_block_size)
+    else:gradient=make_loss_and_grad(14)
+    decode=make_decoder(14)
+    @jax.jit
+    def batch_gradient(parameters,ds,ys,base,context,static,valid,masks,measured,grid,measurement_indices,counts,example_weights):
+        p,pullback=jax.vjp(lambda w:probabilities(w,ds,base,context,static,valid,grid,measurement_indices,counts),parameters)
+        loss,pred,g=gradient(ds,ys,p,masks,measured)
+        grads=pullback(g*example_weights[None,:]/jnp.sum(example_weights))[0]
+        return grads,jnp.mean(loss),jnp.mean((pred>=.5)!=ys),jnp.sum(loss*example_weights)/jnp.sum(example_weights)
+    @jax.jit
+    def apply_gradient(parameters,state,grads):
+        changes,state=optimizer.update(grads,state,parameters)
+        return optax.apply_updates(parameters,changes),state,optax.global_norm(grads)
+    @jax.jit
+    def infer(parameters,ds,base,context,static,valid,masks,measured,grid,measurement_indices,counts):
+        p=probabilities(parameters,ds,base,context,static,valid,grid,measurement_indices,counts)
+        return decode(ds,p,masks,measured)
+    feature_names=['context','static','valid','masks','measured','grid','measurement_indices','counts']
+    def evaluate(step):
+        results=[];start=time.time()
+        for item in dataset:
+            n=min(args.validation_shots,len(item['validation_labels']))
+            ix=np.random.default_rng(20261102).choice(len(item['validation_labels']),n,replace=False)
+            length=((int(item['operation_count'])+511)//512)*512
+            features=[item[k][:length] for k in feature_names[:5]]+[item[k] for k in feature_names[5:]]
+            parts=[]
+            for begin in range(0,n,args.validation_batch):
+                selected=ix[begin:begin+args.validation_batch];size=len(selected)
+                ds=np.pad(item['validation_dets'][selected],((0,args.validation_batch-size),(0,0)))
+                base=np.pad(item['validation_base_logits'][selected,:length],((0,args.validation_batch-size),(0,0)))
+                parts.append(np.asarray(infer(parameters,ds,base,*features))[:size])
+            p=np.concatenate(parts);y=item['validation_labels'][ix].astype(np.float64)
+            pp=np.clip(p.astype(np.float64),1e-7,1-1e-7)
+            results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=y)),
+                'negative_log_likelihood':float(np.mean(-y*np.log(pp)-(1-y)*np.log1p(-pp)))})
+        result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])),
+            'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])),
+            'seconds':time.time()-start,'conditions':results}
+        (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n')
+        np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()})
+        leaves,_=jax.tree_util.tree_flatten(state);np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+        (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+        (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'training_samples':step*args.batch*args.accumulate_conditions,
+            'unique_training_rows_seen_in_this_phase':sum(int(mask.sum()) for mask in seen),
+            'weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(),'complete':True})+'\n')
+        print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True)
+    evaluate(0);records=[]
+    for step in range(1,args.steps+1):
+        total_grads=None;loss=0.;error=0.;objective=0.
+        for _ in range(args.accumulate_conditions):
+            condition_index=int(rng.integers(len(dataset)));item=dataset[condition_index]
+            ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True
+            length=((int(item['operation_count'])+511)//512)*512 if args.bucket_operations else len(item['valid'])
+            features=[item[k][:length] for k in feature_names[:5]]+[item[k] for k in feature_names[5:]]
+            physical=item['train_physical_probabilities'][ix]
+            example_weights=(args.uncertainty_weight_floor+(1-args.uncertainty_weight_floor)*4*physical*(1-physical)).astype(np.float32)
+            grads,batch_loss,batch_error,batch_objective=batch_gradient(parameters,item['train_dets'][ix],item['train_labels'][ix],item['train_base_logits'][ix,:length],*features,example_weights)
+            total_grads=grads if total_grads is None else jax.tree_util.tree_map(jnp.add,total_grads,grads)
+            loss+=batch_loss/args.accumulate_conditions;error+=batch_error/args.accumulate_conditions
+            objective+=batch_objective/args.accumulate_conditions
+        total_grads=jax.tree_util.tree_map(lambda g:g/args.accumulate_conditions,total_grads)
+        parameters,state,norm=apply_gradient(parameters,state,total_grads)
+        if step==1 or step%16==0:
+            r={'step':step,'loss':float(loss),'objective':float(objective),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-started}
+            assert np.isfinite(r['loss']);records.append(r);print(json.dumps(r),flush=True)
+        if step%args.eval_every==0 or step==args.steps:evaluate(step)
+    provenance={'initialization':(f'Continue from the recorded session-trained checkpoint; original random initialization seed {args.initial_seed}' if args.init_weights else
+            f'All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed {args.initial_seed}'),
+        'prior_pass':args.prior_pass,'initial_seed':args.initial_seed,
+        'training_source_sha256':source_hashes,'runtime_versions':config['runtime_versions'],
+        'hidden_width':actual_hidden,
+        'input_features':input_features,'feature_mode':feature_mode,
+        'architecture':f'Two {actual_hidden}-unit SiLU layers; {input_features} features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.',
+        'training':('All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.' if args.training_cache else
+            '4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.'),
+        'training_cache':str(args.training_cache) if args.training_cache else None,
+        'training_cache_provenance':json.loads((args.training_cache/'provenance.json').read_text()) if args.training_cache else None,
+        'training_shots':sum(len(item['train_labels']) for item in dataset),
+        'training_pool_interpretation':'Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.',
+        'unique_training_rows_seen_in_this_phase':sum(int(mask.sum()) for mask in seen),
+        'unique_rows_by_condition':{item['row']['name']:int(mask.sum()) for item,mask in zip(dataset,seen)},
+        'gradient_block_size':args.gradient_block_size,
+        'bucket_operations':args.bucket_operations,
+        'accumulate_conditions':args.accumulate_conditions,
+        'effective_batch_size':args.batch*args.accumulate_conditions,
+        'uncertainty_weight_floor':args.uncertainty_weight_floor,
+        'example_weighting':('Uniform BCE' if args.uncertainty_weight_floor==1 else
+            'Frozen physical pass3 confidence gives w=floor+(1-floor)*4*p*(1-p), normalized within each condition batch. All weights positive; full validation remains unweighted.'),
+        'loss':'Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed',
+        'steps':args.steps,'batch':args.batch,'learning_rate':args.learning_rate,'sampling_seed':args.seed,
+        'optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1','optimizer_restored':restored,
+        'rng_restored':rng_restored,
+        'explicit_optimizer_reset':args.reset_optimizer,'explicit_rng_reset':args.reset_rng,
+        'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}',
+        'starting_checkpoint':str(args.init_weights) if args.init_weights else None,
+        'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None,
+        'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None,
+        'validation':'Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication',
+        'validation_shots_per_condition':args.validation_shots,'test_data_used':False,'records':records}
+    (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__checkpoint_gradient.py

@@ -0,0 +1,73 @@
+"""Exact logical BCE gradient with block recomputation of frontier histories."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width, block_size=32):
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+
+    @jax.jit
+    def evaluate(dets, labels, probabilities, masks, measured):
+        nops, batch = probabilities.shape
+        padding = (-nops) % block_size
+        p = jnp.pad(probabilities, ((0, padding), (0, 0)))
+        m = jnp.pad(masks, (0, padding))
+        d = jnp.pad(measured, (0, padding), constant_values=-1)
+        blocks = (p.reshape(-1, block_size, batch), m.reshape(-1, block_size),
+                  d.reshape(-1, block_size))
+
+        def forward(f, args):
+            probability, mask, detector = args
+
+            def error(f):
+                out = (1 - probability[:, None]) * f + probability[:, None] * f[:, indices ^ mask]
+                return out, jnp.ones(batch)
+
+            def project(f):
+                dst = (indices[None, :] & ~mask) | (dets[:, detector, None].astype(jnp.int32) * mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask) == 0)
+                norm = jnp.maximum(g.sum(axis=1), 1e-30)
+                return g / norm[:, None], norm
+
+            out, norm = jax.lax.cond(detector < 0, error, project, f)
+            return out, (f, norm)
+
+        def forward_block(f, args):
+            def step(carry, item):
+                result, _ = forward(carry, item)
+                return result, None
+            out, _ = jax.lax.scan(step, f, args)
+            return out, f
+
+        initial = jnp.zeros((batch, 1 << width), jnp.float32).at[:, 0].set(1)
+        f, checkpoints = jax.lax.scan(forward_block, initial, blocks)
+        indicator = ((indices[None, :] & 1) == labels[:, None])
+        correct = jnp.maximum(jnp.sum(f * indicator, axis=1), 1e-10)
+        prediction = jnp.sum(f[:, 1::2], axis=1)
+        terminal = 1 - indicator / correct[:, None]
+
+        def backward(b, args):
+            probability, mask, detector, old, norm = args
+
+            def error(b):
+                flipped = b[:, indices ^ mask]
+                grad = jnp.sum(old * (flipped - b), axis=1)
+                return (1 - probability[:, None]) * b + probability[:, None] * flipped, grad
+
+            def project(b):
+                obs = ((indices[None, :] & mask) == dets[:, detector, None].astype(jnp.int32) * mask)
+                values = b[:, indices & ~mask]
+                mean = jnp.sum(old * obs * values, axis=1) / norm
+                return (values - mean[:, None]) * obs / norm[:, None], jnp.zeros(batch)
+
+            return jax.lax.cond(detector < 0, error, project, b)
+
+        def backward_block(b, args):
+            probabilities, masks, measured, checkpoint = args
+            _, (history, norms) = jax.lax.scan(forward, checkpoint, (probabilities, masks, measured))
+            return jax.lax.scan(backward, b, (probabilities, masks, measured, history, norms), reverse=True)
+
+        _, gradients = jax.lax.scan(backward_block, terminal, (*blocks, checkpoints), reverse=True)
+        return -jnp.log(correct), prediction, gradients.reshape(-1, batch)[:nops]
+
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__gradient.py

@@ -0,0 +1,43 @@
+"""Differentiable conditional logical likelihood through exact DEM elimination."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width):
+    indices=jnp.arange(1<<width,dtype=jnp.int32)
+    @jax.jit
+    def evaluate(dets,labels,probabilities,masks,measured):
+        # Per-shot error probabilities have shape [operations,batch].
+        f=jnp.zeros((len(dets),1<<width),jnp.float32).at[:,0].set(1)
+        def forward(f,args):
+            p,mask,d=args
+            def error(f):
+                return (1-p[:,None])*f+p[:,None]*f[:,indices^mask],jnp.ones(len(dets))
+            def project(f):
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],norm
+            out,norm=jax.lax.cond(d<0,error,project,f)
+            return out,(f,norm)
+        f,(history,norms)=jax.lax.scan(forward,f,(probabilities,masks,measured))
+        indicator=((indices[None,:]&1)==labels[:,None])
+        correct=jnp.maximum(jnp.sum(f*indicator,axis=1),1e-10)
+        predicted=jnp.sum(f[:,1::2],axis=1)
+        initial=1-indicator/correct[:,None]
+        def backward(b,args):
+            p,mask,d,old,norm=args
+            def error(b):
+                flipped=b[:,indices^mask]
+                grad=jnp.sum(old*(flipped-b),axis=1)
+                return (1-p[:,None])*b+p[:,None]*flipped,grad
+            def project(b):
+                obs=((indices[None,:]&mask)==dets[:,d,None].astype(jnp.int32)*mask)
+                values=b[:,indices&~mask]
+                mean=jnp.sum(old*obs*values,axis=1)/norm
+                prior=(values-mean[:,None])*obs/norm[:,None]
+                return prior,jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        _,grad=jax.lax.scan(backward,initial,(probabilities,masks,measured,history,norms),reverse=True)
+        return -jnp.log(correct),predicted,grad
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__data.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_plan,parse_errors
+
+
+def _attach_arrays(item,root,splits):
+    row=item['row']
+    for split in splits:
+        a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little')
+        item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1])))
+        item[split+'_labels']=a['labels']
+
+
+def load_all(max_ops=3072,splits=('train','validation')):
+    assert set(splits)<=set(['train','validation'])
+    root=Path('/workspace/data')
+    rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3]
+    groups=sorted({r['group'] for r in rows});result=[]
+    cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}'
+    cache.mkdir(exist_ok=True)
+    for row in rows:
+        cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz"
+        if cached.exists():
+            item=dict(np.load(cached,allow_pickle=False));item['row']=row
+            _attach_arrays(item,root,splits);result.append(item);continue
+        dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem)
+        assert int(plan['width'])<=10
+        count=len(plan['masks']);assert count<=max_ops,(row['name'],count)
+        coords=dem.get_detector_coordinates()
+        circuit=stim.Circuit.from_file(root/'train'/row['circuit'])
+        qubit_coords=circuit.get_final_qubit_coordinates()
+        first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+        spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy())
+        assert len(spaces)==8
+        idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+        errors=parse_errors(dem)
+        context=np.full((max_ops,40),200,np.int32)
+        static=np.zeros((max_ops,57),np.float32)
+        for op,source in enumerate(plan['source_indices']):
+            if source<0:continue
+            ds,logical,p=errors[source]
+            t=min(int(coords[d][2]) for d in ds) if ds else 0
+            for dt in range(-2,3):
+                for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200)
+            for d in ds:
+                c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1
+            static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8
+            static[op,41]=logical;static[op,42]=len(ds)/4
+            static[op,43]=t/25;static[op,44]=row['rounds']/25
+            static[op,45]=t==0;static[op,46]=t>=row['rounds']-1
+            static[op,47+groups.index(row['group'])]=1
+            static[op,55]=row['basis']=='X';static[op,56]=1
+        masks=np.pad(plan['masks'],(0,max_ops-count))
+        measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1)
+        p=np.pad(plan['probabilities'],(0,max_ops-count))
+        valid=((p>0)&(measured<0)).astype(np.float32)
+        logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32)
+        item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid}
+        grid=np.full((26,8),200,np.int32)
+        measurement_indices=np.full(201,208,np.int32)
+        for detector,c in coords.items():
+            t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector
+            measurement_indices[detector]=t*8+s
+        item['grid']=grid;item['measurement_indices']=measurement_indices
+        item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32)
+        temporary=cached.with_suffix('.tmp.npz')
+        np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached)
+        _attach_arrays(item,root,splits)
+        result.append(item)
+    return result

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__fresh_specialize_train.py

@@ -0,0 +1,161 @@
+# Derived from specialize_train.py SHA256 5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95; fresh-seed parent provenance only, unchanged update equations.
+"""Fine-tune eight existing session-trained d3 models on their respective groups."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+from pathlib import Path
+import argparse, hashlib, json, shutil, sys, time
+import numpy as np
+import jax, jax.numpy as jnp, optax
+from data import load_all
+from temporal_model import probabilities
+from gradient import make_loss_and_grad
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_decoder
+
+FIELDS=['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']
+
+def sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+def main():
+    parser=argparse.ArgumentParser()
+    parser.add_argument('--package',type=Path,required=True)
+    parser.add_argument('--output',type=Path,required=True)
+    parser.add_argument('--steps',type=int,default=256)
+    parser.add_argument('--eval-every',type=int,default=128)
+    parser.add_argument('--batch',type=int,default=1024)
+    parser.add_argument('--validation-shots',type=int,default=1024)
+    parser.add_argument('--validation-batch',type=int,default=1024)
+    parser.add_argument('--learning-rate',type=float,default=.0001)
+    parser.add_argument('--seed',type=int,default=20261200)
+    parser.add_argument('--groups',nargs='+')
+    args=parser.parse_args()
+    assert args.steps>0 and args.eval_every>0 and args.batch>0
+    args.output.mkdir(parents=True,exist_ok=False)
+    config=json.loads((args.package/'model_config.json').read_text())
+    groups=sorted(config['temporal_contextual'])
+    if args.groups:
+        assert set(args.groups)<=set(groups)
+        groups=[g for g in groups if g in args.groups]
+    assert groups
+    source=Path(__file__).resolve();research=source.parent.parent
+    source_hashes={}
+    snapshot=args.output/'training_source';snapshot.mkdir()
+    for path in [source,source.parent/'temporal_model.py',source.parent/'data.py',
+                 source.parent/'gradient.py',research/'exact_d3/exact.py']:
+        name=str(path.relative_to(research)).replace('/','__')
+        shutil.copyfile(path,snapshot/name);source_hashes[name]=sha(path)
+    parents=args.output/'parents';parents.mkdir()
+    shutil.copyfile(args.package/'training_provenance.json',parents/'training_provenance.json')
+    shutil.copyfile(args.package/'model_config.json',parents/'model_config.json')
+    run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()}
+    run_config.update(training_source_sha256=source_hashes,
+                      runtime_versions={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__},
+                      parent_config_sha256=sha(parents/'model_config.json'),
+                      parent_provenance_sha256=sha(parents/'training_provenance.json'),
+                      train_manifest_sha256=sha('/workspace/data/train/manifest.json'),
+                      validation_manifest_sha256=sha('/workspace/data/validation/manifest.json'),
+                      groups=groups)
+    (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n')
+    started=time.time();dataset=load_all()
+    dataset=[item for item in dataset if item['row']['group'] in groups]
+    assert len(dataset)==13*len(groups)
+    optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(args.learning_rate,weight_decay=1e-4))
+    exact_gradient=make_loss_and_grad(10);exact_decode=make_decoder(10)
+
+    @jax.jit
+    def update(parameters,state,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters)
+        loss,pred,g=exact_gradient(ds,ys,p,masks,measured)
+        grads=pullback(g/len(ds))[0]
+        changes,state=optimizer.update(grads,state,parameters)
+        return optax.apply_updates(parameters,changes),state,jnp.mean(loss),jnp.mean((pred>=.5)!=ys),optax.global_norm(grads)
+
+    @jax.jit
+    def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts)
+        return exact_decode(ds,p,masks,measured)
+
+    reports={}
+    for group_index,group in enumerate(groups):
+        items=[item for item in dataset if item['row']['group']==group]
+        assert sorted(item['row']['rounds'] for item in items)==list(range(1,26,2))
+        out=args.output/group;out.mkdir()
+        settings=config['temporal_contextual'][group]
+        parent=args.package/settings['weights'];parent_copy=parents/f'{group}.npz'
+        shutil.copyfile(parent,parent_copy)
+        parameters={k:jnp.asarray(v) for k,v in dict(np.load(parent_copy,allow_pickle=False)).items()}
+        state=optimizer.init(parameters)
+        seed=args.seed+sorted(config['temporal_contextual']).index(group)
+        rng=np.random.default_rng(seed);seen=[np.zeros(len(i['train_labels']),bool) for i in items]
+        records=[]
+
+        def evaluate(step):
+            results=[];begin=time.time()
+            for item in items:
+                n=min(args.validation_shots,len(item['validation_labels']))
+                ix=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False)
+                vd=item['validation_dets'][ix];vy=item['validation_labels'][ix];parts=[]
+                for start in range(0,n,args.validation_batch):
+                    ds=vd[start:start+args.validation_batch];size=len(ds)
+                    ds=np.pad(ds,((0,args.validation_batch-size),(0,0)))
+                    parts.append(np.asarray(infer(parameters,ds,*[item[k] for k in FIELDS]))[:size])
+                p=np.concatenate(parts);pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64)
+                results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)),
+                                'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp)))})
+            result={'group':group,'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])),
+                    'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])),
+                    'seconds':time.time()-begin,'conditions':results}
+            (out/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n')
+            np.savez(out/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()})
+            leaves,_=jax.tree_util.tree_flatten(state)
+            np.savez(out/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+            (out/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+            checkpoint={'group':group,'step':step,'training_draws':step*args.batch,
+                        'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+                        'unique_rows_by_condition':{i['row']['name']:int(x.sum()) for i,x in zip(items,seen)},
+                        'weights':f'weights-{step}.npz','weights_sha256':sha(out/f'weights-{step}.npz'),'complete':True}
+            (out/f'checkpoint-{step}.json').write_text(json.dumps(checkpoint,indent=2)+'\n')
+            print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True)
+
+        evaluate(0)
+        for step in range(1,args.steps+1):
+            ci=int(rng.integers(len(items)));item=items[ci]
+            ix=rng.integers(len(item['train_labels']),size=args.batch);seen[ci][ix]=True
+            parameters,state,loss,error,norm=update(parameters,state,item['train_dets'][ix],item['train_labels'][ix],*[item[k] for k in FIELDS])
+            if step==1 or step%16==0:
+                record={'group':group,'step':step,'loss':float(loss),'error':float(error),
+                        'gradient_norm':float(norm),'elapsed':time.time()-started}
+                assert np.isfinite(record['loss']);records.append(record);print(json.dumps(record),flush=True)
+            if step%args.eval_every==0 or step==args.steps:evaluate(step)
+        provenance={'initialization':'Continue the temporal component of the selected session-trained group decoder; no new random parameters',
+                    'original_initialization':'Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session',
+                    'group':group,'parent_model':settings,'parent_weights_sha256':sha(parent_copy),
+                    'parent_provenance_sha256':run_config['parent_provenance_sha256'],
+                    'parent_record':'../parents/training_provenance.json',
+                    'training':'Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only',
+                    'eligible_training_shots':sum(len(i['train_labels']) for i in items),
+                    'training_draws':args.steps*args.batch,
+                    'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+                    'unique_rows_by_condition':{i['row']['name']:int(x.sum()) for i,x in zip(items,seen)},
+                    'steps':args.steps,'batch_size':args.batch,'learning_rate':args.learning_rate,
+                    'optimizer':'Fresh AdamW moments for every group, weight decay1e-4, global norm clip1',
+                    'optimizer_restored':False,'rng_restored':False,'sampling_seed':seed,
+                    'validation':'Fixed random screen per condition using seed20261028; full validation is used by the separate selector',
+                    'validation_shots_requested_per_condition':args.validation_shots,
+                    'loss':'Uniform binary conditional logical likelihood through exact frontier contraction',
+                    'training_source_sha256':source_hashes,'test_data_used':False,'log':records}
+        (out/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n');reports[group]=provenance
+    (args.output/'provenance.json').write_text(json.dumps({'experiment':'group-specific d3 continuation','groups':reports,
+        'initialization':'Continue session-trained selected temporal components; no new random parameters',
+        'training':'Each group samples uniformly over its own13 durations; supplied training labels only',
+        'eligible_training_shots':sum(len(i['train_labels']) for i in dataset),
+        'steps':args.steps*len(groups),'steps_per_group':args.steps,'batch_size':args.batch,
+        'learning_rate':args.learning_rate,'optimizer_restored':False,'rng_restored':False,
+        'training_source_sha256':source_hashes,
+        'run_config':run_config,'parent_record':'parents/training_provenance.json','new_random_parameters':0,
+        'training_draws':args.steps*args.batch*len(groups),'test_data_used':False},indent=2)+'\n')
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__gradient.py

@@ -0,0 +1,43 @@
+"""Differentiable conditional logical likelihood through exact DEM elimination."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width):
+    indices=jnp.arange(1<<width,dtype=jnp.int32)
+    @jax.jit
+    def evaluate(dets,labels,probabilities,masks,measured):
+        # Per-shot error probabilities have shape [operations,batch].
+        f=jnp.zeros((len(dets),1<<width),jnp.float32).at[:,0].set(1)
+        def forward(f,args):
+            p,mask,d=args
+            def error(f):
+                return (1-p[:,None])*f+p[:,None]*f[:,indices^mask],jnp.ones(len(dets))
+            def project(f):
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],norm
+            out,norm=jax.lax.cond(d<0,error,project,f)
+            return out,(f,norm)
+        f,(history,norms)=jax.lax.scan(forward,f,(probabilities,masks,measured))
+        indicator=((indices[None,:]&1)==labels[:,None])
+        correct=jnp.maximum(jnp.sum(f*indicator,axis=1),1e-10)
+        predicted=jnp.sum(f[:,1::2],axis=1)
+        initial=1-indicator/correct[:,None]
+        def backward(b,args):
+            p,mask,d,old,norm=args
+            def error(b):
+                flipped=b[:,indices^mask]
+                grad=jnp.sum(old*(flipped-b),axis=1)
+                return (1-p[:,None])*b+p[:,None]*flipped,grad
+            def project(b):
+                obs=((indices[None,:]&mask)==dets[:,d,None].astype(jnp.int32)*mask)
+                values=b[:,indices&~mask]
+                mean=jnp.sum(old*obs*values,axis=1)/norm
+                prior=(values-mean[:,None])*obs/norm[:,None]
+                return prior,jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        _,grad=jax.lax.scan(backward,initial,(probabilities,masks,measured,history,norms),reverse=True)
+        return -jnp.log(correct),predicted,grad
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__temporal_model.py

@@ -0,0 +1,44 @@
+"""Long temporal context for contextual exact d3 decoding."""
+import numpy as np
+import jax
+import jax.numpy as jnp
+
+
+def initialize_from_rich(path,seed=20261104,channels=32):
+    parameters={k:jnp.asarray(v) for k,v in dict(np.load(path,allow_pickle=False)).items()}
+    keys=jax.random.split(jax.random.key(seed),6)
+    parameters['w1']=jnp.concatenate([parameters['w1'],jax.random.normal(keys[0],(channels,parameters['w1'].shape[1]))*.001],axis=0)
+    parameters['temporal_in']=jax.random.normal(keys[1],(24,channels))*jnp.sqrt(2/24)
+    parameters['temporal_bias']=jnp.zeros(channels)
+    for i in range(4):
+        parameters[f'temporal_conv_{i}']=jax.random.normal(keys[i+2],(3,channels,channels))*jnp.sqrt(1/(3*channels))
+        parameters[f'temporal_conv_bias_{i}']=jnp.zeros(channels)
+    return parameters
+
+
+def probabilities(parameters,dets,context_indices,static,base_logits,valid,grid,measurement_indices,counts):
+    event_grid=dets[:,grid]
+    measurement_grid=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    observed=(grid!=200).astype(jnp.float32)
+    frames=jnp.concatenate([event_grid.astype(jnp.float32),measurement_grid*observed[None,:,:],
+        jnp.broadcast_to(observed[None,:,:],event_grid.shape)],axis=-1)
+    temporal=jax.nn.silu(frames@parameters['temporal_in']+parameters['temporal_bias'])
+    for i,dilation in enumerate([1,2,4,8]):
+        mean=jnp.mean(temporal,axis=-1,keepdims=True)
+        normalized=(temporal-mean)*jax.lax.rsqrt(jnp.mean((temporal-mean)**2,axis=-1,keepdims=True)+1e-5)
+        value=jax.lax.conv_general_dilated(normalized,parameters[f'temporal_conv_{i}'],(1,),padding='SAME',
+            rhs_dilation=(dilation,),dimension_numbers=('NWC','WIO','NWC'))
+        temporal=temporal+jax.nn.silu(value+parameters[f'temporal_conv_bias_{i}'])
+    times=jnp.clip(jnp.rint(static[:,43]*25).astype(jnp.int32),0,25)
+    temporal_context=temporal[:,times,:]
+    measured=jnp.pad(measurement_grid.reshape(len(dets),208),((0,0),(0,1)))
+    events=dets[:,context_indices].astype(jnp.float32)
+    measurements=measured[:,measurement_indices[context_indices]].astype(jnp.float32)
+    density=jnp.sum(event_grid,axis=1)/counts[None,:]
+    features=jnp.concatenate([events,measurements,
+        jnp.broadcast_to(density[:,None,:],(len(dets),len(context_indices),8)),
+        jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),temporal_context],axis=-1)
+    h=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    h=jax.nn.silu(h@parameters['w2']+parameters['b2'])
+    delta=4*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0])
+    return (jax.nn.sigmoid(base_logits[None,:]+delta)*valid[None,:]).T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/run_config.json

@@ -0,0 +1,37 @@
+{
+  "package": "/run-state/workspace/research/learned_exact/fresh_specialize1_parents",
+  "output": "/run-state/workspace/research/learned_exact/fresh_specialize1",
+  "steps": 256,
+  "eval_every": 128,
+  "batch": 1024,
+  "validation_shots": 1024,
+  "validation_batch": 1024,
+  "learning_rate": 0.0001,
+  "seed": 20261340,
+  "groups": [
+    "d3_bX_center_3_5",
+    "d3_bX_center_5_3",
+    "d3_bX_center_5_7",
+    "d3_bX_center_7_5",
+    "d3_bZ_center_3_5",
+    "d3_bZ_center_5_3",
+    "d3_bZ_center_5_7",
+    "d3_bZ_center_7_5"
+  ],
+  "training_source_sha256": {
+    "learned_exact__fresh_specialize_train.py": "a9e0de6a3ea39c5bc1b4cc81a8b112273a2f237df0e97f8ba6ccb4d70a632a5f",
+    "learned_exact__temporal_model.py": "76fd01d5ae50f7d0b5790800898e7103ddb86db8f6a2ace883407515add2e186",
+    "learned_exact__data.py": "6f88582230aec7bbf35170a672ff615cac0cf18c0a690b2983874bb4c02c75e6",
+    "learned_exact__gradient.py": "ecb6b45698480386fa124fe878db7dbfa246d1969fd720ec26daff9547da2001",
+    "exact_d3__exact.py": "869dfacb295c419c156d1070fc2afdd6e20d02ac1840e45e72346b2b289f4825"
+  },
+  "runtime_versions": {
+    "jax": "0.7.2",
+    "numpy": "2.3.3",
+    "optax": "0.2.6"
+  },
+  "parent_config_sha256": "7aaeceb1cb1b1de03d151539dfaf13bd195361484e553a8c0e7085eb3d563127",
+  "parent_provenance_sha256": "579a7c41148f2721b361f395a2fd70e17cf344be6528560fb13c54b713ffbdb0",
+  "train_manifest_sha256": "ce46c21e3595cfc5885bbe2b6481105317d2e6267498ec4572601469825914b8",
+  "validation_manifest_sha256": "482bb7268c6c827ebbf1f756ee6994750acfcd011adab08eaa2ada703e5faea1"
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__data.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_plan,parse_errors
+
+
+def _attach_arrays(item,root,splits):
+    row=item['row']
+    for split in splits:
+        a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little')
+        item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1])))
+        item[split+'_labels']=a['labels']
+
+
+def load_all(max_ops=3072,splits=('train','validation')):
+    assert set(splits)<=set(['train','validation'])
+    root=Path('/workspace/data')
+    rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3]
+    groups=sorted({r['group'] for r in rows});result=[]
+    cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}'
+    cache.mkdir(exist_ok=True)
+    for row in rows:
+        cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz"
+        if cached.exists():
+            item=dict(np.load(cached,allow_pickle=False));item['row']=row
+            _attach_arrays(item,root,splits);result.append(item);continue
+        dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem)
+        assert int(plan['width'])<=10
+        count=len(plan['masks']);assert count<=max_ops,(row['name'],count)
+        coords=dem.get_detector_coordinates()
+        circuit=stim.Circuit.from_file(root/'train'/row['circuit'])
+        qubit_coords=circuit.get_final_qubit_coordinates()
+        first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+        spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy())
+        assert len(spaces)==8
+        idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+        errors=parse_errors(dem)
+        context=np.full((max_ops,40),200,np.int32)
+        static=np.zeros((max_ops,57),np.float32)
+        for op,source in enumerate(plan['source_indices']):
+            if source<0:continue
+            ds,logical,p=errors[source]
+            t=min(int(coords[d][2]) for d in ds) if ds else 0
+            for dt in range(-2,3):
+                for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200)
+            for d in ds:
+                c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1
+            static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8
+            static[op,41]=logical;static[op,42]=len(ds)/4
+            static[op,43]=t/25;static[op,44]=row['rounds']/25
+            static[op,45]=t==0;static[op,46]=t>=row['rounds']-1
+            static[op,47+groups.index(row['group'])]=1
+            static[op,55]=row['basis']=='X';static[op,56]=1
+        masks=np.pad(plan['masks'],(0,max_ops-count))
+        measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1)
+        p=np.pad(plan['probabilities'],(0,max_ops-count))
+        valid=((p>0)&(measured<0)).astype(np.float32)
+        logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32)
+        item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid}
+        grid=np.full((26,8),200,np.int32)
+        measurement_indices=np.full(201,208,np.int32)
+        for detector,c in coords.items():
+            t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector
+            measurement_indices[detector]=t*8+s
+        item['grid']=grid;item['measurement_indices']=measurement_indices
+        item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32)
+        temporary=cached.with_suffix('.tmp.npz')
+        np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached)
+        _attach_arrays(item,root,splits)
+        result.append(item)
+    return result

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__fresh_temporal_initialization.py

@@ -0,0 +1,16 @@
+"""Fresh independent d3 trunk and temporal encoder; no checkpoint loading."""
+import jax
+import jax.numpy as jnp
+from model import initialize as initialize_trunk
+
+
+def initialize(seed=20261300, encoder_seed=20261301, channels=32):
+    parameters = initialize_trunk(seed, 145, hidden=128)
+    keys = jax.random.split(jax.random.key(encoder_seed), 6)
+    parameters['w1'] = jnp.concatenate([parameters['w1'], jax.random.normal(keys[0], (channels, 128)) * .001], axis=0)
+    parameters['temporal_in'] = jax.random.normal(keys[1], (24, channels)) * jnp.sqrt(2 / 24)
+    parameters['temporal_bias'] = jnp.zeros(channels)
+    for i in range(4):
+        parameters[f'temporal_conv_{i}'] = jax.random.normal(keys[i + 2], (3, channels, channels)) * jnp.sqrt(1 / (3 * channels))
+        parameters[f'temporal_conv_bias_{i}'] = jnp.zeros(channels)
+    return parameters

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__fresh_temporal_train.py

@@ -0,0 +1,140 @@
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+from pathlib import Path
+import argparse,json,time,sys,hashlib,shutil
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from temporal_model import probabilities
+from fresh_temporal_initialization import initialize
+from data import load_all
+from gradient import make_loss_and_grad
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_decoder
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--steps',type=int,default=512);parser.add_argument('--batch',type=int,default=128)
+    parser.add_argument('--output',type=Path,required=True);parser.add_argument('--validation-shots',type=int,default=1024)
+    parser.add_argument('--init-weights',type=Path)
+    parser.add_argument('--initial-seed',type=int,default=20261300)
+    parser.add_argument('--encoder-seed',type=int,default=20261301)
+    parser.add_argument('--learning-rate',type=float,default=1e-3)
+    parser.add_argument('--eval-every',type=int,default=256)
+    parser.add_argument('--seed',type=int,default=20261025)
+    parser.add_argument('--validation-batch',type=int,default=1024)
+    parser.add_argument('--uniform-validation',action='store_true')
+    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
+    run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()}
+    run_config['original_random_seed']=args.initial_seed
+    run_config['feature_mode']='events+measurements+global_density+temporal_convolutions'
+    run_config['temporal_seed']=args.encoder_seed
+    run_config['hidden_width']=128
+    run_config['logit_correction_bound']=4
+    run_config['starting_checkpoint_sha256']=hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None
+    run_config['train_manifest_sha256']=hashlib.sha256(Path('/workspace/data/train/manifest.json').read_bytes()).hexdigest()
+    run_config['validation_manifest_sha256']=hashlib.sha256(Path('/workspace/data/validation/manifest.json').read_bytes()).hexdigest()
+    source_root=Path(__file__).resolve().parent;research=source_root.parent
+    snapshot=args.output/'training_source';snapshot.mkdir(exist_ok=True)
+    source_hashes={}
+    for source in [Path(__file__).resolve(),source_root/'temporal_model.py',source_root/'fresh_temporal_initialization.py',source_root/'model.py',source_root/'data.py',source_root/'gradient.py',research/'exact_d3/exact.py']:
+        name=str(source.relative_to(research)).replace('/','__')
+        shutil.copyfile(source,snapshot/name);source_hashes[name]=hashlib.sha256(source.read_bytes()).hexdigest()
+    run_config['training_source_sha256']=source_hashes
+    run_config['runtime_versions']={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__}
+    (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n')
+    t=time.time();dataset=load_all();print(json.dumps({'loaded':len(dataset),'seconds':time.time()-t}),flush=True)
+    seen=[np.zeros(len(item['train_labels']),bool) for item in dataset]
+    parameters=initialize(args.initial_seed,args.encoder_seed)
+    if args.init_weights:
+        parent_config=json.loads((args.init_weights.parent/'run_config.json').read_text())
+        assert parent_config['initial_seed']==args.initial_seed and parent_config['encoder_seed']==args.encoder_seed
+        parameters={k:jnp.asarray(v) for k,v in dict(np.load(args.init_weights,allow_pickle=False)).items()}
+    optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(learning_rate=args.learning_rate,weight_decay=1e-4))
+    state=optimizer.init(parameters);exact_gradient=make_loss_and_grad(10)
+    rng=np.random.default_rng(args.seed);optimizer_restored=False;rng_restored=False
+    if args.init_weights:
+        optfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','optimizer-'))
+        if optfile.exists():
+            leaves,treedef=jax.tree_util.tree_flatten(state);saved=np.load(optfile,allow_pickle=False)
+            assert len(leaves)==len(saved.files)
+            state=jax.tree_util.tree_unflatten(treedef,[jnp.asarray(saved[f'arr_{i}']) for i in range(len(leaves))]);optimizer_restored=True
+        rngfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','rng-')).with_suffix('.json')
+        if rngfile.exists():rng.bit_generator.state=json.loads(rngfile.read_text());rng_restored=True
+    @jax.jit
+    def update(parameters,state,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters)
+        loss,pred,g=exact_gradient(ds,ys,p,masks,measured)
+        grads=pullback(g/len(ds))[0]
+        changes,state=optimizer.update(grads,state,parameters)
+        parameters=optax.apply_updates(parameters,changes)
+        return parameters,state,jnp.mean(loss),jnp.mean((pred>=.5)!=ys),optax.global_norm(grads)
+    exact_decode=make_decoder(10)
+    @jax.jit
+    def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts)
+        return exact_decode(ds,p,masks,measured)
+    def evaluate(step):
+        results=[];start=time.time()
+        for item in dataset:
+            n=min(args.validation_shots,len(item['validation_labels']));pred=[]
+            selected=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False) if args.uniform_validation else np.arange(n)
+            vd=item['validation_dets'][selected];vy=item['validation_labels'][selected]
+            for begin in range(0,n,args.validation_batch):
+                ds=vd[begin:begin+args.validation_batch];size=len(ds)
+                ds=np.pad(ds,((0,args.validation_batch-size),(0,0)))
+                p=np.asarray(infer(parameters,ds,*[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]))[:size]
+                pred.append(p)
+            p=np.concatenate(pred)
+            pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64)
+            results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)),
+                'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp))),
+                'brier':float(np.mean((p-vy)**2))})
+        result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])),
+                'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])),
+                'seconds':time.time()-start,'conditions':results}
+        (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n')
+        np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()})
+        leaves,_=jax.tree_util.tree_flatten(state)
+        np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+        (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+        (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'new_training_shots':step*args.batch,
+            'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+            'weights':f'weights-{step}.npz','weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(),
+            'validation':f'validation-{step}.json','complete':True},indent=2)+'\n')
+        print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True)
+    evaluate(0)
+    records=[]
+    for step in range(1,args.steps+1):
+        condition_index=int(rng.integers(len(dataset)));item=dataset[condition_index]
+        ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True
+        parameters,state,loss,error,norm=update(parameters,state,item['train_dets'][ix],item['train_labels'][ix],
+            *[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']])
+        if step%16==0 or step==1:
+            record={'step':step,'loss':float(loss),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-t}
+            records.append(record);print(json.dumps(record),flush=True)
+            if not np.isfinite(record['loss']):raise ValueError('Nonfinite training loss')
+        if step%args.eval_every==0 or step==args.steps:evaluate(step)
+    provenance={'initialization':('Continue from this session\'s trained checkpoint' if args.init_weights else 'Entire rich trunk and temporal encoder initialized randomly in this session; no learned checkpoint loaded'),
+        'original_initialization':f'Fresh128-unit rich trunk NumPy seed{args.initial_seed}: hidden weights Normal(0,1/sqrt(fan-in)),output Normal(0,.001),zero biases. Fresh32-channel temporal encoder JAX seed{args.encoder_seed}: variance-scaled normal input/convolution weights,zero biases; appendedinput rows Normal(0,.001).',
+        'initial_seed':args.initial_seed,'encoder_seed':args.encoder_seed,
+        'architecture':'Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.',
+        'training':'Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only',
+        'training_source_sha256':source_hashes,'runtime_versions':run_config['runtime_versions'],
+        'eligible_training_shots':sum(len(item['train_labels']) for item in dataset),
+        'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+        'unique_rows_by_condition':{item['row']['name']:int(x.sum()) for item,x in zip(dataset,seen)},
+        'steps':args.steps,'batch_size':args.batch,'optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1',
+        'learning_rate':args.learning_rate,'sampling_seed':args.seed,'optimizer_restored':optimizer_restored,'rng_restored':rng_restored,
+        'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}',
+        'session_trained_starting_checkpoint':str(args.init_weights) if args.init_weights else None,
+        'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None,
+        'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None,
+        'loss':'Binary conditional logical likelihood computed by exact frontier elimination',
+        'validation_shots_per_condition':args.validation_shots,'uniform_validation':args.uniform_validation,
+        'uniform_validation_seed':20261028 if args.uniform_validation else None,'test_data_used':False,'log':records}
+    (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__gradient.py

@@ -0,0 +1,43 @@
+"""Differentiable conditional logical likelihood through exact DEM elimination."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width):
+    indices=jnp.arange(1<<width,dtype=jnp.int32)
+    @jax.jit
+    def evaluate(dets,labels,probabilities,masks,measured):
+        # Per-shot error probabilities have shape [operations,batch].
+        f=jnp.zeros((len(dets),1<<width),jnp.float32).at[:,0].set(1)
+        def forward(f,args):
+            p,mask,d=args
+            def error(f):
+                return (1-p[:,None])*f+p[:,None]*f[:,indices^mask],jnp.ones(len(dets))
+            def project(f):
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],norm
+            out,norm=jax.lax.cond(d<0,error,project,f)
+            return out,(f,norm)
+        f,(history,norms)=jax.lax.scan(forward,f,(probabilities,masks,measured))
+        indicator=((indices[None,:]&1)==labels[:,None])
+        correct=jnp.maximum(jnp.sum(f*indicator,axis=1),1e-10)
+        predicted=jnp.sum(f[:,1::2],axis=1)
+        initial=1-indicator/correct[:,None]
+        def backward(b,args):
+            p,mask,d,old,norm=args
+            def error(b):
+                flipped=b[:,indices^mask]
+                grad=jnp.sum(old*(flipped-b),axis=1)
+                return (1-p[:,None])*b+p[:,None]*flipped,grad
+            def project(b):
+                obs=((indices[None,:]&mask)==dets[:,d,None].astype(jnp.int32)*mask)
+                values=b[:,indices&~mask]
+                mean=jnp.sum(old*obs*values,axis=1)/norm
+                prior=(values-mean[:,None])*obs/norm[:,None]
+                return prior,jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        _,grad=jax.lax.scan(backward,initial,(probabilities,masks,measured,history,norms),reverse=True)
+        return -jnp.log(correct),predicted,grad
+    return evaluate

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__model.py

@@ -0,0 +1,21 @@
+"""A small contextual network reweights hyperedges before exact decoding."""
+import numpy as np
+import jax
+import jax.numpy as jnp
+
+
+def initialize(seed,input_width,hidden=32):
+    rng=np.random.default_rng(seed)
+    return {'w1':jnp.asarray(rng.normal(0,1/np.sqrt(input_width),(input_width,hidden)),jnp.float32),
+            'b1':jnp.zeros(hidden),'w2':jnp.asarray(rng.normal(0,1/np.sqrt(hidden),(hidden,hidden)),jnp.float32),
+            'b2':jnp.zeros(hidden),'w3':jnp.asarray(rng.normal(0,.001,(hidden,1)),jnp.float32),'b3':jnp.zeros(1)}
+
+
+def probabilities(parameters,dets,context_indices,static,base_logits,valid):
+    observed=dets[:,context_indices].astype(jnp.float32)
+    features=jnp.concatenate([observed,jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape))],axis=-1)
+    hidden=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    hidden=jax.nn.silu(hidden@parameters['w2']+parameters['b2'])
+    delta=2*jnp.tanh((hidden@parameters['w3']+parameters['b3'])[...,0])
+    p=jax.nn.sigmoid(base_logits[None,:]+delta)*valid[None,:]
+    return p.T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_full/learned_exact__temporal_model.py

@@ -0,0 +1,44 @@
+"""Long temporal context for contextual exact d3 decoding."""
+import numpy as np
+import jax
+import jax.numpy as jnp
+
+
+def initialize_from_rich(path,seed=20261104,channels=32):
+    parameters={k:jnp.asarray(v) for k,v in dict(np.load(path,allow_pickle=False)).items()}
+    keys=jax.random.split(jax.random.key(seed),6)
+    parameters['w1']=jnp.concatenate([parameters['w1'],jax.random.normal(keys[0],(channels,parameters['w1'].shape[1]))*.001],axis=0)
+    parameters['temporal_in']=jax.random.normal(keys[1],(24,channels))*jnp.sqrt(2/24)
+    parameters['temporal_bias']=jnp.zeros(channels)
+    for i in range(4):
+        parameters[f'temporal_conv_{i}']=jax.random.normal(keys[i+2],(3,channels,channels))*jnp.sqrt(1/(3*channels))
+        parameters[f'temporal_conv_bias_{i}']=jnp.zeros(channels)
+    return parameters
+
+
+def probabilities(parameters,dets,context_indices,static,base_logits,valid,grid,measurement_indices,counts):
+    event_grid=dets[:,grid]
+    measurement_grid=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    observed=(grid!=200).astype(jnp.float32)
+    frames=jnp.concatenate([event_grid.astype(jnp.float32),measurement_grid*observed[None,:,:],
+        jnp.broadcast_to(observed[None,:,:],event_grid.shape)],axis=-1)
+    temporal=jax.nn.silu(frames@parameters['temporal_in']+parameters['temporal_bias'])
+    for i,dilation in enumerate([1,2,4,8]):
+        mean=jnp.mean(temporal,axis=-1,keepdims=True)
+        normalized=(temporal-mean)*jax.lax.rsqrt(jnp.mean((temporal-mean)**2,axis=-1,keepdims=True)+1e-5)
+        value=jax.lax.conv_general_dilated(normalized,parameters[f'temporal_conv_{i}'],(1,),padding='SAME',
+            rhs_dilation=(dilation,),dimension_numbers=('NWC','WIO','NWC'))
+        temporal=temporal+jax.nn.silu(value+parameters[f'temporal_conv_bias_{i}'])
+    times=jnp.clip(jnp.rint(static[:,43]*25).astype(jnp.int32),0,25)
+    temporal_context=temporal[:,times,:]
+    measured=jnp.pad(measurement_grid.reshape(len(dets),208),((0,0),(0,1)))
+    events=dets[:,context_indices].astype(jnp.float32)
+    measurements=measured[:,measurement_indices[context_indices]].astype(jnp.float32)
+    density=jnp.sum(event_grid,axis=1)/counts[None,:]
+    features=jnp.concatenate([events,measurements,
+        jnp.broadcast_to(density[:,None,:],(len(dets),len(context_indices),8)),
+        jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),temporal_context],axis=-1)
+    h=jax.nn.silu(features@parameters['w1']+parameters['b1'])
+    h=jax.nn.silu(h@parameters['w2']+parameters['b2'])
+    delta=4*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0])
+    return (jax.nn.sigmoid(base_logits[None,:]+delta)*valid[None,:]).T

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/exact_d3__exact.py

@@ -0,0 +1,213 @@
+"""Exact detector-error-model contraction by bounded-frontier elimination."""
+import collections
+import numpy as np
+import stim
+
+
+def parse_errors(dem):
+    errors = []
+    for ins in dem.flattened():
+        if ins.type != 'error':
+            continue
+        ds, logical = set(), 0
+        for t in ins.targets_copy():
+            if t.is_relative_detector_id():
+                ds.symmetric_difference_update([t.val])
+            elif t.is_logical_observable_id():
+                assert t.val == 0
+                logical ^= 1
+        errors.append((ds, logical, ins.args_copy()[0]))
+    return errors
+
+
+def elimination_order(dem, errors):
+    blocks = collections.defaultdict(list)
+    for d, c in dem.get_detector_coordinates().items():
+        blocks[c[-1]].append(d)
+    pending = [ds for ds, _, _ in errors if ds]
+    active, used, order = set(), set(), []
+    for _, block in sorted(blocks.items()):
+        remain = set(block)
+        while remain:
+            def score(d):
+                new = set().union(*(e for e in pending if d in e)) - used
+                return len(active | new), -sum(d in e for e in pending), d
+            d = min(remain, key=score)
+            related = [e for e in pending if d in e]
+            active |= set().union(*related) - used
+            active.discard(d)
+            pending = [e for e in pending if d not in e]
+            used.add(d)
+            remain.remove(d)
+            order.append(d)
+    assert sorted(order) == list(range(dem.num_detectors))
+    return order
+
+
+def make_plan(dem):
+    errors = parse_errors(dem)
+    order = elimination_order(dem, errors)
+    rank = {d: i for i, d in enumerate(order)}
+    groups = collections.defaultdict(list)
+    for source_index, (ds, logical, p) in enumerate(errors):
+        first = min(ds, key=rank.get) if ds else order[0]
+        groups[first].append((ds, logical, p, source_index))
+    slots, probabilities, masks, measured, source_indices = {}, [], [], [], []
+    width = 1
+    for d in order:
+        related = groups[d]
+        needed = set().union(*(ds for ds, _, _, _ in related)) | {d}
+        for node in sorted(needed):
+            if node not in slots:
+                free = next(i for i in range(1, 64) if i not in slots.values())
+                slots[node] = free
+                width = max(width, free+1)
+        for ds, logical, p, source_index in related:
+            mask = logical
+            for node in ds:
+                mask ^= 1 << slots[node]
+            probabilities.append(p)
+            masks.append(mask)
+            measured.append(-1)
+            source_indices.append(source_index)
+        probabilities.append(0)
+        masks.append(1 << slots.pop(d))
+        measured.append(d)
+        source_indices.append(-1)
+    assert not slots
+    return {'probabilities': np.array(probabilities, np.float32),
+            'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32),
+            'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32),
+            'source_indices': np.array(source_indices, np.int32),
+            'order': np.array(order, np.int32)}
+
+
+def make_decoder(width):
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    @jax.jit
+    def decode(dets, probabilities, masks, measured):
+        f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1)
+        def step(f, args):
+            p, mask, d = args
+            def error(f):
+                prob = p[:, None] if p.ndim else p
+                return (1-prob)*f + prob*f[:, indices ^ mask]
+            def project(f):
+                obs = dets[:, d].astype(jnp.int32)
+                dst = (indices[None, :] & ~mask) | (obs[:, None]*mask)
+                g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0)
+                return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30)
+            return jax.lax.cond(d < 0, error, project, f), None
+        f, _ = jax.lax.scan(step, f, (probabilities, masks, measured))
+        return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30)
+    return decode
+
+
+def make_marginals(width):
+    """Per-shot derivatives of log syndrome probability give all error marginals."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    def log_partition(dets, probabilities, masks, measured):
+        f = jnp.zeros(1 << width, jnp.float32).at[0].set(1)
+        def step(carry, args):
+            f, logz = carry
+            p, mask, d = args
+            def error(carry):
+                f, logz = carry
+                return ((1-p)*f + p*f[indices ^ mask], logz)
+            def project(carry):
+                f, logz = carry
+                dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask)
+                g = f[dst] * ((indices & mask)==0)
+                norm = jnp.maximum(jnp.sum(g), 1e-30)
+                return g/norm, logz+jnp.log(norm)
+            return jax.lax.cond(d<0, error, project, carry), None
+        (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured))
+        return logz
+    return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None)))
+
+
+def make_marginals_fb(width, return_observable=False):
+    """Forward/backward contraction without generic gather-gradient scatter."""
+    import jax
+    import jax.numpy as jnp
+    indices = jnp.arange(1 << width, dtype=jnp.int32)
+    # The syndrome likelihood marginalizes the unobserved logical bit. Keep
+    # that bit in the forward state for its output, but omit it from histories
+    # and backward messages, halving the largest buffers.
+    backward_width=width-1 if return_observable else width
+    backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32)
+    @jax.jit
+    def marginals(dets, probabilities, masks, measured):
+        f=jnp.zeros((dets.shape[0],1<<width),jnp.float32).at[:,0].set(1)
+        def forward(carry,args):
+            f,logz=carry
+            p,mask,d=args
+            def error(carry):
+                f,logz=carry
+                prob=p[:,None] if p.ndim else p
+                return ((1-prob)*f+prob*f[:,indices^mask],logz)
+            def project(carry):
+                f,logz=carry
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],logz+jnp.log(norm)
+            out=jax.lax.cond(d<0,error,project,carry)
+            return out,(f[:,::2]+f[:,1::2]) if return_observable else f
+        (final,logz),history=jax.lax.scan(forward,(f,jnp.zeros(len(dets))),(probabilities,masks,measured))
+        def backward(b,args):
+            p,mask,d,f=args
+            def error(b):
+                flipped=b[:,backward_indices^mask]
+                prob=p[:,None] if p.ndim else p
+                prior=(1-prob)*b+prob*flipped
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                q=p*jnp.sum(f*flipped,axis=1)/norm
+                grad=(q-p)/jnp.maximum(p*(1-p),1e-20)
+                return prior/norm[:,None],grad
+            def project(b):
+                prior=b[:,backward_indices&~mask]*((backward_indices[None,:]&mask)==(dets[:,d,None].astype(jnp.int32)*mask))
+                norm=jnp.maximum(jnp.sum(f*prior,axis=1),1e-30)
+                return prior/norm[:,None],jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        backward_masks=masks>>1 if return_observable else masks
+        _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<<backward_width),jnp.float32),
+            (probabilities,backward_masks,measured,history),reverse=True)
+        if return_observable:
+            return logz,grad.T,jnp.sum(final[:,1::2],axis=1)/jnp.maximum(jnp.sum(final,axis=1),1e-30)
+        return logz,grad.T
+    return marginals
+
+
+def predict(plan, packed, decoder=None, batch=256):
+    import jax
+    decoder = decoder or make_decoder(int(plan['width']))
+    dets = np.unpackbits(packed, bitorder='little', axis=1, count=int(plan['num_detectors']))
+    args = [jax.device_put(plan[k]) for k in ['probabilities', 'masks', 'measured']]
+    result = []
+    for start in range(0, len(dets), batch):
+        ds = dets[start:start+batch]
+        ds = np.pad(ds, ((0, batch-len(ds)), (0, 0)))
+        result.append(np.asarray(decoder(ds, *args))[:min(batch, len(dets)-start)])
+    return np.concatenate(result)
+
+
+if __name__ == '__main__':
+    import sys, time
+    from pathlib import Path
+    import jax
+    print(jax.devices(), flush=True)
+    path = Path(sys.argv[1])
+    dem = stim.DetectorErrorModel.from_file(path/'pij_from_even_for_odd.dem')
+    plan = make_plan(dem)
+    print({k: v.shape if v.ndim else int(v) for k, v in plan.items()}, flush=True)
+    a = np.load(path/'arrays.npz')
+    decoder = make_decoder(int(plan['width']))
+    for i in range(2):
+        t = time.time()
+        p = predict(plan, a['detectors'][:1024], decoder)
+        print({'seconds': time.time()-t, 'failure': np.mean((p>=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/learned_exact__average_fresh_temporal.py

@@ -0,0 +1,31 @@
+"""Predefined parameter averages of the d3 temporal continuation checkpoints."""
+from pathlib import Path
+import hashlib,json,shutil
+import numpy as np
+root=Path(__file__).resolve().parent;source=root/'fresh_temporal1_full';out=root/'fresh_temporal1_swa'
+out.mkdir()
+parent=json.loads((source/'provenance.json').read_text())
+specifications={'mean2':[4096,6144],'mean3':[2048,4096,6144]}
+records={}
+for label,steps in specifications.items():
+    checkpoints=[dict(np.load(source/f'weights-{step}.npz',allow_pickle=False)) for step in steps]
+    assert all(set(w)==set(checkpoints[0]) for w in checkpoints)
+    weights={key:np.mean(np.stack([w[key].astype(np.float64) for w in checkpoints]),axis=0).astype(np.float32)
+             for key in checkpoints[0]}
+    assert all(np.isfinite(value).all() for value in weights.values())
+    assert all(all(w[k].shape==checkpoints[0][k].shape for k in weights) for w in checkpoints)
+    path=out/f'weights-{label}.npz';np.savez(path,**weights)
+    record={'checkpoint_label':label,'kind':'uniform_parameter_average','optimizer_updates_in_derived_run':0,
+            'source_optimizer_steps':steps,'source_training_run':'fresh_temporal1_full',
+            'source_weights_sha256':{str(step):hashlib.sha256((source/f'weights-{step}.npz').read_bytes()).hexdigest() for step in steps},
+            'source_checkpoint_records':{str(step):json.loads((source/f'checkpoint-{step}.json').read_text()) for step in steps},
+            'weights_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'complete':True}
+    records[label]=record;(out/f'checkpoint-{label}.json').write_text(json.dumps(record,indent=2)+'\n')
+shutil.copytree(source/'training_source',out/'training_source')
+shutil.copyfile(Path(__file__),out/'training_source/learned_exact__average_fresh_temporal.py')
+provenance={'initialization':'Uniform averages of the same session-trained temporal trajectory; no external weights',
+            'optimizer_updates_in_derived_run':0,'source_training_provenance':parent,'derived_checkpoints':records,'declared_plan':json.loads((root/'fresh_temporal1_swa_plan.json').read_text()),
+            'selection':'Predefined last-two and last-three noninitial fresh_temporal1_full checkpoint means, declared before later checkpoints completed; all104conditions evaluated before group selection',
+            'test_data_used':False,'derivation_source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}
+(out/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+print(json.dumps({'run':str(out),'labels':list(records),'new_optimizer_updates':0}),flush=True)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/learned_exact__data.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+import json,sys
+import numpy as np
+import stim
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_plan,parse_errors
+
+
+def _attach_arrays(item,root,splits):
+    row=item['row']
+    for split in splits:
+        a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little')
+        item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1])))
+        item[split+'_labels']=a['labels']
+
+
+def load_all(max_ops=3072,splits=('train','validation')):
+    assert set(splits)<=set(['train','validation'])
+    root=Path('/workspace/data')
+    rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3]
+    groups=sorted({r['group'] for r in rows});result=[]
+    cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}'
+    cache.mkdir(exist_ok=True)
+    for row in rows:
+        cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz"
+        if cached.exists():
+            item=dict(np.load(cached,allow_pickle=False));item['row']=row
+            _attach_arrays(item,root,splits);result.append(item);continue
+        dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem)
+        assert int(plan['width'])<=10
+        count=len(plan['masks']);assert count<=max_ops,(row['name'],count)
+        coords=dem.get_detector_coordinates()
+        circuit=stim.Circuit.from_file(root/'train'/row['circuit'])
+        qubit_coords=circuit.get_final_qubit_coordinates()
+        first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX'])
+        spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy())
+        assert len(spaces)==8
+        idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()}
+        errors=parse_errors(dem)
+        context=np.full((max_ops,40),200,np.int32)
+        static=np.zeros((max_ops,57),np.float32)
+        for op,source in enumerate(plan['source_indices']):
+            if source<0:continue
+            ds,logical,p=errors[source]
+            t=min(int(coords[d][2]) for d in ds) if ds else 0
+            for dt in range(-2,3):
+                for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200)
+            for d in ds:
+                c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1
+            static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8
+            static[op,41]=logical;static[op,42]=len(ds)/4
+            static[op,43]=t/25;static[op,44]=row['rounds']/25
+            static[op,45]=t==0;static[op,46]=t>=row['rounds']-1
+            static[op,47+groups.index(row['group'])]=1
+            static[op,55]=row['basis']=='X';static[op,56]=1
+        masks=np.pad(plan['masks'],(0,max_ops-count))
+        measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1)
+        p=np.pad(plan['probabilities'],(0,max_ops-count))
+        valid=((p>0)&(measured<0)).astype(np.float32)
+        logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32)
+        item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid}
+        grid=np.full((26,8),200,np.int32)
+        measurement_indices=np.full(201,208,np.int32)
+        for detector,c in coords.items():
+            t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector
+            measurement_indices[detector]=t*8+s
+        item['grid']=grid;item['measurement_indices']=measurement_indices
+        item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32)
+        temporary=cached.with_suffix('.tmp.npz')
+        np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached)
+        _attach_arrays(item,root,splits)
+        result.append(item)
+    return result

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/learned_exact__fresh_temporal_initialization.py

@@ -0,0 +1,16 @@
+"""Fresh independent d3 trunk and temporal encoder; no checkpoint loading."""
+import jax
+import jax.numpy as jnp
+from model import initialize as initialize_trunk
+
+
+def initialize(seed=20261300, encoder_seed=20261301, channels=32):
+    parameters = initialize_trunk(seed, 145, hidden=128)
+    keys = jax.random.split(jax.random.key(encoder_seed), 6)
+    parameters['w1'] = jnp.concatenate([parameters['w1'], jax.random.normal(keys[0], (channels, 128)) * .001], axis=0)
+    parameters['temporal_in'] = jax.random.normal(keys[1], (24, channels)) * jnp.sqrt(2 / 24)
+    parameters['temporal_bias'] = jnp.zeros(channels)
+    for i in range(4):
+        parameters[f'temporal_conv_{i}'] = jax.random.normal(keys[i + 2], (3, channels, channels)) * jnp.sqrt(1 / (3 * channels))
+        parameters[f'temporal_conv_bias_{i}'] = jnp.zeros(channels)
+    return parameters

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/learned_exact__fresh_temporal_train.py

@@ -0,0 +1,140 @@
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1'
+os.environ['OMP_NUM_THREADS']='1'
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+from pathlib import Path
+import argparse,json,time,sys,hashlib,shutil
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from temporal_model import probabilities
+from fresh_temporal_initialization import initialize
+from data import load_all
+from gradient import make_loss_and_grad
+sys.path.insert(0,'/workspace/research/exact_d3')
+from exact import make_decoder
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--steps',type=int,default=512);parser.add_argument('--batch',type=int,default=128)
+    parser.add_argument('--output',type=Path,required=True);parser.add_argument('--validation-shots',type=int,default=1024)
+    parser.add_argument('--init-weights',type=Path)
+    parser.add_argument('--initial-seed',type=int,default=20261300)
+    parser.add_argument('--encoder-seed',type=int,default=20261301)
+    parser.add_argument('--learning-rate',type=float,default=1e-3)
+    parser.add_argument('--eval-every',type=int,default=256)
+    parser.add_argument('--seed',type=int,default=20261025)
+    parser.add_argument('--validation-batch',type=int,default=1024)
+    parser.add_argument('--uniform-validation',action='store_true')
+    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
+    run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()}
+    run_config['original_random_seed']=args.initial_seed
+    run_config['feature_mode']='events+measurements+global_density+temporal_convolutions'
+    run_config['temporal_seed']=args.encoder_seed
+    run_config['hidden_width']=128
+    run_config['logit_correction_bound']=4
+    run_config['starting_checkpoint_sha256']=hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None
+    run_config['train_manifest_sha256']=hashlib.sha256(Path('/workspace/data/train/manifest.json').read_bytes()).hexdigest()
+    run_config['validation_manifest_sha256']=hashlib.sha256(Path('/workspace/data/validation/manifest.json').read_bytes()).hexdigest()
+    source_root=Path(__file__).resolve().parent;research=source_root.parent
+    snapshot=args.output/'training_source';snapshot.mkdir(exist_ok=True)
+    source_hashes={}
+    for source in [Path(__file__).resolve(),source_root/'temporal_model.py',source_root/'fresh_temporal_initialization.py',source_root/'model.py',source_root/'data.py',source_root/'gradient.py',research/'exact_d3/exact.py']:
+        name=str(source.relative_to(research)).replace('/','__')
+        shutil.copyfile(source,snapshot/name);source_hashes[name]=hashlib.sha256(source.read_bytes()).hexdigest()
+    run_config['training_source_sha256']=source_hashes
+    run_config['runtime_versions']={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__}
+    (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n')
+    t=time.time();dataset=load_all();print(json.dumps({'loaded':len(dataset),'seconds':time.time()-t}),flush=True)
+    seen=[np.zeros(len(item['train_labels']),bool) for item in dataset]
+    parameters=initialize(args.initial_seed,args.encoder_seed)
+    if args.init_weights:
+        parent_config=json.loads((args.init_weights.parent/'run_config.json').read_text())
+        assert parent_config['initial_seed']==args.initial_seed and parent_config['encoder_seed']==args.encoder_seed
+        parameters={k:jnp.asarray(v) for k,v in dict(np.load(args.init_weights,allow_pickle=False)).items()}
+    optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(learning_rate=args.learning_rate,weight_decay=1e-4))
+    state=optimizer.init(parameters);exact_gradient=make_loss_and_grad(10)
+    rng=np.random.default_rng(args.seed);optimizer_restored=False;rng_restored=False
+    if args.init_weights:
+        optfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','optimizer-'))
+        if optfile.exists():
+            leaves,treedef=jax.tree_util.tree_flatten(state);saved=np.load(optfile,allow_pickle=False)
+            assert len(leaves)==len(saved.files)
+            state=jax.tree_util.tree_unflatten(treedef,[jnp.asarray(saved[f'arr_{i}']) for i in range(len(leaves))]);optimizer_restored=True
+        rngfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','rng-')).with_suffix('.json')
+        if rngfile.exists():rng.bit_generator.state=json.loads(rngfile.read_text());rng_restored=True
+    @jax.jit
+    def update(parameters,state,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters)
+        loss,pred,g=exact_gradient(ds,ys,p,masks,measured)
+        grads=pullback(g/len(ds))[0]
+        changes,state=optimizer.update(grads,state,parameters)
+        parameters=optax.apply_updates(parameters,changes)
+        return parameters,state,jnp.mean(loss),jnp.mean((pred>=.5)!=ys),optax.global_norm(grads)
+    exact_decode=make_decoder(10)
+    @jax.jit
+    def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+        p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts)
+        return exact_decode(ds,p,masks,measured)
+    def evaluate(step):
+        results=[];start=time.time()
+        for item in dataset:
+            n=min(args.validation_shots,len(item['validation_labels']));pred=[]
+            selected=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False) if args.uniform_validation else np.arange(n)
+            vd=item['validation_dets'][selected];vy=item['validation_labels'][selected]
+            for begin in range(0,n,args.validation_batch):
+                ds=vd[begin:begin+args.validation_batch];size=len(ds)
+                ds=np.pad(ds,((0,args.validation_batch-size),(0,0)))
+                p=np.asarray(infer(parameters,ds,*[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]))[:size]
+                pred.append(p)
+            p=np.concatenate(pred)
+            pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64)
+            results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)),
+                'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp))),
+                'brier':float(np.mean((p-vy)**2))})
+        result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])),
+                'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])),
+                'seconds':time.time()-start,'conditions':results}
+        (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n')
+        np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()})
+        leaves,_=jax.tree_util.tree_flatten(state)
+        np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+        (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+        (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'new_training_shots':step*args.batch,
+            'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+            'weights':f'weights-{step}.npz','weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(),
+            'validation':f'validation-{step}.json','complete':True},indent=2)+'\n')
+        print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True)
+    evaluate(0)
+    records=[]
+    for step in range(1,args.steps+1):
+        condition_index=int(rng.integers(len(dataset)));item=dataset[condition_index]
+        ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True
+        parameters,state,loss,error,norm=update(parameters,state,item['train_dets'][ix],item['train_labels'][ix],
+            *[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']])
+        if step%16==0 or step==1:
+            record={'step':step,'loss':float(loss),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-t}
+            records.append(record);print(json.dumps(record),flush=True)
+            if not np.isfinite(record['loss']):raise ValueError('Nonfinite training loss')
+        if step%args.eval_every==0 or step==args.steps:evaluate(step)
+    provenance={'initialization':('Continue from this session\'s trained checkpoint' if args.init_weights else 'Entire rich trunk and temporal encoder initialized randomly in this session; no learned checkpoint loaded'),
+        'original_initialization':f'Fresh128-unit rich trunk NumPy seed{args.initial_seed}: hidden weights Normal(0,1/sqrt(fan-in)),output Normal(0,.001),zero biases. Fresh32-channel temporal encoder JAX seed{args.encoder_seed}: variance-scaled normal input/convolution weights,zero biases; appendedinput rows Normal(0,.001).',
+        'initial_seed':args.initial_seed,'encoder_seed':args.encoder_seed,
+        'architecture':'Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.',
+        'training':'Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only',
+        'training_source_sha256':source_hashes,'runtime_versions':run_config['runtime_versions'],
+        'eligible_training_shots':sum(len(item['train_labels']) for item in dataset),
+        'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen),
+        'unique_rows_by_condition':{item['row']['name']:int(x.sum()) for item,x in zip(dataset,seen)},
+        'steps':args.steps,'batch_size':args.batch,'optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1',
+        'learning_rate':args.learning_rate,'sampling_seed':args.seed,'optimizer_restored':optimizer_restored,'rng_restored':rng_restored,
+        'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}',
+        'session_trained_starting_checkpoint':str(args.init_weights) if args.init_weights else None,
+        'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None,
+        'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None,
+        'loss':'Binary conditional logical likelihood computed by exact frontier elimination',
+        'validation_shots_per_condition':args.validation_shots,'uniform_validation':args.uniform_validation,
+        'uniform_validation_seed':20261028 if args.uniform_validation else None,'test_data_used':False,'log':records}
+    (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+
+
+if __name__=='__main__':main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_temporal1_swa/learned_exact__gradient.py

@@ -0,0 +1,43 @@
+"""Differentiable conditional logical likelihood through exact DEM elimination."""
+import jax
+import jax.numpy as jnp
+
+
+def make_loss_and_grad(width):
+    indices=jnp.arange(1<<width,dtype=jnp.int32)
+    @jax.jit
+    def evaluate(dets,labels,probabilities,masks,measured):
+        # Per-shot error probabilities have shape [operations,batch].
+        f=jnp.zeros((len(dets),1<<width),jnp.float32).at[:,0].set(1)
+        def forward(f,args):
+            p,mask,d=args
+            def error(f):
+                return (1-p[:,None])*f+p[:,None]*f[:,indices^mask],jnp.ones(len(dets))
+            def project(f):
+                dst=(indices[None,:]&~mask)|(dets[:,d,None].astype(jnp.int32)*mask)
+                g=jnp.take_along_axis(f,dst,axis=1)*((indices&mask)==0)
+                norm=jnp.maximum(g.sum(axis=1),1e-30)
+                return g/norm[:,None],norm
+            out,norm=jax.lax.cond(d<0,error,project,f)
+            return out,(f,norm)
+        f,(history,norms)=jax.lax.scan(forward,f,(probabilities,masks,measured))
+        indicator=((indices[None,:]&1)==labels[:,None])
+        correct=jnp.maximum(jnp.sum(f*indicator,axis=1),1e-10)
+        predicted=jnp.sum(f[:,1::2],axis=1)
+        initial=1-indicator/correct[:,None]
+        def backward(b,args):
+            p,mask,d,old,norm=args
+            def error(b):
+                flipped=b[:,indices^mask]
+                grad=jnp.sum(old*(flipped-b),axis=1)
+                return (1-p[:,None])*b+p[:,None]*flipped,grad
+            def project(b):
+                obs=((indices[None,:]&mask)==dets[:,d,None].astype(jnp.int32)*mask)
+                values=b[:,indices&~mask]
+                mean=jnp.sum(old*obs*values,axis=1)/norm
+                prior=(values-mean[:,None])*obs/norm[:,None]
+                return prior,jnp.zeros(len(dets))
+            return jax.lax.cond(d<0,error,project,b)
+        _,grad=jax.lax.scan(backward,initial,(probabilities,masks,measured,history,norms),reverse=True)
+        return -jnp.log(correct),predicted,grad
+    return evaluate