Finite Difference Methods: Solving the Pricing Equation on a Grid

A finite difference method lays a grid over time and over the level, replaces every derivative in the pricing equation with arithmetic on neighbouring grid points, and solves the resulting system backwards from the payoff. The method solves the equation rather than averaging outcomes. Its two spacings are tied together, and breaking that tie does not cost accuracy, it destroys the answer.

Two spacings, one in time and one in the level, and they cannot be chosen independently. The whole character of the method comes from that single fact. Refine one and the other is forced. Refuse the force and the arithmetic does not degrade politely; it comes apart, and it prints a number that looks like a price and is not one.

What does a finite difference method do?

The idea is older than any of this, and everyone has already used it in an ordinary human version. Suppose the question is how steep a road is at one particular lamp post. Steepness at a point is a derivative, and a point cannot be measured. So the only thing available is done instead: the height of the road is measured at the post before and at the post after, the two are subtracted, and the difference is divided by the distance between them. The number that comes out is not the derivative. The number is an arithmetic stand-in for the derivative, built from two readings that can actually be taken, and the stand-in gets closer to the derivative as the posts get closer together.

Building a stand-in out of nearby readings is the entire idea. A finite difference methodSolving the pricing equation on a grid rather than averaging outcomes. takes an equation written in derivatives, replaces every derivative in it with a stand-in built from readings at nearby points, and then solves the arithmetic problem that is left. Nothing about the idea is specific to prices. A great deal of physics and engineering has been computed this way for a century, and pricing borrowed the method whole.

Now the part that makes this method different from the other three in this reading order. The others all build an average. A lattice walks a branching set of outcomes forward and averages the payoffs back with weights. A sampling method draws many finishes and takes the mean of what they pay. Both are answering the question by asking what might happen and averaging over it. A grid method does not ask that question at all. A grid method takes the differential equation that the price must satisfy at every point, and solves that equation. The word solve is meant literally: the answer comes out of the equation, not out of a set of outcomes.

The queue outside a ticket window makes the difference concrete. The average wait can be found one of two ways. One is the sampling approach: a thousand people are followed through the queue with a stopwatch and the measurements are averaged. The other is to write down the rule for how the length of the queue changes from one minute to the next, and solve that rule. The second way never watches a single person. The answer is the same information, reached through the law of motion rather than through the outcomes, and when the law is known that route is usually the cheaper of the two.

The equation being solved is the one the option pricing material produced, where it is derived. One particular form of it makes the grid arithmetic simple, and the work below uses that form. Instead of working in the level itself, the work is done in the logarithm of the level. The coefficients then stop depending on position on the grid. Every row of the calculation uses the same three numbers rather than a fresh set at every point.

The flip to time remaining changed the direction of the whole problem, and the change is worth stating. The pricing equation is naturally a backwards problem: the value at the horizon is known and the value today is wanted. Working in time remaining turns that into an ordinary forwards march. The march starts with the payoff, the value when no time is left, and steps forwards in time remaining until a whole year has been stepped. At that point the march is standing at today. Every scheme in this guide is a backward solutionWorking from the payoff row back to today, which every scheme here does.. The flip to time remaining is only a bookkeeping trick, and the trick lets a backward solution be written as a forward one.

What is the grid, and what are its two spacings?

The gridThe mesh of points in time and in the level on which the equation is solved. is a mesh. One axis is time remaining and the other is the logarithm of the level. Both axes are cut into equal pieces, and the value of the contract is computed only at the crossing points. Between the crossing points nothing is computed and nothing is claimed. A grid method delivers a table of values at chosen points, not a formula.

The two cuts have names. The space stepThe spacing in the level, 0.05 in the logarithm here. is the spacing along the level axis, and here it is 0.05 in the logarithm. The time stepThe spacing in time, which cannot be chosen independently of the space step. is the spacing along the time axis, one year divided by the number of time steps. The exponential of 0.05 is 1.051271. A space step of 0.05 in the logarithm therefore puts each neighbouring node about 5.13 per cent above the one below it.

Here is the fact that gives this method its whole character, and it is not obvious. The two spacings cannot be chosen independently. A fine grid in the level and a coarse one in time cannot be chosen together to save work. Choosing the space step fixes an upper limit on the time step, and that limit falls with the square of the space step. Halving the spacing in the level drops the largest workable time step to a quarter of what it was. Four times as many rows must then be computed, and each of those rows now has twice as many nodes in it. Halving one spacing therefore costs roughly eight times the work, not twice.

