{
  "approach": "Returned the supplied start file unchanged: no tested change established a broad, independently confirmed gain within the entry requirements. Measurements identify one-cent stock acquisition as the main arbitrage leak in rich runs, but larger asks, fixed horizon cuts and tested queue/flow changes did not justify replacing the baseline.",
  "blocked": null,
  "spread": 1,
  "base_mean_edge": 108.63974289615767,
  "found": [
    "Local measurements on all 2035 spread-1 choosing seeds in [30000,37999]; 259 rich runs have true post-move probability below 0.02 on more than 500 steps. Rich-run mean such steps=821.8996138996139. The deployable code never observes true probability or a seed.",
    "Across each entire rich run, retail BUY dollars offered averaged 1143.1774799431337 and participant retail BUY fill edge averaged 315.9121530563667. The detailed waterfall below is restricted to steps with true post-move probability below 0.02.",
    "Across each entire rich run, official mean total edge=247.93331654292123, retail edge (both sides)=323.6437527265112 and arb edge=-75.71043618356602.",
    "Rich-run low-price retail BUY-dollar waterfall, means per rich run: offered=468.35592098214397; kept fill edge=304.27649787289744; true value of YES delivered=82.11328591088635; unreceived dollars classified as size/no-quote/quantum residual=67.52251927981243, worse posted price/FIFO=0.0, insufficient current YES cover=14.443617918547748. These sum to offered dollars; value delivered is not an execution loss. Classification allocates cover shortages first, then worse posted FIFO, then size/no-quote; it is descriptive, not a causal oracle.",
    "On a fixed-path current-front-price benchmark (rival tick if already ahead there, otherwise one tick inside with floor tick 1), positive retail missed-edge gaps averaged 35.63058232448227 for size/no-quote, 0.0 for worse posted tick/FIFO and 2.849649974267128 when YES inventory was below 0.01 shares. This ignores inventory and future adverse-fill effects and is not a free-profit estimate.",
    "Worse-tick static comparison: on the same notional as actual participant retail BUY fills, marking at the rival ask instead would increase edge by mean=27.488125457783585 per rich run. It ignores the rival queue and future dynamics and is not an attainable-profit claim. No-quote cases are in the size bucket above.",
    "Across each whole rich run, arbitrage loss on bids priced at most 0.05 averaged 57.602857049021644: one-cent stock=43.15102600909279, two-to-five-cent stock=5.053196766844253, normal one-cent quotes=1.4279861178327864, normal two-to-five-cent quotes=7.907548706288288, probes/tiny residuals=0.06309944896358381. One-cent stock remaining sizes greater than 60 shares at arbitrage time accounted for 42.98415969915998; smaller stock orders for 0.1668663099328003. This is already included in arb_edge and is not charged again against retail.",
    "During the rich runs' steps with true probability below 0.02, arbitrage bid loss averaged 50.16821047207126 and ask loss 1.6715040775674403.",
    "Rich runs ended with mean YES inventory=14977.37308880309 and mean final wealth=946.1854741312742. Settlement/holding is not an additional edge charge: the simulator scores fills only.",
    "Logging-only replay matched total_edge, retail_edge, arb_edge, final_cash, final_yes_inventory, final_no_inventory and final_wealth exactly for all 259 rich choosing runs. Per-run retail-dollar waterfall residual was below 1e-7. Original choosing-run failures=0.",
    "Final holdout uses all 2032 spread-1 seeds in [90000,97999]. Other-spread equality compares every SimulationResult field on 300 seeds of each spread 2, 3 and 4, starting at 90000."
  ],
  "holdout": {
    "mean_edge": 39.089297776806546,
    "retail_edge": 62.495372076100054,
    "arb_edge": -23.406074299315012,
    "failures": 0
  },
  "diff": {
    "mean": 0.0,
    "standard_error": 0.0,
    "retail": 0.0,
    "arb": 0.0,
    "trimmed": 0.0,
    "runs_up": 0,
    "runs_down": 0
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "start": 113.6790072307922,
    "yours": 112.21224761940539
  },
  "code": "\"\"\"Crossing-cover base with isolated, untuned per-spread overrides stacked: each acts only in runs of its own competitor spread.\"\"\"\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 == 4:\n                # Censored compound-Poisson flow likelihood, using only our fills.\n                self.f4_exposure = [0, 0]\n                self.f4_events = [0, 0]\n                self.f4_weights = [[0.0] * 9, [0.0] * 9]\n                self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n                # Positive aggregate flow is approximately lognormal; +0.065\n                # accounts for the occasional second arrival in a timestep.\n                self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n                self.f4_last = [None, None]\n                self.f4_rate = 0.1265\n                self.f4_mean = 4.488\n                self.f4_flow = self.f4_rate * self.f4_mean\n                self.f4_extreme = inv(1 - 1e-6)\n            if self.s == 2:\n                self.params.update(dict(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\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 == 4:\n            for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n                last = self.f4_last[side]\n                if last is None:\n                    continue\n                tick, conv, cap, old_bound, ids = last\n                if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n                    continue\n                # Track only the main quote, excluding probes and stock orders.\n                remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n                value = max(0.0, cap - remaining * conv)\n                self.f4_exposure[side] += 1\n                if value > 0.01:\n                    self.f4_events[side] += 1\n                    censored = remaining < 0.011\n                    logv = math.log(max(value, 0.01))\n                    weights = self.f4_weights[side]\n                    for i, mu4 in enumerate(self.f4_mu):\n                        z4 = (logv - mu4) / 1.2\n                        weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n            if state.step % 25 == 0:\n                exposure = sum(self.f4_exposure)\n                events = sum(self.f4_events)\n                event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n                self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n                weights = [a + b for a, b in zip(*self.f4_weights)]\n                peak = max(weights)\n                weights = [math.exp(w - peak) for w in weights]\n                self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n                self.f4_flow = self.f4_rate * self.f4_mean\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 == 4:\n                exp = math.exp\n                if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n                    # On this stationary grid, spacing is exactly 1/8 tick.\n                    # Equal index distances therefore have bit-identical d*d*k.\n                    # Reuse exp values while retaining the original sum order.\n                    kernel = []\n                    c0 = cs[0]\n                    for ci in self.bc:\n                        d = c0 - ci\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, e in zip(self.bw, kernel[start:start + nb]):\n                            if e:\n                                t += wi * e\n                        ws.append(t)\n                else:\n                    previous = tuple(zip(self.bc, self.bw))\n                    for c in cs:\n                        t = uni\n                        for ci, wi in previous:\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            if self.s == 4:\n                ja = jb = 0.0\n                for p, w in jp:\n                    if x > p:\n                        ja += w * (x - p)\n                    else:\n                        jb += w * (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            if self.s == 4 and tail <= 1e-6:\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\n            return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n        ptk = phat * 100\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 4 and phat * 100 - t < P['dmin']:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if phat * 100 - t < P['dmin']:\n                return 0.0\n            if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n                return 0.0\n            if phat < P['pL']:\n                ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n                a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 4 and t - phat * 100 < P['dmin']:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            if self.s == 4:\n                tail = b * kA / max(self.f4_rate * a, 1e-30)\n                if a <= 0 or tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n            if self.s == 2 and phat < 0.1:\n                a = max(0.0, a - 0.0015 * (1 - min(1.0, state.yes_inventory / 3000.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            threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else P['min_ahead']\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\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            flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n            target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(flow_scale * 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 == 4:\n                stock_rate *= self.f4_flow / 0.6\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                if self.s == 2:\n                    ub = min(ub, max(0.0, free - 200 * min(1.0, H / 50.0)))\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        if self.s == 4:\n            self.f4_last = [None, None]\n            # Eligibility is decided before observing fills, so depleted quotes\n            # remain in the sample as right-censored observations.\n            for side, tick, bound, conv, distance in (\n                (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n                (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n                if distance < max(0.01, 3.0 * self.st / 100.0):\n                    continue\n                if side == 0:\n                    if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n                        continue\n                    orders = asks\n                    order_side = Side.SELL\n                else:\n                    if not (bid_t > cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n                        continue\n                    if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n                        continue\n                    orders = bids\n                    order_side = Side.BUY\n                tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n                tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n                cap = sum(tracked.values()) * conv\n                if cap >= 0.5:\n                    self.f4_last[side] = (tick, conv, cap, bound, tracked)\n        return actions + out\n",
  "code_sha256": "4bbf720ff34be09b441e84a7e0c1bf47cba036b5211c4118e44a597f941453db",
  "tried": [
    "Python 3.12.3, simulator b244530ee2a6247b5f930830eeca9dd950da0e7e: python3 -m orderbook_pm_challenge run ../earlier.py --simulations 600 --seed-start 1000 --workers 4 --json, without sandbox. Mean edge=108.63974289615767, failures=0. File birth-to-final-write baseline wall interval=164.483260874 seconds, below 300 seconds; no run counts halved.",
    "Extend the existing 5x low-price ask multiplier from tick 2 to tick 1. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": -6.209647425071105, \"standard_error\": 2.057173086254269, \"retail\": -0.10493943374901411, \"arb\": -6.104707991321993, \"trimmed\": -1.432059816615292, \"runs_up\": 248, \"runs_down\": 161, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": -9.896797583030471, \"standard_error\": 6.476770805211343, \"retail\": 5.264974343000779, \"arb\": -15.161771926017188, \"trimmed\": -0.2278640505037051, \"runs_up\": 56, \"runs_down\": 53, \"failures\": 0}.",
    "Spread 1 only: shorten Wf from 2000 to 500 for all stock calculations. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": -4.1154882188871795, \"standard_error\": 1.034348296708088, \"retail\": -2.008061604389546, \"arb\": -2.107426614498126, \"trimmed\": -0.6064264960871232, \"runs_up\": 66, \"runs_down\": 54, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": -33.205019766156255, \"standard_error\": 7.738841983520471, \"retail\": -15.914688174232031, \"arb\": -17.29033159192734, \"trimmed\": -6.295605678027781, \"runs_up\": 60, \"runs_down\": 53, \"failures\": 0}.",
    "Spread 1 only: queue at tick 2 instead of fronting tick 1 and permit replenishment at the rival tick. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": -5.163407592418343, \"standard_error\": 2.726052234913349, \"retail\": -1.0501539145126235, \"arb\": -4.113253677906706, \"trimmed\": -2.246236256843763, \"runs_up\": 149, \"runs_down\": 314, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": 3.2590290114914042, \"standard_error\": 8.054114530618858, \"retail\": 3.775386498033593, \"arb\": -0.5163574865515607, \"trimmed\": -6.33586320135741, \"runs_up\": 61, \"runs_down\": 67, \"failures\": 0}.",
    "Suppress one-cent ammunition when asking one cent; a no-op because the existing ammunition block already requires ask_t >= 2. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": 0.0, \"standard_error\": 0.0, \"retail\": 0.0, \"arb\": 0.0, \"trimmed\": 0.0, \"runs_up\": 0, \"runs_down\": 0, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": 0.0, \"standard_error\": 0.0, \"retail\": 0.0, \"arb\": 0.0, \"trimmed\": 0.0, \"runs_up\": 0, \"runs_down\": 0, \"failures\": 0}.",
    "Activate tick-2 queueing only after 500 observed estimated-price-below-2-cent steps. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": -1.6916930318846157, \"standard_error\": 0.4687398098591108, \"retail\": -1.7398103543416172, \"arb\": 0.048117322456804716, \"trimmed\": -1.3858356182564389, \"runs_up\": 27, \"runs_down\": 88, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": -13.40138073696094, \"standard_error\": 3.556376240089884, \"retail\": -13.782560150799998, \"arb\": 0.38117941383749987, \"trimmed\": -12.754820412471298, \"runs_up\": 27, \"runs_down\": 88, \"failures\": 0}.",
    "Shorten only the one-cent crossing-stock horizon to 500; retain every other stock horizon. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": -4.021222722002663, \"standard_error\": 1.0164595552603963, \"retail\": -2.1066249247747537, \"arb\": -1.9145977972276131, \"trimmed\": -0.5739620356023143, \"runs_up\": 66, \"runs_down\": 53, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": -32.458260283024224, \"standard_error\": 7.609848724062753, \"retail\": -16.695494477908596, \"arb\": -15.7627658051125, \"trimmed\": -5.996812402825004, \"runs_up\": 60, \"runs_down\": 52, \"failures\": 0}.",
    "Reuse the supplied spread-4 censored-flow estimator, constants and one-cent eligibility for spread 1; scale only its one-cent crossing-stock target by estimated flow / 0.6. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": 0.35331360805207107, \"standard_error\": 0.40229340976774514, \"retail\": -0.06917656693865876, \"arb\": 0.4224901749887574, \"trimmed\": 0.1876081460896377, \"runs_up\": 309, \"runs_down\": 177, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": 0.037037565885156526, \"standard_error\": 2.6612805027648316, \"retail\": 0.12177531060312519, \"arb\": -0.08473774472968713, \"trimmed\": 1.3709239030388878, \"runs_up\": 66, \"runs_down\": 58, \"failures\": 0}.",
    "Same flow-based stock target, with a half-tick minimum observation distance for spread 1; retain the original three-sigma safety test. Discovery spread-1 seeds [30000,33999]: {\"runs\": 1014, \"mean\": 0.0011438663609468376, \"standard_error\": 0.39425907921385783, \"retail\": 0.1543673094814595, \"arb\": -0.15322344312317554, \"trimmed\": -0.25628574372967805, \"runs_up\": 298, \"runs_down\": 186, \"failures\": 0}; rich subset: {\"runs\": 128, \"mean\": -2.2360150599085946, \"standard_error\": 2.7428400745525314, \"retail\": 1.242272407228906, \"arb\": -3.4782874671531245, \"trimmed\": -1.701112022377779, \"runs_up\": 56, \"runs_down\": 67, \"failures\": 0}.",
    "Fixed flowstock candidate on reserved choosing seeds [34000,37999], not used to design it: {\"runs\": 1021, \"mean\": -0.09565798625817869, \"standard_error\": 0.4133122943483028, \"retail\": -0.04471574274701324, \"arb\": -0.05094224351204698, \"trimmed\": 0.11851255687032915, \"runs_up\": 297, \"runs_down\": 179, \"failures\": 0}; rich subset: {\"runs\": 131, \"mean\": -2.6749241860076367, \"standard_error\": 3.080963964356635, \"retail\": -0.8448019559030561, \"arb\": -1.8301222301068705, \"trimmed\": -1.0392838336954997, \"runs_up\": 68, \"runs_down\": 62, \"failures\": 0}.",
    "Final timings sum engine.run wall seconds for 200 matched spread-1 seeds in one process, alternating execution order, after all our parallel evaluation batches finished.",
    "Return the exact start file. Full discovery contained 1014 spread-1 runs, with 1021 reserved choosing runs. The fixed original-eligibility flowstock candidate gained 0.35331360805207107 in discovery but lost 0.09565798625817869 in reserved choosing runs (rich subset -2.6749241860076367); it fails the independent-gain requirement. The half-tick-eligibility variant had discovery mean 0.0011438663609468376 but trimmed mean -0.25628574372967805 and rich mean -2.2360150599085946, so was not a broad gain. All other active candidates lost discovery mean edge, and nochurn was a no-op. No confirming spread-1 scores were inspected before this decision; no constants were fitted after reserved validation."
  ],
  "next": "Test a probability- and jump-risk-aware cap on one-cent crossing-cover bids while retaining higher-tick stock horizons and established tick-2 FIFO priority. Do not reuse the rejected blanket size/horizon changes as improvements."
}