Path Dependency

The strategy's internal state is non-Markovian; it depends on the entire history, not just the current observation. Each execution alters the state for the next decision.

• Example: A strategy that buys on a 5% dip must track the peak price since entry, not just the current price.
• Example: A stop-loss that trails the highest high requires storing the running maximum of the price series.
• The backtesting engine must serialize and restore this state precisely at each event boundary.

The sequence in which orders are filled directly impacts the strategy's position and P&L. A partial fill on a limit order changes the remaining quantity, affecting subsequent order placement logic.

• A FIFO queue position in the order book determines if a limit order is filled before or after other resting orders.
• Pro-rata matching can split a single parent order into multiple fills at different prices, each a state transition.
• The simulation must replay the exact matching engine logic of the target exchange.

A decision on one asset is constrained by the capital consumed by prior executions across the entire portfolio. This creates cross-asset path dependency.

• Capital allocation: Buying Asset A reduces the cash available for Asset B, making the sequence of signals critical.
• Risk limits: A Value-at-Risk (VaR) constraint that is breached mid-simulation prevents all subsequent trades until the exposure drops.
• The engine must maintain a global portfolio state object updated atomically after each fill.

Path-dependent strategies demand bit-exact reproducibility. The same historical data and seed must produce the identical equity curve every time.

• The engine must log the exact timestamp and sequence number of every state mutation.
• Random number generators must be seeded and their state checkpointed at each decision point.
• Without deterministic replay, debugging a path-dependent logic error is impossible because the bug may not reproduce.

Path-dependent strategies require a lookback window to initialize their state before the official evaluation period begins.

• A strategy using a 200-day moving average needs 200 days of data before its first valid signal.
• A trailing stop needs enough history to establish its initial anchor price.
• The warm-up period must be excluded from performance metrics but included in state initialization to avoid cold-start bias.

Corporate actions like stock splits and dividends alter the price series retroactively. A path-dependent strategy's stored price levels become invalid if not adjusted.

• A stop-loss set at $100 before a 2-for-1 split must be adjusted to $50 to maintain equivalence.
• Special dividends reduce the stock price on ex-date; a strategy's profit target must account for this drop.
• The engine must apply back-adjusted pricing to the entire history to maintain state consistency across corporate events.

The computational backbone for managing path dependency in backtesting. A state machine defines a finite set of statuses—such as pending, partially filled, or cancelled—and the deterministic rules for transitioning between them. This ensures that an order's current state is always a function of its prior sequence of events, preventing logical inconsistencies where a cancelled order could later be filled. In event-driven architectures, the state machine processes each market event sequentially, guaranteeing that the simulation's internal logic perfectly mirrors a live trading engine's order management system.

The architectural paradigm required to accurately model path dependency. Unlike vectorized backtesting, which operates on static arrays, event-driven simulation processes market data chronologically—tick by tick or bar by bar. When a new quote arrives, the engine checks if it triggers a strategy signal, which then creates an order, which then enters a fill simulation loop. This strict temporal ordering ensures that a decision at time t is contingent only on information available up to time t, faithfully replicating the sequential dependencies that define live trading.

The most destructive violation of path dependency in simulation. This flaw occurs when a strategy uses data at time t that would not have been available until time t+n. For example, using a company's reported earnings to trade before the announcement date, or applying a technical indicator calculated with future closing prices. In a path-dependent system, the information set at each decision point must be strictly constrained to point-in-time data. Even subtle look-ahead leaks, such as using the high of a bar before it closes, can catastrophically inflate backtest performance.

The engine component where path dependency directly impacts execution outcomes. A fill simulation must determine if a limit order to buy at $100.00 is executed when the market trades at that price. This depends on the order's queue position, which is a function of the sequence of prior orders at that price level. A naive simulation might fill the order instantly, but a path-dependent model tracks the order book's FIFO queue, only filling the order after all preceding orders at $100.00 are cleared. This accurately models the latency and competition inherent in real markets.

The auditability standard that validates a path-dependent engine's correctness. A simulation is deterministic if, given the same initial state and the same sequence of timestamped market events, it produces an identical equity curve every time. This requires fixing all random seeds and ensuring that no external, non-reproducible data sources influence the logic. Deterministic replay is critical for debugging: if a trade executes unexpectedly, developers can re-run the exact event sequence to trace the state machine's transitions and identify the root cause without non-deterministic noise.

A validation framework that respects path dependency across time. Instead of optimizing parameters on the entire historical dataset, the data is split into a rolling sequence of in-sample and out-of-sample windows. Parameters are optimized on the first in-sample window, and that specific parameter set is tested on the immediately following out-of-sample period. This process repeats, rolling forward through time. This preserves the temporal sequence of market regimes, ensuring that the strategy's live-like performance is evaluated on data that strictly follows the optimization period, preventing future information from leaking into parameter selection.