34. Knowing the Forecasts of Others#

34.1. Introduction#

Robert E. Lucas, Jr. [Robert E. Lucas, 1975], Kenneth Kasa [Kasa, 2000], and Robert Townsend [Townsend, 1983] showed that putting decision makers into environments in which they want to infer persistent hidden state variables from equilibrium prices and quantities can elongate and amplify impulse responses to aggregate shocks.

This provides a promising way to think about amplification mechanisms in business cycle models.

Townsend [Townsend, 1983] noted that living in such environments makes decision makers want to forecast forecasts of others.

This theme has been pursued for situations in which decision makers’ imperfect information forces them to pursue an infinite recursion that involves forming beliefs about the beliefs of others (e.g., [Allen et al., 2002]).

Lucas [Robert E. Lucas, 1975] side stepped having decision makers forecast the forecasts of other decision makers by assuming that they simply pool their information before forecasting.

A pooling equilibrium like Lucas’s plays a prominent role in this lecture.

Because he didn’t assume such pooling, [Townsend, 1983] confronted the forecasting the forecasts of others problem.

To formulate the problem recursively required that Townsend define a decision maker’s state vector.

Townsend concluded that his original model required an intractable infinite dimensional state space.

Therefore, he constructed a more manageable approximating model in which a hidden Markov component of a demand shock is revealed to all firms after a fixed, finite number of periods.

In this lecture, we illustrate again the theme that finding the state is an art by showing how to formulate Townsend’s original model in terms of a low-dimensional state space.

We show that Townsend’s model shares equilibrium prices and quantities with those that prevail in a pooling equilibrium.

That finding emerged from a line of research about Townsend’s model that built on [Pearlman et al., 1986] and that culminated in [Pearlman and Sargent, 2005] .

Rather than directly deploying the [Pearlman et al., 1986] machinery here, we shall instead implement a sneaky guess-and-verify tactic.

• We first compute a pooling equilibrium and represent it as an instance of a linear state-space system provided by the Python class quantecon.LinearStateSpace.

• Leaving the state-transition equation for the pooling equilibrium unaltered, we alter the observation vector for a firm to match what it is in Townsend’s original model. So rather than directly observing the signal received by firms in the other industry, a firm sees the equilibrium price of the good produced by the other industry.

• We compute a population linear least squares regression of the noisy signal at time $t$ that firms in the other industry would receive in a pooling equilibrium on time $t$ information that a firm receives in Townsend’s original model.

• The $R^2$ in this regression equals $1$.

• That verifies that a firm’s information set in Townsend’s original model equals its information set in a pooling equilibrium.

• Therefore, equilibrium prices and quantities in Townsend’s original model equal those in a pooling equilibrium.

34.2. The Setting#

We cast all variables in terms of deviations from means.

Therefore, we omit constants from inverse demand curves and other functions.

Firms in industry $i=1,2$ use a single factor of production, capital $k_t^i$, to produce output of a single good, $y_t^i$.

Firms bear quadratic costs of adjusting their capital stocks.

A representative firm in industry $i$ has production function $y_t^i=f{k}_t^i$, $f>0$.

The firm acts as a price taker with respect to output price $P_t^i$, and maximizes

Demand in industry $i$ is described by the inverse demand curve

where $P_t^i$ is the price of good $i$ at $t$, $Y_t^i=f{K}_t^i$ is output in market $i$, ${\theta }_t$ is a persistent component of a demand shock that is common across the two industries, and ${\epsilon }_t^i$ is an industry specific component of the demand shock that is i.i.d. and whose time $t$ marginal distribution is $\mathcal{N}(0,{\sigma }_{\epsilon }^2)$.

We assume that ${\theta }_t$ is governed by

where $\{v_t\}$ is an i.i.d. sequence of Gaussian shocks, each with mean zero and variance ${\sigma }_v^2$.

To simplify notation, we’ll study a special case by setting $h=f=1$.

Costs of adjusting their capital stocks impart to firms an incentive to forecast the price of the good that they sell.

Throughout, we use the rational expectations equilibrium concept presented in this lecture Rational Expectations Equilibrium.

