Journal of Computational Finance

Risk.net

The two-dimensional tree–grid method

Igor Kossaczký, Matthias Ehrhardt and Michael Günther

  • The two-dimensional Tree-Grid method is an unconditionally stable, convergent explicit method for solving the two-dimensional  stochastic control problems and Hamilton-Jacobi-Bellman equation.
  • The method can be used on an arbitrary (equidistant or non-equidistant) rectangular grid, and no interpolation is needed in the stencil construction.
  • We present the solution of the two-factor uncertain volatility model using the two-dimensional Tree-Grid method.

In this paper, we introduce a novel, explicit, wide-stencil, two-dimensional (2D) tree–grid method for solving stochastic control problems (SCPs) with two space dimensions and one time dimension, or, equivalently, the corresponding Hamilton– Jacobi–Bellman equation. This new method can be seen as a generalization of the tree–grid method for SCPs with one space dimension that was recently developed by the authors. The method is unconditionally stable and no 2D interpolation is needed in the stencil construction. We prove the convergence of the method and exemplify it in our application to a two-factor uncertain volatility model.

1 Introduction

Stochastic control problems (SCPs) arise in many applications where the stochastic (Itô) process is controlled with respect to time and state in order to optimize the expectation of some utility or cost function. The problem of searching for an optimal control strategy can often be solved by solving the underlying partial differential equation (PDE): the so-called Hamilton–Jacobi–Bellman (HJB) equation.

1.1 Overview of the numerical methods

Either way – solving the SCPs directly or solving the HJB equation – numerical methods are often needed, as closed-form solutions are rarely known. For the one-dimensional (1D) SCP (with one controlled stochastic process for one state variable), various numerical methods were developed. Based on the approximation of the time-continuous stochastic process with a discrete chain, Markov chain approximation methods are presented in Kushner and Dupuis (2013). Implicit finite-difference methods (FDMs) for solving HJB equations were presented, for example, in Forsyth and Vetzal (2012). The advantage of these methods in contrast with the explicit FDMs is their unconditional stability and monotonicity. In Kilianová and Ševčovič (2013), a method based on a transformation of the HJB equation was developed. The advantage of using this approach is that we do not need to solve the optimization problem in each time layer. Recently, a new explicit but still unconditionally stable and monotone tree–grid method was developed in Kossaczký et al (2018). This method combines the tree structure from the trinomial tree methods for option pricing with the grid typically used in FDMs, and it can be seen as some special explicit FDM or a Markov chain approximation. A useful modification of the method was presented in Kossaczký et al (2017). As the explicitness and great flexibility of this method (unconditional stability with any grid spacing) are clear advantages, we are interested in generalizing it to two state-space dimensions (two controlled stochastic processes).

A generalization of the implicit unconditionally stable method from Wang and Forsyth (2008) in two space dimensions was presented in Ma and Forsyth (2016) and later used in Chen and Wan (2016). The main idea behind this method is to combine the wide and the fixed stencil, depending on the correlation in a particular time–space node. Alternatively, explicit methods based on the ideas of Kushner and Dupuis (2013) presented in Bonnans and Zidani (2003) and Debrabant and Jakobsen (2013, 2014) can be used. These are wide-stencil schemes that are stable under some Courant–Friedrichs–Lewy (CFL) condition. Moreover, bilinear interpolation of the grid values is needed in these methods. Our generalization of the tree–grid method presented in this paper also falls into the class of wide-stencil schemes; however, it is unconditionally stable and no two-dimensional (2D) interpolation of the grid values is needed. The unconditional stability is achieved by making the stencil size dependent not only on the space steps but also on the time step. In order to get a monotone seven-point-wide stencil, we possibly need to artificially increase the variance and decrease the covariance of the system. However, the approximation is still consistent, as this artificial increase/decrease vanishes with grid refinement and, in standard cases, even reaches zero at some point. Note that even in standard wide-stencil schemes (Debrabant and Jakobsen 2013) the variance is increased and the covariance is altered due to the use of interpolation. Moreover, in that case, this behavior is present for any grid refinement, which contrasts with the case of the tree–grid method presented in this work. As this 2D tree–grid method is explicit, it is also suitable for parallelization.

1.2 Problem formulation

We are concerned with searching for the value function V(x,y,t) of the following 2D general SCP:

  V(x,y,t) =maxθ(x,y,t)Θ¯?(tTexp(tkr(*l)dl)f(*k)dk  
            +exp(tTr(*k)dk)VT(XT,YT)  
                    |Xt=x,Yt=y),   (1.1)
  dXt =μx(*t)dt+σx(*t)dWtx,   (1.2)
  dYt =μy(*t)dt+σy(*t)dWty,   (1.3)
  dWtxdWty =σxy(*t)/(σx(*t)σy(*t)),   (1.4)
  t =(Xt,Yt,t,θ(Xt,Yt,t)),0<t<T,x,y,  

where x and y are state variables and t is time. Here, Θ¯ is the space of all suitable control functions (see, for example, Kushner and Dupuis 2013; Yong and Zhou 1999) from 2×[0,T] to a set Θ. For our purpose, we will assume Θ to be discrete. If this is not the case, we can easily achieve this property by its discretization. Now, following Bellman’s principle, the dynamic programming equation holds:

  V(x,y,tj)=maxθ(x,y,t)Θ¯tj ?(tjtj+1exp(tjkr(*l)dl)f(*k)dk  
    +exp(tjtj+1r(*k)dk)V(Xtj+1,Ytj+1,tj+1)  
                  |Xtj=x,Ytj=y),   (1.5)

where 0tj<tj+1T are some time points and Θ¯tj is a set of control functions from Θ¯ restricted to the 2×[tj,tj+1) domain. Using (1.5), it can be shown (Yong and Zhou 1999) that solving the SCP (1.1)–(1.4) is equivalent to solving the 2D HJB equation:

  Vt+maxθΘ(LV+r()V+f())=0,   (1.6)
  LV=σx()222Vx2+σxy()2Vxy+σy()222Vy2+μx()Vx+μy()Vy,   (1.7)
  V(x,y,T)=VT(x,y),   (1.8)
  0<t<T,x,y,  

where σx(), σy(), σxy(), μx(), μy(), r() and f() are functions of x, y, t and θ. Note that the maximum operator in (1.1) and (1.6) can be replaced by a minimum operator and the entire following analysis will hold analogously. A possible generalization of the SCP with a corresponding HJB equation is the stochastic differential game with a corresponding Hamilton–Jacobi–Bellman–Isaac equation (Mataramvura and Øksendal 2008). Further generalizations can be found in Song (2008).

2 Construction of two-dimensional tree–grid algorithm

In this section, we will derive the 2D tree–grid algorithm for solving (1.1)–(1.4). We will use ideas that were thoroughly explained in Kossaczký et al (2018) and Kossaczký et al (2017), and we refer interested readers to these papers. We will work on a three-dimensional (3D) rectangular domain with two space dimensions and one time dimension. For a fixed control θ, the candidate for a value in each node V(xi,yj,tk) will be computed using seven values from the next time layer tk+1. Figure 1 illustrates this approach. We will denote these seven values in this context simply as a stencil located at (xi,yj,tk). The weights of these seven values can be interpreted as probabilities, and we therefore demand that the moments of such a discrete random variable match with the moments of the increment of the 2D stochastic process (1.2)–(1.4) with a fixed control θ, at least asymptotically. Then, the actual value V(xi,yj,tk) will be computed as a maximum of the candidates. For handling nodes close to the boundary, we suppose that we both know how the solution behaves in the outer neighborhood of the boundaries and can describe this behavior with a boundary function BC(x,y,t). The terminal condition in the time layer tM=T reads V(x,y,tM)=VT(x,y).

