{
  "approach": "Returned the supplied base code byte-for-byte unchanged because no tested port qualified under the strict no-slower requirement. The frozen spread-2 inventory-demand port gained 0.4078506954646198 per unseen run (paired SE 0.21170420273540744) on all 1987 target seeds in 60000-67999, with zero failures and all 900 non-target comparisons identical in every SimulationResult field, but failed the final post-bulk speed gate. Its wall seconds were 151.39373784000054 versus base 149.99026280920953, and CPU seconds were 151.36930251099997 versus base 149.9614801699997. These experimental scores are recorded in tried and are not assigned to the returned base. base_unseen and holdout both describe the returned original base, so the paired diff and its SE are exactly zero. The base's requested 4000-run CLI check on seeds 4000-7999 exactly reproduced 98.4694596619638 with zero failures. The original base itself was run on all 1987 target unseen seeds. The 900 non-target comparisons tested the frozen demand port against the base and passed; returning the original base preserves those paths identically. seconds compares two independent executions of the identical base code, each on 200 fixed target seeds in the same post-bulk timing process, with alternating forward/reverse ordering around the experimental candidate; one warmup per factory, loading and config sampling excluded. Timing used Python 3.12. This is a local negative result for candidate eligibility, not a Paradigm submission. The full-data inventory port also gained on all 1967 target tuning seeds, but financial gain alone did not satisfy the speed condition.",
  "blocked": null,
  "spread": 2,
  "base_mean_edge": 98.4694596619638,
  "base_unseen": {
    "mean_edge": 75.37891657984132,
    "retail_edge": 102.41461084785999,
    "arb_edge": -27.035694268030902
  },
  "holdout": {
    "mean_edge": 75.37891657984132,
    "retail_edge": 102.41461084785999,
    "arb_edge": -27.035694268030902,
    "failures": 0
  },
  "diff": {
    "mean": 0.0,
    "standard_error": 0.0,
    "retail": 0.0,
    "arb": 0.0
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "base": 149.99026280920953,
    "yours": 149.8819624609314
  },
  "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            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\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 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": "dcf68e0c9a7b06f90cf70a833357b60e2208b5b3e2971e7dddf02986d4747076",
  "tried": [
    "Full published 81-point posterior for ordinary quote tails plus inventory: {\"discovery\":{\"n\":200,\"mean\":-1.2317892114655005,\"se\":1.9857322939423057,\"retail\":-0.6588341091624996,\"arb\":-0.5729551023304996,\"failures\":0}}",
    "Full posterior port with a 25-point parameter grid: {\"discovery\":{\"n\":200,\"mean\":-1.003434742468,\"se\":1.7184819037632766,\"retail\":-0.7710160615145004,\"arb\":-0.23241868099049992,\"failures\":0}}",
    "25-point inventory-only posterior, keeping base ordinary quote sizes: {\"discovery\":{\"n\":200,\"mean\":0.7190721407905001,\"se\":1.057267375852317,\"retail\":0.7694408366114998,\"arb\":-0.050368695822499594,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.4102868126096661,\"se\":1.0459792926393237,\"retail\":0.24870016118933297,\"arb\":0.1615866514219999,\"failures\":0}}",
    "Posterior compound-Poisson ordinary quote tails only: {\"discovery\":{\"n\":200,\"mean\":-1.6366901292945,\"se\":1.3193790738460307,\"retail\":-1.5110528273335,\"arb\":-0.12563730199099948,\"failures\":0}}",
    "Posterior rate and mean in the original single-order quote formula: {\"discovery\":{\"n\":200,\"mean\":-1.4949635487545008,\"se\":1.577961154915772,\"retail\":-1.1053233960039994,\"arb\":-0.38964015277299985,\"failures\":0}}",
    "Surviving-bid stock gate only, without demand inference: {\"discovery\":{\"n\":200,\"mean\":-0.11768107439350019,\"se\":0.14165309322687814,\"retail\":-0.023525650179499955,\"arb\":-0.09415542421499992,\"failures\":0}}",
    "Full-data inventory posterior with 1.0x tick-1 target: {\"discovery\":{\"n\":200,\"mean\":1.0199458909989996,\"se\":0.8610718899332573,\"retail\":0.474591358207,\"arb\":0.5453545327890004,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.5122691590536663,\"se\":0.9458827200243998,\"retail\":0.155037294822666,\"arb\":0.3572318642316664,\"failures\":0}}",
    "Full-data inventory posterior with 1.5x tick-1 target: {\"discovery\":{\"n\":200,\"mean\":0.15567740467350058,\"se\":1.251821268261988,\"retail\":0.7807957395159997,\"arb\":-0.6251183348464994,\"failures\":0}}",
    "Full-data inventory posterior with 0.75x tick-1 target: {\"discovery\":{\"n\":200,\"mean\":-0.5826770892195006,\"se\":0.5541551054243558,\"retail\":0.11841152869950068,\"arb\":-0.7010886179179998,\"failures\":0},\"validation\":{\"n\":300,\"mean\":-0.9628259238396675,\"se\":0.6265930457363608,\"retail\":-0.15062210135533338,\"arb\":-0.8122038224856667,\"failures\":0}}",
    "Inventory posterior with native math.sumprod Gaussian convolution: {\"discovery\":{\"n\":200,\"mean\":0.7190721407905001,\"se\":1.057267375852317,\"retail\":0.7694408366114998,\"arb\":-0.050368695822499594,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.4102868126096661,\"se\":1.0459792926393237,\"retail\":0.24870016118933297,\"arb\":0.1615866514219999,\"failures\":0}}",
    "Native convolution plus aggregated likelihood refreshes and direct main-order snapshots: {\"discovery\":{\"n\":200,\"mean\":0.7190721407905001,\"se\":1.057267375852317,\"retail\":0.7694408366114998,\"arb\":-0.050368695822499594,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.4102868126096661,\"se\":1.0459792926393237,\"retail\":0.24870016118933297,\"arb\":0.1615866514219999,\"failures\":0}}",
    "Efficient estimator using ask observations only: {\"discovery\":{\"n\":200,\"mean\":0.6405950949164996,\"se\":1.0576679042562231,\"retail\":0.7637922873074998,\"arb\":-0.12319719239549981,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.4450623640523331,\"se\":1.044470807427395,\"retail\":0.24866781726266624,\"arb\":0.19639454679199989,\"failures\":0}}",
    "Efficient estimator observing both sides every fourth step: {\"discovery\":{\"n\":200,\"mean\":0.11223994347599936,\"se\":0.6113354357350198,\"retail\":0.5593051797019996,\"arb\":-0.44706523622800004,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.316793075022,\"se\":0.8383501396480375,\"retail\":-0.011074019907999666,\"arb\":0.3278670949306664,\"failures\":0}}",
    "Every-fourth-step estimator with 1.0x tick-1 target: {\"discovery\":{\"n\":200,\"mean\":-0.163202960600001,\"se\":0.2994267180470947,\"retail\":0.12680481324200013,\"arb\":-0.29000777384299986,\"failures\":0},\"validation\":{\"n\":300,\"mean\":-0.4348392534416666,\"se\":0.53541302527897,\"retail\":-0.2779734576803331,\"arb\":-0.1568657957619999,\"failures\":0}}",
    "Half-resolution probability grid (4 bins per tick), full demand observations: {\"discovery\":{\"n\":200,\"mean\":0.7728046528975004,\"se\":1.047968940410287,\"retail\":0.8088723835835006,\"arb\":-0.03606773068299982,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.8537542325236657,\"se\":1.0829237984579883,\"retail\":0.48199384446866467,\"arb\":0.3717603880513326,\"failures\":0}}",
    "Half-resolution grid and every-fourth-step demand observations: {\"discovery\":{\"n\":200,\"mean\":0.25900179155650044,\"se\":0.62291740767634,\"retail\":0.6636404178485003,\"arb\":-0.4046386262869996,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.7094978344073323,\"se\":0.8903984792292937,\"retail\":0.22289827652533106,\"arb\":0.48659955787799947,\"failures\":0}}",
    "Retain lone probes only at otherwise empty interior ticks: {\"discovery\":{\"n\":200,\"mean\":0.7191259240600004,\"se\":1.0573048943187267,\"retail\":0.7694885507100001,\"arb\":-0.050362626654499906,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.410423163651999,\"se\":1.0459827882938064,\"retail\":0.24867179021333272,\"arb\":0.1617513734396662,\"failures\":0}}",
    "Final priority-preserving probe reuse, allowing probes already behind older bulk orders: {\"discovery\":{\"n\":200,\"mean\":0.7191310261175005,\"se\":1.057304862420538,\"retail\":0.7694915472500005,\"arb\":-0.050360521137999804,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.41042628899899875,\"se\":1.0459825228899826,\"retail\":0.24867381159899946,\"arb\":0.16175247740066637,\"failures\":0}}",
    "Full-data inventory port, all 1967 spread-2 tuning runs in 8000-15999: {\"n\":1967,\"mean\":0.6679086652925778,\"se\":0.2712838968180014,\"retail\":0.31195956868144387,\"arb\":0.35594909661052354,\"failures\":0}",
    "Timing diagnostic prebench: {\"paths\":[\".cache/base.py\",\".cache/port-fast.py\",\".cache/compact.py\",\".cache/stock.py\"],\"seconds\":[118.05458696885034,128.636380254291,124.28679611859843,119.425854426343],\"failures\":[0,0,0,0],\"runs\":20}",
    "Timing diagnostic native-prebench: {\"paths\":[\".cache/base.py\",\".cache/native.py\"],\"seconds\":[145.69072438590229,149.84194699209183],\"failures\":[0,0],\"runs\":20}",
    "Timing diagnostic efficient-prebench: {\"paths\":[\".cache/base.py\",\".cache/efficient.py\"],\"seconds\":[163.76117702713236,170.02759960340336],\"cpu_seconds\":[16.503738597999998,17.055410415999997],\"failures\":[0,0],\"runs\":20}",
    "Timing diagnostic last-prebench: {\"paths\":[\".cache/base.py\",\".cache/asks-only.py\",\".cache/sparse.py\"],\"seconds\":[157.83566133724526,162.212548898533,162.5505306320265],\"cpu_seconds\":[16.24312575700001,16.522312274999987,16.592227006000012],\"failures\":[0,0,0],\"runs\":20}",
    "Timing diagnostic half-prebench: {\"paths\":[\".cache/base.py\",\".cache/half.py\",\".cache/half-sparse.py\"],\"seconds\":[176.59971453156322,176.36577254673466,176.40825639665127],\"cpu_seconds\":[16.36696203600001,16.534210229000003,16.297389442999993],\"failures\":[0,0,0],\"runs\":20}",
    "Timing diagnostic reuse-prebench: {\"paths\":[\".cache/base.py\",\".cache/reuse.py\"],\"seconds\":[156.32900729309767,157.36007407633588],\"cpu_seconds\":[16.548671077999995,16.674670401000004],\"failures\":[0,0],\"runs\":20}",
    "Timing diagnostic reuse2-prebench: {\"paths\":[\".cache/base.py\",\".cache/reuse2.py\"],\"seconds\":[132.86631228448823,133.82409583823755],\"cpu_seconds\":[16.263575517000007,16.318810551999988],\"failures\":[0,0],\"runs\":20}",
    "Timing diagnostic timing: {\"paths\":[\".cache/base.py\",\".cache/frozen.py\"],\"seconds\":[1437.8411110281013,1515.4134794850834],\"failures\":[0,0],\"runs\":200}",
    "Final code frozen before its unseen comparison completed; after this freeze no strategy changes were made: {\"utc\":\"2026-11-06T07:36:06.551557+00:00\",\"code_sha256\":\"ff4b81e35d9e08d4e23d6a0d82442c2619478be19f80d390d9ef02d76e8b36e9\",\"code\":\".cache/final.py\",\"mechanism\":\"25-point full-data demand likelihood, inventory only, original 8-bin probability resolution; retain eligible probes behind existing bulk orders; new bulk at a tick forces re-placement. Final tuning validation is in progress; accept only if positive and no failures. No candidate unseen edge results have been inspected.\"}",
    "The quoted-side size posterior and cheaper single-order demand-tail replacement lost on tuning. Inventory-only was carried forward for the frozen experiment; 1.0x stock and half-resolution alternatives had full financial comparisons only on tuning. Probe reuse was introduced to meet the strict speed gate while retaining the original probability-grid resolution and complete observation stream.",
    "Frozen priority-preserving probe candidate, complete 1987-run unseen comparison: {\"base\":{\"mean_edge\":75.37891657984132,\"retail_edge\":102.41461084785999,\"arb_edge\":-27.035694268030902},\"candidate\":{\"mean_edge\":75.78676727530593,\"retail_edge\":102.6499978946232,\"arb_edge\":-26.86323061932904},\"diff\":{\"mean\":0.4078506954646198,\"standard_error\":0.21170420273540744,\"retail\":0.2353870467632107,\"arb\":0.1724636487018621},\"failures\":0}",
    "Contended 200-run timing of final frozen candidate; superseded by one predeclared post-bulk timing pass because the margin was close: {\"paths\":[\".cache/base.py\",\".cache/final.py\"],\"seconds\":[627.501177799888,633.4015896003693],\"cpu_seconds\":[164.02133353300047,166.28477880399998],\"failures\":[0,0],\"runs\":200}",
    "Single post-bulk timing pass, one warmup each, then 200 runs each of base, frozen candidate, and an identical-base control in one process. Fixed target seeds, alternating forward/reverse execution order; final decision uses base index 0 versus candidate index 1, with the identical-base control used for the returned fallback if needed: {\"paths\":[\".cache/base.py\",\".cache/final.py\",\".cache/base.py\"],\"seconds\":[149.99026280920953,151.39373784000054,149.8819624609314],\"cpu_seconds\":[149.9614801699997,151.36930251099997,149.86110630199994],\"failures\":[0,0,0],\"runs\":200}",
    "Final eligibility decision, requiring positive unseen paired mean and no slower in both post-bulk wall and CPU measurements: {\"accepted\":false,\"unseen_diff\":{\"mean\":0.4078506954646198,\"standard_error\":0.21170420273540744,\"retail\":0.2353870467632107,\"arb\":0.1724636487018621},\"candidate_failures\":0,\"discovery\":{\"n\":200,\"mean\":0.7191310261175005,\"se\":1.057304862420538,\"retail\":0.7694915472500005,\"arb\":-0.050360521137999804,\"failures\":0},\"validation\":{\"n\":300,\"mean\":0.41042628899899875,\"se\":1.0459825228899826,\"retail\":0.24867381159899946,\"arb\":0.16175247740066637,\"failures\":0},\"wall_ratio\":1.0093571076182208,\"cpu_ratio\":1.0093878930736369}"
  ],
  "next": "Test a 3-by-3 demand-posterior grid using original indices 0,4,8, or defer posterior refreshes until inventory-sensitive price bands, to remove the measured inference overhead without weakening the probability grid. Those changes were not tested here. The 1.0x inventory multiplier passed both full-data tuning blocks; a half-resolution grid with every-fourth-step observations also passed tuning and had a slightly faster preliminary CPU timing, but neither received a full unseen comparison. Use fresh unseen seeds."
}