Multilevel Monte Carlo Methodsfor American Options

Simon Gemmrich, PhD

Kellog College

University of Oxford

A thesis submitted in partial fulfillment of the MSc in

Mathematical Finance

November 19, 2012

To my wife Miriam and my son Jakob

Acknowledgements

It is a pleasure to thank my supervisor Prof. Mike Giles for pointing me

in the direction of this fun project and for his thorough help and guidance

while I was working on this thesis. This thesis would not have been

possible without him.

I thank my former employer d-fine GmbH for the opportunity to partici-

pate in the Oxford Math Finance programme.

Above all I thank my wife Miriam for her endless support.

ii

Contents

1 Introduction and scope 1

2 American options 3

2.1 Option basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2 Pricing models for American options . . . . . . . . . . . . . . . . . . 4

2.2.1 Free boundary formulation . . . . . . . . . . . . . . . . . . . . 5

2.2.2 Linear complementarity formulation . . . . . . . . . . . . . . . 6

2.2.3 Optimal stopping formulation . . . . . . . . . . . . . . . . . . 7

2.2.4 Stopping rules and parametric approximations . . . . . . . . . 8

2.3 Finite Difference θ-scheme for American options . . . . . . . . . . . . 10

2.4 The Longstaff-Schwartz algorithm . . . . . . . . . . . . . . . . . . . . 13

3 Multilevel Monte Carlo method 16

3.1 The setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.2 Basic multilevel decomposition . . . . . . . . . . . . . . . . . . . . . . 17

3.3 Monte Carlo estimators . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.4 The multilevel algorithm . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.5 Complexity and convergence theorem . . . . . . . . . . . . . . . . . . 19

4 Numerical implementation for an American put option under a pre-

set exercise strategy 22

4.1 Discretizing the SDE . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.1.1 Exact path simulation for geometric Brownian motion . . . . . 23

4.2 Estimators for a given exercise strategy . . . . . . . . . . . . . . . . . 24

4.3 Numerical example . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.3.1 A brief aside on Brownian bridge construction and Brownian

interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.3.2 Equidistant time grids . . . . . . . . . . . . . . . . . . . . . . 29

4.3.3 Time discretization in transformed coordinates . . . . . . . . . 31

iii

5 Optimizing exercise strategies 35

5.1 Parametric forms for the exercise boundary of an American put option 36

5.2 Stochastic approximation . . . . . . . . . . . . . . . . . . . . . . . . . 38

5.3 The optimization algorithm . . . . . . . . . . . . . . . . . . . . . . . 42

5.4 Numerical examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6 Conclusion 48

A MATLAB code 50

A.1 MLMCAmOp.m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

A.2 MLMCAmOpLevelL.m . . . . . . . . . . . . . . . . . . . . . . . . . . 52

A.3 mlmc AmOp Test.m . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Bibliography 60

iv

Chapter 1

Introduction and scope

The best mathematics is likeliterature - it brings a story to lifebefore your eyes and involves you init, intellectually and emotionally.

Herbert Ellis Robbins

The correct pricing of American style options is still an active field of research

within the quantitative finance world. Unlike for their European counterparts there

exist no general closed form solutions for the value of American put and call options.

Various approaches exist in the literature on how to solve the valuation prob-

lem for American options. They differ greatly in style and spirit. Some are based

on optimal stopping formulations. Others are based on partial differential equation

and free boundary formulations or are phrased as a linear complementarity prob-

lem. Some are purely numerical in nature and employ finite difference schemes or

binomial/trinomial tree methods. Others put more emphasis on the analytical work.

Some approaches end up working with integral equations, in which the early exercise

boundary features as an unknown. One of the most heavily used techniques is the

famous Longstaff-Schwartz algorithm, which is based on Monte Carlo ideas and which

tries to approximate the early exercise boundary by a least squares regression of the

continuation value onto a certain set of basis functions.

The aim of this thesis is to show how the ideas from multilevel Monte Carlo

(MLMC) methods can be used in the valuation of American options. The core idea is

to use and adapt the multilevel Monte Carlo method introduced in [Gil08] and [Gil]

to find the value of an American option under a given exercise rule and then optimize

over all exercise rules from a feasible set.

In the spirit of the above quote by H. E. Robbins we hope to tell a consistent story

and validate it through numerical tests. We work with simple test cases, for which

1

existing solution techniques will most likely outperform our new MLMC approach.

This thesis should be understood as a first step towards a new competitive pricing

algorithm for American options in cases where established finite difference and other

lattice methods fail. Ultimately, it should stand the test against other Monte Carlo

like methods such as the Longstaff-Schwartz approach. Heavy theorem proving and

a full numerical analysis are beyond the scope of this thesis.

The thesis is structured as follows. In Chapter 2 we review some of the known

facts and pricing approaches for American options, thereby setting the stage for the

underlying problem of this thesis. Chapter 3 then introduces the multilevel Monte

Carlo method by Giles and reviews some of its properties. Chapter 4 continues with

the numerical implementation and its intricacies. Finally, Chapter 5 first deals with

stochastic approximation algorithms and then ties the knot around the whole pricing

algorithm and applies the algorithm to several test cases.

2

Chapter 2

American options

In our view, however, derivativesare financial weapons of massdestruction, carrying dangers that,while now latent, are potentiallylethal.

Warren Buffet, 2002

In this chapter we list some well-known facts about American options and set the

stage for their numerical treatment by multilevel Monte Carlo methods.

We start by briefly discussing the necessary options jargon. Afterwards, we men-

tion the most common mathematical pricing frameworks for American options in-

cluding the optimal-stopping formulation on which our numerical algorithm is based.

Moreover, we discuss the finite difference θ-scheme and how it can be used to approx-

imate the price of an American option written on a single underlying. We will later

use the finite difference method to compute benchmark solutions against which we

hold our multilevel method. The chapter ends with a very brief presentation of the

famous Longstaff-Schwartz algorithm.

This chapter is by no means intended as an exhaustive treatment of option intri-

cacies. A nicely written account of option trading strategies is for example [Sin10].

2.1 Option basics

A financial option is a contract between two counterparties. On one side of the

contract there is the option holder (also called the owner of the option) and on the

other side of the contract there is the option seller (also called the writer of the option).

The option contract gives the option holder the right, but not the obligation, to buy

3

or sell an underlying asset for a specified price at a specific time. There is a variety

of option types with different properties.

If the option gives the owner the right to buy the underlying asset it is referred to

as a call option, if it gives the option holder the right to sell the underlying asset it

is called a put option. The predetermined price for the underlying asset is called the

strike price or simply the strike. The option holder buys the contract from the option

seller in exchange for an upfront payment, usually called the option premium. The

fair value of an option is derived from the value of the underlying asset and specific

option characteristics. One of the main characteristics of each option is its exercise

type. If the option can only be exercised on a single date the exercise type and the

option itself are called European, if it can be exercised on several dates the exercise

type and the option are classified as Bermudan and if the option can be exercised at

any time up until its final maturity, the exercise type and the option are referred to

as American.

If an American and a European option are identical except for their exercise

types, then the American option must be worth at least as much as its European

counterpart. After all, the holder of an American option can always choose not to

exercise before expiry, thereby limiting his rights to mimic the European option. A

simple no-arbitrage argument then guarantees that the American option is at least

as valuable as the European one. We note that the inequality here is not strict. The

value of an American call option written on an underlying without dividends turns

out to be equal to the value of the European counterpart.

Assuming that no arbitrage opportunities exist, an American option must always

be at least as valuable as its immediate payoff. Otherwise, an investor could simply

buy the option and exercise it immediately in clear violation of the no-arbitrage

assumption.

Basic options without any special features are classified as plain vanilla.

2.2 Pricing models for American options

The pricing and risk management of American options is still a field of ongoing

research, especially when considering options which are written on more than one

underlying asset. From a theoretical point of view, the pricing problem of an Amer-

ican option can be formulated in various ways. Some of the most common pricing

approaches are based on

• an optimal-stopping formulation,

4

• a dynamic programming formulation,

• a linear complementarity formulation or

• a moving boundary formulation.

The linear complementarity and the moving boundary formulations make use of the

associated partial differential equation and we briefly discuss them in sections 2.2.1

and 2.2.2.

Longstaff and Schwartz introduced their well-known pricing algorithm for Ameri-

can options in [LS01] based on a dynamic programming formulation. The Longstaff-

Schwartz algorithm uses a backward iteration where at every timestep the continua-

tion value of the option is approximated with a least squares fit against a set of basis

functions. We give a very brief introduction to the main ideas behind the Longstaff-

Schwartz algorithm in section 2.4.

Most tree based methods to approximate the value of an American option are also

based on backward iterations. Such methods are simple yet powerful pricing tools.

We will, however, not pursue any tree based methods in this thesis, but instead refer

the reader to [Gla04, 8.3] for detailed information.

With a Monte Carlo approach pricing and managing the risks of American deriva-

tives is far more involved than pricing and managing the risks of European options.

The added difficulty stems from the fact that it is a priori unclear when the option

holder will choose to exercise the option. Also Monte Carlo methods usually work

forward in time whereas most formulations for pricing American derivatives lend

themselves better to methods working backwards on the time scale.

The difference in value between an American derivative and its European equiv-

alent is referred to as the early exercise premium. In contrast to European options

there are generally no closed-form solutions for American option even for plain vanilla

instruments. The pricing of an American option is based on the assumption that a

rational option holder will choose to exercise his right optimally in some sense. Thus,

finding an optimal exercise strategy is at the core of pricing an American option.

Mathematically, this translates into the optimal stopping formulation discussed in

section 2.2.3.

2.2.1 Free boundary formulation

One way to phrase the American options pricing problem is as a free boundary prob-

lem. Here, we sketch this approach for a classical American put option.

5

At every point in time, depending on the current value of the underlying, it is

either optimal to exercise the option or to continue to hold it. Mathematically, the

(t, S) plane can be divided into a hold region (where it is optimal to hold the option)

and an exercise region (where it is optimal to exercise it). The barrier between those

two regions is called the optimal exercise boundary B∗(t).

Denote the fair value of the American put option by Pam and assume that the

underlying price process is a geometric Brownian motion. In this situation the hold

region lies above the exercise boundary B∗(t) in the (t, S) plane. Within the hold

region the value function Pam satisfies the Black-Scholes equation, i.e.

LBS [Pam] :=∂Pam∂t

+1

2σ2 S2 ∂

2Pam∂S2

+ r S∂Pam∂S

− r Pam = 0, (2.1)

where r and σ are the usual drift and volatility parameters from the geometric Brow-

nian motion SDE. At expiry T and along the optimal exercise boundary B∗(t) the

option is worth its payoff, i.e.

Pam(T, S) = max (K − S, 0) and Pam(t, B∗(t)) = max (K −B∗(t), 0) .

The transition between the two regions is smooth, in the sense of the so-called smooth

pasting condition

∂Pam∂S

(t, B∗(t)) = −1.

Since the optimal exercise boundary is not known a priori but must be computed

as part of the solution, the problem is much harder to solve than a simple boundary

value problem.

We note that the smooth pasting condition only holds for options whose payoff

is sufficiently smooth. It does not hold in the case of an American digital put for

example. Another point worth mentioning is that for more complicated American

derivatives the hold region might not be simply connected at all times. Overall,

free boundary problems are hard to solve numerically. We will not consider this

formulation any further.

2.2.2 Linear complementarity formulation

Another way to characterize the price of an American option is as the solution of a

linear complementarity formulation. In this formulation we are looking for a function

V (S, t) such that

LBS (V ) ≤ 0, V (S, t) ≥ P (S, t)

(V (S, t)− P (S, t)) LBS [V ] = 0

6

and

V (S, T ) = P (S, T ).

Here, P (S, t) denotes the payoff function of the option and the Black-Scholes operator

LBS is defined as in (2.1).

The linear complementarity formulation is the clever combination of several fea-

