Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Brownian Motion and Random Walk Models › From Discrete to Continuous: Scaling the Random Walk

Michael BrenndoerferNovember 22, 20255 min read

Quantitative FinanceAll chapters

Part 5 of 15Stochastic Calculus and Pricing Theory

Chapter 26Brownian Motion and Random Walk Models › From Discrete to Continuous: Scaling the Random Walk

Reading section 3 of 10 · From Discrete to Continuous: Scaling the Random Walk · 5 minSection 3 of 10 · 5 min

Section 3 of 10 · 5 min read

Brownian Motion and Random Walk Models › From Discrete to Continuous: Scaling the Random WalkOne section · Sections in this chapter3 / 10 ↓

Sections in this chapter10

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

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 more than a mathematical convenience; it 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 $\Delta x$ (instead of 1)
Steps occur at time intervals of $\Delta t$ (instead of 1)
We observe the process over a fixed time horizon $T$

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

S_T = \sum_{i=1}^{n} X_i \cdot \Delta x

where:

$S_T$ : position at time $T$
$X_i$ : direction of step $i$ ( $\pm 1$ )
$\Delta x$ : size of each step
$n$ : total number of steps ( $T/\Delta t$ )

We now need to determine how $\Delta x$ should scale as $\Delta t$ shrinks. If we keep $\Delta x$ fixed while $\Delta t \to 0$ , the variance of $S_T$ would grow without bound because we're adding more and more independent random variables. Conversely, if we shrink $\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:

\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:

$\text{Var}(S_T)$ : variance of the position at time $T$
$n$ : number of steps
$\Delta x$ : spatial step size
$T$ : total time horizon
$\Delta t$ : time interval between steps

For the variance to remain finite and proportional to $T$ as we take the limit $\Delta t \to 0$ , we need:

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

where:

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

for some constant $\sigma^2$ . This means $\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 $\Delta t$ has magnitude proportional to $\sqrt{\Delta t}$ , which is much larger than $\Delta t$ itself when $\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 coarse scaled random walk paths with 10 discrete steps over the unit interval. — Scaled random walk with 10 steps ($n=10$) over the unit interval. The path is coarse, showing distinct discrete steps.

Three scaled random walk paths with 100 steps showing finer fluctuations over the unit interval. — Scaled random walk with 100 steps ($n=100$). The trajectories resolve finer fluctuations as the spatial and temporal step sizes decrease.

Three scaled random walk paths with 1000 steps appearing nearly continuous at the displayed scale. — Scaled random walk with 1000 steps ($n=1000$). The trajectories appear continuous at the displayed scale while maintaining the same terminal 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.