diff --git a/REMARKs/KRR99/KRR99.md b/REMARKs/KRR99/KRR99.md new file mode 100644 index 00000000..b6cf2dfa --- /dev/null +++ b/REMARKs/KRR99/KRR99.md @@ -0,0 +1,27 @@ +--- +tags: + - REMARK + - Replication +abstract: # abstract: optional +authors: # required + - + family-names: Koh + given-names: "Kyung Woong" + orcid: "https://orcid.org/0000-0002-1670-6556" +# REMARK fields +# github_repo_url: https://github.com/kwkak37/REMARK # required +version: 1.1 # required +remark-name: KRR99 # required +title-original-paper: On the Size of U.S. Government: Political Economy in the Neoclassical Growth Model # optional +notebooks: # path to any notebooks within the repo - optional + - + code/python/KohKRR99.ipynb +--- + +# On the Size of U.S. Government: Political Economy in the Neoclassical Growth Model + +## Replication of Krusell and Rios-Rull (1999) + +## by Kyung Woong Koh + +This notebook attempts to replicate "On the Size of U.S. Government: Political Economy in the Neoclassical Growth Model" by Krusell and Rios-Rull (1999), by incorporating a flat income tax rate and lump-sum transfers into an economy with idiosyncratic transitory income shocks, then computing the tax rate chosen by the median agent. \ No newline at end of file diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py new file mode 100644 index 00000000..380dbf57 --- /dev/null +++ b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py @@ -0,0 +1,482 @@ +""" +ConsAggShockModel, but with flat income tax rates and lump-sum transfers +""" + + +import numpy as np +import scipy.stats as stats +from HARK.interpolation import ( + LinearInterp, + LinearInterpOnInterp1D, + ConstantFunction, + IdentityFunction, + VariableLowerBoundFunc2D, + BilinearInterp, + LowerEnvelope2D, + UpperEnvelope, + MargValueFuncCRRA, + ValueFuncCRRA +) +from HARK.utilities import ( + CRRAutility, + CRRAutilityP, + CRRAutilityPP, + CRRAutilityP_inv, + CRRAutility_invP, + CRRAutility_inv, + make_grid_exp_mult, +) +from HARK.distribution import ( + MarkovProcess, + MeanOneLogNormal, + Uniform, + combine_indep_dstns, + calc_expectation +) +from HARK.ConsumptionSaving.ConsIndShockModel import ( + ConsumerSolution, + IndShockConsumerType, + init_idiosyncratic_shocks, +) +from HARK import MetricObject, Market, AgentType +from copy import deepcopy +import matplotlib.pyplot as plt + + +from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, + CobbDouglasEconomy, + init_agg_shocks, + init_cobb_douglas, + solveConsAggShock, + AggregateSavingRule +) + + +class ValueFunc2D(MetricObject): + """ + A class for representing a value function in models (with CRRA utility). + """ + + distance_criteria = ["cFunc", "CRRA"] + + def __init__(self, cFunc, CRRA): + """ + Constructor for a new value function object. + Parameters + ---------- + cFunc : function + A real function representing the marginal value function composed + with the inverse marginal utility function, defined on normalized individual market + resources and aggregate market resources-to-labor ratio: uP_inv(vPfunc(m,M)). + Called cFunc because when standard envelope condition applies, + uP_inv(vPfunc(m,M)) = cFunc(m,M). + CRRA : float + Coefficient of relative risk aversion. + Returns + ------- + new instance of MargValueFunc + """ + self.cFunc = deepcopy(cFunc) + self.CRRA = CRRA + + def __call__(self, m, M): + return utility(self.cFunc(m, M), gam=self.CRRA) + + +# Make a dictionary to specify an aggregate shocks consumer with taxes and transfers + + +init_agg_shocks_tax = init_agg_shocks.copy() +init_agg_shocks_tax["tax_rate"] = 0.0 + +class AggShockConsumerType_tax(AggShockConsumerType): + """ + Same as AggShockConsumerType, but with taxes and transfers + """ + def __init__(self, **kwds): + """ + Makes a new instance of AggShockConsumerType_tax, an extension of + AggShockConsumerType. Sets appropriate solver and input lists. + """ + + self.vFunc = None + + params = init_agg_shocks_tax.copy() + params.update(kwds) + + AggShockConsumerType.__init__(self, **params) + + self.add_to_time_inv("tax_rate") + + self.solve_one_period = solveConsAggShock_tax + self.update() + + def transition(self): + """" + Same as in AggShockConsumerType, but with flat income tax and lump-sum transfers + """ + + pLvlPrev = self.state_prev['pLvl'] + aNrmPrev = self.state_prev['aNrm'] + RfreeNow = self.get_Rfree() + + # Calculate new states: normalized market resources and permanent income level + pLvlNow = pLvlPrev*self.shocks['PermShk'] # Updated permanent income level + # Updated aggregate permanent productivity level + PlvlAggNow = self.state_prev['PlvlAgg']*self.PermShkAggNow + # "Effective" interest factor on normalized assets + ReffNow = RfreeNow/self.shocks['PermShk'] + + # In AggShockConsumerType class: + # mNrmNow = bNrmNow + self.shocks['TranShk'] # Market resources after income + + bNrmNow = (1 + (1-self.tax_rate)*(ReffNow-1)) * aNrmPrev + # Bank balances before labor income and subtracted by taxed portion of capital income + + mNrmNow = bNrmNow + (1-self.tax_rate)*self.shocks['TranShk'] + self.calc_transfers() + # Market resources, after (taxed) transitory income shock and lump-sum transfers + + return pLvlNow, PlvlAggNow, bNrmNow, mNrmNow, None + + def calc_transfers(self): + """ + Returns level of (normalized) lump-sum transfers + """ + aNrmPrev = self.state_prev['aNrm'] + RfreeNow = self.get_Rfree() + ReffNow = RfreeNow / self.shocks['PermShk'] + + # calculates lump-sum transfer by multiplying tax rate to to (capital + labor) income + taxrevenue = np.mean(self.tax_rate * ((ReffNow - 1) * aNrmPrev + self.shocks['TranShk'])) + transfers = taxrevenue + return transfers + + def update_solution_terminal(self): + """ + Same as update_solution_terminal() in the AggShockConsumerType class, + with the addition of the value function vFunc + + Parameters + ---------- + None + + Returns + ------- + None + """ + cFunc_terminal = BilinearInterp( + np.array([[0.0, 0.0], [1.0, 1.0]]), + np.array([0.0, 1.0]), + np.array([0.0, 1.0]), + ) + vPfunc_terminal = MargValueFuncCRRA(cFunc_terminal, self.CRRA) + vFunc_terminal = ValueFuncCRRA(cFunc_terminal, self.CRRA) + mNrmMin_terminal = ConstantFunction(0) + self.solution_terminal = ConsumerSolution( + cFunc=cFunc_terminal, vPfunc=vPfunc_terminal, vFunc=vFunc_terminal, mNrmMin=mNrmMin_terminal + ) + + + +def solveConsAggShock_tax( + solution_next, + IncShkDstn, + LivPrb, + DiscFac, + CRRA, + PermGroFac, + PermGroFacAgg, + aXtraGrid, + BoroCnstArt, + Mgrid, + AFunc, + Rfunc, + wFunc, +): + """ + Same as solveConsAggShock in ConsAggShockModel.py, + with the addition that it calculates a value function in the solution. + + Parameters + ---------- + solution_next : ConsumerSolution + The solution to the succeeding one period problem. + IncShkDstn : distribution.Distribution + A discrete + approximation to the income process between the period being solved + and the one immediately following (in solution_next). Order: + idiosyncratic permanent shocks, idiosyncratic transitory + shocks, aggregate permanent shocks, aggregate transitory shocks. + LivPrb : float + Survival probability; likelihood of being alive at the beginning of + the succeeding period. + DiscFac : float + Intertemporal discount factor for future utility. + CRRA : float + Coefficient of relative risk aversion. + PermGroFac : float + Expected permanent income growth factor at the end of this period. + PermGroFacAgg : float + Expected aggregate productivity growth factor. + aXtraGrid : np.array + Array of "extra" end-of-period asset values-- assets above the + absolute minimum acceptable level. + BoroCnstArt : float + Artificial borrowing constraint; minimum allowable end-of-period asset-to- + permanent-income ratio. Unlike other models, this *can't* be None. + Mgrid : np.array + A grid of aggregate market resourses to permanent income in the economy. + AFunc : function + Aggregate savings as a function of aggregate market resources. + Rfunc : function + The net interest factor on assets as a function of capital ratio k. + wFunc : function + The wage rate for labor as a function of capital-to-labor ratio k. + DeprFac : float + Capital Depreciation Rate + + Returns + ------- + solution_now : ConsumerSolution + The solution to the single period consumption-saving problem. Includes + a consumption function cFunc (linear interpolation over linear interpola- + tions), a marginal value function vPfunc, and a value function vFunc. + """ + + # Unpack next period's solution + vPfuncNext = solution_next.vPfunc + vFuncNext = solution_next.vFunc + mNrmMinNext = solution_next.mNrmMin + + # Unpack the income shocks + ShkPrbsNext = IncShkDstn.pmf + PermShkValsNext = IncShkDstn.X[0] + TranShkValsNext = IncShkDstn.X[1] + PermShkAggValsNext = IncShkDstn.X[2] + TranShkAggValsNext = IncShkDstn.X[3] + ShkCount = ShkPrbsNext.size + + # Make the grid of end-of-period asset values, and a tiled version + aNrmNow = aXtraGrid + aCount = aNrmNow.size + Mcount = Mgrid.size + aXtra_tiled = np.tile(np.reshape(aNrmNow, (1, aCount, 1)), (Mcount, 1, ShkCount)) + + # Make tiled versions of the income shocks + # Dimension order: Mnow, aNow, Shk + ShkPrbsNext_tiled = np.tile( + np.reshape(ShkPrbsNext, (1, 1, ShkCount)), (Mcount, aCount, 1) + ) + PermShkValsNext_tiled = np.tile( + np.reshape(PermShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1) + ) + TranShkValsNext_tiled = np.tile( + np.reshape(TranShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1) + ) + PermShkAggValsNext_tiled = np.tile( + np.reshape(PermShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1) + ) + TranShkAggValsNext_tiled = np.tile( + np.reshape(TranShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1) + ) + + # Calculate returns to capital and labor in the next period + AaggNow_tiled = np.tile( + np.reshape(AFunc(Mgrid), (Mcount, 1, 1)), (1, aCount, ShkCount) + ) + kNext_array = AaggNow_tiled / ( + PermGroFacAgg * PermShkAggValsNext_tiled + ) # Next period's aggregate capital/labor ratio + kNextEff_array = ( + kNext_array / TranShkAggValsNext_tiled + ) # Same thing, but account for *transitory* shock + R_array = Rfunc(kNextEff_array) # Interest factor on aggregate assets + Reff_array = ( + R_array / LivPrb + ) # Effective interest factor on individual assets *for survivors* + wEff_array = ( + wFunc(kNextEff_array) * TranShkAggValsNext_tiled + ) # Effective wage rate (accounts for labor supply) + PermShkTotal_array = ( + PermGroFac * PermGroFacAgg * PermShkValsNext_tiled * PermShkAggValsNext_tiled + ) # total / combined permanent shock + + Mnext_array = ( + kNext_array * R_array + wEff_array + ) # next period's aggregate market resources + + # Find the natural borrowing constraint for each value of M in the Mgrid. + # There is likely a faster way to do this, but someone needs to do the math: + # is aNrmMin determined by getting the worst shock of all four types? + aNrmMin_candidates = ( + PermGroFac + * PermGroFacAgg + * PermShkValsNext_tiled[:, 0, :] + * PermShkAggValsNext_tiled[:, 0, :] + / Reff_array[:, 0, :] + * ( + mNrmMinNext(Mnext_array[:, 0, :]) + - wEff_array[:, 0, :] * TranShkValsNext_tiled[:, 0, :] + ) + ) + aNrmMin_vec = np.max(aNrmMin_candidates, axis=1) + BoroCnstNat_vec = aNrmMin_vec + aNrmMin_tiled = np.tile( + np.reshape(aNrmMin_vec, (Mcount, 1, 1)), (1, aCount, ShkCount) + ) + aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled + + # Calculate market resources next period (and a constant array of capital-to-labor ratio) + mNrmNext_array = ( + Reff_array * aNrmNow_tiled / PermShkTotal_array + + TranShkValsNext_tiled * wEff_array + ) + + # Find marginal value next period at every income shock realization and every aggregate market resource gridpoint + vPnext_array = ( + Reff_array + * PermShkTotal_array ** (-CRRA) + * vPfuncNext(mNrmNext_array, Mnext_array) + ) + + # Calculate expectated marginal value at the end of the period at every asset gridpoint + EndOfPrdvP = DiscFac * LivPrb * np.sum(vPnext_array * ShkPrbsNext_tiled, axis=2) + + # Calculate optimal consumption from each asset gridpoint + cNrmNow = EndOfPrdvP ** (-1.0 / CRRA) + mNrmNow = aNrmNow_tiled[:, :, 0] + cNrmNow + + # Loop through the values in Mgrid and make a linear consumption function for each + cFuncBaseByM_list = [] + for j in range(Mcount): + c_temp = np.insert(cNrmNow[j, :], 0, 0.0) # Add point at bottom + m_temp = np.insert(mNrmNow[j, :] - BoroCnstNat_vec[j], 0, 0.0) + cFuncBaseByM_list.append(LinearInterp(m_temp, c_temp)) + # Add the M-specific consumption function to the list + + # Construct the overall unconstrained consumption function by combining the M-specific functions + BoroCnstNat = LinearInterp( + np.insert(Mgrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0) + ) + cFuncBase = LinearInterpOnInterp1D(cFuncBaseByM_list, Mgrid) + cFuncUnc = VariableLowerBoundFunc2D(cFuncBase, BoroCnstNat) + + # Make the constrained consumption function and combine it with the unconstrained component + cFuncCnst = BilinearInterp( + np.array([[0.0, 0.0], [1.0, 1.0]]), + np.array([BoroCnstArt, BoroCnstArt + 1.0]), + np.array([0.0, 1.0]), + ) + cFuncNow = LowerEnvelope2D(cFuncUnc, cFuncCnst) + + # Make the minimum m function as the greater of the natural and artificial constraints + mNrmMinNow = UpperEnvelope(BoroCnstNat, ConstantFunction(BoroCnstArt)) + + # Construct the marginal value function using the envelope condition + vPfuncNow = MargValueFuncCRRA(cFuncNow, CRRA) + + # Construct the marginal value function using the envelope condition + vFuncNow = ValueFuncCRRA(cFuncNow, CRRA) + + # Pack up and return the solution + solution_now = ConsumerSolution( + cFunc=cFuncNow, vPfunc=vPfuncNow, vFunc=vFuncNow, mNrmMin=mNrmMinNow + ) + return solution_now + + + + +# Make a dictionary to specify a Cobb-Douglas economy with income tax rates + +init_cobb_douglas_tax = init_cobb_douglas.copy() +init_cobb_douglas_tax["tax_rate"] = 0.00 + +class CobbDouglasEconomy_tax(CobbDouglasEconomy): + """ + Same as the CobbDouglasEconomy market class, with the addition + of a flat income tax rate affecting the steady state level of capital + per capita and hence aggregate output. + + Additional Parameters + ---------- + tax_rate: float [0,1] + """ + + def __init__(self, agents=None, tolerance=0.0001, act_T=1200, **kwds): + agents = agents if agents is not None else list() + params = init_cobb_douglas.copy() + params["sow_vars"] = [ + "MaggNow", + "AaggNow", + "RfreeNow", + "wRteNow", + "PermShkAggNow", + "TranShkAggNow", + "KtoLnow", + ] + params.update(kwds) + + Market.__init__( + self, + agents=agents, + reap_vars=['aLvl', 'pLvl'], + track_vars=["MaggNow", "AaggNow"], + dyn_vars=["AFunc"], + tolerance=tolerance, + act_T=act_T, + **params + ) + self.update() + + # Use previously hardcoded values for AFunc updating if not passed + # as part of initialization dictionary. This is to prevent a last + # minute update to HARK before a release from having a breaking change. + if not hasattr(self, "tax_rate"): + self.tax_rate = 0.0 + + def update(self): + """ + Use primitive parameters (and perfect foresight calibrations) to make + interest factor and wage rate functions (of capital to labor ratio), + as well as discrete approximations to the aggregate shock distributions. + + Parameters + ---------- + None + + Returns + ------- + None + """ + + self.kSS = ( + ( + self.get_PermGroFacAggLR() ** (self.CRRA) / self.DiscFac + - (1.0 - self.DeprFac) + ) / (1 - self.tax_rate) + / self.CapShare + ) ** (1.0 / (self.CapShare - 1.0)) + self.KtoYSS = self.kSS ** (1.0 - self.CapShare) + self.wRteSS = (1.0 - self.CapShare) * self.kSS ** (self.CapShare) + self.RfreeSS = ( + 1.0 + self.CapShare * self.kSS ** (self.CapShare - 1.0) - self.DeprFac + ) + self.MSS = self.kSS * self.RfreeSS + self.wRteSS + self.convertKtoY = lambda KtoY: KtoY ** ( + 1.0 / (1.0 - self.CapShare) + ) # converts K/Y to K/L + self.Rfunc = lambda k: ( + 1.0 + self.CapShare * k ** (self.CapShare - 1.0) - self.DeprFac + ) + self.wFunc = lambda k: ((1.0 - self.CapShare) * k ** (self.CapShare)) + + self.sow_init["KtoLnow"] = self.kSS + self.sow_init["MaggNow"] = self.kSS + self.sow_init["AaggNow"] = self.kSS + self.sow_init["RfreeNow"] = self.Rfunc(self.kSS) + self.sow_init["wRteNow"] = self.wFunc(self.kSS) + self.sow_init["PermShkAggNow"] = 1.0 + self.sow_init["TranShkAggNow"] = 1.0 + self.make_AggShkDstn() + self.AFunc = AggregateSavingRule(self.intercept_prev, self.slope_prev) diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb new file mode 100644 index 00000000..8ccc4ebb --- /dev/null +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -0,0 +1,1282 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d00bc7f1", + "metadata": {}, + "source": [ + "# Replication Plans for Krusell and Rios-Rull (1999)\n", + "### \"On the Size of U.S. Government: Political Economy in the Neoclassical Growth Model\"\n", + "### AER 89 (5) p.1156-1181, 1999\n", + "\n", + "### Kyung Woong Koh (May 24, 2022)" + ] + }, + { + "cell_type": "markdown", + "id": "266ca20b", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "### Introduction: Part of A Serious Attempt at Political Economy and Macroeconomics\n", + "\n", + "- Political economy: \"How does the macroeconomy how are policies affected?\"\n", + "- Macroeconomics: \"How do policies affect the macroeconomy?\"\n", + "- A serious discussion in each discipline eventually requires a dynamic model that answers the other discipline's questions (ex. \"Is this tax cut exogenous?\")\n", + "\n", + "Krusell and Rios-Rull 1999 (henceforth KRR): Dynamic macroeconomic model with political economic mechanism for determining income tax rate\n", + "- Income tax rate is determined by votes of all agents in the economy, as in Meltzer and Richard (1981)\n", + "\n", + "Original goal of KRR, inspired from Meltzer and Richard (1981), is to predict the size of total transfers (to GDP ratio) and therefore the \"size of the U.S. government\" from political economy theory\n", + "- \"The total size of transfers predicted by our political-economy model is quite close to the size of transfers in the data.\" [About 30\\% in the data and KRR's dynamic model]\n", + "\n", + "Since then, this strand of literature (ex. political business cycles) has focused on the political economy question rather than the macroeconomic question\n", + "- Most of macroeconomics and its modelling until now has been homogeneous agents\n", + "- But politics can't exist among homogeneous agents (especially with homogeneous preferences)\n", + "- Macro deals in means, but political economy deals in medians\n", + "\n", + "With heterogeneous agent macro, now we can discuss models with different agents, with different levels of income/wealth and therefore different preferred levels of taxation (poor people want more taxation and more redistribution than rich people do)\n", + "\n", + "With HARK, we can go further!" + ] + }, + { + "cell_type": "markdown", + "id": "c72eefeb", + "metadata": {}, + "source": [ + "### My Goals from Replication of KRR\n", + "1. Compare resulting size of transfers (\"size of government\") from replication with KRR\n", + "2. Look at effects of parameter shocks (permanent income, transitory income, etc.) to size of transfers\n", + "- Does a higher standard deviation of permanent or transitory income lead to a greater size of transfers preferred by the \"median\" voter? (\"Social insurance\")\n", + "- Does a negative aggregate productivity shock lead to a greater size of transfers preferred by the \"median\" voter? Does the existence of idiosyncratic shocks change this result?" + ] + }, + { + "cell_type": "markdown", + "id": "bc77d326", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "### Description of the KRR Economy\n", + "\n", + "1. Economy is composed of heterogeneous consumers with individual labor productivity $\\varepsilon_{t}$ and assets $a_{t}$, receive at labor wage rate $w_{t}$ and capital rental rate $r_{t}$, pay $\\tau_{t}$ of their total income in tax, consume $c_{t}$ and save income towards individual wealth $a_{t+1}$\n", + "\\begin{align}\n", + " &\\max \\sum_{t=0}^{\\infty} \\beta^{t} u(c_{t}, l_{t}) \\text{ s.t. } \\\\\n", + " c_{t} + a_{t+1} &= a_{t}(1+r_{t}(1-\\tau_{t})) + w_{t}\\varepsilon_{t}(1-l_{t})(1-\\tau_{t}) + T_{t} \\\\\n", + " u(c,l) &= ((c^{\\alpha}l^{1-\\alpha})^{1-\\sigma}-1)/(1-\\sigma)\n", + "\\end{align}\n", + "\n", + "\n", + "2. Aggregate labor and aggregate capital are normalized as follows:\n", + "\\begin{align}\n", + " \\sum_{i}\\varepsilon_{it} &= N \\\\\n", + " \\sum_{i}a_{it} &= K\n", + "\\end{align}\n", + "\n", + "\n", + "3. Resource constraint of economy is\n", + "\\begin{equation}\n", + " C_{t} + K_{t+1} - K_{t}(1-\\delta) + g_{t} = F(K_{t},N_{t})\n", + "\\end{equation}\n", + "where $F(K,N)$ is the aggregate production function\n", + "\n", + "\n", + "4. Income taxation is redistributed as equal lump-sum transfers (after accounting for government consumption $g_{t}$)\n", + "\\begin{equation}\n", + " g_{t} + T_{t} = \\tau_{t}(K_{t}r_{t} + N_{t}w_{t})\n", + "\\end{equation}\n", + "\n", + "\n", + "5. Each consumer periodically votes for the tax rate $\\tau_{t}$ that maximizes his/her equilibrium utility, given the asset (\"wealth\") distribution $A_{t}=\\{a_{it}\\}$:\n", + "\\begin{align}\n", + " \\tau_{t+1} &= \\Psi(A_{t},\\tau_{t}) \\\\\n", + " A_{t+1} &= H(A_{t},\\tau_{t})\n", + "\\end{align}\n", + "where $\\Psi(A,\\tau)$ is the transition function of current asset distribution $A_{t}$ and tax rate $\\tau_{t}$ to the new politically determined tax rate $\\tau_{t+1}$ (political equilibrium), and $H(A,\\tau)$ is the transition function to the next period's asset distribution $A_{t+1}$ (economic equilibrium).\n", + "\n", + "Our goal is to find the politico-economic equilibrium $\\tau =\\Psi(A,\\tau)$ and $A = H(A,\\tau)$" + ] + }, + { + "cell_type": "markdown", + "id": "51a7993d", + "metadata": {}, + "source": [ + "### What is already possible in HARK\n", + "\n", + "I would use the $\\texttt{AggShockConsumerType}$ and $\\texttt{CobbDouglasEconomy}$ classes under $\\texttt{HARK.ConsumptionSaving.ConsAggShockModel}$, which provides the tools to compute both consumption and labor choices in an economy with Cobb-Douglas production of aggregate labor and aggregate capital" + ] + }, + { + "cell_type": "markdown", + "id": "490dfc60-1ddf-4eb1-91ee-8a5e72becebd", + "metadata": { + "tags": [] + }, + "source": [ + "### To Do ###\n", + "\n", + "- Use \"market\" class for updating tax rates (partial eq. version, solve for R and w using Cobb-Douglas, etc.)\n", + "(https://github.com/econ-ark/DistributionOfWealthMPC)\n", + "- 1. compute with tax rates\n", + "- 2. compute with different tax rates\n", + "- 3. utility of different groups with different tax rates" + ] + }, + { + "cell_type": "markdown", + "id": "3c81deb7-bc45-464f-ab4b-157b5d4e10a2", + "metadata": { + "tags": [] + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "id": "14369395-a683-4a4c-8099-6085888e322b", + "metadata": {}, + "source": [ + "**Parameters in KRR99**\n", + "

