GARCH Volatility

On October 19, 1987, the Dow Jones fell 22 % in a single day. The day after, it swung violently again. The following weeks stayed turbulent. Weeks later, calm returned — and held.

That is volatility clustering: large price changes tend to be followed by more large changes, and small ones by small ones. The market does not simply flip between risky and safe at random. Turbulence has memory.

Plain statistical models miss this entirely. If you estimate a single standard deviation for the whole series, you assume every day is equally risky. That assumption is wrong — and dangerously so for anyone pricing options, computing capital reserves, or managing a portfolio.

In 1982 the economist Robert F. Engle published the ARCH model (Autoregressive Conditional Heteroskedasticity), which let volatility vary over time and depend on past shocks. His student Tim Bollerslev extended it in 1986 into GARCH (Generalized ARCH), the version used in virtually every quantitative finance desk today. Engle received the 2003 Nobel Prize in Economics for this work.

The core idea is elegant: yesterday's squared surprise, together with yesterday's estimated variance, predicts today's variance. Calm breeds calm; storms breed storms — until the process reverts toward its long-run average.

The chart below simulates a GARCH(1,1) process. Each bar is one time step: the height shows the return (price change) and the orange curve tracks the conditional standard deviation — the model's live forecast of how wild the next step might be.

<!-- {{c_intro}} -->
<div class="controls">
  <button id="btn-run" type="button">{{btn_run}}</button>
  <button id="btn-shock" type="button">{{btn_shock}}</button>
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
  <span class="label-vol">{{label_vol}} <strong id="cur-vol">—</strong></span>
</div>
<canvas id="chart" width="560" height="260"></canvas>
<p class="hint" id="hint-msg">{{hint_idle}}</p>

/* {{c_layout}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls { display: flex; gap: .5rem; align-items: center; flex-wrap: wrap; margin-bottom: .6rem; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
#chart { width: 100%; height: auto; display: block; border: 1px solid #dce4ed; border-radius: 8px; background: #f7f9fb; }
.label-vol { font-size: .85rem; color: #555; margin-left: auto; }
.hint { font-size: .82rem; color: #666; margin: .5rem 0 0; min-height: 1.3em; }

// Code not found

Click Shock to inject a large return and watch the orange forecast spike, then slowly decay. Click Run to generate a long random path and observe how bursts of large returns cluster together — even though the underlying random draws are independent. That is the memory GARCH encodes.

GARCH(1,1) has just three parameters — $\omega$, $\alpha$, $\beta$ — and one recursion:

$$\sigma_t^2 = \omega + \alpha \, \varepsilon_{t-1}^2 + \beta \, \sigma_{t-1}^2$$

where $\varepsilon_{t-1} = r_{t-1} - \mu$ is yesterday's demeaned return (the shock) and $\sigma_t^2$ is today's conditional variance. The return itself is:

$$r_t = \mu + \sigma_t \cdot z_t, \quad z_t \sim \mathcal{N}(0, 1)$$

What each term does:

• $\omega$ — the baseline. When everything else is zero, variance reverts here.
• $\alpha \, \varepsilon_{t-1}^2$ — the ARCH term. A large shock yesterday ($\varepsilon^2$ large) pushes today's variance up.
• $\beta \, \sigma_{t-1}^2$ — the GARCH term. Yesterday's already-elevated variance carries forward.

Stationarity requires $\alpha + \beta < 1$. Then the unconditional (long-run) variance is $\sigma^2_{\infty} = \omega / (1 - \alpha - \beta)$ and the process is mean-reverting. In real markets $\alpha + \beta$ is often 0.97–0.99: shocks decay slowly, which is why turbulent periods last weeks, not days.

Estimation is done by maximum likelihood. Given a return series $r_1, \dots, r_T$, the log-likelihood is:

$$\ell = -\frac{1}{2} \sum_{t=1}^{T} \left[ \log(2\pi) + \log \sigma_t^2 + \frac{\varepsilon_t^2}{\sigma_t^2} \right]$$

Maximizing over $(\omega, \alpha, \beta)$ via gradient descent or quasi-Newton methods gives the fitted model. The recursion is not analytically solvable in general — you walk forward from an initial $\sigma_1^2$ and let the series teach the parameters.

Extensions abound: EGARCH adds asymmetry (bad news raises volatility more than good news of the same size — the leverage effect); GJR-GARCH adds an indicator term; multivariate DCC-GARCH models correlations across assets. But the intuition lives entirely in the scalar GARCH(1,1). See also Bayesian inference for an alternative way to fit models with memory.

Anywhere that risk is priced or managed, a volatility model is underneath:

• Option pricing: the Black–Scholes formula needs a volatility input. GARCH provides a time-varying one that matches the implied volatility smile far better than a constant.
• Value at Risk (VaR): regulators under Basel II/III require banks to estimate the loss that will not be exceeded on 99 % of trading days. A GARCH-based VaR adapts when markets get rough; a static estimate does not.
• Portfolio risk: mean–variance optimization is only as good as its covariance matrix. DCC-GARCH provides correlations that shift during crises (assets that seem uncorrelated in calm periods often move together in crashes).
• Algorithmic trading: many strategies scale position size inversely to the current GARCH volatility estimate, automatically pulling back when turbulence spikes.
• Central banks and regulators: monitoring systemic risk requires tracking when volatility across many markets rises simultaneously — a multivariate GARCH signal.

The insight generalizes far beyond finance: any time series where the variance of the noise is itself variable and autocorrelated — electricity prices, internet traffic, seismic activity — is a candidate for GARCH-type modeling. The math of volatility clustering is not limited to stock markets.

GARCH is a lesson in finding the right abstraction. The raw observation — that big market moves cluster — was known long before Engle. What was missing was a model that could encode that memory, estimate it from data, and forecast it one step ahead.

The GARCH(1,1) recursion does all three with just three numbers: a floor, a reaction speed, and a persistence. Together they produce the alternating calm and stormy regimes that anyone who has watched financial markets recognizes — not as mystical market moods, but as the output of a simple, mean-reverting variance process.

Next time you see a volatility index spike and linger for weeks, you are watching $\alpha$ and $\beta$ at work. And if you want to predict when the storm will pass, the same model gives you the answer — in expectation, at least. See Bayesian inference for a complementary view of how uncertainty about parameters is handled when the data is limited.