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 ﬁrst 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 deﬁned
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 deﬁned 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 ‘ﬁnal’ 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 deﬁnition 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
simpliﬁes 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
speciﬁed 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 Efﬁcient 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 deﬁnition G(0, 0) = $1. The Arrow–Debreu
prices of securities paying $1 in any of the nodes at the ﬁrst 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 modiﬁed in moving from the ﬁrst 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 ﬁrst 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 deﬁnition
give the value of a unit payment in states ‘up’, ‘mid’ and ‘down’ at time 1, respectively.
Therefore, again given the deﬁnition 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, Dufﬁe (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 ﬁnancial
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 ﬂexibility in the possible values reached
by a parent node. This, in turn, is closely linked to the stability of explicit ﬁnite 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 ﬁnite 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 ﬁnite differences approaches
attempt to ﬁnd 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 ﬁnite 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 ﬁnancial 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 reﬂect
the ﬁnancial 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 ﬁrst node
(see Figure 11.3).
Three probabilities (p(up), p(mid) and p(down)) have to be determined. The usual
normalization condition provides the ﬁrst 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 ﬁrst 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 ﬁrst 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 ﬁrst 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 ﬁrst 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 ﬁrst 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 ﬁrst 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 ﬁrst option to be a call and place the strike of the ﬁrst 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 ﬁrst 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 modiﬁed 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 ﬁgures; 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 difﬁculties, 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 ﬁrst 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 ﬁnite 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, ﬁnancially 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 ﬁnancial 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 ﬁnite 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 ﬁnite differences stability criterion is met. The probability violation on the forward condition can be easily
ﬁxed using, for example, non-symmetric or ‘abnormal’ branching, as ﬁrst 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 ﬁnancial 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 ﬁtted 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 ﬂat
(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-ﬂat 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 brieﬂy 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
ﬁnite 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