Tải bản đầy đủ - 0 (trang)
4 Green’s Functions (Arrow–Debreu Prices) in the DK Construction

4 Green’s Functions (Arrow–Debreu Prices) in the DK Construction

Tải bản đầy đủ - 0trang

11.4 GREEN’S FUNCTIONS IN THE DK CONSTRUCTION



323



the world on a lattice by two indices, the first labelling time and the second the price

level. Given a state k and a time j , the Arrow–Debreu price, G(j, k), is then defined

to be the price today of a security that pays $1 if state k is reached at time j , and 0

otherwise.2 Given two such state–time pairs, (j, k) and (r, s), the Arrow–Debreu price,

G(j, k, r, s), j > r, is defined to be the price at time r and in state s of a security that

pays $1 if state k is reached at time j , and 0 otherwise. So, in general, an Arrow–Debreu

price should have as argument four sets of quantities: two times, and the collections of

state variables required to identify the ‘initial’ and ‘final’ states. Since we are assuming

that a future state is perfectly represented by the realization of the stock price, these state

variables collapse to being just the stock price itself.

It is easy to see how to evaluate the price today of a security with a single payoff time, and with the payoff itself purely dependent on the realization of the stock

price. Let us assume that the security in question pays out at time j the amounts

D k = D(Sjk ), k = 1, 2, . . . , n, if the underlying is in state k at time j . If this is

the case, by the definition of the Arrow–Debreu price one can write the value of the

j -maturity security at an earlier time r contingent on the then-prevailing state of the

world (stock price) being s, PVj (r, s), as

D(Sjk )G(j, k, r, s)



PVj (r, s) =



(11.8)



k



In particular, if we are interested in the present value today of the payoff, the expression

simplifies to

D(Sjk )G(j, k, 0, 0) =



PVj (0) =

k



D(Sjk )G(j, k)



(11.9)



k



Arrow–Debreu prices are fundamental in asset pricing, because their existence is directly

linked to market completeness. Since a market is said to be complete if there exists a security or combination of securities that can provide a certain payoff in each possible future

state of the world, and since perfect payoff replication and unique pricing by no-arbitrage

are only possible in a complete market, one can see that exact payoff replication and

preference-free pricing are both directly linked to the existence of Arrow–Debreu prices.3

Furthermore, since their payoffs are unitary, Arrow–Debreu prices can be easily related

(modulo discounting) to the (risk-adjusted!) probability of reaching state (j, k). If one

deals with time-0 Arrow–Debreu prices, G(j, k, 0, 0), these probabilities are unconditional. If the full set of Arrow–Debreu prices, G(j, k, r, s), are known, then also all

the conditional probabilities can be obtained. Since a process for the underlying is fully

specified by assigning all the unconditional and conditional probabilities, the set of prices

G(j, k, r, s) characterize the stochastic evolution of the underlying. When looked at in

this light, Arrow–Debreu prices are often referred to as state price densities. See, for

example, Cochrane (2001).

From a practical point of view, if we knew the values the Arrow–Debreu prices G(j, k)

for all j and k we could immediately evaluate the prices of calls and puts with strikes

2 Arrow–Debreu prices give the ‘response’ of the ‘system’ to a ‘unit input’: by analogy with their counterparts

in physics they are therefore also known as ‘Green’s functions’.

3 At least as long as the state of the world if fully characterized by the price of a traded quantity.



324



CHAPTER 11 LOCAL-VOLATILITY MODELS



k expiring at times j . Constructing Arrow–Debreu prices by brute force, however, is no

simpler than evaluating the discounted expectations of call or put payoffs. Fortunately,

given the very special nature of the payoffs associated with Arrow–Debreu prices, there

is a systematic way to ‘update’ their values at time j + 1 if their values at time j are

known. How to do this is shown in the next section.



11.4.2 Efficient Computation of Arrow–Debreu Prices

