Fin Maverick
Foundations VocabularyAccounting & ReportingEconomics & MacroQuant Methods & ProgrammingBusiness & Company AnalysisCorporate Finance & ValuationBehavioural Finance
Banking & Market InfrastructureFixed Income & RatesDerivatives & Structured ProductsPublic EquitiesTransactions & DealsPortfolio ConstructionFunds & AMCs
Private Markets & AlternativesRisk, Treasury & ControlAI & Digital FinanceStochastic Calculus & PricingWealth & Personal FinanceIndian Markets & RegulationProfessional Practice
CalculatorComparison
Frameworks
Explore Bootcamps
Equity ResearchPortfolio ManagementMutual Fund MasteryFinancial LiteracyInvestment Banking Analyst
Private Equity AnalystHedge Funds AnalystBreaking Into VCBreaking Into QuantsAI For Finance
Financial Analyst ProgramRisk Management ProgramPrivate Wealth ManagementDebt Capital MarketsDerivatives Foundation
Explore Internships
Equity Research InternMutual Fund Intern
Portfolio Management InternFinancial Literacy Intern
Explore Micro Courses

Equity Research6

Writing an Investment ThesisBuilding a Discounted Cash FlowReading an Annual Report FastReading a Sector Before a CompanySpotting Quality of Earnings Red FlagsBuilding a Revenue Forecast From Drivers

Portfolio Management3

Rebalancing: When, Why and What It CostsStrategic and Tactical Asset AllocationMeasuring Risk in a Portfolio

Mutual Fund Mastery3

Comparing Funds Without Being FooledHow a NAV Is Struck and Which Day You GetReading a Fund Factsheet Properly

Derivatives Unlocked4

Hedging a Real ExposureThe Greeks, PracticallyFutures, the Basis and What Moves ItReading an Option Payoff

AI For Finance2

Retrieval and Grounding for FinanceDocument Extraction in Finance

Breaking Into Quants4

Backtesting a StrategyHypothesis TestingCleaning Financial DataRegression for Finance

Breaking Into VC3

Sizing a MarketReading a Term Sheet as a FounderHow a Venture Round Actually Works

Financial Analyst Program4

Common Size and Trend AnalysisReading a Cash Flow StatementRatio Analysis That Says SomethingBuilding a Working Capital Schedule

Risk Management Program2

Credit Exposure and How It Is ReducedValue at Risk and What It Hides

Investment Banking Analyst3

Precedent Transactions and Why They DifferReading a Term Sheet StructurallyBuilding a Comparable Companies Table

Private Wealth Management3

Tax Aware Portfolio DecisionsBuilding a Client Risk ProfileGoal Based Planning Arithmetic

Debt Capital Markets3

Analysing an Issuer's CreditDuration and What It Does Not Tell YouBond Pricing and Yield Mechanics

Private Equity Analyst2

Fund Waterfalls and CarryThe LBO in Structure

Hedge Funds Analyst2

