text:
# Fast Pricing of European Asian Options with Provable Accuracy: Single-stock and Basket Options

## 1 Introduction

A *call* (respectively, *put*) *option* is a contract assigning its *holder* the right, but not the obligation, to buy (respectively, sell) a security at some future time for a specified *strike price* $`X`$ . If the holder *exercises* her right, the other party in the contract, the *writer*, is obligated to assume the opposite side of the transaction. In exchange for this right, the holder pays the writer an *option price* $`P`$. The security in this contract can be any financial asset; for the purpose of this paper, we restrict it to a single stock or a portfolio of stocks. An option in the latter case is commonly called a basket option; for clarity, we call an option in the former case a single-stock option.

Options are popular financial instruments for a variety of trading strategies. For example, options can be used to hedge risk. As protection from a potential price fall in a stock price, one can purchase a put on the stock, thereby locking in a minimum sell price. On the other hand, options can provide additional income for stockholders who write calls on their holdings; of course, this strategy carries the risk of being forced to sell the stock should the calls be exercised.

An option is valid until its *expiry date*. For a *European* option, the holder may exercise it only on the expiry date. For an *American* option, the holder may exercise it on any date up to and including the expiry date. The *payoff* of an option is the amount of money its holder makes on the contract. A European call is worth exercising if and only if $`SX`$, where $`S`$ is the stock price on the expiry date. The payoff of the call is $`(SX)^+=\mathrm{max}(SX,0)`$. For an American call, $`S`$ is set to the stock price at the exercise time. An Asian option comes in European and American flavors, depending on when it may be exercised. For an European Asian call, if $`A`$ is the average stock price over the entire life of the contract up to the expiry date, the payoff is $`(AX)^+`$. For an American Asian call, $`A`$ is set to the average stock price up to the exercise date. The payoffs of puts can be symmetrically defined.

The price $`P`$ of an option is the discounted expected value of the payoff with an appropriate martingale measure. Because of the popularity of options, pricing techniques for computing $`P`$ have been extensively researched . Generally, it is more difficult to price a basket option than a single-stock option. To compute $`P`$, the price movement of each individual stock needs to be modeled. Typically, it is modeled as Brownian motion with drift. Using a stochastic differential equation, $`P`$ can then be computed via a closed-form solution to the equation. When a closed-form solution is not known, various approaches are used to find an approximate solution. One class of approaches involves approximating the solution using numerical methods. Other approaches approximate the Brownian motion model with a discrete model, and use this model to approximate $`P`$. One such discrete model is the *binomial tree* model, due to Cox, Ross, and Rubenstein ; see Section 2 for the definition of the model.

This paper develops three polynomial-time pricing techniques with provably small errors. The remaining discussion makes the following assumptions:

1. The option in question is an European Asian single-stock or basket call.
2. Our task is to price the call at the start of its contract life.
3. The price of each underlying stock follows the binomial tree model.
4. In the case of a basket call, the price of each underlying stock moves independently.

Our results generalize easily for puts, for a later time point than the start of the contract life, and for trees with higher degrees than two. The cases of American options and of interdependent stocks remain open.

Monte Carlo simulation has been commonly used in the financial community. Despite this popularity, most reported results on error bounds are experimental or heuristic . Our first technique is the first known Monte Carlo algorithm that has analytical error bounds suitable for pricing a European Asian call with meaningful confidence and speed. As shown by Theorem 5, the number of simulations required is polynomial in (P1) the logarithm of the inverse of the error probability and (P2) the inverse of the price error relative to the strike price but is exponential in (E1) the square root of the number of underlying stocks and (E2) the volatility of these stocks over the call’s life. In particular, the algorithm is reasonably fast and accurate for a single-stock European Asian call with reasonable volatility.

Monte Carlo simulation is a randomized technique, and thus there is always a nonzero probability that the price obtained by polynomial-time Monte Carlo simulation is not accurate enough. The aggregation algorithm of Aingworth, Motwani, and Oldham (AMO)  is the first polynomial-time algorithm for pricing single-stock European Asian calls and other path-dependent options with guaranteed worst-case price errors. The AMO algorithm is based on a simple yet powerful idea called bucketing. Our second technique is a general recursive bucketing-based scheme that can use the AMO algorithm, Monte-Carlo simulation, and possibly others as the base-case subroutine. This scheme enables robust trade-offs between accuracy and time over subtrees of different sizes. For long-term options or high-frequency price averaging, it can price single-stock European Asian calls with smaller error bounds in less time than the base-case algorithms themselves. In particular, as implied by Theorem 14, given the same runtime, this recursive scheme prices more accurately than the AMO algorithm; similarly, given the same accuracy, the scheme runs faster than the AMO algorithm.

This recursive scheme works for calls written on a single stock. Our third technique combines Fast Fourier Transform (FFT)  and bucketing-based schemes to price basket calls and is applicable to European Asian calls as well as others. As shown in Theorem 18, this technique takes polynomial time in the number of days and the number of stocks, and does not add any errors to those already incurred in the companion bucketing schemes.

The remainder of this paper is organized as follows. Section 2 reviews the binomial tree model and basic definitions. Section 3 describes the new Monte Carlo algorithm. Section 4 details the recursive scheme. Section 5 gives the FFT-based technique for pricing basket calls. Section 6 concludes the paper with directions for further research.

## 2 The Binomial Tree Model

A *binomial* tree $`𝒯`$ is a *recombinant* binary tree. If $`n`$ is the depth of $`𝒯`$, $`𝒯`$ has $`t+1`$ nodes at depth $`t`$, for $`0tn`$. For $`0it`$, let $`𝒯[t,i]`$ (or simply $`[t,i]`$ if $`𝒯`$ is obvious from context) be the $`i`$-th node at level $`t`$ of $`𝒯`$. For $`t>0`$, $`𝒯[t,0]`$ and $`𝒯[t,t]`$ have one parent each, $`𝒯[t1,0]`$ and $`𝒯[t1,t1]`$ respectively. For $`0<i<t`$, $`𝒯[t,i]`$ has two parents, $`𝒯[t1,i1]`$ and $`𝒯[t1,i]`$. The number of nodes in $`𝒯`$ is $`\frac{(n+1)(n+2)}{2}`$.

Given a stock in the binomial tree model, the stock price is assumed to follow a geometric random walk through $`𝒯`$. Time is divided into $`n`$ equal periods, with the root $`𝒯[0,0]`$ corresponding to time $`t=0`$, when the option is priced, and the leaves $`𝒯[n,]`$ corresponding to time $`t=n`$, the expiry date of the option. Let $`s(𝒯[t,i])`$ (or simply $`s(t,i)`$) be the stock price at node $`𝒯[t,i]`$. At each time step, the stock price $`s(t,i)`$ rises to $`s(t+1,i+1)=us(t,i)`$—an *uptick*—with probability $`p`$ or falls to $`s(t+1,i)=ds(t,i)`$—a *downtick*—with probability $`q=1p`$. Letting $`r`$ denote the *risk-free interest rate*, the parameters $`u`$ and $`d`$ satisfy $`0<d1+ru`$ and are typically taken to be $`u=\frac{1}{d}=e^{\sigma /\sqrt{n}}`$, where $`\sigma `$ is the $`n`$-period *volatility*, or standard deviation, of the stock price . Although the probability $`p`$ of an uptick is not known in general, for the purposes of pricing options, we can use the *risk-neutral probability model* , which states that $`p=\frac{(1+r)d}{ud}`$, where $`r`$ is the risk-free interest rate for one period. This makes the expected return on the stock over one period, $`pu+(1p)d`$, equal to the risk-free return, $`1+r`$.

Let $`\mathrm{\Omega }`$ be the sample space of paths $`\omega =(\omega _1,\mathrm{},\omega _n)`$ down $`𝒯`$, where each $`\omega _t\{1,1\}`$, with $`1`$ corresponding to a downtick and $`1`$ corresponding to an uptick. Given $`\omega \mathrm{\Omega }`$ and $`0tn`$, let $`𝒯[t,\omega ]`$ be the unique node at level $`t`$ that $`\omega `$ passes through. Similar to the notation introduced above, we let $`s(𝒯[t,\omega ])=s(t,\omega )`$ be the price at node $`𝒯[t,\omega ]`$.

We define the random variables $`Y_1,\mathrm{},Y_n`$ on $`\mathrm{\Omega }`$ by $`Y_t(\omega )=\omega _t`$, the $`t`$-th component of $`\omega `$. We define the probability measure $`\mathrm{\Pi }`$ on $`\mathrm{\Omega }`$ to be the unique measure for which the random variables $`Y_1,\mathrm{},Y_n`$ are independent, identically distributed (i.i.d.) with $`P(Y_i=1)=p`$ and $`P(Y_i=1)=q`$. We start with an initial fixed stock price $`S_0=s(𝒯[0,0])`$. For $`1tn`$, the stock price $`S_t`$ is a random variable defined by $`S_t=S_0u^{_{i=1}^tY_i}`$. From the structure of the binomial tree, we have $`\mathrm{Pr}(S_t=s(t,i))=\left(\genfrac{}{}{0pt}{}{t}{i}\right)p^i(1p)^{ti}`$, where $`0it`$. The *running total* of the stock prices is defined by $`T_t=_{i=0}^tS_i`$ and the *running average* is $`A_t=T_t/(t+1)`$. For $`\omega \mathrm{\Omega }`$, we let $`S_t(\omega )=S_0u^{_{i=1}^tY_i(\omega )}`$, $`T_t(\omega )=_{i=0}^tS_i(\omega )`$, and $`A_t(\omega )=T_t(\omega )/(t+1)`$.

Recall that $`X`$ is the strike price of a European Asian call. Using the above notation, the price of this call is