We let capital letters denote market wide objects and lower case letters denote objects chosen by a representative firm.

In each industry, a competitive equilibrium prevails.

To rationalize the big $K$, little $k$ connection, we can think of there being a continuum of firms in industry $i$, with each firm being indexed by $\omega \in [0,1]$ and $K^i={\int }_0^1{k}^i(\omega )d\omega$.

In equilibrium, $k_t^i=K_t^i$, but we must distinguish between $k_t^i$ and $K_t^i$ when we pose the firm’s optimization problem.

34.3. Tactics#

We shall compute equilibrium laws of motion for capital in industry $i$ under a sequence of assumptions about what a representative firm observes.

Successive members of this sequence make a representative firm’s information more and more obscure.

We begin with the most information, then gradually withdraw information in a way that approaches and eventually reaches the Townsend-like information structure that we are ultimately interested in.

Thus, we shall compute equilibria under the following alternative information structures:

• Perfect foresight: future values of ${\theta }_t,{\epsilon }_t^i$ are observed in industry $i$.

• Observed history of stochastic ${\theta }_t$: $\{{\theta }_t,{\epsilon }_t^i\}$ are realizations from a stochastic process; current and past values of each are observed at time $t$ but future values are not.

• One noise-ridden observation on ${\theta }_t$: values of $\{{\theta }_t,{\epsilon }_t^i\}$ separately are never observed. However, at time $t$, a history $w^t$ of scalar noise-ridden observations on ${\theta }_t$ is observed at time $t$.

• Two noise-ridden observations on ${\theta }_t$: values of $\{{\theta }_t,{\epsilon }_t^i\}$ separately are never observed. However, at time $t$, a history $w^t$ of two noise-ridden observations on ${\theta }_t$ is observed at time $t$.

Successive computations build one on previous ones.

We proceed by first finding an equilibrium under perfect foresight.

To compute an equilibrium with current and past but not future values of ${\theta }_t$ observed, we use a certainty equivalence principle to justify modifying the perfect foresight equilibrium by replacing future values of ${\theta }_s,{\epsilon }_s^i,s\ge t$ with mathematical expectations conditioned on ${\theta }_t$.

This provides the equilibrium when ${\theta }_t$ is observed at $t$ but future ${\theta }_{t+j}$ and ${\epsilon }_{t+j}^i$ are not observed.

To find an equilibrium when a history $w^t$ observations of a single noise-ridden ${\theta }_t$ is observed, we again apply a certainty equivalence principle and replace future values of the random variables ${\theta }_s,{\epsilon }_s^i,s\ge t$ with their mathematical expectations conditioned on $w^t$.

To find an equilibrium when a history $w^t$ of two noisy signals on ${\theta }_t$ is observed, we replace future values of the random variables ${\theta }_s,{\epsilon }_s^i,s\ge t$ with their mathematical expectations conditioned on history $w^t$.

We call the equilibrium with two noise-ridden observations on ${\theta }_t$ a pooling equilibrium.

• It corresponds to an arrangement in which at the beginning of each period firms in industries $1$ and $2$ somehow get together and share information about current values of their noisy signals on $\theta$.

We want ultimately to compare outcomes in a pooling equilibrium with an equilibrium under the following alternative information structure for a firm in industry $i$ that originally interested Townsend [Townsend, 1983]:

• Firm $i$’s noise-ridden signal on ${\theta }_t$ and the price in industry $-i$, a firm in industry $i$ observes a history $w^t$ of one noise-ridden signal on ${\theta }_t$ and a history of industry $-i$’s price is observed. (Here $-i$ means ``not $i$’’.)

With this information structure, a representative firm $i$ sees the price as well as the aggregate endogenous state variable $Y_t^i$ in its own industry.

That allows it to infer the total demand shock ${\theta }_t+{\epsilon }_t^i$.

However, at time $t$, the firm sees only $P_t^{-i}$ and does not see $Y_t^{-i}$, so that a firm in industry $i$ does not directly observe ${\theta }_t+{\epsilon }_t^{-i}$.

Nevertheless, it will turn out that equilibrium prices and quantities in this equilibrium equal their counterparts in a pooling equilibrium because firms in industry $i$ are able to infer the noisy signal about the demand shock received by firms in industry $-i$.

