tax_smooth.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7b970d95",
   "metadata": {},
   "source": [
    "# Tax Smoothing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de169fa",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "This  is a sister lecture to our  lecture on [consumption-smoothing](https://intro.quantecon.org/cons_smooth.html).\n",
    "\n",
    "By renaming variables, we  obtain  a a version of a model “tax-smoothing model” that  Robert Barro [[Barro, 1979](https://intro.quantecon.org/zreferences.html#id168)] used  to explain why governments sometimes choose not to balance their budgets every period but instead use issue debt to smooth tax rates over time.\n",
    "\n",
    "The government chooses a tax collection path that minimizes the present value of its costs of raising revenue.\n",
    "\n",
    "The government minimizes those costs by smoothing  tax collections  over time and by issuing government debt during temporary surges in government expenditures.\n",
    "\n",
    "The present value of government expenditures is at the core of the tax-smoothing model,\n",
    "so we’ll again use formulas presented in [present value formulas](https://intro.quantecon.org/pv.html).\n",
    "\n",
    "We’ll again use the matrix multiplication and matrix inversion tools that we used in  [present value formulas](https://intro.quantecon.org/pv.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fe2473",
   "metadata": {},
   "source": [
    "## Analysis\n",
    "\n",
    "As usual, we’ll start by importing some Python modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "483c4aa8",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import namedtuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9687861b",
   "metadata": {},
   "source": [
    "A government exists at times $ t=0, 1, \\ldots, S $ and  faces an exogenous stream of expenditures $ \\{G_t\\}_{t=0}^S $.\n",
    "\n",
    "It chooses  chooses a stream of tax collections $ \\{T_t\\}_{t=0}^S $.\n",
    "\n",
    "The model takes a government expenditure stream as an “exogenous” input that is somehow determined  outside the model.\n",
    "\n",
    "The government faces a gross interest rate of $ R >1 $ that is constant over time.\n",
    "\n",
    "The government can borrow or lend at interest rate $ R $, subject to some limits on the amount of debt that it can issue  that we’ll describe below.\n",
    "\n",
    "Let\n",
    "\n",
    "- $ S \\geq 2 $  be a positive integer that constitutes a time-horizon.  \n",
    "- $ G = \\{G_t\\}_{t=0}^S $ be a sequence of government expenditures.  \n",
    "- $ B = \\{B_t\\}_{t=0}^{S+1} $ be a sequence of government debt.  \n",
    "- $ T = \\{T_t\\}_{t=0}^S $ be a sequence of tax collections.  \n",
    "- $ R \\geq 1 $ be a fixed gross one period interest rate.  \n",
    "- $ \\beta \\in (0,1) $ be a fixed discount factor.  \n",
    "- $ B_0 $ be a given initial level of government debt  \n",
    "- $ B_{S+1} \\geq 0 $  be a terminal condition.  \n",
    "\n",
    "\n",
    "The sequence of government debt $ B $ is to be determined by the model.\n",
    "\n",
    "We require it to satisfy two **boundary conditions**:\n",
    "\n",
    "- it must equal an exogenous value $ B_0 $ at time $ 0 $  \n",
    "- it must equal or exceed an exogenous value $ B_{S+1} $ at time $ S+1 $.  \n",
    "\n",
    "\n",
    "The **terminal condition** $ B_{S+1} \\geq 0 $   requires that the government  not end up with negative assets.\n",
    "\n",
    "(This no-Ponzi condition ensures that the government  ultimately pays off its debts – it can’t simply roll them over indefinitely.)\n",
    "\n",
    "The government faces a sequence of budget constraints that constrain sequences $ (G, T, B) $\n",
    "\n",
    "\n",
    "<a id='equation-eq-b-t'></a>\n",
    "$$\n",
    "B_{t+1} = R (B_t + G_t - T_t), \\quad t =0, 1, \\ldots S \\tag{13.1}\n",
    "$$\n",
    "\n",
    "Equations [(13.1)](#equation-eq-b-t) constitute $ S+1 $ such budget constraints, one for each $ t=0, 1, \\ldots, S $.\n",
    "\n",
    "Given a sequence $ G $ of government expenditures, a large set of pairs $ (B, T) $ of (government debt, tax collections) sequences satisfy the sequence of budget constraints [(13.1)](#equation-eq-b-t).\n",
    "\n",
    "The  model follows the following logical flow:\n",
    "\n",
    "- start with an exogenous government expenditure sequence $ G $, an initial government debt $ B_0 $, and\n",
    "  a candidate tax collection path $ T $.  \n",
    "- use the system of equations [(13.1)](#equation-eq-b-t) for $ t=0, \\ldots, S $ to compute a path $ B $ of government debt  \n",
    "- verify that $ B_{S+1} $ satisfies the terminal debt constraint $ B_{S+1} \\geq 0 $.  \n",
    "  - If it does, declare that the candidate path is **budget feasible**.  \n",
    "  - if the candidate tax path is not budget feasible, propose a different tax path and start over  \n",
    "\n",
    "\n",
    "Below, we’ll describe how to execute these steps using linear algebra – matrix inversion and multiplication.\n",
    "\n",
    "The above procedure seems like a sensible way to find “budget-feasible” tax paths $ T $, i.e., paths that are consistent with the exogenous government expenditure stream $ G $, the initial debt level $ B_0 $, and the terminal debt level $ B_{S+1} $.\n",
    "\n",
    "In general, there are **many** budget feasible tax paths $ T $.\n",
    "\n",
    "Among all budget-feasible tax paths, which one should a government choose?\n",
    "\n",
    "To answer this question, we assess  alternative budget feasible tax paths $ T $ using the following cost functional:\n",
    "\n",
    "\n",
    "<a id='equation-cost'></a>\n",
    "$$\n",
    "L = - \\sum_{t=0}^S \\beta^t (g_1 T_t - \\frac{g_2}{2} T_t^2 ) \\tag{13.2}\n",
    "$$\n",
    "\n",
    "where $ g_1 > 0, g_2 > 0 $.\n",
    "\n",
    "This is called the “present value of revenue-raising costs” in [[Barro, 1979](https://intro.quantecon.org/zreferences.html#id168)].\n",
    "\n",
    "The quadratic term $ -\\frac{g_2}{2} T_t^2 $ captures increasing marginal costs of taxation, implying that tax distortions rise more than proportionally with tax rates.\n",
    "\n",
    "This creates an incentive for tax smoothing.\n",
    "\n",
    "Indeed, we shall see that when $ \\beta R = 1 $, criterion [(13.2)](#equation-cost) leads to smoother tax paths.\n",
    "\n",
    "By **smoother** we mean tax rates that are as close as possible to being constant over time.\n",
    "\n",
    "The preference for smooth tax paths that is built into the model gives it the name “tax-smoothing model”.\n",
    "\n",
    "Or equivalently, we can transform this into the same problem as in the [consumption-smoothing](https://intro.quantecon.org/cons_smooth.html) lecture by maximizing the welfare criterion:\n",
    "\n",
    "\n",
    "<a id='equation-welfare-tax'></a>\n",
    "$$\n",
    "W = \\sum_{t=0}^S \\beta^t (g_1 T_t - \\frac{g_2}{2} T_t^2 ) \\tag{13.3}\n",
    "$$\n",
    "\n",
    "Let’s dive in and do some calculations that will help us understand how the model works.\n",
    "\n",
    "Here we use default parameters $ R = 1.05 $, $ g_1 = 1 $, $ g_2 = 1/2 $, and $ S = 65 $.\n",
    "\n",
    "We create a Python `namedtuple` to store these parameters with default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53491ec8",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "TaxSmoothing = namedtuple(\"TaxSmoothing\", \n",
    "                        [\"R\", \"g1\", \"g2\", \"β_seq\", \"S\"])\n",
    "\n",
    "def create_tax_smoothing_model(R=1.01, g1=1, g2=1/2, S=65):\n",
    "    \"\"\"\n",
    "    Creates an instance of the tax smoothing model.\n",
    "    \"\"\"\n",
    "    β = 1/R\n",
    "    β_seq = np.array([β**i for i in range(S+1)])\n",
    "\n",
    "    return TaxSmoothing(R, g1, g2, β_seq, S)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08165df1",
   "metadata": {},
   "source": [
    "## Barro tax-smoothing model\n",
    "\n",
    "A key object is the present value of government expenditures at time $ 0 $:\n",
    "\n",
    "$$\n",
    "h_0 \\equiv \\sum_{t=0}^S R^{-t} G_t = \\begin{bmatrix} 1 & R^{-1} & \\cdots & R^{-S} \\end{bmatrix}\n",
    "\\begin{bmatrix} G_0 \\cr G_1  \\cr \\vdots \\cr G_S \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "This sum represents the present value of all future government expenditures that must be financed.\n",
    "\n",
    "Formally it resembles the present value calculations we saw in this QuantEcon lecture [present values](https://intro.quantecon.org/pv.html).\n",
    "\n",
    "This present value calculation is crucial for determining the government’s total financing needs.\n",
    "\n",
    "By iterating on equation [(13.1)](#equation-eq-b-t) and imposing the terminal condition\n",
    "\n",
    "$$\n",
    "B_{S+1} = 0,\n",
    "$$\n",
    "\n",
    "it is possible to convert a sequence of budget constraints [(13.1)](#equation-eq-b-t) into a single intertemporal constraint\n",
    "\n",
    "\n",
    "<a id='equation-eq-budget-intertemp-tax'></a>\n",
    "$$\n",
    "\\sum_{t=0}^S R^{-t} T_t = B_0 + h_0. \\tag{13.4}\n",
    "$$\n",
    "\n",
    "Equation [(13.4)](#equation-eq-budget-intertemp-tax) says that the present value of tax collections must equal the sum of initial debt and the present value of government expenditures.\n",
    "\n",
    "When $ \\beta R = 1 $, it is optimal for a government to smooth taxes by setting\n",
    "\n",
    "$$\n",
    "T_t = T_0 \\quad t =0, 1, \\ldots, S\n",
    "$$\n",
    "\n",
    "(Later we’ll present a “variational argument” that shows that this constant path minimizes\n",
    "criterion [(13.2)](#equation-cost) and maximizes [(13.3)](#equation-welfare-tax) when $ \\beta R =1 $.)\n",
    "\n",
    "In this case, we can use the intertemporal budget constraint to write\n",
    "\n",
    "\n",
    "<a id='equation-eq-taxsmoothing'></a>\n",
    "$$\n",
    "T_t = T_0  = \\left(\\sum_{t=0}^S R^{-t}\\right)^{-1} (B_0 + h_0), \\quad t= 0, 1, \\ldots, S. \\tag{13.5}\n",
    "$$\n",
    "\n",
    "Equation [(13.5)](#equation-eq-taxsmoothing) is the tax-smoothing model in a nutshell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b7b0b74",
   "metadata": {},
   "source": [
    "## Mechanics of tax-smoothing\n",
    "\n",
    "As promised, we’ll provide step-by-step instructions on how to use linear algebra, readily implemented in Python, to compute all objects in play in the tax-smoothing model.\n",
    "\n",
    "In the calculations below, we’ll set default values of $ R > 1 $, e.g., $ R = 1.05 $, and $ \\beta = R^{-1} $."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7434a7e",
   "metadata": {},
   "source": [
    "### Step 1\n",
    "\n",
    "For a $ (S+1) \\times 1 $ vector $ G $ of government expenditures, use matrix algebra to compute the present value\n",
    "\n",
    "$$\n",
    "h_0 = \\sum_{t=0}^S R^{-t} G_t = \\begin{bmatrix} 1 & R^{-1} & \\cdots & R^{-S} \\end{bmatrix}\n",
    "\\begin{bmatrix} G_0 \\cr G_1  \\cr \\vdots \\cr G_S \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d58cc4",
   "metadata": {},
   "source": [
    "### Step 2\n",
    "\n",
    "Compute a constant tax rate $ T_0 $:\n",
    "\n",
    "$$\n",
    "T_t = T_0 = \\left( \\frac{1 - R^{-1}}{1 - R^{-(S+1)}} \\right) (B_0 + \\sum_{t=0}^S R^{-t} G_t ) , \\quad t = 0, 1, \\ldots, S\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb03986",
   "metadata": {},
   "source": [
    "### Step 3\n",
    "\n",
    "Use the system of equations [(13.1)](#equation-eq-b-t) for $ t=0, \\ldots, S $ to compute a path $ B $ of government debt.\n",
    "\n",
    "To do this, we translate that system of difference equations into a single matrix equation as follows:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} \n",
    "1 & 0 & 0 & \\cdots & 0 & 0 & 0 \\cr\n",
    "-R & 1 & 0 & \\cdots & 0 & 0 & 0 \\cr\n",
    "0 & -R & 1 & \\cdots & 0 & 0 & 0 \\cr\n",
    "\\vdots  &\\vdots & \\vdots & \\cdots & \\vdots & \\vdots & \\vdots \\cr\n",
    "0 & 0 & 0 & \\cdots & -R & 1 & 0 \\cr\n",
    "0 & 0 & 0 & \\cdots & 0 & -R & 1\n",
    "\\end{bmatrix} \n",
    "\\begin{bmatrix} B_1 \\cr B_2 \\cr B_3 \\cr \\vdots \\cr B_S \\cr B_{S+1} \n",
    "\\end{bmatrix}\n",
    "= R \n",
    "\\begin{bmatrix} G_0 + B_0 - T_0 \\cr G_1 - T_0 \\cr G_2 - T_0 \\cr \\vdots\\cr G_{S-1} - T_0 \\cr G_S - T_0\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Multiply both sides by the inverse of the matrix on the left side to compute\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} B_1 \\cr B_2 \\cr B_3 \\cr \\vdots \\cr B_S \\cr B_{S+1} \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Because we have built into our calculations that the government must satisfy its intertemporal budget constraint and end with zero debt, just barely satisfying the\n",
    "terminal condition that $ B_{S+1} \\geq 0 $, it should turn out that\n",
    "\n",
    "$$\n",
    "B_{S+1} = 0.\n",
    "$$\n",
    "\n",
    "Let’s verify this with Python code.\n",
    "\n",
    "First we implement the model with `compute_optimal`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fedc12a",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def compute_optimal(model, B0, G_seq):\n",
    "\n",
    "    R, S = model.R, model.S\n",
    "\n",
    "    # present value of government expenditures\n",
    "    h0 = model.β_seq @ G_seq     # since β = 1/R\n",
    "\n",
    "    # optimal constant tax rate\n",
    "    T0 = (1 - 1/R) / (1 - (1/R)**(S+1)) * (B0 + h0)\n",
    "    T_seq = T0*np.ones(S+1)\n",
    "\n",
    "    A = np.diag(-R*np.ones(S), k=-1) + np.eye(S+1)\n",
    "    b = G_seq - T_seq\n",
    "    b[0] = b[0] + B0\n",
    "    B_seq = np.linalg.inv(A) @ b\n",
    "    B_seq = np.concatenate([[B0], B_seq])\n",
    "\n",
    "    return T_seq, B_seq, h0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a0f9d6",
   "metadata": {},
   "source": [
    "We use an example where the government starts with initial debt $ B_0>0 $.\n",
    "\n",
    "This represents the government’s initial debt burden.\n",
    "\n",
    "The government expenditure process $ \\{G_t\\}_{t=0}^{S} $ is constant and positive up to $ t=45 $ and then drops to zero afterward.\n",
    "\n",
    "The drop in government expenditures could reflect a change in spending requirements or demographic shifts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c322874c",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Initial debt\n",
    "B0 = 2     # initial government debt\n",
    "\n",
    "# Government expenditure process\n",
    "G_seq = np.concatenate([np.ones(46), 4*np.ones(5), np.ones(15)])\n",
    "tax_model = create_tax_smoothing_model()\n",
    "T_seq, B_seq, h0 = compute_optimal(tax_model, B0, G_seq)\n",
    "\n",
    "print('check B_S+1=0:', \n",
    "      np.abs(B_seq[-1] - 0) <= 1e-8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fad8dd58",
   "metadata": {},
   "source": [
    "The graphs below show paths of government expenditures, tax collections, and government debt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a202aeaa",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Sequence length\n",
    "S = tax_model.S\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(12,5))\n",
    "\n",
    "axes[0].plot(range(S+1), G_seq, label='expenditures', lw=2)\n",
    "axes[0].plot(range(S+1), T_seq, label='tax', lw=2)\n",
    "axes[1].plot(range(S+2), B_seq, label='debt', color='green', lw=2)\n",
    "axes[0].set_ylabel(r'$T_t,G_t$')\n",
    "axes[1].set_ylabel(r'$B_t$')\n",
    "\n",
    "for ax in axes:\n",
    "    ax.plot(range(S+2), np.zeros(S+2), '--', lw=1, color='black')\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(r'$t$')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15441fe3",
   "metadata": {},
   "source": [
    "Note that $ B_{S+1} = 0 $, as anticipated.\n",
    "\n",
    "We can evaluate cost criterion [(13.2)](#equation-cost) which measures the total cost / welfare of taxation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bec64a26",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def cost(model, T_seq):\n",
    "    β_seq, g1, g2 = model.β_seq, model.g1, model.g2\n",
    "    cost_seq = g1 * T_seq - g2/2 * T_seq**2\n",
    "    return - β_seq @ cost_seq\n",
    "\n",
    "print('Cost:', cost(tax_model, T_seq))\n",
    "\n",
    "def welfare(model, T_seq):\n",
    "    return - cost(model, T_seq)\n",
    "\n",
    "print('Welfare:', welfare(tax_model, T_seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c53256c4",
   "metadata": {},
   "source": [
    "### Experiments\n",
    "\n",
    "In this section we describe how a tax sequence would optimally respond to different sequences of government expenditures.\n",
    "\n",
    "First we create a function `plot_ts` that generates graphs for different instances of the tax-smoothing model `tax_model`.\n",
    "\n",
    "This will help us avoid rewriting code to plot outcomes for different government expenditure sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccb190b2",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def plot_ts(model,    # tax-smoothing model      \n",
    "            B0,       # initial government debt\n",
    "            G_seq     # government expenditure process\n",
    "           ):\n",
    "    \n",
    "    # Compute optimal tax path\n",
    "    T_seq, B_seq, h0 = compute_optimal(model, B0, G_seq)\n",
    "    \n",
    "    # Sequence length\n",
    "    S = tax_model.S\n",
    "    \n",
    "    fig, axes = plt.subplots(1, 2, figsize=(12,5))\n",
    "    \n",
    "    axes[0].plot(range(S+1), G_seq, label='expenditures', lw=2)\n",
    "    axes[0].plot(range(S+1), T_seq, label='taxes', lw=2)\n",
    "    axes[1].plot(range(S+2), B_seq, label='debt', color='green', lw=2)\n",
    "    axes[0].set_ylabel(r'$T_t,G_t$')\n",
    "    axes[1].set_ylabel(r'$B_t$')\n",
    "    \n",
    "    for ax in axes:\n",
    "        ax.plot(range(S+2), np.zeros(S+2), '--', lw=1, color='black')\n",
    "        ax.legend()\n",
    "        ax.set_xlabel(r'$t$')\n",
    "    \n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "228c101e",
   "metadata": {},
   "source": [
    "In the experiments below, please study how tax and government debt sequences vary across different sequences for government expenditures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d96fd6da",
   "metadata": {},
   "source": [
    "#### Experiment 1: one-time spending shock\n",
    "\n",
    "We first assume a one-time spending shock of $ W_0 $ in year 21 of the expenditure sequence $ G $.\n",
    "\n",
    "We’ll make $ W_0 $ big - positive to indicate a spending surge (like a war or disaster), and negative to indicate a spending cut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f290900",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Spending surge W_0 = 2.5\n",
    "G_seq_pos = np.concatenate([np.ones(21), np.array([2.5]), \n",
    "np.ones(24), np.zeros(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae315db",
   "metadata": {},
   "source": [
    "#### Experiment 2: permanent expenditure shift\n",
    "\n",
    "Now we assume a permanent increase in government expenditures of $ L $ in year 21 of the $ G $-sequence.\n",
    "\n",
    "Again we can study positive and negative cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b03e293",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Positive temporary expenditure shift L = 0.5 when t >= 21\n",
    "G_seq_pos = np.concatenate(\n",
    "    [np.ones(21), 1.5*np.ones(25), np.ones(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0689416d",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Negative temporary expenditure shift L = -0.5 when t >= 21\n",
    "G_seq_neg = np.concatenate(\n",
    "    [np.ones(21), .5*np.ones(25), np.ones(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_neg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de3a4e2b",
   "metadata": {},
   "source": [
    "#### Experiment 3: delayed spending surge\n",
    "\n",
    "Now we simulate a $ G $ sequence in which government expenditures are zero for 46 years, and then rise to 1 for the last 20 years (perhaps due to demographic aging)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92da6180",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Delayed spending\n",
    "G_seq_late = np.concatenate(\n",
    "    [np.ones(46), 2*np.ones(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_late)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac116fe",
   "metadata": {},
   "source": [
    "#### Experiment 4: growing expenditures\n",
    "\n",
    "Now we simulate a geometric $ G $ sequence in which government expenditures grow at rate $ G_t = \\lambda^t G_0 $ in first 46 years.\n",
    "\n",
    "We first experiment with $ \\lambda = 1.05 $ (growing expenditures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b82f1b64",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Geometric growth parameters where λ = 1.05\n",
    "λ = 1.05\n",
    "G_0 = 1\n",
    "t_max = 46\n",
    "\n",
    "# Generate geometric G sequence\n",
    "geo_seq = λ ** np.arange(t_max) * G_0 \n",
    "G_seq_geo = np.concatenate(\n",
    "            [geo_seq, np.max(geo_seq)*np.ones(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_geo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9e7806",
   "metadata": {},
   "source": [
    "Now we show the behavior when $ \\lambda = 0.95 $ (declining expenditures)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b90f9c7f",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "λ = 0.95\n",
    "geo_seq = λ ** np.arange(t_max) * G_0 \n",
    "G_seq_geo = np.concatenate(\n",
    "            [geo_seq, np.zeros(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_geo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5d880e4",
   "metadata": {},
   "source": [
    "What happens with oscillating expenditures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a87c62d",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "λ = -0.95\n",
    "geo_seq = λ ** np.arange(t_max) * G_0 + 1\n",
    "G_seq_geo = np.concatenate(\n",
    "            [geo_seq, np.ones(20)])\n",
    "\n",
    "plot_ts(tax_model, B0, G_seq_geo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a42ca7d",
   "metadata": {},
   "source": [
    "### Feasible Tax Variations\n",
    "\n",
    "We promised to justify our claim that a constant tax rate $ T_t = T_0 $ for all $ t $ is optimal.\n",
    "\n",
    "Let’s do that now.\n",
    "\n",
    "The approach we’ll take is an elementary example of the “calculus of variations”.\n",
    "\n",
    "Let’s dive in and see what the key idea is.\n",
    "\n",
    "To explore what types of tax paths are cost-minimizing / welfare-improving, we shall create an **admissible tax path variation sequence** $ \\{v_t\\}_{t=0}^S $\n",
    "that satisfies\n",
    "\n",
    "$$\n",
    "\\sum_{t=0}^S R^{-t} v_t = 0.\n",
    "$$\n",
    "\n",
    "This equation says that the **present value** of admissible tax path variations must be zero.\n",
    "\n",
    "So once again, we encounter a formula for the present value:\n",
    "\n",
    "- we require that the present value of tax path variations be zero to maintain budget balance.  \n",
    "\n",
    "\n",
    "Here we’ll restrict ourselves to a two-parameter class of admissible tax path variations of the form\n",
    "\n",
    "$$\n",
    "v_t = \\xi_1 \\phi^t - \\xi_0.\n",
    "$$\n",
    "\n",
    "We say two and not three-parameter class because $ \\xi_0 $ will be a function of $ (\\phi, \\xi_1; R) $ that guarantees that the variation sequence is feasible.\n",
    "\n",
    "Let’s compute that function.\n",
    "\n",
    "We require\n",
    "\n",
    "$$\n",
    "\\sum_{t=0}^S R^{-t}\\left[ \\xi_1 \\phi^t - \\xi_0 \\right] = 0\n",
    "$$\n",
    "\n",
    "which implies that\n",
    "\n",
    "$$\n",
    "\\xi_1 \\sum_{t=0}^S \\phi_t R^{-t} - \\xi_0 \\sum_{t=0}^S R^{-t} = 0\n",
    "$$\n",
    "\n",
    "which implies that\n",
    "\n",
    "$$\n",
    "\\xi_1 \\frac{1 - (\\phi R^{-1})^{S+1}}{1 - \\phi R^{-1}} - \\xi_0 \\frac{1 - R^{-(S+1)}}{1-R^{-1} } =0\n",
    "$$\n",
    "\n",
    "which implies that\n",
    "\n",
    "$$\n",
    "\\xi_0 = \\xi_0(\\phi, \\xi_1; R) = \\xi_1 \\left(\\frac{1 - R^{-1}}{1 - R^{-(S+1)}}\\right) \\left(\\frac{1 - (\\phi R^{-1})^{S+1}}{1 - \\phi R^{-1}}\\right)\n",
    "$$\n",
    "\n",
    "This is our formula for $ \\xi_0 $.\n",
    "\n",
    "**Key Idea:** if $ T^o $ is a budget-feasible tax path, then so is $ T^o + v $,\n",
    "where $ v $ is a budget-feasible variation.\n",
    "\n",
    "Given $ R $, we thus have a two parameter class of budget feasible variations $ v $ that we can use\n",
    "to compute alternative tax paths, then evaluate their welfare costs.\n",
    "\n",
    "Now let’s compute and plot tax path variations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f36ca6c",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def compute_variation(model, ξ1, ϕ, B0, G_seq, verbose=1):\n",
    "    R, S, β_seq = model.R, model.S, model.β_seq\n",
    "\n",
    "    ξ0 = ξ1*((1 - 1/R) / (1 - (1/R)**(S+1))) * ((1 - (ϕ/R)**(S+1)) / (1 - ϕ/R))\n",
    "    v_seq = np.array([(ξ1*ϕ**t - ξ0) for t in range(S+1)])\n",
    "    \n",
    "    if verbose == 1:\n",
    "        print('check feasible:', np.isclose(β_seq @ v_seq, 0))     \n",
    "\n",
    "    T_opt, _, _ = compute_optimal(model, B0, G_seq)\n",
    "    Tvar_seq = T_opt + v_seq\n",
    "\n",
    "    return Tvar_seq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f931dd",
   "metadata": {},
   "source": [
    "We visualize variations for $ \\xi_1 \\in \\{.01, .05\\} $ and $ \\phi \\in \\{.95, 1.02\\} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0591da3",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ξ1s = [.01, .05]\n",
    "ϕs= [.95, 1.02]\n",
    "colors = {.01: 'tab:blue', .05: 'tab:green'}\n",
    "params = np.array(np.meshgrid(ξ1s, ϕs)).T.reshape(-1, 2)\n",
    "wel_opt = welfare(tax_model, T_seq)\n",
    "\n",
    "for i, param in enumerate(params):\n",
    "    ξ1, ϕ = param\n",
    "    print(f'variation {i}: ξ1={ξ1}, ϕ={ϕ}')\n",
    "\n",
    "    Tvar_seq = compute_variation(model=tax_model, \n",
    "                                 ξ1=ξ1, ϕ=ϕ, B0=B0, \n",
    "                                 G_seq=G_seq)\n",
    "    print(f'welfare={welfare(tax_model, Tvar_seq)}')\n",
    "    print(f'welfare < optimal: {welfare(tax_model, Tvar_seq) < wel_opt}')\n",
    "    print('-'*64)\n",
    "\n",
    "    if i % 2 == 0:\n",
    "        ls = '-.'\n",
    "    else: \n",
    "        ls = '-'  \n",
    "    ax.plot(range(S+1), Tvar_seq, ls=ls, \n",
    "            color=colors[ξ1], \n",
    "            label=fr'$\\xi_1 = {ξ1}, \\phi = {ϕ}$')\n",
    "\n",
    "plt.plot(range(S+1), T_seq, \n",
    "         color='orange', label=r'Optimal $\\vec{T}$ ')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel(r'$t$')\n",
    "plt.ylabel(r'$T_t$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8c50604",
   "metadata": {},
   "source": [
    "We can even use the Python `np.gradient` command to compute derivatives of cost with respect to our two parameters.\n",
    "\n",
    "We are teaching the key idea beneath the **calculus of variations**.\n",
    "First, we define the cost with respect to $ \\xi_1 $ and $ \\phi $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24e7471e",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def cost_rel(ξ1, ϕ):\n",
    "    \"\"\"\n",
    "    Compute cost of variation sequence \n",
    "    for given ϕ, ξ1 with a tax-smoothing model\n",
    "    \"\"\"\n",
    "    \n",
    "    Tvar_seq = compute_variation(tax_model, ξ1=ξ1, \n",
    "                                 ϕ=ϕ, B0=B0, \n",
    "                                 G_seq=G_seq, \n",
    "                                 verbose=0)\n",
    "    return cost(tax_model, Tvar_seq)\n",
    "\n",
    "# Vectorize the function to allow array input\n",
    "cost_vec = np.vectorize(cost_rel)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba85d04",
   "metadata": {},
   "source": [
    "Then we can visualize the relationship between cost and $ \\xi_1 $ and compute its derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fab4504f",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "ξ1_arr = np.linspace(-0.5, 0.5, 20)\n",
    "\n",
    "plt.plot(ξ1_arr, cost_vec(ξ1_arr, 1.02))\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel(r'$\\xi_1$')\n",
    "plt.show()\n",
    "\n",
    "cost_grad = cost_vec(ξ1_arr, 1.02)\n",
    "cost_grad = np.gradient(cost_grad)\n",
    "plt.plot(ξ1_arr, cost_grad)\n",
    "plt.ylabel('derivative of cost')\n",
    "plt.xlabel(r'$\\xi_1$')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "897a149b",
   "metadata": {},
   "source": [
    "The same can be done on $ \\phi $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33c87364",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "ϕ_arr = np.linspace(-0.5, 0.5, 20)\n",
    "\n",
    "plt.plot(ξ1_arr, cost_vec(0.05, ϕ_arr))\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel(r'$\\phi$')\n",
    "plt.show()\n",
    "\n",
    "cost_grad = cost_vec(0.05, ϕ_arr)\n",
    "cost_grad = np.gradient(cost_grad)\n",
    "plt.plot(ξ1_arr, cost_grad)\n",
    "plt.ylabel('derivative of cost')\n",
    "plt.xlabel(r'$\\phi$')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "date": 1738361556.8448718,
  "filename": "tax_smooth.md",
  "kernelspec": {
   "display_name": "Python",
   "language": "python3",
   "name": "python3"
  },
  "title": "Tax Smoothing"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}