beta = 0.96 (Annual discount rate)
\n", + "alpha = 0.429 (Utility weight of consumption)
\n", + "sigma = 4 (Risk aversion parameter)
\n", + "delta = 0.05 (Depreciation rate)
\n", + "theta = 0.36 (Share of capital income)
\n", + "Wealth-output ratio = 3.3
\n", + "r = 0.06 (Pre-tax)
\n", + "C/Y = 0.638 (Consumption-output ratio)
\n", + "g/Y = 0.199 (Government spending-output ratio, but for now I assume in the code g/Y = 0)
\n", + "N = 0.34 (Labor hours)

" + ] + }, + { + "cell_type": "markdown", + "id": "534eb96b-d392-406f-b3a4-dac79078948a", + "metadata": {}, + "source": [ + "**Progress:**\n", + "1. *Devised code for `AggShockConsumerType_tax` class*: Inherits from `AggShockConsumerType` class and introduces flat income tax rate (`tax_rate`)\n", + "2. *Included code for calculating value function (`vFunc`) in `AggShockConsumerType_tax` class*: This is to calculate the value function of the median agent (as in the agent with the median level of wealth)\n", + "3. *Devised code for finding median agent's preferred tax rate*: For loop process for calculating post-tax(-and-transfer) value function of agent with median level of wealth" + ] + }, + { + "cell_type": "markdown", + "id": "8d215140-cbbf-4dc5-a6dd-ece0c88e5a4e", + "metadata": {}, + "source": [ + "**Stumbling Blocks:**\n", + "1. *Getting to single-peaked preferences for tax rates*: I have so far located and altered the code that calculates the lump-sum transfers that each agent receives, and higher tax rates do lead to lower levels of individual asset levels (`aLvl`, normalized to `aNrm`). However, I am having trouble replicating the single-peaked preferences of agents on the tax rate and hence level of redistribution (transfers). The code in its current state leads to the top 60\\% of the agents (in terms of wealth) preferring a zero tax rate and the bottom 40\\% preferring the maximum level of tax rate (0.95 in the current code).\n", + "- If I can replicate the results of single-peaked preferences on tax rates for each agent, the most preferred tax rate of the median agent in terms of wealth should be the economy's chosen flat income tax rate." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ac322ba6-510b-438b-837e-dde9a4ee2ee9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import HARK\n", + "import sys\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, CobbDouglasEconomy, init_agg_shocks,\n", + " init_cobb_douglas,\n", + " solveConsAggShock,\n", + " AggregateSavingRule\n", + ")\n", + "\n", + "from ConsAggShockModel_tax import *\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from copy import deepcopy\n", + "from HARK.utilities import plot_funcs, make_figs\n", + "import statsmodels.api as sm\n", + "from time import process_time\n", + "def mystr(number):\n", + " return \"{:.4f}\".format(number)" + ] + }, + { + "cell_type": "markdown", + "id": "fffc487a", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "I first set the parameters for each agent in the `AggShockConsumerType_tax` class as follows, with the addition of a flat income tax rate (`tax_rate`):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c9645f21-92f8-436e-b794-ea26aa0f29de", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Define a dictionary with calibrated parameters\n", + "AgentParameters = {\n", + " \"CRRA\":4.00, # Coefficient of relative risk aversion\n", + " \"DiscFac\": 0.96, # Default intertemporal discount factor; dummy value, will be overwritten\n", + " \"Rfree\": 1.06, # Survival probability,\n", + " \"PermShkCount\" : 1, # Number of points in discrete approximation to permanent income shocks - no shocks of this kind!\n", + " \"TranShkCount\" : 5, # Number of points in discrete approximation to transitory income shocks\n", + " \"PermShkStd\" : [0.0], # Standard deviation of log permanent income shocks - no shocks of this kind!\n", + " \"TranShkStd\" : [0.5], # Standard deviation of log transitory income shocks\n", + " \"UnempPrb\" : 0.0, # Probability of unemployment while working - no shocks of this kind!\n", + " \"UnempPrbRet\" : 0.00, # Probability of \"unemployment\" while retired - no shocks of this kind!\n", + " \"IncUnemp\" : 0.0, # Unemployment benefits replacement rate\n", + " \"IncUnempRet\" : 0.0, # \"Unemployment\" benefits when retired\n", + " \"T_retire\" : 0, # Period of retirement (0 --> no retirement)\n", + " \"BoroCnstArt\" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets\n", + " \"PermGroFac\" : [1.0], # Permanent income growth factor\n", + "\n", + " \"CubicBool\":False,\n", + " \"vFuncBool\":True,\n", + " \"aXtraMin\":0.00001, # Minimum end-of-period assets in grid\n", + " \"aXtraMax\":40, # Maximum end-of-period assets in grid\n", + " \"aXtraCount\":32, # Number of points in assets grid\n", + " \"aXtraExtra\":[None],\n", + " \"aXtraNestFac\":3, # Number of times to 'exponentially nest' when constructing assets grid\n", + " \"LivPrb\":[1.0], # Survival probability\n", + " # \"LivPrb\":[1.0 - 1.0/160.0], # Survival probability\n", + "\n", + " \"cycles\":0,\n", + " \"T_cycle\":1,\n", + " 'T_sim':50, # Number of periods to simulate (idiosyncratic shocks model, perpetual youth)\n", + " 'T_age': 100,\n", + " 'IndL': 1.0, # Labor supply per individual (constant)\n", + " 'aNrmInitMean':np.log(0.00001),\n", + " 'aNrmInitStd':0.0,\n", + " 'pLvlInitMean':0.0,\n", + " 'pLvlInitStd':0.0,\n", + " 'AgentCount':100,\n", + " 'MgridBase': np.array([0.1,0.3,0.6,\n", + " 0.8,0.9,0.98,\n", + " 1.0,1.02,1.1,\n", + " 1.2,1.6,2.0,\n", + " 3.0]), # Grid of capital-to-labor-ratios (factors)\n", + " 'PermGroFacAgg': 1.0,\n", + "\n", + " # Variables necessary for AggShockConsumerType_tax model\n", + " 'tax_rate':0.00,\n", + "\n", + " # Parameters describing the income process\n", + " # New Parameters that we need now\n", + " 'PermShkAggStd' : [0.0], # Standard deviation of log aggregate permanent shocks by state. No continous shocks in a state.\n", + " 'TranShkAggStd' : [0.0], # Standard deviation of log aggregate transitory shocks by state. No continuous shocks in a state.\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6b59cab9-deec-4cd2-8ff5-7f13297dc6b8", + "metadata": {}, + "outputs": [], + "source": [ + "# Code source: https://github.com/econ-ark/HARK/blob/master/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb\n", + "# See also, on HARK.core.Market: https://hark.readthedocs.io/en/latest/reference/tools/core.html#HARK.core.Market\n", + "# For details on Krusell-Smith model in HARK: https://github.com/econ-ark/KrusellSmith/blob/master/Code/Python/KrusellSmith.ipynb\n", + "# See also: https://github.com/econ-ark/HARK/blob/master/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb\n", + "\n", + "AggShockAgent_tax = AggShockConsumerType_tax(**AgentParameters)" + ] + }, + { + "cell_type": "markdown", + "id": "167dacd2", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "I create a new Market class, `CobbDouglasEconomy_tax`, to account for the fact that flat income tax rates have distortionary effects on output and therefore income. The trade-off is that higher tax rates lead to higher transfers to the median voter, but also incur greater productive inefficiencies and therefore decreases aggregate output and thus aggregate income.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d476e500-624c-4bc8-ae78-4d22901fd8dd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "EconomyExample = CobbDouglasEconomy_tax(agents=[AggShockAgent_tax], PermShkAggCount = 1, TranShkAggCount = 1,\n", + " PermShkAggStd = 0.0, TranShkAggStd = 0.0, DeprFac = 0.025, PermGroFacAgg = 1.0,\n", + " AggregateL = 1.0, CapShare = 0.36, CRRA = 4.0, tolerance = 0.01, tax_rate = 0.00)" + ] + }, + { + "cell_type": "markdown", + "id": "183e4573", + "metadata": {}, + "source": [ + "I then solve for the model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f5592aac-9677-4951-9c3c-8b675d7c971f", + "metadata": {}, + "outputs": [], + "source": [ + "# Have the consumers inherit relevant objects from the economy\n", + "AggShockAgent_tax.get_economy_data(EconomyExample)\n", + "\n", + "# Simulate a history of aggregate shocks\n", + "EconomyExample.make_AggShkHist()\n", + "\n", + "# Solve for aggregate shock consumer model\n", + "AggShockAgent_tax.solve()\n", + "AggShockAgent_tax.track_vars = ['pLvl','TranShk']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "71c66623-6ff5-485a-8815-431c2be0764a", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\n", + "intercept=-0.4105444080600119, slope=1.125591755269752, r-sq=0.8751220283100419\n", + "intercept=-0.5773773336944872, slope=1.1758308616806983, r-sq=0.7832480696460743\n", + "intercept=-0.6143577175394321, slope=1.1769354543417325, r-sq=0.7775438351465407\n", + "intercept=-0.6007363390178455, slope=1.1626718040790442, r-sq=0.7970695854316208\n", + "intercept=-0.5690387254827868, slope=1.144596971056191, r-sq=0.8063777583962056\n", + "intercept=-0.5468314979996045, slope=1.1330227287075487, r-sq=0.8063809444926041\n", + "intercept=-0.5361412473190595, slope=1.1275020394502473, r-sq=0.8088097539216079\n", + "intercept=-0.5311542259396487, slope=1.1249304315188215, r-sq=0.8099901725510611\n" + ] + } + ], + "source": [ + "# Solve the \"macroeconomic\" model by searching for a \"fixed point dynamic rule\"\n", + "print(\"Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\")\n", + "EconomyExample.solve()" + ] + }, + { + "cell_type": "markdown", + "id": "f56a211b", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Consumption function at each aggregate market resources-to-labor ratio gridpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b247866", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function at each aggregate market resources-to-labor ratio gridpoint:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "AggShockAgent_tax.unpack('cFunc')\n", + "\n", + "print(\"Consumption function at each aggregate market resources-to-labor ratio gridpoint:\")\n", + "m_grid = np.linspace(0, 5, 200)\n", + "for M in AggShockAgent_tax.Mgrid.tolist():\n", + " mMin = AggShockAgent_tax.solution[0].mNrmMin(M)\n", + " c_at_this_M = AggShockAgent_tax.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", + " plt.plot(m_grid + mMin, c_at_this_M)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8e041354", + "metadata": {}, + "source": [ + "Value function at each aggregate market resources-to-labor ratio gridpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3141f9c5", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value function at each aggregate market resources-to-labor ratio gridpoint:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "AggShockAgent_tax.unpack('vFunc')\n", + "\n", + "print(\"Value function at each aggregate market resources-to-labor ratio gridpoint:\")\n", + "m_grid = np.linspace(0, 5, 200)\n", + "for M in AggShockAgent_tax.Mgrid.tolist():\n", + " mMin = AggShockAgent_tax.solution[0].mNrmMin(M)+0.5\n", + " v_at_this_M = AggShockAgent_tax.vFunc[0](m_grid + mMin, M * np.ones_like(m_grid))\n", + " plt.plot(m_grid + mMin, v_at_this_M)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8f2e560d", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Summary Statistics for Agents' Wealth and Income " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bf1f7e9b-1ee3-43a4-a313-264e13c90dd0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The lump-sum transfer in terms of permanent income is: 0.0\n", + "The mean of individual market resources is 17.209977576559048; the standard deviation is 4.400319630466238; the median is 16.418608939597988.\n", + "The mean of individual wealth is 14.981784923214564; the standard deviation is 4.153142622717656; the median is 14.234446679033013.\n", + "The median level of market resources is: 16.418608939597988\n" + ] + } + ], + "source": [ + "# Normalized market resources of each agent\n", + "sim_market_resources = AggShockAgent_tax.state_now['mNrm']\n", + "\n", + "# Normalized assets of each agent\n", + "sim_wealth = AggShockAgent_tax.state_now['aNrm']\n", + "\n", + "# Summary Statistics\n", + "\n", + "# Lump-sum transfers are calculated through AggShockConsumerType_tax.calc_transfers() method:\n", + "print(\"The lump-sum transfer in terms of permanent income is: \" + str(AggShockAgent_tax.calc_transfers()))\n", + "\n", + "print(\"The mean of individual market resources is \" + str(sim_market_resources.mean()) + \"; the standard deviation is \"\n", + " + str(sim_market_resources.std()) + \"; the median is \" + str(np.median(sim_market_resources)) + \".\")\n", + "print(\"The mean of individual wealth is \" + str(sim_wealth.mean()) + \"; the standard deviation is \"\n", + " + str(sim_wealth.std()) + \"; the median is \" + str(np.median(sim_wealth)) + \".\")\n", + "\n", + "print(\"The median level of market resources is: \" + str(np.median(AggShockAgent_tax.state_now['mNrm'])))" + ] + }, + { + "cell_type": "markdown", + "id": "47704b66", + "metadata": {}, + "source": [ + "So far, the model generatse far too little wealth inequality, as seen by the graph of the Lorenz curve of the wealth distribution below:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4a61f5a0-c60e-41bd-ada6-0efe880cb0b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Lorenz Curve of Wealth Distribution\n", + "\n", + "from HARK.datasets import load_SCF_wealth_weights\n", + "from HARK.utilities import get_lorenz_shares, get_percentiles\n", + "\n", + "SCF_wealth, SCF_weights = load_SCF_wealth_weights()\n", + "\n", + "pctiles = np.linspace(0.001,0.999,200)\n", + "\n", + "SCF_Lorenz_points = get_lorenz_shares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = get_lorenz_shares(sim_wealth,percentiles=pctiles)\n", + "plt.plot(pctiles,pctiles,'-r')\n", + "plt.plot(pctiles,SCF_Lorenz_points,'--k')\n", + "plt.plot(pctiles,sim_Lorenz_points,'-b')\n", + "plt.xlabel('Percentile of net worth')\n", + "plt.ylabel('Cumulative share of wealth')\n", + "plt.show(block=False)" + ] + }, + { + "cell_type": "markdown", + "id": "1f575e26", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### The method for determining the optimal tax rate for the median voter is as follows:\n", + "\n", + "1. Create a grid of tax rates.\n", + "2. For each tax rate, use the procedure above to compute each agent's normalized market resources (and asset).\n", + "3. Given the array of normalized market resources, we locate the median level of market resources as the median agent, then compute their value function at their level of market resources.\n", + "4. Record the value function of the median agent at the given tax rate.\n", + "5. Repeat steps 2 to 4 until we have solved for the median agent's value function at each tax rate. The tax rate corresponding to the highest value of the median agent's value function is the optimal tax rate **for the median voter**, hence the political equilibrium (flat income tax rate)." + ] + }, + { + "cell_type": "markdown", + "id": "0e4f4099", + "metadata": {}, + "source": [ + "For tax rates, I create a 20 $\\times$ 1 grid of tax rates from 0.00 to 0.95.\n", + "\n", + "For reference (and to reduce computing time), in the for loop code below I calculate the optimal tax rate for agents with their wealth in the 10th, 20th, and up to 90th percentiles." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8e6d627b-c3c7-4ab5-ab3f-97f6687a8d74", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.0000\n", + "The lump-sum transfer in terms of permanent income is: 0.0000\n", + "The mean of individual wealth is 1.6152; the standard deviation is 1.1373366189717646; the median is 1.5974.\n", + "The mean of individual market resources is 3.3754; the standard deviation is 1.4259230889521275; the median is 3.4264.\n", + "The 90th percentile of individual wealth is 3.2004.\n", + "The 80th percentile of individual wealth is 2.6403.\n", + "The 70th percentile of individual wealth is 2.0155.\n", + "The 60th percentile of individual wealth is 1.7983.\n", + "The median of individual wealth is 1.5974.\n", + "The 40th percentile of individual wealth is 1.0583.\n", + "The 30th percentile of individual wealth is 0.8105.\n", + "The 20th percentile of individual wealth is 0.5695.\n", + "The 10th percentile of individual wealth is 0.3880.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.0500\n", + "The lump-sum transfer in terms of permanent income is: 0.0854\n", + "The mean of individual wealth is 1.5748; the standard deviation is 1.0714290458669407; the median is 1.5656.\n", + "The mean of individual market resources is 3.3332; the standard deviation is 1.3444825044181996; the median is 3.3874.\n", + "The 90th percentile of individual wealth is 3.0626.\n", + "The 80th percentile of individual wealth is 2.5094.\n", + "The 70th percentile of individual wealth is 1.9663.\n", + "The 60th percentile of individual wealth is 1.7630.\n", + "The median of individual wealth is 1.5656.\n", + "The 40th percentile of individual wealth is 1.0590.\n", + "The 30th percentile of individual wealth is 0.8263.\n", + "The 20th percentile of individual wealth is 0.5900.\n", + "The 10th percentile of individual wealth is 0.4048.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.1000\n", + "The lump-sum transfer in terms of permanent income is: 0.1707\n", + "The mean of individual wealth is 1.5369; the standard deviation is 1.0066276298249914; the median is 1.5348.\n", + "The mean of individual market resources is 3.2931; the standard deviation is 1.2647573137114339; the median is 3.3495.\n", + "The 90th percentile of individual wealth is 2.9307.\n", + "The 80th percentile of individual wealth is 2.3850.\n", + "The 70th percentile of individual wealth is 1.9176.\n", + "The 60th percentile of individual wealth is 1.7301.\n", + "The median of individual wealth is 1.5348.\n", + "The 40th percentile of individual wealth is 1.0601.\n", + "The 30th percentile of individual wealth is 0.8428.\n", + "The 20th percentile of individual wealth is 0.6133.\n", + "The 10th percentile of individual wealth is 0.4306.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.1500\n", + "The lump-sum transfer in terms of permanent income is: 0.2558\n", + "The mean of individual wealth is 1.5019; the standard deviation is 0.9425527162442904; the median is 1.5084.\n", + "The mean of individual market resources is 3.2558; the standard deviation is 1.1865037694883243; the median is 3.3171.\n", + "The 90th percentile of individual wealth is 2.8030.\n", + "The 80th percentile of individual wealth is 2.2719.\n", + "The 70th percentile of individual wealth is 1.8698.\n", + "The 60th percentile of individual wealth is 1.6981.\n", + "The median of individual wealth is 1.5084.\n", + "The 40th percentile of individual wealth is 1.0624.\n", + "The 30th percentile of individual wealth is 0.8594.\n", + "The 20th percentile of individual wealth is 0.6396.\n", + "The 10th percentile of individual wealth is 0.4488.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.2000\n", + "The lump-sum transfer in terms of permanent income is: 0.3408\n", + "The mean of individual wealth is 1.4693; the standard deviation is 0.8797683997815959; the median is 1.4851.\n", + "The mean of individual market resources is 3.2211; the standard deviation is 1.1091670100871052; the median is 3.2886.\n", + "The 90th percentile of individual wealth is 2.6819.\n", + "The 80th percentile of individual wealth is 2.1686.\n", + "The 70th percentile of individual wealth is 1.8256.\n", + "The 60th percentile of individual wealth is 1.6668.\n", + "The median of individual wealth is 1.4851.\n", + "The 40th percentile of individual wealth is 1.0653.\n", + "The 30th percentile of individual wealth is 0.8769.\n", + "The 20th percentile of individual wealth is 0.6694.\n", + "The 10th percentile of individual wealth is 0.4440.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.2500\n", + "The lump-sum transfer in terms of permanent income is: 0.4257\n", + "The mean of individual wealth is 1.4390; the standard deviation is 0.8185711901903785; the median is 1.4633.\n", + "The mean of individual market resources is 3.1891; the standard deviation is 1.0333752680278874; the median is 3.2616.\n", + "The 90th percentile of individual wealth is 2.5594.\n", + "The 80th percentile of individual wealth is 2.0709.\n", + "The 70th percentile of individual wealth is 1.7823.\n", + "The 60th percentile of individual wealth is 1.6358.\n", + "The median of individual wealth is 1.4633.\n", + "The 40th percentile of individual wealth is 1.0691.\n", + "The 30th percentile of individual wealth is 0.8895.\n", + "The 20th percentile of individual wealth is 0.6964.\n", + "The 10th percentile of individual wealth is 0.4496.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.3000\n", + "The lump-sum transfer in terms of permanent income is: 0.5105\n", + "The mean of individual wealth is 1.4112; the standard deviation is 0.7583331889418846; the median is 1.4414.\n", + "The mean of individual market resources is 3.1598; the standard deviation is 0.9583674440519271; the median is 3.2344.\n", + "The 90th percentile of individual wealth is 2.4515.\n", + "The 80th percentile of individual wealth is 1.9747.\n", + "The 70th percentile of individual wealth is 1.7392.\n", + "The 60th percentile of individual wealth is 1.6054.\n", + "The median of individual wealth is 1.4414.\n", + "The 40th percentile of individual wealth is 1.0736.\n", + "The 30th percentile of individual wealth is 0.9016.\n", + "The 20th percentile of individual wealth is 0.7217.\n", + "The 10th percentile of individual wealth is 0.4750.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.3500\n", + "The lump-sum transfer in terms of permanent income is: 0.5953\n", + "The mean of individual wealth is 1.3856; the standard deviation is 0.6988534721259945; the median is 1.4169.\n", + "The mean of individual market resources is 3.1328; the standard deviation is 0.8841353664226425; the median is 3.2037.\n", + "The 90th percentile of individual wealth is 2.3416.\n", + "The 80th percentile of individual wealth is 1.9091.\n", + "The 70th percentile of individual wealth is 1.6976.\n", + "The 60th percentile of individual wealth is 1.5745.\n", + "The median of individual wealth is 1.4169.\n", + "The 40th percentile of individual wealth is 1.0791.\n", + "The 30th percentile of individual wealth is 0.9165.\n", + "The 20th percentile of individual wealth is 0.7473.\n", + "The 10th percentile of individual wealth is 0.5118.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.4000\n", + "The lump-sum transfer in terms of permanent income is: 0.6800\n", + "The mean of individual wealth is 1.3623; the standard deviation is 0.6405593018138305; the median is 1.3931.\n", + "The mean of individual market resources is 3.1083; the standard deviation is 0.8109795580122193; the median is 3.1736.\n", + "The 90th percentile of individual wealth is 2.2362.\n", + "The 80th percentile of individual wealth is 1.8488.\n", + "The 70th percentile of individual wealth is 1.6569.\n", + "The 60th percentile of individual wealth is 1.5434.\n", + "The median of individual wealth is 1.3931.\n", + "The 40th percentile of individual wealth is 1.0853.\n", + "The 30th percentile of individual wealth is 0.9337.\n", + "The 20th percentile of individual wealth is 0.7756.\n", + "The 10th percentile of individual wealth is 0.5548.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.4500\n", + "The lump-sum transfer in terms of permanent income is: 0.7646\n", + "The mean of individual wealth is 1.3410; the standard deviation is 0.5833032342349028; the median is 1.3700.\n", + "The mean of individual market resources is 3.0860; the standard deviation is 0.7388351961625467; the median is 3.1445.\n", + "The 90th percentile of individual wealth is 2.1357.\n", + "The 80th percentile of individual wealth is 1.7904.\n", + "The 70th percentile of individual wealth is 1.6173.\n", + "The 60th percentile of individual wealth is 1.5121.\n", + "The median of individual wealth is 1.3700.\n", + "The 40th percentile of individual wealth is 1.0939.\n", + "The 30th percentile of individual wealth is 0.9513.\n", + "The 20th percentile of individual wealth is 0.8059.\n", + "The 10th percentile of individual wealth is 0.6010.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.5000\n", + "The lump-sum transfer in terms of permanent income is: 0.8491\n", + "The mean of individual wealth is 1.3219; the standard deviation is 0.5267598218139468; the median is 1.3488.\n", + "The mean of individual market resources is 3.0659; the standard deviation is 0.6677477677191371; the median is 3.1176.\n", + "The 90th percentile of individual wealth is 2.0377.\n", + "The 80th percentile of individual wealth is 1.7337.\n", + "The 70th percentile of individual wealth is 1.5778.\n", + "The 60th percentile of individual wealth is 1.4814.\n", + "The median of individual wealth is 1.3488.\n", + "The 40th percentile of individual wealth is 1.1034.\n", + "The 30th percentile of individual wealth is 0.9700.\n", + "The 20th percentile of individual wealth is 0.8390.\n", + "The 10th percentile of individual wealth is 0.6495.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.5500\n", + "The lump-sum transfer in terms of permanent income is: 0.9337\n", + "The mean of individual wealth is 1.3049; the standard deviation is 0.4709080382935694; the median is 1.3329.\n", + "The mean of individual market resources is 3.0480; the standard deviation is 0.5973544529624285; the median is 3.0976.\n", + "The 90th percentile of individual wealth is 1.9401.\n", + "The 80th percentile of individual wealth is 1.6779.\n", + "The 70th percentile of individual wealth is 1.5378.\n", + "The 60th percentile of individual wealth is 1.4522.\n", + "The median of individual wealth is 1.3329.\n", + "The 40th percentile of individual wealth is 1.1134.\n", + "The 30th percentile of individual wealth is 0.9899.\n", + "The 20th percentile of individual wealth is 0.8749.\n", + "The 10th percentile of individual wealth is 0.6959.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.6000\n", + "The lump-sum transfer in terms of permanent income is: 1.0182\n", + "The mean of individual wealth is 1.2899; the standard deviation is 0.4158368452258919; the median is 1.3197.\n", + "The mean of individual market resources is 3.0322; the standard deviation is 0.5278107660477036; the median is 3.0809.\n", + "The 90th percentile of individual wealth is 1.8436.\n", + "The 80th percentile of individual wealth is 1.6186.\n", + "The 70th percentile of individual wealth is 1.4992.\n", + "The 60th percentile of individual wealth is 1.4242.\n", + "The median of individual wealth is 1.3197.\n", + "The 40th percentile of individual wealth is 1.1239.\n", + "The 30th percentile of individual wealth is 1.0107.\n", + "The 20th percentile of individual wealth is 0.9111.\n", + "The 10th percentile of individual wealth is 0.7510.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.6500\n", + "The lump-sum transfer in terms of permanent income is: 1.1027\n", + "The mean of individual wealth is 1.2766; the standard deviation is 0.36135567791924733; the median is 1.3065.\n", + "The mean of individual market resources is 3.0182; the standard deviation is 0.45895175878646766; the median is 3.0643.\n", + "The 90th percentile of individual wealth is 1.7529.\n", + "The 80th percentile of individual wealth is 1.5552.\n", + "The 70th percentile of individual wealth is 1.4605.\n", + "The 60th percentile of individual wealth is 1.3961.\n", + "The median of individual wealth is 1.3065.\n", + "The 40th percentile of individual wealth is 1.1348.\n", + "The 30th percentile of individual wealth is 1.0346.\n", + "The 20th percentile of individual wealth is 0.9476.\n", + "The 10th percentile of individual wealth is 0.8059.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.7000\n", + "The lump-sum transfer in terms of permanent income is: 1.1873\n", + "The mean of individual wealth is 1.2652; the standard deviation is 0.30781299157303355; the median is 1.2938.\n", + "The mean of individual market resources is 3.0061; the standard deviation is 0.3909826989677497; the median is 3.0482.\n", + "The 90th percentile of individual wealth is 1.6743.\n", + "The 80th percentile of individual wealth is 1.4987.\n", + "The 70th percentile of individual wealth is 1.4248.\n", + "The 60th percentile of individual wealth is 1.3696.\n", + "The median of individual wealth is 1.2938.\n", + "The 40th percentile of individual wealth is 1.1471.\n", + "The 30th percentile of individual wealth is 1.0593.\n", + "The 20th percentile of individual wealth is 0.9847.\n", + "The 10th percentile of individual wealth is 0.8638.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.7500\n", + "The lump-sum transfer in terms of permanent income is: 1.2718\n", + "The mean of individual wealth is 1.2556; the standard deviation is 0.25505636247846414; the median is 1.2822.\n", + "The mean of individual market resources is 2.9959; the standard deviation is 0.32393688137019283; the median is 3.0335.\n", + "The 90th percentile of individual wealth is 1.5946.\n", + "The 80th percentile of individual wealth is 1.4489.\n", + "The 70th percentile of individual wealth is 1.3897.\n", + "The 60th percentile of individual wealth is 1.3440.\n", + "The median of individual wealth is 1.2822.\n", + "The 40th percentile of individual wealth is 1.1602.\n", + "The 30th percentile of individual wealth is 1.0849.\n", + "The 20th percentile of individual wealth is 1.0236.\n", + "The 10th percentile of individual wealth is 0.9227.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.8000\n", + "The lump-sum transfer in terms of permanent income is: 1.3563\n", + "The mean of individual wealth is 1.2478; the standard deviation is 0.20292086959984096; the median is 1.2707.\n", + "The mean of individual market resources is 2.9877; the standard deviation is 0.2577239580096911; the median is 3.0191.\n", + "The 90th percentile of individual wealth is 1.5157.\n", + "The 80th percentile of individual wealth is 1.4011.\n", + "The 70th percentile of individual wealth is 1.3536.\n", + "The 60th percentile of individual wealth is 1.3196.\n", + "The median of individual wealth is 1.2707.\n", + "The 40th percentile of individual wealth is 1.1741.\n", + "The 30th percentile of individual wealth is 1.1123.\n", + "The 20th percentile of individual wealth is 1.0622.\n", + "The 10th percentile of individual wealth is 0.9827.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.8500\n", + "The lump-sum transfer in terms of permanent income is: 1.4409\n", + "The mean of individual wealth is 1.2415; the standard deviation is 0.15152449997491307; the median is 1.2597.\n", + "The mean of individual market resources is 2.9811; the standard deviation is 0.19237219236114972; the median is 3.0052.\n", + "The 90th percentile of individual wealth is 1.4395.\n", + "The 80th percentile of individual wealth is 1.3553.\n", + "The 70th percentile of individual wealth is 1.3197.\n", + "The 60th percentile of individual wealth is 1.2972.\n", + "The median of individual wealth is 1.2597.\n", + "The 40th percentile of individual wealth is 1.1885.\n", + "The 30th percentile of individual wealth is 1.1410.\n", + "The 20th percentile of individual wealth is 1.1026.\n", + "The 10th percentile of individual wealth is 1.0438.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.9000\n", + "The lump-sum transfer in terms of permanent income is: 1.5255\n", + "The mean of individual wealth is 1.2373; the standard deviation is 0.10086260227471801; the median is 1.2498.\n", + "The mean of individual market resources is 2.9766; the standard deviation is 0.12778456908404473; the median is 2.9926.\n", + "The 90th percentile of individual wealth is 1.3677.\n", + "The 80th percentile of individual wealth is 1.3137.\n", + "The 70th percentile of individual wealth is 1.2893.\n", + "The 60th percentile of individual wealth is 1.2758.\n", + "The median of individual wealth is 1.2498.\n", + "The 40th percentile of individual wealth is 1.2037.\n", + "The 30th percentile of individual wealth is 1.1716.\n", + "The 20th percentile of individual wealth is 1.1454.\n", + "The 10th percentile of individual wealth is 1.1054.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", + "The flat income tax rate is: 0.9500\n", + "The lump-sum transfer in terms of permanent income is: 1.6102\n", + "The mean of individual wealth is 1.2356; the standard deviation is 0.05031191420969742; the median is 1.2422.\n", + "The mean of individual market resources is 2.9747; the standard deviation is 0.06354821655377278; the median is 2.9830.\n", + "The 90th percentile of individual wealth is 1.3001.\n", + "The 80th percentile of individual wealth is 1.2739.\n", + "The 70th percentile of individual wealth is 1.2619.\n", + "The 60th percentile of individual wealth is 1.2554.\n", + "The median of individual wealth is 1.2422.\n", + "The 40th percentile of individual wealth is 1.2193.\n", + "The 30th percentile of individual wealth is 1.2032.\n", + "The 20th percentile of individual wealth is 1.1898.\n", + "The 10th percentile of individual wealth is 1.1699.\n", + "\n" + ] + } + ], + "source": [ + "rates = 20\n", + "tax_rates = np.linspace(0.00, 0.95, num=rates)\n", + "\n", + "v_at_p90_wealth = [] # Vector for value function of 90th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p80_wealth = [] # Vector for value function of 80th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p70_wealth = [] # Vector for value function of 70th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p60_wealth = [] # Vector for value function of 60th percentile wealth agent at each level of flat income tax rate\n", + "v_at_median_wealth = [] # Vector for value function of median wealth agent at each level of flat income tax rate\n", + "v_at_p40_wealth = [] # Vector for value function of 40th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p30_wealth = [] # Vector for value function of 30th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p20_wealth = [] # Vector for value function of 20th percentile wealth agent at each level of flat income tax rate\n", + "v_at_p10_wealth = [] # Vector for value function of 10th percentile wealth agent at each level of flat income tax rate\n", + "\n", + "for tau in tax_rates:\n", + "\n", + " AggShockAgent_tax_tau = deepcopy(AggShockAgent_tax)\n", + " AggShockAgent_tax_tau.tax_rate = tau\n", + " EconomyExample_tau = deepcopy(EconomyExample)\n", + " EconomyExample_tau.tax_rate = tau\n", + " AggShockAgent_tax_tau.get_economy_data(EconomyExample_tau)\n", + " EconomyExample_tau.make_AggShkHist()\n", + " AggShockAgent_tax_tau.solve()\n", + " AggShockAgent_tax_tau.initialize_sim()\n", + " AggShockAgent_tax_tau.simulate()\n", + " AggShockAgent_tax_tau.track_vars = ['aNrm','pLvl','mNrm','TranShk']\n", + " EconomyExample_tau.solve()\n", + " AggShockAgent_tax_tau.unpack('vFunc')\n", + "\n", + " sim_market_resources_tau = AggShockAgent_tax_tau.state_now['mNrm']\n", + " sim_wealth_tau = AggShockAgent_tax_tau.state_now['aNrm']\n", + " \n", + " print(\"The flat income tax rate is: \" + mystr(AggShockAgent_tax_tau.tax_rate))\n", + "\n", + " print(\"The lump-sum transfer in terms of permanent income is: \" + mystr(AggShockAgent_tax_tau.calc_transfers()))\n", + "\n", + " print(\"The mean of individual wealth is \" + mystr(sim_wealth_tau.mean()) + \"; the standard deviation is \"\n", + " + str(sim_wealth_tau.std()) + \"; the median is \" + mystr(np.median(sim_wealth_tau)) + \".\")\n", + " print(\"The mean of individual market resources is \" + mystr(sim_market_resources_tau.mean()) + \"; the standard deviation is \"\n", + " + str(sim_market_resources_tau.std()) + \"; the median is \" + mystr(np.median(sim_market_resources_tau)) + \".\")\n", + " print(\"The 90th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,90)) + \".\")\n", + " print(\"The 80th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,80)) + \".\")\n", + " print(\"The 70th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,70)) + \".\")\n", + " print(\"The 60th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,60)) + \".\")\n", + " print(\"The median of individual wealth is \" + mystr(np.median(sim_wealth_tau)) + \".\")\n", + " print(\"The 40th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,40)) + \".\")\n", + " print(\"The 30th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,30)) + \".\")\n", + " print(\"The 20th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,20)) + \".\")\n", + " print(\"The 10th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,10)) + \".\\n\")\n", + " \n", + " # Tax rate as determined by agent (pre-tax)'s wealth and income\n", + " sim_p90_wealth_tau = np.percentile(sim_wealth_tau,90)\n", + " sim_p90_market_resources_tau = np.percentile(sim_market_resources_tau,90)\n", + " sim_p80_wealth_tau = np.percentile(sim_wealth_tau,80)\n", + " sim_p80_market_resources_tau = np.percentile(sim_market_resources_tau,80)\n", + " sim_p70_wealth_tau = np.percentile(sim_wealth_tau,70)\n", + " sim_p70_market_resources_tau = np.percentile(sim_market_resources_tau,70)\n", + " sim_p60_wealth_tau = np.percentile(sim_wealth_tau,60)\n", + " sim_p60_market_resources_tau = np.percentile(sim_market_resources_tau,60)\n", + " sim_median_wealth_tau = np.median(sim_wealth_tau)\n", + " sim_median_market_resources_tau = np.median(sim_market_resources_tau)\n", + " sim_p40_wealth_tau = np.percentile(sim_wealth_tau,40)\n", + " sim_p40_market_resources_tau = np.percentile(sim_market_resources_tau,40)\n", + " sim_p30_wealth_tau = np.percentile(sim_wealth_tau,30)\n", + " sim_p30_market_resources_tau = np.percentile(sim_market_resources_tau,30)\n", + " sim_p20_wealth_tau = np.percentile(sim_wealth_tau,20)\n", + " sim_p20_market_resources_tau = np.percentile(sim_market_resources_tau,20)\n", + " sim_p10_wealth_tau = np.percentile(sim_wealth_tau,10)\n", + " sim_p10_market_resources_tau = np.percentile(sim_market_resources_tau,10)\n", + " # Find value function of post-tax Xth-percentile wealth agent/voter, with X taking values from 10 to 90\n", + " # vFunc arguments: Each agent's level of market resources\n", + " # and median agent's capital-labor ratio (assumed as 1.0 for now)\n", + " v_at_p90_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p90_market_resources_tau, 1.0)\n", + " v_at_p80_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p80_market_resources_tau, 1.0)\n", + " v_at_p70_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p70_market_resources_tau, 1.0)\n", + " v_at_p60_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p60_market_resources_tau, 1.0)\n", + " v_at_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau, 1.0)\n", + " v_at_p40_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p40_market_resources_tau, 1.0)\n", + " v_at_p30_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p30_market_resources_tau, 1.0)\n", + " v_at_p20_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p20_market_resources_tau, 1.0)\n", + " v_at_p10_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p10_market_resources_tau, 1.0)\n", + "\n", + " v_at_p90_wealth.append(v_at_p90_wealth_tau)\n", + " v_at_p80_wealth.append(v_at_p80_wealth_tau)\n", + " v_at_p70_wealth.append(v_at_p70_wealth_tau)\n", + " v_at_p60_wealth.append(v_at_p60_wealth_tau)\n", + " v_at_median_wealth.append(v_at_median_wealth_tau)\n", + " v_at_p40_wealth.append(v_at_p40_wealth_tau)\n", + " v_at_p30_wealth.append(v_at_p30_wealth_tau)\n", + " v_at_p20_wealth.append(v_at_p20_wealth_tau)\n", + " v_at_p10_wealth.append(v_at_p10_wealth_tau)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1ce75045-7f2e-4248-82bb-4f9a15d12303", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.18024185069296117, -0.18317580502027975, -0.1860943631876579, -0.18863797524560463, -0.19091539573104457, -0.19331515020503487, -0.19578321513387012, -0.19863371576492914, -0.20146974527626826, -0.20427111010720223, -0.20689967041648563, -0.208894082770684, -0.21057150198480734, -0.21225877485094602, -0.21389641664241943, -0.21538697127150086, -0.21687049297348124, -0.2183058299162628, -0.2196147425502362, -0.22062562463681654]\n", + "-0.1802\n", + "The optimal tax rate for the median voter is 0.0000.\n" + ] + } + ], + "source": [ + "# Create graph of value function of agent with median level of wealth for each tax rate from 0.00 to 0.95 (in increments of 0.05)\n", + "print(v_at_median_wealth)\n", + "print(mystr(np.max(v_at_median_wealth)))\n", + "optimal_tax_rate = tax_rates[v_at_median_wealth.index(np.max(v_at_median_wealth))]\n", + "print(\"The optimal tax rate for the median voter is \" + str(mystr(optimal_tax_rate)) + \".\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c9f6f0a4-0155-4f25-b15b-9a26ccddc502", + "metadata": { + "scrolled": false, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(7,4))\n", + "plt.plot(tax_rates, v_at_median_wealth, 'b-', label = 'Value function of median wealth agent')\n", + "plt.xlabel('Flat income tax rate')\n", + "plt.ylabel('Value function of median wealth agent')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "16fb31a4", + "metadata": {}, + "source": [ + "The graph above shows the value function for the median wealth agent at tax rates from 0\\% to 95\\% (in 5\\% increments). We see that the value function generally decreases linearly.\n", + "\n", + "Ideally, the graph would show single-peaked preferences for the median wealth agent, with a roughly parabolic value function." + ] + }, + { + "cell_type": "markdown", + "id": "9e14a0e8-efab-4647-850e-a8909e965d09", + "metadata": {}, + "source": [ + "### So far, the problem is that the median pre-tax wealth is already greater than the mean pre-tax wealth, and so the median voter most prefers an income tax rate of 0.\n", + "\n", + "What would be the optimal tax rate for agents with wealth / market resources of other percentiles?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "29ebd769-075f-45a9-af40-23fcabd8b2d1", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(13,6))\n", + "plt.plot(tax_rates, v_at_p90_wealth, 'r--', label = 'Value function of p90 wealth agent')\n", + "plt.plot(tax_rates, v_at_p80_wealth, 'g--', label = 'Value function of p80 wealth agent')\n", + "plt.plot(tax_rates, v_at_p70_wealth, 'b--', label = 'Value function of p70 wealth agent')\n", + "plt.plot(tax_rates, v_at_p60_wealth, 'y--', label = 'Value function of p60 wealth agent')\n", + "plt.plot(tax_rates, v_at_median_wealth, 'k-', label = 'Value function of median wealth agent')\n", + "plt.plot(tax_rates, v_at_p40_wealth, 'r-', label = 'Value function of p40 wealth agent')\n", + "plt.plot(tax_rates, v_at_p30_wealth, 'g-', label = 'Value function of p30 wealth agent')\n", + "plt.plot(tax_rates, v_at_p20_wealth, 'b-', label = 'Value function of p20 wealth agent')\n", + "plt.plot(tax_rates, v_at_p10_wealth, 'y-', label = 'Value function of p10 wealth agent')\n", + "\n", + "plt.xlabel('Flat income tax rate')\n", + "plt.ylabel('Value function of agents')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "52a25c9d", + "metadata": {}, + "source": [ + "The graph above shows the value function for an agent at the 10th, 20th, and up to 90th percentile of the wealth distribution at tax rates from 0\\% to 95\\% (in 5\\% increments). We see that the value function generally increases linearly for agents with relatively lower levels of wealth (up to the 40th percentile, or `p40 wealth agent`), but generally decreases linearly for agents with relatively higher levels of wealth (down to the 50th percnetile, or `median wealth agent`).\n", + "\n", + "Ideally, the graph would show single-peaked preferences for each agent, with the value functions being roughly parabolic and with their peaks at higher levels of tax rates for agents with relatively lower levels of wealth." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "064044b2-8897-4d41-bac0-c5f3fd10a199", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The optimal tax rate for the 90th percentile voter is 0.0000.\n", + "The optimal tax rate for the 80th percentile voter is 0.0000.\n", + "The optimal tax rate for the 70th percentile voter is 0.0000.\n", + "The optimal tax rate for the 60th percentile voter is 0.0000.\n", + "The optimal tax rate for the median voter is 0.0000.\n", + "The optimal tax rate for the 40th percentile voter is 0.9500.\n", + "The optimal tax rate for the 30th percentile voter is 0.9500.\n", + "The optimal tax rate for the 20th percentile voter is 0.9500.\n", + "The optimal tax rate for the 10th percentile voter is 0.9500.\n" + ] + } + ], + "source": [ + "optimal_tax_rate_p90 = tax_rates[v_at_p90_wealth.index(np.max(v_at_p90_wealth))]\n", + "optimal_tax_rate_p80 = tax_rates[v_at_p80_wealth.index(np.max(v_at_p80_wealth))]\n", + "optimal_tax_rate_p70 = tax_rates[v_at_p70_wealth.index(np.max(v_at_p70_wealth))]\n", + "optimal_tax_rate_p60 = tax_rates[v_at_p60_wealth.index(np.max(v_at_p60_wealth))]\n", + "optimal_tax_rate_median = tax_rates[v_at_median_wealth.index(np.max(v_at_median_wealth))]\n", + "optimal_tax_rate_p40 = tax_rates[v_at_p40_wealth.index(np.max(v_at_p40_wealth))]\n", + "optimal_tax_rate_p30 = tax_rates[v_at_p30_wealth.index(np.max(v_at_p30_wealth))]\n", + "optimal_tax_rate_p20 = tax_rates[v_at_p20_wealth.index(np.max(v_at_p20_wealth))]\n", + "optimal_tax_rate_p10 = tax_rates[v_at_p10_wealth.index(np.max(v_at_p10_wealth))]\n", + "\n", + "print(\"The optimal tax rate for the 90th percentile voter is \" + str(mystr(optimal_tax_rate_p90)) + \".\")\n", + "print(\"The optimal tax rate for the 80th percentile voter is \" + str(mystr(optimal_tax_rate_p80)) + \".\")\n", + "print(\"The optimal tax rate for the 70th percentile voter is \" + str(mystr(optimal_tax_rate_p70)) + \".\")\n", + "print(\"The optimal tax rate for the 60th percentile voter is \" + str(mystr(optimal_tax_rate_p60)) + \".\")\n", + "print(\"The optimal tax rate for the median voter is \" + str(mystr(optimal_tax_rate_median)) + \".\")\n", + "print(\"The optimal tax rate for the 40th percentile voter is \" + str(mystr(optimal_tax_rate_p40)) + \".\")\n", + "print(\"The optimal tax rate for the 30th percentile voter is \" + str(mystr(optimal_tax_rate_p30)) + \".\")\n", + "print(\"The optimal tax rate for the 20th percentile voter is \" + str(mystr(optimal_tax_rate_p20)) + \".\")\n", + "print(\"The optimal tax rate for the 10th percentile voter is \" + str(mystr(optimal_tax_rate_p10)) + \".\")" + ] + }, + { + "cell_type": "markdown", + "id": "2562716a", + "metadata": {}, + "source": [ + "So far, for agents in different percentiles of wealth still prefer a flat income tax rate of either zero or the maximum value (here, 0.95), which shows that the code so far does not result in single-peaked preferences of voters for tax rates. However, we do find that the optimal tax rate for agents with lower levels of wealth relative to others prefer a higher tax rate. This somewhat confirms that voters with lower levels of wealth will prefer higher levels of taxation and redistribution, and vice versa.\n", + "\n", + "In this simulation, we find that the bottom 40 percent of voters would vote for (nearly) full redistribution, whereas the top 60 percent would vote for zero redistribution. This would lead to a politically determined tax rate of 0\\%." + ] + }, + { + "cell_type": "markdown", + "id": "a7e521a4", + "metadata": {}, + "source": [ + "### Things to Improve Upon\n", + "\n", + "My replication, so far, is able to show how voters/agents with lower levels of wealth prefer a higher flat income tax rate and thus a higher level of redistribution than voters/agents with higher levels of wealth, thus satisfying a crucial result from Romer (1975) and Krusell and Rios-Rull (1999).\n", + "\n", + "However, my still fails to show single-peaked preferences for the flat income tax rate and thus the level of income redistribution of each voter/agent at their respective level of wealth / market resources.\n", + "\n", + "In further simulations (by changing parameter values), I find that changing the value of the CRRA coefficient or the standard deviation of the transitory idiosyncratic income shock does not substantially change the results of this replication in its current state: still not enough voters (around 40\\%) prefer a positive tax rate, resulting in zero redistribution.\n", + "\n", + "A significant part of the problem is that somehow the specifications so far lead to the median voter facing a post-tax decrease in market resources, thereby preferring to vote against any positive tax rate. The solution may lie in altering the parameters to the point where the lump-sum transfers that the median-wealth voter gets is greater than the loss in output / median-wealth voter's wealth through distortionary taxation.\n", + "\n", + "Alternatively, it may just be that the current `AggShockConsumerType` class simply assumes an exogenous labor supply of 1 (both for each agent and, in aggregate, mean). With an endogenous labor supply, a higher income tax rate would lower each agent's labor supply and increase each agent's leisure, thus leading to a higher value of the value function at higher tax rates than currently from the code. That may increase the optimal tax rate for some agents (particularly for the median agent), although I am not sure whether that would lead to single-peaked preferences as opposed to the linear shape of the curves above that we see right now." + ] + } + ], + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.py b/REMARKs/KRR99/code/python/Koh_KRR99.py new file mode 100644 index 00000000..b188f2b9 --- /dev/null +++ b/REMARKs/KRR99/code/python/Koh_KRR99.py @@ -0,0 +1,343 @@ +#!/usr/bin/env python +# coding: utf-8 + +# Import IndShockConsumerType +import HARK +import sys +from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, CobbDouglasEconomy, init_agg_shocks, + init_cobb_douglas, + solveConsAggShock, + AggregateSavingRule +) +from ConsAggShockModel_tax import * + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from copy import deepcopy +from HARK.utilities import plot_funcs, make_figs +import statsmodels.api as sm +from time import process_time +def mystr(number): + return "{:.4f}".format(number) + + + + +# **Krusell and Rios-Rull's parameters for income and wealth distribution:** +# +# Sorted by Wealth +# +#

Group 1 (49%): Household wealth = 0.30, Earnings = 0.57
+# Group 2 (2%): Household wealth = 1, Earnings = 1
+# Group 3 (49%): Household wealth = 4.78, Earnings = 1.91

+# +#

Sorted by Earnings
+# Group 1 (49%): Household wealth = 0.55, Earnings = 0.24
+# Group 2 (2%): Household wealth = 1, Earnings = 1
+# Group 3 (49%): Household wealth = 2.93, Earnings = 2.94

+# +# *Greater inequality in household wealth than in household earnings* + +# **Parameters in KRR99** +#

beta = 0.96 (Annual discount rate)
+# alpha = 0.429 (Utility weight of consumption)
+# sigma = 4 (Risk aversion parameter)
+# delta = 0.05 (Depreciation rate)
+# theta = 0.36 (Share of capital income)
+# Wealth-output ratio = 3.3
+# r = 0.06 (Pre-tax)
+# C/Y = 0.638 (Consumption-output ratio)
+# g/Y = 0.199 (Government spending-output ratio)
+# N = 0.34 (Labor hours)

+ + + +# Define a dictionary with calibrated parameters +AgentParameters = { + "CRRA": 4.00, # Coefficient of relative risk aversion + "DiscFac": 0.96, # Default intertemporal discount factor; dummy value, will be overwritten + "Rfree": 1.06, # Survival probability, + "PermShkCount" : 1, # Number of points in discrete approximation to permanent income shocks - no shocks of this kind! + "TranShkCount" : 3, # Number of points in discrete approximation to transitory income shocks - no shocks of this kind! + "PermShkStd" : [0.0], # Standard deviation of log permanent income shocks - no shocks of this kind! + "TranShkStd" : [0.5], # Standard deviation of log transitory income shocks - no shocks of this kind! + "UnempPrb" : 0.0, # Probability of unemployment while working - no shocks of this kind! + "UnempPrbRet" : 0.00, # Probability of "unemployment" while retired - no shocks of this kind! + "IncUnemp" : 0.0, # Unemployment benefits replacement rate + "IncUnempRet" : 0.0, # "Unemployment" benefits when retired + "T_retire" : 0, # Period of retirement (0 --> no retirement) + "BoroCnstArt" : 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets + "PermGroFac" : [1.0], # Permanent income growth factor + + "CubicBool":False, + "vFuncBool":True, + "aXtraMin":0.00001, # Minimum end-of-period assets in grid + "aXtraMax":40, # Maximum end-of-period assets in grid + "aXtraCount":32, # Number of points in assets grid + "aXtraExtra":[None], + "aXtraNestFac":3, # Number of times to 'exponentially nest' when constructing assets grid + "LivPrb":[1.0], # Survival probability + # "LivPrb":[1.0 - 1.0/160.0], # Survival probability + + "cycles":0, + "T_cycle":1, + 'T_sim':2, # Number of periods to simulate (idiosyncratic shocks model, perpetual youth) + 'T_age': 100, + 'IndL': 1.0, # Labor supply per individual (constant) + 'aNrmInitMean':np.log(0.00001), + 'aNrmInitStd':0.0, + 'pLvlInitMean':0.0, + 'pLvlInitStd':0.0, + 'AgentCount':100, + 'MgridBase': np.array([0.1,0.3,0.6, + 0.8,0.9,0.98, + 1.0,1.02,1.1, + 1.2,1.6,2.0, + 3.0]), # Grid of capital-to-labor-ratios (factors) + 'PermGroFacAgg': 1.0, + + # Variables necessary for AggShockConsumerType_tax model + 'tax_rate':0.00, + + # Parameters describing the income process + # New Parameters that we need now + 'PermShkAggStd' : [0.0], # Standard deviation of log aggregate permanent shocks by state. No continous shocks in a state. + 'TranShkAggStd' : [0.0], # Standard deviation of log aggregate transitory shocks by state. No continuous shocks in a state. +} + + +# Code source: https://github.com/econ-ark/HARK/blob/master/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb +# See also, on HARK.core.Market: https://hark.readthedocs.io/en/latest/reference/tools/core.html#HARK.core.Market +# For details on Krusell-Smith model in HARK: https://github.com/econ-ark/KrusellSmith/blob/master/Code/Python/KrusellSmith.ipynb +# See also: https://github.com/econ-ark/HARK/blob/master/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb + +# Define aggregate shock consumer (simplest consumer type possible that has both labor and assets/capital) +AggShockAgent_tax = AggShockConsumerType_tax(**AgentParameters) + + +# Create Cobb-Douglas economy with AggShockExample consumers +# EconomyExample = CobbDouglasEconomy(agents=[AggShockAgent_tax], **EconomyDictionary) +# Somehow the above method of applying parameters like the above line doesn't seem to work + +EconomyExample = CobbDouglasEconomy_tax(agents=[AggShockAgent_tax], PermShkAggCount = 1, TranShkAggCount = 1, + PermShkAggStd = 0.0, TranShkAggStd = 0.0, DeprFac = 0.05, PermGroFacAgg = 1.0, + AggregateL = 1.0, CapShare = 0.36, CRRA = 4.0, tolerance = 0.01, tax_rate = 0.00) + + +# Have the consumers inherit relevant objects from the economy +AggShockAgent_tax.get_economy_data(EconomyExample) + +# Simulate a history of aggregate shocks +EconomyExample.make_AggShkHist() + +# Solve for aggregate shock consumer model +AggShockAgent_tax.solve() +AggShockAgent_tax.track_vars = ['pLvl','TranShk'] + +# Solve the "macroeconomic" model by searching for a "fixed point dynamic rule" +print("Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...") +EconomyExample.solve() + +AggShockAgent_tax.unpack('cFunc') + +print("Consumption function at each aggregate market resources-to-labor ratio gridpoint:") +m_grid = np.linspace(0, 5, 200) +for M in AggShockAgent_tax.Mgrid.tolist(): + mMin = AggShockAgent_tax.solution[0].mNrmMin(M) + c_at_this_M = AggShockAgent_tax.cFunc[0](m_grid + mMin, M * np.ones_like(m_grid)) + plt.plot(m_grid + mMin, c_at_this_M) +plt.show() + +AggShockAgent_tax.unpack('vFunc') + +print("Value function at each aggregate market resources-to-labor ratio gridpoint:") +m_grid = np.linspace(0, 5, 200) +for M in AggShockAgent_tax.Mgrid.tolist(): + mMin = AggShockAgent_tax.solution[0].mNrmMin(M)+0.5 + v_at_this_M = AggShockAgent_tax.vFunc[0](m_grid + mMin, M * np.ones_like(m_grid)) + plt.plot(m_grid + mMin, v_at_this_M) +plt.show() + +# Normalized market resources of each agent +sim_market_resources = AggShockAgent_tax.state_now['mNrm'] + +# Normalized assets of each agent +sim_wealth = AggShockAgent_tax.state_now['aNrm'] + +# Summary Statistics + +# Lump-sum transfers are calculated through AggShockConsumerType_tax.calc_transfers() method: +print("The lump-sum transfer in terms of permanent income is: " + str(AggShockAgent_tax.calc_transfers())) + +print("The mean of individual market resources is " + str(sim_market_resources.mean()) + "; the standard deviation is " + + str(sim_market_resources.std()) + "; the median is " + str(np.median(sim_market_resources)) + ".") +print("The mean of individual wealth is " + str(sim_wealth.mean()) + "; the standard deviation is " + + str(sim_wealth.std()) + "; the median is " + str(np.median(sim_wealth)) + ".") + +print("The median level of market resources is: " + str(np.median(AggShockAgent_tax.state_now['mNrm']))) + +# Lorenz Curve of Wealth Distribution + +from HARK.datasets import load_SCF_wealth_weights +from HARK.utilities import get_lorenz_shares, get_percentiles + +SCF_wealth, SCF_weights = load_SCF_wealth_weights() + +pctiles = np.linspace(0.001,0.999,200) + +SCF_Lorenz_points = get_lorenz_shares(SCF_wealth,weights=SCF_weights,percentiles=pctiles) +sim_Lorenz_points = get_lorenz_shares(sim_wealth,percentiles=pctiles) +plt.plot(pctiles,pctiles,'-r') +plt.plot(pctiles,SCF_Lorenz_points,'--k') +plt.plot(pctiles,sim_Lorenz_points,'-b') +plt.xlabel('Percentile of net worth') +plt.ylabel('Cumulative share of wealth') +plt.show(block=False) + +rates = 20 +tax_rates = np.linspace(0.00, 0.95, num=rates) + +v_at_p90_wealth = [] # Vector for value function of 90th percentile wealth agent at each level of flat income tax rate +v_at_p80_wealth = [] # Vector for value function of 80th percentile wealth agent at each level of flat income tax rate +v_at_p70_wealth = [] # Vector for value function of 70th percentile wealth agent at each level of flat income tax rate +v_at_p60_wealth = [] # Vector for value function of 60th percentile wealth agent at each level of flat income tax rate +v_at_median_wealth = [] # Vector for value function of median wealth agent at each level of flat income tax rate +v_at_p40_wealth = [] # Vector for value function of 40th percentile wealth agent at each level of flat income tax rate +v_at_p30_wealth = [] # Vector for value function of 30th percentile wealth agent at each level of flat income tax rate +v_at_p20_wealth = [] # Vector for value function of 20th percentile wealth agent at each level of flat income tax rate +v_at_p10_wealth = [] # Vector for value function of 10th percentile wealth agent at each level of flat income tax rate + +for tau in tax_rates: + + AggShockAgent_tax_tau = deepcopy(AggShockAgent_tax) + AggShockAgent_tax_tau.tax_rate = tau + EconomyExample_tau = deepcopy(EconomyExample) + EconomyExample_tau.tax_rate = tau + AggShockAgent_tax_tau.get_economy_data(EconomyExample_tau) + EconomyExample_tau.make_AggShkHist() + AggShockAgent_tax_tau.solve() + AggShockAgent_tax_tau.initialize_sim() + AggShockAgent_tax_tau.simulate() + AggShockAgent_tax_tau.track_vars = ['aNrm','pLvl','mNrm','TranShk'] + EconomyExample_tau.solve() + AggShockAgent_tax_tau.unpack('vFunc') + + sim_market_resources_tau = AggShockAgent_tax_tau.state_now['mNrm'] + sim_wealth_tau = AggShockAgent_tax_tau.state_now['aNrm'] + + print("The flat income tax rate is: " + mystr(AggShockAgent_tax_tau.tax_rate)) + + print("The lump-sum transfer in terms of permanent income is: " + mystr(AggShockAgent_tax_tau.calc_transfers())) + + print("The mean of individual wealth is " + mystr(sim_wealth_tau.mean()) + "; the standard deviation is " + + str(sim_wealth_tau.std()) + "; the median is " + mystr(np.median(sim_wealth_tau)) + ".") + print("The mean of individual market resources is " + mystr(sim_market_resources_tau.mean()) + "; the standard deviation is " + + str(sim_market_resources_tau.std()) + "; the median is " + mystr(np.median(sim_market_resources_tau)) + ".") + print("The 90th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,90)) + ".") + print("The 80th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,80)) + ".") + print("The 70th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,70)) + ".") + print("The 60th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,60)) + ".") + print("The median of individual wealth is " + mystr(np.median(sim_wealth_tau)) + ".") + print("The 40th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,40)) + ".") + print("The 30th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,30)) + ".") + print("The 20th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,20)) + ".") + print("The 10th percentile of individual wealth is " + mystr(np.percentile(sim_wealth_tau,10)) + ".\n") + + # Tax rate as determined by agent (pre-tax)'s wealth and income + sim_p90_wealth_tau = np.percentile(sim_wealth_tau,90) + sim_p90_market_resources_tau = np.percentile(sim_market_resources_tau,90) + sim_p80_wealth_tau = np.percentile(sim_wealth_tau,80) + sim_p80_market_resources_tau = np.percentile(sim_market_resources_tau,80) + sim_p70_wealth_tau = np.percentile(sim_wealth_tau,70) + sim_p70_market_resources_tau = np.percentile(sim_market_resources_tau,70) + sim_p60_wealth_tau = np.percentile(sim_wealth_tau,60) + sim_p60_market_resources_tau = np.percentile(sim_market_resources_tau,60) + sim_median_wealth_tau = np.median(sim_wealth_tau) + sim_median_market_resources_tau = np.median(sim_market_resources_tau) + sim_p40_wealth_tau = np.percentile(sim_wealth_tau,40) + sim_p40_market_resources_tau = np.percentile(sim_market_resources_tau,40) + sim_p30_wealth_tau = np.percentile(sim_wealth_tau,30) + sim_p30_market_resources_tau = np.percentile(sim_market_resources_tau,30) + sim_p20_wealth_tau = np.percentile(sim_wealth_tau,20) + sim_p20_market_resources_tau = np.percentile(sim_market_resources_tau,20) + sim_p10_wealth_tau = np.percentile(sim_wealth_tau,10) + sim_p10_market_resources_tau = np.percentile(sim_market_resources_tau,10) + # Find value function of post-tax Xth-percentile wealth agent/voter, with X taking values from 10 to 90 + # vFunc arguments: Each agent's level of market resources + # and median agent's capital-labor ratio (assumed as 1.0 for now) + v_at_p90_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p90_market_resources_tau, 1.0) + v_at_p80_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p80_market_resources_tau, 1.0) + v_at_p70_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p70_market_resources_tau, 1.0) + v_at_p60_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p60_market_resources_tau, 1.0) + v_at_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau, 1.0) + v_at_p40_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p40_market_resources_tau, 1.0) + v_at_p30_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p30_market_resources_tau, 1.0) + v_at_p20_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p20_market_resources_tau, 1.0) + v_at_p10_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_p10_market_resources_tau, 1.0) + + v_at_p90_wealth.append(v_at_p90_wealth_tau) + v_at_p80_wealth.append(v_at_p80_wealth_tau) + v_at_p70_wealth.append(v_at_p70_wealth_tau) + v_at_p60_wealth.append(v_at_p60_wealth_tau) + v_at_median_wealth.append(v_at_median_wealth_tau) + v_at_p40_wealth.append(v_at_p40_wealth_tau) + v_at_p30_wealth.append(v_at_p30_wealth_tau) + v_at_p20_wealth.append(v_at_p20_wealth_tau) + v_at_p10_wealth.append(v_at_p10_wealth_tau) + +# Create graph of value function of agent with median level of wealth for each tax rate from 0.00 to 0.95 (in increments of 0.05) +print(v_at_median_wealth) +print(mystr(np.max(v_at_median_wealth))) +optimal_tax_rate = tax_rates[v_at_median_wealth.index(np.max(v_at_median_wealth))] +print("The optimal tax rate for the median voter is " + str(mystr(optimal_tax_rate)) + ".") + + +plt.figure(figsize=(7,4)) +plt.plot(tax_rates, v_at_median_wealth, 'b-', label = 'Value function of median wealth agent') +plt.xlabel('Flat income tax rate') +plt.ylabel('Value function of median wealth agent') +plt.show() + + + + +plt.figure(figsize=(13,6)) +plt.plot(tax_rates, v_at_p90_wealth, 'r--', label = 'Value function of p90 wealth agent') +plt.plot(tax_rates, v_at_p80_wealth, 'g--', label = 'Value function of p80 wealth agent') +plt.plot(tax_rates, v_at_p70_wealth, 'b--', label = 'Value function of p70 wealth agent') +plt.plot(tax_rates, v_at_p60_wealth, 'y--', label = 'Value function of p60 wealth agent') +plt.plot(tax_rates, v_at_median_wealth, 'k-', label = 'Value function of median wealth agent') +plt.plot(tax_rates, v_at_p40_wealth, 'r-', label = 'Value function of p40 wealth agent') +plt.plot(tax_rates, v_at_p30_wealth, 'g-', label = 'Value function of p30 wealth agent') +plt.plot(tax_rates, v_at_p20_wealth, 'b-', label = 'Value function of p20 wealth agent') +plt.plot(tax_rates, v_at_p10_wealth, 'y-', label = 'Value function of p10 wealth agent') + +plt.xlabel('Flat income tax rate') +plt.ylabel('Value function of agents') +plt.legend() +plt.show() + + + + +optimal_tax_rate_p90 = tax_rates[v_at_p90_wealth.index(np.max(v_at_p90_wealth))] +optimal_tax_rate_p80 = tax_rates[v_at_p80_wealth.index(np.max(v_at_p80_wealth))] +optimal_tax_rate_p70 = tax_rates[v_at_p70_wealth.index(np.max(v_at_p70_wealth))] +optimal_tax_rate_p60 = tax_rates[v_at_p60_wealth.index(np.max(v_at_p60_wealth))] +optimal_tax_rate_median = tax_rates[v_at_median_wealth.index(np.max(v_at_median_wealth))] +optimal_tax_rate_p40 = tax_rates[v_at_p40_wealth.index(np.max(v_at_p40_wealth))] +optimal_tax_rate_p30 = tax_rates[v_at_p30_wealth.index(np.max(v_at_p30_wealth))] +optimal_tax_rate_p20 = tax_rates[v_at_p20_wealth.index(np.max(v_at_p20_wealth))] +optimal_tax_rate_p10 = tax_rates[v_at_p10_wealth.index(np.max(v_at_p10_wealth))] + +print("The optimal tax rate for the 90th percentile voter is " + str(mystr(optimal_tax_rate_p90)) + ".") +print("The optimal tax rate for the 80th percentile voter is " + str(mystr(optimal_tax_rate_p80)) + ".") +print("The optimal tax rate for the 70th percentile voter is " + str(mystr(optimal_tax_rate_p70)) + ".") +print("The optimal tax rate for the 60th percentile voter is " + str(mystr(optimal_tax_rate_p60)) + ".") +print("The optimal tax rate for the median voter is " + str(mystr(optimal_tax_rate_median)) + ".") +print("The optimal tax rate for the 40th percentile voter is " + str(mystr(optimal_tax_rate_p40)) + ".") +print("The optimal tax rate for the 30th percentile voter is " + str(mystr(optimal_tax_rate_p30)) + ".") +print("The optimal tax rate for the 20th percentile voter is " + str(mystr(optimal_tax_rate_p20)) + ".") +print("The optimal tax rate for the 10th percentile voter is " + str(mystr(optimal_tax_rate_p10)) + ".") + diff --git a/REMARKs/KRR99/code/python/__init__.py b/REMARKs/KRR99/code/python/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/REMARKs/KRR99/readme.txt b/REMARKs/KRR99/readme.txt new file mode 100644 index 00000000..c35c5034 --- /dev/null +++ b/REMARKs/KRR99/readme.txt @@ -0,0 +1,9 @@ +Replication Attempt of "On the Size of the US Government: Political Economy in the Neoclassical Growth Model" by Krusell and Rios-Rull (1999) +by Kyung Woong Koh (180.604 Advanced Macro II Spring 2022) + + +Contents: + +code/python: Contains python notebook for Krusell and Rios-Rull (1999) + - ConsAggShockModel_tax.py: Contains only the new classes that incorporate flat income tax rate and lump-sum transfers (based from ConsAggShockModel) + - Koh_KRR99.ipynb: Replication notebook \ No newline at end of file diff --git a/REMARKs/KRR99/reproduce.sh b/REMARKs/KRR99/reproduce.sh new file mode 100644 index 00000000..cf562a2d --- /dev/null +++ b/REMARKs/KRR99/reproduce.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +python3 -m pip install --ignore-installed -r requirements.txt + +ipython Koh_KRR99.ipynb \ No newline at end of file diff --git a/REMARKs/KRR99/requirements.txt b/REMARKs/KRR99/requirements.txt new file mode 100644 index 00000000..fd4bc7c5 --- /dev/null +++ b/REMARKs/KRR99/requirements.txt @@ -0,0 +1,12 @@ +econ-ark == 0.12 +matplotlib +numpy +ipywidgets +scipy +cite2c +pandas +pandas-datareader +statsmodels +tqdm +nbval +git+https://github.com/econ-ark/hark@master