Discretisation: Turning a Continuous Model Into Computable Steps
Discretising replaces a continuous equation with a finite number of steps, holding the drift and the diffusion fixed across each one at the values they had when the step began. Holding both fixed across a step is exactly the assumption the Ito integral was built on. The error this makes shrinks as the steps shorten, but the shrinking is a statement about many paths, and on any single path it need not improve at every refinement.
A machine cannot take a limit. A machine can add, multiply and loop, and that is the whole of its vocabulary. Every continuous model that has ever been run on a computer has therefore been run in translation, and discretisationReplacing a continuous equation with a finite number of steps, so that a machine that can only add and multiply has something it can actually run. is the name of that translation. One equation is translated below in the plainest possible way, and the error that translation makes is worked out in rupees. The error turns out to be the interesting part, and not for the reason most readers expect.
Everything here runs on the same invented worked instance the rest of this reading order uses. The standard processThe single invented traded quantity used throughout this reading order, starting at Rs 100/-, with a drift of 8 per cent and a volatility of 20 per cent a year, over a one year horizon., written S with a time subscript, starts at Rs 100/-, drifts at 8 per cent a year and carries a volatility of 20 per cent a year over a horizon of one year. The process is stepped along the locked path, the twelve step path of driving values published for this reading order and reused unchanged wherever such a path is drawn. Because the exact answer is available in closed form here, every error in this guide is a computed number rather than an estimate, and each one can be checked directly.
What does discretising an equation actually do?
The everyday version comes first. The question is how far a walk along a winding riverbank ran. The curve itself cannot be measured, so it is paced out: a marker is planted, the walk continues to the next marker, the straight line distance is written down, and the straight lines are added up. Between markers the bank has been assumed straight. The bank is not straight. Moving the markers closer together makes the assumption less wrong. Pacing a curve out in straight lines is the entire idea, and it is old enough to have no author.
The equation is doing the same thing in time rather than in space. The equation says how the process changes over an instant: a drift piece proportional to the length of the instant, and a diffusion piece proportional to the Brownian increment over that instant. An instant is not something a machine can loop over. So markers are planted in time, and across each interval between markers the drift and the diffusion are held constant. Both coefficients depend on the level, and the level moves during the step, so between markers the assumption is wrong. Moving the markers closer makes the assumption less wrong.
| \(S_t\) | the standard process at time \(t\), an invented traded quantity starting at Rs 100/- |
| \(\mu\) | the drift, 0.08 a year on the standard process |
| \(\sigma\) | the volatility, 0.20 a year on the standard process |
| \(W_t\) | standard Brownian motion under the physical measure P |
| \(T\) | the horizon, one year throughout |
| \(dt,\;dW_t\) | the elapsed time and the Brownian increment over an instant |
The form on the right matters more than it looks. The differential form is shorthand. The integral form is the actual statement, and the second integral in it is an Ito integral, itself built as the limit of a sum over a grid. Everything below turns on that fact. The quantity to be computed was defined as the limit of exactly the kind of sum a machine can compute. So the translation is not a new idea imposed from outside. The translation is the definition itself, stopped one move early.
Two consequences follow immediately, and both are worth naming before the arithmetic starts. First, a schemeThe rule saying how each step is taken: what is read, what it is multiplied by, and what is added to the running level. is a choice, not a fact. Nothing forces the coefficients to be held constant across a step; that is one decision among many, and the fact that this one is the plainest available is the only reason it is here. Second, this particular choice matches the way the integral was defined, so the scheme is approximating the object the equation actually names, rather than some cousin of it. A scheme built on a different reading point would converge to a different quantity, and would be silently answering a different question.
What does the simplest scheme hold fixed across each step?
What exactly is the simplest scheme, and what does it assume?
The scheme is one line. Standing on a level, it adds the drift coefficient at that level multiplied by the length of the step, and adds the diffusion coefficient at that level multiplied by the Brownian increment across the step. The sum is the new level, and the scheme stands on it and does the same thing again. Nothing is solved, nothing is inverted, and no equation is rearranged. The whole step is arithmetic a patient person could do with a pen.
| \(\hat{S}_{t_i}\) | the scheme's level at the start of step \(i\), carrying a hat to separate it from the exact \(S_{t_i}\) |
| \(n\) | the number of steps the horizon is cut into |
| \(\Delta t\) | the step length, being the horizon divided by \(n\) |
| \(\Delta W_i\) | the Brownian increment across step \(i\), taken from the locked path and never redrawn |
| \(\mu,\;\sigma\) | the drift and volatility, 0.08 and 0.20 a year on the standard process |
Look at where the hats sit. Both coefficients are evaluated at the level with the subscript i, the level at the start of the step. Neither is evaluated at the end, neither at the midpoint, and neither at any average of the two. The start-of-step valuesReading the coefficients before the step happens, using only what was known when the step began, which is the evaluation point the Ito integral is built on. are the single assumption the scheme makes, and every rupee of error below traces back to them. The true process does not hold still while the step runs. Its level moves continuously, so the drift coefficient and the diffusion coefficient both move continuously, and the scheme pretends neither did.
Here is the very first step of the locked path at its finest setting, worked in full so there is no mystery in the loop. The step length is one twelfth of a year. The starting level is Rs 100/-. The drift piece is Rs 100/- multiplied by 0.08 multiplied by one twelfth, or Rs 0.666667/-. The Brownian increment for the first step is the first driving value of minus 0.5 multiplied by the square root of one twelfth, or 0.288675, giving minus 0.144338. The diffusion piece is Rs 100/- multiplied by 0.20 multiplied by that increment, or minus Rs 2.886751/-. Add all three and the scheme stands on Rs 97.779915/- at the end of month one.
The first step build carries a lesson beyond bookkeeping. Over a step of one month the drift piece is worth two thirds of a rupee and the diffusion piece is worth nearly three. The drift piece shrinks in proportion to the step. The diffusion piece shrinks only in proportion to the square root of the step, so over short steps the random piece is far larger than the deterministic one. Halve the step and the drift piece halves while the diffusion piece falls to about seventy one per cent. Keep halving and the gap widens without bound. Everything difficult about stepping these equations comes from that mismatch of orders.
Where in each step does the simplest scheme read the drift and the diffusion?
Why must the coefficients be read at the start and nowhere else?
Because that is where the Ito integral reads them, and reading them anywhere else answers a different question. The evaluation point is the one choice here that is not a matter of taste.
Recall what the Ito integral did. The Ito integral approximated an integral by a sum in which the integrand was evaluated at the left end of each interval, and only then sent the intervals to zero. The left end is the only point in an interval whose value is known before that interval happens. An integrand that peeks at the end of its own step is using information that had not arrived, and the whole apparatus of the filtration exists to forbid exactly that. The scheme inherits the choice unchanged.
| \(\hat{S}_{t_i}\) | the scheme's level, read before step \(i\) is taken |
| \(\Delta W_i\) | the Brownian increment across step \(i\), which is not known when \(\hat{S}_{t_i}\) is read |
| \(n\) | the number of steps, which is what is sent upward to take the limit |
| \(\int_0^T\) | accumulation from the start of the year to the horizon |
There is an everyday version of this too. A lift only knows which floor it is standing on. The lift decides whether to go up before it has moved, using what it knows at the moment of the decision, and it cannot use where it will end up to decide where to go. Reading the coefficients at the end of the step builds a lift that consults its own destination. The arithmetic still produces numbers, and the numbers still converge, but they converge to a different quantity, one that no longer has the property the whole subject was built to preserve.
How large is the error on a path that can be checked?
Now the useful part. Because a strong solution exists here in closed form, the exact level at the horizon is available as a formula rather than as another approximation. The closed form makes the discretisation errorThe gap between the scheme's answer and the exact one, available as a computed number here because the exact answer is known in closed form. a computed number to as many decimals as are wanted, and not an estimate of an estimate.
| \(S_T\) | the exact solutionThe formula the scheme is approximating. It is available here in closed form, which is what makes the error a computed number rather than a guess. at the horizon |
| \(\mu-\tfrac12\sigma^2\) | 0.06 exactly on the standard process, being 0.08 less half of 0.04 |
| \(W_T\) | the Brownian level at the horizon, which is 0.000000 on the locked path by construction |
| \(\hat{S}^{(n)}_{T}\) | the level the scheme reaches at the horizon after \(n\) steps |
| \(e_n\) | the signed error at \(n\) steps, positive when the scheme finishes above the exact level |
On the locked path the twelve driving values sum to zero exactly, so the Brownian level at the horizon is nil and the exact answer is Rs 100/- multiplied by the exponential of 0.06, or Rs 106.183655/-. Every reading below is measured against that figure. The exact solution does not know or care how the stepping was chosen, so the same figure stands whatever grid the scheme runs on.
The scheme is about to be run at twelve steps along the locked path. How large is the error likely to be?
The whole spine of the argument sits in one table. The same locked driving values are used at every setting, so nothing changes between rows except how the year is cut. At one step the whole year is one piece and the increment is the sum of all twelve driving values. At two steps each piece is six of them, at three steps four of them, and so on down to twelve steps where each piece is a single driving value.
| Steps | Step length | Where the scheme finishes | Signed error | Against the previous setting |
|---|---|---|---|---|
| 1 | one year | Rs 108.000000/- | plus Rs 1.816345/- | no previous setting |
| 2 | six months | Rs 107.596667/- | plus Rs 1.413012/- | smaller |
| 3 | four months | Rs 108.150785/- | plus Rs 1.967130/- | larger, and this is the point |
| 4 | three months | Rs 105.299068/- | less Rs 0.884587/- | smaller, and the sign has flipped |
| 6 | two months | Rs 106.132004/- | less Rs 0.051651/- | smaller |
| 12 | one month | Rs 106.184491/- | plus Rs 0.000836/- | smaller, and the sign has flipped again |
The column of errors does not do what most readers expect, and it repays slow reading. Plus Rs 1.816345/-, then plus Rs 1.413012/-, then plus Rs 1.967130/-. Going from two steps to three made the error worse, from plus Rs 1.413012/- to plus Rs 1.967130/-, and that is not a mistake in the arithmetic but a genuine property of what happens on one path. Then the error crosses zero, landing at less Rs 0.884587/- at four steps. The error shrinks to less Rs 0.051651/- at six. And then it crosses zero a second time, finishing at plus Rs 0.000836/- at twelve.
So the sequence of signs runs plus, plus, plus, minus, minus, plus. There are two crossings, not one. The magnitudes are better behaved than the signs: from three steps onward the size of the error falls at every single refinement, 1.967130 to 0.884587 to 0.051651 to 0.000836. But between one step and three there is no order at all, and a reader who was told that refining helps has just watched it not help.
Between which two settings does the error first change sign?
The control below is about to move from two steps to three. Before it moves: does the error get smaller?
Refine the grid and watch whether it actually helped
The driving values never change. Only the number of steps does. The grey line is the exact solution, the dark line is the scheme, and the faint dashed line is the setting one notch coarser, showing whether the refinement helped or hurt. The dial underneath shows all six errors at once with the current one filled in.
Why is a single path's error not monotone in the number of steps?
Because the error is not a single quantity that gets whittled down. The error is a total made of many separate mistakes, one per step, and those mistakes carry signs. Refining the grid does two things at once. Shorter steps make each individual mistake smaller, and smaller mistakes help. Shorter steps also make more mistakes and rearrange which ones sit next to which, changing how they cancel. On a single path the cancellation is arbitrary, and there is nothing stopping a finer grid from happening to cancel less well than the coarse one it replaced.
Look at what actually happens between two steps and three on the locked path. At two steps the year is cut in half, and the first half of the driving values sums to plus 1.3 while the second half sums to minus 1.3. The scheme rises hard, then falls hard, and the two large moves partly undo each other. At three steps the year is cut into thirds and the driving values regroup entirely: the first four sum to minus 0.3, the middle four to minus 0.2 and the last four to plus 0.5. Different groupings, different products, different cancellation. The scheme happens to finish further from the exact answer than it did before. Nothing went wrong; the arithmetic simply landed differently.
The everyday version is a weighing scale that reads to the nearest gram. A sack weighed in one go is wrong by up to half a gram. Weighed in three parts and added, each part is wrong by up to half a gram, so the total could be wrong by up to one and a half. The total could also be wrong by nothing at all, if the three roundings happen to cancel. More readings means smaller individual mistakes and more chances for them to line up badly. Which of the two wins on any one sack is not something the sack will reveal.
The zoom ladder makes one more point that is easy to miss. At twelve steps the scheme misses by Rs 0.000836/-, roughly one part in a hundred and twenty seven thousand, and it takes a magnification of about fourteen hundred times before the miss is even visible beside the numbers from the coarse settings. The refinement is doing real work. The refinement is just doing that work underneath a layer of sign changes that make the sequence look untidy.
What does convergence actually mean here?
ConvergenceThe error shrinking as the steps shorten, stated as a property measured across all paths at once rather than on any single one. is not a promise about any one path. Convergence is a statement about a quantity that averages over every path the process could have taken. Once that quantity is identified, the whole apparent contradiction in this guide dissolves.
The usual measurement is the root mean square of the error: square the gap between the scheme and the exact solution at the horizon, average that square over all paths, and take the square root. The root mean square has a closed form for this scheme on this equation. Computed exactly rather than sampled, the numbers below are as checkable as everything else here.
| \(\varepsilon_n\) | the root mean square error at \(n\) steps, measured across every path at once |
| \(\mathbb{E}[\cdot]\) | expectation under the physical measure P, being the average over all paths |
| \(\hat{S}^{(n)}_{T}\) | where the scheme finishes at \(n\) steps, now treated as a random quantity rather than one number |
| \(S_T\) | where the exact solution finishes on the same driving randomness |
| \(\Delta t\) | the step length, being one over \(n\) here |
The table below sets out that quantity at the same six settings, beside the one path this guide has been following. Both columns are in rupees, and both are magnitudes, so they are directly comparable.
| Steps | Size of the error on the locked path | Root mean square error, all paths | Did the refinement help? |
|---|---|---|---|
| 1 | Rs 1.816345/- | Rs 3.520975/- | no previous setting |
| 2 | Rs 1.413012/- | Rs 2.371961/- | both fell |
| 3 | Rs 1.967130/- | Rs 1.897412/- | one path rose, all paths fell |
| 4 | Rs 0.884587/- | Rs 1.624777/- | both fell |
| 6 | Rs 0.051651/- | Rs 1.310730/- | both fell |
| 12 | Rs 0.000836/- | Rs 0.914943/- | both fell |
The right hand column falls at every single refinement, without exception and without a single reversal, while the left hand column rose at three steps. The difference between the two columns is the whole resolution. Convergence lives in the right hand column. The left hand column is one draw, and one draw is permitted to do anything it likes as long as the average of the squares behaves.
Two further readings are worth taking from that table. The first is that the root mean square error falls slowly. Going from one step to twelve, a twelvefold increase in work, cuts it from Rs 3.520975/- to Rs 0.914943/-, a factor of under four. Each halving of the step length multiplies it by about 0.6737, then 0.6850, then 0.6908, then 0.6980, a sequence creeping toward 0.7071, one over the square root of two. A creep toward that ratio is the signature of a method whose error falls like the square root of the step length, and it is why this scheme is cheap per step and expensive per decimal place.
The second reading is stranger and worth holding on to. At six steps the locked path had an error of Rs 0.051651/-. The root mean square across all paths at six steps was Rs 1.310730/-. The locked path was more than twenty five times better than typical. The gap is not a sign that six steps is a good setting. The gap is a sign that this particular path, on this particular grid, got lucky.
Convergence is a statement about what?
The error that gets made, and what it costs
Choosing a step length by running one path, refining it once or twice, and stopping when the error looks small enough. Stopping when the error looks small enough is the most natural test imaginable, and it is the wrong test. The quantity it measures is not the quantity that has the property being tested.
The locked path settles it without any argument. A tester who ran two steps and then three would see the error grow from plus Rs 1.413012/- to plus Rs 1.967130/-, would conclude that refining this model makes it worse, and would stop at two steps. A different tester who happened to try six steps would see an error of Rs 0.051651/- against a level of Rs 106/-, would conclude the scheme is excellent at two month steps, and would also stop. Both readings are correct. Both conclusions are wrong. At six steps the root mean square error across all paths is Rs 1.310730/-, so the second tester was reading a fluke that was more than twenty five times better than typical, on a setting that is about to cross zero.
The cost is a step length chosen on one draw that will not hold on the next, and it lands quietly. The test that produced the number looked exactly like a convergence check, so there is no error message, no failed check and no warning. The only defence is to notice that a non-monotoneNot improving at every refinement. A single path's error is not monotone in the number of steps, even though the error across all paths is. reading on one path is evidence of nothing at all, in either direction, and to measure the thing the property is actually about.
A tester compares two steps and three on one path, sees the error grow, and concludes refining hurts. What went wrong?
How is a step length actually chosen?
Two things decide it, and testing one path is neither of them.
The first is how much error the use can carry. A quantity read to the nearest rupee tolerates an error a thousand times larger than one read to six decimal places, and the tolerance is set by the use the answer is put to, not by the equation. Write the tolerance down before running anything, in the units of the answer, and it becomes a target rather than a feeling. Without it, "small enough" means whatever the first plausible number happened to be.
The second is how much computing time is available. Cost rises in proportion to the number of steps. The root mean square error falls only in proportion to the square root of the step length. Put together, buying one extra decimal place of accuracy costs a hundredfold increase in work. The exchange rate is brutal, and it is the honest reason schemes better than this one exist at all, a subject covered separately.
Between the two the result is a range rather than a number, and the working rule is to take the coarsest step lengthHow much time one step covers. Shortening it lowers the error across many paths and raises the cost in proportion to the number of steps. whose error across many paths sits inside the tolerance, with a margin. Then check the margin by refining once more and confirming that the measured error across many paths fell in the way the square root rule predicted. If it did not, something else is wrong, and that is a real signal rather than a coincidence of cancellation on one draw.
What two things actually decide the step length?
How does somebody checking a computation rather than building one use this?
A checker asks three questions, and none of them requires reading the code. The first is what the step length was and why that number. If the answer is a round figure with no tolerance behind it, the choice was made by habit rather than by requirement, and the answer may be fine but nobody knows whether it is. The second is how many paths the accuracy claim rests on. If it rests on one, the claim is not about accuracy, and the locked path above shows exactly how that goes wrong. The third is whether refining once more moved the answer, and by how much, measured across the same many paths rather than the same one path.
There is a version of this outside any computation at all. Somebody claims a bathroom scale is accurate because they weighed one object on it twice and got nearly the same number. Weighing one object twice is a repeatability check, not an accuracy check, and the two are unrelated: a scale that reads three kilograms heavy will pass it perfectly every time. A one path refinement test has the same shape. The test is checking something, quite carefully, and the thing it is checking is not the thing being claimed.
The practical habit worth keeping is to treat any single path reading as a story and any across-paths reading as evidence, and to notice which one a claim is standing on. The single path above told a story in which refining hurt, then helped, then flipped sign, then flipped again. The across-paths reading told a plain, dull, monotone story of an error falling from Rs 3.520975/- to Rs 0.914943/-. The dull one is the one that generalises.
Does any of this depend on jurisdiction?
No. No authority anywhere sets the form of an equation, no convention alters what a limit over refining grids equals, and no jurisdiction has a view on how many steps a computation should take. The scheme works identically everywhere and belongs to nowhere.
The worked instance is a construction. The standard process, its four parameters and the locked path are all built illustrations rather than observations. The parameters were chosen so that the arithmetic reconciles to figures a reader can check: the twelve driving values sum to zero exactly, the exact solution at the horizon is Rs 100/- multiplied by the exponential of 0.06, and every error quoted here is that solution subtracted from a number reproducible with a pen and enough patience.
References
| Source | Document | Where |
|---|---|---|
| arXiv Quantitative Finance | Preprint repository for discretisation schemes for stochastic differential equations and their convergence orders | arxiv.org |
| Social Science Research Network | Working paper repository for the same material | ssrn.com |
| Ito | The integral whose construction this scheme stops one move short of, and the source of the start-of-step evaluation point | named in the text only |
| Hull, Shreve and Wilmott | Standard texts on stochastic calculus and its numerical schemes | named in the text only |
The standard process and the locked path are invented.
Educational material. Not advice on any investment, tax, budget or market position.
