Code should execute sequentially if run in a Jupyter notebook

- See the set up page to install Jupyter, Julia (0.6+) and all necessary libraries
- Please direct feedback to contact@quantecon.org or the discourse forum

# Rational Expectations Equilibrium¶

Contents

“If you’re so smart, why aren’t you rich?”

## Overview¶

This lecture introduces the concept of *rational expectations equilibrium*

To illustrate it, we describe a linear quadratic version of a famous and important model due to Lucas and Prescott [LP71]

This 1971 paper is one of a small number of research articles that kicked off the *rational expectations revolution*

We follow Lucas and Prescott by employing a setting that is readily “Bellmanized” (i.e., capable of being formulated in terms of dynamic programming problems)

Because we use linear quadratic setups for demand and costs, we can adapt the LQ programming techniques described in this lecture

We will learn about how a representative agent’s problem differs from a planner’s, and how a planning problem can be used to compute rational expectations quantities

We will also learn about how a rational expectations equilibrium can be characterized as a fixed point of a mapping from a *perceived law of motion* to an *actual law of motion*

Equality between a perceived and an actual law of motion for endogenous market-wide objects captures in a nutshell what the rational expectations equilibrium concept is all about

Finally, we will learn about the important “Big \(K\), little \(k\)” trick, a modeling device widely used in macroeconomics

Except that for us

- Instead of “Big \(K\)” it will be “Big \(Y\)“
- Instead of “little \(k\)” it will be “little \(y\)“

### The Big \(Y\), little \(y\) trick¶

This widely used method applies in contexts in which a “representative firm” or agent is a “price taker” operating within a competitive equilibrium

We want to impose that

- The representative firm or individual takes
*aggregate*\(Y\) as given when it chooses individual \(y\), but \(\ldots\) - At the end of the day, \(Y = y\), so that the representative firm is indeed representative

The Big \(Y\), little \(y\) trick accomplishes these two goals by

- Taking \(Y\) as beyond control when posing the choice problem of who chooses \(y\); but \(\ldots\)
- Imposing \(Y = y\)
*after*having solved the individual’s optimization problem

Please watch for how this strategy is applied as the lecture unfolds

We begin by applying the Big \(Y\), little \(y\) trick in a very simple static context

#### A simple static example of the Big \(Y\), little \(y\) trick¶

Consider a static model in which a collection of \(n\) firms produce a homogeneous good that is sold in a competitive market

Each of these \(n\) firms sells output \(y\)

The price \(p\) of the good lies on an inverse demand curve

where

- \(a_i > 0\) for \(i = 0, 1\)
- \(Y = n y\) is the market-wide level of output

Each firm has total cost function

The profits of a representative firm are \(p y - c(y)\)

Using (1), we can express the problem of the representative firm as

In posing problem (2), we want the firm to be a *price taker*

We do that by regarding \(p\) and therefore \(Y\) as exogenous to the firm

The essence of the Big \(Y\), little \(y\) trick is *not* to set \(Y = n y\) *before* taking the first-order condition with respect
to \(y\) in problem (2)

This assures that the firm is a price taker

The first order condition for problem (2) is

At this point, *but not before*, we substitute \(Y = ny\) into (3)
to obtain the following linear equation

to be solved for the competitive equilibrium market wide output \(Y\)

After solving for \(Y\), we can compute the competitive equilibrium price \(p\) from the inverse demand curve (1)

## Defining Rational Expectations Equilibrium¶

Our first illustration of a rational expectations equilibrium involves a market with \(n\) firms, each of which seeks to maximize the discounted present value of profits in the face of adjustment costs

The adjustment costs induce the firms to make gradual adjustments, which in turn requires consideration of future prices

Individual firms understand that, via the inverse demand curve, the price is determined by the amounts supplied by other firms

Hence each firm wants to forecast future total industry supplies

In our context, a forecast is generated by a belief about the law of motion for the aggregate state

Rational expectations equilibrium prevails when this belief coincides with the actual law of motion generated by production choices induced by this belief

We formulate a rational expectations equilibrium in terms of a fixed point of an operator that maps beliefs into optimal beliefs

### Competitive Equilibrium with Adjustment Costs¶

