{
 "approach": "The base (tick probes, sub-tick belief, quotes one tick inside the competitor, marginal sizing where one more share is quoted while P(retail reaches it)*edge exceeds expected arbitrage loss, cheap YES stock near 0) with one mechanism added from a rules reading: the arbitrageur in market.py always takes an order's entire remaining quantity, so any partial fill, or a full fill whose price is still at least half a tick on the right side of the post-step estimate of p, must be retail. Those fills give an online estimate of each run's retail intensity (rate times notional, which varies about fivefold across regimes and which the base fixes at 0.25*5). Retail notional seen per quoted side-step, divided by the prior per-side rate, scaled by 1.34 to correct the size truncation bias, shrunk toward 1 with 100 prior side-steps and clipped to [0.4, 2.5], multiplies the retail rate in the sizing rule. In quiet regimes it quotes smaller (arb loss falls), in busy ones larger. Gain is small: +0.91 on tuning seeds and +0.13 on the holdout; the oracle ceiling for perfect retail-regime knowledge was only +1.1.",
 "blocked": null,
 "python_version": "3.12.3",
 "base_mean_edge": 102.33197908899267,
 "score": {
  "mean_edge": 108.15649684917884,
  "retail_edge": 134.35938878886,
  "arb_edge": -26.202891939700333,
  "simulations": 600,
  "seed_start": 1000,
  "failures": 0
 },
 "holdout": {
  "mean_edge": 96.17078093861683,
  "simulations": 600,
  "seed_start": 30000,
  "failures": 0
 },
 "code": "\"\"\"Stale-quote defence with tick probes, a sub-tick belief and cheap YES stock.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low\nasks.  That YES is bought when it is cheap: a large bid rests at tick 1 while p\nis above it, so the arbitrageur fills it on the crossing for about 0.1 tick a\nshare instead of nearly a full tick once p is near zero, and smaller bids sit on\nwhichever tick p is within 0.15 of.  Below tick 1 the estimate of p decays with\nthe time spent there, since no probe can see it.\n\nAdded (fresh-rules-lawyer): the retail arrival rate is no longer a fixed prior.\nThe arbitrageur always takes an order's whole remaining quantity, so a partial\nfill, or a full fill whose price is still on the right side of the estimate,\nis retail.  Retail notional seen on the main quotes per quoted side-step,\nshrunk to the prior (N0 side-steps) and clipped to [0.4, 2.5], scales the\nretail rate used in the marginal sizing rule.\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)\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\nRON = 1\nRM = 0.5\nN0 = 100.0\nRC = 1.34\nRLO = 0.4\nRHI = 2.5\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.prev = {}         # main order id -> (side, ticks, remaining) after last step's actions\n        self.rn = 0.0          # retail notional seen on main quotes (in units of the prior per-side rate)\n        self.ex = 0.0          # side-steps with a main quote resting\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        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        # retail intensity read from our own fills: a partial fill, or a full fill whose price\n        # is still on the right side of p, can only be retail\n        cur = {o.order_id: o.remaining_quantity for o in state.own_orders}\n        k0 = P['lam_r'] * 0.5 * P['m']\n        sides = set()\n        for oid, (sd_, t, rq) in self.prev.items():\n            sides.add(sd_)\n            rem = cur.get(oid, 0.0)\n            f = rq - rem\n            if f <= 1e-9:\n                continue\n            ret = rem > 1e-9 or (t > (phat * 100) + RM if sd_ is Side.SELL else t < (phat * 100) - RM)\n            if ret:\n                self.rn += f * (t / 100.0 if sd_ is Side.SELL else max(phat, 0.05)) / k0\n        self.ex += len(sides)\n        ratio = min(RHI, max(RLO, (N0 + RC * self.rn) / (N0 + self.ex)))\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 * (ratio if RON else 1.0)\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            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - 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        self.prev = {}\n        gone = {a.order_id for a in actions if isinstance(a, CancelOrder)}\n        for o in state.own_orders:\n            if o.order_id[:1] in 'ab' and o.order_id not in gone and o.remaining_quantity > PROBE + 1e-9:\n                self.prev[o.order_id] = (o.side, o.price_ticks, o.remaining_quantity)\n        for a in out:\n            if a.client_order_id and a.client_order_id[:1] in 'ab':\n                self.prev[a.client_order_id] = (a.side, a.price_ticks, a.quantity)\n        self.ratio = ratio\n        return actions + out\n",
 "code_sha256": "1a94bafbba0ca34d0e88f0fb3f9496fb6b19c9b82a95c7f52c2788b0b31b8125",
 "tried": [
  "Rules read from engine.py/market.py (ten quirks): (1) arbitrage runs before retail each step, so every retail fill has edge >= 0 and every arb fill <= 0; (2) the arb takes an order's whole remaining quantity, never part of it; (3) arb stops at price >= p - 1e-9, ties at p are safe; (4) FIFO ties break on a global sequence, and competitor replenishments get a fresh sequence at step start, before the participant acts, so a resting order keeps priority over later replenishments at its tick; (5) replenishments land next step at +/- spread on the opposite side and vanish outside ticks 1-99; (6) score is edge at p after the move, never settlement, so inventory only matters through collateral; (7) YES and NO never net: each pair locks $1 of cash until settlement; (8) retail sells are sized notional/max(p,0.05) but retail buys notional/price, so at tick 1 a retail buy takes 100x notional shares; (9) the last step resolves p to exactly 0 or 1; (10) crossed or self-crossing participant orders are accepted, never matched on placement, only swept by the arb.",
  "Fresh standalone ladder-inference strategy (p from where the arb last swept the competitor ladder, one tick inside, fixed size 6, sticky vs cancel-all): 1.04 / 1.04 on seeds 1000-1599 (margin 0.6), -5.78 with margin 0-0.3. Sticky priority made no difference (alone at an inside tick, quirk 4 only matters at the competitor's own tick, which the base already exploits via its 'ahead' set). Abandoned; the base was opened early (about 75 min before the deadline, not in the last 30) because this line could not approach it.",
  "Oracle ceilings on the base, scratch runner, seeds 1000-1399, control 111.99: true retail rate and mean notional handed to the sizing rule +1.12 (113.11); true jump intensity/sigma +0.45 (112.44); cash effectively unlimited (1e5, quirk 7) +1.67 (113.66). Perfect post-move p with naive at-p quoting earned only 45.0 retail: knowing p is not enough without the inside-competitor margin.",
  "Online retail-intensity estimate from own fills (quirk 2: a partial fill, or a full fill still on the right side of p by 0.5 tick, cannot be the arbitrageur), correlation 0.68 with the true rate*notional across 200 seeds, mean 0.68 vs true 0.91 so scaled by RC: N0=30 RC=1.34 107.3660; RC=1.7 107.3842; N0=300 RC=1.34 107.9179; N0=100 RC=1.15 107.9073; N0=300 RC=1.0 107.9891 (seeds 1000-1599).",
  "--sandbox on 20 simulations fails on Python 3.12 for examples/starter_strategy.py as well as this file (ImportError: Import of 'ntpath' is not allowed in sandbox mode, from pathlib); not a candidate-specific failure. --workers 8 worked here.",
  "Base unchanged for comparison: 107.2442 on seeds 1000-1599, 96.0405 on holdout 30000-30599.",
  "Best: base + online retail-intensity scaling of the sizing rule's retail rate, N0=100 RC=1.34 clip [0.4,2.5]: 108.1565 on 1000-1599 (+0.91 over base), holdout 30000-30599 96.1708 (+0.13 over base, arb -26.58 vs -28.33)."
 ],
 "next": "The retail-regime ceiling is about +1.1 and cash (YES/NO pairs never net, each locks $1) about +1.7 on the base, so both are small; combine them (estimate flow, then budget collateral for it). The fill-classification rule (partial fill => retail) is exact and could also feed the belief: a full fill of a large main order is almost surely the arbitrageur and says p crossed that tick, which the base currently learns only from probes. Measure the jump-step loss of the 'ahead' orders at the competitor tick, which keep priority (FIFO sequence) but also sit exposed longest."
}