The Multi-Strike Pitfall: When Delta and Gamma Both Fail

A three-option portfolio with two strike prices where the linear and quadratic approximations both badly misrepresent the true payoff — and full valuation becomes unavoidable

The delta and delta-gamma approximations are local around the current spot \(S_t\): the option delta \(\delta = \partial c/\partial S\) and gamma \(\gamma = \partial^{2} c/\partial S^{2}\) are both evaluated at today’s spot. For a single option that local view is often enough. But as soon as a portfolio contains options at different strike prices, the payoff profile acquires higher-order curvature — kinks and curvature that shift as the underlying \(S\) crosses each strike. A single portfolio-level \(\delta\) and \(\gamma\) computed at \(S_t\) cannot capture them (Christoffersen 2012, chap. 11, §8).

This page plots the exact horizon payoff of a three-option portfolio against hypothetical future spot prices and overlays the two approximations. The default book is a concentrated short-gamma trade at one strike partially protected by long calls at a higher strike — the kind of structure the approximations handle worst.

normalCDF = x => {
  const a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741
  const a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911
  const sign = x < 0 ? -1 : 1
  const 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)
  return 0.5 * (1 + sign * y)
}

normalPDF = x => Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI)

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: type === "call" ? (S > X ? 1 : 0) : (S < X ? -1 : 0), gamma: 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 * sqrtT
  const eqT = Math.exp(-q * T), erT = Math.exp(-r * T)
  const Nd1 = normalCDF(d1), Nd2 = normalCDF(d2), pdf = normalPDF(d1)
  let price, delta
  if (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 }
}

fmt = (x, d) => (x === undefined || !isFinite(x) || isNaN(x)) ? "N/A" : x.toFixed(d)

fmtSigned = (x, d) => {
  if (x === undefined || !isFinite(x) || isNaN(x)) return "N/A"
  return (x >= 0 ? "+" : "") + x.toFixed(d)
}

Portfolio and horizon

Tip

How to experiment

Start with the defaults. The dark blue curve is the true portfolio value at horizon; notice it has a cubic-looking shape. The orange line is the delta approximation — flat, off by tens of dollars at the edges. The green parabola (delta-gamma) does not do much better and can be worse than delta on the downside. Push the two strikes apart, flip one of the positions, or zoom out to a larger price range: the approximations continue to miss. Now set \(X_{1} = X_{2}\) and the portfolio reduces to an ordinary long/short gamma book where gamma works well — the green parabola tracks the true price closely.

viewof tpSt = Inputs.range([20, 120], { label: "Sₜ current spot", step: 0.5, value: 60 })

viewof tpX1 = Inputs.range([20, 120], { label: "X₁ (lower strike)", step: 0.5, value: 55 })

viewof tpX2 = Inputs.range([20, 120], { label: "X₂ (upper strike)", step: 0.5, value: 65 })

viewof tpSig = Inputs.range([5, 80], { label: "σ annual volatility (%)", step: 0.5, value: 35 })

viewof tpDays = Inputs.range([5, 365], { label: "T̃ option maturity (calendar days)", step: 1, value: 35 })

viewof tpHorizon = Inputs.range([1, 30], { label: "Risk horizon (calendar days)", step: 1, value: 7 })

viewof tpR = Inputs.range([0, 8], { label: "r risk-free rate (%/year)", step: 0.1, value: 2.0 })

viewof tpQ = Inputs.range([0, 8], { label: "q dividend yield (%/year)", step: 0.1, value: 0.0 })

viewof tpM1 = Inputs.range([-5, 5], { label: "m₁  (put at X₁)", step: 0.5, value: -1 })

viewof tpM2 = Inputs.range([-5, 5], { label: "m₂  (call at X₁)", step: 0.5, value: -1.5 })

viewof tpM3 = Inputs.range([-5, 5], { label: "m₃  (call at X₂)", step: 0.5, value: 2.5 })

viewof tpZoom = Inputs.range([0.15, 0.60], { label: "Plot range (± fraction of Sₜ)", step: 0.05, value: 0.30 })

