American Put Pricing with Early Exercise in a Binomial Tree
Summary
The document explains how to adapt a European option binomial tree to price an American put. In backward induction, each node's value should be the greater of its immediate exercise payoff and the discounted risk-neutral expected value of continuing to hold the option. The sample implementation had used an incorrect expression for the exercise branch, confusing the strike with the underlying asset value.
The correction requires calculating the underlying price at each node and then computing intrinsic value using the option type and strike. The response gives the relevant node-level relationships and identifies where they belong in the recursion, rather than supplying a full revised program. This is a conceptual correction for a basic recombining tree; the document provides no numerical price comparison or discussion of convergence, dividends, or implementation details beyond this early-exercise decision.
Key ideas
- American option nodes compare immediate exercise value with discounted continuation value.
- Continuation value is the risk-neutral expected value of the two successor nodes, discounted by the risk-free rate.
- The exercise payoff must be calculated from the underlying price at the current node and the strike.
- The document focuses on the early-exercise rule and does not assess numerical accuracy or convergence.
Tags
Full text
# Pricing American Put Options via Binomial Tree in Matlab
# Pricing American Put Options via Binomial Tree in Matlab
I currently am completing a Computational Finance Assignment, and am trying to figure out how to alter this Matlab code which prices a European put or call option, in order to price an American Put Option. I honestly thought it would be as simple as placing a `max()` in the backwards recursion step. I don't want you to just provide the altered code, as I'd rather learn, but I have been thinking about this for a while and am at crossroads. I have left my altered code in thus far in the hope that you could point me in the right direction.
```
function price = tree_slow(S0, K, T, r, sigma, opttype, Nsteps)
%
% S0 - current stock price
% K - strike
% T - expiry time
% r - interest rate
% sigma - volatility
% opttype - 0 for a call, otherwise a put
% Nsteps - number of timesteps
%Output
% price : option price
%Practical 1: compute the timestep size (Delta t) and tree parameters
delt = T/Nsteps;
u = exp(sigma * sqrt(delt) );
d = 1./u;
a = exp( r*delt );
p = (a - d)/(u - d);
%vector of payoff and option price in the tree
W = zeros(Nsteps+1,1);
%Practical 1: compute the S value at time T and store it in W
for j=0:Nsteps
W(j+1,1) = S0*u^(j)*d^(Nsteps -j);
end
%Practical 1: compute the payoff
if(opttype == 0)
W = max(W-K,0);
else
W = max(K-W,0);
end
%Practical 2: fill in the backward recursion
for n=Nsteps-1:-1:0%timeloop
%loop over all possible S levels at time t_n
for j=0:n
%instruction: complete the expectation formula
W(j+1,1) = max(K-W(j+2,1),exp(-r*delt)*( p*W(j+2,1) + (1-p)*W(j+1,1) ));
end
end
%instruction: fill in with the right index
price = W(1);
```
## Answer by Quantuple (score 1)
https://quant.stackexchange.com/a/29534
It is as simple as just taking the `max()`. The problem is that you took the wrong one.
You must consider the max between the intrinsic value of the option on the one hand and its discounted continuation value (which is an expectation in the risk-neutral world) on the other.
In your final loop, you should therefore replace the line
```
W(j+1,1) = max(K-W(j+2,1),exp(-r*delt)*( p*W(j+2,1) + (1-p)*W(j+1,1) ));
```
with
```
W(j+1,1) = max(phi, exp(-r*delt)*( p*W(j+2,1) + (1-p)*W(j+1,1) ));
```
where for the tree node `j` at the time iteration `n`
```
w = (+1) * (opttype == 0) + (-1) * (opttype ~= 0) % w = (opttype == 0) ? +1 : -1
S = S0*u^(j)*d^(n-j)
phi = w*(S-K)
```Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.