Both worlds: forward contract scenario analysis

Interactive demonstration of why scenario analysis for derivatives requires both real-world and risk-neutral frameworks

Sometimes a scenario analysis requires both the real world and the risk-neutral world (see Hull 2023, chap. 10). Consider a financial institution with a short forward contract (obligation to sell shares at delivery price \(K\) at maturity \(T\)). To assess how much the position could lose at a future horizon \(T_h < T\):

1. Step 1 (Real world): Generate the probability distribution for the stock price at the horizon \(T_h\), using the real-world expected return \(\mu\).
2. Step 2 (Risk-neutral): For each possible stock price at \(T_h\), value the forward contract using risk-neutral valuation (see derivation below).

The worst-case loss combines the real-world worst-case stock price with risk-neutral valuation of the remaining contract.

Valuing the short forward at the horizon

At maturity \(T\), the short forward’s payoff is \(K - S_T\). Applying risk-neutral valuation at time \(T_h\):

\[ f = e^{-r(T - T_h)}\,\hat{E}(K - S_T) \]

In the risk-neutral world, the expected stock price at \(T\) given \(S_{T_h}\) is \(\hat{E}(S_T) = S_{T_h}\,e^{r(T - T_h)}\). Substituting:

\[ f = e^{-r(T - T_h)}\!\left[K - S_{T_h}\,e^{r(T - T_h)}\right] = Ke^{-r(T - T_h)} - S_{T_h} \]

Intuitively: \(Ke^{-r(T - T_h)}\) is the present value (at \(T_h\)) of the delivery price you will receive, and \(S_{T_h}\) is the current cost of the stock you are obligated to deliver. The short forward’s value is the difference.

Tip

How to experiment

1. Increase \(\mu\) to see the worst-case stock price move higher (worse for the short forward).
2. Increase \(\sigma\) to widen the range of scenarios.
3. Change the horizon \(T_h\) to see how the risk changes over time.

viewof fwdS0 = Inputs.range([10, 200], {
  label: "Current stock price S₀ ($)",
  step: 5,
  value: 50
})

viewof fwdK = Inputs.range([10, 200], {
  label: "Delivery price K ($)",
  step: 5,
  value: 55
})

viewof fwdR = Inputs.range([0.01, 0.10], {
  label: "Risk-free rate r (per year)",
  step: 0.01,
  value: 0.03
})

viewof fwdMu = Inputs.range([0.01, 0.25], {
  label: "Real-world expected return μ (per year)",
  step: 0.01,
  value: 0.10
})

viewof fwdSigma = Inputs.range([0.05, 0.60], {
  label: "Volatility σ (per year)",
  step: 0.01,
  value: 0.30
})

viewof fwdTc = Inputs.range([1, 5], {
  label: "Contract maturity T (years)",
  step: 0.5,
  value: 2
})

viewof fwdTh = Inputs.range([0.25, 4.5], {
  label: "Scenario horizon Th (years)",
  step: 0.25,
  value: 0.5
})

viewof fwdConf = Inputs.range([0.90, 0.99], {
  label: "Confidence level",
  step: 0.01,
  value: 0.99
})

