{"approach": "Exact-behavior speed refactor of the fixed-parameter crossing-cover base. Reuses bounded public grid geometry and invariant math, consolidates order classification, and removes repeated zip creation and dead target calculations. Preserves floating-point operation order and every trading decision. Selection used only tuning seeds 4000-4009 and separate validation 6000-6009; code was frozen before full 4000-7999 and 50000-53999 scoring. All 8600 requested seeds establish exact base/candidate equality with zero failures: 600 independent calibration pairs and 8000 action-by-action comparisons on a shared unchanged official engine trajectory. The latter avoid duplicated market execution, not any strategy calls or simulation steps. Long sweeps used PyPy Python 3.12.15; the initial calibration and timing use CPython 3.12.3. seconds reports isolated elapsed wall seconds per 200 full runs in one CPython process, using four counterbalanced blocks and equal warmup. CPU times and the earlier concurrent-load timings are retained in tried. Native PyPy calibration mean is 108.62320549194204 versus CPython 108.63974289615767: runtime arithmetic changes two calibration trading trajectories, so absolute full-range scores are explicitly PyPy-specific. No simulator or builtins patches were used for those scores. The delivered strategy has no dependency beyond Python standard library and the challenge API. Failure investigation and its limits are recorded in tried.", "blocked": null, "python_version": "3.12.15", "base_mean_edge": 108.63974289615767, "base_unseen": {"mean_edge": 97.54400381637852, "retail_edge": 126.93125591904779, "arb_edge": -29.387252102662867}, "score": {"mean_edge": 98.09786217293227, "retail_edge": 125.18124886807635, "arb_edge": -27.08338669515864, "simulations": 4000, "seed_start": 4000, "failures": 0}, "holdout": {"mean_edge": 97.54400381637852, "retail_edge": 126.93125591904779, "arb_edge": -29.387252102662867, "simulations": 4000, "seed_start": 50000, "failures": 0}, "diff": {"mean": 0.0, "standard_error": 0.0, "retail": 0.0, "arb": 0.0}, "seconds": {"base": 265.82176911085844, "yours": 257.17929600796197}, "code": "\"\"\"Crossing-cover base with exact arithmetic-preserving repeated-work removal.\"\"\"\nimport math\nfrom functools import lru_cache\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\n# Fixed strategy constants, evaluated with the original expressions.\nVAR = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\nRHO = P['lam_r'] * 0.5\nMU = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\nINV_01 = inv(0.01)\n\n@lru_cache(maxsize=512)\ndef _grid(lo, hi):\n    wid = max(hi - lo, 1e-6)\n    nb = max(2, min(48, int(round(wid * P['bins']))))\n    return tuple(lo + (i + 0.5) * wid / nb for i in range(nb))\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\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        lo, hi = cb, ca\n        sb, sa = set(), set()\n        bids, asks, probes = [], [], []\n        for o in state.own_orders:\n            is_probe = o.remaining_quantity <= PROBE + 1e-9\n            if is_probe:\n                probes.append(o)\n            if o.side is Side.BUY:\n                lo = max(lo, o.price_ticks)\n                if is_probe:\n                    sb.add(o.price_ticks)\n                else:\n                    bids.append(o)\n            else:\n                hi = min(hi, o.price_ticks)\n                if is_probe:\n                    sa.add(o.price_ticks)\n                else:\n                    asks.append(o)\n        if P['pinf'] > 0:\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 = _grid(lo, hi)\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            pairs = tuple(zip(self.bc, self.bw))\n            exp = math.exp\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            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 = VAR\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_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 = RHO\n        mu = MU\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                a *= P['kLb'] / 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        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            q1 = max(0.0, P['ydf1'] * 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        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 probes:\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        return actions + out\n", "code_sha256": "0351b7a677600ba8070e0f65bf1f160b20687fe3547c770eaa0cf04fc94fcb8f", "tried": ["Original simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; no simulator edits, no sandbox, standard randomized configurations and 2000 steps. CPython 3.12.3 CLI calibration on 1000-1599 with --workers 4 exactly reproduced mean 108.63974289615767; zero failures.", "CPython cProfile, seeds 4000-4009: {\"on_step_calls\": 20000, \"on_step_self_seconds\": 9.735985548, \"on_step_cumulative_seconds\": 21.543128067, \"total_profiled_seconds\": 76.05441006600014}; profiler overhead and concurrent workloads mean these are attribution measurements, not throughput timings.", "Rejected unique-distance Gaussian kernel: exact full results for 30 tuning seeds 4000-4029; ten-run CPU base 15.062272793 versus candidate 16.589081118. On the 30-run repeat CPU base 46.790843144 versus candidate 46.618413951, too small/inconsistent to select.", "Rejected sparse bisect filter variants: combined sparse/single-pass version replay CPU 3.144273814 seconds on 4000-4009 but 3.4967018719999996 on validation 6000-6009 versus base 3.367253792; action lists remained equal. Removed the bisect traversal from the final candidate.", "Runtime distinction: long sweeps use PyPy 8.0.1 / Python 3.12.15, with the unmodified official engine, sampler and result aggregation. CPython 3.12.3 is used for the required initial calibration and 200-run timings. Cross-runtime floating-point sums can differ in final bits, including per-run edge as well as inventory averages and initial-probability summaries; equality claims compare base and candidate within the same runtime.", "Cross-runtime calibration detail (native PyPy, no compatibility monkeypatch used for reported scores): {\"pypy_mean_edge\": 108.62320549194204, \"different_edge_seeds\": [[1107, -9.99982319171977e-11], [1385, 0.9254775658999961], [1481, 9.99946792035189e-11], [1541, -10.847920095199981]]}. Small arithmetic differences can propagate into different trades; the two material edge differences are not presented as candidate gains. CPython baseline is the required initial reproduction, while final full-range absolute scores are native PyPy-specific.", "Calibration independent PyPy runs: {\"base\":{\"mean_edge\":108.62320549194204,\"retail_edge\":136.27132097716466,\"arb_edge\":-27.64811548523451,\"simulations\":600,\"seed_start\":1000,\"failures\":0},\"fast4\":{\"mean_edge\":108.62320549194204,\"retail_edge\":136.27132097716466,\"arb_edge\":-27.64811548523451,\"simulations\":600,\"seed_start\":1000,\"failures\":0}}", "Supplementary independent native PyPy checks: all 313 complete tuning pairs on seeds 4000-4312 matched every SimulationResult field. First 30 full tuning per-run edges also match the earlier CPython reference.", "Final tuning action-equivalence runs: {\"base\":{\"mean_edge\":98.09786217293227,\"retail_edge\":125.18124886807635,\"arb_edge\":-27.08338669515864,\"simulations\":4000,\"seed_start\":4000,\"failures\":0},\"fast4\":{\"mean_edge\":98.09786217293227,\"retail_edge\":125.18124886807635,\"arb_edge\":-27.08338669515864,\"simulations\":4000,\"seed_start\":4000,\"failures\":0}}", "600 calibration pairs ran independently and match every SimulationResult field exactly. The 4000 tuning and 4000 unseen runs each instantiate independent base/candidate strategies, compare every action list (including exact quantities, IDs and ordering) and filter weights, then advance one unchanged official SimulationEngine with the identical actions. A mismatch raises an error and fails the run. Thus both market trajectories and every result field are identical by induction; these large sweeps share engine execution rather than independently replaying it. 16000000 checked steps across the large ranges; zero mismatches or failures. Canonical per-range result SHA256: {\"calibration\":\"c1776d17b1883f1d9c829393ea7df71708f1dc4e8dabd32f1ef29742248e8710\",\"tuning\":\"39bc9505f41a8eb958bb5981cac5c13593e2da24f1dc8517d92a162a249def72\",\"unseen\":\"0a651e7dbf8480fb5f62896113d54a8baf16b148226bbe27ebabfd250e3b4a76\"}", "Initial concurrent-load timing: one CPython process, 200 full simulations per file on seeds 6000-6199. Raw wall/CPU times and scores; these are not used as the final speed estimate: {\"base\":{\"wall\":944.0962711879984,\"cpu\":281.93288483,\"edge\":104.3629488397225,\"failures\":0},\"fast4\":{\"wall\":544.6666759670479,\"cpu\":259.593384381,\"edge\":104.3629488397225,\"failures\":0},\"failed1\":{\"wall\":401.13969070103485,\"cpu\":265.45966402,\"edge\":104.27565169744001,\"failures\":0},\"failed2\":{\"wall\":400.139660436078,\"cpu\":265.36345218300005,\"edge\":105.380067769083,\"failures\":0}}", "Final isolated CPython 3.12.3 timing: 200 full runs per file, seeds 6000-6199 in four counterbalanced 50-run blocks, one process, after equal two-run warmups on 7998-7999. No simulation jobs ran concurrently. All 200 independent result pairs matched every field. seconds contains the summed elapsed wall times, not CPU times. Raw measurements: {\"totals\":{\"base\":{\"wall\":265.82176911085844,\"cpu\":265.61252747,\"simulations\":200,\"failures\":0},\"fast4\":{\"wall\":257.17929600796197,\"cpu\":257.033364528,\"simulations\":200,\"failures\":0}},\"blocks\":[{\"seed_start\":6000,\"order\":[\"base\",\"fast4\"],\"timings\":{\"base\":{\"wall\":65.83718256093562,\"cpu\":65.76796581,\"mean_edge\":67.33322706196,\"failures\":0},\"fast4\":{\"wall\":65.36958261497784,\"cpu\":65.335882793,\"mean_edge\":67.33322706196,\"failures\":0}}},{\"seed_start\":6050,\"order\":[\"fast4\",\"base\"],\"timings\":{\"fast4\":{\"wall\":62.20586624299176,\"cpu\":62.15903410200002,\"mean_edge\":115.83995437003999,\"failures\":0},\"base\":{\"wall\":66.29833297198638,\"cpu\":66.26259282500004,\"mean_edge\":115.83995437003999,\"failures\":0}}},{\"seed_start\":6100,\"order\":[\"base\",\"fast4\"],\"timings\":{\"base\":{\"wall\":68.99043255695142,\"cpu\":68.93564329499998,\"mean_edge\":159.810797642674,\"failures\":0},\"fast4\":{\"wall\":66.57348561799154,\"cpu\":66.53529496099998,\"mean_edge\":159.810797642674,\"failures\":0}}},{\"seed_start\":6150,\"order\":[\"fast4\",\"base\"],\"timings\":{\"fast4\":{\"wall\":63.030361532000825,\"cpu\":63.003152672,\"mean_edge\":74.467816284216,\"failures\":0},\"base\":{\"wall\":64.69582102098502,\"cpu\":64.64632553999996,\"mean_edge\":74.467816284216,\"failures\":0}}}],\"exact_pairs\":200}", "Failure diagnosis a799a7073e05509473d99a982226006f4ebce8fdcc04d75b44cae846a158142b: {\"range\":[50000,50999],\"mean_edge\":92.32221105307814,\"retail_edge\":116.93913308207954,\"arb_edge\":-24.616922028993407,\"simulations\":1000,\"seed_start\":50000,\"failures\":0,\"max_cpu_seconds\":2.854954689,\"max_cpu_seed\":50000,\"max_wall_seconds\":8.608382285921834,\"max_wall_seed\":50000,\"warm_max_cpu_seconds\":0.7148003450000147,\"first_100_mean_cpu\":0.6386719918300002,\"last_100_mean_cpu\":0.47127237648000286,\"cpython_200\":{\"wall\":401.13969070103485,\"cpu\":265.45966402,\"edge\":104.27565169744001,\"failures\":0}}", "Failure diagnosis 5aa77c807417d8eb4743635be24fb9590f57e3e636dfb11050dd283e0a14ad6d: {\"range\":[50000,50999],\"mean_edge\":91.39885994047332,\"retail_edge\":116.9249422578437,\"arb_edge\":-25.526082317357005,\"simulations\":1000,\"seed_start\":50000,\"failures\":0,\"max_cpu_seconds\":2.1314109,\"max_cpu_seed\":50000,\"max_wall_seconds\":6.392912463983521,\"max_wall_seed\":50000,\"warm_max_cpu_seconds\":0.6780277089999913,\"first_100_mean_cpu\":0.6041778220400001,\"last_100_mean_cpu\":0.45048050263999984,\"cpython_200\":{\"wall\":400.139660436078,\"cpu\":265.36345218300005,\"edge\":105.380067769083,\"failures\":0}}", "Most likely explanation of the reported approximately-five-minute hosted stops: an aggregate execution/resource deadline, not a reproduced strategy exception. This is an inference; hosted logs, seed list and job-limit settings were unavailable. The repository sandbox default timeout is 300 seconds PER SIMULATION, which does not establish the hosted batch deadline. Both suspect files have bounded belief grids (48 bins) and fixed loops; their retained order-ID maps reset in each new Strategy. statistics is on the sandbox import allowlist. No actual sandbox run was attempted, as requested.", "SELECTED and frozen before full scoring: cache at most 512 public tick grids, zip the previous grid/weights once per step and bind math.exp locally; hoist unchanged variance/rho/mu/inv(0.01); classify orders/probes in one traversal; eliminate unused allocations and the inventory target whose two coefficients both equal 0.08. Original products, cutoff and accumulation order retained. Replay CPU 4000-4009: base 3.304284075, candidate 3.0855715740000003; separate validation 6000-6009: base 3.367253792, candidate 3.0490106420000007. All actions equal on both blocks. No parameters, economic rules, seed handling or trading policy changed. Final unseen mean/retail/arb differences and standard error are exactly zero."], "next": "Use this as a policy-identical fixed-parameter base. When grafting parameter changes, restore the deleted inventory branch if kLb and kLf differ; it is specialized to their equal 0.08 values. Refresh derived constants if mutating P at runtime, and clear the grid cache if bins changes. Further exact speed work could cache squared grid coordinates without changing arithmetic order. Obtain hosted termination logs before attributing the old stops to a specific sandbox limit."}