# Sizing from the record Every trade here has a stop and a target, and every finished trade is written up from the venue's own fills. That makes two things possible that a trading agent usually cannot do honestly: measure what the desk's trades actually return, in the same units every time, and let that measurement lower the risk the next trade takes. No model is involved. The arithmetic below is all of it, and `tra sizing` prints it for your desk. It is off until you turn it on, and once on it can only lower the risk you declared in `[controls].max_risk_per_trade_bps`, never raise it. ```toml [sizing] kelly_fraction = 0.25 # a quarter of the Kelly fraction; turning this on is what enables it # min_round_trips = 30 # finished trades before the record decides anything # lookback_round_trips = 100 # only the newest trades count # simulate_trades = 100 # how far ahead the drawdown is simulated, 10 to 300 # simulate_paths = 2000 # 100 to 5000, so a cycle waits seconds at most # seed = 20261021 # the same seed gives the same figures on any machine # max_drawdown_probability = 0.05 ``` ## The unit: what the trade planned to lose When a cycle writes an intent, it also writes `loss_at_stop_bps`: the distance from the price to the stop plus the round trip it pays, in basis points of the notional. That is what the trade loses if the stop is hit as priced. When the trade finishes, its net result is divided by that figure and written on the round trip as `r`. A stop hit as priced is about -1. A target twice as far as the stop is about +2 less the cost. A time exit lands wherever it lands. `r` is price and fees, like `net`; funding is recorded beside it as the venue reports it, because venues sign it differently. Reading results in planned losses makes trades of different sizes, instruments and stop distances comparable, and it is the unit the risk limit is already in: risking 50 bps at the stop and getting `r = -1` costs the account 50 bps. ## Kelly from the record From the newest `lookback_round_trips` trades with an `r`, three figures: the share that won (p), the share that lost (q), and the average win and loss in planned losses (W and L). A trade that closed flat counts in neither. The fraction of equity to lose on a losing trade that maximises long-run growth is then: ``` f* = (p * W - q * L) / ((p + q) * W * L) ``` With every trade a win or a loss this is the familiar `p / L - q / W`. As arithmetic only: half the trades winning 2 and half losing 1 gives `f* = (0.5 * 2 - 0.5 * 1) / 2 = 0.25`, a quarter of equity at the stop. Nobody should bet that, and the record does not ask you to: - **Only `kelly_fraction` of it is applied.** p, W and L are estimates from a few dozen trades, and full Kelly on an overstated edge loses accounts. A quarter is a common choice; 0.25 of 0.25 is 625 bps. - **It is a ceiling.** The risk a cycle uses is the smaller of this and your declared `max_risk_per_trade_bps`. With 50 bps declared, the ceiling above changes nothing. - **Too few trades decide nothing.** Below `min_round_trips` the declared risk stands, and the cycle records how many trades the record holds. - **No edge refuses.** With enough trades, an f* at or below zero means the record supports no bet, and the cycle refuses new entries with the figures behind it. The same when none of the trades won. A person decides what happens next; lowering or removing `[sizing]` is a configuration change. Beside f*, the record also gives the win rate it supports at 95% confidence (the lower Wilson bound), so you can see how much of the win rate is the sample. ## The drawdown ahead: a seeded Monte Carlo Kelly is about the average. The path matters too, and `[controls].max_drawdown_bps` is where the desk stops taking entries. So the cycle also asks: at this risk per trade, how likely is the desk to fall through the room it has left under that limit in the next `simulate_trades` trades? It answers by resampling. It draws `simulate_trades` results, with replacement, from the same trades the Kelly figures came from, compounds them at the risk being tested, and repeats that `simulate_paths` times. The share of paths whose drawdown reaches the room left is the chance it reports. If the Kelly ceiling keeps that chance within `max_drawdown_probability`, it stands; otherwise the risk is lowered, by bisection to a hundredth of a basis point, to the largest value that does. The room is your limit minus the drawdown the account already has from its highest equity, read at the start of the cycle, in whole basis points rounded down. It is repeatable to the digit: - the draws come from a generator seeded with `seed`, and the same draws are reused at every risk level tried; - the draws are integers taken from the generator's own numbers, so nothing depends on how a Python version implements random choice; - percentiles are nearest-rank in integer arithmetic. The same record, settings and seed give the same answer on any machine, and the cycle writes the seed, the paths, the risk and the figures into its record, so anyone can run it again. Each answer is also kept in memory, so a desk asking the same question every cycle does not simulate it again. What it is not: a forecast. Resampling assumes the next trades look like the last ones. It is a check on how hard the recent record could push the account at a given risk, which is the question a drawdown limit is there to answer. ## Excursions, measured by the system Every round trip that closes in venue mode now also carries how far it went for and against the position before it closed, read from the venue's own candles over the hold. The finest candles that cover the hold in at most 1000 bars are used, one minute for most holds. | Field | What it is | |---|---| | `mfe_bps` | the best the position stood at, in bps of the entry, positive when it was in front | | `mae_bps` | the worst, negative when it was under water | | `bars_to_mfe`, `bars_to_mae` | on which bar each happened | | `mae_of_stop` | the worst as a share of the stop distance: 0.9 is a stop that nearly fired | | `mfe_of_take` | the best as a share of the target distance: over 1 is a target that was reached | | `timeframe`, `complete` | the candles read, and whether they covered the whole hold | The first and the last bar can include prices from just before the entry and just after the exit, which is why the finest candles are used. The quant auditor and the risk manager read these figures; they no longer have to infer the shape of a trade from its result. ## Where it shows | Where | What | |---|---| | the cycle record, `sizing` in `cycle.json` | the rule, the measured figures, f*, the ceiling, the simulation and why | | `intents.jsonl` | `loss_at_stop_bps` on every intent | | `round_trips.jsonl` | `loss_at_stop_bps`, `r`, `stop`, `take` and `excursion` on every finished trade | | `tra sizing` | the same calculation the cycle makes, from the records, without changing anything | Trades written before this version have no `loss_at_stop_bps`, so they are not counted: the record starts with the first trade that knows what it planned to lose.