Friday, April 4, 2008

Pricing American-style Options Using the Least-Squares Monte Carlo Approach

Pricing American-style options has been an important issue in modern finance for a very long time. In theory, an American-style option allows the holder to exercise at any point up to its expiration. This differs from a European-style option in which the holder can only exercise at the expiration date. This basically means that an American option is harder to valuate and is also more valuable, in general. With the Black-Scholes framework, the PDE for a European option has a fixed boundary and can be solved analytically. In contrast, an American-style option has a moving boundary condition, which prevents it from being solved analytically (however, a solution may have been found recently - I'll look into this some more). Thus, one must use numerical methods to approximate values for American-style options.

The most common numerical methods for approximating American options are:
1. Finite difference schemes, and
2. Monte Carlo methods

Throughout this semester, I have looked closely at one method of approximating values for American-options using Monte Carlo methods. The technique was developed by Longstaff and Schwartz (2001) in their paper entitled "Valuing American Options by Simulation: A Simple Least Squares Approach".

To understand their approach, one must realize that the holder of an American option must decide optimally at what point to exercise. That is, at every discrete time step, he must ask himself: Should I exercise now, or continue to hold the option (in hopes of getting a better payoff in the future)? This notion is the very basis behind finding the optimal exercise strategy and consequent value of an American-option. The Least Squares Monte Carlo (LSM) approach determines an approximation to this optimal stopping strategy to value the option, and the empirical results have been very good.

The idea is simple: after randomly generating many stock price paths using Monte Carlo methods, use least squares regression to estimate the conditional payoff to the option holder from continuation. This will allow the holder to compare the payoff of his option from immediate exercise to the expected payoff (found using the regression) from continuation. Naturally, if his expected value from continuation is higher than immediate exercise, he will avoid immediate exercise and continue the life of the option. In this way, the algorithm works backward from the final time step, say N, and creates a regression with time step N-1. The optimal stopping strategy is determined, and then this process is repeated with a regression of time N-1 and N-2. This continues until the optimal stopping strategy is found all the way to time 1. One can then average over these values and the price of the American-option is determined.

The results of this approach (in comparison with those using finite difference schemes) have been very similar. We receive a result that converges to an approximate solution close to the "true" value of the option found using the finite difference schemes, however, it appears the LSM approach necessarily underestimates the value of the option very slightly. This is because we use a finite set of basis functions for the regression and we are finding an approximation to the optimal stopping rule, and not the optimal stopping rule itself.

I could go much more in depth into the math and theory behind the LSM approach and its results, but I'll spare the reader. The purpose of this post is to show that the LSM algorithm is indeed an efficient and relatively simple way to approximate the value of an American-style option. Coding the method is easier than coding finite difference schemes and results are almost as good. Using MATLAB, most trials took up to 20 or 30 minutes max using 100,000 stock price paths generated using Monte Carlo methods and 50 discrete time steps. My trials were completed on my Toshiba laptop (2 GHz Centrino, 1 GB RAM). One would most likely get a convergence result faster coding the LSM algorithm in C++ or FORTRAN.

No comments: