{ "approach": "Started from s1-flow (per-run Bayesian flow estimate from own fills scaling sizes and stock, with dmin guards), added the priced spread-1 block's front-of-queue ask rule (5x ask at tick 2 ahead of rival when phat<1c; front asks <=2 ticks not cancelled), then q1-bids' bid lead (bids ahead of rival kept/banked, stock bids tagged as ahead, looser sticky at step 1), then s1-bids' rule (no stock bids at ticks 2-5). q1-life was tried and dropped (lost). Every change is gated on self.s == 1. Joined by text patching the exact lines each piece changes in its own diff against the base.", "blocked": null, "spread": 1, "base_mean_edge": 108.63974289615767, "contains": [ "s1-flow", "priced spread-1 front rule (q1-ahead family)", "q1-bids", "s1-bids" ], "holdout": { "mean_edge": 42.320043599360666, "retail_edge": 62.59729209684333, "arb_edge": -20.277248497484667, "failures": 0 }, "diff": { "mean": 3.951276983398, "standard_error": 1.512010620337482, "retail": 1.7511890804060009, "arb": 2.2000879029686664 }, "vs_priced": { "mean": 1.0885710578066663, "standard_error": 0.7838365727203974 }, "others_identical": { "runs": 450, "identical": true }, "seconds": { "base": 100.46663093566895, "yours": 107.09078288078308 }, "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\n\n\n\n# 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\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.iv01=inv(0.01)\n self.iv002=inv(0.002)\n self.iv998=inv(0.998)\n self.ivtail=inv(1-1e-6)\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\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 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 exp=math.exp\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 pairs = tuple(zip(self.bc,self.bw)) if self.s==1 else None\n if self.s==1 and len(self.bc)==8:\n c0,c1,c2,c3,c4,c5,c6,c7=self.bc\n w0,w1,w2,w3,w4,w5,w6,w7=self.bw\n for c in cs:\n t=uni\n d=c-c0\n d2=d*d*k\n if d2>-12.5:\n t+=w0*exp(d2)\n d=c-c1\n d2=d*d*k\n if d2>-12.5:\n t+=w1*exp(d2)\n d=c-c2\n d2=d*d*k\n if d2>-12.5:\n t+=w2*exp(d2)\n d=c-c3\n d2=d*d*k\n if d2>-12.5:\n t+=w3*exp(d2)\n d=c-c4\n d2=d*d*k\n if d2>-12.5:\n t+=w4*exp(d2)\n d=c-c5\n d2=d*d*k\n if d2>-12.5:\n t+=w5*exp(d2)\n d=c-c6\n d2=d*d*k\n if d2>-12.5:\n t+=w6*exp(d2)\n d=c-c7\n d2=d*d*k\n if d2>-12.5:\n t+=w7*exp(d2)\n ws.append(t)\n else:\n for c in cs:\n t = uni\n for ci, wi in (pairs if pairs is not None else zip(self.bc, self.bw)):\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * exp(d2)\n ws.append(t)\n\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((self.iv01 if self.s==1 else inv(0.01)) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n z = (self.iv002 if phat==0.002 else self.iv998 if phat==0.998 else inv(phat)) if self.s==1 else 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 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 sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n jp = None if self.s==1 else [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n lj = P['lam_j']\n\n def AB(x):\n nonlocal jp\n if jp is None:\n jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n k = (x - phat) / s\n a = s * lpm(k)\n b = a - (x - phat)\n if self.s==1:\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 else:\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):\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 self.s==1 else rho\n mm = math.log(5.0+0.5*(self.fl_m-5.0))-0.5*P['sig_n']**2 if flow and self.s==1 else mu\n tail = loss / (rr * gain)\n if tail >= 1.0:\n return 0.0\n return min(P['qmax'], math.exp(mm + P['sig_n'] * (self.ivtail if self.s==1 and tail<=1e-6 else 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 if self.s==1 and phat*100-t 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==1 and t-phat*100 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 self.s == 1 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 flow_scale = max(0.4,min(1.9,1.0+0.5*(self.fl_rate/0.568734-1))) if self.s==1 else 1.0\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(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\n # Avoid bulk stock purchases at intermediate low ticks in spread one.\n if self.s == 1 and 2 <= amt <= 5:\n amt, qam = 0, 0.0\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 # 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 banked = {}\n def manage(orders, t, q, comp):\n kept = 0.0\n for o in orders:\n if self.s == 1 and o.side is Side.BUY and o.order_id in self.ahead 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 elif o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead) or (self.s == 1 and o.side is Side.BUY and o.order_id in self.ahead 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 self.s == 1:\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 self.s == 1:\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