Given a trinomial lattice and an associated set of probabilities we can easily construct a tree

of Arrow–Debreu prices. To begin with, by definition G(0, 0) = $1. The Arrow–Debreu

prices of securities paying $1 in any of the nodes at the first time-step are almost as

straightforward to determine, as shown in Figure 11.1, where deterministic and constant

interest rates have, for simplicity, been assumed: they are given by the discounted probabilities of reaching each of the three nodes at time-step 1. Note in passing that the

discounting rate r in Figure 11.1 is actually the difference between the riskless oneperiod borrowing/lending rate and the (constant) dividend yield in the case of equities, or

the difference between the domestic and foreign rate in the case of FX rates.

The construction is slightly more complex for the second time-step, and is shown in

Figure 11.2.

To see how the construction is modified in moving from the first to the second timestep, let us now place $1 at, say, the central node at time-step 2 (i.e. the node reached

after a ‘down’ jump followed by an ‘up’ jump, or by an ‘up’ jump and a ‘down’ jump, or

after two ‘mid’ jumps). Let us call this node the (mid-mid, 2) node, and let us calculate

G(mid-mid, 2). See Figure 11.2. By putting $1 at node (mid-mid, 2) one obtains a nonzero value at the roots of the upper, the middle and the bottom trinomial subtree originating

at time 1. (These first trinomial subtrees are simply made up of the three branches originating from the top, mid and bottom node at time-step 1.) The contribution, for instance,

to the node of the uppermost subtree (the one originating from the state ‘up’) is given by

[$0 ∗ p(up, up)

+ $0 ∗ p(up, mid)

+ $1 ∗ p(up, down)] ∗ exp[−r t]



(11.10)



G (up) = exp[−r * dt ] * p (up)



p (up)



O



p (mid)



p (down)



G (mid) = exp[−r * dt ] * p (mid)



G (down) = exp[−r * dt ] * p (down)



Figure 11.1 The Arrow–Debreu prices for the three states reached at time 1 from the root.



11.4 GREEN’S FUNCTIONS IN THE DK CONSTRUCTION



325

0



G (up) = exp[−r * dt ] * p (up)



0



G (mid) = exp[−r * dt ] * p (mid)



1



G (down) = exp[−r * dt ] * p (down)



0



p (up)



O



p (mid)



p (down)



0



Figure 11.2 Construction of the price of an Arrow–Debreu security paying $1 if the central state

at time-step 2 is reached, and $0 otherwise.



This is the value at tree node (up, 1) of $1 placed at node (mid-mid, 2). Similarly, $1

placed in the central node at time 2 will contribute to the central and bottom subtrees as

well. We can compute in a similar way the value of $1 placed at (mid-mid, 2) at tree

node (mid, 1) and the value of $1 placed at (mid-mid, 2) at tree node (down, 1).

Let us call the three contributions to the three subtrees originating from placing $1 at

state (mid-mid, 2) X, Y and Z. Therefore

X = [$0 ∗ p(up, up)

+ $0 ∗ p(up, mid)

+ $1 ∗ p(up, down)] ∗ exp[−r t]



(11.11)



Y = [$0 ∗ p(mid, up)

+ $1 ∗ p(mid, mid)

+ $0 ∗ p(mid, down)] ∗ exp[−r t]



(11.12)



Z = [$1 ∗ p(down, up)

+ $0 ∗ p(down, mid)

+ $0 ∗ p(down, down)] ∗ exp[−r t]



(11.13)



326



CHAPTER 11 LOCAL-VOLATILITY MODELS



The Arrow–Debreu prices G(up, 1), G(mid, 1) and G(down, 1), however, by definition

give the value of a unit payment in states ‘up’, ‘mid’ and ‘down’ at time 1, respectively.

Therefore, again given the definition of Arrow–Debreu prices, G(mid-mid, 2) is equal to

