DCC Correlation Dynamics

Interactive exploration of Dynamic Conditional Correlation (DCC) models for time-varying correlations between asset returns

The Dynamic Conditional Correlation (DCC) model (Engle 2002; Christoffersen 2012, chap. 7) decomposes the covariance matrix into separate volatility and correlation components:

\[ \Sigma_{t+1} = D_{t+1} \, \Upsilon_{t+1} \, D_{t+1} \]

where \(D_{t+1}\) is the diagonal matrix of GARCH volatilities and \(\Upsilon_{t+1}\) is the correlation matrix with time-varying entries. This decomposition allows separate modeling of volatilities (asset-specific GARCH parameters) and correlations (common DCC persistence parameters).

The correlation dynamics are driven by standardized returns \(z_{i,t} = R_{i,t}/\sigma_{i,t}\), whose conditional covariance equals the conditional correlation:

\[ E_t(z_{i,t+1}\, z_{j,t+1}) = \rho_{ij,t+1} \]

Two specifications are common:

• Exponential smoother DCC: \(q_{ij,t+1} = (1-\lambda)(z_{i,t}\, z_{j,t}) + \lambda\, q_{ij,t}\)
• Mean-reverting DCC: \(q_{ij,t+1} = \bar{\rho}_{ij}(1-\alpha-\beta) + \alpha(z_{i,t}\, z_{j,t}) + \beta\, q_{ij,t}\)

The correlation is obtained by normalization: \(\rho_{ij,t+1} = q_{ij,t+1} / \sqrt{q_{ii,t+1}\, q_{jj,t+1}}\), ensuring \(-1 \leq \rho_{ij,t+1} \leq 1\).

Note

Common persistence parameters. The parameters \(\lambda\) (or \(\alpha, \beta\)) must be identical across all asset pairs. Allowing pair-specific persistence parameters could cause the covariance matrix to lose positive semidefiniteness, producing nonsensical negative portfolio variances. The level of correlation, governed by \(\bar{\rho}_{ij}\), does vary across pairs.

Note

Parameter constraints. For the mean-reverting DCC, the parameters must satisfy \(\alpha \geq 0\), \(\beta \geq 0\), and \(\alpha + \beta < 1\). The last condition ensures stationarity: the correlation mean-reverts to its long-run level \(\bar{\rho}_{ij}\). When \(\alpha + \beta = 1\), the model reduces to the exponential smoother (no mean-reversion). If \(\alpha + \beta \geq 1\), the process becomes non-stationary or explosive. For the exponential smoother, the constraint is simply \(0 < \lambda < 1\).

rng_utils = {
  function mulberry32(seed) {
    return function() {
      seed |= 0; seed = seed + 0x6D2B79F5 | 0
      let t = Math.imul(seed ^ seed >>> 15, 1 | seed)
      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t
      return ((t ^ t >>> 14) >>> 0) / 4294967296
    }
  }
  function boxMuller(rng) {
    const u1 = rng(), u2 = rng()
    return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)
  }
  function gammaSample(rng, shape) {
    if (shape < 1) return gammaSample(rng, shape + 1) * Math.pow(rng(), 1 / shape)
    const d = shape - 1 / 3, c = 1 / Math.sqrt(9 * d)
    while (true) {
      let x, v
      do { x = boxMuller(rng); v = 1 + c * x } while (v <= 0)
      v = v * v * v
      const u = rng()
      if (u < 1 - 0.0331 * (x * x) * (x * x)) return d * v
      if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v
    }
  }
  function stdTSample(rng, d) {
    const normal = boxMuller(rng)
    const chi2 = 2 * gammaSample(rng, d / 2)
    return normal / Math.sqrt(chi2 / d) * Math.sqrt((d - 2) / d)
  }
  return { mulberry32, boxMuller, stdTSample }
}

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

