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

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/runtime_sources/persistent_attention1/plan.json

@@ -0,0 +1,31 @@
+{
+  "name": "persistent_attention1",
+  "created_utc": "2026-10-21T21:43:42.641693+00:00",
+  "status": "CPU controls passed; queued after pretrained_axial1",
+  "hypothesis": "Global per-condition jax.clear_caches in hybrid3 forces repeated compilation of fixed-shape attention. Retain bounded compiled callable across clears to reduce startup overhead. CPU controls confirmed retention and exact predictions; GPU runtime benefit unmeasured.",
+  "changes": "Only two recognized axial dispatchers use PersistentCompiled instead of jax.jit; shapes/dtypes/weaktypes form cache key, at most2 executables per wrapper. No weights, modelconfig, loss, training, validation choice or mathematical inference changes.",
+  "current_reference": {
+    "package": "/run-state/workspace/research/context_upgrades/axial_residual1/package",
+    "predictions": "/run-state/workspace/research/context_upgrades/axial_residual1/predictions",
+    "score": "/run-state/workspace/research/context_upgrades/axial_residual1/score.json",
+    "P": 0.7674663837139424
+  },
+  "queue_after": "pretrained_axial/pretrained_axial1_finished.json",
+  "mandatory_before_publication": "ActualnativeGPU B256repeatedfreshJIT/clear/order/shapecontrols and<75GiBpeak; full26d5actualreplay+trusted130score;0decisionchangesandmaxprobdelta<1e-5;readonlyrelocationchecks; actualreplayfasterthanthen-currentrecordedreplay;runtimeprojection<3600. No publicationifnoactiveattentionroute ornotfaster. Timingsareseparateruns.",
+  "test_data_used": false,
+  "frozen_source_sha256": {
+    "persistent_attention/control_cpu.py": "6a065ed03d1ddb27a46a15479987b8a836d0328c965975dc9c0ce02969326691",
+    "persistent_attention/after_pretrained.py": "732d28a009eec864f0b056b3ba78202a1aa21202ae7b70d38dc92b1909158476",
+    "persistent_attention/export_control_cpu.py": "eddf82b51a3cdff62b514c69e0cd9fa611f7e9302a8fbfd9b00738284820ceb3",
+    "persistent_attention/compiled.py": "c54ce7837bc6ad683ed2b5bf5353eb161dc12156ae5564618e1c4f08489386dd",
+    "persistent_attention/control_gpu.py": "6243506814a7b31b7123a77136d976c496a0f4dc4850b8dbe44977138fb13e82",
+    "persistent_attention/export.py": "59c5c3e0a9e94374626f58dd7a6cd6bcc34ec32c5f73ba819ef34d38213b8301",
+    "persistent_attention/control_cpu.json": "36496b247c1f6c43220fa9a72eab20e2e665b79e6f6cf67dc113dabf097034de",
+    "persistent_attention/export_control_cpu.json": "3f90b6f33ee84f1c12f6d16bb9be5948cdde39ea8d5e7ce148a272f7ed4c0936",
+    "axial_residual/model.py": "a62d91d239325f45d9f1a6af6e91095b8d6028a52959dcb7b98ba109df097537",
+    "axial_residual/data.py": "3fb7f50cac3adf37b53db5873965a8e62e6eac09ccc54d89198ec569450271d3",
+    "axial_residual/contextual.py": "6865098931f4c9a84c791235fb3e0a0e0e5a8b4d10150b924528f078793f589c",
+    "pretrained_axial/contextual.py": "3b70b79285379b3424bb422daaf99dcebfa152e8695e858b58ecfa7376a359d0",
+    "axial_residual/axial1/weights-2048.npz": "c26b6b6faf8ac559161f1ba5370bd2ac7302e77852849ba1742a7a14eae3a9a3"
+  }
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/short_syndrome_model.py

@@ -0,0 +1,8 @@
+"""Categorical logical decoder indexed only by an8-bit detection syndrome."""
+import numpy as np
+from scipy.special import expit
+
+def predict(packed,state):
+    assert packed.dtype==np.uint8 and packed.ndim==2 and packed.shape[1]==1
+    key=packed[:,0]
+    return expit(state['physical_logits'][key]+state['residual_logits'][key]).astype(np.float32)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/temporal_base_contextual.py

@@ -0,0 +1,32 @@
+"""Portable temporal contextual exact decoder with shot-local features."""
+from pathlib import Path
+import numpy as np
+
+
+class TemporalContextualDecoder:
+    def __init__(self):
+        import jax
+        from temporal_model import probabilities
+        from exact import make_decoder
+        exact=make_decoder(10)
+        @jax.jit
+        def infer(weights,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts):
+            p=probabilities(weights,ds,context,static,base_logits,valid,grid,measurement_indices,counts)
+            return exact(ds,p,masks,measured)
+        self.infer=infer;self.weights={}
+
+    def predict(self,root,record,group_record,packed,num_detectors,batch=1024):
+        import jax.numpy as jnp
+        path=group_record['weights']
+        if path not in self.weights:
+            self.weights[path]={k:jnp.asarray(v) for k,v in dict(np.load(root/path,allow_pickle=False)).items()}
+        plan=dict(np.load(root/record['rich_plan'],allow_pickle=False))
+        ds=np.unpackbits(packed,axis=1,count=num_detectors,bitorder='little')
+        ds=np.pad(ds,((0,0),(0,201-num_detectors)))
+        args=[plan[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]
+        outputs=[]
+        for begin in range(0,len(ds),batch):
+            selected=ds[begin:begin+batch];n=len(selected)
+            selected=np.pad(selected,((0,batch-n),(0,0)))
+            outputs.append(np.asarray(self.infer(self.weights[path],selected,*args))[:n])
+        return np.concatenate(outputs).astype(np.float32)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/temporal_contextual.py

@@ -0,0 +1,42 @@
+"""Portable one-quality-chain route; original surrounding routes remain callable."""
+import numpy as np
+from d3_pre_latent_temporal import TemporalContextualDecoder as ParentDecoder
+from d3_lr_compiled import PersistentCompiled
+from d3_lr_core import make_kernels
+
+class TemporalContextualDecoder(ParentDecoder):
+ def __init__(self):
+  import jax
+  super().__init__();self.latent_weights={};self.latent_groups={};self.latent_plans={}
+  self.latent_infer=PersistentCompiled(make_kernels(interpret=jax.default_backend()=='cpu')[0],max_executables=32)
+ def predict(self,root,record,group_record,packed,num_detectors,batch=None):
+  settings=record.get('d3_latent_readout')
+  if settings is None:
+   if batch is None:return super().predict(root,record,group_record,packed,num_detectors)
+   return super().predict(root,record,group_record,packed,num_detectors,batch)
+  if batch is None:batch=256
+  import jax.numpy as jnp
+  key=(settings['weights'],settings['group'])
+  if key not in self.latent_weights:
+   with np.load(root/settings['weights'],allow_pickle=False) as f:self.latent_weights[key]=jnp.asarray(f[settings['group']])
+  group=settings['group']
+  if group not in self.latent_groups:
+   weights=[];coefficients=[]
+   for member in group_record.get('members',[group_record]):
+    with np.load(root/member['weights'],allow_pickle=False) as f:weights.append({k:jnp.asarray(f[k]) for k in f.files})
+    coefficients.append(member.get('coefficient',1.))
+   coefficients=np.asarray(coefficients,np.float32);coefficients/=coefficients.sum()
+   self.latent_groups[group]=({k:jnp.stack([w[k] for w in weights]) for k in weights[0]},coefficients)
+  gp=settings['geometry']
+  if gp not in self.latent_plans:
+   with np.load(root/record['rich_plan'],allow_pickle=False) as f:plan={k:f[k] for k in f.files}
+   with np.load(root/gp,allow_pickle=False) as f:geometry={k:f[k] for k in f.files}
+   self.latent_plans[gp]=(plan,geometry)
+  plan,geometry=self.latent_plans[gp];frozen,coefficients=self.latent_groups[group]
+  ds=np.pad(np.unpackbits(packed,axis=1,count=num_detectors,bitorder='little'),((0,0),(0,201-num_detectors)));values=[]
+  for pos in range(0,len(ds),batch):
+   n=min(batch,len(ds)-pos);dets=np.pad(ds[pos:pos+batch],((0,batch-n),(0,0)))
+   q=self.latent_infer(self.latent_weights[key],frozen,dets,coefficients,np.ones(batch,np.float32),np.zeros(batch,np.float32),
+    *[plan[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']],geometry['quality_times'],geometry['transition_gaps'])
+   values.append(np.asarray(q)[:n])
+  return np.concatenate(values).astype(np.float32)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/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/S044/training_code.py

@@ -0,0 +1,108 @@
+"""Fit matching ensemble from random coefficients using the hardware training split."""
+import os
+os.environ['OPENBLAS_NUM_THREADS'] = '1'
+os.environ['OMP_NUM_THREADS'] = '1'
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+import json, time, hashlib, shutil, importlib.metadata
+import numpy as np
+import stim
+from scipy.optimize import minimize
+from scipy.special import expit
+from decoder import match_features, predict_features
+
+ROOT = Path(__file__).resolve().parent
+DATA = Path('/workspace/data')
+
+
+def features(row):
+    path = ROOT/'cache'/f"{row['name']}.npz"
+    if path.exists():
+        return row['name']
+    dem = stim.DetectorErrorModel.from_file(DATA/'train'/row['noise'])
+    content = {}
+    for split in ('train', 'validation'):
+        with np.load(DATA/split/row['arrays'], allow_pickle=False) as a:
+            content[split+'_x'] = match_features(dem, a['detectors'], row['rounds'])
+            content[split+'_y'] = a['labels']
+    np.savez(path, **content)
+    return row['name']
+
+
+def main():
+    start = time.time()
+    rows = json.loads((DATA/'train/manifest.json').read_text())['conditions']
+    (ROOT/'cache').mkdir(exist_ok=True)
+    with ProcessPoolExecutor(max_workers=16) as pool:
+        futures = [pool.submit(features, row) for row in rows]
+        for i, future in enumerate(as_completed(futures)):
+            print(json.dumps({'features_done': i+1, 'condition': future.result(), 'seconds': time.time()-start}), flush=True)
+    pkg = ROOT/'package'
+    pkg.mkdir(exist_ok=True)
+    (pkg/'weights').mkdir(exist_ok=True)
+    (pkg/'dems').mkdir(exist_ok=True)
+    config = {'architecture': 'per-group logistic ensemble of MWPM, correlated MWPM, and two constrained logical cosets',
+              'feature_version': 1, 'groups': {}, 'conditions': {}}
+    history = []
+    for group in sorted({r['group'] for r in rows}):
+        members = [r for r in rows if r['group'] == group]
+        cache = [np.load(ROOT/'cache'/f"{r['name']}.npz") for r in members]
+        x = np.concatenate([a['train_x'] for a in cache]).astype(np.float64)
+        y = np.concatenate([a['train_y'] for a in cache]).astype(np.float64)
+        vx = np.concatenate([a['validation_x'] for a in cache]).astype(np.float64)
+        vy = np.concatenate([a['validation_y'] for a in cache])
+        scale = np.maximum(np.sqrt(np.mean(x*x, axis=0)), 0.01)
+        x /= scale
+        rng = np.random.default_rng(20261021)
+        initial = rng.normal(0, 0.01, x.shape[1])
+        def objective(w):
+            z = x @ w
+            loss = np.mean(np.logaddexp(0, z)-y*z) + 1e-5*np.sum(w*w)
+            grad = x.T @ (expit(z)-y)/len(y) + 2e-5*w
+            return loss, grad
+        fit = minimize(objective, initial, jac=True, method='L-BFGS-B', options={'maxiter': 300, 'ftol': 1e-12})
+        state = {'coef': fit.x.astype(np.float32), 'scale': scale.astype(np.float32)}
+        p = predict_features(vx, state)
+        metrics = {'group': group, 'train_loss': float(fit.fun), 'iterations': int(fit.nit),
+                   'failure': float(np.mean((p>=.5)!=vy)),
+                   'plain_failure': float(np.mean((vx[:,2]>0)!=vy)),
+                   'correlated_failure': float(np.mean((vx[:,3]>0)!=vy)),
+                   'coset_failure': float(np.mean((vx[:,1]>0)!=vy)),
+                   'optimizer_success': bool(fit.success)}
+        history.append(metrics)
+        print(json.dumps(metrics), flush=True)
+        np.savez(pkg/'weights'/f'{group}.npz', **state)
+        config['groups'][group] = f'weights/{group}.npz'
+    for row in rows:
+        target = f"dems/{row['name']}.dem"
+        shutil.copyfile(DATA/'train'/row['noise'], pkg/target)
+        config['conditions'][row['name']] = {'dem': target, 'circuit_sha256': row['circuit_sha256']}
+    shutil.copyfile(ROOT/'decoder.py', pkg/'decoder.py')
+    shutil.copyfile(ROOT/'train.py', pkg/'training_code.py')
+    (pkg/'infer.sh').write_text('#!/bin/sh\nset -eu\nexport OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1\nROOT="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"\nexec python "$ROOT/decoder.py" "$1" "$2"\n')
+    (pkg/'infer.sh').chmod(0o755)
+    (pkg/'README.md').write_text('# Learned matching ensemble\n\nRun `bash infer.sh INPUT_ROOT OUTPUT_ROOT`. Ten logistic specialists are trained from random initialization on all supplied hardware training shots. Features combine matching decisions, constrained logical-coset weight gaps, event density and duration. No IDs enter the model. Fitted DEMs are included for all 130 conditions. Training and validation history is in training_provenance.json.\n')
+    deps = ['numpy', 'scipy', 'stim', 'pymatching']
+    (pkg/'requirements.lock').write_text('\n'.join(f'{d}=={importlib.metadata.version(d)}' for d in deps)+'\n')
+    sha = lambda p: hashlib.sha256(p.read_bytes()).hexdigest()
+    provenance = {'initialization': {'distribution': 'Normal(0,0.01)', 'seed': 20261021, 'pretrained_weights': False},
+                  'training_data': 'all 19880 supplied training shots per condition; all 130 conditions',
+                  'train_manifest_sha256': sha(DATA/'train/manifest.json'),
+                  'validation_manifest_sha256': sha(DATA/'validation/manifest.json'),
+                  'calibration_exception': 'Supplied even-fitted DEMs include validation syndromes but no logical labels or test data.',
+                  'optimizer': 'L-BFGS-B binary cross entropy plus 1e-5 L2, maximum 300 iterations',
+                  'selection': 'First trained candidate; validation reported without parameter fitting or hyperparameter selection',
+                  'test_data_used': False, 'released_per_shot_predictions_used': False,
+                  'history': history, 'elapsed_seconds': time.time()-start}
+    for name, obj in [('model_config.json', config), ('training_provenance.json', provenance)]:
+        (pkg/name).write_text(json.dumps(obj, indent=2)+'\n')
+    checkpoints = [{'path': str(p.relative_to(pkg)), 'sha256': sha(p), 'format': 'npz' if p.suffix=='.npz' else 'stim-dem'}
+                   for p in sorted((pkg/'weights').glob('*'))+sorted((pkg/'dems').glob('*'))]
+    (pkg/'model_manifest.json').write_text(json.dumps({'schema': 'surface-code-decoding-model/v1', 'checkpoints': checkpoints,
+        'model_config': 'model_config.json', 'training_provenance': 'training_provenance.json'}, indent=2)+'\n')
+    p = 1-np.mean([np.mean([h['failure'] for h in history if h['group'].startswith(d)]) for d in ['d3', 'd5']])
+    print(json.dumps({'P': p, 'package': str(pkg), 'seconds': time.time()-start}), flush=True)
+
+
+if __name__ == '__main__':
+    main()

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/axial_residual1/data.py

@@ -0,0 +1,51 @@
+"""Authorized data and frozen, session-trained parent probabilities."""
+from pathlib import Path
+import hashlib,json
+import numpy as np
+
+ROOT=Path(__file__).resolve().parent
+RESEARCH=ROOT.parent
+
+def digest(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+def reference():
+    info=json.loads((ROOT/'reference.json').read_text());package=Path(info['package'])
+    for name,sha in info['sha256'].items():assert digest(package/name)==sha,name
+    return info,package,json.loads((package/'model_config.json').read_text())
+
+def aligned(path,ids):
+    with np.load(path,allow_pickle=False) as saved:
+        assert set(saved.files)=={'sample_ids','probabilities'}
+        source_ids=saved['sample_ids'];q=saved['probabilities']
+    assert source_ids.dtype==np.uint64 and len(np.unique(source_ids))==len(source_ids)
+    order=np.argsort(source_ids);locations=np.searchsorted(source_ids[order],ids)
+    assert np.all(locations<len(order))
+    indices=order[locations];assert np.array_equal(source_ids[indices],ids)
+    q=q[indices];assert q.dtype==np.float32 and np.isfinite(q).all() and ((q>=0)&(q<=1)).all()
+    return q
+
+def load_all(splits=('train','validation'),cache=None):
+    cache=ROOT/'cache1' if cache is None else Path(cache)
+    info,package,config=reference();items=[]
+    manifests={s:json.loads((Path('/workspace/data')/s/'manifest.json').read_text()) for s in splits}
+    rows=sorted([r for r in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if r['distance']==5],key=lambda r:r['name'])
+    for row in rows:
+        path=package/config['conditions'][row['name']]['neural_d5_plan']
+        with np.load(path,allow_pickle=False) as plan:grid=plan['grid'].copy()
+        assert grid.shape==(26,24) and np.array_equal(np.sort(grid[grid!=600]),np.arange(row['num_detectors']))
+        item={'row':row,'grid':grid,'feature_plan_sha256':digest(path)}
+        for split in splits:
+            record=next(r for r in manifests[split]['conditions'] if r['name']==row['name'])
+            with np.load(Path('/workspace/data')/split/record['arrays'],allow_pickle=False) as saved:
+                ids=saved['sample_ids'];labels=saved['labels'];packed=saved['detectors']
+            source=(cache if split=='train' else Path(info['predictions']))/(row['name']+'.npz')
+            q=aligned(source,ids)
+            detectors=np.unpackbits(packed,axis=1,count=row['num_detectors'],bitorder='little')
+            item[split+'_dets']=np.pad(detectors,((0,0),(0,601-row['num_detectors'])))
+            item[split+'_parent']=q;item[split+'_labels']=labels;item[split+'_sample_ids']=ids
+            item[split+'_reference']={'file':str(source),'file_sha256':digest(source),'input_arrays_sha256':record['arrays_sha256'],
+                'sample_ids_sha256':hashlib.sha256(ids.tobytes()).hexdigest(),'alignment':'Opaque sample ID equality join, with uniqueness and membership assertions'}
+        items.append(item)
+    assert len(items)==26
+    return items

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/axial_residual1/model.py

@@ -0,0 +1,89 @@
+"""Untrained axial-attention residual over a frozen session-trained decoder."""
+import jax
+import jax.numpy as jnp
+
+DEFAULT={'width':64,'heads':4,'depth':3,'expansion':2,'dropout':.1,'correction_bound':4.}
+
+def initialize(seed,config=None):
+    c=DEFAULT if config is None else config;d=c['width'];params={};key=jax.random.key(seed)
+    def random(shape,scale):
+        nonlocal key
+        key,sub=jax.random.split(key);return jax.random.normal(sub,shape)*scale
+    params['input_w']=random((8,d),jnp.sqrt(1/8));params['input_b']=jnp.zeros(d)
+    params['space_embedding']=random((24,d),.02);params['time_embedding']=random((26,d),.02)
+    for i in range(c['depth']):
+        for axis in ['time','space']:
+            prefix=f'b{i}_{axis}'
+            params[prefix+'_scale']=jnp.ones(d);params[prefix+'_bias']=jnp.zeros(d)
+            params[prefix+'_qkv']=random((d,3*d),jnp.sqrt(1/d));params[prefix+'_qkv_b']=jnp.zeros(3*d)
+            params[prefix+'_out']=random((d,d),jnp.sqrt(1/d));params[prefix+'_out_b']=jnp.zeros(d)
+        prefix=f'b{i}_ff';hidden=d*c['expansion']
+        params[prefix+'_scale']=jnp.ones(d);params[prefix+'_bias']=jnp.zeros(d)
+        params[prefix+'_w1']=random((d,hidden),jnp.sqrt(1/d));params[prefix+'_b1']=jnp.zeros(hidden)
+        params[prefix+'_w2']=random((hidden,d),jnp.sqrt(1/hidden));params[prefix+'_b2']=jnp.zeros(d)
+    params['readout_scale']=jnp.ones(d);params['readout_bias']=jnp.zeros(d)
+    params['readout_w1']=random((d+2,d),jnp.sqrt(1/(d+2)));params['readout_b1']=jnp.zeros(d)
+    params['readout_w2']=jnp.zeros((d,1));params['readout_b2']=jnp.zeros(1)
+    return params
+
+def parent_logit(probability):
+    p=jnp.clip(probability,1e-7,1-1e-7)
+    return jnp.log(p)-jnp.log1p(-p)
+
+def token_features(dets,grid,basis,rounds,parent):
+    valid=grid!=600;events=dets[:,grid].astype(jnp.float32)*valid[None]
+    measured=(jnp.cumsum(events.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    shape=events.shape
+    broadcast=lambda v:jnp.broadcast_to(v,shape)
+    z=jnp.clip(parent_logit(parent),-8.,8.)/8
+    return jnp.stack([events,measured,broadcast(valid[None]),broadcast(jnp.arange(26)[None,:,None]/25),
+        broadcast(jnp.asarray(basis,jnp.float32)),broadcast(jnp.asarray(rounds,jnp.float32)/25),
+        broadcast(z[:,None,None]),broadcast(jnp.abs(z)[:,None,None])],axis=-1),valid
+
+def layer_norm(x,scale,bias):
+    mean=x.mean(axis=-1,keepdims=True);variance=jnp.mean((x-mean)**2,axis=-1,keepdims=True)
+    return (x-mean)*jax.lax.rsqrt(variance+1e-5)*scale+bias
+
+def dropout(x,key,rate,training):
+    if not training or rate==0:return x
+    keep=1-rate;return jnp.where(jax.random.bernoulli(key,keep,x.shape),x/keep,0.)
+
+def attention(parameters,prefix,x,valid,axis,heads):
+    # Reshape each temporal/spatial line into its own attention group.
+    if axis=='time':x=jnp.swapaxes(x,1,2);valid=valid.T
+    batch,groups,length,width=x.shape;head_width=width//heads
+    qkv=x@parameters[prefix+'_qkv']+parameters[prefix+'_qkv_b']
+    q,k,v=[part.reshape(batch,groups,length,heads,head_width) for part in jnp.split(qkv,3,axis=-1)]
+    score=jnp.einsum('bgihd,bgjhd->bghij',q,k)/jnp.sqrt(jnp.float32(head_width))
+    score=jnp.where(valid[None,:,None,None,:],score,-1e9)
+    weights=jax.nn.softmax(score,axis=-1)
+    value=jnp.einsum('bghij,bgjhd->bgihd',weights,v).reshape(batch,groups,length,width)
+    value=(value@parameters[prefix+'_out']+parameters[prefix+'_out_b'])*valid[None,:,:,None]
+    return jnp.swapaxes(value,1,2) if axis=='time' else value
+
+def logits(parameters,dets,grid,basis,rounds,parent,*,training=False,key=None,config=None):
+    c=DEFAULT if config is None else config
+    features,valid=token_features(dets,grid,basis,rounds,parent);mask=valid[None,:,:,None]
+    x=(features@parameters['input_w']+parameters['input_b']+parameters['space_embedding'][None,None]+parameters['time_embedding'][None,:,None])*mask
+    if key is None:key=jax.random.key(0)
+    keys=jax.random.split(key,3*c['depth'])
+    for i in range(c['depth']):
+        for rank,axis in enumerate(['time','space']):
+            prefix=f'b{i}_{axis}';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias'])
+            update=attention(parameters,prefix,normalized,valid,axis,c['heads'])
+            x=(x+dropout(update,keys[3*i+rank],c['dropout'],training))*mask
+        prefix=f'b{i}_ff';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias'])
+        update=jax.nn.gelu(normalized@parameters[prefix+'_w1']+parameters[prefix+'_b1'])@parameters[prefix+'_w2']+parameters[prefix+'_b2']
+        x=(x+dropout(update,keys[3*i+2],c['dropout'],training))*mask
+    x=layer_norm(x,parameters['readout_scale'],parameters['readout_bias'])*mask
+    pooled=x.sum(axis=(1,2))/jnp.maximum(valid.sum(),1)
+    base=parent_logit(parent);z=jnp.clip(base,-8,8)/8
+    hidden=jax.nn.silu(jnp.concatenate([pooled,z[:,None],jnp.abs(z)[:,None]],axis=1)@parameters['readout_w1']+parameters['readout_b1'])
+    correction=c['correction_bound']*jnp.tanh((hidden@parameters['readout_w2']+parameters['readout_b2'])[:,0])
+    return base+correction
+
+def predict(parameters,dets,grid,basis,rounds,parent,config=None):
+    return jax.nn.sigmoid(logits(parameters,dets,grid,basis,rounds,parent,config=config))
+
+def binary_loss(logit,labels):
+    return jnp.mean(jax.nn.softplus(logit)-labels*logit)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/axial_residual1/state.py

@@ -0,0 +1,34 @@
+"""Numeric-only checkpoint state for a newly initialized residual model."""
+import numpy as np
+import jax
+import jax.numpy as jnp
+import optax
+
+def save_state(path,state):
+    np.savez(path,**{f'arr_{i}':np.asarray(v) for i,v in enumerate(jax.tree_util.tree_leaves(state))})
+
+def load_state(path,template):
+    leaves,tree=jax.tree_util.tree_flatten(template);values=[]
+    with np.load(path,allow_pickle=False) as saved:
+        assert set(saved.files)=={f'arr_{i}' for i in range(len(leaves))}
+        for i,v in enumerate(leaves):
+            a=saved[f'arr_{i}'];assert a.shape==v.shape and a.dtype==v.dtype
+            values.append(jnp.asarray(a))
+    return jax.tree_util.tree_unflatten(tree,values)
+
+def optimizer(learning_rate,total_steps=4096):
+    schedule=optax.warmup_cosine_decay_schedule(learning_rate/128,learning_rate,128,total_steps,end_value=learning_rate*.1)
+    return optax.chain(optax.clip_by_global_norm(1.),optax.adamw(schedule,weight_decay=1e-4))
+
+def make_step(architecture,optim,dropout_seed):
+    from model import logits,binary_loss
+    def objective(p,dets,grid,basis,rounds,parent,y,step):
+        key=jax.random.fold_in(jax.random.key(dropout_seed),step)
+        z=logits(p,dets,grid,basis,rounds,parent,training=True,key=key,config=architecture)
+        return binary_loss(z,y),jnp.mean((z>=0)!=y)
+    @jax.jit
+    def update(p,state,dets,grid,basis,rounds,parent,y,step):
+        (loss,error),gradient=jax.value_and_grad(objective,has_aux=True)(p,dets,grid,basis,rounds,parent,y,step)
+        updates,state=optim.update(gradient,state,p)
+        return optax.apply_updates(p,updates),state,loss,error,optax.global_norm(gradient)
+    return update

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/axial_residual1/train.py

@@ -0,0 +1,87 @@
+"""Fresh axial attention over a frozen session-trained parent; all d5 conditions."""
+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,time
+import numpy as np
+import jax
+import jax.numpy as jnp
+from data import load_all,reference,digest
+from model import initialize,predict,DEFAULT
+from state import save_state,load_state,optimizer,make_step
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--output',type=Path,required=True);parser.add_argument('--cache',type=Path)
+    parser.add_argument('--resume',type=Path);parser.add_argument('--steps',type=int,default=4096);parser.add_argument('--batch',type=int,default=256)
+    parser.add_argument('--learning-rate',type=float,default=.0002);parser.add_argument('--schedule-steps',type=int,default=4096)
+    parser.add_argument('--initial-seed',type=int,default=20261800);parser.add_argument('--seed',type=int,default=20261801);parser.add_argument('--dropout-seed',type=int,default=20261802)
+    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=256)
+    args=parser.parse_args();args.output.mkdir(exist_ok=False);root=Path(__file__).resolve().parent
+    config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()};config['architecture']=DEFAULT
+    source=args.output/'training_source';source.mkdir();hashes={}
+    for name in ['model.py','data.py','state.py','train.py']:
+        shutil.copyfile(root/name,source/name);hashes[name]=digest(root/name)
+    parameters=initialize(args.initial_seed);optim=optimizer(args.learning_rate,args.schedule_steps);state=optim.init(parameters)
+    rng=np.random.default_rng(args.seed);start_step=0;dataset=load_all(cache=args.cache);seen=[np.zeros(len(x['train_labels']),bool) for x in dataset]
+    if args.resume:
+        previous=json.loads((args.resume.parent/'run_config.json').read_text())
+        for name in ['batch','learning_rate','schedule_steps','initial_seed','seed','dropout_seed','architecture']:assert config[name]==previous[name],name
+        start_step=int(args.resume.stem.split('-')[-1]);assert start_step<args.steps
+        with np.load(args.resume,allow_pickle=False) as saved:
+            assert set(saved.files)==set(parameters)
+            for k,v in parameters.items():assert saved[k].shape==v.shape and saved[k].dtype==v.dtype
+            parameters={k:jnp.asarray(saved[k]) for k in parameters}
+        state=load_state(args.resume.with_name(f'optimizer-{start_step}.npz'),state)
+        rng.bit_generator.state=json.loads(args.resume.with_name(f'rng-{start_step}.json').read_text())
+        with np.load(args.resume.with_name(f'seen-{start_step}.npz'),allow_pickle=False) as saved:
+            seen=[saved[item['row']['name']] for item in dataset]
+    assert int(state[1][0].count)==start_step
+    config.update(training_source_sha256=hashes,parameter_count=sum(v.size for v in parameters.values()),initial_adam_count=start_step,
+        initialization='Session random initialization, zero output; frozen parent trained in the same session. Resume restores exact weights, Adam, RNG and seen masks.',
+        dropout_keys='fold_in(JAX key(dropout_seed), absolute update number)',runtime_versions={'jax':jax.__version__,'numpy':np.__version__})
+    (args.output/'run_config.json').write_text(json.dumps(config,indent=2)+'\n')
+    update=make_step(DEFAULT,optim,args.dropout_seed);infer=jax.jit(predict);started=time.time();records=[]
+    print(json.dumps({'conditions':len(dataset),'training_rows':sum(len(x['train_labels']) for x in dataset),'start_step':start_step}),flush=True)
+    def evaluate(step):
+        rows=[];beginning=time.time()
+        for item in dataset:
+            row=item['row'];n=min(args.validation_shots,len(item['validation_labels']))
+            ix=np.random.default_rng(20261102).choice(len(item['validation_labels']),n,replace=False);values=[]
+            for start in range(0,n,args.validation_batch):
+                selected=ix[start:start+args.validation_batch];size=len(selected)
+                ds=np.pad(item['validation_dets'][selected],((0,args.validation_batch-size),(0,0)))
+                parent=np.pad(item['validation_parent'][selected],(0,args.validation_batch-size),constant_values=.5)
+                values.append(np.asarray(infer(parameters,ds,item['grid'],row['basis']=='X',row['rounds'],parent))[:size])
+            q=np.concatenate(values);y=item['validation_labels'][ix].astype(np.float64);qq=np.clip(q.astype(np.float64),1e-7,1-1e-7)
+            assert np.isfinite(q).all() and ((q>=0)&(q<=1)).all()
+            rows.append({'condition':row['name'],'failure':float(np.mean((q>=.5)!=y)),
+                'negative_log_likelihood':float(np.mean(-y*np.log(qq)-(1-y)*np.log1p(-qq)))})
+        report={'step':step,'validation_failure':float(np.mean([x['failure'] for x in rows])),
+            'negative_log_likelihood':float(np.mean([x['negative_log_likelihood'] for x in rows])),'conditions':rows,'seconds':time.time()-beginning}
+        np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()});save_state(args.output/f'optimizer-{step}.npz',state)
+        np.savez(args.output/f'seen-{step}.npz',**{item['row']['name']:mask for item,mask in zip(dataset,seen)})
+        (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n')
+        checkpoint={'step':step,'training_draws':step*args.batch,'distinct_rows':sum(int(x.sum()) for x in seen),
+            'distinct_by_condition':{item['row']['name']:int(mask.sum()) for item,mask in zip(dataset,seen)},
+            'adam_count':int(state[1][0].count),'weights_sha256':digest(args.output/f'weights-{step}.npz'),'complete':True}
+        assert checkpoint['adam_count']==step
+        (args.output/f'checkpoint-{step}.json').write_text(json.dumps(checkpoint,indent=2)+'\n')
+        (args.output/f'validation-{step}.json').write_text(json.dumps(report,indent=2)+'\n')
+        print(json.dumps({k:v for k,v in report.items() if k!='conditions'}),flush=True)
+    evaluate(start_step)
+    for step in range(start_step+1,args.steps+1):
+        ci=int(rng.integers(len(dataset)));item=dataset[ci];row=item['row'];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['grid'],row['basis']=='X',row['rounds'],item['train_parent'][ix],item['train_labels'][ix],step)
+        if step==start_step+1 or step%32==0:
+            record={'step':step,'loss':float(loss),'error':float(error),'gradient_norm':float(norm),'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,'frozen_parent':reference()[0],'training_rows':sum(len(x['train_labels']) for x in dataset),
+        'data_references':{x['row']['name']:{'feature_plan_sha256':x['feature_plan_sha256'],'train':x['train_reference'],'validation':x['validation_reference']} for x in dataset},
+        'training':'Uniform condition/row sampling over all516880supplied d5training rows; binary logical BCE and dropout. Parent parameters frozen.',
+        'loss':'Logical observable BCE on parent logit plus bounded4tanh learned correction',
+        'validation':'Seed20261102 per-condition screens; full supplied validation required for checkpoint selection',
+        '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/S044/training_sources/beam_calibration1/FIT_SOURCE_LOCK.json

@@ -0,0 +1,15 @@
+{
+  "created_utc": "2026-10-21T20:25:33.650374+00:00",
+  "source_sha256": {
+    "beam_calibration/core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7",
+    "beam_calibration/fit.py": "bb494e78078963e81f287dcd0925ce4c071276e791b1902202a17d7a028a2f41",
+    "beam_calibration/control_cpu.py": "8e7dcb714f5e5ca8a1d86188fc24d569bd0456d65a42a86f8e7a1bd56a6a0f8f",
+    "beam_calibration/plan.json": "6a16f161a24d54c05afe10004f0d6f119aa3879394195d63f9d1ce65830b52c1",
+    "beam_calibration/generate_beam_training.py": "b7d8aabc20b10577500518002df566b789b65fa5da398584e8d35185892ce41f",
+    "beam_calibration/generate_parent_training.py": "c8c11132e5eb98cae6e71936cdeba4a90211fe1cdc03dd63e5b7982f49d87073",
+    "full_frontier/beam_lookahead.py": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5",
+    "beam_r3/reference.json": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701"
+  },
+  "scope": "Frozen before any beam_calibration hardware-label fitting. Evidence generation is in progress; fits await and audit both complete caches.",
+  "test_data_used": false
+}

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

@@ -0,0 +1,19 @@
+{
+  "created_utc": "2026-10-21T20:27:57.623048+00:00",
+  "queue_after": "full_frontier/resource_finished.json",
+  "source_sha256": {
+    "beam_calibration/runtime.py": "a3e6f859e6d4a350858c47ab362f5716155f3434e25661bb70e8e2896ab228c5",
+    "beam_calibration/export.py": "ad0c3d9cdf2897b350e4b9abb44a044bff5a84d81003775d5e7d682571fd2cd4",
+    "beam_calibration/runtime_control.py": "f93fe417f7b43a4f95314b84c6102f7a3eba6a4255600409f57555553bb1abc4",
+    "beam_calibration/core.py": "6cc89f9e5a3143564c57f8a79c7ea6e1d1cd5b2612dacfd5a52b58b6bcde41c7",
+    "beam_calibration/package.py": "7ce80033a384a5943a3e3d877dd7bde023322800871c7aab5aca551871e4c036",
+    "beam_calibration/after_resource.py": "cc2fdb0c0d24d46ad7e793913be53100f4969b67af72f3418802fcf1574b89fb",
+    "beam_calibration/plan.json": "6a16f161a24d54c05afe10004f0d6f119aa3879394195d63f9d1ce65830b52c1",
+    "beam_calibration/FIT_SOURCE_LOCK.json": "05595c096ef729d9981461316c883d106c2e95722b0f0ba1067cea86ff17fad9",
+    "full_frontier/beam_jax.py": "45ce979892fad6eaa88325477fb063e6513e635f89370d8a6a9c930f56f09cb1",
+    "beam_r3/plans/surface_code_bX_d5_r03_center_5_5.npz": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d",
+    "beam_r3/plans/surface_code_bZ_d5_r03_center_5_5.npz": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d"
+  },
+  "scope": "Portable and packaging code frozen after actual CPU runtime controls, before fitted validation outcomes. GPU work only if a global candidate improves, serialized after the frontier resource study; no original queue reordered.",
+  "test_data_used": false
+}

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

@@ -0,0 +1,10 @@
+{
+  "created_utc": "2026-10-21T20:43:17.769949+00:00",
+  "previous_waiter_pid": 80427,
+  "previous_waiter_session": 95715,
+  "previous_queue_after": "full_frontier/resource_finished.json",
+  "new_queue": "GPUidle gap after completed block_physical resource study and failed/pretraining trajectorycontrol; finish calibrationverificationbeforetrajectoryrestart",
+  "reason": "Completed prespecifiedfitselectedparent-onlycalibration (no beam needed); verify strongestcandidate promptly whiletrajectorycontrolrecoveryprepared. Only operational scheduling changes, no training/selection/model changes.",
+  "original_source_lock_sha256": "a73ad807bf27cb8c65ed3b06fa287d2ce1fd1206b7a74f867221e35261b4edfa",
+  "test_data_used": false
+}

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

@@ -0,0 +1,32 @@
+"""Publish only after serialized resource work, fitted assessment and actual replay."""
+from pathlib import Path
+import hashlib,json,subprocess,time
+root=Path(__file__).resolve().parent;r=root.parent;started=time.monotonic();report_path=root/'fit1/report.json';marker=r/'full_frontier/resource_finished.json'
+while not report_path.exists():
+    if time.monotonic()-started>86400:raise TimeoutError('Calibration did not finish')
+    time.sleep(2)
+report=json.loads(report_path.read_text());assert report['status']=='complete';selected=report['selected']
+if selected is None:
+    (root/'beam_calibration1_finished.json').write_text(json.dumps({'complete':True,'published':False,'reason':'All six global validation choices failed to improve frozen reference','test_data_used':False})+'\n')
+else:
+    while not marker.exists():
+        if (r/'full_frontier/resource_failure.json').exists():raise RuntimeError('Prior GPU resource study failed; inspect and recover before advancing queue')
+        if time.monotonic()-started>86400:raise TimeoutError('Prior resource study did not complete')
+        time.sleep(2)
+    assert json.loads(marker.read_text())['complete']
+    assert not subprocess.check_output(['nvidia-smi','--query-compute-apps=pid','--format=csv,noheader'],text=True).strip()
+    for path,digest in json.loads((root/'PACKAGE_SOURCE_LOCK.json').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']:
+        control=json.loads((root/filename).read_text());assert control['status']=='passed'
+        for path,digest in control['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());score=json.loads(Path(current['score']).read_text());gain=sum((score['per_condition'][z['condition']]['errors']/score['per_condition'][z['condition']]['total']-z['failure'])/52 for z in selected['conditions'])
+    if gain<=1e-12:
+        (root/'beam_calibration1_finished.json').write_text(json.dumps({'complete':True,'published':False,'reason':'Selected global choice no longer improves then-current incumbent','test_data_used':False})+'\n')
+    else:
+        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'
+        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'],'test_data_used':False})+'\n')

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

@@ -0,0 +1,45 @@
+"""Untrained NumPy sparse frontier prototype, capped separately by logical sector."""
+import numpy as np
+
+def decode(plan,dets,per_sector=128):
+    keys=np.array([0],np.uint32);mass=np.ones(1,np.float64)
+    pruned_steps=0;maximum_states=1;discarded_fractions=[]
+    for probability,mask,detector in zip(plan['probabilities'],plan['masks'],plan['measured']):
+        probability=float(probability);mask=np.uint32(mask)
+        if detector<0:
+            expanded=np.concatenate([keys,keys^mask]);values=np.concatenate([(1-probability)*mass,probability*mass])
+            order=np.argsort(expanded,kind='stable');expanded=expanded[order];values=values[order]
+            starts=np.r_[0,np.flatnonzero(expanded[1:]!=expanded[:-1])+1]
+            keys=expanded[starts];mass=np.add.reduceat(values,starts)
+            positive=mass>0;keys,mass=keys[positive],mass[positive]
+            selected=[]
+            for sector in [0,1]:
+                indices=np.flatnonzero((keys&1)==sector)
+                if len(indices)>per_sector:
+                    # Deterministic key tie break; never use sample IDs or other shots.
+                    indices=indices[np.lexsort((keys[indices],-mass[indices]))[:per_sector]]
+                selected.extend(indices.tolist())
+            if len(selected)<len(keys):
+                total=mass.sum();discarded_fractions.append(float(1-mass[selected].sum()/total));pruned_steps+=1
+                keys,mass=keys[selected],mass[selected]
+        else:
+            keep=(keys&mask)==np.uint32(int(dets[int(detector)]))*mask
+            keys,mass=keys[keep]&~mask,mass[keep]
+            norm=mass.sum()
+            if norm==0:return np.float64(.5),{'status':'empty_beam','detector':int(detector),'pruned_steps':pruned_steps,'maximum_states':maximum_states}
+            mass/=norm
+        maximum_states=max(maximum_states,len(keys))
+    probability=mass[(keys&1)!=0].sum()/mass.sum()
+    return probability,{'status':'ok','pruned_steps':pruned_steps,'maximum_states':maximum_states,
+        'maximum_discarded_fraction':max(discarded_fractions,default=0.),'sum_discarded_fractions':sum(discarded_fractions)}
+
+def dense_reference(plan,dets):
+    width=int(plan['width']);assert width<=14,'CPU reference limited to small controlled frontiers'
+    indices=np.arange(1<<width);mass=np.zeros(1<<width,np.float64);mass[0]=1
+    for p,mask,detector in zip(plan['probabilities'],plan['masks'],plan['measured']):
+        p=float(p);mask=int(mask)
+        if detector<0:mass=(1-p)*mass+p*mass[indices^mask]
+        else:
+            mass=mass[((indices&~mask)|(int(dets[int(detector)])*mask))]*((indices&mask)==0)
+            mass/=mass.sum()
+    return mass[1::2].sum()/mass.sum()

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

@@ -0,0 +1,76 @@
+"""Sparse frontier with independent remaining-syndrome marginals used only for ranking."""
+import numpy as np
+
+
+def prepare_lookahead(plan):
+    width=int(plan['width']);bits=np.left_shift(np.uint32(1),np.arange(1,width,dtype=np.uint32))
+    active_masks=[];active=np.uint32(1)
+    for mask,d in zip(plan['masks'],plan['measured']):
+        active|=np.uint32(mask);active_masks.append(active)
+        if d>=0:active&=~np.uint32(mask)
+    detectors=np.full((len(active_masks),width-1),-1,np.int32)
+    future=np.zeros((len(active_masks),width-1),np.float64)
+    active=np.asarray(active_masks,np.uint32)[:,None]&bits[None,:]!=0
+    assigned=np.full(width-1,-1,np.int32);log_parity=np.zeros(width-1,np.float64)
+    for i in range(len(active_masks)-1,-1,-1):
+        p=float(plan['probabilities'][i]);mask=np.uint32(plan['masks'][i]);d=int(plan['measured'][i]);touched=(mask&bits)!=0
+        if d>=0:
+            assert touched.sum()==1
+            assigned[touched]=d;log_parity[touched]=0.
+        else:
+            assert 0<=p<.5
+            detectors[i]=assigned;future[i]=-.5*np.expm1(log_parity)
+            assert (assigned[active[i]]>=0).all()
+            log_parity[touched]+=np.log1p(-2*p)
+    return {'detectors':detectors,'future':future,'active':active,'bits':bits}
+
+def decode(plan,dets,per_sector=128,lookahead=None):
+    lookahead=prepare_lookahead(plan) if lookahead is None else lookahead
+    keys=np.array([0],np.uint32);mass=np.ones(1,np.float64)
+    pruned_steps=0;maximum_states=1;discarded_fractions=[]
+    for operation,(probability,mask,detector) in enumerate(zip(plan['probabilities'],plan['masks'],plan['measured'])):
+        probability=float(probability);mask=np.uint32(mask)
+        if detector<0:
+            expanded=np.concatenate([keys,keys^mask]);values=np.concatenate([(1-probability)*mass,probability*mass])
+            order=np.argsort(expanded,kind='stable');expanded=expanded[order];values=values[order]
+            starts=np.r_[0,np.flatnonzero(expanded[1:]!=expanded[:-1])+1]
+            keys=expanded[starts];mass=np.add.reduceat(values,starts)
+            positive=mass>0;keys,mass=keys[positive],mass[positive]
+            selected=[];scores=None
+            for sector in [0,1]:
+                indices=np.flatnonzero((keys&1)==sector)
+                if len(indices)>per_sector:
+                    # Deterministic key tie break; never use sample IDs or other shots.
+                    if scores is None:
+                        active=lookahead['active'][operation];bits=lookahead['bits'][active]
+                        ds=lookahead['detectors'][operation,active];q=lookahead['future'][operation,active]
+                        mismatch=((keys[:,None]&bits[None,:])!=0)!=dets[ds][None,:]
+                        with np.errstate(divide='ignore'):
+                            future_log=np.where(mismatch,np.log(q)[None,:],np.log1p(-q)[None,:]).sum(axis=1)
+                        scores=np.log(mass)+future_log
+                    indices=indices[np.lexsort((keys[indices],-scores[indices]))[:per_sector]]
+                selected.extend(indices.tolist())
+            if len(selected)<len(keys):
+                total=mass.sum();discarded_fractions.append(float(1-mass[selected].sum()/total));pruned_steps+=1
+                keys,mass=keys[selected],mass[selected]
+        else:
+            keep=(keys&mask)==np.uint32(int(dets[int(detector)]))*mask
+            keys,mass=keys[keep]&~mask,mass[keep]
+            norm=mass.sum()
+            if norm==0:return np.float64(.5),{'status':'empty_beam','detector':int(detector),'pruned_steps':pruned_steps,'maximum_states':maximum_states}
+            mass/=norm
+        maximum_states=max(maximum_states,len(keys))
+    probability=mass[(keys&1)!=0].sum()/mass.sum()
+    return probability,{'status':'ok','pruned_steps':pruned_steps,'maximum_states':maximum_states,
+        'maximum_discarded_fraction':max(discarded_fractions,default=0.),'sum_discarded_fractions':sum(discarded_fractions)}
+
+def dense_reference(plan,dets):
+    width=int(plan['width']);assert width<=14,'CPU reference limited to small controlled frontiers'
+    indices=np.arange(1<<width);mass=np.zeros(1<<width,np.float64);mass[0]=1
+    for p,mask,detector in zip(plan['probabilities'],plan['masks'],plan['measured']):
+        p=float(p);mask=int(mask)
+        if detector<0:mass=(1-p)*mass+p*mass[indices^mask]
+        else:
+            mass=mass[((indices&~mask)|(int(dets[int(detector)])*mask))]*((indices&mask)==0)
+            mass/=mass.sum()
+    return mass[1::2].sum()/mass.sum()

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

@@ -0,0 +1,20 @@
+"""Independent gradient, unsigned-label, and row/subset controls."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1';os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:4])
+from pathlib import Path
+import hashlib,json
+import numpy as np
+from scipy.special import expit
+from core import raw_features,normalize,objective_gradient,predict
+root=Path(__file__).resolve().parent;rng=np.random.default_rng(20262110);parent=np.r_[0.,1.,.5,rng.uniform(.001,.999,29)].astype(np.float32);beam=np.r_[1.,0.,.5,rng.uniform(.001,.999,29)].astype(np.float32);labels=rng.integers(2,size=len(parent),dtype=np.uint8);checks=[]
+for mode in ['parent_only','parent_plus_beam']:
+    b=None if mode=='parent_only' else beam;base,raw=raw_features(parent,b);state={'center':raw.mean(axis=0),'scale':np.maximum(raw.std(axis=0),.05),'weights':rng.normal(0,.2,raw.shape[1]+1)};x=normalize(raw,state['center'],state['scale']);value,gradient=objective_gradient(state['weights'],x,base,labels,.001);finite=[]
+    for i in range(len(gradient)):
+        offset=np.zeros(len(gradient));offset[i]=1e-5
+        a=objective_gradient(state['weights']+offset,x,base,labels,.001)[0];c=objective_gradient(state['weights']-offset,x,base,labels,.001)[0];finite.append((a-c)/2e-5)
+    delta=float(abs(gradient-finite).max());assert delta<1e-9
+    actual=predict(parent,b,state);expected=expit(base+x@state['weights']).astype(np.float32);assert np.array_equal(actual,expected)
+    reverse=predict(parent[::-1].copy(),None if b is None else b[::-1].copy(),state);single=predict(parent[7:8],None if b is None else b[7:8],state);assert np.array_equal(reverse,actual[::-1]) and np.array_equal(single,actual[7:8]);assert np.isfinite(actual).all() and ((actual>=0)&(actual<=1)).all()
+    neutral={**state,'weights':np.zeros_like(state['weights'])};neutral_p=predict(parent,b,neutral);assert ((neutral_p>=.5)==(parent>=.5)).all();checks.append({'mode':mode,'gradient_max_abs_difference':delta,'independent_scipy_probability_exact':True,'order_subset_exact':True,'neutral_decisions_exact':True,'neutral_probability_max_abs':float(abs(neutral_p-parent).max())})
+y=np.array([1,0],np.uint8);base=np.log(np.array([.8,.2])/np.array([.2,.8]));value,_=objective_gradient(np.zeros(2),np.array([[1.,0.],[1.,0.]]),base,y,0.);assert abs(value+np.log(.8))<1e-14
+report={'status':'passed','checks':checks,'unsigned_label_reference_loss':value,'hardware_labels_accessed':False,'optimizer_updates':0,'test_data_used':False,'source_sha256':{p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in [root/'core.py',Path(__file__).resolve()]}};(root/'control_cpu.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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/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/S044/training_sources/conditional_edge_projection1/PROPOSAL.json

@@ -0,0 +1,17 @@
+{
+  "name": "conditional_edge_projection_cpu_prototype",
+  "created_utc": "2026-10-22T00:19:02.702150+00:00",
+  "status": "CPU attachment prototype only; notGPUqueued, no main training protocol or validation selection yet.",
+  "hypothesis": "The original reconstruction loss supervises masked positions, but the first frozen edge-projection study uses unmasked representations. Instead give each fault endpoint its representation from a deterministic pass where its own bit is hidden. Original raw syndrome features remain in the frozen edge networks.",
+  "frozen_encoder": "masked_pretraining/auxiliary1/weights-8192.npz",
+  "frozen_encoder_sha256": "c2002e838abdc41fa166248396eaf63501905f000befab6f1b2bffefe00794f8",
+  "frozen_parent": "Own r3 parent: X confidence_joint1024 with two frozen experts and frozen confidence gate; Z fresh2full1536 with physical prior5. All originate from random initialization in this session.",
+  "new_parameters": "One zero-initialized64x64 first-hidden-layer input projection per frozen expert: Xexpert0,Xexpert1,Zsingle. No updates to original MLPs, gate or encoder.",
+  "partition_seed": 20263501,
+  "partition_count": 8,
+  "partition": "Same fixed26x24 colors as masked_conditional_features. Eightpasses, each token taken from its own maskedpass; masked events removed before cumulative parity. Colors depend only on ideal slot positions, not IDs/rows/batch data.",
+  "training_only_evidence": "masked_conditional_features/probe_report.json: conditional reconstruction NLL.344819 vspositionfreq.408062 on64originalreservedtrainingrows percondition,26d5conditions. No logical accuracy claim. CPU target-bit invariance/order/composition controls passed.",
+  "prototype": "Reuse unchanged exact frozen-parent edge equations; compare projected-head gradients to whole-contraction autodiff, neutral behavior, frozen-state and resume/order on real training X3/Z3N2. Only six discarded control updates includingreplay.",
+  "future_if_pursued": "Main should match original projection2048B512 data/draws/optimizer/checkpointchoices, with only token feature construction changed. ActualGPU resources and runtime feasibility must pass first. Decision to pursue main follows completed original fullvalidation. No current queue.",
+  "test_data_used": false
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/REPLAY_BACKEND_RECOVERY_PLAN.json

@@ -0,0 +1,16 @@
+{
+  "created_utc": "2026-10-22T01:28:37.966406+00:00",
+  "failure": "GPU control and training workers explicitly set cuda, but their CPU preparation supervisor passed JAX_PLATFORMS=cpu to the shared full-package replay helper. GPU telemetry showed zero GPU compute and 4MiB device memory while replay consumed CPU and Xr1 took83s versus prior14s. The queue source demonstrates inheritedCPU; /proc environment read was denied and is not claimed as evidence.",
+  "stopped_processes": [
+    166742,
+    167145,
+    174418,
+    174419
+  ],
+  "preservation": "Original helper, partial predictions, complete cached predictions, original candidate metadata and logs preserved in cpu_replay_failure. Original cached validation predictions copied back; original helper will create a fresh cache before replay. No rows or probabilities modified.",
+  "repair": "Shared verify_d5_candidate.py now supplies JAX_PLATFORMS=cuda explicitly to full inference and relocated subset inference. Trusted scoring unchanged. This also repairs subsequent queued experiments using that helper.",
+  "scientific_effect": "None: all673 frozen study source/state pins remain unchanged. No new updates, checkpoints, choices or threshold changes. Timed replay restarts on the oneH100. No candidate publication occurred.",
+  "original_helper_sha256": "4f3725d3292df8a0e04a64d52ef365d19ba64be92ed1b92bb369848c36c48cf1",
+  "corrected_helper_sha256": "1d9d817f6df96abb654c141e4b2cc31c1bfa54b190e1a9d188d8a7f9f510fece",
+  "test_data_used": false
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/RUNTIME_PRECISION_RECOVERY_PLAN.json

@@ -0,0 +1,96 @@
+{
+  "created_utc": "2026-10-22T01:49:36.006244+00:00",
+  "status": "Fresh-process numerical controls passed; only runtime encoder precision repaired; full replay pending",
+  "cause_evidence": "Native fresh-process warmups Z1/X1 change conditional encoder tokens by0.00159/0.00149 and logical outputs by~5.53e-5; live priors are bitwise identical. Within-process permutation/subset checks are exact. This isolates the observed discrepancy to encoder compilation context, without claiming a particular backend kernel implementation.",
+  "repair": "Only conditional_edge_features.token_embeddings enters jax.default_matmul_precision(highest) during encoder tracing. Physical head, prior calculation, selected weights, geometry, masks, batch size, input features and equations unchanged. No weight fitting or new checkpoint choice.",
+  "fixed_selection": "Original Z1024 and incumbentX from three declared cached choices. No precision variant selected using validation score.",
+  "criteria": "Fresh-process encoder tokens/pooling<2e-5, priorlogits<1e-6, logicalprobabilities<2e-6 and zero decision changes for cold/Z1/X1 contexts. Full original readonly subset criterion remains<2e-6; all26 actual replay and trusted130score required.",
+  "controls": {
+    "status": "passed",
+    "scope": "Fixed trained weights and training detectors; Only encoder matmuls use highestfloat32; originalphysicalhead/priorprecision unchanged. Earlier condition warmup differs. Freshprocesses, no fitting, labels, IDs or score selection.",
+    "records": [
+      {
+        "warm": "none",
+        "max_abs_versus_cold": {
+          "tokens": 0.0,
+          "pooled": 0.0,
+          "base": 0.0,
+          "logical": 0.0
+        },
+        "decision_differences": 0
+      },
+      {
+        "warm": "Z1",
+        "max_abs_versus_cold": {
+          "tokens": 0.0,
+          "pooled": 0.0,
+          "base": 0.0,
+          "logical": 0.0
+        },
+        "decision_differences": 0
+      },
+      {
+        "warm": "X1",
+        "max_abs_versus_cold": {
+          "tokens": 0.0,
+          "pooled": 0.0,
+          "base": 0.0,
+          "logical": 0.0
+        },
+        "decision_differences": 0
+      }
+    ],
+    "source_sha256": {
+      "control_conditional_precise_stages.py": "4b3169ac1f4d342b734f9508d4a3e2a6643c934a35777bc78f32b0f71b8049ad",
+      "capture_conditional_precise_stages.py": "45a47113f8f0cc54d72cdca595902ffd0e50dba14b6876026f51fe28cd096bf4"
+    },
+    "test_data_used": false
+  },
+  "diagnosis": {
+    "status": "complete",
+    "scope": "Fixed trained weights and training detectors; only earlier condition warmup differs. Freshprocesses, no fitting, labels, IDs or score selection.",
+    "records": [
+      {
+        "warm": "none",
+        "max_abs_versus_cold": {
+          "tokens": 0.0,
+          "pooled": 0.0,
+          "base": 0.0,
+          "logical": 0.0
+        },
+        "decision_differences": 0
+      },
+      {
+        "warm": "Z1",
+        "max_abs_versus_cold": {
+          "tokens": 0.0015914440155029297,
+          "pooled": 0.0015914440155029297,
+          "base": 0.0,
+          "logical": 5.53131103515625e-05
+        },
+        "decision_differences": 0
+      },
+      {
+        "warm": "X1",
+        "max_abs_versus_cold": {
+          "tokens": 0.0014914870262145996,
+          "pooled": 0.0014914870262145996,
+          "base": 0.0,
+          "logical": 5.525350570678711e-05
+        },
+        "decision_differences": 0
+      }
+    ],
+    "source_sha256": {
+      "diagnose_conditional_fresh_stages.py": "6e4ed8fbc2f535a7c985647d3577b4806d5f30c35f21c9488937ba9e938771c2",
+      "capture_conditional_fresh_stages.py": "3d884292adffc9734564eaeb0a3e25a5049c64b87b99ecef86c06d72e1202f69"
+    },
+    "test_data_used": false
+  },
+  "source_file": "conditional_edge_features.py",
+  "source_before_sha256": "0dd05676027b5bbe71dc168f89a004f746b670e5533de27b6ec809843afabd25",
+  "source_after_sha256": "a54e0a0f50583372509f2fbbfd507099d2331fa721217e1e016e67c8852fc22c",
+  "frozen_scientific_pins_unchanged": 673,
+  "preserved_failure": "production_portability_failure contains native full/cached predictions, score, logs, failed contract and complete pre-repair package snapshot under contract/relocated. CPU backend failure remains separately preserved.",
+  "test_data_used": false
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/TRAINING_PLAN.json

@@ -0,0 +1,28 @@
+{
+  "name": "conditional_edge_projection1",
+  "created_utc": "2026-10-22T00:35:23.164582+00:00",
+  "status": "Declared after completed unmasked projection results and before actual trainer controls or main fitting",
+  "prototype_control": "control_cpu.json",
+  "steps": 2048,
+  "batch": 512,
+  "learning_rate": 0.0005,
+  "sampling_seed": 20263201,
+  "optimizer": "Fresh separate X and Z AdamW states; beta defaults, constant learning rate. Clip norm1 across active basis projections only; decay1e-4 on projections only. All frozen parents, confidence gate and auxiliary encoder excluded from optimizer and weight decay.",
+  "initial_projection": "Allzero64x64 per Xexpert0/Xexpert1/Zsingle; no new random learned weights. All frozen weights descend own-session random initialization.",
+  "data": "All516880d5 supplied training labels, uniform condition then uniform row with replacement, conditions sorted by canonical name. Same frozen r3 parent and physical prior3X/prior5Z as declared prototype.",
+  "feature_computation": "Frozen auxiliary encoder8192. Eight deterministic ideal-slot masking partitions, seed20263501; each token embedding is taken only from the pass hiding its own detector event. Masked bits are zeroed before cumulative parity. Endpoint pooling unchanged; no dropout or logical probability inputs. Features evaluated live.",
+  "validation_screens": "Fixed1024 rows percondition fromseed20261102 at0 and every512updates, including1536; diagnostic only. Full selection remains512/1024/2048.",
+  "selection_steps": [
+    512,
+    1024,
+    2048
+  ],
+  "selection": "Full26d5 validation, all13 durations perbasis; three raw checkpoints plus retain then-current. No blends or step0 selection.",
+  "mandatory_controls": "All26geometry support audits; actual CPU trainer full2 versus1+resume1, all-source/hash/ID/seen/RNG/active-basis Adam audit; CUDA CPU-reference gradients and native production B512 X25/Z25 discarded memory pilots; actual exported live/cached order/subset/globalclear controls; full0 frozen-parent cache agreement before main.",
+  "publication": "Full assembled d5 replay, trusted all130 scoring, readonly relocation/subset/ID checks and <3600second runtime projection before atomic publication. If numerical or resource controls fail, preserve evidence and resolve before any main fitting.",
+  "queue": "After d3_masked_head completes, subject to all CPU and actual GPU numerical/resource/runtime controls.",
+  "test_data_used": false,
+  "pre_main_clarification": "The implemented eval-every512 trainer also emits a1536 diagnostic screen, as its earlier sibling trainers do. This monitoring-only clarification is recorded before main execution/source freeze; no checkpoint selection or training math changes. Existing discarded CPU fixtures used the previous wording.",
+  "matched_control": "Completed masked_edge_projection/projection1: identical initial zero projections, frozen parents/encoder, all train/cache rows, sampler seed and every draw, optimizer schedule, separate basis clocks and three full checkpoint choices. Only token feature construction changes. Every draw/state descriptor and initial weights are compared explicitly; fitted weights and optimizer moments are expected to differ.",
+  "validation_cache": "Reuse original projection recovered exact-runtime validation priors with explicit ID equality joins; no historical prior cache. Full zero audit still required."
+}

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/after_d3_head.py

@@ -0,0 +1,27 @@
+"""Serialize projection controls, initial cache audit, fitting and publication on one H100."""
+import os
+os.environ['OPENBLAS_NUM_THREADS']='1';os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:22])
+from pathlib import Path
+import json,datetime,subprocess,time
+from fixtures import digest,frozen_states
+from audit_run import audit
+from matched_draw_audit import audit as matched_audit
+root=Path(__file__).resolve().parent;r=root.parent;marker=r/'d3_masked_head/d3_masked_head1_finished.json';started=time.monotonic()
+while not marker.exists():
+ if time.monotonic()-started>86400:raise TimeoutError('Prior d3 masked-head study incomplete')
+ time.sleep(2)
+assert json.loads(marker.read_text())['complete'];assert not subprocess.check_output(['nvidia-smi','--query-compute-apps=pid','--format=csv,noheader'],text=True).strip();plan=json.loads((root/'plan.json').read_text())
+for path,sha in plan['frozen_source_sha256'].items():assert digest(r/path)==sha,path
+for name in ['control_cpu.json','pipeline_control_cpu.json','dual_basis_control_cpu.json','geometry_control_cpu.json','backend_control_cpu.json','runtime_control_cpu.json']:
+ a=json.loads((root/name).read_text());assert a['status']=='passed'
+ for path,sha in a['source_sha256'].items():assert digest(root/path)==sha,(name,path)
+for name in ['zero_parent_audit','projection1','validation-512','validation-1024','validation-2048']:assert not (root/name).exists(),name
+def call(script,*args,gpu=False,log=None):
+ cmd=['python']+([str(r/'run_limited.py')] if gpu else [])+[str(root/script),*map(str,args)];env=os.environ.copy();env['JAX_PLATFORMS']='cuda' if gpu else 'cpu'
+ if log:
+  with (root/log).open('w') as stream:subprocess.run(cmd,stdout=stream,stderr=subprocess.STDOUT,check=True,env=env)
+ else:subprocess.run(cmd,check=True,env=env)
+call('backend_control.py','--device','gpu',gpu=True);call('runtime_control.py','--device','gpu',gpu=True);call('evaluate.py','--zero','--output',root/'zero_parent_audit',gpu=True,log='zero_parent_audit.log');a=json.loads((root/'zero_parent_audit/report.json').read_text());assert a['status']=='passed' and a['zero_parent_audit'] and a['shots']==133120 and all(x['frozen_parent_decision_changes']==0 for x in a['conditions']);plan.update(status='All GPU production controls and full zero-projection parent/cache agreement passed; main fitting launched',launch_utc=datetime.datetime.now(datetime.timezone.utc).isoformat());(root/'plan.json').write_text(json.dumps(plan,indent=2)+'\n')
+call('train.py','--output',root/'projection1',gpu=True,log='projection1.log');evidence=audit(root/'projection1');assert evidence['training_draws']==1048576 and evidence['eligible_rows']==516880;provenance=json.loads((root/'projection1/provenance.json').read_text());matched=matched_audit(root/'projection1');provenance.update(declared_plan=plan,sampling_audit=evidence,zero_parent_audit=a,matched_draw_audit=matched);(root/'projection1/provenance.json').write_text(json.dumps(provenance,indent=2)+'\n')
+for step in plan['selection_steps']:call('evaluate.py','--weights',root/f'projection1/weights-{step}.npz','--output',root/f'validation-{step}',gpu=True,log=f'validation-{step}.log')
+previous=json.loads((r/'CURRENT.json').read_text())['predictions'];call('package.py');out=r/'context_upgrades/conditional_edge_projection1';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',previous],check=True);(root/'conditional_edge_projection1_finished.json').write_text(json.dumps({'complete':True,'test_data_used':False})+'\n')

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/audit_run.py

@@ -0,0 +1,34 @@
+"""Replay every condition/row draw and the separate projection Adam clocks."""
+from pathlib import Path
+import argparse,json,hashlib
+import numpy as np
+
+def digest(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
+def audit(run):
+    run=Path(run);config=json.loads((run/'run_config.json').read_text());assert config['start_step']==0 and not config['resume'];plan=config['training_plan'];rows=sorted([x for x in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if x['distance']==5],key=lambda x:x['name']);assert len(rows)==26 and len(config['data'])==26
+    for name,sha in config['source_sha256'].items():assert digest(run/'training_source'/name)==sha
+    for record,row in zip(config['data'],rows):
+        assert record['condition']==row['name']
+        for split,source in record['sources'].items():
+            assert digest(source['cache'])==source['cache_sha256'];path=Path('/workspace/data')/split/row['arrays'];assert digest(path)==source['arrays_sha256']
+            with np.load(path,allow_pickle=False) as f:ids=f['sample_ids']
+            assert hashlib.sha256(ids.tobytes()).hexdigest()==source['ID_sha256']
+    rng=np.random.default_rng(plan['sampling_seed']);seen=[np.zeros(x['shots'],bool) for x in rows];counts={'X':0,'Z':0};draw_hash=hashlib.sha256();steps=[]
+    for step in range(config['steps']+1):
+        if step:
+            ci=int(rng.integers(26));ix=rng.integers(rows[ci]['shots'],size=config['batch']);seen[ci][ix]=True;counts[rows[ci]['basis']]+=1;draw_hash.update(np.asarray([ci,*ix],dtype='<i8').tobytes())
+        path=run/f'checkpoint-{step}.json'
+        if not path.exists():continue
+        a=json.loads(path.read_text());assert a['complete'] and a['frozen_encoder_parents_and_gate_exact'] and a['step']==step and a['training_draws']==step*config['batch'] and a['basis_update_counts']==counts and a['weights_sha256']==digest(run/f'weights-{step}.npz') and a['draw_descriptor_sha256']==draw_hash.hexdigest() and a['unique_rows']==sum(int(x.sum()) for x in seen)
+        assert json.loads((run/f'rng-{step}.json').read_text())==rng.bit_generator.state
+        with np.load(run/f'seen-{step}.npz',allow_pickle=False) as f:assert set(f.files)=={x['name'] for x in rows} and all(np.array_equal(f[x['name']],v) for x,v in zip(rows,seen))
+        with np.load(run/f'optimizer-{step}.npz',allow_pickle=False) as f:
+            actual=[int(f[k]) for k in f.files if f[k].shape==() and np.issubdtype(f[k].dtype,np.integer)];assert actual==[counts['X'],counts['Z']],actual
+        with np.load(run/f'weights-{step}.npz',allow_pickle=False) as f:
+            assert set(f.files)=={'X_expert0','X_expert1','Z'} and all(f[k].shape==(64,64) and f[k].dtype==np.float32 and np.isfinite(f[k]).all() for k in f.files)
+            if step==0:assert all(not f[k].any() for k in f.files)
+        steps.append(step)
+    assert config['steps'] in steps;provenance=json.loads((run/'provenance.json').read_text());assert provenance['training_draws']==config['steps']*config['batch'] and provenance['basis_update_counts']==counts and provenance['draw_descriptor_sha256']==draw_hash.hexdigest()
+    report={'status':'passed','checked_steps':steps,'training_draws':config['steps']*config['batch'],'eligible_rows':516880,'basis_update_counts':counts,'every_draw_seen_RNG_hash_and_separate_Adam_clock_verified':True,'optimizer_contains_projections_only':True,'zero_initial_projections_verified':True,'source_sha256':digest(Path(__file__).resolve()),'test_data_used':False};(run/'audit.json').write_text(json.dumps(report,indent=2)+'\n');return report
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('run',type=Path);a=p.parse_args();print(json.dumps(audit(a.run),indent=2))

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/aux_encoder.py

@@ -0,0 +1,39 @@
+"""Dense masked-event objective using the unchanged axial encoder equations."""
+import jax
+import jax.numpy as jnp
+from axial_base import DEFAULT,layer_norm,attention,dropout
+
+def features(dets,grid,basis,rounds,mask):
+    valid=grid!=600
+    target=dets[:,grid].astype(jnp.float32)*valid[None]
+    mask=mask&valid[None]
+    events=jnp.where(mask,0.,target)
+    measured=(jnp.cumsum(events.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    broadcast=lambda value:jnp.broadcast_to(value,events.shape)
+    x=jnp.stack([events,measured,broadcast(valid[None]),broadcast(jnp.arange(26)[None,:,None]/25),broadcast(jnp.asarray(basis,jnp.float32)),broadcast(jnp.asarray(rounds,jnp.float32)/25),mask.astype(jnp.float32),jnp.zeros_like(events)],axis=-1)
+    return x,valid,target,mask
+
+def encode(parameters,inputs,valid,*,training=False,key=None,config=None):
+    c=DEFAULT if config is None else config;mask=valid[None,:,:,None]
+    x=(inputs@parameters['input_w']+parameters['input_b']+parameters['space_embedding'][None,None]+parameters['time_embedding'][None,:,None])*mask
+    if key is None:key=jax.random.key(0)
+    keys=jax.random.split(key,3*c['depth'])
+    for i in range(c['depth']):
+        for rank,axis in enumerate(['time','space']):
+            prefix=f'b{i}_{axis}';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias']);update=attention(parameters,prefix,normalized,valid,axis,c['heads']);x=(x+dropout(update,keys[3*i+rank],c['dropout'],training))*mask
+        prefix=f'b{i}_ff';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias']);update=jax.nn.gelu(normalized@parameters[prefix+'_w1']+parameters[prefix+'_b1'])@parameters[prefix+'_w2']+parameters[prefix+'_b2'];x=(x+dropout(update,keys[3*i+2],c['dropout'],training))*mask
+    return layer_norm(x,parameters['readout_scale'],parameters['readout_bias'])*mask
+
+def token_logits(parameters,dets,grid,basis,rounds,mask,*,training=False,key=None):
+    x,valid,target,mask=features(dets,grid,basis,rounds,mask);hidden=encode(parameters,x,valid,training=training,key=key)
+    return (hidden@parameters['mask_w'])[:,:, :,0]+parameters['mask_b'][0],target,mask
+
+def objective(parameters,dets,grid,basis,rounds,mask,*,training=False,key=None):
+    z,y,mask=token_logits(parameters,dets,grid,basis,rounds,mask,training=training,key=key);count=jnp.maximum(mask.sum(),1)
+    return jnp.sum(jnp.where(mask,jax.nn.softplus(z)-y*z,0.))/count
+
+def attach(trained,initial):
+    result={key:value for key,value in trained.items() if not key.startswith('mask_')}
+    result['input_w']=result['input_w'].at[6:8].set(initial['input_w'][6:8])
+    for key in ['readout_w1','readout_b1','readout_w2','readout_b2']:result[key]=initial[key]
+    return result

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/axial_base.py

@@ -0,0 +1,89 @@
+"""Untrained axial-attention residual over a frozen session-trained decoder."""
+import jax
+import jax.numpy as jnp
+
+DEFAULT={'width':64,'heads':4,'depth':3,'expansion':2,'dropout':.1,'correction_bound':4.}
+
+def initialize(seed,config=None):
+    c=DEFAULT if config is None else config;d=c['width'];params={};key=jax.random.key(seed)
+    def random(shape,scale):
+        nonlocal key
+        key,sub=jax.random.split(key);return jax.random.normal(sub,shape)*scale
+    params['input_w']=random((8,d),jnp.sqrt(1/8));params['input_b']=jnp.zeros(d)
+    params['space_embedding']=random((24,d),.02);params['time_embedding']=random((26,d),.02)
+    for i in range(c['depth']):
+        for axis in ['time','space']:
+            prefix=f'b{i}_{axis}'
+            params[prefix+'_scale']=jnp.ones(d);params[prefix+'_bias']=jnp.zeros(d)
+            params[prefix+'_qkv']=random((d,3*d),jnp.sqrt(1/d));params[prefix+'_qkv_b']=jnp.zeros(3*d)
+            params[prefix+'_out']=random((d,d),jnp.sqrt(1/d));params[prefix+'_out_b']=jnp.zeros(d)
+        prefix=f'b{i}_ff';hidden=d*c['expansion']
+        params[prefix+'_scale']=jnp.ones(d);params[prefix+'_bias']=jnp.zeros(d)
+        params[prefix+'_w1']=random((d,hidden),jnp.sqrt(1/d));params[prefix+'_b1']=jnp.zeros(hidden)
+        params[prefix+'_w2']=random((hidden,d),jnp.sqrt(1/hidden));params[prefix+'_b2']=jnp.zeros(d)
+    params['readout_scale']=jnp.ones(d);params['readout_bias']=jnp.zeros(d)
+    params['readout_w1']=random((d+2,d),jnp.sqrt(1/(d+2)));params['readout_b1']=jnp.zeros(d)
+    params['readout_w2']=jnp.zeros((d,1));params['readout_b2']=jnp.zeros(1)
+    return params
+
+def parent_logit(probability):
+    p=jnp.clip(probability,1e-7,1-1e-7)
+    return jnp.log(p)-jnp.log1p(-p)
+
+def token_features(dets,grid,basis,rounds,parent):
+    valid=grid!=600;events=dets[:,grid].astype(jnp.float32)*valid[None]
+    measured=(jnp.cumsum(events.astype(jnp.int32),axis=1)&1).astype(jnp.float32)
+    shape=events.shape
+    broadcast=lambda v:jnp.broadcast_to(v,shape)
+    z=jnp.clip(parent_logit(parent),-8.,8.)/8
+    return jnp.stack([events,measured,broadcast(valid[None]),broadcast(jnp.arange(26)[None,:,None]/25),
+        broadcast(jnp.asarray(basis,jnp.float32)),broadcast(jnp.asarray(rounds,jnp.float32)/25),
+        broadcast(z[:,None,None]),broadcast(jnp.abs(z)[:,None,None])],axis=-1),valid
+
+def layer_norm(x,scale,bias):
+    mean=x.mean(axis=-1,keepdims=True);variance=jnp.mean((x-mean)**2,axis=-1,keepdims=True)
+    return (x-mean)*jax.lax.rsqrt(variance+1e-5)*scale+bias
+
+def dropout(x,key,rate,training):
+    if not training or rate==0:return x
+    keep=1-rate;return jnp.where(jax.random.bernoulli(key,keep,x.shape),x/keep,0.)
+
+def attention(parameters,prefix,x,valid,axis,heads):
+    # Reshape each temporal/spatial line into its own attention group.
+    if axis=='time':x=jnp.swapaxes(x,1,2);valid=valid.T
+    batch,groups,length,width=x.shape;head_width=width//heads
+    qkv=x@parameters[prefix+'_qkv']+parameters[prefix+'_qkv_b']
+    q,k,v=[part.reshape(batch,groups,length,heads,head_width) for part in jnp.split(qkv,3,axis=-1)]
+    score=jnp.einsum('bgihd,bgjhd->bghij',q,k)/jnp.sqrt(jnp.float32(head_width))
+    score=jnp.where(valid[None,:,None,None,:],score,-1e9)
+    weights=jax.nn.softmax(score,axis=-1)
+    value=jnp.einsum('bghij,bgjhd->bgihd',weights,v).reshape(batch,groups,length,width)
+    value=(value@parameters[prefix+'_out']+parameters[prefix+'_out_b'])*valid[None,:,:,None]
+    return jnp.swapaxes(value,1,2) if axis=='time' else value
+
+def logits(parameters,dets,grid,basis,rounds,parent,*,training=False,key=None,config=None):
+    c=DEFAULT if config is None else config
+    features,valid=token_features(dets,grid,basis,rounds,parent);mask=valid[None,:,:,None]
+    x=(features@parameters['input_w']+parameters['input_b']+parameters['space_embedding'][None,None]+parameters['time_embedding'][None,:,None])*mask
+    if key is None:key=jax.random.key(0)
+    keys=jax.random.split(key,3*c['depth'])
+    for i in range(c['depth']):
+        for rank,axis in enumerate(['time','space']):
+            prefix=f'b{i}_{axis}';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias'])
+            update=attention(parameters,prefix,normalized,valid,axis,c['heads'])
+            x=(x+dropout(update,keys[3*i+rank],c['dropout'],training))*mask
+        prefix=f'b{i}_ff';normalized=layer_norm(x,parameters[prefix+'_scale'],parameters[prefix+'_bias'])
+        update=jax.nn.gelu(normalized@parameters[prefix+'_w1']+parameters[prefix+'_b1'])@parameters[prefix+'_w2']+parameters[prefix+'_b2']
+        x=(x+dropout(update,keys[3*i+2],c['dropout'],training))*mask
+    x=layer_norm(x,parameters['readout_scale'],parameters['readout_bias'])*mask
+    pooled=x.sum(axis=(1,2))/jnp.maximum(valid.sum(),1)
+    base=parent_logit(parent);z=jnp.clip(base,-8,8)/8
+    hidden=jax.nn.silu(jnp.concatenate([pooled,z[:,None],jnp.abs(z)[:,None]],axis=1)@parameters['readout_w1']+parameters['readout_b1'])
+    correction=c['correction_bound']*jnp.tanh((hidden@parameters['readout_w2']+parameters['readout_b2'])[:,0])
+    return base+correction
+
+def predict(parameters,dets,grid,basis,rounds,parent,config=None):
+    return jax.nn.sigmoid(logits(parameters,dets,grid,basis,rounds,parent,config=config))
+
+def binary_loss(logit,labels):
+    return jnp.mean(jax.nn.softplus(logit)-labels*logit)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/backend_control.py

@@ -0,0 +1,32 @@
+"""CPU/CUDA gradient references and actual native B512 physical-gradient pilots."""
+import argparse,os
+parser=argparse.ArgumentParser();parser.add_argument('--device',choices=['cpu','gpu'],required=True);args=parser.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 json,time
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from fixtures import frozen_states,training_probe,digest
+from features import token_embeddings,pool_endpoints,endpoint_plan
+from core import make_kernels
+from state import initialize,optimizer
+from train import make_updates
+root=Path(__file__).resolve().parent;encoder,parents,_,_,hashes=frozen_states();assert jax.default_backend()==args.device;rng=np.random.default_rng(20263210);projection=jax.tree_util.tree_map(lambda a:jnp.asarray(rng.normal(0,.01,a.shape),a.dtype),initialize());sg,_,mg,_=make_kernels();gradients={'X':mg,'Z':sg};encode=jax.jit(token_embeddings);pool=jax.jit(pool_endpoints);reference={};checks=[]
+for basis in ['X','Z']:
+ row,dets,y,base,fields,source=training_probe(basis,3,2);indices,weights=endpoint_plan(fields[0],fields[1],fields[2],fields[6])
+ with jax.default_matmul_precision('highest'):
+  embedding=pool(encode(encoder,dets,fields[5],basis=='X',3),indices,weights);g,loss,error=gradients[basis](projection[basis],parents[basis],dets,y,base,embedding,*fields)
+ arrays={'embedding':np.asarray(embedding),'loss':np.asarray(loss),**{f'gradient_{i}':np.asarray(v) for i,v in enumerate(jax.tree_util.tree_leaves(g))}};check={'condition':row['name'],'loss':float(loss),'gradient_norm':float(optax.global_norm(g))}
+ if args.device=='cpu':reference.update({basis+'__'+k:v for k,v in arrays.items()})
+ else:
+  with np.load(root/'backend_reference.npz',allow_pickle=False) as f:
+   differences=[a-f[basis+'__'+k] for k,a in arrays.items() if k.startswith('gradient')];maximum=max(float(abs(x).max()) for x in differences);relative=float(np.sqrt(sum(np.sum(x.astype(float)**2) for x in differences)/sum(np.sum(f[basis+'__'+k].astype(float)**2) for k in arrays if k.startswith('gradient'))));emb_error=float(abs(arrays['embedding']-f[basis+'__embedding']).max());loss_error=float(abs(arrays['loss']-f[basis+'__loss']))
+  assert emb_error<2e-5 and loss_error<2e-6 and maximum<1e-5 and relative<1e-4,(basis,emb_error,loss_error,maximum,relative);check.update(embedding_max_abs=emb_error,loss_max_abs=loss_error,gradient_max_abs=maximum,gradient_relative_l2=relative)
+ checks.append(check);print(json.dumps(check),flush=True)
+if args.device=='cpu':np.savez(root/'backend_reference.npz',**reference)
+pilots=[]
+if args.device=='gpu':
+ original=[np.asarray(x).copy() for x in jax.tree_util.tree_leaves((encoder,parents))];zero=initialize();optim=optimizer(.0005);updates=make_updates(optim)
+ for basis in ['X','Z']:
+  row,dets,y,base,fields,source=training_probe(basis,25,512);indices,weights=endpoint_plan(fields[0],fields[1],fields[2],fields[6]);started=time.monotonic();embedding=pool(encode(encoder,dets,fields[5],basis=='X',25),indices,weights);result=updates[basis](zero[basis],optim.init(zero[basis]),parents[basis],dets,y,base,embedding,*fields);jax.block_until_ready(result);peak=int((jax.devices()[0].memory_stats() or {}).get('peak_bytes_in_use',0));assert 0<peak<75*1024**3 and np.isfinite(float(result[2])) and int(result[1][1][0].count)==1;assert all(np.array_equal(a,b) for a,b in zip(original,jax.tree_util.tree_leaves((encoder,parents))));pilots.append({'condition':row['name'],'batch':512,'seconds':time.monotonic()-started,'peak_gpu_bytes':peak,'loss':float(result[2]),'gradient_norm':float(result[4]),'discarded_updates':1,'frozen_parameters_exact':True});print(json.dumps(pilots[-1]),flush=True)
+report={'status':'passed','device':str(jax.devices()[0]),'comparison_precision':'Highest float32 only for CPU/CUDA comparison; production pilots use native precision','cases':checks,'pilots':pilots,'frozen_weights_sha256':hashes,'source_sha256':{n:digest(root/n) for n in ['backend_control.py','train.py','core.py','features.py','conditional_tokens.py','fixtures.py','model.py','state.py','aux_encoder.py','axial_base.py','confidence_joint.py','joint_mixture.py','checkpoint_gradient.py','exact.py']},'test_data_used':False};(root/f'backend_control_{args.device}.json').write_text(json.dumps(report,indent=2)+'\n')

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/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/S044/training_sources/conditional_edge_projection1/compiled.py

@@ -0,0 +1,19 @@
+"""Retain bounded compiled attention executables across global JAX cache clears."""
+from collections import OrderedDict
+import jax
+
+class PersistentCompiled:
+    def __init__(self,function,max_executables=2):
+        self.function=jax.jit(function);self.executables=OrderedDict();self.max_executables=max_executables;self.compilations=0
+    def __call__(self,*args):
+        leaves,tree=jax.tree_util.tree_flatten(args)
+        signatures=[]
+        for value in leaves:
+            abstract=jax.core.get_aval(value)
+            signatures.append((abstract.shape,str(abstract.dtype),bool(abstract.weak_type)))
+        key=(tree,tuple(signatures))
+        if key not in self.executables:
+            self.executables[key]=self.function.lower(*args).compile();self.compilations+=1
+            while len(self.executables)>self.max_executables:self.executables.popitem(last=False)
+        self.executables.move_to_end(key)
+        return self.executables[key](*args)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/conditional_tokens.py

@@ -0,0 +1,16 @@
+"""Deterministic conditional token representations from eight masking partitions."""
+import jax
+import jax.numpy as jnp
+from aux_encoder import features,encode
+
+def conditional_tokens(parameters,dets,grid,basis,rounds,colors):
+ valid=grid!=600
+ def body(color,result):
+  mask=jnp.broadcast_to((colors==color)&valid,(len(dets),26,24));inputs,active,_,_=features(dets,grid,basis,rounds,mask);tokens=encode(parameters,inputs,active,training=False);return jnp.where(mask[:,:,:,None],tokens,result)
+ return jax.lax.fori_loop(0,8,body,jnp.zeros((len(dets),26,24,parameters['input_w'].shape[-1]),jnp.float32))
+
+def conditional_logits(parameters,dets,grid,basis,rounds,colors):
+ h=conditional_tokens(parameters,dets,grid,basis,rounds,colors);return (h@parameters['mask_w'])[:,:,:,0]+parameters['mask_b'][0]
+
+# Fixed ideal-slot partition, generated once by seed20263501.
+COLORS=[[6, 2, 0, 7, 3, 2, 3, 1, 2, 2, 4, 7, 4, 2, 4, 0, 2, 5, 0, 3, 6, 3, 6, 4], [1, 5, 4, 4, 5, 4, 5, 1, 0, 1, 3, 1, 5, 1, 7, 5, 1, 4, 6, 2, 3, 5, 6, 6], [7, 7, 6, 1, 2, 7, 7, 7, 1, 6, 0, 2, 6, 7, 2, 5, 1, 3, 4, 0, 4, 5, 1, 5], [4, 3, 0, 3, 3, 1, 5, 6, 0, 3, 2, 7, 4, 4, 4, 5, 7, 3, 2, 0, 0, 6, 1, 5], [4, 2, 7, 5, 1, 6, 3, 2, 1, 1, 0, 6, 7, 5, 2, 4, 4, 1, 5, 0, 2, 7, 1, 7], [3, 4, 2, 5, 2, 1, 6, 0, 0, 7, 2, 5, 4, 7, 6, 6, 4, 7, 6, 4, 7, 2, 3, 3], [0, 3, 4, 7, 4, 7, 2, 4, 7, 5, 7, 2, 1, 6, 4, 0, 6, 0, 4, 4, 4, 6, 1, 0], [5, 3, 7, 0, 7, 2, 3, 5, 5, 7, 0, 2, 0, 4, 0, 4, 1, 1, 1, 1, 4, 2, 7, 3], [0, 3, 2, 5, 7, 5, 1, 7, 6, 2, 0, 5, 7, 1, 6, 6, 6, 4, 6, 0, 6, 6, 2, 1], [6, 0, 4, 7, 1, 6, 2, 7, 0, 2, 4, 1, 3, 7, 7, 0, 3, 5, 4, 4, 5, 2, 2, 1], [2, 1, 5, 3, 2, 6, 4, 4, 4, 4, 0, 4, 0, 0, 2, 4, 3, 6, 3, 7, 4, 7, 2, 7], [2, 0, 4, 0, 4, 1, 6, 0, 1, 5, 2, 7, 4, 3, 6, 6, 0, 3, 0, 2, 1, 0, 6, 1], [1, 6, 1, 5, 4, 4, 1, 4, 6, 3, 0, 2, 6, 1, 1, 6, 0, 6, 0, 4, 6, 3, 3, 7], [5, 1, 7, 0, 2, 0, 0, 5, 3, 1, 2, 0, 3, 3, 3, 1, 3, 1, 3, 3, 7, 5, 3, 5], [2, 6, 4, 1, 7, 4, 7, 3, 2, 6, 4, 1, 2, 4, 6, 6, 3, 6, 5, 7, 3, 4, 6, 0], [7, 5, 4, 3, 0, 4, 6, 1, 4, 1, 2, 6, 5, 1, 3, 1, 3, 0, 7, 6, 5, 0, 0, 6], [1, 1, 3, 2, 6, 6, 7, 2, 5, 7, 7, 3, 6, 5, 4, 2, 6, 2, 5, 3, 3, 3, 1, 2], [4, 7, 4, 1, 4, 4, 1, 2, 0, 6, 6, 1, 1, 1, 6, 1, 0, 1, 4, 2, 4, 0, 3, 6], [7, 7, 6, 7, 0, 0, 7, 4, 5, 2, 4, 2, 2, 0, 6, 5, 6, 3, 5, 1, 6, 3, 2, 3], [6, 3, 5, 1, 7, 4, 0, 3, 4, 4, 5, 7, 5, 3, 1, 3, 2, 0, 7, 6, 5, 7, 3, 6], [6, 1, 7, 6, 4, 5, 3, 0, 6, 4, 4, 7, 5, 4, 1, 1, 3, 7, 5, 2, 0, 1, 7, 0], [1, 2, 3, 5, 7, 2, 1, 4, 4, 7, 7, 2, 1, 1, 5, 3, 7, 3, 4, 7, 3, 0, 0, 4], [7, 6, 0, 0, 7, 4, 2, 6, 0, 0, 2, 5, 5, 3, 4, 1, 0, 2, 2, 2, 3, 0, 2, 3], [1, 5, 2, 6, 3, 6, 0, 4, 5, 1, 6, 5, 4, 3, 5, 3, 6, 1, 3, 0, 0, 2, 7, 7], [5, 5, 6, 7, 3, 0, 7, 3, 6, 5, 4, 1, 4, 3, 6, 6, 5, 0, 4, 0, 7, 3, 3, 2], [6, 5, 3, 2, 6, 7, 6, 7, 7, 7, 5, 1, 1, 0, 1, 7, 6, 2, 4, 2, 0, 0, 1, 2]]

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/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/S044/training_sources/conditional_edge_projection1/contextual.py

@@ -0,0 +1,40 @@
+"""Portable structured decoder with frozen endpoint embeddings and learned projections."""
+import numpy as np
+from d5_preconditional_edge_contextual import NeuralD5Decoder as PreviousDecoder
+from conditional_edge_compiled import PersistentCompiled
+from conditional_edge_features import token_embeddings,pool_endpoints,endpoint_plan
+from conditional_edge_core import make_kernels
+
+class NeuralD5Decoder(PreviousDecoder):
+    def __init__(self):
+        super().__init__();_,single,_,mixture=make_kernels();self.edge_infer={'X':PersistentCompiled(mixture),'Z':PersistentCompiled(single)};self.edge_encode=PersistentCompiled(token_embeddings);self.edge_pool=PersistentCompiled(pool_endpoints);self.edge_weights={}
+
+    def predict(self,root,record,settings,packed,num_detectors,batch=512,initial_priors=None,**kwargs):
+        extension=settings.get('conditional_edge_projection')
+        if extension is None:return super().predict(root,record,settings,packed,num_detectors,batch,initial_priors=initial_priors,**kwargs)
+        import jax.numpy as jnp
+        from conditional import load_state
+        from turbo import TurboDecoder
+        parent_settings=extension['parent_settings'];assert settings['prior_pass']==parent_settings['prior_pass'] and not parent_settings.get('blend_turbo',False)
+        plan=dict(np.load(root/record['neural_d5_plan'],allow_pickle=False));basis='X' if bool(np.max(plan['static'][:,127])) else 'Z';rounds=int(round(float(np.max(plan['static'][:,124]))*25));key=(extension['weights'],extension['encoder_weights'],basis)
+        if key not in self.edge_weights:
+            with np.load(root/extension['weights'],allow_pickle=False) as f:projection={k:jnp.asarray(f['X_'+k]) for k in ['expert0','expert1']} if basis=='X' else jnp.asarray(f['Z'])
+            with np.load(root/extension['encoder_weights'],allow_pickle=False) as f:encoder={k:jnp.asarray(f[k]) for k in f.files}
+            path=parent_settings['confidence_joint']['weights'] if basis=='X' else parent_settings['weights']
+            with np.load(root/path,allow_pickle=False) as f:
+                if basis=='X':
+                    parent={k:{} for k in ['expert0','expert1','gate']}
+                    for name in f.files:part,field=name.split('__',1);parent[part][field]=jnp.asarray(f[name])
+                else:parent={k:jnp.asarray(f[k]) for k in f.files}
+            self.edge_weights[key]=(projection,encoder,parent)
+        projection,encoder,parent=self.edge_weights[key];dets=np.unpackbits(packed,axis=1,count=num_detectors,bitorder='little');passes=settings['prior_pass'];assert passes==(3 if basis=='X' else 5)
+        if initial_priors is not None:priors=np.asarray(initial_priors)
+        elif 'turbo_plan' in record:
+            decoder=TurboDecoder(load_state(root/record['turbo_plan']),batch=batch);_,captured=decoder.predict(dets,damping=1.,iterations=passes,last_only=True,message_clip=8.,return_priors_at=(passes,),skip_final_logical=True);priors=captured[passes];del decoder
+        else:
+            fixed=dict(np.load(root/record['plan'],allow_pickle=False))['probabilities'];priors=np.broadcast_to(fixed[None],(len(dets),len(fixed)))
+        length=((int(plan['operation_count'])+511)//512)*512;assert priors.shape==(len(dets),int(plan['operation_count']));base=np.log(np.clip(priors,1e-7,1-1e-7)/np.clip(1-priors,1e-7,1-1e-7));base=np.pad(base,((0,0),(0,length-base.shape[1]))).astype(np.float32);dets=np.pad(dets,((0,0),(0,601-num_detectors)))
+        fields=[plan[k][:length] for k in ['context','static','valid','masks','measured']]+[plan[k] for k in ['grid','measurement_indices','counts']];indices,weights=endpoint_plan(fields[0],fields[1],fields[2],fields[6]);output=[]
+        for pos in range(0,len(dets),batch):
+            count=min(batch,len(dets)-pos);ds=np.pad(dets[pos:pos+batch],((0,batch-count),(0,0)));z=np.pad(base[pos:pos+batch],((0,batch-count),(0,0)));tokens=self.edge_encode(encoder,ds,plan['grid'],basis=='X',rounds);embedding=self.edge_pool(tokens,indices,weights);q=self.edge_infer[basis](projection,parent,ds,z,embedding,*fields);output.append(np.asarray(q)[:count])
+        return np.concatenate(output).astype(np.float32)

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/control_cpu.py

@@ -0,0 +1,45 @@
+"""Endpoint geometry, neutral attachment, independent gradients and discarded state replay."""
+import os
+os.environ['JAX_PLATFORMS']='cpu';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 json,tempfile
+import numpy as np
+import jax,jax.numpy as jnp,optax
+from fixtures import frozen_states,training_probe,digest
+from features import endpoint_plan,token_embeddings,pool_endpoints
+from model import probabilities
+from base_edge import probabilities as original_probabilities
+from confidence_joint import gate_features,gate_logit,mix_predictions
+from core import make_kernels
+from exact import make_decoder
+root=Path(__file__).resolve().parent;encoder,parents,_,_,hashes=frozen_states();original=[np.asarray(x).copy() for x in jax.tree_util.tree_leaves((encoder,parents))];sg,si,mg,mi=make_kernels();decode=make_decoder(14);checks=[];rng=np.random.default_rng(20263210);encode=jax.jit(token_embeddings)
+for basis in ['X','Z']:
+    row,dets,y,base,fields,source=training_probe(basis,3);context,static,valid,masks,measured,grid,mapping,counts=fields;indices,weight=endpoint_plan(context,static,valid,mapping);tokens=encode(encoder,dets,grid,basis=='X',3);embedding=jax.jit(pool_endpoints)(tokens,indices,weight);reference=np.zeros(embedding.shape,np.float64);flat=np.asarray(tokens).reshape(len(dets),624,64)
+    for op in range(len(context)):
+        selected=indices[op][weight[op]>0]
+        if len(selected):reference[:,op]=flat[:,selected].astype(float).mean(axis=1)
+    pool_error=float(abs(np.asarray(embedding)-reference).max());assert pool_error<1e-6;assert not np.asarray(embedding)[:,valid==0].any()
+    frozen=parents[basis];is_mixture=basis=='X';projection={k:jnp.zeros((64,64),jnp.float32) for k in ['expert0','expert1']} if is_mixture else jnp.zeros((64,64),jnp.float32);infer=mi if is_mixture else si;gradient=mg if is_mixture else sg
+    zero=infer(projection,frozen,dets,base,embedding,*fields)
+    if is_mixture:
+        q=jnp.stack([decode(dets,original_probabilities(frozen[k],dets,base,context,static,valid,grid,mapping,counts),masks,measured) for k in ['expert0','expert1']],axis=1);expected=mix_predictions(q,gate_logit(frozen['gate'],gate_features(dets,grid,static,q)))
+    else:expected=decode(dets,original_probabilities(frozen,dets,base,context,static,valid,grid,mapping,counts),masks,measured)
+    neutral=float(abs(zero-expected).max());assert neutral<2e-7
+    trial=jax.tree_util.tree_map(lambda v:jnp.asarray(rng.normal(0,.01,v.shape),v.dtype),projection)
+    def independent_loss(p):
+        q=infer(p,frozen,dets,base,embedding,*fields);return -jnp.mean(jnp.log(jnp.where(y.astype(bool),q,1-q)))
+    reference_loss,reference_gradient=jax.jit(jax.value_and_grad(independent_loss))(trial);actual,loss,error=gradient(trial,frozen,dets,y,base,embedding,*fields);leaves=jax.tree_util.tree_leaves(actual);ref=jax.tree_util.tree_leaves(reference_gradient);relative=float(np.sqrt(sum(np.sum((np.asarray(a)-np.asarray(b)).astype(float)**2) for a,b in zip(leaves,ref))/max(sum(np.sum(np.asarray(b,dtype=float)**2) for b in ref),1e-24)));assert relative<1e-4 and abs(float(loss-reference_loss))<1e-6 and float(optax.global_norm(actual))>0,(basis,relative,float(loss-reference_loss))
+    optim=optax.chain(optax.clip_by_global_norm(1),optax.adamw(.001,weight_decay=1e-4));state=optim.init(projection)
+    @jax.jit
+    def update(p,s):
+        g,loss,_=gradient(p,frozen,dets,y,base,embedding,*fields);changes,s=optim.update(g,s,p);return optax.apply_updates(p,changes),s,loss
+    p1,s1,_=update(projection,state);p2,s2,_=update(p1,s1);leaves,tree=jax.tree_util.tree_flatten((p1,s1))
+    with tempfile.TemporaryDirectory(prefix='masked-edge-control-') as temp:
+        path=Path(temp)/'state.npz';np.savez(path,**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)})
+        with np.load(path,allow_pickle=False) as f:loaded=jax.tree_util.tree_unflatten(tree,[jnp.asarray(f[f'arr_{i}']) for i in range(len(leaves))])
+        rp,rs,_=update(*loaded)
+    assert all(np.array_equal(a,b) for a,b in zip(jax.tree_util.tree_leaves((p2,s2)),jax.tree_util.tree_leaves((rp,rs))))
+    assert int(s2[1][0].count)==2 and float(optax.global_norm(p2))>0
+    q=infer(p2,frozen,dets,base,embedding,*fields);reverse=infer(p2,frozen,dets[::-1].copy(),base[::-1].copy(),embedding[::-1],*fields);assert np.array_equal(q,reverse[::-1]);assert all(np.array_equal(a,b) for a,b in zip(original,jax.tree_util.tree_leaves((encoder,parents))))
+    checks.append({'condition':row['name'],'endpoint_pool_reference_max_abs':pool_error,'neutral_original_probability_max_abs':neutral,'independent_whole_contraction_gradient_relative_l2':relative,'loss_difference':float(abs(loss-reference_loss)),'trainable_projection_count':sum(v.size for v in jax.tree_util.tree_leaves(projection)),'actual_projection_gradient_norm':float(optax.global_norm(actual)),'frozen_encoder_parent_and_gate_exact':True,'two_updates_plus_serialized_resume_exact':True,'order_exact':True,'source':source});print(json.dumps(checks[-1]),flush=True)
+report={'status':'passed','checks':checks,'discarded_optimizer_updates_including_resume':6,'scope':'CPU prototype only, four primary discarded updates plus two resumed replays. No main optimizer schedule, fitting or validation selection. No GPU queue.','source_sha256':{p.name:digest(p) for p in root.glob('*.py')},'frozen_weights_sha256':hashes,'test_data_used':False};(root/'control_cpu.json').write_text(json.dumps(report,indent=2)+'\n')

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

@@ -0,0 +1,30 @@
+"""Projection-only exact gradients, including the frozen confidence gate's input path."""
+import jax
+import jax.numpy as jnp
+from model import probabilities
+from checkpoint_gradient import make_loss_and_grad
+from exact import make_decoder
+from confidence_joint import gate_features,gate_logit,mixture_terms,mix_predictions,expert_adjoint_factors
+
+def make_kernels(width=14,block_size=32):
+    exact=make_loss_and_grad(width,block_size);decode=make_decoder(width)
+    @jax.jit
+    def single_gradient(projection,frozen,dets,labels,base,embedding,context,static,valid,masks,measured,grid,mapping,counts):
+        p,pull=jax.vjp(lambda v:probabilities(v,frozen,dets,base,embedding,context,static,valid,grid,mapping,counts),projection);loss,prediction,adjoint=exact(dets,labels,p,masks,measured)
+        return pull(adjoint/len(dets))[0],loss.mean(),jnp.mean((prediction>=.5)!=labels)
+    @jax.jit
+    def single_infer(projection,frozen,dets,base,embedding,context,static,valid,masks,measured,grid,mapping,counts):
+        return decode(dets,probabilities(projection,frozen,dets,base,embedding,context,static,valid,grid,mapping,counts),masks,measured)
+    @jax.jit
+    def mixture_gradient(projections,frozen,dets,labels,base,embedding,context,static,valid,masks,measured,grid,mapping,counts):
+        p0,pull0=jax.vjp(lambda v:probabilities(v,frozen['expert0'],dets,base,embedding,context,static,valid,grid,mapping,counts),projections['expert0']);loss0,pred0,g0=exact(dets,labels,p0,masks,measured)
+        p1,pull1=jax.vjp(lambda v:probabilities(v,frozen['expert1'],dets,base,embedding,context,static,valid,grid,mapping,counts),projections['expert1']);loss1,pred1,g1=exact(dets,labels,p1,masks,measured)
+        losses=jnp.stack([loss0,loss1],axis=1);prediction=jnp.stack([pred0,pred1],axis=1)
+        z,pull_gate=jax.vjp(lambda q:gate_logit(frozen['gate'],gate_features(dets,grid,static,q)),prediction);loss,responsibility,adjoint,coefficients=mixture_terms(losses,z);extra=pull_gate(adjoint)[0];factor=expert_adjoint_factors(losses,labels,responsibility,extra)
+        gradient={'expert0':pull0(g0*factor[:,0][None]/len(dets))[0],'expert1':pull1(g1*factor[:,1][None]/len(dets))[0]};q=mix_predictions(prediction,z)
+        return gradient,loss.mean(),jnp.mean((q>=.5)!=labels)
+    @jax.jit
+    def mixture_infer(projections,frozen,dets,base,embedding,context,static,valid,masks,measured,grid,mapping,counts):
+        q=jnp.stack([decode(dets,probabilities(projections[k],frozen[k],dets,base,embedding,context,static,valid,grid,mapping,counts),masks,measured) for k in ['expert0','expert1']],axis=1)
+        return mix_predictions(q,gate_logit(frozen['gate'],gate_features(dets,grid,static,q)))
+    return single_gradient,single_infer,mixture_gradient,mixture_infer

tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S044/training_sources/conditional_edge_projection1/data.py

@@ -0,0 +1,38 @@
+"""Full authorized hardware data with the frozen parent's physical-prior cache lineage."""
+from pathlib import Path
+import json,hashlib
+import numpy as np
+from fixtures import frozen_states,digest,ROOT,RESEARCH
+from features import endpoint_plan
+
+def align(ids,target):
+    assert len(np.unique(ids))==len(ids);order=np.argsort(ids);location=np.searchsorted(ids[order],target);assert np.all(location<len(order));index=order[location];assert np.array_equal(ids[index],target);return index
+
+def load_all(splits=('train','validation')):
+    _,_,package,config,_=frozen_states();rows=sorted([x for x in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if x['distance']==5],key=lambda x:x['name']);items=[];records=[]
+    for row in rows:
+        path=package/config['conditions'][row['name']]['neural_d5_plan']
+        with np.load(path,allow_pickle=False) as f:item={k:f[k] for k in f.files}
+        length=((int(item['operation_count'])+511)//512)*512;item['length']=length;item['row']=row
+        for key in ['context','static','valid','masks','measured']:item[key]=item[key][:length]
+        item['endpoint_indices'],item['endpoint_weights']=endpoint_plan(item['context'],item['static'],item['valid'],item['measurement_indices']);prior_pass=config['neural_d5'][row['group']]['prior_pass'];sources={}
+        for split in splits:
+            record=next(x for x in json.loads((Path('/workspace/data')/split/'manifest.json').read_text())['conditions'] if x['name']==row['name']);path=Path('/workspace/data')/split/record['arrays'];assert digest(path)==record['arrays_sha256']
+            with np.load(path,allow_pickle=False) as f:ids=f['sample_ids'];labels=f['labels'];packed=f['detectors']
+            if split=='train':
+                cache=RESEARCH/('learned_d5/full_training_priors3' if prior_pass==3 else 'full_prior5/cache1')/(row['name']+'.npz')
+                with np.load(cache,allow_pickle=False) as f:ix=align(f['sample_ids'],ids);prior=f[f'priors{prior_pass}'][ix]
+                lineage='Own generated full-training priors; opaque-ID equality alignment for every row.'
+            else:
+                cache=RESEARCH/'masked_edge_projection/runtime_validation_priors'/(row['name']+'.npz')
+                with np.load(cache,allow_pickle=False) as f:ix=align(f['sample_ids'],ids);prior=f[f'priors{prior_pass}'][ix]
+                lineage='Own exact packaged-runtime validation priors, batch512, pass3X/pass5Z, generated from detection events only. Explicit opaque-ID equality alignment. Rebuilt before main after historical-cache numerical discrepancy; original evidence and unchanged audit tolerance retained in masked_edge_projection/VALIDATION_CACHE_RECOVERY_PLAN.json.'
+            assert prior.shape==(len(ids),int(item['operation_count']))
+            logits=np.log(np.clip(prior,1e-7,1-1e-7)/np.clip(1-prior,1e-7,1-1e-7)).astype(np.float32);item[split+'_base']=np.pad(logits,((0,0),(0,length-logits.shape[1])));item[split+'_dets']=np.pad(np.unpackbits(packed,axis=1,count=row['num_detectors'],bitorder='little'),((0,0),(0,601-row['num_detectors'])));item[split+'_labels']=labels;item[split+'_ids']=ids
+            sources[split]={'arrays_sha256':record['arrays_sha256'],'cache':str(cache),'cache_sha256':digest(cache),'ID_sha256':hashlib.sha256(ids.tobytes()).hexdigest(),'lineage':lineage}
+        items.append(item);records.append({'condition':row['name'],'feature_plan_sha256':digest(package/config['conditions'][row['name']]['neural_d5_plan']),'prior_pass':prior_pass,'sources':sources})
+    assert len(items)==26
+    if 'train' in splits:assert sum(len(x['train_labels']) for x in items)==516880
+    return items,records
+
+def fields(item):return [item[k] for k in ['context','static','valid','masks','measured','grid','measurement_indices','counts']]