{"approach":"In spread 4 only, remove the main-bid stock-building loss discount when YES inventory already meets the existing ytg stock target. Keep the original discount during a stock shortage and use the existing normal low-probability risk weight otherwise. The ledger identified main bids as the largest absolute arbitrage-loss source, with low-priced bids earning much less retail edge per arbitrage dollar lost than low asks. An ablation of the stock rule with the worst direct loss/retail ratio failed validation, demonstrating why subsequent ask revenue matters. The selected main-bid guard gained on both choosing halves without changing any constants. All behavior changes require self.s == 4.","blocked":null,"spread":4,"base_mean_edge":108.63974289615767,"found":["main_bid: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-9.918823549258281,\"arb_loss_per_retail_edge\":0.2290334852683477,\"jump_arb_edge\":-4.167887582829506,\"jump_retail_edge\":0.13458988446347106,\"median_run_arb_loss\":7.221487172685386,\"plain_arb_edge\":-5.750935966428775,\"plain_retail_edge\":43.17271750614304,\"retail_edge\":43.30730739060651,\"runs_with_arb_loss\":2050,\"top20_runs_share_of_loss\":0.05306720547616472,\"worst_run_arb_loss\":70.0143677986834}","main_ask: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-8.4522052438144,\"arb_loss_per_retail_edge\":0.0857009007985836,\"jump_arb_edge\":-6.164592675866616,\"jump_retail_edge\":0.2367113028752917,\"median_run_arb_loss\":2.9676862300480513,\"plain_arb_edge\":-2.287612567947785,\"plain_retail_edge\":98.38775080959404,\"retail_edge\":98.62446211246933,\"runs_with_arb_loss\":2045,\"top20_runs_share_of_loss\":0.27708978913961196,\"worst_run_arb_loss\":899.1714908707313}","front_ask_held_at_rival: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-2.123710773245284,\"arb_loss_per_retail_edge\":0.05664436781886937,\"jump_arb_edge\":-1.9788013456121343,\"jump_retail_edge\":0.08690616187650478,\"median_run_arb_loss\":0.03256103672994373,\"plain_arb_edge\":-0.14490942763314973,\"plain_retail_edge\":37.40509622106532,\"retail_edge\":37.49200238294183,\"runs_with_arb_loss\":1282,\"top20_runs_share_of_loss\":0.3883105256941244,\"worst_run_arb_loss\":158.2905949963981}","stock_tick1: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.7524098694591446,\"arb_loss_per_retail_edge\":6.925264325338248,\"jump_arb_edge\":-0.4622530514529669,\"jump_retail_edge\":0.0,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":-0.29015681800617765,\"plain_retail_edge\":0.10864709765751719,\"retail_edge\":0.10864709765751719,\"runs_with_arb_loss\":417,\"top20_runs_share_of_loss\":0.4613433460195099,\"worst_run_arb_loss\":70.02110805309226}","stock_cross_above: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.3985812477742958,\"arb_loss_per_retail_edge\":50.774291464401024,\"jump_arb_edge\":-0.006869204251186337,\"jump_retail_edge\":0.0,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":-0.3917120435231095,\"plain_retail_edge\":0.007850060262362301,\"retail_edge\":0.007850060262362301,\"runs_with_arb_loss\":347,\"top20_runs_share_of_loss\":0.2027557138956587,\"worst_run_arb_loss\":12.911707413916382}","stock_ammo_above: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.8270814958183706,\"arb_loss_per_retail_edge\":65.59627558817472,\"jump_arb_edge\":-0.003452448207085603,\"jump_retail_edge\":0.0038740441391265615,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":-0.8236290476112851,\"plain_retail_edge\":0.008734621343818505,\"retail_edge\":0.012608665482945066,\"runs_with_arb_loss\":485,\"top20_runs_share_of_loss\":0.3755075798245684,\"worst_run_arb_loss\":72.62226086920285}","stock_cross_below: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.2797686120955878,\"arb_loss_per_retail_edge\":0.7860354216081584,\"jump_arb_edge\":-0.019125795311216182,\"jump_retail_edge\":0.00021901046309916322,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":-0.2606428167843716,\"plain_retail_edge\":0.35570465964734715,\"retail_edge\":0.35592367011044634,\"runs_with_arb_loss\":371,\"top20_runs_share_of_loss\":0.20079433302592206,\"worst_run_arb_loss\":10.65979198596036}","stock_bridge: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.6888098521043636,\"arb_loss_per_retail_edge\":2.7139755463258255,\"jump_arb_edge\":-0.057483764536616216,\"jump_retail_edge\":0.0001240107551902196,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":-0.6313260875677474,\"plain_retail_edge\":0.2536770424771696,\"retail_edge\":0.2538010532323598,\"runs_with_arb_loss\":873,\"top20_runs_share_of_loss\":0.12299237964624579,\"worst_run_arb_loss\":16.461868003485165}","stock_pre: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":0.0,\"jump_arb_edge\":0.0,\"jump_retail_edge\":0.0,\"median_run_arb_loss\":-0.0,\"plain_arb_edge\":0.0,\"plain_retail_edge\":0.0,\"retail_edge\":0.0,\"runs_with_arb_loss\":0,\"worst_run_arb_loss\":-0.0}","probe_bid: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.37706082292880805,\"arb_loss_per_retail_edge\":23.135885672431986,\"jump_arb_edge\":-0.004586843027178889,\"jump_retail_edge\":0.0005100890720311086,\"median_run_arb_loss\":0.40449251858540614,\"plain_arb_edge\":-0.37247397990162917,\"plain_retail_edge\":0.01578757198436416,\"retail_edge\":0.01629766105639527,\"runs_with_arb_loss\":2050,\"top20_runs_share_of_loss\":0.01534451516697603,\"worst_run_arb_loss\":0.6215923439352817}","probe_ask: per-run mean dollars on 2050 spread-4 choosing runs; {\"arb_edge\":-0.37422574050643265,\"arb_loss_per_retail_edge\":22.88440127216055,\"jump_arb_edge\":-0.004655837453683765,\"jump_retail_edge\":0.0004674537066026368,\"median_run_arb_loss\":0.409952419450842,\"plain_arb_edge\":-0.3695699030527489,\"plain_retail_edge\":0.015885420727638634,\"retail_edge\":0.01635287443424127,\"runs_with_arb_loss\":2050,\"top20_runs_share_of_loss\":0.015485264107397284,\"worst_run_arb_loss\":0.6352991004503471}","main_bid under5c (subset of main_bid, not additional): {\"jump_arb_edge\":-0.4004999210873523,\"jump_retail_edge\":0.02729704645375253,\"plain_arb_edge\":-3.0757395193913717,\"plain_retail_edge\":5.987393417127407}","main_bid 5cplus (subset of main_bid, not additional): {\"jump_arb_edge\":-3.7673876617421533,\"jump_retail_edge\":0.10729283800971853,\"plain_arb_edge\":-2.675196447037404,\"plain_retail_edge\":37.18532408901563}","Ledger totals: {\"arb_edge\":-24.192677207045367,\"failures\":0,\"jump_arb_edge\":-12.86970854854819,\"jump_retail_edge\":0.46340195735131723,\"jump_steps\":3.80390243902439,\"n\":2050,\"plain_arb_edge\":-11.32296865845678,\"plain_retail_edge\":179.7318510109026,\"plain_steps\":1996.1960975609757,\"retail_edge\":180.19525296825492,\"total_edge\":156.00257576121712}","Attribution: main_ask means a main sell quote; front_ask_held_at_rival is its kept-ahead portion when the rival best ask reaches its tick. Stock tags record the final branch that generated the buy, after the bridge override; stock_pre is disabled. Jump means an actual positive Poisson jump count, not an inferred price-move threshold. Ledger edges use the post-move probability. Direct stock-buy edge excludes subsequent ask revenue, so it is not the causal value of stock-building."],"holdout":{"mean_edge":157.43713114219602,"retail_edge":183.2706512570302,"arb_edge":-25.833520114846824,"failures":0},"diff":{"mean":0.5808840586829631,"standard_error":0.04835727476297392,"retail":-0.07850187361177052,"arb":0.6593859322964378,"trimmed":0.5820531944625457,"runs_up":809,"runs_down":162},"others_identical":{"runs":900,"identical":true},"seconds":{"start":128.82859911303967,"yours":128.5911680147983},"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\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\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                # 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(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\n            if self.s == 1:\n                self.params.update({'dmin': 0.3, 'pfl': 1e-06})\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        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 == 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        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        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        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):\n            loss *= kA\n            if gain <= 0:\n                return 0.0\n            tail = loss / (rho * 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(P['qmax'], math.exp(mu + 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                if self.s != 4 or state.yes_inventory < ytg:\n                    a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\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                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            if self.s == 2 and phat < 0.1:\n                a = max(0.0, a - 0.0015 * (1 - min(1.0, state.yes_inventory / 3000.0)))\n            return qsize(b, a, t / 100.0)\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 = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else P['min_ahead']\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        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        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 1.0\n            target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\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 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 Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\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 = P['ydf1']\n            if self.s == 4:\n                stock_rate *= self.f4_flow / 0.6\n            if self.s == 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(1 * 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        # 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            for o in orders:\n                if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\n                    kept += o.remaining_quantity\n                    kept_ids.add(o.order_id)\n                else:\n                    cancel(o)\n            return kept\n        kb = manage(bids, bid_t, qb, cb)\n        ka = manage(asks, ask_t, qa, ca)\n        add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n        add_a = (qa - ka) if (ka < qa * 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            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            oid = self._oid('b')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n            free -= 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                if self.s == 2:\n                    ub = min(ub, max(0.0, free - 200 * min(1.0, H / 50.0)))\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 == 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 == 4:\n            self.f4_last = [None, None]\n            # Eligibility is decided before observing fills, so depleted quotes\n            # remain in the sample as right-censored observations.\n            for side, tick, bound, conv, distance in (\n                (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n                (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n                if distance < max(0.01, 3.0 * self.st / 100.0):\n                    continue\n                if side == 0:\n                    if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n                        continue\n                    orders = asks\n                    order_side = Side.SELL\n                else:\n                    if not (bid_t > 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        return actions + out\n","code_sha256":"09200bce41ecb807a03a721f444d2f1012e465aed55e49fbe0d3e91441392ead","tried":["Scorer: python3 -m orderbook_pm_challenge run ../earlier.py --simulations 600 --seed-start 1000 --workers 4 --json; no sandbox; Python 3.12.3; mean_edge=108.63974289615767; failures=0; matches author exactly; completed below 5 minutes; no counts halved.","Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e, no third-party dependencies. Select seeds using unmodified sample_config(ChallengeConfig(),ParameterVariance(),seed=N).competitor.spread_ticks. Choosing: every spread-4 seed in [30000,38000), n=2050; first 1025 are discovery, remaining 1025 are validation. Confirming: every spread-4 seed in [90000,98000), n=1937.","Logging-only scratch strategy tags action identities without changing order IDs. Hooks call original placement and scoring, and observe the original Poisson sampler without extra RNG draws. All 2050 instrumented runs match all fields of the unmodified SimulationResult exactly; each per-run total/retail/arb ledger reconciles within 1e-7. No strategy reads jump labels, true probability, seeds, or simulator internals.","Input strategy SHA256=4bbf720ff34be09b441e84a7e0c1bf47cba036b5211c4118e44a597f941453db. Choosing start file: {\"arb_edge\":-24.192677207045367,\"failures\":0,\"n\":2050,\"retail_edge\":180.19525296825492,\"total_edge\":156.00257576121712}","Main-bid flow sizing: reuse existing spread-4 f4_rate and log(f4_mean)-0.5*sig_n**2 for qsize; asks already use those estimates. Discovery n=1025; {\"arb\":0.720102806979122,\"mean\":0.6208593750787328,\"retail\":-0.09924343189385387,\"runs_down\":503,\"runs_up\":522,\"standard_error\":0.15171891494078138,\"trimmed\":0.47733567347104583}; failures=0","Main-bid surplus correction: skip the low-probability stock-building loss discount when self.s==4 and inventory>=ytg; preserve it for a stock shortfall. Discovery n=1025; {\"arb\":0.5811755500622439,\"mean\":0.5148347559681953,\"retail\":-0.06634079409443927,\"runs_down\":80,\"runs_up\":404,\"standard_error\":0.0770717066648967,\"trimmed\":0.5388632752133335}; failures=0","Above-value ammunition ablation: add self.s != 4 to the generic above-probability stock-buy branch; retain near-crossing, below-crossing, reservoir and bridge stock paths. Discovery n=1025; {\"arb\":0.4621769703152195,\"mean\":0.20128720817775644,\"retail\":-0.26088976213853665,\"runs_down\":31,\"runs_up\":213,\"standard_error\":0.09858727576024066,\"trimmed\":0.2601943282000002}; failures=0","Rejected above-value ammunition ablation: previously unused second choosing half n=1025: {\"arb\":0.5184700560581463,\"mean\":-0.15460648172380542,\"retail\":-0.6730765377825363,\"runs_down\":23,\"runs_up\":218,\"standard_error\":0.22886028645007708,\"trimmed\":0.35104953728577054}; failed to gain in untrimmed mean, so not kept.","Selected candidate, previously unused second choosing half n=1025: {\"arb\":0.587335712388,\"mean\":0.5023790509405853,\"retail\":-0.08495666144653707,\"runs_down\":84,\"runs_up\":425,\"standard_error\":0.06676917839479532,\"trimmed\":0.5036773154176121}; failures=0","The main-bid surplus variant was defined and discovery-tested before any validation results were opened. After rejecting the stock-ammunition ablation on validation, tested this fixed alternative on the second choosing half; no parameters or thresholds were adjusted. Validation gains in four consecutive seed quarters: [0.2922778337527345, 0.5976147424140635, 0.5958050911398424, 0.5237351143330741].","Selected main-bid surplus guard on all 2050 choosing runs, paired against start: {\"arb\": 0.5842556312251219, \"mean\": 0.5086069034543903, \"retail\": -0.07564872777048817, \"runs_down\": 164, \"runs_up\": 829, \"standard_error\": 0.050973454157231174, \"trimmed\": 0.5080676858729065}. Freeze precedes all confirming-seed runs.","Frozen before confirming runs; SHA256=09200bce41ecb807a03a721f444d2f1012e465aed55e49fbe0d3e91441392ead. Confirming start file: {\"arb_edge\":-26.49290604714326,\"failures\":0,\"n\":1937,\"retail_edge\":183.34915313064198,\"total_edge\":156.85624708351307}; submitted file: {\"arb_edge\":-25.833520114846824,\"failures\":0,\"n\":1937,\"retail_edge\":183.2706512570302,\"total_edge\":157.43713114219602}; paired diff={\"arb\":0.6593859322964378,\"mean\":0.5808840586829631,\"retail\":-0.07850187361177052,\"runs_down\":162,\"runs_up\":809,\"standard_error\":0.04835727476297392,\"trimmed\":0.5820531944625457}. Arb diff is signed: positive means less lost. Trimmed removes exactly 20 pairs with largest absolute total-edge differences.","Other spreads: first 300 eligible seeds per spread 1, 2 and 3 from 90000 onward; 900 paired runs, all SimulationResult fields identical, zero failures.","Timing: 200 spread-4 confirming seeds, both strategies in one process, both warmed, alternating order within each seed; seconds are accumulated simulation wall times, not parallel batch times; {\"start\":128.82859911303967,\"yours\":128.5911680147983}; yours/start=0.9981570000770323."],"next":"Test the existing spread-4 flow estimate for main-bid sizing on top of the new inventory guard. Standalone flow sizing gained 0.6208593750787328 per discovery run, but was not independently validated here; measure its paired retail and jump/plain arbitrage effects before combining it."}