ProblemSets/PS4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Set 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1. Tauchen Method\n",
    "\n",
    "Tauchen method is the simplest method to discretize an AR(1) process. An AR(1) process has the form\n",
    "\n",
    "$$\n",
    "x_{t} = \\rho x_{t-1} + \\epsilon_{t}\n",
    "$$\n",
    "\n",
    "where $\\epsilon$ follows Normal distribution with standard deviation $\\sigma$.\n",
    "\n",
    "For discrete dynamic programming, it is usually useful to discretize the continuous AR(1) process. We need two ingredients: 1) the points (the states) on the finite state space; and 2) the transition probabilities between each pair of the states. Check the related pdf file.\n",
    "\n",
    "For the rest of this question, we assume that $\\rho = 0.95$ and $\\sigma = 0.01$. We choose $m=4$ and $N=15$ for the process (see both of these definitions in the pdf file)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1.1 Coding Tauchen method up\n",
    "Define a function for Tauchen method that returns the finite state space and the transition matrix. (If you checked some references for this one please mention them)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1.2 Simulation and check the statistics\n",
    "Now you have a discretized Markov Chain for this continuous AR(1) process. Randomly simulate this process for 1000 periods by setting the state of the first period as 8 (since we have 15 states and they are symmetric, the starting period would be 0). For the sample chain you got, compute the 1) autocorrelation of the realizations; 2) the unconditional variance of the process. What do you find?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q2. A Modified RBC model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We think about a model with the so-called \"investment cost shock\" instead of the usual TFP shock that we have. This question solves a drastically simplified version of Justiniano, Primiceri, and Tambalotti (2011).\n",
    "\n",
    "Consider a representative agent that lives forever. Time is discrete. The agent wishes to maximize the expectation of discounted sum of utility,\n",
    "\n",
    "$$\n",
    "\\max_{\\left\\{ c_{t}\\right\\} }\\mathbb{E}\\left[\\sum_{t=0}^{\\infty}\\beta^{t}u\\left(c_{t}\\right)\\right]\n",
    "$$\n",
    " \n",
    "This agent owns capital $k_t$ at the beginning of time period $t$, and produce some final output following a production function $y=f\\left(k\\right)$. She can choose to consume or to invest the final output, therefore, facing a budget constraint\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "c_{t}+i_{t} & \\leqslant y_{t}\\\\\n",
    "y_{t} & =f\\left(k_{t}\\right)\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "There's an investment cost shock, denoted as $z$. $z$ is a discrete, exogenous Markov process. And the capital accumulates following\n",
    "\n",
    "$$\n",
    "k_{t+1}=\\left(1-\\delta\\right)k_{t}+\\exp\\left(z_{t}\\right)i_{t}\n",
    "$$\n",
    "\n",
    "The difference between this model and the classical RBC model that we covered in class is that the shock is no longer scaling the production function, but rather on the investment that agents choose."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2.1 The Bellman equation\n",
    "\n",
    "Write down the Bellman equation of this problem. As you Markovize this problem, you can denote the variables at time $t$ as $c,i,k,y,z$, and the variables at time $t+1$ as $c',i', k', y', z'$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2.2 Solve the problem\n",
    "\n",
    "We assume some functional forms and parameter values. $u\\left(c\\right)=\\log\\left(c\\right)$, $f\\left(k\\right)=k^{\\alpha}$. For the parameters,\n",
    "\n",
    "| Parameter | Value |\n",
    "|-----------|-------|\n",
    "| $\\alpha$  | 0.33  |\n",
    "| $\\beta$   | 0.96  |\n",
    "| $\\delta$  | 0.1   |\n",
    "\n",
    "And $z$ follows a 3-state Markov chain,\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "z & =\\left[-0.02,0,0.02\\right]\\\\\n",
    "P & =\\left[\\begin{array}{ccc}\n",
    "0.8 & 0.15 & 0.05\\\\\n",
    "0.1 & 0.8 & 0.1\\\\\n",
    "0.05 & 0.15 & 0.8\n",
    "\\end{array}\\right]\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "Solve the value function (hint: the state variables are the same as what we did in the class -- both $z$ and $k$. You can probably use the same grid of capital that we did in class). Describe the economic intuition behind it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}