{"approach": "Multiply newly placed tick-2 ask depth by five only when the estimate is below 1 cent and tick 2 is strictly inside the rival ask. Retain ahead low-tick asks while the model still wants positive quantity, instead of canceling when the target shrinks. This allocates inventory to the useful lifetime of the queue position before the rival arrives. Performance-only repair after the original speed gate failed: Cache immutable prior grid pairs and math.exp in the spread-1 belief loop, preserving floating-point operation order and all financial parameters. Original 200-pair time: base=211.82275046454743, candidate=212.19043029402383. Exact equivalence with the original trading candidate was checked on all 2036 tuning, 1969 unseen and 900 non-target runs, including every SimulationResult field. The optimized file was refrozen before these complete repeat evaluations; no trading parameter was changed after unseen scoring. All added behavior is guarded by self.s == 1. No seed recognition, future information, external dependencies, or changes to other-spread parameters. Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; default 2000-step configurations, no sandbox. The required CLI baseline uses 4000 runs, seeds 4000-7999, workers=4. Tuning seeds are all 2036 seeds with sampled spread 1 in [8000,16000); first 100 discovery, next 400 separate validation, final 1536 confirmation. Selection among the three fixed finalists uses positive validation and confirmation means and maximum confirmation mean, before reading candidate unseen scores. Code frozen at 2026-11-06T07:17:13.930574+00:00 with SHA256 c937628ccb161886b377bd1dcf1151c31e37b8b2f4056eb020f47e08e6e8ca6b. Unseen pairs are all 1969 spread-1 seeds in [60000,68000); no unseen-based alternate candidate selection. Other-spread checks compare every SimulationResult field on the first 300 seeds of each spread 2,3,4 from 60000. Each run uses sample_config(ChallengeConfig(), ParameterVariance(), seed=seed) and SimulationEngine(config, fresh_strategy, seed=seed). Timing is 200 identical spread-1 seeds from 60000, one process, one warmup each, alternating execution order, engine construction/run only; reported values are summed perf_counter seconds. Arb edge is signed (positive delta means less arbitrage loss). Paired standard error is sample stdev of per-run edge differences divided by sqrt(n). Scores are local simulator scores, not Paradigm submissions. Queue diagnostic on the first 100 discovery seeds: {'orders': 93, 'front_steps': 3364, 'front_edge': 468.39939439776185, 'retail_edge': 513.4983588895874, 'arb_edge': -0.6848318710518986, 'filled': 92, 'cancelled': 1, 'mean_initial_front_quantity': 439.3775268817204, 'unique_rival_edge_after_front_loss': 384.9063180047828, 'lost_by_reason': {'filled': 384.9063180047828, 'cancel': 7.93410907993525}}. front_steps counts shared-tick steps; front_edge includes fills after first becoming front. The rival-edge opportunity is deduplicated across overlapping 200-step windows after a front order disappears and ends when probability next crosses its ask; it is diagnostic, not an achievable-score claim.", "blocked": null, "python_version": "3.12.3", "spread": 1, "base_mean_edge": 98.4694596619638, "runs": {"tuning": 2036, "unseen": 1969}, "base_unseen": {"mean_edge": 41.78494849744236, "retail_edge": 65.91107840022042, "arb_edge": -24.1261299027871}, "holdout": {"mean_edge": 44.04861374654357, "retail_edge": 68.11922881472341, "arb_edge": -24.070615068188626, "failures": 0}, "diff": {"mean": 2.263665249101219, "standard_error": 0.3540732844043558, "retail": 2.2081504145029967, "arb": 0.055514834598476434}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 210.6053889724426, "yours": 206.79859197651967}, "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            uni = P['uni'] * sg\n            if self.s == 1:\n                prior = tuple(zip(self.bc, self.bw))\n                exp = math.exp\n                for c in cs:\n                    t = uni\n                    for ci, wi in prior:\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            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        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            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) 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                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": "c937628ccb161886b377bd1dcf1151c31e37b8b2f4056eb020f47e08e6e8ca6b", "tried": ["Retain oversize ahead asks at ticks <=2 while model still wants positive quantity: discovery {'n': 100, 'mean': 0.6136062232900004, 'se': 0.292355805944282, 'retail': 0.5842577516439998, 'arb': 0.029348471646999937, 'failures': 0}", "Retain oversize ahead asks at ticks <=5: discovery {'n': 100, 'mean': 0.6011828890910003, 'se': 0.293705731203474, 'retail': 0.5881064526059999, 'arb': 0.013076436485999831, 'failures': 0}", "Retain oversize ahead bids and asks at all ticks: discovery {'n': 100, 'mean': 0.602318712273998, 'se': 0.2866128280197744, 'retail': 0.6104188933839995, 'arb': -0.008100181102999959, 'failures': 0}", "Multiply initial ahead ask depth at ticks <=5 by 2: discovery {'n': 100, 'mean': 4.346153127005, 'se': 12.461130416393232, 'retail': 1.502427338128, 'arb': 2.8437257888769985, 'failures': 0}", "Multiply initial ahead ask depth at ticks <=5 by 4: discovery {'n': 100, 'mean': -10.519581696898001, 'se': 15.705631282057286, 'retail': 0.15067655079899986, 'arb': -10.670258247707, 'failures': 0}", "Multiply initial ahead ask depth at ticks <=5 by 10: discovery {'n': 100, 'mean': -41.319666968716, 'se': 27.10083765158426, 'retail': -2.531283339579, 'arb': -38.788383629116, 'failures': 0}", "Allow same-tick ask top-ups without replacing the old order: discovery {'n': 100, 'mean': 0.9454616728319986, 'se': 0.9430816349792099, 'retail': 0.3691892791950007, 'arb': 0.5762723936409984, 'failures': 0}", "Treat the final 0.02-2 shares as front position instead of undercutting: discovery {'n': 100, 'mean': 0.06593504329299997, 'se': 0.06649425525830994, 'retail': 0.03180883406099862, 'arb': 0.03412620925799932, 'failures': 0}", "Raise initial ahead tick-2 ask quantity to 20 steps of expected retail demand, bounded by YES inventory, and retain it: discovery {'n': 100, 'mean': -5.984364326173, 'se': 1.820440280015977, 'retail': 0.0019070806470001854, 'arb': -5.986271406813002, 'failures': 0}", "Raise initial ahead tick-2 ask quantity to 50 steps of expected retail demand, bounded by YES inventory, and retain it: discovery {'n': 100, 'mean': -8.286362022271, 'se': 2.7866023165131653, 'retail': -0.21118459990700178, 'arb': -8.075177422356001, 'failures': 0}", "Raise initial ahead tick-2 ask quantity to 100 steps of expected retail demand, bounded by YES inventory, and retain it: discovery {'n': 100, 'mean': -8.816189269037, 'se': 3.3092553163299074, 'retail': 0.08813984975400001, 'arb': -8.904329118787002, 'failures': 0}", "Double newly placed tick-2 front depth only below 1-cent estimated probability, and retain it: discovery {'n': 100, 'mean': 1.9992991758590002, 'se': 0.9970780059448991, 'retail': 1.5389130970280003, 'arb': 0.4603860788399998, 'failures': 0}", "Multiply newly placed tick-2 front depth by five only below 1-cent estimated probability, and retain it: discovery {'n': 100, 'mean': 3.273645329892, 'se': 1.9071918444982443, 'retail': 2.4802144047709995, 'arb': 0.7934309251299998, 'failures': 0}", "Multiply initial ahead tick-2 ask depth by 1.5 without the below-1-cent guard: discovery {'n': 100, 'mean': 5.407947125980999, 'se': 6.690843807166442, 'retail': 0.5954205567709981, 'arb': 4.812526569194, 'failures': 0}", "Multiply initial ahead tick-2 ask depth by 2 without the below-1-cent guard: discovery {'n': 100, 'mean': 2.283433575373999, 'se': 7.813618795036023, 'retail': 1.9325190095070002, 'arb': 0.35091456586599995, 'failures': 0}", "Multiply initial ahead tick-2 ask depth by 4 without the below-1-cent guard: discovery {'n': 100, 'mean': -6.954126367236, 'se': 11.80729110725914, 'retail': 1.217202853688, 'arb': -8.171329220940002, 'failures': 0}", "The same tick-2 depth multiplier 1.5 plus preserving the older order: discovery {'n': 100, 'mean': 7.92771686565, 'se': 6.516066309853476, 'retail': 1.3814159941699977, 'arb': 6.546300871464999, 'failures': 0}", "The same tick-2 depth multiplier 2 plus preserving the older order: discovery {'n': 100, 'mean': 5.004779174433, 'se': 7.77927614960204, 'retail': 2.594322050685, 'arb': 2.4104571237529995, 'failures': 0}", "The same tick-2 depth multiplier 4 plus preserving the older order: discovery {'n': 100, 'mean': -1.6124433616350007, 'se': 11.845262175280983, 'retail': 3.101174572361, 'arb': -4.713617934007003, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=1; size multiplier=1; below-1-cent guard=False: discovery {'n': 100, 'mean': 0.0, 'se': 0.0, 'retail': 0.0, 'arb': 0.0, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=2; size multiplier=1; below-1-cent guard=False: discovery {'n': 100, 'mean': -14.812259809454, 'se': 3.9312823602388827, 'retail': -18.377885719609, 'arb': 3.5656259101709993, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=2; size multiplier=1; below-1-cent guard=True: discovery {'n': 100, 'mean': -17.251660645642, 'se': 4.368354248833722, 'retail': -21.473895240811, 'arb': 4.222234595188999, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=2; size multiplier=4; below-1-cent guard=False: discovery {'n': 100, 'mean': -39.823498159146006, 'se': 17.62711316990707, 'retail': -15.665631606836001, 'arb': -24.157866552297, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=3; size multiplier=1; below-1-cent guard=False: discovery {'n': 100, 'mean': -43.828823104991, 'se': 9.569097645124389, 'retail': -47.386908881029, 'arb': 3.558085776051, 'failures': 0}", "Join the rival ask rather than undercutting at ticks <=5; size multiplier=1; below-1-cent guard=False: discovery {'n': 100, 'mean': -44.03325509405, 'se': 13.385164201313941, 'retail': -51.156170242382004, 'arb': 7.12291514836, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=2; fair-value guard=True: discovery {'n': 100, 'mean': 1.0991249999960929e-05, 'se': 9.307145435696527e-06, 'retail': 1.099124999967671e-05, 'arb': 0.0, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=5; fair-value guard=True: discovery {'n': 100, 'mean': -0.013686199720999923, 'se': 0.6565715518327598, 'retail': -0.16662364323700088, 'arb': 0.15293744352700042, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=99; fair-value guard=True: discovery {'n': 100, 'mean': 0.5074447053799992, 'se': 0.5053305186646055, 'retail': 0.377476292769, 'arb': 0.12996841258699948, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=2; fair-value guard=False: discovery {'n': 100, 'mean': 1.0991249999960929e-05, 'se': 9.307145435696527e-06, 'retail': 1.099124999967671e-05, 'arb': 0.0, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=5; fair-value guard=False: discovery {'n': 100, 'mean': -0.013686199720999923, 'se': 0.6565715518327598, 'retail': -0.16662364323700088, 'arb': 0.15293744352700042, 'failures': 0}", "Keep dormant ahead asks at higher ticks through rival quote changes; cap=99; fair-value guard=False: discovery {'n': 100, 'mean': 0.5074447053799992, 'se': 0.5053305186646055, 'retail': 0.377476292769, 'arb': 0.12996841258699948, 'failures': 0}", "Retain ahead asks at ticks <=5 even if qsize is zero while price minus estimate is at least 0 ticks: discovery {'n': 100, 'mean': 0.6011828890910003, 'se': 0.293705731203474, 'retail': 0.5881064526059999, 'arb': 0.013076436485999831, 'failures': 0}", "Retain ahead asks at ticks <=5 even if qsize is zero while price minus estimate is at least 0.15 ticks: discovery {'n': 100, 'mean': 0.6011828890910003, 'se': 0.293705731203474, 'retail': 0.5881064526059999, 'arb': 0.013076436485999831, 'failures': 0}", "Retain ahead asks at ticks <=5 even if qsize is zero while price minus estimate is at least 0.3 ticks: discovery {'n': 100, 'mean': 0.6011828890910003, 'se': 0.293705731203474, 'retail': 0.5881064526059999, 'arb': 0.013076436485999831, 'failures': 0}", "Retain oversize ahead asks at tick 2 only, including before the rival arrives: discovery {'n': 100, 'mean': 0.6136062232900004, 'se': 0.292355805944282, 'retail': 0.5842577516439998, 'arb': 0.029348471646999937, 'failures': 0}", "Retain oversize ahead tick-2 asks only while the rival is actually at tick 2: discovery {'n': 100, 'mean': 0.5362669915210003, 'se': 0.2834227032612414, 'retail': 0.5362236116729998, 'arb': 4.337984899995817e-05, 'failures': 0}", "keep_asks2: independent validation 400; mean=0.11469877419349996; standard_error=0.10938308984184511; failures=0", "depthkeep1_5: independent validation 400; mean=-1.38634316015025; standard_error=1.4296567074189264; failures=0", "topup: independent validation 400; mean=-1.043400029405001; standard_error=0.6116633073645998; failures=0", "deep_low2: independent validation 400; mean=0.4057090311345001; standard_error=0.1788883586886006; failures=0", "deep_low5: independent validation 400; mean=0.5311566637340002; standard_error=0.3623729182668211; failures=0", "queue_tick2: full tuning confirmation {'n': 1536, 'mean': 0.10234849809791668, 'se': 0.04788234306964485, 'retail': 0.08080099894225261, 'arb': 0.021547499155338556, 'failures': 0}", "queue_tick2: full tuning all {'n': 2036, 'mean': 0.12988571958978393, 'se': 0.04444946926840764, 'retail': 0.11246473200250491, 'arb': 0.01742098758683694, 'failures': 0}", "deep_low2: full tuning confirmation {'n': 1536, 'mean': 0.6795917187461589, 'se': 0.16178568349677677, 'retail': 0.5823624961104168, 'arb': 0.09722922263300782, 'failures': 0}", "deep_low2: full tuning all {'n': 2036, 'mean': 0.6906023624920433, 'se': 0.13620678926072502, 'retail': 0.6034005020813852, 'arb': 0.08720186040795674, 'failures': 0}", "deep_low5: full tuning confirmation {'n': 1536, 'mean': 1.0019543878647788, 'se': 0.46623160901259525, 'retail': 1.6322672831539717, 'arb': -0.6303128952942708, 'failures': 0}", "deep_low5: full tuning all {'n': 2036, 'mean': 1.0210359225162573, 'se': 0.3709349824254382, 'retail': 1.49887210270668, 'arb': -0.4778361801945972, 'failures': 0}", "Frozen deep_low5_fast unseen spread-1 paired results: {'n': 1969, 'mean': 2.263665249101219, 'se': 0.3540732844043558, 'retail': 2.208150414502996, 'arb': 0.055514834598476434, 'failures': 0}; 900 other-spread equality: {'runs': 900, 'identical': True}; single-process 200-pair elapsed seconds: {'base': 210.6053889724426, 'yours': 206.79859197651967}", "Frozen unseen diagnostics (observational, no post-holdout retuning): {'changed': 145, 'positive_edge_delta': 130, 'negative_edge_delta': 13, 'minimum_edge_delta': -61.1247766355, 'maximum_edge_delta': 273.01179961829996, 'settlement': {'0.0': {'runs': 1024, 'mean': 4.352692261211231, 'standard_error': 0.6744323520364148}, '1.0': {'runs': 945, 'mean': 0.0, 'standard_error': 0.0}}}", "Performance repair: Cache immutable prior grid pairs and math.exp in the spread-1 belief loop, preserving floating-point operation order and all financial parameters. Original 200-pair time: base=211.82275046454743, candidate=212.19043029402383.; exact equivalence on tuning={'kind': 'tuning', 'runs': 2036, 'identical_to_original': True, 'different_seeds': []}, unseen={'kind': 'unseen', 'runs': 1969, 'identical_to_original': True, 'different_seeds': []}, other spreads={'kind': 'others', 'runs': 900, 'identical_to_original': True, 'different_seeds': []}", "BEST ELIGIBLE: deep_low5_fast; {'n': 1969, 'mean': 2.263665249101219, 'se': 0.3540732844043558, 'retail': 2.208150414502996, 'arb': 0.055514834598476434, 'failures': 0}; measured seconds {'base': 210.6053889724426, 'yours': 206.79859197651967}"], "next": "Estimate the retail service horizon of an ahead tick-2 ask from observable replenishment and fill history, and allocate initial covered depth to that horizon rather than a multiplier. Keep the below-1-cent entry guard: broad depth increases failed independent validation. Do not retune on the now-used 60000-67999 unseen range."}