Lectures Methods: Python programming for economists

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, 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 tend 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 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

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.

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.???continue here???

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:

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])

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 parameters. The function expected_q_given_p_uniform computes the expected quality conditional on \(q < p\). The price update is iterated until convergence.

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} \]

The Nash equilibrium is found by iteratively updating each firm’s quantity.

Python code in Marimo:

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])

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\).

From scipy.optimize use the root function to calculate the Cournot equilibrium. You can use an LLM to help you with this.

def fixed_point(x,c):
    q1, q2 = x
    return  [
        # q1 minus firm 1's optimal response,
        # q2 minus firm 2's optimal response
    ]

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:

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])

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")

This code simulates the labor market Markov process using Marimo sliders for all parameters.

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

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\)?

import numpy as np
import matplotlib.pyplot as plt

v0, v1 = 30, 90
markups = np.linspace(1.01, 2.0, 100)
eq_prices = []
fractions = []

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

for m in markups:
    p = m*v1  # start at high price
    for _ in range(30):
        expected_q = expected_q_given_p_uniform(p, v0, v1)
        if expected_q is None:
            break
        new_p = m * expected_q
        if abs(new_p - p) < 1e-6:
            break
        p = new_p
    eq_prices.append(p)
    frac = max(0, min(1, (p-v0)/(v1-v0)))
    fractions.append(frac)

plt.plot(markups, eq_prices, label="Equilibrium price")
plt.plot(markups, fractions, label="Fraction traded")
plt.xlabel("Markup")
plt.legend()

—

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\).
• Write a function fixed_point and use this function to solve for the equilibrium.

# Reaction for each: maximize (1 - sum(qs) - c)*q_i
def r1(q2, q3, c): return (1 - q2 - q3 - c)/2
def r2(q1, q3, c): return (1 - q1 - q3 - c)/2
def r3(q1, q2, c): return (1 - q1 - q2 - c)/2
c = 0.2
qs = [0.3, 0.3, 0.3]
history = [qs.copy()]
for i in range(15):
    qs[0] = r1(qs[1], qs[2], c)
    history.append(qs.copy())
    qs[1] = r2(qs[0], qs[2], c)
    history.append(qs.copy())
    qs[2] = r3(qs[0], qs[1], c)
    history.append(qs.copy())
plt.plot([row[0] for row in history], label='$q_1$')
plt.plot([row[1] for row in history], label='$q_2$')
plt.plot([row[2] for row in history], label='$q_3$')
plt.legend()
plt.xlabel("Step")

—

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.

import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt

lambda_, delta_l, delta_h = 0.1, 0.05, 0.03
mus = np.linspace(0.01, 0.5, 100)
def matrix_A(mu):
 return np.array([
    [1-mu, delta_l, delta_h],
    [mu, 1-lambda_-delta_l,0],
    [0, lambda_,1-delta_h]
    ])

def fixed_point(x,mu):
    x = (x/np.sum(x)).reshape(3,1)
    return x - np.dot(matrix_A(mu),x)

u_star = []
for mu in mus:
    x = optimize.root(lambda x: fixed_point(x,mu), [1/3.0, 1/3.0, 1/3.0], method='broyden1', tol=1e-14).x
    u_star.append(x[0])
plt.plot(mus,u_star)
plt.xlabel(r'$\mu$ (job finding rate)')
plt.ylabel('Steady state $u^*$')

—

In the labor market model, implement the time path simulation using only Numpy arrays and matrix multiplication (not manually updating variables).

• Set up the transition matrix for \(\mu=0.12\), \(\lambda=0.09\), \(\delta_l=0.04\), \(\delta_h=0.03\), \(u_0=0.8\).
• Plot the evolution of all three states.

mu, lmbd, dl, dh = 0.12, 0.09, 0.04, 0.03
A = np.array([
    [1 - mu, dl, dh],
    [mu, 1 - lmbd - dl, 0],
    [0, lmbd, 1 - dh]
])
S = np.array([0.8, 0.2, 0]).reshape(3,1)
history = [S.flatten()]
for _ in range(60):
    S = np.dot(A, S)
    S = S / np.sum(S)   # (optional: renormalize so they sum to 1)
    history.append(S.flatten())
