# White Paper #5: Realistic Execution Modeling — Fill-Gap Rescaling --- ## One-line summary When an order intends to fill at price X but actually fills at Y (gap, slippage, partial fill), the stop-loss and take-profit must be rescaled relative to actual fill — not original intent. --- ## The Backtest Reality Gap Most trading backtests assume idealized execution. You intend to buy at $100, you buy at $100. This is false even in equities, catastrophically wrong in futures and crypto. The reality: markets gap. Limit orders fill at different prices than expected. Stops slip through. Take-profits get partial fills. Weekend closes and overnight news create discontinuities that naive backtests ignore. This creates a systematic bias in backtest results: - **Losses are underestimated** (stops slip past intended levels) - **Wins are overestimated** (takes fill fully at exact price) - **Risk is miscalculated** (actual exposure differs from intended) The bias is asymmetric because losses hurt more than wins help. Over time, ignoring execution divergence turns profitable backtests into losing live accounts. --- ## The Intent-vs-Fill Divergence Problem ### Scenario A: Gap-Up Stop You short at $100 with a stop at $101 (1% risk). The market gaps to $101.50 overnight due to news. Your stop fills at $101.50. - **Naive backtest says**: 1% loss - **Reality says**: 1.5% loss The additional 0.5% comes from the gap, not from the trade idea. But it's real money. ### Scenario B: Partial Take-Profit You buy at $100 with a take-profit at $102 (2:1 R/R). The market hits $102 but only fills 60% due to depth. - **Naive backtest says**: Full win recorded, 2R returned - **Reality says**: Partial win, slippage on remaining position, ~1.2R returned The missing 0.8R is not "bad luck" — it's execution cost. ### Scenario C: Limit Order Never Fills You place a limit buy at $99.50. The market never trades at that price. Your order sits unfilled. - **Naive backtest says**: Missed opportunity - **Reality says**: Capital stayed available for other opportunities The opportunity cost matters. Ignoring unfilled orders overstates capital efficiency. These divergences compound across thousands of trades. A system that looks profitable on paper may lose 20-30% to execution costs in live trading. --- ## The Rescaling Solution When actual fill price diverges from intent, we preserve the risk geometry: ``` # Original intent entry_intent = $100 stop_intent = $98 (2% below) tp_intent = $104 (4% above) stop_dist = $2 tp_dist = $4 # Actual fill entry_actual = $101 (gap up at open) # Rescaled levels stop_actual = entry_actual - stop_dist = $99 tp_actual = entry_actual + tp_dist = $105 # Risk maintained at 2% of equity, but entry worse ``` The distances are preserved. The anchor point shifts to actual fill. This maintains the trader's risk parameters while acknowledging execution reality. This is implemented in `backtest_harness_laguna/internal/brain_driver/driver.go` in `ProcessPendingOrders`. --- ## Worked Example: 0.5% Gap-Open Scenario ### Market Conditions - Symbol: BTCUSDT - Bar close: $60,000 (short signal triggered) - Bar open: $60,300 (0.5% gap up, adverse for shorts) - Stop intended at: $60,600 (1% above entry) - TP intended at: $59,400 (1% below entry) ### Naive Backtest ``` Entry: $60,000 Stop: $60,600 (hit, full fill) PnL: -$600 (loss) ``` The system "paid" 1R for being wrong about timing. ### Realistic Backtest (Fill-Gap Rescaling) ``` Entry intent: $60,000 Entry actual: $60,300 (market order fills at open) Stop intent distance: $600 Stop rescaled: $60,300 + $600 = $60,900 TP rescaled: $60,300 - $600 = $59,700 Result: Position worse than expected Risk: Maintained at original 1% of equity PnL: -$630 (loss) + slippage on any exit ``` The rescaling preserves the trader's intent while acknowledging execution reality. The position is worse, but the risk parameters are maintained. --- ## Implementation Detail: IntentPrice Field The `Order` struct in the backtest driver includes: ```go type Order struct { ID string Symbol string Side "BUY" | "SELL" IntentPrice float64 // What we expected to fill ActualPrice float64 // What we actually got StopLoss float64 // Rescaled from ActualPrice TakeProfit float64 // Rescaled from ActualPrice Status string } ``` When `ActualPrice != IntentPrice`, the `ProcessPendingOrders` function rescales stops and targets: ```go func (o *Order) RescaleFromFill(actualPrice float64) { distToStop = o.IntentPrice - o.StopLoss distToTP = o.TakeProfit - o.IntentPrice o.StopLoss = actualPrice - distToStop o.TakeProfit = actualPrice + distToTP } ``` This ensures risk geometry is preserved regardless of execution divergence. --- ## Why This Matters for Credibility 99% of trading harnesses ignore execution divergence. This is not because they're wrong about everything else — it's because execution is the hardest part to model. By exposing and correcting fill-gap rescaling, we demonstrate: 1. **Methodological seriousness** — We care about real-world fidelity, not idealized backtests 2. **Structural honesty** — The code shows exactly how we handle execution divergence 3. **Risk clarity** — Actual risk differs from naive expectations; we account for this This is a trust signal that doesn't reveal strategy. The rescaling math is generic. Everyone should do this. Almost no one does. --- ## The Broader Pattern Fill-gap rescaling joins other realism features in our backtest harness: - **Slippage modeling** on market orders (0.1% default) - **Partial fill simulation** at key levels (depth-dependent) - **Stale price entry prevention** via Freshness Guard (45s timeout) - **Regime-aware throttling** based on volatility Each feature degrades naive performance while improving real-world correlation. The system earns its track record honestly. The pattern is intentional: we prefer honest losses to dishonest wins. A system that loses $100 in backtest because it respects execution costs will not surprise you with hidden losses in live trading. --- ## Implementation Status Live in production backtest harness since commit `e186f1e3`. Observe in logs: ``` Order BTCUSDT-1234: intent=60000, actual=60300, stop_rescaled=60900, tp_rescaled=59700 ``` The IntentPrice field ensures every execution divergence is visible. No hidden model error. You can audit every order's entry condition versus its actual fill. The rescaling logic is straightforward enough to verify: distances are preserved, anchors shift to actual. No hidden complexity. --- ## What This Enables The fill-gap rescaling mechanism enables: 1. **Trust without secrecy** — Users know how execution is modeled 2. **Honest performance estimates** — Backtest PnL is closer to live PnL 3. **Risk parameter preservation** — Stops and targets maintain intent 4. **Debugging capability** — Execution divergences are logged explicitly This is the detail work that separates serious trading infrastructure from marketing demos. It's not flashy. It's not secret. It's correct.