{"key":"h-d","approach":"New-incumbent code-free reference calibration, block h-d: immutable combine-cash C minus incumbent B on the assigned 500 paired holdout seeds. No tuning or promotion decision.","tried":["Only the supplied C and B; exact UTF-8 source hashes verified before and after measurement.","Each assigned seed attempted once per strategy, serially in one OS process; the first 10 timing pairs are included in all statistics."],"next":"Combine this block with the other assigned reference blocks using sums and sums of squares; this isolated reference block makes no promotion claim.","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        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":"baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273","incumbent_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","tuning":null,"paired":{"n":500,"sum_d":-1009.9952433165,"sum_d2":96348.87680428708,"mean_diff":-2.019990486633,"se":0.6148095360485271,"C_mean_edges":{"total_edge":94.924972374378,"retail_edge":117.1763806623502,"arb_edge":-22.251408288008598},"B_mean_edges":{"total_edge":96.94496286101099,"retail_edge":119.03570764014741,"arb_edge":-22.090744779181},"retail_diff":-1.8593269777971992,"arb_diff":-0.16066350882759986,"seeds":{"start":411500,"end":411999,"inclusive":true},"complete":true,"by_spread":{"1":{"n":134,"sum_d":-531.7678653127,"sum_d2":46756.13419583611,"mean_diff":-3.968416905318657,"se":1.5827501568813909,"C_mean_edges":{"total_edge":25.39118891121567,"retail_edge":45.47245643083731,"arb_edge":-20.081267519579104},"B_mean_edges":{"total_edge":29.359605816534327,"retail_edge":47.61264183523731,"arb_edge":-18.253036018694775},"retail_diff":-2.1401854044,"arb_diff":-1.828231500884328},"2":{"n":129,"sum_d":-164.48165623140002,"sum_d2":9028.027588298222,"mean_diff":-1.2750515986930235,"se":0.7307902048439922,"C_mean_edges":{"total_edge":87.10688298074419,"retail_edge":107.88817220145815,"arb_edge":-20.781289220745737},"B_mean_edges":{"total_edge":88.38193457943721,"retail_edge":111.5864909673752,"arb_edge":-23.204556387955037},"retail_diff":-3.6983187659170538,"arb_diff":2.423267167209302},"3":{"n":126,"sum_d":-119.09623392389996,"sum_d2":13556.339028587849,"mean_diff":-0.9452082057452378,"se":0.9238899230456911,"C_mean_edges":{"total_edge":127.05866696730952,"retail_edge":151.1685946955008,"arb_edge":-24.10992772826984},"B_mean_edges":{"total_edge":128.00387517305475,"retail_edge":153.20867897988572,"arb_edge":-25.204803806905556},"retail_diff":-2.04008428438492,"arb_diff":1.0948760786357146},"4":{"n":111,"sum_d":-194.6494878485,"sum_d2":27008.3759915649,"mean_diff":-1.7535989896261261,"se":1.477847307927351,"C_mean_edges":{"total_edge":151.47645883503694,"retail_edge":175.94652273713243,"arb_edge":-24.470063902184684},"B_mean_edges":{"total_edge":153.23005782466305,"retail_edge":175.1244047558099,"arb_edge":-21.894346931253153},"retail_diff":0.8221179813225239,"arb_diff":-2.575716970931531}}},"failures":[],"missing_seeds":[],"exceptions":[],"seconds_per_simulation":0.5546274051210002,"timing":{"first_10_pairs":[{"seed":411500,"C":0.630417083,"B":0.637045},{"seed":411501,"C":0.4665885000000001,"B":0.473282},{"seed":411502,"C":0.5945341249999996,"B":0.6044607910000002},{"seed":411503,"C":0.43736770899999966,"B":0.45251741700000014},{"seed":411504,"C":0.6461520000000007,"B":0.6388769170000002},{"seed":411505,"C":0.6704611659999999,"B":0.6755268329999993},{"seed":411506,"C":0.42946174999999975,"B":0.45117600000000024},{"seed":411507,"C":0.4494763749999997,"B":0.538449},{"seed":411508,"C":0.4990273330000008,"B":0.5308542500000009},{"seed":411509,"C":0.5854377500000005,"B":0.6012978750000002}],"first_10_seconds_per_simulation":0.5506204937000001,"simulation_seconds":554.6274051210002,"wall_seconds":554.935366167,"budget_seconds":2700,"stop_reason":"all 500 pairs attempted"},"checks":{"source_hashes_verified":true,"simulator_git_blobs_verified":true,"returned_seeds_verified":true,"finite_edges_verified":true,"first_observed_spreads_match_sampled_and_returned_regimes":true,"C_B_regimes_equal":true,"failed_flags":{"C":0,"B":0},"returned_error_count":0,"fixture_roundtrip_verified":true,"reserved_finalist_seeds_run":0},"simulator_commit":"b244530ee2a6247b5f930830eeca9dd950da0e7e","reproduction":{"python":"3.9.6","method":"Use unmodified orderbook_pm_challenge at the pinned commit, standard library only. For seed in range(411500,412000), config=sample_config(ChallengeConfig(),ParameterVariance(),seed=seed), with default 2000 steps. For C then B, load_strategy_factory from its verified exact source anew and run SimulationEngine(config,observing_factory,seed=seed).run() in the same process. observing_factory creates one fresh Strategy; on its first callback record the StepState bid/ask, pass state unchanged, and return actions unchanged. Infer s=max(1,((ask or 100)-(bid or 0)+1)//2); verify against config.competitor.spread_ticks and returned regime. No seed/config is passed to either Strategy. No multiprocessing, workers, sandbox, retries, tuning, or substitute seeds. All first 10 timing pairs are retained.","statistics":"Holdout only; tuning=null. d=C.total_edge-B.total_edge; sum_d=math.fsum(d); sum_d2=math.fsum(d*d); mean_diff=sum_d/n; se=sqrt(fsum((d-mean_diff)**2)/(n-1)/n). C_mean_edges/B_mean_edges are arithmetic means. retail_diff and arb_diff are signed mean C-minus-B differences. Include completed returned pairs even if failed, recording flags; any failure or missing pair makes complete=false. Compute overall and separately for each observed s. Floats are serialized with Python round-trip precision.","fixture":"Rows ordered by ascending seed; each contains only B score data. Decode base64, zlib-decompress, verify SHA256 of raw UTF-8 bytes, then JSON-decode and verify all five columns, row count, seed order, and B hash. No B source, policy outputs, or implementation summary is in the fixture."},"fixture":{"codec":"base64(zlib(UTF-8 compact JSON))","payload":"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","row_count":500,"seed_start":411500,"seed_end":411999,"schema":["seed","s","total_edge","retail_edge","arb_edge"],"uncompressed_sha256":"fffee86577e19c80ac35d9058d0d49660fbeb3219655b7086f4da3c172c1eab5","incumbent_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae"}}