Illustration of the 2D tree--grid structure. Only the red nodes in later time layers impact the blue node. On the other hand, the red nodes can be interpreted as possible future states if we are in the blue node state. This figure illustrates a situation with positive correlation and a variance that is larger in the x-direction than in the y-direction. The stencil size in each direction is roughly proportional to the square root of the variance coefficient in that direction, multiplied by ...
Figure 1: Illustration of the 2D tree–grid structure. Only the red nodes in later time layers impact the blue node. On the other hand, the red nodes can be interpreted as possible future states if we are in the blue node state. This figure illustrates a situation with positive correlation and a variance that is larger in the x-direction than in the y-direction. The stencil size in each direction is roughly proportional to the square root of the variance coefficient in that direction, multiplied by the discretization parameter h.

2.1 Notation

First, before discussing how to choose the stencil nodes around node (xi,yj,tk) and the proper weights, we present the notation used in this paper.

  • x1,x2,,xNx: space discretization in one space dimension. y1,y2,,yNy: space discretization in two space dimensions. t1,t2,,tM: time discretization.

  • Δkt=tk+1-tk: (current) time step. We will use equidistant time stepping Δkt=Δt for all k=1,2,,M-1. Generalization to nonequidistant time stepping is straightforward.

  • Δix=xi+1-xi, Δjy=yj+1-yj: space steps in one dimension and two dimensions (possibly nonequidistant).

  • Δx=maxiΔix, Δy=maxiΔiy.

  • h=max(Kmax(Δx,Δy),Δt), where K>0 is a parameter used for regulating the stencil size. In the nonequidistant case, Δt should be replaced by Δkt.

  • b=h/Δt: in the nonequidistant case, this should be replaced by b=h/Δkt in the following algorithm.

  • (xi,yj,tk): the node for which the stencil is constructed.

  • E*=μ*(xi,yj,tk,θ)Δt for *=x,y.

  • Var*=(σ*2(xi,yj,tk,θ)+?(h))Δt for *=x,y (to be determined later).

  • ρ(xi,yj,tk,θ)=σxy(xi,yj,tk,θ)/(σx(xi,yj,tk,θ)σy(xi,yj,tk,θ)).

  • σ~xy(xi,yj,tk,θ)=σxy(xi,yj,tk,θ)+?(h) (to be determined later).

  • Cov=(σxy(xi,yj,tk,θ)+?(h))Δt (to be determined later).

  • W*=Var*+E*2 for *=x,y.

  • Wxy=Cov+ExEy.

  • vi,jk: numerical approximation of V(xi,yj,tk).

2.2 Choosing stencil nodes

Next, we describe how to choose the stencil nodes around an arbitrary node (xi,yj,tk) for a fixed control θ. The values in these nodes will affect the value in the node (xi,yj,tk).

If Ex>0,

  x-=xi-2Wxbx,x+=max(xi+2Wxb,xi+(xi-x-))x;   (2.1)

else if Ex<0,

  x+=xi+2Wxbx,x-=min(xi-2Wxb,xi-(x+-xi))x;   (2.2)

else (Ex=0)

  x+=xi+2Wxbx,x-=xi-2Wxbx,   (2.3)

where x (respectively, x) denotes rounding to the nearest greater (respectively, smaller) element from x1,x2,,xNx. If such an element does not exist, zx (respectively, zx) will return just z.

If Ey>0,

  y-=yj-2Wyby,y+=max(yj+2Wyb,yj+(yj-y-))y;   (2.4)

else if Ey<0,

  y+=yj+2Wyby,y-=min(yj-2Wyb,yj-(y+-yj))y;   (2.5)

else (Ey=0)

  y+=yj+2Wyby,y-=yj-2Wyby,   (2.6)

where y and y are defined analogously. Note that the operators x, x, y and y formally correspond to some special (left or right neighbor) constant interpolation in one dimension. However, in the standard wide-stencil schemes for 2D problems, constant, (bi)linear or higher-order interpolations in two dimensions are used. In such cases, the use of higher-order interpolations is motivated by a need to reduce the interpolation error. In our scheme, however, this 1D constant interpolation does not introduce any additional interpolation error, as it is only needed to identify the stencil nodes. As we will see later, the moments of our approximation match exactly with the moments of the original stochastic process for a nondegenerate problem and small enough h.

The following nodes with their respective weights (probabilities) will be used in the stencil located at (xi,yj,tk):

  • node (xi,yj,tk+1) with probability po;

  • nodes (x+,yj,tk+1) and (x-,yj,tk+1) with probabilities px+ and px-;

  • nodes (xi,y+,tk+1) and (xi,y-,tk+1) with probabilities py+ and py-; and

  • nodes (x+,y+,tk+1) and (x-,y-,tk+1), both with probability pxy if Wxy is nonnegative, and nodes (x+,y-,tk+1) and (x-,y+,tk+1), both with probability pxy if Wxy is negative (in the following algorithm, we will focus on the case of nonnegative Wxy; the case of negative Wxy is treated analogously).

In the next section, we will impose six conditions on these probabilities in equation form in order to match with the moments of the discrete and the original process as well as ensure that the probabilities sum up to 1. Therefore, to get a unique solution to these equations, we need, in the seven nodes, only six different probabilities, which explains why we chose the same probability for nodes (x+,y+,tk+1) and (x-,y-,tk+1) (respectively, (x+,y-,tk+1) and (x-,y+,tk+1)). Our motivation for choosing these particular nodes to have the same probability is that we try to handle the drift and diffusion in the x (respectively, y) direction in a similar manner to the 1D tree–grid method (Kossaczký et al 2018, 2017), using the nodes on the x (respectively, y) axis with origin at (xi,yj). Then, only one probability remains for the two remaining nodes.

2.3 Choosing the stencil weights (probabilities)

First, let us define the following difference operators:

  Δ+x =x+-xi,Δ-x=xi-x-,   (2.7)
  Δ+y =y+-yi,Δ-y=yi-y-.   (2.8)

To match with the first two moments of the approximative increment of the stochastic process and of the increment of the discrete process defined by the stencil nodes and their probabilities, and to ensure that the probabilities are positive and sum up to 1, we demand the following:

  po+px++px-+py++py-+2pxy =1,   (2.9)
  (px++pxy)Δ+x-(px-+pxy)Δ-x =Ex,   (2.10)
  (py++pxy)Δ+y-(py-+pxy)Δ-y =Ey,   (2.11)
  (px++pxy)(Δ+x)2+(px-+pxy)(Δ-x)2 =Wx,   (2.12)
  (py++pxy)(Δ+y)2+(py-+pxy)(Δ-y)2 =Wy,   (2.13)
  pxy(Δ+xΔ+y+Δ-xΔ-y) =Wxy,   (2.14)
  po,px+,px-,py+,py-,pxy 0.   (2.15)

For negative Wxy, only the condition (2.14) changes to

  pxy(Δ+xΔ-y+Δ-xΔ+y) =|Wxy|.   (2.16)

