{
  "approach": "Returned base code byte-for-byte unchanged. No candidate retained: candidate slower in paired wall-clock test. Tested approach: Spread-3-only lifetime sizing and retention of front positions. New larger asks are allowed only at the next rival replacement tick within one diffusion SD of its triggering bid, or at an already-owned front tick. The model approximates retail fill probability before a crossing with competing clocks, using the base probability filter, remaining horizon, learned retail notional flow in this run, and the base diffusion/jump-size prior. It raises the ask target to at most twice the one-step target, so it can exceed 3000 shares without exposing the entire stock. At confirmed front ticks, retain orders up to twice the recomputed target instead of cancelling at 1.5 times; orders still cancel when the target is zero. This avoids throwing away priority for modest target shrinkage. Inventory acquisition targets are computed before the enlargement. The base cash/YES collateral rules remain active. The returned model uses the base jump prior; per-run jump-fitting variants were tested and rejected. A numerical filter-loop optimization preserves calculation order and was checked on 12 full runs.  Reported seconds are two separate 200-run timings of identical returned base code; the rejected candidate timings are recorded in tried. The apparent candidate unseen gain 8.685466363612524e-05 was far below its standard error 0.2626548112982506; it is not evidence of a useful gain. Unseen comparison covers all 2035 spread-3 seeds in [60000,68000). Front lifecycle audit numbers and all tuning controls are in tried.",
  "blocked": null,
  "spread": 3,
  "base_mean_edge": 98.4694596619638,
  "base_unseen": {
    "mean_edge": 118.8166859338749,
    "retail_edge": 149.05823988395983,
    "arb_edge": -30.241553950072774
  },
  "holdout": {
    "mean_edge": 118.8166859338749,
    "retail_edge": 149.05823988395983,
    "arb_edge": -30.241553950072774,
    "failures": 0
  },
  "diff": {
    "mean": 0.0,
    "standard_error": 0.0,
    "retail": 0.0,
    "arb": 0.0
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "base": 618.5047668293118,
    "yours": 620.9549152406398
  },
  "code": "\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\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 == 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 == 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            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            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            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            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            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.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            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= P['min_ahead']:\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\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            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(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 == 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):\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                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        return actions + out\n",
  "code_sha256": "dcf68e0c9a7b06f90cf70a833357b60e2208b5b3e2971e7dddf02986d4747076",
  "tried": [
    "Unrestricted exponential retail/crossing-clock sizing on both sides; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -8.16158266546906, 'standard_error': 4.996845312444464, 'retail': 6.594886688756354, 'arb': -14.756469354103867}, failures=0.",
    "Same model bounded at twice the one-step target, both sides; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.8369999148364629, 'standard_error': 2.7431788876219962, 'retail': 4.963711937717126, 'arb': -6.8007118525480665}, failures=0.",
    "Twice-bounded sell-side lifetime sizing; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -2.379213781907184, 'standard_error': 2.7344435888269545, 'retail': 3.7793103515027617, 'arb': -6.15852413338674}, failures=0.",
    "Only asks at ticks >=4 can receive rival replacements; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -2.4133135307392277, 'standard_error': 2.6676297523483607, 'retail': 3.037074301679005, 'arb': -5.450387832392265}, failures=0.",
    "Replenishable ask ticks, without the two-times bound; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -6.817678192836466, 'standard_error': 4.637401340153739, 'retail': 3.8439168523856355, 'arb': -10.661595045128177}, failures=0.",
    "Apply lifetime sizing after inventory acquisition targets; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -3.2830146564690614, 'standard_error': 2.676501962473712, 'retail': 2.043410697093369, 'arb': -5.326425353538674}, failures=0.",
    "Analytic conservative 0.6-sigma jump tail; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.338457720636465, 'standard_error': 2.1317752551679123, 'retail': 3.0224105687386738, 'arb': -4.360868289366298}, failures=0.",
    "Control: double asks at ticks >=4 without a lifetime value model; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -11.563610492848069, 'standard_error': 3.8520657289007905, 'retail': 2.4964408680165717, 'arb': -14.060051360877349}, failures=0.",
    "Enlarge only existing front orders or next replenishment ticks within one diffusion SD; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': 0.06269593228176887, 'standard_error': 0.10402189110191218, 'retail': 0.24362819606298253, 'arb': -0.1809322637845306}, failures=0.",
    "Same near-replenishment rule without the two-times bound; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': 0.032406484273480966, 'standard_error': 0.09872416678554423, 'retail': 0.3360361551209938, 'arb': -0.3036296708425417}, failures=0.",
    "Widen near-replenishment window to three diffusion SDs; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -2.172203819318784, 'standard_error': 1.7001298789713977, 'retail': 0.8644054882618767, 'arb': -3.0366093075756906}, failures=0.",
    "Use at most one tick of incremental benefit in the lifetime model; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.5406775810917117, 'standard_error': 1.8612124526837577, 'retail': 2.2426788069801082, 'arb': -3.7833563880784538}, failures=0.",
    "Include diffusion-crossing overshoot and conservative jump loss; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -2.5267966987939228, 'standard_error': 2.588478255075973, 'retail': 2.0494011446414357, 'arb': -4.576197843439779}, failures=0.",
    "Use undiscounted lifetime loss rather than the inventory-building risk discount; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -0.31974484958618826, 'standard_error': 1.0427979685854138, 'retail': 1.0443100605414375, 'arb': -1.3640549101386745}, failures=0.",
    "Infer jump-size second moment from observed quote jumps; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -0.2604930174845319, 'standard_error': 1.1518192093808017, 'retail': 1.2039550948906086, 'arb': -1.4644481123779012}, failures=0.",
    "Undiscounted risk model without the two-times bound; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.1228249718480658, 'standard_error': 1.8027564398916984, 'retail': 1.3621271086867388, 'arb': -2.4849520804712717}, failures=0.",
    "Observed-jump risk model without the two-times bound; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.737744862607182, 'standard_error': 2.5018857424539194, 'retail': 1.4252874285674013, 'arb': -3.163032291108288}, failures=0.",
    "Allow crossing before the first retail arrival; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.441782652701104, 'standard_error': 2.4291249523538694, 'retail': 1.4201426624569042, 'arb': -2.861925315149724}, failures=0.",
    "Also cap size at estimated remaining retail demand; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.441782652701104, 'standard_error': 2.4291249523538694, 'retail': 1.4201426624569042, 'arb': -2.861925315149724}, failures=0.",
    "Near-replenishment control with wider retention tolerance for confirmed front orders; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': 0.303906797112708, 'standard_error': 0.1219332907853143, 'retail': 0.7144783349734796, 'arb': -0.410571537862431}, failures=0.",
    "Undiscounted capped model only at actual next replacement tick or confirmed front; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -0.3214413917944751, 'standard_error': 1.0429091381008535, 'retail': 1.0424901685071828, 'arb': -1.3639315603116027}, failures=0.",
    "Frozen model: horizon, arrival, observed jumps, and actual replacement-tick eligibility; discovery spread-3 seeds in [8000,8800), n=181, diff={'mean': -1.4417537648602203, 'standard_error': 2.429124286092118, 'retail': 1.4201739251657441, 'arb': -2.8619276900171267}, failures=0.",
    "near2 extended tuning in [8800,12000), pruned after 448 completed simulations for lack of clear gain; diff={'mean': -0.07066193908415148, 'standard_error': 0.18272169323616225, 'retail': 0.25064168202924103, 'arb': -0.32130362111071403}; failures=0.",
    "fair2 extended tuning in [8800,12000), pruned after 288 completed simulations for lack of clear gain; diff={'mean': -0.48465133288159795, 'standard_error': 0.9525790697378964, 'retail': 1.0759865768729169, 'arb': -1.5606379097604168}; failures=0.",
    "Broad seat2 on separate early tuning block [8800,9600), n=209, diff={'mean': -3.021020259955981, 'standard_error': 3.0101616616243265, 'retail': 3.6609607322334914, 'arb': -6.681980992217225}.",
    "Unselected near2 control validation extension pruned after 208 completed runs in [12000,16000); diff={'mean': 0.052987182031249636, 'standard_error': 0.05171161202005581, 'retail': 0.10926007144903764, 'arb': -0.05627288941346142}.",
    "Frozen final candidate predeclared validation: first 300 spread-3 seeds in [12000,16000), n=300, diff={'mean': 0.2860183892223325, 'standard_error': 0.15589183072072443, 'retail': 0.524005607702999, 'arb': -0.23798721847166643}, failures=0.",
    "Frozen final candidate unseen [60000,68000), spread 3 only, n=2035, diff={'mean': 8.685466363612524e-05, 'standard_error': 0.2626548112982506, 'retail': 0.5766313862713018, 'arb': -0.5765445316103686}, failures=0; no unseen-driven tuning.",
    "Front-order lifecycle audit on the same 181 discovery runs. A position is a main order placed strictly ahead of the rival at its tick; at_rival selects positions later observed ahead at the rival best tick. Before={'runs': 181, 'all': {'positions': 126759, 'shares': 41.800924904739915, 'filled': 15.498055207125574, 'edge': 0.20599825000835875, 'retail': 0.23881754659859333, 'arb': -0.03281929659023494, 'per_run': 700.3259668508288}, 'at_rival': {'positions': 31197, 'shares': 43.1071692790973, 'filled': 13.909469820816105, 'edge': 0.32889653958172704, 'retail': 0.36615182533844987, 'arb': -0.037255285756722066, 'per_run': 172.35911602209944}}; experiment after={'runs': 181, 'all': {'positions': 126588, 'shares': 42.33614457926455, 'filled': 15.616749138939149, 'edge': 0.2067996515769941, 'retail': 0.24018171991883314, 'arb': -0.03338206834183926, 'per_run': 699.3812154696133}, 'at_rival': {'positions': 31216, 'shares': 44.033739748846656, 'filled': 14.503182662737057, 'edge': 0.3353523418451344, 'retail': 0.3747709327279838, 'arb': -0.0394185908828489, 'per_run': 172.46408839779005}}. Cohorts may differ because orders and queues change.",
    "Paired timing, 200 full spread-3 discovery simulations each, alternating strategy order by run, one process: {'base': 1115.253594392212, 'yours': 1116.9954248778522, 'cpu_base': 242.42522699999995, 'cpu_yours': 243.87008949099996, 'failures': [0, 0], 'runs_each': 200}.",
    "Other-spread full-result equality: 300 seeds of each spread 1,2,4 from 60000 onward, n=900, identical=True.",
    "Simulator revision b244530ee2a6247b5f930830eeca9dd950da0e7e, Python 3.12.3; baseline command: python3 -m orderbook_pm_challenge run ../base.py --simulations 4000 --seed-start 4000 --workers 4 --json; sandbox omitted. All custom simulations use sample_config(ChallengeConfig(), ParameterVariance(), seed=N), then SimulationEngine(config, factory, seed=N).run().",
    "Observed-jump horizon/replacement model rejected before opening its unseen scores: partial tuning validation n=272, diff={'mean': -0.16125001320367727, 'standard_error': 0.6421022362253281, 'retail': 0.6487904522761019, 'arb': -0.8100404654904407}. Unseen outputs for that rejected model were not inspected or used.",
    "Returned base code timed twice in one process, 200 runs each; differences are measurement variation between identical implementations: {'base': 618.5047668293118, 'yours': 620.9549152406398, 'cpu_base': 230.79172085199986, 'cpu_yours': 230.73660156899987, 'failures': [0, 0], 'runs_each': 200}",
    "Rejected final candidate source, sha256=4ba6ff80ff16b77dccc1c6f3cebfb15f62f67679c683ea6036e7c7d95e60f1aa, reconstructible from the returned base with this JSON-escaped unified diff: \"--- base.py\\n+++ rejected_candidate.py\\n@@ -107,14 +107,26 @@\\n             k = -0.5 / (sg * sg)\\n             ws = []\\n             uni = P['uni'] * sg\\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+            if self.s == 3:\\n+                life_pairs = tuple(zip(self.bc, self.bw))\\n+                life_exp = math.exp\\n+                for c in cs:\\n+                    t = uni\\n+                    for ci, wi in life_pairs:\\n+                        d = c - ci\\n+                        d2 = d * d * k\\n+                        if d2 > -12.5:\\n+                            t += wi * life_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@@ -234,6 +246,25 @@\\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+        # Spread 3: size the queue for competing retail and crossing clocks.\\n+        if self.s == 3 and (ask_t == ca or (cb > 0 and ask_t == cb + 3 and phat <= cb / 100.0 + sp)):\\n+            def life(t, buy):\\n+                if not 1 <= t <= 99:\\n+                    return 0.0\\n+                x = t / 100.0\\n+                d = phat - x if buy else x - phat\\n+                if d <= 0.0 or H <= 1:\\n+                    return 0.0\\n+                a, b = AB(x)\\n+                loss = a if buy else b\\n+                jump_cross = sum(w for p, w in jp if (p < x if buy else p > x))\\n+                hazard = max(1.0 / H, 1 * sp * sp / (d * d) + lj * jump_cross)\\n+                flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\\n+                rate = flow / (max(phat, 0.05) if buy else x)\\n+                return rate / hazard * math.log1p(d * hazard / max(kA * loss, 1e-12))\\n+            if ask_t >= 4:\\n+                qa = max(qa, min(2 * qa, life(ask_t, False)))\\n+\\n         # order management\\n         actions = []\\n         free = state.free_cash - 2.0\\n@@ -257,7 +288,7 @@\\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):\\n+                if o.price_ticks == t and q > 0 and kept + o.remaining_quantity <= max(q * (2.0 if self.s == 3 and t == comp and o.order_id in self.ahead else P['keep_hi']), 1.0):\\n                     kept += o.remaining_quantity\\n                     kept_ids.add(o.order_id)\\n                 else:\\n\""
  ],
  "next": "Value the incremental one-tick queue advantage against the base counterfactual, rather than the entire distance to fair probability, and fit a compound-Poisson retail-demand/time-to-replenishment model. Rare jumps before priority is actually gained remain the main sizing danger."
}