tpLegs = [
  { idx: 1, m: tpM1, X: tpX1, type: "put",  label: "Put at X₁" },
  { idx: 2, m: tpM2, X: tpX1, type: "call", label: "Call at X₁" },
  { idx: 3, m: tpM3, X: tpX2, type: "call", label: "Call at X₂" }
]

tpCore = {
  const S = tpSt
  const sig = tpSig / 100
  const T = tpDays / 365
  const r = tpR / 100, q = tpQ / 100

  // Current portfolio value, delta, gamma
  let VPF = 0, delta = 0, gamma = 0
  const legDetails = tpLegs.map(L => {
    const b = bsm(S, L.X, T, r, q, sig, L.type)
    VPF  += L.m * b.price
    delta += L.m * b.delta
    gamma += L.m * b.gamma
    return { ...L, price: b.price, delta: b.delta, gamma: b.gamma, notional: L.m * b.price }
  })

  // Horizon maturity
  const Tnew = Math.max((tpDays - tpHorizon) / 365, 0.1 / 365)

  // Sweep over future S
  const N = 240
  const sLo = S * (1 - tpZoom), sHi = S * (1 + tpZoom)
  const rows = []
  for (let i = 0; i <= N; i++) {
    const Sf = sLo + (sHi - sLo) * i / N
    const dS = Sf - S

    // Full valuation at horizon (reduced maturity)
    let VPFfull = 0
    for (const L of tpLegs) {
      VPFfull += L.m * bsm(Sf, L.X, Tnew, r, q, sig, L.type).price
    }

    const VPFdelta = VPF + delta * dS
    const VPFgamma = VPFdelta + 0.5 * gamma * dS * dS

    rows.push({ Sf, VPFfull, VPFdelta, VPFgamma,
                errDelta: VPFdelta - VPFfull,
                errGamma: VPFgamma - VPFfull })
  }

  return { S, VPF, delta, gamma, T, Tnew, sLo, sHi, rows, legDetails }
}

Payoff at horizon

{
  const c = tpCore
  return Plot.plot({
    height: 440, marginLeft: 60, marginRight: 20,
    x: { label: `S at horizon (${tpHorizon} calendar days ahead)`, domain: [c.sLo, c.sHi] },
    y: { label: "Portfolio value at horizon ($)", grid: true },
    color: { legend: true,
             domain: ["Full valuation (true)", "Delta approximation", "Delta–gamma approximation"],
             range: ["#2f71d5", "#e67e22", "#2e7d32"] },
    marks: [
      Plot.ruleY([0], { stroke: "#bbb" }),
      Plot.ruleX([tpX1], { stroke: "#bbb", strokeDasharray: "3 3" }),
      Plot.ruleX([tpX2], { stroke: "#bbb", strokeDasharray: "3 3" }),
      Plot.ruleX([c.S], { stroke: "#777", strokeDasharray: "2 3" }),
      Plot.line(c.rows, { x: "Sf", y: "VPFdelta", stroke: "#e67e22", strokeWidth: 2, strokeDasharray: "4 3" }),
      Plot.line(c.rows, { x: "Sf", y: "VPFgamma", stroke: "#2e7d32", strokeWidth: 2, strokeDasharray: "6 3" }),
      Plot.line(c.rows, { x: "Sf", y: "VPFfull",  stroke: "#2f71d5", strokeWidth: 2.5 }),
      Plot.dot([{ x: c.S, y: c.VPF }], { x: "x", y: "y", r: 5, fill: "#2f71d5", stroke: "white", strokeWidth: 1.5 })
    ]
  })
}

