{
  "approach": "Start from the priced spread-4 flow-estimation block c80c33382f9c458ab6286dbc11fa761100a7e156dad7f3c12d74040b7c76578f. Join the retained behavioral changes: halve normal bid depth below five cents at bid ticks >=2; require 50 shares ahead at the rival ask below five cents before staying at that tick; multiply middle-price ask loss by 1.4 before flow-based sizing. Every added rule is gated on self.s == 4. Flow estimation and its arithmetic-preserving optimizations occur once; overlapping optimization edits were not stacked. Constants are copied unchanged, and the strategy uses only public callback state. Selection used full choosing-seed paired differences; confirmation followed a recorded code freeze. All numerical results are local measurements using the linked, unmodified simulator, not scores from Paradigm.",
  "blocked": null,
  "spread": 4,
  "base_mean_edge": 108.63974289615767,
  "contains": [
    "priced",
    "s4-bids",
    "s4-asks",
    "s4-middle"
  ],
  "holdout": {
    "mean_edge": 149.88068239544955,
    "retail_edge": 174.81916364410174,
    "arb_edge": -24.938481248681338,
    "failures": 0
  },
  "diff": {
    "mean": 2.163802854692901,
    "standard_error": 0.37363360350464353,
    "retail": -1.5476680507807814,
    "arb": 3.7114709054788033
  },
  "vs_priced": {
    "mean": 1.093612110448124,
    "standard_error": 0.15242673594139847
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "base": 137.76304837525822,
    "yours": 139.73779390007257
  },
  "code": "\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\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 == 1:\n                self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n            if self.s == 4:\n                self.params['ka4'] = 1.4\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 and P['pL'] <= phat <= 0.95:\n                b *= P['ka4']\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            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        ma_ask = 50.0 if (self.s == 4 and phat < 0.05) else P['min_ahead']\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) >= (ma_ask if step < 0 else 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        if self.s == 4 and phat < 0.05 and bid_t >= 2:\n            qb *= 0.5\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            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 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            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):\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        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": "2314723a8e7644db204d39a7b4d53aa8c59a90bc3edf46b53dbf4978ab52cef0",
  "tried": [
    "Scorer: unmodified simulator b244530ee2a6247b5f930830eeca9dd950da0e7e; Python 3.13.5; default 2000 steps; no sandbox or external dependencies. Required parent CLI: 600 simulations, seed_start=1000, workers=4; mean_edge=108.63974289615767, failures=0, seconds=87.41626536403783; exact match to 108.63974289615767. No run counts halved.",
    "Choosing: all 1953 spread-4 seeds in inclusive range 20000..27999, selected only by sample_config(ChallengeConfig(), ParameterVariance(), seed=N).competitor.spread_ticks. Every addition paired against its preceding file on these same seeds. All supplied constants retained. No earlier-seat ranges used.",
    "Join verification: each extracted behavioral piece on the base matched its complete source strategy action-for-action on the first 16 spread-4 choosing seeds: 80 simulations, 160000 callbacks. Priced performance optimizations retained once; overlapping performance-only edits from the other pieces omitted.",
    "Choose priced+s4-bids: n=1953, mean_edge=154.68121889054373, previous=priced, incremental_mean=0.43694355223000486, incremental_standard_error=0.10298687642675447, incremental_retail=-0.14689090730256016, incremental_arb=0.58383445953277, vs_priced_mean=0.43694355223000486, vs_priced_standard_error=0.10298687642675447, failures=0, selected_at_stage=false.",
    "Choose priced+s4-asks: n=1953, mean_edge=154.71427029266263, previous=priced, incremental_mean=0.46999495434889915, incremental_standard_error=0.06397783568934598, incremental_retail=0.45830218777890386, incremental_arb=0.01169276656743478, vs_priced_mean=0.46999495434889915, vs_priced_standard_error=0.06397783568934598, failures=0, selected_at_stage=true.",
    "Choose priced+s4-queue: n=1953, mean_edge=154.46728453171238, previous=priced, incremental_mean=0.22300919339866876, incremental_standard_error=0.08078797968772128, incremental_retail=0.5164054269525341, incremental_arb=-0.29339623355463385, vs_priced_mean=0.22300919339866876, vs_priced_standard_error=0.08078797968772128, failures=0, selected_at_stage=false.",
    "Choose priced+s4-middle: n=1953, mean_edge=154.39510300860618, previous=priced, incremental_mean=0.15082767029247302, incremental_standard_error=0.16821504415434357, incremental_retail=-1.5440997353403991, incremental_arb=1.6949274056320534, vs_priced_mean=0.15082767029247302, vs_priced_standard_error=0.16821504415434357, failures=0, selected_at_stage=false.",
    "Choose priced+q4-ahead: n=1953, mean_edge=154.298596665912, previous=priced, incremental_mean=0.05432132759825955, incremental_standard_error=0.06909267408102848, incremental_retail=0.13377603125299553, incremental_arb=-0.07945470366861242, vs_priced_mean=0.05432132759825955, vs_priced_standard_error=0.06909267408102848, failures=0, selected_at_stage=false.",
    "Choose priced+s4-bids+s4-asks: n=1953, mean_edge=155.07966483327712, previous=pair-s4-asks, incremental_mean=0.3653945406144901, incremental_standard_error=0.14872099608890346, incremental_retail=-0.13935364999877123, incremental_arb=0.5047481906124935, vs_priced_mean=0.8353894949633892, vs_priced_standard_error=0.16193287167503542, failures=0, selected_at_stage=true.",
    "Choose priced+s4-asks+s4-queue: n=1953, mean_edge=154.98881616897046, previous=pair-s4-asks, incremental_mean=0.27454587630783417, incremental_standard_error=0.0737312404412192, incremental_retail=0.5642316532427545, incremental_arb=-0.2896857769349206, vs_priced_mean=0.7445408306567334, vs_priced_standard_error=0.0975311648618069, failures=0, selected_at_stage=false.",
    "Choose priced+s4-asks+s4-middle: n=1953, mean_edge=154.8883085117696, previous=pair-s4-asks, incremental_mean=0.17403821910696374, incremental_standard_error=0.1574807808007668, incremental_retail=-1.5447534143292876, incremental_arb=1.718791633438505, vs_priced_mean=0.6440331734558629, vs_priced_standard_error=0.1723446058062074, failures=0, selected_at_stage=false.",
    "Choose priced+s4-asks+q4-ahead: n=1953, mean_edge=154.79207387223025, previous=pair-s4-asks, incremental_mean=0.07780357956763978, incremental_standard_error=0.06076914931895787, incremental_retail=0.13656693176359458, incremental_arb=-0.05876335220814141, vs_priced_mean=0.547798533916539, vs_priced_standard_error=0.08882118067577387, failures=0, selected_at_stage=false.",
    "Choose priced+s4-bids+s4-asks+s4-queue: n=1953, mean_edge=155.37650716566253, previous=triple-0-1, incremental_mean=0.29684233238540764, incremental_standard_error=0.08382319366450133, incremental_retail=0.5480399362443927, incremental_arb=-0.2511976038574501, vs_priced_mean=1.132231827348797, vs_priced_standard_error=0.17904500626504094, failures=0, selected_at_stage=false.",
    "Choose priced+s4-bids+s4-asks+s4-middle: n=1953, mean_edge=155.46983497568746, previous=triple-0-1, incremental_mean=0.39017014241034353, incremental_standard_error=0.19277905710000523, incremental_retail=-1.5248066672337426, incremental_arb=1.9149768096490014, vs_priced_mean=1.2255596373737327, vs_priced_standard_error=0.1799140853869194, failures=0, selected_at_stage=true.",
    "Choose priced+s4-bids+s4-asks+q4-ahead: n=1953, mean_edge=155.36061173310088, previous=triple-0-1, incremental_mean=0.28094689982375887, incremental_standard_error=0.12372320651857362, incremental_retail=0.16788433542698414, incremental_arb=0.11306256438540711, vs_priced_mean=1.116336394787148, vs_priced_standard_error=0.12842299533701892, failures=0, selected_at_stage=false.",
    "Search rule fixed before confirmation: select the highest-mean positive pair, evaluate every remaining piece as an addition to that pair, retain the highest positive triple, then evaluate every remaining addition to that triple and retain the highest positive four-piece file. This is a measured greedy extension path, not an exhaustive search of all triples and quadruples.",
    "Frozen before confirmation: selected=quad-0-1-3, UTC=2026-11-06T15:57:14.957963+00:00, sha256=2314723a8e7644db204d39a7b4d53aa8c59a90bc3edf46b53dbf4978ab52cef0.",
    "Confirmation: all 1972 spread-4 seeds in 80000..87999, paired for frozen/base/priced. Frozen minus priced: mean=1.093612110448124, standard_error=0.15242673594139847. Final source=frozen; the only permitted holdout selection was fallback to the original priced file if the frozen gain was nonpositive.",
    "Paired standard errors use sample standard deviation of per-seed total-edge differences divided by sqrt(n). Retail and arbitrage fields are means of signed edge; no rounding added. Failed simulations are reported; none excluded from these comparisons.",
    "Other spreads: 300 seeds of each spread 1, 2, 3, starting at 80000 in ascending order. Every field of SimulationResult matched the base exactly on all 900 runs; no failures.",
    "Timing: first 200 confirming spread-4 seeds, both files in one process, alternating execution order by seed, one warmup per file. Timed engine construction/run plus result conversion; configuration sampling/loading excluded. Wall base=137.76304837525822, yours=139.73779390007257, ratio=1.0143343628651078. CPU base=137.38213894400002, yours=139.36104467999996, ratio=1.0144043887452254. Every timed result matched its confirmation result.",
    "Local simulator findings only; no Paradigm submission or leaderboard gain claimed."
  ],
  "next": "Have the operator price this frozen block on Paradigm. Next measure s4-queue and q4-ahead as separate fifth additions on fresh choosing seeds, keeping constants fixed and confirming independently: their positive increments on the triple do not establish gains on this four-piece block."
}