history = np.array(history)
plt.plot(history[:,0], label="Unemployed")
plt.plot(history[:,1], label="Low wage")
plt.plot(history[:,2], label="High wage")
plt.legend()
plt.show()

—

Suppose a fraction \(\alpha\) of unemployed directly get a high wage job each period. The equations become:

• Write Marimo code to simulate the process, using sliders for \(\mu, \lambda, \delta_l, \delta_h, u_0, \alpha\).
• Plot over time.
• What happens as \(\alpha\) increases?

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

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)
    to_l = mu.value * u
    to_h = alpha.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 - to_l - to_h
    next_l = l + to_l - l_to_h - l_to_u
    next_h = h + l_to_h + 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")
plt.plot(h_hist,label="high wage")
plt.legend()

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 the worker and the 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 remaining unemployed is higher.

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.

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 productivity
• \(\beta\): worker bargaining power

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.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^α V^{1−α}\)
• Wage: \(w = βa + (1−β)b θ^{1−α}\)

—

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

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 the app, immigration is controlled with a slider. In marimo we create the same interaction using a widget.

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.

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

Short run assumption:

• immigration increases unemployment
• vacancies remain fixed

This reduces labor market tightness \(θ = 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 θ")
ax.set_ylabel("Wage index")

plt.show()

Interpretation:

• the curve shows wages implied by Nash bargaining
• immigration increases unemployment
• this lowers tightness \(θ\)
• 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.

import numpy as np
import matplotlib.pyplot as plt

m = 0.8
alpha = 0.5
V = 100

U = np.linspace(50, 200, 100)

M = m * (U**alpha) * (V**(1-alpha))

plt.plot(U, M)
plt.xlabel("Unemployment U")
plt.ylabel("Matches M")
plt.title("Matching Function")
plt.show()

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.

import numpy as np
import matplotlib.pyplot as plt

m = 0.8
alpha = 0.5

theta = np.linspace(0.2, 2, 100)

p = m * theta**(1-alpha)

plt.plot(theta, p)
plt.xlabel("Labor market tightness θ")
plt.ylabel("Job-finding probability")
plt.title("Job-finding probability")
plt.show()

The wage equation in the lecture is

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

Assume \(a = 200\), \(b = 50\), \(\alpha = 0.5\), \(\beta = 0.5\).

Write Python code that plots the wage curve for \(\theta\) between 0.2 and 2.

import numpy as np
import matplotlib.pyplot as plt

a = 200
b = 50
alpha = 0.5
beta = 0.5

theta = np.linspace(0.2, 2, 100)

w = beta * a + (1-beta) * b * theta**(1-alpha)

plt.plot(theta, w)
plt.xlabel("Labor market tightness θ")
plt.ylabel("Wage")
plt.title("Wage curve")
plt.show()

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 \(θ_0\) • computes the new tightness after immigration • computes the corresponding wages using the wage equation.

import numpy as np

a = 200
b = 50
alpha = 0.5
beta = 0.5

U0 = 200
V = 150

theta0 = V / U0

U1 = U0 * 1.2
theta1 = V / U1

w0 = beta * a + (1-beta) * b * theta0**(1-alpha)
w1 = beta * a + (1-beta) * b * theta1**(1-alpha)

print(theta0, theta1)
print(w0, w1)

Using the matching function

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

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

Hint: rearrange the equation as

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

Compute the average value of \(m\) from your simulated observations.

import numpy as np

alpha = 0.5
m_true = 0.8

np.random.seed(0)

U = np.random.uniform(50, 200, 100)
V = np.random.uniform(50, 200, 100)

M = m_true * (U**alpha) * (V**(1-alpha)) + np.random.normal(0,10,100)

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 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?

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 or less early in the life of a product? 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.

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 (α)")
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'(θ) = (θ − λ/f(θ))/c
λ'(θ) = −f(θ)

Boundary conditions:

u(θ_min) = 0
λ(θ_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
λ(t)      shadow value

Differential equations:

Q'(t)
λ'(t)

Boundary conditions:

Q(0) = 0
λ(T) = 0

—

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

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

In your marimo notebook:

• change the distribution f(θ)
• compare the information rent in the optimal solution with the information rent in the first-best allocation.

In your marimo notebook:

• vary time horizon T
• 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.