legend = (items) => {
  const el = document.createElement("div")
  el.style.cssText = "display:flex; flex-wrap:wrap; margin-top:-4px; margin-bottom:6px;"
  const hidden = new Set()
  for (const d of items) {
    const key = d.key || d.label
    const span = document.createElement("span")
    span.style.cssText = "display:inline-flex; align-items:center; gap:4px; margin-right:14px; cursor:pointer; user-select:none; transition:opacity 0.15s;"
    let swatchHTML
    if (d.type === "dashed") swatchHTML = `<svg width="22" height="12"><line x1="0" y1="6" x2="22" y2="6" stroke="${d.color}" stroke-width="2" stroke-dasharray="4 2"/></svg>`
    else swatchHTML = `<svg width="22" height="12"><line x1="0" y1="6" x2="22" y2="6" stroke="${d.color}" stroke-width="2"/></svg>`
    span.innerHTML = `${swatchHTML}<span style="font-size:0.82rem;">${d.label}</span>`
    span.addEventListener("click", () => {
      const nowHidden = !hidden.has(key)
      if (nowHidden) hidden.add(key); else hidden.delete(key)
      span.style.opacity = nowHidden ? "0.35" : "1"
      span.querySelector("span").style.textDecoration = nowHidden ? "line-through" : "none"
      el.value = new Set(hidden)
      el.dispatchEvent(new Event("input", {bubbles: true}))
    })
    el.appendChild(span)
  }
  el.value = new Set(hidden)
  return el
}

DCC correlation dynamics

This simulation generates two correlated GARCH(1,1) return series and runs the DCC recursion to compute the dynamic conditional correlation. Observe how the correlation fluctuates around its long-run level and responds to joint large moves.

Tip

How to experiment

Start with the mean-reverting DCC and default parameters. Notice how the correlation fluctuates around \(\bar{\rho}\). Then increase \(\alpha\) to see faster response to shocks, or increase \(\beta\) for more persistence. Switch to the exponential smoother and observe that without mean-reversion, the correlation can drift further from its long-run level. Check the “Stress periods” tab to see how joint negative shocks drive correlations upward.

viewof dccType = Inputs.radio(["Mean-reverting DCC", "Exponential smoother"], {
  label: "DCC specification",
  value: "Mean-reverting DCC"
})

viewof dccLambda = dccType === "Exponential smoother" ? Inputs.range([0.90, 0.99], {
  label: "λ (persistence)",
  step: 0.01,
  value: 0.94
}) : Object.assign(html`<span></span>`, {value: 0.94})

viewof dccAlpha = dccType === "Mean-reverting DCC" ? Inputs.range([0.01, 0.15], {
  label: "α (DCC reaction)",
  step: 0.01,
  value: 0.05
}) : Object.assign(html`<span></span>`, {value: 0.05})

viewof dccBeta = dccType === "Mean-reverting DCC" ? Inputs.range([0.80, 0.98], {
  label: "β (DCC persistence)",
  step: 0.01,
  value: 0.93
}) : Object.assign(html`<span></span>`, {value: 0.93})

{
  if (dccType === "Mean-reverting DCC" && dccAlpha + dccBeta >= 1) {
    return html`<div style="background:#fff3cd;border:1px solid #ffc107;border-radius:6px;padding:8px 12px;margin-bottom:8px;font-size:0.85rem;color:#856404;"><strong>Warning:</strong> α + β = ${fmt(dccAlpha + dccBeta, 2)} ≥ 1. The mean-reverting DCC requires α + β < 1 for stationarity. The correlation process will not mean-revert to ρ̄ and may become explosive.</div>`
  }
  return html`<span></span>`
}

viewof dccRhoBar = Inputs.range([-0.50, 0.90], {
  label: "ρ̄₁₂ (unconditional correlation)",
  step: 0.01,
  value: 0.40
})

viewof dccN = Inputs.range([500, 3000], {
  label: "Sample size",
  step: 100,
  value: 2000
})

viewof dccDist = Inputs.radio(["Normal", "Standardized t"], {
  label: "Shock distribution",
  value: "Normal"
})

viewof dccDf = dccDist === "Standardized t" ? Inputs.range([4, 30], {
  label: "Degrees of freedom d",
  step: 1,
  value: 8
}) : Object.assign(html`<span></span>`, {value: 8})

mutable dccSeed = 0

viewof dccReseed = {
  const btn = html`<button style="background:#2f71d5;color:white;border:none;border-radius:6px;padding:0.35rem 1rem;font-weight:500;font-size:0.9rem;cursor:pointer;">New sample</button>`
  btn.onclick = () => { mutable dccSeed++ }
  return btn
}

