Stochastic Processes and Brownian Motion in Finance

Brownian motion is the mathematical backbone of modern quantitative finance. Almost every pricing model, simulation engine, and risk calculation you will ever touch rests on a stochastic process — a sequence of random variables evolving through time. If you understand how a discrete random walk becomes a continuous Wiener process, and how that process gets bent into geometric Brownian motion (GBM) to model prices, you understand the engine under Black-Scholes, Monte Carlo simulation, and most of the derivatives world. This guide builds that intuition from the ground up, shows you how to simulate price paths in Python, and — just as importantly — tells you exactly where the model lies to you.

From coin flips to random walks

Start with the simplest stochastic process: a random walk. At each step you flip a fair coin and move up or down by one unit. The position after n steps is the sum of n independent ±1 shocks. Two facts matter:

The expected position stays at zero (no drift, fair coin).
The variance grows linearly with the number of steps, so the spread of where

you might be grows with the square root of time, √n.

That √t scaling of uncertainty is the single most important fingerprint of Brownian motion, and it shows up everywhere — including why volatility scales with the square root of time.

The Wiener process: a random walk in continuous time

Shrink the time step toward zero and the step size appropriately, and the random walk converges to a Wiener process (standard Brownian motion), denoted W(t). It has three defining properties:

W(0) = 0.
Independent increments: non-overlapping changes are independent.
Gaussian increments: W(t) − W(s) ~ Normal(0, t − s). The variance of a change

equals the elapsed time.

A Wiener path is continuous everywhere but differentiable nowhere — infinitely jagged. That nastiness is exactly why we need a special calculus (Ito's) to work with it.

Drift and diffusion

A raw Wiener process has no trend and a fixed scale. Real assets trend (a little) and have their own volatility, so we generalize to a process with drift and diffusion:

dX = μ dt + σ dW

μ is the drift — the deterministic per-unit-time push.
σ is the diffusion coefficient — the size of random shocks.
dW is the increment of the Wiener process, the source of randomness.

This is the canonical stochastic differential equation (SDE). Read it as: over a tiny instant dt, the change in X is a steady push μ dt plus a random kick σ dW. Closely related mean-reverting variants like the Ornstein-Uhlenbeck process just make μ depend on the current level.

Geometric Brownian motion: the standard price model

Prices cannot go negative, and a \$5 stock and a \$500 stock should not have the same dollar volatility — they should have comparable percentage volatility. So instead of modeling the price level with arithmetic Brownian motion, we model the log price. The result is geometric Brownian motion:

dS = μ S dt + σ S dW

Here drift and diffusion both scale with the price S, so returns rather than dollar moves are stationary in scale. Solving this SDE (via Ito's lemma, below) gives a closed form:

S(t) = S(0) · exp( (μ − ½σ²) t + σ W(t) )

Two features deserve attention:

Because the exponent is normally distributed, S(t) is lognormal — strictly

positive, right-skewed. Good: prices stay positive.

The drift inside the exponent is μ − ½σ², not μ. That −½σ² Ito correction

is the volatility drag, and it is why a high-volatility asset with the same μ compounds more slowly. Forgetting it is one of the most common modeling bugs.

A light touch of Ito's lemma

Ordinary calculus says d(f) = f' dx. For functions of a stochastic process you need a second-order term because (dW)² does not vanish — it behaves like dt. Ito's lemma for f(S) reads:

df = f'(S) dS + ½ f''(S) (dS)²,   with (dW)² → dt

Apply it to f = ln(S) with dS = μ S dt + σ S dW, and the extra ½ f'' (dS)² term produces exactly the −½σ² correction in the GBM solution above. You do not need to manipulate SDEs by hand daily, but knowing why that half-variance term appears keeps you from misreading drift parameters.

Simulating GBM in Python

Discretize the exact solution over small steps and you have a path simulator. This is the workhorse behind option pricing by simulation and Monte Carlo risk analysis:

import numpy as np

def simulate_gbm(s0, mu, sigma, T, steps, paths, seed=0):
    rng = np.random.default_rng(seed)
    dt = T / steps
    # standard normal shocks, one per step per path
    z = rng.standard_normal((steps, paths))
    # log-return increments with the Ito drift correction
    increments = (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * z
    log_paths = np.cumsum(increments, axis=0)
    s = s0 * np.exp(log_paths)
    return np.vstack([np.full(paths, s0), s])  # prepend S0

prices = simulate_gbm(s0=100, mu=0.08, sigma=0.2, T=1.0,
                      steps=252, paths=10000)
terminal = prices[-1]
print(f"Mean terminal price: {terminal.mean():.2f}")
print(f"5% quantile:         {np.quantile(terminal, 0.05):.2f}")

Note the np.sqrt(dt) multiplying the shock: that is the √t scaling of Brownian motion again. Use the exact lognormal solution (as above) rather than a naive S + μS dt + σS √dt z Euler step — the Euler version can drift negative and introduces discretization bias.

Why we model prices this way

Property	What GBM gives you	Why it matters
Positivity	Lognormal prices > 0	Prices can't go negative
Scale invariance	Returns, not dollars, are stationary	\$5 and \$500 stocks comparable
Tractability	Closed-form Black-Scholes	Fast, analytic option prices
`√t` uncertainty	Variance grows linearly in time	Clean volatility scaling

The combination of positivity, analytic tractability, and the clean separation of drift and volatility made GBM the default. It is "wrong but useful" — the right first approximation.

Where the model breaks

GBM assumes returns are independent, normally distributed, and have constant volatility. Real markets violate all three:

Fat tails. Actual return distributions are leptokurtic: large moves happen far

more often than a normal distribution predicts. A 5-sigma daily move should be a once-in-millennia event under GBM, yet markets serve several per decade. This is the domain of extreme value theory.

Volatility clustering. Volatility is not constant; calm and turbulent regimes

persist. Big moves follow big moves. This is what GARCH models capture and GBM ignores.

Jumps. Earnings, central-bank surprises, and crashes produce discontinuous

gaps that a continuous diffusion cannot represent without jump-diffusion extensions.

Non-stationarity of drift. μ is tiny relative to σ and notoriously unstable;

see stationarity for why estimating it is so fragile.

The fixes — stochastic volatility, jump-diffusion, regime-switching — all start from the Brownian skeleton and patch its known failures.

Common mistakes

Dropping the Ito correction. Simulating with drift μ instead of μ − ½σ²

systematically overstates expected growth.

Estimating drift from short samples. With realistic volatility you need decades

of data to estimate μ with any precision; do not trust a one-year drift estimate.

Euler stepping the level directly. It can produce negative prices and biases;

step the log-price or use the exact lognormal form.

Assuming normal tails for risk. Sizing positions or VaR off GBM normality badly

understates the chance of large losses.

Confusing √t with t scaling. Volatility scales with √t, variance with t.

Mixing them up corrupts annualization.

Key takeaways

A random walk in the continuous limit becomes the Wiener process, whose

uncertainty grows with √t.

Add drift and diffusion to get the general SDE dX = μ dt + σ dW.
Geometric Brownian motion models prices as lognormal, keeping them positive and

scale-invariant, and underpins Black-Scholes.

Ito's lemma explains the crucial −½σ² volatility drag in the drift.
Simulate GBM by stepping log-returns with √dt shocks for

Monte Carlo work.

GBM is a first approximation: real markets have fat tails, **volatility

clustering, and jumps**, so always stress-test beyond the normal model.