Merton Model from Equity Data

Solve the two-equation Merton system numerically from observable equity value and equity volatility to recover asset value, asset volatility, distance to default and risk-neutral PD

For a publicly traded firm the asset value \(V_0\) and asset volatility \(\sigma_V\) are not directly observable, but the equity value \(E_0\) and equity return volatility \(\sigma_E\) usually are. Merton’s model provides two equations linking the four quantities (Christoffersen 2012, chap. 12; Hull 2023, chap. 17):

\[ E_0 = V_0\,\Phi(d_1) - D\,e^{-rT}\,\Phi(d_2) \]

\[ \sigma_E\,E_0 = \Phi(d_1)\,\sigma_V\,V_0 \]

where \(d_1 = [\ln(V_0/D) + (r + \sigma_V^2/2)T] / (\sigma_V\sqrt{T})\) and \(d_2 = d_1 - \sigma_V\sqrt{T}\). The second equation follows from Itô’s lemma applied to \(E(V, t)\) and captures the fact that equity is a leveraged claim on assets.

The system is nonlinear but well behaved. Any root-finding routine works — we solve it in the browser with a damped Newton iteration so that the results update as you move the sliders.

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)
}

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

pctFmt = (x, d = 2) => (x * 100).toFixed(d) + "%"

mertonSolve = (E0, sigmaE, D, T, r) => {
  // Solve for (V0, sigmaV) such that:
  //   F1 = V0 Φ(d1) - D e^{-rT} Φ(d2) - E0 = 0
  //   F2 = Φ(d1) σV V0 - σE E0 = 0
  // Use finite-difference Jacobian + damped Newton, with a fallback to Nelder–Mead-ish coordinate search.
  const f = (V0, sV) => {
    const d1 = (Math.log(V0 / D) + (r + sV * sV / 2) * T) / (sV * Math.sqrt(T))
    const d2 = d1 - sV * Math.sqrt(T)
    const F1 = V0 * normalCDF(d1) - D * Math.exp(-r * T) * normalCDF(d2) - E0
    const F2 = normalCDF(d1) * sV * V0 - sigmaE * E0
    return [F1, F2, d1, d2]
  }
  // Initial guess
  let V0 = E0 + D * Math.exp(-r * T)
  let sV = sigmaE * E0 / V0
  if (!(sV > 0.01)) sV = 0.05

  const h = 1e-5
  let converged = false
  let iters = 0
  for (let k = 0; k < 200; k++) {
    iters = k + 1
    const [F1, F2] = f(V0, sV)
    const norm = Math.abs(F1) + Math.abs(F2)
    if (norm < 1e-9) { converged = true; break }
    const [F1a] = f(V0 + h, sV)
    const [F1b] = f(V0, sV + h)
    const [, F2a] = f(V0 + h, sV)
    const [, F2b] = f(V0, sV + h)
    const J11 = (F1a - F1) / h
    const J12 = (F1b - F1) / h
    const J21 = (F2a - F2) / h
    const J22 = (F2b - F2) / h
    const det = J11 * J22 - J12 * J21
    if (Math.abs(det) < 1e-14) break
    let dV = (J22 * F1 - J12 * F2) / det
    let dS = (-J21 * F1 + J11 * F2) / det
    // Damping
    let step = 1
    while (step > 1e-3) {
      const V0n = V0 - step * dV
      const sVn = sV - step * dS
      if (V0n > 1e-6 && sVn > 1e-4) {
        const [F1n, F2n] = f(V0n, sVn)
        if (Math.abs(F1n) + Math.abs(F2n) < norm) {
          V0 = V0n; sV = sVn
          break
        }
      }
      step *= 0.5
    }
    if (step <= 1e-3) break
  }
  const [F1, F2, d1, d2] = f(V0, sV)
  const PD = normalCDF(-d2)
  const D0 = D * Math.exp(-r * T) * normalCDF(d2) + V0 * normalCDF(-d1)
  const yCorp = -Math.log(D0 / D) / T
  return {
    V0, sigmaV: sV, d1, d2, PD, dd: d2, D0,
    D0_rf: D * Math.exp(-r * T),
    creditSpread: yCorp - r,
    residualE: F1, residualVol: F2,
    converged, iters
  }
}

