{
 "approach": "Blind build from the simulator only. S0 (97 lines): keeps an interval [lo,hi] (ticks) for the fair probability from the competitor's best bid/ask. The arbitrageur sweeps every resting ask below p and bid above p, so p lies in [competitor_bid, competitor_ask]; when the ask side rises (asks swept) p is within one tick below it, when the bid side falls p is within one tick above it; between sweeps the interval widens by WIDEN ticks/step; a missing side means p is past 99 or below 1. One bid at min(competitor_bid+1, floor(mid-MARGIN)) and one ask at max(competitor_ask-1, ceil(mid+MARGIN)), SIZE shares each, cash-checked, CancelAll every step. S1 = S0 with the single quote per side replaced by a ladder: LEVELS levels per side spaced GAP ticks away from the top quote (deeper = further from the estimate), sizes SIZE*RATIO^k. Only LEVELS/RATIO/GAP differ between S0 and S1.",
 "tried": [
  {
   "variant": "S0 WIDEN=1.0 MARGIN=2.0 SIZE=10",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -2.039,
   "mean_retail_edge": 9.4976,
   "mean_arb_edge": -11.5366
  },
  {
   "variant": "S0 WIDEN=1.0 MARGIN=2.5 SIZE=20",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -5.8033,
   "mean_retail_edge": 12.0254,
   "mean_arb_edge": -17.8286
  },
  {
   "variant": "S0 WIDEN=0.5 MARGIN=2.0 SIZE=10 (frozen S0)",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -0.5766,
   "mean_retail_edge": 10.6246,
   "mean_arb_edge": -11.2012
  },
  {
   "variant": "S0 WIDEN=1.0 MARGIN=3.0 SIZE=20",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -5.821,
   "mean_retail_edge": 6.4987,
   "mean_arb_edge": -12.3198
  },
  {
   "variant": "S1 = frozen S0 + LEVELS=3 RATIO=0.5 GAP=1",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -4.0898,
   "mean_retail_edge": 11.0037,
   "mean_arb_edge": -15.0935
  },
  {
   "variant": "S1 = frozen S0 + LEVELS=4 RATIO=0.5 GAP=2",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -3.4157,
   "mean_retail_edge": 10.7516,
   "mean_arb_edge": -14.1673
  },
  {
   "variant": "S1 = frozen S0 + LEVELS=3 RATIO=0.3 GAP=3 (frozen S1)",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -1.7014,
   "mean_retail_edge": 10.6548,
   "mean_arb_edge": -12.3562
  },
  {
   "variant": "S1 = frozen S0 + LEVELS=5 RATIO=0.7 GAP=1",
   "seeds": "115000..115499",
   "n": 500,
   "mean_total_edge": -7.7663,
   "mean_retail_edge": 11.2105,
   "mean_arb_edge": -18.9768
  }
 ],
 "next": "The geometric ladder does not pay here: deeper levels sit behind the static competitor ladder, so retail almost never reaches them (retail gain +0.02) while jumps and fast end-of-run moves sweep them for the arbitrageur (arb -1.06). Mechanism is a take-away for strategies like this. The S0 baseline itself is weak (near zero, vs B about 99.5): its loss is ~1 tick per share on diffusion crossings, so a better probability estimate (e.g. inverting the known jump-diffusion formula for p given steps remaining) matters far more than order shape. A ladder could only help if its deep levels stay strictly inside the competitor spread when the spread is wide (spread_ticks 3-4) and only on the side away from the last sweep; untested.",
 "code": "from __future__ import annotations\n\nimport math\n\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelAll, PlaceOrder, Side, StepState\n\n\nclass Strategy(BaseStrategy):\n    \"\"\"Passive quotes around an interval estimate of the fair probability.\n\n    The arbitrageur sweeps every resting ask below p and every bid above p, so\n    after each step p lies in [competitor_bid, competitor_ask] (ticks). When a\n    side is swept, p sits within one tick of that side. Between sweeps the\n    interval [lo, hi] widens by WIDEN ticks per step. Bids rest at or below\n    lo - MARGIN, asks at or above hi + MARGIN, one tick inside the competitor\n    when that is still far enough from the interval.\n    \"\"\"\n\n    WIDEN = 0.5        # interval growth per step (ticks)\n    MARGIN = 2.0       # distance between quote and interval edge (ticks)\n    SIZE = 10.0        # shares in the top quote\n    LEVELS = 3         # ladder levels per side (1 = single quote)\n    RATIO = 0.3        # geometric size ratio between successive levels\n    GAP = 3            # ticks between successive ladder levels\n\n    def __init__(self) -> None:\n        self.lo = None\n        self.hi = None\n        self.pb = None\n        self.pa = None\n\n    def _update(self, cb, ca):\n        bot = float(cb) if cb is not None else 0.0\n        top = float(ca) if ca is not None else 100.0\n        if ca is None and cb is not None:\n            bot = 99.0  # every ask swept: p is above 0.99\n        if cb is None and ca is not None:\n            top = 1.0   # every bid swept: p is below 0.01\n        if self.lo is None:\n            lo, hi = bot, top\n        else:\n            lo, hi = self.lo - self.WIDEN, self.hi + self.WIDEN\n            if ca is not None and self.pa is not None and ca > self.pa:\n                lo, hi = ca - 1.0, ca\n            if cb is not None and self.pb is not None and cb < self.pb:\n                lo, hi = cb, cb + 1.0\n        lo, hi = max(lo, bot), min(hi, top)\n        if lo > hi:\n            lo, hi = bot, top\n        self.lo, self.hi, self.pb, self.pa = lo, hi, cb, ca\n        return lo, hi\n\n    def _levels(self, top, step):\n        out = []\n        size = self.SIZE\n        for k in range(self.LEVELS):\n            tick = top + step * self.GAP * k\n            if tick < 1 or tick > 99:\n                break\n            out.append((tick, size))\n            size *= self.RATIO\n        return out\n\n    def on_step(self, state: StepState):\n        cb = state.competitor_best_bid_ticks\n        ca = state.competitor_best_ask_ticks\n        lo, hi = self._update(cb, ca)\n        actions = [CancelAll()]\n        free = state.free_cash - 1.0\n\n        mid = 0.5 * (lo + hi)\n        bid_top = math.floor(mid - self.MARGIN)\n        if cb is not None:\n            bid_top = min(bid_top, cb + 1)\n        for tick, q in self._levels(bid_top, -1):\n            q = math.floor(q * 100) / 100\n            cost = tick / 100.0 * q\n            if q <= 0 or cost > free:\n                break\n            free -= cost\n            actions.append(PlaceOrder(side=Side.BUY, price_ticks=tick, quantity=q))\n\n        yes = state.yes_inventory\n        ask_top = math.ceil(mid + self.MARGIN)\n        if ca is not None:\n            ask_top = max(ask_top, ca - 1)\n        for tick, q in self._levels(ask_top, 1):\n            q = math.floor(q * 100) / 100\n            covered = min(yes, q)\n            cost = (1.0 - tick / 100.0) * (q - covered)\n            if q <= 0 or cost > free:\n                break\n            yes -= covered\n            free -= cost\n            actions.append(PlaceOrder(side=Side.SELL, price_ticks=tick, quantity=q))\n        return actions\n",
 "code_sha256": "836af37a1889ec053188fb9479cdb137e04a8c8e770ce7278162c0b59ca2bef7",
 "code_s0": "from __future__ import annotations\n\nimport math\n\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelAll, PlaceOrder, Side, StepState\n\n\nclass Strategy(BaseStrategy):\n    \"\"\"Passive quotes around an interval estimate of the fair probability.\n\n    The arbitrageur sweeps every resting ask below p and every bid above p, so\n    after each step p lies in [competitor_bid, competitor_ask] (ticks). When a\n    side is swept, p sits within one tick of that side. Between sweeps the\n    interval [lo, hi] widens by WIDEN ticks per step. Bids rest at or below\n    lo - MARGIN, asks at or above hi + MARGIN, one tick inside the competitor\n    when that is still far enough from the interval.\n    \"\"\"\n\n    WIDEN = 0.5        # interval growth per step (ticks)\n    MARGIN = 2.0       # distance between quote and interval edge (ticks)\n    SIZE = 10.0        # shares in the top quote\n    LEVELS = 1         # ladder levels per side (1 = single quote)\n    RATIO = 0.5        # geometric size ratio between successive levels\n    GAP = 1            # ticks between successive ladder levels\n\n    def __init__(self) -> None:\n        self.lo = None\n        self.hi = None\n        self.pb = None\n        self.pa = None\n\n    def _update(self, cb, ca):\n        bot = float(cb) if cb is not None else 0.0\n        top = float(ca) if ca is not None else 100.0\n        if ca is None and cb is not None:\n            bot = 99.0  # every ask swept: p is above 0.99\n        if cb is None and ca is not None:\n            top = 1.0   # every bid swept: p is below 0.01\n        if self.lo is None:\n            lo, hi = bot, top\n        else:\n            lo, hi = self.lo - self.WIDEN, self.hi + self.WIDEN\n            if ca is not None and self.pa is not None and ca > self.pa:\n                lo, hi = ca - 1.0, ca\n            if cb is not None and self.pb is not None and cb < self.pb:\n                lo, hi = cb, cb + 1.0\n        lo, hi = max(lo, bot), min(hi, top)\n        if lo > hi:\n            lo, hi = bot, top\n        self.lo, self.hi, self.pb, self.pa = lo, hi, cb, ca\n        return lo, hi\n\n    def _levels(self, top, step):\n        out = []\n        size = self.SIZE\n        for k in range(self.LEVELS):\n            tick = top + step * self.GAP * k\n            if tick < 1 or tick > 99:\n                break\n            out.append((tick, size))\n            size *= self.RATIO\n        return out\n\n    def on_step(self, state: StepState):\n        cb = state.competitor_best_bid_ticks\n        ca = state.competitor_best_ask_ticks\n        lo, hi = self._update(cb, ca)\n        actions = [CancelAll()]\n        free = state.free_cash - 1.0\n\n        mid = 0.5 * (lo + hi)\n        bid_top = math.floor(mid - self.MARGIN)\n        if cb is not None:\n            bid_top = min(bid_top, cb + 1)\n        for tick, q in self._levels(bid_top, -1):\n            q = math.floor(q * 100) / 100\n            cost = tick / 100.0 * q\n            if q <= 0 or cost > free:\n                break\n            free -= cost\n            actions.append(PlaceOrder(side=Side.BUY, price_ticks=tick, quantity=q))\n\n        yes = state.yes_inventory\n        ask_top = math.ceil(mid + self.MARGIN)\n        if ca is not None:\n            ask_top = max(ask_top, ca - 1)\n        for tick, q in self._levels(ask_top, 1):\n            q = math.floor(q * 100) / 100\n            covered = min(yes, q)\n            cost = (1.0 - tick / 100.0) * (q - covered)\n            if q <= 0 or cost > free:\n                break\n            yes -= covered\n            free -= cost\n            actions.append(PlaceOrder(side=Side.SELL, price_ticks=tick, quantity=q))\n        return actions\n",
 "code_s0_sha256": "eccc0007882dffa21e0a68bed5a46e462cd78bfb693adffbdadb5e7eb3263d77",
 "tuning_score": {
  "seeds": "115000..115499",
  "n": 500,
  "s1_mean": -1.7014,
  "s0_mean": -0.5766
 },
 "paired": {
  "seeds": "200000..200999",
  "n": 1000,
  "complete": true,
  "mechanism_diff": -1.0385,
  "mechanism_se": 0.0454,
  "mechanism_retail_diff": 0.0198,
  "mechanism_retail_se": 0.0022,
  "mechanism_arb_diff": -1.0582,
  "mechanism_arb_se": 0.0453,
  "reference_diff": -100.278,
  "reference_se": 5.4292,
  "s1_mean": -0.5822,
  "s0_mean": 0.4563,
  "b_mean": 99.6959,
  "s1_retail_mean": 10.755,
  "s1_arb_mean": -11.3372,
  "s0_retail_mean": 10.7353,
  "s0_arb_mean": -10.2789,
  "failures": []
 },
 "graft": "Replace each side's single quote (tick t, size Q) with LEVELS=3 orders at t, t-3, t-6 for bids (t, t+3, t+6 for asks), sizes Q, 0.3Q, 0.09Q, skipping ticks outside 1..99 and stopping when collateral runs out. Measured here it lowered total edge (deep levels mostly feed the arbitrageur), so graft only to test, not to promote.",
 "seconds_per_simulation": 0.453,
 "notes": "Holdout complete: all 1000 seeds 200000..200999 for both S0 and S1, no failures. Run single-process per seed with run_batch(factory, base_config=ChallengeConfig(), variance=ParameterVariance(), n_simulations=1, seed_start=seed, workers=1), simulator unmodified at commit b244530, 8 OS processes on disjoint seed ranges. Before formal tuning, design/debug smoke runs used seeds 115000..115039 only (subset of the tuning range), to find an estimator bug at the price bounds and pick the estimator form. reference_diff = S1 minus B's per-seed total_edge from fixture.H (sha256 verified). seconds_per_simulation is wall time per simulation per process."
}