Variance-Covariance VaR for a Multi-Asset Portfolio

Matrix-form portfolio VaR and ES for a linear portfolio of four asset classes with editable positions, volatilities, and correlations

For a linear portfolio with \(n\) positions, the dollar change in value is \(\Delta P = \sum_{i=1}^{n} \delta_i \, \Delta x_i\), where \(\delta_i\) is the dollar sensitivity of position \(i\) to risk factor \(i\) and \(\Delta x_i\) is the proportional change in that risk factor. Assuming the factor changes are jointly normal with covariance matrix \(\Sigma_{t+1}\), the portfolio variance is

\[ \sigma_{P,t+1}^{2} \;=\; \delta^{\top}\,\Sigma_{t+1}\,\delta \;=\; \sum_{i=1}^{n}\sum_{j=1}^{n} \delta_i\,\delta_j\,\rho_{ij,t+1}\,\sigma_{i,t+1}\,\sigma_{j,t+1} \]

where \(\delta = (\delta_1, \dots, \delta_n)^{\top}\) is the column vector of dollar sensitivities, \(\sigma_{i,t+1}\) is the one-day-ahead standard deviation of factor \(i\), and \(\rho_{ij,t+1}\) is the correlation between factors \(i\) and \(j\). The \(T\)-trading-day VaR and ES at tail probability \(p\) follow from the standard-normal quantile (Hull 2023, chap. 13)

\[ \text{VaR}^{\,p}_{T} \;=\; -\sigma_{P,t+1}\sqrt{T}\,\Phi_p^{-1}, \qquad \text{ES}^{\,p}_{T} \;=\; \sigma_{P,t+1}\sqrt{T}\,\frac{\phi(\Phi_p^{-1})}{p}, \]

where \(\sigma_{P,t+1} = \sqrt{\sigma_{P,t+1}^{2}}\) is the one-day portfolio standard deviation, \(\Phi_p^{-1}\) is the \(p\)-quantile of the standard normal distribution, and \(\phi(\cdot)\) is the standard normal density.

The defaults below describe a mixed portfolio of equities, government bonds, gold, and a foreign-exchange exposure. All risk measures are dollar amounts.

Tip

How to experiment

Start from the default allocation and change one correlation at a time. Drive the equity-bond correlation from the defensive \(-0.3\) towards \(+0.8\): the portfolio volatility jumps as the hedge breaks down. Then flip the sign of a position (short the S&P) and watch both correlations and the diversification benefit flip as well. The correlation matrix is validated: an entry that would violate positive semi-definiteness is highlighted.

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

qnorm = {
  const a1 = -3.969683028665376e+01, a2 =  2.209460984245205e+02
  const a3 = -2.759285104469687e+02, a4 =  1.383577518672690e+02
  const a5 = -3.066479806614716e+01, a6 =  2.506628277459239e+00
  const b1 = -5.447609879822406e+01, b2 =  1.615858368580409e+02
  const b3 = -1.556989798598866e+02, b4 =  6.680131188771972e+01
  const b5 = -1.328068155288572e+01
  const c1 = -7.784894002430293e-03, c2 = -3.223964580411365e-01
  const c3 = -2.400758277161838e+00, c4 = -2.549732539343734e+00
  const c5 =  4.374664141464968e+00, c6 =  2.938163982698783e+00
  const d1 =  7.784695709041462e-03, d2 =  3.224671290700398e-01
  const d3 =  2.445134137142996e+00, d4 =  3.754408661907416e+00
  const pLow = 0.02425, pHigh = 1 - pLow
  return p => {
    if (p <= 0) return -Infinity
    if (p >= 1) return Infinity
    if (p < pLow) {
      const q = Math.sqrt(-2 * Math.log(p))
      return (((((c1*q+c2)*q+c3)*q+c4)*q+c5)*q+c6) / ((((d1*q+d2)*q+d3)*q+d4)*q+1)
    }
    if (p <= pHigh) {
      const q = p - 0.5, r = q * q
      return (((((a1*r+a2)*r+a3)*r+a4)*r+a5)*r+a6)*q / (((((b1*r+b2)*r+b3)*r+b4)*r+b5)*r+1)
    }
    const q = Math.sqrt(-2 * Math.log(1 - p))
    return -(((((c1*q+c2)*q+c3)*q+c4)*q+c5)*q+c6) / ((((d1*q+d2)*q+d3)*q+d4)*q+1)
  }
}

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