The solutions of (2.9)–(2.14) are

  po =Δ+xΔ-xΔ+yΔ-y-Δ+xΔ-xWy-Δ+yΔ-yWxΔ+xΔ-xΔ+yΔ-y,  
      +Ey(Δ+y-Δ-y)Δ+yΔ-y+Ex(Δ+x-Δ-x)Δ+xΔ-x+2|Wxy|Δc,   (2.17)
  px+ =Wx+ExΔ-x(Δ+x)2+Δ+xΔ-x-|Wxy|Δc,   (2.18)
  px- =Wx-ExΔ+x(Δ-x)2+Δ+xΔ-x-|Wxy|Δc,   (2.19)
  py+ =Wy+EyΔ-y(Δ+y)2+Δ+yΔ-y-|Wxy|Δc,   (2.20)
  py- =Wy-EyΔ+y(Δ-y)2+Δ+yΔ-y-|Wxy|Δc,   (2.21)
  pxy =|Wxy|Δc,   (2.22)

where Δc=Δ+xΔ+y+Δ-xΔ-y for nonnegative (σ~xy(xi,yj,tk,θ)Δt+ExEy) and Δc=Δ+xΔ-y+Δ-xΔ+y for negative (σ~xy(xi,yj,tk,θ)Δt+ExEy).

Following the construction of x+, x-, y+ and y-, it is easy to check that po is always nonnegative. The same holds for pxy. To ensure the nonnegativity of px+, px-, py+ and py-, we have to properly choose the variables Varx, Vary and Cov to get nonnegative weights while remaining consistent with the original problem as h0. This is done in the next section.

2.4 Artificial diffusion and covariance adjustment

Let us assume Ex0. Now, the first fraction of px+ is positive, but the first fraction of px- may be negative. We will set Varx (and, hence, Wx) in such way that the latter will be also positive. It holds that

  Wx-ExΔ+x>Varx+Ex2-Ex(2b(Varx+Ex2)+2Δx).   (2.23)

The right-hand side of the inequality (2.23) is 0 for Varx=Ax and greater than 0 for Varx>Ax with

  Ax=12(|Ex|4b2Ex2+16bΔx|Ex|-(2b-2)Ex2+4Δx|Ex|).   (2.24)

Here, we replaced Ex with |Ex| to cover the analogous case Ex<0 and possibly negative px+. Now, if we set

  Varx =max(σx2(xi,yj,tk,θ)Δt,Ax,Ex2),   (2.25)
  Vary =max(σy2(xi,yj,tk,θ)Δt,Ay,Ey2),   (2.26)

where Ay is defined analogously, the first fraction in px+, px-, py+ and py- will be nonnegative. The possible difference between Varx (respectively, Vary) and the variances from the original problem σx2Δt (respectively, σy2Δt) is called artificial diffusion. Now, taking into account the correlation coefficient in the current node and following these definitions of variances Varx and Vary, we define a new covariance:

  σ~xy=ρVarxVaryΔt   (2.27)

and

  Cxy:=min( Wx+ExΔ-x(Δ+x)2+Δ+xΔ-xΔc,Wx-ExΔ+x(Δ-x)2+Δ+xΔ-xΔc,  
    Wy+EyΔ-y(Δ+y)2+Δ+yΔ-yΔc,Wy-EyΔ+y(Δ-y)2+Δ+yΔ-yΔc,  
               |σ~xy(xi,yj,tk,θ)Δt+ExEy|).   (2.28)

Now, we define Cov as

  Cov={Cxy-ExEyif (σ~xy(xi,yj,tk,θ)Δt+ExEy)0,-Cxy-ExEyif (σ~xy(xi,yj,tk,θ)Δt+ExEy)<0.   (2.29)

This covariance Cov is consistent with variances Varx and Vary defined by (2.25) and (2.26). As for σ~xy(xi,yj,tk,θ)Δt+ExEy0, it holds that

  -VarxVary-ExEyCovσ~xy(xi,yj,tk,θ)ΔtVarxVary,   (2.30)

and for σ~xy(xi,yj,tk,θ)Δt+ExEy<0 it holds that

  -VarxVaryσ~xy(xi,yj,tk,θ)ΔtCov-ExEyVarxVary.   (2.31)

Now, it also holds that |Wxy|=Cxy, which implies that px+, px-, py+ and py- are all positive. It is easy to check that the following holds:

  VarxΔt=σx2(xi,yj,tk,θ)+?(h),VaryΔt=σy2(xi,yj,tk,θ)+?(h).   (2.32)

In addition, for σx2(xi,yj,tk,θ)0 (respectively, σy2(xi,yj,tk,θ)0) and small enough h,

  VarxΔt=σx2(xi,yj,tk,θ)(respectively, VaryΔt=σy2(xi,yj,tk,θ))   (2.33)

holds. It also holds that

  Wx+ExΔ-x =(σx2+?(h))Δt,   (2.34)
  (Δ+x)2+Δ+xΔ-x =4hσx2+?(h3/2),   (2.35)
  Δc =4hσxσy+?(h3/2).   (2.36)

It follows that

  Wx+ExΔ-x(Δ+x)2+Δ+xΔ-xΔc=(σxσy+?(h))Δt,   (2.37)

and the same holds for the second, third and fourth maximum candidates in (2.28). Moreover,

  |σ~xyΔt+ExEy|=|σ~xy|Δt+?((Δt)2)=(|σxy|+?(h))Δt.   (2.38)

Therefore,

  Cxy=(|σxy|+?(h))ΔtCovΔt=σxy+?(h),   (2.39)

and it is easy to check for σx20, σy20, |σxy|σxσy and small enough h that

  CovΔt=σxy   (2.40)

holds. Following (2.32) and (2.39), the modified variances and modified covariance are consistent with the variances and covariance from the original problem. Moreover, for σx,σy0 and |σxy|<σxσy, the modified variances and covariance will be equal to their originals for small enough h.

2.5 Setting parameter K and stencil-size reduction

In the formula for h=max(Kmax(Δx,Δy),Δt), the Kmax(Δx,Δy) part is responsible for keeping the correlation in the numerical model consistent with the correlation of the original problem. Here, the parameter K>0 can be chosen arbitrarily; however, for a large (relative to problem parameters) K, the stencil is also large, which typically increases the error. On the other hand, for too small K, the correlation may start being exact (or exact enough) for very fine grids only and not sufficiently exact for coarse grids, resulting in larger errors on these coarse grids. For K=0, we cannot guarantee the convergence of the correlation. However, the correlation in the numerical model may match with the correlation from the original problem even for small K or K=0. This motivates the following multiple K modification of the tree–grid method.

For each control in each node,

  1. (1)

    set l=1 and use K=K0, K00 to compute x*, y*, p*

  2. (2)

    compute the correlation of the numerical model, ρ~=Cov/VarxVary

  3. (3)

    if ρ~ρ, recompute x*, y*, p* with K=Kl, Kl>Kl-1 and set l:=l+1

    else break.

  4. (4)

    if l<lmax, go to step (2)

    else break.

With this modification, we will use a smaller stencil size as much as possible. This approach can be seen as somewhat analogous to the approach in Ma and Forsyth (2016), where a fixed (and thus small) stencil is used as much as possible. However, we will not increase the convergence rate, but we might reduce the error.

Another approach, the nonconstant K modification, involves using nonconstant K=K(x,y,θ). This can be smaller in nodes with large volatilities σx and σy, and larger in nodes with smaller σx and σy, thus regulating the stencil size to not explode in case of large volatilities.

Both modifications can also be combined, and it is easy to check that they do not harm the consistency. In our numerical simulation, these modifications did not lead to significant improvements; therefore, we decided to just use a constant K=1/400. However, they may be useful for other SCPs.

3 The two-dimensional tree–grid algorithm

Finally, we can use the stencil nodes and weights to construct the 2D tree–grid algorithm.

We define the function vk+1 as follows:

  if (x,y){x1,x2,,xNx}×{y1,y2,,yNy},vk+1(x,y)=vi,jk+1 so that (x,y)=(xi,yj);else vk+1(x,y)=BC(x,y,tk+1).}   (3.1)