$$𝔼\left((A_nX)^+\right)=\frac{1}{n+1}𝔼\left((T_n(n+1)X)^+\right)=\frac{1}{n+1}𝔼\left(\mathrm{max}(T_n(n+1)X,0)\right).$$

For large $`n`$, it is not known if this quantity can be computed exactly because the stock price can follow exponentially many paths down the tree. Below, we show how to estimate $`𝔼\left((T_n(n+1)X)^+\right)`$, from which the price of the option can be easily computed.

## 3 A New Monte Carlo Algorithm

Monte Carlo simulation methods for asset pricing were introduced to finance by Boyle . They are very popular in pricing complex instruments, particularly path-dependent European-style options. These methods involve randomly sampling paths $`\omega \mathrm{\Omega }`$ according to the distribution $`\mathrm{\Pi }`$ and computing the payoff $`(A_n(\omega )X)^+`$ on each sample. Suppose $`N`$ samples $`\omega ^1,\mathrm{},\omega ^N`$ are taken from $`\mathrm{\Omega }`$. The price estimate of the call is

$$\mu =\frac{1}{N}\underset{i=1}{\overset{N}{}}(A_n(\omega ^i)X)^+.$$

The accuracy of this estimate depends on the number of simulations $`N`$ and the variance $`\tau ^2`$ of the payoff: the error bound typically guaranteed by Monte Carlo methods is $`𝒪(\tau /\sqrt{N})`$. Generally $`\tau ^2`$ is not known, and itself must be estimated to determine the error bound of $`\mu `$.

A number of techniques are used to reduce the error of $`\mu `$. For example,  use the control variate technique, which ties the price of the option to the price of another instrument (the control variate) for which an analytically tractable solution is known. The simulation then estimates the difference between the option price and the control variate, which can be determined with greater accuracy than the option price itself. The antithetic variate method  follows not only randomly sampled paths $`\omega `$ down the binomial tree, but also the “mirror images” of each $`\omega `$. None of these techniques have known analytical error bounds for $`\mu `$.

Below we use concentration of measure results in conjunction with Monte Carlo simulation to estimate the price of a European Asian call and derive analytical error bounds for this estimate. The error bounds are in terms of the strike price $`X`$ of the option and the maximum volatility $`\sigma _{\mathrm{max}}`$ of the underlying stocks.

### 3.1 Analytical Error Bounds for the Single-stock Case

Let $`C=e^{𝔼(\mathrm{ln}T_n)}`$. In this section, we show that if $`(n+1)X/C`$ is “small”, $`𝔼\left((T_n(n+1)X)^+\right)`$ is close to $`𝔼(T_n(n+1)X)=𝔼(T_n)(n+1)X`$ (Theorem 3(1)). The option is *deep-in-the-money* and will probably be exercised. Since a closed-form formula exists for $`𝔼(T_n)`$, as described in Lemma 6, $`𝔼(T_n(n+1)X)`$ can be computed exactly, and our algorithm uses it as our estimate for $`𝔼\left((T_n(n+1)X)^+\right)`$. On the other hand, if $`(n+1)X/C`$ is not small, the variance of $`(T_n(n+1)X)^+`$ can be bounded from above (Theorem 3(2)) and our algorithm estimates its expectation with bounded error using Monte Carlo simulation.

We first give some theoretical results, then show how these results can be used in our Monte Carlo algorithm, BoundedMC. We begin by finding bounds $`A`$ and $`B`$ such that $`T_n[A,B]`$ with high probability. Our main tool for this is an inequality arising from the theory of martingales, usually known as Azuma’s Inequality . We use the inequality in a form taken from Frieze . Suppose we have a random variable $`U=U(V)`$, where $`V=(V_1,\mathrm{},V_\eta )`$ and, for $`1i\eta `$, $`V_i`$ is chosen independently from the probability space $`\mathrm{\Omega }_i`$. For $`V,W\mathrm{\Omega }=\mathrm{\Omega }_1\times \mathrm{}\times \mathrm{\Omega }_\eta `$, write $`VW`$ if $`V`$ and $`W`$ differ in exactly one component.

###### Theorem 1 (Azuma’s Inequality)

Suppose that $`VW`$ implies $`|U(V)U(W)|a`$, for some constant $`a>0`$. Then, for any real $`b0`$,

$$\mathrm{Pr}(|U𝔼(U)|b)2e^{\frac{2b^2}{a^2\eta }}.$$

###### Lemma 2

Let $`C=e^{𝔼(\mathrm{ln}T_n)}`$. For any $`\lambda >0`$, we have

$$\mathrm{Pr}\left(T_nCe^{\sigma \lambda }\text{ or }T_nCe^{\sigma \lambda }\right)2e^{\lambda ^2/2},$$

where $`\sigma `$ is the volatility of the stock.

###### Proof.

We apply Azuma’s Inequality to the random variable $`U=\mathrm{ln}T_n`$. Let $`\omega _X,\omega _Y\mathrm{\Omega }`$ be two paths that differ in a single component, say on day $`t`$. Assume without loss of generality that $`\omega _X`$ has an uptick on day $`t`$ while $`\omega _Y`$ has a downtick. Then $`\frac{T_n(\omega _X)}{T_n(\omega _Y)}u^2`$ and $`|\mathrm{ln}\frac{T_n(\omega _X)}{T_n(\omega _Y)}|=|\mathrm{ln}T_n(\omega _X)\mathrm{ln}T_n(\omega _Y)|2\mathrm{ln}u=2\frac{\sigma }{\sqrt{n}}`$.

Applying Azuma’s Inequality with $`a=2\frac{\sigma }{\sqrt{n}}`$ and $`b=\sigma \lambda `$, we have

$$\mathrm{Pr}(|\mathrm{ln}T_n𝔼(\mathrm{ln}T_n)|\sigma \lambda )2e^{\lambda ^2/2}.$$

The claimed result follows from the fact that

$`|\mathrm{ln}T_n𝔼(\mathrm{ln}T_n)|\sigma \lambda `$ $``$ $`\mathrm{ln}T_n𝔼(\mathrm{ln}T_n)\sigma \lambda \text{ or }\mathrm{ln}T_n𝔼(\mathrm{ln}T_n)\sigma \lambda `$
$``$ $`e^{\mathrm{ln}T_n}/Ce^{\sigma \lambda }\text{ or }e^{\mathrm{ln}T_n}/Ce^{\sigma \lambda }.`$
Now, fix $`\epsilon >0`$ and choose $`\lambda _0=\sqrt{2\mathrm{ln}\frac{2}{\epsilon }}`$. Then, by Lemma 2,

$$\mathrm{Pr}\left(T_nCe^{\sigma \lambda }\text{ or }T_nCe^{\sigma \lambda }\right)\epsilon .$$

Theorem 3(1) says that if $`(n+1)X<Ce^{\sigma \lambda _0}`$, then $`𝔼\left((T_n(n+1)X)^+\right)`$ is close to $`𝔼(T_n(n+1)X)`$. Otherwise, Theorem 3(2) says that $`\mathrm{Var}\left((T_n(n+1)X)^+\right)`$ is bounded.

###### Theorem 3

Let $`C=e^{𝔼(\mathrm{ln}T_n)}`$.

1. If $`(n+1)X<Ce^{\sigma \lambda _0}`$, then

$$\left|𝔼\left((T_n(n+1)X)^+\right)𝔼\left(T_n(n+1)X\right)\right|\epsilon (n+1)X.$$
2. If $`(n+1)XCe^{\sigma \lambda _0}`$, then

$$\mathrm{Var}\left((T_n(n+1)X)^+\right)(n+1)^2X^2e^{4\sigma \lambda _0}\frac{1+2\sigma \epsilon }{\lambda _02\sigma }.$$

###### Proof.

Let $`\varphi (t)`$ denote the probability density function of $`T_n`$.

Statement 1. Note first that

$`𝔼\left((T_n(n+1)X)^+\right)`$ $`=`$ $`{\displaystyle _0^{\mathrm{}}}(t(n+1)X)^+\varphi (t)𝑑t={\displaystyle _{(n+1)X}^{\mathrm{}}}(t(n+1)X)\varphi (t)𝑑t`$
$`=`$ $`𝔼(T_n(n+1)X){\displaystyle _0^{(n+1)X}}(t(n+1)X)\varphi (t)𝑑t.`$
Then

$`\left|𝔼\left((T_n(n+1)X)^+\right)𝔼(T_n(n+1)X)\right|`$
$`=\left|{\displaystyle _0^{(n+1)X}}(t(n+1)X)\varphi (t)𝑑t\right|(n+1)X{\displaystyle _0^{(n+1)X}}\varphi (t)𝑑t`$
$`=(n+1)X\mathrm{Pr}\left(T_n(n+1)X\right)(n+1)X\mathrm{Pr}\left(T_nCe^{\sigma \lambda _0}\right)`$
$`\epsilon (n+1)X,`$
where the second-last inequality follows from the assumption that $`(n+1)X<Ce^{\sigma \lambda _0}`$ and the last inequality follows from Lemma 2 and our choice of $`\lambda _0`$.

Statement 2. Since $`(n+1)XCe^{\sigma \lambda _0}`$,

