Luigi Piva, CQF — Quanthedge AI (research arm of AlgosWorks AI Ltd)
All code in this article is runnable as-is. The example track record is synthetic and fully specified, so every number is reproducible; 

Search for “Monte Carlo simulation trading strategy” and you will find, with remarkable consistency, the same recipe: take the list of your backtest trades, shuffle their order a few thousand times, recompute the equity curve each time, and read off a distribution of drawdowns. This is presented as “Monte Carlo analysis” of your system, and it is supposed to tell you what risk to expect going forward.

It is not Monte Carlo. It is not even a well-specified bootstrap. It is a permutation of your sample, and for the one question it is usually asked to answer, the depth of future drawdowns, it is biased in the most dangerous direction: it makes your strategy look “safer” than the data says it is.

This article does three things. It defines precisely what the bootstrap is and what Monte Carlo is, two different tools that answer two different questions. It shows, with code and numbers, how the popular shuffle systematically thins the drawdown tail whenever returns exhibit the serial structure that real strategy returns always exhibit. And it ends with an operational taxonomy: which question you are asking, and which procedure is entitled to answer it.

The Canonical Error

Here is the forum recipe, stated honestly for what it is:

1. Take the sequence of realised P&L (trades or daily returns).
2. Randomly permute the sequence B times.
3. For each permutation, rebuild the equity curve and record max drawdown, time under water, etc.
4. Report percentiles of that distribution as “what could have happened”.

Two assumptions are buried in step 2, and both are false for trading strategies.

First: exchangeability: A permutation treats every ordering of your P&L as equally likely, which is only true if the observations are independent and identically distributed. Strategy returns are not i.i.d. Volatility clusters, turbulent weeks follow turbulent weeks and most systematic strategies have some serial dependence in returns themselves: trend systems bleed in small correlated losses and win in correlated runs; mean-reversion systems do the opposite. The regime structure of markets induces regime structure in your P&L.

Second: the sample is the population: Shuffling never produces a return that did not occur in your backtest. It cannot generate a volatility level you have not seen, a correlation breakdown you have not lived through, or a losing streak longer than combinatorics of your own history allows. It recycles the past in a different order; it creates no new information about the world.

Now, why does this specifically understate drawdown risk? Because maximum drawdown is a functional of the path, and the path property that produces deep drawdowns is precisely the clustering of bad outcomes. Permutation destroys clustering by construction: it takes your correlated losing streaks, breaks them apart, and sprinkles the pieces uniformly through time. The resampled equity curves are smoother than any curve your strategy could actually produce. The distribution of simulated drawdowns is pulled toward zero, and its bad tail, the only part you care about, is the most distorted of all.

Let’s quantify it.

A reproducible testbed

I need a return series with the two features that matter, volatility clustering and mild serial dependence  and I want it fully specified so you can rerun everything. A two-state Markov regime process with a light AR(1) overlay does the job; it is a caricature of a real futures strategy track record, but a caricature with the right anatomy. (When you rerun this on your own strategy, delete this block and load your returns.)

“`python
import numpy as np
rng = np.random.default_rng(42)

n = 2520                                  # ~10 years of daily returns
P   = np.array([[0.99, 0.01],
                [0.04, 0.96]])            # calm <-> turbulent transitions
mu  = np.array([ 0.0008, -0.0004])        # daily drift by regime
sig = np.array([ 0.006 ,  0.016 ])        # daily vol by regime

states = np.zeros(n, dtype=int)
for t in range(1, n):
    states[t] = rng.choice(2, p=P[states[t-1]])

eps = rng.normal(mu[states], sig[states])
r = np.empty(n)
r[0] = eps[0]
for t in range(1, n):
    r[t] = 0.08 * r[t-1] + eps[t]         # mild serial dependence

def sharpe(x):
    return x.mean() / x.std(ddof=1) * np.sqrt(252)

def max_drawdown(x):
    w = np.cumprod(1.0 + x)
    return (w / np.maximum.accumulate(w) – 1.0).min()
“`

The realized history: Sharpe 0.76, maximum drawdown −41.5%**, first-order autocorrelation of 0.12 in returns and 0.16 in squared returns. Nothing exotic, these are unremarkable numbers for a mid-frequency futures programme, and exactly the kind of dependence structure the shuffle assumes away.

What the Bootstrap actually is

The bootstrap (Efron, 1979) answers a specific question: given that I observed this sample, how uncertain is a statistic computed from it? You resample from the empirical distribution — with replacement — recompute the statistic each time, and use the resulting spread as an estimate of the sampling distribution. It is a device for putting confidence intervals around your Sharpe ratio, your CAGR, your drawdown, without assuming normality.

The textbook version resamples individual observations, and that is where the i.i.d. assumption sneaks back in. Resampling single days destroys serial structure just as thoroughly as shuffling does. For dependent data you need the block family:

-Moving block bootstrap (Künsch, 1989): resample contiguous blocks of fixed length.
– Stationary bootstrap(Politis–Romano, 1994): blocks of *geometrically distributed* random length, which keeps the resampled series stationary and removes the artificial seams of fixed blocks.
– Block length is a bandwidth parameter; Politis–White (2004) give an automatic selection rule. In practice, for daily strategy returns, mean blocks of 10–40 days bracket the answer, and you should report sensitivity rather than a single sacred number.

Here is a compact, vectorised stationary bootstrap:

“`python
def sb_indices(n, mean_block, rng):
    “””Politis-Romano stationary bootstrap index sequence.”””
    p = 1.0 / mean_block
    restarts = rng.random(n) < p          # geometric block ends
    restarts[0] = True
    block_id = np.cumsum(restarts) – 1
    pos = np.arange(n)
    offsets = pos – pos[restarts][block_id]
    starts = rng.integers(0, n, restarts.sum())
    return (starts[block_id] + offsets) % n   # circular wrap

def stationary_bootstrap(x, stat, B=5000, mean_block=20, rng=rng):
    n = len(x)
    return np.array([stat(x[sb_indices(n, mean_block, rng)])
                     for _ in range(B)])

def shuffle_dist(x, stat, B=5000, rng=rng):   # the forum recipe
    return np.array([stat(rng.permutation(x)) for _ in range(B)])

def iid_bootstrap(x, stat, B=5000, rng=rng):  # textbook bootstrap
    n = len(x)
    return np.array([stat(x[rng.integers(0, n, n)]) for _ in range(B)])
“`

What can a (correct) bootstrap tell you? The uncertainty of statistics of the history you actually had. What can it not tell you? Anything about states of the world absent from your sample. If your ten years contain no 2008, no block resampling will manufacture one. Keep that limitation in mind; it is the door through which real Monte Carlo enters later.

The Numbers

Tab.1 Running all three
procedures on the same series, B = 5,000 each: