Brownian Motion: From Random Walks to Stock Price Models

Michael BrenndoerferNovember 22, 202550 min read

Build mathematical models for random price movements. Learn simple random walks, Brownian motion properties, and Geometric Brownian Motion for asset pricing.

Reading Level

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Brownian Motion and Random Walk Models

The previous chapter documented the stylized facts of financial returns: fat tails, volatility clustering, and the approximate unpredictability of price movements. Now we turn to building mathematical models that capture at least the essence of these phenomena. The starting point, perhaps surprisingly, comes from 19th-century botany.

In 1827, Scottish botanist Robert Brown observed pollen grains suspended in water through a microscope. The particles moved erratically, jittering in seemingly random directions. This "Brownian motion" puzzled scientists until Einstein's 1905 paper explained it as the cumulative effect of countless molecular collisions, each individually invisible but collectively producing observable random movement.

Finance adopted this framework because stock prices exhibit similar behavior. Each trade, news item, or shift in sentiment acts like a molecular collision, nudging prices in unpredictable directions. The accumulated effect of millions of such nudges produces the irregular price paths we observe in markets.

This chapter builds Brownian motion from the ground up. We start with the simplest possible random process, a coin-flip walk on integers, then show how scaling this discrete model produces continuous Brownian motion in the limit. We then introduce Geometric Brownian Motion (GBM). This model adapts standard Brownian motion for asset prices, which cannot be negative and exhibit percentage returns. GBM forms the foundation for the Black-Scholes option pricing framework we'll develop in later chapters.

The Simple Random Walk

A random walk is exactly what it sounds like: a sequence of steps where each step's direction is determined by chance. The simplest version uses fair coin flips to decide whether to step up or down. Before diving into the formal mathematics, consider the intuition behind this construction. Imagine you are standing at the origin of a number line. You flip a fair coin repeatedly: if it lands heads, you take one step to the right; if tails, one step to the left. After many flips, where do you end up? This deceptively simple question reveals important properties of randomness and diffusive processes.

The random walk serves as our conceptual foundation because it distills randomness to its purest form. Each step is completely independent of every previous step, yet when we observe the accumulated position over time, patterns emerge. The walker tends to drift away from the origin, not because of any systematic force, but simply because random movements accumulate. This phenomenon, where independent random increments sum to produce gradually increasing uncertainty, lies at the heart of all diffusion processes in physics, biology, and finance.

Simple Random Walk

A simple random walk is a discrete-time stochastic process {Sn}n=0\{S_n\}_{n=0}^{\infty} where S0=0S_0 = 0 and:

Sn=Sn1+Xn=i=1nXiS_n = S_{n-1} + X_n = \sum_{i=1}^{n} X_i

where:

  • SnS_n: position of the random walk after nn steps
  • Sn1S_{n-1}: position after n1n-1 steps
  • XiX_i: independent step at time ii, taking values +1+1 or 1-1 with probability 1/21/2
  • nn: current time step

The definition above encapsulates several important ideas. First, the recursive formulation Sn=Sn1+XnS_n = S_{n-1} + X_n tells us that the position at any time depends only on the previous position plus a new random increment. This is the Markov property in its simplest form: the future depends on the present but not on the past. Second, the alternative representation as a sum Sn=i=1nXiS_n = \sum_{i=1}^{n} X_i emphasizes that the current position is simply the cumulative total of all steps taken so far. This summation viewpoint connects directly to the Central Limit Theorem and explains why random walks eventually produce Gaussian distributions.

Starting at zero, after nn steps the walker's position is the sum of nn independent coin flips, each contributing +1+1 (heads) or 1-1 (tails). Let's simulate this process:

In[2]:
Code
import numpy as np


def simple_random_walk(n_steps, n_paths=1):
    """Simulate simple random walks with +1/-1 steps."""
    steps = np.random.choice([-1, 1], size=(n_paths, n_steps))
    positions = np.cumsum(steps, axis=1)
    positions = np.hstack([np.zeros((n_paths, 1)), positions])
    return positions
Out[3]:
Visualization
Line chart showing five random walk paths diverging from zero over 1000 time steps.
Simulated paths of five simple random walks over 1000 discrete time steps. All paths begin at the origin and evolve through independent unit steps (plus or minus 1), demonstrating how random fluctuations accumulate to produce divergent trajectories.

The paths exhibit several notable features. They wander away from zero but occasionally return. Some paths drift predominantly positive or negative over this sample, though with infinite time, a random walk returns to zero infinitely often (a property called recurrence). The paths look "rough" with jagged local movements but smoother trends at larger scales.

Properties of the Simple Random Walk

The mathematical properties of the simple random walk follow directly from the properties of sums of independent random variables, which we covered in the chapter on probability fundamentals. Understanding these properties builds the intuition we need for continuous-time models. Each property tells us something essential about how randomness accumulates over time.

Expected position: The first question we ask about any random process is: what is its average behavior? For a random walk, this amounts to asking where we expect the walker to be after nn steps. Since each individual step has an expected value of zero (heads contributes +1+1 and tails contributes 1-1, each with probability 1/21/2, so E[Xi]=(1/2)(+1)+(1/2)(1)=0\mathbb{E}[X_i] = (1/2)(+1) + (1/2)(-1) = 0), and since expectation is linear, the expected position after nn steps must also be zero:

E[Sn]=E[i=1nXi](definition of Sn)=i=1nE[Xi](linearity of expectation)=0(since E[Xi]=0)\begin{aligned} \mathbb{E}[S_n] &= \mathbb{E}\left[\sum_{i=1}^{n} X_i\right] && \text{(definition of } S_n \text{)} \\ &= \sum_{i=1}^{n} \mathbb{E}[X_i] && \text{(linearity of expectation)} \\ &= 0 && \text{(since } \mathbb{E}[X_i] = 0 \text{)} \end{aligned}

where:

  • E[]\mathbb{E}[\cdot]: expected value operator
  • SnS_n: position after nn steps
  • XiX_i: random step at index ii

This result, while mathematically straightforward, has a profound interpretation. The random walk has no systematic drift: on average, the walker stays at the origin. The coin is fair, so there is no bias pushing the walker in either direction. Yet this does not mean the walker stays near zero. As we shall see, the walker typically wanders quite far from the origin, even though the average position remains zero.

Variance of position: To understand how far the walker typically wanders, we need to compute the variance. Each step has variance Var(Xi)=E[Xi2](E[Xi])2=10=1\text{Var}(X_i) = \mathbb{E}[X_i^2] - (\mathbb{E}[X_i])^2 = 1 - 0 = 1. The variance equals one because the step is either +1+1 or 1-1, so the squared step is always 11, and the squared mean is zero. Since the steps are independent, a fundamental property of variance tells us that the variance of a sum equals the sum of the variances:

Var(Sn)=i=1nVar(Xi)(independence of steps)=i=1n1(variance of single step)=n(sum of n ones)\begin{aligned} \text{Var}(S_n) &= \sum_{i=1}^{n} \text{Var}(X_i) && \text{(independence of steps)} \\ &= \sum_{i=1}^{n} 1 && \text{(variance of single step)} \\ &= n && \text{(sum of } n \text{ ones)} \end{aligned}

where:

  • Var()\text{Var}(\cdot): variance operator
  • SnS_n: position after nn steps
  • XiX_i: random step variable (variance is 1)
  • nn: total number of steps

This reveals a fundamental insight: while the expected position stays at zero, the typical deviation from zero grows like n\sqrt{n}. The standard deviation of the position is Var(Sn)=n\sqrt{\text{Var}(S_n)} = \sqrt{n}, meaning that after 100 steps, the walker is typically about 10 units away from the origin. After 10,000 steps, the typical distance grows to about 100 units. The walker doesn't systematically go anywhere, but uncertainty about its location increases over time. This square-root growth of uncertainty is a universal feature of diffusive processes, appearing in contexts ranging from heat conduction to portfolio theory.

Out[4]:
Visualization
Growth of uncertainty in simple random walks over 500 steps. The standard deviation of the position increases with the square root of time (orange dashed lines), enveloping the majority of the 100 simulated paths (blue lines) and illustrating the diffusive nature of the process.
Growth of uncertainty in simple random walks over 500 steps. The standard deviation of the position increases with the square root of time (orange dashed lines), enveloping the majority of the 100 simulated paths (blue lines) and illustrating the diffusive nature of the process.

Distribution of position: Beyond the mean and variance, we can characterize the entire probability distribution of the walker's position. By the Central Limit Theorem, for large nn, the sum SnS_n of nn independent, identically distributed random variables approaches a normal distribution:

SndN(0,n)S_n \xrightarrow{d} N(0, n)

where:

  • SnS_n: position after nn steps
  • d\xrightarrow{d}: convergence in distribution
  • N(0,n)N(0, n): normal distribution with mean 0 and variance nn

The Central Limit Theorem is a fundamental result in probability theory. It tells us that regardless of the distribution of individual steps (as long as they have finite mean and variance), their sum becomes approximately Gaussian. For our random walk with ±1\pm 1 steps, the convergence is rapid: even after just 30 or 40 steps, the distribution is nearly indistinguishable from a normal distribution. This explains why Gaussian distributions appear so frequently in nature and finance: whenever a quantity is the sum of many small independent contributions, normality emerges.

Let's verify these properties empirically:

In[5]:
Code
import numpy as np

# Simulate many random walks to check distribution
n_paths = 10000
n_steps = 100

walks_many = simple_random_walk(n_steps, n_paths)
final_positions = walks_many[:, -1]  # Position at step 100

# Calculate empirical statistics
theoretical_mean = 0.0
empirical_mean = final_positions.mean()
empirical_std = final_positions.std()
theoretical_std = np.sqrt(n_steps)
Out[6]:
Console
After 100 steps across 10,000 simulations:
  Theoretical mean: 0.000
  Empirical mean:   -0.004
  Theoretical std:  10.000
  Empirical std:    9.980

The empirical mean is close to the theoretical value of zero, and the standard deviation matches the square root of the number of steps (10). This confirms the random walk's diffusive nature.

Out[7]:
Visualization
Histogram of random walk endpoints with overlaid normal distribution curve.
Empirical distribution of random walk positions after 100 steps compared to the theoretical normal distribution. The histogram of 10,000 simulations (blue bars) aligns closely with the Gaussian curve (red line), demonstrating the Central Limit Theorem in action as discrete steps aggregate into a normal distribution.

The empirical distribution matches the theoretical normal distribution well, confirming that the sum of many independent random steps produces Gaussian outcomes.

Independent Increments

A crucial property of random walks is that increments over non-overlapping time intervals are independent. This property is so fundamental that it becomes one of the defining characteristics of Brownian motion, and it has far-reaching implications for financial modeling. To understand what this means, consider two time intervals: from time mm to time nn, and from some earlier time 00 to time mm (where m<nm < n). The change in position from time mm to time nn is:

SnSm=i=m+1nXiS_n - S_m = \sum_{i=m+1}^{n} X_i

where:

  • SnS_n: position at time nn
  • SmS_m: position at time mm (where m<nm < n)
  • XiX_i: independent step at time ii

This increment depends only on steps Xm+1,,XnX_{m+1}, \ldots, X_n, which are independent of all earlier steps X1,,XmX_1, \ldots, X_m. The steps in the future interval have nothing to do with the steps in the past interval because each coin flip is completely independent of all others. Therefore, knowing where the walker was at time mm tells you nothing about how far it will move between mm and nn.

This property has profound implications for financial modeling. If price changes follow a random walk, then past price movements cannot predict future movements: the process is a martingale with respect to its natural filtration. In practical terms, this means that technical analysis based on historical price patterns should not provide systematic profits if prices truly follow a random walk. The market incorporates all past information into the current price, and future price changes depend only on new information, which by definition cannot be predicted from the past.

From Discrete to Continuous: Scaling the Random Walk

Financial markets don't move in discrete integer steps. Prices change in small increments throughout the trading day, and we'd like a model that works in continuous time. The key insight is that if we make the random walk steps smaller and more frequent in the right proportion, the limiting process becomes a well-defined continuous-time object: Brownian motion. This passage from discrete to continuous is not merely a mathematical convenience but reflects the physical intuition that many small random shocks, occurring over short time intervals, aggregate into a smooth random process.

Consider a random walk where:

  • Each step has size Δx\Delta x (instead of 1)
  • Steps occur at time intervals of Δt\Delta t (instead of 1)
  • We observe the process over a fixed time horizon TT

The number of steps in time TT is n=T/Δtn = T/\Delta t. As we let Δt\Delta t become smaller, the number of steps increases correspondingly. The position at time TT is the sum of all these steps:

ST=i=1nXiΔxS_T = \sum_{i=1}^{n} X_i \cdot \Delta x

where:

  • STS_T: position at time TT
  • XiX_i: direction of step ii (±1\pm 1)
  • Δx\Delta x: size of each step
  • nn: total number of steps (T/ΔtT/\Delta t)

Now we face a crucial question: how should we scale Δx\Delta x as Δt\Delta t shrinks? If we keep Δx\Delta x fixed while Δt0\Delta t \to 0, the variance of STS_T would grow without bound because we're adding more and more independent random variables. Conversely, if we shrink Δx\Delta x too quickly, the variance would go to zero and we'd be left with a deterministic process. The right scaling must preserve a finite, meaningful level of randomness.

The variance of this position is:

Var(ST)=n(Δx)2(sum of n independent steps)=TΔt(Δx)2(substitute n=T/Δt)\begin{aligned} \text{Var}(S_T) &= n \cdot (\Delta x)^2 && \text{(sum of } n \text{ independent steps)} \\ &= \frac{T}{\Delta t} \cdot (\Delta x)^2 && \text{(substitute } n = T/\Delta t \text{)} \end{aligned}

where:

  • Var(ST)\text{Var}(S_T): variance of the position at time TT
  • nn: number of steps
  • Δx\Delta x: spatial step size
  • TT: total time horizon
  • Δt\Delta t: time interval between steps

For the variance to remain finite and proportional to TT as we take the limit Δt0\Delta t \to 0, we need:

(Δx)2Δt=σ2\frac{(\Delta x)^2}{\Delta t} = \sigma^2

where:

  • Δx\Delta x: spatial step size
  • Δt\Delta t: time step size
  • σ2\sigma^2: variance scaling constant (volatility squared)

for some constant σ2\sigma^2. This means Δx=σΔt\Delta x = \sigma\sqrt{\Delta t}.

This scaling relationship is the key to understanding why continuous-time models behave differently from ordinary calculus. As time steps shrink, the spatial steps shrink like the square root of time, not linearly. A step over time interval Δt\Delta t has magnitude proportional to Δt\sqrt{\Delta t}, which is much larger than Δt\Delta t itself when Δt\Delta t is small. This creates paths that are continuous but have infinite length over any interval, and are nowhere differentiable. The square-root scaling is the mathematical signature of diffusion, and it underlies all the special rules of stochastic calculus that we'll develop in subsequent chapters.

Let's visualize this convergence:

In[8]:
Code
import numpy as np


def scaled_random_walk(T, n_steps, n_paths=1, sigma=1.0):
    """Simulate scaled random walk converging to Brownian motion."""
    dt = T / n_steps
    dx = sigma * np.sqrt(dt)

    steps = np.random.choice([-1, 1], size=(n_paths, n_steps)) * dx
    positions = np.cumsum(steps, axis=1)
    positions = np.hstack([np.zeros((n_paths, 1)), positions])
    times = np.linspace(0, T, n_steps + 1)
    return times, positions


# Compare different refinement levels
T = 1.0
np.random.seed(123)  # Same seed for visual comparison
Out[9]:
Visualization
Three panel plot showing random walks with 10, 100, and 1000 steps becoming progressively smoother.
Scaled random walk with 10 steps ($n=10$) over the unit interval. The path is coarse, showing distinct discrete steps.
Scaled random walk with 100 steps ($n=100$). The trajectory becomes smoother as the step size decreases.
Scaled random walk with 100 steps ($n=100$). The trajectory becomes smoother as the step size decreases.
Scaled random walk with 1000 steps ($n=1000$). The path converges visually to continuous Brownian motion while maintaining constant variance.
Scaled random walk with 1000 steps ($n=1000$). The path converges visually to continuous Brownian motion while maintaining constant variance.

As we increase the number of steps, the paths become visually smoother. In the limit, we obtain Brownian motion: a continuous process that captures the essential randomness of the discrete walk.

Brownian Motion (Wiener Process)

Standard Brownian motion, also called a Wiener process (after mathematician Norbert Wiener who rigorously constructed it in the 1920s), is the continuous-time limit of the scaled random walk. It serves as the fundamental building block for stochastic calculus in finance. Just as the real numbers emerge as the completion of the rationals, Brownian motion emerges as the natural completion of discrete random walks when we demand continuity and the diffusive scaling property.

The existence of Brownian motion as a well-defined mathematical object is nontrivial. We are asking for a random process that has uncountably many time points, each with a random value, yet maintains consistency across all of them. Wiener's construction showed that such an object exists and is essentially unique, meaning that any process satisfying the defining properties must have the same distribution.

Standard Brownian Motion

A stochastic process {Wt}t0\{W_t\}_{t \geq 0} is a standard Brownian motion (or Wiener process) if:

  1. W0=0W_0 = 0 (starts at origin)

  2. WtW_t has continuous sample paths (no jumps)

  3. For 0s<t0 \leq s < t, the increment WtWsW_t - W_s is normally distributed with mean 0 and variance tst - s:

    WtWsN(0,ts)W_t - W_s \sim N(0, t-s)

    where:

    • Wt,WsW_t, W_s: value of Brownian motion at times tt and ss
    • N(0,ts)N(0, t-s): normal distribution with variance tst-s
  4. For non-overlapping intervals, increments are independent: if 0t1<t2t3<t40 \leq t_1 < t_2 \leq t_3 < t_4, then Wt2Wt1W_{t_2} - W_{t_1} is independent of Wt4Wt3W_{t_4} - W_{t_3}

These four properties completely characterize Brownian motion. Every process satisfying these axioms has the same probabilistic behavior, and these properties are sufficient to derive all other characteristics of the process. Let's unpack what each means:

Property 1 is simply a normalization. We can always shift a Brownian motion to start elsewhere, but the standard version starts at zero. This is analogous to how we define the standard normal distribution to have mean zero and variance one; we can always translate and scale as needed for specific applications.

Property 2 guarantees that sample paths are continuous functions of time. You can trace a Brownian path without lifting your pencil. This is essential for financial modeling since prices don't teleport. There are no jumps or gaps in a Brownian motion path. This continuity, combined with the other properties, creates paths that are continuous but extraordinarily irregular, as we shall see.

Property 3 tells us that the change in position over any time interval is Gaussian, with variance proportional to the length of the interval. The longer you wait, the more uncertain the position becomes, but uncertainty grows with the square root of time. A process that wanders for twice as long doesn't have twice the uncertainty; it has only 21.41\sqrt{2} \approx 1.41 times the uncertainty. This square-root law is fundamental and appears throughout finance, from portfolio volatility to option pricing.

Property 4 is the continuous-time version of the "no memory" property. Past movements don't help predict future movements. What happens between times t1t_1 and t2t_2 is completely independent of what happens between times t3t_3 and t4t_4, as long as these intervals don't overlap. This is the continuous-time analog of independent coin flips in the discrete random walk.

Simulating Brownian Motion

To simulate Brownian motion numerically, we discretize time and generate increments from the appropriate normal distribution. Since we cannot actually compute with continuous time on a digital computer, we approximate Brownian motion by generating its values at a finite set of time points and connecting them. The key insight is that Property 3 tells us exactly what distribution to use for each increment.

If we divide [0,T][0, T] into nn steps of size Δt=T/n\Delta t = T/n, each increment is:

ΔWi=WtiWti1N(0,Δt)\Delta W_i = W_{t_{i}} - W_{t_{i-1}} \sim N(0, \Delta t)

where:

  • ΔWi\Delta W_i: change in the process over step ii
  • WtiW_{t_i}: value at time step ii
  • Δt\Delta t: time step size (T/nT/n)
  • N(0,Δt)N(0, \Delta t): normal distribution with variance Δt\Delta t

We can write this as ΔWi=ΔtZi\Delta W_i = \sqrt{\Delta t} \cdot Z_i where ZiN(0,1)Z_i \sim N(0,1) are standard normal random variables. This representation is particularly useful for implementation because random number generators typically provide standard normal samples. We simply scale them by Δt\sqrt{\Delta t} to obtain increments of the correct variance.

In[10]:
Code
import numpy as np


def brownian_motion(T, n_steps, n_paths=1):
    """Simulate standard Brownian motion paths."""
    dt = T / n_steps
    # Generate increments: sqrt(dt) * standard normal
    dW = np.sqrt(dt) * np.random.randn(n_paths, n_steps)
    # Cumulative sum gives the path
    W = np.cumsum(dW, axis=1)
    # Prepend zeros for W_0 = 0
    W = np.hstack([np.zeros((n_paths, 1)), W])
    times = np.linspace(0, T, n_steps + 1)
    return times, W


# Simulate Brownian motion paths
T = 1.0
n_steps = 1000
n_paths = 5

np.random.seed(42)
times, W = brownian_motion(T, n_steps, n_paths)
Out[11]:
Visualization
Line chart showing five Brownian motion paths from time 0 to 1.
Five independent realizations of standard Brownian motion on the unit interval. The paths exhibit the fractal-like, non-differentiable structure characteristic of the process, starting at zero and wandering continuously without defined trends.

Key Properties of Brownian Motion

Beyond the defining properties, Brownian motion exhibits several remarkable characteristics that have important implications for financial modeling. These derived properties follow logically from the four axioms, but they provide additional insight into the nature of the process.

Stationary Increments: The distribution of Wt+sWtW_{t+s} - W_t depends only on the length ss of the interval, not on the starting time tt. This means the statistical behavior of the process is the same regardless of when you start observing it. Whether you look at the increment from time 0 to time 1 or from time 1000 to time 1001, the distribution is identical: N(0,1)N(0, 1) in both cases. This stationarity reflects the idea that there is nothing special about any particular moment in time; the randomness is homogeneous across the entire timeline.

Gaussian Process: For any collection of times 0<t1<t2<<tn0 < t_1 < t_2 < \cdots < t_n, the joint distribution of (Wt1,Wt2,,Wtn)(W_{t_1}, W_{t_2}, \ldots, W_{t_n}) is multivariate normal. This is a powerful statement: not only is each individual WtW_t normally distributed, but any finite-dimensional collection of values from the process is jointly Gaussian. The entire process is characterized by its mean function (identically zero) and its covariance function. The covariance between WsW_s and WtW_t is:

Cov(Ws,Wt)=min(s,t)\text{Cov}(W_s, W_t) = \min(s, t)

where:

  • Cov(,)\text{Cov}(\cdot, \cdot): covariance operator
  • Ws,WtW_s, W_t: Brownian motion values at times ss and tt
  • min(s,t)\min(s, t): the smaller of the two time points

This formula has an intuitive interpretation. The covariance between WsW_s and WtW_t equals the length of time during which both have been "accumulating randomness" together. If s<ts < t, then WsW_s and WtW_t share the randomness from time 0 to time ss, which is exactly min(s,t)=s\min(s, t) = s. After time ss, the additional randomness in WtW_t is independent of WsW_s, so it doesn't contribute to their covariance.

Markov Property: The future evolution of WtW_t depends only on its current value, not on its past history. Formally, conditional on WtW_t, the future increments Wt+sWtW_{t+s} - W_t are independent of {Wu:ut}\{W_u : u \leq t\}. This "memoryless" property means that knowing the entire path up to time tt provides no more information about future behavior than knowing just the current value WtW_t. The process forgets its history at every instant.

Martingale Property: Brownian motion is a martingale, meaning that the best forecast of the future value is the current value:

E[WtWs]=Wsfor s<t\mathbb{E}[W_t | W_s] = W_s \quad \text{for } s < t

where:

  • E[WtWs]\mathbb{E}[W_t | W_s]: expected value of WtW_t given information at time ss
  • WsW_s: known value at current time ss
  • tt: future time point

This follows because E[WtWsWs]=0\mathbb{E}[W_t - W_s | W_s] = 0 by the independence of increments. The increment WtWsW_t - W_s is independent of all information available at time ss, and its unconditional expectation is zero. Therefore, the conditional expectation of WtW_t given WsW_s equals WsW_s plus zero. The martingale property is central to financial theory because it captures the idea of a "fair game" where, on average, you neither gain nor lose.

Let's verify the covariance structure empirically:

In[12]:
Code
import numpy as np

# Simulate many paths to estimate covariance
np.random.seed(42)
n_paths = 10000
times, W = brownian_motion(T=1.0, n_steps=100, n_paths=n_paths)

# Check covariance at specific time points
t1, t2 = 0.3, 0.7
idx1 = int(t1 * 100)
idx2 = int(t2 * 100)

empirical_cov = np.cov(W[:, idx1], W[:, idx2])[0, 1]
theoretical_cov = min(t1, t2)
Out[13]:
Console
Covariance between W(0.3) and W(0.7):
  Theoretical: min(0.3, 0.7) = 0.3
  Empirical:   0.3007

The empirical covariance closely matches the theoretical value, confirming that the process correlation structure depends on the overlapping time duration.

Out[14]:
Visualization
Covariance structure of standard Brownian motion, Cov(W_s, W_t) = min(s, t). The heatmap shows increasing covariance along the diagonal as time progresses (since variance grows with time), with off-diagonal values determined by the earlier time point, illustrating the non-stationary nature of the process.
Covariance structure of standard Brownian motion, Cov(W_s, W_t) = min(s, t). The heatmap shows increasing covariance along the diagonal as time progresses (since variance grows with time), with off-diagonal values determined by the earlier time point, illustrating the non-stationary nature of the process.

Quadratic Variation

One of the most surprising and important properties of Brownian motion is its quadratic variation. This property is what makes stochastic calculus fundamentally different from ordinary calculus, and understanding it is essential for deriving results like Itô's lemma and the Black-Scholes equation.

For any ordinary smooth function f(t)f(t), such as a polynomial or a sine wave, the sum of squared increments goes to zero as the partition becomes finer:

i=1n[f(ti)f(ti1)]20as n\sum_{i=1}^{n} [f(t_i) - f(t_{i-1})]^2 \to 0 \quad \text{as } n \to \infty

where:

  • f(t)f(t): a differentiable (smooth) function
  • tit_i: time points in the partition
  • nn: number of intervals in the partition

The intuition is straightforward: for a smooth function, each increment is approximately f(ti)Δtf'(t_i) \Delta t, so the squared increment is approximately [f(ti)]2(Δt)2[f'(t_i)]^2 (\Delta t)^2. Summing nn such terms gives order n(Δt)2=TΔtn \cdot (\Delta t)^2 = T \cdot \Delta t, which goes to zero as Δt0\Delta t \to 0.

