Geometric Brownian Motion: The Foundation of Continuous-Time Finance

What Is Geometric Brownian Motion?

Geometric Brownian motion (GBM) is the continuous-time stochastic process most commonly used to model the price of a risky asset. It combines two features that make it convenient and moderately realistic: prices remain strictly positive, and log-returns are normally distributed. The process sits at the centre of the Black–Scholes–Merton framework (Black & Scholes, 1973; Merton, 1973); textbook treatments of the SDE and its solution are given in Hull (2021), Shreve (2004), and Baxter & Rennie (1996).

Formally, a process (S_t) is a geometric Brownian motion if it satisfies the stochastic differential equation:

dS_t = mu * S_t dt + sigma * S_t dW_t

where (\mu) is the drift, (\sigma > 0) is the volatility, and (W_t) is a standard Brownian motion. The distinctive feature is that both the drift and the diffusion are proportional to the current level (S_t), which means percentage moves — not absolute moves — are homogeneous over time.

GBM sits underneath the Black–Scholes model, most equity Monte Carlo pricers, and countless risk models. Understanding its derivation, its distributional properties, and where it breaks down is one of the core competencies of a quantitative analyst.

---

From Brownian Motion to Geometric Brownian Motion

A standard Brownian motion (W_t) has independent normal increments with mean zero and variance equal to the time step. Naively modelling a price as (S_t = S_0 + \mu t + \sigma W_t) — arithmetic Brownian motion — has three fatal defects:

1. (S_t) can become negative, which is impossible for a limited-liability asset.
2. Volatility (\sigma) is expressed in currency units, not percentage terms.
3. Absolute price changes have the same distribution regardless of price level, which contradicts the empirical observation that a £1 move in a £10 stock is very different from a £1 move in a £1,000 stock.

Geometric Brownian motion fixes all three by making the SDE multiplicative in (S_t). The drift and diffusion are now proportional to the level, so (\mu) is a percentage growth rate and (\sigma) is a percentage volatility.

---

Solving the SDE with Itô's Lemma

The GBM SDE is nonlinear because of the (S_t) that multiplies the diffusion term. The trick is to work with (\log S_t) instead.

Let (f(S) = \log S). Its derivatives are:

• (f'(S) = 1/S)
• (f''(S) = -1/S^2)

Itô's lemma gives:

d(log S_t) = f'(S_t) dS_t + (1/2) f''(S_t) (dS_t)^2

Substituting (dS_t = \mu S_t dt + \sigma S_t dW_t) and using ((dS_t)^2 = \sigma^2 S_t^2 dt) (the Itô table):

d(log S_t) = (1/S_t)(mu * S_t dt + sigma * S_t dW_t) - (1/2)(1/S_t^2)(sigma^2 S_t^2 dt)

The (S_t) terms cancel neatly:

d(log S_t) = (mu - sigma^2 / 2) dt + sigma dW_t

The log-price follows a Brownian motion with drift (\mu - \sigma^2 / 2) and volatility (\sigma). Integrating from 0 to (t):

log S_t = log S_0 + (mu - sigma^2 / 2) t + sigma W_t

Exponentiating:

S_t = S_0 * exp( (mu - sigma^2 / 2) t + sigma * W_t )

This is the closed-form solution for GBM.

---

The Log-Normal Distribution

Because (W_t \sim N(0, t)), the exponent in the solution is normal. Therefore (S_t) is log-normally distributed conditional on (S_0):

log(S_t / S_0) ~ N( (mu - sigma^2 / 2) * t, sigma^2 * t )

Two things deserve emphasis.

The Volatility Adjustment in the Drift

The drift of the log-price is (\mu - \sigma^2 / 2), not (\mu). This is a direct consequence of Itô's lemma. Practically, it means:

• The expected price grows at rate (\mu): (E[S_t] = S_0 e^{\mu t}).
• The median price grows at the slower rate (\mu - \sigma^2 / 2): (\text{median}(S_t) = S_0 e^{(\mu - \sigma^2/2) t}).
• The expected log-return is (\mu - \sigma^2 / 2), not (\mu).

The gap (\sigma^2 / 2) is the variance drag: over long horizons, higher volatility mechanically reduces compound growth for the same expected return. This is why realised CAGR is typically lower than average arithmetic return.

Moments of (S_t)

From the log-normal formula:

E[S_t] = S_0 * exp(mu * t)

Var[S_t] = S_0^2 * exp(2 mu t) * (exp(sigma^2 t) - 1)

The mean grows exponentially at the drift rate. The variance grows exponentially at a faster rate, which is why longer-horizon simulations show fanning wider than one might intuit.

---

Simulating GBM

Because the exact solution is known, GBM can be simulated without discretisation error at any step size.

Exact Simulation

S_{t + Delta t} = S_t * exp( (mu - sigma^2 / 2) * Delta t + sigma * sqrt(Delta t) * Z )

where (Z \sim N(0, 1)). This is the recommended scheme.

Euler-Maruyama

The naive Euler discretisation is:

S_{t + Delta t} = S_t + mu * S_t * Delta t + sigma * S_t * sqrt(Delta t) * Z

This has bias of order (\Delta t) and, worse, can produce negative prices when the step size is large. Never use it for GBM when the exact scheme is available.

Python Implementation

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


def simulate_gbm(
    s0: float,
    mu: float,
    sigma: float,
    T: float,
    n_steps: int,
    n_paths: int = 1,
    seed: int | None = None,
) -> np.ndarray:
    """Exact simulation of geometric Brownian motion.

    Returns an array of shape (n_paths, n_steps + 1) with the initial column set to s0.
    """
    rng = np.random.default_rng(seed)
    dt = T / n_steps

    z = rng.standard_normal((n_paths, n_steps))
    log_increments = (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * z
    log_paths = np.cumsum(log_increments, axis=1)

    paths = np.empty((n_paths, n_steps + 1))
    paths[:, 0] = s0
    paths[:, 1:] = s0 * np.exp(log_paths)
    return paths


# Example: 10,000 one-year paths of a stock at S0 = 100, mu = 8%, sigma = 20%
paths = simulate_gbm(s0=100.0, mu=0.08, sigma=0.20, T=1.0, n_steps=252, n_paths=10_000, seed=42)

terminal = paths[:, -1]
print(f"Mean terminal price:   {terminal.mean():.2f}   (theory: {100 * np.exp(0.08):.2f})")
print(f"Median terminal price: {np.median(terminal):.2f}   (theory: {100 * np.exp(0.08 - 0.5 * 0.20**2):.2f})")
print(f"Std terminal price:    {terminal.std():.2f}")
print(f"5th percentile:        {np.percentile(terminal, 5):.2f}")
print(f"95th percentile:       {np.percentile(terminal, 95):.2f}")

The mean and median differ visibly — the mean is inflated by the right tail of the log-normal. In practice, the median is often a more useful "central" summary for long-horizon simulations.

---

GBM and Black-Scholes

The Black-Scholes framework assumes the underlying asset follows GBM under the risk-neutral measure (\mathbb{Q}) (Black & Scholes, 1973; Hull, 2021, ch. 15):

dS_t = r * S_t dt + sigma * S_t dW_t^Q

Under (\mathbb{Q}), the drift is the risk-free rate (r), not the physical expected return (\mu). The change of measure from the physical measure (\mathbb{P}) to (\mathbb{Q}) — formalised by Girsanov's theorem — leaves (\sigma) unchanged but replaces the drift.

Combined with the risk-neutral pricing principle, this gives the closed-form Black-Scholes formula for European calls and puts. The log-normal distribution of (S_T) is precisely what makes the integral for the option price tractable.

More generally, GBM is the workhorse asset dynamic in Monte Carlo pricing of path-independent European options. For path-dependent options (barriers, Asians, lookbacks), simulation on a fine time grid is still used but the closed-form advantage disappears.

---

Multi-Asset GBM

For a portfolio of (n) correlated assets, the natural extension is:

dS_{i,t} = mu_i * S_{i,t} dt + sigma_i * S_{i,t} dW_{i,t}

where the Brownian motions (W_{i,t}) have correlation matrix (\Sigma). Simulation uses a Cholesky factor of (\Sigma) to correlate independent standard-normal draws.

def simulate_multi_gbm(
    s0: np.ndarray,
    mu: np.ndarray,
    sigma: np.ndarray,
    corr: np.ndarray,
    T: float,
    n_steps: int,
    n_paths: int,
    seed: int | None = None,
) -> np.ndarray:
    """Simulate correlated GBMs. Returns shape (n_paths, n_steps + 1, n_assets)."""
    rng = np.random.default_rng(seed)
    n_assets = len(s0)
    dt = T / n_steps
    L = np.linalg.cholesky(corr)

    z = rng.standard_normal((n_paths, n_steps, n_assets))
    correlated = z @ L.T
    drift = (mu - 0.5 * sigma**2) * dt
    diffusion = sigma * np.sqrt(dt) * correlated
    log_increments = drift + diffusion

    log_paths = np.cumsum(log_increments, axis=1)
    paths = np.empty((n_paths, n_steps + 1, n_assets))
    paths[:, 0, :] = s0
    paths[:, 1:, :] = s0 * np.exp(log_paths)
    return paths


s0 = np.array([100.0, 50.0])
mu = np.array([0.08, 0.05])
sigma = np.array([0.20, 0.30])
corr = np.array([[1.0, 0.6], [0.6, 1.0]])

paths = simulate_multi_gbm(s0, mu, sigma, corr, T=1.0, n_steps=252, n_paths=5000, seed=0)
terminal = paths[:, -1, :]
print(f"Realised correlation of log-returns: {np.corrcoef(np.log(terminal / s0).T)[0, 1]:.3f}")

Multi-asset GBM is the standard model for basket options, index Monte Carlo, and risk-factor scenario generation.

---

Where GBM Breaks Down

GBM is a workable first approximation to real asset dynamics, but it disagrees with the data in well-documented ways.

Fat Tails

Real log-returns have heavier tails than the normal distribution. Empirical kurtosis of daily equity log-returns is routinely 5-10, versus 3 for a normal distribution. Under GBM, six-sigma daily moves should occur roughly once every 500,000 years; in practice they occur every few years.

Volatility Clustering

GBM assumes constant (\sigma). Real volatility varies over time in an autocorrelated way — quiet periods cluster, as do turbulent ones. GARCH and stochastic-volatility models such as Heston capture this at the cost of tractability.

Volatility Smile

If GBM held, implied volatilities of options on the same underlying would be identical across strikes. In practice, out-of-the-money puts on equity indices trade at much higher implied vols than at-the-money options — the volatility smile or, for equities, the skew. Local-vol, stochastic-vol, and jump-diffusion models are all attempts to fit the observed smile.

Jumps

GBM paths are continuous. Real prices jump — earnings surprises, geopolitical shocks, gap opens. Merton's jump-diffusion model (Merton, 1976) adds a compound Poisson jump term to GBM to address this.

Mean-Reverting Underlyings

Some assets — interest rates, volatility itself, commodity spreads — are more naturally mean-reverting than lognormal. Modelling them with GBM understates the tendency to revert and misprices long-dated derivatives.

Practically, GBM is a good baseline: use it, understand what it misses, and add complexity only when the mispricing matters for the specific application.

---

References

• Baxter, M., & Rennie, A. (1996). Financial Calculus: An Introduction to Derivative Pricing. Cambridge University Press.
• Black, F., & Scholes, M. (1973). The pricing of options and corporate liabilities. Journal of Political Economy, 81(3), 637–654.
• Hull, J. C. (2021). Options, Futures, and Other Derivatives (11th ed.). Pearson.
• Merton, R. C. (1973). Theory of rational option pricing. Bell Journal of Economics and Management Science, 4(1), 141–183.
• Merton, R. C. (1976). Option pricing when underlying stock returns are discontinuous. Journal of Financial Economics, 3(1–2), 125–144.
• Shreve, S. E. (2004). Stochastic Calculus for Finance II: Continuous-Time Models. Springer.

---

Frequently Asked Questions

Why does the drift of log S_t include a variance term?

Because of Jensen's inequality applied through Itô's lemma. The expectation of (e^X) for normal (X) is not (e^{E[X]}); it is (e^{E[X] + \text{Var}[X]/2}). If (\log S_t) has drift (\alpha), then (E[S_t] = S_0 e^{\alpha t + \sigma^2 t / 2}). Requiring (E[S_t] = S_0 e^{\mu t}) forces (\alpha = \mu - \sigma^2 / 2).

What is the difference between arithmetic and geometric Brownian motion?

Arithmetic Brownian motion is (dS_t = \mu dt + \sigma dW_t) — additive noise, normal levels, can go negative. Geometric Brownian motion is (dS_t = \mu S_t dt + \sigma S_t dW_t) — multiplicative noise, log-normal levels, strictly positive. For long-horizon financial applications the multiplicative form is essential.

Can I use GBM for negative-priced assets?

No. GBM produces strictly positive prices. For assets that can go negative — spreads, net cash positions, some commodities — use arithmetic Brownian motion or a Bachelier-style model instead.

How is GBM simulated efficiently at high dimension?

Two tricks. First, use the log-return formulation and cumulative-sum increments (as in the Python snippet above) to avoid step-by-step loops. Second, when simulating correlated assets, pre-compute the Cholesky factor once and reuse it across paths. For very high dimension, factor decompositions (PCA on the correlation matrix, keeping the top (k) factors) reduce the dimensionality of the noise while preserving the dominant covariance structure.

What is the physical vs risk-neutral drift of GBM?

Under the physical measure (\mathbb{P}), the drift is the expected return of the asset, which typically exceeds the risk-free rate by a risk premium. Under the risk-neutral measure (\mathbb{Q}), the drift is exactly the risk-free rate (r). The change of measure is achieved by Girsanov's theorem and is essential to no-arbitrage option pricing.

Is GBM appropriate for modelling interest rates?

Rarely. Interest rates are bounded, mean-reverting, and empirically exhibit distinct regime behaviour. Standard short-rate models such as Vasicek, CIR, and Hull-White use mean-reverting SDEs precisely because GBM would predict rates diverging to infinity or collapsing to zero far more often than they do. GBM is more appropriate for equity prices, commodity spot prices, and FX rates.