For a given space node (xi,yj) and a given control θ, we define

  vok+1 =vk+1(xi,yj),vx+k+1=vk+1(x+,yj),vx-k+1=vk+1(x-,yj),   (3.2)
  vy+k+1 =vk+1(xi,y+),vy-k+1=vk+1(xi,y-);   (3.3)
  if Wxy 0,vxy+k+1=vk+1(x+,y+),vxy-k+1=vk+1(x-,y-);   (3.4)
  if Wxy <0,vxy+k+1=vk+1(x+,y-),vxy-k+1=vk+1(x-,y+);   (3.5)
  fi,jk(θ) =f(xi,yj,tk,θ),ri,jk(θ)=r(xi,yj,tk,θ).   (3.6)

Now, the discretized version of the dynamic programming equation for i=2,3,,Nx-1, j=2,3,,Ny-1, k=1,2,,M-1 reads

  vi,jk =maxθΘwi,jk(θ),   (3.7)
  wi,jk(θ) =fi,jk(θ)Δt+(1+ri,jk(θ)Δt)  
      ×(px+vx+k+1+px-vx-k+1+py+vy+k+1+py-vy-k+1  
                +povok+1+pxy(vxy+k+1+vxy-k+1)).   (3.8)

For boundary nodes (xi,yj) (i{1,Nx} or j{1,Ny}), we employ the boundary condition

  vi,jk=BC(xi,yj,tk).   (3.9)

The terminal condition is defined as

  vi,jM=VT(xi,yj).   (3.10)

Finally, we can summarize the 2D tree–grid method in Algorithm 1.

Algorithm 1 The 2D tree–grid method.
1:   Set vi,jM=VT(xi,yj) for i=1,2,,Nx, j=1,2,,Ny;
2:   for k=M-1,M-2,,1 do
3:      for i=1,2,3,,Nx do
4:         for j=1,2,3,,Ny do
5:            if i{1,Nx} or j{1,Ny} then
6:               Compute vi,jk according to (3.9);
7:            else
8:               for θΘ do
9:                  Determine Ex, Ey according to Section 2.1;
10:                  Compute Ax, Ay according to (2.24);
11:                  Compute Varx, Vary according to (2.25), (2.26);
12:                  Determine Wx, Wy according to Section 2.1;
13:                  Determine x+, x-, y+, y- according to (2.1)–(2.6);
14:                  Determine Δ+x, Δ-x, Δ+y, Δ-y according to (2.7), (2.8);
15:                  Compute σ~xy according to (2.27);
16:                  Compute Cxy according to (2.28);
17:                  Compute Cov according to (2.29);
18:                  Determine Wxy according to Section 2.1;
19:                  Compute po,px+,px-,py+,py-,pxy according to (2.17)–(2.22);
20:                  Using (3.1), compute all variables defined by (3.2)–(3.6);
21:                  Compute wi,jk(θ) according to (3.8);
22:               end for
23:               Compute vi,jk according to (3.7);
24:            end if
25:         end for
26:      end for
27:   end for
Remark 3.1 (Computational complexity).

Following Algorithm 1, the computational complexity of the tree–grid method is ?(MNQ)=?(MNxNyQ), where M, N and Q are numbers of time steps, nodes and controls in Θ, and Nx (respectively, Ny) are numbers of space steps in the x (respectively, y) direction (N=NxNy). This computational complexity is equivalent to the computational complexity of other explicit methods (Debrabant and Jakobsen 2013) as well as the worst-case computational complexity of the implicit algorithm from Ma and Forsyth (2016).

Remark 3.2 (Relationship to other wide-stencil methods).

The size of the stencil in both the x and the y directions is ?(h); therefore, our method can be classified as a wide-stencil method. However, in contrast to other wide-stencil methods, no coordinate transformation is used: the method is based on the original Cartesian coordinates, which makes it particularly straightforward to implement. Using a simple seven-point stencil, we concentrate on moment-matching, which is, following Section 2.4, exact for nondegenerate problems and small enough h. Note that exact moment-matching is not possible for other wide-stencil methods, as a 2D interpolation introducing an additional interpolation error is needed due to the use of coordinate transformation. Moreover, the use of a nonconstant 2D interpolation in standard wide-stencil schemes makes their actual stencils include more points (as each off-grid stencil point is interpolated by three or four gridpoints) and increases the computational costs of the scheme. Another important distinction from other wide-stencil schemes is the unconditional stability we achieve (following our definition of h in Section 2.1) by also making the stencil size dependent on Δt.

4 Convergence

In this section, we will prove the convergence of the 2D tree–grid method. To begin, we will quickly summarize the convergence theory of Barles and Souganidis (1991) before using it to prove the convergence of our scheme. Note that the algorithm was derived by discretizing the dynamics in the original SCP (1.1)–(1.4). We will, however, prove that the scheme is consistent with the HJB equation (1.6)–(1.8).

4.1 The convergence theory

Let U denote some suitable function space. Let us define some nonlinear differential operator F:

  F:U,V(s)FV(s).  

We suppose there exists a viscosity solution (see Crandall et al 1992) of the equation FV(s)=0, and we denote this solution simply by V(s). To find some approximation of the viscosity solution, we define a discrete approximation scheme:

  Gv(s)=G(v(s),v(s+b1h),v(s+b2h),,v(s+bnh)),   (4.1)

where v(s), sK, is defined as a (possibly) multidimensional function, biK, i=1,2,,n, and h+.

Let us consider the system of sets called the discretized domain:

  Sh={siKi=1,2,,Nh},   (4.2)

defined for different values of h, which is often referred to as the step size.

Definition 4.1 (Numerical scheme).

The system of equations Gv(s)=0 with sSh depending on a parameter h+ is called the numerical scheme.

The numerical scheme is considered well defined if it possesses a unique solution. We will assume that this condition is met for any feasible h. By v(s), we will denote an approximation of the solution of FV(s)=0, computed by solving the system of equations Gv(s)=0, sSh. In order to distinguish between approximations with different h, we will sometimes denote v(s) as vh(s).

Definition 4.2 (Monotonicity).

A discrete approximation scheme Gv(s)=G(v(s),v(s+b1h),v(s+b2h),,v(s+bnh)) is monotone if the function G is nonincreasing in v(s+bih) for bi0, i=1,,n.

Definition 4.3 (Consistency).

The scheme Gv(s)=G(v(s),v(s+b1h),v(s+b2h),,v(s+bnh)) is a consistent approximation of FV(s) if limh0|Fϕ(s)-Gϕ(s)|=0 for any C-smooth test function ϕ(s).

