BufferStockTheory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "06633a3a",
   "metadata": {},
   "source": [
    "# Theoretical Foundations of Buffer Stock Saving\n",
    "\n",
    "<cite data-cite=\"6202365/8AH9AXN2\"></cite>\n",
    "\n",
    "\n",
    "[![econ-ark.org](https://img.shields.io/badge/Powered%20by-Econ--ARK-3e8acc.svg)](https://econ-ark.org/materials/bufferstocktheory)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e97a4428",
   "metadata": {},
   "source": [
    "<a id='interactive-dashboard'></a>\n",
    "\n",
    "[This notebook](https://econ-ark.org/materials/bufferstocktheory?launch) uses the [Econ-ARK/HARK](https://github.com/econ-ark/HARK) toolkit to reproduce and illustrate key results of the paper [Theoretical Foundations of Buffer Stock Saving](https://econ-ark.github.io/BufferStockTheory/).\n",
    "\n",
    "An [interactive dashboard](https://econ-ark.org/materials/bufferstocktheory?dashboard) allows you to modify parameters to see how (some of) the figures change.\n",
    "\n",
    "\n",
    "- In JupyterLab, click on the $\\bullet$$\\bullet$$\\bullet$ patterns to expose the runnable code\n",
    "- in either a Jupyter notebook or JupyterLab:\n",
    "\n",
    "    * Click the double triangle <span class=reload>&#x23e9;</span> above to execute the code and generate the figures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf242f9e",
   "metadata": {},
   "source": [
    "`# Setup Python Below`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "19c9bead",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import required python packages\n",
    "import os.path\n",
    "import sys\n",
    "import subprocess\n",
    "import logging\n",
    "import numpy as np\n",
    "from copy import deepcopy\n",
    "import warnings\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['svg.hashsalt'] = \"42\" # Prevent mpl from generating random noise (for reproducibility)\n",
    "import matplotlib.pyplot as plt\n",
    "warnings.filterwarnings(\"ignore\") # Ignore some harmless but alarming warning messages\n",
    "\n",
    "# Make sure other required tools (like HARK) are installed\n",
    "if os.path.isdir('binder'):  # Folder defining requirements exists\n",
    "    # File requirements.out should be created first time notebook is run\n",
    "    if not os.path.isfile('./binder/requirements.out'):\n",
    "        try:\n",
    "            output = subprocess.check_output(\n",
    "                [sys.executable, '-m', 'pip', 'install','--user','-r','./binder/requirements.txt'],stderr=subprocess.STDOUT) \n",
    "            requirements_out = open(\"./binder/requirements.out\",\"w\")\n",
    "            requirements_out.write(output.decode(\"utf8\"))\n",
    "        except subprocess.CalledProcessError as e:\n",
    "            print(output.decode(\"utf8\"))\n",
    "            print(e.output.decode(\"utf8\"),e.returncode)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd73238",
   "metadata": {},
   "source": [
    "`# Setup HARK Below`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b28cfe6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from HARK import __version__ as HARKversion\n",
    "from HARK.utilities import (\n",
    "    plot_funcs, find_gui, make_figs, determine_platform,\n",
    "    test_latex_installation, setup_latex_env_notebook)\n",
    "from HARK.ConsumptionSaving.ConsIndShockModel import (\n",
    "    PerfForesightConsumerType, IndShockConsumerType, init_perfect_foresight, init_idiosyncratic_shocks)\n",
    "\n",
    "\n",
    "# Whether to save the figures to Figures_dir\n",
    "saveFigs = True\n",
    "\n",
    "# Whether to draw the figures\n",
    "drawFigs = True\n",
    "\n",
    "pf = determine_platform() # latex checking depends on platform\n",
    "try: # test whether latex is installed on command line \n",
    "    latexExists = test_latex_installation(pf)\n",
    "except ImportError:  # windows and MacOS requires manual latex install\n",
    "    latexExists = False\n",
    "\n",
    "setup_latex_env_notebook(pf, latexExists)\n",
    "\n",
    "# check if GUI is present; if not then switch drawFigs to False and force saveFigs to be True\n",
    "if not find_gui():\n",
    "    drawFigs, saveFigs = False, True\n",
    "\n",
    "# Font sizes for figures\n",
    "fssml, fsmid, fsbig = 18, 22, 26\n",
    "\n",
    "def makeFig(figure_name, target_dir=\"./Figures\"):\n",
    "    print('')\n",
    "    make_figs(figure_name, saveFigs, drawFigs, target_dir)\n",
    "    print('')\n",
    "    \n",
    "base_params = deepcopy(init_idiosyncratic_shocks)\n",
    "# Uninteresting housekeeping and details\n",
    "# Make global variables for the things that were lists above \n",
    "PermGroFac, PermShkStd, TranShkStd = base_params['PermGroFac'][0], base_params['PermShkStd'][0], base_params['TranShkStd'][0]\n",
    "\n",
    "# Some technical settings that are not interesting for our purposes\n",
    "base_params['LivPrb'] = [1.0]   # 100 percent chance of living to next period\n",
    "base_params['BoroCnstArt'] = None    # No artificial borrowing constraint\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d0c3a33",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## [The Problem](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory/BufferStockTheory3.html#The-Problem)\n",
    "\n",
    "The paper [calibrates](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Calibration) a small set of parameters:\n",
    "\n",
    "\\begin{align}\n",
    " &\n",
    "\\newcommand\\maththorn{\\mathord{\\pmb{\\text{\\TH}}}}\n",
    "\\newcommand{\\aLvl}{\\mathbf{a}}\n",
    "\\newcommand{\\aNrm}{{a}}\n",
    "\\newcommand{\\BalGroRte}{\\tilde}\n",
    "\\newcommand{\\Bal}{\\check}\n",
    "\\newcommand{\\bLvl}{{\\mathbf{b}}}\n",
    "\\newcommand{\\bNrm}{{b}}\n",
    "\\newcommand{\\cFunc}{\\mathrm{c}}\n",
    "\\newcommand{\\cLvl}{{\\mathbf{c}}}\n",
    "\\newcommand{\\cNrm}{{c}}\n",
    "\\newcommand{\\CRRA}{\\rho}\n",
    "\\newcommand{\\DiscFac}{\\beta}\n",
    "\\newcommand{\\dLvl}{{\\mathbf{d}}}\n",
    "\\newcommand{\\dNrm}{{d}}\n",
    "\\newcommand{\\Ex}{\\mathbb{E}}\n",
    "\\newcommand{\\hLvl}{{\\mathbf{h}}}\n",
    "\\newcommand{\\hNrm}{{h}}\n",
    "\\newcommand{\\IncUnemp}{\\mu}\n",
    "\\newcommand{\\mLvl}{{\\mathbf{m}}}\n",
    "\\newcommand{\\mNrm}{{m}}\n",
    "\\newcommand{\\MPC}{\\kappa}\n",
    "\\newcommand{\\PatFac}{\\pmb{\\unicode[0.55,0.05]{0x00DE}}}\n",
    "\\newcommand{\\PatRte}{\\pmb{\\unicode[0.55,0.05]{0x00FE}}}\n",
    "\\newcommand{\\PermGroFacAdj}{\\tilde{\\Phi}}\n",
    "\\newcommand{\\PermGroFac}{\\pmb{\\Phi}}\n",
    "\\newcommand{\\PermShkStd}{\\sigma_{\\PermShk}}\n",
    "\\newcommand{\\PermShk}{\\pmb{\\Psi}} % New\n",
    "\\newcommand{\\pLvl}{{\\mathbf{p}}}\n",
    "\\newcommand{\\Rfree}{\\mathsf{R}}\n",
    "\\newcommand{\\RNrm}{\\mathcal{R}}\n",
    "\\newcommand{\\Thorn}{\\pmb{\\TH}}\n",
    "\\newcommand{\\TranShkAll}{\\pmb{\\xi}}\n",
    "\\newcommand{\\TranShkStd}{\\sigma_{\\TranShk}}\n",
    "\\newcommand{\\TranShk}{\\pmb{\\theta}}\n",
    "\\newcommand{\\Trg}{\\hat}\n",
    "\\newcommand{\\uFunc}{\\mathrm{u}}\n",
    "\\newcommand{\\UnempPrb}{\\wp}\n",
    "\\newcommand{\\vLvl}{{\\mathbf{v}}}\n",
    "\\newcommand{\\vNrm}{{v}}\n",
    "\\renewcommand{\\APFac}{\\pmb{\\unicode[0.55,0.05]{0x00DE}}}\n",
    "\\end{align}\n",
    "\n",
    "| Parameter | Description | Python Variable | Value |\n",
    "|:---:      | :---:       | :---:  | :---: |\n",
    "| $\\PermGroFac$ | Permanent Income Growth Factor | $\\texttt{PermGroFac}$ | 1.03 |\n",
    "| $\\Rfree$ | Interest Factor | $\\texttt{Rfree}$ | 1.04 |\n",
    "| $\\DiscFac$ | Time Preference Factor | $\\texttt{DiscFac}$ | 0.96 |\n",
    "| $\\CRRA$ | Coeﬃcient of Relative Risk Aversion| $\\texttt{CRRA}$ | 2 |\n",
    "| $\\UnempPrb$ | Probability of Unemployment | $\\texttt{UnempPrb}$ | 0.005 |\n",
    "| $\\TranShk^{\\large u}$ | Income when Unemployed | $\\texttt{IncUnemp}$ | 0. |\n",
    "| $\\PermShkStd$ | Std Dev of Log Permanent Shock| $\\texttt{PermShkStd}$ | 0.1 |\n",
    "| $\\TranShkStd$ | Std Dev of Log Transitory Shock| $\\texttt{TranShkStd}$ | 0.1 |\n",
    "\n",
    "that define the preferences and environment of microeconomic consumers as detailed below.  (For notational conventions used here and in the paper, see the [NARK](https://github.com/econ-ark/HARK/blob/BST-HARK-pre-release-v4/Documentation/NARK/NARK.pdf).)\n",
    "\n",
    "The objective of such a consumer with a horizon of $n$ periods is to maximize the value obtained from the sequence of consumption choices __**c**__ from period $t=T-n$ to a terminal period $T$:\n",
    "\n",
    "\\begin{equation}\n",
    "\\mathbf{v}_{t} = \\sum_{i=0}^{n} \\DiscFac^{n}\\mathrm{u}(\\mathbf{c}_{t+n})\n",
    "\\end{equation}\n",
    "\n",
    "The infinite-horizon solution is defined as the limit of the first period solution $\\mathrm{c}_{T-n}$ as the horizon $n$ goes to infinity."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ce47bf3",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Details\n",
    "For a microeconomic consumer who begins period $t$ with __**m**__arket resources boldface $\\mLvl_{t}$ (=net worth plus current income), the amount that remains after __**c**__onsumption of $\\cLvl_{t}$ will be end-of-period __**a**__ssets $\\aLvl_{t}$,\n",
    "\n",
    "<!-- Next period's 'Balances' $B_{t+1}$ reflect this period's $\\aLvl_{t}$ augmented by return factor $R$:-->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73882d7",
   "metadata": {},
   "source": [
    "\\begin{eqnarray}\n",
    "\\aLvl_{t}   &=&\\mLvl_{t}-\\cLvl_{t}. \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "The consumer's __**p**__ermanent noncapital income $\\pLvl$ grows by a predictable factor $\\PermGroFac$ and is subject to an unpredictable multiplicative shock $\\Ex_{t}[\\PermShk_{t+1}]=1$,\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\pLvl_{t+1} & = & \\pLvl_{t} \\PermGroFac \\PermShk_{t+1}, \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "and, if the consumer is employed, actual income is permanent income multiplied by a transitory shock $\\TranShk^{\\large e}$.  There is also a probability $\\UnempPrb$ that the consumer will be temporarily unemployed and experience income of $\\TranShk^{\\large u}  = 0$.  We construct $\\TranShk^{\\large e}$ so that its mean value is $1/(1-\\UnempPrb)$ because in that case the mean level of the transitory shock (accounting for both unemployed and employed states) is exactly\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\Ex_{t}[\\TranShk_{t+1}] & = & \\TranShk^{\\large{u}}  \\times \\UnempPrb + (1-\\UnempPrb) \\times \\Ex_{t}[\\TranShk^{\\large{e}}_{t+1}] \\notag\n",
    "\\\\ & = & 0 \\times \\UnempPrb + (1-\\UnempPrb) \\times 1/(1-\\UnempPrb)  \\notag\n",
    "\\\\ & = & 1. \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "  We can combine the unemployment shock $\\TranShk^{\\large u}$ and the transitory shock to employment income $\\TranShk^{\\large e}$ into $\\TranShkAll_{t+1}$, so that next period's market resources are\n",
    "\\begin{eqnarray}\n",
    "    \\mLvl_{t+1} &=& \\aLvl_{t}\\Rfree +\\pLvl_{t+1}\\TranShkAll_{t+1}.  \\notag\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e16be6",
   "metadata": {},
   "source": [
    "When the consumer has a CRRA utility function $u(\\cLvl)=\\frac{\\cLvl^{1-\\CRRA}}{1-\\CRRA}$, the paper shows that the problem can be written in terms of ratios (nonbold font) of level (bold font) variables to permanent income, e.g. $m_{t} \\equiv \\mLvl_{t}/\\pLvl_{t}$, and the Bellman form of [the problem reduces to](https://econ-ark.github.io/BufferStockTheory/#The-Related-Problem):\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "v_t(m_t) &=& \\max_{c_t}~~ u(c_t) + \\DiscFac~\\Ex_{t} [(\\PermGroFac\\PermShk_{t+1})^{1-\\CRRA} v_{t+1}(m_{t+1}) ] \\\\\n",
    "& s.t. & \\\\\n",
    "a_t &=& m_t - c_t \\\\\n",
    "m_{t+1} &=& a_t \\Rfree/(\\PermGroFac \\PermShk_{t+1}) + \\TranShkAll_{t+1} \\\\\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ff616b5",
   "metadata": {
    "lines_to_next_cell": 0,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the parameters for the baseline results in the paper\n",
    "base_params['PermGroFac'] = [1.03]         # Permanent income growth factor\n",
    "base_params['Rfree'] = Rfree = 1.04        # Interest factor on assets\n",
    "base_params['DiscFac'] = DiscFac = 0.96    # Time Preference Factor\n",
    "base_params['CRRA'] = CRRA = 2.00          # Coefficient of relative risk aversion\n",
    "# Probability of unemployment (e.g. Probability of Zero Income in the paper)\n",
    "base_params['UnempPrb'] = UnempPrb = 0.005\n",
    "base_params['IncUnemp'] = IncUnemp = 0.0   # Induces natural borrowing constraint\n",
    "base_params['PermShkStd'] = [0.1]          # Standard deviation of log permanent income shocks\n",
    "base_params['TranShkStd'] = [0.1]          # Standard deviation of log transitory income shocks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8220cc68",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Convergence of the Consumption Rules\n",
    "\n",
    "Under the given parameter values, [the paper's first figure](https://econ-ark.github.io/BufferStockTheory/#Convergence-of-the-Consumption-Rules) depicts the successive consumption rules that apply in the last period of life $(c_{T}(m))$, the second-to-last period, and earlier periods $(c_{T-n})$.  The consumption function to which these converge is $c(m)$:\n",
    "\n",
    "\\begin{equation}\n",
    "c(m) = \\lim_{n \\uparrow \\infty} c_{T-n}(m) \\notag\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf782ac2",
   "metadata": {},
   "source": [
    "`# Create a buffer stock consumer instance:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0894c22",
   "metadata": {
    "lines_to_next_cell": 2,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create a buffer stock consumer instance by invoking the IndShockConsumerType class\n",
    "# with the parameter dictionary \"base_params\"\n",
    "\n",
    "base_params['cycles'] = 100  # periods to solve from end\n",
    "# Construct finite horizon agent with baseline parameters\n",
    "baseAgent_Fin = \\\n",
    "    IndShockConsumerType(**base_params,\n",
    "                         quietly=True)  # Don't babble during setup\n",
    "\n",
    "baseAgent_Fin.solve(quietly=True)  # Solve the model quietly\n",
    "\n",
    "baseAgent_Fin.unpack('cFunc')  # Retrieve consumption functions\n",
    "cFunc = baseAgent_Fin.cFunc    # Shortcut"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a60998f1",
   "metadata": {},
   "source": [
    "`# Plot the consumption rules:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a5746d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot the different consumption rules for the different periods\n",
    "\n",
    "mPlotMin = 0\n",
    "mLocCLabels = 9.6  # Defines horizontal limit of figure\n",
    "mPlotTop = 6.5     # Defines maximum m value where functions are plotted\n",
    "mPts = 1000        # Number of points at which functions are evaluated\n",
    "\n",
    "mBelwLabels = np.linspace(mPlotMin, mLocCLabels-0.1, mPts) # Range of m below loc of labels\n",
    "m_FullRange = np.linspace(mPlotMin, mPlotTop, mPts)        # Full plot range\n",
    "\n",
    "# c_Tm0  defines the last period consumption rule (c=m)\n",
    "T = -1  # Solution in the last period\n",
    "c_Tm0 = m_FullRange\n",
    "# c_Tm1 defines the second-to-last period consumption rule\n",
    "c_Tm1  = cFunc[T-1 ](mBelwLabels)\n",
    "c_Tm5  = cFunc[T-5 ](mBelwLabels) # c_Tm5  defines the T-5  period consumption rule\n",
    "c_Tm10 = cFunc[T-10](mBelwLabels) # c_Tm10 defines the T-10 period consumption rule\n",
    "c_Limt = cFunc[0   ](mBelwLabels) # limiting inﬁnite-horizon consumption rule\n",
    "\n",
    "plt.figure(figsize=(12, 9))\n",
    "plt.rcParams['font.size'], plt.rcParams['font.weight'] = fsmid, 'bold'\n",
    "\n",
    "xMin, xMax = 0, 11\n",
    "yMin, yMax = 0, 7\n",
    "plt.xlim(xMin, xMax)\n",
    "plt.ylim(yMin, yMax)\n",
    "\n",
    "plt.plot(mBelwLabels, c_Limt, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm1, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm5, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm10, color='black')\n",
    "plt.plot(m_FullRange, c_Tm0, color='black')\n",
    "plt.text(yMax, yMax-1    , r'$c_{T   }(m) = 45$ degree line')\n",
    "plt.text(mLocCLabels, 5.3, r'$c_{T-1 }(m)$')\n",
    "plt.text(mLocCLabels, 2.6, r'$c_{T-5 }(m)$')\n",
    "plt.text(mLocCLabels, 2.1, r'$c_{T-10}(m)$')\n",
    "plt.text(mLocCLabels, 1.7, r'$c(m)       $')\n",
    "plt.arrow(6.9, 6.05, -0.6, 0, head_width=0.1, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "                right='off', bottom='off', top='off')\n",
    "plt.text(0, 7.05, \"$c$\", fontsize=fsbig)\n",
    "plt.text(xMax+0.1, 0, \"$m$\", fontsize=fsbig)\n",
    "\n",
    "# Save the figure\n",
    "makeFig('cFuncsConverge')  # Comment out if you want to run uninterrupted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e7b8149",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Use the [interactive dashboard](#interactive-dashboard) to explore the effects of changes in patience, risk aversion, or risk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e365e041",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Factors and Conditions\n",
    "\n",
    "### [The Finite Human Wealth Condition](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Human-Wealth)\n",
    "\n",
    "Human wealth for a perfect foresight consumer is the present discounted value of future noncapital income:\n",
    "\n",
    "\\begin{eqnarray}\\notag\n",
    "\\hLvl_{t} & = & \\Ex_{t}[\\pLvl_{t} + \\Rfree^{-1} \\pLvl_{t+1} + \\Rfree^{2} \\pLvl_{t+2} ... ] \\\\ \\notag\n",
    "      & = & \\pLvl_{t} \\left(1 + (\\PermGroFac/\\Rfree) + (\\PermGroFac/\\Rfree)^{2} ... \\right)\n",
    "\\end{eqnarray}\n",
    "\n",
    "which approaches infinity as the horizon extends if $\\PermGroFac/\\Rfree \\geq 1$.  We say that the 'Finite Human Wealth Condition' [(FHWC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FHWC) holds if\n",
    "$0 \\leq (\\PermGroFac/\\Rfree) < 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d69326",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Absolute Patience and the AIC](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AIC)\n",
    "\n",
    "The paper defines the Absolute Patience Factor [(APF)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APFac) as being equal to the ratio $\\cLvl_{t+1}/\\cLvl_{t}$ for a perfect foresight consumer.  (The Old English character [Thorn](https://en.wikipedia.org/wiki/Thorn_(letter)) used for this object in the paper cannot reliably be rendered in Jupyter notebooks; it may appear as capital Phi):\n",
    "\n",
    "\\begin{equation}\n",
    "\\PatFac = (\\Rfree \\DiscFac)^{1/\\CRRA}\n",
    "\\end{equation}\n",
    "\n",
    "If $\\APFac = 1$, a perfect foresight consumer will spend at exactly the level of $\\cLvl$ that can be sustained perpetually (given their current and future resources).  If $\\APFac < 1$ (the consumer is 'absolutely impatient'; or, 'the absolute impatience condition holds'), the consumer is consuming more than the sustainable amount, so consumption will fall, and if the consumer is 'absolutely patient' with $\\APFac > 1$ consumption will grow over time.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0b0313",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Growth Patience and the GICRaw](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GIC)\n",
    "\n",
    "For a [perfect foresight consumer](https://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA), whether the ratio $c$=__**c**__/__**p**__ is rising, constant, or falling depends on the relative growth rates of consumption and permanent income; that ratio is measured by the [Perfect Foresight Growth Patience Factor](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#PFGPF):\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\APFac_{\\PermGroFac} & = & \\APFac/\\PermGroFac\n",
    "\\end{eqnarray}\n",
    "and whether the $c$ is falling or rising over time depends on whether $\\APFac_{\\PermGroFac}$ is below or above 1.\n",
    "\n",
    "An analogous condition can be defined when there is uncertainty about permanent income.  Defining $\\tilde{\\PermGroFac} = (\\Ex[\\PermShk^{-1}])^{-1}\\PermGroFac$, the\n",
    "['Growth Impatience Condition'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GIC) determines whether, _in expectation_, the stochastic value of $c$ is rising, constant, or falling over time:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "  \\APFac/\\tilde{\\PermGroFac} & < & 1.\n",
    "\\end{eqnarray}\n",
    "\n",
    "### [The Finite Value of Autarky Condition (FVAC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1dd54dd",
   "metadata": {},
   "source": [
    "The paper [shows](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value) that a consumer who planned to spend his permanent noncapital income $\\{ \\pLvl_{t}, \\pLvl_{t+1}, ...\\} $ in every period would have value defined by\n",
    "\n",
    "\\begin{equation*}\n",
    "\\vLvl_{t}^{\\text{autarky}} = \\uFunc(\\pLvl_{t})\\left(\\frac{1}{1-\\DiscFac \\PermGroFac^{1-\\CRRA} \\Ex[\\PermShk^{1-\\CRRA}]}\\right)\n",
    "\\end{equation*}\n",
    "\n",
    "and defines the ['Finite Value of Autarky Condition'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value) as the requirement that the denominator be a positive finite number:\n",
    "\n",
    "\\begin{equation*}\n",
    "\\DiscFac \\PermGroFac^{1-\\CRRA} \\Ex[\\PermShk^{1-\\CRRA}] < 1\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1d10d4",
   "metadata": {},
   "source": [
    "### [The Weak Return Impatience Condition (WRIC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#WRIC)\n",
    "\n",
    "The [Return Impatience Condition](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#RIC) $\\APFac/\\Rfree < 1$ has long been understood to be required for the perfect foresight model to have a nondegenerate solution (a common special case is when $\\CRRA=1$; in this case $\\APFac = \\Rfree \\DiscFac$ so $\\APFac<1$ reduces to the familiar condition $\\DiscFac < \\Rfree$).\n",
    "\n",
    "If the RIC does not hold, the consumer is so patient that the optimal consumption function approaches zero as the horizon extends indefinitely.\n",
    "\n",
    "When the probability of unemployment is $\\UnempPrb$, the paper articulates an analogous (but weaker) return impatience condition:\n",
    "\n",
    "\\begin{eqnarray}\n",
    " \\UnempPrb^{1/\\CRRA} \\APFac/\\Rfree & < & 1\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8ad2a5e",
   "metadata": {},
   "source": [
    "# Key Results\n",
    "\n",
    "## [Nondegenerate Solution Requires FVAC and WRIC](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Sufficient-Conditions-For-Nondegenerate-Solution)\n",
    "\n",
    "A main result of the paper is that the conditions required for the model to have a nondegenerate limiting solution ($0 < c(m) < \\infty$ for feasible $m$) are that the Finite Value of Autarky (FVAC) and Weak Return Impatience Condition (WRIC) hold."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eb0a439",
   "metadata": {},
   "source": [
    "## [Natural Borrowing Constraint limits to Artificial Borrowing Constraint](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#The-Liquidity-Constrained-Solution-as-a-Limit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7873be03",
   "metadata": {},
   "source": [
    "Defining $\\chi(\\UnempPrb)$ as the consumption function associated with any particular probability of a zero-income shock $\\UnempPrb,$ and defining $\\hat{\\chi}$ as the consumption function that would apply in the absence of the transitory zero-income shocks but in the presence of an 'artificial' borrowing constraint requiring $a \\geq 0$ (_a la_ Deaton (1991)), the paper shows that\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\lim_{\\UnempPrb \\downarrow 0}~\\chi(\\UnempPrb) & = & \\hat{\\chi}\n",
    "\\end{eqnarray}\n",
    "\n",
    "That is, as $\\UnempPrb$ approaches zero the problem with uncertainty becomes identical to the problem that instead has constraints.  (See [Precautionary Saving and Liquidity Constraints](https://econ-ark.github.io/LiqConstr) for a full treatment of the relationship between precautionary saving and liquidity constraints)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58daad3",
   "metadata": {},
   "source": [
    "## [$\\cFunc(m)$ can be Finite Even When Human Wealth Is Infinite](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#When-The-GICRaw-Fails)\n",
    "\n",
    "In the perfect foresight model, if $\\Rfree < \\PermGroFac$ the PDV of future labor income approaches infinity as the horizon extends and so the limiting consumption function is $c(m) = \\infty$ for all $m$.  Many models have no well-defined limiting solution when human wealth is infinite.\n",
    "\n",
    "The presence of uncertainty changes this: Even when limiting human wealth is infinite, the limiting consumption function is finite for all values of $m$.\n",
    "\n",
    "This is because uncertainty imposes a \"natural borrowing constraint\" that deters the consumer from borrowing against their unbounded (but uncertain) future labor income."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "575c8290",
   "metadata": {},
   "source": [
    "A [table](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Sufficient-Conditions-For-Nondegenerate-Solution) puts this result in the context of implications of other conditions and restrictions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4eaa221",
   "metadata": {},
   "source": [
    "## [Unique and Stable Values of $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Unique-Stable-Points)\n",
    "\n",
    "Assuming that the **FVAC** and **WRIC** hold so that the problem has a nondegenerate solution, under more stringent conditions its dynamics can also be shown to exhibit certain kinds of stability.  Two particularly useful kinds of stability are existence of a 'target' value of market resources $\\Trg{\\mNrm}$ (`mNrmFacTrg` in the toolkit) and a 'pseudo-steady-state' value $\\Bal{\\mNrm}$ (`mBalLvl` in the toolkit).\n",
    "\n",
    "### [If the GIC-Nrm Holds, $\\exists$ a finite 'target' $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#onetarget)\n",
    "\n",
    "Section [Individual Target Wealth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#onetarget) shows that, under parameter values for which the limiting consumption function exists, if the [GICMod](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod) holds then there will be a value $\\Trg{m}$ such that:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex[m_{t+1}] & > & m_{t}~\\text{if $m_{t} < \\Trg{m}$} \\\\\n",
    "\\Ex[m_{t+1}] & < & m_{t}~\\text{if $m_{t} > \\Trg{m}$} \\\\\n",
    "\\Ex[m_{t+1}] & = & m_{t}~\\text{if $m_{t} = \\Trg{m}$}\n",
    "\\end{eqnarray*}\n",
    "\n",
    "[An equation](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#mTargImplicit) in the paper tells us that, for the expected normalized interest factor $\\bar{\\RNrm}=\\mathbb{E}[\\Rfree/(\\PermGroFac \\PermShk)]$, if $\\mNrm_{t}=\\Trg{m}$ then:\n",
    "\n",
    "\\begin{align}\n",
    "(\\Trg{\\mNrm}-\\cFunc(\\Trg{\\mNrm}))\\bar{\\RNrm}+1 & = \\Trg{\\mNrm}\n",
    "%\\\\ \\Trg{\\mNrm}(1-\\bar{\\RNrm}^{-1})+\\bar{\\RNrm}^{-1} & = \\Trg{\\cNrm}\n",
    "%\\\\ \\Trg{\\cNrm} & = \\Trg{\\mNrm} - (\\Trg{\\mNrm} - 1)\\bar{\\RNrm}^{-1}\n",
    "\\end{align}\n",
    "\n",
    "which can be solved numerically for the unique $\\Trg{\\mNrm}$ that satisfies it.\n",
    "\n",
    "### [If the GIC-Raw Holds, $\\exists$ a balanced growth 'pseudo-steady-state' $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#pseudo-steady-state)\n",
    "\n",
    "Section [Individual Balanced-Growth 'pseudo steady state'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#pseudo-steady-state) shows that, under parameter values for which the limiting consumption function exists, if the **GIC** holds then there will be a value $\\Bal{m}$ such that:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & > & \\PermGroFac~\\text{if $m_{t} < \\Bal{m}$} \\\\\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & < & \\PermGroFac~\\text{if $m_{t} > \\Bal{m}$} \\\\\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & = & \\PermGroFac~\\text{if $m_{t} = \\Bal{m}$}\n",
    "\\end{eqnarray*}\n",
    "\n",
    "[An equation](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#balgrostableSolve) in the paper tells us that if $\\mNrm_{t}=\\Bal{m}$ then:\n",
    "\n",
    "\\begin{align}\n",
    "(\\Bal{\\mNrm}-\\cFunc(\\Bal{\\mNrm}))\\RNrm+1 & = \\Bal{\\mNrm}\n",
    "\\end{align}\n",
    "\n",
    "which can be solved numerically for the unique $\\Bal{\\mNrm}$ that satisfies it.\n",
    "\n",
    "\n",
    "### [Example With Finite Pseudo-Steady-State But Infinite Target Wealth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds)\n",
    "\n",
    "[A figure](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds) depicts a solution when the **FVAC** [(Finite Value of Autarky Condition)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC) and [**WRIC**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC) hold (so that the model has a solution), the [**GIC**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICRaw) holds, so the model has a pseudo-steady-state $\\Bal{\\mNrm}$, but the [**GIC-Nrm**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod) fails, so the model does not have an individual target wealth ratio $\\Trg{\\mNrm}$ (or, rather, the target wealth ratio is infinity, as can be seen by the fact that the level of $\\cNrm$ is always below the level that would keep $\\Ex_{t}[\\Delta \\mNrm_{t+1}] = 0$).\n",
    "\n",
    "This example was constructed by quadrupling the variance of the permanent shocks from the baseline parameterization.  The extra precautionary saving induced by increased uncertainty is what pushes the agent into the region without a target wealth ratio."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e103f755",
   "metadata": {},
   "source": [
    "`# Create an example consumer instance where the GICMod fails but the GIC Holds:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c558fce3",
   "metadata": {
    "lines_to_next_cell": 0,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# GICModFailsButGICRawHolds Example\n",
    "\n",
    "base_params['cycles'] = 0  # revert to default of infinite horizon\n",
    "GICModFailsButGICRawHolds_params = dict(base_params)\n",
    "\n",
    "# Increase patience by increasing risk\n",
    "GICModFailsButGICRawHolds_params['PermShkStd'] = [0.2]\n",
    "\n",
    "# Create an agent with these parameters\n",
    "GICModFailsButGICRawHolds = \\\n",
    "    IndShockConsumerType(**GICModFailsButGICRawHolds_params,\n",
    "                         quietly=True,messaging_level=logging.CRITICAL  # If True, output suppressed\n",
    "                         )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa44a31",
   "metadata": {},
   "source": [
    "`# Solve that consumer's problem:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58431a1b",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Solve the model for these parameter values\n",
    "GICModFailsButGICRawHolds.tolerance = 0.0001  # Declare victory at ...\n",
    "# Suppress output during solution\n",
    "GICModFailsButGICRawHolds.solve(quietly=False,messaging_level=logging.CRITICAL) \n",
    "\n",
    "# Because we are trying to solve a problem very close to the poised patience\n",
    "# values, we want to do it with extra precision to be sure we've gotten the\n",
    "# answer right.  We can retrieve the distance between the last two solutions:\n",
    "\n",
    "distance_original = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "\n",
    "# But high precision would have slowed things down if we used it from the start\n",
    "\n",
    "# Instead, we can take the solution obtained above, and continue it but with\n",
    "# parameters that will yield a more precise answer:\n",
    "\n",
    "# Solve with larger than normal range\n",
    "GICModFailsButGICRawHolds.aXtraMax = GICModFailsButGICRawHolds.aXtraMax * 10\n",
    "\n",
    "# Solve using four times as many gridpoints\n",
    "GICModFailsButGICRawHolds.aXtraCount = GICModFailsButGICRawHolds.aXtraCount * 4\n",
    "\n",
    "GICModFailsButGICRawHolds.update_assets_grid()\n",
    "\n",
    "# Solve to a 10 times tighter degree of error tolerance\n",
    "GICModFailsButGICRawHolds.tolerance = GICModFailsButGICRawHolds.tolerance/10\n",
    "\n",
    "# When the solver reaches its tolerance threshold, it changes the solver\n",
    "# attribute stge_kind to have 'iter_status' of 'finished'\n",
    "# If we want to continue the solution (having changed something, as above)\n",
    "# To continue the solution from where we left off, we just change the\n",
    "# 'iter_status' to 'iterator' and tell it to \".solve()\" again\n",
    "\n",
    "GICModFailsButGICRawHolds.solution[0].stge_kind['iter_status'] = 'iterator'\n",
    "# continue solving\n",
    "\n",
    "# Setting messaging_level to NOTSET prints all info including progress\n",
    "GICModFailsButGICRawHolds.solve(messaging_level=logging.NOTSET, quietly=False)\n",
    "\n",
    "# Test whether the new solution meets a tighter tolerance than before:\n",
    "distance_now = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "print('\\ndistance_now < distance_original: ' +\n",
    "      str(distance_now < distance_original))\n",
    "\n",
    "# Again increase the range\n",
    "GICModFailsButGICRawHolds.aXtraMax = GICModFailsButGICRawHolds.aXtraMax * 10\n",
    "\n",
    "# and gridpoints\n",
    "GICModFailsButGICRawHolds.aXtraCount = GICModFailsButGICRawHolds.aXtraCount * 2\n",
    "\n",
    "# construct grid with the extra gridpoints and expanded range\n",
    "GICModFailsButGICRawHolds.update_assets_grid()\n",
    "\n",
    "# and decrease error tolerance\n",
    "GICModFailsButGICRawHolds.tolerance = GICModFailsButGICRawHolds.tolerance/100\n",
    "\n",
    "# mark as not finished but ready to continue iterating\n",
    "GICModFailsButGICRawHolds.solution[0].stge_kind['iter_status'] = 'iterator'\n",
    "\n",
    "# continue solving\n",
    "GICModFailsButGICRawHolds.solve(messaging_level=logging.DEBUG, quietly=False)\n",
    "\n",
    "# Test whether the new solution meets a tighter tolerance than before:\n",
    "distance_now = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "print('\\ndistance_now < distance_original: ' +\n",
    "      str(distance_now < distance_original))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8264351",
   "metadata": {},
   "source": [
    "`# Plot the results:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfbdc00c",
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds\n",
    "\n",
    "soln = GICModFailsButGICRawHolds.solution[0]  # Short alias for solution\n",
    "\n",
    "# Get objects that have been Built, parameters configured, and expectations \n",
    "Bilt, Pars, E_tp1_ = soln.Bilt, soln.Pars, soln.E_Next_\n",
    "\n",
    "# consumption function\n",
    "cFunc = Bilt.cFunc\n",
    "\n",
    "# Shortcuts to useful items\n",
    "RPFac = Bilt.RPFac\n",
    "G = Pars.PermGroFac\n",
    "\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCminDefn\n",
    "mpc_Min = 1.0-RPFac \n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#hNrmDefn\n",
    "h_inf = (1.0/(1.0-G/Rfree))\n",
    "\n",
    "# Perfect foresight consumption function (unused but convenient for explorations)\n",
    "def cFunc_Uncnst(m): return mpc_Min * m + (h_inf - 1) * mpc_Min\n",
    "\n",
    "# Initialize figure setup\n",
    "fig, ax = plt.subplots(figsize=(12, 8))\n",
    "\n",
    "[xMin, xMax] = [0.0, 8.0]\n",
    "yMin = 0.0\n",
    "yMax = E_tp1_.c_where_E_Next_m_tp1_minus_m_t_eq_0(xMax)*1.3\n",
    "\n",
    "mPltVals = np.linspace(xMin, xMax, mPts)\n",
    "\n",
    "if latexExists:\n",
    "    c_Stable_TrgNrm_txt = \"$\\Ex_{t}[\\Delta m_{t+1}] = 0$\"\n",
    "    c_Stable_BalLvl_txt = \"$\\Ex_{t}[{\\mathbf{m}}_{t+1}/{\\mathbf{m}}_{t}] = \\PermGroFac$\"\n",
    "    c_Stable_BalLog_txt = \"$\\Ex_{t}[\\log {\\mathbf{m}}_{t+1} - \\log {\\mathbf{m}}_{t}] = \\log \\PermGroFac$\"\n",
    "    c_Unconstrained_txt = r'$\\bar{\\cFunc}(\\mNrm)$'\n",
    "else:\n",
    "    c_Stable_TrgNrm_txt = \"$\\mathsf{E}_{t}[\\Delta m_{t+1}] = 0$\"\n",
    "    c_Stable_BalLvl_txt = \"$\\mathsf{E}_{t}[\\mathbf{m}_{t+1}/\\mathbf{m}_{t}] = \\Phi$\"\n",
    "    c_Stable_BalLog_txt = \"$\\mathsf{E}_{t}[\\log \\mathbf{m}_{t+1} - \\log \\mathbf{m}_{t}] = \\log \\Phi$\"\n",
    "    c_Unconstrained_txt = r'$\\bar{\\cFunc}(\\mNrm)$'\n",
    "\n",
    "cVals_Lmting_color = \"black\"\n",
    "c_Stable_BalLvl_color = \"black\"  # or \"blue\"\n",
    "c_Stable_BalLog_color = \"blue\"  # or \"blue\"\n",
    "c_Stable_TrgNrm_color = \"black\"  # or \"red\"\n",
    "c_Unconstrained_color = \"black\"  # or \"red\"\n",
    "\n",
    "cVals_Lmting = cFunc(mPltVals)\n",
    "c_Stable_TrgNrm = E_tp1_.c_where_E_Next_m_tp1_minus_m_t_eq_0(mPltVals)\n",
    "c_Stable_BalLvl = E_tp1_.c_where_E_Next_PermShk_tp1_times_m_tp1_minus_m_t_eq_0(mPltVals)\n",
    "c_Stable_BalLog = list(map(lambda mPltVal: soln.c_where_E_Next_mLog_tp1_minus_mLog_t_eq_0(mPltVal), mPltVals))\n",
    "c_Unconstrained = list(map(lambda mPltVal: cFunc_Uncnst(mPltVal), mPltVals))\n",
    "\n",
    "# To reduce clutter, results for PF soln and balanced-log-growth are omitted\n",
    "cVals_Lmting_lbl, = ax.plot(mPltVals, cVals_Lmting, color=cVals_Lmting_color)\n",
    "c_Stable_TrgNrm_lbl, = ax.plot(mPltVals, c_Stable_TrgNrm,\n",
    "                            color=c_Stable_TrgNrm_color, linestyle=\"dashed\", label=c_Stable_TrgNrm_txt)\n",
    "c_Stable_BalLvl_lbl, = ax.plot(mPltVals, c_Stable_BalLvl,\n",
    "                            color=c_Stable_BalLvl_color, linestyle=\"dotted\", label=c_Stable_BalLvl_txt)\n",
    "#c_Stable_BalLog_lbl, = ax.plot(mPltVals, c_Stable_BalLog,\n",
    "#                            color=c_Stable_BalLog_color, linestyle=\"dotted\", label=c_Stable_BalLog_txt)\n",
    "# c_Unconstrained_lbl, = ax.plot(mPltVals, c_Unconstrained,color=c_Unconstrained_color, linestyle=\"dashdot\", label=c_Unconstrained_txt)\n",
    "ax.set_xlim(xMin, xMax)\n",
    "ax.set_ylim(yMin, yMax)\n",
    "ax.set_xlabel(\"$\\mathit{m}$\", fontweight='bold', fontsize=fsmid, loc=\"right\")\n",
    "ax.set_ylabel(\"$\\mathit{c}$\", fontweight='bold', fontsize=fsmid, loc=\"top\", rotation=0)\n",
    "\n",
    "ax.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "               right='off', bottom='off', top='off')\n",
    "\n",
    "ax.legend(handles=[c_Stable_TrgNrm_lbl, c_Stable_BalLvl_lbl])\n",
    "#ax.legend(handles=[c_Stable_TrgNrm_lbl, c_Stable_BalLvl_lbl, c_Stable_BalLog_lbl])\n",
    "ax.legend(prop=dict(size=fsmid))\n",
    "\n",
    "mBalLvl = Bilt.mBalLvl\n",
    "cNrmFacBalLvl = c_Stable_BalNrm = cFunc(mBalLvl)\n",
    "\n",
    "ax.plot(mBalLvl, cNrmFacBalLvl, marker=\".\", markersize=15, color=\"black\")  # Dot at Bal point\n",
    "ax.text(1, 0.6, \"$\\mathrm{c}(m_{t})$\", fontsize=fsmid)  # label cFunc\n",
    "\n",
    "if latexExists:\n",
    "    ax.text(mBalLvl+0.02, cNrmFacBalLvl-0.10, r\"$\\nwarrow$\", fontsize=fsmid)\n",
    "    ax.text(mBalLvl+0.25, cNrmFacBalLvl-0.18, r\"$\\check{m}~$\", fontsize=fsmid)\n",
    "else:\n",
    "    ax.text(mBalLvl+0.02, cNrmFacBalLvl-0.10, r\"$\\nwarrow$\", fontsize=fsmid)\n",
    "    ax.text(mBalLvl+0.25, cNrmFacBalLvl-0.18, r\"$\\check{m}~$\", fontsize=fsmid)\n",
    "\n",
    "makeFig('GICModFailsButGICRawHolds')\n",
    "print('Finite mBalLvl but infinite mNrmFacTrgNrm')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "275b6019",
   "metadata": {},
   "source": [
    "In the [interactive dashboard](#interactive-dashboard), see what happens as changes in the time preference rate (or changes in risk $\\PermShkStd$) change the consumer from _normalized-growth-patient_ $(\\APFac > \\PermGroFac)$ to _normalized-growth-impatient_ ($\\APFac < \\PermGroFac$)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0faf2c15",
   "metadata": {},
   "source": [
    "As a foundation for the remaining figures, we define another instance of the class $\\texttt{IndShockConsumerType}$, which has the same parameter values as the instance $\\texttt{baseAgent}$ defined previously but is solved to convergence (our definition of an infinite horizon agent type) instead of only 100 periods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "421bc11f",
   "metadata": {},
   "source": [
    "`# Construct infinite horizon solution for consumer with baseline parameters:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e589f15f",
   "metadata": {
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Find the infinite horizon solution\n",
    "\n",
    "base_params['aXtraCount'] = base_params['aXtraCount'] * 20\n",
    "base_params['CubicBool'] = False\n",
    "base_params['cycles'] = 0  # Default for infinite horizon model\n",
    "\n",
    "baseAgent_Inf = IndShockConsumerType(\n",
    "    **base_params,\n",
    "    horizon='infinite',  # Infinite horizon\n",
    "    quietly=True, messaging_level=logging.CRITICAL)  # construct it silently"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5d14b30",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Expected Consumption Growth, and Permanent Income Growth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AnalysisoftheConvergedConsumptionFunction)\n",
    "\n",
    "$\\renewcommand{\\PermShk}{\\pmb{\\Psi}}$\n",
    "The next figure, [Analysis of the Converged Consumption Function](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#cNrmTargetFig), shows expected growth factors for the levels of consumption $\\cLvl$ and market resources $\\mLvl$ as a function of the market resources ratio $\\mNrm$ for a consumer behaving according to the converged consumption rule, along with the growth factor for $\\mNrm$ itself, and the (constant) growth factors for consumption and expected permanent income, $\\APFac$ and $\\PermGroFac$.\n",
    "\n",
    "The growth factor for consumption can be computed without knowing the _level_ of the consumer's permanent income:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\cLvl_{t+1}/\\cLvl_{t}] & = & \\Ex_{t}\\left[\\frac{\\pLvl_{t+1}\\cFunc(m_{t+1})}{\\pLvl_{t}\\cFunc(m_{t})}\\right] \\\\\n",
    "% & = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\pLvl_{t}}{\\pLvl_{t}}\\frac{\\cFunc(m_{t+1})}{\\cFunc(m_{t})}\\right] \\\\\n",
    "& = & \\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\cFunc(m_{t+1})}{\\cFunc(m_{t})}\\right]\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9b8db1",
   "metadata": {
    "tags": []
   },
   "source": [
    "and similarly the growth factor for the level of market resources is:\n",
    "\n",
    "\\begin{eqnarray*}\\renewcommand{\\PermShk}{\\pmb{\\Psi}}\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]\n",
    "& = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\mNrm_{t+1}} {\\mNrm_{t}} \\right]\n",
    "\\\\ & = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} (\\aNrm_{t}\\Rfree/(\\PermGroFac \\PermShk_{t+1}))+\\PermGroFac \\PermShk_{t+1}\\TranShk_{t+1}}\n",
    "{\\mNrm_{t}}\\right]\n",
    "\\\\ & = & \\Ex_{t}\\left[\\frac{\\PermGroFac (\\aNrm_{t}\\RNrm+\\PermShk_{t+1}\\TranShk_{t+1})}\n",
    "{\\mNrm_{t}}\\right]\n",
    "\\\\ & = & \\PermGroFac \\left[\\frac{\\aNrm_{t}\\RNrm+1}{\\mNrm_{t}}\\right]\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001f7b91",
   "metadata": {},
   "source": [
    "For the ratio $\\mNrm$ things are only slightly more complicated:\n",
    "\\begin{eqnarray*}\\renewcommand{\\PermShk}{\\pmb{\\Psi}}\n",
    "\\Ex_{t}[m_{t+1}]\n",
    "& = & \\Ex_{t}\\left[(m_{t}-c_{t})(\\Rfree/(\\PermShk_{t+1}\\PermGroFac)) +\\TranShk_{t+1}\\right]\\\\\n",
    "& = & a_{t}\\Rfree\\Ex_{t}\\left[(\\PermShk_{t+1}\\PermGroFac)^{-1}\\right] +1 \\\\\n",
    "\\Ex_{t}\\left[m_{t+1}/m_{t}\\right] & = & \\left(\\frac{a_{t}\\bar{\\RNrm}+1}{\\mNrm_{t}}\\right)\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb84d9c7",
   "metadata": {
    "tags": []
   },
   "source": [
    "<!-- The expectation of the growth in the log of $\\mLvl$ is a downward-adjusted value of the log of the growth factor:\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\log(\\mLvl_{t+1}/\\mLvl_{t})]\n",
    "& = & \\Ex_{t}\\left[\\log \\PermGroFac \\PermShk_{t+1} \\mNrm_{t+1}\\right] - \\log \\mNrm_{t}\n",
    "\\\\ & = & \\Ex_{t}\\left[\\log \\PermGroFac \\left(\\PermShk_{t+1} (\\aNrm_{t}\\Rfree/(\\PermGroFac \\PermShk_{t+1}))+\\PermShk_{t+1}\\TranShk_{t+1}\\right)\\right]-\\log \\mNrm_{t}\n",
    "\\\\ & = & \\Ex_{t}\\left[\\log \\PermGroFac (\\aNrm_{t}\\RNrm+\\PermShk_{t+1}\\TranShk_{t+1}+1-1)\\right] - \\log \n",
    "{\\mNrm_{t}}\n",
    "\\\\ & = & \n",
    "\\log \\left(\\PermGroFac \n",
    "(\\aNrm_{t}\\RNrm+1)\\Ex_{t}\\left[\\left(\n",
    "1+\\frac{\\PermShk_{t+1}\\TranShk_{t+1}-1}{(\\aNrm_{t}\\RNrm+1)}\n",
    "\\right)\n",
    "\\right]\\right) - \\log {\\mNrm_{t}}\n",
    "\\\\ & = & \\log \\underbrace{\\PermGroFac \\left[\\frac{\\aNrm_{t}\\RNrm+1}{\\mNrm_{t}}\\right]}_{\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]}+\n",
    "\\log \\Ex_{t}\\left[\\left(1+\n",
    "\\frac{\\PermShk_{t+1}\\TranShk_{t+1}-1}{(\\aNrm_{t}\\RNrm+1)}\n",
    "\\right)\n",
    "\\right]\n",
    "\\end{eqnarray*}\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97507f3f",
   "metadata": {},
   "source": [
    "`# Solve problem of consumer with baseline parameters:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15419151",
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Solve baseline parameters agent\n",
    "tweaked_params = deepcopy(base_params)\n",
    "tweaked_params['DiscFac'] = 0.970  # Tweak to make figure clearer\n",
    "baseAgent_Inf = IndShockConsumerType(\n",
    "    **tweaked_params, quietly=True, messaging_level=logging.CRITICAL)  # construct it silently\n",
    "\n",
    "baseAgent_Inf.solve(\n",
    "    quietly=False, messaging_level=logging.INFO)  # Solve it with info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98360c1f",
   "metadata": {
    "tags": []
   },
   "source": [
    "`# Plot growth factors for various model elements at steady state:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "266094be",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot growth rates\n",
    "\n",
    "soln = baseAgent_Inf.solution[0]\n",
    "\n",
    "# Built, parameters, expectations\n",
    "Bilt, Pars, E_Next_ = soln.Bilt, soln.Pars, soln.E_Next_\n",
    "\n",
    "# Retrieve parameters (makes code more readable)\n",
    "Rfree, DiscFac, CRRA, PermGroFac = \\\n",
    "    Pars.Rfree, Pars.DiscFac, Pars.CRRA, Pars.PermGroFac\n",
    "\n",
    "color_cons, color_mrktLev, color_mrktNrm, color_perm, color_mLogGroExp = \\\n",
    "    \"blue\", \"red\", \"green\", \"black\", \"orange\"\n",
    "\n",
    "mPlotMin, mCalcMax, mPlotMax = 1.0, 50, 1.8\n",
    "\n",
    "# Get steady state equilibrium and target values for m\n",
    "mBalLvl, mNrmFacTrg = Bilt.mBalLvl, Bilt.mTrgNrm\n",
    "\n",
    "pts_num = 200  # Plot this many points\n",
    "\n",
    "m_pts = np.linspace(mPlotMin, mPlotMax, pts_num)   # values of m for plot\n",
    "c_pts = soln.cFunc(m_pts)                   # values of c for plot\n",
    "a_pts = m_pts - c_pts                       # values of a\n",
    "\n",
    "# Get ingredients for calculating growth factors, then calculate them\n",
    "Ex_cLvl_tp1_Over_pLvl_t = [ \n",
    "    soln.E_Next_.cLvl_tp1_Over_pLvl_t_from_a_t(a) for a in a_pts]\n",
    "Ex_mLvl_tp1_Over_pLvl_t = [\n",
    "    soln.E_Next_.mLvl_tp1_Over_pLvl_t_from_a_t(a) for a in a_pts]\n",
    "Ex_mLog_tp1_minus_mLog_t_from_m_t = [\n",
    "    soln.E_Next_.mLog_tp1_minus_mLog_t_from_m_t(m) for m in m_pts]\n",
    "Ex_m_tp1_from_a_t = [\n",
    "    soln.E_Next_.m_tp1_from_a_t(a) for a in a_pts]\n",
    "\n",
    "Ex_cLvlGroFac = np.array(Ex_cLvl_tp1_Over_pLvl_t)/c_pts\n",
    "Ex_mLvlGroFac = np.array(Ex_mLvl_tp1_Over_pLvl_t)/m_pts\n",
    "Ex_mNrmGroFac = np.array(Ex_m_tp1_from_a_t)/m_pts\n",
    "# Exponentiated growth rate; not used but available for exploration\n",
    "Ex_mLogGroFac = np.exp(Ex_mLog_tp1_minus_mLog_t_from_m_t) \n",
    "\n",
    "# Absolute Patience Factor = lower bound of consumption growth factor\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APF\n",
    "APFac = Bilt.APFac\n",
    "\n",
    "# Init figure and axes\n",
    "fig, ax = plt.subplots(figsize=(12, 8))\n",
    "plt.rcParams['font.size'], plt.rcParams['font.weight'] = fsmid, 'bold'\n",
    "\n",
    "# Plot the Absolute Patience Factor line\n",
    "ax.plot([0, mPlotMax], [APFac, APFac], color=color_cons)\n",
    "\n",
    "# Plot the Permanent Income Growth Factor line\n",
    "ax.plot([0, mPlotMax], [PermGroFac, PermGroFac]    , color=color_perm)\n",
    "\n",
    "# Plot the expected consumption growth factor\n",
    "ax.plot(m_pts, Ex_cLvlGroFac        , color=color_cons)\n",
    "\n",
    "# Plot expected growth for the level of market resources\n",
    "ax.plot(m_pts, Ex_mLvlGroFac        , color=color_mrktLev)\n",
    "\n",
    "# Plot expected growth for the market resources ratio\n",
    "ax.plot(m_pts, Ex_mNrmGroFac        , color=color_mrktNrm)\n",
    "\n",
    "# To reduce clutter, the exponentiated log growth is left out\n",
    "#ax.plot(m_pts, Ex_mLogGroExp        , color=color_mLogGroExp)\n",
    "\n",
    "# Axes limits\n",
    "GroFacMin, GroFacMax, xMin = 0.976, 1.06, 1.1\n",
    "\n",
    "ax.set_xlim(xMin, mPlotMax * 1.1)\n",
    "ax.set_ylim(GroFacMin, GroFacMax)\n",
    "\n",
    "Thorn = u\"\\u00DE\"\n",
    "\n",
    "# If latex installed on system, plotting can look better\n",
    "if latexExists:\n",
    "    mNrmFacTrg_lbl = r'$1.00 = \\Ex_{t}[\\mNrm_{t+1}/\\mNrm_{t}]:~ \\Trg{m} \\rightarrow~~$'\n",
    "    PermGro_lbl = r\"$\\PermGroFac$\"\n",
    "    cLvlGroFac_lbl = r\"$\\Ex_{t}[\\cLvl_{t+1}/\\cLvl_{t}]$\"\n",
    "    mNrmGroFac_lbl = r\"$\\Ex_{t}[\\mNrm_{t+1}/\\mNrm_{t}] ^{\\nearrow}$\"\n",
    "    mLvlGroFac_lbl = r\"$\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]$\"\n",
    "    mBalLvl_lbl = r\"$\\check{\\mNrm}_{\\searrow}~$\"    \n",
    "    cLvlAPFac_lbl = r'$\\pmb{\\text{\\TH}} = (\\Rfree\\DiscFac)^{1/\\CRRA}$'\n",
    "else:\n",
    "    mNrmFacTrg_lbl = r'$\\mathsf{E}_{t}[m_{t+1}/m_{t}]:~ \\hat{m} \\rightarrow~~$'\n",
    "    PermGro_lbl = r\"$\\Phi$\"\n",
    "    cLvlGroFac_lbl = r\"$\\mathsf{E}_{t}[\\mathbf{c}_{t+1}/\\mathbf{c}_{t}]$\"\n",
    "    mNrmGroFac_lbl = r\"$\\mathsf{E}_{t}[m_{t+1}/m_{t}]^{\\nearrow}$\"\n",
    "    mLvlGroFac_lbl = r\"$\\mathsf{E}_{t}[\\mathbf{m}_{t+1}/\\mathbf{m}_{t}]$\"\n",
    "    mBalLvl_lbl = r\"$\\check{m}_{\\searrow}$\"    \n",
    "    cLvlAPFac_lbl = Thorn + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "\n",
    "\n",
    "if mNrmFacTrg:  # Do not try to plot it if it does not exist!\n",
    "    ax.text(mNrmFacTrg-0.01, 1.0-0.001, \n",
    "            mNrmFacTrg_lbl, ha='right')\n",
    "\n",
    "ax.plot(mBalLvl, G  , marker=\".\", markersize=12, color=\"black\")  # Dot at mBalLvl \n",
    "ax.plot(mNrmFacTrg, 1.0, marker=\".\", markersize=12, color=\"black\")  # Dot at mNrmFacTrg \n",
    "\n",
    "mLvlGroFac_lbl_xVal = mPlotMax\n",
    "mLvlGroFac_lbl_yVal = soln.E_Next_.mLvl_tp1_Over_mLvl_t(mLvlGroFac_lbl_xVal)\n",
    "\n",
    "mNrmGroFac_lbl_xVal = 0.92*mNrmFacTrg\n",
    "mNrmGroFac_lbl_yVal = soln.E_Next_.m_tp1_Over_m_t(mNrmGroFac_lbl_xVal)\n",
    "\n",
    "ax.text(mPlotMax+0.01, G-0.001,PermGro_lbl)\n",
    "ax.text(mPlotMax+0.01, Ex_cLvlGroFac[-1]  ,cLvlGroFac_lbl)\n",
    "ax.text(mPlotMax+0.01, APFac-0.001       ,cLvlAPFac_lbl)\n",
    "ax.text(mBalLvl-0.06, G+0.001,mBalLvl_lbl              ,va='bottom',ha='left')\n",
    "ax.text(mNrmGroFac_lbl_xVal-0.01, mNrmGroFac_lbl_yVal-0.003,mNrmGroFac_lbl,va='bottom',ha='right')\n",
    "ax.text(mLvlGroFac_lbl_xVal+0.01, mLvlGroFac_lbl_yVal+0.001,mLvlGroFac_lbl,va='top')\n",
    "\n",
    "# Ticks\n",
    "ax.tick_params(labelbottom=True, labelleft=True, left='off', right='on', bottom='on', top='off')\n",
    "plt.setp(ax.get_yticklabels(), fontsize=fssml)\n",
    "\n",
    "# Label the mNrmFacTrg with vertical lines\n",
    "plt.axvline(x=mNrmFacTrg,label='Individual Target', linestyle='dotted')\n",
    "plt.legend()\n",
    "ax.set_ylabel('Growth Factors')\n",
    "makeFig('cNrmTargetFig')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00f13e4",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Consumption Function Bounds](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AnalysisOfTheConvergedConsumptionFunction)\n",
    "[The next figure](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#cFuncBounds)\n",
    "illustrates theoretical bounds for the consumption function.\n",
    "\n",
    "We define two useful variables: the lower bound of $\\tilde{\\MPC}$ (marginal propensity to consume) and the limit of $h$ (Human wealth), along with some functions such as the limiting perfect foresight consumption function $\\bar{c}(m)$, the upper bound function $\\bar{\\bar c}(m)$, and the lower bound function $\\tilde{c}$(m)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d5c9978",
   "metadata": {
    "tags": []
   },
   "source": [
    "`# Define bounds for figure:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dfff6c1",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define mpc_Min, h_inf and PF consumption function, upper and lower bound of c function\n",
    "\n",
    "# construct and solve it silently\n",
    "baseAgent_Inf = IndShockConsumerType(**base_params, quietly=True, messaging_level=logging.CRITICAL)\n",
    "baseAgent_Inf.solve(quietly=True, messaging_level=logging.CRITICAL)  # Solve it with info\n",
    "soln = baseAgent_Inf.solution[0]\n",
    "\n",
    "UnempPrb = Pars.IncShkDstn.parameters['UnempPrb']\n",
    "\n",
    "# Return Patience Factor\n",
    "RPFacRaw = ((Rfree * DiscFac)**(1.0/CRRA)/Rfree)\n",
    "RPFac = baseAgent_Inf.solution[0].Bilt.RPFac\n",
    "\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCminDefn\n",
    "mpc_Min = 1.0-RPFac \n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCmaxDefn\n",
    "mpc_Max = 1.0 - (UnempPrb**(1/CRRA)) * RPFac\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#hNrmDefn\n",
    "h_inf = (1.0/(1.0-PermGroFac/Rfree))\n",
    "\n",
    "def cFunc_Uncnst(m): return mpc_Min * m + (h_inf - 1) * mpc_Min\n",
    "def cFunc_TopBnd(m): return mpc_Max * m\n",
    "def cFunc_BotBnd(m): return mpc_Min * m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b80dd9f",
   "metadata": {},
   "source": [
    "`# Plot figure showing bounds`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ab17a0",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot the consumption function and its bounds\n",
    "cMaxLabel = r'$\\overline{c}(m)= (m-1+h)\\tilde{\\kappa}$'\n",
    "cMinLabel = r'Lower Bound: $\\tilde{c}(m)= (1-\\pmb{\\text{\\TH}}_{\\mathsf{R}})\\tilde{\\kappa}m$'\n",
    "if not latexExists:\n",
    "    cMaxLabel = r'$\\bar{c}(m) = (m-1+h)\\kappa$'  # Use unicode kludge\n",
    "    cMinLabel = r'Lower Bound: c̲$(m)= (1-$'+Thorn+r'$_{\\mathsf{R}})m = \\kappa m$'\n",
    "#    cMinLabel = r'Lower Bound: c̲$(m)= (1-$'+   ''+r'$_{\\mathsf{R}})m = \\kappa m$'\n",
    "    cLvlAPFac_lbl = Thorn + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "#    cLvlAPFac_lbl = ' ' + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "\n",
    "    \n",
    "mPlotMin = 0.0\n",
    "mPlotMax = 25\n",
    "# mKnk is point where the two upper bounds meet\n",
    "mKnk = ((h_inf-1) * mpc_Min)/((1 - UnempPrb**(1.0/CRRA)*(Rfree*DiscFac)**(1.0/CRRA)/Rfree)-mpc_Min)\n",
    "mBelwKnkPts = 300\n",
    "mAbveKnkPts = 700\n",
    "mBelwKnk = np.linspace(mPlotMin, mKnk, mBelwKnkPts)\n",
    "mAbveKnk = np.linspace(mKnk, mPlotMax, mAbveKnkPts)\n",
    "mFullPts = np.linspace(mPlotMin, mPlotMax, mBelwKnkPts+mAbveKnkPts)\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "cTopMult = 1.12\n",
    "plt.plot(mFullPts, soln.cFunc(mFullPts), color=\"black\")\n",
    "plt.plot(mBelwKnk, cFunc_Uncnst(mBelwKnk), color=\"black\", linestyle=\"--\")\n",
    "plt.plot(mAbveKnk, cFunc_Uncnst(mAbveKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mBelwKnk, cFunc_TopBnd(mBelwKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mAbveKnk, cFunc_TopBnd(mAbveKnk), color=\"black\", linestyle=\"--\")\n",
    "plt.plot(mBelwKnk, cFunc_BotBnd(mBelwKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mAbveKnk, cFunc_BotBnd(mAbveKnk), color=\"black\", linewidth=2.5)\n",
    "plt.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "                right='off', bottom='off', top='off')\n",
    "plt.xlim(mPlotMin, mPlotMax)\n",
    "plt.ylim(mPlotMin, cTopMult*cFunc_Uncnst(mPlotMax))\n",
    "plt.text(mPlotMin, cTopMult*cFunc_Uncnst(mPlotMax)+0.05, \"$c$\", fontsize=22)\n",
    "plt.text(mPlotMax+0.1, mPlotMin, \"$m$\", fontsize=22)\n",
    "plt.text(2.5, 1, r'$c(m)$', fontsize=22, fontweight='bold')\n",
    "upper_upper_bound_m = 4.6\n",
    "\n",
    "if latexExists:\n",
    "    upper_upper_bound_m_lbl = r'$\\leftarrow \\overline{\\overline{c}}(m)= \\overline{\\MPC}m = (1-\\UnempPrb^{1/\\CRRA}\\pmb{\\text{\\TH}}_{\\mathsf{R}})m$'\n",
    "else:\n",
    "    upper_upper_bound_m_lbl = r'$\\overline{\\overline{c}}(m)= \\overline{\\kappa}m = (1-\\wp^{1/\\rho}$'+Thorn+r'$_{\\mathsf{R}})m$'\n",
    "#    upper_upper_bound_m_lbl = r'$\\overline{\\overline{c}}(m)= \\overline{\\kappa}m = (1-\\wp^{1/\\rho}$'+   ''+r'$_{\\mathsf{R}})m$'\n",
    "    \n",
    "plt.text(upper_upper_bound_m+0.6, cFunc_TopBnd(upper_upper_bound_m+0.5), \n",
    "             upper_upper_bound_m_lbl,\n",
    "             fontsize=22, fontweight='bold')\n",
    "\n",
    "upper_bound_m = 12\n",
    "upper_bound_m_lbl=r'Upper Bound $ = $ Min $[\\overline{\\overline{c}}(m),\\overline{c}(m)]$'\n",
    "plt.text(upper_bound_m, cFunc_Uncnst(upper_bound_m)-0.3, upper_bound_m_lbl, fontsize=22, fontweight='bold')\n",
    "plt.text(8, 0.9, cMinLabel, fontsize=22, fontweight='bold')\n",
    "lower_unc_bound_m = 1.7\n",
    "lower_unc_bound_c = cFunc_Uncnst(lower_unc_bound_m)-0.2\n",
    "plt.text(lower_unc_bound_m, lower_unc_bound_c-0.2, cMaxLabel, fontsize=22, fontweight='bold')\n",
    "plt.arrow(2.45, 1.05, -0.5, 0.02, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(lower_unc_bound_m, lower_unc_bound_c, -0.5, 0.1, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(upper_bound_m, cFunc_Uncnst(upper_bound_m)-0.2, -0.8, 0.05, head_width=0.1, width=0.015,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "unconst_m = 4.5\n",
    "plt.arrow(14, 0.70, 0.5, -0.1, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "\n",
    "makeFig('cFuncBounds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86734840",
   "metadata": {},
   "source": [
    "### [Upper and Lower Limits of the Marginal Propensity to Consume](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCLimits)\n",
    "\n",
    "The paper shows that as $m_{t}~\\uparrow~\\infty$ the consumption function in the presence of risk gets arbitrarily close to the perfect foresight consumption function.  Defining $\\tilde{κ}$\n",
    "as the perfect foresight model's MPC, this implies that $\\lim_{m_{t}~\\uparrow~\\infty} c^{\\prime}(m) = \\tilde{\\kappa}$.\n",
    "\n",
    "The paper also derives an analytical limit $\\bar{\\MPC}$ for the MPC as $m$ approaches 0., its bounding value.  Strict concavity of the consumption function implies that the consumption function will be everywhere below a function $\\bar{\\MPC}m$, and strictly declining everywhere.  The last figure plots the MPC between these two limits."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c09778",
   "metadata": {},
   "source": [
    "`# Make and plot figure showing the upper and lower limits of the MPC:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64eeb897",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The last figure shows the upper and lower limits of the MPC\n",
    "\n",
    "mPlotMin = 0\n",
    "mPlotMax = 8\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "# Set the plot range of m\n",
    "m = np.linspace(0.001, mPlotMax, mPts)\n",
    "\n",
    "# Use the HARK method derivative to get the derivative of cFunc, and which constitutes the MPC\n",
    "MPC = soln.cFunc.derivative(m)\n",
    "\n",
    "kappaDef = r'$\\tilde{\\kappa}\\equiv(1-\\pmb{\\text{\\TH}}_{\\mathsf{R}})$'\n",
    "if not latexExists:\n",
    "    kappaDef = r'κ̲$\\equiv(1-$'+Thorn+'$_{\\mathsf{R}})$'\n",
    "\n",
    "plt.plot(m, MPC, color='black')\n",
    "plt.plot([mPlotMin, mPlotMax], [mpc_Max, mpc_Max], color='black')\n",
    "plt.plot([mPlotMin, mPlotMax], [mpc_Min, mpc_Min], color='black')\n",
    "plt.xlim(mPlotMin, mPlotMax)\n",
    "plt.ylim(0, 1)  # MPC bounds are between 0 and 1\n",
    "\n",
    "if latexExists:\n",
    "    plt.text(1.5, 0.6, r'$\\MPC(m) \\equiv c^{\\prime}(m)$', fontsize=26, fontweight='bold')\n",
    "    plt.text(5, 0.87, r'$(1-\\UnempPrb^{1/\\CRRA}\\pmb{\\text{\\TH}}_{\\mathsf{R}})\\equiv \\overline{\\MPC}$',\n",
    "             fontsize=26, fontweight='bold')  # Use Thorn character\n",
    "else:\n",
    "    plt.text(1.5, 0.6, r'$\\kappa(m) \\equiv c^{\\prime}(m)$', fontsize=26, fontweight='bold')\n",
    "    plt.text(5, 0.87, r'$(1-\\wp^{1/\\rho}$'+Thorn+'$_{R})\\equiv \\bar{\\kappa}$',\n",
    "             fontsize=26, fontweight='bold')  # Use Phi instead of Thorn (alas)\n",
    "\n",
    "plt.text(0.5, 0.07, kappaDef, fontsize=26, fontweight='bold')\n",
    "plt.text(mPlotMax+0.05, mPlotMin, \"$m$\", fontsize=26)\n",
    "plt.arrow(1.45, 0.61, -0.4, mPlotMin, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(2.2, 0.07, 0.2, -0.01, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(4.95, 0.895, -0.2, 0.03, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "\n",
    "makeFig('MPCLimits')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b5b93c",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "[Two tables in the paper](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Factors-Defined-And-Compared) summarize the various definitions, and then articulate conditions required for the problem to have a nondegenerate solution.  Among the nondegenerate cases, the most interesting result is that if the Growth Impatience Condition holds there will be a target level of wealth."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cf64536",
   "metadata": {
    "heading_collapsed": "true",
    "tags": []
   },
   "source": [
    "### Appendix: Options for Interacting With This Notebook <a id='optionsForInstalling'></a>\n",
    "\n",
    "1. [View (static version)](https://nbviewer.org/github/econ-ark/BufferStockTheory/blob/master/BufferStockTheory.ipynb)\n",
    "1. [Launch Online Interactive Version](https://econ-ark.org/materials/bufferstocktheory?launch)\n",
    "1. For fast (local) execution, install [econ-ark](http://github.com/econ-ark) on your computer ([QUICK START GUIDE](https://github.com/econ-ark/HARK/blob/master/README.md)) then follow these instructions to retrieve the full contents of the `BufferStockTheory` [REMARK](https://github.com/econ-ark/BufferStockTheory):\n",
    "   1. At a command line, change the working directory to the one where you want to install\n",
    "       * On unix, if you install in the `/tmp` directory, the installation will disappear after a reboot:\n",
    "       * `cd /tmp`\n",
    "   1. `git clone https://github.com/econ-ark/BufferStockTheory`\n",
    "   1. `cd BufferStockTheory`\n",
    "   1. `jupyter lab BufferStockTheory.ipynb`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c32ea74",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Appendix: Perfect foresight agent failing both the FHWC and RIC\n",
    "\n",
    "An appendix shows the solution for the problem of a perfect foresight consumer whose parameters fail to satisfy both the FHWC and the RIC\n",
    "\n",
    "[Perfect Foresight Liquidity Constrained Solution](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#ApndxLiqConstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "081ea8bd",
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "PFGICRawHoldsFHWCFailsRICFails_par = deepcopy(init_perfect_foresight)\n",
    "\n",
    "# Replace parameters.\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['Rfree'] = 0.98\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['DiscFac'] = 1.0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['PermGroFac'] = [0.99]\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['CRRA'] = 2\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['BoroCnstArt'] = 0.0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['T_cycle'] = 1  # No seasonal cycles\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['T_retire'] = 0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['cycles'] = 400  # This many periods\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['MaxKinks'] = 400\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['quiet'] = False\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['BoroCnstArt'] = 0.0  # Borrowing constraint\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['LivPrb'] = [1.0]\n",
    "\n",
    "# Create the agent\n",
    "HWRichButReturnPatientPFConstrainedAgent = \\\n",
    "    PerfForesightConsumerType(**PFGICRawHoldsFHWCFailsRICFails_par,\n",
    "                              quietly=True\n",
    "                              )\n",
    "# Solve and report on conditions\n",
    "this_agent = HWRichButReturnPatientPFConstrainedAgent\n",
    "this_agent.solve(quietly=False, messaging_level=logging.DEBUG)\n",
    "\n",
    "# Plot\n",
    "mPlotMin, mPlotMax = 1, 9.5\n",
    "plt.figure(figsize=(8, 4))\n",
    "m_grid = np.linspace(mPlotMin, mPlotMax, 500)\n",
    "plt.plot(m_grid-1, this_agent.solution[0].cFunc(m_grid), color=\"black\")\n",
    "plt.text(mPlotMax-1+0.05, 1, r\"$b$\", fontsize=26)\n",
    "plt.text(mPlotMin-1, 1.017, r\"$c$\", fontsize=26)\n",
    "plt.xlim(mPlotMin-1, mPlotMax-1)\n",
    "plt.ylim(mPlotMin, 1.016)\n",
    "\n",
    "makeFig('PFGICRawHoldsFHWCFailsRICFails')"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "ExecuteTime,collapsed,tags,pycharm,jupyter,slideshow,jp-MarkdownHeadingCollapsed,heading_collapsed,-autoscroll",
   "cell_metadata_json": true,
   "encoding": "# -*- coding: utf-8 -*-",
   "formats": "ipynb,py:percent",
   "notebook_metadata_filter": "all,-widgets,-varInspector"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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.10.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": false,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}