odu.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Job Search III: Search with Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "- [Job Search III: Search with Learning](#Job-Search-III:-Search-with-Learning)  \n",
    "  - [Overview](#Overview)  \n",
    "  - [Model](#Model)  \n",
    "  - [Take 1: Solution by VFI](#Take-1:-Solution-by-VFI)  \n",
    "  - [Take 2: A More Efficient Method](#Take-2:-A-More-Efficient-Method)  \n",
    "  - [Exercises](#Exercises)  \n",
    "  - [Solutions](#Solutions)  \n",
    "  - [Appendix](#Appendix)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "In this lecture we consider an extension of the [previously studied](https://lectures.quantecon.org/py/mccall_model.html) job search model of McCall [[McC70]](https://lectures.quantecon.org/py/zreferences.html#mccall1970)\n",
    "\n",
    "In the McCall model, an unemployed worker decides when to accept a permanent position at a specified wage, given\n",
    "\n",
    "- his or her discount rate  \n",
    "- the level of unemployment compensation  \n",
    "- the distribution from which wage offers are drawn  \n",
    "\n",
    "\n",
    "In the version considered below, the wage distribution is unknown and must be learned\n",
    "\n",
    "- The following is based on the presentation in [[LS18]](https://lectures.quantecon.org/py/zreferences.html#ljungqvist2012), section 6.6  \n",
    "\n",
    "\n",
    "Let’s start with some imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "from numba import njit, prange, vectorize\n",
    "from interpolation import mlinterp, interp\n",
    "from math import gamma\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model features\n",
    "\n",
    "- Infinite horizon dynamic programming with two states and one binary control  \n",
    "- Bayesian updating to learn the unknown distribution  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model\n",
    "\n",
    "\n",
    "<a id='index-0'></a>\n",
    "Let’s first review the basic McCall model [[McC70]](https://lectures.quantecon.org/py/zreferences.html#mccall1970) and then add the variation we want to consider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Basic McCall Model\n",
    "\n",
    "\n",
    "<a id='index-1'></a>\n",
    "Recall that, [in the baseline model](https://lectures.quantecon.org/py/mccall_model.html), an unemployed worker is presented in each period with a\n",
    "permanent job offer at wage $ W_t $\n",
    "\n",
    "At time $ t $, our worker either\n",
    "\n",
    "1. accepts the offer and works permanently at constant wage $ W_t $  \n",
    "1. rejects the offer, receives unemployment compensation $ c $ and reconsiders next period  \n",
    "\n",
    "\n",
    "The wage sequence $ \\{W_t\\} $ is iid and generated from known density $ q $\n",
    "\n",
    "The worker aims to maximize the expected discounted sum of earnings $ \\mathbb{E} \\sum_{t=0}^{\\infty} \\beta^t y_t $\n",
    "The function $ V $ satisfies the recursion\n",
    "\n",
    "\n",
    "<a id='equation-odu-odu-pv'></a>\n",
    "$$\n",
    "v(w)\n",
    "= \\max \\left\\{\n",
    "\\frac{w}{1 - \\beta}, \\, c + \\beta \\int v(w')q(w') dw'\n",
    "\\right\\} \\tag{1}\n",
    "$$\n",
    "\n",
    "The optimal policy has the form $ \\mathbf{1}\\{w \\geq \\bar w\\} $, where\n",
    "$ \\bar w $ is a constant depending called the *reservation wage*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Offer Distribution Unknown\n",
    "\n",
    "Now let’s extend the model by considering the variation presented in [[LS18]](https://lectures.quantecon.org/py/zreferences.html#ljungqvist2012), section 6.6\n",
    "\n",
    "The model is as above, apart from the fact that\n",
    "\n",
    "- the density $ q $ is unknown  \n",
    "- the worker learns about $ q $ by starting with a prior and updating based on wage offers that he/she observes  \n",
    "\n",
    "\n",
    "The worker knows there are two possible distributions $ F $ and $ G $ — with densities $ f $ and $ g $\n",
    "\n",
    "At the start of time, “nature” selects $ q $ to be either $ f $ or\n",
    "$ g $ — the wage distribution from which the entire sequence $ \\{W_t\\} $ will be drawn\n",
    "\n",
    "This choice is not observed by the worker, who puts prior probability $ \\pi_0 $ on $ f $ being chosen\n",
    "\n",
    "Update rule: worker’s time $ t $ estimate of the distribution is $ \\pi_t f + (1 - \\pi_t) g $, where $ \\pi_t $ updates via\n",
    "\n",
    "\n",
    "<a id='equation-odu-pi-rec'></a>\n",
    "$$\n",
    "\\pi_{t+1}\n",
    "= \\frac{\\pi_t f(w_{t+1})}{\\pi_t f(w_{t+1}) + (1 - \\pi_t) g(w_{t+1})} \\tag{2}\n",
    "$$\n",
    "\n",
    "This last expression follows from Bayes’ rule, which tells us that\n",
    "\n",
    "$$\n",
    "\\mathbb{P}\\{q = f \\,|\\, W = w\\}\n",
    "= \\frac{\\mathbb{P}\\{W = w \\,|\\, q = f\\}\\mathbb{P}\\{q = f\\}}\n",
    "{\\mathbb{P}\\{W = w\\}}\n",
    "\\quad \\text{and} \\quad\n",
    "\\mathbb{P}\\{W = w\\} = \\sum_{\\omega \\in \\{f, g\\}} \\mathbb{P}\\{W = w \\,|\\, q = \\omega\\} \\mathbb{P}\\{q = \\omega\\}\n",
    "$$\n",
    "\n",
    "The fact that [(2)](#equation-odu-pi-rec) is recursive allows us to progress to a recursive solution method\n",
    "\n",
    "Letting\n",
    "\n",
    "$$\n",
    "q_{\\pi}(w) := \\pi f(w) + (1 - \\pi) g(w)\n",
    "\\quad \\text{and} \\quad\n",
    "\\kappa(w, \\pi) := \\frac{\\pi f(w)}{\\pi f(w) + (1 - \\pi) g(w)}\n",
    "$$\n",
    "\n",
    "we can express the value function for the unemployed worker recursively as\n",
    "follows\n",
    "\n",
    "\n",
    "<a id='equation-odu-mvf'></a>\n",
    "$$\n",
    "v(w, \\pi)\n",
    "= \\max \\left\\{\n",
    "\\frac{w}{1 - \\beta}, \\, c + \\beta \\int v(w', \\pi') \\, q_{\\pi}(w') \\, dw'\n",
    "\\right\\}\n",
    "\\quad \\text{where} \\quad\n",
    "\\pi' = \\kappa(w', \\pi) \\tag{3}\n",
    "$$\n",
    "\n",
    "Notice that the current guess $ \\pi $ is a state variable, since it affects the worker’s perception of probabilities for future rewards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameterization\n",
    "\n",
    "Following  section 6.6 of [[LS18]](https://lectures.quantecon.org/py/zreferences.html#ljungqvist2012), our baseline parameterization will be\n",
    "\n",
    "- $ f $ is $ \\operatorname{Beta}(1, 1) $  \n",
    "- $ g $ is $ \\operatorname{Beta}(3, 1.2) $  \n",
    "- $ \\beta = 0.95 $ and $ c = 0.3 $  \n",
    "\n",
    "\n",
    "The densities $ f $ and $ g $ have the following shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def beta_function_factory(a, b):\n",
    "\n",
    "    @vectorize\n",
    "    def p(x):\n",
    "        r = gamma(a + b) / (gamma(a) * gamma(b))\n",
    "        return r * x**(a-1) * (1 - x)**(b-1)\n",
    "\n",
    "    return p\n",
    "\n",
    "\n",
    "x_grid = np.linspace(0, 1, 100)\n",
    "f = beta_function_factory(1, 1)\n",
    "g = beta_function_factory(3, 1.2)\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plt.plot(x_grid, f(x_grid), label='$f$', lw=2)\n",
    "plt.plot(x_grid, g(x_grid), label='$g$', lw=2)\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a id='looking-forward'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looking Forward\n",
    "\n",
    "What kind of optimal policy might result from [(3)](#equation-odu-mvf) and the parameterization specified above?\n",
    "\n",
    "Intuitively, if we accept at $ w_a $ and $ w_a \\leq w_b $, then — all other things being given — we should also accept at $ w_b $\n",
    "\n",
    "This suggests a policy of accepting whenever $ w $ exceeds some threshold value $ \\bar w $\n",
    "\n",
    "But $ \\bar w $ should depend on $ \\pi $ — in fact it should be decreasing in $ \\pi $ because\n",
    "\n",
    "- $ f $ is a less attractive offer distribution than $ g $  \n",
    "- larger $ \\pi $ means more weight on $ f $ and less on $ g $  \n",
    "\n",
    "\n",
    "Thus larger $ \\pi $ depresses the worker’s assessment of her future prospects, and relatively low current offers become more attractive\n",
    "\n",
    "**Summary:**  We conjecture that the optimal policy is of the form\n",
    "$ \\mathbb 1\\{w \\geq \\bar w(\\pi) \\} $ for some decreasing function\n",
    "$ \\bar w $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Take 1: Solution by VFI\n",
    "\n",
    "Let’s set about solving the model and see how our results match with our intuition\n",
    "\n",
    "We begin by solving via value function iteration (VFI), which is natural but ultimately turns out to be second best\n",
    "\n",
    "The class `SearchProblem` is used to store parameters and methods needed to compute optimal actions\n",
    "\n",
    "\n",
    "<a id='odu-vfi-code'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "class SearchProblem:\n",
    "    \"\"\"\n",
    "    A class to store a given parameterization of the \"offer distribution\n",
    "    unknown\" model.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self,\n",
    "                 β=0.95,            # Discount factor\n",
    "                 c=0.3,             # Unemployment compensation\n",
    "                 F_a=1,\n",
    "                 F_b=1,\n",
    "                 G_a=3,\n",
    "                 G_b=1.2,\n",
    "                 w_max=1,           # Maximum wage possible\n",
    "                 w_grid_size=100,\n",
    "                 π_grid_size=100,\n",
    "                 mc_size=500):\n",
    "\n",
    "        self.β, self.c, self.w_max = β, c, w_max\n",
    "\n",
    "        self.f = beta_function_factory(F_a, F_b)\n",
    "        self.g = beta_function_factory(G_a, G_b)\n",
    "\n",
    "        self.π_min, self.π_max = 1e-3, 1-1e-3    # Avoids instability\n",
    "        self.w_grid = np.linspace(0, w_max, w_grid_size)\n",
    "        self.π_grid = np.linspace(self.π_min, self.π_max, π_grid_size)\n",
    "\n",
    "        self.mc_size = mc_size\n",
    "\n",
    "        self.w_f = np.random.beta(F_a, F_b, mc_size)\n",
    "        self.w_g = np.random.beta(G_a, G_b, mc_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function takes an instance of this class and returns jitted versions\n",
    "of the Bellman operator `T`, and a `get_greedy()` function to compute the approximate\n",
    "optimal policy from a guess `v` of the value function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def operator_factory(sp, parallel_flag=True):\n",
    "\n",
    "    f, g = sp.f, sp.g\n",
    "    w_f, w_g = sp.w_f, sp.w_g\n",
    "    β, c = sp.β, sp.c\n",
    "    mc_size = sp.mc_size\n",
    "    w_grid, π_grid = sp.w_grid, sp.π_grid\n",
    "\n",
    "    @njit\n",
    "    def κ(w, π):\n",
    "        \"\"\"\n",
    "        Updates π using Bayes' rule and the current wage observation w.\n",
    "        \"\"\"\n",
    "        pf, pg = π * f(w), (1 - π) * g(w)\n",
    "        π_new = pf / (pf + pg)\n",
    "\n",
    "        return π_new\n",
    "\n",
    "    @njit(parallel=parallel_flag)\n",
    "    def T(v):\n",
    "        \"\"\"\n",
    "        The Bellman operator.\n",
    "\n",
    "        \"\"\"\n",
    "        v_func = lambda x, y: mlinterp((w_grid, π_grid), v, (x, y))\n",
    "        v_new = np.empty_like(v)\n",
    "\n",
    "        for i in prange(len(w_grid)):\n",
    "            for j in prange(len(π_grid)):\n",
    "                w = w_grid[i]\n",
    "                π = π_grid[j]\n",
    "\n",
    "                v_1 = w / (1 - β)\n",
    "\n",
    "                integral_f, integral_g = 0.0, 0.0\n",
    "                for m in prange(mc_size):\n",
    "                    integral_f += v_func(w_f[m], κ(w_f[m], π))\n",
    "                    integral_g += v_func(w_g[m], κ(w_g[m], π))\n",
    "                integral = (π * integral_f + (1 - π) * integral_g) / mc_size\n",
    "\n",
    "                v_2 = c + β * integral\n",
    "                v_new[i, j] = max(v_1, v_2)\n",
    "\n",
    "        return v_new\n",
    "\n",
    "    @njit(parallel=parallel_flag)\n",
    "    def get_greedy(v):\n",
    "        \"\"\"\"\n",
    "        Compute optimal actions taking v as the value function.\n",
    "\n",
    "        \"\"\"\n",
    "\n",
    "        v_func = lambda x, y: mlinterp((w_grid, π_grid), v, (x, y))\n",
    "        σ = np.empty_like(v)\n",
    "\n",
    "        for i in prange(len(w_grid)):\n",
    "            for j in prange(len(π_grid)):\n",
    "                w = w_grid[i]\n",
    "                π = π_grid[j]\n",
    "\n",
    "                v_1 = w / (1 - β)\n",
    "\n",
    "                integral_f, integral_g = 0.0, 0.0\n",
    "                for m in prange(mc_size):\n",
    "                    integral_f += v_func(w_f[m], κ(w_f[m], π))\n",
    "                    integral_g += v_func(w_g[m], κ(w_g[m], π))\n",
    "                integral = (π * integral_f + (1 - π) * integral_g) / mc_size\n",
    "\n",
    "                v_2 = c + β * integral\n",
    "\n",
    "                σ[i, j] = v_1 > v_2  # Evaluates to 1 or 0\n",
    "\n",
    "        return σ\n",
    "\n",
    "    return T, get_greedy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will omit a detailed discussion of the code because there is a\n",
    "more efficient solution method that we will use later\n",
    "\n",
    "To solve the model we will use the following function that iterates using\n",
    "T to find a fixed point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def solve_model(sp,\n",
    "                use_parallel=True,\n",
    "                tol=1e-4,\n",
    "                max_iter=1000,\n",
    "                verbose=True,\n",
    "                print_skip=5):\n",
    "\n",
    "    \"\"\"\n",
    "    Solves for the value function\n",
    "\n",
    "    * sp is an instance of SearchProblem\n",
    "    \"\"\"\n",
    "\n",
    "    T, _ = operator_factory(sp, use_parallel)\n",
    "\n",
    "    # Set up loop\n",
    "    i = 0\n",
    "    error = tol + 1\n",
    "    m, n = len(sp.w_grid), len(sp.π_grid)\n",
    "\n",
    "    # Initialize v\n",
    "    v = np.zeros((m, n)) + sp.c / (1 - sp.β)\n",
    "\n",
    "    while i < max_iter and error > tol:\n",
    "        v_new = T(v)\n",
    "        error = np.max(np.abs(v - v_new))\n",
    "        i += 1\n",
    "        if verbose and i % print_skip == 0:\n",
    "            print(f\"Error at iteration {i} is {error}.\")\n",
    "        v = v_new\n",
    "\n",
    "    if i == max_iter:\n",
    "        print(\"Failed to converge!\")\n",
    "\n",
    "    if verbose and i < max_iter:\n",
    "        print(f\"\\nConverged in {i} iterations.\")\n",
    "\n",
    "\n",
    "    return v_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s look at solutions computed from value function iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 5 is 0.6171930148420586.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 10 is 0.10370947001528208.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 15 is 0.022544805380521282.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 20 is 0.0050410790903470115.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 25 is 0.0011274063822721558.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 30 is 0.000252129858454353.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Converged in 34 iterations.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sp = SearchProblem()\n",
    "v_star = solve_model(sp)\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "ax.contourf(sp.π_grid, sp.w_grid, v_star, 12, alpha=0.6, cmap=cm.jet)\n",
    "cs = ax.contour(sp.π_grid, sp.w_grid, v_star, 12, colors=\"black\")\n",
    "ax.clabel(cs, inline=1, fontsize=10)\n",
    "ax.set(xlabel='$\\pi$', ylabel='$w$')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a id='odu-pol-vfi'></a>\n",
    "We will also plot the optimal policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "T, get_greedy = operator_factory(sp)\n",
    "σ_star = get_greedy(v_star)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 6))\n",
    "ax.contourf(sp.π_grid, sp.w_grid, σ_star, 1, alpha=0.6, cmap=cm.jet)\n",
    "ax.contour(sp.π_grid, sp.w_grid, σ_star, 1, colors=\"black\")\n",
    "ax.set(xlabel='$\\pi$', ylabel='$w$')\n",
    "\n",
    "ax.text(0.5, 0.6, 'reject')\n",
    "ax.text(0.7, 0.9, 'accept')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results fit well with our intuition from section [looking forward](#looking-forward)\n",
    "\n",
    "- The black line in the figure above corresponds to the function $ \\bar w(\\pi) $ introduced there  \n",
    "- It is decreasing as expected  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Take 2: A More Efficient Method\n",
    "\n",
    "Let’s consider another method to solve for the optimal policy\n",
    "\n",
    "We will use iteration with an operator that has the same contraction rate as the Bellman operator, but\n",
    "\n",
    "- one dimensional rather than two dimensional  \n",
    "- no maximization step  \n",
    "\n",
    "\n",
    "As a consequence, the algorithm is orders of magnitude faster than VFI\n",
    "\n",
    "This section illustrates the point that when it comes to programming, a bit of\n",
    "mathematical analysis goes a long way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another Functional Equation\n",
    "\n",
    "To begin, note that when $ w = \\bar w(\\pi) $, the worker is indifferent\n",
    "between accepting and rejecting\n",
    "\n",
    "Hence the two choices on the right-hand side of [(3)](#equation-odu-mvf) have equal value:\n",
    "\n",
    "\n",
    "<a id='equation-odu-mvf2'></a>\n",
    "$$\n",
    "\\frac{\\bar w(\\pi)}{1 - \\beta}\n",
    "= c + \\beta \\int v(w', \\pi') \\, q_{\\pi}(w') \\, dw' \\tag{4}\n",
    "$$\n",
    "\n",
    "Together, [(3)](#equation-odu-mvf) and [(4)](#equation-odu-mvf2) give\n",
    "\n",
    "\n",
    "<a id='equation-odu-mvf3'></a>\n",
    "$$\n",
    "v(w, \\pi) =\n",
    "\\max\n",
    "\\left\\{\n",
    "    \\frac{w}{1 - \\beta} ,\\, \\frac{\\bar w(\\pi)}{1 - \\beta}\n",
    "\\right\\} \\tag{5}\n",
    "$$\n",
    "\n",
    "Combining [(4)](#equation-odu-mvf2) and [(5)](#equation-odu-mvf3), we obtain\n",
    "\n",
    "$$\n",
    "\\frac{\\bar w(\\pi)}{1 - \\beta}\n",
    "= c + \\beta \\int \\max \\left\\{\n",
    "    \\frac{w'}{1 - \\beta} ,\\, \\frac{\\bar w(\\pi')}{1 - \\beta}\n",
    "\\right\\}\n",
    "\\, q_{\\pi}(w') \\, dw'\n",
    "$$\n",
    "\n",
    "Multiplying by $ 1 - \\beta $, substituting in $ \\pi' = \\kappa(w', \\pi) $\n",
    "and using $ \\circ $ for composition of functions yields\n",
    "\n",
    "\n",
    "<a id='equation-odu-mvf4'></a>\n",
    "$$\n",
    "\\bar w(\\pi)\n",
    "= (1 - \\beta) c +\n",
    "\\beta \\int \\max \\left\\{ w', \\bar w \\circ \\kappa(w', \\pi) \\right\\} \\, q_{\\pi}(w') \\, dw' \\tag{6}\n",
    "$$\n",
    "\n",
    "Equation [(6)](#equation-odu-mvf4) can be understood as a functional equation, where $ \\bar w $ is the unknown function\n",
    "\n",
    "- Let’s call it the *reservation wage functional equation* (RWFE)  \n",
    "- The solution $ \\bar w $ to the RWFE is the object that we wish to compute  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solving the RWFE\n",
    "\n",
    "To solve the RWFE, we will first show that its solution is the\n",
    "fixed point of a [contraction mapping](https://en.wikipedia.org/wiki/Contraction_mapping)\n",
    "\n",
    "To this end, let\n",
    "\n",
    "- $ b[0,1] $ be the bounded real-valued functions on $ [0,1] $  \n",
    "- $ \\| \\omega \\| := \\sup_{x \\in [0,1]} | \\omega(x) | $  \n",
    "\n",
    "\n",
    "Consider the operator $ Q $ mapping $ \\omega \\in b[0,1] $ into $ Q\\omega \\in b[0,1] $ via\n",
    "\n",
    "\n",
    "<a id='equation-odu-dq'></a>\n",
    "$$\n",
    "(Q \\omega)(\\pi)\n",
    "= (1 - \\beta) c +\n",
    "\\beta \\int \\max \\left\\{ w', \\omega \\circ \\kappa(w', \\pi) \\right\\} \\, q_{\\pi}(w') \\, dw' \\tag{7}\n",
    "$$\n",
    "\n",
    "Comparing [(6)](#equation-odu-mvf4) and [(7)](#equation-odu-dq), we see that the set of fixed points of $ Q $ exactly coincides with the set of solutions to the RWFE\n",
    "\n",
    "- If $ Q \\bar w = \\bar w $ then $ \\bar w $ solves [(6)](#equation-odu-mvf4) and vice versa  \n",
    "\n",
    "\n",
    "Moreover, for any $ \\omega, \\omega' \\in b[0,1] $, basic algebra and the\n",
    "triangle inequality for integrals tells us that\n",
    "\n",
    "\n",
    "<a id='equation-odu-nt'></a>\n",
    "$$\n",
    "|(Q \\omega)(\\pi) - (Q \\omega')(\\pi)|\n",
    "\\leq \\beta \\int\n",
    "\\left|\n",
    "\\max \\left\\{w', \\omega \\circ \\kappa(w', \\pi) \\right\\} -\n",
    "\\max \\left\\{w', \\omega' \\circ \\kappa(w', \\pi) \\right\\}\n",
    "\\right|\n",
    "\\, q_{\\pi}(w') \\, dw' \\tag{8}\n",
    "$$\n",
    "\n",
    "Working case by case, it is easy to check that for real numbers $ a, b, c $ we always have\n",
    "\n",
    "\n",
    "<a id='equation-odu-nt2'></a>\n",
    "$$\n",
    "| \\max\\{a, b\\} - \\max\\{a, c\\}| \\leq | b - c| \\tag{9}\n",
    "$$\n",
    "\n",
    "Combining [(8)](#equation-odu-nt) and [(9)](#equation-odu-nt2) yields\n",
    "\n",
    "\n",
    "<a id='equation-odu-nt3'></a>\n",
    "$$\n",
    "|(Q \\omega)(\\pi) - (Q \\omega')(\\pi)|\n",
    "\\leq \\beta \\int\n",
    "\\left| \\omega \\circ \\kappa(w', \\pi) -  \\omega' \\circ \\kappa(w', \\pi) \\right|\n",
    "\\, q_{\\pi}(w') \\, dw'\n",
    "\\leq \\beta \\| \\omega - \\omega' \\| \\tag{10}\n",
    "$$\n",
    "\n",
    "Taking the supremum over $ \\pi $ now gives us\n",
    "\n",
    "\n",
    "<a id='equation-odu-rwc'></a>\n",
    "$$\n",
    "\\|Q \\omega - Q \\omega'\\|\n",
    "\\leq \\beta \\| \\omega - \\omega' \\| \\tag{11}\n",
    "$$\n",
    "\n",
    "In other words, $ Q $ is a contraction of modulus $ \\beta $ on the\n",
    "complete metric space $ (b[0,1], \\| \\cdot \\|) $\n",
    "\n",
    "Hence\n",
    "\n",
    "- A unique solution $ \\bar w $ to the RWFE exists in $ b[0,1] $  \n",
    "- $ Q^k \\omega \\to \\bar w $ uniformly as $ k \\to \\infty $, for any $ \\omega \\in b[0,1] $  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementation\n",
    "\n",
    "The following function takes an instance of `SearchProblem` and returns the\n",
    "operator `Q`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def Q_factory(sp, parallel_flag=True):\n",
    "\n",
    "    f, g = sp.f, sp.g\n",
    "    w_f, w_g = sp.w_f, sp.w_g\n",
    "    β, c = sp.β, sp.c\n",
    "    mc_size = sp.mc_size\n",
    "    w_grid, π_grid = sp.w_grid, sp.π_grid\n",
    "\n",
    "    @njit\n",
    "    def κ(w, π):\n",
    "        \"\"\"\n",
    "        Updates π using Bayes' rule and the current wage observation w.\n",
    "        \"\"\"\n",
    "        pf, pg = π * f(w), (1 - π) * g(w)\n",
    "        π_new = pf / (pf + pg)\n",
    "\n",
    "        return π_new\n",
    "\n",
    "    @njit\n",
    "    def Q(ω):\n",
    "        \"\"\"\n",
    "\n",
    "        Updates the reservation wage function guess ω via the operator\n",
    "        Q.\n",
    "\n",
    "        \"\"\"\n",
    "        ω_func = lambda p: interp(π_grid, ω, p)\n",
    "        ω_new = np.empty_like(ω)\n",
    "\n",
    "        for i in prange(len(π_grid)):\n",
    "            π = π_grid[i]\n",
    "            integral_f, integral_g = 0.0, 0.0\n",
    "\n",
    "            for m in prange(mc_size):\n",
    "                integral_f += max(w_f[m], ω_func(κ(w_f[m], π)))\n",
    "                integral_g += max(w_g[m], ω_func(κ(w_g[m], π)))\n",
    "            integral = (π * integral_f + (1 - π) * integral_g) / mc_size\n",
    "\n",
    "            ω_new[i] = (1 - β) * c + β * integral\n",
    "\n",
    "        return ω_new\n",
    "\n",
    "    return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next exercise you are asked to compute an approximation to $ \\bar w $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "\n",
    "<a id='odu-ex1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Use the default parameters and `Q_factory` to compute an optimal policy\n",
    "\n",
    "Your result should coincide closely with the figure for the optimal policy [shown above](#odu-pol-vfi)\n",
    "\n",
    "Try experimenting with different parameters, and confirm that the change in\n",
    "the optimal policy coincides with your intuition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "This code solves the “Offer Distribution Unknown” model by iterating on\n",
    "a guess of the reservation wage function\n",
    "\n",
    "You should find that the run time is shorter than that of the value\n",
    "function approach\n",
    "\n",
    "Similar to above, we set up a function to iterate with `Q` to find the fixed point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def solve_wbar(sp,\n",
    "               use_parallel=True,\n",
    "               tol=1e-4,\n",
    "               max_iter=1000,\n",
    "               verbose=True,\n",
    "               print_skip=5):\n",
    "\n",
    "    Q = Q_factory(sp, use_parallel)\n",
    "\n",
    "    # Set up loop\n",
    "    i = 0\n",
    "    error = tol + 1\n",
    "    m, n = len(sp.w_grid), len(sp.π_grid)\n",
    "\n",
    "    # Initialize w\n",
    "    w = np.ones_like(sp.π_grid)\n",
    "\n",
    "    while i < max_iter and error > tol:\n",
    "        w_new = Q(w)\n",
    "        error = np.max(np.abs(w - w_new))\n",
    "        i += 1\n",
    "        if verbose and i % print_skip == 0:\n",
    "            print(f\"Error at iteration {i} is {error}.\")\n",
    "        w = w_new\n",
    "\n",
    "    if i == max_iter:\n",
    "        print(\"Failed to converge!\")\n",
    "\n",
    "    if verbose and i < max_iter:\n",
    "        print(f\"\\nConverged in {i} iterations.\")\n",
    "\n",
    "    return w_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution can be plotted as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 5 is 0.021067874645703255.\n",
      "Error at iteration 10 is 0.006394129775353252.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at iteration 15 is 0.0015272673190784847.\n",
      "Error at iteration 20 is 0.0003501429539156664.\n",
      "Error at iteration 25 is 8.007578961810591e-05.\n",
      "\n",
      "Converged in 25 iterations.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sp = SearchProblem()\n",
    "w_bar = solve_wbar(sp)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(9, 7))\n",
    "\n",
    "ax.plot(sp.π_grid, w_bar, color='k')\n",
    "ax.fill_between(sp.π_grid, 0, w_bar, color='blue', alpha=0.15)\n",
    "ax.fill_between(sp.π_grid, w_bar, sp.w_max, color='green', alpha=0.15)\n",
    "ax.text(0.5, 0.6, 'reject')\n",
    "ax.text(0.7, 0.9, 'accept')\n",
    "ax.set(xlabel='$\\pi$', ylabel='$w$')\n",
    "ax.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix\n",
    "\n",
    "The next piece of code is just a fun simulation to see what the effect of a change in the\n",
    "underlying distribution on the unemployment rate is\n",
    "\n",
    "At a point in the simulation, the distribution becomes significantly worse\n",
    "\n",
    "It takes a while for agents to learn this, and in the meantime they are too optimistic,\n",
    "and turn down too many jobs\n",
    "\n",
    "As a result, the unemployment rate spikes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "F_a, F_b, G_a, G_b = 1, 1, 3, 1.2\n",
    "\n",
    "sp = SearchProblem(F_a=F_a, F_b=F_b, G_a=G_a, G_b=G_b)\n",
    "f, g = sp.f, sp.g\n",
    "\n",
    "# Solve for reservation wage\n",
    "w_bar = solve_wbar(sp, verbose=False)\n",
    "\n",
    "# Interpolate reservation wage function\n",
    "π_grid = sp.π_grid\n",
    "w_func = njit(lambda x: interp(π_grid, w_bar, x))\n",
    "\n",
    "@njit\n",
    "def update(a, b, e, π):\n",
    "    \"Update e and π by drawing wage offer from beta distribution with parameters a and b.\"\n",
    "\n",
    "    if e == False:\n",
    "        w = np.random.beta(a, b)       # Draw random wage\n",
    "        if w >= w_func(π):\n",
    "            e = True                   # Take new job\n",
    "        else:\n",
    "            π = 1 / (1 + ((1 - π) * g(w)) / (π * f(w)))\n",
    "\n",
    "    return e, π\n",
    "\n",
    "@njit\n",
    "def simulate_path(F_a=F_a,\n",
    "                  F_b=F_b,\n",
    "                  G_a=G_a,\n",
    "                  G_b=G_b,\n",
    "                  N=5000,       # Number of agents\n",
    "                  T=600,        # Simulation length\n",
    "                  d=200,        # Change date\n",
    "                  s=0.025):     # Separation rate\n",
    "\n",
    "    \"\"\"Simulates path of employment for N number of works over T periods.\"\"\"\n",
    "\n",
    "    e = np.ones((N, T+1))\n",
    "    π = np.ones((N, T+1)) * 1e-3\n",
    "\n",
    "    a, b = G_a, G_b   # Initial distribution parameters\n",
    "\n",
    "    for t in range(T+1):\n",
    "\n",
    "        if t == d:\n",
    "            a, b = F_a, F_b  # Change distribution parameters\n",
    "\n",
    "        # Update each agent\n",
    "        for n in range(N):\n",
    "            if e[n, t] == 1:                    # If agent is currently employment\n",
    "                p = np.random.uniform(0, 1)\n",
    "                if p <= s:                      # Randomly separate with probability s\n",
    "                    e[n, t] = 0\n",
    "\n",
    "            new_e, new_π = update(a, b, e[n, t], π[n, t])\n",
    "            e[n, t+1] = new_e\n",
    "            π[n, t+1] = new_π\n",
    "\n",
    "    return e[:, 1:]\n",
    "\n",
    "d = 200  # Change distribution at time d\n",
    "unemployment_rate = 1 - simulate_path(d=d).mean(axis=0)\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(unemployment_rate)\n",
    "plt.axvline(d, color='r', alpha=0.6, label='Change date')\n",
    "plt.xlabel('Time')\n",
    "plt.title('Unemployment rate')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "filename": "odu.rst",
  "kernelspec": {
   "display_name": "Python",
   "language": "python3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "title": "Job Search III: Search with Learning"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}