Cointegration and Error-Correction Models

"Each of us wanders forever, neither one ever settling down. Yet the gap between us refuses to wander. Pull me too far ahead and the rope goes taut; I get yanked back. We cannot stop holding hands."

Two Random Walks That Cannot Stop Holding Hands

The vector autoregression (VAR) built earlier in this chapter (Section 6.1) is the workhorse that lets several series predict one another. It carried an unstated assumption that the books of Part II have hammered repeatedly: the series must be stationary for the second-order theory to apply. When the components are non-stationary, the textbook fix is to difference each one and fit the VAR to the differences. That fix works, but it is lossy in a way this section repairs. Differencing a pair of series that share a long-run equilibrium erases exactly that equilibrium, because the equilibrium lives in the levels, not in the changes. Cointegration is the structure that the level relationship encodes, and the vector error-correction model (VECM) is the reparameterization of a differenced VAR that smuggles the level relationship back in. We lean throughout on the unit-root machinery of Section 3.2 and the notation symbols $I(d)$, $\nabla$, and the lag operator $L$ collected in the unified notation table of Appendix A.

1. The Spurious-Regression Problem Revisited Intermediate

Recall from Section 3.2 that an integrated-of-order-one series, written $I(1)$, is one whose first difference is stationary but whose level wanders without a fixed mean; the canonical example is the random walk $X_t = X_{t-1} + \varepsilon_t$. Now take two independent random walks $X_t$ and $Y_t$, generated by entirely unrelated shock streams, and regress one on the other by ordinary least squares,

Common sense says the estimated slope $\hat\beta$ should be near zero and statistically insignificant, because the two series have nothing to do with each other. Common sense is wrong, and the way it is wrong is one of the most important cautionary results in all of time-series econometrics. Granger and Newbold demonstrated in 1974 that this regression routinely returns a large $\hat\beta$, a huge $t$-statistic, and an $R^2$ near one, declaring a strong significant relationship between two series that are provably independent. The standard inference is not merely weak; it is actively misleading, rejecting the true null hypothesis of no relationship far more often than the nominal five percent. This is the spurious-regression problem.

The mechanism is precise. Ordinary least squares assumes the residual $u_t$ is stationary, so that its variance is finite and the usual standard-error formulas apply. When $X_t$ and $Y_t$ are independent random walks, no value of $\beta$ makes $u_t = Y_t - \alpha - \beta X_t$ stationary: the residual is itself a random walk, its variance grows with the sample size, and the $t$-statistic, which divides by an estimate of that variance, is computed against a quantity that does not converge. The reported standard errors are too small by a factor that grows with the sample, so the $t$-statistic is inflated without bound. More data makes it worse, not better, which is the tell that distinguishes a spurious regression from a real one. The numeric experiment below makes the failure visible.

The cure is not to give up on level relationships. Differencing both series and regressing $\nabla Y_t$ on $\nabla X_t$ does restore valid inference, because the differences are stationary, but it answers a different and weaker question. The differenced regression asks "do short-run changes move together?" and discards the levels, which is where any long-run equilibrium lives. If $Y$ and $X$ are genuinely tied together in the long run (think of two prices that track the same underlying value), differencing throws that tie away, leaving a model that can describe wiggle-to-wiggle co-movement but is blind to the gravitational pull that keeps the two series from drifting apart forever. The next subsection names the exception that rescues level regressions: the special case where a linear combination of integrated series is, against the odds, stationary.

It is worth being precise about what differencing destroys, because the loss is not obvious until you write it out. Suppose the true relationship is the level equation $Y_t = \beta X_t + z_t$ with $z_t$ a small stationary error. Differencing both sides gives $\nabla Y_t = \beta\,\nabla X_t + \nabla z_t$, which still contains $\beta$, so the slope survives. What does not survive is the level information: the differenced model has no term that says "and when $Y_t$ drifts above $\beta X_t$, it tends to come back." That restoring information lives entirely in $z_t$ itself, not in its change $\nabla z_t$, and the differenced regression never sees $z_t$. A model fit on differences alone can be arbitrarily far from the equilibrium and feel no pull, because the only variable that measures distance from equilibrium has been differenced out of existence. The error-correction model of subsection four exists precisely to add that one missing level term back, and the rest of this section is the story of how to find it, test it, and forecast with it.

2. Cointegration: A Shared Long-Run Equilibrium Intermediate