Short Selling MechanicsLong Short Mechanics
Courses
Explore Career Roadmaps
Investment Banking AnalystEquity Research AnalystVC AnalystPrivate Equity AnalystHedge Funds Analyst
Quant AnalystAI For FinanceFinancial Analyst ProgramPrivate Wealth ManagementDebt Capital Markets
Risk Management ProgramDerivatives FoundationPortfolio ManagementMutual Fund Mastery
PartnershipsShowdown
Log inSign up
Quant Analyst · CoreTrack
1Quantitative Methods, Financial Data & Programming
iProbability
Probability in FinanceRandom VariableProbability DistributionsThe Normal DistributionNormal Distribution ProbabilityThe Lognormal DistributionRandomness vs Uncertainty
iiStatistics and Inference
Population and SampleMean, Median and ModePrecision and AccuracyVariable TypesVariance, Standard Deviation and…Dispersion MeasuresStatistical BiasEffect SizeHypothesis TestingThe Sampling DistributionSkewnessKurtosisCovarianceConfidence IntervalArithmetic Mean vs Geometric MeanStatistical Significance vs Economic…Confidence Interval vs Prediction IntervalHow to Summarise a…
iiiCorrelation and Regression
RegressionCorrelation and CausationOrdinary Least SquaresInteraction TermsRegression CoefficientsRegression vs ClassificationHow to Build a…Spurious CorrelationRegression, Correlation and FitResidualsMulticollinearityAutocorrelation and Partial Autocorrelation
ivTime Series
Time Series in FinanceSimple, Weighted and Exponential…Moving Average CalculatorPrice, Return and Level SeriesHow to Prepare Time-Series…LagFrequencySeasonalityTimestampsTrendStationarity and the Unit RootHeteroskedasticityLeadRolling WindowsDifferencing
vSimulation and Numerical Methods
SimulationMonte Carlo SimulationHow to Run a…Numerical MethodsIterationResampling and the BootstrapPseudorandom Numbers and the SeedConvergence and ToleranceNumerical Stability
viOptimisation
OptimisationLocal and Global OptimaConstraintsConvex OptimisationThe SolverLinear ProgrammingThe Objective FunctionConstraint ViolationThe Feasible SetLagrange MultipliersQuadratic Programming
viiModelling Practice
Linear, Logistic, Ridge and…Training, Validation and Test…The ModelModel ErrorDependent and Independent VariablesThe ROC Curve and AUCWhat a Model HoldsMSE, RMSE, MAE and MAPEPrecision and RecallCross Validation and RegularisationOverfitting and UnderfittingReturn Series MeasuresSimple, Compound and Log Return
viiiBacktesting and Research Integrity
BacktestingBacktest vs Live PerformanceHow to Document a…How to Prevent Backtest…Out-of-Sample TestingWalk-Forward AnalysisMultiple TestingP-HackingData Snooping
ixData Quality and Structure
Data QualityThe DatasetSelection and Survivorship BiasVersioned DatasetsData Structures in FinanceData CleaningMissing Data and Null ValuesStructured Data vs Unstructured DataMissing Data vs ZeroData Validation vs Data CleaningOutliersDuplicate Records
xProgramming for Finance
Data PipelinesAPIs for Financial DataAPI vs CSV FileDatabases in FinancePython for FinanceJoinsSQL for FinanceThe Analysis Workflow
xiQuantitative Research
Research DesignThe Data Generating ProcessReproducibilityPeer Review in Analytical WorkThe Research HypothesisRobustness and Sensitivity
2Stochastic Calculus & Derivative Pricing Theory
iProbability Foundations
The Probability SpaceRandom VectorsSigma-AlgebraExpectationSample Space and EventsDensity and Distribution FunctionsRisk-Neutral ProbabilityState Price Density vs…
iiStochastic Processes and Jumps
Properties of a Stochastic ProcessMartingaleBrownian Motion and Its PropertiesBrownian Motion vs Geometric…Stopping TimeThe Markov PropertyState VariablesTransition ProbabilityQuadratic VariationQuadratic Variation vs Ordinary…Submartingale and SupermartingaleMartingale RepresentationMarkov Process vs MartingaleOptional StoppingFiltrationJump ProcessesThe Poisson ProcessLevy ProcessesJump Diffusion
iiiIto Calculus
The Ito IntegralThe Ito Integral vs the Riemann IntegralInfinitesimals in Stochastic CalculusQuadratic CovariationIto's LemmaHow to Apply Ito's…The Infinitesimal GeneratorIto Calculus vs Ordinary Calculus
ivStochastic Differential Equations
Stochastic Differential EquationsStochastic Differential Equation vs…Drift and DiffusionStrong and Weak Solutions ComparedDiscretisationGeometric Brownian Motion
vPricing Theory and No-Arbitrage
No-ArbitrageGirsanov, Radon-Nikodym and Change…Physical and Risk-Neutral Measures…The Fundamental Theorems of…The Law of One PriceThe Pricing KernelDiscount Factors and Zero-Coupon PricesReplication vs HedgingComplete Market vs Incomplete MarketClearing Margin Architecture
viOption Pricing Theory
European and American OptionsMonte Carlo European OptionThe Black-Scholes PDEBlack Scholes and the GreeksThe Payoff FunctionThe Binomial ModelBinomial Option PricingDelta Hedging in TheoryBoundary, Initial and Terminal ConditionsThe Exercise BoundaryHow to Check Put-Call…
viiVolatility Models
Constant, Local and Stochastic…Vasicek Model vs CIR ModelThe Heston ModelThe SABR ModelThe Volatility ProcessImplied VolatilityVolatility Smile vs Skew vs Surface
viiiInterest Rate Models
Interest-Rate DerivativesMean ReversionThe Zero-Coupon BondThe Ornstein-Uhlenbeck ProcessThe Discount CurveZero RatesShort-Rate Model vs Market Model
ixNumerical Pricing
Closed Form and Numerical…Monte Carlo PricingEuler and Milstein Schemes ComparedTree MethodsFinite Difference MethodsNumerical Error and StabilityVariance Reduction
xCalibration and Model Risk
Model OverrideMarket Price and Model PriceCalibrationHow to Document a Pricing ModelThe Educational Illustration LabelMarket ConventionsModel Uncertainty and LimitationsBacktesting a Pricing ModelIdentifiabilityCalibrated ParametersThe Calibration Loss Function

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.