Inputs

Tip

How to experiment

Pick a firm with a known capital structure. Equity volatility above 60% with moderate leverage usually implies an asset volatility well below it — equity amplifies asset moves by roughly \(V_0 / E_0\). Crank \(\sigma_E\) up to 100% and watch the implied PD rise sharply. Reduce \(E_0\) toward zero to enter the “near-bankruptcy” region: leverage explodes, \(V_0 \to D\,e^{-rT}\) from above, and \(\sigma_V/\sigma_E \to 0\) (a very leveraged equity claim gets a lot of volatility from a small amount of asset volatility). Conversely, raise \(E_0\) well above \(D\): leverage falls toward 1, \(\Phi(d_1) \to 1\), and \(\sigma_V/\sigma_E \to 1\) — the unlevered limit.

viewof miE0 = Inputs.range([0.1, 50], {
  label: "E₀ equity market value",
  step: 0.1,
  value: 4
})

viewof miSigmaE = Inputs.range([0.05, 1.5], {
  label: "σ_E equity return volatility",
  step: 0.01,
  value: 0.50
})

viewof miD = Inputs.range([0.1, 100], {
  label: "D face value of debt",
  step: 0.1,
  value: 12
})

viewof miT = Inputs.range([0.25, 10], {
  label: "T horizon (years)",
  step: 0.25,
  value: 2
})

viewof miR = Inputs.range([0.0, 0.10], {
  label: "r risk-free rate",
  step: 0.001,
  value: 0.05
})

miSol = mertonSolve(miE0, miSigmaE, miD, miT, miR)

{
  const s = miSol
  const leverage = (s.V0 / miE0)
  const statusColor = s.converged ? "#2e7d32" : "#d62728"
  const statusLabel = s.converged ? "converged" : "did not fully converge"
  return html`<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px;margin-top:8px;">
  <div style="padding:12px 16px;border-radius:8px;background:#e3f2fd;">
    <div style="font-size:0.8rem;color:#666;">Asset value V₀</div>
    <div style="font-size:1.4em;font-weight:700;color:#2f71d5;">${fmt(s.V0, 3)}</div>
    <div style="font-size:0.8rem;color:#666;">Leverage V₀/E₀ = ${fmt(leverage, 2)}×</div>
  </div>
  <div style="padding:12px 16px;border-radius:8px;background:#e8f5e9;">
    <div style="font-size:0.8rem;color:#666;">Asset volatility σ_V</div>
    <div style="font-size:1.4em;font-weight:700;color:#2e7d32;">${pctFmt(s.sigmaV, 2)}</div>
    <div style="font-size:0.8rem;color:#666;">σ_V / σ_E = ${fmt(s.sigmaV / miSigmaE, 3)}</div>
  </div>
  <div style="padding:12px 16px;border-radius:8px;background:#fff3e0;">
    <div style="font-size:0.8rem;color:#666;">Distance to default</div>
    <div style="font-size:1.4em;font-weight:700;color:#e67e22;">${fmt(s.dd, 3)}</div>
    <div style="font-size:0.8rem;color:#666;">d₁ = ${fmt(s.d1, 3)}, d₂ = ${fmt(s.d2, 3)}</div>
  </div>
  <div style="padding:12px 16px;border-radius:8px;background:#fbe9e7;">
    <div style="font-size:0.8rem;color:#666;">Risk-neutral PD</div>
    <div style="font-size:1.4em;font-weight:700;color:#d62728;">${pctFmt(s.PD, 3)}</div>
    <div style="font-size:0.8rem;color:#666;">Φ(−d₂)</div>
  </div>
  <div style="padding:12px 16px;border-radius:8px;background:#ede7f6;">
    <div style="font-size:0.8rem;color:#666;">Credit spread</div>
    <div style="font-size:1.4em;font-weight:700;color:#5e35b1;">${pctFmt(s.creditSpread, 2)}</div>
    <div style="font-size:0.8rem;color:#666;">D₀ = ${fmt(s.D0, 3)}; risk-free = ${fmt(s.D0_rf, 3)}</div>
  </div>
  <div style="padding:12px 16px;border-radius:8px;background:#f5f7fa;">
    <div style="font-size:0.8rem;color:#666;">Solver</div>
    <div style="font-size:1.1em;font-weight:700;color:${statusColor};">${statusLabel}</div>
    <div style="font-size:0.8rem;color:#666;">${s.iters} iterations; residuals (${fmt(s.residualE, 6)}, ${fmt(s.residualVol, 6)})</div>
  </div>
</div>`
}

