The Binomial Model: Pricing in Discrete Steps

The lattice prices a contract by working backward from the horizon. Value the payoff at every finishing level, then step back one period at a time, replacing each pair of later values with their weighted average discounted by one period, until a single number stands at today. The lattice is slower than the closed form, and it survives because every step is arithmetic a reader can check by hand.

Everything in this guide runs on the same worked instance the rest of this subject area uses. The standard process starts at Rs 100/-, carries a volatility of 20 per cent a year and sits in a world with one rate of 5 per cent a year, continuously compounded, over a horizon of one year. The contract is the at-the-money one, struck at Rs 100/-. Its payoff arrives already known and is used here only as the function being valued. What the contract pays is set out under the payoff function.

The closed form for that contract is Rs 10.450584/-. The closed form price is worth keeping in view. The lattice produces a sequence of answers that walks toward it in a way almost nobody predicts correctly the first time. The lattice does not creep up on the true price from one side; it overshoots, undershoots, and crosses back and forth, and the crossings are not noise but a consequence of where a fixed strike sits on a moving grid.

What does the lattice actually do?

A binomial latticeA grid of possible levels for a process, built by letting each level move to exactly one of two new levels over each period. replaces a process that can take any value at any instant with a process that can do exactly two things over each period: multiply by an up factor, or multiply by a down factor. Nothing else is allowed to happen. Over the whole horizon that produces a grid of reachable levels, and the contract is valued only at the points of that grid.

Here is the everyday version, and it carries the entire argument. A wall is to be measured and the only instrument to hand is a metre stick. The stick is laid down repeatedly and the lengths counted. The answer is not the wall; it is the number of stick lengths that fit, and everything between the last mark and the wall is invisible. A shorter stick improves the answer. But the improvement does not arrive smoothly. Whether the last mark lands on the wall or just short of it depends on the stick, not on the wall. Hold that thought. The lattice behaves in exactly that way.

Each point on the grid is a nodeOne point on the lattice, fixed by a time and a level. Every node carries a level for the process and, after the backward pass, a value for the contract., and each node carries two things: a level for the standard process, and a value for the contract at that level and that time. The levels are fixed the moment the factors are chosen. The backward pass then fills in the values.

The one construction choice that makes any of this workable is that the down factor is the reciprocal of the up factor. The reciprocal makes the tree recombiningUp then down landing on exactly the same level as down then up, so the two orderings share one node instead of needing two.. An up move followed by a down move multiplies the level by the up factor and then by its reciprocal, returning it to where it started. A down move followed by an up move does the same. The two orderings land on one node instead of two.

The consequence is a change of scale rather than a convenience. Without recombination, a lattice of fifty periods would have one endpoint for every distinct ordering of ups and downs, two raised to the fiftieth power, a count above a thousand million million. With recombination only the number of ups survives, not the order they happened in, so the lattice has fifty one finishing levels. The tree grows with the square of the step count rather than doubling at each step, and that single fact is what makes the method computable at all. At fifty steps the whole grid holds 1,326 nodes.

Because the down factor is the reciprocal of the up factor, an up move followed by a down move lands on exactly the same level as a down move followed by an up move, which collapses an unmanageable count of orderings into fifty one finishing levels at fifty steps.

The level at any node of the grid

$$ S_{i,j} \;=\; S_0\,u^{\,j}\,d^{\,i-j} \;=\; S_0\,u^{\,2j-i}, \qquad j=0,1,\dots,i $$

$S_{i,j}$	the level of the standard process after $i$ periods, at the node reached by $j$ up moves
$S_0$	the starting level of the standard process, Rs 100/- throughout this guide
$u,\ d$	the up factor and the down factor, with $d=1/u$ by construction
$i,\ j$	the period counted from today, and the number of up moves within it

What it says in wordsThe level at a node depends only on how many up moves happened and how many down moves, not on the order they came in, because the two factors are reciprocals and cancel in pairs. That is why the second form has a single exponent in it, and why a grid of $i$ periods carries only $i+1$ levels rather than one for every route through it.

Try it out

A fifty step tree on the standard process. How many finishing levels does it carry?

How to Set Up a Binomial Pricing Model: what are the five lines?

The whole specification is five lines and each one is a formula that can be evaluated on paper. There is nothing hidden behind them, no calibration, no fitting and no judgement. The five lines take a volatility, a rate, a horizon and a step countHow many equal periods the horizon is divided into. The count is a choice made by whoever runs the model, not a property of anything being modelled., and the answer is determined.