// Simulate two correlated GARCH series with DCC
dccSim = {
  dccSeed  // reactivity
  const rng = rng_utils.mulberry32(42 + dccSeed)
  const N = dccN
  const rhoBar = dccRhoBar

  // GARCH parameters for each asset
  const alpha1 = 0.08, beta1 = 0.88, vl1 = (0.015)**2
  const omega1 = vl1 * (1 - alpha1 - beta1)
  const alpha2 = 0.10, beta2 = 0.85, vl2 = (0.020)**2
  const omega2 = vl2 * (1 - alpha2 - beta2)

  // Generate uncorrelated shocks, then correlate with true constant rho
  const sq = Math.sqrt(Math.max(0, 1 - rhoBar * rhoBar))

  const R1 = new Array(N), R2 = new Array(N)
  const sig2_1 = new Array(N), sig2_2 = new Array(N)
  const z1 = new Array(N), z2 = new Array(N)

  sig2_1[0] = vl1
  sig2_2[0] = vl2

  for (let t = 0; t < N; t++) {
    // Generate correlated shocks
    let zu1, zu2
    if (dccDist === "Normal") {
      zu1 = rng_utils.boxMuller(rng)
      zu2 = rng_utils.boxMuller(rng)
    } else {
      zu1 = rng_utils.stdTSample(rng, dccDf)
      zu2 = rng_utils.stdTSample(rng, dccDf)
    }
    const shock1 = zu1
    const shock2 = rhoBar * zu1 + sq * zu2

    R1[t] = Math.sqrt(sig2_1[t]) * shock1
    R2[t] = Math.sqrt(sig2_2[t]) * shock2

    z1[t] = R1[t] / Math.sqrt(sig2_1[t])
    z2[t] = R2[t] / Math.sqrt(sig2_2[t])

    if (t < N - 1) {
      sig2_1[t + 1] = omega1 + alpha1 * R1[t]**2 + beta1 * sig2_1[t]
      sig2_2[t + 1] = omega2 + alpha2 * R2[t]**2 + beta2 * sig2_2[t]
    }
  }

  // Run DCC recursion
  const q11 = new Array(N), q22 = new Array(N), q12 = new Array(N)
  const rho = new Array(N)

  // Initialize
  q11[0] = 1
  q22[0] = 1
  q12[0] = rhoBar

  for (let t = 0; t < N; t++) {
    // Normalize to get correlation
    rho[t] = q12[t] / Math.sqrt(q11[t] * q22[t])

    if (t < N - 1) {
      if (dccType === "Exponential smoother") {
        const lam = dccLambda
        q11[t + 1] = (1 - lam) * z1[t] * z1[t] + lam * q11[t]
        q22[t + 1] = (1 - lam) * z2[t] * z2[t] + lam * q22[t]
        q12[t + 1] = (1 - lam) * z1[t] * z2[t] + lam * q12[t]
      } else {
        const a = dccAlpha, b = dccBeta
        q11[t + 1] = 1 * (1 - a - b) + a * z1[t] * z1[t] + b * q11[t]
        q22[t + 1] = 1 * (1 - a - b) + a * z2[t] * z2[t] + b * q22[t]
        q12[t + 1] = rhoBar * (1 - a - b) + a * z1[t] * z2[t] + b * q12[t]
      }
    }
  }

  // Rolling correlation (window = 60)
  const rollW = 60
  const rollCorr = new Array(N).fill(null)
  for (let t = rollW - 1; t < N; t++) {
    let sz1 = 0, sz2 = 0, sz12 = 0, sz1sq = 0, sz2sq = 0
    for (let k = t - rollW + 1; k <= t; k++) {
      sz1 += z1[k]; sz2 += z2[k]
      sz12 += z1[k] * z2[k]
      sz1sq += z1[k]**2; sz2sq += z2[k]**2
    }
    const m1 = sz1 / rollW, m2 = sz2 / rollW
    const v1 = sz1sq / rollW - m1*m1, v2 = sz2sq / rollW - m2*m2
    const cv = sz12 / rollW - m1*m2
    rollCorr[t] = (v1 > 0 && v2 > 0) ? cv / Math.sqrt(v1 * v2) : null
  }

  return { R1, R2, sig2_1, sig2_2, z1, z2, q11, q22, q12, rho, rollCorr, N }
}

