{"approach": "Start strategy plus isolated spread-specific patches in order deadband, premium, postjump, cross, cancel. Each candidate compared run-by-run with currently retained strategy on first eligible spread seeds from 150000, accepted only for strictly positive gains in both equal halves. Fixed constants only; final strategy frozen before independent holdout.", "blocked": null, "base_mean_edge": 108.63974289615767, "changes": [{"name": "deadband", "spread": 1, "kept": true, "runs": 800, "gain": 1.95456000048525, "standard_error": 1.130810207389846, "retail": 1.177816300468125, "arb": 0.7767436999981254, "first_half": 1.0139993693862501, "second_half": 2.89512063158425}, {"name": "deadband", "spread": 3, "kept": true, "runs": 800, "gain": 0.6127362211706253, "standard_error": 0.4064824581431537, "retail": 1.5210945617035003, "arb": -0.9083583405225001, "first_half": 1.0038792547347506, "second_half": 0.22159318760650001}, {"name": "deadband", "spread": 4, "kept": true, "runs": 800, "gain": 0.4844501797157491, "standard_error": 0.27850396446170805, "retail": 2.1534634983689993, "arb": -1.6690133186573748, "first_half": 0.48532049053924986, "second_half": 0.48357986889224847}, {"name": "premium", "spread": 4, "kept": false, "runs": 800, "gain": -0.5530713286213749, "standard_error": 0.21617909955159165, "retail": 1.4942316305030006, "arb": -2.0473029591275, "first_half": -0.8362005056520003, "second_half": -0.2699421515907495}, {"name": "postjump", "spread": 1, "kept": true, "runs": 800, "gain": 0.17625968372849982, "standard_error": 0.19034444428188801, "retail": -0.06399796827262438, "arb": 0.2402576520008745, "first_half": 0.0020865339904996925, "second_half": 0.3504328334665}, {"name": "cross", "spread": 1, "kept": true, "runs": 800, "gain": 0.6063841173272502, "standard_error": 0.30209973635958604, "retail": -0.754131366606375, "arb": 1.3605154839523752, "first_half": 1.0607474269100006, "second_half": 0.15202080774449975}, {"name": "cross", "spread": 2, "kept": true, "runs": 800, "gain": 0.5229960566512495, "standard_error": 0.10610274268281601, "retail": 0.38943116388137516, "arb": 0.13356489275937475, "first_half": 0.5257728375702497, "second_half": 0.520219275732249}, {"name": "cross", "spread": 3, "kept": true, "runs": 800, "gain": 0.22030573250837393, "standard_error": 0.12485051477862424, "retail": -0.0004105674983748409, "arb": 0.22071629999475006, "first_half": 0.20804995107249916, "second_half": 0.23256151394424865}, {"name": "cancel", "spread": 1, "kept": false, "runs": 800, "gain": -1.6540003131891254, "standard_error": 0.8813897341805681, "retail": -4.340088898846001, "arb": 2.6860885856342502, "first_half": -1.7236403204212507, "second_half": -1.584360305957}, {"name": "cancel", "spread": 2, "kept": false, "runs": 800, "gain": 0.10727170822175053, "standard_error": 0.4637861881671467, "retail": -0.2686360459292497, "arb": 0.37590775416250005, "first_half": -0.23946692572349956, "second_half": 0.4540103421670006}, {"name": "cancel", "spread": 3, "kept": true, "runs": 800, "gain": 0.6790491505312505, "standard_error": 0.16383802326047398, "retail": -0.00045159062162509534, "arb": 0.6795007411737499, "first_half": 0.6754262862287504, "second_half": 0.6826720148337506}, {"name": "cancel", "spread": 4, "kept": true, "runs": 800, "gain": 0.5197140850931254, "standard_error": 0.11931601230132634, "retail": -0.2221750972919995, "arb": 0.741889182387625, "first_half": 0.47754905986774987, "second_half": 0.5618791103185011}], "by_spread": {"spread1": {"runs": 743, "mean": -0.21789687315773912, "standard_error": 0.8156780115426311, "retail": -0.5946258066465676, "arb": 0.3767289334952895}, "spread2": {"runs": 729, "mean": 0.526070196753498, "standard_error": 0.07642157522926436, "retail": 0.323316946606173, "arb": 0.20275325014691364}, "spread3": {"runs": 738, "mean": 1.465977865198375, "standard_error": 0.3010164662430712, "retail": 1.738342222878319, "arb": -0.2723643576861786}, "spread4": {"runs": 790, "mean": 1.2690688747881016, "standard_error": 0.41837430080342203, "retail": 1.8703311907337967, "arb": -0.6012623159730379}}, "holdout": {"mean_edge": 101.86645626489778, "retail_edge": 125.10820712861836, "arb_edge": -23.241750863756533, "failures": 0}, "diff": {"mean": 0.768687957425367, "standard_error": 0.2426212765874633, "retail": 0.8514497603004664, "arb": -0.0827618028823332}, "seconds": {"start": 167.0329424010124, "yours": 170.58695952803828}, "code": "\"\"\"Crossing-cover base with isolated, untuned per-spread overrides stacked: each acts only in runs of its own competitor spread.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\nP = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05,\n ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0,\n ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0,\n ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\ndef cdf(x): return 0.5 * (1.0 + math.erf(x / SQ2))\ndef pdf(x): return math.exp(-0.5 * x * x) / SQ2PI\ndef inv(p):\n p = min(max(p, 1e-9), 1 - 1e-9)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n d = pdf(x)\n if d < 1e-12:\n break\n x -= (cdf(x) - p) / d\n return x\ndef lpm(k):\n return pdf(k) + k * cdf(k)\ndef fl(q):\n return math.floor(q * 100 + 1e-9) / 100\n\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\n\nF_AH = 1\nF_FL = 1\nF_QB = 1\n\n# s1-flow: conditional likelihood of partial fills and zeros. Fully exhausted quotes\n# can be either retail or arbitrage; neither is treated as a zero or a\n# complete retail order. Truncation normalization corrects the selection.\nFLOW_CAPS = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.)\nFLOW_GRID = []\nFLOW_PRIORS=[]\nfor _rn,_rw in ((-math.sqrt(0.6),5/18),(0.,4/9),(math.sqrt(0.6),5/18)):\n _r=0.1265+0.0495*_rn\n for _mn,_mw in ((-0.906179845938664,0.118463442528095),(-0.538469310105683,0.239314335249683),(0.,0.284444444444444),(0.538469310105683,0.239314335249683),(0.906179845938664,0.118463442528095)):\n _m=4.488+1.848*_mn\n _parts=[]\n for _n in (1,2,3):\n _v=math.log(1+(math.exp(1.44)-1)/_n)\n _sg=math.sqrt(_v)\n _mu=math.log(_n*_m)-_v/2\n _w=_r**_n/math.factorial(_n)\n _parts.append((_mu,_sg,_w))\n _norm=[]\n for _c in FLOW_CAPS:\n _prob=sum(w*(cdf((math.log(_c)-mu)/sg)-cdf((math.log(0.03)-mu)/sg)) for mu,sg,w in _parts)\n _norm.append(math.log1p(_prob))\n _tails=[]\n for _c in FLOW_CAPS:\n _cdf=1+sum(w*cdf((math.log(_c)-mu)/sg) for mu,sg,w in _parts)\n _tails.append(math.log(max(1e-100,1-math.exp(-_r)*_cdf)))\n FLOW_GRID.append((_r,_m,_parts,_norm,_tails))\n FLOW_PRIORS.append(math.log(_rw*_mw))\n\n\nclass Strategy(BaseStrategy):\n def __init__(self):\n self.n = 0\n self.ahead = set() # main orders placed strictly ahead of any competitor order at their tick\n self.res = {} # order id -> uncovered quantity at placement\n self.bc = None # belief: sub-tick grid centres (ticks)\n self.bw = None # belief: weights\n self.st = 0.5 # last one-step sd in ticks\n self.pcb = self.pca = None\n self.pb = set()\n self.pa = set()\n self.tb = 0\n self.s = None # competitor spread parameter\n self.flow_notional = 0.0\n self.flow_exposure = 0\n self.last_ask_tick = None\n self.last_quote_exposed = False\n self.last_flow_ca = None\n self.last_flow_cap = 0.0\n self.last_flow_correction = 1.0\n self.params = P.copy()\n self.s2_mb = set()\n self.s2_ma = set()\n self.s2_lb = self.s2_la = -99\n self.fl_obs = ()\n self.fl_scores = FLOW_PRIORS.copy()\n self.fl_bins = [0]*len(FLOW_CAPS)\n self.fl_rate = 0.568734\n self.fl_r = 0.1265\n self.fl_m = 4.488\n self.fl_buy_sum = self.fl_sell_sum = 0.0\n self.fl_buy_exp = self.fl_sell_exp = 0.0\n self.fl_exp = 0\n self.fl_dirty=False\n self.fl_ahead=set()\n self.fl_safe_n=0\n self.fl_sbins=[0]*len(FLOW_CAPS)\n\n def _oid(self, tag):\n self.n += 1\n return tag + str(self.n)\n\n def on_step(self, state):\n H = max(1, state.steps_remaining)\n cb = state.competitor_best_bid_ticks or 0\n ca = state.competitor_best_ask_ticks or 100\n if self.s is None:\n self.s = max(1, (ca - cb + 1) // 2)\n if self.s == 4:\n # Use the existing low-price risk penalty on bids too; inventory\n # cover orders already provide the separate stocking mechanism.\n self.params['kLb'] = self.params['kLf'] = self.params['kL']\n # Censored compound-Poisson flow likelihood, using only our fills.\n self.f4_exposure = [0, 0]\n self.f4_events = [0, 0]\n self.f4_weights = [[0.0] * 9, [0.0] * 9]\n self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n # Positive aggregate flow is approximately lognormal; +0.065\n # accounts for the occasional second arrival in a timestep.\n self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n self.f4_last = [None, None]\n self.f4_rate = 0.1265\n self.f4_mean = 4.488\n self.f4_flow = self.f4_rate * self.f4_mean\n self.f4_extreme = inv(1 - 1e-6)\n if self.s == 2:\n self.params.update(dict(flow_prior=200, flow_level=0.6, flow_strength=1.0, flow_safety=2.0, flow_exposure_min=5.0))\n self.params.update({'kLf': 0.16})\n if self.s == 1:\n self.params.update({'dmin': 0.3, 'pfl': 1e-06, 'qb_z': 4.0})\n if self.s == 3:\n self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n P = self.params\n s1 = self.s == 1\n AH = s1 and F_AH\n FL = s1 and F_FL\n QB = s1 and F_QB\n if self.s == 4:\n for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n last = self.f4_last[side]\n if last is None:\n continue\n tick, conv, cap, old_bound, ids = last\n if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n continue\n # Track only the main quote, excluding probes and stock orders.\n remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n value = max(0.0, cap - remaining * conv)\n self.f4_exposure[side] += 1\n if value > 0.01:\n self.f4_events[side] += 1\n censored = remaining < 0.011\n logv = math.log(max(value, 0.01))\n weights = self.f4_weights[side]\n for i, mu4 in enumerate(self.f4_mu):\n z4 = (logv - mu4) / 1.2\n weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n if state.step % 25 == 0:\n exposure = sum(self.f4_exposure)\n events = sum(self.f4_events)\n event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n weights = [a + b for a, b in zip(*self.f4_weights)]\n peak = max(weights)\n weights = [math.exp(w - peak) for w in weights]\n self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n self.f4_flow = self.f4_rate * self.f4_mean\n if self.s in (2, 3) and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n self.flow_exposure += 1\n self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n lo, hi = cb, ca\n for o in state.own_orders:\n if o.side is Side.BUY:\n lo = max(lo, o.price_ticks)\n else:\n hi = min(hi, o.price_ticks)\n if P['pinf'] > 0:\n sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n ea = self.pa - sa\n eb = self.pb - sb\n if sa and ea:\n lo = max(lo, min(max(ea), hi))\n if eb and (sb or min(eb) <= P['p1t']):\n hi = min(hi, max(min(eb), lo))\n if P['jumpinfo'] > 0 and self.pcb is not None:\n if ca > self.pca + 1:\n lo = max(lo, ca - 1)\n if cb < self.pcb - 1:\n hi = min(hi, cb + 1)\n hitB = hitA = shB = shA = False\n if self.s == 2:\n ids = {o.order_id for o in state.own_orders}\n hitB = bool(self.s2_mb) and not (self.s2_mb & ids)\n hitA = bool(self.s2_ma) and not (self.s2_ma & ids)\n if hitB:\n self.s2_lb = state.step\n if hitA:\n self.s2_la = state.step\n hitB = state.step - self.s2_lb < 1\n hitA = state.step - self.s2_la < 1\n if self.pcb is not None:\n shB = cb < self.pcb - 1\n shA = ca > self.pca + 1\n if self.s in (1, 2, 3):\n retreat_ask = self.pca is not None and ca == self.pca + 1\n retreat_bid = self.pcb is not None and cb == self.pcb - 1\n self.pcb, self.pca = cb, ca\n if lo > hi:\n lo, hi = hi, lo\n # sub-tick belief over p_(t-1): predict with one-step noise, truncate to [lo, hi]\n wid = max(hi - lo, 1e-6)\n nb = max(2, min(48, int(round(wid * P['bins']))))\n cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n if self.bc is None or P['filt'] <= 0:\n ws = [1.0 / nb] * nb\n else:\n sg = max(self.st, 0.6 * wid / nb)\n k = -0.5 / (sg * sg)\n ws = []\n uni = P['uni'] * sg\n if self.s == 4:\n exp = math.exp\n if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n # On this stationary grid, spacing is exactly 1/8 tick.\n # Equal index distances therefore have bit-identical d*d*k.\n # Reuse exp values while retaining the original sum order.\n kernel = []\n c0 = cs[0]\n for ci in self.bc:\n d = c0 - ci\n d2 = d * d * k\n kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n kernel = kernel[:0:-1] + kernel\n for i in range(nb):\n t = uni\n start = nb - 1 - i\n for wi, e in zip(self.bw, kernel[start:start + nb]):\n if e:\n t += wi * e\n ws.append(t)\n else:\n previous = tuple(zip(self.bc, self.bw))\n for c in cs:\n t = uni\n for ci, wi in previous:\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * exp(d2)\n ws.append(t)\n else:\n for c in cs:\n t = uni\n for ci, wi in zip(self.bc, self.bw):\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * math.exp(d2)\n ws.append(t)\n tot = sum(ws)\n ws = [w / tot for w in ws]\n if self.s in (1, 2, 3) and (retreat_ask or retreat_bid):\n retreat_strength = 0.5\n for i, c in enumerate(cs):\n if retreat_ask and not ca - 1 <= c <= ca:\n ws[i] *= 1.0 - retreat_strength\n if retreat_bid and not cb <= c <= cb + 1:\n ws[i] *= 1.0 - retreat_strength\n retreat_total = sum(ws)\n ws = [w / retreat_total for w in ws]\n self.bc, self.bw = cs, ws\n mean_t = sum(c * w for c, w in zip(cs, ws))\n var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n phat = min(max(mean_t / 100.0, 0.002), 0.998)\n var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n sd = math.sqrt(H * var)\n self.tb = self.tb + 1 if hi <= 1 else 0\n if self.tb > 0 and P['zd'] > 0:\n # below the last tick there is no probe: the score keeps walking away from it\n phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n z = inv(phat)\n Z = z * sd\n sp = pdf(z) / sd * P['sig']\n self.st = sp * 100.0\n if FL:\n remaining={o.order_id:o.remaining_quantity for o in state.own_orders} if self.fl_obs else {}\n for px, ci, buying, previous, tick in self.fl_obs:\n qty=max(0.0,sum(q-remaining.get(oid,0.0) for oid,q in previous))\n x=qty*px\n cap=FLOW_CAPS[ci]\n gap=tick/100.0-phat if buying else phat-tick/100.0\n safe=gap>max(0.005,2.0*math.sqrt(var_t)/100.0)\n if 0=cap:\n if safe:\n self.fl_sbins[ci]+=1\n self.fl_exp+=1\n self.fl_dirty=True\n continue\n if safe:\n self.fl_safe_n+=1\n else:\n self.fl_bins[ci]+=1\n self.fl_exp+=1\n self.fl_dirty=True\n if buying:\n self.fl_buy_exp+=1\n else:\n self.fl_sell_exp+=1\n if x>0:\n lx=math.log(x)\n for i,(r,m,parts,norm,tails) in enumerate(FLOW_GRID):\n density=sum(w*pdf((lx-mu)/sg)/sg for mu,sg,w in parts)\n self.fl_scores[i]+=math.log(max(density,1e-100))\n if state.step % 100 == 0 and (self.fl_dirty or state.step==0):\n bins=[(i,n) for i,n in enumerate(self.fl_bins) if n]\n sbins=[(i,n) for i,n in enumerate(self.fl_sbins) if n]\n logs=[score-sum(n*g[3][i] for i,n in bins)-g[0]*self.fl_safe_n+sum(n*g[4][i] for i,n in sbins) for score,g in zip(self.fl_scores,FLOW_GRID)]\n mx=max(logs)\n weights=[math.exp(v-mx) for v in logs]\n den=sum(weights)\n self.fl_dirty=False\n self.fl_rate=sum(w*g[0]*g[1] for w,g in zip(weights,FLOW_GRID))/den\n self.fl_r=sum(w*g[0] for w,g in zip(weights,FLOW_GRID))/den\n self.fl_m=sum(w*g[1] for w,g in zip(weights,FLOW_GRID))/den\n\n s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n lj = P['lam_j']\n\n def AB(x):\n k = (x - phat) / s\n a = s * lpm(k)\n b = a - (x - phat)\n if self.s == 4:\n ja = jb = 0.0\n for p, w in jp:\n if x > p:\n ja += w * (x - p)\n else:\n jb += w * (p - x)\n else:\n ja = sum(w * max(0.0, x - p) for p, w in jp)\n jb = sum(w * max(0.0, p - x) for p, w in jp)\n return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n\n if H == 1:\n def AB(x):\n return (1 - phat) * x, phat * (1 - x)\n rho = P['lam_r'] * 0.5\n mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n kA = P['kL'] if phat < P['pL'] else P['kA']\n\n def qsize(loss, gain, px, flow=False, cap=None):\n loss *= kA\n if gain <= 0:\n return 0.0\n rr = (0.125+0.5*(self.fl_r-0.125)) if flow and FL else rho\n mm = math.log(5.0+0.5*(self.fl_m-5.0))-0.5*P['sig_n']**2 if flow and FL else mu\n tail = loss / (rr * gain)\n if tail >= 1.0:\n return 0.0\n if self.s == 4 and tail <= 1e-6:\n return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\n return min((cap if cap is not None else P['qmax']), math.exp(mm + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n ptk = phat * 100\n def qbid(t):\n if not 1 <= t <= 99:\n return 0.0\n if self.s == 4 and phat * 100 - t < P['dmin']:\n return 0.0\n a, b = AB(t / 100.0)\n if phat * 100 - t < P['dmin']:\n return 0.0\n if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n return 0.0\n if phat < P['pL']:\n ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n if self.s == 3:\n # Subsidize cover only while more stock is needed for remaining retail.\n # Once the whole horizon is covered, use the ordinary bid risk weight.\n flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n if state.yes_inventory >= flow * H / max(ca - 1, ptk + 1) * 100.0:\n a *= P['kA'] / P['kLf']\n return qsize(a, b, max(phat, 0.05))\n\n def qask(t):\n if not 1 <= t <= 99:\n return 0.0\n if self.s == 4 and t - phat * 100 < P['dmin']:\n return 0.0\n a, b = AB(t / 100.0)\n if t - phat * 100 < P['dmin']:\n return 0.0\n if self.s == 4:\n if P['pL'] <= phat <= 0.95:\n b *= 1.4\n tail = b * kA / max(self.f4_rate * a, 1e-30)\n if a <= 0 or tail >= 1.0:\n return 0.0\n return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n return qsize(b, a, t / 100.0, flow=True, cap=(15000 if AH and t == 2 and phat < 0.01 else None))\n\n bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n sticky = P['sticky'] > 0\n def top(orders, comp, step):\n threshold = P['min_ahead']\n if self.s == 3 and step == -1 and 1 <= comp <= 5:\n threshold = max(P['min_ahead'], 20 * 100.0 / comp)\n elif QB and step == 1:\n threshold = PROBE + 0.01\n elif self.s == 2:\n # spread 2: a front order that one ordinary retail buy would use up is not worth holding the quote at the rival's tick\n threshold = max(P['min_ahead'], 400.0 / max(comp, 1))\n elif self.s == 4 and step < 0 and phat < 0.05:\n threshold = 50.0\n if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\n return comp\n return comp + step\n bid_t = top(bids, cb, 1)\n ask_t = top(asks, ca, -1)\n qb = qbid(bid_t)\n qa = qask(ask_t)\n s2f = self.s == 2 and bid_t == cb and qb > 0 and cb / 100.0 < phat\n if self.s == 4 and phat < 0.05 and bid_t >= 2:\n qb *= 0.5\n if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n qa *= 5\n\n Y = state.yes_inventory\n if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n qa = qa if Y >= P['a1'] > 0 else 0.0 # let the competitor's 2-tick ask erode instead of fronting it for nothing\n # ammunition: hold YES so that low asks are covered\n ptick = phat * 100\n amt = 0\n qam = 0.0\n fs1 = max(0.4,min(1.9,1.0+0.5*(self.fl_rate/0.568734-1))) if FL else 1.0\n if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n wealth = state.cash + Y * phat\n x = max(ask_t, ptick + 1) / 100.0\n capw = P['fy'] * wealth / max(phat, 0.005)\n flow_scale = self.f4_flow / 0.6 if self.s == 4 else fs1\n target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n if self.s == 3:\n # Buy routine cover only for the current front ask's desired size.\n target = min(target, qa)\n if self.s == 4:\n # Pay above fair value only for the current retail quote's cover.\n target = min(target, qa)\n full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n g = t - ptick\n if self.s != 3 and Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n amt, qam = t, min(P['qf'], full - Y) # a tick p has just crossed: nearly free\n elif (self.s != 2 or t == 1) and Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n if self.s == 1:\n passive_t = t - 1\n if passive_t >= max(1, bid_t):\n amt, qam = passive_t, min(P['ammo_q'], target - Y)\n else:\n amt, qam = t, min(P['ammo_q'], target - Y)\n elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n amt, qam = t - 1, min(P['qf'], full - Y) # rest just under p: filled only on the crossing, or by retail\n\n if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n q1 = 0.0\n if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n stock_rate = fs1 * P['ydf1']\n if self.s == 4:\n stock_rate *= self.f4_flow / 0.6\n if self.s in (2, 3):\n flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n scale = max(0.5, min(2.0, flow / P['flow_level']))\n stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n\n # Bridge expected retail demand until another tick crossing is available.\n if 0.02 < phat < 0.1:\n ct = max(2, min(99, int(math.floor(ptick))))\n wealth = state.cash + Y * phat\n goal = min(fs1 * qa, 0.3 * max(wealth, 0.0) / phat)\n if Y < goal and ct < ask_t:\n amt, qam = ct, min(3000.0, goal - Y)\n if self.s == 2:\n if hitB:\n qb = 0.0\n qam = 0.0\n q1 = 0.0\n if hitA:\n qa = 0.0\n # order management\n actions = []\n free = state.free_cash - 2.0\n keep_ask = 0.0\n new_b = []\n new_a = []\n def cancel(o):\n nonlocal free\n actions.append(CancelOrder(o.order_id))\n x = o.price_ticks / 100.0\n if o.side is Side.BUY:\n free += x * o.remaining_quantity\n else:\n free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n self.ahead.discard(o.order_id)\n self.res.pop(o.order_id, None)\n for o in state.own_orders:\n if o.remaining_quantity <= PROBE + 1e-9:\n cancel(o)\n kept_ids = set()\n def manage(orders, t, q, comp):\n kept = 0.0\n if self.s == 2:\n buy = comp == cb\n held = {}\n for o in orders:\n x = o.price_ticks\n gain = ptk - x if buy else x - ptk\n # under 10 cents a front order is kept whole for its life: resizing it would give up its place to the rival\n if x == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (x == comp and o.order_id in self.ahead and ptk <= 10.0 and gain >= 0.0)):\n kept += o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n # a small front remainder stays behind the new inside quote: it still fills ahead of the rival on a large retail order\n if x == comp and x != t and o.order_id in self.ahead and gain >= 1.0:\n if x not in held:\n held[x] = [0.0, qbid(x) if buy else qask(x)]\n h = held[x]\n if h[0] + o.remaining_quantity <= max(h[1], 1.0) and h[1] > 0:\n h[0] += o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n cancel(o)\n return kept\n banked = {}\n bound_t, bound_q = t, q\n for o in orders:\n ah = o.order_id in self.ahead\n if AH and ah and o.remaining_quantity >= P['min_ahead'] and o.price_ticks != t:\n if (o.side is Side.SELL and o.price_ticks > t) or (o.side is Side.BUY and o.price_ticks < t):\n enough = bound_q > 0 and (\n o.remaining_quantity <= bound_q if o.side is Side.BUY else\n o.remaining_quantity * o.price_ticks <= min(bound_q, P['qmax']) * bound_t)\n if enough:\n kept_ids.add(o.order_id)\n continue\n if o.price_ticks == bound_t:\n capacity = bound_q\n else:\n capacity = qask(o.price_ticks) if o.side is Side.SELL else qbid(o.price_ticks)\n bound_t, bound_q = o.price_ticks, capacity\n if capacity > 0 and o.remaining_quantity <= max(capacity, 1.0):\n kept_ids.add(o.order_id)\n continue\n if QB and ah and o.side is Side.BUY and o.price_ticks < t and (ptk - o.price_ticks >= P['qb_z'] * 100.0 * s) and banked.get(o.price_ticks, 0.0) + o.remaining_quantity <= P['keep_hi'] * qbid(o.price_ticks):\n banked[o.price_ticks] = banked.get(o.price_ticks, 0.0) + o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n khi = 10.0 if (AH and ah) else (3.0 if (self.s == 4 and o.side is Side.SELL and ah and o.price_ticks == comp) else P['keep_hi'])\n if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * khi, 1.0)\n or (s1 and ah and (o.side is Side.SELL) and o.price_ticks <= 2)\n or (QB and ah and o.side is Side.BUY and o.price_ticks == comp)):\n kept += o.remaining_quantity\n kept_ids.add(o.order_id)\n else:\n cancel(o)\n return kept\n if s2f and 1:\n kb = 0.0\n for o in bids:\n if o.price_ticks == bid_t and o.order_id in self.ahead:\n kb += o.remaining_quantity\n kept_ids.add(o.order_id)\n else:\n cancel(o)\n elif self.s == 2 and 1 and bid_t == cb + 1:\n qf = qbid(cb) if 1 else 1.0\n fr = [o for o in bids if o.price_ticks == cb and o.order_id in self.ahead and cb / 100.0 < phat - 0.0 and qf > 0]\n for o in fr:\n kept_ids.add(o.order_id)\n kb = manage([o for o in bids if o not in fr], bid_t, qb, cb)\n else:\n kb = manage(bids, bid_t, qb, cb)\n ka = manage(asks, ask_t, qa, ca)\n add_b = (qb - kb) if (kb < qb * (1.0 if self.s in (1, 3, 4) else P['keep_lo']) and bid_t != cb) else 0.0\n add_a = (qa - ka) if (ka < qa * (1.0 if self.s in (1, 3, 4) else P['keep_lo']) and ask_t != ca) else 0.0\n\n budget = P['fb'] * max(free, 0.0)\n cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n if cost > budget:\n f = budget / cost\n add_b *= f\n qam *= f\n cost = budget\n out = []\n q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n if q1 >= 0.01:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n free -= fl(q1) / 100.0 + 1e-6\n if amt and qam >= 0.01:\n q = fl(qam)\n if QB:\n oid = self._oid('m')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n if amt > cb:\n self.ahead.add(oid)\n else:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n free -= q * amt / 100.0 + 1e-6\n if bid_t >= 1 and add_b >= 0.01:\n q = fl(add_b)\n total_q = q\n if self.s == 4 and ca <= 99 and bid_t > cb and bid_t == ca - 4 and q >= 4.0 and q * bid_t / 100 >= 4 * P['m']:\n head = fl(q / 2)\n oid = self._oid('b')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=head, client_order_id=oid))\n self.ahead.add(oid)\n q = fl(q - head)\n oid = self._oid('b')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n free -= total_q * bid_t / 100.0 + 1e-6\n if bid_t > cb:\n self.ahead.add(oid)\n if ask_t <= 99 and add_a >= 0.01:\n x = ask_t / 100.0\n covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n for o in asks if o.order_id in kept_ids)\n cov = max(0.0, Y - covk - 0.1)\n unc = max(0.0, add_a - cov)\n if unc > 0:\n ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n if H < P['Hu'] and phat < 0.05:\n ub = max(0.0, free * (1 - H / P['Hu']))\n unc = min(unc, ub / (1 - x))\n q = fl(min(add_a, cov + unc))\n if q >= 0.01:\n oid = self._oid('a')\n out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n r = max(0.0, q - cov)\n self.res[oid] = r\n free -= r * (1 - x) + 1e-6\n if ask_t < ca:\n self.ahead.add(oid)\n\n # probes: tiny orders that the arbitrageur removes when p crosses them\n f = int(math.floor(ptick + 1e-9))\n r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n self.pb = set()\n self.pa = set()\n if free > 1.0:\n for t in range(f, f + r + 1):\n if cb < t < ca and 1 <= t <= 99:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n self.pb.add(t)\n for t in range(f + 1 - r, f + 2):\n if cb < t < ca and 1 <= t <= 99:\n out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n self.pa.add(t)\n if self.s in (2, 3):\n self.last_ask_tick = ask_t\n self.last_flow_ca = ca\n exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n self.last_flow_cap = exposed_qty * ask_t / 100.0\n self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n if self.last_quote_exposed:\n logcap = math.log(self.last_flow_cap)\n mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n if self.s == 1:\n split_out = []\n for order in out:\n oid = order.client_order_id\n if (order.side is Side.SELL and oid is not None and oid.startswith('a')\n and order.price_ticks >= 3 and order.price_ticks < 99):\n back = fl(order.quantity * 0.5)\n front = fl(order.quantity - back)\n reserve = self.res.pop(oid, 0.0)\n front_reserve = max(0.0, reserve - back)\n if front >= 0.01:\n split_out.append(PlaceOrder(side=Side.SELL, price_ticks=order.price_ticks, quantity=front, client_order_id=oid))\n self.res[oid] = front_reserve\n if back >= 0.01:\n back_id = self._oid('a')\n split_out.append(PlaceOrder(side=Side.SELL, price_ticks=order.price_ticks + 1, quantity=back, client_order_id=back_id))\n self.res[back_id] = max(0.0, reserve-front_reserve)\n else:\n split_out.append(order)\n out = split_out\n if FL:\n if not kept_ids and not any(o.quantity>PROBE for o in out):\n self.fl_obs=()\n self.fl_ahead.clear()\n return actions+out\n # Give stock orders explicit ids so per-order remaining quantities\n # separate their fills from other bid levels and tiny probes.\n for i,o in enumerate(out):\n if o.client_order_id is None and o.quantity>PROBE:\n out[i]=PlaceOrder(side=o.side,price_ticks=o.price_ticks,quantity=o.quantity,client_order_id=self._oid('f'))\n live=[]\n oldids={o.order_id for o in state.own_orders if o.order_id in kept_ids}\n self.fl_ahead.intersection_update(oldids)\n for o in state.own_orders:\n if o.order_id in kept_ids and o.remaining_quantity>PROBE:\n live.append((o.side,o.price_ticks,o.remaining_quantity,o.order_id))\n for o in out:\n if o.quantity>PROBE:\n live.append((o.side,o.price_ticks,o.quantity,o.client_order_id))\n if (o.side is Side.SELL and o.price_tickscb):\n self.fl_ahead.add(o.client_order_id)\n obs=[]\n for buying,side,comp in ((True,Side.SELL,ca),(False,Side.BUY,cb)):\n orders=[o for o in live if o[0] is side]\n if not orders:\n continue\n tick=min(o[1] for o in orders) if buying else max(o[1] for o in orders)\n orders=[o for o in orders if o[1]==tick]\n if not all(o[3] in self.fl_ahead for o in orders):\n continue\n if (buying and tick>comp) or (not buying and tick cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n continue\n if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n continue\n orders = bids\n order_side = Side.BUY\n tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n cap = sum(tracked.values()) * conv\n if cap >= 0.5:\n self.f4_last[side] = (tick, conv, cap, bound, tracked)\n if self.s == 2:\n self.s2_mb = {o.order_id for o in bids if o.order_id in kept_ids} | {o.client_order_id for o in out if o.side is Side.BUY and o.client_order_id}\n self.s2_ma = {o.order_id for o in asks if o.order_id in kept_ids} | {o.client_order_id for o in out if o.side is Side.SELL and o.client_order_id}\n return actions + out\n\n\n_N = Strategy\n\nimport dataclasses as _dc\nfrom orderbook_pm_challenge.types import PlaceOrder as _PO, Side as _Sd\n\n\nclass Strategy(BaseStrategy):\n ACT = (1,)\n M = 4\n JUMP = 2.0\n ON = True\n\n def __init__(self, *a, **k):\n super().__init__(*a, **k)\n self._n = _N(*a, **k)\n self._s = None\n self._pm = None\n self._dis = 0\n self._lo = 0\n self._hi = 0\n self._dir = 0\n self._pd = 0.05\n\n def on_step(self, state):\n acts = self._n.on_step(state)\n b, a = state.competitor_best_bid_ticks, state.competitor_best_ask_ticks\n self.s = self._n.s\n self._s = self.s\n if not self.ON or self._s not in self.ACT or b is None or a is None:\n return acts\n mid = (a + b) / 2.0\n pm = self._pm\n self._pm = mid\n if pm is None:\n return acts\n mv = mid - pm\n fb, fs = state.buy_filled_quantity, state.sell_filled_quantity\n # two-state filter: likelihood-ratio update on quote move and own fills\n ev = abs(mv) / self.JUMP + (0.5 if (fs > 0 and mv > 0) or (fb > 0 and mv < 0) else 0.0)\n p = self._pd\n lr = 2.718281828 ** (3.0 * (ev - 1.0))\n p = p * lr / (p * lr + (1 - p))\n self._pd = min(0.95, max(0.01, 0.9 * p + 0.01))\n if p > 0.5 and abs(mv) >= 1:\n self._dis = self.M\n self._dir = 1 if mv > 0 else -1\n self._lo = min(pm, mid)\n self._hi = max(pm, mid)\n elif self._dis > 0:\n if abs(mv) >= 1 and (mv > 0) == (self._dir > 0):\n self._lo = min(self._lo, mid)\n self._hi = max(self._hi, mid)\n self._dis = self.M\n else:\n self._dis -= 1\n if self._dis <= 0:\n return acts\n out = []\n for x in acts:\n if isinstance(x, _PO):\n pr = x.price_ticks\n if self._dir > 0 and x.side == _Sd.SELL and pr <= self._hi + self._s:\n continue\n if self._dir < 0 and x.side == _Sd.BUY and pr >= self._lo - self._s:\n continue\n out.append(x)\n return out\n\n\n_CancelBase = Strategy\n\nclass Strategy(_CancelBase):\n def __init__(self):\n super().__init__()\n self._retreat_previous = (None, None)\n\n def on_step(self, state):\n bid, ask = state.competitor_best_bid_ticks, state.competitor_best_ask_ticks\n old_bid, old_ask = self._retreat_previous\n self._retreat_previous = (bid, ask)\n actions = super().on_step(state)\n core = getattr(self, '_n', self)\n if core.s not in (3, 4):\n return actions\n blocked = set()\n if bid is not None and old_bid is not None and bid == old_bid - 1:\n blocked.add(Side.BUY)\n if ask is not None and old_ask is not None and ask == old_ask + 1:\n blocked.add(Side.SELL)\n if not blocked:\n return actions\n out = []\n withheld_ids = set()\n for action in actions:\n if isinstance(action, PlaceOrder) and action.side in blocked:\n withheld_ids.add(action.client_order_id)\n else:\n out.append(action)\n canceled = {a.order_id for a in out if isinstance(a, CancelOrder)}\n for order in state.own_orders:\n if order.side in blocked:\n withheld_ids.add(order.order_id)\n if order.order_id not in canceled:\n out.append(CancelOrder(order.order_id))\n core.ahead.difference_update(withheld_ids)\n core.fl_ahead.difference_update(withheld_ids)\n for oid in withheld_ids:\n core.res.pop(oid, None)\n if Side.BUY in blocked:\n core.pb.clear()\n core.s2_mb.clear()\n if Side.SELL in blocked:\n core.pa.clear()\n core.s2_ma.clear()\n core.last_quote_exposed = False\n if core.s == 1:\n core.fl_obs = [obs for obs in core.fl_obs\n if (Side.SELL if obs[2] else Side.BUY) not in blocked]\n if core.s == 4:\n if Side.SELL in blocked:\n core.f4_last[0] = None\n if Side.BUY in blocked:\n core.f4_last[1] = None\n return out\n", "code_sha256": "abb152716f4e3db6981c84b61df1bd38e1365273a6afa44c76bc8de6888a28fd", "tried": ["Calibration: requested CLI, 600 seeds 1000..1599, workers=4, no sandbox; mean=108.63974289615767; elapsed=123.30325834196992s.", "Calibration finished within five minutes; all requested run counts retained.", "deadband spread 1: kept; paired first/second half gains 1.0139993693862501, 2.89512063158425.", "deadband spread 3: kept; paired first/second half gains 1.0038792547347506, 0.22159318760650001.", "deadband spread 4: kept; paired first/second half gains 0.48532049053924986, 0.48357986889224847.", "premium spread 4: rejected; paired first/second half gains -0.8362005056520003, -0.2699421515907495.", "postjump spread 1: kept; paired first/second half gains 0.0020865339904996925, 0.3504328334665.", "cross spread 1: kept; paired first/second half gains 1.0607474269100006, 0.15202080774449975.", "cross spread 2: kept; paired first/second half gains 0.5257728375702497, 0.520219275732249.", "cross spread 3: kept; paired first/second half gains 0.20804995107249916, 0.23256151394424865.", "cancel spread 1: rejected; paired first/second half gains -1.7236403204212507, -1.584360305957.", "cancel spread 2: rejected; paired first/second half gains -0.23946692572349956, 0.4540103421670006.", "cancel spread 3: kept; paired first/second half gains 0.6754262862287504, 0.6826720148337506.", "cancel spread 4: kept; paired first/second half gains 0.47754905986774987, 0.5618791103185011.", "Compared supplied change files as text against the older file; carried changes by hand onto start, retaining its eight fixes. Cut excluded. Cross used only spreads 1, 2, 3.", "Cancel tested all four spreads for exactly one callback; all placements suppressed on retreated side, all resting orders there canceled; affected s2_mb/s2_ma, pb/pa, last_quote_exposed, fl_obs/f4_last, ahead/res/fl_ahead memories cleared.", "Postjump includes both internal qb_z=4.0/banked-order guard and supplied two-state wrapper M=4, JUMP=2.0 unchanged.", "Frozen code before holdout; paired seeds 170000..172999, no seed recognition or parameter tuning. Timing uses 200 consecutive holdout seeds per file, serially in one process.", "Simulator revision b244530ee2a6247b5f930830eeca9dd950da0e7e; dependency-free Python simulator; all nine downloaded source code hashes matched their embedded SHA-256 values.", "All-patches cancel audit checked every blocked placement, resting-order cancellation, and affected probe/flow/main-order memory over retreat callbacks by spread: {\"1\": 328, \"2\": 296, \"3\": 178, \"4\": 193}. No assertion or simulation failed.", "Step 3: every spread retained at least one change, so no spread requires the conditional 100-run untouched-spread equality proof."], "next": "Operator may enter the code directly. Holdout differences are paired versus the supplied start, not the older file. Standard errors are sample standard deviation of paired edge differences divided by sqrt(n). No dependencies beyond simulator and Python standard library; no missing inputs or fabricated data. Spread 1 has a negative holdout difference; the frozen file was not retuned after holdout. Consult by_spread for paired means and uncertainties."}