## American Vanilla Option Pricing – Binomial Tree Method

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

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

We assume the annualised risk free rate is .

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

We then construct a portfolio with shares of underlying asset and amount of cash invested at risk free rate. The initial portfolio cost is , the portfolio value at end of the time step is or  depending on underlying.

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

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:

with

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 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, is the probability that underlying asset price goes up to , and is the probability it goes down to . And the current underlying price is just the discounted value of future expected payoffs, i.e.

which can be simplified as:

From our assumption, we know the underlying asset price return over one time step follows Binomial distribution, thus the one-step variance of price return is .

Cox introduced another condition:

Now, from the above 3 equations, we can solve for for given as below:

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]

## European Vanilla Option Pricing – Black-Scholes PDE

Assume underlying spot follows Geometric Brownian Motion, i.e.

Let be the call option price. We obtain using Ito Lemma

Construct a delta neutral portfolio (short call option and long underlying), then we have:

If we combine the terms, we will get

Realise is independent of random term , thus portfolio is risk free.
Realise is independent of expected return .

Thus, portfolio should earn the risk free rate of return, i.e.

Therefore, combining with in the previous step, we have below Black-Scholes PDE:

Now we need to solve the above Black-Scholes PDE.

Step 1

Transformation: Let’s introduce new variables , and .

Therefore, the Call option price can be represented using new variables and as .

Now we introduce a new function . We need to find the PDE for  where

By Chain rule for partial derivatives, we have:

Now we plug into the Black-Scholes PDE, then we find the PDE for :

Step 2

Transformation to Heat Equation: Let’s introduce a new function . We need to choose constants so that the PDE of is Heat Equation.

Together with the PDE for , we can derive the PDE for :

To be a Heat Equation, we need to force the last two terms be . Thus

Then we have

Step 3

The solution of PDE is given by Green formula as below:

Step 4

We look at the boundary condition .

Then

which can be integrated as below, where is the cumulative distribution function (CDF) for Normal distribution.

Step 5

From the above steps, we have relation

And from Step 4, we know the result of .

Therefore, we derive as

Now we plug in , , , from previous steps. Finally, Call option price can be represented as

where

Python implementation of Black-Scholes formula:

def ncdf(x):
"""
Cumulative distribution function for the standard normal distribution.
Alternatively, we can use below:
from scipy.stats import norm
norm.cdf(x)
"""
return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0

def npdf(x):
"""
Probability distribution function for the standard normal distribution.
Alternatively, we can use below:
from scipy.stats import norm
norm.pdf(x)
"""
return np.exp(-np.square(x) / 2) / np.sqrt(2 * np.pi)

def blackScholesOptionPrice(callPut, spot, strike, tenor, rate, sigma):
"""
Black-Scholes option pricing
tenor is float in years. e.g. tenor for 6 month is 0.5
"""
d1 = (np.log(spot / strike) + (rate + 0.5 * sigma ** 2) * tenor) / (sigma * np.sqrt(tenor))
d2 = d1 - sigma * np.sqrt(tenor)

if callPut == 'Call':
return spot * ncdf(d1) - strike * np.exp(-rate * tenor) * ncdf(d2)
elif callPut == 'Put':
return -spot * ncdf(-d1) + strike * np.exp(-rate * tenor) * ncdf(-d2)

def blackScholesVega(callPut, spot, strike, tenor, rate, sigma):
""" Black-Scholes vega """
d1 = (np.log(spot / strike) + (rate + 0.5 * sigma ** 2) * tenor) / (sigma * np.sqrt(tenor))
return spot * np.sqrt(tenor) * npdf(d1)

def blackScholesDelta(callPut, spot, strike, tenor, rate, sigma):
""" Black-Scholes delta """
d1 = (np.log(spot / strike) + (rate + 0.5 * sigma ** 2) * tenor) / (sigma * np.sqrt(tenor))
if callPut == 'Call':
return ncdf(d1)
elif callPut == 'Put':
return ncdf(d1) - 1

def blackScholesGamma(callPut, spot, strike, tenor, rate, sigma):
"""" Black-Scholes gamma """
d1 = (np.log(spot / strike) + (rate + 0.5 * sigma ** 2) * tenor) / (sigma * np.sqrt(tenor))
return npdf(d1) / (spot * sigma * np.sqrt(tenor))

## Monte Carlo Methods

### Why

#### Compute function integral

Suppose we want to find the value of:

in some region with volume .
Now, we can estimate this integral by estimating the proportion of random points that fall under , then multiplied by .

### Convergence Rate

The speed Monte Carlo method converges to the correct result as we increase the sample size / number of simulations.

Monte Carlo has convergence rate .

Quasi Monte Carlo has convergence rate .

### Variance Reduction

Reduce the variance of Monte Carlo simulated result with regard to the true result.

#### Increase number of simulations

Not very feasible, as in order to decrease variance / noise linearly, we have to increase simulations exponentially.

#### Quasi Monte Carlo (QMC)

##### Low-discrepancy Sequence
###### Faure Sequence

We take any prime number r where r>=2. Any integer n has a unique expansion with base r. We can then generate a sequence of numbers in the interval [0, 1), which are equally spaced within the interval.

For example, r = 3 and n = 7. We can write 7 in the form of base 3 as below:

Now, if we reflect this number about its “decimal point”, we get a new number in [0, 1):

We keep on doing this for every number n, we will generate a sequence in interval [0, 1). And we observe that the newly generated number keep filling the gaps in proceeding sequence. For example, for n = 1 to 9, we have below Faure Sequence:

In a general form, for any given number n, we can represent n in base r:

Then, we can find the corresponding Faure number in interval [0, 1) as follows:

## European Vanilla Option Pricing – Monte Carlo Methods

1. We use Ito’s Lemma with , then we have

By Ito’s Lemma, we have

1. Therefore, the change of between time 0 and future time T, is normally distributed as following:

Thus, the future underlying price can be written as,

is the noise term from standard normal distribution.

Note, we will take , which is the risk free rate. This means investors are risk neutral and requires risk free return on underlying asset. This is to be consistent with the risk neutral probabilities used in simulation.
Correspondingly, we also use risk free rate in the discount factor in step 5.

1. So now we can simulate the future underlying price at expiry. With European Call or Put boundary condition to calculate the payoff.

1. We then need to discount the future payoff back to present by multiplying a discount factor,

1. The above two steps are repeated many times and its expectation is calculated as the final simulation result.
python code：
def getMCPrice(self):
"""
Determine the option price using a Monte Carlo approach.
The log return of underlying follow Normal distribution.
s_T = s_t * exp((r - 1/2 * sig^2) * (T-t) + sig * sqrt(T-t) * sig_Normal)
"""
calc = np.zeros([self.iterations, 2])
rand = np.random.normal(0, 1, [1, self.iterations])
mult = self.spot * np.exp(self.tenor * (self.rate - 0.5 * self.sigma**2))

if self.callPut == 'Call':
calc[:,1] = mult * np.exp(np.sqrt((self.sigma**2)*self.tenor) * rand) - self.strike
elif self.callPut == 'Put':
calc[:,1] = self.strike - mult*np.exp(np.sqrt((self.sigma**2) * self.tenor) * rand)

avgPayOff = np.sum(np.amax(calc, axis=1)) / float(self.iterations)

return np.exp(-self.rate * self.tenor) * avgPayOff

def getBSPrice(self):
""" Determine the option price using the exact Black-Scholes expression. """
return blackScholesOptionPrice(self.callPut, self.spot, self.strike, self.tenor, self.rate, self.sigma)
We can run the above in Python console：
from option_pricer import EuropeanVanillaPricer
pricer = EuropeanVanillaPricer()
pricer.getMCPrice()
2.1620364099067015
pricer.getBSPrice()
2.1736062697012564
As we can see in the above Monte Carlo simulation, we rely on drawing random numbers, from a Standard Normal distribution.
Alternatively, we can use random numbers from a Uniform distribution, i.e. equal probability of each random number.

To do this, we combine step 3, 4 and 5, the current option price is obtained by integrating the terminal payoff under the risk neutral measure:

In the first line, function is just the payoff condition at expiry. As we are integrating with regard to , which follows Standard Normal distribution, the last term is the probability density function.
In the second line, we just use a new function h of epsilon to make the expression more compact.
In the third line, we do inverse transformation to integrate with regard to the cumulative probability, .

So now it becomes an integral of function over the UNIFORM distribution with range [0, 1].
Now our simulation task becomes taking random number from the Uniform distribution [0, 1], and then calculate integral of function using Monte Carlo.

To be more specific, our task has been changed from calculating

To evaluating

When we use Monte Carlo to estimate function integral, we may run into problem of random number clustering, which essentially leads to Convergence rate of .
To conquer this issue, instead of using pseudo-random numbers, we can use a deterministic sequence, whose numbers are more equally spaced. And this is exactly what Quasi Monte Carlo (QMC) does. More details on the low-discrepancy sequences can be found in this post.

## 用Python计算分析实现波动率和隐含波动率

Python代码可以详见:
class VolatilityPricer():
"""
Realized vol:
Same as Black-Scholes, we assume the underlying follows a Geometric Brownian Motion.
Then its log return follows a Normal distribution, with mean as 0.
We take as input the historical daily underlying prices.
Annualization factor is 252.
Degree of Freedom is 0 as we are calculating the exact realized vol for the given historical period.

Implied vol:
Use Black-Scholes to back out the implied volatility from the given market option price.

"""

def __init__(self):
self.historicalDataBySymbol = dict()
self.dataHub = DataHub()
self.realizedVolBySymbol = dict()

def _calculateRealizedVol(self, ts):
""" Calculate the realized vol from given time series """
pctChange = ts.pct_change().dropna()
logReturns = np.log(1+pctChange)
vol = np.sqrt(np.sum(np.square(logReturns)) / logReturns.size)
annualizedVol = vol * np.sqrt(252)

return annualizedVol

def getRealizedVol(self, startDate=datetime.date.today()-datetime.timedelta(days=30), endDate=datetime.date.today(), symbols=['SPY']):
""" Calculate the realized volatility from historical market data """

for symbol, df in self.historicalDataBySymbol.iteritems():
# Use daily Close to calculate realized vols
realizedVol = self._calculateRealizedVol(df.loc[:, 'Close'])
self.realizedVolBySymbol[symbol] = realizedVol

return self.realizedVolBySymbol

def getImpliedVol(self, optionPrice=17.5, callPut='Call', spot=586.08, strike=585.0, tenor=0.109589, rate=0.0002):
""" Calculate the implied volatility from option market price """
return blackScholesSolveImpliedVol(optionPrice, callPut, spot, strike, tenor, rate)

### 计算股票的实现波动率

from volatility_pricer import VolatilityPricer
vp = VolatilityPricer()
vp.getRealizedVol()
{'SPY': 0.086197389793546381}
vp.getRealizedVol(startDate=datetime.date(2018,1,1))
{'SPY': 0.16562165494524139}

### 计算给定期权的隐含波动率

from volatility_pricer import VolatilityPricer
vp = VolatilityPricer()
vp.getImpliedVol()
0.21921387741959775