fmtMoney = x => {
  if (!isFinite(x) || isNaN(x)) return "N/A"
  const sign = x < 0 ? "-" : ""
  const a = Math.abs(x)
  if (a >= 1e6) return sign + "$" + (a/1e6).toFixed(3) + "M"
  if (a >= 1e3) return sign + "$" + (a/1e3).toFixed(2) + "k"
  return sign + "$" + a.toFixed(2)
}

Portfolio composition

viewof vcPosSPX = Inputs.range([-20, 20], { label: "Position 1: US equities ($M)", step: 0.5, value: 5.0 })

viewof vcPosBond = Inputs.range([-20, 20], { label: "Position 2: 10Y Treasuries ($M)", step: 0.5, value: 8.0 })

viewof vcPosGold = Inputs.range([-20, 20], { label: "Position 3: Gold ($M)", step: 0.5, value: 2.0 })

viewof vcPosEUR = Inputs.range([-20, 20], { label: "Position 4: EUR/USD ($M)", step: 0.5, value: 3.0 })

viewof vcSig1 = Inputs.range([0.1, 3.0], { label: "σ₁ equities (%/day)", step: 0.05, value: 1.20 })

viewof vcSig2 = Inputs.range([0.05, 1.5], { label: "σ₂ bonds (%/day)", step: 0.01, value: 0.40 })

viewof vcSig3 = Inputs.range([0.1, 3.0], { label: "σ₃ gold (%/day)", step: 0.05, value: 1.00 })

viewof vcSig4 = Inputs.range([0.05, 2.0], { label: "σ₄ EUR/USD (%/day)", step: 0.05, value: 0.50 })

viewof vcRho12 = Inputs.range([-1, 1], { label: "ρ(eq, bond)", step: 0.01, value: -0.30 })

viewof vcRho13 = Inputs.range([-1, 1], { label: "ρ(eq, gold)", step: 0.01, value: -0.10 })

viewof vcRho14 = Inputs.range([-1, 1], { label: "ρ(eq, EUR)", step: 0.01, value: 0.30 })

viewof vcRho23 = Inputs.range([-1, 1], { label: "ρ(bond, gold)", step: 0.01, value: 0.20 })

viewof vcRho24 = Inputs.range([-1, 1], { label: "ρ(bond, EUR)", step: 0.01, value: -0.10 })

viewof vcRho34 = Inputs.range([-1, 1], { label: "ρ(gold, EUR)", step: 0.01, value: 0.40 })

viewof vcHorizon = Inputs.range([1, 20], { label: "Horizon T (trading days)", step: 1, value: 10 })

viewof vcTail = Inputs.range([0.1, 10], { label: "Tail probability p (%)", step: 0.1, value: 1.0 })

vcNames = ["Equities", "Bonds", "Gold", "EUR/USD"]