For Brownian motion, something entirely different happens. The quadratic variation over [0,T][0, T] converges to TT:

i=1n[WtiWti1]2Tas n\sum_{i=1}^{n} [W_{t_i} - W_{t_{i-1}}]^2 \to T \quad \text{as } n \to \infty

where:

  • WtiW_{t_i}: Brownian motion value at time tit_i
  • TT: total length of the time interval [0,T][0, T]
  • nn: number of steps

This is often written in differential form as dWtdWt=dtdW_t \cdot dW_t = dt, a shorthand that captures the essential relationship.

The intuition is that while each increment ΔWi\Delta W_i is small (of order Δt\sqrt{\Delta t}), there are n=T/Δtn = T/\Delta t of them. When we square the increments, each contributes order Δt\Delta t, and summing nn terms gives order nΔt=Tn \cdot \Delta t = T. More precisely, each (ΔWi)2(\Delta W_i)^2 has expected value Δt\Delta t, and by a law of large numbers argument, the sum converges to its expected value as the number of terms grows.

This non-zero quadratic variation is why stochastic calculus differs from ordinary calculus and leads to Itô's lemma, which we'll develop in the next chapter. When we apply the chain rule to a function of Brownian motion, we cannot ignore the second-order terms because the quadratic variation contributes at the same order as the first-order terms. This is the mathematical origin of the mysterious σ2/2-\sigma^2/2 correction that appears in option pricing formulas.

In[15]:
Code
import numpy as np


def quadratic_variation(path, dt):
    """Calculate realized quadratic variation of a path."""
    increments = np.diff(path)
    return np.sum(increments**2)


# Calculate quadratic variation for different refinement levels
T = 1.0
np.random.seed(42)

refinement_levels = [10, 100, 1000, 10000]
qv_values = []

for n_steps in refinement_levels:
    _, W = brownian_motion(T, n_steps, n_paths=1000)
    qv = np.array([quadratic_variation(W[i], T / n_steps) for i in range(1000)])
    qv_values.append((n_steps, qv.mean(), qv.std()))

theoretical_qv = T
theoretical_qv_std = 0.0
Out[16]:
Console
Quadratic Variation over [0, 1]:
==================================================
   n_steps         Mean QV          Std QV
--------------------------------------------------
        10        1.006841        0.452404
       100        1.000053        0.141522
      1000        1.001648        0.044262
     10000        0.999955        0.014361
--------------------------------------------------
Theoretical        1.000000        0.000000

As the number of steps increases, the quadratic variation converges to T=1T = 1 with decreasing variance. This deterministic limit of a random quantity is a remarkable feature of Brownian motion.

Out[17]:
Visualization
Convergence of realized quadratic variation to the theoretical value $T=1$. As the partition of the time interval becomes finer (increasing number of steps), the mean quadratic variation (blue dots) approaches the theoretical limit (red dashed line) and the variance decreases, confirming that quadratic variation becomes deterministic in the limit.
Convergence of realized quadratic variation to the theoretical value $T=1$. As the partition of the time interval becomes finer (increasing number of steps), the mean quadratic variation (blue dots) approaches the theoretical limit (red dashed line) and the variance decreases, confirming that quadratic variation becomes deterministic in the limit.

Nowhere Differentiability

Brownian motion paths are continuous everywhere but differentiable nowhere. This seems paradoxical since continuity usually suggests some smoothness, but Brownian paths are maximally irregular. They are continuous because small changes in time produce small changes in position (no jumps), yet they are so jagged that no tangent line exists at any point.

The intuition comes from the scaling property. Over a small time interval Δt\Delta t, the typical change in position is of order Δt\sqrt{\Delta t}, not Δt\Delta t. The "derivative" would be:

Wt+ΔtWtΔtΔtΔt(scaling property)=1Δt(simplify)\begin{aligned} \frac{W_{t+\Delta t} - W_t}{\Delta t} &\sim \frac{\sqrt{\Delta t}}{\Delta t} && \text{(scaling property)} \\ &= \frac{1}{\sqrt{\Delta t}} && \text{(simplify)} \end{aligned}

where:

  • WtW_t: value of Brownian motion at time tt
  • Δt\Delta t: small time increment
  • \sim: indicates the order of magnitude

As Δt0\Delta t \to 0, this ratio blows up rather than converging. The path oscillates too wildly at every scale for a derivative to exist. If you zoom in on any portion of a Brownian path, you don't see a straight line approximating the curve; instead, you see the same jagged, irregular behavior at the finer scale. This self-similarity at all scales is a hallmark of fractal geometry, and Brownian motion is indeed a fractal object with Hausdorff dimension 1.5.

This has practical implications: we cannot write dWt/dtdW_t/dt as an ordinary derivative. Instead, we work with the differential dWtdW_t itself, leading to stochastic differential equations rather than ordinary ones. The notation dWtdW_t does not mean an infinitesimal change divided by an infinitesimal time; it is a fundamentally different mathematical object that requires new rules for manipulation.

Out[18]:
Visualization
Full Brownian motion path over the interval [0, 1]. The trajectory exhibits characteristic roughness and irregularity.
Full Brownian motion path over the interval [0, 1]. The trajectory exhibits characteristic roughness and irregularity.
A 10x zoom of the same path over [0.4, 0.5]. The local structure resembles the global path, illustrating self-similarity.
A 10x zoom of the same path over [0.4, 0.5]. The local structure resembles the global path, illustrating self-similarity.
A 100x zoom over [0.44, 0.45]. The fractal nature is evident as the path remains non-differentiable even at fine scales.
A 100x zoom over [0.44, 0.45]. The fractal nature is evident as the path remains non-differentiable even at fine scales.

Geometric Brownian Motion

Standard Brownian motion can go negative, which makes it unsuitable for modeling asset prices directly. A stock price of negative $50 is meaningless. We need a modification that ensures prices stay positive and captures the multiplicative nature of returns, where a 10% gain followed by a 10% loss doesn't return you to the starting point. If you start with $100, gain 10% to reach $110, then lose 10%, you end at $99, not $100.

Geometric Brownian Motion (GBM) solves both problems by modeling the logarithm of the price as Brownian motion with drift. By taking the exponential of a process that can range from negative infinity to positive infinity, we obtain a process that ranges from zero to positive infinity, which is exactly the domain of asset prices. The multiplicative structure of percentage returns emerges naturally from this construction.

Geometric Brownian Motion

A stochastic process {St}t0\{S_t\}_{t \geq 0} follows Geometric Brownian Motion if it satisfies the stochastic differential equation:

dSt=μStdt+σStdWtdS_t = \mu S_t \, dt + \sigma S_t \, dW_t

