23. Dynamics in One Dimension#

23.1. Overview#

In economics many variables depend on their past values

For example, it seems reasonable to believe that inflation last year with affects inflation this year.

(Perhaps high inflation last year will lead people to demand higher wages to compensate, which will feed into higher prices this year.)

Letting $π_{t}$ be inflation this year and $π_{t - 1}$ be inflation last year, we can write this relationship in a general form as

π_{t} = f (π_{t - 1})

where $f$ is some function describing the relationship between the variables.

This equation is an example of one-dimensional discrete time dynamic system.

In this lecture we cover the foundations of one-dimensional discrete time dynamics.

(While most quantitative models have two or more state variables, the one-dimensional setting is a good place to learn foundations and understand key concepts.)

Let’s start with some standard imports:

import matplotlib.pyplot as plt
import numpy as np

23.2. Some definitions#

This section sets out the objects of interest and the kinds of properties we study.

23.2.1. Composition of functions#

For this lecture you should know the following.

$g$ is a function from $A$ to $B$ and
$f$ is a function from $B$ to $C$ ,

then the composition $f \circ g$ of $f$ and $g$ is defined by

(f \circ g) (x) = f (g (x))

For example, if

$A = B = C = R$ , the set of real numbers,
$g (x) = x^{2}$ and $f (x) = \sqrt{x}$ , then $(f \circ g) (x) = \sqrt{x^{2}} = | x |$ .

If $f$ is a function from $A$ to itself, then $f^{2}$ is the composition of $f$ with itself.

For example, if $A = (0, \infty)$ , the set of positive numbers, and $f (x) = \sqrt{x}$ , then

f^{2} (x) = \sqrt{\sqrt{x}} = x^{1 / 4}

Similarly, if $n$ is a positive integer, then $f^{n}$ is $n$ compositions of $f$ with itself.

In the example above, $f^{n} (x) = x^{1 / (2^{n})}$ .

23.2.2. Dynamic systems#

A (discrete time) dynamic system is a set $S$ and a function $g$ that sends set $S$ back into to itself.

Examples of dynamic systems include

$S = (0, 1)$ and $g (x) = \sqrt{x}$
$S = (0, 1)$ and $g (x) = x^{2}$
$S = Z$ (the integers) and $g (x) = 2 x$

On the other hand, if $S = (- 1, 1)$ and $g (x) = x + 1$ , then $S$ and $g$ do not form a dynamic system, since $g (1) = 2$ .

$g$ does not always send points in $S$ back into $S$ .

We care about dynamic systems because we can use them to study dynamics!

Given a dynamic system consisting of set $S$ and function $g$ , we can create a sequence ${x_{t}}$ of points in $S$ by setting

(23.1)#

x_{t + 1} = g (x_{t}) with x_{0} given .

This means that we choose some number $x_{0}$ in $S$ and then take

(23.2)#

x_{0}, x_{1} = g (x_{0}), x_{2} = g (x_{1}) = g (g (x_{0})), etc.

This sequence ${x_{t}}$ is called the trajectory of $x_{0}$ under $g$ .

In this setting, $S$ is called the state space and $x_{t}$ is called the state variable.

Recalling that $g^{n}$ is the $n$ compositions of $g$ with itself, we can write the trajectory more simply as

x_{t} = g^{t} (x_{0}) for t = 0, 1, 2, \dots

In all of what follows, we are going to assume that $S$ is a subset of $R$ , the real numbers.

Equation (23.1) is sometimes called a first order difference equation

first order means dependence on only one lag (i.e., earlier states such as $x_{t - 1}$ do not enter into (23.1)).

23.2.3. Example: a linear model#

One simple example of a dynamic system is when $S = R$ and $g (x) = a x + b$ , where $a, b$ are constants (sometimes called ``parameters’’).

This leads to the linear difference equation

x_{t + 1} = a x_{t} + b with x_{0} given .

The trajectory of $x_{0}$ is

(23.3)#

x_{0}, a x_{0} + b, a^{2} x_{0} + a b + b, etc.

Continuing in this way, and using our knowledge of geometric series, we find that, for any $t = 0, 1, 2, \dots$ ,

(23.4)#

x_{t} = a^{t} x_{0} + b \frac{1 - a^{t}}{1 - a}

We have an exact expression for $x_{t}$ for all non-negative integer $t$ and hence a full understanding of the dynamics.