We shall verify this assertion by using a guess and verify tactic that involves running a least squares regression and inspecting its $R^2$. 1

34.4. Equilibrium Conditions#

It is convenient to solve a firm’s problem without uncertainty by forming the Lagrangian:

where $\{{\varphi }_t^i\}$ is a sequence of Lagrange multipliers on the transition law $k_{t+1}^i=k_t^i+{\mu }_t^i$.

First order conditions for the nonstochastic problem are

Substituting the demand function (34.2) for $P_t^i$, imposing the condition $k_t^i=K_t^i$ that makes representative firm be representative, and using definition (34.6) of $g_t^i$, the Euler equation (34.4) lagged by one period can be expressed as $-b{k}_t^i+{\theta }_t+{\epsilon }_t^i+(k_{t+1}^i-k_t^i)-g_t^i=0$ or

where we define $g_t^i$ by

We can write Euler equation (34.4) as:

In addition, we have the law of motion for ${\theta }_t$, (34.3), and the demand equation (34.2).

In summary, with perfect foresight, equilibrium conditions for industry $i$ comprise the following system of difference equations:

Without perfect foresight, the same system prevails except that the following equation replaces the third equation of (34.8):

where $x_{t+1,t}$ denotes the mathematical expectation of $x_{t+1}$ conditional on information at time $t$.

34.5. Equilibrium with ${\theta }_t$ stochastic but observed at $t$#

If future $\theta$’s are unknown at $t$, it is appropriate to replace all random variables on the right side of (34.10) with their conditional expectations based on the information available to decision makers in market $i$.

For now, we assume that this information set is $I_t^p=\left[\begin{array}{cc}{\theta }^t& {\epsilon }^{it}\end{array}\right]$, where $z^t$ represents the semi-infinite history of variable $z_s$ up to time $t$.

Later we shall give firms less information.

To obtain an appropriate counterpart to (34.10) under our current assumption about information, we apply a certainty equivalence principle.

In particular, it is appropriate to take (34.10) and replace each term $({\epsilon }_{t+j}^i+{\theta }_{t+j})$ on the right side with $E[({\epsilon }_{t+j}^i+{\theta }_{t+j})|{\theta }^t]$.

After using (34.3) and the i.i.d. assumption about $\{{\epsilon }_t^i\}$, this gives

or

where $\lambda \equiv (\beta \tilde{\lambda }{)}^{-1}$.

For our purposes, it is convenient to represent the equilibrium $\{k_t^i{\}}_t$ process recursively as

34.6. Guess-and-Verify Tactic#

As a preliminary step we shall take our recursive representation (34.23) of an equilibrium in industry $i$ with one noisy signal on ${\theta }_t$ and perform the following steps:

• Compute $\lambda$ and $\tilde{\lambda }$ by posing a root-finding problem and solving it with numpy.roots

• Compute $p$ by forming the appropriate discrete Riccati equation and then solving it using quantecon.solve_discrete_riccati

• Add a measurement equation for $P_t^i=b{k}_t^i+{\theta }_t+e_t$, ${\theta }_t+e_t$, and $e_t$ to system (34.23).

• Write the resulting system in state-space form and encode it using quantecon.LinearStateSpace

• Use methods of the quantecon.LinearStateSpace to compute impulse response functions of $k_t^i$ with respect to shocks $v_t,e_t$.

After analyzing the one-noisy-signal structure in this way, by making appropriate modifications we shall analyze the two-noisy-signal structure.

We proceed to analyze first the one-noisy-signal structure and then the two-noisy-signal structure.

34.7. Equilibrium with One Noisy Signal on ${\theta }_t$#

import numpy as np
import quantecon as qe
import plotly.graph_objects as go
import plotly.offline as pyo
from statsmodels.regression.linear_model import OLS
from IPython.display import display, Latex, Image

pyo.init_notebook_mode(connected=True)

β = 0.9  # Discount factor
ρ = 0.8  # Persistence parameter for the hidden state
b = 1.5  # Demand curve parameter
σ_v = 0.5  # Standard deviation of shock to θ_t
σ_e = 0.6  # Standard deviation of shocks to w_t

