Merged reported results; no simulator runs or promotion decision. Rows copy tuning_score and paired fields, with approach/next truncated as requested. The incumbent identified by all items is `baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273`. All quantitative claims below are attributed to the corresponding input, not independently replicated. The source-recheck warning for bank-size comes from the assignment; the failed source itself was not provided.

Sources (row key → supplied input; statistics: tuning_score/paired; interpretation: approach/next; top code: code/code_sha256):

- [ask-two-tier](../../../../../../.imd/reads/artifacts/item-ask-two-tier)
- [bank-size](../../../../../../.imd/reads/artifacts/item-bank-size)
- [bank-spread-gate](../../../../../../.imd/reads/artifacts/item-bank-spread-gate)
- [bid-only-jump-charge](../../../../../../.imd/reads/artifacts/item-bid-only-jump-charge)
- [competitor-mid-likelihood](../../../../../../.imd/reads/artifacts/item-competitor-mid-likelihood)
- [endgame-halve](../../../../../../.imd/reads/artifacts/item-endgame-halve)
- [fill-pullback](../../../../../../.imd/reads/artifacts/item-fill-pullback)
- [gate-plus-jump](../../../../../../.imd/reads/artifacts/item-gate-plus-jump)
- [jump-charge-scale](../../../../../../.imd/reads/artifacts/item-jump-charge-scale)
- [retreat-soft-cut](../../../../../../.imd/reads/artifacts/item-retreat-soft-cut)
- [spread1-ka](../../../../../../.imd/reads/artifacts/item-spread1-ka)
- [subtick-loss-split](../../../../../../.imd/reads/artifacts/item-subtick-loss-split)