To illustrate, consider a collection of \(n\) firms producing a homogeneous good that is sold in a competitive market.

Each of these \(n\) firms sells output \(y_t\)

The price \(p_t\) of the good lies on the inverse demand curve

where

- \(a_i > 0\) for \(i = 0, 1\)
- \(Y_t = n y_t\) is the market-wide level of output

#### The Firm’s Problem¶

Each firm is a price taker

While it faces no uncertainty, it does face adjustment costs

In particular, it chooses a production plan to maximize

where

Regarding the parameters,

- \(\beta \in (0,1)\) is a discount factor
- \(\gamma > 0\) measures the cost of adjusting the rate of output

Regarding timing, the firm observes \(p_t\) and \(y_t\) when it chooses \(y_{t+1}\) at at time \(t\)

To state the firm’s optimization problem completely requires that we specify dynamics for all state variables

This includes ones that the firm cares about but does not control like \(p_t\)

We turn to this problem now

#### Prices and Aggregate Output¶

In view of (5), the firm’s incentive to forecast the market price translates into an incentive to forecast aggregate output \(Y_t\)

Aggregate output depends on the choices of other firms

We assume that \(n\) is such a large number that the output of any single firm has a negligible effect on aggregate output

That justifies firms in regarding their forecasts of aggregate output as being unaffected by their own output decisions

#### The Firm’s Beliefs¶

We suppose the firm believes that market-wide output \(Y_t\) follows the law of motion

where \(Y_0\) is a known initial condition

The *belief function* \(H\) is an equilibrium object, and hence remains to be determined

#### Optimal Behavior Given Beliefs¶

For now let’s fix a particular belief \(H\) in (8) and investigate the firm’s response to it

Let \(v\) be the optimal value function for the firm’s problem given \(H\)

The value function satisfies the Bellman equation

Let’s denote the firm’s optimal policy function by \(h\), so that

where

Evidently \(v\) and \(h\) both depend on \(H\)

#### First-Order Characterization of \(h\)¶

In what follows it will be helpful to have a second characterization of \(h\), based on first order conditions