// Plot data
dccPlotData = dccSim.rho.map((r, i) => ({
  t: i + 1,
  rho: r,
  rollCorr: dccSim.rollCorr[i],
  z1: dccSim.z1[i],
  z2: dccSim.z2[i],
  crossProd: dccSim.z1[i] * dccSim.z2[i],
  q11: dccSim.q11[i],
  q22: dccSim.q22[i],
  q12: dccSim.q12[i],
  bothNeg: dccSim.z1[i] < -1.5 && dccSim.z2[i] < -1.5
}))

Dynamic correlation

viewof dccCorrLegend = legend([
  { key: "dcc", label: "DCC correlation", color: "#2f71d5", type: "line" },
  { key: "roll", label: "Rolling correlation (60 days)", color: "#aaa", type: "line" },
  { key: "rhobar", label: "ρ̄ (unconditional)", color: "#d62728", type: "dashed" }
])

{
  const h = dccCorrLegend
  const marks = []

  if (!h.has("rhobar"))
    marks.push(Plot.ruleY([dccRhoBar], { stroke: "#d62728", strokeWidth: 1.5, strokeDasharray: "6 3" }))
  if (!h.has("roll"))
    marks.push(Plot.line(dccPlotData.filter(d => d.rollCorr !== null), { x: "t", y: "rollCorr", stroke: "#aaa", strokeWidth: 1 }))
  if (!h.has("dcc"))
    marks.push(Plot.line(dccPlotData, { x: "t", y: "rho", stroke: "#2f71d5", strokeWidth: 1.5 }))

  return Plot.plot({
    height: 400, marginLeft: 60,
    x: { label: "Day", grid: false },
    y: { label: "Correlation ρ₁₂,t", grid: true, domain: [-1, 1] },
    marks
  })
}

html`<p style="color:#666;font-size:0.85rem;">The <span style="color:#2f71d5;font-weight:700;">DCC correlation</span> responds to market shocks through the cross-product z₁z₂. The <span style="color:#aaa;">rolling 60-day correlation</span> lags behind. The <span style="color:#d62728;font-weight:700;">dashed line</span> shows the unconditional correlation ρ̄ toward which the mean-reverting DCC gravitates.</p>`

Stress periods

{
  const stressData = dccPlotData.filter(d => d.bothNeg)
  const nStress = stressData.length

  const marks = [
    Plot.ruleY([dccRhoBar], { stroke: "#d62728", strokeWidth: 1, strokeDasharray: "6 3" }),
    Plot.line(dccPlotData, { x: "t", y: "rho", stroke: "#2f71d5", strokeWidth: 1.5 })
  ]

  if (nStress > 0) {
    marks.push(Plot.dot(stressData, { x: "t", y: "rho", r: 4, fill: "#d62728", fillOpacity: 0.7 }))
  }

  const plot = Plot.plot({
    height: 400, marginLeft: 60,
    x: { label: "Day", grid: false },
    y: { label: "Correlation ρ₁₂,t", grid: true, domain: [-1, 1] },
    marks
  })

  const cpPlot = Plot.plot({
    height: 200, marginLeft: 60, marginTop: 5,
    x: { label: "Day", grid: false },
    y: { label: "Cross-product z₁z₂", grid: true },
    marks: [
      Plot.ruleY([0], { stroke: "#ddd" }),
      Plot.line(dccPlotData, { x: "t", y: "crossProd", stroke: "#999", strokeWidth: 0.5 }),
      ...(nStress > 0 ? [Plot.dot(stressData, { x: "t", y: "crossProd", r: 3, fill: "#d62728", fillOpacity: 0.7 })] : [])
    ]
  })

  return html`<div>
    ${plot}
    ${cpPlot}
    <p style="color:#666;font-size:0.85rem;"><strong>Top:</strong> DCC correlation with <span style="color:#d62728;font-weight:700;">red dots</span> marking days when both assets had large <em>negative</em> standardized returns (z₁ < −1.5 and z₂ < −1.5). ${nStress} stress days detected in this sample. <strong>Bottom:</strong> Cross-product z₁z₂ that drives the DCC update. Note that large positive cross-products also arise from joint <em>positive</em> returns (both assets rallying), not only from joint crashes; only the latter are highlighted as stress events. Also note that the highest cross-product spikes do not necessarily coincide with the highest correlations above: because the DCC update is an exponentially weighted average (with weight β ≈ ${dccType === "Mean-reverting DCC" ? fmt(dccBeta, 2) : fmt(dccLambda, 2)} on the previous q-value), a single large shock only moves the correlation modestly. The highest correlations tend to follow <em>sustained</em> periods of positive cross-products rather than isolated spikes.</p>
  </div>`
}

