Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

No-Arbitrage Principle and Risk-Neutral Valuation › Multi-Period Binomial Model

Michael BrenndoerferNovember 25, 20258 min read

Quantitative FinanceAll chapters

Part 5 of 15Stochastic Calculus and Pricing Theory

Chapter 28No-Arbitrage Principle and Risk-Neutral Valuation › Multi-Period Binomial Model

Reading section 7 of 12 · Multi-Period Binomial Model · 8 minSection 7 of 12 · 8 min

Section 7 of 12 · 8 min read

No-Arbitrage Principle and Risk-Neutral Valuation › Multi-Period Binomial ModelOne section · Sections in this chapter7 / 12 ↓

Sections in this chapter12

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

The one-period model extends naturally to multiple periods, and gives a flexible framework for pricing American options and path-dependent derivatives. By chaining together many small one-period models, we can approximate arbitrarily complex price dynamics while maintaining the tractability of the binomial approach.

Model StructureLink Copied

Divide the time to expiration $T$ into $n$ steps, each of length $\Delta t = T/n$ . At each step, the stock either goes up by factor $u$ or down by factor $d$ . After $n$ steps, the stock can be at any of $n+1$ different price levels. The tree structure grows exponentially: at step $k$ , there are $k+1$ possible stock prices, corresponding to having experienced $j$ up moves and $k-j$ down moves for each $j$ from 0 to $k$ .

In[14]:

Code

import numpy as np


def binomial_tree_price(S0, K, T, r, u, d, n, option_type="call"):
    """
    Price a European option using the binomial tree model.

    Parameters:
    -----------
    S0 : float - Current stock price
    K : float - Strike price
    T : float - Time to expiration (years)
    r : float - Risk-free rate
    u : float - Up factor per step
    d : float - Down factor per step
    n : int - Number of time steps
    option_type : str - 'call' or 'put'

    Returns:
    --------
    float - Option price
    """
    dt = T / n

    # Risk-neutral probability (per step)
    q = (np.exp(r * dt) - d) / (u - d)

    # Initialize asset prices at maturity
    S = np.array([S0 * (u**j) * (d ** (n - j)) for j in range(n + 1)])

    # Calculate option payoffs at maturity
    if option_type == "call":
        V = np.maximum(S - K, 0)
    else:
        V = np.maximum(K - S, 0)

    # Work backwards through the tree
    for i in range(n - 1, -1, -1):
        V = np.exp(-r * dt) * (q * V[1 : i + 2] + (1 - q) * V[0 : i + 1])

    return V[0]

The algorithm works by backward induction, starting from the known payoffs at expiration and working back to the present. This is the natural approach because at expiration we know exactly what the option is worth (its intrinsic value), and at each earlier node we can compute the value from the risk-neutral formula. The steps are:

Calculate all possible stock prices at expiration
Compute the option payoff at each terminal node
Work backwards: at each earlier node, the option value is the discounted risk-neutral expectation of its values at the two successor nodes

In[15]:

Code

# Multi-period example
n_steps = 50
dt = T / n_steps

sigma = 0.20  # Volatility

# Use same u and d per period (simplified)
u_step = np.exp(sigma * np.sqrt(dt))
d_step = 1 / u_step

call_price_tree = binomial_tree_price(
    S0, K, T, r, u_step, d_step, n_steps, "call"
)
put_price_tree = binomial_tree_price(
    S0, K, T, r, u_step, d_step, n_steps, "put"
)

# Verify Put-Call Parity
parity_diff = call_price_tree - put_price_tree
parity_theoretical = S0 - K * np.exp(-r * T)

Out[16]:

Console

Multi-Period Binomial Tree Pricing
========================================
Number of steps: 50
Time per step: 0.0200 years
Per-step up factor: 1.028688
Per-step down factor: 0.972112

European Call Price: $10.4107
European Put Price: $5.5336

Verifying Put-Call Parity:
C - P = $4.8771
S0 - K×e^(-rT) = $4.8771

The 50-step binomial tree yields call and put prices that satisfy put-call parity. The calculated prices reflect the discrete approximations of the continuous process, and as we increase the number of steps, these values will converge to the Black-Scholes prices. The fact that put-call parity holds confirms that our implementation is internally consistent.

Out[17]:

Visualization

Binomial tree lattice diagram showing stock price evolution over 4 time steps with recombining paths. — Lattice structure of a four-step binomial tree. The recombining nature of the tree implies that paths with the same number of up and down moves reach the same node, preventing the number of states from growing exponentially.

Convergence to Continuous TimeLink Copied

An important property of the binomial model is that as we increase the number of steps, the discrete model converges to a continuous-time model. This convergence is not merely approximate: with the right choice of parameters, the binomial model converges exactly to the continuous-time geometric Brownian motion model. If we choose:

u = e^{\sigma\sqrt{\Delta t}}, \quad d = e^{-\sigma\sqrt{\Delta t}}

where:

$u, d$ : up and down factors
$\sigma$ : volatility of the stock
$\Delta t$ : length of each time step

Then as $n \to \infty$ and $\Delta t \to 0$ , the binomial stock price process converges to geometric Brownian motion:

dS_t = \mu S_t \, dt + \sigma S_t \, dW_t

where:

$dS_t$ : change in stock price
$S_t$ : stock price at time $t$
$\mu$ : drift (expected return)
$dt$ : small time increment
$\sigma$ : volatility
$dW_t$ : increment of a standard Brownian motion

This is the process we studied in the previous chapter on Brownian Motion and Random Walk Models. The binomial model can be viewed as a discretization of this continuous process. As we make the time steps smaller and smaller, the discrete jumps of the binomial model approximate the continuous fluctuations of Brownian motion with increasing accuracy. The binomial option prices converge to the Black-Scholes prices, which we'll derive in the next chapter.

In[18]:

Code

import numpy as np
from scipy.stats import norm


def black_scholes_call(S, K, T, r, sigma):
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)


# Parameters for convergence analysis
sigma_conv = 0.20
steps_range = range(5, 201, 5)
binomial_prices = []

# Calculate prices for increasing number of steps
for n in steps_range:
    dt_n = T / n
    u_n = np.exp(sigma_conv * np.sqrt(dt_n))
    d_n = 1 / u_n
    price = binomial_tree_price(S0, K, T, r, u_n, d_n, n, "call")
    binomial_prices.append(price)

bs_price = black_scholes_call(S0, K, T, r, sigma_conv)

Out[19]:

Visualization

Line chart showing binomial tree call option price versus number of time steps, converging to a horizontal asymptote. — Convergence of binomial tree option prices to the Black-Scholes analytical solution as the number of time steps increases. The oscillatory behavior diminishes as the discrete grid becomes finer, stabilizing at the continuous-time limit.

The oscillation in binomial prices, visible for small numbers of steps, occurs because the discrete lattice can position the strike price differently relative to the nodes. Depending on whether the strike falls near a node or between nodes, the approximation error can be larger or smaller. These oscillations dampen as the number of steps increases, and the price converges smoothly to the Black-Scholes value. In practice, 50-100 steps typically provide sufficient accuracy for most applications.

Key ParametersLink Copied

The key parameters for the Multi-Period Binomial Model are:

n: Number of time steps. Controls the resolution of the tree; higher $n$ converges to continuous-time prices.
σ: Volatility of the underlying asset. Used to calculate the up and down factors ( $u$ and $d$ ) so that the tree matches the asset's variance.
Δt: Time step size ( $T/n$ ). The duration of each step in the tree; as $\Delta t \to 0$ the model converges to the continuous-time geometric Brownian motion.