66. Markov Perfect Equilibrium#

66.2.1. Example: A Duopoly Model#

Two firms are the only producers of a good, the demand for which is governed by a linear inverse demand function

Here $p=p_t$ is the price of the good, $q_i=q_{it}$ is the output of firm $i=1,2$ at time $t$ and $a_0>0,a_1>0$.

In (66.1) and what follows,

• the time subscript is suppressed when possible to simplify notation

• $\hat{x}$ denotes a next period value of variable $x$

Each firm recognizes that its output affects total output and therefore the market price.

The one-period payoff function of firm $i$ is price times quantity minus adjustment costs:

Substituting the inverse demand curve (66.1) into (66.2) lets us express the one-period payoff as

where $q_{-i}$ denotes the output of the firm other than $i$.

The objective of the firm is to maximize $\sum _{t=0}^{\mathrm{\infty }}{\beta }^t{\pi }_{it}$.

Firm $i$ chooses a decision rule that sets next period quantity ${\hat{q}}_i$ as a function $f_i$ of the current state $(q_i,q_{-i})$.

An essential aspect of a Markov perfect equilibrium is that each firm takes the decision rule of the other firm as known and given.

Given $f_{-i}$, the Bellman equation of firm $i$ is

Definition A Markov perfect equilibrium of the duopoly model is a pair of value functions $(v_1,v_2)$ and a pair of policy functions $(f_1,f_2)$ such that, for each $i\in \{1,2\}$ and each possible state,

• The value function $v_i$ satisfies Bellman equation (66.4).

• The maximizer on the right side of (66.4) equals $f_i(q_i,q_{-i})$.

The adjective “Markov” denotes that the equilibrium decision rules depend only on the current values of the state variables, not other parts of their histories.

“Perfect” means complete, in the sense that the equilibrium is constructed by backward induction and hence builds in optimizing behavior for each firm at all possible future states.

• These include many states that will not be reached when we iterate forward on the pair of equilibrium strategies $f_i$ starting from a given initial state.

66.2.2. Computation#

One strategy for computing a Markov perfect equilibrium is iterating to convergence on pairs of Bellman equations and decision rules.

In particular, let $v_i^j,f_i^j$ be the value function and policy function for firm $i$ at the $j$-th iteration.

Imagine constructing the iterates

These iterations can be challenging to implement computationally.

However, they simplify for the case in which one-period payoff functions are quadratic and transition laws are linear — which takes us to our next topic.

66.3.1. Coupled Linear Regulator Problems#

We consider a general linear-quadratic regulator game with two players.

For convenience, we’ll start with a finite horizon formulation, where $t_0$ is the initial date and $t_1$ is the common terminal date.

Player $i$ takes $\{u_{-it}\}$ as given and minimizes

while the state evolves according to

Here

• $x_t$ is an $n\times 1$ state vector and $u_{it}$ is a $k_i\times 1$ vector of controls for player $i$

• $R_i$ is $n\times n$

• $S_i$ is $k_{-i}\times k_{-i}$

• $Q_i$ is $k_i\times k_i$

• $W_i$ is $n\times k_i$

• $M_i$ is $k_{-i}\times k_i$

• $A$ is $n\times n$

• $B_i$ is $n\times k_i$

66.3.2. Computing Equilibrium#

We formulate a linear Markov perfect equilibrium as follows.

Player $i$ employs linear decision rules $u_{it}=-F_{it}{x}_t$, where $F_{it}$ is a $k_i\times n$ matrix.

A Markov perfect equilibrium is a pair of sequences $\{F_{1t},F_{2t}\}$ over $t=t_0,\dots ,t_1-1$ such that

• $\{F_{1t}\}$ solves player 1’s problem, taking $\{F_{2t}\}$ as given, and

• $\{F_{2t}\}$ solves player 2’s problem, taking $\{F_{1t}\}$ as given

If we take $u_{2t}=-F_{2t}{x}_t$ and substitute it into (66.6) and (66.7), then player 1’s problem becomes minimization of

subject to

where

• ${\mathrm{\Lambda }}_{it}:=A-B_{-i}{F}_{-it}$

• ${\mathrm{\Pi }}_{it}:=R_i+F_{-it}^{\prime }{S}_i{F}_{-it}$

• ${\mathrm{\Gamma }}_{it}:=W_i^{\prime }-M_i^{\prime }{F}_{-it}$

This is an LQ dynamic programming problem that can be solved by working backwards.

Decision rules that solve this problem are

where $P_{1t}$ solves the matrix Riccati difference equation

Similarly, decision rules that solve player 2’s problem are

where $P_{2t}$ solves

Here, in all cases $t=t_0,\dots ,t_1-1$ and the terminal conditions are $P_{i{t}_1}=0$.

The solution procedure is to use equations (66.10), (66.11), (66.12), and (66.13), and “work backwards” from time $t_1-1$.

Since we’re working backward, $P_{1t+1}$ and $P_{2t+1}$ are taken as given at each stage.