The stepDivide the horizon by the number of steps. One year over twelve steps gives a step of one twelfth of a year.
The up factorRaise the constant e to the volatility multiplied by the square root of the step. At twelve steps that is 1.059434.
The down factorTake one over the up factor. At twelve steps that is 0.943900. This is what makes the grid recombine.
The weightTake one period of growth on cash, subtract the down factor, and divide by the spread between the two factors. At twelve steps that is 0.521710.
The backward ruleValue the payoff at every finishing node, then set every earlier node to the discounted weighted average of the two nodes that follow it.

Notice what is not in the list: the drift of the standard process appears nowhere. The 8 per cent that the process carries under the physical measure P has no role in any of the five lines. The weight is built from the rate and the two factors alone, and that construction is the risk-neutral measure Q arriving in the only form a lattice can carry it. The result is settled under physical and risk-neutral measures and is used here rather than argued again.

The whole model is five evaluable lines, and the drift of the standard process appears in none of them, which is where the risk-neutral measure enters a lattice.

Try it out

Where does the up factor come from?

Where do the up and down factors come from?

The up factorThe multiple the level takes on an up move. The factor is built from the volatility and the length of the step, and from nothing else. is not a guess and it is not free. The factor is chosen so that the discrete grid carries the same amount of variation per unit of time as the continuous process it stands in for. The logarithm of the level moves by plus or minus the volatility times the square root of the step. The variance of the logarithmic move over one step is then the variance rate times the step, exactly what the continuous process delivers.

The variance match is the whole derivation, and it explains the square root. Variation accumulates with time, so the standard deviation of the move accumulates with the square root of time. Halve the step and the move shrinks by a factor of the square root of two, not by half. At one step the logarithmic move is 0.200000. At four steps it is 0.100000. At twenty five steps it is 0.040000. At two hundred steps it is 0.014142. The grid gets finer in level as well as in time, and it does so at a slower rate in level. The square root law has become geometry.

The two factors, and the variance they are built to match

$$ u=e^{\sigma\sqrt{\Delta t}},\qquad d=e^{-\sigma\sqrt{\Delta t}}=\frac{1}{u},\qquad \Delta t=\frac{T}{n} $$ $$ \operatorname{Var}\!\bigl[\ln(S_{i+1}/S_i)\bigr]\;=\;\bigl(\sigma\sqrt{\Delta t}\bigr)^{2}\cdot 4q(1-q)\;\longrightarrow\;\sigma^{2}\Delta t $$

$\sigma$	the volatility of the standard process, 20 per cent a year throughout this guide
$\Delta t$	the length of one step, the horizon divided by the number of steps
$T$	the horizon, one year throughout
$n$	the number of steps the horizon is divided into, a choice rather than a property
$q$	the weight attached to an up move, which tends to one half as the step shrinks

What it says in wordsThe up factor is fixed by requiring that one step of the grid carries the same variation as one step of the continuous process, which puts the volatility multiplied by the square root of the step in the exponent. Making the down factor the reciprocal is a separate choice, taken so that the grid recombines, and it costs nothing because the drift is carried by the weight rather than by the factors.

What happens on the backward pass?

Backward inductionWorking from the horizon toward today, replacing each node with a value computed from the two nodes that follow it, until one number stands at the start. is the part people expect to be complicated and it is not. At the horizon the value of the contract is the payoff, handed over here rather than derived. One period before the horizon, every node has exactly two successors. Take those two values, weight them, average them, discount them by one period, and write the result on the node. Then do it again. The lattice is that single move repeated, and it introduces no idea that was not already settled in the one step pricing argument.

Follow it right through at two steps, where the arithmetic fits on one line each. The step is half a year, so the up factor is 1.151910, the down factor is 0.868123 and the weight is 0.553908. The three finishing levels are Rs 132.689644/-, Rs 100.000000/- and Rs 75.363832/-, and the payoffs on them are Rs 32.689644/-, nothing and nothing.

Step back one period. The upper node at Rs 115.190991/- takes 0.553908 of Rs 32.689644/- and 0.446092 of nothing, giving Rs 18.107490/-. Discounting that by half a year at 5 per cent gives Rs 17.660000/-. The lower node at Rs 86.812345/- has nothing after it in either direction, so it is worth nothing. Step back once more. 0.553908 of Rs 17.660000/- plus 0.446092 of nothing is Rs 9.782010/-, and discounting gives Rs 9.540501/-, the two step lattice price of the at-the-money contract. The lattice price sits Rs 0.910083/- below the closed form.

