{"approach": "Started from the base (seat 845, crossing cover), which reproduces exactly (108.6397428961575 on seeds 1000-1599). Added a second price level: a second ask one tick above the main ask and a second bid one tick below the main bid. Each is sized from the lognormal retail-size tail: the order must survive the main order plus an assumed 48 notional of competitor queue ahead of it, so the size is the tail quantile where retail gain covers kA*arbitrage loss at that tick, capped at 400 shares and 30% of free cash. Second-level orders are tracked separately from the main ladder, so the base's quoting and stickiness are unchanged. Added a collateral guard that mirrors the engine's reservation rules (YES covered first, cash for the rest, fills tracked) and shrinks any placement that would be refused. Without it, 4 of 200 early runs failed with 'Insufficient free cash'. Screened on seeds 4000-5999, where the second level on all spreads gained retail but lost more to arbitrage on spreads 1 and 4. Froze it for competitor spreads 1-2 only, with k2=1 and one tick behind. The held-back seeds 6000-7999 confirmed it: +0.0768 mean, +0.1780 retail. On unseen seeds 50000-53999 it gains +0.0352 mean (se 0.0640) and +0.0451 retail, with no failures. That is within noise. It is about 11% slower than the base (60.7s vs 54.4s for 200 runs, timed concurrently), so it fails the 'no slower than the base' candidate rule unless the guard is made cheaper.", "blocked": null, "python_version": "3.15.0", "base_mean_edge": 108.6397428961575, "base_unseen": {"mean_edge": 97.54703502577885, "retail_edge": 126.92890288111944, "arb_edge": -29.381867855334075}, "score": {"mean_edge": 98.1403613467095, "retail_edge": 125.31791925205133, "arb_edge": -27.177557905356323, "simulations": 4000, "seed_start": 4000, "failures": 0}, "holdout": {"mean_edge": 97.58225602321812, "retail_edge": 126.97403767255823, "arb_edge": -29.391781649334, "simulations": 4000, "seed_start": 50000, "failures": 0}, "diff": {"mean": 0.035220997439274926, "standard_error": 0.0640336497981795, "retail": 0.04513479143878385, "arb": -0.009913793999924536}, "seconds": {"base": 54.44736991589889, "yours": 60.663953667040914}, "code": "\"\"\"Crossing-funded inventory for passive prediction-market quotes, with a second price level.\n\nBase (seat 845, crossing cover) plus: when the competitor spread is 1 or 2 ticks, a second bid one tick below the main bid and a second ask one tick above the main ask, sized so the marginal retail order that walks past the main order and the competitor queue ahead pays for the arbitrage risk at that tick (lognormal retail-size tail). A collateral guard mirrors the engine reservation rules so no placement is refused.\n\"\"\"\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,\n         L2a=1.0, L2b=1.0, d2=1, cN=48.0, k2=1.0, f2=0.3, q2max=400.0, s2min=1, s2max=2, keep2=1.5)\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.l2 = set()        # second-level order ids\n        self.rv = {}           # order id -> [remaining, reserved_yes, reserved_cash, side_is_buy, price]\n\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def on_step(self, state):\n        return self._guard(state, self._step(state))\n\n    def _guard(self, state, acts):\n        # mirror the engine's collateral rules exactly, so no placement can be refused\n        rv = {}\n        for o in state.own_orders:\n            r = self.rv.get(o.order_id)\n            if r is None:\n                continue\n            f = r[0] - o.remaining_quantity\n            if f > 0 and not r[3]:\n                c = min(r[1], f)\n                r[1] -= c\n                r[2] = max(0.0, r[2] - (1 - r[4]) * (f - c))\n            elif f > 0:\n                r[2] = max(0.0, r[2] - r[4] * f)\n            r[0] = o.remaining_quantity\n            rv[o.order_id] = r\n        free = state.cash - sum(r[2] for r in rv.values())\n        ry = sum(r[1] for r in rv.values())\n        out = []\n        for a in acts:\n            if isinstance(a, CancelOrder):\n                r = rv.pop(a.order_id, None)\n                if r is not None:\n                    free += r[2]\n                    ry -= r[1]\n                out.append(a)\n                continue\n            x = a.price_ticks / 100.0\n            q = fl(a.quantity)\n            if a.side is Side.BUY:\n                q = min(q, fl(max(free - 1e-6, 0.0) / x))\n                yv = 0.0\n                c = x * q\n            else:\n                av = max(0.0, state.yes_inventory - ry)\n                yv = min(q, av)\n                need = (1 - x) * (q - yv)\n                if need > free - 1e-6:\n                    q = fl(yv + max(free - 1e-6, 0.0) / (1 - x))\n                    yv = min(q, av)\n                c = (1 - x) * (q - yv)\n            if q < 0.01:\n                continue\n            oid = a.client_order_id or self._oid('x')\n            out.append(PlaceOrder(side=a.side, price_ticks=a.price_ticks, quantity=q, client_order_id=oid))\n            free -= c\n            ry += yv\n            rv[oid] = [q, yv, c, a.side is Side.BUY, x]\n        self.rv = rv\n        return out\n\n    def _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        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        l2 = self.l2\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9 and o.order_id not in l2]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9 and o.order_id not in l2]\n        bids2 = [o for o in state.own_orders if o.side is Side.BUY and o.order_id in l2]\n        asks2 = [o for o in state.own_orders if o.side is Side.SELL and o.order_id in l2]\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            q1 = max(0.0, P['ydf1'] * 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        gone = set()\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            gone.add(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            covk += sum(o.remaining_quantity for o in asks2 if o.order_id not in gone)\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        # second price level: catches the heavy tail of retail size that walks past the first level\n        main_b = sum(o.remaining_quantity for o in bids if o.order_id in kept_ids) + (fl(add_b) if add_b >= 0.01 else 0.0)\n        main_a = sum(o.remaining_quantity for o in asks if o.order_id in kept_ids) + (q if (ask_t <= 99 and add_a >= 0.01 and q >= 0.01) else 0.0)\n        cov_used = sum(o.remaining_quantity for o in state.own_orders if o.side is Side.SELL and o.order_id not in gone)\n        slack = 0.0\n        if ask_t <= 99 and add_a >= 0.01 and q >= 0.01:\n            slack = max(0.0, max(0.0, q - max(0.0, Y - cov_used)) - self.res.get(oid, 0.0)) * (1 - ask_t / 100.0)\n            cov_used += q\n        ok2 = P['s2min'] <= self.s <= P['s2max'] and H > 1\n\n        def q2size(loss, gain, ahead_n, px):\n            loss *= kA * P['k2']\n            if gain <= 0:\n                return 0.0\n            tail = loss / (rho * gain)\n            if tail >= 1.0:\n                return 0.0\n            nstar = math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6)))\n            return min(P['q2max'], max(0.0, nstar - ahead_n) / px)\n\n        qa2 = qb2 = 0.0\n        ta2 = ask_t + P['d2']\n        tb2 = bid_t - P['d2']\n        if ok2 and P['L2a'] > 0 and ask_t <= 99 and ta2 <= 99:\n            a, b = AB(ta2 / 100.0)\n            ncomp = max(0, ta2 - max(ca, ask_t + 1) + 1) + (1 if ask_t == ca else 0)\n            ahead = main_a * ask_t / 100.0 + ncomp * P['cN']\n            qa2 = q2size(b, a, ahead, ta2 / 100.0)\n        if ok2 and P['L2b'] > 0 and bid_t >= 1 and tb2 >= 1:\n            a, b = AB(tb2 / 100.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 Y < ytg else P['kLf']) / P['kL']\n            px = max(phat, 0.05)\n            ncomp_sh = sum(P['cN'] / (t / 100.0) for t in range(max(tb2, 1), min(cb, bid_t - 1) + 1)) + (P['cN'] / (cb / 100.0) if bid_t == cb and cb >= 1 else 0.0)\n            ahead = (main_b + ncomp_sh) * px\n            qb2 = q2size(a, b, ahead, px)\n        free2 = P['f2'] * max(free - 1.0 - slack, 0.0)\n\n        def manage2(orders, t, q2):\n            kept = 0.0\n            for o in orders:\n                if o.order_id in gone:\n                    continue\n                if o.price_ticks == t and q2 > 0 and kept + o.remaining_quantity <= max(q2 * P['keep2'], 1.0):\n                    kept += o.remaining_quantity\n                else:\n                    cancel(o)\n                    self.l2.discard(o.order_id)\n            return kept\n        kb2 = manage2(bids2, tb2, qb2)\n        ka2 = manage2(asks2, ta2, qa2)\n        if qb2 >= 0.01 and kb2 < qb2 * P['keep_lo']:\n            qq = fl(min(qb2 - kb2, free2 * 100.0 / tb2))\n            if qq >= 0.01:\n                oid2 = self._oid('B')\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=tb2, quantity=qq, client_order_id=oid2))\n                self.l2.add(oid2)\n                free -= qq * tb2 / 100.0 + 1e-6\n                free2 -= qq * tb2 / 100.0 + 1e-6\n        if qa2 >= 0.01 and ka2 < qa2 * P['keep_lo']:\n            x2 = ta2 / 100.0\n            cov2 = max(0.0, Y - cov_used - 0.1)\n            want = qa2 - ka2\n            unc2 = min(max(0.0, want - cov2), max(free2, 0.0) / (1 - x2))\n            qq = fl(min(want, cov2 + unc2))\n            if qq >= 0.01:\n                oid2 = self._oid('A')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ta2, quantity=qq, client_order_id=oid2))\n                self.l2.add(oid2)\n                r2 = max(0.0, qq - cov2)\n                self.res[oid2] = r2\n                free -= r2 * (1 - x2) + 1e-6\n        live = {o.order_id for o in state.own_orders}\n        self.l2 = {i for i in self.l2 if i in live and i not in gone} | {o.client_order_id for o in out if isinstance(o, PlaceOrder) and o.client_order_id and o.client_order_id[0] in 'AB'}\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        return actions + out\n", "code_sha256": "27978c8bfb52db9d0915dd326c1138d00fcd39fb71131fbb02383ce4adb27f88", "tried": ["Base on seeds 4000-7999: mean 98.09969568041932, retail 125.17961744069841, arb -27.0799217602933, 0 failures.", "L2 without collateral guard, seeds 4000-4199: 4 of 200 failed (Insufficient free cash: base coverage estimate ignores YES reserved by L2 asks). Fixed with an exact engine-mirroring guard.", "L2 two ticks behind (d2=2), all spreads, seeds 4000-5999 vs base: mean -0.1556 (se 0.0946), retail +0.0140, arb -0.1697.", "L2 k2=1.5 (smaller), all spreads, seeds 4000-5999: mean -0.1273 (se 0.0565), retail +0.0409, arb -0.1682.", "L2 k2=3.0 (smaller), all spreads, seeds 4000-5999: mean -0.0916 (se 0.0987), retail +0.0371, arb -0.1287.", "L2 one tick behind, k2=1, all spreads, seeds 4000-5999: mean -0.0655 (se 0.0490), retail +0.0592, arb -0.1248; spread1 retail +0.3592 arb -0.3855, spread2 mean +0.0419, spread4 mean -0.2611.", "Final, L2 one tick behind, k2=1, spreads 1-2 only: seeds 4000-7999 mean +0.0407 (se 0.0373), retail +0.1383, arb -0.0976 vs base; held-back 6000-7999 mean +0.0768, retail +0.1780; unseen 50000-53999 mean +0.0352 (se 0.0640), retail +0.0451, arb -0.0099."], "next": "The retail tail past the main order is small: the competitor queue (24-72 notional) ahead of any order behind the main tick swallows most large orders. Spread 1 gains the most retail but gives most of it back to arbitrage, so try a spread-1-only second ask sized by the observed fill rate. Make the collateral guard cheaper (only run it when a placement could be uncovered) to recover the ~11% speed. A bigger main order at the same tick, which sits ahead of the competitor, may capture the heavy tail better than a level behind it."}