Notice in particular that $| a | < 1$ , then, by (23.4), we have

(23.5)#

x_{t} \to \frac{b}{1 - a} as t \to \infty

regardless of $x_{0}$ .

This is an example of what is called global stability, a topic we return to below.

23.2.4. Example: a nonlinear model#

In the linear example above, we obtained an exact analytical expression for $x_{t}$ in terms of arbitrary non-negative integer $t$ and $x_{0}$ .

This made analysis of dynamics very easy.

When models are nonlinear, however, the situation can be quite different.

For example, in a later lecture The Solow-Swan Growth Model, we will study the Solow-Swan growth model, which has dynamics

(23.6)#

k_{t + 1} = s A k_{t}^{α} + (1 - δ) k_{t}

Here $k = K / L$ is the per capita capital stock, $s$ is the saving rate, $A$ is the total factor productivity, $α$ is the capital share, and $δ$ is the depreciation rate.

All these parameter are positive and $0 < α, δ < 1$ .

If you try to iterate like we did in (23.3), you will find that the algebra gets messy quickly.

Analyzing the dynamics of this model requires a different method (see below).

23.3. Stability#

Consider a dynamic system consisting of set $S \subset R$ and $g$ mapping $S$ to $S$ .

23.3.1. Steady states#

A steady state of this system is a point $x^{*}$ in $S$ such that $x^{*} = g (x^{*})$ .

In other words, $x^{*}$ is a fixed point of the function $g$ in $S$ .

For example, for the linear model $x_{t + 1} = a x_{t} + b$ , you can use the definition to check that

$x^{*} := b / (1 - a)$ is a steady state whenever $a \neq 1$ ,
if $a = 1$ and $b = 0$ , then every $x \in R$ is a steady state,
if $a = 1$ and $b \neq 0$ , then the linear model has no steady state in $R$ .

23.3.2. Global stability#

A steady state $x^{*}$ of the dynamic system is called globally stable if, for all $x_{0} \in S$ ,

x_{t} = g^{t} (x_{0}) \to x^{*} as t \to \infty

For example, in the linear model $x_{t + 1} = a x_{t} + b$ with $a \neq 1$ , the steady state $x^{*}$

is globally stable if $| a | < 1$ and
fails to be globally stable otherwise.

This follows directly from (23.4).

23.3.3. Local stability#

A steady state $x^{*}$ of the dynamic system is called locally stable if there exists an $ϵ > 0$ such that

| x_{0} - x^{*} | < ϵ ⟹ x_{t} = g^{t} (x_{0}) \to x^{*} as t \to \infty

Obviously every globally stable steady state is also locally stable.

Here is an example where the converse is not true.

Example 23.1

Consider the self-map $g$ on $R$ defined by $g (x) = x^{2}$ . The fixed point $1$ is not stable.

For example, $g^{t} (x) \to \infty$ for any $x > 1$ .

However, $0$ is locally stable, because $- 1 < x < 1$ implies that $g^{t} (x) \to 0$ as $t \to \infty$ .

Since we have more than one fixed point, $0$ is not globally stable.

23.4. Graphical analysis#

As we saw above, analyzing the dynamics for nonlinear models is nontrivial.

There is no single way to tackle all nonlinear models.

However, there is one technique for one-dimensional models that provides a great deal of intuition.

This is a graphical approach based on 45-degree diagrams.

Let’s look at an example: the Solow-Swan model with dynamics given in (23.6).

We begin with some plotting code that you can ignore at first reading.

The function of the code is to produce 45-degree diagrams and time series plots.

Show source Hide code cell source

def subplots():
    "Custom subplots with axes throught the origin"
    fig, ax = plt.subplots()

    # Set the axes through the origin
    for spine in ['left', 'bottom']:
        ax.spines[spine].set_position('zero')
        ax.spines[spine].set_color('green')
    for spine in ['right', 'top']:
        ax.spines[spine].set_color('none')

    return fig, ax


