A backtest showing 42% net profit and a 1.8 profit factor looks great. But that result is path-dependent. Change the order of the same winning and losing trades, and the equity curve can collapse. Most traders never see this because MetaTrader's optimizer only shows one historical path—the one that actually happened.
1. The Sequence Risk Problem
Consider a strategy with 200 trades: 120 winners (+$100 each) and 80 losers (-$100 each). Net profit = $4,000. But what if the 80 losers cluster within the first 50 trades? Or the winners arrive late? The same trades in different order produce wildly different drawdown profiles.
Standard MT4/MT5 backtests cannot answer this question. Professional quant firms solve it with Monte Carlo bootstrap resampling.
2. Bootstrap Resampling Architecture
The core method: treat each historical trade as an independent observation, then randomly resample with replacement thousands of times:
```cpp
// Monte Carlo trade sequence simulator for MQL5
struct SMonteCarloResult {
double finalEquity; // Ending balance for this simulation
double maxDrawdownPct; // Maximum peak-to-trough decline
double sharpeEstimate; // Risk-adjusted return proxy
int ruinFlag; // 1 if drawdown exceeded threshold
};
class CMonteCarloValidator {
private:
double m_trades[]; // Historical trade P&L values
int m_tradeCount;
double m_initialBalance;
double m_ruinThreshold; // e.g., 0.20 = 20%
int m_simulations;
public:
CMonteCarloValidator(double initBalance, double ruinThreshold, int sims=10000) {
m_initialBalance = initBalance;
m_ruinThreshold = ruinThreshold;
m_simulations = sims;
}
bool LoadTradeHistory(string csvFile) {
int handle = FileOpen(csvFile, FILE_READ|FILE_CSV, ',');
if(handle == INVALID_HANDLE) return false;
double buffer[];
int count = 0;
FileReadString(handle); // skip header
while(!FileIsEnding(handle)) {
string row = FileReadString(handle);
string cols[];
StringSplit(row, ',', cols);
if(ArraySize(cols) >= 2) {
ArrayResize(buffer, count+1);
buffer[count++] = StringToDouble(cols[1]); // profit column
}
}
FileClose(handle);
ArrayResize(m_trades, count);
ArrayCopy(m_trades, buffer);
m_tradeCount = count;
return count > 0;
}
void RunSimulations(SMonteCarloResult &results[]) {
ArrayResize(results, m_simulations);
MathSrand((int)TimeLocal());
for(int sim = 0; sim < m_simulations; sim++) {
double equity = m_initialBalance;
double peak = m_initialBalance;
double maxDD = 0;
for(int t = 0; t < m_tradeCount; t++) {
// Random draw with replacement
int idx = MathRand() % m_tradeCount;
equity += m_trades[idx];
// Track peak for drawdown calculation
if(equity > peak) peak = equity;
double currentDD = (peak > 0) ? (peak - equity) / peak : 0;
if(currentDD > maxDD) maxDD = currentDD;
}
results[sim].finalEquity = equity;
results[sim].maxDrawdownPct = maxDD;
results[sim].ruinFlag = (maxDD >= m_ruinThreshold) ? 1 : 0;
}
}
};
```
3. Slippage and Commission Stress Injection
Realistic simulation requires adding execution friction to each resampled trade:
```cpp
void RunWithExecutionFriction(SMonteCarloResult &results[],
double commissionPerTrade,
double maxSlippage) {
ArrayResize(results, m_simulations);
for(int sim = 0; sim < m_simulations; sim++) {
double equity = m_initialBalance;
double peak = m_initialBalance;
double maxDD = 0;
for(int t = 0; t < m_tradeCount; t++) {
int idx = MathRand() % m_tradeCount;
double pnl = m_trades[idx];
// Add realistic execution costs
double slippage = ((double)MathRand() / 32767.0) * maxSlippage;
pnl -= (commissionPerTrade + slippage);
equity += pnl;
if(equity > peak) peak = equity;
double currentDD = (peak - equity) / peak;
if(currentDD > maxDD) maxDD = currentDD;
}
results[sim].finalEquity = equity;
results[sim].maxDrawdownPct = maxDD;
results[sim].ruinFlag = (maxDD >= m_ruinThreshold) ? 1 : 0;
}
}
```
4. Interpreting Monte Carlo Output
Run 10,000 simulations and extract key risk metrics:
| Metric | Calculation | What It Reveals |
|--------|-------------|------------------|
| Median Max DD | 50th percentile of drawdowns | Typical worst-case |
| Stress Drawdown | 95th percentile | 1-in-20 bad scenario |
| Value at Risk (5%) | Initial Balance − P5 Final Equity | Capital at risk |
| Ruin Probability | % simulations exceeding threshold | Strategy kill rate |
```cpp
void ComputeRiskMetrics(SMonteCarloResult &results[],
double &medianDD,
double &stressDD,
double &var5,
double &ruinProb) {
int sims = ArraySize(results);
double drawdowns[];
double finalEqs[];
ArrayResize(drawdowns, sims);
ArrayResize(finalEqs, sims);
for(int i = 0; i < sims; i++) {
drawdowns[i] = results[i].maxDrawdownPct;
finalEqs[i] = results[i].finalEquity;
}
ArraySort(drawdowns);
ArraySort(finalEqs);
medianDD = drawdowns[(int)(sims * 0.5)];
stressDD = drawdowns[(int)(sims * 0.95)];
var5 = m_initialBalance - finalEqs[(int)(sims * 0.05)];
int ruinCount = 0;
for(int i = 0; i < sims; i++) ruinCount += results[i].ruinFlag;
ruinProb = (double)ruinCount / sims;
}
```
5. Complete Validation Workflow
The professional testing sequence:
```cpp
// Full validation script
void OnStart() {
CMonteCarloValidator validator(10000.0, 0.20, 10000);
if(!validator.LoadTradeHistory("my_ea_trades.csv")) {
Print("Failed to load trade history");
return;
}
SMonteCarloResult results[];
validator.RunWithExecutionFriction(results, 2.0, 3.0);
double medianDD, stressDD, var5, ruinProb;
validator.ComputeRiskMetrics(results, medianDD, stressDD, var5, ruinProb);
Print("=== Monte Carlo Risk Report ===");
PrintFormat("Median Max Drawdown: %.2f%%", medianDD * 100);
PrintFormat("Stress Drawdown (95th): %.2f%%", stressDD * 100);
PrintFormat("Value at Risk (5%%): $%.2f", var5);
PrintFormat("Ruin Probability (>20%% DD): %.2f%%", ruinProb * 100);
// Decision rule from professional validation
if(ruinProb > 0.10 || medianDD > 0.15) {
Print("VERDICT: REJECT - Unacceptable sequence risk");
} else {
Print("VERDICT: PASS - Strategy shows sequence robustness");
}
}
```
6. Professional Acceptance Criteria
Martyn Tinsley (DARWIN: TRO manager) defines the standard:
Reference: MQL5 Documentation, "Monte Carlo Simulation" (2026); Darwinex Zero, "Strategy Validation Series" (2026); Pardo, Robert. "The Evaluation and Optimization of Trading Strategies" (Wiley, 2008).