Solow Steady State.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Das Solow-Modell\n",
    "\n",
    "Das Solow Modell ist einfaches Modell, das die langfristige Entwicklung einer geschlossenen Volkswirtschaft beschreibt.\n",
    "\n",
    "## Produktion und Produktion pro Kopf\n",
    "Das Solow-Modell basiert auf einer aggregierten Produktionsfunktion $Y$ mit den Inputfaktoren Kapital $K$ und Arbeit $N$:\n",
    "\\begin{align}\n",
    "Y=F(K,N)\n",
    "\\end{align}\n",
    "Die aggregierte Produktionsfunktion hat per Annahme folgende Eigenschaften:\n",
    "* positive, aber fallende Grenzerträge: eine Erhöhung eines einzelnen Inputfaktors führt immer zu mehr Output führt. Dieser Zuwachs wird aber kleiner, je mehr vom von diesem Faktor bereits verwendet wird.\n",
    "    * mathematisch: $\\frac{\\partial Y}{\\partial K}>0$, $\\frac{\\partial Y}{\\partial N}>0$, $\\frac{\\partial^2 Y}{\\partial K^2}<0$, $\\frac{\\partial^2 Y}{\\partial N^2}<0$\n",
    "* konstante Skalenerträge: einer Verdoppelung beides Inputfaktoren führt zu einer Verdoppelung der Produktion.\n",
    "    * mathematisch: $F(x\\cdot K,x\\cdot N)=x\\cdot F(K,N)$\n",
    "\n",
    "Eine einfache Produktionsfunktion, die beide Eigenschaften erfüllt, ist die Cobb-Douglas Produktionsfunktion:\n",
    "\n",
    "$$Y=F(K,N)=K^\\alpha N ^{1-\\alpha}$$\n",
    "\n",
    "Der Parameter $\\alpha\\in(0,1)$ ist die Elastizität des Output bezüglich des Kapitals und gibt an, um wie viel Prozent der Output steigt, wenn das Kapital um einen Prozent erhöht wird.\n",
    "\n",
    "In der Regel betrachten wir die Volkswirtschaft im Solow Modell aber nicht in aggregierten Einheiten sondern in pro-Kopf (bzw. pro-Arbeiter) Einheiten an.\n",
    "Dazu definieren wir\n",
    "* Kapital pro Arbeiter: $k=\\frac{K}{N}$ und wird als Kapitalintensität bezeichnet\n",
    "* Output pro Arbeiter: $y=\\frac{Y}{N}$\n",
    "\n",
    "Berechnen wir den Output pro Arbeiter ergibt sich\n",
    "\\begin{align}\n",
    "y   &=\\frac{Y}{N}&\\\\\n",
    "    &=\\frac{1}{N}F(K,N)                       & \\text{konstante Skalenerträge: }F(x\\cdot K,x\\cdot N)=x\\cdot F(K,N) \\text{ für } x=\\frac{1}{N}\\\\\n",
    "    &=F\\left(\\frac{1}{N}K,\\frac{1}{N}N\\right) &\\\\\n",
    "    &=F(k,1) &\n",
    "\\end{align}\n",
    "\n",
    "Da das zweite Argument $(1)$ fix ist, schreiben wir der Einfachheit halber $y=F(k,1)=f(k)$.\n",
    "Der Output pro Arbeiter hängt also nur von der Kapitalintensität ab.\n",
    "Für das Beispiel der Cobb-Douglas-Funktion mit $F(K,N)=K^{\\alpha}N^{1-\\alpha}$ ergibt sich\n",
    "\n",
    "\\begin{align}\n",
    "y=f(k) = F(k,1)= k^\\alpha 1^{1-\\alpha}=k^\\alpha.\n",
    "\\end{align}\n",
    "\n",
    "Um ein Gefühl für aggregierte Produktionsfunktion und Output pro Kopf zu bekommen, betrachten wir die folgenden Grafiken.\n",
    "In der linken Grafik wird die aggregierte Produktionsfunktion dargestellt, in der rechten der Output pro Kopf.\n",
    "Sie können den Parameter $\\alpha$ über einen Regler verändern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from ipywidgets import interactive\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits import mplot3d\n",
    "\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "from matplotlib import cm\n",
    "\n",
    "plt.rcParams['figure.figsize'] = [24/2.54, 18/2.54] # Größe der Grafik anpassen\n",
    "plt.rcParams['font.size']=12 # Schriftgröße"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "95ec7c4143804c04932193bc701a383b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.4, description='$\\\\alpha$', max=1.0, step=0.05), Output()), _dom_cla…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(alpha):\n",
    "    fig = plt.figure(figsize=plt.figaspect(0.5))\n",
    "    \n",
    "    ax = fig.add_subplot(1, 2, 1, projection='3d')\n",
    "\n",
    "    K=np.linspace(start=0, stop=10) # mögliche Werte für K\n",
    "    N=np.linspace(start=0, stop=10) # mögliche Werte für N\n",
    "    K, N = np.meshgrid(K, N)\n",
    "    Y= np.multiply(K**(alpha) , N**(1-alpha)) # Berechne Output, a**b bedeutet a^b\n",
    "    y_int = K[1,:]**(alpha)\n",
    "    cont = ax.plot_wireframe(K, N, Y, rstride=10, cstride=10)\n",
    "    ax.plot3D(K[1,:],np.ones_like(K[1,:]), y_int,'red')\n",
    "\n",
    "    ax.set_xlabel('Kapital')\n",
    "    ax.set_ylabel('Arbeit')\n",
    "    ax.set_zlabel('Output')\n",
    "    ax.view_init(15, -135)\n",
    "    \n",
    "    ax = fig.add_subplot(1, 2, 2)\n",
    "    k = np.geomspace(0.0001, 10, num=50) # mögliche Werte für Kapitalintensität\n",
    "    y = k**alpha # Output pro Arbeiter\n",
    "    \n",
    "    ax.plot(k, y,'red')\n",
    "    ax.set_xlabel('Kapitalintensität')\n",
    "    ax.set_ylabel('Output pro Arbeiter')\n",
    "    ax.axis(ymin=0, ymax=4)\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "interactive_plot = interactive(f, # Name der Funktion, die die Grafik erstellt\n",
    "                               # Slider für die Inputs der Grafik-Funktion\n",
    "                               alpha=widgets.FloatSlider(value=0.4, description='$\\\\alpha$',\n",
    "                                                            max=1, min=0, step=0.05) \n",
    "                              )\n",
    "\n",
    "output = interactive_plot.children[-1]\n",
    "interactive_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zum Üben gibt es hier einige vertiefende Aufgaben.\n",
    "\n",
    "### Vertiefende Aufgaben\n",
    "1. Zeigen Sie, dass die Cobb-Douglas Produktionsfunktion $Y=K^\\alpha N^{1-\\alpha}$ in der Tat positive und fallende Grenzerträge und konstante Skalenerträge aufweist.\n",
    "2. Wie verändert sich die (Cobb-Douglas) Produktionsfunktion, wenn $\\alpha$ nahe oder bei 0 bzw. 1 liegt? Wie hoch sind die Grenzerträge von Arbeit und Kapital in beiden Fällen? Nutzen Sie dazu die interaktiven Grafiken!\n",
    "3. Zeigen Sie, das $\\alpha$ die Elastizität des Outputs bezüglich des Kapitals ist: $\\varepsilon_{Y,K}=\\frac{\\partial Y}{\\partial K}/\\frac{Y}{K}=\\alpha$.\n",
    "4. Wie ist die Elastizität des Outputs bezüglich des Kapitals zu interpretieren? Was sagt Ihnen ein Wert von $\\alpha=0.4$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Veränderung des Kapitalstocks\n",
    "\n",
    "Bis jetzt haben wir uns angeschaut, wie die Volkswirtschaft in einer einzelnen Periode produziert.\n",
    "Zu jedem Zeitpunkt können wir die Volkswirtschaft anhand des Kapitalstocks und der Arbeiter beschreiben.\n",
    "Jetzt wollen wir verschiedene Perioden mit einigen einfachen Regeln für die Entwicklung von Kapitalstock und Arbeitern miteinander verbinden.\n",
    "Um zu verdeutlichen, von welcher Periode wir sprechen, verwenden wir den Zeitindex $t$, ob $t$ für Monate oder Jahre steht ist nicht wichtig. Unter Verwendung von Zeitindizes lautet\n",
    "\n",
    "* die aggregierte Produktionsfunktion $Y_t=K_t^\\alpha N_t^{1-\\alpha}$\n",
    "* der Output pro Kopf $y_t=k_t^\\alpha$\n",
    "\n",
    "Für den Moment nehmen wir an, dass die Anzahl der Arbeiter konstant ist, also gilt $N_t=N$.\n",
    "Wir lockern diese Annahme später, für den Einstieg macht sie uns das Leben aber deutlich einfacher.\n",
    "\n",
    "\n",
    "Wir nehmen an, dass ein fixer Anteil $\\delta\\in(0,1)$ (auch Abnutzungsrate) des Kapitalstocks jedes Jahr abgenutzt wird, also kaputt geht. Im nächsten Jahr ist also noch ein Anteil von $(1-\\delta)$ des alten Kapitalstocks vorhanden.\n",
    "Wir nehmen an, dass die Volkswirtschaft geschlossen ist.\n",
    "Die gesamtwirtschaftliche Ersparnis entspricht also den gesamtwirtschaftlichen Investitionen.\n",
    "Wir nehmen an, dass ein konstanter Anteil $s\\in(0,1)$ (auch Sparquote) des Einkommens gespart bzw. investiert wird.\n",
    "Das bedeutet, dass die Investitionen $I_t=sY_t$ betragen, der Rest des Einkommens wird konsumiert.\n",
    "Die Änderung des aggregierten Kapitalstocks $\\Delta K_{t+1}=K_{t+1}-K_t$ ist also gleich der Investitionen abzüglich der Abnutzung:\n",
    "\n",
    "\\begin{align}\n",
    "\\Delta K_{t+1}=sY_t-\\delta K_t\n",
    "\\end{align}\n",
    "\n",
    "Die Änderung der Kapitalintensität (Kapital pro Arbeiter) können wir berechnen, indem wir durch $N$ teilen:\n",
    "\n",
    "\\begin{align}\n",
    "\\Delta k_{t+1} &=\\frac{\\Delta K_{t+1}}{N}\\\\\n",
    "               &=\\frac{sY_t-\\delta K_t}{N}\\\\\n",
    "               &=s\\frac{Y_t}{N}-\\delta\\frac{K_t}{N}\\\\\n",
    "               &=sy_t-\\delta k_t\n",
    "\\end{align}\n",
    "\n",
    "Die Änderung der Kapitalintensität ist also gleich der Investitionen je Arbeiter abzüglich der Abnutzung.\n",
    "Wenn wir auf beiden Seiten $k_t$ abziehen, bekommen wir eine einfache Gleichung, mit der wir den Kapitalstock der nächsten Periode berechnen können:\n",
    "\n",
    "\\begin{align}\n",
    "\\Delta k_{t+1}=k_{t+1}-k_t&=sy_t-\\delta k_t & +k_t\\\\\n",
    "        k_{t+1}&=(1-\\delta)k_t+sy_t\n",
    "\\end{align}\n",
    "\n",
    "Wir haben gesehen, dass für den Spezialfall der Cobb-Douglas Produktionsfunktion gilt: $y_t=f(k_t)=k_t^\\alpha$.\n",
    "Damit können wir $k_{t+1}$ genauer beschreiben:\n",
    "\n",
    "\\begin{align}\n",
    "        k_{t+1}&=(1-\\delta)k_t+sk_t^\\alpha\n",
    "\\end{align}\n",
    "\n",
    "Mit dieser einfachen Rechenregel können wir für eine gegebene Kapitalintensität heute $k_t$ die Kapitalintensität morgen $k_{t+1}$ berechnen. Wie sich die Kapitalintensität für verschiedene Startwerte $k_0$ entwickelt, zeigt die folgende Grafik.\n",
    "Die Parameter für die Outputelastizität des Kapitals $\\alpha$, die Abnutzungsrate $\\delta$ und die Sparquote $s$ können Sie über Schieberegler verändern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17274e77449948af9fd91fe92f17d3be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.4, description='$\\\\alpha$', max=0.95, min=0.05, step=0.05), FloatSli…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(alpha, delta, savr):\n",
    "    max_time=50\n",
    "    t = np.arange(0,max_time,1) # Zeitpunkte\n",
    "    n_paths=20\n",
    "    k = np.zeros((n_paths,max_time))\n",
    "\n",
    "    k[:,0] = np.linspace(start=0, stop=10, num=n_paths) # verschiedene Anfangswerte für Kapitalintensität\n",
    "\n",
    "    k_star=(savr/delta)**(1/(1-alpha))\n",
    "    \n",
    "    for tt in t[1:max_time]: # loop über alle Zeitpunkte außer 0\n",
    "        y=k[:,tt-1]**alpha\n",
    "        k[:,tt] = (1-delta)*k[:,tt-1]+savr*y\n",
    "\n",
    "        \n",
    "    plt.plot(k.T)\n",
    "    plt.annotate('$k^*$',(max_time-0.5,k_star),)\n",
    "    plt.ylim(0,10)\n",
    "    plt.ylabel('Kapitalintensität')\n",
    "    plt.xlabel('Zeit t')\n",
    "    plt.show()\n",
    "    \n",
    "interactive_plot = interactive(f, # Name der Funktion, die die Grafik erstellt\n",
    "                               # Slider für die Inputs der Grafik-Funktion\n",
    "                               alpha=widgets.FloatSlider(value=0.4, description='$\\\\alpha$',max=0.95, min=0.05, step=0.05),\n",
    "                               delta=widgets.FloatSlider(value=0.4, description='$\\\\delta$',max=0.95, min=0.05, step=0.05), \n",
    "                               savr=widgets.FloatSlider(value=0.4, description='$s$',max=0.95, min=0.05, step=0.05)\n",
    "                              )\n",
    "\n",
    "output = interactive_plot.children[-1]\n",
    "interactive_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Grafik zeigt, dass sich unabhängig die Kapitalintensität unabhängig vom Startwert im Laufe der Zeit gegen einen (bestimmten) langfristigen Wert $k^*$ konvergiert.\n",
    "Die einzige Ausnahme ist der Spezialfall $k_0=0$. In diesem Fall gibt es zu Beginn gar kein Kapital, wodurch nichts produziert und damit gespart werden kann.\n",
    "Die Kapitalintensität steckt in diesem Fall für immer bei $k_t=0$ fest.\n",
    "Für alle anderen Startwerte stellt sich Laufe der Zeit eine bestimmte langfristige Kapitalintensität $k^*$ ein.\n",
    "Wie wir diese bestimmen können und wie diese von den Parametern abhängt ist das Thema des nächsten Kapitels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Steady State\n",
    "Wir haben gesehen, dass sich im Solow-Modell unabhängig vom aktuellen Kapitalstock $k_t$ langfristig eine Kapitalintensität $k^*$ einstellt. Diesen Wert bezeichnen wir auch als Steady State Kapitalintensität. Das gleiche gilt für den Output pro Kopf, der gegen $y^*$ konvergiert. Im Folgenden wollen wir diese Kapitalintensität bestimmen.\n",
    "Im Steady State ist die Kapitalintensität konstant, die Änderung also per Definition 0.\n",
    "\\begin{align}\n",
    "\\Delta k_{t+1}=0&= sy^*-\\delta k^*         &   y^*=(k^*)^\\alpha\\\\\n",
    "                &= s(k^*)^\\alpha-\\delta k^*\n",
    "\\end{align}\n",
    "\n",
    "In dieser Gleichung gibt es nur eine Unbekannte, nämlich die Steady State Kapitalintensität $k^*$, nach der wir auflösen:\n",
    "\n",
    "\\begin{align}\n",
    "k^* = \\left(\\frac{s}{\\delta} \\right)^\\frac{1}{1-\\alpha}\n",
    "\\end{align}\n",
    "\n",
    "Für gegebene Parameter können wir also nun die Steady State Kapitalintensität berechnen.\n",
    "Inwiefern die Politik diese Parameter beeinflussen kann, und ob es einen \"optimalen\" Steady State gibt, ist das Thema des nächsten Kapitels. \n",
    "Um die Inhalte aus diesem Kapitel zu wiederholen, können Sie folgende vertiefende Aufgaben lösen:\n",
    "\n",
    "### Vertiefende Aufgaben\n",
    "1. Leiten Sie aus der aggregierten Produktionsfunktion und der Veränderung des aggregierten Kapitalstocks die entsprechende Intensitätsform, also Produktion und Veränderung des Kapitalstocks je Arbeiter, her.\n",
    "2. Zeigen Sie, dass für die Steady State Kapitalintensität gilt $k^*=\\left(\\frac{s}{\\delta}\\right)^{\\frac{1}{1-\\alpha}}$\n",
    "3. Nutzen Sie die interaktive Grafik, um herauszufinden, wie Sparrate $s$, Outputelastizität bezüglich des Kapitals $\\alpha$ und Abnutzungsrate $\\delta$ die langfristige Kapitalintensität $k^*$ beeinflussen.\n",
    "4. Überprüfen Sie Ihre Ergebnisse, indem Sie zeigen, dass die ersten Ableitungen der langfristigen Kapitalintensität wie folgt nach den Parametern wie folgt lauten:\n",
    "    1. Ableitung nach der Sparquote $s$: $$\\frac{\\partial k^*}{\\partial s}=\\frac{1}{s}\\cdot\\frac{1}{1-\\alpha}k^*>0$$\n",
    "    2. Ableitung nach der Abnutzungsrate $\\delta$: $$\\frac{\\partial k^*}{\\partial \\delta}=-\\frac{1}{\\delta}\\cdot\\frac{1}{1-\\alpha}\\cdot k^*<0$$\n",
    "    3. Ableitung nach der Outputelastizität bezüglich des Kapitals $\\alpha$: $$\\frac{\\partial k^*}{\\partial \\alpha}=\\ln\\left(\\frac{s}{\\delta}\\right)\\cdot \\frac{1}{(1-\\alpha)^2}\\cdot k^*$$\n",
    "5. Unter welcher Bedingung ist die Ableitung $\\frac{\\partial k^*}{\\partial \\alpha}$ positiv bzw. negativ? Warum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Die Goldene Regel\n",
    "Im letzten Kapitel haben wir die Steady State Kapitalintensität hergeleitet:\n",
    "$k^* = \\left(\\frac{s}{\\delta} \\right)^\\frac{1}{1-\\alpha}$.\n",
    "Per Definition ergeben sich damit\n",
    "1. der Output pro Arbeiter im Steady State $y^*=f(k^*)=\\left(\\left(\\frac{s}{\\delta}\\right)^{\\frac{1}{1-\\alpha}}\\right)^{\\alpha}=\\left(\\frac{s}{\\delta}\\right)^{\\frac{\\alpha}{1-\\alpha}}$ und \n",
    "2. Kosum pro Arbeiter im Steady State $c^*=(1-s)\\cdot y^*=(1-s)\\cdot \\left(\\frac{s}{\\delta}\\right)^{\\frac{\\alpha}{1-\\alpha}}$\n",
    " \n",
    "Der Steady Konsum pro Arbeiter hängt also nur von den Parametern (und nicht dem ursprünglichen Kapitalstock $k_0$) ab.\n",
    "\n",
    "Von den Parametern ist an dieser Stelle die Sparquote von besonderem Interesse, da sie (per Annahme) durch Politikmaßnahmen,\n",
    "z.B. Sparanreizen, beeinflusst werden kann. \n",
    "Daher stellt sich die Frage, ob es eine optimale Sparquote gibt, die den Steady State Konsum pro Kopf maximiert. \n",
    "Mathematisch handelt es sich bei dieser Sparquote um die Lösung für das Optimierungsproblem\n",
    "$$\\max_s c^*=(1-s)\\cdot \\left(\\frac{s}{\\delta}\\right)^{\\frac{\\alpha}{1-\\alpha}}$$\n",
    "Wir können uns dieses Optimierungsproblem auch grafisch veranschaulichen.\n",
    "Dargestellt sind Output pro Kopf $y_t=k_t^{\\alpha}$, Abnutzung pro Kopf $\\delta k_t$ und Ersparnis pro Kopf $sk_t^\\alpha$\n",
    "Der Konsum im Steady State ist in rot eingetragen und ist gleich der Differenz aus Output pro Kopf und Ersparnis pro Kopf im Steady State.\n",
    "Für den Moment ist nur der Regler für die Sparquote interessant. Verändern Sie diesen, wird der Steady State Konsum berechnet. Wenn Sie hier $s=\\alpha$ einstellen, wird der Steady State Konsum maximal und entspricht der Goldenen Regel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "25593e07e79d4f24bf5e4670646d738f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.3, description='$\\\\alpha$', max=0.4, step=0.01), FloatSlider(value=0…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f(alpha, delta, sav_r): # was soll mit den Werten aus den Widgets passieren\n",
    "    plt.figure(2)\n",
    " \n",
    "    k = np.geomspace(0.0001, 100, num=100) # Kapitalintensität\n",
    "    \n",
    "    output = k**(alpha) # Output/Kopf k^alpha\n",
    "    depreciation = k * delta # Abschreibung/Abnutzung\n",
    "    saving = output * sav_r # Ersparnis\n",
    "\n",
    "    # Steady State\n",
    "    ss_k = (sav_r/delta)**(1/(1-alpha)) # Kapitalintensität\n",
    "    ss_y = ss_k ** alpha # Output\n",
    "    ss_s = ss_y * sav_r # Ersparnis\n",
    "    \n",
    "    # Golden Rule\n",
    "    gr_s=alpha # Sparquote nach der goldenen Regel\n",
    "    gr_k=(gr_s/delta)**(1/(1-alpha)) # Kapitalintensität nach der goldenen Regel\n",
    "    gr_y=gr_k**alpha # Output nach der goldenen Regel\n",
    "    gr_s=gr_s*gr_y # Ersparnisse/Investitionen nach der goldenen Regel\n",
    "\n",
    "    plt.plot([ss_k,ss_k],[ss_y, ss_s],marker='o', markersize=1, color=\"red\") # zeichne Konsum im Steady State ein\n",
    "    plt.annotate('Steady State Konsum',(ss_k+1,0.5*(ss_y+ss_s)),)\n",
    "\n",
    "    plt.plot([gr_k,gr_k],[gr_y, gr_s],marker='o', markersize=1, color=\"black\") # zeichne Konsum im Steady State ein\n",
    "    plt.annotate('Goldene Regel Konsum',(gr_k+1,gr_s-0.125),)\n",
    "    \n",
    "    outp, = plt.plot(k, output, label='Output')\n",
    "    abnu, = plt.plot(k, depreciation, label='Abnutzung')\n",
    "    savi, = plt.plot(k, saving, label='Ersparnis')\n",
    "    \n",
    "    plt.ylim(0, 5)\n",
    "    plt.xlim(k[0],k[-1])\n",
    "    plt.xlabel('Kapitalintensität')\n",
    "    plt.ylabel('Euro pro Kopf')\n",
    "    plt.legend(handles=[outp, abnu, savi], bbox_to_anchor=(0,1.02,1,0.2), loc=\"lower left\",mode=\"expand\",ncol=3,frameon=False)\n",
    "#    plt.grid()\n",
    "    plt.show()\n",
    "    \n",
    "interactive_plot = interactive(f, # Name der Funktion, die die Grafik erstellt\n",
    "                               # Slider für die Inputs der Grafik-Funktion\n",
    "                               alpha=widgets.FloatSlider(value=0.3, description='$\\\\alpha$', max=0.4, min=0, step=0.01), \n",
    "                               delta=widgets.FloatSlider(value=0.05, description='$\\\\delta$', max=0.1, min=0.01, step=0.01),\n",
    "                               sav_r=widgets.FloatSlider(value=0.5, description='$s$', max=1, min=0, step=0.05),\n",
    "                              )\n",
    "\n",
    "output = interactive_plot.children[-1]\n",
    "#output.layout.height = '350px'\n",
    "interactive_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für jede Parameterkombination ist der Steady State Konsum die Strecke zwischen Steady State Investition/Abnutzung und Output.\n",
    "Die schwarze Strecke ist der Steady State Konsum nach der Goldenen Regel, also der maximale Steady State Konsum, der durch Variation der Sparrate erreicht werden kann. Es lässt sich zeigen, dass für diese Sparquote gilt \n",
    "$$s_g=\\alpha.$$\n",
    "\n",
    "## Vertiefende Aufgaben\n",
    "1. Lösen Sie das Optimierungsproblem $\\max_s c^*=(1-s)\\cdot\\left(\\frac{s}{\\delta}\\right)^{\\frac{\\alpha}{1-\\alpha}}$ und zeigen Sie, dass $s_{g}=\\alpha$.\n",
    "2. Bestimmen Sie die Steady State Kapitalintensität, den Output und den Konsum nach der Goldenen Regel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<details>\n",
       "<summary>Click to view session information</summary>\n",
       "<pre>\n",
       "-----\n",
       "ipywidgets          7.6.5\n",
       "matplotlib          3.5.2\n",
       "mpl_toolkits        NA\n",
       "numpy               1.21.5\n",
       "session_info        1.0.0\n",
       "-----\n",
       "</pre>\n",
       "<details>\n",
       "<summary>Click to view modules imported as dependencies</summary>\n",
       "<pre>\n",
       "PIL                         9.2.0\n",
       "backcall                    0.2.0\n",
       "cffi                        1.15.1\n",
       "colorama                    0.4.5\n",
       "cycler                      0.10.0\n",
       "cython_runtime              NA\n",
       "dateutil                    2.8.2\n",
       "debugpy                     1.5.1\n",
       "decorator                   5.1.1\n",
       "defusedxml                  0.7.1\n",
       "entrypoints                 0.4\n",
       "ipykernel                   6.15.2\n",
       "ipython_genutils            0.2.0\n",
       "jedi                        0.18.1\n",
       "jupyter_server              1.18.1\n",
       "kiwisolver                  1.4.2\n",
       "matplotlib_inline           0.1.6\n",
       "mkl                         2.4.0\n",
       "nt                          NA\n",
       "ntsecuritycon               NA\n",
       "packaging                   21.3\n",
       "parso                       0.8.3\n",
       "pickleshare                 0.7.5\n",
       "pkg_resources               NA\n",
       "prompt_toolkit              3.0.20\n",
       "psutil                      5.9.0\n",
       "pydev_ipython               NA\n",
       "pydevconsole                NA\n",
       "pydevd                      2.6.0\n",
       "pydevd_concurrency_analyser NA\n",
       "pydevd_file_utils           NA\n",
       "pydevd_plugins              NA\n",
       "pydevd_tracing              NA\n",
       "pygments                    2.11.2\n",
       "pyparsing                   3.0.9\n",
       "pythoncom                   NA\n",
       "pywintypes                  NA\n",
       "ruamel                      NA\n",
       "six                         1.16.0\n",
       "sphinxcontrib               NA\n",
       "storemagic                  NA\n",
       "tornado                     6.1\n",
       "traitlets                   5.1.1\n",
       "wcwidth                     0.2.5\n",
       "win32api                    NA\n",
       "win32com                    NA\n",
       "win32security               NA\n",
       "zmq                         23.2.0\n",
       "zope                        NA\n",
       "</pre>\n",
       "</details> <!-- seems like this ends pre, so might as well be explicit -->\n",
       "<pre>\n",
       "-----\n",
       "IPython             7.31.1\n",
       "jupyter_client      7.3.4\n",
       "jupyter_core        4.11.1\n",
       "jupyterlab          3.4.4\n",
       "notebook            6.4.12\n",
       "-----\n",
       "Python 3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]\n",
       "Windows-10-10.0.22621-SP0\n",
       "-----\n",
       "Session information updated at 2023-01-24 11:33\n",
       "</pre>\n",
       "</details>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import session_info\n",
    "\n",
    "session_info.show()\n",
    "#%load_ext watermark\n",
    "\n",
    "# python, ipython, packages, and machine characteristics\n",
    "#%watermark -v -m -p ipywidgets,matplotlib,numpy,watermark \n",
    "\n",
    "# date\n",
    "#print (\" \")\n",
    "#%watermark -u -n -t -z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}