// Inverse normal CDF (rational approximation, Beasley-Springer-Moro)
norminv = p => {
  if (p <= 0) return -Infinity
  if (p >= 1) return Infinity
  if (p === 0.5) return 0
  const a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
    1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00]
  const b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
    6.680131188771972e+01, -1.328068155288572e+01]
  const c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
    -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00]
  const d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00,
    3.754408661907416e+00]
  const pLow = 0.02425, pHigh = 1 - pLow
  let q, r
  if (p < pLow) {
    q = Math.sqrt(-2 * Math.log(p))
    return (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
      ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
  } else if (p <= pHigh) {
    q = p - 0.5
    r = q * q
    return (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q /
      (((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1)
  } else {
    q = Math.sqrt(-2 * Math.log(1 - p))
    return -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
      ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
  }
}

// Compute lognormal PDF for given parameters
lognormalPDF = (S0, mu, sigma, T, nPts) => {
  const meanLog = Math.log(S0) + (mu - sigma ** 2 / 2) * T
  const sdLog = sigma * Math.sqrt(T)
  const meanST = S0 * Math.exp(mu * T)
  const sdST = meanST * Math.sqrt(Math.exp(sigma ** 2 * T) - 1)
  const xMax = meanST + 4 * sdST
  const xMin = Math.max(0.01, meanST - 3.5 * sdST)
  const dx = (xMax - xMin) / nPts
  const pts = []
  for (let i = 0; i <= nPts; i++) {
    const x = xMin + i * dx
    if (x <= 0) continue
    const logx = Math.log(x)
    const pdf = (1 / (x * sdLog * Math.sqrt(2 * Math.PI))) *
      Math.exp(-0.5 * ((logx - meanLog) / sdLog) ** 2)
    pts.push({ x, pdf })
  }
  return pts
}

fwdThEff = Math.min(fwdTh, fwdTc - 0.25)
fwdRemaining = fwdTc - fwdThEff

// Current value of short forward: Ke^{-rT} - S0
fwdCurrentValue = fwdK * Math.exp(-fwdR * fwdTc) - fwdS0

fwdQ = 1 - fwdConf
fwdWorstS = fwdS0 * Math.exp((fwdMu - fwdSigma ** 2 / 2) * fwdThEff - norminv(fwdQ) * fwdSigma * Math.sqrt(fwdThEff))

// Forward value at horizon for worst-case stock price: Ke^{-r(T - T_h)} - S_{T_h}
fwdWorstValue = fwdK * Math.exp(-fwdR * fwdRemaining) - fwdWorstS

// Distribution of forward values across stock price scenarios
fwdScenarios = {
  const meanLog = Math.log(fwdS0) + (fwdMu - fwdSigma ** 2 / 2) * fwdThEff
  const sdLog = fwdSigma * Math.sqrt(fwdThEff)
  const pts = []
  // Generate stock price quantiles from 0.5% to 99.5%
  for (let pctile = 0.5; pctile <= 99.5; pctile += 0.5) {
    const z = norminv(pctile / 100)
    const S = Math.exp(meanLog + z * sdLog)
    const fwdVal = fwdK * Math.exp(-fwdR * fwdRemaining) - S
    pts.push({ percentile: pctile, stockPrice: S, forwardValue: fwdVal })
  }
  return pts
}

fmtDollar = v => v.toFixed(2)

Stock price scenarios (real world)

fwdStockPDF = lognormalPDF(fwdS0, fwdMu, fwdSigma, fwdThEff, 400)

Plot.plot({
  height: 300,
  marginLeft: 50,
  marginRight: 20,
  x: { label: `Stock price at horizon Th = ${fwdThEff} years ($)`, grid: false },
  y: { label: "Density", grid: true },
  marks: [
    Plot.areaY(fwdStockPDF.filter(d => d.x >= fwdWorstS), {
      x: "x", y: "pdf",
      fill: "#d62728", fillOpacity: 0.2,
      curve: "natural"
    }),
    Plot.line(fwdStockPDF, {
      x: "x", y: "pdf",
      stroke: "#4682b4", strokeWidth: 2.5, curve: "natural"
    }),
    Plot.ruleX([fwdWorstS], { stroke: "#d62728", strokeWidth: 2, strokeDash: [6, 3] }),
    Plot.text([{ x: fwdWorstS, label: `$${fmtDollar(fwdWorstS)}` }], {
      x: "x",
      y: fwdStockPDF.reduce((m, d) => Math.max(m, d.pdf), 0) * 0.85,
      text: "label", fill: "#d62728", fontWeight: "bold", fontSize: 11, dx: 5, textAnchor: "start"
    })
  ]
})

The shaded tail shows the \({(fwdQ * 100).toFixed(0)}% worst-case region. The worst-case stock price is **\)** (computed in the real world using μ = %).

Forward value distribution (risk-neutral)

Plot.plot({
  height: 300,
  marginLeft: 60,
  marginRight: 20,
  x: { label: "Forward contract value at horizon ($)", grid: false,
    tickFormat: d => (d / 1).toFixed(0) },
  y: { label: "Stock price percentile (%)", grid: true },
  marks: [
    Plot.ruleX([0], { stroke: "#888", strokeOpacity: 0.4 }),
    Plot.line(fwdScenarios, {
      x: "forwardValue", y: "percentile",
      stroke: "#4682b4", strokeWidth: 2.5
    }),
    Plot.dot([{ forwardValue: fwdWorstValue, percentile: fwdConf * 100 }], {
      x: "forwardValue", y: "percentile",
      fill: "#d62728", r: 5,
      tip: true,
      title: d => `${fwdConf * 100}th percentile worst case\nForward value: $${fmtDollar(d.forwardValue)}`
    }),
    Plot.ruleX([fwdCurrentValue], { stroke: "#2ca02c", strokeDash: [4, 4], strokeOpacity: 0.6 }),
    Plot.text([{ x: fwdCurrentValue, label: `Current: $${fmtDollar(fwdCurrentValue)}` }], {
      x: "x", y: 90,
      text: "label", fill: "#2ca02c", fontSize: 10, dx: 5, textAnchor: "start"
    })
  ]
})

Each point on the curve shows the forward contract value for a given stock price percentile. The red dot marks the worst-case value at the % confidence level.

Summary

html`<table class="table" style="width:100%;">
<thead><tr><th colspan="2">Forward contract scenario analysis</th></tr></thead>
<tbody>
<tr><td style="font-weight:500;">Current short forward value</td><td>$${fmtDollar(fwdCurrentValue)}</td></tr>
<tr><td style="font-weight:500;">Worst-case stock price at T<sub>h</sub> (real world)</td><td>$${fmtDollar(fwdWorstS)}</td></tr>
<tr><td style="font-weight:500;">Remaining contract life (T − T<sub>h</sub>)</td><td>${fwdRemaining.toFixed(2)} years</td></tr>
<tr><td style="font-weight:500;">Worst-case forward value (risk-neutral)</td><td>$${fmtDollar(fwdWorstValue)}</td></tr>
<tr style="border-top: 2px solid #888;"><td style="font-weight:700;">Worst-case loss</td><td style="font-weight:700;">$${fmtDollar(fwdCurrentValue - fwdWorstValue)}</td></tr>
</tbody></table>
<p style="margin-top:0.5rem; color:#666; font-size:0.85rem;">The worst-case stock price was computed in the <strong>real world</strong> (Step 1). The forward contract was then valued using <strong>risk-neutral valuation</strong> (Step 2). Neither world alone would produce the correct answer.</p>`

Note

Why both worlds are needed

The real world generates realistic scenarios for what might actually happen to the stock price. But once we know the stock price at the horizon, we need risk-neutral valuation to determine what the forward contract (with remaining life) would be worth at that point. Using the real-world expected return for valuation would give incorrect derivative prices; using the risk-neutral expected return for scenario generation would underestimate the probability of adverse outcomes.

References

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