The first-order necessary condition for choosing \(y'\) is

An important useful envelope result of Benveniste-Scheinkman [BS79] implies that to differentiate \(v\) with respect to \(y\) we can naively differentiate the right side of (9), giving

Substituting this equation into (12) gives the *Euler equation*

The firm optimally sets an output path that satisfies (13), taking (8) as given, and subject to

- the initial conditions for \((y_0, Y_0)\)
- the terminal condition \(\lim_{t \rightarrow \infty } \beta^t y_t v_y(y_{t}, Y_t) = 0\)

This last condition is called the *transversality condition*, and acts as a first-order necessary condition “at infinity”

The firm’s decision rule solves the difference equation (13) subject to the given initial condition \(y_0\) and the transversality condition

Note that solving the Bellman equation (9) for \(v\) and then \(h\) in (11) yields a decision rule that automatically imposes both the Euler equation (13) and the transversality condition

#### The Actual Law of Motion for \(\{Y_t\}\)¶

As we’ve seen, a given belief translates into a particular decision rule \(h\)

Recalling that \(Y_t = ny_t\), the *actual law of motion* for market-wide output is then

Thus, when firms believe that the law of motion for market-wide output is (8), their optimizing behavior makes the actual law of motion be (14)

### Definition of Rational Expectations Equilibrium¶

A *rational expectations equilibrium* or *recursive competitive equilibrium* of the model with adjustment costs is a decision rule \(h\) and an aggregate law of motion \(H\) such that

- Given belief \(H\), the map \(h\) is the firm’s optimal policy function
- The law of motion \(H\) satisfies \(H(Y)= nh(Y/n,Y)\) for all \(Y\)

Thus, a rational expectations equilibrium equates the perceived and actual laws of motion (8) and (14)

#### Fixed point characterization¶

As we’ve seen, the firm’s optimum problem induces a mapping \(\Phi\) from a perceived law of motion \(H\) for market-wide output to an actual law of motion \(\Phi(H)\)

The mapping \(\Phi\) is the composition of two operations, taking a perceived law of motion into a decision rule via (9)–(11), and a decision rule into an actual law via (14)

The \(H\) component of a rational expectations equilibrium is a fixed point of \(\Phi\)

## Computation of an Equilibrium¶

Now let’s consider the problem of computing the rational expectations equilibrium

### Misbehavior of \(\Phi\)¶

Readers accustomed to dynamic programming arguments might try to address this problem by choosing some guess \(H_0\) for the aggregate law of motion and then iterating with \(\Phi\)

Unfortunately, the mapping \(\Phi\) is not a contraction

In particular, there is no guarantee that direct iterations on \(\Phi\) converge [1]

Fortunately, there is another method that works here

The method exploits a general connection between equilibrium and Pareto optimality expressed in the fundamental theorems of welfare economics (see, e.g, [MCWG95])

Lucas and Prescott [LP71] used this method to construct a rational expectations equilibrium

The details follow

### A Planning Problem Approach¶

Our plan of attack is to match the Euler equations of the market problem with those for a single-agent choice problem

As we’ll see, this planning problem can be solved by LQ control (linear regulator)

The optimal quantities from the planning problem are rational expectations equilibrium quantities

The rational expectations equilibrium price can be obtained as a shadow price in the planning problem

For convenience, in this section we set \(n=1\)

We first compute a sum of consumer and producer surplus at time \(t\)

The first term is the area under the demand curve, while the second measures the social costs of changing output

The *planning problem* is to choose a production plan \(\{Y_t\}\) to maximize

subject to an initial condition for \(Y_0\)

### Solution of the Planning Problem¶

Evaluating the integral in (15) yields the quadratic form \(a_0 Y_t - a_1 Y_t^2 / 2\)

As a result, the Bellman equation for the planning problem is

The associated first order condition is

Applying the same Benveniste-Scheinkman formula gives

Substituting this into equation (17) and rearranging leads to the Euler equation

### The Key Insight¶

Return to equation (13) and set \(y_t = Y_t\) for all \(t\)

(Recall that for this section we’ve set \(n=1\) to simplify the calculations)

A small amount of algebra will convince you that when \(y_t=Y_t\), equations (18) and (13) are identical

Thus, the Euler equation for the planning problem matches the second-order difference equation that we derived by

- finding the Euler equation of the representative firm and
- substituting into it the expression \(Y_t = n y_t\) that “makes the representative firm be representative”

If it is appropriate to apply the same terminal conditions for these two difference equations, which it is, then we have verified that a solution of the planning problem is also a rational expectations equilibrium quantity sequence

It follows that for this example we can compute equilibrium quantities by forming the optimal linear regulator problem corresponding to the Bellman equation (16)

The optimal policy function for the planning problem is the aggregate law of motion \(H\) that the representative firm faces within a rational expectations equilibrium.

#### Structure of the Law of Motion¶

As you are asked to show in the exercises, the fact that the planner’s problem is an LQ problem implies an optimal policy — and hence aggregate law of motion — taking the form

for some parameter pair \(\kappa_0, \kappa_1\)

Now that we know the aggregate law of motion is linear, we can see from the firm’s Bellman equation (9) that the firm’s problem can also be framed as an LQ problem

As you’re asked to show in the exercises, the LQ formulation of the firm’s problem implies a law of motion that looks as follows

Hence a rational expectations equilibrium will be defined by the parameters \((\kappa_0, \kappa_1, h_0, h_1, h_2)\) in (19)–(20)

## Exercises¶

### Exercise 1¶

Consider the firm problem described above

Let the firm’s belief function \(H\) be as given in (19)

Formulate the firm’s problem as a discounted optimal linear regulator problem, being careful to describe all of the objects needed

Use the type `LQ`

from the QuantEcon.jl package to solve the firm’s problem for the following parameter values:

Express the solution of the firm’s problem in the form (20) and give the values for each \(h_j\)

If there were \(n\) identical competitive firms all behaving according to (20), what would (20) imply for the *actual* law of motion (8) for market supply

### Exercise 2¶

Consider the following \(\kappa_0, \kappa_1\) pairs as candidates for the aggregate law of motion component of a rational expectations equilibrium (see (19))

Extending the program that you wrote for exercise 1, determine which if any satisfy the definition of a rational expectations equilibrium

- (94.0886298678, 0.923409232937)
- (93.2119845412, 0.984323478873)
- (95.0818452486, 0.952459076301)

Describe an iterative algorithm that uses the program that you wrote for exercise 1 to compute a rational expectations equilibrium

(You are not being asked actually to use the algorithm you are suggesting)

### Exercise 3¶

Recall the planner’s problem described above

Formulate the planner’s problem as an LQ problem

Solve it using the same parameter values in exercise 1

- \(a_0= 100, a_1= 0.05, \beta = 0.95, \gamma=10\)

Represent the solution in the form \(Y_{t+1} = \kappa_0 + \kappa_1 Y_t\)

Compare your answer with the results from exercise 2

### Exercise 4¶

A monopolist faces the industry demand curve (5) and chooses \(\{Y_t\}\) to maximize \(\sum_{t=0}^{\infty} \beta^t r_t\) where

Formulate this problem as an LQ problem

Compute the optimal policy using the same parameters as the previous exercise

In particular, solve for the parameters in

Compare your results with the previous exercise. Comment.

## Solutions¶

The following solutions were put together by Chase Coleman, Spencer Lyon, Thomas Sargent and John Stachurski

### Exercise 1¶

```
using QuantEcon
```

To map a problem into a discounted optimal linear control problem, we need to define

- state vector \(x_t\) and control vector \(u_t\)
- matrices \(A, B, Q, R\) that define preferences and the law of motion for the state

For the state and control vectors we choose

For \(, B, Q, R\) we set

By multiplying out you can confirm that

- \(x_t' R x_t + u_t' Q u_t = - r_t\)
- \(x_{t+1} = A x_t + B u_t\)

We’ll use the module `lqcontrol.jl`

to solve the firm’s problem at the
stated parameter values

This will return an LQ policy \(F\) with the interpretation \(u_t = - F x_t\), or

Matching parameters with \(y_{t+1} = h_0 + h_1 y_t + h_2 Y_t\) leads to

Here’s our solution

```
# == Model parameters == #
a0 = 100
a1 = 0.05
bet = 0.95
gamma = 10.0
# == Beliefs == #
kappa0 = 95.5
kappa1 = 0.95
# == Formulate the LQ problem == #
A = [1 0 0
0 kappa1 kappa0
0 0 1]
B = [1.0, 0.0, 0.0]
R = [0 a1/2 -a0/2
a1/2 0 0
-a0/2 0 0]
Q = 0.5 * gamma
# == Solve for the optimal policy == #
lq = LQ(Q, R, A, B; bet = bet)
P, F, d = stationary_values(lq)
hh = h0, h1, h2 = -F[3], 1 - F[1], -F[2]
@printf("F = [%.3f, %.3f, %.3f]\n", F[1], F[2], F[3])
@printf("(h0, h1, h2) = [%.3f, %.3f, %.3f]\n", h0, h1, h2)
```

```
F = [-0.000, 0.046, -96.949]
(h0, h1, h2) = [96.949, 1.000, -0.046]
```

The implication is that

For the case \(n > 1\), recall that \(Y_t = n y_t\), which, combined with the previous equation, yields

### Exercise 2¶

To determine whether a \(\kappa_0, \kappa_1\) pair forms the aggregate law of motion component of a rational expectations equilibrium, we can proceed as follows:

- Determine the corresponding firm law of motion \(y_{t+1} = h_0 + h_1 y_t + h_2 Y_t\)
- Test whether the associated aggregate law :\(Y_{t+1} = n h(Y_t/n, Y_t)\) evaluates to \(Y_{t+1} = \kappa_0 + \kappa_1 Y_t\)

In the second step we can use \(Y_t = n y_t = y_t\), so that \(Y_{t+1} = n h(Y_t/n, Y_t)\) becomes

Hence to test the second step we can test \(\kappa_0 = h_0\) and \(\kappa_1 = h_1 + h_2\)

The following code implements this test

```
candidates = ([94.0886298678, 0.923409232937],
[93.2119845412, 0.984323478873],
[95.0818452486, 0.952459076301])
for (k0, k1) in candidates
A = [1 0 0
0 k1 k0
0 0 1]
lq = LQ(Q, R, A, B; bet = bet)
P, F, d = stationary_values(lq)
hh = h0, h1, h2 = -F[3], 1 - F[1], -F[2]
if isapprox(k0, h0; atol = 1e-4) && isapprox(k1, h1 + h2; atol = 1e-4)
@printf("Equilibrium pair = (%.6f, %.6f)\n", k0, k1)
@printf("(h0, h1, h2) = [%.6f, %.6f, %.6f]\n", h0, h1, h2)
end
end
```

```
Equilibrium pair = (95.081845, 0.952459)
(h0, h1, h2) = [95.081891, 1.000000, -0.047541]
```

The output tells us that the answer is pair (iii), which implies \((h_0, h_1, h_2) = (95.0819, 1.0000, -.0475)\)

(Notice we use `isapprox`

to test equality of floating point numbers,
since exact equality is too strict)

Regarding the iterative algorithm, one could loop from a given \((\kappa_0, \kappa_1)\) pair to the associated firm law and then to a new \((\kappa_0, \kappa_1)\) pair

This amounts to implementing the operator \(\Phi\) described in the lecture

(There is in general no guarantee that this iterative process will converge to a rational expectations equilibrium)

### Exercise 3¶

We are asked to write the planner problem as an LQ problem

For the state and control vectors we choose

For the LQ matrices we set

By multiplying out you can confirm that

- \(x_t' R x_t + u_t' Q u_t = - s(Y_t, Y_{t+1})\)
- \(x_{t+1} = A x_t + B u_t\)

By obtaining the optimal policy and using \(u_t = - F x_t\) or

we can obtain the implied aggregate law of motion via \(\kappa_0 = -F_1\) and \(\kappa_1 = 1-F_0\)

The Python code to solve this problem is below:

```
# == Formulate the planner's LQ problem == #
A = eye(2)
B = [1.0, 0.0]
R = [a1 / 2.0 -a0 / 2.0
-a0 / 2.0 0.0]
Q = gamma / 2.0
# == Solve for the optimal policy == #
lq = LQ(Q, R, A, B; bet = bet)
P, F, d = stationary_values(lq)
# == Print the results == #
kappa0, kappa1 = -F[2], 1 - F[1]
println("kappa0=$kappa0\tkappa1=$kappa1")
```

```
kappa0=95.08187459215002 kappa1=0.9524590627039248
```

The output yields the same \((\kappa_0, \kappa_1)\) pair obtained as an equilibrium from the previous exercise

### Exercise 4¶

The monopolist’s LQ problem is almost identical to the planner’s problem from the previous exercise, except that

The problem can be solved as follows

```
# == Formulate the monopolist's LQ problem == #
A = eye(2)
B = [1.0, 0.0]
R = [a1 -a0 / 2.0
-a0 / 2.0 0.0]
Q = gamma / 2.0
# == Solve for the optimal policy == #
lq = LQ(Q, R, A, B; bet = bet)
P, F, d = stationary_values(lq)
# == Print the results == #
m0, m1 = -F[2], 1 - F[1]
println("m0=$m0\tm1=$m1")
```

```
m0=73.47294403502833 m1=0.9265270559649701
```

We see that the law of motion for the monopolist is approximately \(Y_{t+1} = 73.4729 + 0.9265 Y_t\)

In the rational expectations case the law of motion was approximately \(Y_{t+1} = 95.0819 + 0.9525 Y_t\)

One way to compare these two laws of motion is by their fixed points, which give long run equilibrium output in each case

For laws of the form \(Y_{t+1} = c_0 + c_1 Y_t\), the fixed point is \(c_0 / (1 - c_1)\)

If you crunch the numbers, you will see that the monopolist adopts a lower long run quantity than obtained by the competitive market, implying a higher market price

This is analogous to the elementary static-case results

Footnotes

[1] | A literature that studies whether models populated with agents
who learn can converge to rational expectations equilibria features
iterations on a modification of the mapping \(\Phi\) that can be
approximated as \(\gamma \Phi + (1-\gamma)I\). Here \(I\) is the
identity operator and \(\gamma \in (0,1)\) is a relaxation parameter.
See [MS89] and [EH01] for statements
and applications of this approach to establish conditions under which
collections of adaptive agents who use least squares learning converge to a
rational expectations equilibrium. |