A scheme is consistent on a numerical domain if it is consistent in all points of this numerical domain. In such a case, we will call the scheme consistent. In the literature, C2-smooth test functions are often used. However (as shown in Lions (1983), for example), this leads to an equivalent definition.

Definition 4.4 (Stability).

The numerical scheme defined by the system of equations Gvh(s)=0, sSh, with solution vh(s), is stable if some constant C exists so that vh(s)<C for all h>0.

The following theorem of Barles and Souganidis (1991) is key to proving the convergence of a numerical scheme approximating a nonlinear PDE.

Theorem 4.5 (Barles–Souganidis).

If the equation FV(s)=0 satisfies the strong uniqueness property (see Barles and Souganidis 1991), and if the numerical scheme Gvh(s)=0, sSh, approximating the equation FV(s)=0 is monotone, consistent and stable, its solution vh(s) converges locally uniformly to the solution V(s) of FV(s)=0 with h0.

The abovementioned strong uniqueness property (Barles and Souganidis 1991) is a property of the problem and not of the numerical scheme. As stated in Ma and Forsyth (2016), following Pham (2005), this property is fulfilled, for example, for the two-factor uncertain volatility option pricing model with a payoff with quadratic growth. We will solve this problem numerically in Section 5.

4.2 Convergence of 2D tree–grid method

In this section, we will prove the convergence of the 2D tree–grid method. For the purposes of this convergence analysis, we will rewrite (3.7) and (3.8) as

  Gv(xi,yj,tk) =G(vok+1,vx+k+1,vx-k+1,vy+k+1,vy-k+1,vxy+k+1,vxy-k+1)  
    =1Δt(vi,jk-maxθΘ(fi,jk(θ)Δt+(1+ri,jk(θ)Δt)  
        ×(px+vx+k+1+px-vx-k+1+py+vy+k+1+py-vy-k+1  
                +povok+1+pxy(vxy+k+1+vxy-k+1))))  
    =0.   (4.3)

Using the theory from Section 4.1, our goal is to show that (4.3) is a monotone, consistent and stable approximation of the nonlinear differential operator F defined by the PDE (1.6):

  FV(x,y,t)=-Vt-maxθΘ(LV+r()V+f()).   (4.4)

Let us define the difference operators

  Δo+z=Δ+z,Δo-z=-Δ-z   (4.5)

for z{x,y}. First, we will show the consistency of the scheme at an arbitrary point (xi,yj,tk).

Lemma 4.6 (Consistency).

The discrete scheme (4.3) is consistent with the PDE operator (4.4).

Proof.

Let ϕ:2×[0,T] be a C-smooth function. Let us define ϕk(x,y)=ϕ(x,y,tk). Let us also use short notation defined by (3.2)–(3.6) for ϕk+1 instead of vk+1. At first, let us sketch the main idea of the proof of consistency in an arbitrary point (xi,yj,tk). We will write all values ϕαk+1 for α{x+,x-,y+,y-,xy+,xy-} as Taylor expansions around ϕi,jk. We will substitute these Taylor expansions into the discrete scheme (4.3), group terms with the same derivatives together and estimate the sum of coefficients in front of them. We will end up with the PDE operator (4.4) and some terms of order ?(hλ), where λ=12 if |ρ|=1, σx=0 or σy=0, and λ=1 else. Let us suppose that Wxy0 in (xi,yj,tk). The case of negative Wxy can be treated analogously. For *{+,-}, let us define the operators:

  Axy*ϕ =ϕxΔo*x+ϕyΔo*y+122ϕx2(Δo*x)2  
      +2ϕxyΔo*xΔo*y+122ϕy2(Δo*y)2,   (4.6)
  Bxy*ϕ =163ϕx3(Δo*x)3+123ϕx2y(Δo*x)2Δo*y  
      +123ϕxy2Δo*x(Δo*y)2+163ϕy3(Δo*y)3,   (4.7)
  Cxy*ϕ =1244ϕx4(Δo*x)4+164ϕx3y(Δo*x)3Δo*y  
      +144ϕx2y2(Δo*x)2(Δo*y)2  
      +164ϕxy3Δo*x(Δo*y)3+1244ϕy4(Δo*y)4.   (4.8)

Now we can expand ϕxy*k+1 around ϕi,jk, as follows:

  ϕxy*k+1 =ϕi,jk+tϕi,jkΔt+Axy*ϕi,jk  
      +t(Axy*ϕi,jk)Δt+Bxy*ϕi,jk  
      +t(Bxy*Rxy*)Δt+Cxy*Rxy*+?((Δt)2),   (4.9)

where

  Rxy*=ϕ(xi+εxy*Δo*x,yj+δxy*Δo*y,tk+γxy*Δt)   (4.10)

for some εxy*,δxy*,γxy*[0,1]. We expand ϕx*k+1,ϕy*k+1, *{+,-}, in the same manner: for ϕx*k+1 we only need to substitute Δo*y with 0, and for ϕy*k+1 we only need to substitute Δo*x with 0 in the Taylor expansion (4.9) and change the index xy* to x* (respectively, y*) in all expressions (4.6)–(4.10). Now, by substituting the Taylor expansions into the scheme Gϕi,jk defined by (4.3), we get

  Gϕi,jk =1Δt(ϕi,jk-maxθΘ(fi,jk(θ)Δt+(1+ri,jk(θ)Δt)  
              ×(ϕi,jk+ϕi,jktΔt+(Lϕi,jk+?(hλ))Δt)))  
    =Fϕi,jk+?(hλ),   (4.11)

where λ=12 if |ρ|=1, σx=0 or σy=0, and λ=1 else. In the first equation of (4.11), we used the estimates of the linear combinations of higher-order terms from the Taylor expansions. The coefficients of these linear combinations are the probabilities po, px+, px-, py+, py-, pxy+ and pxy- (according to the definition of G (4.3)). We describe these estimates as follows.

  1. (1)

    For the linear combinations of the terms included in Aαϕi,jk, α{x+,x-,y+,y-,xy+,xy-}, we used the properties of the scheme (2.9)–(2.14). After summing all expressions obtained by applying (2.9)–(2.14), we get (Lϕi,jk+?(h1/2))Δt. Moreover, following Section 2, if |ρ|1, σx0 and σy0, for small enough h we end up with just Lϕi,jkΔt.

  2. (2)

    In the same way, for the linear combinations of the terms included in (/t)(Aαϕi,jk)Δt, we get (L(ϕi,jk/t)+?(hλ))(Δt)2=?(h)Δt.

  3. (3)

    For the linear combinations of the terms included in Bαϕi,jk, we used the following estimates:

        (px++pxy+)(Δo+x)3+(px-+pxy+)(Δo-x)3  
                =Wx(Δo+x+Δo-x)-ExΔo+xΔo-x  
                =?(h)Δt,   (4.12)
        pxy+(Δo+x)2Δo+y+pxy-(Δo-x)2Δo-y  
                =Wxy((Δo+x)2Δo+y+(Δo-x)2Δo-y)Δo+xΔo+y+Δo-xΔo-y  
                =?(h)Δt.   (4.13)

    Here, we used Δo+x+Δo-x=?(h) and (Δo+x)2Δo+y+(Δo-x)2Δo-y=?(h2). We also used analogous estimates for the terms where x and y are switched symmetrically.

  4. (4)

    As (Δo*x)2=?(h) and (Δo*y)2=?(h), it is clear that all terms in (/t)(BαRα)Δt are of order ?(h)Δt.

  5. (5)

    For the linear combinations of the terms included in CαRα, we constructed our estimate in the following way. Let us define

      ψ=(px+ax++pxy+axy+)(Δo+x)2+(px-ax-+pxy-axy-)(Δo-x)2.  

    Then, it holds that

      m(σx2+?(h))ΔtψM(σx2+?(h))Δt,  
      m=min(ax+,ax-,axy+,axy-),M=max(ax+,ax-,axy+,axy-).  

    If m=?(h) and M=?(h), then ψ=?(h)Δt. Now, for (ax+,ax-,axy+,axy-) equal to

      1244x4((Δo+x)2Rx+,(Δo-x)2Rx-,(Δo+x)2Rxy+,(Δo-x)2Rxy-),  
      164x3y(0,0,Δo+xΔo+yRxy+,Δo-xΔo-yRxy-),  
      144x3y(0,0,(Δo+y)2Rxy+,(Δo-y)2Rxy-),  

    which are all ?(h), we get that the linear combinations of the first three terms in CαRα are of order ?(h)Δt. Using analogous estimates, the linear combinations of the fourth and fifth terms are also of order ?(h)Δt.