The span matters as much as the spacing, and it is a choice rather than a consequence. The exponential of one is 2.718282 and the exponential of minus one is 0.367879. Twenty nodes either side of the starting level at a spacing of 0.05 therefore puts the lowest node at Rs 36.7879/- and the highest at Rs 271.8282/-. The two edges are where the grid stops. No neighbour lies beyond them to difference against, and the value there has to be stated rather than computed. The two edge conditions do exactly that, and they arrive already known from the option pricing material rather than being chosen here.

How does a derivative become arithmetic?

Back to the lamp posts. The slope at the middle post is wanted, and the height at the post either side is available. Subtracting the two and dividing by the distance walked between them gives the first derivative, replaced by arithmetic on two neighbours. The distance is two spacings rather than one. The walk ran from the post before to the post after. The stand-in uses the middle post not at all. The omission surprises people the first time they see it and is exactly right. The slope at the middle is best estimated by looking either side of it, not by looking at it.

The second derivative is curvature, and curvature is the amount by which the middle post fails to sit on the straight line joining its two neighbours. Adding the two neighbours and subtracting twice the middle gives that gap. Dividing by the square of the spacing gives the second derivative. Every derivative in the pricing equation becomes a small weighted sum of three neighbouring values, and once that substitution is made there are no derivatives left anywhere in the problem.

What is the explicit scheme, and what does it require?

Substitute both stand-ins into the pricing equation and something very clean falls out. The new value at a node is the old value at that node plus a time step multiplied by a combination of the three old values around it. Rearrange and the whole thing collapses to three numbers. An explicit schemeA scheme computing each new point directly from the previous row. computes each new value as a fixed weighted sum of the three values directly beneath it in the previous row, and the same three weights are used at every node and in every row.

Now look hard at those three weights. The entire behaviour of the method is sitting in them and nowhere else. Add them up. At a time step of 0.05, twenty steps in the year, the weights come to 0.385000, 0.197500 and 0.415000, and they sum to 0.997500. The sum is not an accident. One less the rate multiplied by the time step is a step of discounting. So when all three weights are positive, the new value is a discounted weighted average of three old ones.

The single observation about positive weights is the whole safety property. A weighted average with positive weights can never leave the range of the things being averaged. If the three values beneath a node are all somewhere between nought and Rs 176.7052/-, a positive weighted average of them is between nought and Rs 176.7052/- too. With the whole calculation started from a payoff row that is never negative and the weights kept positive, no value anywhere on the grid can ever go negative. The method is safe not because someone proved a theorem about it but because it is doing arithmetic that cannot produce a number outside the range it started in.

And now the failure mode is obvious before a single broken number has appeared. The middle weight is the only one of the three that can go negative, and it goes negative when the time step gets too big. The moment it does, the update stops being an average and becomes a subtraction, and a subtraction has no range to stay inside.

The classical condition, the one that drops the discount term, carries the names of Courant, Friedrichs and Lewy, who set it out in 1928 for wave problems long before anyone priced anything with it. The three names are worth carrying. The same condition reappears wherever an explicit scheme is used, and a reader who has met it in a physics course has already met it here.

The stability limitThe largest time step the explicit scheme tolerates, 0.062500 here. at these settings is therefore 0.062500 and sixteen steps sits exactly on it. The strict version, 0.062305 rather than 0.062500, is a detail almost everywhere. At sixteen steps the difference stops being a detail, and sixteen steps is the one setting sitting between the two. At sixteen steps the middle weight is minus 0.003125, faintly negative. Sixteen steps therefore returns Rs 10.331273/- against Rs 10.447356/- at twenty steps. The reading exactly on the classical limit is the least accurate of all the workable ones.

How to Set Up a Finite-Difference Pricing Grid

Everything above is now enough to build one from nothing, and the build is short. The worked instance is the at-the-money contract of this subject area, strike Rs 100/-, one year, on the standard process starting at Rs 100/- with a volatility of 20 per cent against a rate of 5 per cent. The closed form it is being checked against is Rs 10.450584/-, the locked figure every method in this subject area is measured against.