Every arrow on the backward pass performs one operation, a weighted average of the two later values discounted by one period, and the two step lattice reaches Rs 9.540501/- after only three such operations.

The backward rule, which is the whole of the pricing

$$ V_{i,j} \;=\; e^{-r\Delta t}\Bigl[\,q\,V_{i+1,\,j+1} \;+\; (1-q)\,V_{i+1,\,j}\,\Bigr], \qquad q=\frac{e^{r\Delta t}-d}{u-d} $$

$V_{i,j}$	the value written on the node after $i$ periods reached by $j$ up moves
$q$	the weight on the up move, 0.553908 at two steps and 0.521710 at twelve
$r$	the one rate in this world, 5 per cent a year, continuously compounded
$e^{-r\Delta t}$	one period of discounting, 0.975310 at two steps and 0.995842 at twelve

What it says in wordsThe value at a node is the two values that follow it, weighted, added and pulled back by one period of interest. That is the entire pricing operation, and running it once for every node from the horizon backward is the entire model. Nothing new is introduced at any node; the same three arithmetic moves are repeated until one number remains.

Because the same rule runs at every node and nothing at a node depends on the route taken to reach it, the entire backward pass can be collapsed into a single sum over the finishing levels. Each finishing level gets the weight of the number of routes that reach it, multiplied by the weight of each route, and the payoff there is multiplied by that total. The sum is the same calculation written the other way round, and it lands on exactly the same number: Rs 9.540501/- at two steps, Rs 10.285850/- at twelve and Rs 10.520966/- at twenty five. The backward pass is the version that can be checked by hand; the sum is the version that shows what is being averaged.

The backward pass collapsed into one sum

$$ V_{0,0} \;=\; e^{-rT}\sum_{j=0}^{n}\binom{n}{j}\,q^{\,j}(1-q)^{\,n-j}\,\max\!\bigl(S_0u^{\,j}d^{\,n-j}-K,\;0\bigr) $$

$\binom{n}{j}$	the number of routes through the grid that arrive with exactly $j$ up moves
$K$	the strike of the contract being valued, Rs 100/- throughout this guide
$e^{-rT}$	discounting over the whole horizon at once, 0.951229 for one year at 5 per cent
$n$	the number of steps, so that $n+1$ finishing levels carry the whole sum

What it says in wordsEvery finishing level carries a weight made of two parts, how many routes reach it and how likely each route is under the weight the model uses, and the price is the weighted average of the payoffs discounted once over the whole horizon. Running the backward pass node by node and evaluating this sum are the same arithmetic in two arrangements, and they agree to every decimal place at every step count.

Try it out

What happens at each node of the backward pass?

How does the answer behave as steps are added?

Try it out

One step gives Rs 12.162285/- and two gives Rs 9.540501/-. Before reading on: does three land between them?

Here are ten readings on the same contract, the same process and the same four parameters, differing only in how many steps the horizon is cut into. Every one is computed from the lattice and none is sampled. The sign is where the surprise lives, so read the signed error column rather than the price column.

Steps	Up factor	Weight	Lattice price	Signed error	Side
1	1.221403	0.577493	12.162285	plus 1.711701	above
2	1.151910	0.553908	9.540501	minus 0.910083	below
3	1.122401	0.543777	11.043871	plus 0.593287	above
4	1.105171	0.537808	9.970523	minus 0.480061	below
8	1.073271	0.526625	10.205099	minus 0.245485	below
12	1.059434	0.521710	10.285850	minus 0.164734	below
25	1.040811	0.515020	10.520966	plus 0.070382	above
50	1.028688	0.510614	10.410692	minus 0.039892	below
100	1.020201	0.507502	10.430612	minus 0.019972	below
200	1.014243	0.505304	10.440591	minus 0.009993	below
closed form			10.450584	nil

The first four readings are the striking ones. One step is Rs 1.711701/- too high. Two steps is Rs 0.910083/- too low. Three steps is Rs 0.593287/- too high again. Four steps is Rs 0.480061/- too low again. The sign flips on every one of the first four counts, and the size roughly halves each time. Nobody looking at the first two readings alone would predict that three steps lands above both of them, and yet it does, at Rs 11.043871/-.