Using the estimates above, we proved (4.11), which is the first-order consistency of our scheme if |ρ|<1, σx>0 and σy>0, and the consistency of order 12 otherwise. Therefore, the scheme is also consistent in the case of degenerate diffusion, only the order of consistency is lower. On the other hand, the possibly zero-valued advection coefficients μx and μy do not have any effect on the order of consistency. ∎

Below, we present the lemma establishing the monotonicity of the scheme.

Lemma 4.7 (Monotonicity).

If 1+ri,jk(θ)Δt0 for all possible ijk and θ, then the discrete scheme (4.3) is monotone.

Proof.

Monotonicity is in this case a direct implication of the nonnegativity of po, px+, px-, py+, py-, pxy+ and pxy-. ∎

Remark 4.8.

As already mentioned in Kossaczký et al (2018), even if 1+ri,jk(θ)Δt<0 for some i, j, k and θ, we can get a monotone scheme if we substitute 1+ri,jk(θ)Δt by 1/(1-ri,jk(θ)Δt) in (4.3) for the parameters i, j, k and θ. Note that this change does not harm the consistency or the stability of the scheme.

The stability analysis of the 2D tree–grid method is basically identical to the stability analysis of the 1D tree–grid method done in Kossaczký et al (2018). Therefore, we only state the stability condition and the lemma about the stability of the scheme here.

Property 4.9 (Stability condition of the problem).

We suppose that

  1. (1)

    there exist constants Cf and Cr such that, for all x, y, t and θ[x1,xNx]×[y1,yNy]×[t1,tM]×Θ, |f(x,y,t,θ)|<Cf and |r(x,y,t,θ)|<Cr hold; and

  2. (2)

    there exists a constant CBC such that |BC(x,y,t)|<CBC holds for all t[t1,tM] and for all possible outer-domain values (x,y) of the variables (x+,yj), (x-,yj), (xi,y+), (xi,y-) and (x+,y+), (x+,y-), (x-,y+), (x-,y-) for any grid.

The lemma about the stability of the scheme follows.

Lemma 4.10 (Stability).

If the problem satisfies the stability conditions defined in Property 4.9, then the scheme (4.3) is stable.

Proof.

The proof of this lemma can be found in Kossaczký et al (2018). ∎

Finally, the convergence theorem follows.

Theorem 4.11 (Convergence of the 2D tree–grid method).

Assume that an SCP (1.1)–(1.4) and the corresponding HJB equation (1.6)–(1.8) satisfy the strong uniqueness property (see Barles and Souganidis 1991). Then, if the stability conditions defined in Property 4.9 are fulfilled, the approximation computed with the 2D tree–grid method defined by Algorithm 1 converges to the viscosity solution of this SCP (and the HJB equation).

Proof.

The proof follows from Theorem 4.5 and Lemmas 4.6, 4.7 and 4.10. ∎

5 Application to option pricing models

5.1 Two-factor uncertain volatility model

In this section, we will use the 2D tree–grid method for pricing options on two different risky assets under uncertain volatility. In this setting, the volatilities and the correlation of the assets are only known to lie in certain bounds. The maximal option price can, in this case, be computed as a solution of the HJB equation

  Vt+maxθΘ(LV-rV)=0,   (5.1)
  LV=σx22x22Vx2+ρσxσyxy2Vxy+σy22y22Vy2+rxVx+ryVy,   (5.2)
  V(x,y,T)=VT(x,y),   (5.3)
  0<t<T,x,y.  

Here, x, y and t denote the first asset price, the second asset price and the time; r denotes the risk-free interest rate; and T is the maturity time. The terminal condition VT(x,y) is the payoff function, and for the control variable it holds that θ=(σx,σy,ρ), where σx, σy and ρ are uncertain volatilities of the first and second assets as well as their correlation. For the set of possible controls, it holds that

  Θ=[σx,min,σx,max]×[σy,min,σy,max]×[ρmin,ρmax].   (5.4)

To obtain the minimal option price, we have to replace max by min in the HJB equation (5.1). This model was discussed, for example, in Pooley et al (2003) and later solved with a hybrid (combining fixed and wide stencils) implicit method in Ma and Forsyth (2016). As explained in Ma and Forsyth (2016), the optimal control lies in a subset of Θ:

  Θ~=(({σx,min,σx,max}×[σy,min,σy,max])([σx,min,σx,max] ×{σy,min,σy,max}))  
      ×{ρmin,ρmax}.   (5.5)

Therefore, we will search for the control in Θ¯, a discretized version of Θ~. To verify the implementation, we will also solve a problem with a one-element set Θ¯={(σx,σy,ρ)}. In this case, (5.1) is simply the 2D Black–Scholes equation (Black and Scholes 1973) for which an analytical solution is known.

Terminal condition

As a terminal condition, we use the payoff function in the form of a butterfly spread on the maximum of two assets:

  VT(x,y)=(M-K1)+ -2(M-(K1+K2)/2)++(M-K2)+,  
        M=max(x,y),K1=34,K2=46.   (5.6)

Boundary conditions

We will use Dirichlet boundary conditions. On the upper boundary and the right boundary, we will set the value to 0:

  BC(x>xmax,y,t)=0,BC(x,y>ymax,t)=0,xmax=ymax=144.  

To verify that our computational domain is large enough, we also solved the HJB and the Black–Scholes equations for xmax=ymax=400 and obtained in node (x,y,t)=(40,40,0) the same values as for xmax=ymax=144. On the lower boundary (y=0) and the left boundary (x=0), (5.1) degenerates to an HJB equation for a 1D uncertain volatility model from Forsyth and Vetzal (2012). We solve this with the 1D tree–grid method, as in Kossaczký et al (2018). For the case that the values from outside of the computational domain [0,xmax]×[0,ymax] are needed, we artificially define the solution for x<0 and y<0 as having the same values as the solution on the boundary:

  BC(x<0,y)=BC(0,y),BC(x,y<0)=BC(x,0),BC(x<0,y<0)=0.  

