{
 "approach": "Starts from the base (tick probes, sub-tick grid belief, quotes one tick inside the competitor, marginal sizing, cheap tick-1 YES stock, zd decay below 1c) and grafts the overflow mechanism onto it: each step it adds small bid/ask orders at the competitor's own best prices, sized at the marginal optimum there minus the core quote and a $24 notional queue allowance, each side capped at 15% of free cash (asks counting YES cover separately), cancelled and re-placed every step; the core inside quotes are split into four FIFO slices so downsizing cancels the newest slices and keeps queue priority. The belief filter (latent censored mixture filter) was also ported onto the base and measured alone, with overflow, and in mid-range-only, blended, variance-kept and clamped forms; none beat overflow alone, and alone it lost 1.8 on tuning seeds by raising arbitrage loss, so the frozen file keeps that code behind a flag set off (LAT = 0). On tuning seeds 1000-1599 the result is +0.54 over base; on holdout 30000-30599 it ties base (-0.004).",
 "blocked": null,
 "python_version": "3.12.3",
 "base_mean_edge": 102.33197908899267,
 "score": {
  "mean_edge": 107.77941648794467,
  "retail_edge": 137.01055490399065,
  "arb_edge": -29.231138416059004,
  "simulations": 600,
  "seed_start": 1000,
  "failures": 0
 },
 "holdout": {
  "mean_edge": 96.0368042128295,
  "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\"\"\"\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\nLAT = 0\nOVF = 1\nSLC = 1\nOV_Q = 24.0\nOV_F = 0.15\nLZD = 1\nBLAM = 0.0019\nBJS = 0.4\nLAT_LIK = 1.0\nLAT_JUMPINFO = 1.0\nMIXES = {}\nZTICKS = {}\ndef mixture(H):\n    if H not in MIXES:\n        v=math.exp(-H*BLAM)\n        arr=[]\n        for n in range(16):\n            arr.append((v,1.0/math.sqrt(max(H,1)*0.0004+n*BJS*BJS)))\n            v*=H*BLAM/(n+1)\n        MIXES[H]=arr\n    return MIXES[H]\ndef latent_tick(H,t):\n    if t<=0: return -12.0\n    if t>=100: return 12.0\n    key=(H,t)\n    if key not in ZTICKS:\n        mix=mixture(H)\n        z=inv(t/100.0)*math.sqrt(H*(0.0004+BLAM*BJS*BJS))\n        for _ in range(10):\n            prob=sum(w*cdf(z*r) for w,r in mix)\n            d=sum(w*r*pdf(z*r) for w,r in mix)\n            dz=max(-0.5,min(0.5,(prob-t/100.0)/max(d,1e-12)))\n            z-=dz\n            if abs(dz)<1e-8: break\n        ZTICKS[key]=z\n    return ZTICKS[key]\ndef normal_piece(mean,var,lo,hi):\n    sd=math.sqrt(max(var,1e-12))\n    a=(lo-mean)/sd;b=(hi-mean)/sd\n    if a>0:\n        mass=0.5*(math.erfc(a/SQ2)-math.erfc(b/SQ2))\n    elif b<0:\n        mass=0.5*(math.erfc(-b/SQ2)-math.erfc(-a/SQ2))\n    else:\n        mass=cdf(b)-cdf(a)\n    if mass<1e-200: return 0.0,mean,var\n    pa=pdf(a);pb=pdf(b)\n    shift=(pa-pb)/mass\n    m=mean+sd*shift\n    v=var*max(1e-8,1+(a*pa-b*pb)/mass-shift*shift)\n    return mass,m,v\n\n\ndef inverse_survival(q):\n    q=min(0.5,max(1e-300,q))\n    t=math.sqrt(-2.0*math.log(q))\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    for _ in range(5):\n        x+=(0.5*math.erfc(x/SQ2)-q)/max(pdf(x),1e-300)\n    return max(0.0,x)\n\ndef truncated_quantile(mean,sd,lo,hi,u):\n    a=(lo-mean)/sd;b=(hi-mean)/sd\n    if a>0:\n        qa=0.5*math.erfc(a/SQ2);qb=0.5*math.erfc(b/SQ2)\n        z=inverse_survival(qa+u*(qb-qa))\n    elif b<0:\n        qa=0.5*math.erfc(-a/SQ2);qb=0.5*math.erfc(-b/SQ2)\n        z=-inverse_survival(qa+u*(qb-qa))\n    else:\n        z=inv(cdf(a)+u*(cdf(b)-cdf(a)))\n    return min(hi,max(lo,mean+sd*z))\n\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\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def remember(self, state, actions):\n        prev = {o.order_id:(o.side,o.price_ticks,o.remaining_quantity) for o in state.own_orders}\n        for action in actions:\n            if isinstance(action, CancelOrder):\n                prev.pop(action.order_id,None)\n            elif isinstance(action, PlaceOrder):\n                prev[action.client_order_id]=(action.side,action.price_ticks,action.quantity)\n        self.previous_orders = prev\n\n    def belief(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.pcb is None:\n            spread=max(1,(ca-cb+1)//2)\n            lo,hi=cb+spread-1,ca-spread+1\n        else:\n            lo,hi=min(cb,self.pcb),max(ca,self.pca)\n        for o in state.own_orders:\n            if o.side is Side.BUY: lo=max(lo,o.price_ticks)\n            else: hi=min(hi,o.price_ticks)\n        if LAT_JUMPINFO and self.pcb is not None:\n            if ca>self.pca+1: lo=max(lo,ca-1)\n            if cb<self.pcb-1: hi=min(hi,cb+1)\n        self.pcb,self.pca=cb,ca\n        if lo>=hi: lo,hi=min(lo,hi)-0.001,max(lo,hi)+0.001\n        prev=getattr(self,'previous_orders',{})\n        survivors={o.order_id:o.remaining_quantity for o in state.own_orders}\n        filled=[[],[]]\n        cuts={lo,hi}\n        for oid,(side,tick,qty) in prev.items():\n            rest=survivors.get(oid,0.0)\n            if qty-rest>0.005:\n                filled[0 if side is Side.BUY else 1].append((tick,qty-rest,rest))\n                if lo<tick<hi: cuts.add(tick)\n        bounds=sorted(cuts)\n        if not hasattr(self,'zm'):\n            zl=latent_tick(H,lo);zh=latent_tick(H,hi)\n            self.zm=(zl+zh)/2; self.zv=(zh-zl)**2/12\n        components=[]\n        points=[]\n        for l,h in zip(bounds,bounds[1:]):\n            c=(l+h)/2\n            like=1.0\n            if LAT_LIK:\n                for side,records in enumerate(filled):\n                    rq=cash=0.0\n                    for tick,qty,rest in records:\n                        isarb=tick>c if side==0 else tick<c\n                        if not isarb:\n                            rq+=qty;cash+=qty*tick/100.0\n                    if rq<=0.005:\n                        like*=0.875\n                    else:\n                        value=rq*max(c/100.0,0.05) if side==0 else cash\n                        k=(math.log(max(value,1e-9))-(math.log(4.5)-0.72))/1.2\n                        tail=1-cdf(k)\n                        if any(rest>0.005 for tick,qty,rest in records):\n                            tail=pdf(k)/max(value*1.2,1e-9)\n                        like*=max(1e-8,0.125*tail)\n            zl=latent_tick(H,l);zh=latent_tick(H,h)\n            for jump,weight in [(0,1-BLAM),(BJS*BJS,BLAM)]:\n                mass,m,v=normal_piece(self.zm,self.zv+0.0004+jump,zl,zh)\n                components.append((weight*mass*like,m,v))\n                if mass > 1e-100:\n                    sd=math.sqrt(self.zv+0.0004+jump)\n                    aa=cdf((zl-self.zm)/sd)\n                    bb=cdf((zh-self.zm)/sd)\n                    for u,qw in [(0.1127016654,5/18),(0.5,4/9),(0.8872983346,5/18)]:\n                        zz=truncated_quantile(self.zm,sd,zl,zh,u)\n                        pp=sum(w*cdf(zz*r) for w,r in mixture(H))\n                        points.append((weight*mass*like*qw,pp))\n        total=sum(w for w,m,v in components)\n        if total<=1e-150:\n            zl=latent_tick(H,lo);zh=latent_tick(H,hi)\n            self.zm=max(zl,min(zh,self.zm));self.zv=0.0004\n        else:\n            m=sum(w*m for w,m,v in components)/total\n            v=sum(w*(v+(mm-m)**2) for w,mm,v in components)/total\n            self.zm,self.zv=m,max(v,1e-10)\n        mean=sum(w*cdf(self.zm/math.sqrt(1/r**2+self.zv)) for w,r in mixture(H))\n        if total > 1e-150 and points:\n            mean=sum(w*pp for w,pp in points)/total\n            v=max(0,sum(w*(pp-mean)**2 for w,pp in points)/total)\n        else:\n            deriv=sum(w*r*pdf(self.zm*r) for w,r in mixture(H))\n            v=deriv**2*self.zv\n        return min(0.999999,max(0.000001,mean)),v\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        self.lpcb, self.lpca = self.pcb, self.pca\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        if LAT:\n            self.pcb, self.pca = self.lpcb, self.lpca\n            phat, _vp = self.belief(state)\n            var_t = 0.0\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            if LZD or not LAT:\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 not o.order_id.startswith('d') and o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n        asks = [o for o in state.own_orders if not o.order_id.startswith('d') and 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 or o.order_id.startswith('d'):\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), client_order_id=self._oid('k')))\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, client_order_id=self._oid('m')))\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        # A small second level can collect retail overflow past finite competitor liquidity.\n        if OVF and cb >= 1 and cb < bid_t:\n            q = fl(max(0.0, min(qbid(cb) - OV_Q / max(phat, 0.05) - max(qb, kb), free * OV_F / (cb / 100.0))))\n            if q >= 0.02:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=cb, quantity=q, client_order_id=self._oid('db')))\n                free -= q * cb / 100.0 + 1e-6\n        if OVF and ca <= 99 and ca > ask_t:\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            covnew = sum(o.quantity - self.res.get(o.client_order_id, 0.0)\n                         for o in out if o.side is Side.SELL and o.client_order_id)\n            cov = max(0.0, Y - covk - covnew - 0.1)\n            x = ca / 100.0\n            q = fl(max(0.0, min(qask(ca) - OV_Q / x - max(qa, ka), cov + max(0.0, free - 10.0) * OV_F / (1 - x))))\n            if q >= 0.02:\n                oid = self._oid('da')\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ca, quantity=q, client_order_id=oid))\n                free -= r * (1 - x) + 1e-6\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, client_order_id=self._oid('p')))\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, client_order_id=self._oid('p')))\n                    self.pa.add(t)\n        # Cancel oversized quotes in small pieces while retaining the oldest FIFO slice.\n        pieces = []\n        for order in out:\n            oid = order.client_order_id\n            if not SLC or oid is None or oid[0] not in 'ab' or order.quantity < 0.08:\n                pieces.append(order)\n                continue\n            cents = int(round(order.quantity * 100))\n            covered_left = order.quantity - self.res.pop(oid, 0.0)\n            ahead = oid in self.ahead\n            self.ahead.discard(oid)\n            for i in range(4):\n                q = (cents // 4 + (i < cents % 4)) / 100.0\n                child = oid + '_' + str(i)\n                pieces.append(PlaceOrder(side=order.side, price_ticks=order.price_ticks,\n                                         quantity=q, client_order_id=child))\n                if ahead:\n                    self.ahead.add(child)\n                if order.side is Side.SELL:\n                    covered = min(covered_left, q)\n                    covered_left -= covered\n                    self.res[child] = max(0.0, q - covered)\n        if LAT:\n            self.remember(state, actions + pieces)\n        return actions + pieces\n",
 "code_sha256": "058765016de59ba7c3f891fcfb68798202750da54eab541679092112fb3b39f8",
 "tried": [
  "Scorer check: base on seeds 0-599 = 102.33197908899267 (author 102.33197908899267), unmodified simulator commit b244530, Python 3.12.3, --workers 4 worked.",
  "--sandbox: final file 0/20 and examples/starter_strategy.py 0/20, both fail with ImportError: Import of 'ntpath' is not allowed in sandbox mode (Python 3.12 pathlib). No workaround applied; unsandboxed runs have 0 failures.",
  "All rows below are paired against base on tuning seeds 1000-1599 (base there: mean 107.2442, retail 135.802, arb -28.557); 300-seed rows use 1000-1299 unless noted.",
  "Belief filter (latent censored Gaussian-mixture filter from the belief artifact) replacing the base grid's phat, sizing variance 0, base zd decay kept: 105.439 on 600, -1.81 +- 0.86, arb worse by 4.19.",
  "Belief + overflow together (both on the base): 105.260 on 600, -1.98 +- 0.98, arb worse by 5.18. They do not add: the belief filter costs more arb loss on this base than it did on the older strategy.",
  "Belief only when grid phat in (0.05,0.95), grid otherwise, + overflow: -2.69 +- 1.17 (300) - the latent filter hurts in the mid range, not only near 0.",
  "50/50 blend of latent and grid phat + overflow: +0.15 +- 1.08 (300); 25% latent: -0.60; keep grid sizing variance with full latent: -0.11; latent clamped into the base's probe bounds [lo,hi]: +0.07; clamp + blend: +0.03; clamp + jump sigma 0.3: +0.31 +- 1.18. All below overflow alone (+0.53 on the same 300).",
  "Overflow constants: queue allowance $12 instead of $24: -0.39 (300); cash cap 30% per side instead of 15%: +0.51 on 1000-1299 and +0.43 on 1300-1599 vs +0.53/+0.54 at 15%; kept 15%.",
  "Overflow without FIFO slices: -0.16 +- 0.86 (300) vs +0.53 with slices.",
  "Overflow orders at the competitor's prices ($24 queue allowance, 15% cash per side) plus four FIFO slices of main quotes, on the base unchanged otherwise: 107.779 on 600, +0.535 +- 0.497, retail +1.21, arb -0.67. Frozen as final. Holdout 30000-30599: 96.0368042128295 vs base 96.0405203261775 on the same seeds, paired diff -0.004 +- 0.40: no measurable gain out of sample."
 ],
 "next": "Neither graft gives a holdout gain on the current base, so do not spend another seat combining them as they are. The overflow orders add ~1.2 retail but ~0.7 arb loss; size them from an estimate of remaining competitor queue (quote age and depletion) rather than a fixed $24, and test asks-only, since the original seat found nearly all its gain on the ask side. The latent filter loses on this base mostly through arb (+4 to +5 loss): the base's hard probe reads (eaten probe, lone tick-1 probe) and zd decay are sharper than its soft fill likelihoods; if retried, feed it the base's probe bounds as hard truncation and measure arb by price band first."
}