```json
{
  "rows": [
    {
      "key": "retreat-soft-cut",
      "idea": "B with exactly one mechanism added: inside the existing jumpinfo condition, detect a one-tick competitor ask retreat (ca == previous ca + 1) and bid retreat (cb == previous cb - 1). After the existing",
      "code_sha256": "5479707f80b03971ec40940acca3f5f3bd3d1fb0d0760113a46872ee56a0d2a6",
      "t_n": 500,
      "t_diff": 1.242224667380799,
      "t_se": 0.340243982322761,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.8796475022306004,
      "h_se": 0.27714920530504944,
      "h_sum_d": 879.6475022306004,
      "h_sum_d2": 77508.65004739976,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.5082971850425004,
      "h_arb_diff": 1.3879446872837997,
      "failures": [],
      "next": "Have a measure item replicate the frozen candidate against the current best on the reserved finalist seeds before considering promotion; this item did not use those seeds. Treat the holdout result as reported, without retuning on H.",
      "flag": null
    },
    {
      "key": "competitor-mid-likelihood",
      "idea": "Starting from the exact hash-verified combine-cash incumbent B, insert one soft observation update immediately after the existing grid prediction/truncation and before storing its posterior. Multiply ",
      "code_sha256": "32379b1d73bcca96e7209e8e8d6d4a064976187a97a2becc7386d19283935b43",
      "t_n": 500,
      "t_diff": -0.12672776187339996,
      "t_se": 0.08767641363191203,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.15800444835940067,
      "h_se": 0.13956975364091176,
      "h_sum_d": 158.00444835940064,
      "h_sum_d2": 19485.201820954775,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.1784601889330999,
      "h_arb_diff": -0.020455740548400266,
      "failures": [],
      "next": "Retain B: the positive holdout difference is below two standard errors and does not establish an improvement. Its point gain is from retail, with slightly worse arbitrage edge. In a separate future item, test a likelihood conditioned on competitor spread, quote age, and missing sides, because the re",
      "flag": null
    },
    {
      "key": "gate-plus-jump",
      "idea": "Combine the tick-1 stock-entry bank gate with the supplied per-side adverse-jump sizing charge. Starting from the hash-verified side-jump-budget source, replace only the q1 upper probability-tick cond",
      "code_sha256": "bb9ede1b3537df3a55fe2f9b02ea9cae2b4aa490f911831d10f7b6e8e991a0f4",
      "t_n": 500,
      "t_diff": -0.9827684788324005,
      "t_se": 0.3920456411215397,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.031885203952301266,
      "h_se": 0.39956547978714585,
      "h_sum_d": 31.885203952301268,
      "h_sum_d2": 159493.9367311256,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -1.0609007669208999,
      "h_arb_diff": 1.0927859708973997,
      "failures": [],
      "next": "Retain B: both combinations lost total edge on tuning despite reducing arbitrage loss, and the frozen winner had no statistically established total-edge gain on holdout (+0.031885, SE 0.399565). Do not promote from this item or revise the frozen code after holdout. A future separately authorized ite",
      "flag": null
    },
    {
      "key": "ask-two-tier",
      "idea": "ask-two-tier: B with one change - the main ask quantity qa is split, fraction TIER_F at ask_t and the rest at ask_t + 1 when ask_t + 1 < ca (else all at ask_t); the ask management keeps orders at both",
      "code_sha256": "84be1ab2506ea952dae51d3a58f2373eac447b6681a1e713085f575d7a617662",
      "t_n": 500,
      "t_diff": 0.0,
      "t_se": 0.0,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": 0.0,
      "h_se": 0.0,
      "h_sum_d": 0.0,
      "h_sum_d2": 0.0,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.0,
      "h_arb_diff": 0.0,
      "failures": [],
      "next": "Do not promote: the frozen candidate behaves the same as B (paired diff exactly 0 on H). Splitting the main ask over a higher tick cannot work while B always quotes one tick inside or at the competitor ask. Resting size at the competitor's tick (ca) trades about 1 unit of arb saving for about 2.2 un",
      "flag": null
    },
    {
      "key": "endgame-halve",
      "idea": "Endgame quote shrink: in the last Hw steps (H = steps_remaining <= Hw), while the belief phat is mid-range (0.05 <= phat <= 0.80), multiply the main bid and ask sizes qb and qa by c, right after they ",
      "code_sha256": "8da18430847ef3236bce1b86eca5e8a7c569bef6ce9fc945e92de49c0884b018",
      "t_n": 500,
      "t_diff": 0.0001421607170001273,
      "t_se": 0.023080407349666338,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.0021035393811999433,
      "h_se": 0.01615061099345695,
      "h_sum_d": -2.103539381199943,
      "h_sum_d2": 260.5858181044387,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.05625520945130002,
      "h_arb_diff": 0.054151670069299995,
      "failures": [],
      "next": "Uniform size shrinking late in the game is a wash: arbitrage loss saved (+0.04 to +0.24 per sim on T) is matched by retail lost. To make it pay, condition the shrink on adverse-selection signals instead of time alone, e.g. shrink only the side the latent drift or a recent jump points against, or onl",
      "flag": null
    },
    {
      "key": "jump-charge-scale",
      "idea": "Start from pilot side-jump-budget (B plus a per-side adverse-jump charge added to the bid/ask edge in qsize), and scale that charge by a multiplier (the literal 1.0 in jump_charge's return) to find th",
      "code_sha256": "48198cc6759062c31c8caf527085a67dbf1d2edaf88d242fdda55e5e7fe74cb9",
      "t_n": 500,
      "t_diff": -0.29839172375900036,
      "t_se": 0.18136563451424498,
      "h_seeds": "210000..210499 (only the first 500 of H; machine throughput ~0.8 s/sim on effectively one core did not allow all 1000)",
      "h_n": 500,
      "h_complete": true,
      "h_diff": -0.13546427473699862,
      "h_se": 0.2226562906010494,
      "h_sum_d": -67.73213736849931,
      "h_sum_d2": 12378.343309047645,
      "h_incumbent_mean": 118.2761131255256,
      "h_retail_diff": -0.44530838811380014,
      "h_arb_diff": 0.30984411340660006,
      "failures": [],
      "next": "Every multiplier lost to B on T (monotone: arb gain grows roughly linearly with the multiplier but retail loss grows faster). The uniform per-side jump charge looks net-negative at any scale; drop it, or apply it only when the jump estimate is confident (state-dependent gating), or charge only the s",
      "flag": "h_incumbent_mean differs from all full-H rows (118.2761131255256 versus 106.5366543275672); only 210000..210499 measured, not full H. Reported complete=true is copied unchanged; subset difference does not by itself show measurement corruption."
    },
    {
      "key": "spread1-ka",
      "idea": "Spread-1 markets (competitor half-spread s==1) carry the largest arbitrage share of retail edge, so the candidate multiplies B's arbitrage-loss weight kA by c1 when self.s == 1 (kL branch for phat < p",
      "code_sha256": "c064a84e5adaac6ba7a7aca81a1538dc381b0e295234e281275bbf480e225ccc",
      "t_n": 500,
      "t_diff": -0.02696492148220005,
      "t_se": 0.04745773872859922,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.1600147116543,
      "h_se": 0.05278030972869739,
      "h_sum_d": -160.01471165430002,
      "h_sum_d2": 2808.58004190798,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.3848975232832999,
      "h_arb_diff": 0.22488281162719995,
      "failures": [],
      "next": "Scaling kA on spread-1 trades retail for arbitrage roughly 1:1 or worse at every c1 tried (monotone: larger c1, more arb saved, more retail lost), so a uniform size cut is not the lever. Try instead conditioning on the jump/probability signal (e.g. raise kA only right after a detected jump or when |",
      "flag": null
    },
    {
      "key": "bid-only-jump-charge",
      "idea": "Charge the jump tail only on bids: in AB(), multiply the bid-loss term lj * ja by cjb, passing cjb only from qbid and retaining the default 1.0 for asks. The H == 1 terminal formula is unchanged. Test",
      "code_sha256": "e21656414e5be7301f6f93c27029a1df0ccf037619750dce27199589b54e344a",
      "t_n": 500,
      "t_diff": -0.018993699710600925,
      "t_se": 0.09287322464100625,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.3734040553563993,
      "h_se": 0.07671559902039232,
      "h_sum_d": -373.4040553563993,
      "h_sum_d2": 6018.828438481165,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -0.8946676321050001,
      "h_arb_diff": 0.5212635767628998,
      "failures": [],
      "next": "Keep B; do not promote the frozen candidate. Its holdout retail-edge cost exceeds its arbitrage savings. A separate item could test a probability-dependent bid jump charge on newly assigned disjoint seeds. Do not reuse H for tuning; finalist seeds remain untouched.",
      "flag": null
    },
    {
      "key": "fill-pullback",
      "idea": "B plus only a main-order fill pullback: track client IDs of main bids and asks, remove IDs when canceled, and detect an ID absent from the next own_orders snapshot. Multiply that side's target qb or q",
      "code_sha256": "57f357c772574d5a74e739355a0c9ae9a3d9259a30f459e9acd0d385d8e1d2ed",
      "t_n": 500,
      "t_diff": 0.21094145095779904,
      "t_se": 0.2676098286694248,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.42094783097149957,
      "h_se": 0.2929899129329948,
      "h_sum_d": -420.94783097149957,
      "h_sum_d2": 85934.44306780299,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -1.7036729614433002,
      "h_arb_diff": 1.282725130491,
      "failures": [],
      "next": "Do not promote this candidate: the holdout does not establish a positive gain. In a separate future item, test whether filtering disappearance events by remaining size or simultaneous probe evidence reduces retail false positives; use a new prespecified tuning/holdout split.",
      "flag": null
    },
    {
      "key": "subtick-loss-split",
      "idea": "B with one change: in AB() the Gaussian (sub-tick diffusion) part of the expected adverse-selection loss/gain is scaled by a new constant kG separately from the jump-mixture part: return ((1-lj)*a*kG ",
      "code_sha256": "f1f2c4e263f1d2b0a72384207e26fe64234fe5c150491c7a2c6a360521dfcf90",
      "t_n": 500,
      "t_diff": 0.03186687944079942,
      "t_se": 0.18940824973556744,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -0.46103821102279946,
      "h_se": 0.2872716068184836,
      "h_sum_d": -461.0382110227995,
      "h_sum_d2": 82655.00734001247,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": 0.6860356839939993,
      "h_arb_diff": -1.1470738949964001,
      "failures": [],
      "next": "Larger kG trades retail edge for arbitrage loss almost one-for-one (kG=2.0: retail +2.49, arb -2.97 on T; kG=0.8 the reverse), so a uniform Gaussian-loss scale is near-neutral. Try making kG state-dependent (e.g. only near phat extremes or late in the horizon where sub-tick diffusion dominates arb l",
      "flag": null
    },
    {
      "key": "bank-size",
      "idea": "Freeze B and change exactly one parameter: vary only P['ydf1'], the quantity scale for the tick-1 q1 bank, over the four permitted values. Select the value with the largest paired mean difference on T",
      "code_sha256": "4b513c692bb42ef8a829c6d734396b90fe504c58c435a05b14e7699b6526ab44",
      "t_n": 500,
      "t_diff": -0.6477530352606007,
      "t_se": 0.31513560179065925,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -1.9275143925314995,
      "h_se": 0.4005487980552413,
      "h_sum_d": -1927.5143925314994,
      "h_sum_d2": 163994.21201729105,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -1.4666004381783997,
      "h_arb_diff": -0.4609139543548002,
      "failures": [],
      "next": "Because every permitted bank size lost on T, test a different single mechanism from the scoreboard, such as a less aggressive reserve or cover-bank rule, on fresh tuning seeds; do not promote this candidate.",
      "flag": null
    },
    {
      "key": "bank-spread-gate",
      "idea": "bank-spread-gate: B with exactly one change. The tick-1 bank (q1 YES accumulation) is allowed only when the competitor spread parameter self.s leaves room, by appending `and self.s > k` to the q1 cond",
      "code_sha256": "f81b61b3cd220f00f2d1a9ff7ec203c01a53e9e02153a37b7623e56cf918dcdc",
      "t_n": 500,
      "t_diff": -5.3490196242992,
      "t_se": 1.2818157565382289,
      "h_seeds": "210000..210999",
      "h_n": 1000,
      "h_complete": true,
      "h_diff": -7.0196198674309995,
      "h_se": 1.4656964177021552,
      "h_sum_d": -7019.619867431,
      "h_sum_d2": 2195392.7859592973,
      "h_incumbent_mean": 106.5366543275672,
      "h_retail_diff": -10.2973061541608,
      "h_arb_diff": 3.2776862867318997,
      "failures": [],
      "next": "Gating the tick-1 bank off on spread-1 markets throws away retail edge worth ~3x the arbitrage it saves, so the bank is net positive exactly where the spread is tight. Rather than gating on s, try sizing q1 (e.g. a smaller ydf1 multiplier or a cap on Wf) when s == 1, or gating on a probability/jump ",
      "flag": null
    }
  ],
  "top": [
    {
      "key": "retreat-soft-cut",
      "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        retreat_ask = retreat_bid = False\n        if P['jumpinfo'] > 0 and self.pcb is not None:\n            retreat_ask = ca == self.pca + 1\n            retreat_bid = cb == self.pcb - 1\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        if retreat_ask or retreat_bid:\n            ws = [weight * (0.016 if retreat_ask and c < ca - 1 else 1.0)\n                  * (0.016 if retreat_bid and c > cb + 1 else 1.0)\n                  for c, weight in zip(cs, ws)]\n            tot = sum(ws)\n            ws = [weight / tot for weight 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": "5479707f80b03971ec40940acca3f5f3bd3d1fb0d0760113a46872ee56a0d2a6"
    },
    {
      "key": "competitor-mid-likelihood",
      "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        # Soft likelihood from the competitor midpoint, in tick units.\n        midpoint = (cb + ca) / 2.0\n        log_likelihoods = [-0.5 * ((c - midpoint) / 4.0) ** 2 for c in cs]\n        log_scale = max(log_likelihoods)\n        ws = [w * math.exp(ll - log_scale) for w, ll in zip(ws, log_likelihoods)]\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": "32379b1d73bcca96e7209e8e8d6d4a064976187a97a2becc7386d19283935b43"
    }
  ],
  "notes": "Reported H results: retreat-soft-cut leads (+0.8796475022306004, SE 0.27714920530504944): arbitrage +1.3879446872837997 outweighs retail -0.5082971850425004. Competitor-mid-likelihood gains retail (+0.1784601889330999) with slightly worse arbitrage (-0.020455740548400266); its reported next says retain B. Gate-plus-jump saves arbitrage but loses nearly as much retail. Bid-only-jump-charge, spread1-ka, fill-pullback and bank-spread-gate likewise sacrifice more retail than arbitrage saved. Endgame-halve is near neutral; ask-two-tier reports an inactive literal rule and exactly zero differences. Subtick-loss-split gains retail but worsens arbitrage more. Bank-size reports both components worse; its one source failed the supplied source recheck, so these are attributed local results, not independently verified evidence from that external source; the failed URL/passage was not supplied. Jump-charge-scale has only 500 H seeds and a different incumbent mean; see its flag. Sources: each named item below, paired/approach/next fields. No finalist evidence or promotion is established by this merge; retreat-soft-cut requests finalist replication. No new statistics or simulations were computed."
}
```