Stochastic Calculus: Brownian Motion

Learning Objectives

By the end of this section, you will be able to:

1. Explain why classical calculus breaks down when prices wiggle infinitely often, and why a new kind of calculus is needed.
2. Construct Brownian motion as the limit of a rescaled random walk with steps of size $\sqrt{\Delta t}$.
3. State the four defining properties of standard Brownian motion $W(t)$ and recognise why each one is mathematically essential.
4. Derive the identity $(dW)^2 = dt$ from quadratic variation — the single fact that powers Itô calculus.
5. Simulate Brownian motion and Geometric Brownian Motion in NumPy and PyTorch, and recognise these simulations inside every Monte-Carlo option-pricing engine.

The Question Calculus Cannot Answer

In Section 31.1 we wrote down the Black-Scholes PDE as if its $\partial V / \partial t$ and $\partial^2 V / \partial S^2$ terms were just ordinary derivatives. They are not. A stock price $S(t)$ is not a smooth curve — it is a microscopically jagged path that wiggles in every interval, no matter how small. Plot a minute-by-minute price and zoom in; you do not see a straight line, you see another wiggly graph. Zoom in again — still wiggly. The path is nowhere differentiable, and a function with no derivative breaks every chain rule you have ever used.

The big question: How do we do calculus on objects that have no slope? That is the problem stochastic calculus was invented to solve, and Brownian motion is its primary building block — the rough surface every other process is built on top of.

The trick will turn out to be: replace the smooth differential $dx$ with a random differential $dW$, redefine what a derivative means, and pay a single price — the Itô correction $\tfrac{1}{2}\sigma^2 \frac{\partial^2 V}{\partial S^2}$ that appears in Black-Scholes. Everything in this chapter hinges on building $W(t)$ carefully, so let us do that now.

From a Drunkard's Walk to a Stock Price

Forget options for a moment and imagine a drunk standing at the origin of a number line. Every second he flips a fair coin: heads he steps $+1$, tails he steps $-1$. After $N$ seconds his position is

Two textbook facts: $\mathbb{E}[X_N] = 0$ (drift-free), and $\operatorname{Var}(X_N) = N$ (variances add because the steps are independent). So the typical magnitude of his position after $N$ seconds is $\sqrt{N}$, not $N$. This is the famous square-root law of diffusion.

The Magic of the √dt Scaling

Now let us speed the drunk up. Say we want him to take $N$ steps in one second instead of $N$ seconds. If we kept the step size at $\pm 1$, after one second his typical distance would be $\sqrt{N}$, which blows up as $N \to \infty$. Useless — we get infinite wandering.

If instead we made each step $\pm 1/N$, after one second his typical distance would be $\sqrt{N}/N = 1/\sqrt{N} \to 0$. Equally useless — every path collapses to zero.

There is exactly one Goldilocks choice: step size $\pm 1/\sqrt{N}$, i.e. $\pm \sqrt{\Delta t}$ with $\Delta t = 1/N$. Then $\operatorname{Var}(X_N) = N \cdot (1/\sqrt{N})^2 = 1$ — finite and independent of $N$. As $N \to \infty$ these rescaled walks converge in distribution to a non-trivial limit: standard Brownian motion $W(t)$.

The visualizer below lets you watch this convergence happen. Drag the slider for N: each panel keeps the same underlying random sequence but uses 4× more steps. Notice that the overall shape is preserved while finer wiggles appear — that is Donsker's invariance principle in action.

Brownian Motion: The Formal Definition

The limit object we just sketched is a continuous-time stochastic process $W : [0, \infty) \to \mathbb{R}$ characterised by four properties (sometimes called the Wiener-process axioms):

1. Starts at zero. $W(0) = 0$.
2. Independent increments. For any $0 \le s < t \le u < v$, the random variables $W(t) - W(s)$ and $W(v) - W(u)$ are independent. The past tells you nothing about the future jump.
3. Gaussian increments. $W(t) - W(s) \sim \mathcal{N}(0,\, t-s)$. Mean zero, variance equal to the elapsed time.
4. Continuous paths. The map $t \mapsto W(t)$ is (almost surely) continuous. No jumps.