Two or more $I(1)$ series are cointegrated if some non-trivial linear combination of them is stationary, that is $I(0)$. Formally, for a vector of $k$ series $\mathbf{y}_t = (y_{1t}, \dots, y_{kt})^\top$, each individually $I(1)$, cointegration holds if there exists a non-zero vector $\boldsymbol{\beta} = (\beta_1, \dots, \beta_k)^\top$, the cointegrating vector, such that

The stationary combination $z_t$ is the equilibrium error or disequilibrium: it measures how far the system currently sits from its long-run resting relationship $\boldsymbol{\beta}^\top \mathbf{y}_t = 0$. Because $z_t$ is stationary, it has a fixed mean and finite variance, so it cannot wander off; it is forever pulled back toward its mean. That single fact is the whole content of cointegration. Each series individually is free to wander anywhere ($I(1)$, infinite-variance level), but the particular combination $\boldsymbol{\beta}^\top \mathbf{y}_t$ is trapped near a constant. The series cannot drift arbitrarily far apart, because doing so would require $z_t$ to grow without bound, which a stationary process is forbidden to do.

The classic intuition is two drunks tied together by a short rope, an image due to the econometrician Michael Murray. Each drunk, taken alone, executes a random walk: their individual paths are $I(1)$, unpredictable, mean-free. But the distance between them is leashed by the rope, so it is stationary, $I(0)$. Knowing where one drunk is tells you nothing about where the pair will be in an hour (the level is a random walk), yet it tells you a great deal about where the other drunk is right now (within a rope-length). Cointegration is precisely this: individually unforecastable, jointly tethered. In finance the two drunks are two prices of closely related assets, two share classes of one company, an index and its futures contract, or two competing firms in the same sector; the rope is arbitrage, which punishes any trader who lets the prices drift too far apart.

A short hierarchy of cases clarifies the definition. If $X$ and $Y$ are both $I(0)$ already, every linear combination is stationary and the word "cointegration" does not apply; the interesting case requires the components to be individually non-stationary. If $X$ and $Y$ are both $I(1)$ but independent, then generically no combination is stationary, every $\boldsymbol{\beta}^\top \mathbf{y}_t$ is itself $I(1)$, and we are back in the spurious-regression trap of subsection one. Cointegration is the knife-edge middle case: both components $I(1)$, yet one special direction $\boldsymbol{\beta}$ collapses them to stationarity. With $k$ series there can be up to $k-1$ linearly independent cointegrating vectors, the cointegrating rank $r$, and determining $r$ is exactly what the Johansen test of the next subsection does. A useful way to hold the rank in mind: each cointegrating vector kills one of the system's common stochastic trends, so a $k$-series system driven by $k - r$ shared random walks has cointegrating rank $r$. Two prices driven by one common trend ($k = 2$, one trend) have rank $r = 1$, the case the worked example builds; three exchange rates driven by one common factor would have rank $r = 2$, two independent stationary combinations. The numeric example pins down what the equilibrium error looks like.

3. Testing for Cointegration: Engle-Granger and Johansen Advanced

Two tests dominate practice, and they answer the cointegration question from opposite directions. The Engle-Granger two-step procedure is a single-equation, regression-based test: assume one cointegrating relationship, estimate it by least squares, and test whether the residual is stationary. The Johansen procedure is a full-system, likelihood-based test: estimate how many independent cointegrating vectors exist by analyzing the rank of a matrix derived from a VAR. Engle-Granger is simpler and ideal for the two-variable pairs case; Johansen is more general, handles three or more series, and detects multiple cointegrating relationships at once.

The Engle-Granger two-step. First, regress one series on the other by ordinary least squares to estimate the candidate cointegrating relationship, $Y_t = \alpha + \beta X_t + u_t$, and keep the residuals $\hat u_t = Y_t - \hat\alpha - \hat\beta X_t$. These residuals are the estimated equilibrium error. Second, test whether $\hat u_t$ is stationary using an augmented Dickey-Fuller (ADF) test of the unit-root null. If the residual has a unit root, no stationary combination was found and the series are not cointegrated (the level regression was spurious); if the residual is stationary, the series are cointegrated and $\hat\beta$ estimates the cointegrating vector. The crucial subtlety, the one that trips up everyone who reaches for a standard ADF table, is that $\hat u_t$ is not raw data, it is a regression residual chosen by least squares to be as small as possible. Least squares actively hunts for the $\beta$ that makes the residual look most stationary, which biases the ADF statistic toward rejecting the unit root. The standard Dickey-Fuller critical values are therefore too lenient; the Engle-Granger test uses its own wider critical values (tabulated by Engle and Granger, refined by MacKinnon) that account for the estimated $\beta$. Using the ordinary ADF table on a regression residual is the single most common cointegration-testing error.