q-value mechanics

{
  return Plot.plot({
    height: 400, marginLeft: 60,
    x: { label: "Day", grid: false },
    y: { label: "q value", grid: true },
    color: { legend: true },
    marks: [
      Plot.line(dccPlotData, { x: "t", y: "q12", stroke: "#2f71d5", strokeWidth: 1.5 }),
      Plot.line(dccPlotData, { x: "t", y: "q11", stroke: "#e67e22", strokeWidth: 1 }),
      Plot.line(dccPlotData, { x: "t", y: "q22", stroke: "#2e7d32", strokeWidth: 1 }),
      Plot.ruleY([1], { stroke: "#999", strokeDasharray: "4 3", strokeWidth: 0.5 }),
      Plot.ruleY([dccRhoBar], { stroke: "#2f71d5", strokeDasharray: "4 3", strokeWidth: 0.5 }),
      // Labels
      Plot.text([dccPlotData[dccPlotData.length - 1]], { x: "t", y: "q12", text: d => "q₁₂", dx: 10, fill: "#2f71d5", fontWeight: 700, fontSize: 11 }),
      Plot.text([dccPlotData[dccPlotData.length - 1]], { x: "t", y: "q11", text: d => "q₁₁", dx: 10, fill: "#e67e22", fontWeight: 700, fontSize: 11 }),
      Plot.text([dccPlotData[dccPlotData.length - 1]], { x: "t", y: "q22", text: d => "q₂₂", dx: 10, fill: "#2e7d32", fontWeight: 700, fontSize: 11 })
    ]
  })
}

{
  const el = html`<p style="color:#666;font-size:0.85rem;">The three q-values that drive the DCC model. <span style="color:#e67e22;font-weight:700;">q₁₁</span> and <span style="color:#2e7d32;font-weight:700;">q₂₂</span> track the "unnormalized variance" of each asset's standardized returns (they hover around 1). <span style="color:#2f71d5;font-weight:700;">q₁₂</span> tracks the unnormalized covariance (hovering around ρ̄). The DCC correlation is obtained by normalizing: \\(\\rho_{12} = q_{12} / \\sqrt{q_{11} \\times q_{22}}\\).</p>`
  if (window.MathJax && MathJax.typesetPromise) MathJax.typesetPromise([el])
  return el
}

Standardized returns

{
  const lim = 5
  return Plot.plot({
    width: 500, height: 500, marginLeft: 50,
    x: { label: "z₁ (standardized return, asset 1)", domain: [-lim, lim], grid: true },
    y: { label: "z₂ (standardized return, asset 2)", domain: [-lim, lim], grid: true },
    color: {
      type: "diverging",
      scheme: "RdBu",
      reverse: true,
      domain: [-1, 1],
      legend: true,
      label: "DCC ρ₁₂"
    },
    marks: [
      Plot.ruleX([0], { stroke: "#ddd" }),
      Plot.ruleY([0], { stroke: "#ddd" }),
      Plot.dot(dccPlotData, { x: "z1", y: "z2", r: 2, fill: "rho", fillOpacity: 0.5 }),
      // Highlight stress quadrant
      Plot.rect([{ x1: -lim, x2: -1.5, y1: -lim, y2: -1.5 }], {
        x1: "x1", x2: "x2", y1: "y1", y2: "y2",
        fill: "#d62728", fillOpacity: 0.05, stroke: "#d62728", strokeDasharray: "4 3"
      })
    ]
  })
}

html`<p style="color:#666;font-size:0.85rem;">Scatter of standardized returns colored by the DCC correlation at each point. The dashed red box highlights the "stress quadrant" where both assets have large negative returns. Points in this region tend to be colored red (high correlation), illustrating the crisis-correlation phenomenon.</p>`

References

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

Engle, Robert. 2002. “Dynamic Conditional Correlation: A Simple Class of Multivariate Generalized Autoregressive Conditional Heteroskedasticity Models.” Journal of Business & Economic Statistics 20 (3): 339–50.