From these four axioms alone, the entire algebra of stochastic integrals follows. Everything you will see in the next sections — Itô's lemma, the Black-Scholes PDE, risk-neutral pricing — is a consequence.

Playing With the Process

Time to get your hands on it. The explorer below simulates either pure Brownian motion $W(t)$ or its multiplicative cousin Geometric Brownian Motion $S(t)$. Each coloured curve is one independent realisation drawn from the distribution described above.

• Switch between W(t) and S(t) with the buttons.
• Slide σ up — paths spread out faster. The dashed band traces $\pm 2\sigma\sqrt{t}$, the 95% envelope.
• Slide steps from 50 to 2000 — finer time grids reveal finer wiggles, but the path's overall shape and ending point stay roughly the same. That is the invariance principle again.
• For S(t) mode, drag μ: the dashed curve is the expected price $\mathbb{E}[S(t)] = S_0 e^{\mu t}$. Individual paths fluctuate around it.
• Click New seed to get a fresh set of paths.

Strange Properties of Brownian Paths

Brownian motion is the source of many counter-intuitive facts. The following four are the ones every quant must internalise:

Quadratic Variation: Why $(dW)^2 = dt$

Take the interval $[0, T]$ and divide it into $N$ sub-intervals of length $\Delta t = T/N$. Form the sum

Each increment $\Delta W_k = W(t_k) - W(t_{k-1})$ is normal with variance $\Delta t$. So $\mathbb{E}[(\Delta W_k)^2] = \Delta t$, and therefore

The variance of $Q_N$ can be computed from the fourth moment of a normal: $\operatorname{Var}(Q_N) = 2N(\Delta t)^2 = 2T \Delta t \to 0$ as $\Delta t \to 0$. So $Q_N$ converges (in mean-square) to the deterministic constant $T$. In differential shorthand:

From W(t) to Stock Prices: Geometric Brownian Motion

Pure Brownian motion is not a great model for stock prices: it can go negative, and it has constant variance per unit time rather than constant percentage variance. The fix is to exponentiate it. Define

This is Geometric Brownian Motion (GBM). It is the process Black and Scholes assumed for the underlying stock — every modern derivatives engine starts here. Three things are worth unpacking:

• It is always positive. $e^x > 0$ for every $x$, no matter how negative $W(t)$ wanders. Stock prices stay above zero — good.
• Log-returns are Gaussian. $\log(S(t)/S_0) = (\mu - \tfrac{1}{2}\sigma^2) t + \sigma W(t) \sim \mathcal{N}\bigl((\mu - \tfrac{1}{2}\sigma^2) t,\, \sigma^2 t\bigr)$. Empirically log-returns of liquid stocks really are roughly normal at short horizons — a major reason the model survives.
• Expected price grows exponentially. $\mathbb{E}[S(t)] = S_0 \, e^{\mu t}$. The $-\tfrac{1}{2}\sigma^2$ correction is exactly what is needed to cancel the convexity of the exponential — this is the first Itô-style correction we will see, and it appears again as the missing term in Black-Scholes.

Switch the explorer above into S(t) mode and play with $\mu$ and $\sigma$. The dashed curve is $\mathbb{E}[S(t)] = S_0 e^{\mu t}$; the coloured paths fluctuate around it.

Worked Example: Hand-Computing a Path

Before you let Python loose, do five steps with a pencil. The example is small enough to redo on a napkin, and it nails down the meaning of every symbol in the simulator.

Plain Python Simulation

We now translate the recipe into NumPy. The exact numbers below come from running this script — they are not approximations, they are the precise output of $\texttt{np.random.seed(0)}$. Click any line on the right and the corresponding explanation card will appear on the left.

1import numpy as np
2import matplotlib.pyplot as plt
3
4np.random.seed(0)
5
6T  = 1.0           # total time horizon (1 year)
7N  = 100           # number of time steps
8dt = T / N         # size of each time step  ->  0.01
9
10# Step 1: draw N independent normal increments,
11# each with mean 0 and variance dt.
12dW = np.random.normal(loc=0.0, scale=np.sqrt(dt), size=N)
13
14# Step 2: the Brownian path is the running sum of those increments.
15W = np.concatenate([[0.0], np.cumsum(dW)])
16
17# Step 3: associated time grid 0, dt, 2dt, ..., T.
18t = np.linspace(0.0, T, N + 1)
19
20print("first 5 dW :", dW[:5].round(4))
21print("first 5 W  :", W[:5].round(4))
22print("W(T)       :", W[-1].round(4))

