Classical Simulators: The Baseline to Beat

When someone says “let’s generate synthetic market data,” the modern reflex is to spin up a GAN, feed it a few years of returns, and wait for the magic. That reflex is almost always wrong as a first move. A neural generator is a black box with millions of parameters and a long list of ways to fool you — mode collapse, silent overfitting, and a tendency to memorize and replay your training set while looking creative. You should never reach for one until you know what you’re trying to beat.

What you’re trying to beat is a classical simulator: a small, transparent model you can write on a napkin and fully understand. Three of them carry almost all the weight in practice — geometric Brownian motion, the bootstrap (block and stationary), and regime-switching / hidden-Markov models. They are cheap, they train in milliseconds, every parameter has a meaning, and crucially they are leak-resistant: a bootstrap can only replay returns that really happened, and GBM has so few knobs it physically cannot memorize your data. They are the control group of this entire field.

So the rule for the rest of the course is simple. A learned generator (lessons 4–6) is only worth its compute, its fragility, and its leakage risk if it clears this baseline and survives the evaluation gauntlet (lesson 7). In this lesson we line up the three classical simulators and grade each one against the stylized-facts rubric from lesson 2 — fat tails, volatility clustering, slow absolute-return ACF, the leverage effect, aggregational Gaussianity, and gain/loss asymmetry. Some of these “straw men” turn out to be alarmingly hard to knock down.

Geometric Brownian motion (GBM)

Analogy. GBM is the spherical cow of finance. A physicist who wants a first answer assumes the cow is a frictionless sphere — wrong in every detail, but a clean starting point you can compute by hand. GBM assumes a market with constant volatility and memoryless, perfectly Gaussian returns. Nobody believes the cow is a sphere; you use it because it gives you a number to argue against.

Definition. GBM is the model you already met in Monte-Carlo Finance. The price $S_t$ follows the stochastic differential equation

$dS = \mu S\, dt + \sigma S\, dW,$

where $\mu$ is the drift, $\sigma$ the volatility, and $dW$ a Brownian increment. The closed-form solution makes log-returns i.i.d. normal:

$\ln\frac{S_{t+\Delta t}}{S_t} \sim \mathcal{N}\!\left(\left(\mu - \tfrac{1}{2}\sigma^2\right)\Delta t,\ \sigma^2 \Delta t\right).$

To simulate one step you draw a standard normal $Z \sim \mathcal{N}(0,1)$ and push the price forward:

$S_{t+\Delta t} = S_t \exp\!\left[\left(\mu - \tfrac{1}{2}\sigma^2\right)\Delta t + \sigma\sqrt{\Delta t}\, Z\right].$

Worked example. Take a start price of $100, so $S_0 = 100$, with annual drift $\mu = 0.08$, annual volatility $\sigma = 0.20$, and one daily step $\Delta t = 1/252$. Then:

• Drift term: $\left(\mu - \tfrac{1}{2}\sigma^2\right)\Delta t = (0.08 - 0.02)\cdot \tfrac{1}{252} = 0.06/252 \approx 0.000238.$
• Diffusion scale: $\sigma\sqrt{\Delta t} = 0.20 \cdot \sqrt{1/252} = 0.20 \cdot 0.0630 \approx 0.0126.$

Suppose the random draw is $Z = 1.5$ (a brisk up day). The log-return is $0.000238 + 0.0126 \cdot 1.5 = 0.000238 + 0.0189 = 0.01914$, so

$S_{t+\Delta t} = 100 \cdot e^{0.01914} = 100 \cdot 1.01932 \approx 101.93,$

i.e. a price of about $101.93.

A draw of $Z = -2.0$ instead gives a log-return of $0.000238 - 0.0252 = -0.02496$ and a price of about $97.54. Same machinery, just a different Gaussian draw — and that sameness is the whole problem.

Grading GBM against the rubric. Here is where the spherical cow gets exposed:

It passes exactly one box, and only because it cheats by being Gaussian everywhere. The picture below shows the core failure: GBM’s return distribution is a clean bell curve, while real returns pile up extra mass in the middle and in the tails.

When to use it

Use GBM as the null hypothesis and pricing scaffold, not as a realistic data source. It is the right tool when you need a closed-form benchmark (Black–Scholes lives here), a quick sanity path, or a deliberately honest lower bound to measure everything else against. The moment you care about tail risk, clustering, or anything path-dependent, GBM is a liability — but it is an indispensable yardstick.

The block bootstrap