G(mid-mid, 2) = X ∗ G(up, 1) + Y ∗ G(mid, 1) + Z ∗ G(down, 1)



(11.14)



The same procedure can be followed for the other nodes at time 2, or, for that matter,

for later time-steps. The construction just presented can therefore be generalized, and one

can draw the following conclusions:

Conclusion 1 Once the Arrow–Debreu prices out to time n are known, one can construct

all the Arrow–Debreu prices at time n + 1 with O(n) operations (in a recombining tree).

One does not have to traverse the tree all the way back to the origin again.

Conclusion 2 Since there are n time steps, and since obtaining the Arrow–Debreu prices

from a given time slice takes O(n) operations, the construction of the whole tree of

ArrowDebreu prices requires O(n2 ) computations. A naăve construction whereby each

payment is discounted all the way back to the root would require O(n3 ) operations. This

would soon render the computational cost prohibitive.

Conclusion 3 The Arrow–Debreu prices can be used to obtain the value of any security

at the origin (i.e. today), provided that the values of this security in all states of the world

for which Arrow–Debreu prices are available are known. This property is central to the

DK construction.

It is important to keep in mind that assuming the existence of Arrow–Debreu prices

is tantamount to assuming the absence of arbitrage and market completeness, and hence

risk-neutral pricing (see, for example, Duffie (1996) for a thorough treatment, or Rebonato

(1998a) for a relatively short but self-contained discussion). One still has to ask oneself the

fundamental question: Are these assumptions actually appropriate to describe the financial

problem at hand, or are they leaving out some essential ‘ingredients’ that would account

for the smile shape? This issue is very important, and will be discussed at length later in

the chapter.

Finally, note also that the tree recombines. This is computationally expedient, since it

avoids the exponential explosion of the number of nodes. This feature is not, however,

without its drawbacks, since it greatly reduces the flexibility in the possible values reached

by a parent node. This, in turn, is closely linked to the stability of explicit finite differences methods – to which trinomial trees are closely related – and to the failure to obtain

positive ‘probabilities’ emanating from some of the nodes. These two related aspects will

also be discussed below.



11.5



The Derman-and-Kani Tree Construction



In order to reproduce exactly the market prices of today’s plain-vanilla options, Derman

and Kani (1998) recommend a computational procedure based on a trinomial tree. The

possible values attainable by the ‘stock’ price at the different levels and time-steps are

arbitrarily pre-chosen. Recombination is ensured by the geometry of the tree. The construction is, in this respect, similar to the explicit finite differences technique: at each



11.5 THE DERMAN-AND-KANI TREE CONSTRUCTION



327



node the user has to determine the three emanating probabilities connecting a parent node

with its three ‘offsprings’. The fundamental difference is that finite differences approaches

attempt to find a solution to a partial differential equation (PDE) – typically linear and

parabolic for option pricing applications without transaction costs – given the drift and

the volatility at each time–space node. In other words, the procedure is akin to a local

moment matching, and in the discretization of the various time and space derivatives

the local volatility is assumed to be known. Explicit finite differences methods are only

conditionally stable, but it is possible and relatively easy to check a priori (i.e. once a

given space–time discretization has been chosen) whether a stability violation will be

encountered at any of the nodes (see, for example, Ames (1977) and Wilmott (1998)). In

the case of the DK construction, however, the local volatilities are a by-product of the

algorithm, and, therefore, it is not possible to check beforehand whether any of the nodes

will give rise to negative probabilities.

Note carefully that, in discrete-time financial theory (see, for example, Pliska (1997)),

absence of arbitrage is linked to the positivity of all the discrete pseudo-probabilities. It

is important to stress that the possibility of encountering negative probabilities in the DK

algorithmic construction need not entail that the underlying price system produced by

a continuous-time, local-volatility process is not arbitrage-free, and might simply reflect

the financial arbitrariness of the chosen grid points. In other words, a different length of

the time-step, a different positioning of the nodes or a different choice of ‘arrival’ points