PyTorch: Batched Path Simulation

Pricing a single derivative typically needs hundreds of thousands of simulated paths. Looping in Python would be glacial; PyTorch lets us draw the entire $(M \times N)$ grid of increments in one CUDA kernel. Here is a tiny example with $M = 4$ paths and $N = 5$ time steps — small enough that you can read every entry. Again, all numbers shown in the explanation cards are the literal output of running this script.

[[ 0.8617,  0.6651,  0.4028, -0.9416, -0.3390],
 [ 0.4822,  0.3581,  0.7516,  0.1591, -0.3071],
 [-0.2206,  0.1080, -0.1036,  0.0187, -0.1125],
 [ 0.3845, -0.1385, -0.1770,  0.3593, -0.2780]]

[[ 0.8617,  1.5269,  1.9297,  0.9881,  0.6490],
 [ 0.4822,  0.8404,  1.5920,  1.7511,  1.4440],
 [-0.2206, -0.1126, -0.2162, -0.1975, -0.3101],
 [ 0.3845,  0.2460,  0.0691,  0.4284,  0.1504]]

[[119.52, 137.35, 149.77, 124.81, 117.33],
 [110.79, 119.73, 139.99, 145.39, 137.55],
 [ 96.26,  98.95,  97.51,  98.46,  96.85],
 [108.64, 106.31, 103.23, 111.59, 106.19]]

1import torch
2
3torch.manual_seed(42)
4
5M, N = 4, 5                 # 4 paths, 5 steps each
6S0, mu, sigma = 100.0, 0.05, 0.20
7T  = 1.0
8dt = T / N                  # 0.2
9
10# Step 1: draw all M*N increments in one call.
11dW = torch.randn(M, N) * (dt ** 0.5)
12
13# Step 2: running sum along the time axis -> W has shape (M, N).
14W = torch.cumsum(dW, dim=1)
15
16# Step 3: time grid 0.2, 0.4, ..., 1.0
17t = torch.arange(1, N + 1).float() * dt
18
19# Step 4: GBM closed form  S_t = S0 * exp((mu - 0.5*sigma^2)*t + sigma*W_t)
20S = S0 * torch.exp((mu - 0.5 * sigma ** 2) * t + sigma * W)
21
22print(S.round(decimals=2))
23print("mean S(T):", S[:, -1].mean().item())

Why Quants Care

Brownian motion is not just a mathematical curiosity — it is the atomic noise model of quantitative finance, physics, and biology. A partial list:

The Big Idea. Every random thing that evolves in continuous time and is driven by independent, mean-zero noise looks locally like a Brownian motion. That is why we spend a whole section on it. Master $W(t)$ and you have the building block for derivative pricing, interest-rate models, diffusion in physics, score-based generative AI, and a great deal of modern probability.

Summary

1. A stock's price wiggles infinitely often — its path is nowhere differentiable. Classical calculus cannot handle this; stochastic calculus can.
2. The rescaled random walk with step size $\sqrt{\Delta t}$ converges to Brownian motion $W(t)$ (Donsker's theorem). The $\sqrt{\Delta t}$ scaling is what keeps variance finite as the time step shrinks.
3. $W(t)$ is defined by four axioms: $W(0)=0$, independent increments, Gaussian increments $\mathcal{N}(0, t-s)$, and continuous paths.
4. The single most important consequence is the quadratic-variation identity $(dW)^2 = dt$. It is the seed of every difference between Itô and Newton-Leibniz calculus.
5. Geometric Brownian Motion $S(t) = S_0 e^{(\mu - \sigma^2/2)t + \sigma W(t)}$ is the standard stock-price model in Black-Scholes. Its expected price grows exponentially at rate $\mu$.
6. A few lines of NumPy or PyTorch are enough to simulate millions of paths — the foundation of every Monte-Carlo derivatives engine in Section 31.8.

Next we promote $(dW)^2 = dt$ into a working tool — Itô's lemma — and use it to write down the SDE for any function of $S(t)$. That is the last missing ingredient before the Black-Scholes PDE falls out almost for free.