Two things about that build are the parts a first attempt gets wrong, and both are worth pausing on. The first is step five. The edge nodes are not computed, they are imposed, and they are imposed at every row rather than once. The strike at the top edge is discounted over the time remaining, and the time remaining grows. The top edge therefore changes as the calculation marches. Fixing the top edge once and leaving it alone puts a slow error into every row after the first.

The second is step two, and it is the one this guide exists for. Step two looks like a performance decision, the place where accuracy is traded against how long the calculation takes to run. No such trade is on offer. The limit is a hard boundary with nothing on the far side of it, and the rest of this guide is about what happens when the boundary is crossed.

What happens when the requirement is broken?

Below is what the scheme actually printed. Each figure is the number the arithmetic above returns at that number of time steps, with the space step held at 0.05 throughout, computed to six decimal places.

At ten time steps the method returns minus Rs 495.898876/- for a call option, and at eight time steps it returns minus Rs 1,456.542649/-. Ten steps is a breach of the limit by less than a factor of two: the limit is 0.062500 and ten steps uses 0.100000. Sixteen steps sits on the limit and returns Rs 10.331273/-. Ten steps, one and six tenths of the way past it, returns a negative number roughly forty seven times the size of the true price and pointing the wrong way. There is nothing between those two readings that could be called a degradation.

Read down the sign of that middle column and the point makes itself. Minus, plus, minus, plus, minus, plus. Blow-upWhat an unstable scheme does, producing numbers with no relationship to anything. flips the answer from one side of nought to the other for every single extra time step added. A quantity that changes sign when one step is added to a calculation is not converging to anything. The problem is not that the grid is too coarse, and no amount of further refinement inside the broken zone will help.

Why is there no gradual degradation?

The three weights have already said as much, but there is a sharper way to see it that costs one line of arithmetic. The grid does one particular thing to the nastiest shape it is capable of holding. On a grid of discrete nodes, the fastest thing that can be drawn is a value that flips sign at every single node: up, down, up, down. Nothing wigglier exists. There are no points in between to wiggle at.

The alternating shape fed into the update comes back in one particular way. The node below and the node above are both the opposite sign to the middle, so their contributions come back with a minus in front, and the whole thing collapses to a single number multiplying the shape that went in.

Put the numbers in. At twenty steps the multiplier is minus 0.602500, whose size is below one, so any wiggle present is cut down by about forty per cent each step and after twenty steps essentially nothing of it survives. At sixteen steps the multiplier is minus 1.003125, whose size is a whisker above one. A wiggle grows by about a third of a per cent each step and by 1.051189 across the full run, a nudge and not a catastrophe. At ten steps it is minus 2.205000, so a wiggle more than doubles at every single step, and across ten steps it is multiplied by 2,717. At eight steps the multiplier is minus 3.006250 and the run multiplies by 6,671.

The exponent is the answer to why there is no middle ground. The multiplier does not creep past one; it passes through one at a definite time step and then climbs steeply, and whatever it is gets raised to the power of the number of steps. A multiplier of 1.05 over sixteen steps is a rounding difference. A multiplier of 2.2 over ten steps is a factor in the thousands. The two settings differ by a time step of four hundredths of a year.

And the payoff hands the scheme a wiggle to work with, whether or not anybody intended it. The payoff of the at-the-money contract has a kink at the strike: flat below Rs 100/-, sloping above it. A kink is exactly the kind of shape that contains a little of the alternating component. Inside the limit that component is squashed flat within a handful of steps and never seen again. Outside the limit it is the seed, and the scheme spends every step multiplying it.

Does a finer grid in time bring the answer closer to the closed form?

Look again at the workable column and something awkward is sitting in it. Twenty steps gives Rs 10.447356/-, Rs 0.003228/- below the closed form. A thousand steps gives Rs 10.394588/-, Rs 0.055996/- below it. The thousand step answer is seventeen times further from the closed form than the twenty step answer. Refining time made it worse.

The reversal is not a contradiction and not a fault in the arithmetic. The reversal is the consequence of holding one spacing still while refining the other. There are two separate errors on this grid. One comes from the time step and shrinks as steps are added. The other comes from the space step, fixed at 0.05 throughout, and does not move at all. Refining time alone does not converge to the closed form. The refinement converges instead to the answer a space step of 0.05 can give, Rs 10.394588/-, and that answer sits Rs 0.055996/- below the closed form.