Moreover, since

• some terms on the right-hand side of (66.10) contain $F_{2t}$

• some terms on the right-hand side of (66.12) contain $F_{1t}$

we need to solve these $k_1+k_2$ equations simultaneously.

66.3.3. Implementation#

We use the function nnash from QuantEcon.py that computes a Markov perfect equilibrium of the infinite horizon linear-quadratic dynamic game in the manner described above.

66.4.1. A Duopoly Model#

To map the duopoly model into coupled linear-quadratic dynamic programming problems, define the state and controls as

If we write

where $Q_1=Q_2=\gamma$,

then we recover the one-period payoffs in expression (66.3).

The law of motion for the state $x_t$ is $x_{t+1}=A{x}_t+B_1{u}_{1t}+B_2{u}_{2t}$ where

The optimal decision rule of firm $i$ will take the form $u_{it}=-F_i{x}_t$, inducing the following closed-loop system for the evolution of $x$ in the Markov perfect equilibrium:

66.4.2. Parameters and Solution#

Consider the previously presented duopoly model with parameter values of:

• $a_0=10$

• $a_1=2$

• $\beta =0.96$

• $\gamma =12$

From these, we compute the infinite horizon MPE using the preceding code

import numpy as np
import quantecon as qe

# Parameters
a0 = 10.0
a1 = 2.0
β = 0.96
γ = 12.0

# In LQ form
A = np.eye(3)
B1 = np.array([[0.], [1.], [0.]])
B2 = np.array([[0.], [0.], [1.]])


R1 = [[      0.,     -a0 / 2,          0.],
      [-a0 / 2.,          a1,     a1 / 2.],
      [       0,     a1 / 2.,          0.]]

R2 = [[     0.,           0.,      -a0 / 2],
      [     0.,           0.,      a1 / 2.],
      [-a0 / 2,      a1 / 2.,           a1]]

Q1 = Q2 = γ
S1 = S2 = W1 = W2 = M1 = M2 = 0.0

# Solve using QE's nnash function
F1, F2, P1, P2 = qe.nnash(A, B1, B2, R1, R2, Q1, 
                          Q2, S1, S2, W1, W2, M1, 
                          M2, beta=β)

# Display policies
print("Computed policies for firm 1 and firm 2:\n")
print(f"F1 = {F1}")
print(f"F2 = {F2}")
print("\n")

Computed policies for firm 1 and firm 2:

F1 = [[-0.66846615  0.29512482  0.07584666]]
F2 = [[-0.66846615  0.07584666  0.29512482]]

Running the code produces the following output.

One way to see that $F_i$ is indeed optimal for firm $i$ taking $F_2$ as given is to use QuantEcon.py’s LQ class.

In particular, let’s take F2 as computed above, plug it into (66.8) and (66.9) to get firm 1’s problem and solve it using LQ.

We hope that the resulting policy will agree with F1 as computed above

Λ1 = A - B2 @ F2
lq1 = qe.LQ(Q1, R1, Λ1, B1, beta=β)
P1_ih, F1_ih, d = lq1.stationary_values()
F1_ih

array([[-0.66846613,  0.29512482,  0.07584666]])

This is close enough for rock and roll, as they say in the trade.

Indeed, np.allclose agrees with our assessment

np.allclose(F1, F1_ih)

True

66.4.3. Dynamics#

Let’s now investigate the dynamics of price and output in this simple duopoly model under the MPE policies.

Given our optimal policies $F1$ and $F2$, the state evolves according to (66.14).

The following program

• imports $F1$ and $F2$ from the previous program along with all parameters.

• computes the evolution of $x_t$ using (66.14).

• extracts and plots industry output $q_t=q_{1t}+q_{2t}$ and price $p_t=a_0-a_1{q}_t$.

AF = A - B1 @ F1 - B2 @ F2
n = 20
x = np.empty((3, n))
x[:, 0] = 1, 1, 1
for t in range(n-1):
    x[:, t+1] = AF @ x[:, t]
q1 = x[1, :]
q2 = x[2, :]
q = q1 + q2       # Total output, MPE
p = a0 - a1 * q   # Price, MPE

fig, ax = plt.subplots(figsize=(9, 5.8))
ax.plot(q, 'b-', lw=2, alpha=0.75, label='total output')
ax.plot(p, 'g-', lw=2, alpha=0.75, label='price')
ax.set_title('Output and prices, duopoly MPE')
ax.legend(frameon=False)
plt.show()

Note that the initial condition has been set to $q_{10}=q_{20}=1.0$.

To gain some perspective we can compare this to what happens in the monopoly case.

The first panel in the next figure compares output of the monopolist and industry output under the MPE, as a function of time.

The second panel shows analogous curves for price.

Here parameters are the same as above for both the MPE and monopoly solutions.

The monopolist initial condition is $q_0=2.0$ to mimic the industry initial condition $q_{10}=q_{20}=1.0$ in the MPE case.

As expected, output is higher and prices are lower under duopoly than monopoly.