{
  const c = tpCore
  const el = html`<p style="color:#666;font-size:0.85rem;">Solid blue: exact portfolio value at the horizon date, obtained by repricing every leg with reduced maturity \\(\\tilde T - \\tau\\). Dashed orange and green: the delta and delta-gamma approximations extrapolated from \\(S_t = ${fmt(c.S, 2)}\\). The blue dot marks today's portfolio value \\(V_{PF} = ${fmt(c.VPF, 2)}\\) at \\(S_t\\): the anchor from which the two approximations are built (both pass exactly through the dot). The full-valuation curve is evaluated at reduced maturity, so at \\(S_{t+\\tau} = S_t\\) it sits below the dot by the portfolio's theta over \\(\\tau\\) days — a gap the local greeks do not capture. Light grey vertical lines mark the two strikes (\\(X_1 = ${fmt(tpX1, 2)}\\), \\(X_2 = ${fmt(tpX2, 2)}\\)); the darker grey line marks \\(S_t\\). The exact payoff curves across the strikes whereas the approximations cannot.</p>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Approximation error

{
  const c = tpCore
  return Plot.plot({
    height: 360, marginLeft: 60, marginRight: 20,
    x: { label: "S at horizon", domain: [c.sLo, c.sHi] },
    y: { label: "Error (approx − true)", grid: true },
    color: { legend: true, domain: ["Delta", "Delta–gamma"], range: ["#e67e22", "#2e7d32"] },
    marks: [
      Plot.ruleY([0], { stroke: "#aaa" }),
      Plot.ruleX([c.S], { stroke: "#777", strokeDasharray: "2 3" }),
      Plot.ruleX([tpX1], { stroke: "#bbb", strokeDasharray: "3 3" }),
      Plot.ruleX([tpX2], { stroke: "#bbb", strokeDasharray: "3 3" }),
      Plot.line(c.rows, { x: "Sf", y: "errDelta", stroke: "#e67e22", strokeWidth: 2 }),
      Plot.line(c.rows, { x: "Sf", y: "errGamma", stroke: "#2e7d32", strokeWidth: 2 })
    ]
  })
}

{
  const el = html`<p style="color:#666;font-size:0.85rem;">Both errors are zero at \\(S_t\\) by construction. In realistic tail scenarios they grow fast. Note how the gamma error can be <em>larger</em> in absolute value than the delta error on one side of \\(S_t\\): a parabola fitted at one strike mislocates the curvature contributed by the other.</p>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Summary

{
  const c = tpCore
  const rows = c.legDetails.map(L => html`<tr>
    <td>${L.label}</td>
    <td>${fmtSigned(L.m, 2)}</td>
    <td>${fmt(L.X, 2)}</td>
    <td>${fmt(L.price, 4)}</td>
    <td>${fmt(L.delta, 4)}</td>
    <td>${fmt(L.gamma, 6)}</td>
    <td>${fmt(L.notional, 4)}</td>
  </tr>`)
  const maxErr = (sel) => c.rows.map(sel).reduce((a, b) => Math.abs(b) > Math.abs(a) ? b : a, 0)
  const errDeltaMax = maxErr(r => r.errDelta)
  const errGammaMax = maxErr(r => r.errGamma)

  const el = html`<div><table class="table" style="width:100%;">
    <thead><tr>
      <th>Leg</th><th>\\(m_i\\)</th><th>Strike</th><th>Price</th><th>\\(\\delta_i\\)</th><th>\\(\\gamma_i\\)</th><th>Leg notional</th>
    </tr></thead>
    <tbody>${rows}
      <tr style="background:#f5f5f5;font-weight:700;">
        <td>Portfolio</td><td>—</td><td>—</td>
        <td>${fmt(c.VPF, 4)}</td>
        <td>${fmt(c.delta, 4)}</td>
        <td>${fmt(c.gamma, 6)}</td>
        <td>${fmt(c.VPF, 4)}</td>
      </tr>
    </tbody></table>
    <p style="color:#666;font-size:0.85rem;">Peak approximation error across the plotted range: delta ${fmtSigned(errDeltaMax, 3)}, delta-gamma ${fmtSigned(errGammaMax, 3)}. Even when the portfolio gamma is small in absolute value, the higher-order curvature from multiple strikes produces large errors once \\(S\\) leaves the immediate neighbourhood of \\(S_t\\).</p></div>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Note

Why full valuation. For realistic option books with thousands of contracts at many strikes, the higher-order non-linearities accumulate. There is no reliable way to summarize the book with a single \(\delta\) and \(\gamma\) computed at \(S_t\), so full valuation (Monte Carlo simulation plus exact option repricing under each scenario) becomes the only defensible choice.

References

Christoffersen, Peter F. 2012. Elements of Financial Risk Management. 2nd ed. Academic Press.