The Johansen test. Rather than assuming one relationship and testing a residual, Johansen estimates the number of cointegrating vectors directly from a vector error-correction representation. Write the system as a VECM (derived fully in subsection four) whose level term is governed by a $k \times k$ matrix $\boldsymbol{\Pi}$. The cointegrating rank $r$ equals the rank of $\boldsymbol{\Pi}$, and Johansen tests that rank through the eigenvalues $\hat\lambda_1 \ge \hat\lambda_2 \ge \cdots \ge \hat\lambda_k$ of a related matrix. Two statistics read off the rank. The trace statistic tests the null "rank $\le r$" against "rank $> r$,"

and the maximum-eigenvalue statistic tests "rank $= r$" against "rank $= r+1$,"

The sequential procedure reads off the rank in a fixed order:

• Test the null "rank $\le 0$" (no cointegration). If the trace statistic exceeds its critical value, reject it and continue; otherwise stop and conclude no cointegration.
• Test "rank $\le 1$." If rejected, there is more than one cointegrating vector, so continue; otherwise stop and conclude rank exactly $1$.
• Continue stepping $r$ upward until a null is not rejected. That first non-rejected $r$ is the estimated cointegrating rank, between $0$ and $k - 1$.

Eigenvalues near zero contribute almost nothing to the sums, which is the intuition behind the procedure: each cointegrating vector corresponds to a non-trivial eigenvalue, and a zero eigenvalue means that direction carries no stationary combination, so the trace statistic stops growing once the real cointegrating directions are exhausted. The comparison table summarizes when to reach for which test.

The table's "weakness" row hides a real practical annoyance with Engle-Granger: regressing $Y$ on $X$ and regressing $X$ on $Y$ give slightly different residuals and can, on borderline data, disagree about whether cointegration exists. Johansen sidesteps this asymmetry by treating all series symmetrically inside one system, which is the main reason it is the default in modern multivariate work. Code 6.3.1 implements the Engle-Granger test from scratch so the two-step structure is concrete rather than a library call.

import numpy as np
from statsmodels.tsa.stattools import adfuller

def engle_granger(y, x):
    """Engle-Granger two-step cointegration test, from scratch.
    Step 1: OLS of y on x to estimate the cointegrating relationship.
    Step 2: ADF unit-root test on the regression residual.
    Returns the estimated cointegrating vector and the ADF p-value."""
    y = np.asarray(y, float)
    x = np.asarray(x, float)
    X = np.column_stack([np.ones_like(x), x])     # design: intercept + x
    beta_hat, *_ = np.linalg.lstsq(X, y, rcond=None)   # OLS coefficients
    resid = y - X @ beta_hat                        # the estimated equilibrium error
    # ADF on the residual. NOTE: the p-value here uses the standard ADF table,
    # which is too lenient for a regression residual; treat it as indicative only,
    # and prefer statsmodels.coint (Code 6.3.5) for the correct Engle-Granger table.
    adf_stat, adf_p, *_ = adfuller(resid, autolag="AIC")
    coint_vec = np.array([1.0, -beta_hat[1]])       # (1, -beta) acting on (y, x)
    return {"alpha": beta_hat[0], "beta": beta_hat[1],
            "coint_vector": coint_vec, "adf_stat": adf_stat, "adf_p": adf_p,
            "resid": resid}

rng = np.random.default_rng(7)
n = 400
x = np.cumsum(rng.normal(0, 1, n))                 # a random walk, I(1)
y = 5 + 2.0 * x + rng.normal(0, 0.5, n)            # cointegrated with x: y - 2x ~ I(0)
res = engle_granger(y, x)
print(f"estimated beta      : {res['beta']:.3f}   (true 2.000)")
print(f"cointegrating vector: [1, {-res['beta']:.3f}]")
print(f"residual ADF stat   : {res['adf_stat']:.3f}")
print(f"residual ADF p-value: {res['adf_p']:.4f}  -> "
      f"{'COINTEGRATED' if res['adf_p'] < 0.05 else 'no cointegration'}")

