How the linear (delta) and quadratic (delta-gamma) Taylor approximations to a Black-Scholes-Merton option price break down as the underlying moves further from the current spot
Risk management of an option position starts from the change in its value as the underlying asset moves. Because option payoffs are non-linear in the underlying price \(S\), that change is not proportional to \(\Delta S\): a call gains more from a rally than it loses from an equivalent sell-off. Two local approximations to the option price \(c(S)\) are standard (Christoffersen 2012, chap. 11):
Here \(S_t\) is today’s spot price and \(S_{t+\tau}\) is the spot after a horizon \(\tau\). The option delta \(\delta = \partial c / \partial S\) is the first-order sensitivity to the underlying, and the option gamma \(\gamma = \partial^{2} c / \partial S^{2}\) is the curvature.
For a European option with strike \(X\), risk-free rate \(r_f\), continuous dividend yield \(q\), volatility \(\sigma\), and time to maturity \(\tilde T\), the Black-Scholes-Merton greeks are \[
\delta^{c} = e^{-q\tilde T}\,\Phi(d), \qquad
\delta^{p} = e^{-q\tilde T}\left(\Phi(d) - 1\right), \qquad
\gamma = \frac{e^{-q\tilde T}\,\phi(d)}{S_t\,\sigma\sqrt{\tilde T}},
\] with \(d = \left[\ln(S_t/X) + \tilde T(r_f - q + \sigma^{2}/2)\right]/(\sigma\sqrt{\tilde T})\), where \(\Phi(\cdot)\) and \(\phi(\cdot)\) are the standard normal CDF and PDF and the superscripts \(c\) and \(p\) identify the call and put delta. Gamma is always positive, peaks near the money, and flattens deep in-the-money or out-of-the-money.
normalCDF = x => {const a1 =0.254829592, a2 =-0.284496736, a3 =1.421413741const a4 =-1.453152027, a5 =1.061405429, p =0.3275911const sign = x <0?-1:1const z =Math.abs(x) /Math.sqrt(2)const t =1.0/ (1.0+ p * z)const y =1- (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *Math.exp(-z * z)return0.5* (1+ sign * y)}
normalPDF = x =>Math.exp(-x * x /2) /Math.sqrt(2*Math.PI)
// BSM pricing and greeks.// S: spot, X: strike, T: years to maturity, r: risk-free rate, q: dividend yield,// sig: volatility (annualized), type: "call" or "put"bsm = (S, X, T, r, q, sig, type) => {if (T <=0) {const intrinsic = type ==="call"?Math.max(S - X,0) :Math.max(X - S,0)return { price: intrinsic,delta:0,gamma:0,d1:0 } }const sqrtT =Math.sqrt(T)const d1 = (Math.log(S / X) + (r - q +0.5* sig * sig) * T) / (sig * sqrtT)const d2 = d1 - sig * sqrtTconst eqT =Math.exp(-q * T)const erT =Math.exp(-r * T)const Nd1 =normalCDF(d1)const Nd2 =normalCDF(d2)const pdf =normalPDF(d1)let price, deltaif (type ==="call") { price = S * eqT * Nd1 - X * erT * Nd2 delta = eqT * Nd1 } else { price = X * erT *normalCDF(-d2) - S * eqT *normalCDF(-d1) delta = eqT * (Nd1 -1) }const gamma = eqT * pdf / (S * sig * sqrtT)return { price, delta, gamma, d1 }}
Start from the default at-the-money call. The true price is a convex curve; the tangent line (delta) hugs it only near \(S_t\). Drag \(S_{t+\tau}\) away from the strike and watch the approximation errors grow. Change the option to deep OTM: the curve flattens, so delta alone is nearly perfect. Change the moneyness so the option is deep ITM: delta approaches 1 and the linear approximation becomes accurate again. The worst case is at-the-money with a large move, where gamma is tall and the linear approximation is far below the true price.
viewof oaSt = Inputs.range([20,120], { label:"Sₜ current spot",step:0.5,value:50 })
{const c = oaCoreconst el =html`<p style="color:#666;font-size:0.85rem;">Solid blue: the exact BSM ${c.type} price. Dashed orange: the tangent (delta) approximation at \\(S_t = ${fmt(c.S,2)}\\). Dashed green: the delta-gamma parabola. The vertical grey lines mark the current spot \\(S_t\\) and the strike \\(X = ${fmt(c.X,2)}\\). The larger blue dot marks the option price at \\(S_t\\). The three smaller dots at \\(S_{t+\\tau} = ${fmt(c.futureS,2)}\\) show, in matching colours, the true price (blue), the delta approximation (orange), and the delta-gamma approximation (green) at the selected evaluation point.</p>`if (window.MathJax&& MathJax.typesetPromise) MathJax.typesetPromise([el])return el}
{const el =html`<p style="color:#666;font-size:0.85rem;">The delta error is always negative for a long call (the curve is above the tangent). The delta-gamma error is close to zero near \\(S_t\\) but the parabola overshoots for large moves. For a short position, both errors flip sign, which is why a short option position <em>understates</em> its downside risk under the delta approximation.</p>`if (window.MathJax&& MathJax.typesetPromise) MathJax.typesetPromise([el])return el}
{const el =html`<p style="color:#666;font-size:0.85rem;">Delta ramps from 0 to 1 (call) or \\(-1\\) to 0 (put) as the option moves from OTM to ITM. Gamma peaks near the strike, showing where the linear approximation fails hardest. Risk from a fixed \\(\\delta\\) assumption is most misleading for positions near-the-money.</p>`if (window.MathJax&& MathJax.typesetPromise) MathJax.typesetPromise([el])return el}
From approximation to portfolio VaR. Delta and gamma only describe a single position. The next page uses them (together with Monte Carlo and full valuation) to build the full distribution of \(\Delta P\) and compare four VaR estimators.
References
Christoffersen, Peter F. 2012. Elements of Financial Risk Management. 2nd ed. Academic Press.