$`\mathrm{Var}\left((T_n(n+1)X)^+\right)𝔼\left(\left((T_n(n+1)X)^+\right)^2\right)={\displaystyle _{(n+1)X}^{\mathrm{}}}(t(n+1)X)^2\varphi (t)𝑑t`$
$`=2{\displaystyle _{(n+1)X}^{\mathrm{}}}(t(n+1)X)\mathrm{Pr}(T_nt)𝑑t`$
$`2{\displaystyle _{Ce^{\sigma \lambda _0}}^{\mathrm{}}}(tCe^{\sigma \lambda _0})\mathrm{Pr}(T_nt)𝑑t`$
$`=2{\displaystyle _{Ce^{\sigma \lambda _0}}^{Ce^{\sigma \lambda _0}}}(tCe^{\sigma \lambda _0})\mathrm{Pr}(T_nt)𝑑t+2{\displaystyle _{Ce^{\sigma \lambda _0}}^{\mathrm{}}}(tCe^{\sigma \lambda _0})\mathrm{Pr}(T_nt)𝑑t`$
$`C^2e^{2\sigma \lambda _0}+4C^2\sigma {\displaystyle _{\lambda _0}^{\mathrm{}}}e^{2\sigma \lambda }e^{\lambda ^2/2}𝑑\lambda `$
(substitute $`t=Ce^{\sigma \lambda }`$ in the second term)
$`=C^2e^{2\sigma \lambda _0}+4C^2\sigma e^{2\sigma ^2}{\displaystyle _{\lambda _0}^{\mathrm{}}}e^{\frac{1}{2}(\lambda 2\sigma )^2}𝑑\lambda `$
$`C^2e^{2\sigma \lambda _0}+4C^2\sigma {\displaystyle \frac{e^{2\sigma \lambda _0}e^{\lambda _0^2/2}}{\lambda _02\sigma }}\text{(from the inequality }_t^{\mathrm{}}e^{\frac{1}{2}x^2}𝑑x\frac{1}{t}e^{\frac{1}{2}t^2}\text{)}`$
$`(n+1)^2X^2e^{4\sigma \lambda _0}\left(1+{\displaystyle \frac{2\sigma \epsilon }{\lambda _02\sigma }}\right)`$
(since $`(n+1)Xe^{2\sigma \lambda _0}Ce^{\sigma \lambda _0}`$ and $`\epsilon =2e^{\lambda _0^2/2}`$)
$`(n+1)^2X^2e^{4\sigma \lambda _0}{\displaystyle \frac{1+2\sigma \epsilon }{\lambda _02\sigma }}.`$
### 3.2 The BoundedMC Algorithm

We next use these results in our algorithm. One approach would be to estimate $`C=e^{\mathrm{ln}T_n}`$ to determine whether we should apply Theorem 3(1) or 3(2). Our algorithm takes a more direct approach. We begin by selecting $`N`$ samples $`\omega ^1,\mathrm{},\omega ^N\mathrm{\Omega }`$ and computing $`T_n(\omega ^1),\mathrm{},T_n(\omega ^N)`$. For $`1iN`$, define the random variable $`Z_i`$ as

$$Z_i=\{\begin{array}{cc}1\hfill & \text{if }T_n(\omega ^i)(n+1)X\text{,}\hfill \\ 0\hfill & \text{otherwise.}\hfill \end{array}$$

Let $`Z=_{i=1}^NZ_i`$.

###### Lemma 4

Let $`0<\delta <1`$ be given. With $`N=\mathrm{\Theta }(\mathrm{log}\frac{1}{\delta })`$ trials, the following statements hold.

1. If $`\frac{Z}{N}2\epsilon `$, then $`\mathrm{Pr}\left(T_n(n+1)X\right)4\epsilon `$ with probability $`1\delta `$.
2. If $`\frac{Z}{N}>2\epsilon `$, then $`\mathrm{Pr}\left(T_n(n+1)X\right)\epsilon `$ with probability $`1\delta `$.

###### Proof.

This follows from the Chernoff bound \[15, Theorems 4.1 and 4.2\]. ∎

###### Theorem 5

Let $`0<\delta <1`$ be given. With $`N=\mathrm{\Theta }(\mathrm{log}\frac{1}{\delta }+\frac{1}{\epsilon ^2}e^{4\sigma \lambda _0}\frac{1+2\sigma \epsilon }{\lambda _02\sigma })`$ trials, the following statements hold.

1. If $`\frac{Z}{N}2\epsilon `$, then, with probability $`1\delta `$, $`𝔼(T_n(n+1)X)`$ estimates $`𝔼\left((T_n(n+1)X)^+\right)`$ with error at most $`4\epsilon (n+1)X`$. Correspondingly, the price of the call is estimated with error at most $`4\epsilon X`$.
2. If $`\frac{Z}{N}>2\epsilon `$, then, with probability $`1\delta `$, $`\frac{1}{N}_{i=1}^N\left(T_n(\omega ^i)(n+1)X\right)^+`$ estimates $`𝔼\left((T_n(n+1)X)^+\right)`$ with standard deviation at most $`\epsilon (n+1)X`$. Correspondingly, the price of the call is estimated with standard deviation at most $`\epsilon X`$.

###### Proof.

The statements are proved as follows.

Statement 1. With probability $`1\delta `$, we have

$`|𝔼\left((T_n(n+1)X)^+\right)𝔼(T_n(n+1)X)|(n+1)X\mathrm{Pr}(T_n(n+1)X)`$
$`4\epsilon (n+1)X,`$
where the first inequality follows from the proof of Theorem 3(1) and the second inequality follows from Lemma 4(1). Since the price of the call is just $`\frac{1}{n+1}𝔼\left((T_n(n+1)X)^+\right)`$, the error in our estimate for the price is at most $`4\epsilon X`$. We give a closed-form formula for $`𝔼(T_n(n+1)X)=𝔼(T_n)(n+1)X`$ in Lemma 6 below.

Statement 2. If $`\frac{Z}{N}>2\epsilon `$, then by Lemma 4(2), with probability $`1\delta `$, $`\mathrm{Pr}(T_n(n+1)X)\epsilon `$. This implies $`(n+1)XCe^{\sigma \lambda _0}`$. Otherwise, if $`(n+1)X<Ce^{\sigma \lambda _0}`$, we would have

$$\epsilon \mathrm{Pr}(T_n(n+1)X)\mathrm{Pr}(T_nCe^{\sigma \lambda _0}),$$

which contradicts our choice of $`\lambda _0`$ above. Since $`(n+1)XCe^{\sigma \lambda _0}`$, we can apply Theorem 3(2). The variance of our estimate $`\frac{1}{N}_{i=1}^N(T_n(\omega ^i)(n+1)X)^+`$ for $`𝔼\left((T_n(n+1)X)^+\right)`$ is $`\frac{1}{N}\mathrm{Var}\left((T_n(n+1)X)^+\right)`$. Since

$$\mathrm{Var}\left((T_n(n+1)X)^+\right)(n+1)^2X^2e^{4\sigma \lambda _0}\frac{1+2\sigma \epsilon }{\lambda _02\sigma },$$

the variance of our estimate is at most $`\epsilon ^2(n+1)^2X^2`$ for $`N\frac{1}{\epsilon ^2}e^{4\sigma \lambda _0}\frac{1+2\sigma \epsilon }{\lambda _02\sigma }`$ and its standard deviation is $`\epsilon (n+1)X`$. Since the price of the call is just $`\frac{1}{n+1}𝔼\left((T_n(n+1)X)^+\right)`$, the expected error in our estimate for the payoff is at most $`\epsilon X`$. ∎

We now summarize our algorithm.

###### Algorithm 1

BoundedMC($`\delta `$, $`\epsilon `$)

generate $`N=\mathrm{\Theta }(\mathrm{log}\frac{1}{\delta }+\frac{1}{\epsilon ^2}e^{4\sigma \lambda _0}\frac{1+2\sigma \epsilon }{\lambda _02\sigma })`$ paths, $`\omega ^1,\mathrm{},\omega ^N`$;

let $`Z`$ be the number of paths $`\omega ^i`$ such that $`T_n(\omega ^i)(n+1)X`$;

if $`Z/N2\epsilon `$

return $`\frac{1}{n+1}𝔼(T_n(n+1)X)=\frac{1}{n+1}(𝔼(T_n)(n+1)X)`$;

else

return $`\frac{1}{N}_{i=1}^N(A_n(\omega ^i)X)^+`$.

For the completeness of Theorem 5, we conclude this section with a formula for $`𝔼(T_n)`$ .

###### Lemma 6

Let $`S_0`$ be the initial stock price and let $`r`$ be the interest rate. Then

$$𝔼(T_n)=\{\begin{array}{cc}(n+1)S_0,\hfill & \text{if }r=0\text{,}\hfill \\ \frac{(1+r)^{n+1}1}{r}S_0,\hfill & \text{if }r>0\text{.}\hfill \end{array}$$

###### Proof.

Recall that $`s(t,\mathrm{})`$ is the stock price at node $`𝒯[t,\mathrm{}]`$, $`u`$ and $`d`$ are the uptick/downtick factors, and $`p`$ and $`q`$ are the risk neutral probabilities. We have

$`𝔼(T_n)`$ $`=`$ $`{\displaystyle \underset{\text{level }0tn}{}}{\displaystyle \underset{\text{node }0\mathrm{}t}{}}s(t,\mathrm{})\mathrm{Pr}(S_t=s(t,\mathrm{}))`$
$`=`$ $`{\displaystyle \underset{t=0}{\overset{n}{}}}{\displaystyle \underset{\mathrm{}=0}{\overset{t}{}}}S_0u^{\mathrm{}}d^t\mathrm{}\left({\displaystyle \genfrac{}{}{0pt}{}{t}{\mathrm{}}}\right)p^{\mathrm{}}(1p)^t\mathrm{}`$
$`=`$ $`S_0{\displaystyle \underset{t=0}{\overset{n}{}}}{\displaystyle \underset{\mathrm{}=0}{\overset{t}{}}}\left({\displaystyle \genfrac{}{}{0pt}{}{t}{\mathrm{}}}\right)(pu)^{\mathrm{}}((1p)d)^t\mathrm{}`$
$`=`$ $`S_0{\displaystyle \underset{t=0}{\overset{n}{}}}(pu+(1p)d)^t\text{(using the binomial theorem)}`$
$`=`$ $`S_0{\displaystyle \underset{t=0}{\overset{n}{}}}(1+r)^t\text{(assuming risk-neutral rate of return)}`$
$`=`$ $`\{\begin{array}{cc}(n+1)S_0,\hfill & \text{if }r=0\text{,}\hfill \\ \frac{(1+r)^{n+1}1}{r}S_0,\hfill & \text{if }r>0\text{,}\hfill \end{array}`$
as claimed. ∎

### 3.3 Pricing Basket Options using BoundedMC

The results derived above are applicable for European Asian basket calls as well. Suppose we have a basket of $`m`$ stocks. Let $`T_n`$ denote the running total of the stocks in the basket up to day $`n`$, let $`\mathrm{\Omega }^i`$ be the sample space of paths the binomial tree corresponding to stock $`i`$ and let $`\mathrm{\Pi }^i`$ be the corresponding measure on $`\mathrm{\Omega }^i`$. Let $`\mathrm{\Omega }=\mathrm{\Omega }^1\times \mathrm{}\times \mathrm{\Omega }^m`$ and $`\mathrm{\Pi }=\mathrm{\Pi }^1\times \mathrm{}\times \mathrm{\Pi }^m`$. Lemma 2 is again applicable, but this time our random variable $`U=\mathrm{ln}T_n`$ has $`mn`$ components. Letting $`\sigma _{\mathrm{max}}`$ denote the maximum volatility among the $`m`$ stocks, we can show, as in Lemma 2, that

$$\mathrm{Pr}\left(T_nCe^{\sigma _{\mathrm{max}}\lambda \sqrt{m}}\text{ or }T_nCe^{\sigma _{\mathrm{max}}\lambda \sqrt{m}}\right)2e^{\lambda ^2/2},$$

for any $`\lambda >0`$. The results of the single stock case are now applicable. Given $`\epsilon >0`$, choose $`\lambda _0=\sqrt{2\mathrm{ln}\frac{2}{\epsilon }}`$, so that $`\mathrm{Pr}\left(T_nCe^{\sigma _{\mathrm{max}}\lambda \sqrt{m}}\text{ or }T_nCe^{\sigma _{\mathrm{max}}\lambda \sqrt{m}}\right)\epsilon `$. We sample $`N`$ paths $`\omega ^1,\mathrm{},\omega ^N`$ in $`\mathrm{\Omega }`$ according to $`\mathrm{\Pi }`$. Let $`Z`$ be be number of paths $`\omega ^i`$ such that $`T_n(\omega ^i)(n+1)X`$, where $`X`$ is the strike price of the basket call.

###### Theorem 7

Let $`0<\delta <1`$ be given. With $`N=\mathrm{\Theta }(\mathrm{log}\frac{1}{\delta }+\frac{1}{\epsilon ^2}e^{4\sigma _{\mathrm{max}}\lambda _0\sqrt{m}}\frac{1+2\sigma _{\mathrm{max}}\epsilon \sqrt{m}}{\lambda _02\sigma _{\mathrm{max}}\sqrt{m}})`$ trials, the following statements hold.

1. If $`\frac{Z}{N}2\epsilon `$, then, with probability $`1\delta `$, $`𝔼(T_n(n+1)X)`$ estimates $`𝔼\left((T_n(n+1)X)^+\right)`$ with error at most $`4\epsilon (n+1)X`$. Correspondingly, the price of the call is estimated with error at most $`4\epsilon X`$.
2. If $`\frac{Z}{N}>2\epsilon `$, then, with probability $`1\delta `$, $`\frac{1}{N}_{i=1}^N\left(T_n(\omega ^i)(n+1)X\right)^+`$ estimates $`𝔼\left((T_n(n+1)X)^+\right)`$ with standard deviation at most $`\epsilon (n+1)X`$. Correspondingly, the price of the call is estimated with standard deviation at most $`\epsilon X`$.

###### Proof.

This theorem is analogous to Theorem 5 and can be proven using similar techniques. ∎

## 4 A Recursive Bucketing-Based Scheme

The AMO algorithm takes $`𝒪(kn^2)`$ time to produce a price estimate in the range $`[P\frac{nX}{k},P]`$, where $`P`$ is the exact price of the call and $`k`$ is any natural number. As in Section 3, this algorithm estimates $`𝔼\left((T_n(n+1)X)^+\right)`$, from which the price of the call, $`𝔼((A_nX)^+)`$, can be easily estimated. Our recursive scheme is a generalization of a variant of the AMO algorithm. Below we first describe this variant, called *Bucketed Tree Traversal* (BTT) and then detail our scheme, called *Recursive* Bucketed Tree Traversal (RecBTT).

Given binomial tree $`𝒯`$ of depth $`n`$, and numbers $`t`$, $`i`$, $`m`$ such that $`0tn`$, $`0it`$, and $`mnt`$, let $`𝒯_m^{[t,i]}`$ be the subtree of depth $`m`$ rooted at node $`𝒯[t,i]`$. Given $`0tn`$, let $`\omega |_t`$ be the prefix of $`\omega `$ up to level $`t`$ of $`𝒯`$. Note that $`\omega |_n=\omega `$. Given $`\psi ,\omega \mathrm{\Omega }`$, we say that $`\psi `$ is an *extension* of $`\omega |_m`$ if, for $`0tm`$, we have $`\psi _t=\omega _t`$. Given another binomial tree $`𝒰`$ of depth $`n`$ we say that $`\psi \mathrm{\Omega }(𝒰)`$ is *isomorphic* to $`\omega \mathrm{\Omega }(𝒯)`$, if, for all $`0tn`$, $`\psi _t=\omega _t`$.

Like the AMO algorithm, BTT is based on the following simple observation. Suppose that the running total $`T_m(\omega )=T_m(\omega |_m)`$ of the stock prices on path $`\omega \mathrm{\Omega }`$ exceeds the *barrier* $`B=(n+1)X`$. Then, for any extension $`\psi `$ of $`\omega |_m`$, $`T_n(\psi )`$ also exceeds $`B`$ and the call will be exercised. If we know the call will be exercised on all extensions of $`\omega |_m`$, it is easy to compute the payoff of the call on these extensions, as described in Lemma 6.

As we travel down a path $`\omega `$, once the running total $`T_m(\omega )`$ exceeds $`B`$, we can just keep track of the running total on extensions $`\psi `$ of $`\omega |_m`$ weighted by $`\mathrm{\Pi }(\psi )`$, from which the value of the option can be computed. Hence, we only need to individually keep track of path prefixes $`\omega |_m`$ that have running totals $`T_m(\omega |_m)`$ less than $`B`$.

Unfortunately, there may be exponentially many such $`\omega |_m`$. However, the running totals $`T_m(\omega |_m)`$ are in the bounded range $`[0,B)`$. Rather than trying to keep track of each running total individually, we instead group the running totals terminating at each node into *buckets* that subdivide this interval. This introduces some round-off error. Suppose we use $`k`$ buckets to divide $`[0,B)`$ into equal-length subintervals and we use the left endpoint of each interval as the representative value of the running totals contained in that bucket. At each step down the tree, when we put a running total into a bucket, an error of at most $`\frac{B}{k}`$ is introduced. Traveling down $`n`$ levels of the tree, the total $`T_n(\omega )`$ of a path $`\omega `$ is underestimated by at most $`\frac{nB}{k}`$ and the average $`A_n(\omega )`$ is underestimated by at most $`\frac{B}{k}`$.

BTT is detailed in Algorithm 2. At each node $`v=𝒯[t,i]`$ of $`𝒯`$, create $`k+1`$ buckets to store partial sums of path prefixes terminating at $`v`$. There will be $`k`$ *core buckets* and one *overflow bucket*. This overflow bucket is the only difference between BTT and the AMO algorithm. For $`0j<k`$, core bucket $`b_j(v)`$ stores the *probability mass* $`b_j(v).\mathrm{mass}`$ of path prefixes that terminate at node $`v`$ and have running totals in its *range* $`\mathrm{range}(j)=[j\frac{B}{k},(j+1)\frac{B}{k})`$. The representative value of partial sums in the bucket is denoted by $`b_j(v).\mathrm{value}=j\frac{B}{k}`$. The overflow bucket $`b_k(v)`$ stores the probability-weighted running total estimates of path prefixes that have estimated running totals exceeding $`B`$. This quantity is denoted by $`b_k(v).\mathrm{value}`$. The probability mass of these path prefixes is denoted by $`b_k(v).\mathrm{mass}`$. BTT iterates through each of the $`k+1`$ buckets of each of the $`\frac{(n+1)(n+2)}{2}`$ nodes in $`𝒯`$, for a total runtime of $`𝒪(kn^2)`$.

###### Algorithm 2

BTT($`𝒯`$, $`k`$, $`B`$)

for each node $`v𝒯`$ and each bucket $`b_j(v)`$

set $`b_j(v).\mathrm{mass}0`$;

take $`j`$ such that initial price $`s(𝒯[0,0])\mathrm{range}(j)`$; $`b_j(𝒯[0,0]).\mathrm{mass}1`$;  % assume $`s(𝒯[0,0])<B`$

for $`t=0,\mathrm{},(n1)`$  % iterate through each level

for $`i=0,\mathrm{},t`$  % iterate through each node at level $`t`$

let $`v=𝒯[t,i]`$;  % shorthand notation for node $`𝒯[t,i]`$

for $`w\{𝒯[t+1,i],𝒯[t+1,i+1]\}`$  % for each child of node $`v`$

let $`p^{}\{p,q\}`$ be the probability of going from node $`v`$ to $`w`$;

for $`b_j(v)\{b_0(v),\mathrm{},b_k(v)\}`$  % for each bucket at node $`v`$

let $`Vb_j(v).\mathrm{value}+s(w)`$;

let $`Mb_j(v).\mathrm{mass}\times p^{}`$;

if $`V<B`$

take $`\mathrm{}`$ such that $`V\mathrm{range}(\mathrm{})`$;

$`b_{\mathrm{}}(w).\mathrm{mass}b_{\mathrm{}}(w).\mathrm{mass}+M`$;

else % in overflow bucket

$`b_k(w).\mathrm{value}\frac{b_k(w).\mathrm{mass}\times b_k(w).\mathrm{value}+M\times V}{b_k(w).\mathrm{mass}+M}`$;

$`b_k(w).\mathrm{mass}b_k(w).\mathrm{mass}+M`$;

return $`_{i=0}^nb_k(n,i).\mathrm{mass}\times (b_k(n,i).\mathrm{value}B)`$.

% return option price estimated from overflow buckets at leaves

We propose RecBTT, a recursive extension of BTT. Consider some level $`t`$ in our binomial tree $`𝒯`$ and assume that the weights of all path prefixes terminating at level $`t`$ have been put into the appropriate buckets. BTT uses these weights to compute the bucket weights of nodes at level $`t+1`$. In contrast, RecBTT recursively solves the problem for subtrees $`𝒯_m^{[t,i]}`$, $`0it`$, of some depth $`m<nt`$ rooted at node $`𝒯[t,i]`$.<sup>1</sup><sup>1</sup>1Actually, the trees on which we recursively solve the problem are not exactly the $`𝒯_m^{[t,i]}`$. Each is identical to the respective $`𝒯_m^{[t,i]}`$, except the price at the root is changed from $`s(𝒯[t,i])`$ to $`0`$. The reason for this is explained in Remark 1. As each recursive call is complete, RecBTT Merges the bucket weights at the leaves of $`𝒯_m^{[t,i]}`$ into the corresponding nodes at level $`t+m`$ of $`𝒯`$. The advantages of the recursive calls are twofold.

1. They use finer bucket granularity, resulting in improved accuracy.
2. The results of a single recursive call on a particular subtree $`𝒯_m^{[t,i]}`$ are used to Estimate the results of other recursive calls to other subtrees $`𝒯_m^{[t,j]}`$, where $`j>i`$, as long as the node prices in $`𝒯_m^{[t,j]}`$ are “sufficiently close” to the corresponding node prices in $`𝒯_m^{[t,i]}`$. This improves the runtime, since we do not need to make all $`t+1`$ of the recursive calls, so there are portions of $`𝒯`$ that we do not directly traverse.

### 4.1 The Merge Procedure

Consider a recursive call on the subtree $`𝒯_1=𝒯_{n_1}^{[t_0,i_0]}`$ of depth $`n_1`$ rooted at node $`v_0=𝒯[t_0,i_0]`$. A leaf $`v_1=𝒯_1[n_1,i_1]`$ of $`𝒯_1`$ ($`0i_1n_1`$) corresponds to the node $`v_2=𝒯[t_0+n_1,i_0+i_1]`$ of $`𝒯`$. Merge incorporates the bucket weights at $`v_1`$ into the bucket weights at $`v_2`$. Recall that the recursive call on $`𝒯_1`$ is made with finer bucket granularity. Assume we use $`k_1=h_1k_0`$ core buckets instead of just $`k_0=k`$. We first combine each group of $`h_1`$ buckets at $`v_1`$ into a single bucket, so that we are left with $`k_0`$ buckets to merge into $`v_2`$. When we refer to a bucket $`b_{j_1}(v_1)`$ below, $`0j_1<k_0`$, we mean one of these $`k_0`$ combined buckets.

The Merge procedure is described in Algorithm 3. Consider first the core buckets. Let $`0j_0,j_1,j_2<k_0`$ denote core bucket indices. Bucket $`b_{j_0}(v_0)`$ contains the mass of path prefixes in $`𝒯`$ terminating at $`v_0`$ whose running total estimates fall into the interval $`\mathrm{range}(j_0)=[j_0\frac{B}{k_0},(j_0+1)\frac{B}{k_0})`$. Bucket $`b_{j_1}(v_1)`$ contains the mass of full paths in $`𝒯_1`$ terminating at node $`v_1`$ whose running total estimates fall into the interval $`\mathrm{range}(j_1)`$. This is equal to the mass of partial paths in $`𝒯`$ starting at node $`v_0`$ and terminating at node $`v_2`$ whose running total estimates fall into the interval $`\mathrm{range}(j_1)`$. Merging $`𝒯_1`$ into $`𝒯`$ involves merging each leaf $`v_1`$ of $`𝒯_1`$ into the corresponding node $`v_2`$ of $`𝒯`$. Once the merging procedure is done, $`b_{j_2}(v_2).\mathrm{mass}`$ is updated to contain the weight of path prefixes in $`𝒯`$ passing through node $`v_0`$ and terminating at node $`v_2`$ that have running total estimates in the interval $`\mathrm{range}(j_2)`$. The overflow buckets are handled similarly.

###### Algorithm 3

Merge($`𝒯`$, $`𝒯_1=𝒯_{n_1}^{[t_0,i_0]}`$)

let $`v_0𝒯[t_0,i_0]`$;

for $`i_1=0,\mathrm{},n_1`$  % for each leaf of $`𝒯_1`$

let $`v_1𝒯_1[n_1,i_1]`$, $`v_2𝒯[t_0+n_1,i_0+i_1]`$;

for $`j_0=0,\mathrm{},k_0`$  % buckets in $`v_0`$

for $`j_1=0,\mathrm{},k_0`$  % buckets in $`v_1`$

let $`Vb_{j_0}(v_0).\mathrm{value}+b_{j_1}(v_1).\mathrm{value}`$;

let $`Mb_{j_0}(v_0).\mathrm{mass}\times b_{j_1}(v_1).\mathrm{mass}`$;

if $`V<B`$

take $`j_2`$ such that $`V\mathrm{range}(j_2)`$;

$`b_{j_2}(v_2).\mathrm{mass}b_{j_2}(v_2).\mathrm{mass}+M`$;

else

$`b_k(v_2).\mathrm{value}\frac{b_k(v_2).\mathrm{mass}\times b_k(v_2).\mathrm{value}+M\times V}{b_k(v_2).\mathrm{mass}+M}`$;

$`b_k(v_2).\mathrm{mass}b_k(v_2).\mathrm{mass}+M`$.

###### Remark 1

Notice that the price at $`v_0`$ is counted twice: once in the path prefix from the root $`𝒯[0,0]`$ to $`v_0`$ and once in the partial path between $`v_0`$ and $`v_2`$. To address this issue, when we recursively solve the problem on the subtree $`𝒯_1`$, we set the price $`s(𝒯_1[0,0])`$ at the root to be $`0`$, ensuring that this price is counted once. This modification does not change our algorithms.

###### Lemma 8

For an arbitrary node $`v`$, let $`E(v)`$ be the maximum amount by which running totals terminating at node $`v`$ are underestimated by the bucket values. Using the Merge algorithm, we have $`E(v_2)E(v_0)+E(v_1)+\frac{B}{k}`$.

###### Proof.

Consider first the core buckets. Bucket $`b_{j_0}(v_0)`$ covers running totals in the range $`[j_0\frac{B}{k},(j_0+1)\frac{B}{k})`$ and $`b_{j_1}(v_1)`$ covers running totals in the range $`[(j_1)\frac{B}{k},(j_1+1)\frac{B}{k})`$. The concatenation of paths in these buckets covers running totals in the range $`[(j_0+j_1)\frac{B}{k},(j_0+j_1+2)\frac{B}{k})`$. Assuming $`j_0+j_1<k`$, we put these paths in bucket $`b_{j_0+j_1}(v_2)`$, and the running totals are underestimated by the original error of $`E(v_0)+E(v_1)`$, plus an additional $`\frac{B}{k}`$, since some partial paths that fall in the range of bucket $`b_{j_0+j_1+1}(v_2)`$ are actually put in $`b_{j_0+j_1}(v_2)`$. If $`j_0+j_1k`$, then these paths are put in the overflow bucket. In this case, no additional error is introduced. The original error of $`E(v_0)+E(v_1)`$ is carried over. Similar arguments can be made when we are merging overflow buckets. ∎

###### Lemma 9

Merge can be made to run in $`𝒪(n_1k\mathrm{log}k)`$ time.

###### Proof.

In the implementation of Algorithm 3, Merge runs in $`𝒪(n_1k^2)`$ time. However, the core buckets can be merged with a faster technique. Let $`a_0(x)=_{j_0=0}^{k1}b_{j_0}(v_0).\mathrm{mass}x^{j_0}`$ and $`a_1(x)=_{j_1=0}^{k1}b_{j_1}(v_1).\mathrm{mass}x^{j_1}`$ be polynomial representations of the bucket masses at nodes $`v_0`$ and $`v_1`$. Let $`a_2(x)=a_0(x)a_1(x)`$. This product can be computed in $`𝒪(k\mathrm{log}k)`$ time with the Fast Fourier Transform (FFT) . For $`0j_2<k`$, the coefficient of the $`x^{j_2}`$ term of $`a_2(x)`$ is the probability mass that should be added to bucket $`b_{j_2}(v_2)`$. For $`j_2>k`$, this coefficient should be added to the overflow bucket $`b_k(v_2)`$. So the core buckets can be merged in $`𝒪(k\mathrm{log}k)`$ time per node. Merging the overflow buckets takes $`𝒪(k)`$ time, so the total runtime per node is $`𝒪(k\mathrm{log}k)`$. ∎

### 4.2 The Estimate Procedure

Let $`𝒯_1=𝒯_m^{[t_0,i_1]}`$ and $`𝒯_2=𝒯_m^{[t_0,i_2]}`$ be two subtrees of $`𝒯`$, where $`i_2>i_1`$ We now describe the Estimate$`(𝒯_2,𝒯_1)`$ procedure, which estimates the weights in the leaf buckets of $`𝒯_2`$ from the weights in the leaf buckets of $`𝒯_1`$. This saves us the work of recursively solving the problem on $`𝒯_2`$.

Estimate is described in Algorithm 4. It uses the following fact. Given any node $`v_1=𝒯_1[t,i]`$ in $`𝒯_1`$, let $`v_2=𝒯_2[t,i]`$ be the corresponding node in $`𝒯_2`$. Notice that there is a constant $`\alpha >1`$ such that for all $`(v_1,v_2)`$ pairs, $`s(v_2)=\alpha s(v_1)`$. Hence, for any path $`\psi \mathrm{\Omega }(𝒯_2)`$, we have $`T_m(\psi )=\alpha T_m(\omega )`$, where $`\omega \mathrm{\Omega }(𝒯_1)`$ is isomorphic to $`\psi `$.

###### Algorithm 4

Estimate($`𝒯_2=𝒯_m^{[t_0,i_2]}`$, $`𝒯_1=𝒯_m^{[t_0,i_1]}`$)

for $`i=0,\mathrm{},m`$  % go through the leaf buckets of $`𝒯_1`$ and $`𝒯_2`$

let $`v_1𝒯_1[m,i]`$, $`v_2𝒯_2[m,i]`$;

for $`j_1=0,\mathrm{},k`$  % go through each bucket at $`v_1`$

let $`V\alpha b_{j_1}(v_1).\mathrm{value}`$;

let $`Mb_{j_1}(v_1).\mathrm{mass}`$;

if $`V<B`$

take $`j_2`$ such that $`V\mathrm{range}(j_2)`$;

$`b_{j_2}(v_2).\mathrm{mass}b_{j_2}(v_2).\mathrm{mass}+M`$;

else

$`b_k(v_2).\mathrm{value}\frac{b_k(v_2).\mathrm{mass}\times b_k(v_2).\mathrm{value}+M\times V}{b_k(v_2).\mathrm{mass}+M}`$;

$`b_k(v_2).\mathrm{mass}b_k(v_2).\mathrm{mass}+M`$;

###### Lemma 10

Suppose that $`\alpha 2`$ and assume that the total path sums in $`𝒯_1`$ are underestimated by our bucketing scheme by at most $`E`$. Estimate underestimates the total path sums in $`𝒯_2`$ by at most $`2E+2\frac{B}{k}`$.

###### Proof.

Take any path $`\omega \mathrm{\Omega }(𝒯_1)`$ and let $`U_m(\omega )`$ be the estimate for $`T_m(\omega )`$ made by the bucketing scheme. By assumption, $`T_m(\omega )U_m(\omega )E`$. Let $`\psi \mathrm{\Omega }(𝒯_2)`$ be isomorphic to $`\omega `$. Using $`\alpha U_m(\omega )`$ as an estimate for $`T_m(\psi )=\alpha T_m(\omega )`$, we underestimate $`T_m(\psi )`$ by at most $`\alpha E2E`$. This accounts for the first error term.

Now, consider core bucket $`b_{j_1}(v_1)`$ of some leaf $`v_1`$ of $`𝒯_1`$. The range of running totals covered by this bucket is $`\mathrm{range}(j_1)=[j_1\frac{B}{k},(j_1+1)\frac{B}{k})`$. When we map this bucket to $`𝒯_2`$, it covers path sums in the range $`[\alpha j_1\frac{B}{k},\alpha (j_1+1)\frac{B}{k})`$, which falls into at most three buckets in the corresponding node $`v_2`$ of $`𝒯_2`$, since $`\alpha 2`$. Call these buckets $`b_{j_2}(v_2)`$, $`b_{j_2+1}(v_2)`$, and $`b_{j_2+2}(v_2)`$ (assume these are all core buckets). Putting the entire mass into $`b_{j_2}(v_2)`$ causes the portion of partial sums that fall into bucket $`b_{j_2+2}(v_2)`$ to be underestimated by additional $`2\frac{B}{k}`$, which accounts for the second error term.

Similar errors occur if the range $`[\alpha j_1\frac{B}{k},\alpha (j_1+1)\frac{B}{k})`$ spills into the overflow bucket $`b_k(v_2)`$ and when mapping the overflow bucket $`b_k(v_1)`$ in $`v_1`$ to $`𝒯_2`$. ∎

###### Lemma 11

Suppose that we would like to determine the leaf bucket weights of the subtrees $`𝒯_m^{[t,i]}`$, where $`0it`$. We need only call RecBTT at most once for every $`\mathrm{\Theta }(\frac{\sqrt{n}}{\sigma })`$ subtrees, and use the Estimate procedure to estimate the leaf bucket weights of the other subtrees with bounded error.

###### Proof.

We begin by recursively solving the problem on the subtree $`𝒯_m^{[t,0]}`$. Notice that $`s(𝒯[t,i])=u^{2i}s(𝒯[t,0])`$. By Lemma 10, as long as $`u^{2i}2`$, we can use Estimate to compute the leaf bucket weights of $`𝒯_m^{[t,i]}`$, without introducing significant error. Recalling that we take $`u=e^{\sigma /\sqrt{n}}`$, where $`\sigma `$ is the volatility of the stock, we see that we can use Estimate$`(𝒯_m^{[t,i]},𝒯_m^{[t,0]})`$ for $`i`$ as large as $`\frac{\sqrt{n}\mathrm{ln}2}{2\sigma }=\mathrm{\Theta }(\frac{\sqrt{n}}{\sigma })`$ while keeping the error bounded. This proves the lemma. ∎

### 4.3 Error and Runtime Analysis

We now derive recursive expressions for the error and runtime of RecBTT. Suppose there are $`n_0`$ trading periods and we use a total of $`k_0`$ buckets per node. For $`i>0`$, let $`n_i`$ be the number of trading periods and $`k_i`$ the number of buckets per node we use in the $`i`$-th subproblem (at the $`i`$-th level into the recursion). Let $`E_i=E(n_i,k_i)`$ be the *error* bound made in the $`i`$-th subproblem. The error is the amount by which RecBTT underestimates the running totals. Let $`T_i=T(n_i,k_i)`$ be the runtime of RecBTT on the $`i`$-th subproblem, including all recursive calls. We recursively call RecBTT on binomial trees of decreasing depth (decreasing $`n_i`$) with an increasing number of buckets (increasing $`k_i`$) until we reach a tree of some small depth.

###### Lemma 12

When $`i`$ recursive calls are made, the error made by RecBTT is

$$E_0=5Bn_0\underset{j=0}{\overset{i}{}}\frac{2^j}{k_jn_{j+1}}+\frac{2^{i+1}n_0}{n_{i+1}}\stackrel{~}{E}_{i+1},$$

where $`\stackrel{~}{E}_{i+1}`$ is the error in solving the $`(i+1)`$-st subproblem.

###### Proof.

Consider the error in the $`i`$-th subproblem, $`E_i=E(n_i,k_i)`$. Each recursive call has an error of $`E_{i+1}`$. When the $`k_{i+1}`$ smaller granularity buckets in the $`(i+1)`$-st problem are grouped into the $`k_i<k_{i+1}`$ buckets of the $`i`$-th problem, an error of one bucket size, $`\frac{B}{k_i}`$, is introduced. A call to Estimate underestimates the price sums by at most $`2(E_{i+1}+\frac{B}{k_i})+2\frac{B}{k_i}=4\frac{B}{k_i}+2E_{i+1}`$, by Lemma 10. This error is made at most $`\frac{n_i}{n_{i+1}}`$ times, once at each of levels $`n_{i+1},2n_{i+1},\mathrm{},\frac{n_i}{n_{i+1}}n_{i+1}`$. At each of these levels, an additional error of $`\frac{B}{k_i}`$ is introduced by the Merge procedure, as described in Lemma 8. The total error in the $`i`$-th subproblem is

$$E_i=\frac{5Bn_i}{k_in_{i+1}}+\frac{2n_i}{n_{i+1}}E_{i+1}.$$

Unraveling $`i`$ levels of the recursion on the original problem yields the result. ∎

For the runtime of RecBTT, we must analyze how many times the $`(i+1)`$-st subproblem needs to be solved when solving the $`i`$-th subproblem. At each of levels $`0,n_{i+1},\mathrm{},(\frac{n_i}{n_{i+1}}1)n_{i+1}`$ in the binomial subtree of the $`i`$-th subproblem, suppose the $`(i+1)`$-st subproblem is called at most $`c_i`$ times.

###### Lemma 13

When $`i`$ recursive calls are made, the runtime of RecBTT is

$$T_0=𝒪\left(\underset{j=0}{\overset{i}{}}n_0n_jk_j\mathrm{log}(k_j)\underset{k=0}{\overset{j1}{}}c_k\right)+\frac{n_0_{k=0}^ic_k}{n_{i+1}}\stackrel{~}{T}_{i+1},$$

where $`\stackrel{~}{T}_{i+1}`$ is the time it takes to solve the $`(i+1)`$-st subproblem.

###### Proof.

Consider the runtime of the $`i`$-th subproblem, $`T_i=T(n_i,k_i)`$. Each recursive call takes time $`T_{i+1}`$ and at most $`c_i`$ recursive calls are made at each of levels $`0,n_{i+1},\mathrm{},(\frac{n_i}{n_{i+1}}1)n_{i+1}`$. The leaf bucket weights of the other at most $`n_i`$ subtrees rooted at the nodes at each of these levels can be determined using Estimate, which takes $`𝒪(k_in_{i+1})`$ time. For the Merge procedure, at each of $`\frac{n_i}{n_{i+1}}`$ levels $`t`$, each of the at most $`n_i`$ nodes at level $`t`$ must be merged with $`n_{i+1}`$ leaves from the subtrees $`𝒯_{n_{i+1}}^{[t,j]}`$ to get the bucket weights at level $`t+n_{i+1}`$. The merging of each node takes $`𝒪(k_i\mathrm{log}k_i)`$ time. The total runtime of the $`i`$-th subproblem is

$$T_i=\frac{n_i}{n_{i+1}}(c_iT_{i+1}+𝒪(n_ik_in_{i+1})+𝒪(n_in_{i+1}k_i\mathrm{log}k_i))=\frac{n_ic_i}{n_{i+1}}T_{i+1}+𝒪(n_i^2k_i\mathrm{log}k_i).$$

Unraveling $`i`$ levels of the recursion on the original problem yields the lemma. ∎

###### Theorem 14

Given integer $`R>2`$, let $`\gamma =\frac{1}{R}`$, and for $`i>0`$, let $`n_i=(\frac{n_0}{\sigma ^2})^{1/2i\gamma }`$ and $`k_i=4^ik_0(\frac{n_0}{\sigma ^2})^{i\gamma }`$, where $`\sigma `$ is the volatility of the stock. RecBTT underestimates $`𝔼\left((T_n(n+1)X)^+\right)`$ by at most $`𝒪\left(\frac{Bn_0^{1/2+\gamma }\sigma ^{12\gamma }}{k_0}\right)`$ and takes time $`𝒪\left(2^{1/\gamma }n_0^2k_0(\frac{1}{\gamma }+\mathrm{log}\frac{k_0n_0}{\sigma ^2})\right).`$

###### Proof.

After $`K=\frac{1}{2\gamma }`$ levels of recursion, we have $`n_K=(\frac{n_0}{\sigma ^2})^0=1`$. The problem consists of a single node and can be solved in constant time $`\stackrel{~}{T}_K`$ with an error of $`\stackrel{~}{E}_K=\frac{B}{k_K}=\frac{\sigma B}{4^Kk_0n_0^{1/2}}`$. ¿From Lemma 12, the error is

$`E_0=5Bn_0{\displaystyle \underset{i=1}{\overset{K}{}}}{\displaystyle \frac{2^{i1}}{k_{i1}n_i}}+{\displaystyle \frac{2^Kn_0}{n_K}}\stackrel{~}{E}_K=5Bn_0{\displaystyle \underset{i=1}{\overset{K}{}}}{\displaystyle \frac{1}{2^{i1}k_0(\frac{n_0}{\sigma ^2})^{1/2\gamma }}}+{\displaystyle \frac{2^Kn_0\sigma B}{4^Kk_0n_0^{1/2}}}`$
$`=𝒪\left({\displaystyle \frac{\sigma ^{12\gamma }Bn_0^{1/2+\gamma }}{k_0}}\right).`$
For the runtime analysis, by Lemma 11, note that $`c_0=\frac{n}{\sqrt{n}/\sigma }=\sigma \sqrt{n}`$. For $`i>0`$, since $`n_i<\frac{\sqrt{n}}{\sigma }`$, $`c_i=1`$. Combining this fact with Lemma 13 yields the runtime

$`T_0`$ $`=`$ $`n_0^2k_0\mathrm{log}k_0+𝒪\left({\displaystyle \underset{i=1}{\overset{K1}{}}}n_0n_ic_0k_i\mathrm{log}k_i\right)+𝒪(n_0c_0)`$
$`=`$ $`n_0^2k_0\mathrm{log}k_0+𝒪\left({\displaystyle \underset{i=1}{\overset{K1}{}}}n_0^24^ik_0(\frac{1}{\gamma }+\mathrm{log}\frac{k_0n_0}{\sigma ^2})\right)`$
$`=`$ $`𝒪(2^{1/\gamma }n_0^2k_0(\frac{1}{\gamma }+\mathrm{log}\frac{k_0n_0}{\sigma ^2})).`$
###### Corollary 15

Given integer $`R>2`$, let $`\gamma =\frac{1}{R}`$ and choose $`n_i`$ and $`k_i`$ as in Theorem 14. In time $`𝒪\left(2^{1/\gamma }n_0^2k_0(\frac{1}{\gamma }+\mathrm{log}\frac{k_0n_0}{\sigma ^2})\right),`$ RecBTT returns an option price in the range $`[P\frac{Xn_0^{1/2+\gamma }\sigma ^{12\gamma }}{k_0},P]`$, where $`P`$ is the exact price of the option.

###### Proof.

This follows from Theorem 14 and the fact that

$$𝔼\left((A_n(n+1)X)^+\right)=\frac{1}{n+1}𝔼\left((T_n(n+1)X)^+\right).$$

###### Remark 2

By comparison, the AMO algorithm  has error $`𝒪(n_0X/k_0)`$ and runtime $`𝒪(k_0n_0^2)`$.

### 4.4 Customization of the RecBTT Scheme

A useful feature of the RecBTT scheme is that the number of recursive calls, the size of each recursive call, and the pricing method by which we solve the base case of the recursion (the final recursive call) can be custom tailored for the application. The base case of the recursion can be solved with any option pricing scheme, including BoundedMC, other variants of the Monte Carlo algorithm, the AMO algorithm, or exhaustive path traversal. For example, consider a 3-month (90-day) Asian option with the average computed on a daily basis ($`n=90`$). Pricing this option exactly requires traversing $`2^{90}`$ paths, which is infeasible. Using our RecBTT scheme, since $`\sqrt{n}<10`$, a single recursive call can reduce this problem to several subproblems each with at most $`2^{10}`$ paths.

In practice, larger values of $`n`$ appear in several applications. Long-term options contracts, LEAPS , are negotiated for exercise dates several years in advance. Companies also offer stock options to employees over periods of up to five years or more. Finally, in *Istanbul* options contracts , rather than computing the average based on daily prices, the average is computed over prices taken at higher frequencies. In each of these cases, $`n`$ is sufficiently large that several recursive calls are required to reduce the problem to a manageable size.

## 5 Pricing Basket Options

The bucketed tree structure created by BTT and RecBTT can be used to price various kinds of European basket options as well. Here, we describe here how to price European Asian basket options. A basket option  is composed of $`m`$ stocks, $`z_1,\mathrm{},z_m`$. For each stock $`z_i`$, we construct a binomial tree (according to the respective stock’s volatility), as described in Section 2. For $`1tn`$ and $`1im`$, let $`S_t^i`$ be the random variable denoting the price of stock $`z_i`$ on day $`t`$ and define $`S_t=_{i=1}^mS_t^i`$ to be the random variable denoting the total of the stock prices on day $`t`$. Recall that the payoff of a European basket call with strike price $`X`$ is $`𝔼((S_nX)^+)`$. Letting $`A_n=\frac{1}{n+1}_{t=0}^nS_t`$ be the average total stock price, the payoff of a European Asian basket call with strike price $`X`$ is $`𝔼((A_nX)^+)`$. There is additional complexity with pricing basket options that does not appear in their single-stock counterparts: the number of paths that the total basket price can follow is exponential, not only in the number of trading periods $`n`$ but also in that of stocks $`m`$. Basket options are usually priced using traditional Monte Carlo methods. The scheme we describe here is the first polynomial time, in both the number of stocks and trading periods, pricing scheme for any kind of basket option with provably small error bounds.

Our European Asian basket call pricing algorithm, BasketBTT, is described in Algoirthm 5. Let $`B=(n+1)X`$, where $`X`$ is the strike price of the basket option. For each stock $`z_i`$, $`1im`$, use RecBTT to construct the bucketed binomial tree structure $`𝒯^i`$ described in Section 4, this time using $`B`$ as the barrier; should the running total of any $`z_i`$ exceed $`B`$, the basket option will always be exercised, regardless of what the other stocks do. For each stock $`z_i`$, we construct $`k+1`$ *superbuckets* $`\beta _j^i`$, $`0jk`$, where $`\beta _j^i`$ is the combination of buckets $`b_j(v)`$ for all leaves $`v𝒯^i`$. For the core buckets $`\beta _j^i`$, $`0j<k`$, let $`\beta _j^i.\mathrm{value}=j\frac{B}{k}`$ and $`\beta _j^i.\mathrm{mass}=_{\mathrm{}=0}^nb_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}`$, where this summation ranges over all leaves $`𝒯^i[n,\mathrm{}]`$ of $`𝒯^i`$. For the overflow bucket $`\beta _k^i`$, let $`\beta _k^i.\mathrm{mass}=_{\mathrm{}=0}^nb_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}`$ and

$$\beta _k^i.\mathrm{value}=\frac{_{\mathrm{}=0}^nb_k(𝒯^i[n,\mathrm{}]).\mathrm{value}\times b_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}}{\beta _k^i.\mathrm{mass}}.$$

#### Handling overflow superbuckets

If the running total of a stock $`z_i`$ reaches the overflow superbucket $`\beta _k^i`$, the option will be exercised regardless of what the other stocks do. Given this, we can determine the value of the option exactly, since

$`𝔼\left((T_n(n+1)X)^+\right)=𝔼\left(T_n(n+1)X\right)=𝔼(T_n)(n+1)X`$
$`=\beta _k^i.\mathrm{value}+{\displaystyle \underset{i^{}i}{}}𝔼(T_n^i^{})(n+1)X,`$
where $`T_n^i^{}`$ is the random variable denoting the running total of stock $`z_i^{}`$ up to day $`n`$. $`𝔼(T_n^i^{})`$ can be computed exactly using Lemma 6.

#### Handling core superbuckets

Consider now the core superbuckets $`\beta _j^i`$, $`0j<k`$. Let $`f_i(x)=_{j=0}^{k1}\beta _j^i.\mathrm{mass}x^j`$ be the polynomial representation of the core bucket masses of stock $`z_i`$ and let $`f(x)=_{i=1}^mf_i(x)`$. This product can be computed efficiently, as described in Lemma 16. Notice that $`f(x)`$ has the form

$$f(x)=b_0x^0+b_1x^1+\mathrm{}+b_{m(k1)}x^{m(k1)}.$$

¿From the definition of $`f(x)`$, observe that $`b_j`$ is just the probability that the sum (over all stocks $`z_i`$) of running totals $`T_n^i`$ from the core buckets falls in the range $`[j\frac{B}{k},(j+1)\frac{B}{k})`$. That is,

$$b_j=\mathrm{Pr}\left(\underset{i=1}{\overset{m}{}}T_n^i[j\frac{B}{k},(j+1)\frac{B}{k})|T_n^i<B\text{ for all }i\right).$$

Hence, the contribution to the option price from the core buckets can be estimated by

$$\underset{j=k}{\overset{m(k1)}{}}b_j(j\frac{B}{k}(n+1)X).$$

#### Pricing the option

Combining the above results for the overflow and the core superbuckets, we see that $`𝔼\left((T_n(n+1)X)^+\right)`$ can be estimated by

$$\underset{i=1}{\overset{m}{}}\beta _k^i.\mathrm{mass}(\beta _k^i.\mathrm{value}+_{i^{}i}𝔼(T_n^i^{})(n+1)X)+\underset{j=k}{\overset{m(k1)}{}}b_j(j\frac{B}{k}(n+1)X).$$

###### Algorithm 5

BasketBTT$`(z_1,\mathrm{},z_m,B=(n+1)X)`$

for $`i=1,\mathrm{},n`$  % for each stock $`z_i`$

compute $`𝔼(T_n^i)`$ using Lemma 6;

run RecBTT on stock $`z_i`$ with barrier $`B`$ and $`k`$ buckets;

for $`j=0,\mathrm{},k1`$  % construct core superbuckets

$`\beta _j^i.\mathrm{value}j\frac{B}{k}`$;

$`\beta _j^i.\mathrm{mass}_{\mathrm{}=0}^nb_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}`$;

$`\beta _k^i.\mathrm{mass}_{\mathrm{}=0}^nb_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}`$;  % construct overflow superbucket

$`\beta _k^i.\mathrm{value}\frac{1}{\beta _k^i.\mathrm{mass}}_{\mathrm{}=0}^nb_k(𝒯^i[n,\mathrm{}]).\mathrm{value}\times b_j(𝒯^i[n,\mathrm{}]).\mathrm{mass}`$;

let $`f_i(x)_{j=0}^{k1}\beta _j^i.\mathrm{mass}x^j`$;

compute $`f(x)_{i=1}^mf_i(x)`$ as described in Lemma 16;

let $`f(x)b_0x^0+b_1x^1+\mathrm{}+b_{m(k1)}x^{m(k1)}`$;  % for some $`b_0,\mathrm{},b_{m(k1)}`$

return $`_{i=1}^m\beta _k^i.\mathrm{mass}(\beta _k^i.\mathrm{value}+_{i^{}i}𝔼(T_n^i^{})(n+1)X)+_{j=k}^{m(k1)}b_j(j\frac{B}{k}(n+1)X)`$;

###### Lemma 16

Let $`\sigma _{\mathrm{min}}`$ be the minimum volatility among the stocks in the basket. The runtime of BasketBTT is

$$𝒪\left(mT(\sigma _{\mathrm{min}},n,k)+mk\mathrm{log}m\mathrm{log}k+mk\mathrm{log}^2m\right),$$

where $`T(\sigma _{\mathrm{min}},n,k)`$ is the runtime of RecBTT on a binomial tree of size $`n`$ when $`k`$ buckets are used and the volatility of the underlying stock is $`\sigma _{\mathrm{min}}`$.

###### Proof.

Computing the leaf bucket weights for each stock $`z_i`$ (using RecBTT) takes $`𝒪(mT(\sigma _{\mathrm{min}},n,k))`$ time. The runtime of the rest of the computation is dominated by the time to compute $`_{i=1}^mf_i(x)`$. We now describe an efficient way to do this. Assume that $`m=2^r`$, for some $`r`$. The general case is handled similarly. We conduct the multiplication by successively multiplying consecutive polynomials together $`\mathrm{log}m=r`$ times until we are left with a single polynomial. For $`1im`$, let $`f_i^0(x)=f_i(x)`$. For $`1jr`$ and $`1i\frac{m}{2^i}`$, let $`f_i^j(x)=f_{2i1}^{j1}(x)f_{2i}^{j1}(x)`$. The answer that we are looking for is just $`_{i=1}^mf_i(x)=f_1^r(x)`$. At stage $`j`$, we multiply together $`\frac{m}{2^j}`$ pairs of polynomials, each of degree $`2^{j1}k`$. Using FFT, this takes $`𝒪\left(\frac{m}{2^j}2^{j1}k\mathrm{log}(2^{j1}k)\right)=𝒪\left(mk\mathrm{log}(2^{j1}k)\right)`$ time. The total runtime to compute the product, over all stages, is $`𝒪\left(mk(r\mathrm{log}k+_{j=1}^r\mathrm{log}2^{j1})\right)=𝒪\left(mk(\mathrm{log}m\mathrm{log}k+\mathrm{log}^2m)\right)`$, from which the claimed result follows. ∎

Our definition of the *error* made by BasketBTT is symmetric to the definition of error made by RecBTT; i.e., it is the maximum amount by which BasketBTT can underestimate $`_{i=1}^m_{t=0}^nS_t^i(\omega ^i)`$, for paths $`\omega ^i𝒯^i`$.

###### Lemma 17

Let $`\sigma _{\mathrm{max}}`$ be the maximum volatility among the stocks in the basket. The error made by BasketBTT is at most $`mE(\sigma _{\mathrm{max}},n,k)`$, where $`E(\sigma _{\mathrm{max}},n,k)`$ is the error made by RecBTT on a single stock with volatility $`\sigma _{\mathrm{max}}`$.

###### Proof.

For $`1im`$, let $`\omega _i`$ be any path down the binomial tree corresponding to stock $`z_i`$ and let $`T_n^i(\omega _i)`$ be the total price down $`\omega _i`$. When we run RecBTT on $`z_i`$, each $`T_n^i(\omega _i)`$ is underestimated by at most $`E(\sigma _{\mathrm{max}},n,k)`$. Hence for any $`\omega _1,\mathrm{},\omega _m`$, $`_{i=1}^mT_n^i(\omega _i)`$ is underestimated by at most $`mE(\sigma _{\mathrm{max}},n,k)`$, as claimed. ∎

###### Theorem 18

Given $`n`$, $`m`$, $`k`$, $`R>2`$, $`\gamma =\frac{1}{R}`$, $`\sigma _{\mathrm{min}}`$ and $`\sigma _{\mathrm{max}}`$, if we apply RecBTT as described in Theorem 14 to construct the bucketed binomial tree for each stock, BasketBTT has an error of $`𝒪(m\frac{Bn^{1/2+\gamma }\sigma _{\mathrm{max}}^{12\gamma }}{k})`$ and runs in time

$$𝒪\left(2^{1/\gamma }n^2mk(\frac{1}{\gamma }+\mathrm{log}\frac{kn}{\sigma _{\mathrm{min}}^2})+mk\mathrm{log}m\mathrm{log}k+mk\mathrm{log}^2m\right).$$

###### Proof.

This follows directly from Lemmas 16 and 17 and Theorem 14. ∎

###### Corollary 19

Given $`n`$, $`m`$, $`k`$, $`R>2`$, $`\gamma =\frac{1}{R}`$, $`\sigma _{\mathrm{min}}`$ and $`\sigma _{\mathrm{max}}`$, BasketBTT underestimates the price of a European Asian basket call by at most $`𝒪(m\frac{Xn^{1/2+\gamma }\sigma _{\mathrm{max}}^{12\gamma }}{k})`$ and runs in time

$$𝒪\left(2^{1/\gamma }n^2mk(\frac{1}{\gamma }+\mathrm{log}\frac{kn}{\sigma _{\mathrm{min}}^2})+mk\mathrm{log}m\mathrm{log}k+mk\mathrm{log}^2m\right).$$

###### Proof.

This follows from Theorem 18, which gives the amount by which the total prices of the stocks may be underestimated. The amount by which the sum of their daily averages is underestimated is smaller by a factor of $`\frac{1}{n+1}`$. ∎

## 6 Further Research

This paper focuses on theoretical aspects of BoundedMC and RecBTT. In order to optimize the performance of RecBTT in practice, we must consider three issues in its implementation: (1) The number of recursive calls and the size of the recursive subproblems will depend on the number of periods (see Section 4.4). (2) For options with a high number of periods, nontrivial data structures may be required. (3) We have a choice of several algorithms to use at the base-case of our recursion (see Section 4.4). The implementation of our algorithms and empirical comparisons between them and others will be reported in a subsequent paper.

This paper opens up several directions for further theoretical research. An immediate open problem is whether similar Monte Carlo and bucketing techniques can be used for pricing American Asian single-stock and basket options.

With regards to our algorithms, it would be an important result if the runtime of BoundedMC on basket options can be bounded by a polynomial in the number of stocks $`m`$; or if the recursive calls in RecBTT can be structured differently to yield improved runtime or error bounds.

Finally, it would be interesting to see whether our Monte Carlo analysis or recursive bucketing techniques can be used to price other types of options or applied to similar problems.

We would like to thank Kyusik Chung, David Goldenberg, and Samuel Ieong for helpful discussions; and Stan Eisenstat for pointers to numerical analysis software.

## References