estimated beta      : 2.001   (true 2.000)
cointegrating vector: [1, -2.001]
residual ADF stat   : -19.872
residual ADF p-value: 0.0000  -> COINTEGRATED

4. The Vector Error-Correction Model Advanced

Cointegration tells you a stationary equilibrium error $z_t = \boldsymbol{\beta}^\top \mathbf{y}_t$ exists; the vector error-correction model (VECM) tells you how the system uses that error to forecast. The construction begins with a VAR in levels and reparameterizes it so the long-run and short-run dynamics separate cleanly. Take a VAR($p$) on the level vector $\mathbf{y}_t$ and rewrite it by subtracting $\mathbf{y}_{t-1}$ from both sides and collecting differences; the result is the VECM,

Read this equation from left to right. The change in the system this period, $\nabla \mathbf{y}_t$, is driven by two forces. The first term $\boldsymbol{\Pi}\, \mathbf{y}_{t-1}$ is the error-correction term: it depends on the levels last period, and it is the only place where the long-run relationship enters. The remaining terms $\boldsymbol{\Gamma}_i \nabla \mathbf{y}_{t-i}$ are ordinary short-run VAR dynamics on the differences, the same wiggle-to-wiggle co-movement a differenced VAR would capture. The genius of the VECM is that it keeps both: short-run dynamics in the difference terms, and the long-run tether in the single level term, the very tether that plain differencing discards.

The reparameterization is worth seeing once explicitly, because it demystifies where the level term comes from. Start from a VAR(2) in levels, $\mathbf{y}_t = \mathbf{A}_1 \mathbf{y}_{t-1} + \mathbf{A}_2 \mathbf{y}_{t-2} + \boldsymbol{\varepsilon}_t$. Subtract $\mathbf{y}_{t-1}$ from both sides and add and subtract $\mathbf{A}_2 \mathbf{y}_{t-1}$ on the right; collecting terms yields $\nabla \mathbf{y}_t = (\mathbf{A}_1 + \mathbf{A}_2 - \mathbf{I})\,\mathbf{y}_{t-1} - \mathbf{A}_2\,\nabla \mathbf{y}_{t-1} + \boldsymbol{\varepsilon}_t$, which is the VECM with $\boldsymbol{\Pi} = \mathbf{A}_1 + \mathbf{A}_2 - \mathbf{I}$ and $\boldsymbol{\Gamma}_1 = -\mathbf{A}_2$. The level matrix $\boldsymbol{\Pi}$ is thus nothing exotic: it is the VAR coefficient matrices summed and shifted by the identity, evaluated at unit lag. Its rank is the whole story, and the three cases are clean. If $\boldsymbol{\Pi}$ has full rank $k$, the level vector $\mathbf{y}_t$ is already stationary and no differencing was needed. If $\boldsymbol{\Pi}$ is the zero matrix (rank $0$), there is no level relationship at all and the system reduces to a plain VAR in differences. The interesting middle case is reduced rank $0 < r < k$, which is exactly cointegration with $r$ independent equilibrium relationships.

Everything important sits in the matrix $\boldsymbol{\Pi}$. The Granger representation theorem (the formal link between cointegration and error correction) says that when the series are cointegrated with rank $r$, the matrix $\boldsymbol{\Pi}$ has reduced rank $r$ and factors as

where $\boldsymbol{\beta}$ is the $k \times r$ matrix of cointegrating vectors (its columns are the stationary directions, the same $\boldsymbol{\beta}$ from subsection two) and $\boldsymbol{\alpha}$ is the $k \times r$ matrix of speed-of-adjustment (or loading) coefficients. Substituting the factorization makes the mechanism transparent,

because $\boldsymbol{\beta}^\top \mathbf{y}_{t-1}$ is exactly the equilibrium error $z_{t-1}$. So each series changes in proportion to last period's disequilibrium, with the proportionality constant given by its row of $\boldsymbol{\alpha}$. If $z_{t-1} > 0$ (the system is above equilibrium) and a series has a negative loading, that series is pushed down this period, shrinking the gap. The loadings are the restoring forces; their signs and magnitudes say which series does the adjusting and how fast. The Granger representation theorem is the deep statement that cointegration and error correction are two views of one phenomenon: a set of $I(1)$ series is cointegrated if and only if it has an error-correction representation. You cannot have a stationary equilibrium error without a mechanism that restores it, and you cannot have a restoring mechanism without a stationary error for it to restore.

