{
  "approach": "Six supplied Paradigm results treated as a small, confounded experiment; these public scores are requester-provided and were not independently rerun. Relative to the parent, crossing cover (the base) gained 1.70758 total: +0.624395 retail and +1.083185 arb. Demand fitting gained 1.189612 despite -0.559985 retail; cash planning gained 0.548739 despite -1.500123 retail; late-game restrictions lost 0.305434 despite saving 1.221202 arb. Thus reducing arbitrage loss can help, but the best public file preserved more retail. The first-to-parent gain also coincided with cheaper pre-positioned YES and more retail capture. These six aggregates do not identify causality or the public seed distribution. Local paired tests rejected broad ask-size multipliers and frequent replenishment when extra arbitrage loss outweighed the retail gain. Raises the ordinary ask size ceiling from 3000 shares to max(3000,min(10000,current YES inventory)) only when the existing fair-probability estimate is below 0.002 (0.2 cents). Extra capacity is backed by stock already held. The original crossing bank, eager purchases, price selection, filter resolution, and replenishment thresholds remain in place. Gaussian kernels are shared only for identical exactly representable grids, fixed parameters are compiled into constants, and jump-loss sums share one loop; these runtime changes passed exact-result checks. The intended public effect is greater capture of large retail orders using cheap inventory, while retaining the base probability filter, crossing cover and ordinary risk rule. I expect this to transfer better than wholesale demand or inventory suppression, but no Paradigm score is claimed or guaranteed. Local eligibility (unseen retail >= base, zero final failures, 200-run wall time <= base): True.",
  "blocked": null,
  "python_version": "3.12.3",
  "base_mean_edge": 108.63974289615767,
  "base_unseen": {
    "mean_edge": 97.54703502577897,
    "retail_edge": 126.92890288111944,
    "arb_edge": -29.381867855334075
  },
  "score": {
    "mean_edge": 98.39034603951998,
    "retail_edge": 125.53389922530091,
    "arb_edge": -27.143553185794875,
    "simulations": 4000,
    "seed_start": 4000,
    "failures": 0
  },
  "holdout": {
    "mean_edge": 97.75643908844914,
    "retail_edge": 127.30311629939337,
    "arb_edge": -29.546677210937975,
    "simulations": 4000,
    "seed_start": 50000,
    "failures": 0
  },
  "diff": {
    "mean": 0.209404062670175,
    "standard_error": 0.0669494819952478,
    "retail": 0.37421341827392507,
    "arb": -0.16480935560390003
  },
  "seconds": {
    "base": 254.04184297309257,
    "yours": 243.92939586169086
  },
  "code": "\"\"\"Inventory-backed retail-tail capacity for passive binary market making.\n\nRaises the ordinary ask size ceiling from 3000 shares to max(3000,min(10000,current YES inventory)) only when the existing fair-probability estimate is below 0.002 (0.2 cents). Extra capacity is backed by stock already held. The original crossing bank, eager purchases, price selection, filter resolution, and replenishment thresholds remain in place. Gaussian kernels are shared only for identical exactly representable grids, fixed parameters are compiled into constants, and jump-loss sums share one loop; these runtime changes passed exact-result checks.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\nMODEL_VAR = 0.02 ** 2 + 0.0019 * 0.35 ** 2\nRETAIL_RHO = 0.25 * 0.5\nRETAIL_MU = math.log(5.0) - 0.5 * 1.2 ** 2\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\n\ndef cdf(x):\n    return 0.5 * (1.0 + math.erf(x / SQ2))\n\ndef pdf(x):\n    return math.exp(-0.5 * x * x) / SQ2PI\n\ndef inv(p):\n    p = min(max(p, 1e-09), 1 - 1e-09)\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\n\ndef lpm(k):\n    return pdf(k) + k * cdf(k)\n\ndef fl(q):\n    return math.floor(q * 100 + 1e-09) / 100\nNODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\nPROBE = 0.01\n\nclass Strategy(BaseStrategy):\n\n    def __init__(self):\n        self.n = 0\n        self.ahead = set()\n        self.res = {}\n        self.bc = None\n        self.bw = None\n        self.st = 0.5\n        self.pcb = self.pca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None\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        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        sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-09}\n        sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-09}\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) <= 1.0):\n            hi = min(hi, max(min(eb), lo))\n        if True 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        wid = max(hi - lo, 1e-06)\n        nb = max(2, min(48, int(round(wid * 8.0))))\n        cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n        if self.bc is None or False:\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 = 0.01 * sg\n            if wid == nb / 8.0 and cs == self.bc:\n                kernel = []\n                for di in range(1 - nb, nb):\n                    d = di / 8.0\n                    d2 = d * d * k\n                    kernel.append(math.exp(d2) if d2 > -12.5 else 0.0)\n                for i in range(nb):\n                    t = uni\n                    for wi, e in zip(self.bw, kernel[nb - 1 - i:2 * nb - 1 - i]):\n                        if e:\n                            t += wi * e\n                    ws.append(t)\n            else:\n                previous_belief = tuple(zip(self.bc, self.bw))\n                for c in cs:\n                    t = uni\n                    for ci, wi in previous_belief:\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 = MODEL_VAR\n        sd = math.sqrt(H * var)\n        self.tb = self.tb + 1 if hi <= 1 else 0\n        if self.tb > 0 and True:\n            phat = min(phat, max(0.0005, cdf(inv(0.01) - 1.0 * 0.02 * math.sqrt(self.tb) / sd)))\n        z = inv(phat)\n        Z = z * sd\n        sp = pdf(z) / sd * 0.02\n        self.st = sp * 100.0\n        s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n        sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n        jp = [(cdf((Z + n * 0.35) / sd1), w) for n, w in NODES]\n        lj = 0.0019\n\n        def AB(x):\n            k = (x - phat) / s\n            a = s * lpm(k)\n            b = a - (x - phat)\n            ja = jb = 0.0\n            for p, w in jp:\n                if x > p:\n                    ja += w * (x - p)\n                elif p > x:\n                    jb += w * (p - x)\n            return ((1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb)\n        if H == 1:\n\n            def AB(x):\n                return ((1 - phat) * x, phat * (1 - x))\n        rho = RETAIL_RHO\n        mu = RETAIL_MU\n        kA = 0.15 if phat < 0.05 else 0.7\n\n        def qsize(loss, gain, px, cap=3000.0):\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(cap, math.exp(mu + 1.2 * inv(1 - max(tail, 1e-06))) / px)\n        ptk = phat * 100\n\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 < 0.0:\n                return 0.0\n            if False and self.s == 1 and (t == 1) and (ptk < 1.0):\n                return 0.0\n            if phat < 0.05:\n                ytg = 0.4 * min(H, 200.0) / max(ca - 1, ptk + 1) * 100.0\n                a *= (0.08 if state.yes_inventory < ytg else 0.08) / 0.15\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 < 0.0:\n                return 0.0\n            return qsize(b, a, t / 100.0, max(3000.0, min(10000.0, state.yes_inventory)) if phat < 0.002 else 3000.0)\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-09]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-09]\n        sticky = True\n\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)) >= 2.0:\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        Y = state.yes_inventory\n        if ask_t == 1 and H > 100.0 and False:\n            qa = qa if Y >= 100.0 > 0 else 0.0\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if True and ask_t >= 2 and (phat < max(0.05, 0.05)):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = 0.6 * wealth / max(phat, 0.005)\n            target = min(0.4 * min(H, 200.0) / x, capw)\n            full = min(0.6 * min(H, 2000.0) / x, capw) if phat < 0.05 else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-09))))\n            g = t - ptick\n            if Y < full and g <= 0.15 and (bid_t <= t < ask_t):\n                amt, qam = (t, min(400.0, full - Y))\n            elif Y < target and phat < 0.05 and (bid_t <= t < ask_t) and (t / 100.0 - phat < 0.02):\n                amt, qam = (t, min(60.0, target - Y))\n            elif Y < full and t >= 2 and (1.0 - g <= 0.15):\n                amt, qam = (t - 1, min(400.0, full - Y))\n        if False and ca == 2 and (phat < 0.01) and (H > 100.0) and (Y < 0.0) and (not qam) and (1.0 - ptick < 1.0):\n            amt, qam = (1, min(60.0, 0.0 - Y))\n        q1 = 0.0\n        if True and 1.0 < ptick < 5.0 + 1.0 and (amt != 1):\n            q1 = max(0.0, 0.6 * min(H, 2000.0) / (self.s / 100.0) - Y)\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        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n\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-09:\n                cancel(o)\n        kept_ids = set()\n\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 * 1.5, 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 * 0.7 and bid_t != cb else 0.0\n        add_a = qa - ka if ka < qa * 0.7 and ask_t != ca else 0.0\n        budget = 0.9 * 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, 0.6 * 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-06\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-06\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-06\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) 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 - 0.7) * max(state.cash, 0.0)) if x >= 0.1 else 0.0\n                if H < 300.0 and phat < 0.05:\n                    ub = max(0.0, free * (1 - H / 300.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-06\n                if ask_t < ca:\n                    self.ahead.add(oid)\n        f = int(math.floor(ptick + 1e-09))\n        r = max(int(2), 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": "0f4d34f0f93c32455d06cb4b0db73682ff9c54805952167870a6dcb2960dcebd",
  "tried": [
    "Scorer reproduction: unmodified simulator b244530ee2a6247b5f930830eeca9dd950da0e7e, official CLI --workers 4, no sandbox, seeds 1000-1599: {'mean_edge': 108.63974289615767, 'retail_edge': 136.2713209771645, 'arb_edge': -27.63157808101933}; failures=0. Exactly matches supplied author mean 108.63974289615767.",
    "Trial design: discovery restricted to seeds 4000-4999 (short screens 4000-4119; later refinement screens 4000-4499); separate validation starts at seed 6000. Final narrow-cap ideas were fixed after looking at early validation prefixes and received a separate 7000-7599 check that had not been used to find them. No candidate reads simulation seeds, hidden process values, or configuration. Public predecessors historically used other seed sets, including 50000+, so unseen means untouched by this task, not necessarily by all network predecessors.",
    "ammo120_4000_120 (Raise eager small stock-purchase limit from 60 to 120 shares): n=120, {'mean_edge': 105.08123789415335, 'retail_edge': 125.42045760019, 'arb_edge': -20.33921970605333}, paired={'mean': -0.04847855283749881, 'standard_error': 0.07554736348098466, 'retail': 0.0033437056991662216, 'arb': -0.051822258531666644}, failures=0",
    "askaggressive_4000_120 (Multiply ask expected loss by 0.7 below fair probability 10c): n=120, {'mean_edge': 104.8921366907225, 'retail_edge': 126.12154152517084, 'arb_edge': -21.22940483446167}, paired={'mean': -0.23757975626833397, 'standard_error': 0.5036797587818865, 'retail': 0.7044276306799986, 'arb': -0.9420073869400004}, failures=0",
    "askcap45_4000_120 (Multiply asks by 1.5 below fair probability 2c): n=120, {'mean_edge': 105.24994804147833, 'retail_edge': 126.42558187695, 'arb_edge': -21.175633835484998}, paired={'mean': 0.1202315944875017, 'standard_error': 0.6521680510039628, 'retail': 1.0084679824591665, 'arb': -0.8882363879633335}, failures=0",
    "askcap6_4000_120 (Multiply asks by 2 below fair probability 2c): n=120, {'mean_edge': 105.64843859834, 'retail_edge': 126.58835355955583, 'arb_edge': -20.93991496123}, paired={'mean': 0.5187221513491674, 'standard_error': 0.79650661718086, 'retail': 1.1712396650649994, 'arb': -0.6525175137083333}, failures=0",
    "askfund_4000_120 (Raise uncovered ask budget fraction to 0.9 and lower price gate to 5c): n=120, {'mean_edge': 104.87127354595167, 'retail_edge': 124.59792433254417, 'arb_edge': -19.72665078661417}, paired={'mean': -0.25844290103916545, 'standard_error': 0.8577368159155618, 'retail': -0.8191895619466675, 'arb': 0.5607466609075}, failures=0",
    "askkeep_4000_120 (Replenish only asks below 90% rather than 70% of target): n=120, {'mean_edge': 105.64035927552916, 'retail_edge': 126.15340410466334, 'arb_edge': -20.513044829149997}, paired={'mean': 0.5106428285383349, 'standard_error': 0.2567294809481393, 'retail': 0.7362902101725008, 'arb': -0.22564738162833323}, failures=0",
    "asklarge_4000_120 (Multiply all desired ask quantities by 1.5): n=120, {'mean_edge': 102.89742247111083, 'retail_edge': 127.89235164451334, 'arb_edge': -24.9949291734}, paired={'mean': -2.232293975879998, 'standard_error': 1.1942042161140893, 'retail': 2.4752377500225005, 'arb': -4.707531725878334}, failures=0",
    "bank50_4000_120 (Shorten dearer immediate-cover target horizon from 200 to 50; keep cheap crossing bank at 2000): n=120, {'mean_edge': 105.17415217286084, 'retail_edge': 124.756038020555, 'arb_edge': -19.5818858477125}, paired={'mean': 0.044435725870002094, 'standard_error': 0.39842260916116157, 'retail': -0.6610758739358339, 'arb': 0.7055115998091666}, failures=0",
    "bank50cap_4000_120 (Combine bank50 with inventory-backed ask cap): n=120, {'mean_edge': 105.86766609584083, 'retail_edge': 125.51779124513084, 'arb_edge': -19.650125149306668}, paired={'mean': 0.7379496488500014, 'standard_error': 0.5500856600253736, 'retail': 0.10067735063999947, 'arb': 0.6372722982149999}, failures=0",
    "bank50cover2_4000_120 (Combine bank50 with crossing-cover target multiplier 2): n=120, {'mean_edge': 104.91736051987166, 'retail_edge': 125.11508662064833, 'arb_edge': -20.19772610079083}, paired={'mean': -0.21235592711916537, 'standard_error': 0.40421865183497147, 'retail': -0.30202727384249983, 'arb': 0.08967134673083356}, failures=0",
    "bankmore_4000_120 (Raise tick-1 stock target coefficient from 0.6 to 0.9): n=120, {'mean_edge': 103.8926094126375, 'retail_edge': 125.7494761715725, 'arb_edge': -21.856866758953334}, paired={'mean': -1.2371070343533321, 'standard_error': 0.880020510328366, 'retail': 0.3323622770816654, 'arb': -1.569469311431667}, failures=0",
    "bankwide_4000_120 (Extend tick-1 bank activation upper fair price from 6c to 10c): n=120, {'mean_edge': 105.1431276212175, 'retail_edge': 125.41709643566418, 'arb_edge': -20.273968814468333}, paired={'mean': 0.013411174226666607, 'standard_error': 0.012996033487484212, 'retail': -1.7458826666446232e-05, 'arb': 0.013428633053333321}, failures=0",
    "base_4000_120 (Unchanged base; runtime suffix records an optimization check): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "base_const_4000_120 (Unchanged base; runtime suffix records an optimization check; exact fixed-parameter compilation): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "base_fast_4000_120 (Unchanged base; runtime suffix records an optimization check; exact jump-loop, belief-zip, and constant-hoisting optimization): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "base_grid_4000_120 (Unchanged base; runtime suffix records an optimization check; exact shared Gaussian kernel): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "base_gridconst_4000_120 (Unchanged base; runtime suffix records an optimization check; exact fixed-parameter compilation and shared Gaussian kernel): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "base_probe_4000_120 (Unchanged base; runtime suffix records an optimization check; retain eligible probes away from main quote prices): n=120, {'mean_edge': 105.12968521536416, 'retail_edge': 125.41709157436084, 'arb_edge': -20.287406359015833}, paired={'mean': -3.123162666668714e-05, 'standard_error': 1.8644380244866718e-05, 'retail': -2.232013000048975e-05, 'arb': -8.911494166715291e-06}, failures=0",
    "bidkeep_4000_120 (Replenish only bids below 90% rather than 70% of target): n=120, {'mean_edge': 105.42217275363083, 'retail_edge': 125.80279109235083, 'arb_edge': -20.380618338725}, paired={'mean': 0.2924563066400017, 'standard_error': 0.14391789074465225, 'retail': 0.3856771978599981, 'arb': -0.09322089120333367}, failures=0",
    "bins4_4000_120 (Reduce filter resolution from 8 to 4 bins per tick): n=120, {'mean_edge': 104.69220456869667, 'retail_edge': 125.22672199021501, 'arb_edge': -20.534517421551666}, paired={'mean': -0.4375118782941642, 'standard_error': 0.4781563900836795, 'retail': -0.19039190427583344, 'arb': -0.24711997402999997}, failures=0",
    "cap10000_4000_120 (Raise ask cap to 10000 shares below fair probability 2c): n=120, {'mean_edge': 105.8149833060225, 'retail_edge': 126.17857365308834, 'arb_edge': -20.363590347085832}, paired={'mean': 0.6852668590316673, 'standard_error': 0.3562396934164579, 'retail': 0.7614597585974984, 'arb': -0.07619289956416658}, failures=0",
    "cap4500_4000_120 (Raise ask cap to 4500 shares below fair probability 2c): n=120, {'mean_edge': 105.59250244368167, 'retail_edge': 126.15460847497334, 'arb_edge': -20.5621060313125}, paired={'mean': 0.46278599669083514, 'standard_error': 0.29720228737036763, 'retail': 0.7374945804824987, 'arb': -0.2747085837908333}, failures=0",
    "cap6000_4000_120 (Raise ask cap to 6000 shares below fair probability 2c): n=120, {'mean_edge': 105.78968543260333, 'retail_edge': 126.15513551417166, 'arb_edge': -20.36545008158833}, paired={'mean': 0.6599689856125001, 'standard_error': 0.34571464447449396, 'retail': 0.7380216196808312, 'arb': -0.07805263406666656}, failures=0",
    "capaskkeep_4000_120 (Combine inventory-backed ask cap with ask-only 90% replenishment): n=120, {'mean_edge': 106.20901196117917, 'retail_edge': 126.74795373015333, 'arb_edge': -20.538941768985833}, paired={'mean': 1.0792955141883345, 'standard_error': 0.4207974317116378, 'retail': 1.3308398356625006, 'arb': -0.2515443214641666}, failures=0",
    "capaskkeep_grid_4000_120 (Combine inventory-backed ask cap with ask-only 90% replenishment; exact shared Gaussian kernel): n=120, {'mean_edge': 106.20901196117917, 'retail_edge': 126.74795373015333, 'arb_edge': -20.538941768985833}, paired={'mean': 1.0792955141883345, 'standard_error': 0.4207974317116378, 'retail': 1.3308398356625006, 'arb': -0.2515443214641666}, failures=0",
    "capaskkeep_probe_4000_120 (Combine inventory-backed ask cap with ask-only 90% replenishment; retain eligible probes away from main quote prices): n=120, {'mean_edge': 106.20901723099668, 'retail_edge': 126.74793566792417, 'arb_edge': -20.538918436939166}, paired={'mean': 1.0793007840058337, 'standard_error': 0.42079670356670823, 'retail': 1.3308217734333339, 'arb': -0.25152098941749995}, failures=0",
    "capcovered20_4000_120 (Inventory-backed cap as capcovered, with ceiling 20000): n=120, {'mean_edge': 105.79597602465667, 'retail_edge': 126.17881891893583, 'arb_edge': -20.382842894299166}, paired={'mean': 0.666259577665834, 'standard_error': 0.3560266494288844, 'retail': 0.7617050244449997, 'arb': -0.09544544677749993}, failures=0",
    "capcovered_4000_120 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES))): n=120, {'mean_edge': 105.79597602465667, 'retail_edge': 126.17881891893583, 'arb_edge': -20.382842894299166}, paired={'mean': 0.666259577665834, 'standard_error': 0.3560266494288844, 'retail': 0.7617050244449997, 'arb': -0.09544544677749993}, failures=0",
    "capcovered_probe_4000_120 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES)); retain eligible probes away from main quote prices): n=120, {'mean_edge': 105.795946501155, 'retail_edge': 126.17879992607416, 'arb_edge': -20.38285342494}, paired={'mean': 0.6662300541641667, 'standard_error': 0.35602733091810024, 'retail': 0.7616860315833336, 'arb': -0.09545597741833335}, failures=0",
    "capkeep_grid_4000_120 (Combine inventory-backed ask cap with both-side 90% replenishment; exact shared Gaussian kernel): n=120, {'mean_edge': 106.39252643401333, 'retail_edge': 127.14692870802084, 'arb_edge': -20.754402274010832}, paired={'mean': 1.2628099870225011, 'standard_error': 0.442455177113523, 'retail': 1.7298148135299996, 'arb': -0.4670048264891666}, failures=0",
    "capkeep_probe_4000_120 (Combine inventory-backed ask cap with both-side 90% replenishment; retain eligible probes away from main quote prices): n=120, {'mean_edge': 106.39253438866584, 'retail_edge': 127.14691305800167, 'arb_edge': -20.7543786693375}, paired={'mean': 1.2628179416750014, 'standard_error': 0.4424548298114576, 'retail': 1.7297991635108325, 'arb': -0.4669812218158334}, failures=0",
    "cashcover_4000_120 (Allow uncovered asks down to 5c rather than 10c): n=120, {'mean_edge': 105.8789078634675, 'retail_edge': 125.09588013311166, 'arb_edge': -19.216972269665}, paired={'mean': 0.7491914164766679, 'standard_error': 0.6420470931556487, 'retail': -0.3212337613791675, 'arb': 1.0704251778566667}, failures=0",
    "cheapstock_4000_120 (Raise residual tick-1 purchase budget fraction from 0.6 to 0.9): n=120, {'mean_edge': 103.9322409935975, 'retail_edge': 125.72298809753167, 'arb_edge': -21.790747103954168}, paired={'mean': -1.197475453393332, 'standard_error': 0.8934606358648307, 'retail': 0.3058742030408321, 'arb': -1.5033496564325002}, failures=0",
    "cover15_4000_120 (Crossing cover target 1.5 times desired ordinary ask quantity): n=120, {'mean_edge': 105.403720135505, 'retail_edge': 125.629794305385, 'arb_edge': -20.2260741698975}, paired={'mean': 0.2740036885141674, 'standard_error': 0.11804618248453468, 'retail': 0.21268041089416706, 'arb': 0.061323277624166866}, failures=0",
    "cover15c_4000_120 (Extend crossing cover range from 10c to 15c): n=120, {'mean_edge': 105.1176878521525, 'retail_edge': 125.482860205615, 'arb_edge': -20.365172353488333}, paired={'mean': -0.012028594838332381, 'standard_error': 0.03998223092589339, 'retail': 0.06574631112416653, 'arb': -0.07777490596666674}, failures=0",
    "cover2_4000_120 (Crossing cover target 2 times desired ordinary ask quantity): n=120, {'mean_edge': 105.30734071297334, 'retail_edge': 125.6747514626725, 'arb_edge': -20.367410749715834}, paired={'mean': 0.17762426598250156, 'standard_error': 0.15833327614823348, 'retail': 0.257637568181666, 'arb': -0.08001330219416654}, failures=0",
    "cover3_4000_120 (Crossing cover target 3 times desired ordinary ask quantity): n=120, {'mean_edge': 105.34724198035583, 'retail_edge': 125.77691822320917, 'arb_edge': -20.429676242871665}, paired={'mean': 0.2175255333649998, 'standard_error': 0.4057734790769231, 'retail': 0.3598043287183311, 'arb': -0.14227879534999993}, failures=0",
    "fastbase_4000_120 (Combine the two jump-payoff sums into one exact loop): n=120, {'mean_edge': 105.12971644699084, 'retail_edge': 125.41711389449083, 'arb_edge': -20.287397447521666}, paired={'mean': 0.0, 'standard_error': 0.0, 'retail': 0.0, 'arb': 0.0}, failures=0",
    "keepmore_4000_120 (Replenish both main sides below 90% rather than 70% of target): n=120, {'mean_edge': 105.80692233925417, 'retail_edge': 126.53359777376166, 'arb_edge': -20.726675434514167}, paired={'mean': 0.6772058922633354, 'standard_error': 0.26419128169097394, 'retail': 1.116483879270832, 'arb': -0.4392779869924999}, failures=0",
    "lessfull_4000_120 (Disable the small full-horizon near-crossing stock target): n=120, {'mean_edge': 105.02426029995499, 'retail_edge': 125.20522989431583, 'arb_edge': -20.18096959438917}, paired={'mean': -0.10545614703583357, 'standard_error': 0.5176730109659, 'retail': -0.2118840001750001, 'arb': 0.1064278531325001}, failures=0",
    "loweager_4000_120 (Disable old eager stock purchases above fair probability 1c; preserve added crossing cover): n=120, {'mean_edge': 105.49802616364667, 'retail_edge': 125.07374049965833, 'arb_edge': -19.575714336035}, paired={'mean': 0.3683097166558335, 'standard_error': 0.5548846241641368, 'retail': -0.3433733948324994, 'arb': 0.7116831114866665}, failures=0",
    "lowpremium_4000_120 (Lower eager stock-purchase premium ceiling from 2c to 0.5c): n=120, {'mean_edge': 104.85602600485166, 'retail_edge': 125.00698683690082, 'arb_edge': -20.1509608320675}, paired={'mean': -0.2736904421391663, 'standard_error': 0.37337196350968693, 'retail': -0.41012705758999957, 'arb': 0.13643661545416647}, failures=0",
    "recover100_4000_120 (Renew cash-backed asks ahead of competitor when stock is available and free cash below 100): n=120, {'mean_edge': 105.22359737303833, 'retail_edge': 125.44270198361666, 'arb_edge': -20.219104610600834}, paired={'mean': 0.09388092604750113, 'standard_error': 0.07045903715328886, 'retail': 0.025588089125831933, 'arb': 0.06829283692083342}, failures=0",
    "recover2000_4000_120 (Same ask-reservation renewal, free-cash threshold 2000): n=120, {'mean_edge': 105.17543447154334, 'retail_edge': 125.4100702761975, 'arb_edge': -20.234635804675836}, paired={'mean': 0.04571802455250162, 'standard_error': 0.07266686857232821, 'retail': -0.007043618293333983, 'arb': 0.05276164284583335}, failures=0",
    "recover500_4000_120 (Same ask-reservation renewal, free-cash threshold 500): n=120, {'mean_edge': 105.19345289642334, 'retail_edge': 125.42095899588584, 'arb_edge': -20.227506099485833}, paired={'mean': 0.06373644943250009, 'standard_error': 0.07637627871868909, 'retail': 0.0038451013949990435, 'arb': 0.0598913480358334}, failures=0",
    "bank50capaskkeep_4000_500 (Combine bank50, inventory-backed ask cap, and ask-only 90% replenishment): n=500, {'mean_edge': 108.52843562538361, 'retail_edge': 137.0055019825812, 'arb_edge': -28.477066357165402}, paired={'mean': 0.19602836361260076, 'standard_error': 0.4218672414579097, 'retail': 0.7579979741086006, 'arb': -0.561969610497}, failures=0",
    "bank50capkeep_4000_500 (Combine bank50, inventory-backed ask cap, and both-side 90% replenishment): n=500, {'mean_edge': 108.7299875781682, 'retail_edge': 137.4722905452972, 'arb_edge': -28.742302967086797}, paired={'mean': 0.39758031639720043, 'standard_error': 0.4088758554350035, 'retail': 1.2247865368246014, 'arb': -0.8272062204183995}, failures=0",
    "capdeep2_4000_500 (Inventory-backed ask-cap extension only below fair probability 0.2c): n=500, {'mean_edge': 108.6181011251952, 'retail_edge': 136.7259087880104, 'arb_edge': -28.1078076627806}, paired={'mean': 0.2856938634242, 'standard_error': 0.11087556024293443, 'retail': 0.4784047795378001, 'arb': -0.1927109161122001}, failures=0",
    "capdeep5_4000_500 (Inventory-backed ask-cap extension only below fair probability 0.5c): n=500, {'mean_edge': 108.5292382157608, 'retail_edge': 136.8672378746886, 'arb_edge': -28.3379996588942}, paired={'mean': 0.19683095398979988, 'standard_error': 0.18826465544776283, 'retail': 0.6197338662160001, 'arb': -0.4229029122258001}, failures=0",
    "capearly_4000_500 (Inventory-backed ask-cap extension only with more than 100 steps remaining): n=500, {'mean_edge': 108.4838109524602, 'retail_edge': 136.84186781687018, 'arb_edge': -28.358056864376202}, paired={'mean': 0.1514036906892006, 'standard_error': 0.18468677599678313, 'retail': 0.5943638083976006, 'arb': -0.4429601177078002}, failures=0",
    "caprisk3_4000_500 (Keep ordinary ask target; charge triple modeled loss for shares above the ordinary 3000 cap): n=500, {'mean_edge': 108.3975636308568, 'retail_edge': 136.5705867224068, 'arb_edge': -28.1730230915178}, paired={'mean': 0.06515636908579998, 'standard_error': 0.10646113629911834, 'retail': 0.32308271393420007, 'arb': -0.2579263448494001}, failures=0",
    "capcover_4000_1000 (Combine inventory-backed ask cap with crossing-cover target multiplier 2): n=1000, {'mean_edge': 101.70635774303061, 'retail_edge': 128.9728413233373, 'arb_edge': -27.2664835803104}, paired={'mean': -0.23208838344339938, 'standard_error': 0.4494031501517044, 'retail': 0.7126577704216006, 'arb': -0.9447461538641999}, failures=0",
    "capcovered20_4000_1000 (Inventory-backed cap as capcovered, with ceiling 20000): n=1000, {'mean_edge': 102.0869820403568, 'retail_edge': 128.7072982925484, 'arb_edge': -26.6203162521954}, paired={'mean': 0.1485359138828003, 'standard_error': 0.12173304954635161, 'retail': 0.44711473963270026, 'arb': -0.2985788257492001}, failures=0",
    "capcovered_4000_1000 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES))): n=1000, {'mean_edge': 102.08148731447139, 'retail_edge': 128.70019119191912, 'arb_edge': -26.618703877451498}, paired={'mean': 0.14304118799740023, 'standard_error': 0.12130172497270457, 'retail': 0.44000763900340023, 'arb': -0.2969664510053001}, failures=0",
    "capkeep_4000_1000 (Combine inventory-backed ask cap with both-side 90% replenishment): n=1000, {'mean_edge': 101.649539189299, 'retail_edge': 129.6145831440065, 'arb_edge': -27.965043954703802}, paired={'mean': -0.28890693717499977, 'standard_error': 0.3671601759004064, 'retail': 1.3543995910908009, 'arb': -1.6433065282576}, failures=0",
    "cover2_4000_1000 (Crossing cover target 2 times desired ordinary ask quantity): n=1000, {'mean_edge': 101.6327364993179, 'retail_edge': 128.5657648582758, 'arb_edge': -26.933028358963398}, paired={'mean': -0.305709627156099, 'standard_error': 0.44338727379914344, 'retail': 0.3055813053601, 'arb': -0.6112909325171999}, failures=0",
    "keepmore_4000_1000 (Replenish both main sides below 90% rather than 70% of target): n=1000, {'mean_edge': 101.53869001945391, 'retail_edge': 129.2273158740752, 'arb_edge': -27.688625854618703}, paired={'mean': -0.3997561070200995, 'standard_error': 0.34643850675819204, 'retail': 0.9671323211595003, 'arb': -1.3668884281725}, failures=0",
    "bank50capaskkeep_gridconst_6000_600 (Combine bank50, inventory-backed ask cap, and ask-only 90% replenishment; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 94.261858274557, 'retail_edge': 120.51710852662933, 'arb_edge': -26.255250252107498}, paired={'mean': 0.18807290467999946, 'standard_error': 0.38172991251469135, 'retail': 0.835421351372667, 'arb': -0.6473484466786664}, failures=0",
    "bank50capkeep_gridconst_6000_600 (Combine bank50, inventory-backed ask cap, and both-side 90% replenishment; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 94.53453075824333, 'retail_edge': 120.97645110198165, 'arb_edge': -26.441920343762835}, paired={'mean': 0.4607453883663331, 'standard_error': 0.393411828365296, 'retail': 1.294763926725, 'arb': -0.8340185383339999}, failures=0",
    "capaskkeep_fast_6000_600 (Combine inventory-backed ask cap with ask-only 90% replenishment; exact jump-loop, belief-zip, and constant-hoisting optimization): n=600, {'mean_edge': 93.98355568004483, 'retail_edge': 120.99729595841983, 'arb_edge': -27.013740278413}, paired={'mean': -0.09022968983216668, 'standard_error': 0.3798928211673567, 'retail': 1.3156087831631673, 'arb': -1.4058384729841664}, failures=0",
    "capaskkeep_probe_6000_600 (Combine inventory-backed ask cap with ask-only 90% replenishment; retain eligible probes away from main quote prices): n=600, {'mean_edge': 93.98392113273484, 'retail_edge': 120.99726262787767, 'arb_edge': -27.013341495181}, paired={'mean': -0.08986423714216679, 'standard_error': 0.37990516668376273, 'retail': 1.3155754526210002, 'arb': -1.4054396897521668}, failures=0",
    "capcover_fast_6000_600 (Combine inventory-backed ask cap with crossing-cover target multiplier 2; exact jump-loop, belief-zip, and constant-hoisting optimization): n=600, {'mean_edge': 94.222987744613, 'retail_edge': 120.36323876196766, 'arb_edge': -26.140251017395666}, paired={'mean': 0.14920237473599995, 'standard_error': 0.2595994388787352, 'retail': 0.681551586711, 'arb': -0.5323492119668332}, failures=0",
    "capcovered20_fast_6000_600 (Inventory-backed cap as capcovered, with ceiling 20000; exact jump-loop, belief-zip, and constant-hoisting optimization): n=600, {'mean_edge': 94.21754937291483, 'retail_edge': 120.23961138169167, 'arb_edge': -26.022062008826666}, paired={'mean': 0.14376400303783343, 'standard_error': 0.23153790420658676, 'retail': 0.5579242064350005, 'arb': -0.4141602033978331}, failures=0",
    "capcovered_fast_6000_600 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES)); exact jump-loop, belief-zip, and constant-hoisting optimization): n=600, {'mean_edge': 94.22769943723932, 'retail_edge': 120.2510596853815, 'arb_edge': -26.023360248192}, paired={'mean': 0.15391406736233348, 'standard_error': 0.2353680020939019, 'retail': 0.5693725101248338, 'arb': -0.41545844276316646}, failures=0",
    "capcovered_probe_6000_600 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES)); retain eligible probes away from main quote prices): n=600, {'mean_edge': 94.2277047468425, 'retail_edge': 120.25106741290901, 'arb_edge': -26.023362666114167}, paired={'mean': 0.15391937696550007, 'standard_error': 0.23536784054270812, 'retail': 0.5693802376523335, 'arb': -0.4154608606853333}, failures=0",
    "capkeep_fast_6000_600 (Combine inventory-backed ask cap with both-side 90% replenishment; exact jump-loop, belief-zip, and constant-hoisting optimization): n=600, {'mean_edge': 94.191239059632, 'retail_edge': 121.39157023352084, 'arb_edge': -27.200331173914336}, paired={'mean': 0.11745368975500015, 'standard_error': 0.3856574184896997, 'retail': 1.7098830582641662, 'arb': -1.5924293684855002}, failures=0",
    "capkeep_probe_6000_600 (Combine inventory-backed ask cap with both-side 90% replenishment; retain eligible probes away from main quote prices): n=600, {'mean_edge': 94.19070919423616, 'retail_edge': 121.39082192886434, 'arb_edge': -27.200112734654333}, paired={'mean': 0.11692382435916601, 'standard_error': 0.38568926973526585, 'retail': 1.7091347536076666, 'arb': -1.5922109292255}, failures=0",
    "capaskkeep_fast_6600_1400 (Combine inventory-backed ask cap with ask-only 90% replenishment; exact jump-loop, belief-zip, and constant-hoisting optimization): n=1400, {'mean_edge': 94.40454868444878, 'retail_edge': 124.70595260711322, 'arb_edge': -30.3014039226755}, paired={'mean': -0.1866763406697144, 'standard_error': 0.35358366779075256, 'retail': 1.4037384154870003, 'arb': -1.5904147561534998}, failures=0",
    "capcovered_fast_6600_1400 (Below fair probability 5c, raise ask cap to max(3000,min(10000,YES)); exact jump-loop, belief-zip, and constant-hoisting optimization): n=1400, {'mean_edge': 94.64898334853402, 'retail_edge': 123.8871623641357, 'arb_edge': -29.238179015615714}, paired={'mean': 0.057758323415499704, 'standard_error': 0.22572425948132574, 'retail': 0.5849481725095, 'arb': -0.5271898490937142}, failures=0",
    "capkeep_fast_6600_1400 (Combine inventory-backed ask cap with both-side 90% replenishment; exact jump-loop, belief-zip, and constant-hoisting optimization): n=1400, {'mean_edge': 94.67385875543236, 'retail_edge': 125.07111889617015, 'arb_edge': -30.397260140747214}, paired={'mean': 0.08263373031385732, 'standard_error': 0.353973155373354, 'retail': 1.7689047045439283, 'arb': -1.6862709742252144}, failures=0",
    "bank50capaskkeep_gridconst_7000_600 (Combine bank50, inventory-backed ask cap, and ask-only 90% replenishment; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 90.98007659531582, 'retail_edge': 118.23190835842567, 'arb_edge': -27.251831763087832}, paired={'mean': 0.0745270366120003, 'standard_error': 0.5290838757009302, 'retail': 0.8916142186591668, 'arb': -0.8170871820424999}, failures=0",
    "bank50capkeep_gridconst_7000_600 (Combine bank50, inventory-backed ask cap, and both-side 90% replenishment; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 91.1220589240865, 'retail_edge': 118.61787226937966, 'arb_edge': -27.495813345268502}, paired={'mean': 0.21650936538266682, 'standard_error': 0.5267684666487751, 'retail': 1.277578129613167, 'arb': -1.0610687642231666}, failures=0",
    "capdeep2_gridconst_7000_600 (Inventory-backed ask-cap extension only below fair probability 0.2c; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 91.20115359492067, 'retail_edge': 117.71797030602916, 'arb_edge': -26.516816711091167}, paired={'mean': 0.29560403621683323, 'standard_error': 0.15472346744309382, 'retail': 0.37767616626266665, 'arb': -0.0820721300458334}, failures=0",
    "capdeep5_gridconst_7000_600 (Inventory-backed ask-cap extension only below fair probability 0.5c; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 90.89238343322249, 'retail_edge': 117.82883580159866, 'arb_edge': -26.936452368357834}, paired={'mean': -0.013166125481333373, 'standard_error': 0.2853861325924202, 'retail': 0.4885416618321667, 'arb': -0.5017077873125}, failures=0",
    "capearly_gridconst_7000_600 (Inventory-backed ask-cap extension only with more than 100 steps remaining; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 90.796322045904, 'retail_edge': 117.81338103172983, 'arb_edge': -27.017058985807168}, paired={'mean': -0.10922751279983352, 'standard_error': 0.2905716534109921, 'retail': 0.47308689196333376, 'arb': -0.5823144047618334}, failures=0",
    "caprisk3_gridconst_7000_600 (Keep ordinary ask target; charge triple modeled loss for shares above the ordinary 3000 cap; exact fixed-parameter compilation and shared Gaussian kernel): n=600, {'mean_edge': 91.09075279786883, 'retail_edge': 117.602842931757, 'arb_edge': -26.512090133870668}, paired={'mean': 0.18520323916499967, 'standard_error': 0.08828760620696174, 'retail': 0.2625487919905003, 'arb': -0.0773455528253331}, failures=0",
    "Optimized base retains exact complete SimulationResult records on seeds 4000-4119: True. Optimization combines jump-loss loops, reuses the previous-belief zip within each callback, and hoists fixed model constants; original filter resolution is retained.",
    "base_grid: exact complete SimulationResult equality on all 120 check seeds. Gaussian shared-kernel arithmetic additionally passed 1200 randomized exact-equality cases.",
    "base_const: exact complete SimulationResult equality on all 120 check seeds. Gaussian shared-kernel arithmetic additionally passed 1200 randomized exact-equality cases.",
    "base_gridconst: exact complete SimulationResult equality on all 120 check seeds. Gaussian shared-kernel arithmetic additionally passed 1200 randomized exact-equality cases.",
    "Pre-freeze performance screen capkeep_fast_timing.json: {'seconds': {'base': 503.05499206553213, 'yours': 495.3758432350587}, 'cpu': {'base': 118.11075066400008, 'yours': 116.24130709999987}, 'failures': {'base': 0, 'yours': 0}, 'count': 200, 'candidate': 'capkeep_fast'}",
    "Pre-freeze performance screen capkeep_grid_timing.json: {'seconds': {'base': 690.875632832991, 'yours': 678.5329361271579}, 'cpu': {'base': 120.28089151699992, 'yours': 118.83824121600011}, 'failures': {'base': 0, 'yours': 0}, 'count': 200, 'candidate': 'capkeep_grid'}",
    "Pre-freeze performance screen capkeep_gridconst_timing.json: {'seconds': {'base': 694.9106322720181, 'yours': 677.30528583657}, 'cpu': {'base': 120.26335728000014, 'yours': 117.68577956699998}, 'failures': {'base': 0, 'yours': 0}, 'count': 200, 'candidate': 'capkeep_gridconst'}",
    "Pre-freeze performance screen capkeep_probe_timing.json: {'seconds': {'base': 659.5767626636662, 'yours': 645.9442243787926}, 'cpu': {'base': 119.49303272699999, 'yours': 117.27171375000015}, 'failures': {'base': 0, 'yours': 0}, 'count': 200, 'candidate': 'capkeep_probe'}",
    "Base final tuning 4000-7999: {'mean_edge': 98.0996956804193, 'retail_edge': 125.17961744069841, 'arb_edge': -27.079921760293374}; unseen 50000-53999: {'mean_edge': 97.54703502577897, 'retail_edge': 126.92890288111944, 'arb_edge': -29.381867855334075}; failures=0",
    "Freeze before candidate unseen evaluation: {'selected': 'capdeep2_gridconst', 'sha256': '0f4d34f0f93c32455d06cb4b0db73682ff9c54805952167870a6dcb2960dcebd', 'frozen_at_utc': '2026-11-06T07:34:09.035731+00:00', 'description': 'Raises the ordinary ask size ceiling from 3000 shares to max(3000,min(10000,current YES inventory)) only when the existing fair-probability estimate is below 0.002 (0.2 cents). Extra capacity is backed by stock already held. The original crossing bank, eager purchases, price selection, filter resolution, and replenishment thresholds remain in place. Gaussian kernels are shared only for identical exactly representable grids, fixed parameters are compiled into constants, and jump-loss sums share one loop; these runtime changes passed exact-result checks.', 'base_unseen_precomputed_but_scores_uninspected_until_freeze': True, 'candidate_unseen_not_run_before_freeze': True}. No holdout-driven edits or reselection. Timing interleaves 200 runs of each in one Python process, alternating order per seed 4000-4199; reported seconds are accumulated wall time around SimulationEngine.run, with identical pre-sampled configurations. CPU seconds={'base': 118.90148920799999, 'yours': 113.86568950900002}; failures={'base': 0, 'yours': 0}",
    "BEST FROZEN capdeep2_gridconst: tuning={'mean_edge': 98.39034603951998, 'retail_edge': 125.53389922530091, 'arb_edge': -27.143553185794875, 'simulations': 4000, 'seed_start': 4000, 'failures': 0}; unseen={'mean_edge': 97.75643908844914, 'retail_edge': 127.30311629939337, 'arb_edge': -29.546677210937975, 'simulations': 4000, 'seed_start': 50000, 'failures': 0}; paired unseen={'mean': 0.209404062670175, 'standard_error': 0.0669494819952478, 'retail': 0.37421341827392507, 'arb': -0.16480935560390003}; seconds={'base': 254.04184297309257, 'yours': 243.92939586169086}; eligible=True"
  ],
  "next": "On fresh paired seeds, test a 20000-share inventory-backed ceiling behind the same p<0.002 gate, preserving the base crossing bank and ordinary 3000-share target. Also evaluate the W=50 plus covered-cap plus 90% replenishment combination: it captured more retail but had much noisier net gains here. Audit rare upward-jump losses on extra asks. Treat 50000-53999 as used, and verify any public leaderboard gain directly."
}