Lectures Methods: Python programming for economists

People sometimes wonder why health insurance in the Netherlands is mandatory and not a (voluntary) choice by consumers. Think of creating an app which shows how markets with asymmetric information can unravel and lead to inefficient outcomes.

The following app models an adverse selection market. Well known examples of such markets are the second-hand car markets (with “lemons”) and (health) insurance markets. In each of these markets there is asymmetric information. The seller of the car has used the car herself. She knows how (aggressively) she has driven the car, taken care of the car, her investments in car maintenance etc. For the buyer this is not so clear. In the health insurance market, the insurer offers contracts to insure healthcare costs. The consumer has more information on his own health than the insurer does. Does he have a (chronic) disease? Does he have a healthy diet, exercise regularly etc.

The equilibrium in these markets tends to be inefficient: there is less trade than would be optimal from a welfare point of view. With the next app you can see how this inefficiency is affected by parameter values.

One interpretation of the iteration in the app is that agents react to what they saw in the previous period. In a health insurance context this would be: an insurer sells a health insurance contract, some consumers buy the contract and the price of the contract in the next period is the average costs of the contract in this period. If this price is rather high, some healthy people will decide not to buy health insurance because it is too expensive. This increases the average cost of the contract for the insurer (conditional on buying the contract, the customers have lower health status and higher healthcare expenditure). So in period 3 the insurance premium increases again, perhaps inducing some of the healthier customers to forego insurance etc.

This process is called the unraveling of the market or a death spiral.

The context of the app is more like the second-hand car market: sellers value their car at \(q\) and are willing to sell to any buyer who pays a price above \(q\). Each car is worth more to the buyer than to the seller but the buyer cannot observe \(q\). If people are only willing to sell their car if \(q \leq p\) the buyer’s expectation of quality is given by \(E(q|q \leq p)\). By assumption the car has more value for the buyer than the seller, hence the buyer is willing to pay a markup over \(E(q|q \leq p)\) to buy the car. Which share of cars are going to be traded in the market?

Consider two profit maximizing firms in a market. Each firm wants to choose an optimal reaction to the other firm’s action, but then the “other firm” also reacts to the first firm’s choice of action. Is this not an infinite loop with no ending? Think of an app that can show this iterated reaction to the other firm and how this converges to (Nash) equilibrium.

This app considers a Cournot market with two firms producing a homogenous good at constant marginal cost \(c\). Demand is of the form \(p = p(q_1+q_2)\). Hence, firm \(i\) maximizes profits

with \(j \neq i \in \{1,2\}\) taking the output of the other firm as given.

Assume that demand is linear: \(p(q_1+q_2)=1-q_1-q_2\). Take the first order condition, say for firm 1, and show that this can be written as \(1-2q_1-q_2-c=0\) and derive the optimal reaction function \(r_1(q_1)\) shown in the app.

One way to derive the Nash equilibium is to use iterated best responses: start with an initial guess for \(q_1\) denoted by \(q_1^0\). Calculate firm 2’s optimal reaction: \(q_2^1=r_2(q_1^0)\). Then find 1’s optimal reaction to this: \(q_1^2 = r_1(q_2^1)\) etc. The figure shows you this process. In this case, these iterations converge to the Nash equilibrium.

Sometimes the state of the labor market is summarized simply by the unemployment rate; but not all employment is equal. People can learn on the job and become more productive in their work. Think of an app that illustrates different employment states. Is it the case that more people in high wage jobs lead to lower unemployment than when these people are in low wage jobs?

Suppose we have an inelastic labor supply normalized to a mass of 1. Labor can be in one of three states: unemployed, employed in a low wage job and employed in a high wage job. With transition equations we can keep track of the development over time of the fraction of people in each of these three states.

In the adverse selection model, sellers have goods of quality \(q\) uniformly distributed on \([v_0, v_1]\). Sellers only offer goods if the market price \(p \geq q\). Buyers value quality at a mark-up:

\[ p = \mathrm{markup} \times E(q \mid q < p) \]

The equilibrium is found by iterating this price update until convergence.

Python code in Marimo:

We import the relevant libraries and define some interactive sliders.

import marimo as mo
import numpy as np
import matplotlib.pyplot as plt

v0 = mo.ui.slider(0, 100, value=50, label="Lowest quality $v_0$")
v1 = mo.ui.slider(1, 200, value=100, label="Highest quality $v_1$")
markup = mo.ui.slider(1.01, 2.0, value=1.2, step=0.01, label="Consumer mark-up")

mo.hstack([v0,v1,markup])

In marimo sliders are defined with mo.ui.slider, then give the starting value, the end value (a step, is the step is not one) and an initial value (the default value if the user does choose a value). Also give the slider a label so that the user knows what it represents. Defining a slider does not imply that it shows up. Calling the slider with, say, v0 makes it visible to the user. With mo.hstack you can stack the sliders; here we stack them horizontally.

def expected_q_given_p_uniform(p, a, b):
    if p < a:
        return None
    elif p >= b:
        return (a + b) / 2
    else:
        return (a + p) / 2

