{"approach": "For self.s == 3 only, permit repeated above-estimate stock top-ups only while YES inventory is below the desired ordinary ask quantity, and cap each such purchase by that ask shortfall. Preserve the original near-tick-crossing purchases, below-probability stock bids, remaining-demand targets, run-specific one-cent reservoir and quotes. This pays up only for immediately deficient ask cover instead of building extra reserve at the expensive next tick. No numerical constants changed. Complete removal and a current-ask remaining-demand cap were rejected on disjoint validation because of lost retail. This narrower rule was then evaluated on fresh, disjoint choosing pilot and validation seeds and frozen before confirmation.", "blocked": null, "spread": 3, "base_mean_edge": 108.64128535876738, "found": ["Start-file purchase rule probe; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=27.26350000000131, purchase_edge=-0.2879540253988903, arb_purchase_edge=-0.30326850543089967, cash_paid=11.433540000000002, later_sold_to_retail_FIFO=14.086083333333251, later_sold_to_arb_FIFO=7.850916666666499, YES_left_FIFO=5.326499999999954. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule main_bid; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=1887.154083333334, purchase_edge=19.537864977298607, arb_purchase_edge=-5.637174938472427, cash_paid=665.3189641666667, later_sold_to_retail_FIFO=1175.4254166666658, later_sold_to_arb_FIFO=513.8770833333215, YES_left_FIFO=197.85158333333328. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule bridge; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=320.0295, purchase_edge=-0.4440699396389142, arb_purchase_edge=-0.6734901328949173, cash_paid=17.19282333333333, later_sold_to_retail_FIFO=261.4284166666666, later_sold_to_arb_FIFO=47.83749999999996, YES_left_FIFO=10.763583333333345. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule main_bid_below_5c; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=2202.9551666666666, purchase_edge=-0.7008256068943443, arb_purchase_edge=-3.597015905693811, cash_paid=51.07999666666665, later_sold_to_retail_FIFO=1090.5276666666678, later_sold_to_arb_FIFO=102.30233333333348, YES_left_FIFO=1010.1251666666668. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule cross_above; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=238.7590833333333, purchase_edge=-0.4122060319246246, arb_purchase_edge=-0.4152410537118379, cash_paid=6.485806666666666, later_sold_to_retail_FIFO=215.17516666666674, later_sold_to_arb_FIFO=3.366333333333333, YES_left_FIFO=20.217583333333305. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule cross_below; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=437.35316666666665, purchase_edge=-0.08040163241039465, arb_purchase_edge=-0.47666847803972673, cash_paid=11.543201666666667, later_sold_to_retail_FIFO=366.79800000000006, later_sold_to_arb_FIFO=32.31524999999999, YES_left_FIFO=38.23991666666669. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule topup_above; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=175.0784166666667, purchase_edge=-1.330576859007936, arb_purchase_edge=-1.332776348252568, cash_paid=4.658397500000001, later_sold_to_retail_FIFO=143.01458333333332, later_sold_to_arb_FIFO=13.644999999999976, YES_left_FIFO=18.418833333333353. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Start-file purchase rule reserve_1c; 120 spread-3 seeds, first matching seeds in 30000-37999; per-run shares_bought=1589.4508333333333, purchase_edge=-2.0132339525570977, arb_purchase_edge=-2.021707766330571, cash_paid=15.894508333333333, later_sold_to_retail_FIFO=1147.9175, later_sold_to_arb_FIFO=5.473500000000007, YES_left_FIFO=436.05983333333353. FIFO attribution uses only genuinely covered sales; purchase edge is probability after the move minus purchase price, times quantity.", "Purchase-rule labels split ordinary main bids at five cents: main_bid_below_5c is ticks 1-4; main_bid is ticks 5-99. All purchase measurements use 120 matching spread-3 runs and FIFO attribution of covered sales.", "Scratch logging/scoring parity: all 120 instrumented start-file results equal untouched-engine results in every SimulationResult field. Mean final YES=1737.003."], "holdout": {"mean_edge": 134.19932950401522, "retail_edge": 160.58570270161084, "arb_edge": -26.386373197572574, "failures": 0}, "diff": {"mean": 0.47007203154326677, "standard_error": 0.03732200600673963, "retail": 0.0060683258712873256, "arb": 0.46400370567267324, "trimmed": 0.3580035060823226, "runs_up": 271, "runs_down": 12}, "others_identical": {"runs": 450, "identical": true}, "seconds": {"start": 136.86203591385856, "yours": 133.20383351691999}, "code": "\"\"\"Crossing-cover base with isolated, untuned per-spread overrides stacked: each acts only in runs of its own competitor spread.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\nP = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n         qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05,\n         ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n         fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0,\n         ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0,\n         ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\ndef cdf(x): return 0.5 * (1.0 + math.erf(x / SQ2))\ndef pdf(x): return math.exp(-0.5 * x * x) / SQ2PI\ndef inv(p):\n    p = min(max(p, 1e-9), 1 - 1e-9)\n    t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n    x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n    x = -x if p < 0.5 else x\n    for _ in range(2):\n        d = pdf(x)\n        if d < 1e-12:\n            break\n        x -= (cdf(x) - p) / d\n    return x\ndef lpm(k):\n    return pdf(k) + k * cdf(k)\ndef fl(q):\n    return math.floor(q * 100 + 1e-9) / 100\n\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\n\n\nclass Strategy(BaseStrategy):\n    def __init__(self):\n        self.n = 0\n        self.ahead = set()     # main orders placed strictly ahead of any competitor order at their tick\n        self.res = {}          # order id -> uncovered quantity at placement\n        self.bc = None         # belief: sub-tick grid centres (ticks)\n        self.bw = None         # belief: weights\n        self.st = 0.5          # last one-step sd in ticks\n        self.pcb = self.pca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None          # competitor spread parameter\n        self.flow_notional = 0.0\n        self.flow_exposure = 0\n        self.last_ask_tick = None\n        self.last_quote_exposed = False\n        self.last_flow_ca = None\n        self.last_flow_cap = 0.0\n        self.last_flow_correction = 1.0\n        self.params = P.copy()\n\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def on_step(self, state):\n        H = max(1, state.steps_remaining)\n        cb = state.competitor_best_bid_ticks or 0\n        ca = state.competitor_best_ask_ticks or 100\n        if self.s is None:\n            self.s = max(1, (ca - cb + 1) // 2)\n            if self.s == 4:\n                # Censored compound-Poisson flow likelihood, using only our fills.\n                self.f4_exposure = [0, 0]\n                self.f4_events = [0, 0]\n                self.f4_weights = [[0.0] * 9, [0.0] * 9]\n                self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n                # Positive aggregate flow is approximately lognormal; +0.065\n                # accounts for the occasional second arrival in a timestep.\n                self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n                self.f4_last = [None, None]\n                self.f4_rate = 0.1265\n                self.f4_mean = 4.488\n                self.f4_flow = self.f4_rate * self.f4_mean\n                self.f4_extreme = inv(1 - 1e-6)\n            if self.s == 2:\n                self.params.update(dict(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\n            if self.s == 1:\n                self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n            if self.s == 3:\n                self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n        P = self.params\n        if self.s == 4:\n            for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n                last = self.f4_last[side]\n                if last is None:\n                    continue\n                tick, conv, cap, old_bound, ids = last\n                if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n                    continue\n                # Track only the main quote, excluding probes and stock orders.\n                remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n                value = max(0.0, cap - remaining * conv)\n                self.f4_exposure[side] += 1\n                if value > 0.01:\n                    self.f4_events[side] += 1\n                    censored = remaining < 0.011\n                    logv = math.log(max(value, 0.01))\n                    weights = self.f4_weights[side]\n                    for i, mu4 in enumerate(self.f4_mu):\n                        z4 = (logv - mu4) / 1.2\n                        weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n            if state.step % 25 == 0:\n                exposure = sum(self.f4_exposure)\n                events = sum(self.f4_events)\n                event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n                self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n                weights = [a + b for a, b in zip(*self.f4_weights)]\n                peak = max(weights)\n                weights = [math.exp(w - peak) for w in weights]\n                self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n                self.f4_flow = self.f4_rate * self.f4_mean\n        if self.s == 3 and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n            self.flow_exposure += 1\n            self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n        lo, hi = cb, ca\n        for o in state.own_orders:\n            if o.side is Side.BUY:\n                lo = max(lo, o.price_ticks)\n            else:\n                hi = min(hi, o.price_ticks)\n        if P['pinf'] > 0:\n            sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n            sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n            ea = self.pa - sa\n            eb = self.pb - sb\n            if sa and ea:\n                lo = max(lo, min(max(ea), hi))\n            if eb and (sb or min(eb) <= P['p1t']):\n                hi = min(hi, max(min(eb), lo))\n        if P['jumpinfo'] > 0 and self.pcb is not None:\n            if ca > self.pca + 1:\n                lo = max(lo, ca - 1)\n            if cb < self.pcb - 1:\n                hi = min(hi, cb + 1)\n        self.pcb, self.pca = cb, ca\n        if lo > hi:\n            lo, hi = hi, lo\n        # sub-tick belief over p_(t-1): predict with one-step noise, truncate to [lo, hi]\n        wid = max(hi - lo, 1e-6)\n        nb = max(2, min(48, int(round(wid * P['bins']))))\n        cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n        if self.bc is None or P['filt'] <= 0:\n            ws = [1.0 / nb] * nb\n        else:\n            sg = max(self.st, 0.6 * wid / nb)\n            k = -0.5 / (sg * sg)\n            ws = []\n            uni = P['uni'] * sg\n            if self.s == 4:\n                exp = math.exp\n                if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n                    # On this stationary grid, spacing is exactly 1/8 tick.\n                    # Equal index distances therefore have bit-identical d*d*k.\n                    # Reuse exp values while retaining the original sum order.\n                    kernel = []\n                    c0 = cs[0]\n                    for ci in self.bc:\n                        d = c0 - ci\n                        d2 = d * d * k\n                        kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n                    kernel = kernel[:0:-1] + kernel\n                    for i in range(nb):\n                        t = uni\n                        start = nb - 1 - i\n                        for wi, e in zip(self.bw, kernel[start:start + nb]):\n                            if e:\n                                t += wi * e\n                        ws.append(t)\n                else:\n                    previous = tuple(zip(self.bc, self.bw))\n                    for c in cs:\n                        t = uni\n                        for ci, wi in previous:\n                            d = c - ci\n                            d2 = d * d * k\n                            if d2 > -12.5:\n                                t += wi * exp(d2)\n                        ws.append(t)\n            else:\n                for c in cs:\n                    t = uni\n                    for ci, wi in zip(self.bc, self.bw):\n                        d = c - ci\n                        d2 = d * d * k\n                        if d2 > -12.5:\n                            t += wi * math.exp(d2)\n                    ws.append(t)\n            tot = sum(ws)\n            ws = [w / tot for w in ws]\n        self.bc, self.bw = cs, ws\n        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            if self.s == 4:\n                ja = jb = 0.0\n                for p, w in jp:\n                    if x > p:\n                        ja += w * (x - p)\n                    else:\n                        jb += w * (p - x)\n            else:\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            if self.s == 4 and tail <= 1e-6:\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\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            if self.s == 4 and phat * 100 - t < P['dmin']:\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            if self.s == 4 and t - phat * 100 < P['dmin']:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            if self.s == 4:\n                tail = b * kA / max(self.f4_rate * a, 1e-30)\n                if a <= 0 or tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n            if self.s == 2 and phat < 0.1:\n                a = max(0.0, a - 0.0015 * (1 - min(1.0, state.yes_inventory / 3000.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            threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else P['min_ahead']\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\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        if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n            qa *= 5\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            flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n            target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(flow_scale * 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 (self.s != 3 or Y < qa) 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, qa - Y) if self.s == 3 else min(P['ammo_q'], target - Y)\n            elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n                amt, qam = t - 1, min(P['qf'], full - Y)  # rest just under p: filled only on the crossing, or by retail\n\n        if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n            stock_rate = P['ydf1']\n            if self.s == 4:\n                stock_rate *= self.f4_flow / 0.6\n            if self.s == 3:\n                flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n                scale = max(0.5, min(2.0, flow / P['flow_level']))\n                stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n            q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n\n        # Bridge expected retail demand until another tick crossing is available.\n        if 0.02 < phat < 0.1:\n            ct = max(2, min(99, int(math.floor(ptick))))\n            wealth = state.cash + Y * phat\n            goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            if Y < goal and ct < ask_t:\n                amt, qam = ct, min(3000.0, goal - Y)\n        # order management\n        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            x = o.price_ticks / 100.0\n            if o.side is Side.BUY:\n                free += x * o.remaining_quantity\n            else:\n                free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n            self.ahead.discard(o.order_id)\n            self.res.pop(o.order_id, None)\n        for o in state.own_orders:\n            if o.remaining_quantity <= PROBE + 1e-9:\n                cancel(o)\n        kept_ids = set()\n        def manage(orders, t, q, comp):\n            kept = 0.0\n            for o in orders:\n                if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\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                if self.s == 2:\n                    ub = min(ub, max(0.0, free - 200 * min(1.0, H / 50.0)))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # probes: tiny orders that the arbitrageur removes when p crosses them\n        f = int(math.floor(ptick + 1e-9))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n                    self.pb.add(t)\n            for t in range(f + 1 - r, f + 2):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n                    self.pa.add(t)\n        if self.s == 3:\n            self.last_ask_tick = ask_t\n            self.last_flow_ca = ca\n            exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n            self.last_flow_cap = exposed_qty * ask_t / 100.0\n            self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n            if self.last_quote_exposed:\n                logcap = math.log(self.last_flow_cap)\n                mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n                clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n                self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n        if self.s == 4:\n            self.f4_last = [None, None]\n            # Eligibility is decided before observing fills, so depleted quotes\n            # remain in the sample as right-censored observations.\n            for side, tick, bound, conv, distance in (\n                (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n                (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n                if distance < max(0.01, 3.0 * self.st / 100.0):\n                    continue\n                if side == 0:\n                    if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n                        continue\n                    orders = asks\n                    order_side = Side.SELL\n                else:\n                    if not (bid_t > cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n                        continue\n                    if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n                        continue\n                    orders = bids\n                    order_side = Side.BUY\n                tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n                tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n                cap = sum(tracked.values()) * conv\n                if cap >= 0.5:\n                    self.f4_last[side] = (tick, conv, cap, bound, tracked)\n        return actions + out\n", "code_sha256": "efc27c4ca872b17a3aa78d4ca28e9cb1e5655daeb042a2f98c29abc3abd3ebc0", "tried": ["Python 3.10.12; simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; standard library only; no sandbox. Scorer command: cd .cache/simulator && python3 -m orderbook_pm_challenge run ../earlier.py --simulations 600 --seed-start 1000 --workers 4 --json. Mean edge using simulator's sum/count is 108.64128535876738, supplied reference 108.63974289615767, difference 0.001542462609705808, failures 0, elapsed 618.67 seconds. The supplied earlier artifact records Python 3.12.3; this run uses Python 3.10.12. The discrepancy is reported, not treated as an exact match, and its numerical cause was not established. Both downloaded strategy hashes match their source artifacts.", "Scorer exceeded five minutes; subsequent full choosing count is halved from 1938 to 969 spread-3 seeds; confirming count halved from 2020 to 1010; other-spread counts halved from 300 to 150 each; timing halved from 200 to 100 each. The full 1938-run choosing baseline and initial 240-run no_top/demand pilots were launched before the scorer completed and retained; later structural ideas used the same 240 pilot seeds. No constants were tuned; candidates changed purchase-rule structure using existing flow estimates and thresholds.", "Pilot no_top (remove repeated above-probability cover top-ups; preserve near-crossing buys), first 240 spread-3 seeds in 30000-37999, paired versus start: {\"arb\": 0.6913225796750003, \"failures\": 0, \"mean\": 0.4666116284266664, \"n\": 240, \"retail\": -0.22471095125416712, \"runs_down\": 7, \"runs_up\": 73, \"standard_error\": 0.13928312492710837, \"trimmed\": 0.2625797225813633}.", "Pilot demand (cap planned cover and one-cent reserve jointly at estimated remaining retail notional divided by current ask price, less YES inventory), first 240 spread-3 seeds in 30000-37999, paired versus start: {\"arb\": 0.3740455693716667, \"failures\": 0, \"mean\": 0.3510582597099999, \"n\": 240, \"retail\": -0.022987309662499643, \"runs_down\": 21, \"runs_up\": 67, \"standard_error\": 0.2012021580066616, \"trimmed\": 0.10807318656545407}.", "Pilot cross_demand (combine no_top with demand cap), first 240 spread-3 seeds in 30000-37999, paired versus start: {\"arb\": 1.1545749061170836, \"failures\": 0, \"mean\": 0.7759278421170827, \"n\": 240, \"retail\": -0.37864706400666703, \"runs_down\": 16, \"runs_up\": 93, \"standard_error\": 0.27235574432208937, \"trimmed\": 0.5519350447699995}.", "Pilot all_stock_cap (also cap ordinary bids above estimated probability by the same remaining stock shortfall), first 240 spread-3 seeds in 30000-37999, paired versus start: {\"arb\": 1.1545749061170836, \"failures\": 0, \"mean\": 0.7759278421170827, \"n\": 240, \"retail\": -0.37864706400666703, \"runs_down\": 16, \"runs_up\": 93, \"standard_error\": 0.27235574432208937, \"trimmed\": 0.5519350447699995}.", "First-wave no_top validation, 729 previously unused matching seeds 30981-34028: {\"arb\": 1.3901892799436213, \"failures\": 0, \"mean\": -0.5070741425606313, \"n\": 729, \"retail\": -1.8972634225042526, \"runs_down\": 21, \"runs_up\": 242, \"standard_error\": 0.554472364750368, \"trimmed\": 0.6626459416014102}. Rejected because paired mean is negative, despite a positive trimmed mean.", "First-wave cross_demand validation, 729 previously unused matching seeds 30981-34028: {\"arb\": 1.4253315172379972, \"failures\": 0, \"mean\": -1.4584532137377237, \"n\": 729, \"retail\": -2.883784730976543, \"runs_down\": 72, \"runs_up\": 287, \"standard_error\": 0.7018409681060956, \"trimmed\": 0.6053045745684057}. Rejected because paired mean is negative, despite a positive trimmed mean.", "First-wave combined versus no_top validation: {\"arb\": 0.03514223729437589, \"failures\": 0, \"mean\": -0.9513790711770924, \"n\": 729, \"retail\": -0.9865213084722906, \"runs_down\": 104, \"runs_up\": 189, \"standard_error\": 0.348695782108851, \"trimmed\": 0.0333579201514804}. Both candidates rejected before confirmation. The main-bid add-on was inert in all 240 pilot runs and discarded.", "Follow-up structural ideas preserve needed top-ups: urgent_cover buys above estimated probability only when YES inventory is below desired ordinary ask quantity and caps purchase by that shortfall; low_tick_cover removes repeated top-ups only above the lowest visible one-cent tick. No fitted constants. To avoid using old validation for invention and testing, these ideas use the disjoint second 969 spread-3 choosing runs: 240 pilot seeds at sorted indices 969-1208 and 729 fresh validation seeds at indices 1209-1937. Baseline results for these seeds had not been inspected for designing these follow-ups. Confirmation seeds remain untouched.", "Fresh second-wave pilot urgent: {\"arb\": 0.4633926548258333, \"failures\": 0, \"mean\": 0.42553877066624884, \"n\": 240, \"retail\": -0.037853884159167114, \"runs_down\": 7, \"runs_up\": 59, \"standard_error\": 0.07283642425368429, \"trimmed\": 0.15942424431045368}. Pilot gain passed; validation launched only on the next 729 uninspected matching seeds.", "Fresh second-wave pilot low_tick: {\"arb\": 0.7106826239612499, \"failures\": 0, \"mean\": 0.5752894278108331, \"n\": 240, \"retail\": -0.1353931961508336, \"runs_down\": 9, \"runs_up\": 69, \"standard_error\": 0.10637129337810532, \"trimmed\": 0.254267921766363}. Pilot gain passed; validation launched only on the next 729 uninspected matching seeds.", "Fresh second-wave urgent_pilot: {\"arb\": 0.4633926548258333, \"failures\": 0, \"mean\": 0.42553877066624884, \"n\": 240, \"retail\": -0.037853884159167114, \"runs_down\": 7, \"runs_up\": 59, \"standard_error\": 0.07283642425368429, \"trimmed\": 0.15942424431045368}.", "Fresh second-wave urgent_validation: {\"arb\": 0.6087281065882029, \"failures\": 0, \"mean\": 0.6436335800942391, \"n\": 729, \"retail\": 0.034905473505898205, \"runs_down\": 11, \"runs_up\": 230, \"standard_error\": 0.11624406480776733, \"trimmed\": 0.4023843075816649}.", "Fresh second-wave low_tick_pilot: {\"arb\": 0.7106826239612499, \"failures\": 0, \"mean\": 0.5752894278108331, \"n\": 240, \"retail\": -0.1353931961508336, \"runs_down\": 9, \"runs_up\": 69, \"standard_error\": 0.10637129337810532, \"trimmed\": 0.254267921766363}.", "Fresh second-wave low_tick_validation: {\"arb\": 0.4780898451995883, \"failures\": 0, \"mean\": 0.37716809351385533, \"n\": 729, \"retail\": -0.10092175168367702, \"runs_down\": 20, \"runs_up\": 233, \"standard_error\": 0.2410484293977062, \"trimmed\": 0.465829073788012}.", "Fresh second-wave low_tick_increment_pilot: {\"arb\": 0.24728996913541665, \"failures\": 0, \"mean\": 0.1497506571445843, \"n\": 240, \"retail\": -0.09753931199166649, \"runs_down\": 4, \"runs_up\": 21, \"standard_error\": 0.0745479425325072, \"trimmed\": -2.0605315454489604e-05}.", "Fresh second-wave low_tick_increment_validation: {\"arb\": -0.13063826138861453, \"failures\": 0, \"mean\": -0.26646548658038377, \"n\": 729, \"retail\": -0.1358272251895752, \"runs_down\": 14, \"runs_up\": 36, \"standard_error\": 0.20868671580051665, \"trimmed\": 0.0211962880633287}.", "Second-wave pilot/validation are 240/729 matching spread-3 seeds in the unused second half of 30000-37999, with no overlap with first-wave design/validation. Selection requires positive paired mean, positive 20-outlier-trimmed mean, and more improved than worsened runs in both pilot and validation. Selected urgent_cover; froze SHA-256 efc27c4ca872b17a3aa78d4ca28e9cb1e5655daeb042a2f98c29abc3abd3ebc0 at 2026-11-06T15:59:07.884569+00:00 before scoring any confirmation seeds.", "The low-tick-boundary alternative passed as a standalone candidate but was not chosen: its incremental result versus urgent_cover failed the pilot trimmed-mean check and had a negative validation mean. Urgent_cover had the higher validation mean and lower standard error. No confirmation results were used in this selection.", "Frozen confirmation: first 1010 matching spread-3 seeds in 90000-97999, actual range 90000-93973; baseline mean_edge=133.72925747247197; paired result {\"arb\": 0.46400370567267324, \"failures\": 0, \"mean\": 0.47007203154326677, \"n\": 1010, \"retail\": 0.0060683258712873256, \"runs_down\": 12, \"runs_up\": 271, \"standard_error\": 0.03732200600673963, \"trimmed\": 0.3580035060823226}. No constants or strategy rules changed after freeze. Trimmed excludes the 20 largest absolute paired differences as specified.", "Other spreads: both files run independently on first 150 matching seeds for each of spreads 1, 2, 4 from 90000 onwards (450 paired runs total, reduced from 900 because of Step 1 runtime). Every SimulationResult field identical in every pair; all failures=0.", "Timing in one process with other simulation jobs finished: each file on same first 100 spread-3 matching seeds from 90000 onwards (halved from 200); start_seconds=136.86203591385856, yours_seconds=133.20383351691999, ratio=0.973270875502385. All 100 serial results per file also match corresponding parallel confirmation results in every field. Final builder checks code SHA-256, 50000-byte code bound, 64000-byte result bound, FIFO share conservation and all 120 logged-vs-original result fields; sources are re-fetched and exact quotes checked."], "next": "Investigate inventory-aware sizing of main bids below five cents, which left the most YES at expiry in FIFO measurements. Forecast the future ask-price path when estimating remaining share demand: a static current-ask cap saved arbitrage cost but lost more retail on separate validation. Preserve urgent cover below the lowest visible tick and use fresh paired validation for any new rule."}