Backward Induction in Binomial Option Valuation

# Few questions on Binomial-Lattice Option Valuation


# Few questions on Binomial-Lattice Option Valuation












I have just started applying Binomial-Lattice, however I am yet to fully understand few things. My questions are:

- What is the concept of working backward (left side) from the values in terminal (farthest) nodes at the right side. Why do we need to do backward induction? I started my first node with some value `S`, at say time `t=1`, then all I need to know are the option values anywhere ahead of this time till the option expires. What is the need and meaning of the values obtained by backward induction and how are those different from forward induction?

- Now if I apply backward induction, then the values I get at the starting node (the left most node) is far greater than the values at any other node. What does that mean? Let's take this for example: I start with `S=1.5295e+009` at the starting node, and then after using Binomial-Lattice and doing backward induction, I get `9.9708e+10` at the starting node. Why has it increased this much and what does that imply? If I decrease my time step by two times, then I further get very high values like `-1.235e+25`

- The values that we get in each node as we move ahead of starting node (i.e. the values on the nodes right hand side to left most node) are the value analogues to Present Value (PV) at that time or Net Present Value (NPV)?

EDIT: This is my Matlab code for binomial lattice:

```
function [price,BLOV_lattice]=BLOV_general(S0,K,sigma,r,T,nColumn)

% BLOV stands for Binomial Lattice Option Valuation

%% Constant parameters
del_T=T./nColumn; % where n is the number of columns in binomial lattice
u=exp(sigma.*sqrt(del_T));
d=1./u;
p=(exp(r.*del_T)-d)./(u-d);
a=exp(-r.*del_T);

%% Initializing the lattice
Stree=zeros(nColumn+1,nColumn+1);
BLOV_lattice=zeros(nColumn+1,nColumn+1);

%% Developing the lattice

for i=0:nColumn
    for j=0:i
        Stree(j+1,i+1)=S0.*(u.^j)*(d.^(i-j));
    end
end
for i=0:nColumn
    BLOV_lattice(i+1,nColumn+1)=max(Stree(i+1,nColumn+1)-K,0);
end
for i=nColumn:-1:1
    for j=0:i-1
        BLOV_lattice(j+1,i)=a.*(((1-p).*BLOV_lattice(j+1,i+1))+(p.*BLOV_lattice(j+2,i+1)));
    end
end
price=BLOV_lattice(1,1);
```

EDIT 2 (an additional question): If the binomial lattice is giving me option PV's, and my PV's are supposed to decrease with time, then why does more than half of values in my terminal nodes show an increase in values than what I start with (`=S0`). See the attached picture for values.

## Answer by Brian B (score 1, accepted)

https://quant.stackexchange.com/a/846

Let's start with question (2). If you are not obtaining $S=1.5295e+009$ after backwardation, then you have a bug in your binomial tree code. You may wish to find and eliminate that before proceeding.

One simple check is to make all the terminal nodes have value 1.0. You should obtain that the initial node has value $e^{-rT}$. This assumes, of course, that you are using one of the better tree formulations that does not approximate the interest rate term. Also, check your valuations against one of the online american option pricer website.

Now, the reason you backwardate is, colloquially, that the tree is meant to represent option present-values under a particular set of assumptions and scenarios about how stock prices change. Note that during construction you effectively "forwardate" the stock prices $S$ on the tree (albeit in a trivial manner). Considering the knowledge you start out with for all these stock price scenarios, it is only at the terminal nodes of the tree that the option prices are clearly known with certainty.

The backwardation process is allowing you to form speculative values for the option in nodes / scenarios where you previously did not have a solid idea what the option value is. This whole business is hidden from you in the Black-Scholes formulas, but becomes more explicit in trees due to the need to account for early exercise in the scenarios.

There's a bunch of complicated stochastic calculus and dynamical programming theory behind why the trees you construct are a correct technique for handling the problem of option pricing, but the above should give you a basic idea.