Total derivatives in economics - The case of the indifference curve.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Click the button below if you want to see the code behind the widgets. If you do click  and want to go back to the 'no-code' view, scroll down until you find the 'hide code' button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "MIT License\n",
    "\n",
    "Copyright (c) 2020 Sylvain Barde - University of Kent\n",
    "\n",
    "Permission is hereby granted, free of charge, to any person obtaining a copy\n",
    "of this software and associated documentation files (the \"Software\"), to deal\n",
    "in the Software without restriction, including without limitation the rights\n",
    "to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
    "copies of the Software, and to permit persons to whom the Software is\n",
    "furnished to do so, subject to the following conditions:\n",
    "\n",
    "The above copyright notice and this permission notice shall be included in all\n",
    "copies or substantial portions of the Software.\n",
    "\n",
    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
    "IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
    "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
    "AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
    "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
    "OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
    "SOFTWARE.\n",
    "\"\"\"\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits import mplot3d\n",
    "from matplotlib import cm\n",
    "from matplotlib.colors import ListedColormap\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import rcParams\n",
    "from IPython.display import display, HTML\n",
    "\n",
    "javascript_functions = {False: \"hide()\", True: \"show()\"}\n",
    "button_descriptions  = {False: \"Click to show code\", True: \"Click to hide code\"}\n",
    "\n",
    "def toggle_code(state):\n",
    "    \"\"\"\n",
    "    Toggles the JavaScript show()/hide() function on the div.input element.\n",
    "    \"\"\"\n",
    "\n",
    "    output_string = \"<script>$(\\\"div.input\\\").{}</script>\"\n",
    "    output_args   = (javascript_functions[state],)\n",
    "    output        = output_string.format(*output_args)\n",
    "\n",
    "    display(HTML(output))\n",
    "    \n",
    "def button_action(value):\n",
    "    \"\"\"\n",
    "    Calls the toggle_code function and updates the button description.\n",
    "    \"\"\"\n",
    "    state = value.new\n",
    "\n",
    "    toggle_code(state)\n",
    "\n",
    "    value.owner.description = button_descriptions[state]\n",
    "\n",
    "\n",
    "def utility_widget(curve_init = 'CD', a_init = 0.5, xMin_init = 0, xMax_init = 10, xVal_init = 5, yVal_init = 5, \n",
    "                      elev_init = 30, azim_init = 290, zCut_init = False):\n",
    "    \n",
    "    # Declare widgets for interactive input\n",
    "    curve_list = widgets.Dropdown(options=['CD'],\n",
    "                                value = curve_init,\n",
    "                                description='function:',\n",
    "                                disabled=False)\n",
    "    a_slider = widgets.FloatSlider(min=0,\n",
    "                                 max=1,\n",
    "                                 step=0.1,\n",
    "                                 description=r'$\\alpha$:',\n",
    "                                 value = a_init,\n",
    "                                 continuous_update =False)\n",
    "    xMin_slider = widgets.IntSlider(min=-100,\n",
    "                                 max=0,\n",
    "                                 step=1,\n",
    "                                 description=r'Min. $x$,$y$:',\n",
    "                                 value = xMin_init,\n",
    "                                 continuous_update =False)    \n",
    "    xMax_slider = widgets.IntSlider(min=0,\n",
    "                                 max=100,\n",
    "                                 step=1,\n",
    "                                 description=r'Max. $x$,$y$:',\n",
    "                                 value = xMax_init,\n",
    "                                 continuous_update =False)\n",
    "    xVal_slider = widgets.FloatSlider(min=-100,\n",
    "                                 max=100,\n",
    "                                 step=1,\n",
    "                                 description=r'$x$ coord:',\n",
    "                                 value = xVal_init,\n",
    "                                 continuous_update =False)\n",
    "    yVal_slider = widgets.FloatSlider(min=-100,\n",
    "                                 max=100,\n",
    "                                 step=1,\n",
    "                                 description=r'$y$ coord:',\n",
    "                                 value = yVal_init,\n",
    "                                 continuous_update =False)\n",
    "    elev_slider = widgets.FloatSlider(min=-90,\n",
    "                                 max=90,\n",
    "                                 description= 'Elevation:',\n",
    "                                 value = elev_init,\n",
    "                                 continuous_update =False)\n",
    "    azim_slider = widgets.FloatSlider(min=0,\n",
    "                                 max=360,\n",
    "                                 description= 'Azimuth:',\n",
    "                                 value = azim_init,\n",
    "                                 continuous_update =False)\n",
    "    zCut_check = widgets.Checkbox(value = zCut_init,\n",
    "                                   description='Fix $U$',\n",
    "                                   disabled=False,\n",
    "                                   indent=True)    \n",
    "    \n",
    "    # Link widgets as required\n",
    "    widgets.jslink((xMax_slider,'value'),(xVal_slider,'max'))\n",
    "    widgets.jslink((xMin_slider,'value'),(xVal_slider,'min'))\n",
    "    widgets.jslink((xMax_slider,'value'),(yVal_slider,'max'))\n",
    "    widgets.jslink((xMin_slider,'value'),(yVal_slider,'min'))\n",
    "    \n",
    "    def utility_plot(curve, a, xMin, xMax, xVal, yVal, elev, azim , zCut):\n",
    "\n",
    "        fundict = {'CD': lambda x, y: (x**a)*(y**(1-a)),\n",
    "                  }\n",
    "        fundictAlt = {'CD': lambda x, z: (x**(-a/(1-a)))*(z**(1/(1-a))),\n",
    "                  }\n",
    "\n",
    "        f = fundict[curve]\n",
    "        fAlt = fundictAlt[curve]\n",
    "\n",
    "        res = 50\n",
    "        xFull = np.linspace(1e-3, xMax, res)\n",
    "        yFull = np.linspace(1e-3, xMax, res)\n",
    "        XFull, YFull = np.meshgrid(xFull, yFull)\n",
    "        ZFull = f(XFull, YFull)\n",
    "\n",
    "        zVal = f(xVal, yVal)\n",
    "        zMax = max(ZFull.flatten())\n",
    "\n",
    "        if zCut is True:\n",
    "            resZ = int(np.floor((zVal/zMax)*res))\n",
    "            z = np.linspace(0, zVal, resZ)\n",
    "            zCover = (zVal/zMax)\n",
    "            viridis = cm.get_cmap('viridis', 512)\n",
    "            myCmap = ListedColormap(\n",
    "                       viridis(np.linspace(0, zCover, 256))\n",
    "                       )\n",
    "        else:\n",
    "            z = np.linspace(0, zMax, res)\n",
    "            myCmap = 'viridis'\n",
    "\n",
    "        X, Z = np.meshgrid(xFull, z)\n",
    "        Y = fAlt(X, Z)\n",
    "                \n",
    "        Y = np.clip(Y,0,xMax)\n",
    "        Z = f(X,Y)\n",
    "        \n",
    "        # Create figure\n",
    "        mrkrSize = 2*rcParams['lines.markersize'] ** 2\n",
    "        fig = plt.figure(figsize=(20,10))\n",
    "\n",
    "        # Plot 3D utility function\n",
    "        ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "        ax.plot_surface(X, Y, Z, cmap=myCmap)\n",
    "        \n",
    "        if zCut is True:\n",
    "            xIC = X[-1,:]\n",
    "            yIC = Y[-1,:]\n",
    "            zIC = Z[-1,:]\n",
    "            maskIC = yIC < xMax\n",
    "            ax.plot3D(xIC[maskIC], yIC[maskIC], zIC[maskIC], 'r', linewidth=2)\n",
    "            \n",
    "        ax.plot3D([xVal], [yVal], [f(xVal, yVal)], marker = 'o', color = 'r', zorder = 5)\n",
    "\n",
    "        ax.set_xlim(xMin,xMax)\n",
    "        ax.set_ylim(xMin,xMax)\n",
    "        ax.set_zlim(0,1.5*zMax)\n",
    "        ax.view_init(elev, azim)\n",
    "        ax.set_xlabel(r'$x$', fontdict = {'fontsize': 25},position=(1, 0))\n",
    "        ax.set_ylabel(r'$y$', fontdict = {'fontsize': 25},position=(0, 1))\n",
    "        ax.set_zlabel(r'$U(x,y)$', fontdict = {'fontsize': 25},position=(0, 1), rotation=0)\n",
    "        \n",
    "        # Plot Indifference curve map\n",
    "        ax = fig.add_subplot(1, 2, 2)\n",
    "        numIC = 6\n",
    "        zStepVec = np.linspace(zMax/numIC, zMax-1/numIC, numIC)\n",
    "        for zStep in zStepVec:\n",
    "            ax.plot(xFull, fAlt(xFull, zStep), 'k--', alpha=0.3)\n",
    "        \n",
    "        if zCut is True:\n",
    "            zCurr = f(xVal,yVal)\n",
    "            ax.plot(xFull, fAlt(xFull, zCurr), 'r', linewidth=2, alpha=0.6,\n",
    "                    label=r'Current indifference curve')\n",
    "\n",
    "        # Add markers for the price/quantity points, with dotted lines\n",
    "        ax.scatter(xVal, yVal, s=mrkrSize, c='k', alpha=0.6,\n",
    "                    label='Selection')\n",
    "        ax.plot([0,xVal],[yVal,yVal],'r--',linewidth=1)\n",
    "        ax.plot([xVal,xVal],[0,yVal],'r--',linewidth=1)\n",
    "\n",
    "        ax.autoscale(enable=True, axis='both', tight=True)\n",
    "        ax.set_ylim(top = xMax, bottom = 0)\n",
    "        ax.set_xlim(right = xMax, left = 0)\n",
    "        ax.spines['top'].set_visible(False)\n",
    "        ax.spines['right'].set_visible(False)\n",
    "        ax.set_xlabel(r'$x$', fontdict = {'fontsize': 25},position=(1, 0))\n",
    "        ax.set_ylabel(r'$y$', fontdict = {'fontsize': 25},position=(0, 1), rotation=0)\n",
    "        ax.plot(1, 0, \">k\", transform=ax.get_yaxis_transform(), clip_on=False)\n",
    "        ax.plot(0, 1, \"^k\", transform=ax.get_xaxis_transform(), clip_on=False)\n",
    "        ax.tick_params(labelsize=20)\n",
    "        \n",
    "        plt.tight_layout()\n",
    "\n",
    "    out = widgets.interactive_output(utility_plot, {'curve': curve_list,\n",
    "                                                       'a': a_slider,\n",
    "                                                       'xMin': xMin_slider,\n",
    "                                                       'xMax': xMax_slider,\n",
    "                                                       'xVal': xVal_slider,\n",
    "                                                       'yVal': yVal_slider,\n",
    "                                                       'elev': elev_slider,\n",
    "                                                       'azim': azim_slider,\n",
    "                                                       'zCut': zCut_check})\n",
    "        \n",
    "    output = widgets.VBox([out,\n",
    "                  widgets.HBox([curve_list,\n",
    "                                a_slider]),\n",
    "                  widgets.HBox([xMin_slider,\n",
    "                                xMax_slider,\n",
    "                                xVal_slider,\n",
    "                                yVal_slider]),\n",
    "                  widgets.HBox([elev_slider, \n",
    "                                azim_slider,\n",
    "                                zCut_check])\n",
    "                          ])\n",
    "    display(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>$(\"div.input\").hide()</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "940e10b547b24a6ab611798036574b15",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='Click to show code')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "state = False\n",
    "toggle_code(state)\n",
    "\n",
    "button = widgets.ToggleButton(state, description = button_descriptions[state])\n",
    "button.observe(button_action, \"value\")\n",
    "\n",
    "display(button)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utility functions, indifference curves and total derivatives\n",
    "\n",
    "This notebook will illustrate multivariate functions and total derivatives in the context of the utility function. This is because maximisation of utility subject to a given bugdet is a standard problem that students in economics learn at some point in their training, and we will be looking at this next week.\n",
    "\n",
    "The notebook therefore lays the ground a bit for the stuff we'll see next week. It also allows us to see a neat application of the total derivative of the utility function, in that it allows us to easily find the slope of the indifference curves, a problem which might otherwise be tricky to solve.\n",
    "\n",
    "\n",
    "#### Utility as a multivariate function\n",
    "\n",
    "The utility function of a consumer is the function that tells us how much *utility* (i.e. satisfaction) they get from consuming a 'basket' or various goods: for example, it will tell you how much satisfaction you might get from going out for a Nando's with some friends, followed by a movie with popcorn. At first glance, this seems like a silly concept: we can all agree that you might derive satisfaction from this basket, but how on earth can this be *measured*?\n",
    "\n",
    "The answer comes from the **marginal** approach to economics we saw in last week's notebooks: we don't need to be able to measure it, we only need to know if it increases or falls. So for our 'night out' example, you might not be able to tell me **how much satisfaction** you get from that Nando's + movie + popcorn bundle, but you'll definitely be able to tell me if it increases or falls if I replace the popcorn with nachos. Clearly, everybody has different preferences, so we all have different utility functions, but we should all be able to rank those alternatives.\n",
    "\n",
    "The plot on the left below shows a very specific type of multivariate utility function, often referred to as a 'Cobb-Douglas' function after the name of the two economists who came up with it. The nice thing about this function is that preferences are governed by a single parameter. While this may seem very simplistic, it turns out that in a lot of cases this works pretty well, which is why the function is popular. Given the consumption of two quantities of goods $x$ and $y$, the utility is given by: \n",
    "\n",
    "$$U(x,y) = x^\\alpha y^{1-\\alpha}$$\n",
    "\n",
    "We have a function that accepts 2 inputs ($x$ and $y$) and returns a quantity, utility, hence the 3D plot. Here $\\alpha$ is the parameter that governs the relative preference for goods $x$ and $y$. The closer $\\alpha$ is to 1, the more you prefer $x$ relative to $y$. The reverse is true the closer $\\alpha$ is close to 0. Feel free to modify this parameter in the widget to see its impact on the shape of the utility function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9be3e143a77b4acca0c02e8b3c111f61",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), HBox(children=(Dropdown(description='function:', options=('CD',), value='CD'), FloatS…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "utility_widget()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indifference curves: a 2D map of a 3D function.\n",
    "\n",
    "While the 3D plot can be helpful for visualising or understanding how the function works, it is also useful to be able to represent the function in 2 dimensions. After all, you can't easily print in 3 dimensions on the page of a book...\n",
    "\n",
    "This is where indifference curves come in: If you select a value for $x$ and a value for $y$, the level of utility achieved is displayed with a red point on our utility function. Selecting the 'Fix $U$' will take a slice of the utility function along the vertical axis passing through that point. The red intersection that is revealed shows all the points in the utility function that have the same level of utility as the point itself.\n",
    "\n",
    "The key idea is the same as for the 3D diagrams shown in the videos on multivariate functions: if you take a slice of a 3D function along any axis, the intersection is a univariate function that can be represented in 2D. We already did this for derivatives, when we fixed $x$ or $y$ to reveal a univariate function we could differentiate more easily. The only difference here is that we're taking a slice along the $z$ axis. This curve, shown in red in the diagram on the right, is called an ***indifference curve***. This is because by construction, all the combinations of $x$ and $y$ on that line provide the same utility (we fixed $U$, remember) therefore you are indifferent between them.\n",
    "\n",
    "By changing your selection for $x$ and $y$, you can move about and generate many different indifference curves, each one showing a different level of utility. Such a collection is called an **indifference map**, and the result is the same as for regular maps. As you can see below, altitude is recorded on a regular map in the same way, using a set of contour lines to show locations that share the same altitude. \n",
    "\n",
    "![Contours on a map](https://getoutside.ordnancesurvey.co.uk/site/uploads/images/2018champs/Blog%20imagery/advanced_contours_guide_streams.jpg)\n",
    "\n",
    "#### The slope of the indifference curve using the total derivative of the utility function.\n",
    "\n",
    "So we now have a bunch of curves that can be used to represent a 3D function in two dimensions. They are smooth, and they are non-linear, so they should each have a slope given by a derivative. The question is, how do we calculate these derivative? We don't have an equation for these indifference curves! Furthermore, there are potentially an infinite number of indifference curves, which complicates the problem a bit.\n",
    "\n",
    "**Why** we need the slope of the utility function is something I will explain at the end. Right now, I want to focus on showing **how** to calculate it. This is where the concept of total derivative comes in very handy. So looking back at your lecture notes, you will remember that the total derivative of the utility function is:\n",
    "\n",
    "$${\\rm d}U(x,y) = \\frac{\\partial U(x,y)}{\\partial x}{\\rm d}x \\; + \\; \\frac{\\partial U(x,y)}{\\partial y}{\\rm d}y$$\n",
    "\n",
    "The first thing we can do is replace the partial derivatives w.r.t. $x$ and $y$ by the economic concept of marginal utility. This is the increase in utility, or satisfaction, that you experience if you consume a tiny bit more of $x$ or $y$. This will simplify the notation a bit by getting rid of the partial derivative notation:\n",
    "\n",
    "$${\\rm d}U(x,y) = mU_x{\\rm d}x \\; + \\; mU_y{\\rm d}y$$\n",
    "\n",
    "The important step is to realise that on a given indifference curve, the total amount of utility you experience is constant. Again, remember we generated the indifference curves by slicing the function along the $z$ axis, in other words by keeping utility constant. This means that on an indifference curve, we have ${\\rm d}U(x,y) = 0$ by construction. This tells us that on all indifference curves we have:\n",
    "\n",
    "$$mU_x{\\rm d}x \\; + \\; mU_y{\\rm d}y = 0$$\n",
    "\n",
    "All we have to do now is rearrange the expression to get the slope of the indifference curve that passes through $any$ point we choose on the diagram:\n",
    "\n",
    "$$ mU_y{\\rm d}y \\; = \\; - mU_x{\\rm d}x$$\n",
    "\n",
    "$$ \\frac{{\\rm d}y}{{\\rm d}x} \\; = \\; - \\frac{mU_x}{mU_y}$$\n",
    "\n",
    "What we see is that the slope of an indifference curve at a given point is equal to the ratio of marginal utilities at that point. This makes empirical sense: imagine you are consuming two goods $x$ and $y$, if I reduce the amount of $x$ you have by one unit, you will lose a bit of satisfaction. Suppose I offer to compensate you by giving you more of good $y$ instead. How much do I need to give you? well that depends on how much you value good $y$ relative to good $x$. If you value $y$ a **lot**, then I don't need to give you much more $y$ to offset the loss of $x$. If instead you **don't** like $y$ very much, I'd have to give you a lot more $y$ to make up the loss in $x$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wrapping up...\n",
    "\n",
    "This example was designed to illustrate how powerful total derivatives are when used effectively. The key aspect here is that we have found a formula for the derivative of the indifference curve:\n",
    "- Without picking a specific indifference curve. In fact, the formula works for all indifference curves!\n",
    "- Without having an equation for an indifference curve.\n",
    "- Without much work at all. Just two little lines to re-arrange.\n",
    "\n",
    "Another purpose was to provide a little bit of an introduction to the framework economists use when modeling how agents (consumers in this case) make their choices according to their preferences. We will be looking at this next week, and this is where we will see why know the slope of an indifference curve is important. As we will discover, once you add the fact that consumers have a limited budget and can therefore only pick baskets of goods they can afford, figuring out which is the best basket to pick will depend in great part on the ratio of marginal utilities for that basket, i.e. the slope of the indifference curve. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}