def plot45(g, xmin, xmax, x0, num_arrows=6, var='x'):

    xgrid = np.linspace(xmin, xmax, 200)

    fig, ax = subplots()
    ax.set_xlim(xmin, xmax)
    ax.set_ylim(xmin, xmax)
    ax.set_xlabel(r'${}_t$'.format(var), fontsize=14)
    ax.set_ylabel(r'${}_{}$'.format(var, str('{t+1}')), fontsize=14)

    hw = (xmax - xmin) * 0.01
    hl = 2 * hw
    arrow_args = dict(fc="k", ec="k", head_width=hw,
            length_includes_head=True, lw=1,
            alpha=0.6, head_length=hl)

    ax.plot(xgrid, g(xgrid), 'b-', lw=2, alpha=0.6, label='g')
    ax.plot(xgrid, xgrid, 'k-', lw=1, alpha=0.7, label='45')

    x = x0
    xticks = [xmin]
    xtick_labels = [xmin]

    for i in range(num_arrows):
        if i == 0:
            ax.arrow(x, 0.0, 0.0, g(x), **arrow_args) # x, y, dx, dy
        else:
            ax.arrow(x, x, 0.0, g(x) - x, **arrow_args)
            ax.plot((x, x), (0, x), 'k', ls='dotted')

        ax.arrow(x, g(x), g(x) - x, 0, **arrow_args)
        xticks.append(x)
        xtick_labels.append(r'${}_{}$'.format(var, str(i)))

        x = g(x)
        xticks.append(x)
        xtick_labels.append(r'${}_{}$'.format(var, str(i+1)))
        ax.plot((x, x), (0, x), 'k', ls='dotted')

    xticks.append(xmax)
    xtick_labels.append(xmax)
    ax.set_xticks(xticks)
    ax.set_yticks(xticks)
    ax.set_xticklabels(xtick_labels)
    ax.set_yticklabels(xtick_labels)

    bbox = (0., 1.04, 1., .104)
    legend_args = {'bbox_to_anchor': bbox, 'loc': 'upper right'}

    ax.legend(ncol=2, frameon=False, **legend_args, fontsize=14)
    plt.show()

def ts_plot(g, xmin, xmax, x0, ts_length=6, var='x'):
    fig, ax = subplots()
    ax.set_ylim(xmin, xmax)
    ax.set_xlabel(r'$t$', fontsize=14)
    ax.set_ylabel(r'${}_t$'.format(var), fontsize=14)
    x = np.empty(ts_length)
    x[0] = x0
    for t in range(ts_length-1):
        x[t+1] = g(x[t])
    ax.plot(range(ts_length),
            x,
            'bo-',
            alpha=0.6,
            lw=2,
            label=r'${}_t$'.format(var))
    ax.legend(loc='best', fontsize=14)
    ax.set_xticks(range(ts_length))
    plt.show()

Let’s create a 45-degree diagram for the Solow-Swan model with a fixed set of parameters. Here’s the update function corresponding to the model.

def g(k, A = 2, s = 0.3, alpha = 0.3, delta = 0.4):
    return A * s * k**alpha + (1 - delta) * k

Here is the 45-degree plot.

xmin, xmax = 0, 4  # Suitable plotting region.

plot45(g, xmin, xmax, 0, num_arrows=0)

_images/1b22e04db6d8942db7b7b74e0126e0c76310d3c6cd2e365188831b20f8401350.png

The plot shows the function $g$ and the 45-degree line.

Think of $k_{t}$ as a value on the horizontal axis.

To calculate $k_{t + 1}$ , we can use the graph of $g$ to see its value on the vertical axis.

Clearly,

If $g$ lies above the 45-degree line at this point, then we have $k_{t + 1} > k_{t}$ .
If $g$ lies below the 45-degree line at this point, then we have $k_{t + 1} < k_{t}$ .
If $g$ hits the 45-degree line at this point, then we have $k_{t + 1} = k_{t}$ , so $k_{t}$ is a steady state.

For the Solow-Swan model, there are two steady states when $S = R_{+} = [0, \infty)$ .

the origin $k = 0$
the unique positive number such that $k = s z k^{α} + (1 - δ) k$ .

By using some algebra, we can show that in the second case, the steady state is

k^{*} = {(\frac{s z}{δ})}^{1 / (1 - α)}

23.4.1. Trajectories#

By the preceding discussion, in regions where $g$ lies above the 45-degree line, we know that the trajectory is increasing.

The next figure traces out a trajectory in such a region so we can see this more clearly.

The initial condition is $k_{0} = 0.25$ .

k0 = 0.25

plot45(g, xmin, xmax, k0, num_arrows=5, var='k')

_images/db010d4f718a925aa7e9f904c2fe8aaa879f33c54d291649a3cbba303217e635.png