How the equity-to-asset volatility ratio moves with leverage

miRatio = {
  // Sweep leverage = V0/E0 with other params fixed. Leverage is highly nonlinear
  // in E0 (small E0 → huge leverage), so we space E0 geometrically to get
  // uniform coverage along the leverage axis.
  const rows = []
  const D = miD, T = miT, r = miR, sE = miSigmaE
  const E0_min = Math.max(0.02, miE0 / 50)
  const E0_max = Math.max(miE0 * 5, D * 2)
  const N = 120
  const logLo = Math.log(E0_min), logHi = Math.log(E0_max)
  for (let i = 0; i < N; i++) {
    const e = Math.exp(logLo + (logHi - logLo) * i / (N - 1))
    const s = mertonSolve(e, sE, D, T, r)
    if (s.converged) {
      rows.push({
        E0: e,
        leverage: s.V0 / e,
        sigmaV: s.sigmaV,
        ratio: s.sigmaV / sE,
        PD: s.PD
      })
    }
  }
  return rows.sort((a, b) => a.leverage - b.leverage)
}

{
  const curr = { E0: miE0, leverage: miSol.V0 / miE0, ratio: miSol.sigmaV / miSigmaE, PD: miSol.PD }
  return Plot.plot({
    height: 320, marginLeft: 60, marginRight: 20,
    x: { label: "Leverage V₀ / E₀", grid: true },
    y: { label: "σ_V / σ_E", grid: true, tickFormat: d => (d * 100).toFixed(1) + "%" },
    marks: [
      Plot.ruleY([0]),
      Plot.line(miRatio, { x: "leverage", y: "ratio", stroke: "#2f71d5", strokeWidth: 2.5 }),
      Plot.dot([curr], { x: "leverage", y: "ratio", r: 5, fill: "#2f71d5", stroke: "white", strokeWidth: 2 })
    ]
  })
}

{
  const curr = { leverage: miSol.V0 / miE0, PD: miSol.PD }
  return Plot.plot({
    height: 320, marginLeft: 60, marginRight: 20,
    x: { label: "Leverage V₀ / E₀", grid: true },
    y: { label: "Risk-neutral PD", grid: true, tickFormat: d => (d * 100).toFixed(1) + "%" },
    marks: [
      Plot.ruleY([0]),
      Plot.line(miRatio, { x: "leverage", y: "PD", stroke: "#d62728", strokeWidth: 2.5 }),
      Plot.dot([curr], { x: "leverage", y: "PD", r: 5, fill: "#d62728", stroke: "white", strokeWidth: 2 })
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">The ratio σ_V / σ_E shrinks with leverage because equity amplifies asset moves. A highly leveraged firm with 50% equity volatility can have asset volatility in the teens. PD rises sharply as leverage rises — the Merton model's central message.</p>`

Note

A sanity check. Christoffersen’s worked example takes \(E_0 = 3\), \(\sigma_E = 0.80\), \(D = 10\), \(T = 1\), \(r = 0.05\) and finds \(V_0 \approx 12.40\), \(\sigma_V \approx 0.2123\), PD \(\approx 12.7\%\). Plug those inputs into the sliders to verify the solver reproduces that result.

References

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

Hull, John. 2023. Risk Management and Financial Institutions. 6th ed. John Wiley & Sons.