where:

  • StS_t: asset price at time tt
  • μ\mu: drift rate (expected return)
  • σ\sigma: volatility (standard deviation of returns)
  • WtW_t: standard Brownian motion

Equivalently, logSt\log S_t follows Brownian motion with drift.

The stochastic differential equation above deserves careful interpretation. The term μStdt\mu S_t \, dt represents the deterministic drift: if there were no randomness, the price would grow exponentially at rate μ\mu. The term σStdWt\sigma S_t \, dW_t represents the random fluctuations: the price is continuously perturbed by Brownian shocks, with the magnitude of these shocks proportional to the current price level. This proportionality is crucial because it means that a $100 stock and a $1000 stock experiencing the same percentage volatility will have different dollar volatilities.

The solution to this SDE is:

St=S0exp[(μσ22)t+σWt]S_t = S_0 \exp\left[\left(\mu - \frac{\sigma^2}{2}\right)t + \sigma W_t\right]

where:

  • StS_t: asset price at time tt
  • S0S_0: initial asset price
  • μ\mu: drift parameter
  • σ\sigma: volatility parameter
  • WtW_t: value of Brownian motion at time tt

We'll derive this solution rigorously using Itô's lemma in the next chapter. For now, let's understand why this form makes sense and explore its properties.

Why the Drift Adjustment?

You might expect the exponent to simply be μt+σWt\mu t + \sigma W_t, but there's an additional σ2/2-\sigma^2/2 term. This correction arises from the convexity of the exponential function and the non-zero quadratic variation of Brownian motion. It is perhaps the most important example of how stochastic calculus differs from ordinary calculus.

Consider the logarithm of the price process:

Xt=logSt=logS0+(μσ22)t+σWt\begin{aligned} X_t &= \log S_t \\ &= \log S_0 + \left(\mu - \frac{\sigma^2}{2}\right)t + \sigma W_t \end{aligned}

where:

  • XtX_t: log-price at time tt
  • StS_t: price at time tt
  • μσ2/2\mu - \sigma^2/2: drift of the log-price process
  • WtW_t: standard Brownian motion source of noise

This is an arithmetic Brownian motion with drift μσ2/2\mu - \sigma^2/2 and volatility σ\sigma. The σ2/2-\sigma^2/2 term is sometimes called the "Itô correction" or "convexity adjustment."

The drift μ\mu represents the expected instantaneous return E[dSt/St]/dt\mathbb{E}[dS_t/S_t]/dt, but because of Jensen's inequality, the expected log return is lower:

E[log(St/S0)]/t=μσ2/2\mathbb{E}[\log(S_t/S_0)]/t = \mu - \sigma^2/2

where:

  • E[]\mathbb{E}[\cdot]: expected value operator
  • St/S0S_t/S_0: return ratio over time tt
  • μ\mu: arithmetic drift rate
  • σ2/2\sigma^2/2: convexity adjustment

To understand this intuitively, consider what happens to the average of $100 invested in two equally likely scenarios: either the price doubles to $200 or it halves to $50. The arithmetic average outcome is (200 + 50)/2 = $125, representing a 25% gain. But the geometric average (or equivalently, the average of log returns) is 200×50\sqrt{200 \times 50} = $100, representing a 0% gain. The arithmetic mean exceeds the geometric mean whenever there is volatility, and the gap is approximately σ2/2\sigma^2/2.

For typical equity parameters (μ=0.10\mu = 0.10, σ=0.20\sigma = 0.20), the difference is 0.020.02 or 2% per year, which is economically significant. If you earn an expected arithmetic return of 10% per year, you actually experience expected log returns of only 8% per year. Over long horizons, this difference compounds substantially.

Out[19]:
Visualization
Comparison of the expected price (mean) and median price trajectories for a Geometric Brownian Motion process with drift 10% and volatility 20%. The arithmetic mean (blue solid line) exceeds the median (red dashed line) due to the positive skewness of the lognormal distribution, with the widening gap (purple shading) quantifying the impact of the convexity adjustment.
Comparison of the expected price (mean) and median price trajectories for a Geometric Brownian Motion process with drift 10% and volatility 20%. The arithmetic mean (blue solid line) exceeds the median (red dashed line) due to the positive skewness of the lognormal distribution, with the widening gap (purple shading) quantifying the impact of the convexity adjustment.

Simulating GBM

We can simulate GBM in two equivalent ways: directly using the exact solution, or by discretizing the SDE.

Exact simulation: Since we have a closed-form solution, we can generate StS_t directly:

St=S0exp[(μσ22)t+σWt]S_t = S_0 \exp\left[\left(\mu - \frac{\sigma^2}{2}\right)t + \sigma W_t\right]

where:

  • StS_t: simulated price at time tt
  • S0S_0: starting price
  • μ,σ\mu, \sigma: drift and volatility parameters
  • WtW_t: Brownian motion realization

This approach is highly efficient because we only need to simulate the Brownian motion once, then apply the exponential transformation. There is no discretization error because we are using the exact solution at each time point.

Euler discretization: Approximate the SDE over small time steps:

St+ΔtSt+μStΔt+σStΔtZS_{t+\Delta t} \approx S_t + \mu S_t \Delta t + \sigma S_t \sqrt{\Delta t} \, Z

where:

  • St+ΔtS_{t+\Delta t}: price at the next time step
  • StS_t: current price
  • μ\mu: drift rate
  • σ\sigma: volatility
  • Δt\Delta t: time increment
  • ZZ: standard normal random variable

The Euler method approximates the continuous SDE by treating the drift and diffusion terms as constant over each small time step. This introduces discretization error that shrinks as Δt0\Delta t \to 0, but for any finite time step, the approximation is not exact.

The exact method is preferable when possible since it avoids discretization error.

In[20]:
Code
import numpy as np


def gbm_exact(S0, mu, sigma, T, n_steps, n_paths=1):
    """Simulate GBM using the exact solution."""
    dt = T / n_steps
    times = np.linspace(0, T, n_steps + 1)

    # Generate Brownian motion increments
    dW = np.sqrt(dt) * np.random.randn(n_paths, n_steps)
    W = np.cumsum(dW, axis=1)
    W = np.hstack([np.zeros((n_paths, 1)), W])

    # Apply GBM formula
    drift = (mu - 0.5 * sigma**2) * times
    diffusion = sigma * W
    S = S0 * np.exp(drift + diffusion)

    return times, S


# Typical equity parameters
S0 = 100  # Initial price
mu = 0.10  # 10% annual drift
sigma = 0.20  # 20% annual volatility
T = 1.0  # One year

