Brownian Motion and Random Walk Models › Brownian Motion (Wiener Process)
Quantitative FinanceAll chapters 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.
A stochastic process is a standard Brownian motion (or Wiener process) if:
-
(starts at origin)
-
has continuous sample paths (no jumps)
-
For , the increment is normally distributed with mean 0 and variance :
where:
- : value of Brownian motion at times and
- : normal distribution with variance
-
For non-overlapping intervals, increments are independent: if , then is independent of
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 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 and is completely independent of what happens between times and , 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 into steps of size , each increment is:
where:
- : change in the process over step
- : value at time step
- : time step size ()
- : normal distribution with variance
We can write this as where 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 to obtain increments of the correct variance.
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)
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 depends only on the length of the interval, not on the starting time . 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: 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 , the joint distribution of is multivariate normal. This is a powerful statement: each individual 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 and is:
where:
- : covariance operator
- : Brownian motion values at times and
- : the smaller of the two time points
This formula has an intuitive interpretation. The covariance between and equals the length of time during which both have been "accumulating randomness" together. If , then and share the randomness from time 0 to time , which is exactly . After time , the additional randomness in is independent of , so it doesn't contribute to their covariance.
Markov Property: The future evolution of depends only on its current value, not on its past history. Formally, conditional on , the future increments are independent of . This "memoryless" property means that knowing the entire path up to time provides no more information about future behavior than knowing just the current value . 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:
where:
- : expected value of given information at time
- : known value at current time
- : future time point
This follows because by the independence of increments. The increment is independent of all information available at time , and its unconditional expectation is zero. Therefore, the conditional expectation of given equals 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:
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)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.

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 , such as a polynomial or a sine wave, the sum of squared increments goes to zero as the partition becomes finer:
where:
- : a differentiable (smooth) function
- : time points in the partition
- : number of intervals in the partition
The intuition is straightforward: for a smooth function, each increment is approximately , so the squared increment is approximately . Summing such terms gives order , which goes to zero as .
For Brownian motion, something entirely different happens. The quadratic variation over converges to :
where:
- : Brownian motion value at time
- : total length of the time interval
- : number of steps
This is often written in differential form as , a shorthand that captures the essential relationship.
The intuition is that while each increment is small (of order ), there are of them. When we square the increments, each contributes order , and summing terms gives order . More precisely, each has expected value , 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 correction that appears in option pricing formulas.
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.0Quadratic 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.000000As the number of steps increases, the quadratic variation converges to with decreasing variance. This deterministic limit of a random quantity is a remarkable feature of Brownian motion.

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 , the typical change in position is of order , not . The "derivative" would be:
where:
- : value of Brownian motion at time
- : small time increment
- : indicates the order of magnitude
As , 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 as an ordinary derivative. Instead, we work with the differential itself, leading to stochastic differential equations rather than ordinary ones. The notation does not mean an infinitesimal change divided by an infinitesimal time; it is a fundamentally different mathematical object that requires new rules for manipulation.