5.2 Numerical results

Table 1: Black–Scholes model, σx=0.3, σy=0.5 and ρ=0.4. [M, number of time steps. N, number of space nodes. Value, error and EOC in the final time layer at the point (x,y)=(40,40) with error and EOC in the L and L1 norms in the final time layer. As our reference solution, the exact solution (computed with R library fExoticOptions) was used.]
    Convergence Convergence Convergence
    in (x,y)=(??,??) in L in L?
         
? ? Value Error EOC Error EOC Error EOC
25 352 1.9910 1.77E-01 2.92E-01 1.21E-02
50 692 1.8211 7.02E-03 4.66 3.58E-02 3.03 1.84E-03 2.72
100 1372 1.8229 8.88E-03 -0.34 2.18E-02 0.71 7.16E-04 1.36
200 2732 1.8177 3.67E-03 1.27 1.05E-02 1.06 3.02E-04 1.25
400 5452 1.8141 5.31E-05 6.11 2.05E-03 2.35 1.24E-04 1.28
800 10892 1.8138 1.96E-04 -1.89 6.69E-04 1.62 5.11E-05 1.28
1600 21772 1.8139 1.38E-04 0.51 3.56E-04 0.91 2.54E-05 1.01
Table 2: Black–Scholes model, σx=0.05, σy=0.05 and ρ=-0.95. [M, number of time steps. N, number of space nodes. Value, error and EOC in the final time layer at the point (x,y)=(40,40) with error and EOC in the L and L1 norms in the final time layer. As our reference solution, the exact solution (computed with R library fExoticOptions) was used.]
    Convergence Convergence Convergence
    in (x,y)=(??,??) in L in L?
         
? ? Value Error EOC Error EOC Error EOC
25 352 3.3619 1.28E+00 1.28E+00 3.60E-02
50 692 3.8702 7.71E-01 0.73 7.71E-01 0.73 1.96E-02 0.88
100 1372 4.3095 3.31E-01 1.22 3.66E-01 1.07 7.62E-03 1.37
200 2732 4.6339 6.91E-03 5.58 7.23E-02 2.34 5.53E-04 3.78
400 5452 4.6465 5.73E-03 0.27 7.01E-03 3.37 3.86E-05 3.84
800 10892 4.6468 5.97E-03 -0.06 4.98E-02 -2.83 4.61E-05 -0.26
1600 21772 4.6416 8.35E-04 2.84 1.80E-03 4.79 9.85E-06 2.22

Here, we present the experimental convergence results of the 2D tree–grid method as applied to the Black–Scholes model and the uncertain volatility model. We implemented our method in Python and performed the simulations on four different sets of parameters.11 1 The code we used can be downloaded from https://github.com/igor-vyr/tree-grid-method.

  • Black–Scholes model with moderate volatility and correlation: σx=0.3, σy=0.5 and ρ=0.4. The results of the simulation are in Table 1.

  • Black–Scholes model with extreme parameters: σx=0.05, σy=0.05 and ρ=-0.95. The results of the simulation are in Table 2.

  • Uncertain volatility model, maximal option price (worst-case scenario) with parameters σx,min=σy,min=ρmin=0.3 and σx,max=σy,max=ρmax=0.5. The results of the simulation are in Table 3.

  • Uncertain volatility model, minimal option price (best-case scenario). The max operator is replaced by the min in (5.1); all other parameters are the same as in the worst-case scenario. The results of the simulation are in Table 4.

In all models, we used the parameters T=0.25 and r=0.05. For each model, we computed the approximations of the solution on different refinement levels. Let us denote the final time layer (t=0) of the approximation of the solution on the kth refinement level as Ak. Let us also denote the final time layer of the reference solution as Aref. We measured the error of the approximation on each refinement level in three different ways.

  1. (1)

    The L error: the error was computed using the formula

      error Ak=Ak-Aref.   (5.7)
  2. (2)

    The L1 error: the error was computed using the formula

      error Ak=Ak-Aref1.   (5.8)
  3. (3)

    The error in (x=40, y=40): this was computed using the formula

      error Ak=|Ak(40,40)-Aref(40,40)|.   (5.9)

    We use this error measure and the same parameters of the uncertain volatility model as in Ma and Forsyth (2016) such that the reader can easily compare the results in both papers.

To compute the experimental order of convergence (EOC), we used the following formula:

  EOC Ak=log(ErrAk-1)-log(ErrAk)log(hk-1)-log(hk).   (5.10)

In all refinement levels, we used a (rectangular) grid with equidistant time stepping and nonequidistant space stepping, with more nodes near to the nonsmooth regions of the terminal conditions. The refinements were done uniformly.

Table 3: Uncertain volatility model, worst-case scenario (maximization). [M, number of time steps. N, number of space nodes. Q, number of controls. Value, error and EOC in the final time layer at the point (x,y)=(40,40) with error and EOC in the L and L1 norms in the final time layer. As our reference solution, a solution computed on a fine grid with 400 time steps, 5452 space nodes and 256 controls was used.]
      Convergence Convergence Convergence
      in (x,y)=(??,??) in L in L?
           
? ? ? Value Error EOC Error EOC Error EOC
25 352 16 2.8364 1.59E-01 2.43E-01 1.17E-02
50 692 32 2.6619 1.53E-02 3.38 4.86E-02 2.33 3.64E-03 1.68
100 1372 64 2.6784 1.19E-03 3.68 1.48E-02 1.71 1.17E-03 1.64
200 2732 128 2.6784 1.20E-03 -0.01 4.95E-03 1.59 3.07E-04 1.93
Table 4: Uncertain volatility model, best-case scenario (minimization). [M, number of time steps. N, number of space nodes. Q, number of controls. Value, error and EOC in the final time layer at the point (x,y)=(40,40) with error and EOC in the L and L1 norms in the final time layer. As our reference solution, a solution computed on a fine grid with 400 time steps, 5452 space nodes and 256 controls was used.]
      Convergence Convergence Convergence
      in (x,y)=(??,??) in L in L?
           
? ? ? Value Error EOC Error EOC Error EOC
25 352 16 0.9847 6.95E-02 1.07E-01 4.29E-03
50 692 32 0.9475 3.23E-02 1.11 3.79E-02 1.50 2.01E-03 1.09
100 1372 64 0.9270 1.18E-02 1.46 1.33E-02 1.51 7.59E-04 1.41
200 2732 128 0.9173 2.07E-03 2.50 3.48E-03 1.94 1.31E-04 2.53
Final time layers (t=0) of the approximations of (a) the worst-case option price (maximization) and (b) the best-case option price (minimization) from the uncertain volatility model computed with the 2D tree--grid method with fifty time steps, 69^2 space nodes and thirty-two controls.
Figure 2: Final time layers (t=0) of the approximations of (a) the worst-case option price (maximization) and (b) the best-case option price (minimization) from the uncertain volatility model computed with the 2D tree–grid method with fifty time steps, 692 space nodes and thirty-two controls.

From Table 2, we can deduce that the numerical solution also converges in the case of very small volatility and large correlation, although the convergence is not as smooth as in the case of moderate parameters (Table 1). The L and the pointwise convergence seem to be less smooth than the L1 convergence. This is reasonable, as in the L1 norm the errors in all nodes are averaged. In the uncertain volatility model, the values in (x=40, y=40) are similar to the values from Ma and Forsyth (2016), which verifies our method. The experimental order of convergence in the L1 norm in Tables 1, 3 and 4 seems to be slightly better than the theoretical order 1, while the experimental order of convergence in Table 2 is quite nonsmooth.