could either give rise to or eliminate negative probabilities, without any of the actually

traded prices being affected.



11.5.1 Building the First Step

To see how the DK construction is carried out in practice, let us start from the first node

(see Figure 11.3).

Three probabilities (p(up), p(mid) and p(down)) have to be determined. The usual

normalization condition provides the first equation between them:

Equation 1: p(up) + p(mid) + p(down) = 1.



S (up)



p (up)



S (0)



p (mid)



S (mid) = S (0)



p (down)

S (down)



Figure 11.3 The first step of the DK construction, with the stock prices at time 1 denoted by

S(up), S(mid) and S(down), and the probabilities connecting today’s stock price, S(0), with the

three possible values at time 1 denoted by p(up), p(mid) and p(down).



328



CHAPTER 11 LOCAL-VOLATILITY MODELS



The first moment of S (i.e. the expectation) given its value today is also easily obtainable: a simple no-arbitrage argument shows that it must be equal to the one-period forward

value of the stock price given its price today. More generally, when the construction is

carried out from a node other than the origin, the first moment-matching condition equates

the expectation with the one-period forward price as seen from the parent state:

Equation 2: S(up)p(up) + S(mid)p(mid) + S(down)p(down) = S(0) exp[r t].

Note again that, as mentioned earlier, in the Equation 2 above the quantity r denotes

the difference between the deterministic short rate and the dividend yield for an equity

stock case, or the difference between domestic and foreign rates in the FX case. If the

local volatility were known we could at this point simply carry out the usual momentmatching exercise using any of the well-established techniques (see, for example, Nelson

and Ramaswamy (1990) or Boyle et al. (1994)). In our case, however, we do not have

access to the local variance, and this is where DK’s method is different from the more

traditional approaches.

In order to see how the problem can be overcome, recall that we assumed that the

prices of plain-vanilla calls and puts of all strikes and maturities were known. Therefore

we know the prices of all calls and puts expiring at time-step, say, 1. In particular, we

know, for instance, the price of the call with strike equal to S(mid) (Figure 11.4).

The payoffs of this option in the different states of the world at expiry (i.e. in states

‘up’, ‘down’ and mid’) are given by:

in state (down)

=0

in state (mid)

=0

in state (up)

= [S(up) − S(mid)]

The Arrow–Debreu price at the origin is, trivially, given by G(0, 0) = 1. Therefore

the model value today of the chosen option, Opt(mod), is equal to

Opt (mod) = exp[−r t]

∗{p(down) ∗ 0 + p(mid) ∗ 0 + p(up) ∗ [S(up) − S(mid)]}G(0, 0)

= p(up)[S(up) − S(mid)] exp[−r t]



(11.15)



S (up)



p (up)



S (0)



p (mid)



S (mid) = S (0)



Payoff



p (down)

S (down)



Figure 11.4 The payoff of a call option with strike equal to S(mid) drawn next to the tree

construction for the first step.



11.5 THE DERMAN-AND-KANI TREE CONSTRUCTION



329



By imposing that the model and the market prices should be the same,

Opt (mod) = Opt (market)



(11.16)



one obtains one equation in one unknown, p(up):

Equation 3: p(up) =



Opt (market) exp[r t]

.

[S(up) − S(mid)]G(0, 0)



This formally closes the set of equations for time-step 1.

A few important numerical comments should be made about the quantity Opt(market).

We have assumed in the treatment above that the model value of the option was set equal

to the true observed market price of the relative option. This would however introduce

an unwanted numerical loss of information, whose origin can be easily understood by

noting that at the first time-step we are, after all, evaluating an expectation (which should

in principle require integrating from the strike to +∞) using only three sample points.

As shown later on, this numerical ‘noise’ does not disappear or average out for later

time-steps, but would give rise, if left ‘untreated’, to persistent increasing distortions of

the local volatility function. DK therefore prefer to set the model price given by the