vcCore = {
  const delta = [vcPosSPX, vcPosBond, vcPosGold, vcPosEUR].map(x => x * 1e6)
  const sigDaily = [vcSig1, vcSig2, vcSig3, vcSig4].map(x => x / 100)

  const rho = [
    [1,       vcRho12, vcRho13, vcRho14],
    [vcRho12, 1,       vcRho23, vcRho24],
    [vcRho13, vcRho23, 1,       vcRho34],
    [vcRho14, vcRho24, vcRho34, 1      ]
  ]

  const n = 4
  const cov = Array.from({length: n}, () => new Array(n).fill(0))
  for (let i = 0; i < n; i++)
    for (let j = 0; j < n; j++)
      cov[i][j] = sigDaily[i] * sigDaily[j] * rho[i][j]

  // Portfolio variance (daily)
  let pv = 0
  for (let i = 0; i < n; i++)
    for (let j = 0; j < n; j++)
      pv += delta[i] * delta[j] * cov[i][j]

  const pSigma = Math.sqrt(Math.max(0, pv))

  const p = vcTail / 100
  const T = vcHorizon
  const zp = Math.abs(qnorm(p))
  const esMult = normalPDF(qnorm(p)) / p

  const pVaR = pSigma * Math.sqrt(T) * zp
  const pES  = pSigma * Math.sqrt(T) * esMult

  // Individual dollar VaRs / ESs (stand-alone)
  const indVaR = delta.map((d, i) => Math.abs(d) * sigDaily[i] * Math.sqrt(T) * zp)
  const indES  = delta.map((d, i) => Math.abs(d) * sigDaily[i] * Math.sqrt(T) * esMult)
  const sumVaR = indVaR.reduce((a, b) => a + b, 0)
  const sumES  = indES.reduce((a, b) => a + b, 0)

  // Component VaR: C_i = (δ_i * (Σ δ)_i / σ_P) × √T × z_p
  const Sd = new Array(n).fill(0)
  for (let i = 0; i < n; i++)
    for (let j = 0; j < n; j++)
      Sd[i] += cov[i][j] * delta[j]
  const compVaR = delta.map((d, i) =>
    pSigma > 0 ? (d * Sd[i] / pSigma) * Math.sqrt(T) * zp : 0
  )
  const compES = delta.map((d, i) =>
    pSigma > 0 ? (d * Sd[i] / pSigma) * Math.sqrt(T) * esMult : 0
  )

  // Cholesky-based PSD check: attempt L L^T = rho; fails iff any leading
  // principal minor is not positive definite. Sufficient condition for PSD,
  // unlike a determinant check which can be positive with two negative
  // eigenvalues. Also returns the smallest pivot, as a proxy for "distance"
  // from the PSD boundary.
  const cholesky = (A) => {
    const nn = A.length
    const L = Array.from({length: nn}, () => new Array(nn).fill(0))
    let minPivot = Infinity
    for (let i = 0; i < nn; i++) {
      for (let j = 0; j <= i; j++) {
        let sum = 0
        for (let k = 0; k < j; k++) sum += L[i][k] * L[j][k]
        if (i === j) {
          const pivot = A[i][i] - sum
          if (pivot < minPivot) minPivot = pivot
          if (pivot < -1e-10) return { ok: false, minPivot }
          L[i][j] = Math.sqrt(Math.max(pivot, 0))
        } else {
          L[i][j] = L[j][j] > 1e-12 ? (A[i][j] - sum) / L[j][j] : 0
        }
      }
    }
    return { ok: true, minPivot }
  }
  const chol = cholesky(rho)

  return {
    delta, sigDaily, rho, cov,
    pVar: pv, pSigma, pVaR, pES,
    indVaR, indES, sumVaR, sumES,
    compVaR, compES,
    divBenVaR: sumVaR - pVaR,
    divBenES:  sumES  - pES,
    divBenVaRPct: sumVaR > 0 ? 100 * (sumVaR - pVaR) / sumVaR : 0,
    divBenESPct:  sumES  > 0 ? 100 * (sumES  - pES)  / sumES  : 0,
    T, zp, esMult, p,
    psdOK: chol.ok,
    minPivot: chol.minPivot
  }
}

{
  if (vcCore.psdOK) return html`<div></div>`
  return html`<div style="padding:10px 14px; border-left:4px solid #c0392b; background:#fdecea; color:#922; margin:8px 0;">
    <strong>⚠ Correlation matrix is not positive semi-definite</strong><br/>
    <span style="font-size:0.88rem;">The Cholesky decomposition failed (smallest pivot ${fmt(vcCore.minPivot, 4)}, should be ≥ 0). The implied covariance matrix is inconsistent: some portfolio variance is negative. Adjust the correlations until the matrix becomes valid.</span>
  </div>`
}

Diversification

{
  const c = vcCore
  const M = 1e6

  const rows = vcNames.map((name, i) => ({
    asset: name,
    standalone: c.indVaR[i] / M,
    component: c.compVaR[i] / M
  }))

  const cats = vcNames
  const barWidth = 0.35
  const bars = []
  for (let i = 0; i < cats.length; i++) {
    bars.push({ x1: i - barWidth, x2: i - 0.02, y: rows[i].standalone, kind: "Stand-alone" })
    bars.push({ x1: i + 0.02, x2: i + barWidth, y: rows[i].component, kind: "Component" })
  }

  return Plot.plot({
    height: 380, marginLeft: 70, marginRight: 20, marginBottom: 40,
    x: { label: null, domain: [-0.6, cats.length - 0.4], ticks: cats.map((_, i) => i), tickFormat: d => cats[d] },
    y: { label: "$ VaR ($M)", grid: true },
    color: { legend: true, domain: ["Stand-alone", "Component"], range: ["#aaa", "#2f71d5"] },
    marks: [
      Plot.ruleY([0]),
      Plot.rectY(bars, { x1: "x1", x2: "x2", y: "y", fill: "kind", fillOpacity: 0.85 })
    ]
  })
}

