Numerical Differentiation

A structured product's price comes out of a complicated numerical model — a Monte Carlo simulation or an exotic pricing tree — with no clean algebraic formula. Risk management still needs delta, the sensitivity of price to the underlying's move, to hedge the position. Without a formula to differentiate, the practical answer is to nudge the underlying's price by a tiny amount, rerun the model, and see how much the output moves. That's numerical differentiation: estimating a derivative purely from evaluating the function at nearby points, never touching calculus at all.

An analogy: judging a hill's steepness by walking

If you can't see a topographic map's slope formula but can only measure your altitude at any spot, you can still estimate steepness: walk a short step forward, note how much your altitude changed, and divide the altitude change by the distance walked. A shorter step gives a more precise local estimate of the slope right where you're standing, as long as your altimeter is precise enough to actually detect the small change — a step so short that the altitude change is smaller than your altimeter's precision gives you noise, not a slope.

The math, one piece at a time

The forward difference estimates the derivative of $f$ at a point $x$ using one nudge forward:

$$f'(x) \approx \frac{f(x+h) - f(x)}{h},$$

where $h$ is a small step size. In words: this is exactly the definition of a derivative — the limit of the slope between two nearby points as they get infinitely close — except a computer can't take $h \to 0$, so it uses a small but finite $h$ instead, and pays a price called truncation error, roughly proportional to $h$.

The **central difference** is more accurate for the same step size, using one nudge in each direction: $$f'(x) \approx \frac{f(x+h) - f(x-h)}{2h} .$$

In plain English: instead of comparing $x$ to a point ahead of it, compare a point ahead to a point behind, which cancels out the leading error term by symmetry — central difference's truncation error shrinks proportional to $h^2$, so halving $h$ cuts the error by 4x instead of 2x. But shrinking $h$ too far runs into the opposite problem from earlier: floating-point rounding error in computing $f(x+h)-f(x-h)$ (a subtraction of two close numbers — see catastrophic cancellation) grows roughly like $\varepsilon/h$ as $h$ shrinks, since a smaller numerator is divided by a smaller $h$. The total error is the sum of both effects, and there's an optimal $h$ that balances them — too big and truncation error dominates, too small and rounding error dominates.

Worked example 1: delta by hand

An option prices at $10.00 with the underlying at $100. Bumping the underlying to $100.01 gives a price of $10.0052; bumping down to $99.99 gives $9.9948. Central difference delta:

$$\Delta \approx \frac{10.0052 - 9.9948}{2 \times 0.01} = \frac{0.0104}{0.02} = 0.52 .$$

In words: a $1 move in the underlying moves the option price by about $0.52 — a delta of 0.52, computed with no derivative formula at all, purely from three price evaluations (or in this case, two, since central difference doesn't need $f(x)$ itself).

Worked example 2: finding a good step size

Suppose pricing this option to $0.0001 precision (a realistic Monte Carlo noise floor). With $h = 0.01$: truncation error is roughly proportional to $h^2 \approx 0.0001$, fine. With $h = 0.0000001$ (far too small): the price difference $f(x+h)-f(x-h)$ is now comparable in size to the pricing model's own $0.0001 noise floor, so the "derivative" computed is dominated by simulation noise, not the true slope — a classic case of $h$ chosen too small, producing a wildly unstable delta estimate that can even flip sign between reruns. The lesson: the right step size depends on how precisely the underlying function itself can be evaluated, not just on wanting maximum mathematical accuracy.

What this means in practice

Numerical differentiation via bump-and-reprice is the standard way to compute Greeks for pricing models too complex for closed-form sensitivities — Monte Carlo pricers, exotic-option trees, or any black-box valuation model — and it's also how gradient-based optimizers estimate gradients when no analytic gradient is coded. The choice of step size $h$, and whether to use forward or central differences, is a real engineering decision that trades off truncation error against rounding (or simulation) noise, not a detail to default blindly.