tures of an American option. Some of these can easily be argued heuristically. We

had already argued before that based on the no-arbitrage assumption the option must

be worth no less than its immediate payoff, i.e. V (S, t) ≥ P (S, t). Moreover, it is

clear that the option value coincides with its payoff value whenever it is optimal to

exercise. Also the terminal condition is clear from the definition of the option con-

tract. It can be shown that within the hold region of the option its price function

V (S, t) satisfies the Black Scholes equation. Combining these obeservations one ends

up with the linear complementarity formulation above.

2.2.3 Optimal stopping formulation

The last possible formulation of the pricing problem for American options which we

want to discuss is the optimal stopping formulation. It is at the heart of our multilevel

Monte Carlo approach.

Finding the fair value Vam of an American option contract is equivalent to solving

the following optimal-stopping-time problem (see for example [Gla04, chapter 8])

Vam = supτ∈T

E[e−

∫ τ0 r(u)duPτ (Sτ )

]. (2.2)

Here, the expectation is taken under the risk-neutral martingale measure. The in-

stantaneous short rate process r(t) is used to discount the payoff Pτ at time τ , and

the supremum in (2.2) is taken over all admissible stopping times τ ∈ T between

now and the final expiry of the option. For more exotic path-dependent options, e.g.

lookback options, the payoff in (2.2) could be dependent on the whole path history,

i.e. Pτ ({St : t ∈ [0, τ ]}), but for the purpose of this thesis we restrict ourselves to

(2.2). Also, for the sake of better readability, we will assume the short rate r to be

constant from now on.

To make (2.2) more explicit, we consider the special case of a classical American

put option struck at K on a single underlying S with price process St. If the under-

lying price process follows a geometric Brownian motion with interest rate r under

the risk-neutral martingale measure, then (2.2) reads

supτ∈T

E[e−τr max (K − Sτ , 0)

]. (2.3)

7

In case of a put option on a single underlying the hold and exercise regions are half

planes divided by the optimal exercise boundary B∗(t) and the supremum in (2.3) is

attained for an optimal stopping time τ ∗ of the form

τ ∗ = inf {t ≥ 0 : St ≤ B∗(t)} . (2.4)

Figure 2.1 illustrates the situation for a sample path which hits the optimal exercise

boundary.

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.65

0.7

0.75

0.8

0.85

0.9

0.95

1

1.05

1.1

1.15

t

exercise boundary

underlying price process

exercise region

hold region

Figure 2.1: hold and exercise region under a given exercise rule

2.2.4 Stopping rules and parametric approximations

The connection in (2.4) allows us to interchangeably formulate the pricing problem

either in terms of stopping times or in terms of exercise regions.

Note that any choice of a stopping time τ ∈ T will produce a (usually suboptimal)

value in the expectation from (2.2), i.e.

V (τ)am = E

[e−τ rPτ (Sτ )

]≤ Vam. (2.5)

8

If the optimal exercise region E∗ is known, then the optimal stopping time τ ∗ is

the first time that St enters the exercise region

τ ∗ = infτ∈T{t ≥ 0 : St ∈ E∗} , (2.6)

and the fair value of the option can be computed as a simple expected value according

to

V (τ∗)am = E

[e−τ

∗ rPτ∗ (Sτ∗)]

= Vam. (2.7)

The mapping implicit in (2.6) can be used to assign a stopping time to any given

”exercise region”. We can therefore think in terms of optimizing over exercise regions

(or boundaries) in order to find the value of an American option.

The appealing consequence is that given an exercise strategy (i.e. an exercise

region), we can simply use a forward Monte Carlo simulation of the underlying path

process, compute the payoff for each path and take an average to find the value of

the option under the chosen exercise strategy. We want to emphasize that most

numerical pricing algorithms for American options including the famous Longstaff-

Schwartz algorithm are based on backward iterations and that forward algorithms

are usually unsuited for the problem.

Suppose now that we can parametrize all feasible exercise regions Eθ by some

parameter θ ∈ Θ and denote by τ(θ) the stopping time associated with Eθ according

to the mapping presented in (2.6). The option value is then approximately equal to

Vam = supθ∈Θ

E[e−τ(θ) rPτ(θ)

(Sτ(θ)

)]. (2.8)

Note however, that the value computed in (2.8) is in general biased low because we

might not hit all feasible stopping times in our approximation. In other words, the

set τ(Θ) ⊂ T will in general be a proper subset of T and hence

Vam = supθ∈Θ

E[e−τ(θ) rPτ(θ)

(Sτ(θ)

)]≤ sup

τ∈TE[e−τ rPτ (Sτ )

]= Vam.

Nonetheless, Equation (2.8) is the foundation of our numerical approach.

For an American put option a lot is known about the optimal exercise boundary.

One of its main characteristics is its asymptotic behaviour close to the expiry date

of the option, where it clearly hits the strike. In fact, the optimal exercise boundary

of an American put option asymptotically approaches its strike level K displaying a

square root behaviour (see e.g. [KK98]), i.e.

B∗(t) ∼ K − c√T − t for T − t� 1 (2.9)

9

with an appropriate constant c. This asymptotic feature determines the choice of our

Monte Carlo time discretization in section 4.3.3. Even more importantly, it influences

our choice of a parametric family of feasible exercise boundaries in section 5.1, which

we use in the optimization problem (2.8) and the numerical examples in chapter 3.

2.3 Finite Difference θ-scheme for American op-

tions

In this section we recall the finite difference θ-scheme and how it can be used to

approximate the value of an American put option on a single underlying. We follow

the presentation in the Oxford lecture notes of Dr. Christoph Reisinger and will later

use the finite difference method as a benchmark solution against which we compare

our multilevel Monte Carlo approximations. This section is not supposed to be an

exhaustive treatment of the finite difference method.

First we consider a European put option on a single underlying with strike K and

time to maturity T . Its fair value V (S, t) solves the Black-Scholes equation

∂V

∂t+

1

2σ2 S2 ∂

2V

∂S2+ r S

∂V

∂S− r S = 0

on the domain (S, t) ∈ (0,∞)× (0, T ) and satisfies the terminal condition

V (S, T ) = max (K − S, 0) .

The finite difference scheme discretizes both the equation and its approximate

solution. It starts with the terminal condition at time t = T and moves backwards

in time towards t = 0 according to the discretized version of the partial differen-

tial equation. This only works on a bounded domain and hence we truncate the

computational domain in the space direction, i.e. we only consider the equation for

(S, t) ∈ (0, Smax) × (0, T ) with some upper bound Smax � K and prescribe an ap-

propriate boundary condition along Smax × (0, T ). For a put option this could for

example be zero Dirichlet data.

We subdivide the space direction into N + 1 equidistant grid points Si = i∆S for

i = 0, . . . , N and ∆S = Smax/N and the time direction into M + 1 equidistant grid

points tj = j∆t for j = 0, . . . ,M and ∆t = T/M , and use the notation V mn to refer

to the approximation to V (Sn, tm) on these grid points.

Next, we discretize the partial differential equation. This is done using the follow-

ing difference quotients for the spatial derivatives

∂V

∂S(Sn, tm) =

V (Sn+1, tm)− V (Sn−1, tm)

2∆S+O

((∆S)2

)10

and

∂2V

∂S2(Sn, tm) =

V (Sn+1, tm)− 2V (Sn, tm) + V (Sn−1, tm)

(∆S)2+O

((∆S)2

).

For the time derivative we choose between either a forward difference of the form

∂V

∂t(Sn, tm) =

V (Sn, tm+1)− V (Sn, tm)

∆t+O (∆t)

or a backward difference of the form

∂V

∂t(Sn, tm) =

V (Sn, tm)− V (Sn, tm−1)

∆t+O (∆t) .

Choosing the backward difference leads to the so-called explicit Euler scheme

V mn − V m−1

n

∆t+

1

2σ2 S2

n

V mn+1 − 2V m

n + V mn−1

(∆S)2+ r Sn

V mn+1 − V m

n−1

2∆S− r Sn = 0.

The scheme is called explicit because the solution vector V m−1n at time tm−1 is given

explicitly in terms of the previous iteration step, i.e.

V m−1n = Amn V

mn−1 +Bm

n Vmn + Cm

n Vmn+1

for the coefficients

Amn =1

2n2σ2∆t− 1

2nr∆t

Bmn = 1− n2σ2∆t− r∆t

Cmn =

1

2n2σ2∆t+

1

2nr∆t.

Alternatively, if we choose to approximate the time derivative using the forward

difference we end up with the so-called implicit Euler scheme

V m+1n − V m

n

∆t+

1

2σ2 S2

n

V mn+1 − 2V m

n + V mn−1

(∆S)2+ r Sn

V mn+1 − V m

n−1

2∆S− r Sn = 0.

This scheme is called implicit because at time step tm the new iterate is only given

implicitly and one needs to solve the following equation to advance

amn Vmn−1 + bmn V

mn + cmn V

mn+1 = V m+1

n .

Here, the coefficients are

amn = −1

2n2σ2∆t+

1

2nr∆t

bmn = 1 + n2σ2∆t+ r∆t

cmn = −1

2n2σ2∆t− 1

2nr∆t.

11

The explicit scheme is less costly in terms of computational effort, but requires

rather strict conditions on the size of the time step for it to be stable. The fully

implicit method is usually unconditionally stable. They both show first order conver-

gence with respect to the time discretization. One can keep the stability but improve

on the convergence properties by moving to the so-called θ-scheme.

The θ-scheme is a weighted average of the explicit and the implicit Euler scheme

with weight factor θ ∈ [0, 1], i.e.

amn Vm−1n−1 + bmn V

m−1n + cmn V

m−1n+1 = Amn V

mn−1 +Bm

n Vmn + Cm

n Vmn+1 (2.10)

with coefficients

Amn =1

2(1− θ) ∆t

(n2σ2 − nr

)Bmn = 1− (1− θ) ∆t

(n2σ2 + r

)Cmn =

1

2(1− θ) ∆t

(n2σ2 + nr

)amn = −1

2θ∆t

(n2σ2 − nr

)bmn = 1 + θ∆t

(n2σ2 + r

)cmn = −1

2θ∆t

(n2σ2 + nr

).

Alternatively, the procedure in (2.10) can be written in matrix form as

M1Vm−1 = M2V

m, (2.11)

where the matrices M1 and M2 are tridiagonal.

Note that in setting θ = 0 or θ = 1 one recovers the explicit or implicit schemes

from above. We usually work with θ = 1/2, a choice for which the method is called

the Crank-Nicolson scheme.

Recall, that in order to find the value of a European put, we start from the terminal

condition

VMn = max (K − Sn, 0)

and iterate backwards in time towards V0 using the θ-scheme (2.11).

An American option can be exercised at any time and thus it must always be worth

at least as much as its immediate payoff g. The immediate payoff of an American

put option is given by gn = max (K − Sn, 0). We incorporate this into the method

12

by dynamic programming and force the option value to be worth at least as much as

its immediate payoff at each iterate, i.e. we modify the algorithm towards

M1Vm−1 = M2V

m (2.12)

Vm−1 = max(g, Vm−1

). (2.13)

To be precise, this only approximates the value of a Bermudan option with possible

exercise date on each ti. In fact, the method has an O (∆t) bias when used to

approximate the value of an American option. For small ∆t this is still a good

approximation for the American case where exercising is possible on a continuous

time scale.

Although, using (2.12) and (2.13) might not the most effective way to price an

American option with a finite difference method, it suffices completely for our pur-

poses. For details on how to improve the scheme (e.g. by Rannacher time stepping)

we refer the reader to the Oxford lecture notes of Dr. Christoph Reisinger on finite

difference methods.

The finite difference method is a powerful pricing algorithm for American options

written on a single underlying. For models depending on multiple stochastic factors,

however, the computational cost of finite difference methods increases drastically to

the point where it becomes prohibitive.

