{"approach": "No change: the code is the base, byte for byte, because no wait-then-lead switch for spread 2 gained on tuning seeds held back from the search. Scorer check: the CLI run (4000 simulations from seed 4000, 4 workers, no sandbox, simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e, Python 3.12.3) reproduced the author's mean edge exactly. What was built and measured (all gated on self.s == 2, tuned only on spread-2 seeds in 8000-15999, split into four parts A-D of about 500): (1) wait: an ask resting behind the rival's lot at its own tick, covered by stock the inside quote does not use, promoted to front once the rival's best ask moves above it; (2) switch: no inside quote while it sits within a set distance of the price, resting at the rival's tick instead; (3) lead keeping: a front order at the rival's tick is not cancelled when the one-step size rule shrinks; (4) deep front orders: an inside (free-tick) order sized for many steps so the lead lasts when the rival's lot returns. Why it does not pay at spread 2. A diagnostic of the base on 160 tuning runs splits its 78.50 mean edge by true price: 59.91 of the retail edge on asks is earned under 1 cent, 9.51 at 1-2 cents, 5.13 at 2-3, 3.69 at 3-5, 3.18 at 5-10. Under 1 cent the base already sells at tick 2 for about 0.90 of every retail dollar (66.55 of the 70.62 dollars of retail buying, edge 59.91) and its stock costs little (arbitrage cost of bids there 5.22); first place at tick 3 would earn about 0.93, so the lead is worth about 0.03 a dollar, while waiting for the rival's 24 to 72 dollar lot gives up about 0.90 a dollar of it: the wait never pays there. Between 1 and 5 cents the inside quote within one tick of the price nets about nothing (switching it off lost 4.38 of retail edge and saved 4.48 of arbitrage loss per low-price run), so the wait is free, but the lot takes about 85 steps of average retail buying to be used up (my estimate from the configured ranges: a 48 dollar lot against 0.253 orders a step of 4.49 dollars, half of them buys), while a run spends on average only 33.45 steps at 1-2 cents, 31.01 at 2-3 and 37.79 at 3-5, so the lead rarely arrives; larger resting orders are swept by jumps and drain the stock (retail falls as well). Lead keeping alone moved the result by a few hundredths with a standard error of the same size and changed sign across parts. The frozen file was still scored as the brief asks: on the 1987 unseen spread-2 seeds in 60000-67999 it and the base agree on every run, and on 300 runs of each other spread (first 300 seeds of that spread from 60000 on) every result field is equal. Timing is 200 runs (seeds 60000-60199) of each in one process, interleaved seed by seed with alternating order; the two figures are the same code measured twice, so their difference is timer noise. Tuning-part figures in 'tried' are mean paired differences (variant minus base) over the runs of that part whose true price goes under 7 cents at some step (255 of 500 in part A, 253 in B, 243 in C); the other runs of the part are not touched by a rule that acts under 5 cents, so the per-run figure over the whole part is about half.", "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": 56.602461212925846, "yours": 56.787860767013626}, "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": ["Scorer check: base CLI mean edge 98.4694596619638 over seeds 4000-7999 (author: 98.4694596619638); by spread: s1 34.857533632043946 (999 runs), s2 78.31377315579168 (1033), s3 124.39361247344229 (993), s4 158.59915660859724 (975).", "Diagnostic, base, 160 spread-2 tuning runs, mean edge 78.50218019333877: retail edge on asks by true price 0-1c 59.91, 1-2c 9.51, 2-3c 5.13, 3-5c 3.69, 5-10c 3.18, 10-30c 4.32, 30-70c 3.14; retail buying available 70.62, 21.96, 18.51, 20.61, 38.56, 176.52, 420.92 dollars; steps with our ask first at the rival's tick 18.84 of 124.78 under 1c, 97.48 of 754.28 at 30-70c.", "Wait behind the rival's lot plus deep inside orders, size factor 0.5, under 5c: part A -6.487 (se 3.652; retail +0.735, arb -7.222), part B -9.536 (se 2.823; retail -0.087, arb -9.449). Dropped.", "Wait behind only, size factor 0.5: part A -10.778 (se 3.985; retail -3.548, arb -7.230). Dropped: resting stock behind the lot is swept by jumps and earns nothing until the lot is gone.", "Wait behind plus deep inside, size factor 0.05: part A +0.089 (se 0.232; retail +0.255, arb -0.166). Noise.", "Deep inside orders only, size factor 0.1: part A -0.027 (se 0.150; retail +0.362, arb -0.389). The retail gain from longer leads is paid back to the arbitrageur.", "Switch, no inside quote within 0.5 tick of the price, wait at the rival's tick (factor 0.1): part A -0.272 (se 1.724).", "Switch within 1 tick, wait factor 0.1: part A +0.096 (se 0.731; retail -4.379, arb +4.475); factor 0.03: -0.110 (se 0.658; retail -5.034, arb +4.924); factor 0.3: -1.808 (se 0.991; retail -5.216, arb +3.408); factor 1: -11.261 (se 2.773; retail -9.888, arb -1.374).", "Switch within 1 tick, factor 0.1, under 10c instead of 5c: part A -0.209 (se 0.801). Switch within 0.75 tick, factor 0.3: -1.399 (se 0.966). Switch within 1 tick, factor 0.3, under 3c only: -2.402 (se 0.983).", "Diagnostic of the switch (within 1 tick, factor 0.1) on the same 160 runs: mean edge 77.46016257107561 against 78.50218019333877; steps waiting behind the lot 5.32 (1-2c), 10.51 (2-3c), 13.26 (3-5c); retail edge on asks fell 59.91 to 59.18 under 1c, 9.51 to 8.99 at 1-2c, 5.13 to 4.86 at 2-3c, 3.69 to 3.07 at 3-5c.", "Lead keeping only (front order kept up to 1.5 times a many-step size, factor 0.5): part A +0.052 (se 0.052), held-back part B -0.004 (se 0.014), held-back part C +0.005 (se 0.036). Not kept: no gain on the held-back parts.", "Lead keeping only, factor 3: part A +0.110 (se 0.159), part B +2.063 (se 2.095, one run), part C -0.185 (se 0.269); factor 20: part A +0.112 (se 0.163); factor 3 under 15c: part A -0.189 (se 0.421). Not kept.", "Frozen file (the base): unseen spread-2 seeds, 1987 runs, mean edge 75.37891657984132, identical to the base on all 1987; other spreads 900 of 900 runs identical; 0 failures."], "next": "At spread 2 the retail lot cannot be waited out: it needs about 85 steps of average buying and the price leaves a one-cent band sooner. Three things are left. (a) Estimate the buying rate from our own fills and wait only in runs where rate times remaining steps is many times the lot (small lot, heavy flow, price parked between 1 and 3 cents with more than about 300 steps left); the lot size is not in the state, so it has to be inferred from the first time a resting order behind it is reached. (b) The free lead at tick 3: when the price falls through 1 cent while the rival's tick-3 lot is a bid at tick 1, an order already resting at tick 3 is first for good; have the stock on hand before the crossing (the tick-1 bids fill one step too late) and size that order for the whole stay under 1 cent, worth at most about 0.03 a dollar on about 67 dollars a run. (c) The mass of the 47.86 is between 10 and 90 cents, where the base has no ask on about two steps in three and the rival takes the flow one to two ticks from the price; there first place only comes from an order already resting on a free tick when the price falls two ticks, so test small standing orders on both free ticks sized by the arbitrage cost at that distance, on the full tuning set (standard error about 0.2 a run needs all 1967 runs)."}