equation above equal not to the true market price, but to the model price obtained with

a ‘traditional’ trinomial tree. More precisely, the quantity Opt(market) above is obtained

by pricing the relevant option using a ‘traditional’ trinomial tree built using no smile, the

same state space and a constant volatility equal to the implied volatility of the relevant

option. This procedure (similar in spirit to a contravariate technique) attempts to ‘purge’

out of the DK smiley tree construction the numerical errors originating from the coarseness

of the discrete tree. Such errors can therefore be expected to be encountered also in the

construction of a ‘traditional’ trinomial tree. Note, however, that, unlike the DK tree,

the latter is built starting from the assumed knowledge of the volatilities. It is therefore

not a priori obvious that numerical errors in the constructions of the two trees will be

strongly correlated (which is the necessary condition for a contravariate approach to work

effectively). As shown in Sections 11.6 and 11.7, this does turn out to be the case, and

the procedure proves essential to obtaining numerically acceptable results.



11.5.2 Adding Further Steps

For later time-steps the idea is the same, although there is a slight complication owing to

the fact that, as shown below, the model price will be a function not only of one unknown

probability, but also of other (already determined) probabilities. It is at this stage that the

Arrow–Debreu prices are made use of. More precisely, the algorithm is as follows.

• Consider the first time slice for which probabilities have to be determined.

• Choose as many options expiring at this time slice as the number of nodes minus 2.

• Start from the topmost subtree of the time slice, made up of three branches.

• Choose the first option to be a call and place the strike of the first option exactly at

the second node from the top.

• Since, across the whole time slice, only one node has a payoff different from zero

(this is the reason why a call with this particular strike was chosen), this will



330



CHAPTER 11 LOCAL-VOLATILITY MODELS

determine the discounted value of the payoff at the parent node in the previous

time slice as a function of a single probability.



• Multiply this discounted payoff by the Arrow–Debreu price of the parent node to

obtain the model option price today.

• Equating this quantity with the ‘market’ price of the first out-of-the-money option

gives one equation in one unknown.

• Together with the forward-price condition and the probability-normalization condition this equation uniquely determines the three probabilities emanating from the

parent node in the previous time slice.

• Move to the second subtree from the top, and add one (call) option with a strike

positioned at the middle node of this subtree.

• This option also introduces non-zero payoffs for the subtree above the one being

considered, but only adds one unknown probability.

• Multiply the probability-weighted discounted payoffs originating from this option by

the appropriate Arrow–Debreu prices at the previous time slice (which have already

been determined); in so doing only one new probability is introduced.

• Obtain the model option price, equate it with the ‘market’ option value and solve

for the unknown probability.

• Repeat the same for all the nodes along the time slice.

• Move to the next time slice.

As one can appreciate from the description above, the procedure is conceptually very

easy. The only slightly cumbersome aspect is the fact that, as mentioned above, when

one moves from the topmost node downwards, the model price becomes a function not

only of one unknown probability, but also of one or more of the already determined

probabilities for the same time slice. Simple algebraic manipulations give rise to the

expressions reported in Derman and Kani (1998) (the symbols have been modified to

conform with the notation used above):

pi =

qi =



exp[r t]C(Si+1 , tn+1 ) −



j =i+1,2n Gj (Fj



− Si+1 )



Gi (Si+2 − Si+1 )

Fi − pi (Si+2 − Si+1 ) − Si+1

Si − Si+1



(11.17)

(11.18)



when calls are used, and

pi =

qi =



exp[r t]P (Si+1 , tn+1 ) +



j =i+1,2n Gj (Fj



Gi (Si+1 − Si )

Fi − pi (Si+1 − Si ) − Si+1

Si − Si+1



− Si+1 )



(11.19)

(11.20)



when puts are used. In the expressions above, Si+2 , Si+1 and Si correspond to S(up),

S(mid) and S(down), respectively, in the previous figures; Fi denotes the forward price;