The increase of the experimental order of convergence in the last refinement level in the uncertain volatility model results from using a solution computed on a fine grid as our reference solution (this is disproportionately closer to the solution on the last refinement level in contrast to the solutions on previous refinement levels).

In Figure 2, we see the final time layer (t=0) of the approximation of option prices under the uncertain volatility model for both the best- and worst-case scenarios.

6 Conclusion

In this paper, we generalized the 1D tree–grid method to two space dimensions. Although the ideas behind this 2D method are similar to those behind the 1D case, the algorithm construction is more challenging, mainly because of the correlation between the two spatial variables. Our 2D tree–grid method is explicit and, hence, suitable for parallelization, but it is still unconditionally stable and monotone in contrast to other explicit methods (Kushner and Dupuis 2013; Bonnans and Zidani 2003; Debrabant and Jakobsen 2013). Moreover, unlike other wide-stencil methods (Ma and Forsyth 2016; Bonnans and Zidani 2003; Debrabant and Jakobsen 2013), it does not use any 2D interpolation: only a search for the nearest (left or right) node in each dimension, separately, is needed. These properties make the method very flexible and, by simply following Algorithm 1, easy to implement.

We proved the convergence of the 2D tree–grid method using the theory of Barles and Souganidis (1991). We tested our method on the two-factor uncertain volatility model and on the Black–Scholes model for option pricing and verified the convergence experimentally.

Declaration of interest

The authors report no conflicts of interest. The authors alone are responsible for the content and writing of the paper.

Acknowledgements

This research was supported within “ENANEFA – Efficient Numerical Approximation of Nonlinear Equations in Financial Applications”, a bilateral German–Slovakian project financed by DAAD and the Slovakian Ministry of Education (01/2018–12/2019).

References

  • Barles, G., and Souganidis, P. E. (1991). Convergence of approximation schemes for fully nonlinear second order equations. Asymptotic Analysis 4, 2347–2349 (https://doi.org/10.1109/CDC.1990.204046).
  • Black, F., and Scholes, M. (1973). The pricing of options and corporate liabilities. Journal of Political Economy 81(3), 637–654 (https://doi.org/10.1086/260062).
  • Bonnans, J. F., and Zidani, H. (2003). Consistency of generalized finite difference schemes for the stochastic HJB equation. SIAM Journal on Numerical Analysis 41(3), 1008–1021 (https://doi.org/10.1137/S0036142901387336).
  • Chen, Y., and Wan, J. W. (2016). Monotone mixed narrow/wide stencil finite difference scheme for Monge–Ampère equation. Preprint (arXiv:1608.00644).
  • Crandall, M. G., Ishii, H., and Lions, P.-L. (1992). User’s guide to viscosity solutions of second order partial differential equations. Bulletin of the American Mathematical Society 27(1), 1–67 (https://doi.org/10.1090/S0273-0979-1992-00266-5).
  • Debrabant, K., and Jakobsen, E. R. (2013). Semi-Lagrangian schemes for linear and fully non-linear diffusion equations. Mathematics of Computation 82(283), 1433–1462 (https://doi.org/10.1090/S0025-5718-2012-02632-9).
  • Debrabant, K., and Jakobsen, E. R. (2014). Semi-Lagrangian schemes for linear and fully non-linear Hamilton–Jacobi–Bellman equations. In International Conference on Hyperbolic Problems 2014, pp. 483–490. American Institute of Mathematical Sciences, Springfield, MO.
  • Forsyth, P. A., and Vetzal, K. R. (2012). Numerical methods for nonlinear PDEs in finance. In Handbook of Computational Finance, pp. 503–528. Springer (https://doi.org/10.1007/978-3-642-17254-0_18).
  • Kilianová, S., and Ševčovič, D. (2013). A transformation method for solving the Hamilton–Jacobi–Bellman equation for a constrained dynamic stochastic optimal allocation problem. ANZIAM Journal 55(1), 14–38 (https://doi.org/10.1017/S144618111300031X).
  • Kossaczký, I., Ehrhardt, M., and Günther, M. (2017). The tree–grid method with control-independent stencil. In Proceedings of Equadiff 2017 Conference, pp. 79–88. Public Knowledge Project.
  • Kossaczký, I., Ehrhardt, M., and Günther, M. (2018). A new convergent explicit tree–grid method for HJB equations in one space dimension. Numerical Mathematics: Theory, Methods and Applications 11, 1–29 (https://doi.org/10.4208/nmtma.OA-2017-0066).
  • Kushner, H., and Dupuis, P. G. (2013). Numerical Methods for Stochastic Control Problems in Continuous Time. Applications of Mathematics, Volume 24. Springer Science & Business Media.
  • Lions, P.-L. (1983). Optimal control of diffusion processes and Hamilton–Jacobi–Bellman equations. Part 2: viscosity solutions and uniqueness. Communications in Partial Differential Equations 8(11), 1229–1276 (https://doi.org/10.1080/03605308308820301).
  • Ma, K., and Forsyth, P. A. (2016). An unconditionally monotone numerical scheme for the two-factor uncertain volatility model. IMA Journal of Numerical Analysis 37(2), 905–944 (https://doi.org/10.1093/imanum/drw025).
  • Mataramvura, S., and Øksendal, B. (2008). Risk minimizing portfolios and HJBI equations for stochastic differential games. Stochastics: An International Journal of Probability and Stochastic Processes 80(4), 317–337 (https://doi.org/10.1080/17442500701655408).
  • Pham, H. (2005). On some recent aspects of stochastic control and their applications. Probability Surveys 2, 506–549 (https://doi.org/10.1214/154957805100000195).
  • Pooley, D. M., Forsyth, P. A., and Vetzal, K. R. (2003). Numerical convergence properties of option pricing PDEs with uncertain volatility. IMA Journal of Numerical Analysis 23(2), 241–267 (https://doi.org/10.1093/imanum/23.2.241).
  • Song, Q. (2008). Convergence of Markov chain approximation on generalized HJB equation and its applications. Automatica 44(3), 761–766 (https://doi.org/10.1016/j.automatica.2007.07.014).
  • Wang, J., and Forsyth, P. A. (2008). Maximal use of central differencing for Hamilton–Jacobi–Bellman PDEs in finance. SIAM Journal on Numerical Analysis 46(3), 1580–1601 (https://doi.org/10.1137/060675186).
  • Yong, J., and Zhou, X. Y. (1999). Stochastic Controls: Hamiltonian Systems and HJB Equations. Stochastic Modelling and Applied Probability, Volume 43. Springer Science & Business Media.

Only users who have a paid subscription or are part of a corporate subscription are able to print or copy content.

To access these options, along with all other subscription benefits, please contact info@risk.net or view our subscription options here: http://subscriptions.risk.net/subscribe

You are currently unable to copy this content. Please contact info@risk.net to find out more.

You need to sign in to use this feature. If you don’t have a Risk.net account, please register for a trial.

Sign in
You are currently on corporate access.

To use this feature you will need an individual account. If you have one already please sign in.

Sign in.

Alternatively you can request an individual account here