We can plot the time series of per capita capital corresponding to the figure above as follows:

ts_plot(g, xmin, xmax, k0, var='k')

_images/c9b9199822d7ab92fb684eb7ee9dcbfc45764908741fb6e5116403839372f076.png

Here’s a somewhat longer view:

ts_plot(g, xmin, xmax, k0, ts_length=20, var='k')

_images/14e16a3b15fc7f90dab9694bd42a6a1fbbfd9b968010d3d348e5058bf1890a86.png

When per capita capital stock is higher than the unique positive steady state, we see that it declines:

k0 = 2.95

plot45(g, xmin, xmax, k0, num_arrows=5, var='k')

_images/629d30dddd51d46652a4fcd2ea87af943a855ab92861c341edcb290c41132adf.png

Here is the time series:

ts_plot(g, xmin, xmax, k0, var='k')

_images/2c9ec639c951c47d880ec2128bb4f13bc701a14b7c092398c778481a50b1a07d.png

23.4.2. Complex dynamics#

The Solow-Swan model is nonlinear but still generates very regular dynamics.

One model that generates irregular dynamics is the quadratic map

g (x) = 4 x (1 - x), x \in [0, 1]

Let’s have a look at the 45-degree diagram.

xmin, xmax = 0, 1
g = lambda x: 4 * x * (1 - x)

x0 = 0.3
plot45(g, xmin, xmax, x0, num_arrows=0)

_images/c5ff7c0276bb777828cbc01d5519c3b81dee173633f74579bb98ea7ae3433dc0.png

Now let’s look at a typical trajectory.

plot45(g, xmin, xmax, x0, num_arrows=6)

_images/7961d872f0961016407a9e95c8f89f6bd34f721a9f6b2873bcd309d4bce8d317.png

Notice how irregular it is.

Here is the corresponding time series plot.

ts_plot(g, xmin, xmax, x0, ts_length=6)

_images/bad45f0dce1be39fffb7fa8135ca88e9f9a95eeb4c953e76843a344eed22b069.png

The irregularity is even clearer over a longer time horizon:

ts_plot(g, xmin, xmax, x0, ts_length=20)

_images/5d054a31ca9b57bc0c44ba64b2d1006856d40909b60eec2307af137ce2f2bc10.png

23.5. Exercises#

Exercise 23.1

Consider again the linear model $x_{t + 1} = a x_{t} + b$ with $a \neq 1$ .

The unique steady state is $b / (1 - a)$ .

The steady state is globally stable if $| a | < 1$ .

Try to illustrate this graphically by looking at a range of initial conditions.

What differences do you notice in the cases $a \in (- 1, 0)$ and $a \in (0, 1)$ ?

Use $a = 0.5$ and then $a = - 0.5$ and study the trajectories.

Set $b = 1$ throughout.

Solution to Exercise 23.1

We will start with the case $a = 0.5$ .

Let’s set up the model and plotting region:

a, b = 0.5, 1
xmin, xmax = -1, 3
g = lambda x: a * x + b

Now let’s plot a trajectory:

x0 = -0.5
plot45(g, xmin, xmax, x0, num_arrows=5)

_images/0a62931bb69d5cd6f8b563a361e8390257a1ce5ace662d24f1a6dce0e047d658.png

Here is the corresponding time series, which converges towards the steady state.

ts_plot(g, xmin, xmax, x0, ts_length=10)

_images/a5894d498bd38c37a99ec7fd1da7231fde3c063e04763b270c58b627147916db.png

Now let’s try $a = - 0.5$ and see what differences we observe.

Let’s set up the model and plotting region:

a, b = -0.5, 1
xmin, xmax = -1, 3
g = lambda x: a * x + b

Now let’s plot a trajectory:

x0 = -0.5
plot45(g, xmin, xmax, x0, num_arrows=5)

_images/d514ceb73f2f313a147955ec9f5b288d027c2e4f6f41c509b693307a39bd0698.png

Here is the corresponding time series, which converges towards the steady state.

ts_plot(g, xmin, xmax, x0, ts_length=10)

_images/25f0acb334bc8deace12937e4711a541b3947d23ad09f879e103e51d3fad8859.png

Once again, we have convergence to the steady state but the nature of convergence differs.

In particular, the time series jumps from above the steady state to below it and back again.

In the current context, the series is said to exhibit damped oscillations.