So the twenty step reading is not better. Twenty steps is luckier. Its time error happens to point the other way from its space error and the two nearly cancel, and a cancellation nobody arranged is not accuracy. If somebody chose twenty steps because it agreed best with the closed form, they would have chosen it for a reason that would not survive a change of strike, of horizon or of volatility.

Getting genuinely closer means refining the space step, and refining the space step drags the time step down with it. The tie is the one this guide opened with. Halving the space step to 0.025 cuts the residual gap from Rs 0.055996/- to about a quarter of itself, and it demands at least sixty four time steps rather than sixteen. The error in the space step falls with its square, so the reward for the extra work is real, and the work is the eightfold sort described earlier rather than the twofold sort that might have been hoped for.

What does a grid hand over that a single price does not?

Here is the practical reason somebody reaches for this method over the alternatives even when a formula exists. The other methods give a number. A grid gives a row. When the sweep reaches today it has not computed the value at the starting level; it has computed the value at all forty one levels, from Rs 36.7879/- up to Rs 271.8282/-, and it did so for the same cost.

The whole row is the thing people actually want. Someone managing a position needs the worth of the contract now, how that worth moves if the level moves, and how fast that movement itself changes. Both of those are derivatives in the level, and the row already has them: applying the same two stand-ins from earlier in this guide to the values at the three nodes around the middle makes the sensitivities fall out with no extra computation at all.

Doing exactly that on the thousand step row gives a slope of 0.637291 and a curvature of 0.018908 per rupee, against the locked closed-form figures of 0.636831 and 0.018762 for the same invented contract. The gaps are 0.000460 and 0.000146, and they are the same space-step error already identified, showing up in the sensitivities as well as in the price. A sampling method reaches those two quantities only by re-running the whole exercise at shifted levels and differencing the results. The re-run costs several times as much and comes back noisy. The row is the real product of a grid method, and the price at the middle node is only the entry in it somebody happened to ask for.

Consider a survey of a bridge deck. One measurement at the centre span gives the height at the centre span. A level run across the whole deck at fixed intervals gives the height everywhere, and it also gives the gradient and where the deck is bending, none of which the single measurement could have given at any price. The grid is the level run.

Where does this method stop being usable?

The method stops when the problem carries more than one or two uncertain quantities, and it stops abruptly. The grid in this guide holds 41 nodes across one level. Add a second uncertain quantity, a variance that moves for instance, and the grid becomes 41 by 41, or 1,681 points per row. A third quantity makes it 68,921. A fourth makes it 28,25,761, and that is before a single time step has been taken.

The counting is the whole argument. Every additional quantity multiplies the number of points by 41 rather than adding 41 to it. Work that is comfortable at one quantity is heavy at three and impossible at five. Each extra quantity multiplies again, and no amount of faster hardware changes the shape of that growth. A sampling method faces nothing of the kind: adding a quantity to a sampled path costs one more number per path per step, so its cost rises roughly in proportion rather than by repeated multiplication. A grid loses decisively to sampling here, and it loses on counting rather than on cleverness.

The everyday version is a stock check. Counting one shelf of tins is a minute of work. Counting a shelf by size gives ten counts. Counting by size, by flavour and by expiry month gives every combination of the three, and a fourth split turns a job that could be done before lunch into one nobody will finish. Nothing got harder to count. The categories multiply, and there is simply vastly more of it.

What is it, and what is it not?

A finite difference method is a way of turning an equation into arithmetic on a mesh, and of solving that arithmetic backwards from a known payoff. The method hands back a whole row of values rather than one, and the sensitivities in the level come out of that row for nothing. The method carries a hard requirement tying its two spacings together, and the requirement is a boundary rather than a preference.

A grid method is not an averaging method, and calling it one gets the intuition wrong from the first step. The method is not a way of avoiding the pricing equation. The method is a way of solving that equation when the solution cannot be written down. The method is not robust to a coarse setting in the way sampling is. Sampling coarsely gives a noisy answer, and gridding coarsely gives no answer at all. And it is not the only scheme available: the explicit scheme used here is the one whose behaviour is easiest to see, and other schemes trade the arithmetic per step against the freedom to choose the two spacings separately. The other schemes belong with the treatment of numerical error and stability rather than here.