{ "key": "d-s1-join-mid", "idea": "join the rival's price level in the 20 to 80 cent range (spread 1)", "approach": "On spread-1 runs with 0.20<=phat<=0.80, N additionally rests a bid at the rival best bid tick and an ask at the rival best ask tick (join, never improve), sized by N's own qbid/qask at those ticks. These join orders are tracked apart from N's book logic, kept for queue priority, and cancelled when phat leaves the band. The state does not expose the rival's displayed size, so the cap uses the expected displayed size 48/price (the 24..72 notional band's midpoint). Joined orders get almost no retail flow and lose to arbitrage: negative at every cap.", "tried": [ { "name": "cap_1x", "code_sha256": "8de396c2f084d256fbe3176a9636ae4d6f8c72aa5ed929f7d261a06e2ec52307", "mean_diff": -2.183827, "se": 0.323431, "n": 200, "spread1_mean_diff": -8.735309, "spread1_se": 0.72897 }, { "name": "cap_0.5x", "code_sha256": "bf29a8e02a42d4264f3ae0e8a4b0f5929b59f2e26da242981b0adaec38cd95d4", "mean_diff": -2.183827, "se": 0.323431, "n": 200, "spread1_mean_diff": -8.735309, "spread1_se": 0.72897 }, { "name": "cap_0.1x", "code_sha256": "36cbe4f38762144c0edadc241709034607de076ed56b65f9f51f838a2e084b20", "mean_diff": -1.454834, "se": 0.221554, "n": 200, "spread1_mean_diff": -5.819338, "spread1_se": 0.528264 } ], "next": "Drop joining the rival's level on spread 1: queued behind the rival, it collects arbitrage (-5.9/seed on spread 1) and almost no retail flow, and a smaller cap only shrinks the loss.", "code": "\"\"\"Exact per-spread merge: c1-pairs, c2-queue, a3-ledger, c4-all; no fixes.\n\nd-s1-join-mid: on spread-1 runs with 0.20 <= phat <= 0.80, also rest a bid at the\nrival best bid tick and an ask at the rival best ask tick (join, never improve), sized by\nN's qbid/qask at those ticks and capped at JCAP x the rival's expected displayed size\n(48 notional, the midpoint of the 24..72 quote-notional band, / price).\n\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\ndef _spread1():\n P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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)\n SQ2 = math.sqrt(2.0)\n SQ2PI = math.sqrt(2.0 * math.pi)\n\n def cdf(x):\n return 0.5 * (1.0 + math.erf(x / SQ2))\n\n def pdf(x):\n return math.exp(-0.5 * x * x) / SQ2PI\n\n def inv(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n d = pdf(x)\n if d < 1e-12:\n break\n x -= (cdf(x) - p) / d\n return x\n\n def lpm(k):\n return pdf(k) + k * cdf(k)\n\n def fl(q):\n return math.floor(q * 100 + 1e-09) / 100\n NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n PROBE = 0.01\n F_AH = 1\n F_FL = 1\n F_QB = 1\n F_LK = 0\n F_SB = 0\n FLOW_CAPS = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0)\n FLOW_GRID = []\n FLOW_PRIORS = []\n for _rn, _rw in ((-math.sqrt(0.6), 5 / 18), (0.0, 4 / 9), (math.sqrt(0.6), 5 / 18)):\n _r = 0.1265 + 0.0495 * _rn\n for _mn, _mw in ((-0.906179845938664, 0.118463442528095), (-0.538469310105683, 0.239314335249683), (0.0, 0.284444444444444), (0.538469310105683, 0.239314335249683), (0.906179845938664, 0.118463442528095)):\n _m = 4.488 + 1.848 * _mn\n _parts = []\n for _n in (1, 2, 3):\n _v = math.log(1 + (math.exp(1.44) - 1) / _n)\n _sg = math.sqrt(_v)\n _mu = math.log(_n * _m) - _v / 2\n _w = _r ** _n / math.factorial(_n)\n _parts.append((_mu, _sg, _w))\n _norm = []\n for _c in FLOW_CAPS:\n _prob = sum((w * (cdf((math.log(_c) - mu) / sg) - cdf((math.log(0.03) - mu) / sg)) for mu, sg, w in _parts))\n _norm.append(math.log1p(_prob))\n _tails = []\n for _c in FLOW_CAPS:\n _cdf = 1 + sum((w * cdf((math.log(_c) - mu) / sg) for mu, sg, w in _parts))\n _tails.append(math.log(max(1e-100, 1 - math.exp(-_r) * _cdf)))\n FLOW_GRID.append((_r, _m, _parts, _norm, _tails))\n FLOW_PRIORS.append(math.log(_rw * _mw))\n return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS)\n\ndef _spread2():\n P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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)\n SQ2 = math.sqrt(2.0)\n SQ2PI = math.sqrt(2.0 * math.pi)\n\n def cdf(x):\n return 0.5 * (1.0 + math.erf(x / SQ2))\n\n def pdf(x):\n return math.exp(-0.5 * x * x) / SQ2PI\n\n def inv(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n d = pdf(x)\n if d < 1e-12:\n break\n x -= (cdf(x) - p) / d\n return x\n\n def lpm(k):\n return pdf(k) + k * cdf(k)\n\n def fl(q):\n return math.floor(q * 100 + 1e-09) / 100\n NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n PROBE = 0.01\n return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread3():\n P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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)\n SQ2 = math.sqrt(2.0)\n SQ2PI = math.sqrt(2.0 * math.pi)\n\n def cdf(x):\n return 0.5 * (1.0 + math.erf(x / SQ2))\n\n def pdf(x):\n return math.exp(-0.5 * x * x) / SQ2PI\n\n def inv(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n d = pdf(x)\n if d < 1e-12:\n break\n x -= (cdf(x) - p) / d\n return x\n\n def lpm(k):\n return pdf(k) + k * cdf(k)\n\n def fl(q):\n return math.floor(q * 100 + 1e-09) / 100\n NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n PROBE = 0.01\n return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread4():\n P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, 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, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, 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)\n SQ2 = math.sqrt(2.0)\n SQ2PI = math.sqrt(2.0 * math.pi)\n\n def cdf(x):\n return 0.5 * (1.0 + math.erf(x / SQ2))\n\n def pdf(x):\n return math.exp(-0.5 * x * x) / SQ2PI\n\n def inv(p):\n p = min(max(p, 1e-09), 1 - 1e-09)\n t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n x = -x if p < 0.5 else x\n for _ in range(2):\n d = pdf(x)\n if d < 1e-12:\n break\n x -= (cdf(x) - p) / d\n return x\n\n def lpm(k):\n return pdf(k) + k * cdf(k)\n\n def fl(q):\n return math.floor(q * 100 + 1e-09) / 100\n NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n PROBE = 0.01\n return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\nJCAP = 0.1\nJLO, JHI = (0.2, 0.8)\nJNOT = 48.0\n\nclass Strategy(BaseStrategy):\n\n def __init__(self):\n self.n = 0\n self.ahead = set()\n self.res = {}\n self.bc = None\n self.bw = None\n self.st = 0.5\n self.pcb = self.pca = None\n self.pb = set()\n self.pa = set()\n self.tb = 0\n self.s = None\n self.flow_notional = 0.0\n self.flow_exposure = 0\n self.last_ask_tick = None\n self.last_quote_exposed = False\n self.last_flow_ca = None\n self.last_flow_cap = 0.0\n self.last_flow_correction = 1.0\n self.params = None\n self.jids = set()\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 initializing = self.s is None\n if initializing:\n self.s = max(1, (ca - cb + 1) // 2)\n if self.s == 1:\n self._scope = _spread1()\n elif self.s == 2:\n self._scope = _spread2()\n elif self.s == 3:\n self._scope = _spread3()\n elif self.s == 4:\n self._scope = _spread4()\n self.params = self._scope[0].copy()\n if self.s == 1:\n _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS = self._scope\n elif self.s == 2:\n _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n elif self.s == 3:\n _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n elif self.s == 4:\n _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n if initializing:\n if self.s == 1:\n self.fl_obs = ()\n self.fl_scores = FLOW_PRIORS.copy()\n self.fl_bins = [0] * len(FLOW_CAPS)\n self.fl_rate = 0.568734\n self.fl_r = 0.1265\n self.fl_m = 4.488\n self.fl_buy_sum = self.fl_sell_sum = 0.0\n self.fl_buy_exp = self.fl_sell_exp = 0.0\n self.fl_exp = 0\n self.fl_dirty = False\n self.fl_ahead = set()\n self.fl_safe_n = 0\n self.fl_sbins = [0] * len(FLOW_CAPS)\n elif self.s == 2:\n self.params.update(dict(flow_prior=200, flow_level=0.6, flow_strength=1.0, flow_safety=2.0, flow_exposure_min=5.0))\n self.params.update({'kLf': 0.16})\n elif self.s == 4:\n self.f4_exposure = [0, 0]\n self.f4_events = [0, 0]\n self.f4_weights = [[0.0] * 9, [0.0] * 9]\n self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n self.f4_last = [None, None]\n self.f4_rate = 0.1265\n self.f4_mean = 4.488\n self.f4_flow = self.f4_rate * self.f4_mean\n self.f4_extreme = inv(1 - 1e-06)\n if self.s == 1:\n self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n if self.s == 3:\n self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n P = self.params\n if self.s == 1:\n s1 = self.s == 1\n AH = s1 and F_AH\n FL = s1 and F_FL\n QB = s1 and F_QB\n LK = s1 and F_LK\n SB = s1 and F_SB\n elif self.s == 2:\n if self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n self.flow_exposure += 1\n self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n elif self.s == 3:\n if self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n self.flow_exposure += 1\n self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n elif self.s == 4:\n for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n last = self.f4_last[side]\n if last is None:\n continue\n tick, conv, cap, old_bound, ids = last\n if side == 0 and bound > old_bound + 1 or (side == 1 and bound < old_bound - 1):\n continue\n remaining = sum((o.remaining_quantity for o in state.own_orders if o.order_id in ids))\n value = max(0.0, cap - remaining * conv)\n self.f4_exposure[side] += 1\n if value > 0.01:\n self.f4_events[side] += 1\n censored = remaining < 0.011\n logv = math.log(max(value, 0.01))\n weights = self.f4_weights[side]\n for i, mu4 in enumerate(self.f4_mu):\n z4 = (logv - mu4) / 1.2\n weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n if state.step % 25 == 0:\n exposure = sum(self.f4_exposure)\n events = sum(self.f4_events)\n event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-06, 1.0 - event_probability))))\n weights = [a + b for a, b in zip(*self.f4_weights)]\n peak = max(weights)\n weights = [math.exp(w - peak) for w in weights]\n self.f4_mean = sum((m * w for m, w in zip(self.f4_means, weights))) / sum(weights)\n self.f4_flow = self.f4_rate * self.f4_mean\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-09}\n sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-09}\n ea = self.pa - sa\n eb = self.pb - sb\n if sa and ea:\n lo = max(lo, min(max(ea), hi))\n if eb and (sb or min(eb) <= 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 wid = max(hi - lo, 1e-06)\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 if self.s == 1:\n prior = tuple(zip(self.bc, self.bw))\n exp = math.exp\n for c in cs:\n t = uni\n for ci, wi in prior:\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * exp(d2)\n ws.append(t)\n elif self.s == 2:\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 elif self.s == 3:\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 elif self.s == 4:\n exp = math.exp\n if self.bc == cs and 1.0 <= wid <= 6.0 and (nb == 8 * wid):\n kernel = []\n c0 = cs[0]\n for ci in self.bc:\n d = c0 - ci\n d2 = d * d * k\n kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n kernel = kernel[:0:-1] + kernel\n for i in range(nb):\n t = uni\n start = nb - 1 - i\n for wi, e in zip(self.bw, kernel[start:start + nb]):\n if e:\n t += wi * e\n ws.append(t)\n else:\n previous = tuple(zip(self.bc, self.bw))\n for c in cs:\n t = uni\n for ci, wi in previous:\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * 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 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 if self.s == 1:\n if FL:\n remaining = {o.order_id: o.remaining_quantity for o in state.own_orders} if self.fl_obs else {}\n for px, ci, buying, previous, tick in self.fl_obs:\n qty = max(0.0, sum((q - remaining.get(oid, 0.0) for oid, q in previous)))\n x = qty * px\n cap = FLOW_CAPS[ci]\n gap = tick / 100.0 - phat if buying else phat - tick / 100.0\n safe = gap > max(0.005, 2.0 * math.sqrt(var_t) / 100.0)\n if 0 < x < 0.03:\n continue\n if x >= cap:\n if safe:\n self.fl_sbins[ci] += 1\n self.fl_exp += 1\n self.fl_dirty = True\n continue\n if safe:\n self.fl_safe_n += 1\n else:\n self.fl_bins[ci] += 1\n self.fl_exp += 1\n self.fl_dirty = True\n if buying:\n self.fl_buy_exp += 1\n else:\n self.fl_sell_exp += 1\n if x > 0:\n lx = math.log(x)\n for i, (r, m, parts, norm, tails) in enumerate(FLOW_GRID):\n density = sum((w * pdf((lx - mu) / sg) / sg for mu, sg, w in parts))\n self.fl_scores[i] += math.log(max(density, 1e-100))\n if state.step % 100 == 0 and (self.fl_dirty or state.step == 0):\n bins = [(i, n) for i, n in enumerate(self.fl_bins) if n]\n sbins = [(i, n) for i, n in enumerate(self.fl_sbins) if n]\n logs = [score - sum((n * g[3][i] for i, n in bins)) - g[0] * self.fl_safe_n + sum((n * g[4][i] for i, n in sbins)) for score, g in zip(self.fl_scores, FLOW_GRID)]\n mx = max(logs)\n weights = [math.exp(v - mx) for v in logs]\n den = sum(weights)\n self.fl_dirty = False\n self.fl_rate = sum((w * g[0] * g[1] for w, g in zip(weights, FLOW_GRID))) / den\n self.fl_r = sum((w * g[0] for w, g in zip(weights, FLOW_GRID))) / den\n self.fl_m = sum((w * g[1] for w, g in zip(weights, FLOW_GRID))) / den\n s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n jp = [(cdf((Z + n * 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 if self.s == 1:\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 elif self.s == 2:\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 elif self.s == 3:\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 elif self.s == 4:\n ja = jb = 0.0\n for p, w in jp:\n if x > p:\n ja += w * (x - p)\n else:\n jb += w * (p - x)\n return ((1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb)\n if H == 1:\n\n def AB(x):\n return ((1 - phat) * x, phat * (1 - x))\n rho = 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 if self.s == 1:\n\n def qsize(loss, gain, px, flow=False, cap=None):\n loss *= kA\n if gain <= 0:\n return 0.0\n rr = 0.125 + 0.5 * (self.fl_r - 0.125) if flow and FL else rho\n mm = math.log(5.0 + 0.5 * (self.fl_m - 5.0)) - 0.5 * P['sig_n'] ** 2 if flow and FL else mu\n tail = loss / (rr * gain)\n if tail >= 1.0:\n return 0.0\n return min(cap if cap is not None else P['qmax'], math.exp(mm + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n elif self.s == 2:\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-06))) / px)\n elif self.s == 3:\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-06))) / px)\n elif self.s == 4:\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 if tail <= 1e-06:\n return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\n return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n ptk = phat * 100\n\n def qbid(t):\n if not 1 <= t <= 99:\n return 0.0\n if self.s == 4:\n if phat * 100 - t < P['dmin']:\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 if self.s == 4:\n if t - phat * 100 < P['dmin']:\n return 0.0\n a, b = AB(t / 100.0)\n if t - phat * 100 < P['dmin']:\n return 0.0\n if self.s == 1:\n return qsize(b, a, t / 100.0, flow=True, cap=15000 if AH and t == 2 and (phat < 0.01) else None)\n elif self.s == 2:\n return qsize(b, a, t / 100.0)\n elif self.s == 3:\n return qsize(b, a, t / 100.0)\n elif self.s == 4:\n if P['pL'] <= phat <= 0.95:\n b *= 1.4\n tail = b * kA / max(self.f4_rate * a, 1e-30)\n if a <= 0 or tail >= 1.0:\n return 0.0\n return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-06 else inv(1 - tail))) / (t / 100.0))\n return qsize(b, a, t / 100.0)\n own = [o for o in state.own_orders if o.order_id not in self.jids] if self.jids else state.own_orders\n bids = [o for o in own if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-09]\n asks = [o for o in own if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-09]\n sticky = P['sticky'] > 0\n if self.s == 4:\n ma_ask = 50.0 if self.s == 4 and phat < 0.05 else P['min_ahead']\n\n def top(orders, comp, step):\n if self.s == 1:\n if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (PROBE + 0.01 if QB and step == 1 else P['min_ahead']):\n return comp\n elif self.s == 2:\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'] if self.s != 2 else max(P['min_ahead'], 400.0 / max(comp, 1))):\n return comp\n elif self.s == 3:\n threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and (1 <= comp <= 5) else P['min_ahead']\n if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= threshold:\n return comp\n elif self.s == 4:\n if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (ma_ask if step < 0 else 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 = qbid(bid_t)\n if self.s == 2:\n s2f = self.s == 2 and bid_t == cb and (qb > 0) and (cb / 100.0 < phat)\n elif self.s == 4:\n if phat < 0.05 and bid_t >= 2:\n qb *= 0.5\n qa = qask(ask_t)\n if self.s == 1:\n if ask_t == 2 and ask_t < ca and (phat < 0.01):\n qa *= 5\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\n ptick = phat * 100\n if self.s == 1:\n flow_scale = max(0.4, min(1.9, 1.0 + 0.5 * (self.fl_rate / 0.568734 - 1))) if FL else 1.0\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 if self.s == 1:\n target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n elif self.s == 2:\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 elif self.s == 3:\n flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n target = min(target, qa)\n full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n elif self.s == 4:\n flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n full = min(flow_scale * 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-09))))\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))\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))\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 if self.s == 1:\n stock_rate = flow_scale * P['ydf1']\n elif self.s == 2:\n stock_rate = P['ydf1']\n flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n scale = max(0.5, min(2.0, flow / P['flow_level']))\n stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n elif self.s == 3:\n stock_rate = P['ydf1']\n flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n scale = max(0.5, min(2.0, flow / P['flow_level']))\n stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n elif self.s == 4:\n stock_rate = P['ydf1']\n stock_rate *= self.f4_flow / 0.6\n q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n if 0.02 < phat < 0.1:\n ct = max(2, min(99, int(math.floor(ptick))))\n wealth = state.cash + Y * phat\n if self.s == 1:\n goal = min(flow_scale * qa, 0.3 * max(wealth, 0.0) / phat)\n elif self.s == 2:\n goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n elif self.s == 3:\n goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n elif self.s == 4:\n goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n if Y < goal and ct < ask_t:\n amt, qam = (ct, min(3000.0, goal - Y))\n if self.s == 1:\n if SB and 2 <= amt <= 5:\n amt, qam = (0, 0.0)\n actions = []\n free = state.free_cash - 2.0\n keep_ask = 0.0\n new_b = []\n new_a = []\n\n def cancel(o):\n nonlocal free\n actions.append(CancelOrder(o.order_id))\n x = o.price_ticks / 100.0\n if o.side is Side.BUY:\n free += x * o.remaining_quantity\n else:\n free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n self.ahead.discard(o.order_id)\n self.res.pop(o.order_id, None)\n for o in own:\n if o.remaining_quantity <= PROBE + 1e-09:\n cancel(o)\n kept_ids = set()\n\n def manage(orders, t, q, comp):\n kept = 0.0\n if self.s == 1:\n banked = {}\n bound_t, bound_q = (t, q)\n elif self.s == 2:\n buy = comp == cb\n held = {}\n for o in orders:\n x = o.price_ticks\n gain = ptk - x if buy else x - ptk\n if x == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (x == comp and o.order_id in self.ahead and (ptk <= 10.0) and (gain >= 0.0))):\n kept += o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n if x == comp and x != t and (o.order_id in self.ahead) and (gain >= 1.0):\n if x not in held:\n held[x] = [0.0, qbid(x) if buy else qask(x)]\n h = held[x]\n if h[0] + o.remaining_quantity <= max(h[1], 1.0) and h[1] > 0:\n h[0] += o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n cancel(o)\n return kept\n for o in orders:\n if self.s == 1:\n ah = o.order_id in self.ahead\n if AH and ah and (o.remaining_quantity >= P['min_ahead']) and (o.price_ticks != t):\n if o.side is Side.SELL and o.price_ticks > t or (o.side is Side.BUY and o.price_ticks < t):\n enough = bound_q > 0 and (o.remaining_quantity <= bound_q if o.side is Side.BUY else o.remaining_quantity * o.price_ticks <= min(bound_q, P['qmax']) * bound_t)\n if enough:\n kept_ids.add(o.order_id)\n continue\n if o.price_ticks == bound_t:\n capacity = bound_q\n else:\n capacity = qask(o.price_ticks) if o.side is Side.SELL else qbid(o.price_ticks)\n bound_t, bound_q = (o.price_ticks, capacity)\n if capacity > 0 and o.remaining_quantity <= max(capacity, 1.0):\n kept_ids.add(o.order_id)\n continue\n if QB and ah and (o.side is Side.BUY) and (o.price_ticks < t) and (banked.get(o.price_ticks, 0.0) + o.remaining_quantity <= P['keep_hi'] * qbid(o.price_ticks)):\n banked[o.price_ticks] = banked.get(o.price_ticks, 0.0) + o.remaining_quantity\n kept_ids.add(o.order_id)\n continue\n khi = 10.0 if AH and ah else P['keep_hi']\n if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * khi, 1.0) or (s1 and ah and (o.side is Side.SELL) and (o.price_ticks <= 2)) or (LK and ah) or (QB and ah and (o.side is Side.BUY) and (o.price_ticks == comp))):\n kept += o.remaining_quantity\n kept_ids.add(o.order_id)\n else:\n cancel(o)\n elif self.s == 2:\n if 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 elif self.s == 3:\n if 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 elif self.s == 4:\n if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * (3.0 if self.s == 4 and o.side is Side.SELL and (o.order_id in self.ahead) and (o.price_ticks == comp) else 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 if self.s == 1:\n kb = manage(bids, bid_t, qb, cb)\n elif self.s == 2:\n if s2f and 1:\n kb = 0.0\n for o in bids:\n if o.price_ticks == bid_t and o.order_id in self.ahead:\n kb += o.remaining_quantity\n kept_ids.add(o.order_id)\n else:\n cancel(o)\n elif 1 and bid_t == cb + 1:\n qf = qbid(cb) if 1 else 1.0\n fr = [o for o in bids if o.price_ticks == cb and o.order_id in self.ahead and (cb / 100.0 < phat - 0.0) and (qf > 0)]\n for o in fr:\n kept_ids.add(o.order_id)\n kb = manage([o for o in bids if o not in fr], bid_t, qb, cb)\n else:\n kb = manage(bids, bid_t, qb, cb)\n elif self.s == 3:\n kb = manage(bids, bid_t, qb, cb)\n elif self.s == 4:\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 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-06\n if amt and qam >= 0.01:\n q = fl(qam)\n if self.s == 1:\n if QB:\n oid = self._oid('m')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n if amt > cb:\n self.ahead.add(oid)\n else:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n elif self.s == 2:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n elif self.s == 3:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n elif self.s == 4:\n out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n free -= q * amt / 100.0 + 1e-06\n if bid_t >= 1 and add_b >= 0.01:\n q = fl(add_b)\n if self.s == 4:\n total_q = q\n if ca <= 99 and bid_t > cb and (bid_t == ca - 4) and (q >= 4.0) and (q * bid_t / 100 >= 4 * P['m']):\n head = fl(q / 2)\n oid = self._oid('b')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=head, client_order_id=oid))\n self.ahead.add(oid)\n q = fl(q - head)\n oid = self._oid('b')\n out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n if self.s == 1:\n free -= q * bid_t / 100.0 + 1e-06\n elif self.s == 2:\n free -= q * bid_t / 100.0 + 1e-06\n elif self.s == 3:\n free -= q * bid_t / 100.0 + 1e-06\n elif self.s == 4:\n free -= total_q * bid_t / 100.0 + 1e-06\n if bid_t > cb:\n self.ahead.add(oid)\n if ask_t <= 99 and add_a >= 0.01:\n x = ask_t / 100.0\n covk = sum((o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity) for o in asks if o.order_id in kept_ids))\n cov = max(0.0, Y - covk - 0.1)\n unc = max(0.0, add_a - cov)\n if unc > 0:\n ub = max(0.0, free - (1 - 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 unc = min(unc, ub / (1 - x))\n q = fl(min(add_a, cov + unc))\n if q >= 0.01:\n oid = self._oid('a')\n out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n r = max(0.0, q - cov)\n self.res[oid] = r\n free -= r * (1 - x) + 1e-06\n if ask_t < ca:\n self.ahead.add(oid)\n f = int(math.floor(ptick + 1e-09))\n r = max(int(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 jact = []\n jout = []\n if self.s == 1:\n live_j = {o.order_id: o for o in state.own_orders if o.order_id in self.jids}\n self.jids.intersection_update(live_j)\n on = JLO <= phat <= JHI\n jfree = P['fb'] * max(free, 0.0)\n ycommit = sum((o.remaining_quantity for o in state.own_orders if o.side is Side.SELL and o.order_id in kept_ids)) + sum((o.quantity for o in out if o.side is Side.SELL))\n for side, tick in ((Side.BUY, cb), (Side.SELL, ca)):\n q = 0.0\n if on and 1 <= tick <= 99:\n x = tick / 100.0\n q = qbid(tick) if side is Side.BUY else qask(tick)\n q = min(q, JCAP * JNOT / x)\n kept = 0.0\n for o in live_j.values():\n if o.side is not side:\n continue\n if q > 0 and o.price_ticks == tick and o.remaining_quantity > PROBE + 1e-09 and kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0):\n kept += o.remaining_quantity\n if side is Side.SELL:\n ycommit += o.remaining_quantity\n else:\n jact.append(CancelOrder(o.order_id))\n self.jids.discard(o.order_id)\n if q <= 0 or kept >= q * P['keep_lo']:\n continue\n add = q - kept\n if side is Side.BUY:\n add = min(add, jfree / x)\n need = add * x\n else:\n cov = max(0.0, Y - ycommit - 0.1)\n unc = min(max(0.0, add - cov), jfree / (1 - x))\n add = min(add, cov + unc)\n need = max(0.0, add - cov) * (1 - x)\n ycommit += add\n add = fl(add)\n if add >= 0.01:\n oid = self._oid('j')\n jout.append(PlaceOrder(side=side, price_ticks=tick, quantity=add, client_order_id=oid))\n self.jids.add(oid)\n jfree -= need + 1e-06\n if self.s == 1:\n if FL:\n if not kept_ids and (not any((o.quantity > PROBE for o in out))):\n self.fl_obs = ()\n self.fl_ahead.clear()\n return actions + jact + out + jout\n for i, o in enumerate(out):\n if o.client_order_id is None and o.quantity > PROBE:\n out[i] = PlaceOrder(side=o.side, price_ticks=o.price_ticks, quantity=o.quantity, client_order_id=self._oid('f'))\n live = []\n oldids = {o.order_id for o in state.own_orders if o.order_id in kept_ids}\n self.fl_ahead.intersection_update(oldids)\n for o in state.own_orders:\n if o.order_id in kept_ids and o.remaining_quantity > PROBE:\n live.append((o.side, o.price_ticks, o.remaining_quantity, o.order_id))\n for o in out:\n if o.quantity > PROBE:\n live.append((o.side, o.price_ticks, o.quantity, o.client_order_id))\n if o.side is Side.SELL and o.price_ticks < ca or (o.side is Side.BUY and o.price_ticks > cb):\n self.fl_ahead.add(o.client_order_id)\n obs = []\n for buying, side, comp in ((True, Side.SELL, ca), (False, Side.BUY, cb)):\n orders = [o for o in live if o[0] is side]\n if not orders:\n continue\n tick = min((o[1] for o in orders)) if buying else max((o[1] for o in orders))\n orders = [o for o in orders if o[1] == tick]\n if not all((o[3] in self.fl_ahead for o in orders)):\n continue\n if buying and tick > comp or (not buying and tick < comp):\n continue\n px = tick / 100.0 if buying else max(phat, 0.05)\n cap = sum((o[2] for o in orders)) * px\n if cap < 0.04:\n continue\n ci = 0\n while ci + 1 < len(FLOW_CAPS) and FLOW_CAPS[ci + 1] < cap - 0.01:\n ci += 1\n obs.append((px, ci, buying, [(o[3], o[2]) for o in orders], tick))\n self.fl_obs = obs\n elif self.s == 2:\n self.last_ask_tick = ask_t\n self.last_flow_ca = ca\n exposed_qty = ka + sum((o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and (o.quantity > PROBE)))\n self.last_flow_cap = exposed_qty * ask_t / 100.0\n self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n if self.last_quote_exposed:\n logcap = math.log(self.last_flow_cap)\n mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n elif self.s == 3:\n self.last_ask_tick = ask_t\n self.last_flow_ca = ca\n exposed_qty = ka + sum((o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and (o.quantity > PROBE)))\n self.last_flow_cap = exposed_qty * ask_t / 100.0\n self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n if self.last_quote_exposed:\n logcap = math.log(self.last_flow_cap)\n mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n elif self.s == 4:\n self.f4_last = [None, None]\n for side, tick, bound, conv, distance in ((0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat), (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n if distance < max(0.01, 3.0 * self.st / 100.0):\n continue\n if side == 0:\n if not (ask_t < ca or any((o.price_ticks == ask_t and o.order_id in self.ahead for o in asks))):\n continue\n orders = asks\n order_side = Side.SELL\n else:\n if not (bid_t > cb or any((o.price_ticks == bid_t and o.order_id in self.ahead for o in bids))):\n continue\n if qam > 0 and amt >= bid_t or (q1 > 0 and bid_t <= 1):\n continue\n orders = bids\n order_side = Side.BUY\n tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and (o.client_order_id is not None)})\n cap = sum(tracked.values()) * conv\n if cap >= 0.5:\n self.f4_last[side] = (tick, conv, cap, bound, tracked)\n return actions + jact + out + jout\n", "code_sha256": "36cbe4f38762144c0edadc241709034607de076ed56b65f9f51f838a2e084b20", "incumbent_code_sha256": "bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae", "target_spreads": [ 1 ], "tuning": { "seeds": "320000..320199", "selected": "cap_0.1x", "variants": [ { "name": "cap_1x", "code_sha256": "8de396c2f084d256fbe3176a9636ae4d6f8c72aa5ed929f7d261a06e2ec52307", "mean_diff": -2.183827, "se": 0.323431, "n": 200, "spread1_mean_diff": -8.735309, "spread1_se": 0.72897 }, { "name": "cap_0.5x", "code_sha256": "bf29a8e02a42d4264f3ae0e8a4b0f5929b59f2e26da242981b0adaec38cd95d4", "mean_diff": -2.183827, "se": 0.323431, "n": 200, "spread1_mean_diff": -8.735309, "spread1_se": 0.72897 }, { "name": "cap_0.1x", "code_sha256": "36cbe4f38762144c0edadc241709034607de076ed56b65f9f51f838a2e084b20", "mean_diff": -1.454834, "se": 0.221554, "n": 200, "spread1_mean_diff": -5.819338, "spread1_se": 0.528264 } ], "note": "cap_1x and cap_0.5x gave identical runs: N's qbid/qask at the rival ticks never reached 24/price, so neither cap bound. cap_0.1x (4.8/price) was added as the third allowed variant because it does bind. It was selected and frozen as the least negative variant on tuning." }, "paired": { "seeds": "430000..430499", "n": 500, "complete": true, "missing_seeds": [], "overall": { "n": 500, "sum_d": -754.954835, "sum_d2": 7416.614781, "mean_diff": -1.50991, "se": 0.15861, "incumbent_mean": 95.542015, "candidate_mean": 94.032105, "retail_diff": 0.039503, "arb_diff": -1.549413 }, "by_spread": { "1": { "n": 131, "sum_d": -754.954835, "sum_d2": 7416.614781, "mean_diff": -5.763014, "se": 0.424292, "incumbent_mean": 38.277937, "candidate_mean": 32.514923, "retail_diff": 0.150777, "arb_diff": -5.913791 }, "2": { "n": 120, "sum_d": 0.0, "sum_d2": 0.0, "mean_diff": 0.0, "se": 0.0, "incumbent_mean": 77.855864, "candidate_mean": 77.855864, "retail_diff": 0.0, "arb_diff": 0.0 }, "3": { "n": 133, "sum_d": 0.0, "sum_d2": 0.0, "mean_diff": 0.0, "se": 0.0, "incumbent_mean": 146.551404, "candidate_mean": 146.551404, "retail_diff": 0.0, "arb_diff": 0.0 }, "4": { "n": 116, "sum_d": 0.0, "sum_d2": 0.0, "mean_diff": 0.0, "se": 0.0, "incumbent_mean": 120.022047, "candidate_mean": 120.022047, "retail_diff": 0.0, "arb_diff": 0.0 } } }, "failures": [], "check_values": { "310000": 17.116002, "310001": 20.017111, "310002": 2.390311, "310003": 241.484752 }, "python_version": "3.12.3", "seconds_per_simulation": 0.494, "notes": "Spread is classified by N's self.s, read from the rival's spread on the first step. Off-target seeds (s=2..4) gave d exactly 0. The rival's displayed size is not part of StepState, so 'capped at the rival's displayed size' was implemented as JCAP x 48/price, the expected size given the sampled notional range 24..72. Runs: unmodified simulator at b244530, default ChallengeConfig and ParameterVariance, sample_config(seed), SimulationEngine(config, Strategy, seed).run() once per (seed, strategy). Each strategy ran in its own serial process, with no --workers and no --sandbox." }