{ "approach": "The Paradigm-priced spread-1 block (5x ask at tick 2 under 1 cent ahead of the rival, front asks kept), plus three pieces each built on the base and joined behind switches that are live only when self.s == 1: s1-flow (per-run retail flow estimate from own partial fills of front-of-queue quotes; scales ask sizing rate/size and stock targets), q1-ahead (tick-2 ask cap 15000 under 1 cent, keeps ahead orders at safer prices while still within their optimal size, keep_hi x10 for ahead orders), q1-bids (bid lead sticks once ahead with any size, keeps ahead bids banked at lower ticks, stock bids tracked as ahead). The keep rules of all three and the priced block are OR-ed in one order manager. Pieces were added greedily in the order of their pair gains, each measured run by run on the 2016 choosing runs of spread 1 against the file before it; q1-life and s1-bids were left out.", "blocked": null, "spread": 1, "base_mean_edge": 108.63974289615767, "contains": [ "priced spread-1 block", "s1-flow", "q1-ahead", "q1-bids" ], "holdout": { "mean_edge": 35.08133313458728, "retail_edge": 58.121835025434635, "arb_edge": -23.040501890846127, "failures": 0 }, "diff": { "mean": 2.5414027248259132, "standard_error": 0.3917162243225099, "retail": 2.4835917405638086, "arb": 0.057810984265221715 }, "vs_priced": { "mean": 1.235023171864296, "standard_error": 0.2813482609549018 }, "others_identical": { "runs": 900, "identical": true }, "seconds": { "base": 63.8, "yours": 66.3 }, "code": "\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\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)\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\nF_AH = 1\nF_FL = 1\nF_QB = 1\nF_LK = 0\nF_SB = 0\n\n# s1-flow: conditional likelihood of partial fills and zeros. Fully exhausted quotes\n# can be either retail or arbitrage; neither is treated as a zero or a\n# complete retail order. Truncation normalization corrects the selection.\nFLOW_CAPS = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.)\nFLOW_GRID = []\nFLOW_PRIORS=[]\nfor _rn,_rw in ((-math.sqrt(0.6),5/18),(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.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\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 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 = P.copy()\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\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 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 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 if self.s == 3 and 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 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 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 else:\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 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=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\n s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\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, 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-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 return qsize(b, a, t / 100.0, flow=True, cap=(15000 if AH and t == 2 and phat < 0.01 else None))\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) >= (PROBE + 0.01 if QB and step == 1 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 qa = qask(ask_t)\n if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n qa *= 5\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 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 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-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 stock_rate = flow_scale * P['ydf1']\n if self.s == 3:\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 q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n\n # Bridge expected retail demand until another tick crossing is available.\n if 0.02 < phat < 0.1:\n ct = max(2, min(99, int(math.floor(ptick))))\n wealth = state.cash + Y * phat\n goal = min(flow_scale * 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 SB and 2 <= amt <= 5:\n amt, qam = 0, 0.0\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 banked = {}\n bound_t, bound_q = t, q\n for o in orders:\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 (\n o.remaining_quantity <= bound_q if o.side is Side.BUY else\n 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)\n or (s1 and ah and (o.side is Side.SELL) and o.price_ticks <= 2)\n or (LK and ah)\n 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 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 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 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 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 if 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 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+out\n # Give stock orders explicit ids so per-order remaining quantities\n # separate their fills from other bid levels and tiny probes.\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_tickscb):\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