My exposure to options is largely limited to work done in valuing employee share option plans, which is via a binomial model or Monte Carlo simulation (and so apologies in advance for my limited starting point!). The two outputs are the option value and the expected lifetime. Happy with the computed option values – these tie up with the literature, other models, general reasoning, etc.

The binomial model literature (Hull & White, etc.) suggests that the

**expected lifetime**can be calculated using the

**fugit**approach, ie. a risk neutral expected term based on the points at which exercise is expected to happen, where the term is then reset. My calculations show that this gives surprising results, such as an increase in the expected lifetime when the assumed dividend yield increases … hence my posing the following.

There is an old discussion on Willmott.com (archived at https://web.archive.org/web/20150704172739/http://wilmott.com/messageview.cfm?catid=34&threadid=67833) which suggests that using -rho / (option value – delta * current price) is a good approximation … and it definitely does seem to give far more accurate answers! So my questions are:

- Is there an explanation for what this alternative approach is? I’ve read and re-read this old discussion and really just don’t understand. I also can’t find it in the literature.
- Is there a way to approximate this approach in a binomial tree? An extract of my code (dealing with the two loops within the tree) is below. I’m battling to see how this code should be adjusted to take account of what robnavin says in his reply in the old discussion.
- Are there any other accepted means to calculate expected life time of a binomial tree?

Thanks for any pointers that you are able to provide!

Code: Select all

```
double dt = T / N;
double r = exp(risk_free * dt);
double u = exp(sigma * sqrt(dt));
double d = 1 / u;
double p = (exp((risk_free - divrate) * dt) - d) / (u - d);
for (int i = N - 1; i >= 0; i--)
{
for (int j = 0; j <= i; j++)
{
double PV_option_one_period = (p * option_value[i + 1][j + 1] + (1 - p) * option_value[i + 1][j]) / r;
// this is after vesting so note the use of px (determined from exit_post_vesting)
if (i >= VestInt) {
// if option instrinsic value > risk neutral option value, then "optimal" assumes option holder will exercise
// Alternatively if the multiple is hit then option is exercised.
if ((instrinsic_value[i][j] > PV_option_one_period) || (share_price_matrix[i][j] >= strike_price * multiple))
{
option_value[i][j] = instrinsic_value[i][j];
expected_term[i][j] = 0.0;
}
else {
option_value[i][j] = PV_option_one_period;
expected_term[i][j] = (p * expected_term[i + 1][j + 1] + (1 - p) * expected_term[i + 1][j] + dt);
}
}
else {
option_value[i][j] = PV_option_one_period;
expected_term[i][j] = (p * expected_term[i + 1][j + 1] + (1 - p) * expected_term[i + 1][j] + dt);
}
}
}
```