# Compute λ
poly = np.array([1, -(1 + β + b) / β, 1 / β])
roots_poly = np.roots(poly)
λ_tilde = roots_poly.min()
λ = roots_poly.max()

# Verify that λ = (βλ_tilde) ^ (-1)
tol = 1e-12
np.max(np.abs(λ - 1 / (β * λ_tilde))) < tol

True

A_ricc = np.array([[ρ]])
B_ricc = np.array([[1.]])
R_ricc = np.array([[σ_e ** 2]])
Q_ricc = np.array([[σ_v ** 2]])
N_ricc = np.zeros((1, 1))
p = qe.solve_discrete_riccati(A_ricc, B_ricc, Q_ricc, R_ricc, N_ricc).item()

p_one = p  # Save for comparison later

# Verify that p = σ_v ^ 2 + p * ρ ^ 2 - (ρ * p) ^ 2 / (p + σ_e ** 2)
tol = 1e-12
np.abs(p - (σ_v ** 2 + p * ρ ** 2 - (ρ * p) ** 2 / (p + σ_e ** 2))) < tol

True

κ = ρ * p / (p + σ_e ** 2)
κ_prod = κ * σ_e ** 2 / p

κ_one = κ  # Save for comparison later

A_lss = np.array([[0., 0., 0., 0., 0., 0.],
                 [κ / (λ - ρ), λ_tilde, -κ_prod / (λ - ρ), 0., ρ / (λ - ρ), 0.],
                 [-κ, 0., κ_prod, 0., 0., 1.],
                 [b * κ / (λ - ρ) , b * λ_tilde, -b * κ_prod / (λ - ρ), 0., b * ρ / (λ - ρ) + ρ, 1.],
                 [0., 0., 0., 0., ρ, 1.],
                 [0., 0., 0., 0., 0., 0.]])

C_lss = np.array([[σ_e, 0.],
                 [0.,  0.],
                 [0.,  0.],
                 [σ_e, 0.],
                 [0., 0.],
                 [0., σ_v]])

G_lss = np.array([[0., 0., 0., 1., 0., 0.],
                 [1., 0., 0., 0., 1., 0.],
                 [1., 0., 0., 0., 0., 0.]])

mu_0 = np.array([0., 0., 0., 0., 0., 0.])

lss = qe.LinearStateSpace(A_lss, C_lss, G_lss, mu_0=mu_0)

ts_length = 100_000
x, y = lss.simulate(ts_length, random_state=1)

# Verify that two ways of computing P_t match
np.max(np.abs(np.array([[1., b, 0., 0., 1., 0.]]) @ x - x[3])) < 1e-12

True

34.7.4. Step 4: Compute impulse response functions#

To compute impulse response functions of $k_t^i$, we use the impulse_response method of the quantecon.LinearStateSpace class and plot outcomes.

xcoef, ycoef = lss.impulse_response(j=21)
data = np.array([xcoef])[0, :, 1, :]

fig = go.Figure(data=go.Scatter(y=data[:-1, 0], name=r'$e_{t+1}$'))
fig.add_trace(go.Scatter(y=data[1:, 1], name=r'$v_{t+1}$'))
fig.update_layout(title=r'Impulse Response Function',
                   xaxis_title='Time',
                   yaxis_title=r'$k^{i}_{t}$')
fig1 = fig
# Export to PNG file
Image(fig1.to_image(format="png"))
# fig1.show() will provide interactive plot when running
# notebook locally

_, _, Σ_x, Σ_y, Σ_yx = lss.stationary_distributions()

Σ_11 = Σ_x[0, 0]
Σ_12 = Σ_x[0, 1:4]
Σ_21 = Σ_x[1:4, 0]
Σ_22 = Σ_x[1:4, 1:4]

reg_coeffs = Σ_12 @ np.linalg.inv(Σ_22)

print('Regression coefficients (e_t on k_t, P_t, \\tilde{\\theta_t})')
print('------------------------------')
print(r'k_t:', reg_coeffs[0])
print(r'\tilde{\theta_t}:', reg_coeffs[1])
print(r'P_t:', reg_coeffs[2])