11.6 IMPLEMENTATION OF THE DK CONSTRUCTION



331



pi is the ‘up’ probability emanating from node i at time n; qi is the ‘down’ probability

emanating from node i at time n; C(.) and P (.) indicate the prices of calls or puts,

respectively; and G(.), as before, are the Arrow–Debreu prices.

Despite the fact that, in principle, either a call or a put could be used in the procedure,

for practical purposes it is useful to switch option type across the mid point for each

time slice so that at-the-money or out-of-the-money options are always used (calls in the

top part of the tree and puts in the lower part). If that were not the case one would end

up using very deeply-in-the-money options, where the important (time-value-of-money,

volatility-related) information is ‘swamped’ by the uninteresting intrinsic value. Since a

long position in a forward contract struck at K plus a long position in a put, also struck

at K, is equivalent to a long position in a K-strike call, the simultaneous correct recovery

of the forward price and of the out-of-the-money option ensures, by call–put parity, that

the in-the-money option will also be automatically correctly priced.

The exposition shows that the method is conceptually simple and elegant, and would

appear quite easy to implement. In practice, however, one often encounters serious numerical problems. The main ones are discussed in the following section.



11.6



Numerical Aspects of the Implementation of the DK

Construction



The previous section described the general idea behind the DK construction. Its practical

implementation, however, can be fraught with difficulties, many of which stem from

the fact that the price–time grid is chosen in an ‘arbitrary’ fashion, i.e. without prior

knowledge of the local volatility. This state of affairs gives rise to the numerical problems

discussed below. Fixing the first two requires altering the geometry of the tree, whilst the

third is partly mitigated by the use of a ‘contravariate’ parallel tree.



11.6.1 Problem 1: Forward Price Greater Than S(up) or Smaller

Than S(down)

This is the case depicted in Figure 11.5. When the forward price is greater than S(up) or

lower than S(down) no linear combination of S(up), S(down) and S(mid) with positive

S (up)

p (up)



S (0)



p (mid)



S (mid)



p (down)



S (down)

S (0)exp(r * dt )



Figure 11.5



The case when the forward price is not ‘contained’ between S(up) and S(down).



332



CHAPTER 11 LOCAL-VOLATILITY MODELS



weights can be equal to S0 exp(r t). This is one of the well-known stability problems

encountered in the case of the explicit finite differences technique (see Ames (1977)):

the method becomes unstable whenever the expectation is greater than the node above

S(up) or the node below S(down) at the following time-step. Note that, as mentioned

earlier, financially this would imply a possibility of arbitrage; this is, however, only true

if the arbitrarily chosen values S(up), S(down) and S(mid) truly were the only possible

states reachable from the parent node. In the context of the DK construction, the negative

probabilities simply indicate that, given the one-period rate r, the three stock prices

at the following time-step do not constitute a suitable discretization of the underlying

continuous-time process. Since, as mentioned above, the choice of the grid points is

arbitrary, no special financial meaning can be associated to this violation. Finally, note

that it is relatively easy to check whether this condition is met at any point in the tree

before actually carrying out the construction.



11.6.2 Problem 2: Local Volatility Greater Than 12 |S(up) − S(down)|

The maximum conditional variance that can be calculated from the three values S(up),

S(mid) and S(down) is obtained when p(up) = p(down) = 12 , and p(mid) = 0. It is

easy to understand why this should be the case: if there is any probability weight to the

middle node this, by necessity, would reduce the overall dispersion, and therefore the

variance. Similarly, if the probability of reaching either S(up) or S(down) were greater

than 12 , one would also have a greater concentration of mass at either node, and therefore, again, a smaller dispersion. Therefore no greater variance can be obtained than

for the degenerate case of zero middle probability, and ‘up’ and ‘down’ probabilities

equal to 12 . But, when this is the case, one can easily check that the conditional sample

