{"approach":"Start with the priced spread-1 block; compare q1-ahead as a replacement of its overlapping tick-2 enlargement/queue policy, then add the supplied s1-flow, q1-bids, q1-life and s1-bids rules in order, retaining only positive paired choosing gains. No constants tuned. Return the frozen choosing winner, which also gains on confirmation. All added trading behavior is gated by self.s == 1. The overlapping tick-2 ask policies are never stacked; inherited arithmetic optimizations are retained. Local unmodified simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e, default 2000-step configurations, fresh strategy per seed, no sandbox. Choosing n=1008; confirming n=1027. Paired SE is sample standard deviation of seedwise edge deltas divided by sqrt(n); arbitrage edge is signed. These are local simulation results, not a Paradigm submission.","blocked":null,"spread":1,"base_mean_edge":108.63974289615767,"contains":["priced","s1-flow","q1-bids","q1-life"],"holdout":{"mean_edge":37.72374342287069,"retail_edge":57.599535839288315,"arb_edge":-19.875792416420058,"failures":0},"diff":{"mean":2.3158657605373905,"standard_error":0.33790506947116516,"retail":1.9363245830365143,"arb":0.37954117750847133},"vs_priced":{"mean":1.172168248613437,"standard_error":0.2650408952050327},"others_identical":{"runs":450,"identical":true},"seconds":{"base":106.87160528847016,"yours":113.64596724743024},"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# 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 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 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 = [(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):\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'] * 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)\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 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 # 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 def manage(orders, t, q, comp):\n kept = 0.0\n banked = {}\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 continue\n if 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.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) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\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