{"approach": "Take-away seat: the base with every probe order removed, so p is located from fills and the competitor alone. A resting own order is a hard bound on p; an own order that vanished whole is read as the arbitrageur crossing it, weighted against the lognormal chance that one retail order ate it whole; a competitor level that vanished is read the same way (weight 0.03 for the other side, 0.05 for the multi-level case); the competitor's best bid and ask bound p as in the base. The base's sub-tick grid belief takes these as soft likelihoods, moves by a variance-matched walk when the one-step move of p is under 0.6 of a grid cell, and gets a fixed 0.6% of jump mass a step instead of the base's larger uniform floor. Quotes still sit one tick inside the competitor and use the marginal sizing rule, but expected arbitrage loss is summed over the whole belief instead of a normal around its mean, with the loss weight kA cut from 0.7 to 0.5. The base's low-price stock plan is kept; its bids on a tick p is just crossing fire only while the belief sd is under 0.3 tick, and the big tick-1 bid only while the belief puts under 10% below 1c. What is lost: on tuning seeds 1000-1599 the base scores 107.24 (retail 135.80, arb -28.56) and this file 97.92 (retail 130.11, arb -32.19), paired -9.32 +-0.83; on holdout 30000-30599 the base scores 96.04 and this file 87.75, paired -8.29 +-0.76. The loss grows with the competitor spread (holdout: -1.35, -8.89, -11.68, -11.78 for spreads 1 to 4) and sits in the mid range of p, where the belief's bracket was about 3 ticks wide instead of 1.2 when measured on an earlier build. What is freed: the base's probes cost 0.49 a run in arbitrage loss and earn 0.03 from retail (seeds 1000-1095, about 3.6 resting probes a step); I found no use for the freed ticks or queue places, since quote placement does not change. So probes are worth about 8 to 9 a run net and this file is a measurement, not a candidate to enter over the base.", "blocked": null, "python_version": "3.12.3", "base_mean_edge": 102.33197908899267, "score": {"mean_edge": 97.92400676829367, "retail_edge": 130.11073730696, "arb_edge": -32.186730538662005, "simulations": 600, "seed_start": 1000, "failures": 0}, "holdout": {"mean_edge": 87.753135063419, "simulations": 600, "seed_start": 30000, "failures": 0}, "code": "\"\"\"Stale-quote defence with no probe orders: p is located from fills and the competitor alone.\n\nEvery step the arbitrageur removes any order on the wrong side of p.  The base\nread that off tiny two-sided probe orders; this file places none.  Instead:\n  * an own order still resting is a hard bound on p (the arbitrageur left it);\n  * an own order that vanished whole was either crossed by p or eaten whole by\n    one retail order, and the second is rare for a quote of real size, so the\n    belief is reweighted towards \"p crossed it\";\n  * a competitor level that vanished is read the same way, and the competitor's\n    best bid and ask bound p as before.\nA sub-tick grid belief carries this between steps: it diffuses by the one-step\nmove of p (a variance-matched walk when that move is far below a grid cell, so\nquiet stretches near 0 keep what they know), is cut at the hard bounds and takes\nthe vanished orders as soft likelihoods.  Quotes still sit one tick inside the\ncompetitor and are sized by the marginal rule, but the expected arbitrage loss is\nnow taken over the whole belief rather than a normal around its mean.  The\nbase's low-price stock plan is kept (large resting bid at tick 1, YES held to\ncover low asks); its bids on a tick p is \"just crossing\" need p to a fraction of\na tick, so they fire only while the belief is that tight, and the tick-1 bid\nonly while p is unlikely to be under it already.\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.5, 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         epc=0.03, epc2=0.05, epf=0.01, emin=0.002, mix=1.0, tbm=1.0, tri=0.6, q1p=0.1, vg=0.3, uj=0.006, mxd=1.0)\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)]\nDUST = 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.po = {}           # orders left resting after the last step: id -> (side, tick, quantity)\n        self.tb = 0\n        self.bg = None\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 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        # what the fills say: an order that vanished whole was taken by the arbitrageur (p crossed it)\n        # or eaten whole by retail; a competitor level that vanished likewise\n        rho = P['lam_r'] * 0.5\n        mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n        cur = {o.order_id for o in state.own_orders}\n        soft = []              # (tick, +1: p above it / -1: p below it, weight of the other side)\n        van_a = van_b = None\n        gone = {}\n        for oid, (side, t, q) in self.po.items():\n            if oid not in cur:\n                gone[(side, t)] = gone.get((side, t), 0.0) + q\n        for (side, t), q in gone.items():\n            n = q * max(t / 100.0, 0.05)\n            e = max(P['emin'], rho * (1.0 - cdf((math.log(max(n, 1e-9)) - mu) / P['sig_n'])))\n            if side is Side.BUY:\n                soft.append((t, -1, e))\n                van_b = t if van_b is None else max(van_b, t)\n            else:\n                soft.append((t, 1, e))\n                van_a = t if van_a is None else min(van_a, t)\n        if self.pcb is not None:\n            if ca > self.pca:\n                e = P['epf'] if (van_a is not None and van_a < self.pca) else P['epc']\n                if ca > self.pca + 1:\n                    soft.append((ca - 1, 1, P['epc2']))\n                soft.append((self.pca, 1, e))\n            if cb < self.pcb:\n                e = P['epf'] if (van_b is not None and van_b > self.pcb) else P['epc']\n                if cb < self.pcb - 1:\n                    soft.append((cb + 1, -1, P['epc2']))\n                soft.append((self.pcb, -1, e))\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        h = wid / nb\n        g = (lo, hi, nb)\n        if self.bc is None or P['filt'] <= 0:\n            ws = [1.0 / nb] * nb\n        elif P['tri'] > 0 and self.bg == g and self.st < P['tri'] * h:\n            # same grid and a step much shorter than a cell: variance-matched walk, absorbed at observed barriers\n            al = 0.5 * (self.st / h) ** 2\n            b = self.bw\n            u = 0.4 * P['uni'] * wid / nb if P['uj'] < 0 else 0.0\n            ws = []\n            for i in range(nb):\n                dn = b[i - 1] if i else (b[0] if lo <= 0 else 0.0)\n                up = b[i + 1] if i < nb - 1 else (b[i] if hi >= 100 else 0.0)\n                ws.append((1 - 2 * al) * b[i] + al * (dn + up) + u)\n        else:\n            sg = max(self.st, 0.6 * wid / nb)\n            k = -0.5 / (sg * sg)\n            ws = []\n            uni = P['uni'] * sg if P['uj'] < 0 else 0.0\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 P['uj'] >= 0:\n            # jumps: a little mass anywhere in the bracket each step, no more than jumps supply\n            tot = sum(ws) or 1.0\n            u = P['uj'] / nb\n            ws = [(1 - P['uj']) * w / tot + u for w in ws]\n        if soft:\n            for i, c in enumerate(cs):\n                for t, d, e in soft:\n                    if (c - t) * d < 0:\n                        ws[i] *= e\n        tot = sum(ws)\n        ws = [w / tot for w in ws]\n        self.bc, self.bw = cs, ws\n        self.bg = g\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        sdb = math.sqrt(var_t)\n        pb1 = sum(w for c, w in zip(cs, ws) if c < 1.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 or (P['tbm'] > 0 and mean_t < 1.0)) 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        mixw = [(c / 100.0, w) for c, w in zip(cs, ws) if w > 1e-4] if P['mix'] > 0 else None\n        pm = mean_t / 100.0\n        if mixw and P['mxd'] > 0 and phat < pm:\n            # the time decay below tick 1 moved the estimate: move the mixture with it\n            mixw = [(c * phat / pm, w) for c, w in mixw]\n            pm = phat\n        def AB(x):\n            if mixw:\n                a = sum(w * sp * lpm((x - c) / sp) for c, w in mixw)\n                b = a - (x - pm)\n            else:\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        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 > DUST + 1e-9]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > DUST + 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 and sdb <= P['vg']:\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'] and sdb <= P['vg']:\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 and pb1 <= P['q1p']:\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 = {o.order_id: (o.side, o.price_ticks, o.remaining_quantity) for o in state.own_orders}\n        new_b = []\n        new_a = []\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            keep.pop(o.order_id, None)\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 <= DUST + 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            oid = self._oid('y')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1), client_order_id=oid))\n            keep[oid] = (Side.BUY, 1, fl(q1))\n            free -= fl(q1) / 100.0 + 1e-6\n        if amt and qam >= 0.01:\n            q = fl(qam)\n            oid = self._oid('m')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n            keep[oid] = (Side.BUY, amt, 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            keep[oid] = (Side.BUY, bid_t, q)\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                keep[oid] = (Side.SELL, ask_t, q)\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        self.po = keep\n        return actions + out\n", "code_sha256": "9c3491613db59e9f92690e02c721129bc989c01175377bfa6729656f791f9e81", "tried": ["Scorer check: base on seeds 0-599 gives 102.33197908899267, identical to its author's figure. --workers worked here (up to 8).", "--sandbox fails on Python 3.12.3 for examples/starter_strategy.py and for this file alike (pathlib imports ntpath, which the sandbox refuses). On a scratch simulator copy with ntpath and posixpath allowed, the final file passed 20/20 on seeds 1000-1019 with mean 163.511090, equal to the unsandboxed run.", "All +- figures are paired standard errors on the same seeds. Sweeps used seeds 1000-1299 or 1300-1599 (300 runs); base is 118.70 on 1000-1299 and 95.78 on 1300-1599.", "Probe placement simply deleted, nothing else changed: -24.62 on seeds 1000-1599 (retail 101.28, arb -125.89), paired -131.86 +-6.91 against base: an eaten quote teaches the base nothing, so it is re-placed and eaten again.", "Loss weight kA with the fill filter (0.7 in base): 1.0 gave -3.39 +-0.65, 0.5 gave +1.00 +-0.38, 0.35 gave -0.32 +-0.56 against 0.5, 0.4 gave +0.19 +-0.37 against 0.5 at the final settings; kept 0.5. Quoting a little more than the myopic rule pays because a quote's fate is now the only sensor.", "Normal approximation for loss instead of the belief mixture: +0.49 +-0.64 overall (spread 1 +4.27, others negative); mixture kept, and moving the mixture with the base's below-1c time decay then gave +0.21 +-0.14 (spread 1 +0.93).", "Tick-1 bid gate P(p<1c) under 0.1: gate off costs -0.31 +-0.17 at the final settings; gate at 0.3 no better than 0.1.", "Jump mass a step in the belief (the base's uniform floor works out, by my arithmetic and not measured, to about 1.4% a step on a 3.5-tick bracket): 0.05% +0.81 +-0.49, 0.2% -0.21 +-0.70, 0.6% +1.05 +-0.41; kept 0.6%, all within noise of each other.", "Weight on 'retail ate my whole order' floor 0.0002 instead of 0.002: -0.33 +-0.25. Base's pay-up stock buy off (ammo_maxpay -1): -1.72 +-1.06. Low-price loss weight kL 0.1 instead of 0.15: -1.48 +-1.26. None kept.", "Reasoned through and not built: a second real-size quote one tick nearer p as an early warning. If small it is a probe under another name; at real size retail hits it first, giving up a tick of edge on most fills.", "Zone split against base on seeds 1000-1095, on the first written build (filter, walk, crossing-bid gate, tick-1 gate, kA 0.5; per run): p 0.2-0.8 retail 19.84 to 16.20 and arb -7.56 to -9.99; p under 1c arb -5.62 to -9.06; p 1c-5c arb -8.77 to -7.46 and retail 31.39 to 30.30. Belief error against true p in mid range 0.34 to 0.63 tick, bracket width 1.21 to 3.07 ticks.", "Base's probes measured on seeds 1000-1095: arb -0.4947 a run, retail +0.0262 a run, about 7282 probe order-steps a run. That is all that removing them frees.", "Fill-and-competitor belief filter with mixture loss (vanished own order and vanished competitor level as soft likelihoods): 101.16 on seeds 1000-1299, paired -17.54 +-1.39 against base, up from about -132.", "Variance-matched walk for the belief when p moves much less than a grid cell: +0.31 +-0.24 (spread 1 +1.34); kept.", "Crossing bids only while belief sd is under 0.3 tick: +4.43 +-0.66 on seeds 1000-1299 (run together with the walk above); turning those bids off entirely +4.18 +-0.76; sd limit 0.5 -1.12 +-0.34, 0.15 -0.92 +-0.71. First written result with this and the tick-1 gate: 95.62 on seeds 1000-1599, holdout 85.94.", "Trust a vanished competitor level more (other-side weight 0.2 down to 0.05): +1.20 +-0.45 on seeds 1000-1299; 0.01 against 0.2 gave +2.00 +-0.86 on 1300-1599 but 0.01 lost 1.47 +-0.79 to 0.05 on 1000-1299; settled on 0.03 single-level and 0.05 multi-level, the best sum over both halves (109.04 and 86.81).", "Final frozen file: 97.92 on seeds 1000-1599 (tuned on) and 87.75 on untouched holdout 30000-30599, 0 failures in both; base on the same seeds 107.24 and 96.04, measured for comparison only."], "next": "Do not enter this file over the base: it is 8.3 a run below the base on unseen seeds, so keep the probes (they cost 0.5 and buy about 9). What this seat built is worth grafting onto the base with its probes left on, none of it tested there yet: (1) read a vanished main order and a vanished competitor level as soft evidence in the belief, which should matter most on one-tick spreads where the base cannot place a probe at all and where this probe-free file lost least (-1.35 on holdout); (2) the variance-matched walk and smaller jump mass, so the belief keeps what it knows through quiet stretches below 1c where probes cannot see; (3) loss summed over the belief mixture rather than a normal. For a probe-free design the remaining loss is in the mid range on spreads 3 and 4 (about -12 a run), where p moves about a tick a step and a quote is the only sensor: the open question is whether the eaten-whole likelihood can be sharpened by estimating each run's retail rate and size from its own partial fills, which this seat did not try."}