Analogy. Imagine making a “new” highlight reel from old game footage. If you splice it one frame at a time, you get incoherent flicker. If you splice it in clips of a few seconds each, every clip still contains real, coherent motion — you’ve just reshuffled the order of plays. The block bootstrap splices market history in clips, not frames, so each clip carries its own little burst of volatility intact.

Definition. The bootstrap resamples with replacement from your historical returns to build new series of the same length. The naïve version draws single days, which destroys all temporal structure. The moving-block bootstrap instead picks a block length $b$, forms every overlapping block $(r_i, r_{i+1}, \dots, r_{i+b-1})$, and samples whole blocks at random, concatenating them until the synthetic series is long enough.

• Non-overlapping blocks chop the series into fixed, disjoint windows — simpler, but fewer distinct blocks to draw from.
• Moving (overlapping) blocks slide one step at a time, giving $n - b + 1$ candidate blocks and far more variety.

The block length $b$ is the one knob, and it is a genuine tradeoff:

• Too short ($b = 1$): you’re back to the i.i.d. bootstrap — clustering and all serial dependence vanish.
• Too long ($b \approx n$): every “synthetic” series is just your real history with the start point shifted — no novelty at all.

Worked example. Take a tiny daily-return series of $n = 8$ days (in percent):

$[\,+1,\ +2,\ -5,\ -4,\ +1,\ 0,\ +2,\ -1\,].$

Choose block length $b = 3$. The overlapping blocks are $n - b + 1 = 8 - 3 + 1 = 6$ of them:

$B_1=[+1,+2,-5],\quad B_2=[+2,-5,-4],\quad B_3=[-5,-4,+1],$ $B_4=[-4,+1,0],\quad B_5=[+1,0,+2],\quad B_6=[0,+2,-1].$

To build a synthetic length-8 series, draw blocks at random with replacement and concatenate, trimming to 8. Drawing $B_2$, then $B_5$, then $B_1$ gives

$[+2,-5,-4,\ +1,0,+2,\ +1,+2]\ \to\ \text{trim to 8:}\ [+2,-5,-4,+1,0,+2,+1,+2].$

Notice the $-5,-4$ pair survived as a unit — the volatile cluster traveled together. A single-day bootstrap could just as easily have separated them, drowning the storm.

The stationary bootstrap (Politis–Romano). A fixed block length leaves an awkward seam: the synthetic series isn’t strictly stationary because the block boundaries land at predictable spots. The stationary bootstrap fixes this by making the block length random — each block continues with probability $p$ and ends with probability $1 - p$ at every step, so block lengths follow a geometric distribution with mean $1/p$. Averaging over random lengths smooths out the boundary artifacts and guarantees the resampled series is stationary. You trade the single parameter $b$ for the single parameter $p$ (expected length $1/p$).

Grading the bootstrap against the rubric. The bootstrap’s superpower is that it resamples real returns, so anything baked into individual days survives for free:

When to use it

Reach for the block (or stationary) bootstrap when you want realistic, leak-resistant samples and you trust your history to be representative — backtesting trading rules, sizing confidence intervals on a Sharpe ratio, bootstrapping P&L distributions. It is the strongest baseline precisely because it inherits every stylized fact your data already has, at near-zero modeling cost. Avoid it whenever the future must contain events the past did not — novel regimes, structural breaks, or stress beyond the historical maximum.

Regime-switching / hidden-Markov models

Analogy. Think of the market as weather with two moods: sunny (low volatility, gentle drift) and stormy (high volatility, sharp moves). You never get a label that says “it is storm season now” — you only see the daily returns and have to infer the mood. And moods are sticky: a sunny day is usually followed by another sunny day, a storm tends to rage on for a while. That stickiness is the Markov transition matrix.

Definition. A hidden-Markov / regime-switching model posits a small number $K$ of latent states. State $k$ emits returns from its own distribution, typically Gaussian with mean $\mu_k$ and volatility $\sigma_k$. A $K \times K$ transition matrix $P$, with entries $p_{ij} = \Pr(\text{state}_{t+1}=j \mid \text{state}_t=i)$ and rows summing to 1, governs the dynamics. For a two-state (calm / turbulent) model:

$P = \begin{pmatrix} p_{CC} & p_{CT} \\ p_{TC} & p_{TT} \end{pmatrix},\qquad p_{CC}+p_{CT}=1,\quad p_{TC}+p_{TT}=1.$

The expected duration of a regime follows from the self-transition probability $p_{\text{stay}}$. Each day the regime survives with probability $p_{\text{stay}}$, so its length is geometric with mean