{
  const c = vcCore
  const M = 1e6
  return html`<div style="display:flex;gap:16px;flex-wrap:wrap;justify-content:center;margin-top:8px;">
    <div style="padding:12px 20px;border-radius:8px;background:#f5f5f5;text-align:center;">
      <div style="font-size:0.8rem;color:#666;">Sum of stand-alone VaRs</div>
      <div style="font-size:1.2em;font-weight:600;">${fmtMoney(c.sumVaR)}</div>
    </div>
    <div style="padding:12px 20px;border-radius:8px;background:#e3f2fd;text-align:center;">
      <div style="font-size:0.8rem;color:#666;">Portfolio VaR</div>
      <div style="font-size:1.2em;font-weight:700;color:#2f71d5;">${fmtMoney(c.pVaR)}</div>
    </div>
    <div style="padding:12px 20px;border-radius:8px;background:#fff3e0;text-align:center;">
      <div style="font-size:0.8rem;color:#666;">Diversification benefit</div>
      <div style="font-size:1.2em;font-weight:700;color:#e67e22;">${fmtMoney(c.divBenVaR)}</div>
      <div style="font-size:0.8rem;color:#666;">(${fmt(c.divBenVaRPct, 1)}% reduction)</div>
    </div>
  </div>`
}

html`<p style="color:#666;font-size:0.85rem;">Grey bars show each position's <strong>stand-alone</strong> VaR, computed as if the asset were the only thing in the portfolio. Blue bars show the <strong>component VaR</strong>, which sums to the total portfolio VaR (Euler decomposition) and reflects the marginal contribution of each position after accounting for correlations. Component VaRs can be negative when a position hedges the rest of the book.</p>`

Correlation heat map