The tail is quieter but the pattern has not gone away. Twenty five steps overshoots. Fifty, a hundred and two hundred all undershoot, and each of them closes about half the remaining distance: Rs 0.039892/- below, then Rs 0.019972/- below, then Rs 0.009993/- below. Doubling the step count buys roughly one halving of the error, a slow and honest rate. The rate is slow enough that going from fifty steps to a hundred and to two hundred is worth doing and still falls short.

At every magnification the readings sit on both sides of the closed form rather than climbing toward it, and the third panel shows that even by two hundred steps the answer is still approaching from below with about half the previous gap left.

What the limit says, and what it does not say

$$ \lim_{n\to\infty} V^{(n)}_{0,0} \;=\; C_{\mathrm{BS}}, \qquad V^{(n)}_{0,0}-C_{\mathrm{BS}} \;=\; \frac{a(n)}{n} + O\!\left(\frac{1}{n^{2}}\right) $$

$V^{(n)}_{0,0}$	the lattice price at today, computed with $n$ steps
$C_{\mathrm{BS}}$	the closed form price, Rs 10.450584/- for the at-the-money contract here
$a(n)$	a bounded quantity that does not settle down, and whose sign changes with $n$
$O(1/n^{2})$	a remainder that shrinks faster than the leading term and can be ignored for large $n$

What it says in wordsThe lattice price does converge to the closed form, and the size of the error shrinks in proportion to one over the step count, which is why doubling the steps roughly halves the gap. But the leading coefficient is not a constant: it keeps changing as steps are added, and it changes sign. So the limit statement is true and the natural reading of it, that each extra step moves the answer a little nearer from the same side, is false.

Try it out

Twelve steps gives Rs 10.285850/-, below the true Rs 10.450584/-. Before the control moves: is twenty five steps closer, and on which side?

Play with it

Add steps and watch the answer cross the true price

The control moves through the ten step counts. The upper chart carries all ten readings and highlights the one currently selected, with a bar running from it to the closed form so the sign of the error is visible rather than inferred. The lower strip is the mechanism: it draws the finishing levels nearest to Rs 100/- for the count chosen, against the fixed strike. Where the strike lands shifts as the count changes. The default is twelve steps, undershooting at Rs 10.285850/-.

1 step12 steps200 steps

Steps

Lattice price

10.285850

Signed error

minus 0.164734

Finishing levels

At twelve steps the lattice gives Rs 10.285850/-, which is Rs 0.164734/- below the closed form of Rs 10.450584/-, and the strike sits exactly on a finishing level because the step count is even.

Educational illustration. Strike Rs 100/-, rate 5 per cent, volatility 20 per cent, one year, and only the step count moves. Every reading is computed from the lattice itself and never sampled, so the same control position always gives the same number. The ten readings with their signed errors, in order: 1 step Rs 12.162285/- plus 1.711701; 2 steps Rs 9.540501/- minus 0.910083; 3 steps Rs 11.043871/- plus 0.593287; 4 steps Rs 9.970523/- minus 0.480061; 8 steps Rs 10.205099/- minus 0.245485; 12 steps Rs 10.285850/- minus 0.164734; 25 steps Rs 10.520966/- plus 0.070382; 50 steps Rs 10.410692/- minus 0.039892; 100 steps Rs 10.430612/- minus 0.019972; 200 steps Rs 10.440591/- minus 0.009993.

Derivatives Foundation Bootcamp — Fin Maverick

Cleaning Financial Data — free micro-course from Fin Maverick

Why does it oscillate rather than settle?

The cause is not subtle once seen, and it is not a defect in the arithmetic. The payoff has a corner in it at the strike, and the lattice can only look at the payoff where its own finishing levels happen to be. Where the corner falls relative to those levels changes with the step count, and that changes the answer.

Work out where the finishing levels actually are. The finishing levels are the starting level multiplied by the up factor raised to a whole number, and that whole number runs from minus the step count up to plus the step count in jumps of two. So it always has the same parity as the step count. When the step count is even the run includes zero, so one finishing level sits at exactly Rs 100/-, exactly the strike. When the step count is odd, zero is not in the run and no finishing level touches the strike at all.

At three steps the two finishing levels nearest the strike are Rs 89.094725/- and Rs 112.240090/-, and the corner sits in the gap between them, more than Rs 23/- wide. At twenty five steps they are Rs 96.078944/- and Rs 104.081077/-, and the gap is still over Rs 8/- wide. The corner never falls on a node on any odd count, and it always falls on a node on any even count, at every step count, for ever. The alternation is not a numerical accident. It is a property of a geometric grid built from reciprocal factors around a starting level that equals the strike.