$\mathbb{E}[\text{duration}] = \frac{1}{1 - p_{\text{stay}}}.$

Worked example. Calibrate a two-state model with

$P = \begin{pmatrix} 0.98 & 0.02 \\ 0.10 & 0.90 \end{pmatrix},\qquad \begin{aligned} &\text{Calm: } \mu_C = +0.05\%/\text{day},\ \sigma_C = 0.6\%\\ &\text{Turbulent: } \mu_T = -0.10\%/\text{day},\ \sigma_T = 2.5\% \end{aligned}$

Expected durations:

• Calm: $1/(1 - 0.98) = 1/0.02 = 50$ trading days (about 10 weeks of quiet).
• Turbulent: $1/(1 - 0.90) = 1/0.10 = 10$ trading days (a two-week storm).

Long-run regime probabilities come from the stationary distribution $\pi P = \pi$. Solving, the calm probability is $p_{TC}/(p_{CT}+p_{TC}) = 0.10/(0.02+0.10) = 0.10/0.12 \approx 0.833$, so the market is calm about 83% of the time and turbulent about 17%. The unconditional return distribution is then a mixture of two normals:

$f(r) = 0.833 \cdot \mathcal{N}(0.0005,\ 0.006^2) + 0.167 \cdot \mathcal{N}(-0.001,\ 0.025^2).$

That mixture is where the magic happens. A narrow calm bell glued to a wide turbulent bell produces a combined distribution that is peaked in the middle and fat in the tails — leptokurtic, just like real returns — even though each component is a plain Gaussian.

Grading the HMM against the rubric. For such a simple model, the scorecard is surprisingly strong:

When to use it

Use a regime-switching model when you need interpretable structure with realistic tails and clustering — scenario generation for stress tests where you want a named “crisis regime,” volatility forecasting, or any setting where stakeholders will ask why a path looks the way it does. It threads the needle between GBM (too simple) and a neural generator (too opaque): few parameters, every one nameable, yet it clears most of the rubric. Skip it when the real dynamics are genuinely continuous rather than a handful of discrete moods, or when you need the leverage effect baked in.

Why the baseline is so hard to beat

It would be convenient if these models were toys. They are not. The reason they survive is a combination of three properties that learned generators struggle to match all at once.

They are cheap. GBM is two parameters. A bootstrap is zero parameters plus a block length. A two-state HMM is a handful. They calibrate in milliseconds on a laptop, with no GPU, no training instability, and no hyperparameter séance.

They are interpretable. Every knob has a name and a unit. When the output looks wrong you can point at the parameter responsible — drift, volatility, block length, self-transition probability. A GAN that misbehaves offers you a loss curve and a shrug.

They are leak-resistant. This is the underrated one. The bootstrap can only emit returns that actually occurred, so it cannot accidentally regurgitate a memorized training example that the rest of your pipeline then mistakes for genuine novelty — its “leakage” is honest and bounded by construction. GBM and HMMs have so few parameters that they physically lack the capacity to memorize individual paths. A neural generator with millions of weights has exactly the opposite problem: its default failure mode is to copy the training set and pass it off as synthetic, which is catastrophic if you’re using the data to validate a model that also trained on the original.

So a learned generator has to clear a high bar: match or beat the HMM on fat tails and clustering, add the leverage effect and long-range memory the classics miss, and generate genuine novelty (moves beyond the historical sample) the bootstrap can’t — all without secretly memorizing the training data, and while surviving the full evaluation gauntlet of lesson 7. Here is the scorecard that frames the rest of the course:

Read that table as a job description. The two columns where the classics are weak — the leverage effect and genuine novelty — are exactly what a neural generator must deliver to justify its cost. Everything else, it merely has to not lose.

Recap

Before any neural generator earns a place in your pipeline, it has to beat a control group you fully understand. Geometric Brownian motion is the honest straw man: i.i.d. Gaussian log-returns that pass aggregational Gaussianity and fail everything else, but give you a closed-form yardstick. The block (and stationary) bootstrap resamples clips of real history, inheriting empirical fat tails and short-range volatility clustering for free, at the cost of long-range memory and any move bigger than history’s worst day. The two-state hidden-Markov model blends a calm and a turbulent regime into a mixture of normals that delivers both fat tails and clustering while staying interpretable, with expected regime duration $1/(1-p_{\text{stay}})$. All three are cheap, transparent, and leak-resistant — which is exactly why they’re hard to beat. The learned generators of lessons 4–6 must clear this bar on the leverage effect and on genuine novelty, without memorizing the data, and then survive the evaluation gauntlet of lesson 7.