2.4 The Longstaff-Schwartz algorithm

In this section we present the ideas behind the Longstaff-Schwartz algorithm. We

mainly follow the notation used in [Gla04]. The Longstaff-Schwartz algorithm is

used to approximate the value of Bermudan options. In the limit, i.e. for a growing

number of possible exercise dates with shrinking time difference between them, this

is a reasonable approximation for the pricing problem of American options.

Let us denote by Vi(x) the fair value of the option at time ti assuming it has

not been exercised previously. At maturity, this value is determined solely by the

payoff function hm(x). We are ultimately interested in V0(X0) and can get this value

according to the dynamic programming formulation

Vm(x) = hm(x)

Vi−1(x) = max{hi−1(x), E

[Di−1,iVi(x) |Xi−1 = x

]},

13

where Xi is the underlying price at time ti, hi(x) is the exercise value of the option

at time ti and Di−1,i denotes the discount factor for the interval [ti, ti+1]. If we set

Vi(x) = D0,i Vi(x)

hi(x) = D0,ihi(x),

with D0,i = D0,1D1,2 . . . Di−1,i, the formulation can be simplified to

Vm(x) = hm(x) (2.14)

Vi−1(x) = max {hi−1(x), E [Vi(x) |Xi−1 = x ]} . (2.15)

In a first step, the Longstaff-Schwartz algorithm iterates backwards in time to

approximate the continuation values Ci(x) = E [Vi+1(x) |Xi = x ] of the option. It

assumes that Ci(x) can be expanded in terms of an appropriate set of basis functions.

This is certainly true for each element of a Hilbert space because every Hilbert space

has a countable orthonormal basis. The chosen basis is then truncated to a finite

number, R + 1 say, basis functions and the algorithm works with

Ci(x) ≈ Ci(x) =R+1∑l=1

βl φl(x)

The corresponding coefficients βl are found by a least squares regression process,

namely by minimizing

E[(

E [Vi(Xi) |Xi−1 ]− Ci−1(Xi−1))2].

Taking the derivatives with respect to the βl and setting them to zero yields the

following matrix-vector equation

Bφ,φ β = BV,φ,

with

(Bφ,φ)r,s = E [φr(Xi−1)φs(Xi−1)] and (BV,φ)r = E [Vi(Xi)φr(Xi−1)] . (2.16)

In the numerical implementation the expected values in (2.16) are approximated as

Monte Carlo averages over N paths, for example

(Bφ,φ)r,s ≈1

N

N∑n=1

E[φr(X

(n)i−1)φs(X

(n)i−1)]. (2.17)

14

Once the approximate continuation values are known for each time step, the

Longstaff-Schwartz algorithm uses them in a second Monte Carlo step as a deci-

sion guidance on when to exercise. This is done as follows. Starting from expiry and

moving backwards, at each time step i the continuation value of the previous step is

compared to the immediate payoff hi−1(Xi−1). If the immediate payoff is higher than

the continuation value then the algorithm advances to Vi−1 = hi−1(Xi−1), otherwise

the algorithm takes Vi−1 = Vi.

In principle, one can use the first set of path simulations not only to approximate

the continuation values but also to produce an approximate value of the option.

However, this value might be biased high and hence the algorithm is usually split

into two parts. For the second part one can also choose to work forward in time

and stop each path at the first instance when its immediate payoff is higher than

the continuation value. This is more efficient than the backward iteration. For the

purposes of this thesis we will only cite some approximate values computed in the

original paper [LS01] and will not use our own implementation of the algorithm.

15

Chapter 3

Multilevel Monte Carlo method

Onions have layers. Ogres havelayers. Onions have layers. You getit? We both have layers.

Shrek

In this chapter we introduce the basic multilevel Monte Carlo method. We fol-

low the presentation and notation of the original papers [Gil08] and [Gil]. These

two papers started a series of research papers which have shown that the multilevel

Monte Carlo approach is a powerful way to reduce the computational cost in com-

parison to standard Monte Carlo methods when applied to various option pricing

problems. Among the published examples are plain vanilla European options, op-

tions with Asian payoff, digital options, lookback options as well as barrier options.

In [Gil09] the method has been successfully applied to European type basket options,

including lookback, Asian and barrier options. The theoretical analysis of the method

was originally only done for payoffs which are globally Lipschitz, although practical

numerical examples have shown good convergence properties also for digital options

for example. In [GHM09] the authors conduct a deeper numerical analysis of the

method.

3.1 The setup

We want to compute the value of a financial option, whose payoff P = f(St) is given

as a functional of the path of a stochastic process St. We assume that the evolution

of the stochastic process St is governed by the SDE

dSt = a(St, t)dt+ b(St, t)dWt, (3.1)

16

for the time interval 0 < t < T with given initial data S0 and given drift and volatility

terms a(St, t) and b(St, t). Throughout this thesis we will exclusively be working with

geometric Brownian motion, i.e. a(St, t) = rSt and b(St, t) = σSt for constant risk

free rate r and volatility factor σ. However, the multilevel Monte Carlo method is

not restricted to this case and hence we state (3.1) in its more general form.

The payoff of a classical European call option with strike K and expiry T , say,

is given by max (ST −K, 0). In this case the payoff is a simple function only of the

final state ST of the stochastic path. Other options can be highly path dependent,

for example the payoff of a knock-in barrier option naturally depends on the full path

St and not just its final state. Both cases are included in the above setup.

3.2 Basic multilevel decomposition

In order to approximate the value of such an option a standard Monte Carlo method

generates various discrete path simulations of (3.1) with a certain time step size,

evaluates the payoff for each of those paths and computes the expected value as

an average. The chosen step size strongly depends on the desired accuracy of the

computed solution. In fact, the smaller the step size the better the results.

Instead of sticking to one discretisation time step the multilevel Monte Carlo

method uses path simulations corresponding to various nested time grids. The idea

is to reduce the variance of the finest grid approximations using information from

coarser levels in a way that minimizes the overall computational cost.

To be more precise, suppose we are given different time discretisations with step

sizes hl = 2−lT for l = 0 . . . L. For any given Brownian path Wt we denote by P the

payoff of the option and by Pl its numerical approximation using a discretisation with

timestep hl. By linearity we can decompose the expected value on the finest level as

follows

E[PL] = E[P0] +L∑l=1

E[Pl − Pl−1]. (3.2)

In fact, the decomposition (3.2) can (and in our case will) be made a bit more general,

in the sense that the numerical approximation Pl does not need to be the same for

the correction terms E[Pl − Pl−1] and E[Pl+1 − Pl]. Instead, we distinguish between

two possibly different numerical approximations Pl,f and Pl,c with step size hl and

write

E[PL] = E[P0] +L∑l=1

E[Pl,f − Pl−1,c]. (3.3)

17

As long as Pl,f and Pl,c have identical expectation, i.e. E[Pl,f ] = E[Pl,c], the sum is

still telescoping and (3.3) is correct. The additional subscripts f and c were chosen

to resemble the labels fine and coarse for an approximation on any given level l > 0.

The multilevel Monte Carlo method is based on the decomposition in (3.3) and

independently evaluates each expected value on the right hand side of the equation

in a way that minimizes the total variance for a given computational cost. This is

done as follows.

3.3 Monte Carlo estimators

We denote by Y0 an estimator for E[P0] which is based on N0 sample paths. Similarly,

for l > 0 we denote by Yl independent estimators for E[Pl,f − Pl−1,c], each one using

Nl sample paths. The estimators Yl usually are computed as means taken over Nl

sample paths, i.e. for l > 0 the estimator has the form

Yl =1

Nl

Nl∑i=1

(P

(i)l,f − P

(i)l−1,c

). (3.4)

Here, the trick is that P(i)l,f and P

(i)l−1,c are constructed using different time steps but

the same Brownian path.

We combine the Yl and get the overall estimator

Y =L∑l=0

Yl (3.5)

for the option price. Note that Y is in fact a feasible estimator if the Yl are unbiased

because then we have

E[Y]

= E[Y0] +L∑l=1

E[Yl

]= E[P0] +

L∑l=1

E[Pl,f − Pl−1,c

]= E

[PL

].

Let us take a closer look at the mean squared error of the estimator Y .

E[(Y − E [P ]

)2]

= E[(Y − E

[Y])2]

+(E[Y]− E [P ]

)2

= E[(Y − E

[Y])2]

+(E[PL

]− E [P ]

)2

= V[Y]

+(E[PL

]− E [P ]

)2

. (3.6)

18

The first term in (3.6) is just the variance of Y and since all the Yl are independent

it can be written as

V[Y]

= V

[L∑l=0

Yl

]=

L∑l=0

V[Yl

]=

L∑l=0

N−1l Vl, (3.7)

where Vl is the variance of a single path for estimator Yl. Equation (3.7) is one of the

starting points of the multilevel algorithm as will be shown in section 3.5.

The second term in (3.6) corresponds to how well the payoff can be approximated

on the finest grid.

3.4 The multilevel algorithm

In this section we present the pseudocode for the actual multilevel algorithm as de-

scribed in the original paper [Gil08]. The original algorithm takes the desired accuracy

ε as an input and computes the required maximal level of refinement L on the fly.

This is done based on a heuristic convergence criterion, but has proven to be very

effective numerically in the multilevel Monte Carlo research literature.

1. Start with L = 0.

2. Estimate VL using an intial NL samples.

3. Define optimal Nl for l = 0, . . . , L.

4. Evaluate extra samples as needed for new Nl.

5. If L ≥ 2, test for convergence.

6. If L < 2 or not converged, set L = L+ 1 and go back to step 2.

The convergence test in step 5 is usually based on the following criterion

max

{1

2

∣∣∣YL−1

∣∣∣ , ∣∣∣YL∣∣∣} <ε√2.

3.5 Complexity and convergence theorem

In this section we first give a brief and somewhat handwavy explanation of the total

cost of the multilevel Monte Carlo algorithm to achieve a certain accuracy of order ε.

Then we cite the main theorem from [Gil08] which rigorously explains the convergence

and complexity of the multilevel Monte Carlo algorithm for various cases.

19

The Yl are constructed from Nl paths and the computational cost of each path

is proportional to h−1l . Hence, the cost of the combined estimator is proportional

to∑L

l=0Nlh−1l . As mentioned before, we want to minimize the variance in (3.7) for

a given cost, i.e. subject to the contraint∑L

l=0Nlh−1l ≡ Const. Treating Nl as a

continuous variable this minimization can easily be done using a Lagrange multi-

plier approach. As a result one finds that the variance is minimized if Nl is chosen

proportional to√Vlhl.

Assume now that the single variance Vl is of order O(hl) (this corresponds to

β = 1 in Theorem 3.5.1). By what we just saw, the optimal choice for Nl would then

also be of order O(hl). If one chooses Nl = O(ε−2 Lhl), the variance of Y will be

V[Y]

= O(ε2). If the weak convergence of the estimator is of order O(hL) = O(2−L)

on the finest level, then by choosing L = O( log(ε)log(2)

) we can make the second term in

(3.6) order O(ε2). Thus, for a total cost of

L∑l=0

Nlh−1l =

L∑l=0

O(ε−2 Lhl)h−1l = O(ε−2 L2) = O(ε−2 (log ε)2)

the mean squared error E[(Y − E [P ]

)2]

would be of order O(ε2). A standard Monte

Carlo method has a cost of O(ε−3) to achieve the same accuracy. And thus the mul-

tilevel Monte Carlo algorithm brings about a drastic improvement in computational

cost.

The full complexity and convergence properties of the multilevel Monte Carlo

method are generalized and summarized in Theorem 3.5.1.

Theorem 3.5.1 (see [Gil08]) Let P denote a functional of the solution of the SDE

(3.1) for a given Brownian path Wt, and let Pl denote the corresponding approximation

using a numerical discretisation with timestep hl = 2−lT .

If there exist independent estimators Yl based on Nl Monte Carlo samples, and