Back to the wall and the metre stick. Whether the last mark lands on the wall or short of it is decided by the stick, not by the wall. One stick reads a little long, another a little short. Nothing about the wall changed. The lattice reads the payoff long on every odd count and short on every even count, and the sequence is those two readings interleaved.

Split them apart and both halves behave perfectly. The odd counts, one, three, five, seven, nine, eleven, give Rs 12.162285/-, Rs 11.043871/-, Rs 10.805934/-, Rs 10.703790/-, Rs 10.647160/- and Rs 10.611200/-: every one above the closed form, and every one lower than the last. The even counts, two, four, six, eight, ten, twelve, give Rs 9.540501/-, Rs 9.970523/-, Rs 10.125573/-, Rs 10.205099/-, Rs 10.253409/- and Rs 10.285850/-: every one below the closed form, and every one higher than the last. Two clean, one-sided, settled sequences. The mess is entirely in the interleaving.

Separating the first twelve readings by the parity of the step count turns one erratic sequence into two settled ones, with the odd counts falling toward the closed form from above and the even counts rising toward it from below.

The interleaving has a name worth carrying: oscillating convergenceApproaching an answer from alternating sides rather than from one. The sign of the error changes as the calculation is refined.. The published refinements to the lattice all attack it in the same way, by adjusting the geometry so that the strike is placed on a finishing level at every step count rather than only at even ones. Preprints on those refinements sit in the quantitative finance repositories named in the references below. The plain construction of Cox, Ross and Rubinstein, 1979, the one set out above, does not do that, and its convergence is the interleaved sequence just described.

Try it out

What causes the split between odd and even step counts?

The error that gets made, and what it costs

Running the lattice at one step count, seeing an answer that looks close, and concluding that it has settled. Concluding that is the most natural thing in the world to do, and on an oscillating sequence it establishes almost nothing.

Take the two counts in the table that are closest together in spirit. At twenty five steps the answer is Rs 10.520966/-, Rs 0.070382/- above the true price. At twelve steps the answer is Rs 10.285850/-, Rs 0.164734/- below the true price. Somebody who checked only twenty five steps would report that the lattice settles slightly high and would size their remaining error at about seven paise. Somebody who checked only twelve would report that it settles low and would size the error at about sixteen paise. Both are working from a real reading of a correct model, and their conclusions point in opposite directions.

The cost lands in two places. The step count gets fixed on the strength of one reading, so a count that happened to sit close by luck is treated as adequate for every other contract that model will ever price. And the error estimate that goes into the model documentation is wrong in sign as well as in size, so any correction applied on the back of it pushes the answer further away rather than nearer. The fix is cheap: run several counts, write down the signed errors, and look at the pattern instead of the point.

Twelve steps and twenty five steps sit on opposite sides of the true price, so a reader checking either one alone draws a conclusion about the direction of the error that the other reading contradicts.

Try it out

The lattice is run at one step count and the answer looks close. What has been established?

Cleaning Financial Data teaches you to find the errors that survive every check and break every model.

What does the lattice show that the closed form hides?

The closed form is faster, exact and finished. The formula takes four parameters and a strike and returns Rs 10.450584/-. Everything that produced that number, every weighting and every discounting, has been carried out algebraically and compressed out of sight. The formula cannot be checked by hand and does not show where it came from. It can only be trusted or rederived.

The lattice hides nothing. Every node holds a number that can be read, and every number is a weighted average of two other numbers that can also be read. At two steps there are six nodes in total and the whole calculation is three multiplications and three discountings. A reader who can add can audit a lattice, and no reader can audit a closed form without doing the derivation again. That is the trade being made when a slower method survives alongside a faster one.

There is a second thing the grid makes visible. The value at a node depends on the level at that node and on nothing else about how the process arrived there, so the whole conditional structure of the price is laid out in plain view. The value at Rs 115.190991/- after half a year reads straight off the two step grid: it is Rs 17.660000/-. The difference between the two values one period out, divided by the difference between the two levels, is 0.622299 at the root of the two step grid, against 0.636831 from the closed form. The two differ because the grid measures the slope across a whole half year while the closed form takes it at an instant.

The third thing is the one that keeps the method alive in practice. The backward pass does not care what rule is applied at a node. The pass applies whatever rule is written there, once per node. Contracts whose value at a node depends on a comparison made at that node fit the machinery without any change to it, and there is no closed form for most of them. Early exercise is set out under the exercise boundary.

