# Merge 02

```json
{
  "rows": [
    {
      "key": "xu-low-p",
      "idea": "B with exactly one change: the uncovered-ask price floor is lowered only while the estimated probability is in the 5 to 10 cent band, by setting P['xu'] = x when 0.05 <= phat < 0.10 and 0.1 otherwise,",
      "code_sha256": "3a64070f97c80e1e5363faae73bd6541daf338c7f3ea3fed181adba1dd3c5582",
      "t_n": 500,
      "t_diff": 0.13168227538220023,
      "t_se": 0.06064809487123042,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.1533634255990002,
      "h_se": 0.11888987873713697,
      "h_sum_d": 153.3634255990002,
      "h_sum_d2": 14144.188803176461,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.17501889339129986,
      "h_arb_diff": -0.021655467793699996,
      "failures": [],
      "next": "Do not spend finalist seeds on this alone: on H it is +0.15 with se 0.12 and most seeds (820 of 1000) are unchanged. Carry it as a small additive term in a combine item, where its retail gain (+0.16 on T, +0.18 on H, both over 3 se) may add to other changes. Lower x has no further effect, since 0.03",
      "flag": null
    },
    {
      "key": "phat-clamp",
      "idea": "Test four isolated changes to B's probability estimate: symmetric phat clamps [0.001, 0.999] and [0.0005, 0.9995], or below-tick pfl floors 0.0002 and 0.001. Each variant changes only that setting. Se",
      "code_sha256": "6f6a2101c7d39ed4e1cea9bc8b4e55b722a73be8ee0d17b1b8d009e88cd60932",
      "t_n": 500,
      "t_diff": 0.14263927737360033,
      "t_se": 0.05548251841431315,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.06587625234130046,
      "h_se": 0.01792781772835781,
      "h_sum_d": 65.87625234130046,
      "h_sum_d2": 325.4249224752541,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.06839335978929995,
      "h_arb_diff": -0.00251710744800004,
      "failures": [],
      "next": "Use the frozen holdout result as evidence for a later finalist measurement; do not promote from tuning or this holdout. If exploring further, separately test interaction between the below-tick decay rate zd and pfl on newly assigned tuning seeds.",
      "flag": null
    },
    {
      "key": "release-window",
      "idea": "B releases its $200 cash reserve on new uncovered asks linearly over the last min(H,release) steps, with release defaulting to 50 (C.get('release', 50.0)). This item varies only that window by adding ",
      "code_sha256": "b492f9914e13391b8bbdefe9a4b4b250859fa48f9c3e6f5f082d3bc4f0db2bba",
      "t_n": 500,
      "t_diff": 0.089559,
      "t_se": 0.029238,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.05870115959330039,
      "h_se": 0.03333934647739922,
      "h_sum_d": 58.70115959330039,
      "h_sum_d2": 1113.84633765413,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.08279344971040001,
      "h_arb_diff": 0.1414946093050999,
      "failures": [],
      "next": "The release window is a weak lever: all variants moved total edge by under 0.1 per simulation. Longer windows (400) gain on T and somewhat on H, mostly from arbitrage, so the reserve size and window might be tuned together (e.g. reserve 100-400 with release 400-1000). A finalist run on the reserved ",
      "flag": null
    },
    {
      "key": "reserve-low-p",
      "idea": "Candidate = B (combine-cash) with exactly one change: the cash reserve in the uncovered-ask budget (line `ub = min(ub, max(0, free - reserve*min(1,H/release)))`) is R=100 instead of 200 when phat<0.01",
      "code_sha256": "0dd266173983ea66e1aed2d0279ae9566f361f35f6685fffede3ed19b3a2b620",
      "t_n": 500,
      "t_diff": 0.01932259616959999,
      "t_se": 0.011322865491394982,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.0317440451833003,
      "h_se": 0.021393002233771722,
      "h_sum_d": 31.744045183300294,
      "h_sum_d2": 458.210568434187,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.06748869949880004,
      "h_arb_diff": 0.09923274468299997,
      "failures": [],
      "next": "Effect is tiny and not significant on H (+0.03, se 0.02, about 1.5 se); not a promotion by itself. Could be folded into a combined candidate at no cost, but the reserve is not a lever. Spend effort on probability/jump estimation and arbitrage loss instead.",
      "flag": null
    },
    {
      "key": "maxpay-search",
      "idea": "Vary only P['ammo_maxpay'], the maximum premium above estimated probability accepted by the immediate YES cover-buy branch, from B's 0.02 to 0.01, 0.03, 0.04, or 0.015. Measure all four against the ex",
      "code_sha256": "9404626341a480899677771d25578a58b634870f1d32f9a94e483a64d7fd50f7",
      "t_n": 500,
      "t_diff": 0,
      "t_se": 0,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0,
      "h_se": 0,
      "h_sum_d": 0,
      "h_sum_d2": 0,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0,
      "h_arb_diff": 0,
      "failures": [],
      "next": "In a separate item, test sub-cent caps such as 0.0025, 0.005, and 0.0075 on fresh disjoint tuning and holdout seeds: the next-tick cover-price construction normally keeps the premium below one cent, suggesting larger caps can be nonbinding. This item makes no promotion claim; reserved finalist seeds",
      "flag": null
    },
    {
      "key": "join-spread1",
      "idea": "Join-spread1: in spread-1 markets (ca-cb<=1) with 0.2<=phat<=0.8, bid_t=cb and ask_t=ca (join the competitor's tick, behind it) sized by qbid(cb)/qask(ca). B's order-add rule skips adding when bid_t==",
      "code_sha256": "698310b9cf08754d6d15405b8469d63f0a33916c7bbb3439bfed2aebd637c73a",
      "t_n": 50,
      "t_diff": -0.0005656313880000333,
      "t_se": 0.00039018991803536766,
      "h_seeds": "210000..210039 (40 of the planned 1000; unfinished)",
      "h_n": 40,
      "h_complete": false,
      "h_diff": -0.0007164663700016353,
      "h_se": 0.0003839197047556989,
      "h_sum_d": -0.02865865480006541,
      "h_sum_d2": 0.0002504681323052695,
      "h_incumbent_mean": 82.65745448026749,
      "h_retail_diff": 0,
      "h_arb_diff": -0.0007164663650000902,
      "failures": [],
      "next": "Joining behind the competitor does not capture the 9.1 retail edge; a fill needs priority. Try quoting at cb+1 / ca-1 (one tick inside) in spread-2+ only when spread would stay >=1, or check whether the competitor's size is exhausted by retail so a join behind it is unreachable. Rerun with the full ",
      "flag": "n under 500"
    },
    {
      "key": "belief-grid",
      "idea": "B's sub-tick belief is a grid filter over the price between its current lower and upper bounds, with P['bins'] grid points per tick of width (default 8, B's cap of 48 points in total left in place) an",
      "code_sha256": "143e7cdec1e88134d13cbf0a1b412f4e5dc9c357aa70e93f81e21be1e9541da0",
      "t_n": 500,
      "t_diff": -0.029363959432400822,
      "t_se": 0.04786414426202627,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.0020614401306993015,
      "h_se": 0.03557020342548201,
      "h_sum_d": -2.0614401306993013,
      "h_sum_d2": 1263.978381893854,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.006199212890799654,
      "h_arb_diff": -0.008260652999200169,
      "failures": [],
      "next": "Drop bin density as a lever: bins=12 and bins=16 moved neither retail nor arbitrage edge by a material amount. The floor is the only constant here that moved the components. On tuning seeds, paired against B, uni=0.03 changed arbitrage by +0.21 (se 0.13) and retail by -0.26 (se 0.09), and uni=0.003 ",
      "flag": null
    },
    {
      "key": "fu-search",
      "idea": "Search only the uncovered-ask cash fraction P['fu'] in verified incumbent B (fu=0.25). Compare fu=0.15, 0.35, 0.5 and 0.6 against the same B on every T seed 110000..110499, select the largest paired m",
      "code_sha256": "bfa4c0544f46df1ea85f1760bbba975b159d7445da03fb0ff98d00aaef901863",
      "t_n": 500,
      "t_diff": 0.24525759008819972,
      "t_se": 0.3217652850275988,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.013199700650199908,
      "h_se": 0.03407997539023322,
      "h_sum_d": -13.199700650199908,
      "h_sum_d2": 1160.4575099735575,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.06429898296840017,
      "h_arb_diff": 0.051099282319100055,
      "failures": [],
      "next": "Keep B as incumbent unless a measure item confirms a promotion on the reserved finalist set. The selected fu=0.15 has a noisy tuning gain; assess the reported frozen holdout without retuning it. If further work is allocated, investigate whether the cash cap binds around rare arbitrage events and tes",
      "flag": null
    },
    {
      "key": "probe-ladder-width",
      "idea": "Changed only the probe ladder floor and ceiling multiplier. Four joint settings covered rmin 1, 3, and 4 and multipliers 1.5 and 3.0; each was paired with the incumbent on seeds 110000–110499. The lar",
      "code_sha256": "7cdb442c8c173b66e3d61fb0507fa5ba71ae1b65c2a773e4116c3a15d03a51b7",
      "t_n": 500,
      "t_diff": -0.021575836479599896,
      "t_se": 0.017850225193663444,
      "h_seeds": {
        "start": 210000,
        "end": 210999
      },
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.05139300417749977,
      "h_se": 0.01656111761214724,
      "h_sum_d": -51.39300417749977,
      "h_sum_d2": 276.6375868251985,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.014036894113400004,
      "h_arb_diff": -0.06542989828110005,
      "failures": [],
      "next": "The best tuning variant was still negative; test a separate probe-budget or ladder-placement mechanism in a later item, without reusing these holdout seeds for tuning.",
      "flag": null
    },
    {
      "key": "retail-flow-online",
      "idea": "B plus exactly one quoting change: multiply rho by the trailing 200-step observed/expected retail fill-notional ratio, clamped to [0.5, 1.5]. All other B parameters and action logic are unchanged. Rec",
      "code_sha256": "b0e3c69277bb52d05762ebdaa79f2eaae4e3fc9b603f75cc02b88f170621b526",
      "t_n": 500,
      "t_diff": 0.7445819528117997,
      "t_se": 0.5584845808890547,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.27517155317579955,
      "h_se": 0.3739424116547223,
      "h_sum_d": -275.17155317579954,
      "h_sum_d2": 139768.81369059283,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -1.3985182796363005,
      "h_arb_diff": 1.1233467264680999,
      "failures": [],
      "next": "Retain B: the H paired gain does not exceed twice its standard error, and this item does not promote a strategy. On a fresh authorized tuning/holdout split, compare the online estimator against a fixed rho reduction to distinguish learned retail flow from simply smaller quotes. Then investigate prio",
      "flag": null
    },
    {
      "key": "below-tick-decay",
      "idea": "Tune only B's below-tick-1 belief decay, where no tick probe can observe p. Compare four single-constant variants (zd=0.5, 1.5, 2.0, or decay factor 0.03 with zd=1.0) to the exact hash-verified incumb",
      "code_sha256": "1bdf1462aa7521fce81381d885c8266e453c598408de718ccbb3601a5f203de1",
      "t_n": 500,
      "t_diff": -0.06599778592920058,
      "t_se": 0.07745335590073846,
      "h_seeds": [
        210000,
        210999
      ],
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.44555587194449986,
      "h_se": 0.31298371268252273,
      "h_sum_d": -445.55587194449987,
      "h_sum_d2": 98059.36563515563,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.007934027778700007,
      "h_arb_diff": -0.4534898997224001,
      "failures": [],
      "next": "Retain B: this item does not establish a positive holdout gain. In a separate future item, test horizon-dependent below-tick decay rather than merely scaling this coefficient.",
      "flag": null
    },
    {
      "key": "mid-size-floor",
      "idea": "Test one minimum-size block immediately after B computes its main qb and qa: when 0.2 <= phat <= 0.8 and self.s >= 2, floor both at qmin shares; all other source bytes, including cash/collateral check",
      "code_sha256": "f507362629312e83ab30dbb2de6d6ad6ea4bd58ca7938dd0af6a9facf16983f8",
      "t_n": 500,
      "t_diff": -61.139954867441,
      "t_se": 2.7045065957645584,
      "h_seeds": {
        "start": 210000,
        "end": 210999,
        "inclusive": true
      },
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -58.1247752992197,
      "h_se": 1.875354610678874,
      "h_sum_d": -58124.7752992197,
      "h_sum_d2": 6891927.464463497,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 3.965581232876299,
      "h_arb_diff": -62.0903565320994,
      "failures": [],
      "next": "Retain B: every tested floor loses on T, and the frozen 20-share floor also loses on H. A separate future item could test a floor only where the existing marginal-size model already admits profitable size, rather than overriding its zero-size decisions. Do not tune this candidate on H; no promotion ",
      "flag": null
    }
  ],
  "top": [
    {
      "key": "xu-low-p",
      "code": "\"\"\"Stale-quote defence with tick probes, a sub-tick belief and cheap YES stock.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low\nasks.  That YES is bought when it is cheap: a large bid rests at tick 1 while p\nis above it, so the arbitrageur fills it on the crossing for about 0.1 tick a\nshare instead of nearly a full tick once p is near zero, and smaller bids sit on\nwhichever tick p is within 0.15 of.  Below tick 1 the estimate of p decays with\nthe time spent there, since no probe can see it.\n\"\"\"\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)\nP.update({'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'fu': 0.25, 'Hu': 500})\nC = {'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'reserve': 200, 'scar': 0.0025, 'fu': 0.25, 'Hu': 500}\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\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        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        P['xu'] = 0.05 if 0.05 <= phat < 0.10 else 0.1\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            if phat < C.get('scar_p', .1):\n                a = max(0.0, a - C.get('scar', 0.0) * (1 - min(1.0, state.yes_inventory / C.get('stock', 3000.0))))\n            return min(C.get('askcap', P['qmax']), 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 = min(C.get('bidcap', 3000.0), qbid(bid_t))\n        qa = qask(ask_t)\n\n        Y = state.yes_inventory\n        if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n            qa = qa if Y >= P['a1'] > 0 else 0.0          # let the competitor's 2-tick ask erode instead of fronting it for nothing\n        # ammunition: hold YES so that low asks are covered\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n                amt, qam = t, min(P['qf'], full - Y)     # a tick p has just crossed: nearly free\n            elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n                amt, qam = t, min(P['ammo_q'], target - Y)\n            elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n                amt, qam = t - 1, min(P['qf'], full - Y)  # rest just under p: filled only on the crossing, or by retail\n\n        if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        # 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 not (C.get('recover', 0) and o.side is Side.SELL and t < comp and self.res.get(o.order_id, 0.0) > 1 and state.yes_inventory > C.get('recover_yes', 1) and state.free_cash < C.get('recover_cash', 200)) and 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                ub = min(ub, max(0.0, free - C.get('reserve', 0.0) * min(1.0, H / C.get('release', 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        return actions + out\n",
      "code_sha256": "3a64070f97c80e1e5363faae73bd6541daf338c7f3ea3fed181adba1dd3c5582"
    },
    {
      "key": "phat-clamp",
      "code": "\"\"\"Stale-quote defence with tick probes, a sub-tick belief and cheap YES stock.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low\nasks.  That YES is bought when it is cheap: a large bid rests at tick 1 while p\nis above it, so the arbitrageur fills it on the crossing for about 0.1 tick a\nshare instead of nearly a full tick once p is near zero, and smaller bids sit on\nwhichever tick p is within 0.15 of.  Below tick 1 the estimate of p decays with\nthe time spent there, since no probe can see it.\n\"\"\"\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.0002)\nP.update({'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'fu': 0.25, 'Hu': 500})\nC = {'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'reserve': 200, 'scar': 0.0025, 'fu': 0.25, 'Hu': 500}\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\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        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            if phat < C.get('scar_p', .1):\n                a = max(0.0, a - C.get('scar', 0.0) * (1 - min(1.0, state.yes_inventory / C.get('stock', 3000.0))))\n            return min(C.get('askcap', P['qmax']), 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 = min(C.get('bidcap', 3000.0), qbid(bid_t))\n        qa = qask(ask_t)\n\n        Y = state.yes_inventory\n        if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n            qa = qa if Y >= P['a1'] > 0 else 0.0          # let the competitor's 2-tick ask erode instead of fronting it for nothing\n        # ammunition: hold YES so that low asks are covered\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n                amt, qam = t, min(P['qf'], full - Y)     # a tick p has just crossed: nearly free\n            elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n                amt, qam = t, min(P['ammo_q'], target - Y)\n            elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n                amt, qam = t - 1, min(P['qf'], full - Y)  # rest just under p: filled only on the crossing, or by retail\n\n        if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        # 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 not (C.get('recover', 0) and o.side is Side.SELL and t < comp and self.res.get(o.order_id, 0.0) > 1 and state.yes_inventory > C.get('recover_yes', 1) and state.free_cash < C.get('recover_cash', 200)) and 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                ub = min(ub, max(0.0, free - C.get('reserve', 0.0) * min(1.0, H / C.get('release', 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        return actions + out\n",
      "code_sha256": "6f6a2101c7d39ed4e1cea9bc8b4e55b722a73be8ee0d17b1b8d009e88cd60932"
    }
  ],
  "notes": "Sources: the twelve supplied item result JSON records under .imd/reads/artifacts/item-*. The strongest complete holdout gains are xu-low-p (+0.17501889339129986 retail, -0.021655467793699996 arbitrage) and phat-clamp (+0.06839335978929995 retail, -0.00251710744800004 arbitrage). release-window gains +0.1414946093050999 arbitrage but loses -0.08279344971040001 retail; reserve-low-p similarly gains +0.09923274468299997 arbitrage while losing -0.06748869949880004 retail. Probe-ladder-width and below-tick-decay lose arbitrage edge; mid-size-floor adds retail but loses substantially more arbitrage edge. retail-flow-online loses retail and gains arbitrage; its approach is subject to the brief's warning that one cited source did not hold, so no source-dependent inference is used here. maxpay-search is unchanged; its approach likewise has one warned source, and no source-dependent inference is used. join-spread1 is incomplete and flagged. These are item-reported holdout component differences, not a new measurement."
}
```