Brownian Motion and Random Walk Models › Brownian Motion (Wiener Process)

Michael BrenndoerferNovember 22, 202515 min read
Quantitative FinanceAll chapters
Part 5 of 15Stochastic Calculus and Pricing Theory
Chapter 26Brownian Motion and Random Walk Models › Brownian Motion (Wiener Process)
Reading section 4 of 10 · Brownian Motion (Wiener Process) · 15 minSection 4 of 10 · 15 min

Book contents

Section 4 of 10 · 15 min read

Brownian Motion and Random Walk Models › Brownian Motion (Wiener Process)One section · Sections in this chapter4 / 10 ↓
Reading tools Definitions & inline links

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.

Article links

Make inline references clickable

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 is 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}t≥0\{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 0≤s<t0 \leq s < t, the increment Wt−WsW_t - W_s is normally distributed with mean 0 and variance t−st - s:

    Wt−Ws∼N(0,t−s)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,t−s)N(0, t-s): normal distribution with variance t−st-s
  4. For non-overlapping intervals, increments are independent: if 0≤t1<t2≤t3<t40 \leq t_1 < t_2 \leq t_3 < t_4, then Wt2−Wt1W_{t_2} - W_{t_1} is independent of Wt4−Wt3W_{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 2≈1.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 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=Wti−Wti−1∼N(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=Δt⋅Zi\Delta W_i = \sqrt{\Delta t} \cdot Z_i where Zi∼N(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 high characteristics that have practical implications for financial modeling. These derived properties follow logically from the four axioms, but they give additional insight into the nature of the process.

Stationary Increments: The distribution of Wt+s−WtW_{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: each individual WtW_t is normally distributed, and 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+s−WtW_{t+s} - W_t are independent of {Wu:u≤t}\{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[Wt∣Ws]=Wsfor s<t\mathbb{E}[W_t | W_s] = W_s \quad \text{for } s < t

where:

  • E[Wt∣Ws]\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[Wt−Ws∣Ws]=0\mathbb{E}[W_t - W_s | W_s] = 0 by the independence of increments. The increment Wt−WsW_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
Heatmap of Brownian motion covariance matrix with values equal to min(s, t) showing a triangular gradient pattern.
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(ti−1)]2→0as 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 Δt→0\Delta t \to 0.

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

∑i=1n[Wti−Wti−1]2→Tas 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 dWt⋅dWt=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
Log-scale scatter plot showing quadratic variation converging to 1 with shrinking error bars as the number of steps increases.
Convergence of realized quadratic variation to the theoretical value $T=1$. As the partition becomes finer, the mean quadratic variation approaches the dashed theoretical limit and the ±2 standard-deviation error bars shrink, showing concentration around a deterministic 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+Δt−WtΔ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 Δt→0\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
Jagged Brownian motion path over the full unit interval showing overall irregular structure.
Full Brownian motion path over the interval [0, 1]. The trajectory exhibits characteristic roughness and irregularity.
10x zoom of Brownian motion path revealing the same irregular structure at a finer scale.
A 10x zoom of the same path over [0.4, 0.5]. The local structure resembles the global path, illustrating self-similarity.
100x zoom of Brownian motion path confirming self-similar fractal behavior at the finest scale shown.
A 100x zoom over [0.44, 0.45]. The fractal nature is evident as the path remains non-differentiable even at fine scales.