By the end of this chapter, students should be able to:
A one-period model explains the idea of no-arbitrage pricing. A multi-period binomial model explains how pricing becomes dynamic.
At every node of the tree, the same one-period theorem is applied again. This is the mathematical reason that option pricing is naturally recursive: future values are computed first, and current values are obtained by discounting risk-neutral conditional expectations.
In Chapter 3, the stock price moved once. It either went up or down, and a derivative payoff was a vector with two components. In this chapter, the stock moves repeatedly. The model is still simple enough to be computed exactly, but rich enough to introduce dynamic hedging, conditional expectation, American options, and convergence to continuous-time models.
Fix an integer \(N\ge 1\). The trading dates are
\[ 0,1,2,\ldots,N. \]
One period may represent one day, one week, one month, or a small time step \(\Delta t\) in a continuous-time approximation. At each step, the stock price either moves up by a factor \(u\) or down by a factor \(d\):
\[ u>d>0. \]
The bank account grows by the gross risk-free return
\[ R=1+r. \]
Thus one dollar in the bank account at time \(n\) becomes \(R\) dollars at time \(n+1\).
The central no-arbitrage condition is
\[ d<R<u. \]
This condition says that the stock can outperform the bank account in an up move and underperform the bank account in a down move. If this fails, then one asset dominates the other and arbitrage is possible.
Let \(S_n\) denote the stock price at time \(n\). If the stock has moved up \(j\) times and down \(n-j\) times by time \(n\), then
\[ S_n(j)=S_0u^j d^{n-j}, \qquad j=0,1,\ldots,n. \]
There are \(2^n\) possible paths by time \(n\), but only \(n+1\) possible stock prices because many paths lead to the same number of up moves. This is called a recombining tree.
A multi-period binomial stock model consists of parameters
\[ S_0>0,\qquad u>d>0,\qquad R>0,\qquad N\in\mathbb N, \]
and the stock-price process
\[ S_{n+1}= \begin{cases} u S_n, & \text{up move},\\ d S_n, & \text{down move}, \end{cases} \qquad n=0,1,\ldots,N-1. \]
The bank account is
\[ B_n=R^n. \]
Let
\[ S_0=100,\qquad u=1.2,\qquad d=0.8,\qquad N=3. \]
At time \(1\), the possible prices are
\[ 80,\quad 120. \]
At time \(2\), the possible prices are
\[ 64,\quad 96,\quad 144. \]
At time \(3\), the possible prices are
\[ 51.2,\quad 76.8,\quad 115.2,\quad 172.8. \]
The middle values recombine: an up move followed by a down move gives the same price as a down move followed by an up move:
\[ S_0ud=S_0du. \]
A path through the tree is a sequence of up and down moves. Let
\[ \Omega=\{U,D\}^N \]
be the set of all possible paths. A path is written as
\[ \omega=(\omega_1,\omega_2,\ldots,\omega_N), \qquad \omega_k\in\{U,D\}. \]
The information available by time \(n\) is the first \(n\) moves. The corresponding filtration is
\[ \mathcal F_n=\sigma(\omega_1,\ldots,\omega_n), \qquad n=0,1,\ldots,N. \]
A random variable \(X\) is \(\mathcal F_n\)-measurable if its value is known after observing the first \(n\) moves. For example, \(S_n\) is \(\mathcal F_n\)-measurable, while \(S_N\) is usually not \(\mathcal F_n\)-measurable for \(n<N\).
Remark. In this chapter, a node can be indexed by \((n,j)\), where \(n\) is the time and \(j\) is the number of up moves so far. At node \((n,j)\),
\[ S_n(j)=S_0u^jd^{n-j}. \]
A statistical model may assign a physical up probability
\[ \mathbb P(U)=p. \]
This probability describes beliefs about how the stock may actually move. It affects the real-world distribution of future prices and returns. However, the no-arbitrage price of a derivative is not obtained by simply discounting the physical expectation unless \(p\) happens to equal the risk-neutral probability.
The one-period risk-neutral up probability is
\[ q=\frac{R-d}{u-d}. \]
Under the no-arbitrage condition \(d<R<u\), this satisfies
\[ 0<q<1. \]
The risk-neutral probability is not a forecast. It is the probability that makes the discounted stock price a martingale.
The risk-neutral measure \(\mathbb Q\) is the probability measure under which each up move has probability
\[ q=\frac{R-d}{u-d}, \]
and each down move has probability
\[ 1-q=\frac{u-R}{u-d}. \]
In the standard binomial model, the moves are independent under \(\mathbb Q\).
Define the discounted stock price by
\[ \widetilde S_n=\frac{S_n}{B_n}=\frac{S_n}{R^n}. \]
The risk-neutral probability \(q\) is chosen precisely so that
\[ \mathbb E^{\mathbb Q}\left[\widetilde S_{n+1}\mid \mathcal F_n\right]=\widetilde S_n. \]
Assume \(d<R<u\) and let
\[ q=\frac{R-d}{u-d}. \]
Then the discounted stock price process \(\widetilde S_n=S_n/R^n\) is a martingale under \(\mathbb Q\).
Proof. At time \(n\), the stock price \(S_n\) is known. Conditional on \(\mathcal F_n\),
\[ S_{n+1}=\begin{cases} u S_n, & \text{with probability }q,\\ dS_n, & \text{with probability }1-q. \end{cases} \]
Therefore
\[ \mathbb E^{\mathbb Q}[S_{n+1}\mid \mathcal F_n] =quS_n+(1-q)dS_n. \]
Since \(q=(R-d)/(u-d)\), we have
\[ qu+(1-q)d=R. \]
Hence
\[ \mathbb E^{\mathbb Q}[S_{n+1}\mid \mathcal F_n]=RS_n. \]
Dividing by \(R^{n+1}\) gives
\[ \mathbb E^{\mathbb Q}\left[\frac{S_{n+1}}{R^{n+1}}\mid \mathcal F_n\right] = \frac{S_n}{R^n}. \]
Thus \(\widetilde S_n\) is a martingale under \(\mathbb Q\).
This theorem is the discrete-time prototype of the continuous-time martingale pricing principle developed later in the book.
A European derivative is a claim whose payoff is determined at the final time \(N\). The payoff may depend on the whole path or only on the terminal stock price.
A European call option with strike \(K\) has payoff
\[ H=(S_N-K)^+. \]
A European put option has payoff
\[ H=(K-S_N)^+. \]
More generally, if the payoff depends only on \(S_N\), we write
\[ H=h(S_N) \]
for some payoff function \(h\).
A European payoff is an \(\mathcal F_N\)-measurable random variable \(H\). If \(H=h(S_N)\) for some function \(h\), the payoff is called path-independent. If \(H\) depends on the whole path \((S_0,S_1,\ldots,S_N)\), it is called path-dependent.
Examples of path-dependent payoffs include Asian options, barrier options, and lookback options. These appear later in the book. In this chapter we mostly focus on path-independent payoffs.
The no-arbitrage price at time \(n\) of a European payoff \(H\) paid at time \(N\) is
\[ V_n=R^{-(N-n)}\mathbb E^{\mathbb Q}[H\mid \mathcal F_n]. \]
Equivalently, the discounted value process is a martingale:
\[ \widetilde V_n=\frac{V_n}{R^n}, \qquad \widetilde V_n= \mathbb E^{\mathbb Q}\left[\widetilde V_N\mid \mathcal F_n\right]. \]
Since \(\widetilde V_N=H/R^N\), this gives
\[ \frac{V_n}{R^n} = \mathbb E^{\mathbb Q}\left[\frac{H}{R^N}\mid \mathcal F_n\right]. \]
Multiplying by \(R^n\) yields the pricing formula above.
In the \(N\)-period binomial model with \(d<R<u\), the unique no-arbitrage price at time \(n\) of a European payoff \(H\) paid at time \(N\) is
\[ V_n=R^{-(N-n)}\mathbb E^{\mathbb Q}[H\mid \mathcal F_n], \]
where \(\mathbb Q\) is the risk-neutral measure with
\[ q=\frac{R-d}{u-d}. \]
The theorem says that the price is a discounted conditional expectation under \(\mathbb Q\), not under the physical measure \(\mathbb P\).
Suppose \(H=h(S_N)\) depends only on the terminal stock price. If there are \(j\) up moves and \(N-j\) down moves, then
\[ S_N(j)=S_0u^jd^{N-j}. \]
Under \(\mathbb Q\), the number of up moves has binomial distribution
\[ J\sim \operatorname{Binomial}(N,q). \]
Therefore
\[ V_0=R^{-N}\sum_{j=0}^N \binom Nj q^j(1-q)^{N-j}h(S_0u^jd^{N-j}). \]
For a European call,
\[ C_0 = R^{-N}\sum_{j=0}^N \binom Nj q^j(1-q)^{N-j} \left(S_0u^jd^{N-j}-K\right)^+. \]
For a European put,
\[ P_0 = R^{-N}\sum_{j=0}^N \binom Nj q^j(1-q)^{N-j} \left(K-S_0u^jd^{N-j}\right)^+. \]
Let
\[ S_0=100,\qquad u=1.2,\qquad d=0.8,\qquad R=1.05, \qquad N=2, \qquad K=100. \]
The risk-neutral probability is
\[ q=\frac{1.05-0.8}{1.2-0.8}=0.625. \]
The terminal stock prices are
\[ S_2(0)=64,\qquad S_2(1)=96,\qquad S_2(2)=144. \]
The call payoffs are
\[ 0,\qquad 0,\qquad 44. \]
Thus
\[ C_0 = 1.05^{-2}\left[\binom 22(0.625)^2(0.375)^0 44\right] =15.5896. \]
The closed-form formula is convenient for path-independent European claims, but dynamic programming is more general. The tree recursion works for European, American, and many path-dependent claims.
Let \(V_n(j)\) be the option value at node \((n,j)\). For a European payoff \(H=h(S_N)\), start at maturity:
\[ V_N(j)=h(S_N(j)), \qquad j=0,1,\ldots,N. \]
Then move backward through the tree. At node \((n,j)\), the next up node is \((n+1,j+1)\) and the next down node is \((n+1,j)\). The value satisfies
\[ V_n(j)=\frac{1}{R}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right]. \]
This is simply the one-period pricing formula applied locally at every node.
Compute terminal payoffs \(V_N(j)=h(S_0u^jd^{N-j})\) for \(j=0,1,\ldots,N\).
For \(n=N-1,N-2,\ldots,0\), compute
\[ V_n(j)=\frac{1}{R}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right], \qquad j=0,1,\ldots,n. \]
The option price is \(V_0(0)\).
The backward induction formula is often more stable and more flexible than explicitly summing binomial probabilities.
Pricing gives the value of a derivative. Hedging gives the portfolio that replicates it.
At node \((n,j)\), suppose the option values one step later are
\[ V_{n+1}(j+1) \quad \text{after an up move}, \]
and
\[ V_{n+1}(j) \quad \text{after a down move}. \]
The stock prices one step later are
\[ u S_n(j),\qquad dS_n(j). \]
We seek a portfolio with \(\Delta_n(j)\) shares of stock and \(B_n(j)\) dollars in the bank account at node \((n,j)\) such that
\[ \Delta_n(j)uS_n(j)+B_n(j)R=V_{n+1}(j+1), \]
\[ \Delta_n(j)dS_n(j)+B_n(j)R=V_{n+1}(j). \]
Subtracting the equations gives the hedge ratio
\[ \Delta_n(j)= \frac{V_{n+1}(j+1)-V_{n+1}(j)}{S_n(j)(u-d)}. \]
The bank-account position is
\[ B_n(j)=\frac{uV_{n+1}(j)-dV_{n+1}(j+1)}{R(u-d)}. \]
The value at node \((n,j)\) is then
\[ V_n(j)=\Delta_n(j)S_n(j)+B_n(j). \]
Remark. The hedge ratio \(\Delta_n(j)\) is not usually constant across the tree. Dynamic hedging means that the portfolio is rebalanced as time passes and information is revealed.
A dynamic trading strategy specifies holdings in the stock and bank account at each node. Let
\[ \Delta_n \]
be the number of shares held over the interval \([n,n+1]\), and let
\[ B_n^{\mathrm{hold}} \]
be the number of dollars invested in the bank account over the same interval.
The portfolio value at time \(n\) is
\[ V_n=\Delta_nS_n+B_n^{\mathrm{hold}}. \]
A strategy is self-financing if changes in the portfolio holdings are paid for only by reallocating wealth within the portfolio, with no external cash added or removed.
In discrete time, this means that after the time-\(n\) portfolio value is realized, the trader may rebalance holdings for the next period, but the cost of the new holdings must equal the available wealth:
\[ \Delta_{n+1}S_{n+1}+B_{n+1}^{\mathrm{hold}} = \Delta_nS_{n+1}+R B_n^{\mathrm{hold}}. \]
This equation is the mathematical expression of dynamic replication.
A hedge ratio formula computes the number of shares to hold over the next period. It does not mean the trader holds the same number of shares for the whole life of the option. In a multi-period model, replication is a dynamic strategy, not a static one.
An American option may be exercised at any time before or at maturity. This changes the pricing problem from conditional expectation to optimal stopping.
Let \(g(S_n)\) be the immediate exercise payoff at time \(n\). For an American put,
\[ g(S_n)=(K-S_n)^+. \]
At maturity, the option value is
\[ V_N(j)=g(S_N(j)). \]
At an earlier node, the holder chooses between immediate exercise and continuation. Therefore
\[ V_n(j)=\max\left\{g(S_n(j)),\;\frac{1}{R}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right]\right\}. \]
The continuation value is the no-arbitrage value of keeping the option alive for one more period.
For an American payoff process \(g(S_n)\), the binomial American option value is defined backward by
\[ V_N(j)=g(S_N(j)), \]
and
\[ V_n(j)=\max\left\{g(S_n(j)),\;R^{-1}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right]\right\}. \]
This backward recursion is the discrete-time Snell envelope.
Let
\[ S_0=100,\quad K=100,\quad u=1.2,\quad d=0.8,\quad R=1.05,\quad N=2. \]
The terminal put payoffs are
\[ 36,\quad 4,\quad 0 \]
at terminal stock prices
\[ 64,\quad 96,\quad 144. \]
At node \((1,0)\), the stock price is \(80\). The immediate exercise value is
\[ 100-80=20. \]
The continuation value is
\[ \frac{1}{1.05}\left[0.625(4)+0.375(36)\right]=15.2381. \]
Therefore early exercise is optimal at this node, and the node value is \(20\).
For European options on a non-dividend-paying stock, put-call parity holds in the binomial model:
\[ C_0-P_0=S_0-KR^{-N}. \]
More generally, at time \(n\) and node \((n,j)\),
\[ C_n(j)-P_n(j)=S_n(j)-KR^{-(N-n)}. \]
Proof. At maturity,
\[ (S_N-K)^+-(K-S_N)^+=S_N-K. \]
Thus a long call and short put have the same terminal payoff as a forward-style position paying \(S_N-K\). The time-\(n\) value of \(S_N\) is \(S_n\) because the stock itself is traded, and the time-\(n\) value of paying \(K\) at time \(N\) is \(KR^{-(N-n)}\). By the law of one price,
\[ C_n-P_n=S_n-KR^{-(N-n)}. \]
American put-call parity is more subtle because early exercise changes the payoff timing.
The next activity builds a binomial tree and prices a European call option by backward induction.
Use the sliders to change model parameters. The plot shows the terminal payoff and the risk-neutral probability mass over terminal stock prices.
The following code builds the recombining stock-price tree as a list of arrays.
import numpy as np
S0 = 100.0
u = 1.20
d = 0.80
N = 4
tree = []
for n in range(N + 1):
level = np.array([S0 * (u ** j) * (d ** (n - j)) for j in range(n + 1)])
tree.append(level)
for n, level in enumerate(tree):
print(f"time {n}:", np.round(level, 4))time 0: [100.]
time 1: [ 80. 120.]
time 2: [ 64. 96. 144.]
time 3: [ 51.2 76.8 115.2 172.8]
time 4: [ 40.96 61.44 92.16 138.24 207.36]The indexing convention is that entry \(j\) in level \(n\) corresponds to \(j\) up moves.
import numpy as np
def binomial_european_option(S0, K, R, u, d, N, option_type="call"):
"""Price a European call or put in the N-period binomial model."""
if not (d < R < u):
raise ValueError("No-arbitrage condition d < R < u is required.")
q = (R - d) / (u - d)
terminal_prices = np.array([S0 * (u ** j) * (d ** (N - j)) for j in range(N + 1)])
if option_type == "call":
values = np.maximum(terminal_prices - K, 0.0)
elif option_type == "put":
values = np.maximum(K - terminal_prices, 0.0)
else:
raise ValueError("option_type must be 'call' or 'put'.")
tree_values = [None] * (N + 1)
tree_values[N] = values.copy()
for n in range(N - 1, -1, -1):
values = (q * values[1:] + (1 - q) * values[:-1]) / R
tree_values[n] = values.copy()
return tree_values[0][0], tree_values
price, value_tree = binomial_european_option(
S0=100, K=100, R=1.05, u=1.2, d=0.8, N=2, option_type="call"
)
print("European call price:", round(price, 6))
for n, values in enumerate(value_tree):
print(f"V_{n}:", np.round(values, 6))European call price: 15.589569
V_0: [15.589569]
V_1: [ 0. 26.190476]
V_2: [ 0. 0. 44.]This example reproduces the two-step call price from Example 4.2.
The next function computes both the option values and the hedge ratios \(\Delta_n(j)\).
import numpy as np
def binomial_values_and_deltas(S0, K, R, u, d, N, option_type="call"):
if not (d < R < u):
raise ValueError("No-arbitrage condition d < R < u is required.")
q = (R - d) / (u - d)
stock_tree = [np.array([S0 * (u ** j) * (d ** (n - j)) for j in range(n + 1)])
for n in range(N + 1)]
terminal = stock_tree[N]
if option_type == "call":
values = np.maximum(terminal - K, 0.0)
else:
values = np.maximum(K - terminal, 0.0)
value_tree = [None] * (N + 1)
delta_tree = [None] * N
value_tree[N] = values.copy()
for n in range(N - 1, -1, -1):
next_values = values
current_prices = stock_tree[n]
deltas = (next_values[1:] - next_values[:-1]) / (current_prices * (u - d))
values = (q * next_values[1:] + (1 - q) * next_values[:-1]) / R
delta_tree[n] = deltas.copy()
value_tree[n] = values.copy()
return stock_tree, value_tree, delta_tree
stock_tree, value_tree, delta_tree = binomial_values_and_deltas(
S0=100, K=100, R=1.05, u=1.2, d=0.8, N=3, option_type="call"
)
print("Option values:")
for n, values in enumerate(value_tree):
print(f"V_{n}:", np.round(values, 4))
print("\nHedge ratios:")
for n, deltas in enumerate(delta_tree):
print(f"Delta_{n}:", np.round(deltas, 4))Option values:
V_0: [21.1235]
V_1: [ 5.3855 32.2562]
V_2: [ 0. 9.0476 48.7619]
V_3: [ 0. 0. 15.2 72.8]
Hedge ratios:
Delta_0: [0.6718]
Delta_1: [0.2827 0.8274]
Delta_2: [0. 0.3958 1. ]The hedge ratios are local slopes of the option value with respect to the stock price along the tree.
import numpy as np
def binomial_american_put(S0, K, R, u, d, N):
if not (d < R < u):
raise ValueError("No-arbitrage condition d < R < u is required.")
q = (R - d) / (u - d)
stock_tree = [np.array([S0 * (u ** j) * (d ** (n - j)) for j in range(n + 1)])
for n in range(N + 1)]
values = np.maximum(K - stock_tree[N], 0.0)
value_tree = [None] * (N + 1)
exercise_tree = [None] * N
value_tree[N] = values.copy()
for n in range(N - 1, -1, -1):
continuation = (q * values[1:] + (1 - q) * values[:-1]) / R
exercise = np.maximum(K - stock_tree[n], 0.0)
values = np.maximum(exercise, continuation)
exercise_tree[n] = exercise > continuation
value_tree[n] = values.copy()
return value_tree[0][0], value_tree, exercise_tree
american_price, amer_values, exercise = binomial_american_put(
S0=100, K=100, R=1.05, u=1.2, d=0.8, N=2
)
print("American put price:", round(american_price, 6))
for n, values in enumerate(amer_values):
print(f"V_{n}:", np.round(values, 6))
for n, ex in enumerate(exercise):
print(f"exercise at time {n}:", ex)American put price: 7.993197
V_0: [7.993197]
V_1: [20. 1.428571]
V_2: [36. 4. 0.]
exercise at time 0: [False]
exercise at time 1: [ True False]The Boolean arrays mark nodes where immediate exercise is better than continuation.
To approximate a continuous-time model over horizon \(T\), we divide time into \(N\) steps of length
\[ \Delta t=\frac{T}{N}. \]
A common Cox–Ross–Rubinstein parameterization is
\[ u=e^{\sigma\sqrt{\Delta t}}, \qquad d=e^{-\sigma\sqrt{\Delta t}}, \qquad R=e^{r\Delta t}. \]
Then
\[ ud=1. \]
The risk-neutral probability is
\[ q=\frac{e^{r\Delta t}-e^{-\sigma\sqrt{\Delta t}}} {e^{\sigma\sqrt{\Delta t}}-e^{-\sigma\sqrt{\Delta t}}}. \]
As \(N\) increases, the binomial model becomes a better discrete approximation to geometric Brownian motion. Later, the Black–Scholes model will arise as a continuous-time limit.
Remark. The binomial model is not only a numerical trick. It is a pedagogical bridge from finite-dimensional no-arbitrage linear algebra to stochastic calculus. Many continuous-time results become easier to understand after seeing their exact discrete-time analogues.
The following activity compares a Cox–Ross–Rubinstein binomial call price with the Black–Scholes call price as the number of steps increases.
import math
import numpy as np
import pandas as pd
def normal_cdf(x):
return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))
def black_scholes_call(S0, K, r, sigma, T):
d1 = (math.log(S0 / K) + (r + 0.5 * sigma**2) * T) / (sigma * math.sqrt(T))
d2 = d1 - sigma * math.sqrt(T)
return S0 * normal_cdf(d1) - K * math.exp(-r * T) * normal_cdf(d2)
def crr_call(S0, K, r, sigma, T, N):
dt = T / N
u = math.exp(sigma * math.sqrt(dt))
d = math.exp(-sigma * math.sqrt(dt))
R = math.exp(r * dt)
q = (R - d) / (u - d)
values = np.array([
max(S0 * (u ** j) * (d ** (N - j)) - K, 0.0)
for j in range(N + 1)
])
for n in range(N - 1, -1, -1):
values = (q * values[1:] + (1 - q) * values[:-1]) / R
return float(values[0])
S0, K, r, sigma, T = 100.0, 100.0, 0.05, 0.20, 1.0
bs = black_scholes_call(S0, K, r, sigma, T)
rows = []
for N in [1, 2, 5, 10, 25, 50, 100, 200]:
price = crr_call(S0, K, r, sigma, T, N)
rows.append({"N": N, "CRR price": price, "BS reference": bs, "error": price - bs})
pd.DataFrame(rows)| N | CRR price | BS reference | error | |
|---|---|---|---|---|
| 0 | 1 | 12.162285 | 10.450584 | 1.711701 |
| 1 | 2 | 9.540501 | 10.450584 | -0.910082 |
| 2 | 5 | 10.805934 | 10.450584 | 0.355350 |
| 3 | 10 | 10.253409 | 10.450584 | -0.197175 |
| 4 | 25 | 10.520966 | 10.450584 | 0.070382 |
| 5 | 50 | 10.410692 | 10.450584 | -0.039892 |
| 6 | 100 | 10.430612 | 10.450584 | -0.019972 |
| 7 | 200 | 10.440591 | 10.450584 | -0.009992 |
The error does not necessarily decrease monotonically at every step, but the general convergence pattern becomes visible as \(N\) grows.
The chapter can be summarized by four equations.
First, the stock tree is
\[ S_n(j)=S_0u^jd^{n-j}. \]
Second, the no-arbitrage condition is
\[ d<R<u. \]
Third, the risk-neutral probability is
\[ q=\frac{R-d}{u-d}. \]
Fourth, the European pricing recursion is
\[ V_n(j)=\frac{1}{R}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right]. \]
The American recursion adds an exercise choice:
\[ V_n(j)=\max\left\{g(S_n(j)),\frac{1}{R}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right]\right\}. \]
Ask an AI system:
Explain why the binomial backward induction formula \(V_n(j)=R^{-1}[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)]\) is a local one-period no-arbitrage pricing formula, not an ordinary physical expectation.
Then check whether the answer clearly distinguishes \(p\) and \(q\).
Ask an AI system to prove that \(\widetilde S_n=S_n/R^n\) is a martingale under \(\mathbb Q\). Then audit the proof using these questions:
Ask an AI system to review your binomial option-pricing function. Require it to check:
values[1:] for up nodes and values[:-1] for down nodes;Ask an AI system to propose unit tests for a binomial pricing implementation. Good tests should include:
The real-world probability \(p\) may be useful for forecasting, risk management, and statistical estimation. The no-arbitrage price uses the risk-neutral probability \(q\).
The recursion is
\[ V_n(j)=R^{-1}\left[qV_{n+1}(j+1)+(1-q)V_{n+1}(j)\right], \]
not merely the weighted average of future values.
There are \(2^n\) paths by time \(n\), but only \(n+1\) nodes in a recombining binomial tree.
A multi-period hedge ratio depends on the node. It is usually written as \(\Delta_n(j)\), not just \(\Delta\).
The multi-period binomial model extends the one-period model by repeating the same no-arbitrage argument at every node. Its essential ingredients are the stock tree, the bank account, the no-arbitrage inequality \(d<R<u\), and the risk-neutral probability
\[ q=\frac{R-d}{u-d}. \]
Under this probability, discounted traded asset prices are martingales. European derivative prices are discounted conditional expectations under \(\mathbb Q\), while American derivative prices are obtained by comparing immediate exercise value with continuation value. The backward induction method is both a pricing algorithm and a mathematical expression of dynamic no-arbitrage.
This chapter prepares the way for the next chapter on discrete-time martingales, where the martingale structure is developed more systematically.