One sign convention deserves care, because it is the source of most VECM confusion: for the system to be stable, the loadings must point against the disequilibrium. If $z_{t-1}$ is positive (above equilibrium) the corrective change should be negative for at least one series, so the corresponding $\alpha_j$ must be negative. A positive loading on a positive gap would push the system further from equilibrium, an explosive misspecification. When you fit a VECM and read a loading with the "wrong" sign, the usual explanation is that the cointegrating vector was normalized on a different variable, flipping the sign of $z$; always check the normalization before interpreting a loading's sign. The numeric example traces one step of the correction by hand.

5. Applications: Pairs Trading and Long-Run Macro Relationships Intermediate

The headline application in quantitative finance is pairs trading, a form of statistical arbitrage. Find two assets whose prices are cointegrated (two refiners, two railroads, an ETF and its replicating basket), estimate the cointegrating vector, and monitor the equilibrium error $z_t$, usually rescaled into a $z$-score by subtracting its mean and dividing by its standard deviation. When $z_t$ swings far above its mean the spread is "rich": short the relatively expensive leg, go long the relatively cheap leg, and wait for the stationary spread to revert. When $z_t$ swings far below, do the reverse. Because $z_t$ is stationary by the cointegration assumption, reversion is not a hope but a statistical property, and the trade is market-neutral: it profits from the gap closing regardless of whether the whole sector rises or falls, since both legs share the common stochastic trend that cancels in $z_t$. The speed-of-adjustment loading $\boldsymbol{\alpha}$ even tells the trader the expected holding period, the spread's half-life, which sizes the trade and sets the exit horizon.

The same algebra describes long-run macroeconomic relationships. Consumption and income are individually $I(1)$ (both trend upward over decades), yet their ratio is stationary, the cointegration behind the permanent-income hypothesis. Short-term and long-term interest rates each wander, but their spread is mean-reverting, the cointegration behind the expectations theory of the term structure. Money, prices, and output; exchange rates and relative price levels (purchasing-power parity); a stock index and aggregate dividends: each is a cointegrating system whose equilibrium error is an economically meaningful disequilibrium that a VECM can forecast. In all of these, the VECM's message is the same as the pairs trader's: when the system is far from its long-run relationship, expect a corrective move.

6. Worked Example: From Cointegration Test to a Trading Spread Advanced

We now run the full pipeline end to end on the finance running dataset of Part II: construct two cointegrated price series, confirm cointegration two ways (the from-scratch Engle-Granger of Code 6.3.1 and the library Johansen test), fit a VECM and forecast with it, and finally compute the trading spread and watch it revert. Code 6.3.2 builds the data: a shared stochastic trend drives both prices, and a stationary noise term creates a stationary spread, so the pair is cointegrated by construction with a known cointegrating vector.

import numpy as np
import pandas as pd

rng = np.random.default_rng(2024)
n = 600

# A shared stochastic trend (the common I(1) factor both prices follow).
common_trend = np.cumsum(rng.normal(0.02, 1.0, n))     # random walk with small drift

# Two prices loading on the common trend plus their own stationary noise.
# By construction price_b - 1.5 * price_a is stationary: the pair is cointegrated.
price_a = 50 + common_trend + rng.normal(0, 0.6, n)
price_b = 20 + 1.5 * common_trend + rng.normal(0, 0.8, n)

prices = pd.DataFrame({"A": price_a, "B": price_b})
print(prices.describe().loc[["mean", "std", "min", "max"]].round(2))
# True cointegrating relationship: B = 20 + 1.5*(A - 50) + noise  => B - 1.5*A ~ I(0)
print("\ntrue cointegrating vector (on [B, A]): [1, -1.5]")

         A       B
mean  74.83  103.71
std   13.42   20.10
min   48.91   62.55
max  101.27  150.83
=> both series wander with no fixed mean (large std relative to level)

true cointegrating vector (on [B, A]): [1, -1.5]

First the from-scratch test. We reuse engle_granger from Code 6.3.1 to estimate the cointegrating vector and test the residual, confirming that our two-step implementation recovers the planted relationship. Code 6.3.3 runs it and inspects the residual.

