ARMA Models
You now have two engines with complementary temperaments. An
autoregressive
model gives a series long, fading persistence — it leans on its own past and forgets slowly. A
moving-average
model gives it short, sharp shock memory — a surprise echoes for a few steps, then is gone. Real
data usually have both: a smooth underlying momentum plus brief reactions to news. The
obvious move is to bolt the two engines together, and that is the ARMA model.
An ARMA(p, q) puts an AR polynomial on the series and an MA polynomial on the
noise:
x_t = \underbrace{\phi_1 x_{t-1} + \dots + \phi_p x_{t-p}}_{\text{AR part}} + \varepsilon_t + \underbrace{\theta_1 \varepsilon_{t-1} + \dots + \theta_q \varepsilon_{t-q}}_{\text{MA part}}.
In backshift form
the two natures sit on opposite sides of one clean equation:
\phi(B)\,x_t = \theta(B)\,\varepsilon_t,
with \phi(B) = 1 - \phi_1 B - \dots - \phi_p B^{p} and
\theta(B) = 1 + \theta_1 B + \dots + \theta_q B^{q}. AR is the special case
q = 0; MA is the special case p = 0.
Parsimony: the real reason ARMA exists
You might ask: if I can already build any weight sequence with a long enough AR or a long enough MA, why
bother mixing them? The answer is parsimony — fewer parameters for the same fit.
A pure MA representation of a persistent series needs infinitely many terms
(MA(\infty)); truncating it to a usable length still costs many coefficients. A
pure AR often needs a high order p to bend its ACF into the right shape. But a
mixed ARMA(1,1) — just two parameters — can reproduce a decay pattern that
would take an AR(1) an awkward number of extra lags, or an MA a whole tail, to match. Because
\theta(B)/\phi(B) is a ratio of polynomials, it manufactures rich
infinite weight sequences from a tiny number of coefficients — the same efficiency that a rational
function has over a Taylor polynomial. Fewer parameters means less to estimate, tighter forecasts, and
less overfitting.
- An ARMA(p,q) obeys
\phi(B)x_t = \theta(B)\varepsilon_t, combining
p autoregressive and q moving-average terms.
- It is stationary when the AR polynomial's roots satisfy the
causality
condition — the MA part never threatens stationarity.
- Its ψ-weights come from the rational function
\psi(B) = \theta(B)/\phi(B), so a low-order ARMA can stand in for a
high-order AR or MA.
The identification headache
Mixing the two engines has a price, and it is paid at the diagnosis stage. Recall the clean fingerprints:
| Model | ACF | PACF |
| AR(p) | tails off | cuts off after p |
| MA(q) | cuts off after q | tails off |
| ARMA(p,q) | tails off | tails off |
There is the rub: for a genuine ARMA, both the ACF and the
PACF
tail off — neither cuts cleanly — so neither plot hands you the order on a plate. You lose the
"count the spikes" trick that made pure AR and MA so easy to read. Choosing
p and q for a mixed model becomes an art of
trial, comparison and information criteria — the whole business of
identifying ARMA
models.
ARMA(1,1), seen
Below is the ACF of an ARMA(1,1) with \phi = 0.6 and
\theta = 0.5. After an initial value \rho_1 shaped
by the MA term, the correlations settle into a pure geometric decay,
\rho_k = \phi\,\rho_{k-1} for k \ge 2 — tailing off
toward zero without ever cutting off. That "shrinking but never zero" tail is precisely why you cannot
read the order from the picture alone.
Worked example: ARMA(1,1) in backshift form
Start from the raw recursion
x_t = 0.6\,x_{t-1} + \varepsilon_t + 0.5\,\varepsilon_{t-1}.
Collect the x terms on the left and the
\varepsilon terms on the right, replacing each lag by a power of
B:
x_t - 0.6\,B\,x_t = \varepsilon_t + 0.5\,B\,\varepsilon_t \;\Longrightarrow\; (1 - 0.6\,B)\,x_t = (1 + 0.5\,B)\,\varepsilon_t.
So \phi(B) = 1 - 0.6B and \theta(B) = 1 + 0.5B.
Dividing gives the MA(\infty) weights,
\psi(B) = (1+0.5B)/(1-0.6B); expanding the denominator as a geometric series
yields \psi_0 = 1 and, for j \ge 1,
\psi_j = (0.6 + 0.5)\,0.6^{\,j-1} = 1.1\times 0.6^{\,j-1} — two numbers
generating an infinite, smoothly decaying tail.
A subtle trap in mixed models is parameter redundancy. Suppose you write an ARMA(1,1)
whose polynomials share a common factor — the extreme case being
\theta = -\phi, so that
\phi(B) = 1 - \phi B and \theta(B) = 1 - \phi B are
identical. Then
(1-\phi B)x_t = (1-\phi B)\varepsilon_t, and the common factor cancels to
leave x_t = \varepsilon_t — plain white noise wearing an elaborate costume. An
estimator handed such data will thrash: many different
(\phi,\theta) pairs fit almost equally well, standard errors balloon, and the
optimiser wanders. The cure is to keep \phi(B) and
\theta(B) coprime (no shared roots) — a discipline that also
underlies causality
and invertibility.
The ARMA algebra dates back to the 1930s, but for decades it was a theorist's toy — fitting one by hand
was punishing. In 1970 George Box and Gwilym Jenkins
packaged it into a repeatable recipe — identify a candidate order from the ACF and PACF,
estimate the parameters, check the residuals, repeat — turning ARMA from mathematics
into a working methodology that a practitioner could actually run. That loop, the
Box–Jenkins
method, is why "ARIMA" became a household word in forecasting and why the acronym still
stares back at you from spreadsheet menus today.