{"approach": "Spread 3 only: when placing a bid at the base ca-3 advance-quote tick, split orders of at least 8 shares into 25% and 75% FIFO tranches. When a rival ask exists, ca-3 is its replacement-bid destination; the base missing-ask sentinel is retained. Total initial quantity and collateral are unchanged. Subsequent risk resizing can cancel the large tranche while retaining the small tranche ahead of the rival replacement. Other strategy parameters are unchanged. Reuse symmetric Gaussian weights on unchanged eighth-tick grids, cache probability-filter pairs and exp on other grids, inline unchanged normal-distribution arithmetic, and omit zero terms from positive-part jump sums, only in spread 3. These speed changes preserve the arithmetic and were checked for identical results before freezing. All final metrics use the complete matched spread-3 unseen set; all 900 other-spread result dictionaries match exactly. Local simulator measurements, not a claim of a Paradigm submission or leaderboard rank.", "blocked": null, "spread": 3, "base_mean_edge": 98.4694596619638, "base_unseen": {"mean_edge": 118.8166859338749, "retail_edge": 149.05823988395983, "arb_edge": -30.241553950072774}, "holdout": {"mean_edge": 118.95279834564133, "retail_edge": 149.24708630734537, "arb_edge": -30.294287961693218, "failures": 0}, "diff": {"mean": 0.1361124117664367, "standard_error": 0.04071745541231546, "retail": 0.18884642338550361, "arb": -0.05273401162044235}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 114.62022801488638, "yours": 113.92544659553096}, "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\ndef inv_fast(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=math.exp(-0.5*x*x)/SQ2PI\n  if d<1e-12:break\n  x-=(0.5*(1.0+math.erf(x/SQ2))-p)/d\n return x\n\nBASE_INV = inv\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        inv = inv_fast if self.s == 3 else BASE_INV\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            uni = P['uni'] * sg\n            if self.s == 3:\n                exp = math.exp\n                if cs == self.bc and wid == nb / 8.0:\n                    # On an unchanged eighth-tick grid, squared distances repeat.\n                    # Reuse their exponentials; retain the original summation order.\n                    kernel = []\n                    for j in range(nb):\n                        d = j * 0.125\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, weight in zip(self.bw, kernel[start:start + nb]):\n                            t += wi * weight\n                        ws.append(t)\n                else:\n                    pairs = tuple(zip(self.bc, self.bw))\n                    for c in cs:\n                        t = uni\n                        for ci, wi in pairs:\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            if self.s == 3:\n                a = s * (math.exp(-0.5 * k * k) / SQ2PI + k * (0.5 * (1.0 + math.erf(k / SQ2))))\n            else:\n                a = s * lpm(k)\n            b = a - (x - phat)\n            if self.s == 3:\n                ja = sum([w * (x - p) for p, w in jp if x > p])\n                jb = sum([w * (p - x) for p, w in jp if 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            return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n        ptk = phat * 100\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if phat * 100 - t < P['dmin']:\n                return 0.0\n            if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n                return 0.0\n            if phat < P['pL']:\n                ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n                a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            return qsize(b, a, t / 100.0)\n\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > 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) >= 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            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 self.s == 3 and bid_t == ca - 3 and q >= 8:\n                    # Two tranches wait at the depleted ask's replacement bid tick.\n                    first = fl(q * 0.25)\n                    rest = round(q - first, 2)\n                    second_id = self._oid('tranche')\n                    out[-1] = PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=first, client_order_id=oid)\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=rest, client_order_id=second_id))\n                    self.ahead.add(second_id)\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": "a0c13edd9e6917d067d6fc10c1a49aa45c2f091e8e8fa9e1ebc101c65256427d", "tried": ["Final bid-policy implementation matched all 181 screening and all 2035 unseen result dictionaries after arithmetic-preserving performance optimization. Final policy splits bids 25/75 only at ca-3; threshold 8 shares ensures the first tranche reaches the existing 2-share ahead threshold. Filter kernel checked against the original operation order on 20000 random grid/weight cases; inverse-normal helper checked on 20000 inputs. The economic policy was selected only on tuning and reserved validation. Runtime repairs used timing on tuning seeds and exact arithmetic checks; one runtime-only repair followed unseen scoring, and the final frozen file was fully rescored. No trading constants or policy were changed using unseen results.", "Calibration: Python 3.14.4, official CLI 4000 runs, seeds 4000..7999, serial after --workers 4 raised PermissionError for its multiprocessing socket; no sandbox. Final spread-3 unseen count=2035. Final timing: 200 spread-3 tuning seeds, alternating base/candidate order in one process after all other evaluation batches finished; seconds are measured wall time.", "Main ask at nearest replacement destination, including displacing current front quotes; tuning seeds 8000..8799, n=181, failures=0, paired mean=-7.534379033844201, SE=1.4733439585685206, retail=-5.4352329612701675, arb=-2.0991460725364646", "Main bid at nearest replacement destination, including displacing current front quotes; tuning seeds 8000..8799, n=181, failures=0, paired mean=-4.957580632228729, SE=0.5305775331272466, retail=-4.759901821103869, arb=-0.19767881111767963", "Main ask one destination deeper; positive estimated edge gate; tuning seeds 8000..8799, n=181, failures=0, paired mean=-25.25886521039116, SE=2.1842853389489116, retail=-25.950901486362433, arb=0.6920362760270711", "Main bid one destination deeper; positive estimated edge gate; tuning seeds 8000..8799, n=181, failures=0, paired mean=-22.984530030195028, SE=1.7604265767226739, retail=-23.489761187837573, arb=0.5052311576337013", "Deeper ask, 0.75-tick estimated cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-15.286682529788397, SE=1.4863132363884077, retail=-13.860606333931493, arb=-1.4260761957900552", "Deeper bid, 0.75-tick estimated cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-9.707701407658563, SE=0.7283236019670559, retail=-9.506699349251383, arb=-0.2010020583839781", "Deeper ask with 0.75-tick cushion, preserving existing front quotes; tuning seeds 8000..8799, n=181, failures=0, paired mean=-13.563095270237568, SE=1.455898826171875, retail=-12.49036779382707, arb=-1.0727274763569064", "Deeper bid with 0.75-tick cushion, preserving existing front quotes; tuning seeds 8000..8799, n=181, failures=0, paired mean=-8.279763429346962, SE=0.649558157401124, retail=-8.277245663562432, arb=-0.0025177657618789236", "Wait at rival ask four below one cent; promote after old lot clears; tuning seeds 8000..8799, n=181, failures=0, paired mean=-18.26307278653315, SE=3.3100335035355837, retail=-18.613416250517126, arb=0.3503434639718231", "Wait at rival ask four below half a cent; tuning seeds 8000..8799, n=181, failures=0, paired mean=-16.452483175243096, SE=3.1148766917861477, retail=-16.87878610996685, arb=0.42630293473756886", "Initial extra ask seat, 10% sizing; rejected prototype with duplicate-cancel failures; tuning seeds 8000..8799, n=181, failures=2, paired mean=-4.736858085879559, SE=1.6538459642537964, retail=-4.39089202150884, arb=-0.34596606435027655. Failed runs included only for diagnostic differences, not eligible.", "Initial extra bid seat, 10% sizing; rejected prototype with duplicate-cancel failures; tuning seeds 8000..8799, n=181, failures=13, paired mean=-4.189521205146409, SE=1.6977766947076438, retail=-6.146561661731493, arb=1.9570404565839774. Failed runs included only for diagnostic differences, not eligible.", "Repaired extra ask seat at low prices, 10% sizing and one-tick cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-2.2953455336784527, SE=0.578383077133316, retail=-1.8357724288674033, arb=-0.4595731048016577", "Repaired extra ask seat at low prices, 30% sizing and one-tick cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-3.56209904418453, SE=0.8048051723311513, retail=-2.397326283037569, arb=-1.1647727611331495", "Repaired extra ask seat at low prices, 10% sizing and 1.5-tick cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-0.01372438447513808, SE=0.01069132673934995, retail=-0.012309611425966984, arb=-0.00141477304972375", "Separate persistent secondary ask seat; 25% sizing and 1.25-tick cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-2.586168413281769, SE=0.5609426573310103, retail=-1.6406826300745887, arb=-0.9454857831939227", "Separate persistent secondary ask seat; 5% sizing and one-tick cushion; tuning seeds 8000..8799, n=181, failures=0, paired mean=-1.6312678770839775, SE=0.423537014939753, retail=-0.850297011663538, arb=-0.7809708654099451", "Double ask quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-10.964160908759117, SE=3.910491402697799, retail=3.80737167361602, arb=-14.77153258238895", "Double low-price ask quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-4.705601892292817, SE=3.7717537292828998, retail=4.328851910713811, arb=-9.034453803", "Quadruple low-price ask quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-19.143349948903314, SE=9.050855064529424, retail=6.060854593058011, arb=-25.2042045419547", "Double bid quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-1.8996856925099443, SE=0.8156426357644445, retail=4.757784445241987, arb=-6.657470137761878", "Halve low-price ask quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-2.3532979628359105, SE=2.4618097251797226, retail=-6.701076599958564, arb=4.34777863710442", "Halve bid quantity at the immediate replacement destination and while ahead; tuning seeds 8000..8799, n=181, failures=0, paired mean=-3.841316495663536, SE=0.918442993886658, retail=-6.020953637142544, arb=2.1796371414966846", "Split advance asks 25/75 without increasing total quantity; tuning seeds 8000..8799, n=181, failures=0, paired mean=0.11979259624530436, SE=0.17493242072146253, retail=0.3506897360928159, arb=-0.23089713986574592", "Split advance asks 50/50 without increasing total quantity; tuning seeds 8000..8799, n=181, failures=0, paired mean=0.18651050528287388, SE=0.07111282709295533, retail=0.2805362431033154, arb=-0.09402573783535886", "Split advance asks 10/90 without increasing total quantity; tuning seeds 8000..8799, n=181, failures=0, paired mean=-0.03496698092652129, SE=0.08513603042034627, retail=-0.0008635342453034345, arb=-0.0341034467099449", "Split advance asks into three equal tranches; tuning seeds 8000..8799, n=181, failures=0, paired mean=0.19147003599668486, SE=0.1071258670613056, retail=0.4441373477640866, arb=-0.2526673117850832", "Split advance bids 25/75 without increasing total quantity; tuning seeds 8000..8799, n=181, failures=0, paired mean=0.1676036514342542, SE=0.08352358680390501, retail=0.25064133731270444, arb=-0.08303768587016595", "splitaskfast quarter tranche extended tuning 8800..11999; n=786, failures=0, differences={\"mean\": -0.02075025639592851, \"standard_error\": 0.06907308048037754, \"retail\": 0.14709580631348573, \"arb\": -0.16784606270814245}", "splitaskfast quarter tranche reserved tuning validation 12000..15999; n=987, failures=0, differences={\"mean\": 0.02999524185440712, \"standard_error\": 0.0623412614929947, \"retail\": 0.09449403735845995, \"arb\": -0.06449879550405264}", "splitbidfast quarter tranche extended tuning 8800..11999; n=786, failures=0, differences={\"mean\": 0.08669511192544521, \"standard_error\": 0.04086299281278875, \"retail\": 0.16019494218053415, \"arb\": -0.07349983025648854}", "splitbidfast quarter tranche reserved tuning validation 12000..15999; n=987, failures=0, differences={\"mean\": 0.007821173872948187, \"standard_error\": 0.08911578306651805, \"retail\": 0.06789904065288711, \"arb\": -0.06007786678338409}", "splitaskfast full tuning 8000..11999; n=967, differences={\"mean\": 0.005556110023992015, \"standard_error\": 0.06497564584282858, \"retail\": 0.18520387383164372, \"arb\": -0.179647763810031}", "splitbidfast full tuning 8000..11999; n=967, differences={\"mean\": 0.1018393163216132, \"standard_error\": 0.03670526903794661, \"retail\": 0.17712441221044398, \"arb\": -0.07528509588841782}", "Collateral instrumentation base, tuning seeds 8000..8399, n=91: {\"locked_cash\": 22.17184139505499, \"covered_yes\": 214.3151424725272, \"seat_retail\": 0.0, \"seat_arb\": 0.0}; locked_cash and covered_yes are time averages, seat edges are per-run totals.", "Collateral instrumentation ladderalow, tuning seeds 8000..8399, n=91: {\"locked_cash\": 21.726202725274774, \"covered_yes\": 217.08618890109852, \"seat_retail\": 2.655063582426531, \"seat_arb\": -0.12806269334168463}; locked_cash and covered_yes are time averages, seat edges are per-run totals.", "Earlier bid implementation rejected by quiet timing: wall={\"base\": 117.38560018548742, \"yours\": 117.75724906753749}, CPU={\"base\": 117.34785100699993, \"yours\": 117.69153190599991}; economic policy retained and arithmetic-only runtime repair fully rescored.", "Final arithmetic runtime repair: 100000 positive-part jump-sum equivalence cases and 100000 normal-term equivalence cases passed; all 181 screening and all 2035 unseen full result records were also unchanged.", "Final 200-run timing CPU seconds (in addition to reported wall seconds): {\"base\": 114.59004897499987, \"yours\": 113.89627707899982}"], "next": "Try predicting imminent multi-lot depletion from observable quote/probe transitions, then reserve only the additional destination whose expected queue benefit exceeds its jump loss. Broad deeper ladders and waiting behind the floor lot did not pay in these tests."}