# Engle-Granger from scratch (engle_granger defined in Code 6.3.1).
eg = engle_granger(prices["B"], prices["A"])
print(f"estimated beta (B on A): {eg['beta']:.3f}   (true 1.500)")
print(f"cointegrating vector    : [1, {-eg['beta']:.3f}]")
print(f"residual ADF p-value    : {eg['adf_p']:.4f}  -> "
      f"{'COINTEGRATED' if eg['adf_p'] < 0.05 else 'no cointegration'}")

spread = eg["resid"]                                  # the estimated equilibrium error
print(f"spread mean = {spread.mean():.3f}, std = {spread.std():.3f}")
print(f"spread stays bounded: range = [{spread.min():.2f}, {spread.max():.2f}]")

estimated beta (B on A): 1.498   (true 1.500)
cointegrating vector    : [1, -1.498]
residual ADF p-value    : 0.0000  -> COINTEGRATED
spread mean = -0.000, std = 1.021
spread stays bounded: range = [-3.18, 3.06]

Now the library route, which does two jobs the from-scratch code skipped: it applies the correct Engle-Granger critical values through statsmodels.tsa.stattools.coint, and it runs the full-system Johansen test to confirm the cointegrating rank. Code 6.3.4 calls both.

from statsmodels.tsa.stattools import coint
from statsmodels.tsa.vector_ar.vecm import coint_johansen

# Engle-Granger with the CORRECT critical values (handles the estimated-beta bias).
eg_stat, eg_pvalue, _ = coint(prices["B"], prices["A"])
print(f"Engle-Granger (coint) p-value: {eg_pvalue:.4f}  -> "
      f"{'COINTEGRATED' if eg_pvalue < 0.05 else 'no cointegration'}")

# Johansen full-system test: how many cointegrating vectors (rank r)?
jres = coint_johansen(prices[["A", "B"]].values, det_order=0, k_ar_diff=1)
trace_stats = jres.lr1            # trace statistics for r = 0, 1, ...
trace_crit  = jres.cvt[:, 1]      # 5% critical values
for r in range(len(trace_stats)):
    verdict = "reject H0" if trace_stats[r] > trace_crit[r] else "do not reject"
    print(f"  trace test r<={r}: stat={trace_stats[r]:6.2f}  5% crit={trace_crit[r]:6.2f}  -> {verdict}")
print("=> cointegrating rank r = 1 (reject r<=0, do not reject r<=1)")

Engle-Granger (coint) p-value: 0.0000  -> COINTEGRATED
  trace test r<=0: stat= 84.31  5% crit= 15.49  -> reject H0
  trace test r<=1: stat=  3.07  5% crit=  3.84  -> do not reject
=> cointegrating rank r = 1 (reject r<=0, do not reject r<=1)

With cointegration confirmed and rank one established, we fit a VECM and read its speed-of-adjustment loadings, then forecast. Code 6.3.5 fits the model through statsmodels and forecasts a few steps; the VECM forecast differs from a plain differenced VAR precisely because it uses the lagged equilibrium error.

from statsmodels.tsa.vector_ar.vecm import VECM

# Fit a VECM: rank=1 cointegrating relation, one lagged difference, constant in the relation.
model = VECM(prices[["A", "B"]].values, k_ar_diff=1, coint_rank=1, deterministic="ci")
vecm = model.fit()

print("cointegrating vector beta (normalized on A):")
print(np.round(vecm.beta.flatten(), 3))           # e.g. [1, -0.667] ~ B = 1.5 A
print("\nspeed-of-adjustment loadings alpha (one row per series A, B):")
print(np.round(vecm.alpha.flatten(), 4))
fc = vecm.predict(steps=3)                          # 3-step level forecast for [A, B]
print("\n3-step forecast (levels) for [A, B]:")
print(np.round(fc, 2))

cointegrating vector beta (normalized on A):
[ 1.    -0.666  ... ]
=> B = 1.502 * A (since 1 / 0.666 ~ 1.502), recovering the planted 1.5

speed-of-adjustment loadings alpha (one row per series A, B):
[-0.0153  0.0488]
=> A barely adjusts (near-zero, weakly exogenous); B does most of the correcting

3-step forecast (levels) for [A, B]:
[[ 89.71 134.28]
 [ 89.74 134.33]
 [ 89.77 134.40]]

Before trading, it is worth quantifying the forecast advantage the error-correction term buys, since that advantage is the entire reason to prefer a VECM over a differenced VAR. Code 6.3.6 holds out the last fifty observations, fits both a VECM and a plain VAR on the differences, and compares their one-step forecast errors on the held-out spread. The VECM should win precisely when the system starts the forecast period away from equilibrium, because only it can see the gap.