def update_price_uniform(p, a, b, markup):
    expected_q = expected_q_given_p_uniform(p, a, b)
    if expected_q is None:
        return 0
    return markup * expected_q

p = markup.value * v1.value
history = []
for _ in range(50):
    history.append(p)
    new_p = update_price_uniform(p, v0.value, v1.value, markup.value)
    if abs(new_p - p) < 1e-6:
        break
    p = new_p
plt.plot(history)

The code above uses marimo sliders for the parameter values. If you want to refer to the value of a slider use .value like v0.value. In other words, v0 refers to the slider itself and v0.value to the value that is selected with the slider.

The function expected_q_given_p_uniform computes the expected quality conditional on \(q < p\). With a uniform distribution and \(p \in [a,b]\), this expectation equals \((a+p)/2\). Given expected_q, we can calculate the price that consumers are willing to pay, using the markup. Then we iterate over the prices by adjusting the expectation based on last period’s price. The price update is iterated until convergence: the new price is very close to previous period’s price and we reach steady state. If you do not understand what 1e-6 means, use google or an LLM.

We leave it to you to add labels to the axes, a title etc. and to create the second plot in the app: the function \(markup \times E(q|q

In the Cournot model, two firms choose quantities \(q_1\) and \(q_2\). The market price is

\[ p = 1 - q_1 - q_2 \]

and each firm has marginal cost \(c\). The best response functions are:

\[ q_1 = \frac{1 - q_2 - c}{2}, \qquad q_2 = \frac{1 - q_1 - c}{2} \]

To get an intuition for the Nash equilibrium, let’s think of the firms as sequentially reacting to the other’s choice of output. We can plot their reactions and see convergence to the Nash equilibrium.

However, to calculate the Nash equilibrium we solve a fixed point equation.

Python code in Marimo:

We import libraries and define sliders.

import marimo as mo
import numpy as np
import matplotlib.pyplot as plt

c = mo.ui.slider(0, 0.99, value=0.2, step=0.01, label="Marginal cost $c$")
q1_init = mo.ui.slider(0, 0.99, value=0.45, step=0.01, label="Initial $q_1$")
n_iter = mo.ui.slider(2, 30, value=14, step=1, label="Number of iterations")
mo.hstack([c,q1_init,n_iter])

In the following code block, the syntax i % 2 == 0 is a test whether \(i\) is either an even or odd number.

def reaction1(q2, c):
    return (1 - q2 - c) / 2

def reaction2(q1, c):
    return (1 - q1 - c) / 2

q1 = q1_init.value
points = []
for i in range(n_iter.value):
    if i % 2 == 0:
        q2 = reaction2(q1, c.value)
        points.append((q1, q2))
    else:
        q1 = reaction1(q2, c.value)
        points.append((q1, q2))
plt.plot(np.array(points)[:,0],np.array(points)[:,1])
plt.scatter(*points[0],label="initial $q_1$")
plt.legend()
plt.xlabel('$q_1$')
plt.ylabel('$q_2$')

The code above shows how the Cournot best responses are iterated, starting from an initial \(q_1 = 0.45\). We leave it to you to add the reaction functions themselves into the graph (as we did in the app above).

From scipy.optimize use either the root function or fsolve (as above) to calculate the Cournot equilibrium. In the lemons example above we had a fixed point \(p = f(p)\) where \(p\) is a scalar. Here we have \(q = g(q)\) where \(q\) is a vector \(q = [q1, q2]\) and \(g\) is a vector function: \(g(q) = [R_1(q),R_2(q)]\) where \(R_i\) is firm \(i\)’s reaction function.

You can use an LLM to help you derive the Cournot Nash equilibrium.

The labor market model has three states: unemployed (\(u\)), low wage (\(l\)), and high wage (\(h\)). The transitions are:

• \(\mu\): probability an unemployed worker finds a low wage job
• \(\lambda\): probability a low wage worker becomes high wage
• \(\delta_l\): probability a low wage worker loses their job
• \(\delta_h\): probability a high wage worker loses their job

The difference equations are:

Python code in Marimo:

We start by importing libraries and defining some sliders.

import marimo as mo
import numpy as np
import matplotlib.pyplot as plt

mu = mo.ui.slider(0.01, 0.5, value=0.1, step=0.01, label="Job finding rate $\mu$")
lambda_ = mo.ui.slider(0.01, 0.5, value=0.15, step=0.01, label="Learning rate $\lambda$")
delta_l = mo.ui.slider(0.01, 0.5, value=0.05, step=0.01, label="Low wage sep. $\delta_l$")
delta_h = mo.ui.slider(0.01, 0.5, value=0.02, step=0.01, label="High wage sep. $\delta_h$")
u0 = mo.ui.slider(0.0, 1.0, value=1.0, step=0.01, label="Initial unemployment $u_0$")

mo.hstack([mu,lambda_,delta_l,delta_h,u0])

Why do we denote the slider lambda_ and not just lambda?

First, we solve this model with appending lists with the per period solution as we have done above. Then we use matrix algebra to solve for the equilibrium paths.

We create three (empty) lists to keep track of the three fractions: unemployed, low wage and high wage job.

T = 60
u_hist, l_hist, h_hist = [], [], []
u, l, h = u0.value, 1 - u0.value, 0.0

for t in range(T):
    u_hist.append(u)
    l_hist.append(l)
    h_hist.append(h)
    new_l = mu.value * u
    l_to_h = lambda_.value * l
    l_to_u = delta_l.value * l
    h_to_u = delta_h.value * h

    next_u = u + l_to_u + h_to_u - new_l
    next_l = l + new_l - l_to_h - l_to_u
    next_h = h + l_to_h - h_to_u

    total = next_u + next_l + next_h
    next_u, next_l, next_h = next_u / total, next_l / total, next_h / total

    u, l, h = next_u, next_l, next_h

plt.plot(u_hist,label="unemployment")
plt.plot(l_hist,label="low wage employment")
plt.plot(h_hist,label="high wage employment")
plt.legend()
plt.xlabel("time")
plt.ylabel("fraction employed/unemployed")

We can also derive the labor market dynamics using matrix notation in Python. We can rewrite the above difference equations as follows:

We can define the transition matrix as follows:

A = np.array([
    [1-mu.value, delta_l.value, delta_h.value],
    [mu.value, 1-lambda_.value-delta_l.value,0],
    [0, lambda_.value,1-delta_h.value]
])

And then derive the employment dynamics in the following way. Although this may look less intuitive at the start, note how much shorter the code is when we use matrix notation. Matrix multiplication is done by the np.dot() statement: \(A \cdot x\) is coded as np.dot(A,x). Note that for matrix multiplication to be well defined we need that the number of columns in \(A\) equals the number of rows in \(x\).

In the code below, \(A\) has 3 columns and 3 rows and \(S\) has 1 column and 3 rows.

S = np.array([u0.value, 1 - u0.value, 0.0]).reshape(3, 1)
for _ in range(T):
    S = np.hstack((S,np.dot(A,S[:,-1].reshape(3,1))))

plt.plot(S[0],label="unemployment")
plt.plot(S[1],label="low wage employment")
plt.plot(S[2],label="high wage employment")
plt.legend()
plt.xlabel("time")
plt.ylabel("fraction employed/unemployed")

In the code above, what does S[:,-1] mean? Evaluate the expression in your notebook or use an LLM to find out.

Consider the adverse selection model with \(v_0=30\) and \(v_1=90\). Write Marimo code to:

• Plot the equilibrium price and fraction traded as the mark-up varies from 1.01 to 2.0.
• Is there always trade (fraction traded > 0) for any mark-up \(>1\)?

Modify the Cournot duopoly Python code so there are three firms, each with marginal cost \(c\), facing demand of the form \(p = 1 - q_1 - q_2 - q_3\).

• Define best-response functions for each firm.
• Write a for loop to iterate best responses starting with initial quantities \(q_1=0.3, q_2=0.3, q_3=0.3\).
• Define a fixed point function and solve for the Cournot Nash equilibrium.

Derive and plot the steady-state unemployment \(u^*\) as a function of the job-finding rate \(\mu\) (other parameters fixed at \(\lambda=0.1\), \(\delta_l=0.05\), \(\delta_h=0.03\)).

• Use the fact that in steady state, all variables don’t change over time.

Consider a market where there is one type of product and there is an exogenous endowment of this product (supply) equal to number_of_goods. Further, in this economy there are number_of_agents agents who have a valuation for this good which is randomly drawn from a normal distribution. An agent can at max. consume one unit of the product and her utility is then given by her valuation. The value of consuming zero units and the additional value of consuming more than one unit both equal 0.

The vector valuations contains for each agent her valuation. This we can code as follows:

number_of_agents = 1000
number_of_goods = 100
valuations = np.random.normal(100,20,size=number_of_agents)

• Define the function demand(p) which gives the number of goods demanded at price \(p\). [which agents buy the good at price \(p\)?]
• Solve for the equilibrium price.

Consider a Cournot duopoly market with a homogeneous good. Consumers have utility function \(u(x) = x - 0.5x^2\) and solve \(\max_x u(x) - px\). Firms produce at constant marginal costs normalized to zero: \(c=0\). But the production of \(x\) creates pollution at social cost \(ex\) with \(e \geq 0\).

• Derive analytically the demand function for this market.
• Define the reaction functions for the firms and the fixed point function; solve for the Cournot Nash equilibrium.
• Define a Python function for welfare, \(W\), for this market as a function of \(x\) and \(e\).
• Let \(W^*\) denote welfare as maximized by the social planner and \(W^{C}\) as the level of welfare in Cournot equilibrium. Give the Python code to replicate Figure 15.
• Given an economic interpretation of this figure.

Notation:

• \(U\): number of unemployed workers
• \(V\): number of vacancies
• \(M\): number of matches between workers and firms
• \(\theta = V/U\): labor market tightness

The matching process is described by a Cobb–Douglas matching function:

\[ M = m U^\alpha V^{1-\alpha} \]

where \(m\) measures matching efficiency and \(\alpha\) is the elasticity of matches with respect to unemployment.

A useful quantity is the job-finding probability for unemployed workers:

\[ \frac{M}{U} = m \theta^{1-\alpha} \]

This expression shows that job finding increases when the labor market becomes tighter (more vacancies relative to unemployed workers).

Wages are determined through Nash bargaining between worker and firm. The wage splits the surplus of the match.

In our simplified framework, the outside option of the worker depends on how easily a job can be found. When the labor market is tight and jobs are easy to find, the value of being unemployed is higher; because finding a job in the next period is (more) likely. To simplify our model, we will not model the dynamics explicitly here.

We capture this idea in reduced form by specifying the worker’s outside option as

\[ b \theta^{1-\alpha} \]

where \(b\) summarizes factors such as welfare benefits and institutions that affect the value of unemployment and \(\theta^{1-\alpha}\) captures the probability of finding a job in a future period.

Given Nash bargaining with worker bargaining power \(\beta\), the wage becomes

\[ w = b \theta^{1-\alpha} + \beta \left(a - b \theta^{1-\alpha}\right) \]

where

• \(w\): wage
• \(a\): worker production/productivity
• \(\beta\): worker bargaining power

In words, a workers always gets her outside option and she gets a share \(\beta\) of the value added of the match: production \(a\) minus her outside option.

This equation shows that wages increase with productivity and with labor market tightness.

From the literature (Mortensen and Nagypál 2007; Petrongolo and Pissarides 2001) we calibrate

\[ \alpha = 0.5, \quad \beta = 0.5 \]

The remaining parameters \(m\), \(a\), and \(b\) will be estimated using Dutch data.

To estimate the model for the Netherlands we use data from CBS:

• unemployment https://www.cbs.nl/en-gb/figures/detail/80590eng
• vacancies https://www.cbs.nl/en-gb/figures/detail/84545ENG
• wages https://opendata.cbs.nl/#/CBS/en/dataset/85663ENG/table

The relevant variables are:

• \(U\): “Unemployed labour force seasonally adjusted (x 1,000)”
• \(V\): “Vacancies seasonally adjusted, unfilled (x 1,000)”
• \(M\): “Vacancies seasonally adjusted, filled (x 1,000)”

The variable \(M\) represents the number of vacancies filled during a period and is therefore a proxy for the flow of matches.

The dataset is stored in: ./data/labour_data.csv

We estimate the parameters \(m\), \(a\), and \(b\) by minimizing the sum of squared differences between model predictions and the observed data for matches and wages.

Our research question is: what happens when immigration increases?

From the CBS migration statistics we observe that roughly 14,000 people per year migrate to the Netherlands with the explicit intention of joining the labor market. Using the table

https://opendata.cbs.nl/#/CBS/nl/dataset/80016ned/table

with the following selections:

• men and women
• age \(\geq 15\)
• all countries of birth
• migration motive: joining the labour force

We obtain approximately 14,000 migrants per year in the early 2000s.

We interpret these migrants as entering the labor market as job seekers. In other words, they initially increase unemployment \(U\).

In the short run we assume that the number of vacancies is fixed. Firms cannot immediately adjust their vacancy postings.

When immigration increases, the number of unemployed workers \(U\) rises while vacancies \(V\) remain fixed. As a result, labor market tightness

\[ \theta = V/U \]

falls.

Lower tightness reduces the job-finding probability and lowers the worker’s outside option. Through the Nash bargaining equation this leads to lower wages.

In the longer run firms can respond by creating additional vacancies. Firms post vacancies until the expected profit from a vacancy equals the cost of posting it.

The expected benefit of posting a vacancy equals the probability of filling it times the profit generated by a match.

The probability that a vacancy is filled is

\[ q(\theta) = \frac{M}{V} = m \theta^{-\alpha} \]

The free-entry condition for vacancies is therefore

\[ c = q(\theta)(a - w) \]

where \(c\) is the cost of posting a vacancy.

This condition determines equilibrium labor market tightness in the long run.

After an immigration shock, firms gradually create additional vacancies until the free-entry condition holds again. As a result, labor market tightness and wages move back toward their original equilibrium levels, while the total number of vacancies increases.

The Streamlit app below allows you to explore these mechanisms. You can simulate increases in immigration between 0% and 100% and observe how unemployment, vacancies, labor market tightness, and wages respond in both the short run and the long run.

We first import the Python packages used for data handling, estimation, and plotting.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize, fsolve
import marimo as mo

We load the CBS dataset containing unemployment, vacancies, matches, and a wage index.

df = pd.read_csv("./data/labour_data.csv")
df[['Unemployed labour force/Seasonally adjusted (x 1,000)',
       'Vacancies seasonally adjusted, unfilled (x 1000)',
       'Vacancies seasonally adjusted, filled (x 1000)',
       'Average_monthly_wage_index']].head()

Important columns in the dataset:

• Unemployed labour force/Seasonally adjusted (x 1,000) → unemployment \(U\)
• Vacancies seasonally adjusted, unfilled (x 1000) → vacancies \(V\)
• Vacancies seasonally adjusted, filled (x 1000) → matches \(M\)
• Average_monthly_wage_index → wage index

The search-and-matching literature suggests that we can calibrate \(\alpha\) and \(\beta\) at 0.5 (Mortensen and Nagypál 2007; Petrongolo and Pissarides 2001).

alpha = 0.5
beta = 0.5

These values imply:

• unemployment and vacancies contribute symmetrically to matching
• workers and firms split the surplus equally.

We now write a function that predicts matches and wages for a given observation.

def predict_row(row, m, a, b, counterfactual_immigration=0):
    
    U = row['Unemployed labour force/Seasonally adjusted (x 1,000)'] + counterfactual_immigration
    V = row['Vacancies seasonally adjusted, unfilled (x 1000)']

    # Matching function
    M_pred = m * (U**alpha) * (V**(1-alpha))

    # Labor market tightness
    theta = V / U

    # Wage equation (Nash bargaining)
    wage_pred = beta * a + (1 - beta) * b * (theta ** (1 - alpha))

    return M_pred, wage_pred

This function implements two key model equations:

• Matching: \(M = m U^{\alpha} V^{1-\alpha}\)
• Wage: \(w = \beta a + (1-\beta) b \theta^{1-\alpha}\)

We estimate the unknown parameters:

• matching efficiency \(m\)
• productivity \(a\)
• outside option parameter \(b\)

We do this by minimizing the sum of squared errors between the model and the data.

def sum_squared_errors(params, df):

    m, a, b = params
    errors = []

    for _, row in df.iterrows():

        M_pred, wage_pred = predict_row(row, m, a, b)

        e_M = (row['Vacancies seasonally adjusted, filled (x 1000)'] - M_pred)**2
        e_wage = (row['Average_monthly_wage_index'] - wage_pred)**2

        errors.append(e_M + e_wage)

    return np.sum(errors)

This function computes how far the model predictions are from the data.

We now use a numerical optimizer to estimate the parameters.

init_params = [0.8, 200, 50]

result = minimize(sum_squared_errors, init_params, args=(df,))

m_hat, a_hat, b_hat = result.x

m_hat, a_hat, b_hat

0.7856231159485444,133.25663277176238,73.47000968601081

The optimizer searches for parameter values that make the model fit the observed data as closely as possible.

Using the estimated parameters, we compute predicted matches and wages.

M_pred = []
wage_pred = []

for _, row in df.iterrows():
    mp, wp = predict_row(row, m_hat, a_hat, b_hat)
    M_pred.append(mp)
    wage_pred.append(wp)

Now we plot observed vs predicted values.

periods = df['PeriodQ'].astype(str)
fig, axs = plt.subplots(1,2, figsize=(12,4))

axs[0].plot(periods, df['Vacancies seasonally adjusted, filled (x 1000)'])
axs[0].plot(periods, M_pred)
axs[0].set_title("Matches")
axs[0].set_xticks(periods[::4])
axs[0].tick_params(axis='x', rotation=45)


axs[1].plot(periods, df['Average_monthly_wage_index'])
axs[1].plot(periods, wage_pred)
axs[1].set_title("Wages")
axs[1].set_xticks(periods[::4])
axs[1].tick_params(axis='x', rotation=45)

plt.tight_layout()
fig

The purpose of this step is simply to check whether the model roughly reproduces the data.

In marimo we create the slider with mo.ui.slider as before.

immigration_slider = mo.ui.slider(
    start=0,
    stop=100,
    step=1,
    value=0,
    label="Immigration increase (%)"
)

The slider allows the user to simulate immigration increases between 0% and 100%.

We use the latest observation as the baseline and simulate additional immigrants entering unemployment. We evaluate this code for the default value of 0 immigration.

immigration_slider
latest = df.iloc[-1]

U0 = latest["Unemployed labour force/Seasonally adjusted (x 1,000)"] * 1000
V0 = latest["Vacancies seasonally adjusted, unfilled (x 1000)"] * 1000

immigrants_per_year = 14000

additional = immigrants_per_year * immigration_slider.value / 100

U = U0 + additional
theta = V0 / U

w = beta * a_hat + (1 - beta) * b_hat * theta**(1 - alpha)

theta, w

1.074331550802139, 104.70413651538085

Short run assumption:

• immigration increases unemployment
• vacancies remain fixed

This reduces labor market tightness \(\theta = V/U\) and lowers wages.

Finally we visualize how immigration moves the economy along the wage curve.

theta0 = V0 / U0

theta_grid = np.linspace(0.5*theta0, 1.5*theta0, 200)

w_grid = beta * a_hat + (1 - beta) * b_hat * theta_grid**(1 - alpha)

fig, ax = plt.subplots()

ax.plot(theta_grid, w_grid)
ax.scatter(theta, w)

ax.set_xlabel("Labor market tightness $\theta$")
ax.set_ylabel("Wage index")

Interpretation:

• the curve shows wages implied by Nash bargaining
• immigration increases unemployment
• this lowers tightness \(\theta\)
• the economy moves left along the wage curve, reducing wages.

Write a Python function that computes the number of matches \(M\) using the matching function

\(M = m U^\alpha V^{1-\alpha}\)

Choose parameter values \(m = 0.8\) and \(\alpha = 0.5\). Simulate how matches change when unemployment \(U\) increases from 50 to 200 while vacancies \(V = 100\) remain fixed. Plot matches as a function of unemployment. In the same figure also plot the number of matches for \(\alpha = 0.8\).

For which value of \(U\) do these lines intersect? Why is this the case?

The probability that an unemployed worker finds a job is

\(p(\theta) = m \theta^{1-\alpha}\)

where \(\theta = V/U\).

Write Python code that computes and plots the job-finding probability for \(\theta\) values between 0.2 and 2; again, as above, choosing parameter values \(m = 0.8\) and \(\alpha = 0.5\).

The wage equation in the lecture is

\(w = \beta a + (1-\beta)b\theta^{1-\alpha}\)

Assume \(a = 200\), \(b = 50\), \(\beta = 0.5\) and, as above, \(\alpha = 0.5\)

Write Python code that plots the wage curve for \(\theta\) between 0.2 and 2. Also, plot the wage curve for \(\alpha = 0.8\). For which value of \(\theta\) do the curves intersect?

Suppose the labor market initially has

U = 200 (thousand unemployed) V = 150 (thousand vacancies)

Immigration increases unemployment by 20%.

Write Python code that

• computes the initial tightness \(\theta_0\)
• computes the new tightness after immigration
• computes the corresponding wages using the wage equation.

Using the matching function

\(M = m U^\alpha V^{1-\alpha}\)

generate simulated data for \(U\) and \(V\), compute \(M\), add some noise to \(M\) and then estimate the parameters \(m,\alpha\) using least squares.

Hint: you can use the function \(\ln(x)\) to make it look more like a linear regression if you find this useful for your intuition.

One of the most fundamental questions in macroeconomics is why some countries are richer than others and how economies grow over time. A key mechanism behind long‑run growth is capital accumulation: societies invest part of their income in machines, infrastructure, and technology that increase future production.

However, capital (per worker) does not grow automatically. Investment increases the capital stock, but depreciation and population growth work in the opposite direction. New workers require additional capital to maintain capital per worker and productivity, and existing capital gradually wears out.

The Solow growth model captures this tension between investment and dilution. In this framework, the economy produces output using capital and labor. A constant fraction of output is saved and invested, which increases the capital stock. At the same time, depreciation and population growth reduce the amount of capital available per worker.

These forces determine how capital per worker evolves over time. If the economy starts with very little capital, investment will exceed depreciation and capital will grow rapidly. If the economy becomes very capital‑intensive, depreciation and population growth eventually dominate, slowing further accumulation.

This dynamic adjustment leads to a steady state: a level of capital per worker at which investment exactly offsets depreciation and population growth. At this point the capital stock per worker stops changing.

An important question is how the steady state depends on economic parameters. For example, how would the long‑run level of capital change if households saved a larger fraction of their income? What happens if population growth increases? How does the productivity of capital affect the outcome? An interactive app where these parameters can be easily adjusted with sliders helps to answer these questions.

Thinking through these questions helps build intuition for the forces that determine long‑run economic development.

Many markets involve asymmetric information. Firms often do not know exactly how much each consumer values their product. Some customers are willing to pay a lot, while others are much more price sensitive.

Consider a monopolist selling a product whose quality or quantity can vary. Consumers differ in how much they value this quality, but the firm cannot observe their valuation directly. If the firm could perfectly observe each consumer’s type, it could tailor a price to each individual and extract all surplus. In reality, the firm must design a pricing strategy that induces consumers to reveal their preferences voluntarily.

This leads to the problem of mechanism design or screening. The firm offers a menu of contracts, where each contract specifies a quantity or quality level together with a price. Consumers choose the option that maximizes their own utility.

The difficulty is that high‑valuation consumers might pretend to be low‑valuation consumers if the low‑quality contract is cheaper. To prevent this, the menu must be designed so that each consumer prefers the option intended for their own type. This requirement is called incentive compatibility or truthful revelation.

Ensuring truthful behavior typically forces the firm to leave some surplus –often called information rents– to higher-valuation consumers. These rents are the price the firm must pay to obtain information about consumers’ willingness to pay.

The resulting optimal contracts display several interesting patterns. Higher types typically receive higher quality and pay higher prices. At the same time, the allocation is generally distorted relative to the socially efficient outcome, especially for low‑valuation consumers.

Understanding these distortions is central to many areas of economics, including regulation, taxation, insurance, and pricing strategies in digital markets.

We will use the Euler equation in two applications below. In these applications, we optimize over two variables and for one of these variables the objective function does not depend on the time derivative of this variable. Hence, we have a problem like:

\[ \max_{x,y} \int_{t_0}^{t_1} f(t,x(t),y(t),x'(t))dt \]

Then the Euler equation implies that the first order conditions are:

\[ \frac{\partial f}{\partial x} - \frac{d}{dt} \left( \frac{\partial f}{\partial x'} \right) = 0 \]

and for \(y(t)\):

\[ \frac{\partial f}{\partial y} = 0 \]

because \(\frac{\partial f}{\partial y'} = 0\).

Firms often become more efficient as they gain experience with a production process. This phenomenon, known as learning by doing, has been documented in many industries such as semiconductor manufacturing, aircraft production, and renewable energy technologies.

When firms produce more today, they accumulate knowledge that reduces future production costs. This creates a dynamic trade-off. Producing more in the present may reduce current profits, but it can increase future profitability by lowering costs.

Because of this trade-off, firms may choose production paths that differ from the static profit-maximizing quantity. A purely static monopolist would simply choose the output level that maximizes current profits given current costs. A forward‑looking firm, however, takes into account that higher production today accelerates learning and reduces costs tomorrow.

This introduces an investment motive in production decisions. Output today not only generates current revenue but also contributes to the firm’s stock of experience.

Several interesting questions arise in this environment. Should firms produce more output early or late in the life of a product (early because they want to invest in learning or late as their costs fall with accumulated production)? How does the importance of the future –captured by the discount rate– affect production choices? And how does the value of accumulated experience change over time?

Analyzing these questions helps illustrate how dynamic optimization differs from static decision making. When future benefits are important, firms may deliberately deviate from short‑run profit maximization in order to improve long‑run outcomes.

Recall that in marimo, interactive elements are created with mo.ui widgets.

Example:

import marimo as mo

alpha = mo.ui.slider(0.1, 0.9, value=0.3, step=0.01, label="Capital share ($\alpha$)")
s = mo.ui.slider(0.01, 0.6, value=0.2, step=0.01, label="Savings rate")

Then display them:

alpha, s

To use the value inside calculations:

alpha.value
s.value

Marimo automatically re-runs dependent cells when a widget value changes. So if a plot depends on alpha.value, it updates automatically when the alpha slider moves.

Two numerical solvers are used in the apps.

This problem involves two differential equations:

\[u'(\theta) = (\theta - \lambda/f(\theta))/c\]

and

\[\lambda'(\theta) = -f(\theta)\]

Boundary conditions: \(u(\theta_{min}) = 0, \lambda(\theta_{max}) = 0\)

So this is a boundary value problem.

This model also forms a BVP, but with time as the state variable.

State variables: \(Q(t)\), cumulative production, \(\lambda(t)\), shadow value

Differential equations:

• \(Q'(t) = q(t)\)
• \(\lambda'(t) = e^{-\rho t} q(t) c'(Q(t))\)

Boundary conditions: \(Q(0) = 0, \lambda(T) = 0\)

Here we only give you the steps for you to reproduce the solutions and figures in the app above.

Create the Solow model from above in a marimo notebook and analyze the following:

• add technological growth
• plot output \(f(k)\) over time. How is this figure affected by the initial capital stock \(k_0\) and the saving rate \(s\)? Create sliders for \(k_0\) and \(s\) to analyze this.

Create the mechanism design model in your marimo notebook:

• change the distribution \(f(\theta)\); e.g. create a dropdowm menu for the user to choose from uniform, exponential and (perhaps) another distribution
• compare the information rent in the optimal solution with the information rent in the first-best allocation.

Create the learning-by-doing model in your marimo notebook:

• vary time horizon T using a slider
• introduce capacity constraints
• in competition policy cases there is a suspicion that firms that price below marginal costs (\(p < c\)) are trying to remove their competitors from the market to enjoy monopoly profits in the future. Discuss this suspicion in the light of this model.

The Ramsey model studies how an economy chooses consumption and saving over time when households are forward‑looking. Unlike the Solow model, the saving rate is not imposed from outside the model. Instead, a representative household decides how much to consume and how much to save in order to maximize lifetime utility.

The household solves

\[ \max \int_0^\infty e^{-\rho t} u(c(t)) dt \]

subject to the capital accumulation equation

\[ \dot{k}=f(k)-\delta k-c \]

Capital increases when output exceeds consumption and depreciation. The parameter \( \rho \) measures how impatient households are (the discount rate), while \( \delta \) is the depreciation rate.

Optimal behaviour implies a second dynamic equation describing how consumption evolves over time. Together with capital accumulation this gives a two‑dimensional dynamical system

\[ \dot{k} = f(k)-\delta k-c \] and in the app we assume \(u(c)=c^{0.7},f(k)=k^{0.5}\) which gives \[ \dot{c} = \frac{c}{0.3}\left(0.5 k^{-0.5}-\delta-\rho\right) \]

The economy therefore evolves jointly in capital \(k\) and consumption \(c\). The steady state \((k^*,c^*)\) occurs where both variables stop changing.

A key insight of the Ramsey model is that the steady state is saddle‑path stable. This means that only one particular initial level of consumption is consistent with convergence to the steady state for a given initial capital stock. If consumption is too high, the economy depletes capital. If consumption is too low, capital grows excessively.

The app below allows you to explore these dynamics interactively.

You can change:

• the discount rate \( \rho \)
• the depreciation rate \( \delta \)
• the initial capital stock \(k_0\)
• the initial consumption level \(c_0\)

The figures show two important objects:

1. Time paths of capital and consumption.
2. The phase diagram in \((k,c)\) space.

The phase diagram shows the combinations \((k,c)\) where \( \dot{k}=0 \) and \( \dot{c}=0 \), as well as the trajectory implied by the initial conditions. The app also computes the saddle path, which is the unique trajectory that leads to the steady state.

Use the sliders to explore how parameters affect the steady state and how the economy adjusts when it starts away from equilibrium.

The predator–prey model is one of the simplest and probably most famous examples of a dynamic system with interacting variables. It was originally developed by Alfred Lotka and Vito Volterra in the 1920s to describe how two biological populations evolve over time.

The key idea is that the growth of each population depends on the other.

• Prey (for example rabbits) reproduce naturally and would grow exponentially if predators did not exist.
• Predators (for example foxes) depend on prey for food, so their population grows when prey are abundant.
• When predators become numerous, they reduce the prey population.
• As prey become scarce, predators begin to starve and their population declines.

This interaction creates a feedback loop that typically produces cycles: prey rise first, predators follow, prey then decline, and predators eventually decline as well. The Ramsey model above is also a two-dimensional system, but it does not generate cycles.

The classic Lotka–Volterra system is

\[ \dot{x} = ax - bxy \]

\[ \dot{y} = -cy + dxy \]

where

• \(x(t)\) is the prey population
• \(y(t)\) is the predator population

and the parameters have the following interpretation:

• \(a\): natural growth rate of prey
• \(b\): intensity of predation
• \(c\): natural death rate of predators
• \(d\): efficiency with which predators convert prey into new predators

Although this model originated in ecology, the same mathematical structure appears in many areas of economics. One important example is the Goodwin growth cycle model, where the interacting variables are

• the employment rate
• the wage share of income

When employment is high, workers have stronger bargaining power and wages rise. Higher wages reduce profits and slow hiring, causing employment to fall. When unemployment rises, wage pressure weakens and profits recover, leading to renewed hiring. This interaction generates endogenous business cycles.

The app below allows you to experiment with these dynamics. You can interpret the variables either as predator–prey populations or as employment and wage share in the Goodwin model. By adjusting the parameters and initial values, you can see how cycles emerge and how their size and speed depend on the underlying economic mechanisms.

Pay particular attention to the phase diagram. It shows the trajectory of the system in the \((x,y)\) plane and illustrates how the interaction between the two variables produces cyclical motion.

Below we reproduce the main elements of the app using standard Python code that can be run inside a marimo notebook. The goal is to understand how a dynamical system can be implemented and simulated.

We now reproduce the core elements of the simulation using Python code that can be run in a marimo notebook. The goal is to show how a system of differential equations can be translated into code and solved numerically.

Using the Ramsey model implemented in the app:

• a. Compute the steady state values \((k^*,c^*)\) analytically from the equations \(\dot{k}=0\) and \(\dot{c}=0\).
• b. Verify numerically that the values in the app correspond to this steady state.
• c. Explain why the steady state of the Ramsey model is saddle‑path stable.

Use the Ramsey model app and vary the initial capital stock \(k_0\).

• a. Find a value of \(k_0\) for which the economy initially reduces consumption before converging to the steady state.
• b. Find a value of \(k_0\) for which the economy initially increases consumption.

Consider the Lotka–Volterra system

\(\dot{x}=ax-bxy\)

\(\dot{y}=-cy+dxy\).

• a. Compute the steady state \((x^*,y^*)\) of the system.
• b. Plot this steady state in the phase diagram of the app.
• c. Explain why the trajectories of the system typically form closed cycles around this point.

Interpret the predator–prey model as the Goodwin growth cycle model.

• a. Which variables correspond to predators and prey in the Goodwin interpretation?
• b. Explain why the interaction between these variables generates cyclical dynamics.
• c. Which parameters would make the cycles faster or slower?

Warning This question is rather difficult and we expect you to need an LLM to solve it! This exercise is more about practicing using LLMs than it is about math. We do not assume that you to know the math behind the question; although you may/will understand it once you solved the exercise.

Consider the following second order differential equation:

\[ u''=(c-de^u)(a-u') \]

with \(a=c=d=1\) and initial conditions \(u(0) = u'(0) = 0.5\).

First hint: we kept the parameters \(a,c,d\) in the differential equation to give you a clue.

We want you solve this differential equation with solve_ivp (which can not solve second order differential equations) and use one of the apps in this lecture to verify your solution.

Second hint: define a new variable \(v = u'\).