The closed form wins on speed alone, and the lattice keeps its place because the argument stays visible at every node, can be checked by hand and accepts any rule written at a node.

Try it out

The lattice is slower than the closed form. Why does it survive?

How does somebody checking a model actually use this?

Somebody with an implementation in front of them and a duty to say how far off it is does three things, and none of them requires a faster machine.

The first is to refuse a single reading. The lattice is run at several counts, the signed error is recorded against whatever benchmark exists, and the shape is examined. If the signs alternate, that reveals something about the method no single count could have shown, and the error bound written down has to cover both sides.

The second is to pair the counts. Because the odd readings sit above and the even readings sit below, averaging one of each cancels most of what makes each of them wrong. Eleven steps gives Rs 10.611200/- and twelve gives Rs 10.285850/-, each missing by about sixteen paise. Their average is Rs 10.448525/-, out by Rs 0.002059/-, roughly eighty times better than either reading it was built from. The same pairing at twenty five and twenty six gives Rs 10.447512/-, missing by Rs 0.003072/-. Two cheap runs beat one expensive one, and the reason is structural rather than lucky.

The third is to remember what the step count is. The count is a choice made by whoever runs the model, not a fact about the standard process or the contract. Because the same code at fifty steps and at fifty one steps returns answers on opposite sides of the truth, the count belongs in the model documentation beside the parameters, and a reviewer who cannot find it written down anywhere has found a real gap.

The everyday version, one last time. Two weighings on the same scale that give two different readings do not call for picking whichever reading is preferred. The useful response is to notice that the readings straddle something, and to take the pattern seriously as information about the scale. A model that alternates says exactly where its answer lives, and the reader who takes one reading throws that away.

The calculator that computes a lattice is set out under binomial option pricing. The derivation of the closed form it converges to is set out under the Black-Scholes partial differential equation. What the contract pays is set out under the payoff function. Early exercise, the exercise boundary and the premium attached to them are set out under the exercise boundary. No jurisdiction governs any of this: the construction, the convergence and the oscillation are properties of arithmetic and hold wherever the arithmetic is carried out.

Breaking Into Quants Bootcamp — Fin Maverick

References

Source	Document	Where
arXiv Quantitative Finance	Preprint repository for work on lattice methods and the convergence of discrete pricing schemes	arxiv.org
Social Science Research Network	Working paper repository for the same material, including refinements that place the strike on a finishing level	ssrn.com
Cox, Ross and Rubinstein, 1979	Option Pricing: A Simplified Approach, the paper setting out the lattice construction used here	Journal of Financial Economics
Black, Scholes and Merton, 1973	The papers giving the closed form the lattice converges to	Journal of Political Economy and Bell Journal of Economics
Hull, Shreve and Wilmott	Standard texts on derivative pricing, lattice construction and the convergence of discrete schemes	published textbooks

The standard process, its four parameters and the contract valued against them are invented.
Educational material. Not advice on any investment, tax, budget or market position.

Covered in this topic

Subtopics

How to Set Up a Binomial Pricing Model

\(S_{i,j}\)	the level of the standard process after \(i\) periods, at the node reached by \(j\) up moves
\(S_0\)	the starting level of the standard process, Rs 100/- throughout this guide
\(u,\ d\)	the up factor and the down factor, with \(d=1/u\) by construction
\(i,\ j\)	the period counted from today, and the number of up moves within it

\(V_{i,j}\)	the value written on the node after \(i\) periods reached by \(j\) up moves
\(q\)	the weight on the up move, 0.553908 at two steps and 0.521710 at twelve
\(r\)	the one rate in this world, 5 per cent a year, continuously compounded
\(e^{-r\Delta t}\)	one period of discounting, 0.975310 at two steps and 0.995842 at twelve

\(\binom{n}{j}\)	the number of routes through the grid that arrive with exactly \(j\) up moves
\(K\)	the strike of the contract being valued, Rs 100/- throughout this guide
\(e^{-rT}\)	discounting over the whole horizon at once, 0.951229 for one year at 5 per cent
\(n\)	the number of steps, so that \(n+1\) finishing levels carry the whole sum

\(V^{(n)}_{0,0}\)	the lattice price at today, computed with \(n\) steps
\(C_{\mathrm{BS}}\)	the closed form price, Rs 10.450584/- for the at-the-money contract here
\(a(n)\)	a bounded quantity that does not settle down, and whose sign changes with \(n\)
\(O(1/n^{2})\)	a remainder that shrinks faster than the leading term and can be ignored for large \(n\)