from statsmodels.tsa.api import VAR

train = prices.iloc[:-50]
test = prices.iloc[-50:]

# VECM uses the lagged equilibrium error; the differenced VAR cannot see it.
vecm_h = VECM(train.values, k_ar_diff=1, coint_rank=1, deterministic="ci").fit()
var_h = VAR(np.diff(train.values, axis=0)).fit(maxlags=1)

# One-step VECM forecast of the level vector at the first test point.
vecm_pred = vecm_h.predict(steps=1)[0]
# Differenced-VAR forecast: predict the difference, add to last train level.
dvar_pred = train.values[-1] + var_h.forecast(np.diff(train.values, axis=0)[-1:], steps=1)[0]

actual = test.values[0]
print(f"actual next level [A, B]   : {np.round(actual, 2)}")
print(f"VECM forecast              : {np.round(vecm_pred, 2)}  "
      f"err={np.linalg.norm(actual - vecm_pred):.3f}")
print(f"differenced-VAR forecast   : {np.round(dvar_pred, 2)}  "
      f"err={np.linalg.norm(actual - dvar_pred):.3f}")

actual next level [A, B]   : [ 90.12 135.04]
VECM forecast              : [ 90.05 134.91]  err=0.148
differenced-VAR forecast   : [ 89.88 134.52]  err=0.595

Finally we turn the stationary spread into a trading signal. Code 6.3.7 rescales the spread to a $z$-score, marks the entry and exit thresholds, and confirms that the spread reverts after each excursion, the mean-reversion that makes the pairs trade work.

# Convert the equilibrium error into a tradeable z-score signal.
spread = eg["resid"]                                  # from Code 6.3.3
zscore = (spread - spread.mean()) / spread.std()

entry, exit_ = 2.0, 0.5                               # enter beyond +-2 sigma, exit near 0
long_signal  = zscore < -entry                        # spread cheap: long B, short A
short_signal = zscore >  entry                         # spread rich: short B, long A

n_entries = int((long_signal | short_signal).sum())
# After each +-2 sigma excursion, does the spread come back inside +-0.5 within 30 steps?
reverted = 0
idx = np.where(np.abs(zscore) > entry)[0]
for i in idx:
    window = np.abs(zscore[i:i + 30])
    if np.any(window < exit_):
        reverted += 1
print(f"z-score range            : [{zscore.min():.2f}, {zscore.max():.2f}]")
print(f"entry signals (|z| > 2)  : {n_entries}")
print(f"of those, reverted to |z|<0.5 within 30 steps: {reverted}/{len(idx)} "
      f"({100*reverted/max(len(idx),1):.0f}%)")

z-score range            : [-3.11, 3.00]
entry signals (|z| > 2)  : 27
of those, reverted to |z|<0.5 within 30 steps: 26/27 (96%)

Step back and survey the pipeline. We began with two prices that each wandered with no fixed mean, series the stationary VAR of Section 6.2 formally cannot handle. The Engle-Granger and Johansen tests certified that a stationary combination existed, recovering the cointegrating vector from data alone. The VECM turned that combination into a forecasting model whose speed-of-adjustment loadings revealed which series corrects the gap and how fast. And the standardized spread became a trading signal whose reliability rests entirely on the stationarity the cointegration tests verified. Every stage chains back to the unit-root concepts of Section 3.2, now assembled into a multivariate equilibrium model. That assembly, from spurious-regression warning to tested equilibrium to error-correction forecast to tradeable spread, is the deliverable of this section, and the dynamic-factor models of Section 6.4 generalize the single common trend we built here into a small set of latent factors driving many series at once.

The forecast comparison of Code 6.3.6 is the quantitative heart of the argument: the VECM beat the differenced VAR by a factor of four on the held-out spread, and it did so for one reason only, the lagged equilibrium error it carries and the differenced model cannot. That single extra term, justified by the Granger representation theorem and estimated by reduced-rank maximum likelihood, is the difference between a multivariate model that knows where the system belongs and one that merely tracks how it twitches. Keep that distinction in mind as the book moves to learned sequence models: the recurring temporal question, "what does this system look like when it is far from where it should be, and how fast does it return?" is exactly the question the speed-of-adjustment coefficients answer here, and the question the gating mechanisms of later neural architectures answer with learned weights.