positive constants α ≥ 1/2, β, c1, c2, c3 such that

(i) |E[Pl − P ] | ≤ c1 hαl

(ii) E[Yl] =

{E[P0], l = 0

E[Pl − Pl−1], l > 0

(iii) V[Yl

]≤ c2N

−ll hβl

(iv) the computational complexity Cl of Yl is bounded by Cl ≤ c3Nl h−1l ,

20

then there exists a constant c4 such that for any ε < e−1 there are values L and Nl

for which the multilevel estimator Y =∑L

l=0 Yl has mean-square error with bound

MSE ≡ E[(Y − E [P ]

)2]< ε2,

with a computational complexity bound

C ≤

c4 ε

−2, β > 1

c4 ε−2 (log ε)2 , β = 1

c4 ε−2−(1−β)/α, 0 < β < 1.

21

Chapter 4

Numerical implementation for anAmerican put option under apreset exercise strategy

Any general method for pricingAmerican options by simulationrequires substantial computationaleffort

Paul Glasserman in [Gla04]

The estimators Yl used for the multilevel Monte Carlo method need to be con-

structed carefully in order to avoid the introduction of an undesired bias in the com-

puted solution. In (3.4) we have already given the general form of Yl. So far we have

not, however, described the numerical approximations Pl,c and Pl,f in any detail. In

general, these will depend on the type of application. Recall that they both should

be computed based on a time discretisation with step size hl. For a European call

option we could for example just simulate a path with this step size using an Euler-

Maruyama scheme and evaluate the payoff at the final timestep for both Pl,c and

Pl,f . It gets more complicated for path dependent options where the two quantities

no longer need to be identical. In a sense we have more information about the path

available to compute Pl,c than Pl,f , because we compute Pl,c at the same time as we

compute Pl+1,f , an approximation using a finer timestep. For the remainder of this

thesis we will now focus on the valuation of an American put option. In what follows

we will describe the construction of the corresponding estimators.

22

4.1 Discretizing the SDE

The discretization of the SDE (3.1) is crucial. Its convergence properties affect the

overall variance and therefore the overall convergence of the multilevel algorithm. In

fact, the chosen discretisation scheme for the simulated path strongly influences how

the discretised payoff function is constructed and therefore enters into Theorem 3.5.1

through the parameters α and β.

Suppose we are given a time discretisation of the interval [0, T ] into timesteps

0 = t0 < t1 < · · · < tN = T . The most intuitive way to discretize the scalar SDE

(3.1) is the Euler-Maruyama scheme

Sn+1 = Sn + a(Sn, tn) (tn+1 − tn) + b(Sn, tn)∆Wn, (4.1)

where the initial state S0 = S0 is known, and where Sn indicates the value of the

simulated path at time tn. Moreover, ∆Wn = Wtn+1 −Wtn is the Brownian incre-

ment between timesteps tn and tn+1. Under some weak smoothness conditions on the

functions a(S, t) and b(S, t) the Euler-Maruyama scheme is known to be weakly con-

vergent with order one and strongly convergent with order one half. A more refined

discretisation can in some cases be achieved using the so-called Milstein scheme. The

Milstein scheme approximates the scalar SDE (3.1) via

Sn+1 = Sn + a (tn+1 − tn) + b∆Wn +1

2b∂b

∂S

(∆W 2

n − (tn+1 − tn)), (4.2)

where S0 again is the inital state of the path, ∆Wn is the Brownian increment as

before and the functions a, b and ∂b∂S

are evaluated at (Sn, tn). The Milstein scheme

has strong and weak convergence order both equal to one.

4.1.1 Exact path simulation for geometric Brownian motion

Throughout this thesis we assume that the underlying price process is driven by

geometric Brownian motion, i.e. that the SDE (3.1) takes the form

dSt = r St dt + σ St dWt (4.3)

with constant r and σ. If we consider the process Xt = log(St), Ito’s lemma tells us

that

dXt =

(r − σ2

2

)dt+ σ dWt,

23

for which both the above discretisation schemes coincide and yield exact path values

at the discrete points, i.e.

Xn+1 = Xn +

(r − σ2

2

)(tn+1 − tn) + σ∆Wn

= X0 +

(r − σ2

2

) n∑i=0

(ti+1 − ti) + σ

n∑i=0

∆Wi

= X0 +

(r − σ2

2

)tn+1 + σWn+1

= X(tn+1).

For the purpose of this thesis we will take advantage of the logarithmic transformation

and simulate the path Xt (and thus St) exactly at the discrete points.

4.2 Estimators for a given exercise strategy

In what follows we will focus on the example of an American put option under a

specified exercise strategy.

Suppose we are given an exercise strategy in terms of the exercise region E . Ac-

cording to the mapping implied by (2.6) the exercise region translates into a stopping

time

τ = inf{t ≥ 0 : St ∈ E}.

We are interested in computing the value of an American put option under this

exercise strategy. This is equivalent to computing the expected value E [Pτ ], where

the discounted payoff function is

Pτ = e−r τ (K − Sτ )+1{τ<T} + e−r T (K − ST )+

1{τ≥T}. (4.4)

Here, the notation (K − Sτ )+ is used to denote max (K − Sτ , 0) and 1E is the indica-

tor function of the event E. Note that, in contrast to (2.2) and the equations based

thereon, in (4.4) we have incorporated the discount factor directly into Pτ .

For a given time grid 0 = t0 < t1 < . . . < tN = T and the corresponding discrete

path approximations {Si} the naive way to discretise the payoff Pτ would simply

check at each time step whether or not the exercise region has been reached, i.e. we

would work with τ = inf{ti : Si ∈ E}. But even if we can simulate the path values at

the discrete time steps exactly, this is rather inaccurate, because the path might cross

a barrier between two sample points even if the sample points suggest otherwise. So

24

convergence would be very slow. We follow an improved approach which is commonly

used in the framework of continuously monitored barriers.

In case of an American put on a single underlying the exercise region and the

hold region of the option are separated by a continuous function B(t), also called

the exercise boundary. In fact in this case, the hold region lies above B(t) and the

exercise region lies below.

We denote by pi the probability that the sample path drops below the exercise

boundary (i.e enters the exercise region) in the interval [ti, ti+1] conditioned on the

values of the sampled path Si and Si+1 at the interval end points, i.e.

pi = P(

St ≤ B(t)for some t ∈ [ti, ti+1]

| Si, Si+1

)Unfortunately, this probability can only be computed analytically for few special

boundary shapes. It can be computed, however, for a linear exercise boundary if

the stochastic process has constant drift and diffusion coefficients. If the exercise

boundary was in fact linear between ti and ti+1 with end values B(ti) and B(ti+1)

and if we modelled the sample path as a Brownian bridge with constant drift r Si

and constant diffusion coefficient σ Si in the interval [ti, ti+1], then the probability pi

would equal (see for example [Huh07] or [BN05])

exp

(−2 (Si −B(ti))

+ (Si+1 −B(ti+1))+

(ti+1 − ti)σ2 S2i

). (4.5)

For our application, however, we can do even better. The path process St follows

a geometric Brownian motion and as explained in section 4.1.1 we can simulate the

process Xt = log(St) exactly. Moreover, the drift(r − σ2

2

)and diffusion σ coefficients

of Xt are indeed constant. So instead of using (4.5), we compute the probability based

on the pathXt. This is possible because the logarithm is strictly increasing for positive

arguments. Hence, if the exercise boundary is positive on the subinterval [ti, ti+1] we

can write

pi = P(

St ≤ B(t)for some t ∈ [ti, ti+1]

| Si, Si+1

)= P

(Xt ≤ log (B(t))

for some t ∈ [ti, ti+1]| Xi = log(Si), Xi+1 = log(Si+1)

).

25

Consequently, if both B(ti) and B(ti+1) are positive, there holds

pi = exp

−2(

log(Si

)− log(B(ti))

)+ (log(Si+1

)− log(B(ti+1))

)+

(ti+1 − ti)σ2

= exp

−2(

log(Si

/B(ti)

)+ (log(Si+1

/B(ti+1)

)+

(ti+1 − ti)σ2

(4.6)

In using (4.6) the only potentially remaining source of error is if the exercise boundary

is not linear. And although this linearity assumption about the exercise boundary

will in most cases not be fullfilled we work with (4.6) as an approximate value for the

hitting probability in the interval [ti, ti+1].

Recall that we want to compute the expected value

E [Pτ ] = E[E[Pτ |{Si}

]].

Thus, we concentrate on the conditional expectation E[Pτ |{Si}

]. The first indicator

function in (4.4) can be split up by subintervals

1{τ<T} =N−1∑i=1

1{τ∈[ti,ti+1]}.

This enables us to approximate

Pτ =N−1∑i=1

exp (−r τ) (K − Sτ )+1{τ∈[ti,ti+1]} + e−r T (K − ST )+

1{τ≥T}

≈N−1∑i=1

exp (−r τi) (K − Sτi)+1{τ∈[ti,ti+1]} + e−r T (K − ST )+

1{τ≥T}

for some approximate value τi of the actual crossing time. In our implementation we

choose the interval midpoint τi = ti+ti+1

2. At the crossing point τi the path touches

the barrier and we implement

Sτi = B(τi) = b

(ti + ti+1

2

).

26

The conditional expectation can then be approximated by

E[Pτ |{Si}

]≈

N−1∑i=1

exp (−r τi) (K − Sτi)+ E

[1{τ∈[ti,ti+1]}|{Si}

]+ exp (−r T ) (K − ST )+ E

[1{τ≥T}|{Si}

]=

N−1∑i=1

exp (−r τi) (K − Sτi)+

(pi

i−1∏j=0

(1− pj)

)

+ exp (−r T ) (K − ST )+

(N−1∏j=0

(1− pj)

)(4.7)

The estimator Pl,f from Equation (3.3) is contructed according to (4.7) using the

probabilities pi according to (4.5).

For the coarse path estimator Pl,c we work with an additional idea used in [Gil]

for path dependent payoffs. Recall, that the estimator corresponds to a step size hl

and is computed at the same time as Pl+1,f . On the interval [ti, ti+1] of length hl

we simulate an additional midpoint Sn+ 12

based on a Brownian bridge construction.

The exact definition depends on the chosen time discretization and will be given in

sections 4.3.2 and 4.3.3. We then look at the two probabilities that the sample path

drops below the barrier on either side of the midpoint conditioned on the sampled

values, i.e.

exp

(−2 (Si −B(ti))

+ (Si+ 12−Bavg)

+

(ti+ 12− ti)σ2 S2

i

)(4.8)

and

exp

(−2 (Si+ 1

2−Bavg)

+(Si+1 −B(ti+1))+

(ti+1 − ti+ 12)σ2 S2

i

). (4.9)

The exact value of Bavg again depends on the chosen time discretization and will be

given along with the definition of Sn+ 12

in sections 4.3.2 and 4.3.3. In both probability

formulae there is a factor of Si in the denominator. This stems from the fact that the

underlying Brownian bridge is assumed to have the same volatility coefficient σ Si on

the entire interval [ti, ti+1]. As before, we can do better than this by moving to the

27

transformed path Xt = log(St). Instead of (4.8) and (4.9) we use

pi,1 = exp

−2(

log(Si

)− log(B(ti))

)+ (log(Si+ 1

2

)− log(Bavg)

)+

(ti+ 12− ti)σ2

(4.10)

pi,2 = exp

−2(

log(Si+ 1

2

)− log(Bavg)

)+ (log(Si+1

)− log(B(ti+1))

)+

(ti+1 − ti+ 12)σ2

.

(4.11)

The probability that the path crosses the exercise boundary in the entire interval

is now easily computed via

pi = (1− (1− pi,1) (1− pi,2)) . (4.12)

We construct the coarse estimator Pl,c according to (4.7) using the probabilities pi

from (4.12) .

4.3 Numerical example

As a numerical example we apply the algorithm to an American put option under the

exercise strategy given by the exercise boundary B(t) = K − 0.8√T − t. Our results

are presented in the spirit of [Gil08] and [Gil] and were obtained using the parameters

T = 1.0, K = 1.0, S0 = 1.0, r = 0.05 and σ = 0.2.

4.3.1 A brief aside on Brownian bridge construction andBrownian interpolation

Suppose Xt is a simple Brownian motion with drift µ and diffusion coefficient ρ, i.e.

dXt = µ dt+ ρ dWt =⇒ Xt = µ t+ ρWt.

Suppose further that we have sampled St at times t1 < t2, say Xt1 = a and Xt2 = b.

Then the conditional distribution of Xt at time t = t1 + λ (t2 − t1) for 0 < λ < 1 is

a normal distribution (see e.g. [Gla04]) with mean

a+t− t1t2 − t1

(b− a)

and variance

ρ2 (t2 − t) (t− t1)

t2 − t1.

28

Moreover, if we combine the equations for X(t), X(tn) and X(tn+1) we find that (see

e.g. [Gil09])

Xt = Xtn + λ{Xtn+1 −Xtn

}+ ρ {Wt −Wn − λ (Wn+1 −Wn)} . (4.13)

This means that Xt deviates from a linear interpolation if and only if Wt deviates

from a straight line interpolation.

4.3.2 Equidistant time grids

As a first numerical example we implemented the algorithm using equidistant time

grids. To be more precise, on level l = 1 . . . L we partition the interval [0, T ] using

2l+1 equidistant grid points tn = nT / 2l for n = 0, . . . , 2l. In this case the additional

midpoint Sn+ 12

constructed for the approximation Pl,c actually corresponds to the true

midpoint (tn + tn+1) / 2 of the interval. As for the probabilities in (4.6), (4.10) and

(4.11) we use the process Xt = log(St) and its discretization. In accordance with

(4.13) for λ = 1/2 and ρ = σ we compute

log(Sn+ 1

2

):= Xn+ 1

2:=

1

2

(Xn + Xn+1 − σDn

),

where Dn =(Wn+1 −Wn+ 1

2

)−(Wn+ 1

2−Wn

)is a N (0, hl) variable computed based

on the Brownian increments from the finer path simulation with step size hl+1 = hl / 2.

The definition of Bavg from (4.8) and (4.9) in this case is

log (Bavg) =log (B(ti)) + log (B(ti+1))

2.

Figure 4.1 shows the results. In the top left plot the behaviour of the variance of

both Pl,f and Pl,f − Pl−1,c can be seen. The slope of the latter seems to converge to a

value slightly higher than −32, i.e. Vl = O(h

3/2−εl ) which in the language of Theorem

3.5.1 corresponds to a value of β ≈ 3/2 − ε for some small ε. In the top right plot

we see that E[Pl,f − Pl−1,c

]is approximately of order O(hl) and hence α = 1. The

expected value E[Pl,f

]seems to be biased high for the coarser levels. This bias is

probably due to the fact that the linear approximation of the logarithm of the exercise

boundary is too rough for the coarse levels.

The bottom two plots show the behaviour of the multilevel algorithm for various

levels of desired accuracy ε. The bottom left plot shows the values Nl for l = 0, . . . L.

Recall that the optimal value Nl was to be chosen proportionally to√Vlhl. So for

decreasing Vl and hl the optimal Nl is decreasing for larger l. The bottom right plot

29

shows ε2C where the computational cost C of the multilevel Monte Carlo method is

computed according to

C =L∑l=0

Nl h−1l =

L∑l=0

Nl 2l. (4.14)

In fact the bottom right plot supports the theoretical result from Theorem 3.5.1. For

values α = 1 and β ≈ 3/2− ε the computational cost is proportional to ε−2.

30

0 2 4 6 8 10 12−18

−16

−14

−12

−10

−8

−6

−4

−2

0

l

log

2 v

ariance

Pl

Pl− P

l−1

0 2 4 6 8 10 12−18

−16

−14

−12

−10

−8

−6

−4

−2

0

l

log

2 |m

ean|

Pl

Pl− P

l−1

0 2 4 6 8 10 1210

3

104

105

106

107

108

l

Nl

ε=0.0001

ε=0.0002

ε=0.0005

ε=0.001

ε=0.002

10−4

10−3

10−2

100

101

ε

ε2 C

ost

MLMC

Figure 4.1: American put with exercise boundary B(t) = K−0.8√T − t and equidis-

tant time grids. This exercise boundary is a member of the parametric family whichwe will use later in our optimization scheme.

4.3.3 Time discretization in transformed coordinates

The chosen exercise boundary (as well as the true exercise boundary) has a square

root behaviour at expiry T , see e.g. [KK98] and section 5.1. In order to better account

for this behaviour we now choose a different discretization scheme for the time grids.

31

On level l = 1, . . . , L we set yn =√T(2l − n

)/ 2l for n = 0, . . . , 2l. These are

used to define

tn = t(l)n = T − y2n = T

(1−

(2l − n

)2

(2l)2

)for n = 0, . . . , 2l.

We note that 0 = t(l)0 < . . . < t

(l)

2l= T . The grids are nested, i.e. the finer grids include

all grid points belonging to coarser levels since t(l+1)2n = t

(l)n . The grid refinement is

visualized in Figure 4.2 for the first few levels and T = 1.

0 0.25 0.5 0.75 1

0

1

2

3

4

t

level

non−uniform grid for different levels on [0,1]

Figure 4.2: Grid refinement for the first few levels

The midpoint Sn+ 12

on the interval [t(l)n , t

(l)n+1] used for the approximation Pl,c is

contructed corresponding to the nonuniform grid. It corresponds to the time t(l+1)2n+1 ∈

[t(l)n , t

(l)n+1], i.e. the next refinement step of the interval. We set

λ =t(l+1)2n+1 − t

(l)n

t(l)n+1 − t

(l)n

.

32

Then, again in accordance with (4.13) with ρ = σ, the midpoint is computed via

log(Sn+ 1

2

):= Xn+ 1

2:= Xn + λ

(Xn+1 − Xn

)+ σ

{Wn+ 1

2−Wn − λ (Wn+1 −Wn)

}.

As before, the Brownian increments Wn+ 12−Wn and Wn+1 −Wn are taken from the

calculations on the next finer level. The value Bavg from (4.8) and (4.9) is based on

log (Bavg) = log (B(tn)) + λ {log (B(tn+1))− log (B(tn))} .

Figure 4.3 shows the numerical results. As before, the top left plot shows the be-

haviour of the variance of both Pl,f and Pl,f − Pl−1,c. The slope of the latter seems

to be close to 2, i.e. Vl = O(h2l ). In the language of Theorem 3.5.1 this corresponds

to a value of β ≈ 2 and is a considerable improvement compared to the equidistant

time grid case. In the top right plot we see that E[Pl,f − Pl−1,c

]is approximately of

order O(h3/2l ) and hence α ≈ 3/2, again a considerable improvement compared to the

equidistant case.

The bottom two plots show the behaviour of the multilevel algorithm for various

levels of desired accuracy ε. The bottom left plot shows the values Nl for l = 0, . . . L.

We observe similar behaviour as before with slightly lower values for the Nl, which

means a lower overall cost. The bottom right plot again shows the scaled cost ε2C

for the multilevel Monte Carlo method and a standard Monte Carlo approach, i.e.

C represents the computational cost in both cases. For the multilevel Monte Carlo

method the computational cost C is again computed according to (4.14). For the

standard Monte Carlo approach the computational cost has been estimated as

C =2VL 2L

ε2.

Again, the plot supports the theoretical result from Theorem 3.5.1. For values α ≈3/2 and β ≈ 2 the multilevel computational cost is proportional to ε−2.

33

0 2 4 6 8−22

−20

−18

−16

−14

−12

−10

−8

−6

−4

−2

0

l

log

2 v

ariance

Pl

Pl− P

l−1

0 2 4 6 8−18

−16

−14

−12

−10

−8

−6

−4

−2

0

l

log

2 |m

ean|

Pl

Pl− P

l−1

0 2 4 6 810

3

104

105

106

107

108

l

Nl

ε=0.0001

ε=0.0002

ε=0.0005

ε=0.001

ε=0.002

10−4

10−3

10−2

100

101

ε

ε2 C

ost

MLMC

MC

Figure 4.3: American put with exercise boundary B(t) = K − 0.8√T − t and non-

equidistant time grids. This exercise boundary is a member of the parametric familywhich we will use later in our optimization scheme.

34

Chapter 5

Optimizing exercise strategies

Prius quam incipias, consulto et,ubi consulueris, mature facto opusesBefore you act consider; when youhave considered, tis fully time to act

Sallust

In this section we pick up on the problem formulation presented in Equation (2.8).

Recall that we want to solve the optimization problem

supθ∈Θ

E[e−τ(θ) rPτ(θ)

(Sτ(θ)

)], (5.1)

where the θ ∈ Θ ⊆ Rk parametrize all admissible exercise regions Eθ or equivalently

all admissible exercise boundaries Bθ(t). The translation from an exercise region to a

stopping time τ(θ) is done via (2.6). Note that θ can be vector valued. For the sake

of better readability we cut back the notation in (5.1) and instead write

supθ∈Θ

E[Pτ(θ)

], (5.2)

where from now on we take Pτ to be the discounted payoff (i.e. the discount factor in

(5.1) gets absorbed into the payoff). Moreover, we suppress the argument Sτ of the

payoff as long as this remains unambiguous. In alignment with standard optimization

jargon we refer to E[Pτ(θ)

]as the objective function of the maximization problem

(5.2).

In order for the supremum in (5.2) to be an acceptable approximation of the

true fair value of the original option the parameter forms Eθ for the feasible exercise

strategies need to replicate the true exercise strategy as closely as possible. In the

next section we discuss some properties of the exercise boundary of an American put

option.

35

5.1 Parametric forms for the exercise boundary of

an American put option

The goal of this thesis is to show how the multilevel Monte Carlo method can be used

for pricing American options. As a major test case we restrict ourselves to the case

of an American put option with a single underlying and no dividends.

There is an abundance of literature touching the exact and approximate compu-

tation of the optimal exercise boundary for an American put option, see for example

[LPH00], [CC08], [CJR92], [BAW87]. It would, however, defeat the purpose of this

thesis if we took a parametric form of the exercise boundary which requires too much

a priori information on the actual shape of the exercise boundary. Such information

might not necessarily be available for more complex options with more than one un-

derlying asset for example. Nonetheless, we choose to use some information about

the asymptotic behaviour of the exercise boundary close to expiry T to our bene-

fit. It is obvious that the optimal exercise boundary must reach the strike at expiry.

Moreover, close to expiry, i.e. for T − t � 1, the optimal exercise boundary of an

American put option with strike K behaves like

B∗(t) ∼ K − c√T − t (5.3)

with an appropriate constant c, see e.g. [KK98]). In other words, the exercise bound-

ary displays a square root behaviour at expiry. In order to account for this behaviour

we choose the parametric form

Bθ(t) = K − pθ(√

T − t)

(5.4)

where pθ(x) is a polynomial which satisfies pθ(0) = 0. To be more precise, we floor

the exercise boundary at 0, i.e. we take

Bθ(t) = max(K − pθ

(√T − t

), 0)

Figure 5.1 shows the situation for the polynomial pθ(x) = θ x, i.e. when the exercise

boundary is parameterized with one degree of freedom. For various levels of accuracy

ε we plot the expected discounted payoff of an at-the-money option with parameters

T = 1.0, K = 1.0, S0 = 1.0, r = 0.05 and σ = 0.2 as a function of θ. The expected

discounted payoff was computed using the multilevel Monte Carlo algorithm with the

chosen accuracy. The most accurate computation depicted in the bottom right plot

shows that the expected discounted payoff has a maximum somewhere in the interval

θ ∈ [0.2, 0.3]. An important remark we want to make at this point is that we are

36

dealing with a noisy objective function in the maximization problem (5.2) since it is

computed as a Monte Carlo approximation with a given accuracy. We note that the

choice θ = 0 implies an exercise boundary Bθ(t) = K. Therefore, θ = 0 yields zero

payoff for an exercised put struck at K. For the second extreme case θ → ∞ the

chance of early exercise decreases more and more, and in the limit we deal with the

European option case.

Figure 5.2 shows the situation for the same option parameters and the degree two

polynomial pθ(x) = θ1 x+θ2 x2 for various values of θ = (θ1, θ2) ∈ [−1, 1]2. For each of

the values (θ1, θ2), the expected discounted payoff has been computed with accuracy

ε = 10−4. At this level of accuracy, the noisy behaviour of the objective function is

barely visible. We computed the expected discounted payoff on an equidistant 60×60

grid. On this grid the maximum value of the objective function was 0.0609.

0 0.2 0.4 0.6 0.8 10

0.02

0.04

0.06

0.08

θ

E[P] f or ε = 0.01

0 0.2 0.4 0.6 0.8 10

0.02

0.04

0.06

0.08

θ

E[P] f or ε = 0.001

0 0.2 0.4 0.6 0.8 10

0.02

0.04

0.06

0.08

θ

E[P] f or ε = 0.0005

0 0.2 0.4 0.6 0.8 10

0.02

0.04

0.06

0.08

θ

E[P] f or ε = 0.0001

Figure 5.1: Value of an American put with exercise boundary Bθ(t) = K − θ√T − t

for various levels of accuracy.

37

−1

−0.5

0

0.5

1

−1

−0.5

0

0.5

1

−0.01

0

0.01

0.02

0.03

0.04

0.05

0.06

0.07

θ 2

θ 1

E[P

]

Figure 5.2: Value of an American put with exercise boundary Bθ(t) = K−θ1

√T − t−

θ2 (T − t).

5.2 Stochastic approximation

As mentioned before we only have access to noisy measurements of the objective

function in the optimization problem (5.2). This means that standard deterministic

optimization algorithms are unsuitable for the problem. Such algorithms usually re-

quire exact knowledge of the objective function without noise. Some of them even

work with the exact gradient and maybe the exact Hessian of the objective function.

The presence of noise in our objective function means that our problem falls into

the broad framework of stochastic optimization. Possible algorithms to tackle our

optimization problem include - among others - simulated annealing or genetic algo-

rithms. Simulated annealing was introduced in [KGV83] and is a probabilistic search

algorithm inspired by and mimicking annealing processes from metallurgy. Genetic

algorithms are another class of heuristic search algorithms loosely mimicking processes

from evolution theory, see for example [GHM04] for a brief introduction. We choose

38

to employ a so-called stochastic approximation approach and will explain ingredients

in this section.

Stochastic approximation has been introduced in the seminal paper by Robbins

and Monro [RM51] as a root finding method when only noisy measurements of the

underlying function are available. Kiefer and Wolfowitz in [KW52] and [Wol52] ap-

plied the ideas to a minimization or maximization of a unimodal regression function.

We now present the basic method, loosely following the exposure in [GHM04, chapter

II.6]. Keeping in mind our application, we present the method on the background of

a maximization problem.

We want to maximize the utility function (objective function)

U(θ) := E[Pτ(θ)

]over some feasible set, i.e. for θ ∈ Θ ⊆ Rp. The objective function U(θ) is assumed

to be differentiable and to have a unique maximum at θ∗. We cannot observe U(θ)

directly but only through

y(θ) = U(θ) + η(θ),

where η(θ) is a small noise term. These noise terms η(θ) are assumed to be indepen-

dent and identically distributed.

At every local extremal point of the objective function its gradient must be zero,

i.e. there holds

g(θ∗) :=∂U

∂θ(θ∗) = 0. (5.5)

This is of course only a necessary and not a sufficient condition for a maximum.

Nonetheless, stochastic approximation tries to solve (5.5).

Similar to many deterministic optimization algorithms, stochastic approximation

starts from some initial guess θ0 and works as an iterative scheme of the form

θk+1 = θk + ak gk

(θk

). (5.6)

Here, {ak} is a sequence of positive numbers and the gk

(θk

)approximate the gradient

of the objective function at the current iterate. There are many possible choices

for gk

(θk

). We work with the so-called Finite Difference Stochastic Approximation

(FDSA) and compute the gradient approximations using centered difference stencils

39

of the form

gk

(θk

)=

y(θk+ck ξ1)−y(θk−ck ξ1)

2 ck...

y(θk+ck ξp)−y(θk−ck ξp)2 ck

. (5.7)

In this definition of the gradient estimate ξj ∈ Rp denotes the j−th unit vector. The

sequence {ck} consists of positive numbers which need to be chosen appropriately. We

note that (5.7) requires 2 p function evaluations of y at each iteration step. This can

get prohibitively expensive for large multidimensional problems, i.e. for large p. In

our simple test case we work with exercise boundaries which are parametrized by one

degree of freedom only, and hence this is not a problem for us. If one moved to a larger

parameter space, then (5.7) could be replaced by a certain difference quotient which

only requires two evaluations of the objective function irrespective of the number of

parameters p. This is accomplished by the so-called simultaneous pertubation gradient

approximation, see for example [Spa92].

In our implementation of the gradient estimates (5.7) we use the same Brownian

paths for the computation of all the plus and minus bumps, i.e. for the computation of

all y(θk + ck ξl

)and y

(θk − ck ξl

). This is done to keep the variance of the gradient

estimate as low as possible and to avoid amplification of the inherent noise.

In order to prove convergence of the FDSA, the sequence {ak, ck} must satisfy the

following criteria.

1. ak, ck > 0,

2. ak → 0 and ck → 0 as k →∞,

3.∑∞

k=0 ak =∞

4.∑∞

k=0 a2k / c

2k <∞.

Under these assumptions the FDSA algorithm can be shown to converge to θ∗ in

probability, i.e. θk −→ θ∗ as k →∞ almost surely.

The performance of the FDSA, however, critically depends on the choice of the

{ak, ck}. Unfortunately, there is no general set of parameters which will guarantee

good performance for all possible applications. In [GHM04] the authors mention

common forms for ak and ck. In fact, they suggest

ak =a

(k + 1 + A)αand ck =

c

(k + 1)γ, (5.8)

40

for strictly positive a, c, α, γ and A ≥ 0. We followed this suggestion in our imple-

mentation.

Based on a given set of option parameters Figures 5.3 and 5.4 show how accurate

the gradient estimates from (5.7) are for different noise levels ε, different points θ0

and various levels of k and hence ck. For ck we chose the form given in (5.8) with

γ = 0.2 and c = 0.1.

0 0.5 10

0.02

0.04

0.06

0.08

ε = 0.0005; k = 1; c k = 0.087055

θ

0 0.5 10

0.02

0.04

0.06

0.08

ε = 0.0005; k = 5; c k = 0.069883

θ

0 0.5 10

0.02

0.04

0.06

0.08

ε = 0.0005; k = 10; c k = 0.061904

θ

0 0.5 10

0.02

0.04

0.06

0.08

ε = 0.0005; k = 20; c k = 0.054395

θ

Figure 5.3: The effectiveness of the gradient approximation from (5.7) for ε = 0.0005,θ0 = 0.5 and various choices of k, ck.

41

0 0.15 10

0.02

0.04

0.06

0.08

0.1

ε = 0.001; k = 1; c k = 0.087055

θ

0 0.15 10

0.02

0.04

0.06

0.08

0.1

ε = 0.001; k = 5; c k = 0.069883

θ

0 0.15 10

0.02

0.04

0.06

0.08

0.1

ε = 0.001; k = 10; c k = 0.061904

θ

0 0.15 10

0.02

0.04

0.06

0.08

0.1

ε = 0.001; k = 20; c k = 0.054395

θ

Figure 5.4: The effectiveness of the gradient approximation from (5.7) for ε = 0.001,θ0 = 0.15 and various choices of k, ck.

5.3 The optimization algorithm

We implemented a somewhat heuristic hierarchical optimization strategy based on the

FDSA described in section 5.2. As input it takes a sequence of decreasing tolerances

ε1 > . . . > εM , an initial guess θ0 for θ∗ and a maximal number kmax of iterations to

be conducted.

Start with θ0 and ε = ε1.

1. Compute the expected discounted payoff U(θk) for the current iterate θk as well

as the gradient approximation gk(θk) as described in (5.7). This is done with

the multilevel Monte Carlo algorithm and chosen accuracy ε.

2. If the gradient approximation gk(θk) is small, i.e. if ‖gk(θk)‖ ≤ ε / ck, then move

to the next tolerance level or if we are already at the finest accuracy ε = εM ,

then terminate the algorithm. Otherwise continue with step 3.

42

3. Conduct a line search between θk and θk + ak gk(θk) to find a value

θ ∈ [θk, θk + ak gk(θk)]

for which there is an increase in the objective function.

4. If such a point is found, then advance to θk+1 = θ accordingly. If not, take

θk+1 = θk.

5. If the maximal number of iterations kmax has been reached, then stop. Other-

wise repeat from step 1.

We note that the function evaluations needed to compute the gradient approxi-

mation gk(θk) in step 1 are done based on the same random variables, i.e. they use

the same path information. This is done to achieve a better variance in the gradient

estimate.

The line search in step 3 analyzes the values

θk,j := θk + (1/2)j ak gk(θk)

for j = 0, . . . , Nsearch. If none of these yield an improvement in the objective function,

then we take a second and maybe a third step and look at θk,j for j = Nsearch +

1, . . . , 2Nsearch or j = 2Nsearch + 1, . . . , 3Nsearch. If at that point we did not find a θk,j

with an improved objective function, we move on with θk+1 = θk. Note that although

we set θk+1 = θk the computations of the previous step will not be reproduced exactly,

since the values of ck and ak change. Hence, we do not run into an infinite loop at

this stage.

5.4 Numerical examples

In Figure 5.5 we show the convergence behaviour of the optimization algorithm. The

case presented corresponds to an at-the-money put option with time to expiry T = 1,

risk-free interest rate r = 0.05, volatility coefficient σ = 0.2, strike K = 1.0 and initial

underlying asset price S0 = 1.0.

For the FDSA we chose ck and ak according to (5.8) with a = 5, c = 0.1, A = 1,

α = 0.5 and γ = 0.2. We chose a two-level tolerance (ε1, ε2) = (0.0005, 0.0001) and

an initial guess θ0 = 0.5. For the line search in step 3 of the optimization algorithm

we used Nsearch = 2.

43

0 5 10 15 20 250.057

0.058

0.059

0.06

k

valu

eImprovement in objective function

0 5 10 15 20 250.2

0.3

0.4

0.5

k

θ

Evolu tion of parame te r θ

θ

Change in tolerance

0 5 10 15 20 250

5

10

15

k

num

ber

of M

LM

C r

uns Number of evaluations of the objective function per iterate

MLMC runs

Change in tolerance

Option value

Change in tolerance

Figure 5.5: Convergence of the optimization algorithm with initial guess θ0 = 0.5.

Within 25 iterations and a total of approximately 190 evaluations of the objective

function, the algorithm converged to a value of θ∗ ≈ 0.2502 with a corresponding

option value of

E[Pτ(θ∗)

]≈ 0.0605.

The tolerance change from ε1 to ε2 happened during the 10th iteration. Computa-

tionally, the evaluations of the objective function are of course more costly for lower

tolerances. Roughly 72 evaluations or approximately 35% of the total evaluations of

the objective function were done with tolerance ε1 and about 65% of the evaluations

were done with the smaller tolerance ε2.

As a comparison, we ran the θ-scheme with 1200 grid points in space direction

and 1000 time steps for the same option. This resulted in an option value of 0.0609.

If we take the finite difference result as benchmark value then the MLMC algorithm

yields a relative error of 0.66%.

Figure 5.6 shows the convergence results of the optimization for the same option

parameters and the same algorithm parameters, but with an improved inital guess

44

θ0 = 0.3. Within three iterations and eighteen evaluations of the objective function

the optimization algorithm finds θ∗ = 0.2586 with the same maximal value as before,

i.e. E[Pτ(θ∗)

]≈ 0.0605. Moreover, only one third of the evaluations were done with

the more expensive fine tolerance level ε2. It is therefore well worth it to conduct an

initial blind search over the whole search space with a few equispaced evaluations of

the objective function to find an educated initial guess θ0.

0 1 2 3 40.0595

0.06

0.0605

0.061

k

valu

e

Improvement in objective function

Option value

Change in tolerance

0 1 2 3 40.24

0.26

0.28

0.3

k

θ

Evolu tion of parame te r θ

θ

Change in tolerance

0 1 2 3 45

6

7

k

num

ber

of M

LM

C r

uns

Number of evaluations of the objective function per iterate

MLMC runs

Change in tolerance

Figure 5.6: Convergence of the optimization algorithm with improved initial guessθ0 = 0.3.

We repeated the tests for various other initial underlying asset prices and option

parameters. Some of the results are shown in the following tables. The parameters

of the optimization algorithm have been adjusted for some of the cases.

MLMC FD rel. Errorσ = 0.2, T = 1, K = 1.0, r = 0.05

S0 = 1.0 0.0605 0.0609 0.66%at the moneyS0 = 1.2 0.0136 0.0137 0.73%

out of the moneyS0 = 0.8 0.1959 0.2000 2.05%

in the money

The following two tables include results from further examples. In addition to

the finite difference and the multilevel Monte Carlo results we quote the values for

45

the same option parameters computed with the Longstaff-Schwartz algorithm as pub-

lished in the original paper [LS01, Table 1]. These values have been computed with

50 exercise dates per year and 100000 Monte Carlo paths.

MLMC FD rel. Error LS valueσ = 0.4, T = 1, K = 0.4, r = 0.06

S0 = 0.4 0.0527 0.0532 0.94% 0.5312at the moneyS0 = 0.42 0.04576 0.0459 0.31% 0.4582

out of the moneyS0 = 0.38 0.06138 0.0615 0.2% 0.6148

in the money

σ = 0.2, T = 1, K = 0.4, r = 0.06S0 = 0.4 0.02286 0.023194 1.4% 0.02314

at the moneyS0 = 0.42 0.01599 0.01621 1.3% 0.01617

out of the moneyS0 = 0.38 0.03173 0.03257 2.6% 0.03250

in the money

Note that in all cases the MLMC approach is biased low. The multilevel approach

in its current form came within a 3% range of the correct value in all test cases.

The original Longstaff-Schwartz algorithm seems to outperform our method with the

parametric form of the exercise boundary with one degree of freedom.

We also ran the algorithm for the parametric exercise boundary

Bθ(t) = K − θ1

√T − t− θ2 (T − t)

which is parametrized by two degrees of freedom. As an example we take the case of

the in-the-money option with S0 = 0.38, K = 0.4, T = 1 and σ = 0.2 for which we

found a slightly improved value of 0.03192 which corresponds to a relative error of

approximately 2%. At the same time the computational cost increased considerably.

The algorithm took a total of 315 evaluations of the objective function, almost 100% of

which were done with the finer tolerance level ε2. Note, that we chose a larger value

Nsearch = 4 to improve convergence. Figure 5.7 shows how the objective function

increased over the course of the optimization and how many function evaluations

were used at each iterate. Starting from the initial guess (θ1, θ2) = (0.1, 0.1) the

middle plot shows how the parameters (θ1, θ2) evolved towards (0.06621, 0.06809).

46

0 5 10 15 20 250.0305

0.031

0.0315

0.032

0.0325

k

valu

e

Improvement in objective function

Option value

Change in tolerance

0.065 0.07 0.075 0.08 0.085 0.09 0.095 0.10.06

0.08

0.1

0.12Evolu tion of parame te rs θ 1 and θ 2

θ1

θ2

θ

0 5 10 15 20 2510

15

20

k

num

ber

of M

LM

C r

uns Number of evaluations of the objective function per iterate

MLMC runs

Change in tolerance

Figure 5.7: Convergence of the optimization algorithm for the 2d parametric exerciseboundary.

47

Chapter 6

Conclusion

It is better to recognise that we arein darkness than to pretend that wecan see the light.

Hedley Bull

In this thesis we have presented a novel numerical method to approximate the

value of American options. Our method makes use of the multilevel Monte Carlo

approach introduced by Giles. In fact, we use the multilevel Monte Carlo method

to compute the value of an American option under a given parametrized exercise

rule and optimize over the chosen parametric family with the help of a stochastic

approximation approach.

We demonstrated the promising potential of the method by applying it to Amer-

ican put options written on single underlyings. For such an option a finite difference

approach is the method of choice and the multilevel Monte Carlo approach is far from

competitive. As usual, the strength of the Monte Carlo method lies in its simplicity

and convergence properties when the model is dependent on multiple stochastic fac-

tors. For models with a large number of stochastic factors the computational cost of

finite difference methods soon becomes prohibitive, a phenomenon sometimes referred

to as the curse of dimensionality. In those cases Monte Carlo methods are the only

feasible numerical means to tackle the problem.

Although we only introduced the method for the single underlying case it can in

principle be generalized to higher dimensional problems and should for example be

able to handle American basket options. One of the main obstacles on this path will

be to find a valid parametric form for the optimal exercise boundary. This parametric

form will in general depend on all stochastic factors. If one considers basket options

written on the weighted average of several underlying assets one can most likely

48

achieve a reasonable approximation with the parametric forms used in this thesis.

The multilevel algorithm has already been applied in the valuation of the European

counterpart of such basket options in [Gil09] and it would be a natural step to move

towards their American relatives.

We believe that our method can be improved considerably through further re-

search on the chosen optimization strategy. The noise pollution of the objective

function calls for some form of a stochastic optimization scheme. For the moment we

chose a standard stochastic approximation scheme. This choice might be suboptimal.

Currently, the convergence properties of the stochastic approximation highly depend

on the chosen parameters.

Another possible improvement might be achieved by further refining the paramet-

ric forms for the exercise boundary. In our numerical examples, the improvement

from moving towards the parametric form with two degrees of freedom were rather

disappointing. There might be better parametric forms altogether.

Inherently, the method produces values which are biased low, since we optimize

over a proper subset of the true feasible parameter space. One might want to combine

our approach with a method known to produce values with a high bias in order to

get some kind of confidence interval for the solution. One possible choice might be

the algorithm given in [Rog02].

49

Appendix A

MATLAB code

In this appendix we present some of the core MATLAB functions used in the imple-

mentation of the multilevel Monte Carlo algorithm for American options. We note

that this selection is not complete. In fact, we implemented a second version of the

functions MLMCAmOp.m and MLMCAmOpLevelL.m which compute option values

for several different inputs based on the same Brownian paths. These were used to

approximate the gradient estimates in (5.7). Also, all minor functions such as the

exercise boundary implementation are not shown here. The code for the θ-scheme was

taken from Dr. Christoph Reisingers finite difference notes and adjusted to handle

American options. We don’t show it here.

Due to space restrictions we show the code with forced line breaks. These are

marked with tripple dots.

A.1 MLMCAmOp.m

function [P, Nl] = ...

MLMCAmOp(eps,MLMCAmOpLevelL,exBoundType,exBoundParams)

T = 1;

r = 0.05;

sig = 0.2;

S0 = 0.8;

NperLoop = 10000;

K = 1.0;

L = -1;

N = 1000;

converged = 0;

50

while ~converged

%

% initial variance estimate

%

L = L+1;

sums = feval(MLMCAmOpLevelL,L,N,NperLoop,...

T,r,sig,S0,K,exBoundType,exBoundParams);

suml(1,L+1) = N;

suml(2,L+1) = sums(1);

suml(3,L+1) = sums(2);

%

% optimal sample sizes

%

Vl = suml(3,:)./suml(1,:) - (suml(2,:)./suml(1,:)).^2;

Nl = ceil( 2 * sqrt(Vl./(2.^(0:L))) ...

* sum(sqrt(Vl.*(2.^(0:L)))) / eps^2);

%

% update sample sums

%

for l=0:L

dNl = Nl(l+1)-suml(1,l+1);

if dNl>0

sums = feval(MLMCAmOpLevelL,l,dNl,NperLoop,...

T,r,sig,S0,K,exBoundType,exBoundParams);

suml(1,l+1) = suml(1,l+1) + dNl;

suml(2,l+1) = suml(2,l+1) + sums(1);

suml(3,l+1) = suml(3,l+1) + sums(2);

end

end

%

% test for convergence

%

range = -1:0;

51

if L>1 & 2^L>=16

con = 2.^range.*suml(2,L+1+range)./suml(1,L+1+range);

converged = (max(abs(con)) < eps/sqrt(2)) ;

end

end

%

% evaluate multi-timestep estimator

%

P = sum( suml(2,1:L+1)./suml(1,1:L+1) );

Nl = suml(1,:);

end

A.2 MLMCAmOpLevelL.m

function sums = MLMCAmOpLevelL(l,N,NperLoop,T,r,...

sig,S0,K,exBoundType,exBoundParams)

% l given level --> M^l time steps between 0 and T

% N number of path samples

% NperLoop number of path samples done in one loop

% T final time

% r risk free interest rate

% sig vol parameter

% S0 starting underlying value

% K strike value

% exBoundType flag which denotes the parametrisation

% type of the exercise boundary

% exBoundParams parameters for the exercise boundary

nf = 2^l;

nc = 2^(l-1);

hf = T/nf;

hc = T/nc;

tf = 0.0;

tc = 0.0;

52

sums(1:4) = 0;

% loop until N paths have been computed in total

for N1 = 1:NperLoop:N

% at each step deal with N2 paths

N2 = min(NperLoop,N-N1+1);

% path variable X_t = log(S_t)

Xf(:,1) = log(S0)*ones(N2,1);

% probability of not having crossed yet

Xf(:,2) = ones(N2,1);

% payoff part 1 --> barrier hit during some interval

Xf(:,3) = zeros(N2,1);

Xc = Xf;

tf = 0.0;

tc = 0.0;

if l==0

for n = 1:nf

hf = T/nf^2 * (2*(nf-n)+1);

dWf = sqrt(hf)*randn(N2,1);

Xleft = Xf(:,1);

Xright = Xleft + (r-sig^2/2)*hf + sig*dWf;

leftBarrier = exerciseBoundary(tf,T,...

K,exBoundType,exBoundParams);

tf = tf + hf;

tfMid = tf - hf/2;

rightBarrier = exerciseBoundary(tf,T,...

K,exBoundType,exBoundParams);

midBarrier = exerciseBoundary(tfMid,T,...

K,exBoundType,exBoundParams);

if (leftBarrier ~=0) && (rightBarrier ~=0)

Prob1 = exp(-2.0 * max(Xleft-log(leftBarrier),0)...

53

.* max(Xright-log(rightBarrier),0) /hf /sig^2);

else

Prob1 = exp(-2.0 * max(exp(Xleft)-leftBarrier,0) ...

.* max(exp(Xright)-rightBarrier,0) ...

/hf /sig^2./(exp(Xleft)).^2);

end

% update payoff

Xf(:,3) = Xf(:,3) + Xf(:,2).*Prob1...

.*max(K-midBarrier,0)*exp(-r*tfMid);

% update crossing probability

Xf(:,2) = Xf(:,2) .* (1.0-Prob1);

% update path variable

Xf(:,1) = Xright;

end

else

for n = 1:nc

dWc = zeros(N2,2);

dt = zeros(1,2);

for m = 1:2

hf = T/nf^2 * ( 2*(nf-2*(n-1)-m)+1);

dt(m) = hf;

dWf = sqrt(hf)*randn(N2,1);

dWc(:,m) = dWf;

Xleft = Xf(:,1);

% advance path variable

Xright = Xleft + (r-sig^2/2)*hf + sig*dWf;

% evaluate barrier on left end point

leftBarrier = exerciseBoundary(tf,T,...

K,exBoundType,exBoundParams);

tf = tf + hf;

tfMid = tf - hf/2;

% evaluate barrier on right end point

rightBarrier = exerciseBoundary(tf,T,...

54

K,exBoundType,exBoundParams);

% evaluate barrier at mid point

midBarrier = exerciseBoundary(tfMid,T,...

K,exBoundType,exBoundParams);

% prob of hitting the barrier

if (leftBarrier ~=0) && (rightBarrier ~=0)

Prob1=exp(-2.0 * max(Xleft-log(leftBarrier),0) ...

.* max(Xright-log(rightBarrier),0) /hf/sig^2);

else

Prob1=exp(-2.0 * max(exp(Xleft)-leftBarrier,0) ...

.* max(exp(Xright)-rightBarrier,0) ...

/hf /sig^2./(exp(Xleft)).^2);

end

% update payoff

Xf(:,3) = Xf(:,3) + Xf(:,2).*Prob1...

.*max(K-midBarrier,0)*exp(-r*(tfMid));

% update crossing probability

Xf(:,2) = Xf(:,2).* (1.0-Prob1);

% update path value

Xf(:,1) = Xright;

end

hc = dt(1) + dt(2);

Xleft = Xc(:,1);

% advance path variable

Xright = Xleft + (r-sig^2/2)*hc ...

+ sig*(dWc(:,1)+dWc(:,2));

lambda = dt(1)/hc;

Xmid = Xleft + lambda*(Xright-Xleft) ...

+ sig*(dWc(:,1) - lambda*(dWc(:,1)+dWc(:,2)));

%evaluate barrier at left end point

leftBarrier = exerciseBoundary(tc,T,...

K,exBoundType,exBoundParams);

55

tc = tc + hc;

tcMid = tc - hc/2;

% evaluate barrier at right end point

rightBarrier = exerciseBoundary(tc,T,...

K,exBoundType,exBoundParams);

% evaluate barrier at mid point

midBarrier2 = exerciseBoundary(tcMid,T,...

K,exBoundType,exBoundParams);

% prob of hitting the barrier

if (leftBarrier ~=0) && (rightBarrier ~=0)

logLeftBarrier = log(leftBarrier);

logRightBarrier = log(rightBarrier);

logMidBarrier1 = logLeftBarrier ...

+ lambda*(logRightBarrier-logLeftBarrier);

Prob11 = exp(-2*max(Xleft-logLeftBarrier,0) ...

.* max(Xmid-logMidBarrier1,0) /dt(1)/sig^2);

Prob12 = exp(-2*max(Xmid-logMidBarrier1,0) ...

.* max(Xright-logRightBarrier,0) /dt(2)/sig^2);

else

midBarrier1 = leftBarrier ...

+ lambda*(rightBarrier-leftBarrier);

Prob11 = exp(-2*max(exp(Xleft)-leftBarrier,0) ...

.* max(exp(Xmid)-midBarrier1,0) ...

/dt(1)/sig^2)./(exp(Xleft)).^2;

Prob12 = exp(-2*max(exp(Xmid)-midBarrier1,0) ...

.* max(exp(Xright)-rightBarrier,0)...

/dt(2)/sig^2./(exp(Xleft)).^2);

end

Prob1 = (1.0-(1.0-Prob11).*(1.0-Prob12));

% update payoff

Xc(:,3) = Xc(:,3) + Xc(:,2).*Prob1...

.*max(K-midBarrier2,0)*exp(-r*tcMid);

% update crossing probability

56

Xc(:,2) = Xc(:,2).* (1-Prob1);

% update path variable

Xc(:,1) = Xright;

end

end

Pf = Xf(:,3) + Xf(:,2)...

.*max(K-exp(Xf(:,1)),0)*exp(-r*T);

if l == 0

Pc = 0;

else

Pc = Xc(:,3) + Xc(:,2).*max(K-exp(Xc(:,1)),0)*exp(-r*T);

end

sums(1) = sums(1) + sum(Pf-Pc);

sums(2) = sums(2) + sum((Pf-Pc).^2);

sums(3) = sums(3) + sum(Pf);

sums(4) = sums(4) + sum(Pf.^2);

clear Xf

clear Xc

clear Pf

clear Pc

end

end

A.3 mlmc AmOp Test.m

function mlmc_AmOp_Test

clear all;

close all;

M=2;

NperLoop=5000;

T=1.0;

r=0.05;

sig=0.2;

57

S0=1.0;

K=1.0;

stitle = ’GBM model; American put strategy’;

N=1000000;

randn(’state’,0);

%

% first, convergence tests

%

L = 0:9;

exBoundType = 3;

exBoundParams = [0.8],

del1 = [];

del2 = [];

var1 = [];

var2 = [];

for l = L

disp(sprintf(’l = %d’,l))

sums = MLMCAmOpLevelL(l,N,NperLoop,T,...

r,sig,S0,K,exBoundType,exBoundParams);

del1 = [del1 sums(3)/N ];

del2 = [del2 sums(1)/N ];

var1 = [var1 sums(4)/N-(sums(3)/N)^2 ];

var2 = [var2 sums(2)/N-(sums(1)/N)^2 ];

end

disp(sprintf(’value = %f’,del1(length(L))))

Eps = [ 0.002 0.001 0.0005 0.0002 0.0001];

maxl = 0;

for i = 1:length(Eps)

eps = Eps(i);

[P, Nl] = MLMCAmOp(eps,@MLMCAmOpLevelL,...

58

exBoundType,exBoundParams);

l = length(Nl)-1;

maxl = max(maxl,l);

mlmc_cost(i) = sum(Nl.*M.^(0:l));

std_cost(i) = (2*var1(l+1)/eps^2)*M.^l;

Nls{i,1} = Nl;

end

maxl = max(maxl,4);

nvert = 2;

figure; pos=get(gcf,’pos’);

pos(3:4)=pos(3:4).*[1.0 0.75*nvert]; set(gcf,’pos’,pos);

set(0,’DefaultAxesColorOrder’,[0 0 0]);

set(0,’DefaultAxesLineStyleOrder’,’-*|--*|:*|-.*’)

subplot(2,2,1)

plot(L,log(var1)/log(M),L(2:end),log(var2(2:end))/log(M))

xlabel(’l’); ylabel(’log_2 variance’); %title(stitle)

legend(’P_l’,’P_l- P_{l-1}’,3)

axis([0 maxl -22 0])

subplot(2,2,2)

plot(L,log(abs(del1))/log(M), ...

L(2:end),log(abs(del2(2:end)))/log(M))

xlabel(’l’); ylabel(’log_2 |mean|’); %title(stitle)

legend(’P_l’,’P_l- P_{l-1}’,3)

axis([0 maxl -18 0])

set(0,’DefaultAxesLineStyleOrder’,...

’--o|--x|--d|--*|--s|:o|:x|:d|:*|:s’);

subplot(2,2,3)

59

semilogy(0:length(Nls{5,1})-1,Nls{5,1}, ...

0:length(Nls{4,1})-1,Nls{4,1}, ...

0:length(Nls{3,1})-1,Nls{3,1}, ...

0:length(Nls{2,1})-1,Nls{2,1}, ...

0:length(Nls{1,1})-1,Nls{1,1});

xlabel(’l’); ylabel(’N_l’); %title(stitle)

legend(’\epsilon=0.0001’,’\epsilon=0.0002’,’\epsilon=0.0005’,...

’\epsilon=0.001’,’\epsilon=0.002’,1)

axis([0 maxl 1e3 1e8])

set(0,’DefaultAxesLineStyleOrder’,’-*|-.*|--*|:*’)

subplot(2,2,4)

loglog(Eps,Eps.^2.*mlmc_cost(:)’,Eps, Eps.^2.*std_cost(:)’)

xlabel(’\epsilon’); ylabel(’\epsilon^2 Cost’); %title(stitle)

legend(’MLMC’,’MC’)

axis([1e-4 1e-2 0.2 10])

60

References

[BAW87] Giovanni Barone-Adesi and Robert E. Whaley. Efficient Analytic Approx-

imations of American Option Values. The Journal of Finance, 17:301–320,

1987.

[BN05] K. Borovkov and A. Novikov. Explicit Bounds for Approximation Rates

for Boundary Crossing Probabilities for the Wiener Process. Journal of

Applied Probability, 42(1), March 2005.

[CC08] Xinfu Chen and John Chadam. Convexity of the exercise boundary of

the american put option on a zero dividend asset. Mathematical Finance,

18(1):185–197, 2008.

[CJR92] Peter Carr, Robert Jarrow, and Myneni Ravi. Alternative Characteriza-

tions of American Put options. Mathematical Finance, 2:87–106, March

1992.

[GHM04] J. E. Gentle, W. K. Hardle, and Y. Mori, editors. Handbook of Computa-

tional Statistics, chapter II.6. Springer, 2004.

[GHM09] Mike Giles, Desmond J Higham, and Xuerong Mao. Analysing Multi-level

Monte Carlo for Options with Non-globally Lipschitz Payoff. Finance and

Stochastics, 13(3):403–413, 2009.

[Gil] M. B. Giles. Improved multilevel Monte Carlo convergence using the Mil-

stein scheme. In Monte Carlo and Quasi-Monte Carlo Methods 2006, pages

343–358. Springer-Verlag.

[Gil08] M. B. Giles. Multilevel Monte Carlo Path Simulation. Operations Research,

56(3):607–617, May 2008.

[Gil09] M. B. Giles. Multilevel Monte Carlo for Basket Options. In Proceedings of

the 2009 Winter Simulateion Conference, number 2, 2009.

61

[Gla04] Paul Glasserman. Monte Carlo Methods in Financial Engineering.

Springer, 2004.

[Huh07] Joonhee Huh. Computation of Multivariate Barrier Crossing Probability ,

and Its Applications in Finance. PhD thesis, University of Waterloo, 2007.

[KGV83] S. Kirkpatrick, C. D. Gelatt, and M. P. Vecchi. Optimization by Simulated

Annealing. Science, 220(4598):671–680, 1983.

[KK98] Rachel A. Kuske and Joseph B. Keller. Optimal exercise boundary for an

American put option. Applied Mathematical Finance, 5(2):107–116, 1998.

[KW52] J. Kiefer and J. Wolfowitz. Stochastic estimation of the maximum of a

regression function. Annals of Mathematical Statistics, 23(3), 1952.

[LPH00] Thomas Little, Vijay Pant, and Chunli Hou. A new integral representa-

tion of the early exercise boundary for American put options. Journal of

Computational Finance, pages 73–96, 2000.

[LS01] Francis A. Longstaff and Eduardo S. Schwartz. Valuing American options

by simulation : A simple least-squares approach. Review of Financial Stud-

ies, 14(1):113–147, 2001.

[RM51] H. Robbins and S. Monro. A Stochastic Approximation Method. The

Annals of Mathematical Statistics, 22(3), 1951.

[Rog02] L. C. G. Rogers. Monte Carlo valuation of American options. Mathematical

Finance, 12:271–286, July 2002.

[Sin10] Euan Sinclair. Option Trading, Pricing and Volatility Strategies and Tech-

niques. Wiley, 2010.

[Spa92] James Spall. Multivariate Stochastic Approximation Using a Simultaneous

Perturbation Gradient Approximation. IEEE Transactions on Automatic

Control, 37(3):332ff, 1992.

[Wol52] J. Wolfowitz. On the stochastic approximation method of Robbins and

Monro. Annals of Mathematical Statistics, 23(3):457–461, 1952.

62