{
  "approach": "Spread-1 bid queue banking. Keep a proven front BUY order below the current bid target while the total retained at its tick fits keep_hi times the existing qbid(tick) risk-size rule; these lower seats survive upward moves instead of being canceled. At the current rival bid, preserve an existing front order while qbid is positive rather than discarding its priority on a one-step size shrink, and accept a non-probe remainder down to 0.02 shares. Assign tracked IDs to auxiliary amt stock bids placed above the rival bid so their priority is recognized; q1 stock orders are unchanged. Never add main bid quantity at the rival tick. All behavior changes are guarded by self.s == 1. Exact early distance rejections in qbid/qask avoid calculations whose results would be discarded. Reusing an ordered list of previous belief pairs avoids repeated iterator construction without changing any arithmetic or trading decisions; this offsets queue-management cost. Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; baseline reproduced exactly over 4000 seeds from 4000. Selection used 525 tuning runs and 502 separate validation runs; trading policy was frozen before unseen scoring, and the exact speed-only version was then rerun on all 1969 unseen spread-1 runs. On 220 tuning runs, retail shares filled first at the rival best bid rose from 42506.03 to 59191.909999999996, with share-weighted resting age rising from 22.975113413320415 to 50.38271480004615 steps; the full diagnostic is in tried.",
  "blocked": null,
  "spread": 1,
  "base_mean_edge": 98.4694596619638,
  "base_unseen": {
    "mean_edge": 41.78494849744236,
    "retail_edge": 65.91107840022042,
    "arb_edge": -24.1261299027871
  },
  "holdout": {
    "mean_edge": 42.57676949730853,
    "retail_edge": 66.69230111783418,
    "arb_edge": -24.115531620531186,
    "failures": 0
  },
  "diff": {
    "mean": 0.7918209998661755,
    "standard_error": 0.09450463259327119,
    "retail": 0.7812227176137635,
    "arb": 0.010598282255916568
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "base": 235.0572096775286,
    "yours": 219.3713394990191
  },
  "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 == 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 == 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            # Reuse the same ordered belief pairs; all sums retain their order.\n            pairs = list(zip(self.bc, self.bw)) if self.s == 1 else None\n            uni = P['uni'] * sg\n            for c in cs:\n                t = uni\n                for ci, wi in (pairs if pairs is not None else 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            ja = sum(w * max(0.0, x - p) for p, w in jp)\n            jb = sum(w * max(0.0, p - x) for p, w in jp)\n            return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n\n        if H == 1:\n            def AB(x):\n                return (1 - phat) * x, phat * (1 - x)\n        rho = P['lam_r'] * 0.5\n        mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n        kA = P['kL'] if phat < P['pL'] else P['kA']\n\n        def qsize(loss, gain, px):\n            loss *= kA\n            if gain <= 0:\n                return 0.0\n            tail = loss / (rho * gain)\n            if tail >= 1.0:\n                return 0.0\n            return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n        ptk = phat * 100\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 1 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 == 1 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            return qsize(b, a, t / 100.0)\n\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n        sticky = P['sticky'] > 0\n        def top(orders, comp, step):\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= (PROBE + 0.01 if self.s == 1 and step == 1 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        qa = qask(ask_t)\n\n        Y = state.yes_inventory\n        if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n            qa = qa if Y >= P['a1'] > 0 else 0.0          # let the competitor's 2-tick ask erode instead of fronting it for nothing\n        # ammunition: hold YES so that low asks are covered\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n                amt, qam = t, min(P['qf'], full - Y)     # a tick p has just crossed: nearly free\n            elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n                amt, qam = t, min(P['ammo_q'], target - Y)\n            elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n                amt, qam = t - 1, min(P['qf'], full - Y)  # rest just under p: filled only on the crossing, or by retail\n\n        if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n            stock_rate = P['ydf1']\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            banked = {}\n            for o in orders:\n                if self.s == 1 and o.side is Side.BUY and o.order_id in self.ahead and o.price_ticks < t and banked.get(o.price_ticks, 0.0) + o.remaining_quantity <= P['keep_hi'] * qbid(o.price_ticks):\n                    banked[o.price_ticks] = banked.get(o.price_ticks, 0.0) + o.remaining_quantity\n                    kept_ids.add(o.order_id)\n                elif 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.BUY and o.order_id in self.ahead and o.price_ticks == comp)):\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            if self.s == 1:\n                oid = self._oid('m')\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n                if amt > cb:\n                    self.ahead.add(oid)\n            else:\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        return actions + out\n",
  "code_sha256": "44946eac600d1e701d700252ae49cc695b3f91c0f0a89de4cd369ab30ac199b2",
  "tried": [
    "auxkeep_dev (also track auxiliary stock bid priority): n=114; mean delta=0.16318356572368342; SE=0.10231173611674056; retail delta=0.12117205295263084; arb delta=0.04201151276842055; failures=0.",
    "bank0.6_dev (bank lower proven front bids with at least 0.6 tick estimated distance): n=114; mean delta=2.473893698956141; SE=1.419241290246727; retail delta=0.819001597828947; arb delta=1.654892101153507; failures=0.",
    "bank1.0_dev (bank lower proven front bids with at least 1 tick estimated distance): n=114; mean delta=2.473893698956141; SE=1.419241290246727; retail delta=0.819001597828947; arb delta=1.654892101153507; failures=0.",
    "bankrisk_dev (bank lower proven front bids within the existing price-specific quantity rule, with current-front preservation): n=114; mean delta=2.473893698956141; SE=1.419241290246727; retail delta=0.819001597828947; arb delta=1.654892101153507; failures=0.",
    "keep_dev (preserve current front bid through size shrink, recognize remaining quantities above probe size): n=114; mean delta=0.058058160507016496; SE=0.019670066911633588; retail delta=0.04603398355964871; arb delta=0.012024176944736438; failures=0.",
    "life4_dev (fourfold reduction of marginal bid risk penalty to size for a longer life): n=114; mean delta=-2.9917706269201765; SE=3.6646206805861037; retail delta=-0.9762777223780716; arb delta=-2.0154929045403516; failures=0.",
    "auxkeep_train (also track auxiliary stock bid priority): n=525; mean delta=0.1091693852156187; SE=0.03631787807396249; retail delta=0.1068930672923805; arb delta=0.002276317921904564; failures=0.",
    "bank0.6_train (bank lower proven front bids with at least 0.6 tick estimated distance): n=525; mean delta=0.8187147310152378; SE=0.34965400556626774; retail delta=0.6111333755571423; arb delta=0.20758135546418985; failures=0.",
    "bankaux_train (risk-limited lower banking plus auxiliary priority tracking and current-front preservation): n=525; mean delta=0.916574789945333; SE=0.34913199363773256; retail delta=0.6393045284270471; arb delta=0.2772702615243804; failures=0.",
    "bankauxcap_fast_train (aggregate-capped banking with auxiliary priority tracking): n=525; mean delta=0.798656330972952; SE=0.3408267221848185; retail delta=0.5611075084984763; arb delta=0.2375488224779043; failures=0.",
    "bankcap_fast_train (aggregate the lower front-bid quantity cap at each tick; exact early rejection optimization): n=525; mean delta=0.7800218349337139; SE=0.34034849796546524; retail delta=0.5425869394213334; arb delta=0.23743489551599953; failures=0.",
    "bankhigh_train (restrict distance-based banking to bids above 20 cents): n=525; mean delta=0.07009712639980936; SE=0.0278238219571279; retail delta=0.10580008549123812; arb delta=-0.03570295908761927; failures=0.",
    "banklead_fast_train (aggregate-capped banking, auxiliary priority tracking, preserve current front bid through size shrink and down to a non-probe remainder): n=525; mean delta=0.9176494373251426; SE=0.34915044053387806; retail delta=0.6393045284270471; arb delta=0.2783449089041899; failures=0.",
    "banklow_train (restrict distance-based banking to bids at or below 20 cents): n=525; mean delta=0.8164166511565714; SE=0.34970945716621926; retail delta=0.5839951831939045; arb delta=0.23242146796380916; failures=0.",
    "bankpositive_train (bank lower proven front bids whenever their price-specific qbid remains positive): n=525; mean delta=0.8263581459066665; SE=0.3496284404062711; retail delta=0.6111333755571423; arb delta=0.2152247703556184; failures=0.",
    "bankpure_train (bank lower proven front bids within existing quantity rule only): n=525; mean delta=0.7800415634100948; SE=0.34034842419873795; retail delta=0.5426079180453334; arb delta=0.23743364536819; failures=0.",
    "bankrisk_train (bank lower proven front bids within the existing price-specific quantity rule, with current-front preservation): n=525; mean delta=0.8663530108213331; SE=0.34852328992161347; retail delta=0.608265780235809; arb delta=0.2580872305916184; failures=0.",
    "banksd_train (bank lower proven front bids at least max(0.3 ticks, 2 one-step standard deviations) below estimate): n=525; mean delta=0.8366657634274283; SE=0.34857344514668204; retail delta=0.5867824711819042; arb delta=0.2498832922519994; failures=0.",
    "gap_bank0.6_train (wider-gap placement plus distance-based lower banking): n=525; mean delta=0.8187147310152378; SE=0.34965400556626774; retail delta=0.6111333755571423; arb delta=0.20758135546418985; failures=0.",
    "gap_base_train (place highest eligible bid inside a wider rival gap): n=525; mean delta=0.0; SE=0.0; retail delta=0.0; arb delta=0.0; failures=0.",
    "keep_train (preserve current front bid through size shrink, recognize remaining quantities above probe size): n=525; mean delta=0.07015293645714245; SE=0.02645362571455864; retail delta=0.07888097672666619; arb delta=-0.008728040270285878; failures=0.",
    "refill_train (add behind rival at the same tick when an earlier front quantity exists): n=525; mean delta=-0.11059471339009555; SE=0.07293788051093472; retail delta=0.19458257293276168; arb delta=-0.3051772863226671; failures=0.",
    "split_bank0.6_train (split a 2-share front seat and bank lower proven front bids): n=525; mean delta=0.8186443767845712; SE=0.34965353395329096; retail delta=0.611060745751809; arb delta=0.20758363103942792; failures=0.",
    "split_base_train (split a 2-share front seat from the main bid): n=525; mean delta=0.0001737487632379509; SE=0.0008041352607740564; retail delta=0.00017479792990467716; arb delta=-1.049166666630183e-06; failures=0.",
    "bankcap_fast_valid (aggregate the lower front-bid quantity cap at each tick; exact early rejection optimization): n=502; mean delta=0.5438561391844624; SE=0.10985485140079185; retail delta=0.47367040987231096; arb delta=0.07018572931394448; failures=0.",
    "banklead_fast_valid (aggregate-capped banking, auxiliary priority tracking, preserve current front bid through size shrink and down to a non-probe remainder): n=502; mean delta=0.5664569010093631; SE=0.11000894256990648; retail delta=0.4926848014832668; arb delta=0.07377209952569726; failures=0.",
    "bankpure_fast_valid (bankpure_fast): n=1511; mean delta=0.5722000144698213; SE=0.06984789160358959; retail delta=0.5448335394380547; arb delta=0.027366475036465904; failures=0.",
    "Discovery: spread-1 seeds in [8000,10000); independent validation: [10000,12000) for the final lead/aggregate-cap rules (502 runs), and [10000,16000) for the simpler lower-bank rule (1511 runs). Variants ending _dev used only [8000,8400). No unseen runs used to tune.",
    "Frozen candidate banklead_fast2: all 1969 spread-1 unseen seeds in [60000,68000); paired mean delta=0.7918209998661755, SE=0.09450463259327119.",
    "Runtime: alternating base/candidate order on the first 200 spread-1 seeds from 60000 in one process; wall seconds base=235.0572096775286, yours=219.3713394990191; CPU seconds base=201.26586647600038, yours=190.91542225599983.",
    "Initial frozen-policy timing failed the speed requirement: base wall seconds=146.56660600518808, original candidate wall seconds=149.1910677026026 over 200 runs each. Only an exact ordered-belief-pair allocation optimization followed. Paired 30-run CPU check: {'names': ['banklead_fast', 'banklead_fast2'], 'runs_each': 30, 'identical': True, 'cpu': [23.12610693100001, 21.309114733999994], 'wall': [23.129472906468436, 21.313167959218845]}. The final version recomputed all 1969 unseen runs and every complete result equals the originally frozen policy result.",
    "Fast path only: early distance rejection was identical over 20 paired spread-1 runs; CPU seconds base=18.613256815000007 and optimized=18.04607769199999.",
    "Rival bid retail sells measured under the unchanged base on 220 spread-1 tuning runs in [8000,8800). Zone tuples are (true-p zone, exposure steps, shares, notional, edge, fills): {'3': [230311, 298908.01000000007, 123437.40839999994, 3806.447878457997, 29128], '4': [102337, 43324.899999999994, 38765.5456, 705.3827335620244, 8287], '2': [51831, 267767.03999999986, 25449.39959999999, 2957.032597131274, 6081], '1': [23776, 174527.39000000007, 3660.839300000001, 1159.2832951267585, 1987], '0': [31745, 0, 0, 0, 0]}. Zone 0: p<.01; 1: [.01,.05); 2: [.05,.2); 3: [.2,.8); 4: [.8,1].",
    "Queue mechanism diagnostic on 220 tuning seeds [8000,8800), frozen trading policy before the exact allocation-only optimization: {'base': {'bid_retail_edge_per_run': 3.432716761882107, 'bid_arb_edge_per_run': -18.71624319196002, 'retail_edge_at_rival_best_bid_per_run': 1.8079744164478262, 'retail_shares_at_rival_best_bid': 42506.03, 'share_weighted_order_age_at_those_fills': 22.975113413320415}, 'banklead_fast': {'bid_retail_edge_per_run': 4.034092489221282, 'bid_arb_edge_per_run': -18.649434307215273, 'retail_edge_at_rival_best_bid_per_run': 2.486129052996366, 'retail_shares_at_rival_best_bid': 59191.909999999996, 'share_weighted_order_age_at_those_fills': 50.38271480004615}}. Age is steps since order submission, weighted by filled shares; fills at rival best bid require a rival bid still at that price when our order executes first. No strategy changes followed this diagnostic."
  ],
  "next": "Test a risk-limited tranche of tick-1 stock bids across rival bid depletion/replenishment, rather than retaining the whole large stock order. The current candidate marks auxiliary amt bids but leaves q1 stock bids unchanged. Estimate queue lifetime and size the retained tranche by distance below the probability estimate; the simple 2-share main-order split tested here barely helped."
}