American Vanilla Option Pricing – Binomial Tree Method

We first divide the American Call option tenor into smaller time steps, each represented as \Delta t.

In each time step, assume underlying asset price may move from initial value S either up to Su with real-world probability q or down to Sd with 1-q.

We assume the annualised risk free rate is r.

At the end of this time step \Delta t, the payoff of the American Call option is

    \[C_{u} = Max(0, Su-K), if\, underlying\, goes\, up\, to\, Su\]

    \[C_{d} = Max(0, Sd-K), if\, underlying\, goes\, down\, to\, Sd\]

We then construct a portfolio with h shares of underlying asset and D amount of cash invested at risk free rate. The initial portfolio cost is hS + D, the portfolio value at end of the time step is hSu + De^{r\Delta t} or hSd + De^{r\Delta t} depending on underlying.

And we can carefully choose below h and D so that this portfolio replicates the payoff of American Call option at end of this time step.

    \[h = \frac{C_{u} - C_{d}}{(c - d)S}\]

    \[D = \frac{uC_{d} -dC_{u}}{(u - d)e^{r\Delta t}}\]

With no arbitrage, the value of the American Call option has to be equal to the portfolio initial cost at beginning of the time step. So we have:

    \[C = hS + D = \frac{C_{u} - C_{d}}{(c - d)} + \frac{uC_{d} -dC_{u}}{(u - d)e^{r\Delta t}} = \frac{pC_{u} + (1-p)C_{d}}{e^{r\Delta t}}\]

with

    \[p = \frac{e^{r\Delta t} - d}{u - d}\]

    \[1 - p = \frac{u - e^{r\Delta t}}{u - d}\]

So we notice that the real-world probability q is NOT in the formula, which means the American Call option prices does not depend on investors’ individual risk preference.

We also notice p is between 0 and 1, and therefore be regarded as the risk neutral probability. And the American Call option price is just the discounted value of future expected payoffs.

In the risk neutral world, p is the probability that underlying asset price goes up to Su, and 1-p is the probability it goes down to Sd. And the current underlying price is just the discounted value of future expected payoffs, i.e.

    \[S = \frac{pSu + (1-p)Sd}{e^{r\Delta t}}\]

which can be simplified as:

    \[e^{r\Delta t} = pu + (1-p)d\]

From our assumption, we know the underlying asset price return over one time step \Delta t follows Binomial distribution, thus the one-step variance of price return is \sigma ^{2}\Delta t.

    \[pu^{2}+(1-p)d^{2} - [pu+(1-p)d]^{2} = \sigma ^{2}\Delta t\]

Cox introduced another condition:

    \[u = \frac{1}{d}\]

Now, from the above 3 equations, we can solve for p,\, u,\, d for given r,\, \sigma,\, \Delta t as below:

    \[u = e^{\sigma \sqrt{t}}\]

    \[d = e^{-\sigma \sqrt{t}}\]

    \[p = \frac{e^{r\Delta t} - d}{u - d}\]

So now we can use above Binomial Tree model to calculate the American Call option price step by step backward from expiry. At each step, we need to evaluate the discounted future expected payoffs and the payoff if we exercise at this step. We take the bigger value of the two as the value for this time step node.

Python code:

def binomialTree(callPut, spot, strike, rate, sigma, tenor, N=2000, american=True):
 
    # Each time step period
    deltaT = float(tenor) / N
    u = np.exp(sigma * np.sqrt(deltaT))
    d = 1.0 / u
    a = np.exp(rate * deltaT)
    p = (a - d) / (u - d)
    oneMinusP = 1.0 - p
 
    # Initialize the arrays
    fs = np.asarray([0.0 for i in xrange(N + 1)])
 
    # Stock tree for calculations of expiration values
    fs2 = np.asarray([(spot * u ** j * d ** (N - j)) for j in xrange(N + 1)])
 
    # Vectorize the strikes to speed up expiration check
    fs3 = np.asarray([float(strike) for i in xrange(N + 1)])
 
    # Compute the Binomial Tree leaves, f_{N, j}
    if callPut == 'Call':
        fs[:] = np.maximum(fs2 - fs3, 0.0)
    else:
        fs[:] = np.maximum(-fs2 + fs3, 0.0)
 
    # Calculate backward the option prices
    for i in xrange(N - 1, -1, -1):
        fs[:-1] = np.exp(-rate * deltaT) * (p * fs[1:] + oneMinusP * fs[:-1])
        fs2[:] = fs2[:] * u
 
        if american:
            # Simply check if the option is worth more alive or dead
            if callPut == 'Call':
                fs[:] = np.maximum(fs[:], fs2[:] - fs3[:])
            else:
                fs[:] = np.maximum(fs[:], -fs2[:] + fs3[:])
 
    return fs[0]

3 thoughts on “American Vanilla Option Pricing – Binomial Tree Method”

  1. Nice post. I was checking continuously this blog and I am impressed! Extremely useful information specially the last part 🙂 I care for such info much. I was looking for this certain info for a long time. Thank you and good luck.

  2. Hola! I’ve been following your site for a long time now and finally got the bravery to go ahead and give you a shout out from Houston Texas! Just wanted to tell you keep up the good job!

  3. I’ve been exploring for a little for any high-quality articles or blog posts on this sort of area . Exploring in Yahoo I at last stumbled upon this website. Reading this information So i’m happy to convey that I have a very good uncanny feeling I discovered exactly what I needed. I most certainly will make certain to do not forget this site and give it a glance regularly.

Leave a Reply

Your email address will not be published.