standard deviation is simply given by 12 |S(up) − S(down)|. If this maximum standard

deviation ‘supported by’ the tree construction is not large enough to accommodate the

local volatility necessary to price the corresponding option correctly, then at least one of

the probabilities must become negative. The result of this is the same as before, i.e. an

instability of the associated explicit finite differences scheme. Note carefully again, however, that, unlike the situation with the usual discretizations of PDEs, the local volatilities

in the DK construction are not known a priori. Therefore, unlike the case of Problem

1, before building the tree it is not easy to check if the explicit finite differences stability criterion is met. The probability violation on the forward condition can be easily

fixed using, for example, non-symmetric or ‘abnormal’ branching, as first suggested by

Hull and White (1990b) in the interest-rate context. Fixing the variance violation is more

cumbersome.



11.6.3 Problem 3: Arbitrariness of the Choice of the Strike

The choice of the strike described above gives rise to an algorithm that is motivated by

computational rather than financial considerations. In particular, if we want to place strikes

exactly on tree nodes, the algorithm described above (with its ‘mirror image’, whereby

one starts from the bottom of the tree) allows us to solve explicitly for one probability

at a time. Any other positioning of the same number of strikes would in general require

solving a series of 3 × 3 linear systems.



11.6 IMPLEMENTATION OF THE DK CONSTRUCTION



333



S (up)

p (up)



S (0)



Payoff



p (mid)

S (mid)

p (down)

S (down)



Figure 11.6 The trinomial tree, with different possible values for the strike, still giving rise to a

single equation in a single unknown.



It is also possible, however, to retain the simplicity of a one-unknown–one-equation

problem by placing the strike not exactly at the middle node, but at any (more out-of-themoney) position located for a put between the middle and the down node. See Figure 11.6.

This simple observation gives further insight into the role played by the replacement of

the true market prices with the corresponding model value obtained using the ‘traditional’

trinomial tree. Consider, in fact, the effect of moving the strike progressively more outof-the-money without crossing the next node. The payoff would change linearly, and

multiplication of this discounted payoff by the same Arrow–Debreu price at the parent

node would give a purely linear variation in the model option price. We know, however,

that, in reality, a ‘true’ (i.e. Black) one-period option is not a linear function of the strike.

If one fitted a model price to the corresponding true call or put market price (as opposed

to the ‘control’ market price) one would pollute the estimation of the local volatility

simply because of the numerical failure of the naăve algorithm to capture the correct

convexity. Therefore, if one used the naăve Derman-and-Kani approach with, say, a flat

(no smile) volatility surface, and one moved the position of the strikes as described above,

and shown in Figure 11.6, one would obtain a non-flat local volatility. This numerical

effect becomes smaller and smaller as the number of time-steps increases. If, however, the

DK model is implemented in this naăve manner (which the authors do not recommend),

the speed of convergence can be empirically observed to be very slow.

We have already briefly seen how this problem can be solved. Let us look at the

solution in more detail. For each option, one can construct in parallel a trinomial tree

with exactly the same geometry, i.e. number of nodes and choice of possible states, but

with a deterministic volatility. By analogy with Monte Carlo techniques, this is called the

‘contravariate’ tree. If an option is considered in isolation, there always is at least one

deterministic-volatility function that prices it exactly (e.g. the constant volatility equal

to the implied volatility). The price of the ‘shadow’ market option obtained with the

contravariate tree would therefore in theory converge to the true market price. For a

finite tree, however, the shadow price will in general display a certain deviation from

the true market price. If one then uses the local-volatility trinomial tree as described

above but equates the model price that it produces with the pseudo-market price obtained

using the contravariate (deterministic-volatility) trinomial tree, the convexity effect almost



Tài liệu bạn tìm kiếm đã sẵn sàng tải về

4 Green’s Functions (Arrow–Debreu Prices) in the DK Construction

Tải bản đầy đủ ngay(0 tr)

×