{
  const cells = []
  for (let i = 0; i < 4; i++)
    for (let j = 0; j < 4; j++)
      cells.push({ i, j, row: vcNames[i], col: vcNames[j], rho: vcCore.rho[i][j] })

  return Plot.plot({
    height: 320, marginLeft: 90, marginRight: 30, marginBottom: 70,
    x: { label: null, domain: vcNames, tickRotate: -30 },
    y: { label: null, domain: vcNames },
    color: { scheme: "rdbu", domain: [-1, 1], reverse: true, legend: true, label: "ρ" },
    marks: [
      Plot.cell(cells, { x: "col", y: "row", fill: "rho", inset: 1 }),
      Plot.text(cells, {
        x: "col", y: "row", text: d => d.rho.toFixed(2),
        fill: d => Math.abs(d.rho) > 0.6 ? "white" : "#111",
        fontSize: 12, fontWeight: 600
      })
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">Cells show pairwise correlations. Blue indicates positive correlation, red negative. Negative correlations (equity-bond, equity-gold) are the source of most of the diversification benefit in the default allocation.</p>`

Matrix view

{
  const c = vcCore
  const M = 1e6
  const headerStyle = "padding:6px 10px;background:#f5f5f5;border-bottom:1px solid #ddd;text-align:right;font-weight:600;"
  const cellStyle = "padding:6px 10px;text-align:right;border-bottom:1px solid #eee;"

  const covTable = `
    <div style="overflow-x:auto;">
    <table style="border-collapse:collapse;width:100%;font-size:0.85rem;">
    <thead><tr>
      <th style="${headerStyle}text-align:left;">Covariance (×10⁻⁴)</th>
      ${vcNames.map(n => `<th style="${headerStyle}">${n}</th>`).join("")}
    </tr></thead>
    <tbody>
      ${vcNames.map((name, i) => `<tr>
        <td style="${cellStyle}text-align:left;font-weight:600;">${name}</td>
        ${vcNames.map((_, j) => `<td style="${cellStyle}">${fmt(c.cov[i][j] * 1e4, 4)}</td>`).join("")}
      </tr>`).join("")}
    </tbody>
    </table>
    </div>
  `

  const posTable = `
    <div style="overflow-x:auto;margin-top:16px;">
    <table style="border-collapse:collapse;width:100%;font-size:0.85rem;">
    <thead><tr>
      <th style="${headerStyle}text-align:left;">Position</th>
      <th style="${headerStyle}">δᵢ ($M)</th>
      <th style="${headerStyle}">σᵢ (%/day)</th>
      <th style="${headerStyle}">Stand-alone VaR</th>
      <th style="${headerStyle}">Component VaR</th>
      <th style="${headerStyle}">Share of portfolio VaR</th>
    </tr></thead>
    <tbody>
      ${vcNames.map((name, i) => `<tr>
        <td style="${cellStyle}text-align:left;font-weight:600;">${name}</td>
        <td style="${cellStyle}">${fmt(c.delta[i] / M, 2)}</td>
        <td style="${cellStyle}">${fmt(c.sigDaily[i] * 100, 2)}</td>
        <td style="${cellStyle}">${fmtMoney(c.indVaR[i])}</td>
        <td style="${cellStyle}">${fmtMoney(c.compVaR[i])}</td>
        <td style="${cellStyle}">${c.pVaR > 0 ? fmt(100 * c.compVaR[i] / c.pVaR, 1) + "%" : "—"}</td>
      </tr>`).join("")}
      <tr style="font-weight:700;background:#f5f5f5;">
        <td style="${cellStyle}text-align:left;">Portfolio</td>
        <td style="${cellStyle}">${fmt(c.delta.reduce((a, b) => a + b, 0) / M, 2)}</td>
        <td style="${cellStyle}">—</td>
        <td style="${cellStyle}">${fmtMoney(c.sumVaR)}<br/><span style="font-size:0.8rem;font-weight:400;color:#666;">(undiversified)</span></td>
        <td style="${cellStyle}">${fmtMoney(c.pVaR)}</td>
        <td style="${cellStyle}">100%</td>
      </tr>
    </tbody>
    </table>
    </div>
  `

  return html`<div>${html([covTable])}${html([posTable])}</div>`
}

{
  const el = html`<p style="color:#666;font-size:0.85rem;">The covariance matrix is \\(\\sigma_{i,t+1}\\sigma_{j,t+1}\\rho_{ij,t+1}\\) for \\(i,j = 1,\\dots,4\\). Portfolio variance is \\(\\delta^\\top\\Sigma_{t+1}\\delta\\), where \\(\\delta\\) is the dollar position vector. The component VaR column uses Euler's theorem: each column sums to the portfolio VaR and gives the sensitivity of VaR to a proportional change in each position.</p>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Summary

{
  const c = vcCore
  const el = html`<table class="table" style="width:100%;">
    <thead><tr>
      <th>Measure</th>
      <th>Portfolio</th>
      <th>Sum of stand-alone</th>
      <th>Diversification benefit</th>
    </tr></thead>
    <tbody>
      <tr>
        <td style="font-weight:500;">σ (daily)</td>
        <td style="font-weight:700;">${fmtMoney(c.pSigma)}</td>
        <td>—</td>
        <td>—</td>
      </tr>
      <tr>
        <td style="font-weight:500;">${c.T}-day VaR (${fmt(c.p * 100, 1)}%)</td>
        <td style="font-weight:700;color:#2f71d5;">${fmtMoney(c.pVaR)}</td>
        <td>${fmtMoney(c.sumVaR)}</td>
        <td>${fmtMoney(c.divBenVaR)} (${fmt(c.divBenVaRPct, 1)}%)</td>
      </tr>
      <tr>
        <td style="font-weight:500;">${c.T}-day ES (${fmt(c.p * 100, 1)}%)</td>
        <td style="font-weight:700;color:#2f71d5;">${fmtMoney(c.pES)}</td>
        <td>${fmtMoney(c.sumES)}</td>
        <td>${fmtMoney(c.divBenES)} (${fmt(c.divBenESPct, 1)}%)</td>
      </tr>
    </tbody></table>
    <p style="color:#666;font-size:0.85rem;">Computed under multivariate normality with tail probability ${fmt(c.p * 100, 1)}% and a ${c.T}-trading-day horizon. Portfolio σ is the square root of \\(\\delta^\\top\\Sigma_{t+1}\\delta\\).</p>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Note

Limitations. The variance-covariance approach assumes the \(\Delta x_i\) are jointly normal and that the portfolio is linear in the factors. It underestimates tail risk when returns are fat-tailed (see Stylized facts of asset returns) and breaks down entirely when the portfolio contains options (see the next three pages on delta, gamma, and full-valuation methods).

References

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