Many financial contracts come with the right of exercising a right prematurely. Such early exercise rights are a clear advantage for the option holder. But, these rights create optimal stopping problems for the contract parties. Is this really an advantage? In the following, I will show you a little example from my last shopping trip and what we can learn from it for the design of financial products.

Background

Many types of traded financial options include early exercise rights. Examples are index options, which are often early exercisable. People call these put or call options American options in contrast to European options, which are only exercisable at maturity. This feature is also common in many warrant types, and many OTC contracts. Even more complex are e.g. convertible bonds, where also the issuer can force conversion.

The main argument for early exercise provisions is that the clients like to have choices. Therefore, people often argue that one should always structure financial instruments in a way that the holder can exercise early – the product would sell at a higher price. But, this is not always the case. E.g. the cost of the early exercise feature is not represented correctly in many life insurance contracts and in many mortgages. If the policy holders would start exercising their policies more rationally, the insurance providers might be in deep trouble.

Optimal Stopping

Looking at early exercise decisions, I would like to provide a more visual example: Find a good parking lot at a large supermarket. In many supermarkets, you find a parking like this:

You drive slowly towards the supermarket and at each empty spot (1) you have to decide to park (exercise) or to continue. Continuing the search evolves the risk that you do not find a better spot and you have to drive another full round. A simple solution to this problem is to just take the first empty spot. In a simple numerical example, we find that this strategy would give is the following distribution of distance to the market:

This example uses 10,000 Monte Carlo simulations for finding a parking spot. Since in this example, there is only a 10% chance that each spot is empty, we often find a very bad spot (e.g. more than 1,000 of 10,000 park at a distance of 20) and sometimes we find no spot at all (about 1.200 written as distance 40). Less than 200 find the best spot with distance 1.

If we would like to improve this result, we can create an optimization problem minimizing the expected distance to the supermarket. I did this writing a little ThetaML which you find in the Appendix below. Now, we find that the maximizing strategy is to pass the first four spots (distance 17 to 20) and then take the next empty spot. This leave us with no one parking at a distance of 17 or further. The probability of getting the best spot at distance 1 is higher – over 200 simulations end here. But, this comes at a cost: More than 1,800 simulations do not find a spot at all and have to go for another round:

A Better Solution

Ok, I invested a lot of knowledge and some programming into optimizing the exercise strategy at the car parking. Is this the best we can do?

There is actually a better solution by rearranging the parking lot:

Now, the simple strategy: Take the first empty spot yields to a much better result:

More than 1,000 of the 10,000 simulations find the best spot at a distance of 1. Less than 200 find a bad spot at a distance of 20 and only 1,200 find no spot at all. This is much better than the previous “optimal” solution. And I do not have to take my laptop with me to find the optimal exercise strategy at each time shopping. I wish parking lot architects could see this…

Taking this idea to the financial options market, what can we do? Maybe, the investors do not want to buy American type early exercise options. They might prefer Lookbacks which guarantee a maximal payout. Think about it!

Appendix

ThetaML simulation code solving the optimal stopping problem.

model parkinglot
 import DriveToMarket
 import NumberOfLots
 import ProbabilityOfFree
 export LotIsFree

 loop NumberOfLots
   if DriveToMarket
     distance = NumberOfLots - @time
   else
     distance = @time + 1
   end

   if rand()>ProbabilityOfFree
     LotIsFree = 0
   else
     LotIsFree = distance
   end
   Theta 1
 end
 LotIsFree = 2 * NumberOfLots
end

 

model FindBestLot
 import NumberOfLots
 import LotIsFree
 export LotTaken
 export Distance

 Distance = E(Distance!)
 loop NumberOfLots
   if LotIsFree>0
     if LotIsFree < E(Distance!)
       Distance = LotIsFree
       LotTaken = @time
     end
   end
   Theta 1
 end
 LotTaken = @time
 Distance = LotIsFree
end