{ "approach": "Stack step 1 only: took demand-fit's file (base's parent plus demand-inferred YES stock sizing q1) and grafted onto it the base's single addition, the crossing-cover bid at floor(100p) for 0.02 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\n def _oid(self, tag):\n self.n += 1\n return tag + str(self.n)\n\n def _demand_update(self, state):\n if self.dprev is None:\n return\n tick, prev, cutoff = self.dprev\n now = {o.order_id:o.remaining_quantity for o in state.own_orders}\n # One surviving order proves the arbitrageur did not sweep this tick.\n if not any(oid in now for oid in prev):\n return\n spent = sum(q-now.get(oid,0.0) for oid,q in prev.items())*tick/100.0\n k = 0\n while k < len(DEMAND_BINS) and spent >= DEMAND_BINS[k]:\n k += 1\n if k > cutoff:\n return\n for j, table in enumerate(DEMAND_LOG):\n self.dpost[j] += table[cutoff][k]\n self.dcount += 1\n if self.dcount % 16 == 0:\n mx = max(self.dpost)\n weights = [math.exp(v-mx) for v in self.dpost]\n z = sum(weights)\n self.dflow = sum(w*f for w,f in zip(weights,DEMAND_FLOW))/z\n self.drate = sum(w*DEMAND_RATE[j//len(DEMAND_MEAN)] for j,w in enumerate(weights))/z\n self.dmean = self.dflow/self.drate\n self.dcdf = [sum(w*row[i] for w,row in zip(weights,DEMAND_CDF))/z for i in range(len(DEMAND_BINS))]\n self.dvar = max(0.0,sum(w*f*f for w,f in zip(weights,DEMAND_FLOW))/z-self.dflow*self.dflow)\n self.dm2 = sum(w*DEMAND_FLOW[j]*DEMAND_MEAN[j%len(DEMAND_MEAN)]*math.exp(1.44) for j,w in enumerate(weights))/z\n\n def _demand_snapshot(self, state, actions):\n remaining = {o.order_id:(o.price_ticks,o.remaining_quantity) for o in state.own_orders\n if o.side is Side.SELL and o.order_id in self.ahead}\n for a in actions:\n if isinstance(a, CancelOrder):\n remaining.pop(a.order_id,None)\n elif isinstance(a, PlaceOrder) and a.side is Side.SELL and a.client_order_id in self.ahead:\n remaining[a.client_order_id] = (a.price_ticks,a.quantity)\n self.dprev = None\n if remaining:\n tick = min(v[0] for v in remaining.values())\n front = {oid:q for oid,(t,q) in remaining.items() if t==tick}\n cap = sum(front.values())*tick/100.0\n k = -1\n for i,b in enumerate(DEMAND_BINS):\n if b < cap-.01*tick/100.0:\n k = i\n if k >= 0:\n self.dprev = (tick,front,k)\n\n def on_step(self, state):\n self._demand_update(state)\n ask_prev = self.dprev\n # A surviving ask certifies p <= .05; then SELL share conversion\n # is exactly .05, independent of the filtered probability estimate.\n if any(o.side is Side.SELL and o.price_ticks <= 5 for o in state.own_orders):\n self.dprev = self.dbprev\n self._demand_update(state)\n self.dprev = ask_prev\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 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 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 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):\n # Marginal fill probability is the posterior compound-Poisson\n # tail of TOTAL step notional, including zero/multiple arrivals.\n loss *= kA\n if gain <= 0.0:\n return 0.0\n tail = max(1e-12,loss/gain)\n if tail >= 1.0-self.dcdf[0]:\n return 0.0\n for i in range(1,len(DEMAND_BINS)):\n high = max(1e-14,1.0-self.dcdf[i-1])\n low = max(1e-14,1.0-self.dcdf[i])\n if tail >= low:\n weight = (math.log(high)-math.log(tail))/max(1e-12,math.log(high)-math.log(low))\n notional = DEMAND_BINS[i-1]*(DEMAND_BINS[i]/DEMAND_BINS[i-1])**min(1.,max(0.,weight))\n return min(P['qmax'],notional/px)\n # Beyond the tabulated range use the single-large-order tail,\n # rather than treating an unbounded demand quantile as qmax.\n conditional = max(1e-6,min(.999999,tail/max(self.drate,1e-9)))\n notional = math.exp(math.log(self.dmean)-.72+1.2*inv(1.0-conditional))\n return min(P['qmax'],notional/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)\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) >= 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\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(P['ydem'] * min(H, P['W']) / x, capw)\n full = min((.3+.5*self.dflow) * 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 demand_flow = max(D['floor'], self.dflow * D['mult'])\n q1 = 0.0\n if any(o.side is Side.BUY for o in state.own_orders) and P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n q1 = max(0.0, (demand_flow * min(H, D['horizon']) + D['extra'] * math.sqrt(min(H,D['horizon'])*self.dm2 + min(H,D['horizon'])**2*self.dvar)) / (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(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 # 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 for o in orders:\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 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 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 self._demand_snapshot(state, actions + out)\n remaining = {o.order_id:(o.price_ticks,o.remaining_quantity) for o in state.own_orders\n if o.side is Side.BUY and o.order_id in self.ahead}\n for a in actions + out:\n if isinstance(a,CancelOrder):\n remaining.pop(a.order_id,None)\n elif isinstance(a,PlaceOrder) and a.side is Side.BUY and a.client_order_id in self.ahead:\n remaining[a.client_order_id] = (a.price_ticks,a.quantity)\n self.dbprev = None\n if remaining:\n tick = max(v[0] for v in remaining.values())\n # Do not mistake flow left over after anonymous stock bids for\n # complete front-of-book retail flow.\n unknown = any(o.side is Side.BUY and o.price_ticks>=tick and o.remaining_quantity>PROBE+1e-9 and o.order_id not in self.ahead for o in state.own_orders)\n unknown = unknown or (tick==1 and (q1>=.01 or (amt==1 and qam>=.01)))\n front = {oid:q for oid,(t,q) in remaining.items() if t==tick}\n cap = sum(front.values())*.05\n k = -1\n for i,b in enumerate(DEMAND_BINS):\n if b < cap-.0005:\n k=i\n if k>=0 and not unknown:\n self.dbprev = (5.,front,k)\n return actions + out\n", "code_sha256": "2f568c5997204668f46871f2a89c9709412f1d866894a3e869d200e746638781", "tried": [ "scorer check: base on seeds 1000-1599 = 108.63974289615767 (author 108.63974289615767, exact match)", "seconds are 350-run serial wall times scaled to 200 (base 245 s, stack 263 s per 350): stack ~7% slower than base, so it fails the 'no slower' candidate rule as measured", "demand-fit + crossing cover, tuning seeds 4000-4349: mean 113.5947 vs base 113.5232, retail -1.7030, arb +1.7745", "demand-fit + crossing cover, unseen 50000-50349 run by run: +1.2441 +/- 0.8469, retail +0.3377, arb +0.9064, 0 failures" ], "next": "Rerun this exact file on 4000 seeds of each range on a machine with real parallelism; speed up the demand posterior (update every 32 steps or vectorise) to remove the ~7% slowdown; then add the per-spread overrides once the three spread files are named." }