The equation, in the two forms it is written in
$$ dS_t \;=\; \mu\,S_t\,dt \;+\; \sigma\,S_t\,dW_t \qquad\Longleftrightarrow\qquad S_T \;=\; S_0 \;+\; \int_0^{T}\!\mu\,S_t\,dt \;+\; \int_0^{T}\!\sigma\,S_t\,dW_t $$
\(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
What it says in wordsThe change in the process over an instant is a drift piece proportional to the length of the instant plus a diffusion piece proportional to the random increment over it, and the level at the horizon is the starting level plus the accumulation of both pieces from the start to the horizon.

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.

One construction. Two things that can be done with it. That is the whole relationship. THE SHARED CONSTRUCTION Cut the year into pieces. Read the two coefficients at the START of each piece. Multiply, and add them up. SHRINK THE PIECES TO NIL STOP AT A FINITE GRID THE ITO INTEGRAL the object the equation is written in. Exact, and unrunnable. THE SCHEME the same sum, kept finite. Approximate, and runnable. The two differ by one move only: whether the pieces are then driven to nothing. Because they share the construction, they agree about what is being approximated.
The scheme and the Ito integral are the same sum over a grid with the coefficients read at the start of each piece, separated only by whether the pieces are then shrunk to nothing, which is why the scheme approximates the right object rather than a nearby one.

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.

Try it out

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.

The scheme, one step at a time
$$ \hat{S}_{t_{i+1}} \;=\; \hat{S}_{t_i} \;+\; \mu\,\hat{S}_{t_i}\,\Delta t \;+\; \sigma\,\hat{S}_{t_i}\,\Delta W_i , \qquad \Delta t=\frac{T}{n},\qquad \Delta W_i = W_{t_{i+1}}-W_{t_i} $$
\(\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
What it says in wordsThe next level is the current level, plus the drift coefficient evaluated at the current level multiplied by how long the step lasts, plus the diffusion coefficient evaluated at the current level multiplied by how far the Brownian path moved across the step.

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.

One step, taken apart. The drift piece is the small one, and it usually is. 101 100 99 98 97 96 Rs 100.000000/- the level carried in plus Rs 0.666667/- drift piece level x 0.08 x one twelfth less Rs 2.886751/- diffusion piece level x 0.20 x increment Rs 97.779915/- the level carried out The vertical scale starts at Rs 96/-, not at nil, or the two middle pieces would be invisible.
The first step at twelve settings adds a drift piece of Rs 0.666667/- and subtracts a diffusion piece of Rs 2.886751/- from a level of Rs 100/-, landing on Rs 97.779915/- and showing that the random piece dominates the deterministic one over a short step.

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.

Try it out

Where in each step does the simplest scheme read the drift and the diffusion?

Breaking Into Quants Bootcamp — Fin Maverick

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.

The scheme's sum, and the limit it is one term of
$$ \underbrace{\sum_{i=0}^{n-1}\sigma\,\hat{S}_{t_i}\,\Delta W_i}_{\text{what the scheme computes}} \qquad\xrightarrow[\;n\to\infty\;]{}\qquad \underbrace{\int_0^{T}\!\sigma\,S_t\,dW_t}_{\text{what the equation names}} $$
\(\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
What it says in wordsThe sum the scheme actually adds up is a single term in the very sequence whose limit defines the integral in the equation, so refining the grid walks along that sequence rather than heading somewhere else.

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.

The exact solution, and the error against it
$$ S_T \;=\; S_0\,\exp\!\Bigl(\bigl(\mu-\tfrac{1}{2}\sigma^{2}\bigr)T \;+\; \sigma W_T\Bigr), \qquad e_n \;=\; \hat{S}^{(n)}_{T} \;-\; S_T $$
\(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
What it says in wordsThe exact level at the horizon is the starting level multiplied by the exponential of the drift less half the variance rate over the year plus the volatility multiplied by where the Brownian path finished, and the error is simply the scheme's finish less that exact finish.

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.

Try it out

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.

StepsStep lengthWhere the scheme finishesSigned errorAgainst the previous setting
1one yearRs 108.000000/-plus Rs 1.816345/-no previous setting
2six monthsRs 107.596667/-plus Rs 1.413012/-smaller
3four monthsRs 108.150785/-plus Rs 1.967130/-larger, and this is the point
4three monthsRs 105.299068/-less Rs 0.884587/-smaller, and the sign has flipped
6two monthsRs 106.132004/-less Rs 0.051651/-smaller
12one monthRs 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.

The signed error, one path, six settings. This is the shape, drawn as it is. no error at all plus Rs 1.50/- less Rs 1.00/- +1.816345 +1.413012 +1.967130 -0.884587 -0.051651 +0.000836 refining here made it WORSE 1 step 2 3 4 6 12 steps THE SIGN AT EACH SETTING. The last two are too small to draw to scale, so they are recorded instead. 1: ABOVE 2: ABOVE 3: ABOVE 4: BELOW 6: BELOW 12: ABOVE first crossing second crossing Not a decline. A rise at three steps, a crossing after it, and a second crossing after six.
The signed error runs plus Rs 1.816345/-, plus Rs 1.413012/-, plus Rs 1.967130/-, less Rs 0.884587/-, less Rs 0.051651/- and plus Rs 0.000836/-, rising once at three steps and crossing zero twice, which is not the smooth decline a refinement is usually assumed to produce.
Try it out

Between which two settings does the error first change sign?

Try it out

The control below is about to move from two steps to three. Before it moves: does the error get smaller?

Play with it

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.

Grey is exact. Dark is the scheme. Dashed is one notch coarser. 106.18 100.00 start of the year the horizon exact Rs 106.183655/- THE SIGNED ERROR AT THE HORIZON, all six settings on one scale no error scheme below exact scheme above exact Twelve steps is the finest setting on the locked path.
1 step234612 steps
Steps
12
Scheme finishes at
106.184491
Signed error
+0.000836
This refinement
helped
Stepped in 12 pieces, the scheme finishes at Rs 106.184491/- against the exact Rs 106.183655/-, an error of plus Rs 0.000836/-, and refining from 6 pieces cut the size of the error.
Educational illustration. Every reading is computed from the locked path rather than sampled, so the default of twelve steps reproduces the worked instance of Rs 106.184491/- exactly on every reload. The six readings and their signed errors are Rs 108.000000/- at plus Rs 1.816345/-, Rs 107.596667/- at plus Rs 1.413012/-, Rs 108.150785/- at plus Rs 1.967130/-, Rs 105.299068/- at less Rs 0.884587/-, Rs 106.132004/- at less Rs 0.051651/- and Rs 106.184491/- at plus Rs 0.000836/-, against an exact Rs 106.183655/-. Three steps is worse than two, and the sign flips twice, once between three steps and four and again between six and twelve. The same driving values are used at every setting, so only the step length changes.
Derivatives Foundation Bootcamp — Fin Maverick

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.

Where each setting finishes, against the exact Rs 106.183655/-. Three magnifications. RUNG ONE, scale runs Rs 105.00/- to Rs 108.50/- exact 1 step 2 3 4 six and twelve are inside this box RUNG TWO, scale runs Rs 106.10/- to Rs 106.26/-, magnified about twenty two times exact 6 steps, below twelve is still inside this box, three pixels wide RUNG THREE, scale runs Rs 106.1830/- to Rs 106.1855/-, magnified about fourteen hundred times exact 12 steps, above The scheme finishes on both sides of the exact level, and it changes sides twice.
Magnifying the horizon three times over shows one, two and three steps finishing above the exact level, four and six below it, and twelve above it again, so the scheme crosses the exact answer twice rather than approaching it from one side.

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.

The error across all paths, and its closed form for this scheme
$$ \varepsilon_n \;=\; \sqrt{\mathbb{E}\bigl[(\hat{S}^{(n)}_{T}-S_T)^{2}\bigr]}, \qquad \mathbb{E}\bigl[(\hat{S}^{(n)}_{T})^{2}\bigr] = S_0^{2}\Bigl[(1+\mu\Delta t)^{2}+\sigma^{2}\Delta t\Bigr]^{n} $$
\(\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
What it says in wordsTake the gap between the scheme and the exact answer at the horizon, square it so that gaps in both directions count, average the squares over every path the process could have taken, and take the square root to bring the figure back to rupees.

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.

StepsSize of the error on the locked pathRoot mean square error, all pathsDid the refinement help?
1Rs 1.816345/-Rs 3.520975/-no previous setting
2Rs 1.413012/-Rs 2.371961/-both fell
3Rs 1.967130/-Rs 1.897412/-one path rose, all paths fell
4Rs 0.884587/-Rs 1.624777/-both fell
6Rs 0.051651/-Rs 1.310730/-both fell
12Rs 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.

The same six settings, measured two ways. Only one of them is what convergence is about. ONE PATH, SCALE TOPS AT Rs 2.10/- 1.8163 1.4130 1.9671 0.8846 UP at six and twelve the sizes are 0.0517 and 0.0008, too small to see ALL PATHS, SCALE TOPS AT Rs 3.60/- 3.5210 2.3720 1.8974 1.6248 1.3107 0.9149 down at every refinement, with no reversal anywhere 1 2 3 4 6 12 1 2 3 4 6 12 Convergence is the right panel. The left panel is one draw from it and is allowed to misbehave.
Across the same six settings the size of the error on one path rises from Rs 1.413012/- to Rs 1.967130/- at three steps, while the root mean square error across all paths falls from Rs 3.520975/- to Rs 0.914943/- without a single reversal.
Try it out

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.

The artefact: a step length test that looked like a convergence check. STEP LENGTH TEST, ONE PATH steps signed error verdict 2 +1.413012 baseline 3 +1.967130 WORSE CONCLUSION: refining makes this model worse. Two steps adopted. Test closed. Rows never run: 4, 6, 12 Paths tested: one WHAT THE UNRUN ROWS HELD 4 steps -0.884587 6 steps -0.051651 12 steps +0.000836 The very next row reverses the conclusion. The last row misses by less than a tenth of a paisa. two rows are not a convergence check Nothing in the sheet is wrong. Every number on it was correctly computed.
A test that compares only two steps with three on one path records a genuine rise from plus Rs 1.413012/- to plus Rs 1.967130/- and closes with the wrong conclusion, because the next unrun row reverses it and the last misses by Rs 0.000836/-.
Try it out

A tester compares two steps and three on one path, sees the error grow, and concludes refining hurts. What went wrong?

Risk Management Program Bootcamp — Fin Maverick Rebalancing: When, Why and What It Costs — free micro-course from Fin Maverick

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.

Two gates, closing from opposite ends. What survives between them is the choice. coarse steps, cheap and inaccurate fine steps, accurate and dear RULED OUT BY TOLERANCE RULED OUT BY BUDGET THE STEP LENGTH LIVES HERE GATE ONE how much error can the use carry? GATE TWO how much computing time is there? take the coarsest one that fits A test on one path answers neither question, and produces a number that looks like an answer to both.
The step length is squeezed from one side by how much error the use can carry and from the other by how much computing time is available, so the working choice is the coarsest setting that clears the tolerance across many paths.
Try it out

What two things actually decide the step length?

Rebalancing: When, Why and What It Costs teaches you to choose a rebalancing rule and say what it buys and what it costs.

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.

Schemes better than the simplest one are covered separately and much later, as is the exchange between their extra cost per step and their faster convergence. The derivation of the exact solution is the chain rule result, covered separately. How the driving randomness would be produced in a real computation is covered separately, as is any pricing argument, two reading sequences later. Contract payoffs are a separate subject.

References

SourceDocumentWhere
arXiv Quantitative FinancePreprint repository for discretisation schemes for stochastic differential equations and their convergence ordersarxiv.org
Social Science Research NetworkWorking paper repository for the same materialssrn.com
ItoThe integral whose construction this scheme stops one move short of, and the source of the start-of-step evaluation pointnamed in the text only
Hull, Shreve and WilmottStandard texts on stochastic calculus and its numerical schemesnamed 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.

← PreviousNext →
Fin Maverick Micro CoursesExplore Micro Courses
Fin Maverick BootcampsExplore Bootcamps
Fin Maverick

Finance education that ends in a job, not a certificate that gathers dust. Built for young India.

LEARN
CalculatorsFrameworksComparisonsCareersShowdown
RESOURCES
All CoursesMicro CoursesBootcampsInternships
COMPANY
AboutJob openingPartnership
LEGAL
Privacy PolicyTerms & ConditionsContent LicenseReturn & Refund Policy
© 2026 FIN MAVERICK / BUILT FOR INDIA.DO FINANCE, DO NOT JUST READ ABOUT IT.