Regression coefficients (e_t on k_t, P_t, \tilde{\theta_t})
------------------------------
k_t: -3.275556845219769
\tilde{\theta_t}: -0.9649461170475457
P_t: 0.9649461170475457

# Compute R squared
R_squared = reg_coeffs @ Σ_x[1:4, 1:4] @ reg_coeffs  / Σ_x[0, 0]
R_squared

0.9649461170475461

# Verify that the computed coefficients are close to least squares estimates
model = OLS(x[0], x[1:4].T)
reg_res = model.fit()
np.max(np.abs(reg_coeffs - reg_res.params)) < 1e-2

True

# Verify that R_squared matches least squares estimate
np.abs(reg_res.rsquared - R_squared) < 1e-2

True

# Verify that θ_t + e_t can be recovered
model = OLS(y[1], x[1:4].T)
reg_res = model.fit()
np.abs(reg_res.rsquared - 1.) < 1e-6

True

34.8. Equilibrium with Two Noisy Signals on ${\theta }_t$#

Steps 1, 4, and 5 are identical to those for the one-noisy-signal structure.

Step 2 requires a straightforward modification.

For step 3, we construct the following state-space representation so that we can get our hands on all of the random processes that we require in order to compute a regression of the noisy signal about $\theta$ from the other industry that a firm receives directly in a pooling equilibrium against information that a firm would receive in Townsend’s original model.

For this purpose, we include equilibrium goods prices from both industries in the state vector:

A_ricc = np.array([[ρ]])
B_ricc = np.array([[np.sqrt(2)]])
R_ricc = np.array([[σ_e ** 2]])
Q_ricc = np.array([[σ_v ** 2]])
N_ricc = np.zeros((1, 1))
p = qe.solve_discrete_riccati(A_ricc, B_ricc, Q_ricc, R_ricc, N_ricc).item()

p_two = p  # Save for comparison later

# Verify that p = σ_v^2 + (pρ^2σ_e^2) / (2p + σ_e^2)
tol = 1e-12
np.abs(p - (σ_v ** 2 + p * ρ ** 2 * σ_e ** 2 / (2 * p + σ_e ** 2))) < tol

True

κ = ρ * p / (2 * p + σ_e ** 2)
κ_prod = κ * σ_e ** 2 / p

κ_two = κ  # Save for comparison later

A_lss = np.array([[0., 0., 0., 0., 0., 0., 0., 0.],
                 [0., 0., 0., 0., 0., 0., 0., 0.],
                 [κ / (λ - ρ), κ / (λ - ρ), λ_tilde, -κ_prod / (λ - ρ), 0., 0., ρ / (λ - ρ), 0.],
                 [-κ, -κ, 0., κ_prod, 0., 0., 0., 1.],
                 [b * κ / (λ - ρ), b * κ / (λ - ρ), b * λ_tilde, -b * κ_prod / (λ - ρ), 0., 0., b * ρ / (λ - ρ) + ρ, 1.],
                 [b * κ / (λ - ρ), b * κ / (λ - ρ), b * λ_tilde, -b * κ_prod / (λ - ρ), 0., 0., b * ρ / (λ - ρ) + ρ, 1.],
                 [0., 0., 0., 0., 0., 0., ρ, 1.],
                 [0., 0., 0., 0., 0., 0., 0., 0.]])

C_lss = np.array([[σ_e, 0., 0.],
                 [0., σ_e, 0.],
                 [0., 0.,  0.],
                 [0., 0.,  0.],
                 [σ_e, 0., 0.],
                 [0., σ_e, 0.],
                 [0., 0., 0.],
                 [0., 0., σ_v]])

G_lss = np.array([[0., 0., 0., 0., 1., 0., 0., 0.],
                 [0., 0, 0, 0., 0., 1., 0., 0.],
                 [1., 0., 0., 0., 0., 0., 1., 0.],
                 [0., 1., 0., 0., 0., 0., 1., 0.],
                 [1., 0., 0., 0., 0., 0., 0., 0.],
                 [0., 1., 0., 0., 0., 0., 0., 0.]])