np.random.seed(42)
times, S = gbm_exact(S0, mu, sigma, T, n_steps=252, n_paths=10)
Out[21]:
Visualization
Line chart showing ten GBM stock price paths over one year.
Ten simulated realizations of Geometric Brownian Motion with parameters S_0=100, mu=0.10, and sigma=0.20 over a one-year horizon. Unlike arithmetic Brownian motion, these price paths remain strictly positive and show the compounding effect of returns, with trajectories spreading out as time progresses.

Lognormal Distribution of Prices

Since logSt\log S_t is normally distributed, StS_t itself follows a lognormal distribution. This is a direct consequence of the GBM solution: the exponential of a normal random variable is lognormal. Specifically:

logStN(logS0+(μσ22)t,σ2t)\log S_t \sim N\left(\log S_0 + \left(\mu - \frac{\sigma^2}{2}\right)t, \sigma^2 t\right)

where:

  • logSt\log S_t: natural logarithm of price at time tt
  • N(,)N(\cdot, \cdot): normal distribution notation
  • S0S_0: initial price
  • μ\mu: drift rate
  • σ\sigma: volatility
  • tt: time elapsed
  • logS0+(μσ2/2)t\log S_0 + (\mu - \sigma^2/2)t: mean of the log-price
  • σ2t\sigma^2 t: variance of the log-price

From this, we can derive several important quantities:

  • Expected price: E[St]=S0eμt\mathbb{E}[S_t] = S_0 e^{\mu t}
  • Variance of price: Var(St)=S02e2μt(eσ2t1)\text{Var}(S_t) = S_0^2 e^{2\mu t}(e^{\sigma^2 t} - 1)
  • Median price: Median(St)=S0e(μσ2/2)t\text{Median}(S_t) = S_0 e^{(\mu - \sigma^2/2)t}

The mean exceeds the median because the lognormal distribution is right-skewed. There's a small probability of very large price increases, which pulls the mean above the median. This skewness increases with volatility and time, reflecting the asymmetry between percentage gains and losses: a stock can gain 100% or 200%, but it can only lose at most 100%.

Let's verify the distribution:

In[22]:
Code
import numpy as np

# Simulate many paths to check distribution at T=1
np.random.seed(42)
n_paths = 50000
times, S = gbm_exact(S0, mu, sigma, T=1.0, n_steps=252, n_paths=n_paths)
final_prices = S[:, -1]

# Theoretical values
expected_price = S0 * np.exp(mu * T)
median_price = S0 * np.exp((mu - sigma**2 / 2) * T)
log_mean = np.log(S0) + (mu - sigma**2 / 2) * T
log_std = sigma * np.sqrt(T)

# Empirical values
empirical_mean = final_prices.mean()
empirical_median = np.median(final_prices)
empirical_log_mean = np.log(final_prices).mean()
empirical_log_std = np.log(final_prices).std()
Out[23]:
Console
GBM Distribution at T=1:
==================================================
                        Theoretical      Empirical
--------------------------------------------------
Mean price           $       110.52 $       110.43
Median price         $       108.33 $       108.33
Log mean                     4.6852         4.6845
  Log std:         0.2000         0.1991

The simulation results confirm that while the log-prices are normally distributed, the prices themselves are lognormally distributed. The mean price exceeds the median, reflecting the positive skewness of the lognormal distribution.

Out[24]:
Visualization
Histogram of simulated stock prices with lognormal density overlay.
Empirical distribution of terminal asset prices after one year. The histogram shows the distinct positive skew of the lognormal distribution, with a long right tail representing the limited probability of very large gains.
Histogram of log-prices with normal density overlay.
Empirical distribution of log-prices (log S_T) at the same time horizon. The data aligns with the overlaid normal density curve (red line), confirming that while prices are lognormal, their logarithms are normally distributed.

Returns Under GBM

Under GBM, the log-return over period [t,t+Δt][t, t+\Delta t] is:

rt,t+Δt=logSt+ΔtSt(definition of log-return)=(μσ22)Δt+σ(Wt+ΔtWt)(substitute GBM solution)\begin{aligned} r_{t, t+\Delta t} &= \log\frac{S_{t+\Delta t}}{S_t} && \text{(definition of log-return)} \\ &= \left(\mu - \frac{\sigma^2}{2}\right)\Delta t + \sigma(W_{t+\Delta t} - W_t) && \text{(substitute GBM solution)} \end{aligned}

where:

  • rt,t+Δtr_{t, t+\Delta t}: log-return over the interval
  • St+Δt/StS_{t+\Delta t}/S_t: price ratio
  • Δt\Delta t: length of the time interval
  • Wt+ΔtWtW_{t+\Delta t} - W_t: Brownian increment over the interval

Since the Brownian increment Wt+ΔtWtW_{t+\Delta t} - W_t is normally distributed with mean zero and variance Δt\Delta t, the log-return is normally distributed with mean (μσ2/2)Δt(\mu - \sigma^2/2)\Delta t and variance σ2Δt\sigma^2 \Delta t. This matches one of the stylized facts we discussed in the previous chapter: returns are approximately symmetric and close to normal for moderate return magnitudes.

For small Δt\Delta t, the simple return approximates the log-return:

St+ΔtStStrt,t+Δt\frac{S_{t+\Delta t} - S_t}{S_t} \approx r_{t, t+\Delta t}

where:

  • (St+ΔtSt)/St(S_{t+\Delta t} - S_t)/S_t: simple percentage return
  • rt,t+Δtr_{t, t+\Delta t}: logarithmic return

This approximation follows from the Taylor expansion log(1+x)x\log(1 + x) \approx x for small xx. When the percentage return is small (say, under 10%), the difference between simple and log returns is negligible for most practical purposes.

In[25]:
Code
import numpy as np

# Extract daily returns from simulated paths
daily_returns = np.diff(np.log(S), axis=1).flatten()

# Theoretical values for daily returns (dt = 1/252)
dt = 1 / 252
theoretical_mean = (mu - sigma**2 / 2) * dt
theoretical_std = sigma * np.sqrt(dt)

# Empirical values
from scipy import stats

empirical_mean = daily_returns.mean()
empirical_std = daily_returns.std()
empirical_skew = stats.skew(daily_returns)
empirical_kurt = stats.kurtosis(daily_returns)

theoretical_skew = 0.0
theoretical_kurt = 0.0
Out[26]:
Console
Daily Log-Returns Under GBM:
==================================================
                        Theoretical      Empirical
--------------------------------------------------
Mean                       0.000317       0.000315
Std                        0.012599       0.012599
Skewness                   0.000000      -0.000389
  Excess Kurtosis:       0.000000      -0.000632

The moments of the simulated log-returns match the theoretical values for a normal distribution: mean close to zero, standard deviation consistent with volatility, and negligible skewness and excess kurtosis.

