{ "approach": "Start file (149883fe...) with four changes carried by hand from their files' diffs against the older file db22aff7..., each gated to its spreads through one ON table: cancel (2d4b30bb..., one-callback cancel of the side whose rival quote retreated one tick, with s2_mb/s2_ma, pb/pa, last_quote_exposed, fl_obs entries and f4_last cleared for the withheld side), cut (02547689..., belief weight x0.016 on the stale side after a one-tick retreat) in place of cross, postjump (6a27972e..., spread 1 jump-withhold wrapper plus its qb_z=4 bank condition) and deadband (keep_lo replaced by 1 in add_b/add_a). Changes were added one at a time in the order cancel, cut, postjump, premium, deadband, each measured run by run against the file without it on the first runs of its spread from seed 150000 and kept only if it gained on both halves. Kept: cancel in 2,3,4; cut in 1,4; postjump in 1; deadband in 3. Every change uses its own constants; nothing tuned.", "blocked": null, "base_mean_edge": 108.63974289615767, "changes": [ { "name": "cancel", "spread": 1, "kept": false, "runs": 60, "gain": 0.912588575606668, "standard_error": 1.0493186178104663, "retail": -1.7338664543033342, "arb": 2.6464550298849994, "first_half": 1.8504373306966673, "second_half": -0.025260179483331424 }, { "name": "cancel", "spread": 2, "kept": true, "runs": 60, "gain": 1.7241506522416679, "standard_error": 0.8508291643695077, "retail": 1.034481544791668, "arb": 0.6896691074616667, "first_half": 1.7231918929466687, "second_half": 1.7251094115366667 }, { "name": "cancel", "spread": 3, "kept": true, "runs": 60, "gain": 1.1617802122516652, "standard_error": 0.29938730641386047, "retail": -0.04863847847000121, "arb": 1.21041869082, "first_half": 1.346240607236664, "second_half": 0.9773198172666665 }, { "name": "cancel", "spread": 4, "kept": true, "runs": 60, "gain": 0.6617967417166656, "standard_error": 0.22242217525405508, "retail": -0.02683471165666577, "arb": 0.6886314533916671, "first_half": 1.0164235693233301, "second_half": 0.30716991411000105 }, { "name": "cut", "spread": 1, "kept": true, "runs": 60, "gain": 0.9117586711700002, "standard_error": 0.4251210842263569, "retail": -0.510408328808334, "arb": 1.4221669999816662, "first_half": 0.28717695470333504, "second_half": 1.5363403876366653 }, { "name": "cut", "spread": 2, "kept": false, "runs": 60, "gain": -1.2971878382733377, "standard_error": 2.6816372309720675, "retail": 1.8969880253783336, "arb": -3.1941758636916666, "first_half": -0.4241754506633358, "second_half": -2.17020022588334 }, { "name": "cut", "spread": 3, "kept": false, "runs": 60, "gain": -0.23459444702499632, "standard_error": 0.3859650793386757, "retail": 0.5263163979283362, "arb": -0.7609108449299999, "first_half": -0.32447757890999623, "second_half": -0.14471131513999644 }, { "name": "cut", "spread": 4, "kept": true, "runs": 60, "gain": 0.5905774347783339, "standard_error": 0.6274541668332343, "retail": 0.7298697114799996, "arb": -0.13929227675333364, "first_half": 0.9316647218533332, "second_half": 0.24949014770333464 }, { "name": "postjump", "spread": 1, "kept": true, "runs": 60, "gain": 0.13345613000500148, "standard_error": 0.07131413520148466, "retail": -0.012568258224999823, "arb": 0.1460243882333334, "first_half": 0.12100198562666692, "second_half": 0.14591027438333606 }, { "name": "premium", "spread": 4, "kept": false, "runs": 60, "gain": -0.35600951898, "standard_error": 0.5583322931519599, "retail": 0.9706088759133321, "arb": -1.3266183948699999, "first_half": -0.46798300992000075, "second_half": -0.24403602803999921 }, { "name": "deadband", "spread": 1, "kept": false, "runs": 60, "gain": 0.050356702149999516, "standard_error": 0.5076424483829126, "retail": 0.6246615921800008, "arb": -0.5743048900433337, "first_half": -0.03982325857333354, "second_half": 0.14053666287333258 }, { "name": "deadband", "spread": 3, "kept": true, "runs": 60, "gain": 0.9500827070633351, "standard_error": 0.5006065463763689, "retail": 1.3851087364183334, "arb": -0.4350260293583333, "first_half": 1.6958125560000001, "second_half": 0.20435285812667 }, { "name": "deadband", "spread": 4, "kept": false, "runs": 60, "gain": 1.5407141468383345, "standard_error": 0.9306944486442865, "retail": 2.8290632546399985, "arb": -1.2883491077566667, "first_half": -0.6817542714399994, "second_half": 3.7631825651166686 } ], "by_spread": { "spread1": { "runs": 259, "mean": 1.399831089200387, "standard_error": 0.7481366645019447, "retail": -2.6003472166150585, "arb": 4.000178305783399 }, "spread2": { "runs": 225, "mean": 0.6261861045968888, "standard_error": 0.1840136725526742, "retail": -0.41990643432400016, "arb": 1.046092538943111 }, "spread3": { "runs": 260, "mean": 1.1310493997976931, "standard_error": 0.5088232350536973, "retail": 1.4952188650223068, "arb": -0.3641694652319224 }, "spread4": { "runs": 256, "mean": 1.6767606350285167, "standard_error": 1.022897235587338, "retail": 0.26243684334882766, "arb": 1.414323791637891 } }, "holdout": { "mean_edge": 90.9320907272175, "retail_edge": 114.5758009690896, "arb_edge": -23.6437102419399, "failures": 0 }, "diff": { "mean": 1.2267716921519007, "standard_error": 0.3537142508992249, "retail": -0.3120281400231005, "arb": 1.5387998321591005 }, "seconds": { "start": 157.1656849384308, "yours": 160.84521317481995 }, "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\nON = dict(cancel=(2, 3, 4), cut=(1, 4), postjump=(1,), premium=(), deadband=(3,))\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})\n if 1 in ON['postjump']:\n self.params['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 retreat_ask = retreat_bid = False\n if P['jumpinfo'] > 0 and self.pcb is not None:\n if self.s in ON['cut']:\n retreat_ask = ca == self.pca + 1\n retreat_bid = cb == self.pcb - 1\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 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 retreat_ask or retreat_bid:\n ws = [weight * (0.016 if retreat_ask and c < ca - 1 else 1.0)\n * (0.016 if retreat_bid and c > cb + 1 else 1.0)\n for c, weight in zip(cs, ws)]\n tot = sum(ws)\n ws = [weight / tot for weight 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 4 not in ON['premium'] and 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 ('qb_z' not in P or 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 dbk = 1.0 if self.s in ON['deadband'] else P['keep_lo']\n add_b = (qb - kb) if (kb < qb * dbk and bid_t != cb) else 0.0\n add_a = (qa - ka) if (ka < qa * dbk 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_IncumbentStrategy = Strategy\n\nclass Strategy(_IncumbentStrategy):\n \"\"\"cancel: for one callback after the rival's bid falls (ask rises) exactly one tick, cancel that side and place nothing there.\"\"\"\n def __init__(self):\n super().__init__()\n self._retreat_previous = (None, None)\n self._retreat_left = {Side.BUY: 0, Side.SELL: 0}\n\n def on_step(self, state):\n bid = state.competitor_best_bid_ticks\n ask = 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 if self.s not in ON['cancel']:\n return actions\n for side, retreat in (\n (Side.BUY, bid is not None and old_bid is not None and bid == old_bid - 1),\n (Side.SELL, ask is not None and old_ask is not None and ask == old_ask + 1),\n ):\n if retreat:\n self._retreat_left[side] = 1\n blocked = {side for side, left in self._retreat_left.items() if left > 0}\n for side in blocked:\n self._retreat_left[side] -= 1\n if not blocked:\n return actions\n out = []\n for action in actions:\n if isinstance(action, PlaceOrder) and action.side in blocked:\n self.ahead.discard(action.client_order_id)\n self.res.pop(action.client_order_id, None)\n else:\n out.append(action)\n canceled = {a.order_id for a in out if isinstance(a, CancelOrder)}\n out.extend(CancelOrder(o.order_id) for o in state.own_orders\n if o.side in blocked and o.order_id not in canceled)\n # Forget everything held about the withheld side, so our own cancels are not read as fills or hits.\n if Side.BUY in blocked:\n self.pb.clear()\n self.s2_mb = set()\n self.fl_obs = tuple(x for x in self.fl_obs if x[2])\n if self.s == 4:\n self.f4_last[1] = None\n if Side.SELL in blocked:\n self.pa.clear()\n self.s2_ma = set()\n self.last_quote_exposed = False\n self.fl_obs = tuple(x for x in self.fl_obs if not x[2])\n if self.s == 4:\n self.f4_last[0] = None\n return out\n\n\n_N = Strategy\n\n\nclass Strategy(BaseStrategy):\n \"\"\"postjump (spread 1): after a likely jump in the rival's quotes, withhold quotes on the side the jump runs toward for a few callbacks.\"\"\"\n M = 4\n JUMP = 2.0\n\n def __init__(self, *a, **k):\n super().__init__(*a, **k)\n self._n = _N(*a, **k)\n self.s = None\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 self._s not in ON['postjump'] 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 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, PlaceOrder):\n pr = x.price_ticks\n if self._dir > 0 and x.side == Side.SELL and pr <= self._hi + self._s:\n continue\n if self._dir < 0 and x.side == Side.BUY and pr >= self._lo - self._s:\n continue\n out.append(x)\n return out\n", "code_sha256": "9fba1eb5659d5b0ac9b7273a968a520ef9a95551c697be22020993005af70192", "tried": [ "Step 1: earlier file 40497298... on 600 runs from seed 1000, 4 workers: mean edge 108.63974289615767, matching the expected 108.63974289615767 exactly; took 2m20s.", "With all flags off the carried file gave the start file's exact total_edge on 8 checked runs (2 per spread) before measuring.", "Run counts were cut because of time, not the 5-minute rule: the machine was shared (load average about 33 on 8 cores), two 10-minute attempts at the 800-run stages were killed, so each change was measured on the first 60 runs of its spread from seed 150000 (not 800) and the holdout used seeds 170000-170999 (1000 runs, not 3000). Halves are runs 1-30 and 31-60.", "cancel: kept in spreads 2,3,4; dropped in 1 (second half -0.025).", "cut (instead of cross): kept in 1 and 4; dropped in 2 and 3 (both halves negative).", "postjump (spread 1): kept, small but positive on both halves.", "premium (spread 4): dropped, negative on both halves.", "deadband: kept in 3; dropped in 1 (first half -0.04) and 4 (first half -0.68).", "Step 3: every spread keeps at least one change, so no spread had to reproduce the start file exactly; the all-flags-off check above is the only exactness check run.", "Step 4: frozen file vs start file on seeds 170000-170999 run by run: start mean 89.7053190350656, yours 90.9320907272175, 0 failures. Timing was 200 runs of each in one process, the two files running at the same time on separate processes." ], "next": "The keep decisions rest on 60 runs per spread, so their standard errors are large (cut in spread 1 and cancel in spread 3 have the clearest gains); rerunning the stages on the full 800 runs of each spread and the holdout on 3000 seeds would firm them up. The overall holdout gain is 1.227 +/- 0.354 per run over 1000 seeds." }