Out[27]:
Visualization
Distribution of simulated daily log-returns generated by the GBM model. The histogram perfectly matches the theoretical normal distribution (red curve), highlighting the model's assumption of Gaussian returns which typically fails to capture the fat tails and skewness observed in real financial markets.
Distribution of simulated daily log-returns generated by the GBM model. The histogram perfectly matches the theoretical normal distribution (red curve), highlighting the model's assumption of Gaussian returns which typically fails to capture the fat tails and skewness observed in real financial markets.

Connecting GBM to Real Market Data

How well does GBM describe actual stock prices? Let's compare simulated GBM paths against real market behavior using the stylized facts from the previous chapter.

We'll calibrate GBM parameters from historical data and examine where the model succeeds and fails.

In[28]:
Code
import numpy as np

# Load S&P 500 data (using yfinance for demonstration)
# In practice, you'd have historical data available
np.random.seed(42)

# Simulate "historical" data that mimics S&P 500 characteristics
# Annual return ~10%, volatility ~16%
n_days = 252 * 10  # 10 years of daily data
true_mu = 0.10
true_sigma = 0.16

_, historical_sim = gbm_exact(
    100, true_mu, true_sigma, T=10, n_steps=n_days, n_paths=1
)
historical_prices = historical_sim[0]

# Calculate daily log returns
log_returns = np.diff(np.log(historical_prices))

# Estimate GBM parameters
dt = 1 / 252
estimated_mu = log_returns.mean() / dt + (log_returns.std() ** 2 / dt) / 2
estimated_sigma = log_returns.std() / np.sqrt(dt)
Out[29]:
Console
GBM Parameter Estimation from 10 Years of Data:
==================================================
Parameter                    True      Estimated
--------------------------------------------------
Drift (μ)                  0.1000         0.1832
Volatility (σ)             0.1600         0.1574

The parameter estimation works well when data truly comes from GBM. But real markets deviate from GBM assumptions in systematic ways.

Key Parameters

The key parameters for the Geometric Brownian Motion model are:

  • S0S_0: Initial asset price. The starting point for the simulation or pricing path.
  • μ: Drift rate (expected return). Represents the annualized average growth rate of the asset.
  • σ: Volatility. The standard deviation of the asset's logarithmic returns, measuring uncertainty.
  • T: Time horizon. The total duration for which the price path is simulated.
  • dt: Time step size. Smaller steps (T/nT/n) lead to more accurate approximations of the continuous process.

Limitations and Impact

Geometric Brownian Motion has been highly influential in quantitative finance, forming the foundation for the Black-Scholes option pricing framework. Yet its limitations are equally important to understand.

GBM assumes returns are normally distributed with constant volatility, but as we documented in the chapter on stylized facts, real returns exhibit fat tails and volatility clustering. Extreme market movements like the 1987 crash or the 2008 financial crisis are orders of magnitude more likely than GBM predicts. A daily return of 20%-20\% is essentially impossible under GBM with typical parameters (σ=0.16\sigma = 0.16 would make this a 25-standard-deviation event), yet such moves do occur. This misspecification matters enormously for risk management and option pricing, particularly for out-of-the-money options where the probability of extreme moves determines value.

The assumption of constant volatility is equally problematic. Real volatility varies over time and tends to cluster: periods of high volatility are followed by more high volatility. The VIX index, which measures implied volatility in S&P 500 options, swings from below 10 in calm markets to above 80 during crises. GBM has no mechanism to capture this variation. Models like GARCH (which we'll explore in later chapters on time series) and stochastic volatility models address this limitation by allowing volatility itself to evolve randomly.

GBM also assumes prices are continuous with no jumps. In reality, prices can gap overnight on earnings announcements or news events. Jump-diffusion models extend GBM by adding occasional discontinuous moves, better matching the observed behavior of individual stocks around events.

Despite these limitations, GBM remains foundational for several reasons. First, it provides closed-form solutions that build intuition. The Black-Scholes formula, which we'll derive in upcoming chapters, shows exactly how option prices depend on underlying price, volatility, and time. This transparency is invaluable for understanding risk sensitivities. Second, GBM is mathematically tractable and serves as a building block for more complex models. Once you understand GBM, you can add stochastic volatility, jumps, or other features to create more realistic models. Third, for many applications, GBM is "good enough." For at-the-money options with short maturities, GBM pricing errors are often within bid-ask spreads. The model's simplicity makes it practical for real-time trading applications where computational speed matters.

The practical lesson is to use GBM as a starting point, not an endpoint. Understand its assumptions, recognize when they fail, and know how to extend the framework when higher accuracy is needed. The options chapter on implied volatility and volatility smiles will show how practitioners implicitly correct for GBM's limitations through the prices they quote.

Summary

This chapter built the mathematical foundation for modeling random price movements in continuous time:

Random walks provide an intuitive starting point. A simple random walk adds independent ±1\pm 1 steps, producing positions with zero mean and variance proportional to time. The Central Limit Theorem ensures that the distribution approaches normal as the number of steps grows.

Brownian motion emerges as the continuous-time limit of appropriately scaled random walks. It is characterized by four properties: starting at zero, continuous paths, normally distributed increments with variance proportional to time, and independence of increments over non-overlapping intervals. The quadratic variation of Brownian motion equals elapsed time rather than zero, a property that underlies all of stochastic calculus.

Geometric Brownian Motion adapts Brownian motion for asset prices by modeling log-prices rather than prices. This ensures prices remain positive and captures the multiplicative nature of returns. Under GBM, prices follow a lognormal distribution and log-returns are normally distributed with constant volatility.

These models provide the mathematical foundation for option pricing theory. In the next chapter, we'll develop Itô's lemma, which tells us how functions of Brownian motion evolve and allows us to derive the Black-Scholes equation for option prices.

Quiz

Ready to test your understanding? Take this quick quiz to reinforce what you've learned about Brownian motion and random walk models.

Loading component...

Reference

BIBTEXAcademic
@misc{brownianmotionfromrandomwalkstostockpricemodels, author = {Michael Brenndoerfer}, title = {Brownian Motion: From Random Walks to Stock Price Models}, year = {2025}, url = {https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion}, organization = {mbrenndoerfer.com}, note = {Accessed: 2025-01-01} }
APAAcademic
Michael Brenndoerfer (2025). Brownian Motion: From Random Walks to Stock Price Models. Retrieved from https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion
MLAAcademic
Michael Brenndoerfer. "Brownian Motion: From Random Walks to Stock Price Models." 2026. Web. today. <https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion>.
CHICAGOAcademic
Michael Brenndoerfer. "Brownian Motion: From Random Walks to Stock Price Models." Accessed today. https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion.
HARVARDAcademic
Michael Brenndoerfer (2025) 'Brownian Motion: From Random Walks to Stock Price Models'. Available at: https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion (Accessed: today).
SimpleBasic
Michael Brenndoerfer (2025). Brownian Motion: From Random Walks to Stock Price Models. https://mbrenndoerfer.com/writing/brownian-motion-random-walk-geometric-brownian-motion