From d01519617c0314fc776f99e46d5a7896912618e4 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Fri, 20 May 2022 21:41:16 +0900 Subject: [PATCH 1/9] Kyung Woong Koh - KRR99 Replication Attempt --- REMARKs/KRR99/KRR99.md | 27 + .../KRR99/code/python/ConsAggShockModel.py | 3413 +++++++++++++++++ .../code/python/ConsAggShockModel_tax.py | 181 + REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 924 +++++ REMARKs/KRR99/readme.txt | 10 + REMARKs/KRR99/reproduce.py | 92 + REMARKs/KRR99/reproduce.sh | 5 + REMARKs/KRR99/requirements.txt | 11 + 8 files changed, 4663 insertions(+) create mode 100644 REMARKs/KRR99/KRR99.md create mode 100644 REMARKs/KRR99/code/python/ConsAggShockModel.py create mode 100644 REMARKs/KRR99/code/python/ConsAggShockModel_tax.py create mode 100644 REMARKs/KRR99/code/python/Koh_KRR99.ipynb create mode 100644 REMARKs/KRR99/readme.txt create mode 100644 REMARKs/KRR99/reproduce.py create mode 100644 REMARKs/KRR99/reproduce.sh create mode 100644 REMARKs/KRR99/requirements.txt 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.py b/REMARKs/KRR99/code/python/ConsAggShockModel.py new file mode 100644 index 00000000..1ad261a2 --- /dev/null +++ b/REMARKs/KRR99/code/python/ConsAggShockModel.py @@ -0,0 +1,3413 @@ +""" +Consumption-saving models with aggregate productivity shocks as well as idiosyn- +cratic income shocks. Currently only contains one microeconomic model with a +basic solver. Also includes a subclass of Market called CobbDouglas economy, +used for solving "macroeconomic" models with aggregate shocks. +""" +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.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType +from HARK import MetricObject, Market, AgentType +from copy import deepcopy +import matplotlib.pyplot as plt + +__all__ = [ + "AggShockConsumerType", + "AggShockConsumerType_tax", + "AggShockMarkovConsumerType", + "CobbDouglasEconomy", + "SmallOpenEconomy", + "CobbDouglasMarkovEconomy", + "CobbDouglasMarkovEconomy_tax", + "SmallOpenMarkovEconomy", + "AggregateSavingRule", + "AggShocksDynamicRule", + "init_agg_shocks", + "init_agg_mrkv_shocks", + "init_cobb_douglas", + "init_mrkv_cobb_douglas", +] + +utility = CRRAutility +utilityP = CRRAutilityP +utilityPP = CRRAutilityPP +utilityP_inv = CRRAutilityP_inv +utility_invP = CRRAutility_invP +utility_inv = CRRAutility_inv + +class MargValueFunc2D(MetricObject): + """ + A class for representing a marginal value function in models where the + standard envelope condition of dvdm(m,M) = u'(c(m,M)) holds (with CRRA utility). + """ + + distance_criteria = ["cFunc", "CRRA"] + + def __init__(self, cFunc, CRRA): + """ + Constructor for a new marginal 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 utilityP(self.cFunc(m, M), gam=self.CRRA) + +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 +init_agg_shocks = init_idiosyncratic_shocks.copy() +del init_agg_shocks["Rfree"] # Interest factor is endogenous in agg shocks model +del init_agg_shocks["CubicBool"] # Not supported yet for agg shocks model +# del init_agg_shocks["vFuncBool"] # Not supported yet for agg shocks model +init_agg_shocks["vFuncBool"] = True +init_agg_shocks["PermGroFac"] = [1.0] +# Grid of capital-to-labor-ratios (factors) +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] +) +init_agg_shocks["MgridBase"] = MgridBase +init_agg_shocks["aXtraCount"] = 24 +init_agg_shocks["aNrmInitStd"] = 0.0 +init_agg_shocks["LivPrb"] = [0.98] + + +class AggShockConsumerType(IndShockConsumerType): + """ + A class to represent consumers who face idiosyncratic (transitory and per- + manent) shocks to their income and live in an economy that has aggregate + (transitory and permanent) shocks to labor productivity. As the capital- + to-labor ratio varies in the economy, so does the wage rate and interest + rate. "Aggregate shock consumers" have beliefs about how the capital ratio + evolves over time and take aggregate shocks into account when making their + decision about how much to consume. + """ + + def __init__(self, **kwds): + """ + Make a new instance of AggShockConsumerType, an extension of + IndShockConsumerType. Sets appropriate solver and input lists. + """ + self.vFunc = None + params = init_agg_shocks.copy() + params.update(kwds) + + AgentType.__init__( + self, + solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), + pseudo_terminal=False, + **params + ) + + # Add consumer-type specific objects, copying to create independent versions + self.time_vary = deepcopy(IndShockConsumerType.time_vary_) + self.time_inv = deepcopy(IndShockConsumerType.time_inv_) + self.del_from_time_inv("Rfree", "CubicBool") + + self.solve_one_period = solveConsAggShock + self.update() + + def reset(self): + """ + Initialize this type for a new simulated history of K/L ratio. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.initialize_sim() + self.state_now['aLvlNow'] = self.kInit * np.ones(self.AgentCount) # Start simulation near SS + self.state_now['aNrm'] = self.state_now['aLvlNow'] / self.state_now['pLvl'] # ??? + + def pre_solve(self): + # AgentType.pre_solve() + self.update_solution_terminal() + + def update_solution_terminal(self): + """ + Updates the terminal period solution for an aggregate shock consumer. + Only fills in the consumption function and marginal value function. + + 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 get_economy_data(self, economy): + """ + Imports economy-determined objects into self from a Market. + Instances of AggShockConsumerType "live" in some macroeconomy that has + attributes relevant to their microeconomic model, like the relationship + between the capital-to-labor ratio and the interest and wage rates; this + method imports those attributes from an "economy" object and makes them + attributes of the ConsumerType. + + Parameters + ---------- + economy : Market + The "macroeconomy" in which this instance "lives". Might be of the + subclass CobbDouglasEconomy, which has methods to generate the + relevant attributes. + + Returns + ------- + None + """ + self.T_sim = ( + economy.act_T + ) # Need to be able to track as many periods as economy runs + self.kInit = economy.kSS # Initialize simulation assets to steady state + self.aNrmInitMean = np.log( + 0.00000001 + ) # Initialize newborn assets to nearly zero + self.Mgrid = ( + economy.MSS * self.MgridBase + ) # Aggregate market resources grid adjusted around SS capital ratio + self.AFunc = economy.AFunc # Next period's aggregate savings function + self.Rfunc = economy.Rfunc # Interest factor as function of capital ratio + self.wFunc = economy.wFunc # Wage rate as function of capital ratio + self.DeprFac = economy.DeprFac # Rate of capital depreciation + self.PermGroFacAgg = ( + economy.PermGroFacAgg + ) # Aggregate permanent productivity growth + self.add_AggShkDstn( + economy.AggShkDstn + ) # Combine idiosyncratic and aggregate shocks into one dstn + self.add_to_time_inv( + "Mgrid", "AFunc", "Rfunc", "wFunc", "DeprFac", "PermGroFacAgg" + ) + + def add_AggShkDstn(self, AggShkDstn): + """ + Updates attribute IncShkDstn by combining idiosyncratic shocks with aggregate shocks. + + Parameters + ---------- + AggShkDstn : [np.array] + Aggregate productivity shock distribution. First element is proba- + bilities, second element is agg permanent shocks, third element is + agg transitory shocks. + + Returns + ------- + None + """ + if len(self.IncShkDstn[0].X) > 2: + self.IncShkDstn = self.IncShkDstnWithoutAggShocks + else: + self.IncShkDstnWithoutAggShocks = self.IncShkDstn + self.IncShkDstn = [ + combine_indep_dstns(self.IncShkDstn[t], AggShkDstn) + for t in range(self.T_cycle) + ] + + def sim_birth(self, which_agents): + """ + Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as + well as time variables t_age and t_cycle. Normalized assets and permanent income levels + are drawn from lognormal distributions given by aNrmInitMean and aNrmInitStd (etc). + + Parameters + ---------- + which_agents : np.array(Bool) + Boolean array of size self.AgentCount indicating which agents should be "born". + + Returns + ------- + None + """ + IndShockConsumerType.sim_birth(self, which_agents) + if 'aLvl' in self.state_now and self.state_now['aLvl'] is not None: + self.state_now['aLvl'][which_agents] = ( + self.state_now['aNrm'][which_agents] * self.state_now['pLvl'][which_agents] + ) + else: + self.state_now['aLvl'] = self.state_now['aNrm'] * self.state_now['pLvl'] + + def sim_death(self): + """ + Randomly determine which consumers die, and distribute their wealth among the survivors. + This method only works if there is only one period in the cycle. + + Parameters + ---------- + None + + Returns + ------- + who_dies : np.array(bool) + Boolean array of size AgentCount indicating which agents die. + """ + # Divide agents into wealth groups, kill one random agent per wealth group + # order = np.argsort(self.aLvlNow) + # how_many_die = int(self.AgentCount*(1.0-self.LivPrb[0])) + # group_size = self.AgentCount/how_many_die # This should be an integer + # base_idx = self.RNG.randint(0,group_size,size=how_many_die) + # kill_by_rank = np.arange(how_many_die,dtype=int)*group_size + base_idx + # who_dies = np.zeros(self.AgentCount,dtype=bool) + # who_dies[order[kill_by_rank]] = True + + # Just select a random set of agents to die + how_many_die = int(round(self.AgentCount * (1.0 - self.LivPrb[0]))) + base_bool = np.zeros(self.AgentCount, dtype=bool) + base_bool[0:how_many_die] = True + who_dies = self.RNG.permutation(base_bool) + if self.T_age is not None: + who_dies[self.t_age >= self.T_age] = True + + # Divide up the wealth of those who die, giving it to those who survive + who_lives = np.logical_not(who_dies) + wealth_living = np.sum(self.state_now['aLvl'][who_lives]) + wealth_dead = np.sum(self.state_now['aLvl'][who_dies]) + Ractuarial = 1.0 + wealth_dead / wealth_living + self.state_now['aNrm'][who_lives] = self.state_now['aNrm'][who_lives] * Ractuarial + self.state_now['aLvl'][who_lives] = self.state_now['aLvl'][who_lives] * Ractuarial + return who_dies + + def get_Rfree(self): + """ + Returns an array of size self.AgentCount with self.RfreeNow in every entry. + + Parameters + ---------- + None + + Returns + ------- + RfreeNow : np.array + Array of size self.AgentCount with risk free interest rate for each agent. + """ + RfreeNow = self.RfreeNow * np.ones(self.AgentCount) + return RfreeNow + + + + def get_shocks(self): + """ + Finds the effective permanent and transitory shocks this period by combining the aggregate + and idiosyncratic shocks of each type. + + Parameters + ---------- + None + + Returns + ------- + None + """ + IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks + self.shocks['TranShk'] = ( + self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow + ) + self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow + + + def get_controls(self): + """ + Calculates consumption for each consumer of this type using the consumption functions. + + Parameters + ---------- + None + + Returns + ------- + None + """ + cNrmNow = np.zeros(self.AgentCount) + np.nan + MPCnow = np.zeros(self.AgentCount) + np.nan + MaggNow = self.get_MaggNow() + for t in range(self.T_cycle): + these = t == self.t_cycle + cNrmNow[these] = self.solution[t].cFunc(self.state_now['mNrm'][these], MaggNow[these]) + MPCnow[these] = self.solution[t].cFunc.derivativeX( + self.state_now['mNrm'][these], MaggNow[these] + ) # Marginal propensity to consume + + self.controls['cNrm'] = cNrmNow + self.MPCnow = MPCnow + return None + + def get_MaggNow(self): # This function exists to be overwritten in StickyE model + return self.MaggNow * np.ones(self.AgentCount) + + def market_action(self): + """ + In the aggregate shocks model, the "market action" is to simulate one + period of receiving income and choosing how much to consume. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.simulate(1) + + def calc_bounding_values(self): + """ + Calculate human wealth plus minimum and maximum MPC in an infinite + horizon model with only one period repeated indefinitely. Store results + as attributes of self. Human wealth is the present discounted value of + expected future income after receiving income this period, ignoring mort- + ality. The maximum MPC is the limit of the MPC as m --> mNrmMin. The + minimum MPC is the limit of the MPC as m --> infty. + + NOT YET IMPLEMENTED FOR THIS CLASS + + Parameters + ---------- + None + + Returns + ------- + None + """ + raise NotImplementedError() + + def make_euler_error_func(self, mMax=100, approx_inc_dstn=True): + """ + Creates a "normalized Euler error" function for this instance, mapping + from market resources to "consumption error per dollar of consumption." + Stores result in attribute eulerErrorFunc as an interpolated function. + Has option to use approximate income distribution stored in self.IncShkDstn + or to use a (temporary) very dense approximation. + + NOT YET IMPLEMENTED FOR THIS CLASS + + Parameters + ---------- + mMax : float + Maximum normalized market resources for the Euler error function. + approx_inc_dstn : Boolean + Indicator for whether to use the approximate discrete income distri- + bution stored in self.IncShkDstn[0], or to use a very accurate + discrete approximation instead. When True, uses approximation in + IncShkDstn; when False, makes and uses a very dense approximation. + + Returns + ------- + None + + Notes + ----- + This method is not used by any other code in the library. Rather, it is here + for expository and benchmarking purposes. + + """ + raise NotImplementedError() + + + +# 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. + """ + + 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 + self.update() + + # def get_shocks(self): + # """ + # Same as in AggShockConsumerType, but with transitory income shocks decreased by the tax rate. + # + # Parameters + # ---------- + # None + # + # Returns + # ------- + # None + # """ + # IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks + # self.shocks['TranShk'] = ( + # self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow + # ) + # self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow + + + 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 * (1 - 0.05) + return transfers + + +# This example makes a high risk, low growth state and a low risk, high growth state +MrkvArray = np.array([[0.90, 0.10], [0.04, 0.96]]) +PermShkAggStd = [ + 0.012, + 0.006, +] # Standard deviation of log aggregate permanent shocks by state +TranShkAggStd = [ + 0.006, + 0.003, +] # Standard deviation of log aggregate transitory shocks by state +PermGroFacAgg = [0.98, 1.02] # Aggregate permanent income growth factor + +# Make a dictionary to specify a Markov aggregate shocks consumer +init_agg_mrkv_shocks = init_agg_shocks.copy() +init_agg_mrkv_shocks["MrkvArray"] = MrkvArray + + +class AggShockMarkovConsumerType(AggShockConsumerType): + """ + A class for representing ex ante heterogeneous "types" of consumers who + experience both aggregate and idiosyncratic shocks to productivity (both + permanent and transitory), who lives in an environment where the macroeconomic + state is subject to Markov-style discrete state evolution. + """ + + def __init__(self, **kwds): + params = init_agg_mrkv_shocks.copy() + params.update(kwds) + kwds = params + AggShockConsumerType.__init__(self, **kwds) + + self.shocks['Mrkv'] = None + + self.add_to_time_inv("MrkvArray") + self.solve_one_period = solve_ConsAggMarkov + + def add_AggShkDstn(self, AggShkDstn): + """ + Variation on AggShockConsumerType.add_AggShkDstn that handles the Markov + state. AggShkDstn is a list of aggregate productivity shock distributions + for each Markov state. + """ + if len(self.IncShkDstn[0][0].X) > 2: + self.IncShkDstn = self.IncShkDstnWithoutAggShocks + else: + self.IncShkDstnWithoutAggShocks = self.IncShkDstn + + IncShkDstnOut = [] + N = self.MrkvArray.shape[0] + for t in range(self.T_cycle): + IncShkDstnOut.append( + [ + combine_indep_dstns(self.IncShkDstn[t][n], AggShkDstn[n]) + for n in range(N) + ] + ) + self.IncShkDstn = IncShkDstnOut + + def update_solution_terminal(self): + """ + Update the terminal period solution. This method should be run when a + new AgentType is created or when CRRA changes. + + Parameters + ---------- + None + + Returns + ------- + None + """ + AggShockConsumerType.update_solution_terminal(self) + + # Make replicated terminal period solution + StateCount = self.MrkvArray.shape[0] + self.solution_terminal.cFunc = StateCount * [self.solution_terminal.cFunc] + self.solution_terminal.vPfunc = StateCount * [self.solution_terminal.vPfunc] + self.solution_terminal.mNrmMin = StateCount * [self.solution_terminal.mNrmMin] + + def reset_rng(self): + MarkovConsumerType.reset_rng(self) + + def get_shocks(self): + """ + Gets permanent and transitory income shocks for this period. Samples from IncShkDstn for + each period in the cycle. This is a copy-paste from IndShockConsumerType, with the + addition of the Markov macroeconomic state. Unfortunately, the get_shocks method for + MarkovConsumerType cannot be used, as that method assumes that MrkvNow is a vector + with a value for each agent, not just a single int. + + Parameters + ---------- + None + + Returns + ------- + None + """ + PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays + TranShkNow = np.zeros(self.AgentCount) + newborn = self.t_age == 0 + for t in range(self.T_cycle): + these = t == self.t_cycle + N = np.sum(these) + if N > 0: + IncShkDstnNow = self.IncShkDstn[t - 1][ + self.shocks['Mrkv'] + ] # set current income distribution + PermGroFacNow = self.PermGroFac[t - 1] # and permanent growth factor + + # Get random draws of income shocks from the discrete distribution + ShockDraws = IncShkDstnNow.draw(N, exact_match=True) + # Permanent "shock" includes expected growth + PermShkNow[these] = ShockDraws[0] * PermGroFacNow + TranShkNow[these] = ShockDraws[1] + + # That procedure used the *last* period in the sequence for newborns, but that's not right + # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. + N = np.sum(newborn) + if N > 0: + these = newborn + IncShkDstnNow = self.IncShkDstn[0][ + self.shocks['Mrkv'] + ] # set current income distribution + PermGroFacNow = self.PermGroFac[0] # and permanent growth factor + + # Get random draws of income shocks from the discrete distribution + ShockDraws = IncShkDstnNow.draw(N, exact_match=True) + + # Permanent "shock" includes expected growth + PermShkNow[these] = ShockDraws[0] * PermGroFacNow + TranShkNow[these] = ShockDraws[1] + + # Store the shocks in self + self.EmpNow = np.ones(self.AgentCount, dtype=bool) + self.EmpNow[TranShkNow == self.IncUnemp] = False + self.shocks['TranShk'] = TranShkNow * self.TranShkAggNow * self.wRteNow + self.shocks['PermShk'] = PermShkNow * self.PermShkAggNow + + def get_controls(self): + """ + Calculates consumption for each consumer of this type using the consumption functions. + For this AgentType class, MrkvNow is the same for all consumers. However, in an + extension with "macroeconomic inattention", consumers might misperceive the state + and thus act as if they are in different states. + + Parameters + ---------- + None + + Returns + ------- + None + """ + cNrmNow = np.zeros(self.AgentCount) + np.nan + MPCnow = np.zeros(self.AgentCount) + np.nan + MaggNow = self.get_MaggNow() + MrkvNow = self.getMrkvNow() + + StateCount = self.MrkvArray.shape[0] + MrkvBoolArray = np.zeros((StateCount, self.AgentCount), dtype=bool) + for i in range(StateCount): + MrkvBoolArray[i, :] = i == MrkvNow + + for t in range(self.T_cycle): + these = t == self.t_cycle + for i in range(StateCount): + those = np.logical_and(these, MrkvBoolArray[i, :]) + cNrmNow[those] = self.solution[t].cFunc[i]( + self.state_now['mNrm'][those], MaggNow[those] + ) + # Marginal propensity to consume + MPCnow[those] = ( + self.solution[t] + .cFunc[i] + .derivativeX(self.state_now['mNrm'][those], MaggNow[those]) + ) + self.controls['cNrm'] = cNrmNow + self.MPCnow = MPCnow + return None + + def getMrkvNow(self): # This function exists to be overwritten in StickyE model + return self.shocks['Mrkv'] * np.ones(self.AgentCount, dtype=int) + + +init_KS_agents = { + "T_cycle": 1, + "DiscFac": 0.99, + "CRRA": 1.0, + "LbrInd": 1.0, + "aMin": 0.001, + "aMax": 50.0, + "aCount": 32, + "aNestFac": 2, + "MgridBase": np.array( + [0.1, 0.3, 0.6, 0.8, 0.9, 0.95, 0.98, 1.0, 1.02, 1.05, 1.1, 1.2, 1.6, 2.0, 3.0] + ), + "AgentCount": 5000, +} + + +class KrusellSmithType(AgentType): + """ + A class for representing agents in the seminal Krusell-Smith (1998) model from + the paper "Income and Wealth Heterogeneity in the Macroeconomy". All default + parameters have been set to match those in the paper, but the equilibrium object + is perceptions of aggregate assets as a function of aggregate market resources + in each macroeconomic state (bad=0, good=1), rather than aggregate capital as + a function of previous aggregate capital. This choice was made so that some + of the code from HARK's other HA-macro models can be used. + """ + + def __init__(self, **kwds): + """ + Make a new instance of the Krusell-Smith type. + """ + params = init_KS_agents.copy() + params.update(kwds) + + AgentType.__init__(self, pseudo_terminal=False, **params) + + # Add consumer-type specific objects + self.time_vary = [] + self.time_inv = [ + "DiscFac", + "CRRA", + ] + # need better handling of this + self.state_now = { + "aNow" : None, + "mNow" : None, + "EmpNow" : None + } + self.state_prev = { + "aNow" : None, + "mNow" : None, + "EmpNow" : None + } + + self.shock_vars = { + "Mrkv" : None + } + + self.solve_one_period = solve_KrusellSmith + self.update() + + def pre_solve(self): + self.update() + self.precompute_arrays() + + def update(self): + """ + Construct objects used during solution from primitive parameters. + """ + self.make_grid() + self.update_solution_terminal() + + def get_economy_data(self, Economy): + """ + Imports economy-determined objects into self from a Market. + + Parameters + ---------- + Economy : KrusellSmithEconomy + The "macroeconomy" in which this instance "lives". + + Returns + ------- + None + """ + self.T_sim = ( + Economy.act_T + ) # Need to be able to track as many periods as economy runs + self.kInit = Economy.KSS # Initialize simulation assets to steady state + self.MrkvInit = Economy.sow_init[ + "Mrkv" + ] # Starting Markov state for the macroeconomy + self.Mgrid = ( + Economy.MSS * self.MgridBase + ) # Aggregate market resources grid adjusted around SS capital ratio + self.AFunc = Economy.AFunc # Next period's aggregate savings function + self.DeprFac = Economy.DeprFac # Rate of capital depreciation + self.CapShare = Economy.CapShare # Capital's share of production + self.LbrInd = Economy.LbrInd # Idiosyncratic labor supply (when employed) + self.UrateB = Economy.UrateB # Unemployment rate in bad state + self.UrateG = Economy.UrateG # Unemployment rate in good state + self.ProdB = Economy.ProdB # Total factor productivity in bad state + self.ProdG = Economy.ProdG # Total factor productivity in good state + self.MrkvIndArray = ( + Economy.MrkvIndArray + ) # Transition probabilities among discrete states + self.MrkvAggArray = ( + Economy.MrkvArray + ) # Transition probabilities among aggregate discrete states + self.add_to_time_inv( + "Mgrid", + "AFunc", + "DeprFac", + "CapShare", + "UrateB", + "LbrInd", + "UrateG", + "ProdB", + "ProdG", + "MrkvIndArray", + "MrkvAggArray", + ) + + def make_grid(self): + """ + Construct the attribute aXtraGrid from the primitive attributes aMin, + aMax, aCount, aNestFac. + """ + self.aGrid = make_grid_exp_mult(self.aMin, self.aMax, self.aCount, self.aNestFac) + self.add_to_time_inv("aGrid") + + def update_solution_terminal(self): + """ + Construct the trivial terminal period solution (initial guess). + """ + cFunc_terminal = 4 * [IdentityFunction(n_dims=2)] + vPfunc_terminal = [ + MargValueFuncCRRA(cFunc_terminal[j], self.CRRA) for j in range(4) + ] + self.solution_terminal = ConsumerSolution( + cFunc=cFunc_terminal, vPfunc=vPfunc_terminal + ) + + def precompute_arrays(self): + """ + Construct the attributes ProbArray, mNextArray, MnextArray, and RnextArray, + which will be used by the one period solver. + """ + # Get array sizes + aCount = self.aGrid.size + Mcount = self.Mgrid.size + + # Make tiled array of end-of-period idiosyncratic assets (order: a, M, s, s') + aNow_tiled = np.tile( + np.reshape(self.aGrid, [aCount, 1, 1, 1]), [1, Mcount, 4, 4] + ) + + # Make arrays of end-of-period aggregate assets (capital next period) + AnowB = self.AFunc[0](self.Mgrid) + AnowG = self.AFunc[1](self.Mgrid) + KnextB = np.tile(np.reshape(AnowB, [1, Mcount, 1, 1]), [1, 1, 1, 4]) + KnextG = np.tile(np.reshape(AnowG, [1, Mcount, 1, 1]), [1, 1, 1, 4]) + Knext = np.concatenate((KnextB, KnextB, KnextG, KnextG), axis=2) + + # Make arrays of aggregate labor and TFP next period + Lnext = np.zeros((1, Mcount, 4, 4)) # shape (1,Mcount,4,4) + Lnext[0, :, :, 0:2] = (1.0 - self.UrateB) * self.LbrInd + Lnext[0, :, :, 2:4] = (1.0 - self.UrateG) * self.LbrInd + Znext = np.zeros((1, Mcount, 4, 4)) + Znext[0, :, :, 0:2] = self.ProdB + Znext[0, :, :, 2:4] = self.ProdG + + # Calculate (net) interest factor and wage rate next period + KtoLnext = Knext / Lnext + Rnext = 1.0 + Znext * CapShare * KtoLnext ** (CapShare - 1.0) - DeprFac + Wnext = Znext * (1.0 - CapShare) * KtoLnext ** CapShare + + # Calculate aggregate market resources next period + Ynext = Znext * Knext ** CapShare * Lnext ** (1.0 - CapShare) + Mnext = (1.0 - DeprFac) * Knext + Ynext + + # Tile the interest, wage, and aggregate market resources arrays + Rnext_tiled = np.tile(Rnext, [aCount, 1, 1, 1]) + Wnext_tiled = np.tile(Wnext, [aCount, 1, 1, 1]) + Mnext_tiled = np.tile(Mnext, [aCount, 1, 1, 1]) + + # Make an array of idiosyncratic labor supply next period + lNext_tiled = np.zeros([aCount, Mcount, 4, 4]) + lNext_tiled[:, :, :, 1] = self.LbrInd + lNext_tiled[:, :, :, 3] = self.LbrInd + + # Calculate idiosyncratic market resources next period + mNext = Rnext_tiled * aNow_tiled + Wnext_tiled * lNext_tiled + + # Make a tiled array of transition probabilities + Probs_tiled = np.tile( + np.reshape(self.MrkvIndArray, [1, 1, 4, 4]), [aCount, Mcount, 1, 1] + ) + + # Store the attributes that will be used by the solver + self.ProbArray = Probs_tiled + self.mNextArray = mNext + self.MnextArray = Mnext_tiled + self.RnextArray = Rnext_tiled + self.add_to_time_inv("ProbArray", "mNextArray", "MnextArray", "RnextArray") + + def make_emp_idx_arrays(self): + """ + Construct the attributes emp_permute and unemp_permute, each of which is + a 2x2 nested list of boolean arrays. The j,k-th element of emp_permute + represents the employment states this period for agents who were employed + last period when the macroeconomy is transitioning from state j to state k. + Likewise, j,k-th element of unemp_permute represents the employment states + this period for agents who were unemployed last period when the macro- + economy is transitioning from state j to state k. These attributes are + referenced during simulation, when they are randomly permuted in order to + maintain exact unemployment rates in each period. + """ + # Get counts of employed and unemployed agents in each macroeconomic state + B_unemp_N = int(np.round(self.UrateB * self.AgentCount)) + B_emp_N = self.AgentCount - B_unemp_N + G_unemp_N = int(np.round(self.UrateG * self.AgentCount)) + G_emp_N = self.AgentCount - G_unemp_N + + # Bad-bad transition indices + BB_stay_unemp_N = int( + np.round(B_unemp_N * self.MrkvIndArray[0, 0] / self.MrkvAggArray[0, 0]) + ) + BB_become_unemp_N = B_unemp_N - BB_stay_unemp_N + BB_stay_emp_N = int( + np.round(B_emp_N * self.MrkvIndArray[1, 1] / self.MrkvAggArray[0, 0]) + ) + BB_become_emp_N = B_emp_N - BB_stay_emp_N + BB_unemp_permute = np.concatenate( + [ + np.ones(BB_become_emp_N, dtype=bool), + np.zeros(BB_stay_unemp_N, dtype=bool), + ] + ) + BB_emp_permute = np.concatenate( + [ + np.ones(BB_stay_emp_N, dtype=bool), + np.zeros(BB_become_unemp_N, dtype=bool), + ] + ) + + # Bad-good transition indices + BG_stay_unemp_N = int( + np.round(B_unemp_N * self.MrkvIndArray[0, 2] / self.MrkvAggArray[0, 1]) + ) + BG_become_unemp_N = G_unemp_N - BG_stay_unemp_N + BG_stay_emp_N = int( + np.round(B_emp_N * self.MrkvIndArray[1, 3] / self.MrkvAggArray[0, 1]) + ) + BG_become_emp_N = G_emp_N - BG_stay_emp_N + BG_unemp_permute = np.concatenate( + [ + np.ones(BG_become_emp_N, dtype=bool), + np.zeros(BG_stay_unemp_N, dtype=bool), + ] + ) + BG_emp_permute = np.concatenate( + [ + np.ones(BG_stay_emp_N, dtype=bool), + np.zeros(BG_become_unemp_N, dtype=bool), + ] + ) + + # Good-bad transition indices + GB_stay_unemp_N = int( + np.round(G_unemp_N * self.MrkvIndArray[2, 0] / self.MrkvAggArray[1, 0]) + ) + GB_become_unemp_N = B_unemp_N - GB_stay_unemp_N + GB_stay_emp_N = int( + np.round(G_emp_N * self.MrkvIndArray[3, 1] / self.MrkvAggArray[1, 0]) + ) + GB_become_emp_N = B_emp_N - GB_stay_emp_N + GB_unemp_permute = np.concatenate( + [ + np.ones(GB_become_emp_N, dtype=bool), + np.zeros(GB_stay_unemp_N, dtype=bool), + ] + ) + GB_emp_permute = np.concatenate( + [ + np.ones(GB_stay_emp_N, dtype=bool), + np.zeros(GB_become_unemp_N, dtype=bool), + ] + ) + + # Good-good transition indices + GG_stay_unemp_N = int( + np.round(G_unemp_N * self.MrkvIndArray[2, 2] / self.MrkvAggArray[1, 1]) + ) + GG_become_unemp_N = G_unemp_N - GG_stay_unemp_N + GG_stay_emp_N = int( + np.round(G_emp_N * self.MrkvIndArray[3, 3] / self.MrkvAggArray[1, 1]) + ) + GG_become_emp_N = G_emp_N - GG_stay_emp_N + GG_unemp_permute = np.concatenate( + [ + np.ones(GG_become_emp_N, dtype=bool), + np.zeros(GG_stay_unemp_N, dtype=bool), + ] + ) + GG_emp_permute = np.concatenate( + [ + np.ones(GG_stay_emp_N, dtype=bool), + np.zeros(GG_become_unemp_N, dtype=bool), + ] + ) + + # Store transition matrices as attributes of self + self.unemp_permute = [ + [BB_unemp_permute, BG_unemp_permute], + [GB_unemp_permute, GG_unemp_permute], + ] + self.emp_permute = [ + [BB_emp_permute, BG_emp_permute], + [GB_emp_permute, GG_emp_permute], + ] + + def reset(self): + self.initialize_sim() + + def market_action(self): + self.simulate(1) + + def initialize_sim(self): + self.shocks['Mrkv'] = self.MrkvInit + AgentType.initialize_sim(self) + self.state_now["EmpNow"] = self.state_now["EmpNow"].astype(bool) + self.make_emp_idx_arrays() + + def sim_birth(self, which): + """ + Create newborn agents with randomly drawn employment states. This will + only ever be called by initialize_sim() at the start of a new simulation + history, as the Krusell-Smith model does not have death and replacement. + The sim_death() method does not exist, as AgentType's default of "no death" + is the correct behavior for the model. + """ + N = np.sum(which) + if N == 0: + return + + if self.shocks['Mrkv'] == 0: + unemp_N = int(np.round(self.UrateB * N)) + emp_N = self.AgentCount - unemp_N + elif self.shocks['Mrkv'] == 1: + unemp_N = int(np.round(self.UrateG * N)) + emp_N = self.AgentCount - unemp_N + else: + assert False, "Illegal macroeconomic state: MrkvNow must be 0 or 1" + EmpNew = np.concatenate( + [np.zeros(unemp_N, dtype=bool), np.ones(emp_N, dtype=bool)] + ) + + self.state_now["EmpNow"][which] = self.RNG.permutation(EmpNew) + self.state_now["aNow"][which] = self.kInit + + def get_shocks(self): + """ + Get new idiosyncratic employment states based on the macroeconomic state. + """ + # Get boolean arrays for current employment states + employed = self.state_prev["EmpNow"].copy().astype(bool) + unemployed = np.logical_not(employed) + + # derive from past employment rate rather than store previous value + mrkv_prev = int((unemployed.sum() / float(self.AgentCount)) != self.UrateB) + + # Transition some agents between unemployment and employment + emp_permute = self.emp_permute[mrkv_prev][self.shocks['Mrkv']] + unemp_permute = self.unemp_permute[mrkv_prev][self.shocks['Mrkv']] + # TODO: replace poststate_vars functionality with shocks here + EmpNow = self.state_now["EmpNow"] + + # It's really this permutation that is the shock... + # This apparatus is trying to 'exact match' the 'internal' Markov process. + EmpNow[employed] = self.RNG.permutation(emp_permute) + EmpNow[unemployed] = self.RNG.permutation(unemp_permute) + + def get_states(self): + """ + Get each agent's idiosyncratic state, their household market resources. + """ + self.state_now["mNow"] = self.Rnow * self.state_prev['aNow'] + self.Wnow * self.LbrInd * self.state_now["EmpNow"] + + def get_controls(self): + """ + Get each agent's consumption given their current state.' + """ + employed = self.state_now["EmpNow"].copy().astype(bool) + unemployed = np.logical_not(employed) + + # Get the discrete index for (un)employed agents + if self.shocks['Mrkv'] == 0: # Bad macroeconomic conditions + unemp_idx = 0 + emp_idx = 1 + elif self.shocks['Mrkv'] == 1: # Good macroeconomic conditions + unemp_idx = 2 + emp_idx = 3 + else: + assert False, "Illegal macroeconomic state: MrkvNow must be 0 or 1" + + # Get consumption for each agent using the appropriate consumption function + cNow = np.zeros(self.AgentCount) + Mnow = self.Mnow * np.ones(self.AgentCount) + cNow[unemployed] = self.solution[0].cFunc[unemp_idx]( + self.state_now["mNow"][unemployed], Mnow[unemployed] + ) + cNow[employed] = self.solution[0].cFunc[emp_idx]( + self.state_now["mNow"][employed], Mnow[employed] + ) + self.controls["cNow"] = cNow + + def get_poststates(self): + """ + Gets each agent's retained assets after consumption. + """ + self.state_now['aNow'] = self.state_now["mNow"] - self.controls["cNow"] + + +############################################################################### + + + +def solveConsAggShock( + solution_next, + IncShkDstn, + LivPrb, + DiscFac, + CRRA, + PermGroFac, + PermGroFacAgg, + aXtraGrid, + BoroCnstArt, + Mgrid, + AFunc, + Rfunc, + wFunc, +): + """ + Solve one period of a consumption-saving problem with idiosyncratic and + aggregate shocks (transitory and permanent). This is a basic solver that + can't handle cubic splines, nor can it calculate a value function. + + 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 + + + +def solve_ConsAggShock_new(solution_next, IncShkDstn, LivPrb, DiscFac, CRRA, PermGroFac, + PermGroFacAgg, aXtraGrid, BoroCnstArt, Mgrid, AFunc, Rfunc, wFunc, DeprFac): + ''' + Solve one period of a consumption-saving problem with idiosyncratic and + aggregate shocks (transitory and permanent). This is a basic solver that + can't handle cubic splines, nor can it calculate a value function. This + version uses calc_expectation to reduce code clutter. + + 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) and marginal value function vPfunc. + ''' + # Unpack the income shocks and get grid sizes + PermShkValsNext = IncShkDstn.X[0] + TranShkValsNext = IncShkDstn.X[1] + PermShkAggValsNext = IncShkDstn.X[2] + TranShkAggValsNext = IncShkDstn.X[3] + aCount = aXtraGrid.size + Mcount = Mgrid.size + + # Define a function that calculates M_{t+1} from M_t and the aggregate shocks; + # the function also returns the wage rate and effective interest factor + def calcAggObjects(M,Psi,Theta): + A = AFunc(M) # End-of-period aggregate assets (normalized) + kNext = A/(PermGroFacAgg*Psi) # Next period's aggregate capital/labor ratio + kNextEff = kNext/Theta # Same thing, but account for *transitory* shock + R = Rfunc(kNextEff) # Interest factor on aggregate assets + wEff = wFunc(kNextEff)*Theta # Effective wage rate (accounts for labor supply) + Reff = R/LivPrb # Account for redistribution of decedents' wealth + Mnext = kNext*R + wEff # Next period's aggregate market resources + return Mnext, Reff, wEff + + # Define a function that evaluates R*v'(m_{t+1},M_{t+1}) from a_t, M_t, and the income shocks + def vPnextFunc(a,M,psi,theta,Psi,Theta): + Mnext, Reff, wEff = calcAggObjects(M,Psi,Theta) + PermShkTotal = PermGroFac * PermGroFacAgg * psi * Psi # Total / combined permanent shock + mNext = Reff*a/PermShkTotal + theta*wEff # Idiosyncratic market resources + vPnext = Reff*PermShkTotal**(-CRRA)*solution_next.vPfunc(mNext, Mnext) + return vPnext + + # Make an array of a_t values at which to calculate end-of-period marginal value of assets + BoroCnstNat_vec = np.zeros(Mcount) # Natural borrowing constraint at each M_t + aNrmNow = np.zeros((aCount,Mcount)) + for j in range(Mcount): + Mnext, Reff, wEff = calcAggObjects(Mgrid[j], PermShkAggValsNext, TranShkAggValsNext) + aNrmMin_cand = (PermGroFac*PermGroFacAgg*PermShkValsNext*PermShkAggValsNext/Reff) * \ + (solution_next.mNrmMin(Mnext) - wEff*TranShkValsNext) + aNrmMin = np.max(aNrmMin_cand) # Lowest valid a_t value for this M_t + aNrmNow[:,j] = aNrmMin + aXtraGrid + BoroCnstNat_vec[j] = aNrmMin + + # Compute end-of-period marginal value of assets + MaggNow = np.tile(np.reshape(Mgrid,(1,Mcount)),(aCount,1)) # Tiled Mgrid + EndOfPrdvP = DiscFac*LivPrb*calc_expectation(IncShkDstn,vPnextFunc,[aNrmNow,MaggNow]) + + # Calculate optimal consumption from each asset gridpoint and endogenous m_t gridpoint + cNrmNow = EndOfPrdvP**(-1.0/CRRA) + mNrmNow = aNrmNow + 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)) + + # 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 = MargValueFunc2D(cFuncNow, CRRA) + + # Construct the value function using the envelope condition + vFuncNow = ValueFunc2D(cFuncNow, CRRA) + + # Pack up and return the solution + solution_now = ConsumerSolution(cFunc=cFuncNow, vPfunc=vPfuncNow, vFunc=vFuncNow, mNrmMin=mNrmMinNow) + return solution_now + + +############################################################################### + + +def solve_ConsAggMarkov( + solution_next, + IncShkDstn, + LivPrb, + DiscFac, + CRRA, + MrkvArray, + PermGroFac, + PermGroFacAgg, + aXtraGrid, + BoroCnstArt, + Mgrid, + AFunc, + Rfunc, + wFunc, +): + """ + Solve one period of a consumption-saving problem with idiosyncratic and + aggregate shocks (transitory and permanent). Moreover, the macroeconomic + state follows a Markov process that determines the income distribution and + aggregate permanent growth factor. This is a basic solver that can't handle + cubic splines, nor can it calculate a value function. + + Parameters + ---------- + solution_next : ConsumerSolution + The solution to the succeeding one period problem. + IncShkDstn : [distribution.Distribution] + A list of + discrete approximations to the income process between the period being + solved and the one immediately following (in solution_next). Order: + idisyncratic 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. + MrkvArray : np.array + Markov transition matrix between discrete macroeconomic states. + MrkvArray[i,j] is probability of being in state j next period conditional + on being in state i this period. + PermGroFac : float + Expected permanent income growth factor at the end of this period, + for the *individual*'s productivity. + PermGroFacAgg : [float] + Expected aggregate productivity growth in each Markov macro state. + 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, for each + Markov macro state. + 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) and marginal value function vPfunc. + """ + # Get sizes of grids + aCount = aXtraGrid.size + Mcount = Mgrid.size + StateCount = MrkvArray.shape[0] + + # Loop through next period's states, assuming we reach each one at a time. + # Construct EndOfPrdvP_cond functions for each state. + EndOfPrdvPfunc_cond = [] + BoroCnstNat_cond = [] + for j in range(StateCount): + # Unpack next period's solution + vPfuncNext = solution_next.vPfunc[j] + mNrmMinNext = solution_next.mNrmMin[j] + + # Unpack the income shocks + ShkPrbsNext = IncShkDstn[j].pmf + PermShkValsNext = IncShkDstn[j].X[0] + TranShkValsNext = IncShkDstn[j].X[1] + PermShkAggValsNext = IncShkDstn[j].X[2] + TranShkAggValsNext = IncShkDstn[j].X[3] + ShkCount = ShkPrbsNext.size + aXtra_tiled = np.tile( + np.reshape(aXtraGrid, (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) + ) + + # Make a tiled grid of end-of-period aggregate assets. These lines use + # next prd state j's aggregate saving rule to get a relevant set of Aagg, + # which will be used to make an interpolated EndOfPrdvP_cond function. + # After constructing these functions, we will use the aggregate saving + # rule for *current* state i to get values of Aagg at which to evaluate + # these conditional marginal value functions. In the strange, maybe even + # impossible case where the aggregate saving rules differ wildly across + # macro states *and* there is "anti-persistence", so that the macro state + # is very likely to change each period, then this procedure will lead to + # an inaccurate solution because the grid of Aagg values on which the + # conditional marginal value functions are constructed is not relevant + # to the values at which it will actually be evaluated. + AaggGrid = AFunc[j](Mgrid) + AaggNow_tiled = np.tile( + np.reshape(AaggGrid, (Mcount, 1, 1)), (1, aCount, ShkCount) + ) + + # Calculate returns to capital and labor in the next period + kNext_array = AaggNow_tiled / ( + PermGroFacAgg[j] * PermShkAggValsNext_tiled + ) # Next period's aggregate capital to 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[j] + * 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[j] + * 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) + + # Make the conditional end-of-period marginal value function + BoroCnstNat = LinearInterp( + np.insert(AaggGrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0) + ) + EndOfPrdvPnvrs = np.concatenate( + (np.zeros((Mcount, 1)), EndOfPrdvP ** (-1.0 / CRRA)), axis=1 + ) + EndOfPrdvPnvrsFunc_base = BilinearInterp( + np.transpose(EndOfPrdvPnvrs), np.insert(aXtraGrid, 0, 0.0), AaggGrid + ) + EndOfPrdvPnvrsFunc = VariableLowerBoundFunc2D( + EndOfPrdvPnvrsFunc_base, BoroCnstNat + ) + EndOfPrdvPfunc_cond.append(MargValueFuncCRRA(EndOfPrdvPnvrsFunc, CRRA)) + BoroCnstNat_cond.append(BoroCnstNat) + + # Prepare some objects that are the same across all current states + aXtra_tiled = np.tile(np.reshape(aXtraGrid, (1, aCount)), (Mcount, 1)) + cFuncCnst = BilinearInterp( + np.array([[0.0, 0.0], [1.0, 1.0]]), + np.array([BoroCnstArt, BoroCnstArt + 1.0]), + np.array([0.0, 1.0]), + ) + + # Now loop through *this* period's discrete states, calculating end-of-period + # marginal value (weighting across state transitions), then construct consumption + # and marginal value function for each state. + cFuncNow = [] + vPfuncNow = [] + mNrmMinNow = [] + for i in range(StateCount): + # Find natural borrowing constraint for this state by Aagg + AaggNow = AFunc[i](Mgrid) + aNrmMin_candidates = np.zeros((StateCount, Mcount)) + np.nan + for j in range(StateCount): + if MrkvArray[i, j] > 0.0: # Irrelevant if transition is impossible + aNrmMin_candidates[j, :] = BoroCnstNat_cond[j](AaggNow) + aNrmMin_vec = np.nanmax(aNrmMin_candidates, axis=0) + BoroCnstNat_vec = aNrmMin_vec + + # Make tiled grids of aNrm and Aagg + aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec, (Mcount, 1)), (1, aCount)) + aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled + AaggNow_tiled = np.tile(np.reshape(AaggNow, (Mcount, 1)), (1, aCount)) + + # Loop through feasible transitions and calculate end-of-period marginal value + EndOfPrdvP = np.zeros((Mcount, aCount)) + for j in range(StateCount): + if MrkvArray[i, j] > 0.0: + temp = EndOfPrdvPfunc_cond[j](aNrmNow_tiled, AaggNow_tiled) + EndOfPrdvP += MrkvArray[i, j] * temp + + # Calculate consumption and the endogenous mNrm gridpoints for this state + cNrmNow = EndOfPrdvP ** (-1.0 / CRRA) + mNrmNow = aNrmNow_tiled + cNrmNow + + # Loop through the values in Mgrid and make a piecewise linear consumption function for each + cFuncBaseByM_list = [] + for n in range(Mcount): + c_temp = np.insert(cNrmNow[n, :], 0, 0.0) # Add point at bottom + m_temp = np.insert(mNrmNow[n, :] - BoroCnstNat_vec[n], 0, 0.0) + cFuncBaseByM_list.append(LinearInterp(m_temp, c_temp)) + # Add the M-specific consumption function to the list + + # Construct the 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) + + # Combine the constrained consumption function with unconstrained component + cFuncNow.append(LowerEnvelope2D(cFuncUnc, cFuncCnst)) + + # Make the minimum m function as the greater of the natural and artificial constraints + mNrmMinNow.append(UpperEnvelope(BoroCnstNat, ConstantFunction(BoroCnstArt))) + + # Construct the marginal value function using the envelope condition + vPfuncNow.append(MargValueFuncCRRA(cFuncNow[-1], CRRA)) + + # Pack up and return the solution + solution_now = ConsumerSolution( + cFunc=cFuncNow, vPfunc=vPfuncNow, mNrmMin=mNrmMinNow + ) + return solution_now + + +############################################################################### + + +def solve_KrusellSmith( + solution_next, + DiscFac, + CRRA, + aGrid, + Mgrid, + mNextArray, + MnextArray, + ProbArray, + RnextArray, +): + """ + Solve the one period problem of an agent in Krusell & Smith's canonical 1998 model. + Because this model is so specialized and only intended to be used with a very narrow + case, many arrays can be precomputed, making the code here very short. See the + method KrusellSmithType.precompute_arrays() for details. + + Parameters + ---------- + solution_next : ConsumerSolution + Representation of the solution to next period's problem, including the + discrete-state-conditional consumption function and marginal value function. + DiscFac : float + Intertemporal discount factor. + CRRA : float + Coefficient of relative risk aversion. + aGrid : np.array + Array of end-of-period asset values. + Mgrid : np.array + A grid of aggregate market resources in the economy. + mNextArray : np.array + Precomputed array of next period's market resources attained from every + end-of-period state in the exogenous grid crossed with every shock that + might attain. Has shape [aCount, Mcount, 4, 4] ~ [a, M, s, s']. + MnextArray : np.array + Precomputed array of next period's aggregate market resources attained + from every end-of-period state in the exogenous grid crossed with every + shock that might attain. Corresponds to mNextArray. + ProbArray : np.array + Tiled array of transition probabilities among discrete states. Every + slice [i,j,:,:] is identical and translated from MrkvIndArray. + RnextArray : np.array + Tiled array of net interest factors next period, attained from every + end-of-period state crossed with every shock that might attain. + + Returns + ------- + solution_now : ConsumerSolution + Representation of this period's solution to the Krusell-Smith model. + """ + # Loop over next period's state realizations, computing marginal value of market resources + vPnext = np.zeros_like(mNextArray) + for j in range(4): + vPnext[:, :, :, j] = solution_next.vPfunc[j]( + mNextArray[:, :, :, j], MnextArray[:, :, :, j] + ) + + # Compute end-of-period marginal value of assets + EndOfPrdvP = DiscFac * np.sum(RnextArray * vPnext * ProbArray, axis=3) + + # Invert the first order condition to find optimal consumption + cNow = EndOfPrdvP ** (-1.0 / CRRA) + + # Find the endogenous gridpoints + aCount = aGrid.size + Mcount = Mgrid.size + aNow = np.tile(np.reshape(aGrid, [aCount, 1, 1]), [1, Mcount, 4]) + mNow = aNow + cNow + + # Insert zeros at the bottom of both cNow and mNow arrays (consume nothing) + cNow = np.concatenate([np.zeros([1, Mcount, 4]), cNow], axis=0) + mNow = np.concatenate([np.zeros([1, Mcount, 4]), mNow], axis=0) + + # Construct the consumption and marginal value function for each discrete state + cFunc_by_state = [] + vPfunc_by_state = [] + for j in range(4): + cFunc_by_M = [LinearInterp(mNow[:, k, j], cNow[:, k, j]) for k in range(Mcount)] + cFunc_j = LinearInterpOnInterp1D(cFunc_by_M, Mgrid) + vPfunc_j = MargValueFuncCRRA(cFunc_j, CRRA) + cFunc_by_state.append(cFunc_j) + vPfunc_by_state.append(vPfunc_j) + + # Package and return the solution + solution_now = ConsumerSolution(cFunc=cFunc_by_state, vPfunc=vPfunc_by_state) + return solution_now + + +############################################################################### + +CRRA = 2.0 +DiscFac = 0.96 + +# Parameters for a Cobb-Douglas economy +PermGroFacAgg = 1.00 # Aggregate permanent income growth factor +PermShkAggCount = ( + 3 # Number of points in discrete approximation to aggregate permanent shock dist +) +TranShkAggCount = ( + 3 # Number of points in discrete approximation to aggregate transitory shock dist +) +PermShkAggStd = 0.0063 # Standard deviation of log aggregate permanent shocks +TranShkAggStd = 0.0031 # Standard deviation of log aggregate transitory shocks +DeprFac = 0.025 # Capital depreciation rate +CapShare = 0.36 # Capital's share of income +DiscFacPF = DiscFac # Discount factor of perfect foresight calibration +CRRAPF = CRRA # Coefficient of relative risk aversion of perfect foresight calibration +intercept_prev = 0.0 # Intercept of aggregate savings function +slope_prev = 1.0 # Slope of aggregate savings function +verbose_cobb_douglas = ( + True # Whether to print solution progress to screen while solving +) +T_discard = 200 # Number of simulated "burn in" periods to discard when updating AFunc +DampingFac = 0.5 # Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new +max_loops = 20 # Maximum number of AFunc updating loops to allow + + +# Make a dictionary to specify a Cobb-Douglas economy +init_cobb_douglas = { + "PermShkAggCount": PermShkAggCount, + "TranShkAggCount": TranShkAggCount, + "PermShkAggStd": PermShkAggStd, + "TranShkAggStd": TranShkAggStd, + "DeprFac": DeprFac, + "CapShare": CapShare, + "DiscFac": DiscFacPF, + "CRRA": CRRAPF, + "PermGroFacAgg": PermGroFacAgg, + "AggregateL": 1.0, + "intercept_prev": intercept_prev, + "slope_prev": slope_prev, + "verbose": verbose_cobb_douglas, + "T_discard": T_discard, + "DampingFac": DampingFac, + "max_loops": max_loops, +} + + + + +class CobbDouglasEconomy(Market): + """ + A class to represent an economy with a Cobb-Douglas aggregate production + function over labor and capital, extending HARK.Market. The "aggregate + market process" for this market combines all individuals' asset holdings + into aggregate capital, yielding the interest factor on assets and the wage + rate for the upcoming period. + + Note: The current implementation assumes a constant labor supply, but + this will be generalized in the future. + + Parameters + ---------- + agents : [ConsumerType] + List of types of consumers that live in this economy. + tolerance: float + Minimum acceptable distance between "dynamic rules" to consider the + solution process converged. Distance depends on intercept and slope + of the log-linear "next capital ratio" function. + act_T : int + Number of periods to simulate when making a history of of the market. + """ + + 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, "DampingFac"): + self.DampingFac = 0.5 + if not hasattr(self, "max_loops"): + self.max_loops = 20 + if not hasattr(self, "T_discard"): + self.T_discard = 200 + if not hasattr(self, "verbose"): + self.verbose = True + + + def mill_rule(self, aLvl, pLvl): + """ + Function to calculate the capital to labor ratio, interest factor, and + wage rate based on each agent's current state. Just calls calc_R_and_W(). + + See documentation for calc_R_and_W for more information. + """ + return self.calc_R_and_W(aLvl, pLvl) + + def calc_dynamics(self, MaggNow, AaggNow): + """ + Calculates a new dynamic rule for the economy: end of period savings as + a function of aggregate market resources. Just calls calc_AFunc(). + + See documentation for calc_AFunc for more information. + """ + return self.calc_AFunc(MaggNow, AaggNow) + + 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) + ) + / 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) + + def get_PermGroFacAggLR(self): + """ + A trivial function that returns self.PermGroFacAgg. Exists to be overwritten + and extended by ConsAggShockMarkov model. + + Parameters + ---------- + None + + Returns + ------- + PermGroFacAggLR : float + Long run aggregate permanent income growth, which is the same thing + as aggregate permanent income growth. + """ + return self.PermGroFacAgg + + def make_AggShkDstn(self): + """ + Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. + Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.TranShkAggDstn = MeanOneLogNormal(sigma=self.TranShkAggStd).approx( + N=self.TranShkAggCount + ) + self.PermShkAggDstn = MeanOneLogNormal(sigma=self.PermShkAggStd).approx( + N=self.PermShkAggCount + ) + self.AggShkDstn = combine_indep_dstns(self.PermShkAggDstn, self.TranShkAggDstn) + + def reset(self): + """ + Reset the economy to prepare for a new simulation. Sets the time index + of aggregate shocks to zero and runs Market.reset(). + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.Shk_idx = 0 + Market.reset(self) + + def make_AggShkHist(self): + """ + Make simulated histories of aggregate transitory and permanent shocks. + Histories are of length self.act_T, for use in the general equilibrium + simulation. + + Parameters + ---------- + None + + Returns + ------- + None + """ + sim_periods = self.act_T + Events = np.arange(self.AggShkDstn.pmf.size) # just a list of integers + EventDraws = self.AggShkDstn.draw(N=sim_periods, X=Events) + PermShkAggHist = self.AggShkDstn.X[0][EventDraws] + TranShkAggHist = self.AggShkDstn.X[1][EventDraws] + + # Store the histories + self.PermShkAggHist = PermShkAggHist * self.PermGroFacAgg + self.TranShkAggHist = TranShkAggHist + + + + def calc_R_and_W(self, aLvlNow, pLvlNow): + """ + Calculates the interest factor and wage rate this period using each agent's + capital stock to get the aggregate capital ratio. + + Parameters + ---------- + aLvlNow : [np.array] + Agents' current end-of-period assets. Elements of the list correspond + to types in the economy, entries within arrays to agents of that type. + + Returns + ------- + MaggNow : float + Aggregate market resources for this period normalized by mean permanent income + AaggNow : float + Aggregate savings for this period normalized by mean permanent income + RfreeNow : float + Interest factor on assets in the economy this period. + wRteNow : float + Wage rate for labor in the economy this period. + PermShkAggNow : float + Permanent shock to aggregate labor productivity this period. + TranShkAggNow : float + Transitory shock to aggregate labor productivity this period. + KtoLnow : float + Capital-to-labor ratio in the economy this period. + """ + # Calculate aggregate savings + AaggPrev = np.mean(np.array(aLvlNow)) / np.mean( + pLvlNow + ) # End-of-period savings from last period + # Calculate aggregate capital this period + AggregateK = np.mean(np.array(aLvlNow)) # ...becomes capital today + # This version uses end-of-period assets and + # permanent income to calculate aggregate capital, unlike the Mathematica + # version, which first applies the idiosyncratic permanent income shocks + # and then aggregates. Obviously this is mathematically equivalent. + + # Get this period's aggregate shocks + PermShkAggNow = self.PermShkAggHist[self.Shk_idx] + TranShkAggNow = self.TranShkAggHist[self.Shk_idx] + self.Shk_idx += 1 + + AggregateL = np.mean(pLvlNow) * PermShkAggNow + + # Calculate the interest factor and wage rate this period + KtoLnow = AggregateK / AggregateL + self.KtoYnow = KtoLnow ** (1.0 - self.CapShare) + RfreeNow = self.Rfunc(KtoLnow / TranShkAggNow) + wRteNow = self.wFunc(KtoLnow / TranShkAggNow) + MaggNow = KtoLnow * RfreeNow + wRteNow * TranShkAggNow + self.KtoLnow = KtoLnow # Need to store this as it is a sow variable + + # Package the results into an object and return it + return ( + MaggNow, + AaggPrev, + RfreeNow, + wRteNow, + PermShkAggNow, + TranShkAggNow, + KtoLnow, + ) + + + def calc_AFunc(self, MaggNow, AaggNow): + """ + Calculate a new aggregate savings rule based on the history + of the aggregate savings and aggregate market resources from a simulation. + + Parameters + ---------- + MaggNow : [float] + List of the history of the simulated aggregate market resources for an economy. + AaggNow : [float] + List of the history of the simulated aggregate savings for an economy. + + Returns + ------- + (unnamed) : CapDynamicRule + Object containing a new savings rule + """ + verbose = self.verbose + discard_periods = ( + self.T_discard + ) # Throw out the first T periods to allow the simulation to approach the SS + update_weight = ( + 1.0 - self.DampingFac + ) # Proportional weight to put on new function vs old function parameters + total_periods = len(MaggNow) + + # Regress the log savings against log market resources + logAagg = np.log(AaggNow[discard_periods:total_periods]) + logMagg = np.log(MaggNow[discard_periods - 1 : total_periods - 1]) + slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg, logAagg) + + # Make a new aggregate savings rule by combining the new regression parameters + # with the previous guess + intercept = ( + update_weight * intercept + (1.0 - update_weight) * self.intercept_prev + ) + slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev + AFunc = AggregateSavingRule( + intercept, slope + ) # Make a new next-period capital function + + # Save the new values as "previous" values for the next iteration + self.intercept_prev = intercept + self.slope_prev = slope + + # Print the new parameters + if verbose: + print( + "intercept=" + + str(intercept) + + ", slope=" + + str(slope) + + ", r-sq=" + + str(r_value ** 2) + ) + + return AggShocksDynamicRule(AFunc) + + + +# Make a dictionary to specify a Cobb-Douglas economy + +init_cobb_douglas_tax = init_cobb_douglas.copy() +init_cobb_douglas_tax["tax_rate"] = 0.00 + + + +class CobbDouglasEconomy_tax(CobbDouglasEconomy): + """ + A class to represent an economy with a Cobb-Douglas aggregate production + function over labor and capital, extending HARK.Market. The "aggregate + market process" for this market combines all individuals' asset holdings + into aggregate capital, yielding the interest factor on assets and the wage + rate for the upcoming period. + + Note: The current implementation assumes a constant labor supply, but + this will be generalized in the future. + + Parameters + ---------- + tax_rate: + """ + + 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) + + + + +class SmallOpenEconomy(Market): + """ + A class for representing a small open economy, where the wage rate and interest rate are + exogenously determined by some "global" rate. However, the economy is still subject to + aggregate productivity shocks. + + Parameters + ---------- + agents : [ConsumerType] + List of types of consumers that live in this economy. + tolerance: float + Minimum acceptable distance between "dynamic rules" to consider the + solution process converged. Distance depends on intercept and slope + of the log-linear "next capital ratio" function. + act_T : int + Number of periods to simulate when making a history of of the market. + """ + + def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): + agents = agents if agents is not None else list() + Market.__init__( + self, + agents=agents, + sow_vars=[ + "MaggNow", + "AaggNow", + "RfreeNow", + "wRteNow", + "PermShkAggNow", + "TranShkAggNow", + "KtoLnow", + ], + reap_vars=[], + track_vars=["MaggNow", "AaggNow", "KtoLnow"], + dyn_vars=[], + tolerance=tolerance, + act_T=act_T, + ) + self.assign_parameters(**kwds) + self.update() + + def update(self): + """ + Use primitive parameters to set basic objects. + This is an extremely stripped-down version + of update for CobbDouglasEconomy. + + Parameters + ---------- + none + + Returns + ------- + none + """ + self.kSS = 1.0 + self.MSS = 1.0 + self.sow_init["KtoLnow_init"] = self.kSS + self.Rfunc = ConstantFunction(self.Rfree) + self.wFunc = ConstantFunction(self.wRte) + self.sow_init["RfreeNow"] = self.Rfunc(self.kSS) + self.sow_init["wRteNow"] = self.wFunc(self.kSS) + self.sow_init["MaggNow"] = self.kSS + self.sow_init["AaggNow"] = self.kSS + self.sow_init["PermShkAggNow"] = 1.0 + self.sow_init["TranShkAggNow"] = 1.0 + self.make_AggShkDstn() + self.AFunc = ConstantFunction(1.0) + + def make_AggShkDstn(self): + """ + Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. + Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.TranShkAggDstn = MeanOneLogNormal(sigma=self.TranShkAggStd).approx( + N=self.TranShkAggCount + ) + self.PermShkAggDstn = MeanOneLogNormal(sigma=self.PermShkAggStd).approx( + N=self.PermShkAggCount + ) + self.AggShkDstn = combine_indep_dstns(self.PermShkAggDstn, self.TranShkAggDstn) + + def mill_rule(self): + """ + No aggregation occurs for a small open economy, because the wage and interest rates are + exogenously determined. However, aggregate shocks may occur. + + See documentation for get_AggShocks() for more information. + """ + return self.get_AggShocks() + + def calc_dynamics(self, KtoLnow): + """ + Calculates a new dynamic rule for the economy, which is just an empty object. + There is no "dynamic rule" for a small open economy, because K/L does not generate w and R. + """ + return MetricObject() + + def reset(self): + """ + Reset the economy to prepare for a new simulation. Sets the time index of aggregate shocks + to zero and runs Market.reset(). This replicates the reset method for CobbDouglasEconomy; + future version should create parent class of that class and this one. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.Shk_idx = 0 + Market.reset(self) + + def make_AggShkHist(self): + """ + Make simulated histories of aggregate transitory and permanent shocks. Histories are of + length self.act_T, for use in the general equilibrium simulation. This replicates the same + method for CobbDouglasEconomy; future version should create parent class. + + Parameters + ---------- + None + + Returns + ------- + None + """ + sim_periods = self.act_T + Events = np.arange(self.AggShkDstn.pmf.size) # just a list of integers + EventDraws = self.AggShkDstn.draw(N=sim_periods, X=Events) + PermShkAggHist = self.AggShkDstn.X[0][EventDraws] + TranShkAggHist = self.AggShkDstn.X[1][EventDraws] + + # Store the histories + self.PermShkAggHist = PermShkAggHist + self.TranShkAggHist = TranShkAggHist + + def get_AggShocks(self): + """ + Returns aggregate state variables and shocks for this period. The capital-to-labor ratio + is irrelevant and thus treated as constant, and the wage and interest rates are also + constant. However, aggregate shocks are assigned from a prespecified history. + + Parameters + ---------- + None + + Returns + ------- + MaggNow : float + Aggregate market resources for this period normalized by mean permanent income + AaggNow : float + Aggregate savings for this period normalized by mean permanent income + RfreeNow : float + Interest factor on assets in the economy this period. + wRteNow : float + Wage rate for labor in the economy this period. + PermShkAggNow : float + Permanent shock to aggregate labor productivity this period. + TranShkAggNow : float + Transitory shock to aggregate labor productivity this period. + KtoLnow : float + Capital-to-labor ratio in the economy this period. + + """ + # Get this period's aggregate shocks + PermShkAggNow = self.PermShkAggHist[self.Shk_idx] + TranShkAggNow = self.TranShkAggHist[self.Shk_idx] + self.Shk_idx += 1 + + # Factor prices are constant + RfreeNow = self.Rfunc(1.0 / PermShkAggNow) + wRteNow = self.wFunc(1.0 / PermShkAggNow) + + # Aggregates are irrelavent + AaggNow = 1.0 + MaggNow = 1.0 + KtoLnow = 1.0 / PermShkAggNow + + return ( + MaggNow, + AaggNow, + RfreeNow, + wRteNow, + PermShkAggNow, + TranShkAggNow, + KtoLnow, + ) + + +# Make a dictionary to specify a Markov Cobb-Douglas economy +init_mrkv_cobb_douglas = init_cobb_douglas.copy() +init_mrkv_cobb_douglas["PermShkAggStd"] = [0.012, 0.006] +init_mrkv_cobb_douglas["TranShkAggStd"] = [0.006, 0.003] +init_mrkv_cobb_douglas["PermGroFacAgg"] = [0.98, 1.02] +init_mrkv_cobb_douglas["MrkvArray"] = MrkvArray +init_mrkv_cobb_douglas["MrkvNow_init"] = 0 +init_mrkv_cobb_douglas["slope_prev"] = 2 * [slope_prev] +init_mrkv_cobb_douglas["intercept_prev"] = 2 * [intercept_prev] + + +class CobbDouglasMarkovEconomy(CobbDouglasEconomy): + """ + A class to represent an economy with a Cobb-Douglas aggregate production + function over labor and capital, extending HARK.Market. The "aggregate + market process" for this market combines all individuals' asset holdings + into aggregate capital, yielding the interest factor on assets and the wage + rate for the upcoming period. This small extension incorporates a Markov + state for the "macroeconomy", so that the shock distribution and aggregate + productivity growth factor can vary over time. + + Parameters + ---------- + agents : [ConsumerType] + List of types of consumers that live in this economy. + tolerance: float + Minimum acceptable distance between "dynamic rules" to consider the + solution process converged. Distance depends on intercept and slope + of the log-linear "next capital ratio" function. + act_T : int + Number of periods to simulate when making a history of of the market. + """ + + def __init__( + self, + agents=None, + tolerance=0.0001, + act_T=1200, + sow_vars=[ + "MaggNow", + "AaggNow", + "RfreeNow", + "wRteNow", + "PermShkAggNow", + "TranShkAggNow", + "KtoLnow", + "Mrkv", # This one is new + ], + **kwds + ): + agents = agents if agents is not None else list() + params = init_mrkv_cobb_douglas.copy() + params.update(kwds) + + CobbDouglasEconomy.__init__( + self, + agents=agents, + tolerance=tolerance, + act_T=act_T, + sow_vars=sow_vars, + **params + ) + + self.sow_init["Mrkv"] = params["MrkvNow_init"] + + 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 + """ + CobbDouglasEconomy.update(self) + StateCount = self.MrkvArray.shape[0] + AFunc_all = [] + for i in range(StateCount): + AFunc_all.append( + AggregateSavingRule(self.intercept_prev[i], self.slope_prev[i]) + ) + self.AFunc = AFunc_all + + def get_PermGroFacAggLR(self): + """ + Calculates and returns the long run permanent income growth factor. This + is the average growth factor in self.PermGroFacAgg, weighted by the long + run distribution of Markov states (as determined by self.MrkvArray). + + Parameters + ---------- + None + + Returns + ------- + PermGroFacAggLR : float + Long run aggregate permanent income growth factor + """ + # Find the long run distribution of Markov states + w, v = np.linalg.eig(np.transpose(self.MrkvArray)) + idx = (np.abs(w - 1.0)).argmin() + x = v[:, idx].astype(float) + LR_dstn = x / np.sum(x) + + # Return the weighted average of aggregate permanent income growth factors + PermGroFacAggLR = np.dot(LR_dstn, np.array(self.PermGroFacAgg)) + return PermGroFacAggLR + + def make_AggShkDstn(self): + """ + Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. + Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. + This version accounts for the Markov macroeconomic state. + + Parameters + ---------- + None + + Returns + ------- + None + """ + TranShkAggDstn = [] + PermShkAggDstn = [] + AggShkDstn = [] + StateCount = self.MrkvArray.shape[0] + + for i in range(StateCount): + TranShkAggDstn.append( + MeanOneLogNormal(sigma=self.TranShkAggStd[i]).approx( + N=self.TranShkAggCount + ) + ) + PermShkAggDstn.append( + MeanOneLogNormal(sigma=self.PermShkAggStd[i]).approx( + N=self.PermShkAggCount + ) + ) + AggShkDstn.append(combine_indep_dstns(PermShkAggDstn[-1], TranShkAggDstn[-1])) + + self.TranShkAggDstn = TranShkAggDstn + self.PermShkAggDstn = PermShkAggDstn + self.AggShkDstn = AggShkDstn + + def make_AggShkHist(self): + """ + Make simulated histories of aggregate transitory and permanent shocks. + Histories are of length self.act_T, for use in the general equilibrium + simulation. Draws on history of aggregate Markov states generated by + internal call to make_Mrkv_history(). + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.make_Mrkv_history() # Make a (pseudo)random sequence of Markov states + sim_periods = self.act_T + + # For each Markov state in each simulated period, draw the aggregate shocks + # that would occur in that state in that period + StateCount = self.MrkvArray.shape[0] + PermShkAggHistAll = np.zeros((StateCount, sim_periods)) + TranShkAggHistAll = np.zeros((StateCount, sim_periods)) + for i in range(StateCount): + AggShockDraws = self.AggShkDstn[i].draw(N=sim_periods) + PermShkAggHistAll[i, :] = AggShockDraws[0, :] + TranShkAggHistAll[i, :] = AggShockDraws[1, :] + + # Select the actual history of aggregate shocks based on the sequence + # of Markov states that the economy experiences + PermShkAggHist = np.zeros(sim_periods) + TranShkAggHist = np.zeros(sim_periods) + for i in range(StateCount): + these = i == self.MrkvNow_hist + PermShkAggHist[these] = PermShkAggHistAll[i, these] * self.PermGroFacAgg[i] + TranShkAggHist[these] = TranShkAggHistAll[i, these] + + # Store the histories + self.PermShkAggHist = PermShkAggHist + self.TranShkAggHist = TranShkAggHist + + def make_Mrkv_history(self): + """ + Makes a history of macroeconomic Markov states, stored in the attribute + MrkvNow_hist. This version ensures that each state is reached a sufficient + number of times to have a valid sample for calc_dynamics to produce a good + dynamic rule. It will sometimes cause act_T to be increased beyond its + initially specified level. + + Parameters + ---------- + None + + Returns + ------- + None + """ + if hasattr(self, "loops_max"): + loops_max = self.loops_max + else: # Maximum number of loops; final act_T never exceeds act_T*loops_max + loops_max = 10 + + state_T_min = 50 # Choose minimum number of periods in each state for a valid Markov sequence + logit_scale = ( + 0.2 # Scaling factor on logit choice shocks when jumping to a new state + ) + # Values close to zero make the most underrepresented states very likely to visit, while + # large values of logit_scale make any state very likely to be jumped to. + + # Reset act_T to the level actually specified by the user + if hasattr(self, "act_T_orig"): + act_T = self.act_T_orig + else: # Or store it for the first time + self.act_T_orig = self.act_T + act_T = self.act_T + + # Find the long run distribution of Markov states + w, v = np.linalg.eig(np.transpose(self.MrkvArray)) + idx = (np.abs(w - 1.0)).argmin() + x = v[:, idx].astype(float) + LR_dstn = x / np.sum(x) + + # Initialize the Markov history and set up transitions + MrkvNow_hist = np.zeros(self.act_T_orig, dtype=int) + loops = 0 + go = True + MrkvNow = self.sow_init["Mrkv"] + t = 0 + StateCount = self.MrkvArray.shape[0] + + # Add histories until each state has been visited at least state_T_min times + while go: + draws = Uniform(seed=loops).draw(N=self.act_T_orig) + markov_process = MarkovProcess(self.MrkvArray,seed=loops) + for s in range(self.act_T_orig): # Add act_T_orig more periods + MrkvNow_hist[t] = MrkvNow + MrkvNow = markov_process.draw(MrkvNow) + t += 1 + + # Calculate the empirical distribution + state_T = np.zeros(StateCount) + for i in range(StateCount): + state_T[i] = np.sum(MrkvNow_hist == i) + + # Check whether each state has been visited state_T_min times + if np.all(state_T >= state_T_min): + go = False # If so, terminate the loop + continue + + # Choose an underrepresented state to "jump" to + if np.any( + state_T == 0 + ): # If any states have *never* been visited, randomly choose one of those + never_visited = np.where(np.array(state_T == 0))[0] + MrkvNow = np.random.choice(never_visited) + else: # Otherwise, use logit choice probabilities to visit an underrepresented state + emp_dstn = state_T / act_T + ratios = LR_dstn / emp_dstn + ratios_adj = ratios - np.max(ratios) + ratios_exp = np.exp(ratios_adj / logit_scale) + ratios_sum = np.sum(ratios_exp) + jump_probs = ratios_exp / ratios_sum + cum_probs = np.cumsum(jump_probs) + MrkvNow = np.searchsorted(cum_probs, draws[-1]) + + loops += 1 + # Make the Markov state history longer by act_T_orig periods + if loops >= loops_max: + go = False + print( + "make_Mrkv_history reached maximum number of loops without generating a valid sequence!" + ) + else: + MrkvNow_new = np.zeros(self.act_T_orig, dtype=int) + MrkvNow_hist = np.concatenate((MrkvNow_hist, MrkvNow_new)) + act_T += self.act_T_orig + + # Store the results as attributes of self + self.MrkvNow_hist = MrkvNow_hist + self.act_T = act_T + + def mill_rule(self, aLvl, pLvl): + """ + Function to calculate the capital to labor ratio, interest factor, and + wage rate based on each agent's current state. Just calls calc_R_and_W() + and adds the Markov state index. + + See documentation for calc_R_and_W for more information. + + Params + ------- + aLvl : float + pLvl : float + + Returns + ------- + Mnow : float + Aggregate market resources for this period. + Aprev : float + Aggregate savings for the prior period. + KtoLnow : float + Capital-to-labor ratio in the economy this period. + Rnow : float + Interest factor on assets in the economy this period. + Wnow : float + Wage rate for labor in the economy this period. + MrkvNow : int + Binary indicator for bad (0) or good (1) macroeconomic state. + """ + MrkvNow = self.MrkvNow_hist[self.Shk_idx] + temp = self.calc_R_and_W(aLvl, pLvl) + + return temp + (MrkvNow,) + + def calc_AFunc(self, MaggNow, AaggNow): + """ + Calculate a new aggregate savings rule based on the history of the + aggregate savings and aggregate market resources from a simulation. + Calculates an aggregate saving rule for each macroeconomic Markov state. + + Parameters + ---------- + MaggNow : [float] + List of the history of the simulated aggregate market resources for an economy. + AaggNow : [float] + List of the history of the simulated aggregate savings for an economy. + + Returns + ------- + (unnamed) : CapDynamicRule + Object containing new saving rules for each Markov state. + """ + verbose = self.verbose + discard_periods = ( + self.T_discard + ) # Throw out the first T periods to allow the simulation to approach the SS + update_weight = ( + 1.0 - self.DampingFac + ) # Proportional weight to put on new function vs old function parameters + total_periods = len(MaggNow) + + # Trim the histories of M_t and A_t and convert them to logs + logAagg = np.log(AaggNow[discard_periods:total_periods]) + logMagg = np.log(MaggNow[discard_periods - 1 : total_periods - 1]) + MrkvHist = self.MrkvNow_hist[discard_periods - 1 : total_periods - 1] + + # For each Markov state, regress A_t on M_t and update the saving rule + AFunc_list = [] + rSq_list = [] + for i in range(self.MrkvArray.shape[0]): + these = i == MrkvHist + slope, intercept, r_value, p_value, std_err = stats.linregress( + logMagg[these], logAagg[these] + ) + + # Make a new aggregate savings rule by combining the new regression parameters + # with the previous guess + intercept = ( + update_weight * intercept + + (1.0 - update_weight) * self.intercept_prev[i] + ) + slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev[i] + AFunc_list.append( + AggregateSavingRule(intercept, slope) + ) # Make a new next-period capital function + rSq_list.append(r_value ** 2) + + # Save the new values as "previous" values for the next iteration + self.intercept_prev[i] = intercept + self.slope_prev[i] = slope + + # Print the new parameters + if verbose: + print( + "intercept=" + + str(self.intercept_prev) + + ", slope=" + + str(self.slope_prev) + + ", r-sq=" + + str(rSq_list) + ) + + return AggShocksDynamicRule(AFunc_list) + + +class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy, SmallOpenEconomy): + """ + A class for representing a small open economy, where the wage rate and interest rate are + exogenously determined by some "global" rate. However, the economy is still subject to + aggregate productivity shocks. This version supports a discrete Markov state. All + methods in this class inherit from the two parent classes. + """ + + def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): + agents = agents if agents is not None else list() + CobbDouglasMarkovEconomy.__init__( + self, agents=agents, tolerance=tolerance, act_T=act_T, **kwds + ) + self.reap_vars = [] + self.dyn_vars = [] + + def update(self): + SmallOpenEconomy.update(self) + StateCount = self.MrkvArray.shape[0] + self.AFunc = StateCount * [IdentityFunction()] + + def make_AggShkDstn(self): + CobbDouglasMarkovEconomy.make_AggShkDstn(self) + + def mill_rule(self): + MrkvNow = self.MrkvNow_hist[self.Shk_idx] + temp = SmallOpenEconomy.get_AggShocks(self) + temp(MrkvNow=MrkvNow) + return temp + + def calc_dynamics(self, KtoLnow): + return MetricObject() + + def make_AggShkHist(self): + CobbDouglasMarkovEconomy.make_AggShkHist(self) + + +init_KS_economy = { + "verbose": True, + "act_T": 11000, + "T_discard": 1000, + "DampingFac": 0.5, + "intercept_prev": [0.0, 0.0], + "slope_prev": [1.0, 1.0], + "DiscFac": 0.99, + "CRRA": 1.0, + "LbrInd": 0.3271, # Not listed in KS (1998), but Alan Lujan got this number indirectly from KS + "ProdB": 0.99, + "ProdG": 1.01, + "CapShare": 0.36, + "DeprFac": 0.025, + "DurMeanB": 8.0, + "DurMeanG": 8.0, + "SpellMeanB": 2.5, + "SpellMeanG": 1.5, + "UrateB": 0.10, + "UrateG": 0.04, + "RelProbBG": 0.75, + "RelProbGB": 1.25, + "MrkvNow_init": 0, +} + + +class KrusellSmithEconomy(Market): + """ + A class to represent an economy in the special Krusell-Smith (1998) model. + This model replicates the one presented in the JPE article "Income and Wealth + Heterogeneity in the Macroeconomy", with its default parameters set to match + those in the paper. + + Parameters + ---------- + agents : [ConsumerType] + List of types of consumers that live in this economy. + tolerance: float + Minimum acceptable distance between "dynamic rules" to consider the + solution process converged. Distance depends on intercept and slope + of the log-linear "next capital ratio" function. + act_T : int + Number of periods to simulate when making a history of of the market. + """ + + def __init__(self, agents=None, tolerance=0.0001, **kwds): + agents = agents if agents is not None else list() + params = deepcopy(init_KS_economy) + params.update(kwds) + + Market.__init__( + self, + agents=agents, + tolerance=tolerance, + sow_vars=["Mnow", "Aprev", "Mrkv", "Rnow", "Wnow"], + reap_vars=["aNow", "EmpNow"], + track_vars=["Mrkv", "Aprev", "Mnow", "Urate"], + dyn_vars=["AFunc"], + **params + ) + self.update() + + def update(self): + """ + Construct trivial initial guesses of the aggregate saving rules, as well + as the perfect foresight steady state and associated objects. + """ + StateCount = 2 + AFunc_all = [ + AggregateSavingRule(self.intercept_prev[j], self.slope_prev[j]) + for j in range(StateCount) + ] + self.AFunc = AFunc_all + self.KtoLSS = ( + (1.0 ** self.CRRA / self.DiscFac - (1.0 - self.DeprFac)) / self.CapShare + ) ** (1.0 / (self.CapShare - 1.0)) + self.KSS = self.KtoLSS * self.LbrInd + self.KtoYSS = self.KtoLSS ** (1.0 - self.CapShare) + self.WSS = (1.0 - self.CapShare) * self.KtoLSS ** (self.CapShare) + self.RSS = ( + 1.0 + self.CapShare * self.KtoLSS ** (self.CapShare - 1.0) - self.DeprFac + ) + self.MSS = self.KSS * self.RSS + self.WSS * self.LbrInd + self.convertKtoY = lambda KtoY: KtoY ** ( + 1.0 / (1.0 - self.CapShare) + ) # converts K/Y to K/L + self.rFunc = lambda k: self.CapShare * k ** (self.CapShare - 1.0) + self.Wfunc = lambda k: ((1.0 - self.CapShare) * k ** (self.CapShare)) + self.sow_init["KtoLnow"] = self.KtoLSS + self.sow_init["Mnow"] = self.MSS + self.sow_init["Aprev"] = self.KSS + self.sow_init["Rnow"] = self.RSS + self.sow_init["Wnow"] = self.WSS + self.PermShkAggNow_init = 1.0 + self.TranShkAggNow_init = 1.0 + self.sow_init["Mrkv"] = 0 + self.make_MrkvArray() + + def reset(self): + """ + Reset the economy to prepare for a new simulation. Sets the time index + of aggregate shocks to zero and runs Market.reset(). + """ + self.Shk_idx = 0 + Market.reset(self) + + def make_MrkvArray(self): + """ + Construct the attributes MrkvAggArray and MrkvIndArray from the primitive + attributes DurMeanB, DurMeanG, SpellMeanB, SpellMeanG, UrateB, UrateG, + RelProbGB, and RelProbBG. + """ + # Construct aggregate Markov transition probabilities + ProbBG = 1.0 / self.DurMeanB + ProbGB = 1.0 / self.DurMeanG + ProbBB = 1.0 - ProbBG + ProbGG = 1.0 - ProbGB + MrkvAggArray = np.array([[ProbBB, ProbBG], [ProbGB, ProbGG]]) + + # Construct idiosyncratic Markov transition probabilities + # ORDER: BU, BE, GU, GE + MrkvIndArray = np.zeros((4, 4)) + + # BAD-BAD QUADRANT + MrkvIndArray[0, 1] = ProbBB * 1.0 / self.SpellMeanB + MrkvIndArray[0, 0] = ProbBB * (1 - 1.0 / self.SpellMeanB) + MrkvIndArray[1, 0] = self.UrateB / (1.0 - self.UrateB) * MrkvIndArray[0, 1] + MrkvIndArray[1, 1] = ProbBB - MrkvIndArray[1, 0] + + # GOOD-GOOD QUADRANT + MrkvIndArray[2, 3] = ProbGG * 1.0 / self.SpellMeanG + MrkvIndArray[2, 2] = ProbGG * (1 - 1.0 / self.SpellMeanG) + MrkvIndArray[3, 2] = self.UrateG / (1.0 - self.UrateG) * MrkvIndArray[2, 3] + MrkvIndArray[3, 3] = ProbGG - MrkvIndArray[3, 2] + + # BAD-GOOD QUADRANT + MrkvIndArray[0, 2] = self.RelProbBG * MrkvIndArray[2, 2] / ProbGG * ProbBG + MrkvIndArray[0, 3] = ProbBG - MrkvIndArray[0, 2] + MrkvIndArray[1, 2] = ( + ProbBG * self.UrateG - self.UrateB * MrkvIndArray[0, 2] + ) / (1.0 - self.UrateB) + MrkvIndArray[1, 3] = ProbBG - MrkvIndArray[1, 2] + + # GOOD-BAD QUADRANT + MrkvIndArray[2, 0] = self.RelProbGB * MrkvIndArray[0, 0] / ProbBB * ProbGB + MrkvIndArray[2, 1] = ProbGB - MrkvIndArray[2, 0] + MrkvIndArray[3, 0] = ( + ProbGB * self.UrateB - self.UrateG * MrkvIndArray[2, 0] + ) / (1.0 - self.UrateG) + MrkvIndArray[3, 1] = ProbGB - MrkvIndArray[3, 0] + + # Test for valid idiosyncratic transition probabilities + assert np.all( + MrkvIndArray >= 0.0 + ), "Invalid idiosyncratic transition probabilities!" + self.MrkvArray = MrkvAggArray + self.MrkvIndArray = MrkvIndArray + + def make_Mrkv_history(self): + """ + Makes a history of macroeconomic Markov states, stored in the attribute + MrkvNow_hist. This variable is binary (0 bad, 1 good) in the KS model. + """ + # Initialize the Markov history and set up transitions + self.MrkvNow_hist = np.zeros(self.act_T, dtype=int) + MrkvNow = self.MrkvNow_init + + markov_process = MarkovProcess(self.MrkvArray, seed= 0) + for s in range(self.act_T): # Add act_T_orig more periods + self.MrkvNow_hist[s] = MrkvNow + MrkvNow = markov_process.draw(MrkvNow) + + + def mill_rule(self, aNow, EmpNow): + """ + Method to calculate the capital to labor ratio, interest factor, and + wage rate based on each agent's current state. Just calls calc_R_and_W(). + + See documentation for calc_R_and_W for more information. + + Returns + ------- + Mnow : float + Aggregate market resources for this period. + Aprev : float + Aggregate savings for the prior period. + MrkvNow : int + Binary indicator for bad (0) or good (1) macroeconomic state. + Rnow : float + Interest factor on assets in the economy this period. + Wnow : float + Wage rate for labor in the economy this period. + """ + + return self.calc_R_and_W(aNow, EmpNow) + + def calc_dynamics(self, Mnow, Aprev): + """ + Method to update perceptions of the aggregate saving rule in each + macroeconomic state; just calls calc_AFunc. + """ + return self.calc_AFunc(Mnow, Aprev) + + def calc_R_and_W(self, aNow, EmpNow): + """ + Calculates the interest factor and wage rate this period using each agent's + capital stock to get the aggregate capital ratio. + + Parameters + ---------- + aNow : [np.array] + Agents' current end-of-period assets. Elements of the list correspond + to types in the economy, entries within arrays to agents of that type. + EmpNow [np.array] + Agents' binary employment states. Not actually used in computation of + interest and wage rates, but stored in the history to verify that the + idiosyncratic unemployment probabilities are behaving as expected. + + Returns + ------- + Mnow : float + Aggregate market resources for this period. + Aprev : float + Aggregate savings for the prior period. + MrkvNow : int + Binary indicator for bad (0) or good (1) macroeconomic state. + Rnow : float + Interest factor on assets in the economy this period. + Wnow : float + Wage rate for labor in the economy this period. + """ + # Calculate aggregate savings + Aprev = np.mean(np.array(aNow)) # End-of-period savings from last period + # Calculate aggregate capital this period + AggK = Aprev # ...becomes capital today + + # Calculate unemployment rate + Urate = 1.0 - np.mean(np.array(EmpNow)) + self.Urate = Urate # This is the unemployment rate for the *prior* period + + # Get this period's TFP and labor supply + MrkvNow = self.MrkvNow_hist[self.Shk_idx] + if MrkvNow == 0: + Prod = self.ProdB + AggL = (1.0 - self.UrateB) * self.LbrInd + elif MrkvNow == 1: + Prod = self.ProdG + AggL = (1.0 - self.UrateG) * self.LbrInd + self.Shk_idx += 1 + + # Calculate the interest factor and wage rate this period + KtoLnow = AggK / AggL + Rnow = 1.0 + Prod * self.rFunc(KtoLnow) - self.DeprFac + Wnow = Prod * self.Wfunc(KtoLnow) + Mnow = Rnow * AggK + Wnow * AggL + self.KtoLnow = KtoLnow # Need to store this as it is a sow variable + + # Returns a tuple of these values + return Mnow, Aprev, MrkvNow, Rnow, Wnow + + def calc_AFunc(self, Mnow, Aprev): + """ + Calculate a new aggregate savings rule based on the history of the + aggregate savings and aggregate market resources from a simulation. + Calculates an aggregate saving rule for each macroeconomic Markov state. + + Parameters + ---------- + Mnow : [float] + List of the history of the simulated aggregate market resources for an economy. + Anow : [float] + List of the history of the simulated aggregate savings for an economy. + + Returns + ------- + (unnamed) : CapDynamicRule + Object containing new saving rules for each Markov state. + """ + verbose = self.verbose + discard_periods = ( + self.T_discard + ) # Throw out the first T periods to allow the simulation to approach the SS + update_weight = ( + 1.0 - self.DampingFac + ) # Proportional weight to put on new function vs old function parameters + total_periods = len(Mnow) + + # Trim the histories of M_t and A_t and convert them to logs + logAagg = np.log(Aprev[discard_periods:total_periods]) + logMagg = np.log(Mnow[discard_periods - 1 : total_periods - 1]) + MrkvHist = self.MrkvNow_hist[discard_periods - 1 : total_periods - 1] + + # For each Markov state, regress A_t on M_t and update the saving rule + AFunc_list = [] + rSq_list = [] + for i in range(self.MrkvArray.shape[0]): + these = i == MrkvHist + slope, intercept, r_value, p_value, std_err = stats.linregress( + logMagg[these], logAagg[these] + ) + + # Make a new aggregate savings rule by combining the new regression parameters + # with the previous guess + intercept = ( + update_weight * intercept + + (1.0 - update_weight) * self.intercept_prev[i] + ) + slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev[i] + AFunc_list.append( + AggregateSavingRule(intercept, slope) + ) # Make a new next-period capital function + rSq_list.append(r_value ** 2) + + # Save the new values as "previous" values for the next iteration + self.intercept_prev[i] = intercept + self.slope_prev[i] = slope + + # Print the new parameters + if verbose: + print( + "intercept=" + + str(self.intercept_prev) + + ", slope=" + + str(self.slope_prev) + + ", r-sq=" + + str(rSq_list) + ) + + return AggShocksDynamicRule(AFunc_list) + + +class AggregateSavingRule(MetricObject): + """ + A class to represent agent beliefs about aggregate saving at the end of this period (AaggNow) as + a function of (normalized) aggregate market resources at the beginning of the period (MaggNow). + + Parameters + ---------- + intercept : float + Intercept of the log-linear capital evolution rule. + slope : float + Slope of the log-linear capital evolution rule. + """ + + def __init__(self, intercept, slope): + self.intercept = intercept + self.slope = slope + self.distance_criteria = ["slope", "intercept"] + + def __call__(self, Mnow): + """ + Evaluates aggregate savings as a function of the aggregate market resources this period. + + Parameters + ---------- + Mnow : float + Aggregate market resources this period. + + Returns + ------- + Aagg : Expected aggregate savings this period. + """ + Aagg = np.exp(self.intercept + self.slope * np.log(Mnow)) + return Aagg + + +class AggShocksDynamicRule(MetricObject): + """ + Just a container class for passing the dynamic rule in the aggregate shocks model to agents. + + Parameters + ---------- + AFunc : CapitalEvoRule + Aggregate savings as a function of aggregate market resources. + """ + + def __init__(self, AFunc): + self.AFunc = AFunc + self.distance_criteria = ["AFunc"] diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py new file mode 100644 index 00000000..dd095180 --- /dev/null +++ b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py @@ -0,0 +1,181 @@ +# 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. + """ + + 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 + self.update() + + # def get_shocks(self): + # """ + # Same as in AggShockConsumerType, but with transitory income shocks decreased by the tax rate. + # + # Parameters + # ---------- + # None + # + # Returns + # ------- + # None + # """ + # IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks + # self.shocks['TranShk'] = ( + # self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow + # ) + # self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow + + + 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 * (1 - 0.05) + return transfers + +# 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): + """ + A class to represent an economy with a Cobb-Douglas aggregate production + function over labor and capital, extending HARK.Market. The "aggregate + market process" for this market combines all individuals' asset holdings + into aggregate capital, yielding the interest factor on assets and the wage + rate for the upcoming period. + + Note: The current implementation assumes a constant labor supply, but + this will be generalized in the future. + + Parameters + ---------- + tax_rate: + """ + + 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..006bbadb --- /dev/null +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -0,0 +1,924 @@ +{ + "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\", AER 89 (5) p.1156-1181, 1999\n", + "\n", + "## Kyung Woong Koh (May 17, 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\n", + "\n", + "Distribution of wealth / permanent income / preferences" + ] + }, + { + "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)
\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. *Updating agents' asset levels after taxes and transfers*: I tried multiplying the transitory income shock with (1-tax_rate), but then I had difficulty in locating exactly which part of the code updates individuals' asset levels (aLvl) or normalized asset levels (aNrm). So far, the asset levels (and therefore aggregate capital stock) of the agents are exactly the same for each level of tax rate. Once I figure this part out, the value function for the median agent in each tax rate would be accurate, and hopefully show that the median (wealth) agent's value function is maximized at some middle tax rate between 0 (no redistribution and no distortive taxation) and 1 (total redistribution and totally distortive taxation)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ac322ba6-510b-438b-837e-dde9a4ee2ee9", + "metadata": {}, + "outputs": [], + "source": [ + "import HARK\n", + "import sys\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, AggShockConsumerType_tax,\n", + " CobbDouglasEconomy, CobbDouglasEconomy_tax)\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", + "source": [ + "I first set the parameters for each agent as follows, with the addition of a flat income tax rate (`tax_rate`):" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 27, + "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 - no shocks of this kind!\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 - no shocks of this kind!\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": 28, + "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", + "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" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "d476e500-624c-4bc8-ae78-4d22901fd8dd", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "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", + "source": [ + "I then solve for the model." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 30, + "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": 18, + "id": "71c66623-6ff5-485a-8815-431c2be0764a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.600736339017846, slope=1.1626718040790442, r-sq=0.7970695854316202\n", + "intercept=-0.5690387254827874, slope=1.144596971056191, r-sq=0.8063777583962061\n", + "intercept=-0.5468314979996045, slope=1.1330227287075485, r-sq=0.8063809444926031\n", + "intercept=-0.5361412473190589, slope=1.127502039450247, r-sq=0.8088097539216077\n", + "intercept=-0.5311542259396478, slope=1.1249304315188215, r-sq=0.8099901725510609\n", + "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\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", + "source": [ + "Consumption function at each aggregate market resources-to-labor ratio gridpoint" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6b247866", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption function at each aggregate market resources-to-labor ratio gridpoint:\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABe+klEQVR4nO2dd3hc1Zm43zu9d/VqW+7dlmmmgyFAAgRISEIKkF0SNoWEkLrJbtovvZG2hPRks5C6hE1CSSD0Ymzj3pt6G03v7fz+uKORZMm4SR5JPu/z3OfeuXNn7hlZev3Nd75zjiKEQCKRSCTTH025GyCRSCSSiUEKXSKRSGYIUugSiUQyQ5BCl0gkkhmCFLpEIpHMEHTlurHP5xPNzc3lur1EIpFMSzZu3OgXQlSM91zZhN7c3MyGDRvKdXuJRCKZliiK0na052TKRSKRSGYIUugSiUQyQ5BCl0gkkhmCFLpEIpHMEKTQJRKJZIYghS6RSCQzBCl0iUQimSEcU+iKojQoivJPRVF2KoqyQ1GUu8a55mJFUcKKomwubv8xOc2VSCSS6UksE2N9z3p+uu2nvNj94qTc43gGFuWAjwghNimKYgc2KorydyHEziOue1YI8fqJb6JEIpFMLzL5DHuDe9nu3842/za2+7dzKHwIgbr+xO1Lbufc2nMn/L7HFLoQogfoKR5HFUXZBdQBRwpdIpFIzjgKokBbpG2UvHcHdpMtZAHwmDws9S3lqllXsdS3lMXexbhMrklpywkN/VcUpRlYCbw8ztPnKoqyBegG7hFC7Dj15kkkEsnUoj/RXxL3Nv82dvh3EMvGADDrzCz2LubtC9/OEt8SlvqWUm2tRlGU09K24xa6oig24I/Ah4QQkSOe3gQ0CSFiiqJcDTwEzB3nPe4A7gBobGw82TZLJBLJaSGaibJjcIcq7wFV4v3JfgB0io657rlcPetqlviWsMS3hNnO2Wg12rK1VzmeNUUVRdEDfwEeE0J86ziuPwy0CiH8R7umtbVVyMm5JBLJVCGTz7AnsGdU9H04crj0fJOjqRR1L/YuZoFnASad6bS3U1GUjUKI1vGeO2aErqjfFX4K7DqazBVFqQb6hBBCUZSzUKtnBk+hzRKJRDJpFESBw+HDbPNvKwl8T3APuUIOAK/Jy9KKpbxhzhtY4l3CYt9inEZnmVt9bI4n5bIWeAewTVGUzcVznwIaAYQQ9wE3AXcqipIDksBbxPGE/hKJRHIayOaz7AzsZFPfJjb2beTV/leJZNTMsUVnYYlvCe9c9M5SBF5lqTptee+J5HiqXJ4DXvOTCSG+D3x/oholkUgkp0Iim2DLwBY29W9iU98mtg5sJZVPAdDsaObypstZUbGCZRXLaHY0lzXvPZGUbYELiUQimShCqVBJ3hv7NrIrsIu8yKNRNMx3z+fGeTeyqnIVq6pW4TP7yt3cSUMKXSKRTDt6Yj1s7N/Ipj5V4gfCBwAwaAws8S3h9iW3s6pqFSsqVmAz2Mrc2tOHFLpEIpnSCCE4FD40SuDd8W4AbHobyyuXc83sa1hVtYolviUYtcYyt7h8SKFLJJIpRa6QY3dgNxv7VIG/2v8qwXQQUKtPVlWt4p2L38mqylXMc8+bMfnviUAKXSKRlJVULsU2/7aSwLcMbCGRSwBQb6vngvoLWF21mtVVq2m0N07L6pPThRS6RCI5rUQyETb3by4JfPvgdnKFHAoKc91zuXbOtayuWs2qqlVUWirL3dxphRS6RCKZVPoT/aXqk039m9gX3IdAoNPoWOxdzDsWvYPVlatZUbliWgzemcpIoUskkgkllArxQvcLvNjzIhv7NtIR7QDUiatWVKxg3Yp1rK5azRLfEsw6c5lbO7OQQpdIJKdEQRTYObiTZ7ue5bmu59ju305BFHAanayuXM3N829mddVqFngWoNNI5Uwm8qcrkUhOmKEo/Lmu53i++3kCqQAKCkt8S3jPsvdwft35LPYulhUopxkpdIlEckyOFoW7jC7W1q3l/LrzOa/2PDwmT7mbekYjhS6RSMZFRuHTDyl0iUQCqFH4rsFdPNP1zJgo/Lza87ig/gIZhU9xpNAlkjMYGYXPLKTQJZIziKEo/NmuZ3m269kxUfj5deeztm6tjMKnKVLoEskM52hR+GLvYu5YdgcX1F0go/AZghS6RDLDEEKwL7SPJ9uf5Lmu59jm3yaj8DMEKXSJZIawP7ifx9oe47HDj3EofGhUFH5+3fks8S6RUfgMRwpdIpnGHAgd4PHDj/PY4cc4ED6AgkJrdSu3LLiFy5oum9Gr80jGIoUukUwzDoYP8tjhx3j88OPsD+1HQWF11Wo+teBTrGtaJyV+BiOFLpFMAw6FD6mReNtj7AvuQ0FhZeVKPnnWJ1nXtI4KS0W5myiZAkihSyRTlLZIG48dVnPie4N7AVhVuYpPnPUJ1jWtk3OFS8YghS6RTCHaI+083qbmxHcHdgOwomIFH1/zcS5vupxqa3WZWyiZykihSyRlpiPSwWNtak58V2AXAMsrlvOxNR9jXdM6KXHJcSOFLpGUgc5oZykS3zm4E4BlvmXc03oPVzRdQY2tpswtlExHpNAlktNEd6y7VGK4fXA7AEt9S7mn9R7WNa2j1lZb5hZKpjtS6BLJJJLMJflH2z94aP9DrO9dD8AS7xLuXn03VzRfQZ2trswtlMwkpNAlkglGCMGWgS08tP8hHjv8GLFsjHpbPe9b8T6umX0NDfaGcjdRMkORQpdIJoiBxAAPH3iYPx/4M4fChzDrzKxrWsf1Ldezumo1GkVT7iZKZjhS6BLJKZDNZ3mq8yke2v8Qz3c9T17kWVW5itvOu40rmq/AqreWu4mS000hD7E+CHdBZGjrhmgvxPsh1g8rboG1H5zwWx9T6IqiNAC/AqoAAdwvhLj3iGsU4F7gaiAB3CqE2DThrZVIpgi7A7t5aP9D/PXgXwmlQ1RaKrltyW1cN+c6mp3N5W6eZLIoFFQpR7pGCzs8Utw9UMiNfp3ODPZqsFWBby44JqcD/Hgi9BzwESHEJkVR7MBGRVH+LoTYOeKaq4C5xe1s4L+Ke4lkxhBKhfjrob/y0P6H2B3YjV6j59LGS7m+5XrOrTlXzmQ43SkUIDEIkc6jyLoLIj1QyI5+nc6kCtpRB01rwVmnHjvrh8+b3aAok/4Rjil0IUQP0FM8jiqKsguoA0YK/TrgV0IIAbykKIpLUZSa4mslkmlLrpDjhe4XeGj/QzzV8RTZQpaFnoV88qxPcs3sa3AaneVuouR4EAISgaPIuls9H+mGfGb067SGopTroeGcYVk76orH9WDxnBZZHw8nlENXFKUZWAm8fMRTdUDHiMedxXNS6JJpyaHwIR7a/xD/d+D/GEgO4Da6uXn+zVzfcj3zPfPL3TzJSISAZHA45RHuHCey7oZcavTrNHpw1KhyrmuFRePJ2gua6dOZfdxCVxTFBvwR+JAQInIyN1MU5Q7gDoDGxsaTeQuJZNKIZWI8dvgxHtr/EJsHNqNVtJxfdz7Xt1zPRfUXodfqy93EM5dEAAKHIHgIAgcheHhY3JFuyCZGX69oi5F1LdSsgAXXHCHrOrBWTitZHw/HJXRFUfSoMv+NEOJP41zSBYwsrq0vnhuFEOJ+4H6A1tZWccKtlUgmgZ2DO3lw94M8evhRkrkks52zuXv13bx+9uvltLSnCyHUypBAUdiBg8PyDhyEVHj09fYaNUddtQTmXjk2FWKrgjOwT+N4qlwU4KfALiHEt45y2cPA+xVFeRC1MzQs8+eSqYwQgqc6nuIn237CVv9WzDozV8+6mhvm3sBS31KUKZITnVEU8mpEHTh4hLgPq4+z8eFrFS24GsAzG5a+Cdyz1GPPLHA3g95crk8xpTmeCH0t8A5gm6Iom4vnPgU0Aggh7gP+hlqyuB+1bPG2CW+pRDJBbBvYxjc3fpONfRtpsDfw8TUf59qWa3EYHOVu2vQnl4Fwx7CsR4o71Da601FrKIp6Fsy6UBX20GNXI8gU1wlzPFUuzwGvGa4Uq1veN1GNkkgmg85oJ9/d9F0eOfwIHpOHT5/9aW6YdwN6jRTHCZFJFKPqkWmR4j7cAaIwfK3Bpkq6cqGax/YMRdqzwV4743LY5UaOFJXMeMLpMPdvvZ8Hdj+AVtFyx7I7uH3J7XIU57FIBKB/J/Tvgr4d4N+rSjt6RDbV7FYFXb8Glt08nBrxzAZrxZQp6TsTkEKXzFgy+QwP7H6AH239EbFMjOtbrud9K95HlbWq3E2bWmRTMLC7KO+d0FfcjxS3yQUVC2DOpcNpkSFxm91la7pkNFLokhlHQRR49NCjfPfV79IV62Jt7Vo+vPrDsn68kFdTJX07Rss7cGA4TaI1QsV8mH2xmiapXAxVi9SqEhlpT3mk0CUzild6X+GbG77JjsEdzHfP50frfsR5teeVu1mnFyHUCaD6dwxH2/07oX835JLFixQ1uq5cBEtuGJa3ZzZopRamK/JfTjIjOBg6yLc3fpunOp+iylLFF9d+kdfPfv3Mn18lHVVFfaS8E4PD11gr1Si79XZV3FWL1PSJQfYhzDSk0CXTGn/Szw83/5A/7fsTJp2Ju1bdxdsXvh2TzlTupk0sQkCoHbo2qCmTIXmH2oav0VuHq0kqF6lb1WKw+srXbslpRQpdMi1JZBP8cucv+fn2n5PNZ3nz/Dfz3uXvxWPylLtpE0M6Bt2vQucr0LlB3cf71ecUrToFa91qWPkONeKuXASuJlkGeIYjhS6ZVuQLeR7a/xA/2PwDBpIDXN54OXetumt6z0FeKMDgvqK8X4HOjWoKZaij0tsCLZdBfas6iVTlQtAZy9tmyZRECl0yLRBC8FzXc3xr47fYH9rPsoplfPPib7KycmW5m3biJALQtXG0wNPFuUqMTqhfDQs+qtZ1161Wp2eVzCiEEJMyvYQUumTKs2twF9/c+E1e7nmZBnsD37zom6xrWjc95lvJ59Roe2TqZHC/+pyiUStLltygyrt+jRqNy7TJtEEIQTSdIxDLMBjPEIhnCCUyhJNZQoksoWRG3Y84Diey3La2mbuvmPgyWil0yZQlnA7z7Y3f5k/7/oTD6ODjaz7OzfNvntrT2EZ6RkTeG9Q8+FCpoLUC6s9S15OsXwO1K8FoK297JaPIFwTBRIZgfFjQg/EMgViGQDxNIJElEE8zGFOfCyYyZPPjTxyrUcBlMeAy63Fa9FTaTcyrtOO06FnZODmDsaTQJVMOIQR/OfgXvrHhG4TTYd6x6B28Z/l7pubkWaEOOPAEHHwKOl5RV74BdeKp6mWw+lY1912/Rp1wajp8q5hBpHN5AkUxD21DMh6Mq+JWj9NqdJ3MIo4ysbfdpMNrNeCxGqh3W1he78JtNZTOeWwGPBb12GnRYzPo0GhO77+3FLpkSnEofIgvvvRF1veuZ1nFMu5fd//UGuGZicPh5+DAk7D/CbUzE9SJpprOhfr3q/KuXio7LicYIQTxTL6Y3kgTTAzLeaSgB0fIO5bOjfteGgXcRfl6rAbmV9vV46FzNmNJ1F6rAZfFgEE39VNhUuiSKUEql+In237Cz7b/DJPOxGfO+Qw3zbsJjVLmP6JCAfq2q1H4gSeh/SV1ClidGZrXQuttMOcydbi8jL5PimQmT380RX80TX8kTV9k6DjFQCw9StiZXGHc9zBoNSU5e20GmryWYUHbhqJoY0nQTrP+tEfPpwMpdEnZeaH7Bb740hfpiHZwzexruKf1HnzmMg6GifWr8j7wJBz453D9d+ViOPs96gRVjeeBfoYNXppg4ukc/dHRgh65HzofTY2NovVahQqbkQq7kSqHiYU1jpKwPSPSHF6rEbdVj82omx6d5JOMFLqkbPiTfr72ytd45NAjNDmauH/d/Zxbe+7pb0gurUbeQ1F47zb1vMWrynvOpTD7EnVB4TOcoaqO/khajapH7PuGouqirOOZ/JjXG3QaKouSnldl5/wWH5UOE5V2I5UOE1UOI5V2E64ZGkFPNlLoktNOvpDn93t/z3c3fZdUPsWdy+/k3UvfjVF7mnLOQoB/37DADz+nLjKs0UHDOXDZf6gSr15+RpUQprJ5ukJJekKpUgpkbHSdJpkdK2qzXkulw0iV3cTCWgcXza+gakjUdlPpOYdZRtKTiRS65LSya3AXX3jpC2zzb+Ps6rP59DmfPj2jPAt5aHsBdv4Z9j6qrqwD4JmjlhG2XAbN54PRPvltKROpbJ7OYJLOYKK4V4+7QurxQDQ95jU2o45Ku5r6WF7vKkbSaoRdUZR1lcMoUx5TBCl0yWkhno3zg80/4De7foPL6OLLF3yZa2ZdM7kSyOeg7XnY+RDs+j+ID4DOpHZinv9hVeLu5sm7/2kmmcnTFUrQMULWQ+LuCibwxzKjrtdrFepcZurdFi5bUEm9Wz2udppK0bXVKBUxnZD/WpJJRQjBk+1P8uX1X6Yv0ceb5r2Ju1bdhdPonJwb5nNw+NmixP8CCT/oLTD3Clh0nbqfpoN54ukcXaEkXeNE2Z3BJIPx0cI2aDXUuc3Uu80sWlRFvdtSlLaZOpeFSrtR5qlnGFLokkmjO9bNl17+Ek93Ps1c91y+cdE3WFG5YuJvlM/CoafVdMquv0AyoE4lO+9KWHw9tFw+Leb+FkLQF0mzvz/GQX9sTJQdOFLYOg31LjN1bjNX1DpLsh4Sd4VNCvtMQwpdMuFkC1l+vfPX3LflPgA+svoj3LLoFvSaCRyyn8uoEt/xEOz+C6RC6grz869SI/GWy0Fvnrj7TSD5gqAjkGB/f4z9AzH29an7g/0xoiMGwhh1QxG2hSV1zlGyrneb8VmlsCWjkUKXTCib+zfzuRc/x/7Qfi5uuJhPnfUpamwTVO6XS6tD7Hc8BHv+CqkwGB1FiV+vVqZModrwVDbPIX9cFXdR3gf6Yxz0x0cNkKm0G2mptPHGVXW0VNpoqbAxp9JGpd0oOxolJ4QUumRCGJpI64/7/ki1tZp7L7mXSxsvPfU3zmVg/z/UdMqeR9RpZo1OWHB1UeKXlH2IfTSVHSPtff0xOgIJCsV5QRQFGtwWWiptXDivQhV3pY05FTac5ik82ZhkWiGFLjklhBA8cugRvvrKVwmnw7xz0Tt534r3YdFbTu2N4354+Uew8RfqSE2TCxa+QU2nzL4YdIYJaP2Jkc0X2NsXZWtnmN09EfYPqBLviwyX++m1CrN8VhbXOrhuxXDEPbvCikk/w9c3lZQdKXTJSdMb7+ULL32BZzqfYYl3CT9a9yMWeBac2puGO+GF78HGX0IupXZstt6uplNO47S5hYLg8GCcLZ0htnSE2doZYkd3hHQxVWI1aGmptLG2xVeSdkuljUaPBZ32zBmMJBlLtiAIZnMEcjmC2TzB7PA+lFP3F3kcXFvpmvB7S6FLTpiCKPD7Pb/n25u+TUEU+GjrR7ll4S1oNacQgfr3wXPfga0Pqo+XvQXW3gUV8yakza+FEIKecIqtnSG2dKry3toZLs0xYtJrWFLr5Jazm1je4GR5vYsmr0Xmt2c4Qgji+QKBbI5gbljMgRGCHjo/8lw0P/4EYgB6RcGt19Jsnpw0oRS65ITwJ/187JmP8UrvK5xdczb/ee5/0mBvOPk37N4Mz30Ldj6sDvppfTec9wFwncJ7HoNgPMOWorS3dKgS98fUtIlOo7Cgxs4blteyvN7JsnoXcyttMuqe5uQKohQdD4l4lJizeYK5HIOZYUmHsnkyR5scHXDoNLh1Otx6HR69jhaLCbdei1unw2PQ4dZp8eh16rni3qLRTGogIIUuOW72Bvdy5z/uJJKO8LnzPscbW954cr+cQqjD8J/9pjqfitEJF9wNZ98JtooJbXMuX2BbV5hXDgdK0XdHQF1BSFFgts/KhXN9LG9wsazeycIah8x1T3ES+cKwmLP5UmojMPLcCEkHs3nCubHzzwyhU1CFq9Ph0WuZbTbicViKElZF7NGNFrNbp0N3kiWj+XwKKKDVnmI/0zhIoUuOi1AqxAee+AAI+PXVvz65XLkQsO9xVeQdL6tLsl32n7Dm3WCamJGjQggO+uM8v9/Pc/v8vHhwsJQ6qXOZWd6gpk6W1TtZWufEbpIVJuUkVxAEczn8mRyD2eH9YFaNlgfHSW+kCkePmq1ajSpgvQ6PTkez2TAs4WIk7dYNi9mj12HTnlzULISgUEiSzYbIZANksyGymQDZXIhsJkg2F1T32eCoawqFJM1NdzJnzj2n8qMbFyl0yTHJF/J84tlPMJAc4Jev++WJy7yQhx3/C899W10swtkAV38DVr59Qgb/9EdTvLB/kOf2+3l+v5+ecAqAereZ1y+rYW2Lj7NneamwyxWEJptsQRA4Qsj+EcejzmfUTsLx9KzAsJj1OhrMBpbphiU8MlIePqfFcJKzYwohyOfjqpSH5JxVZZwpCvnI89lskEJh7IRmQ+h0TvR6F3q9B4OxEpttPnq9G73ejdPVelLtPBbHFLqiKD8DXg/0CyGWjPP8xcCfgUPFU38SQnx+AtsoKTP3bb2P57uf5zPnfIalFUuP/4W5NGx5QO3sDB4C3zy4/j5YetMpVazE0znWHwrwXDEK39MXBcBl0XPeHC/vb/FxQUsFjd6J/0p7ppEpFAhk86Oj5xFyPvJc6CipDQ1qWsOr1+E1aJlvNXGeS4fPMHSuuNer504lpaHKOTZCxsVIOXdEBH2EsIXIHOUdlaKYXej1bkymWuz2xcOy1rtLx0PX6HRONJphvWazWRKJRGnLZSdnfdzjidB/AXwf+NVrXPOsEOL1E9IiyZTimc5nuG/LfVw751reNO9Nx/eidEytH3/x+xDtUVe3v+K/Yf41JzW/eDZfYGtniOf2DfL8fj+b2oPkCgKDTsNZzR6uX1nH+S0+FtU60Mqh8McknsvTl8nRn8nSl8nSn84xkMmOiKDz+LPq48hRlnzTAB79sJAX282jhOzVjxa1W69Fe5JpjVwuWoyOR0fKmRGR8pERtBDjryUKmpJ09Xo3JnMDDsfyUef0IwRtMLjR6RwoynC/Sj6fJ5lMluQcCiVGyNqv7mNx4vE4iXiCRCpJNpcd1Yqz563iqrdde8I/j2NxTKELIZ5RFKV5wu8smfJ0RDv4xLOfYIFnAZ855zPHzjPmc/DKT+Dpr0AyCM0XwPU/VFf7OcE/5p5wkr/v7OOZvX5eOjhILJ1DUWBJrZN/uWA257f4aG12yw7MIkIIAtn8sKQzOfrS2eLjHP3p4rlMlvg4ZXU6RRX0kJCXmyzjRs5D51w6LZqTFnSETGaQbDZAJjtINhMgkxks5pgD6uNsoHhNECGy476XomjR6VwYDB70ejcWy6wxUjaMiJrVyNmBMmKdWiEEqVSqJORodKScD6j7eIJ4LKbKOZkglTl6mkWPFpPQYxIGjEJPBRZMwolJGDChx1jQoRWg7x//M50qE5VDP1dRlC1AN3CPEGLHeBcpinIHcAdAY2PjBN1aMhmkcinufupuAL518bcw6Y4xR8rh5+FvH4X+HepIzks+DQ1rTuiebYNxHt3eyyPbe9ncEQKg0WPhDctruWCuj3Nne3FbT/8I0XKSLQgGhqScydKXVoU9UJRzX1o9P5DJkR2nxM6m1VBp0FNp0LHUbuZyg4NKg45Ko56q4vkqo/4UBF0oCTpTkvEg2VGPA8OPXyN61mptRTl7i2mNJRgM3qKU3WM2nc4+KsgQQoxObcQT+IvH8fjBEefjJGKqnBOpJOIopYkaFFXEQo9J6HGhp1pUYESPWegxCgN6oaDJ5yGXQeQy5PIpMoUk6XyCdCFJupAkb9KQMGtJ2w3o7WYsTiezVpYph34cbAKahBAxRVGuBh4C5o53oRDifuB+gNbW1qN3VUvKihCCL770RXYHdvODy37w2nXm0V54/DOw7XdqZ+ebf60O0T8OOQgh2NcfK0l8V08EgCV1Du65Yh6vW1JNS+XMXUEoksvTlcrQkcrQlc7SncrQm8kykC7KOpMlMM5ybwBevU6VsUHPPKuRKoOeKqOeiuK5KoOeSqMOq/bEvsGogg6rgs4EilH0ULQ84lwxwlYFPX4bdTp7McfsGU5tDAna4MGg9xYF7sFg8KDRjO60LhQKJQnH43EGB+PFx4dIJHaUpJ2Ix4nHEyRTCXL58duiAEb0pejZKvR4hQsjlSVhG4QObaGAkstBLkMunyRTSJHOJ8kUIqTySfLaPEmzloxVh85uwuS0Y7Y7MDucWOwVWBzO0mOzw4HJYkXRaBAFQSqRJRnNkoplsDim6MAiIURkxPHfFEX5oaIoPiGE/1TfW1Ie/rDvD/z5wJ95z7L3cGH9heNflM/Cy/fBU1+BfAYuuAcu+AgYXrsjUgjB9q4Ij2zv4dEdvRwciAOwusnNp69ZyJWLq2nwTP/OzLwQ9GeydKaydKUydKYydKaHj7vSmTH5ab2iqNGzQU+j2cAap5VKg54qoyrpCoOeKoOOCoMe/Qn0FahpjhDp9ACZzADpjLrPpEccZ/xkMgFyudBrCNpRlK8Xi7kJvXNlUc5eDHpvUdJDsnaPK+ih3HM8HicwWMwzJwaIx9XjeKy4JeIkU8mjfiYDupKIjcJAtbBhwq2eQ42qtQI0uRzkshRyqaKcE6QLEdL5BJlCipRJQ8aiI243YLBbsDiHhOzCYW9UxWx3YHE4Mdnt6A3qZyoJOpIlGcuURB3oy5LanyEZC5KM9pGMZUlGM6RiWUZ+EVh5RSPn3dBy3P+Gx8spC11RlGqgTwghFEU5C7W/ZPCUWyYpC9v92/nyy19mbe1a7lx+5/gXHXxaTa/496grAL3uK+Cdc9T3LBQEm9qDPLK9l0e399IVSqLVKJwz28Nt5zVzxeJqqhxTZ9rb4yGRL9CdLso5lS0Ke/hxTzo7JgXi0mmpM6myPtdlo95koM6kp95ooN5koMKgO6G0Rz6fKsp4YKysM37S6f7i8eC4eWiNxoTRUInB6MNimYXTuRpDUdj6MXs3miPmsxdCjBZ04NiCPlp6w4iulN6wCQM+4cGMvnjOgFFo0eQLKLkMhVyGXCFJOq+mNNL5gHqsy5Mxa4lZ9BgcJkwO+wgh+/A6HFjsauRsdjhL0TOov6PpuBpBJ6OZkoj724uPo72kYu1HFfSoz2LVYbYZMNv1uCot1MxxYrYbMNn0WOwGTMXzk8HxlC0+AFwM+BRF6QT+E9ADCCHuA24C7lQUJQckgbeIo/2rSaY0wVSQDz/1YSrMFXzlgq+MnZsl3AmPf1qtKXc1wVsfhHmvGze9ks0XePlggEd39PDYjj4GomkMWg3nz/Vx1+VzuXxhFZ4pnA8XQjCQybE/keZgMs3+RIr2pCrtrpRaATISDVBj1FNvMtDqtFJv1FNnMlBnMlBflLZNd+z0hxB5MtkgmfTAUWTtL57rJ5+PjfMOGjXvbKjAaPBhs87DYKzAaKjAUNyMRnWv1VrH5KCHOgjj8TjB4DiCHpJ0PE4ymaQgxq+CMYwQtEUY8AgX5mJ6wywMGIQOXaEAuSwilyabT5LKJ0jn46TzA6QKCWL6AgmrDq3NiNFhxeJ0qakNpxuHvemo0TOogk7F1Og5Fc2WRBzszZCMxUlGg6q8Y2pkfdyCrhoWtNmux2xTBW0pCttk06M9xjQRQgjIHa0K59RQyuXe1tZWsWHDhrLcWzKWfCHPnf+4kw19G/j1Vb9msW/x8JO5NLz4A3jm6yAK6gLLa+8ad1BQIJ7hFy8c5oH17QxE05j1Wi6eX8HrllRz6YLKKTcyM5EvcKgo7AOJNAcTafYn0hxIpEZNsmTSKDSY1Ei6wWSgzqiKekjaNQb9MeumhciTTveTTveQSvWQSveQHrXvJZsdHDfloXYY+lQxF4VsPELQBkNFMZLWjbinIJPJEIvFxmzRaFQ9jkSJxeMkkgkKhfEFrUeLuVi5YS5GzUMRtFkYMKJDlwcln0VkhwQdL0bQ8WL+OQdmLTq7AYPDgsVVFLTDicXpwmJ3YHa6imkPJzr98O+KKAjSiRyJaIZkJEOiGCUnokPCzoyKrlPxLOOOWEIV9JCAzXYD5qF9UdBmu74UUR+PoAFELkc+GCQ3OEhucJD84CC5wQD5QT+5wQC5QT/5wUDpOc+/vJvKu+465vuOh6IoG4UQ4/aqypGiEgB+sPkHvNjzIp8997OjZb7/H/DIx2Fwv1pH/rovgbt5zOsjqSw/efYQP332IIlsnovnVXDzmgYumleJ2VDe0sKCEHSlsxxIpIqyHhJ3iq706FREnVHPHIuRm6o9zLEYabEYmWMxUWfUv2Y6RIgC6cwg6VT3KFGnUj0lgWcy/WNkrdVaMRprMJlq8NrmYzRWjpC1ryTsI+f9yOVyxONxYrEYfv+QpHcOCzsaJRqJEU/EyI4TDSoomDFgLhiwCAO1wo4JbymCNmFAVxBo8jkKmRS5Qroo5gTpfJBUPkFcSZOw6NDa9KXqDbPThcXhxOGoprp4PCRtvWl0Wi2XzZcknIhkSEbVHHQiGiQZ6VPPR7MkI6qkxVGG/Jusesx2Vb7uGiu1JUkfKWwDJqsOzXFOtFZIJsn1dJMpSvq1RJ0PhRg3xNfr0Xm96DwetD4vxrlz0fm8WFqnbpWLZJrzVMdT/Hjbj3ljyxu5cd6N6slQOzz6SXW9Ts9suOUPMHfdmNcmM3l+9eJh/uvpA4QSWa5aUs3d6+Yxt+r0V6cIIejL5NgaTbAtmmRXPMnBRJpDyTTJETKwazXMsZg4x2VjjsVYFLeJWWYjlqP8sedyUeLJzteMro8caajRGFRZG2twu8/BZKzBaFIfm0y1GI01o0rvhnLSo6LnWCex2O5hUUeixGJxkunxOwzVkjoDloIBL0bqhQNLMYo2FyWt5LLkMwnS+QSpfJxUfpBUPk5CJEmaNIRtBnR2ExaXmm+2OFxYnRVUOIZSHk4sDhcGs3l0yqYgSCdzJTkno1kGOjMkIsMpjuHnMmRSR+l8NWiwOFQB2z0mKpvsWIpCNjv0w8cnKGhRKJAPh8kGAuT8g+QDg+T8g+QCg+T9g+QCAfJ+P7mAGkmLRGLc99HYbOi8XrReL8ZZs9G2tqLz+tB6Pei8PnReD1qPF53Pi8ZuP63TLMuUyxlOe6Sdt/zlLdTb6/nVVb/ChKIuMPHMN9QLLrxHnc72iGXeMrkCv93Qwfee2Ed/NM1F8yq454r5LK2fmEm2joUQgs50tiTvrdEE22JJBjJqNKoAzWYDLRYTs4cibbOJFouRCoNu3D+ybDZCMnmYROIwyWQbieRhkok2Esk2stnAqGsVRYvRUFUS9ChRF4/1ek/pPoVCgVgsRiQSGbuFw4RDYaLx2LgpDy0aLBgxF1QxDwnaglHNRxc0aAp5CulEKdUxtCXzcYShgGLTo3dasLpdWF0urC4PVpcbi8uNtbiZbfZSJ+EQ+WxBTXOUouhiRB0dlvbQc6lolsJ4UbTCqCjZMhQ5OwxFOetHHBvQG4//G53IZlUB+/3kjxD1sLCLog4Gx89dazRoPR41kh6ScVHY6n6EqL1eNMbyzgn0WikXKfQzmGQuydv/9nZ647389vW/pb5vDzzyMTW9svANcOWXx8xLni8IHnq1i+88sZeOQJI1zW7uuWI+Z8/2Tlo7C0LQlsywpSjtbUWJB4vzhmgVmG8xsdRuYandzDKbmcU2M9ZxOiGz2fAIUQ8LO5k8TDYbHHWt0ViNxdyM2dKExdyEydxQkrfRUFEaDl4oFIhGo+PKOhwOEwlHiMViYzoQtWiwYsSaN2LFhEUYi1ux7K6Qh0yGbL4YTediJUlnlTSKVYfOYcTsdpakPCxpl3rsdI/KRQPkcwUSkQyJcIZEJE08rAq5FD1HhoSdJZMcv/NOp9eoEnYYhvPP9qKUHSOOi7lozYmUWQ5JesCvpjb8Q+kOP7kBfzH94SfvH1RTHeOgmEyvKWWdd1jaWpdrzH9kUxmZQ5eMQQjBF178AvuC+/jBuZ+j/pFPqQsxe2bDLX+EuZePuf6xHb188/G97OuPsbjWwS9uW8JF8yom9CtlXgj2J9IlaW+NJdgeTZY6KA2KwgKbiWsqXCy1m1lqN7PQasY84mt3NhsiEd9Gb7JtVLSdSLSRy4VG3E3BZKzBbGmiouJKLJZmLOYmzOZmzOZGtFoTQggSiQTBYJCB/lBR1JtVWYeKsk7ExpTj6dBgESZsBSNVWJglPFiFEZswYSgoKNkMuWyMZC5GMh8lkeslmY+TMCtoHAaMTmtR0C6sLi8uV8soaRvMljEVKulEjkQ4QzySJjKYofdQikT4cEnW8aLA0/HxJW2y6YuC1lPZaB+OqB3Dwh56fCJRNIDIZIqR9CA5/4Cai/YPiznnV0Wd9/vJh8PjvofGYkFb4UPn9ampjjVrVEn7fOh83lKaQ+f1oljOzBWlZIR+hvLb3b/liy9/kX/zncWdmx8BkVcHB533AdAPd14JIXh2n59vPL6HrZ1h5lRY+cgV83nd4uoTirqOhhCCPYkUzwZiPBOM8mIoRqwob7NGYZHNzFK7hWU2M8vsZuZZTaUpUoXIk0i0EYvtIhrbRSy2i1h0F+lM34g7KJhMtZjNTVgszeq+GHWbTY1otUby+TzhcJhgMEggECAYDBIMBAn4BwmGQ2Syo3PjOrRYhRFrwYhVmNQoW6jHhgIomTTZbJxUPkYiFyWRj5IqxFFsOnQuM1avC5vXh93jw+71YvP4sHt9WF1uNEeM7BxKecTD6WJEnSERTo8QtCrpRCRDITf2b1mr12B1qhK2OI1YHIbiY2PxnHpsdhxfNceof7tMRo2Wh8Q8OFiKoEdG1jm/n8LRJG21ovV5i9GzF12FrxhBq5LW+XxofepzGvOpT7V8OhFCEEqHGEgO4E/46U/240/66U/0c3bN2VzWeNlJva+M0CWj2Dqwla+s/woXCBPveeUPMOcyeP23wd006roNhwN8/bE9vHwoQJ3LzDfetJzrV9Se8nJsXakMzwSjPBeM8WwwSn8x7z3bbOSGKjetTivL7GZazKZSKWAup1Zx9HfvLsp7N7HYHgqFodWHdFgtc3C7z8Vmm4/FOqcYbTeg0RhJpVKqqINBOtoDBIO7CQy+QHAwQDgWGRVha9FgEyYcBTMtohKHMGMXZox51BRILkYqFyORj5DMdREjQdyuQ++yYPW6sXt92DyVeL0LVWn71CHhI7/W5/MFEuEMsWCaeChNf3uCeCg4Kv2RCKdJJ8aPps12vSplpwF3tWUcSasCN5i0JxSpDkvar+alS8IuRtb+4YqPY0raV4FxzhysZ5+lStpXUYqgp6ukQV1TN5gKluTsT/oZSA4MHycGVIkn/WQLYwd02fV2fGbfSQv9tZAR+hlGIDHAm//3DehSEX47EMd55ZdgxdtGDQ7a3Rvhq4/s5p97BvDZjHzwshZuXtOA8TgGxoxHKJvj+VCMZwKqxA8k1dnqfHodF3rsnO+2cYHbToPJoKYO0j1EozuLkfduYrGdJJPtpffT6ZzYbAuw2xZisy/EbluI1dpCLqfQ39/PwMBAKdIO+AMEgwGS6dSoNpnQYy+YS7J2CDPmgh4lnaKQjRHPhonlQiTyURSnFr3bgs3rGY6sfb5SZG22O0ZJM5fJEwuliQfT6j6UJhZMEwum1OOQGlEfWSet02tKEbPFacA6IoIuSfoko+lCPE5uYOC1t/6Bo6c7hio7iiJWI+cRkbTXi7YobI1peo36HSJfyBNMB0tCPtp+MDlIbpwJxhwGB5WWSnxmX2lfYa6gwlKh7s0V+Cw+zLpT+09MdopKAMhn07zngQt5NR/n14bZLHrDfeCoLT0fTmb59t/38uuX2rAZdbz3ojm867wmLIYT+yKXyhd4JRznmWCUZ4MxtkYTFACLVsN5LhsXuG1c6LazwGpCiDyx2C5CofUEQ+sJhzeO6pw0m5uw2RaOkrdOV0kgEKC/v5/+/n76evvo7+0jGAmVXqeglKLsIWHbhAljXiBSSTK5KLFskFguTNaQQec2Yq304qyuxlVVg7OyGldVNTavF82IEbOZZE6VcyhViq5L8i6eHy9HbbTosLqM2FxGrO7i3mXE5jZhc6vHRsv41TdHQwhBPhQaV855v59c//DjwngleHq9mn+uqChuxWNf8djrRVsU9nSVNAxH1ENR9EhB9yeLjxMDDKYGyY8zqMttdOOz+EpSrrBUlKQ98rFRe3qqX2TKRQLA9x++hZdFgs/XXsaiK75TisoLBcGfXu3iK4/sYjCe4e1nN/GRK+bhshz/0PxgNsfj/gh/84d4OhAlVRDoFFjtsHJ3czUXuG2sdFjQkSMS2UrI/wpb9q8nFN5UGsJuNjfi816Kw7Ecm30BVss84vE8/f39dHX109fXR1/3/zIYHCRfLO9TUHAWzLiFjdmF2bgKFgzZPIV0jEQuTCzrJ1GIELZrSVbYcFRV4Kysprp6TknaRosVKNaBR7NE/Ekig0n2bkgQ9Q8SGUyVouxseuwfvNmux+Y2YfeaqJnjVIU9QtpWlxGD6fj/1EQupw5aGRgg5z96RJ0f8COyY7/SKxZLSc7GRQuxVlw4QtrDm9blmtYdh0M56v5E/7CgRxwPCfxoEbXb6FajZ0sFc91zqTBXlCTts/ioNKtRtv4UVtcaoi+SYnNHiM0dIbZ0hLh6aQ1vP6fp2C88QaTQzxCefOFr/CS2hxuNtbzxyntL53d0h/mPP+9gY1uQlY0ufnHbWSypO75a8r50lkf8Yf42EOL5UIy8UEda3lLj5WKPnXNdNsxKhnD4VUKBV9h+cD3hyKuldRit1rlUV1+Ly3UWDvsqwmENHR0dHDjQR1/3Jgb8j5Ee0SFpFUY8BRuLRQPughVTTiCSMWJZP+HMIWK2ArkaB56GBtzVddRWrcZVVY3dW1HqbMwkc0QGk0T8KXoOJNmzvksVuD9FdDBJLjO6tNDsMODwmvDUWmlc5C1G1SOibKcRrf740x+FeJxsXx+53l6yff3k+nrJ9vaS6+0j29+npj0CARivHt3pRFepytjY3Dy+pH0VaG3W427PVEQIQTgdVjsRi52JQ7L2J4cfDyQHyBXGitppdJbkPNs5u5TyqLRUUmGpmFBRj0c8nWNrZ5gtnSE2t6sS742oKT+dRmFhjQO9dnL+I5UplzOAtrZnecuTd9KEnl++7WmMRgfhZJZvPb6HX7/Uhtti4ONXLeCmVfXHrFxpS6b520CYvw2E2RCJI4A5ZiPXVDi5usLFEguEwusJhV4hFFpPJLKtONOfgt22CJdrDS73WZiMS+jrS9DR0UH7oTa6urvJ5tVo0yB0eIQNT8GGW1ix5LQoqQTJzCDhjJ+MKY2hxoGnsQ5vfRO+hia89Q0YzBYK+QIRf6oYZaeIDCRLAo8MJsekQwwmLXafGYfXhMNnxuEz4fCasRf3x1ueJ4SgEA6PlXSfus/195Ht7aMQjY55rdbtRlddjb6ysiTsUZvPh7aiAo1h6k5mdjwIIYhkIsMpj3FSIEPnxutMdBgcpRTHyHTHSFmfztQHQC5fYG9frCTvLZ0h9vZFGRpf1eixsKLBxfIGFysaXCyudZzyKlsyh34Gk0j4ueW3lzFAnt9d+Quqq1fzh42dfPXR3QQTGd5xThN3r5uP0zJ+tDJUVjgk8e0xtapkqc3M1UWJN2kjDAb+id//BIHAcxQKaRRFh92+FLfrLJyuNRTyzXR3h2hva6fjcDv+kDrDsoKCt2CjsuCkomDHmMyQSg8SyfhJ6ZIYqq04G2vxNTTibWjCV9+EyWYjl8kT6k8Q6IkT7EkQ7I0T7E0Q6ktQyA//Tmt0Cg6vKuzxxG20HjtvLQoF8oEA2d6+YVmXxD0UbfchUqM7XlEUNUddXY2+ugpd1fBeV1WJvroaXWXltM5Pg/o7EsvGRuekj5ICSefHLt9m19tLKY6hFEiluXL0OXPFsVfNmmSEEPSEh1MnmztCbOsMkywuQuKy6Fler8p7ZVHikzGjqBT6GYooFPjEA5fySNbPfUv+DUfNLXzmz9t5tT1Ea5Obz123mMW146dXOlIZ/rt7kL8OhNifSKMAa5xWrvY5ucrnwFM4jN//BH7/E0QiWwAwmerw+S7F5byQWKyari4/HYfa6OjqLK3DaBQ6KgtOqgouHDkdxMOEM33k3QLb7Ao8jY34GprwNTRicbpIJ3MEe+KqsHsSBHrjBHviRAZTpSoRRQGHz4y7xoqnxoKryoqzQpW21WlEOdYsiIUCOb+fbGcX2a6hrZNsVxeZzi6yPT1wZK5ap1Mj6upxJF1Vpe59PhT91Jpd8kRJZBMlKfcl+sakQIbK85K5sXPLWPXWsVF0cT+yEsSin5oLmkRTWbZ2hkcJfCCq/h4btBoW1jpYWYy8lze4aPaensFMUuhnKP/z6Pv4ct8zvMexjF7lE/zm5Xa8VgOfvGohN6yqG/eXry2Z5quHenmoL4iiwPkuO1dXOLnCY8aY3MyA/x/4/U+QSnUB4HAsx+e9DI1mBe3tBfbt2ktnTyeF4u+Vq2Claij6TmVIJQeIKiEMDVYqFsyhZu4CqlvmUsjrGOyMqRF3bzHi7okTDw/n0DU6BXeVBXe1FXe1pShwK85KM7rX+BorhFAj7M6ipLu6huXd2Um2uxuRGT14SOvzoa+rxVBXj76utijuajXKrqpE6/VOq+HiR5Iv5AmkAvQn+ulL9NGf6C8dD8m6P9FPNDs2RWTWmYdTHkdJgVRYKrDqp08uP5svsKc3Oqrjcv9ArDSB4iyfVRV3vZMVjW4W1tiPv4w3FYZgG4Taivt2mHWBOr3GSSCFfgayedtvuG3jl1mdt7Kx8z8JpwTvPLeZD6+bh9M8Nmr0Z3J8p62XX3YNolPgtroKbq2xYow9S//AYwwOPkM+H0OjMeHxrMXtuohYbDYH9g2wb88+Ign1D99bsFFf8OLKGtAkokRSveTdAvvcKqrnzad23gKs7ir8nTH6D0fob4vSfzhCeGA4wtMbtaOE7a5WJe7wmY46s14hkSBz+DCZ9o5ShD1S3EemQ7RuN/q6OnWrV/eG+nr1cW3ttBzwMkQ8Gx8l6SO3vkQfg8mxJXpaRYvP7KPKUlWSdKWlkipL1agORaveOu2rYzqDyZK4N3eE2N4dJpVVO6I9VkNR3i5WNKoSf82Kr2xSlXRJ2ofV/dC5VGj09QY7nH8XXPjRk2q/FPoZht+/mzc/fBO6AvQc/CgLGufy+euWsLDGMebaeD7P/R0D/KC9n0S+wFtrPPyru5PswIP4/U9SKCQxGHz4vJdiNJ5NX5+bfTsP0dbVQb6QRy+01BY81OWcGBJxwqluNI1GKhbOoXbeAiqa5xALCPoOR+hvi9B/OEqgezjysbmNVDY5qGy2U9Fgx1NrxeoyjisMIQS5/n4yhw6RPniQzMFD6vGhg+S6e0Zdq3E6ixF2Hfq6+tHyrq2blpUguUKuNBLxyMi6P9FPf1Ldx7PxMa+1G+xUmitLkh4p6qHNY/KMXaVqBhBOZtk6ouJkS2cIf0z9RmbQaVhS62BFg5sVjS5W1Lto8IyeFph8Vl2tqxRhH7GP94++odYIrkZ15LWraeze7D6uRdSPhhT6GUQ2m+TWX65ljzZDQ/8tvPOKd3D9irHplWxB8EDPIN843Et/JsfrfA7udHeg6f0ekcir6PUeKnxXUhCraT9kYN+ufQRiIQCcBQsNBR+etI5stJeULYFzaQPNy1di9c4i0JWirxh5+zti5IuLIRutOqqaHFQ2F7cmO1bn2IqEQjpNpq2tKOyDpIvizhw8OGqAjMZiwTB7NoZZszDOnoVh1mwMTY3o6+rQOsb+5zWVSeVS9CX66Iv30ZvopS/eN0bYg6nBMTM26jS6Ul76yGi6dGyumLJ56okmkyuwuzeipk7aQ2zuDJUWIgeYU2FV5d3gZEWDm/nVdgwaINozOqoeKe1Il7pS1xCKFpz1RUE3gqt5tLStlTCJ6Tgp9DOIe356FY/pOnld+hw+/Y4fjkmvCCH4mz/Mlw70cCCZZo3Dwgd8nbj6v0M0ugOTqQ6r5UYO7athz94DpLJptEJDTcFNbd6JKZ4gnu1DP8tG3eqlVDQvIdgL7TsDdO4Kqkt/ATqjlspGO5VN9qK8HTh8piMWRCiQbW8ntWsXqZ07Se3dS+bgIbKdnaNWf9HV1mCcpYrbMHsWxqLEdZWV0+KrfyafoS/RR2+8l954b+l4pLyD6eCY1zmNzrGiNleMiqzdJjcaZfrm8k8FIQTtgcSoTssd3REyxQDCZzOyosHFinoHrZWCJdYQtkTnWGmHOyA/ug8Fe83oqHpkxO2oA235hvBIoZ8h3P/Qv/O98MNclPHxvX95cozsXgrF+MKBbjZGEsy1GHmft5Mm/7dIJPZiMjWicDWbXtLhj4QxCB2NBR/VGQsi4idpi+Fe3kjTilYKopLOPWE6dgYIdKvRj8VpoHGhh9p5LiqbHLhrrKNq2kUuR/rAQVXcu3aS2rmT9K7dFOLF6EmvxzhnznCkPXsWxlmzMDQ3o7FM3egym8/Sn+wfI+uRx4FUYMzrnEYnVZYqqq3VVFuqqbZWU2WtKh1XWirLXqY31QjGM2q994iOy2BCDSC8+hSXVCY52x1lsTlEg2YAW7ILZUjeR6ahzJ6jp0ScDaNmHJ1qSKGfAbyw5RE+vOkearNafnXLM9itrtJzu+NJ/t+BHv4+GKHaoOMOTw/LQt8gndyPyTSLZOxiNq5XSOayeAo25mYqINxNoUZDTesiPPWLCfbp6NgVoHtfiHy2gFanoabFSeMiL42LPXhqhzvKCuk06b17Se3YWYq+03v3ItJqyZdiNmOaPx/TokWYFi/CtHAhxpYWlCk2cEYIQSAVoDvWTVe8i95YL72J3lHR9WByEHHELFt2vV2Vs7Uoasvo4ypL1RmTAjlZ0rk8O7sjJXHvbO8jH2ynQRmgQRlgmTXEfFOAOvpxpnvQpUOj38BgH5ESOVLajWA8/UskThRyLpcZzkCwmy+u/yh6LXzukvtLMu9LZ/nywR5+1xvAqtXwft8AayNfp9BzAIxziA6+led3aCmIHE0FH7UJA1llgKpLPTiqLqV9R4ytTw8SDx8GwF1tYckFdTQs9lA714W+uPhztq+PyP89SXz9elJbt5E+cADyagWFxuHAtGgR7re9TRX4ooUYmptRtOXvfBNCMJgapCvWRU+sh65YV0ne3bFuemI9pPKjq2OseivVFjWanueZNxxdF6VdZa2aVuV6UwEhBIf6Quzdt5vetr1Ee/ejDbdTSz/LlAHeoBnARwhGdrfkjaAfSoOcd0QnZPMpdzxOV6TQpzmFfJ5P/P5Gugzwydp3s2zuOeQKgp91DfC1Q71kCoK3uPysi38dw8B+NLo5dB++nn3tNvRCx/xcFc5oAl0TeM9fRnDAyatP+EnF92EwaWkoRuANCz3YPerX0Gx/P4nHHyXx8svE179Mtk2d2lbjdGJevgzbpZcU5b0Ifd349e6n5WcjCgwmB0ui7o53q/tYtyrxeM+YkYsuo4taWy0trhYurLuQWlttaaux1mA3TN/IrqwUChDrhWAb0b4DDLTvJdF/EE24HWe6m0YxyGxluOOxoNWSslSj9TZj9J09ouOxGHHbqia143G6IoU+zfnS/9zGemOMN7KIt1xxN6+E43x8Twc74ynOtcR5a+areIM7UJjD/l1X0T3gxV6wsDLjwZAOYVpkoWBYTfuOJHv2JdAZ08xa5mNuayWNi7xo9Rpyg4MkXv4nPevXk3h5PZmDBwF1jmzLmjW43/pWrGedhXHBgtM+2CaTz9AZ66Qj0kFbpI32aDsd0Y6SuDOF0Z1dHpOHWmstc91zubjhYmpttdTZ6qi1qtKWqZCTRAhIBCB0eLjDMdROPnCYrP8QulgXuuK/hb249Qo3g7pq+l0rCPlm4amfS2XDfLSeZjSOOixl7Hicrsif2DTmf/95H3/Mb2Jl2sy/veNXfHh3Ow/0BKjWwydMv2NJ/LdoaGHn1ivxhyqoybtZnTCgt2bI1VXR17WQ+MYMWl2UpqVe5rZW0bTUi4488VdeYeBrT5N46UXS+/YDapmguXU1rhtvwHLW2ZgWLTwtqZNMPkNntJP2aDttkTY6oh2lfU+8Z1Qpn91gp9HeyHzPfC5pvKQk6jpbHTXWGinsUyEdHb8OO9SuHmdioy4PKw7a8j7aRSWdYjFRUy2mitlUNM5jdstCFjdWUm2UCppI5E9zmrK3bTP3HvwelULhvPN/zMUb9xHL57nZupsrYl/EojFyeP+ltHXXUpv30BoXCI+FkGgm0q9D41doWGzn3DdWMWuZD202QeyZZ+n/zZPEnnmGQiyGYjJhWb0axxuuxXrWGkyLF0/a3CTZfLYk6vZoO+2R9tK+J94zquPRYXDQ5GhiecVyrp1zLQ32BpocTTTaG3GZXJPSvjOCbEot4Qu2jY60h/bJ0aWVBb2VuKWeXk0lBwzz2JxxciDjoUNUEjDU0FJXXZrn5IYGF5WOqVs5MlOQQp+GJFJxPv3YrcT0CtXO9/PZflhljvC2wpepie0l4l/Fpj2zsWVdrIpbSOoNHE40oyR0VM1ysOLyalpaK9FF/ESffILeHz1BfP0rkMuh9XiwX3kF9ssuw3ruuRM+BL4gCnRFu9gb2sv+4H72h9TtcPjwqEUInEYnjfZGVlat5Dr7dTQ6Gmm0N9LkaMJpPL752iVHkM9BpHN0VD1S2rHe0ddrjeBqAFcTueqVdGsq2ZP2sCns5Ol+MzvDOogqaDUKC6rtLF/uYl1xpsHZFTa0E7CIuOTEkEKfhvz7f9/ALmOeBelz2F5xNh/W/p7ViQcpZOawaevVZOM+FqW8KCJLR2wWRqudNVfXM++sKszhTqKPP0TPd58kvXMXAIZZs/De+i5sl16GefmyCUmjCCEYSA6wL7iP/aH9pf3B8MFRM/PV2eqY657LJQ2XMNs1myZ7E42ORintk0EIiA+oc4kED4+NtMNdMHL+FkULzjq1k3Hu5cUBNE3knY0cyvvYNGjg1U61dHDvrij54iTfdS4zK5rUqHt5g4sltU7MhvJXLUmk0Kcd3/jDx/iHvpvlcQ+2Vev4UuKdWLNG9u26mL7+elqyVdgzaboSFaB4WX5ZPcuW6Uj/428E7vub2qGpKJhXrqTyo/dgu+RSjLNnnVKbcoUc+4L72Obfxt7g3pK8I5lI6Rqf2UeLq4Ub597IXPdc5rrmMsc1R+a0T5RMfPQkUEPiHpoQKnvE2qG2arU6pOEcWHbEqEdHPWh19EVSvDo0z8meEFs7Q8Qz6mAou0nHigYXly+cU5rru8J++haQkJwYUujTiD+vf4jfR//KnIyWC+c6mZP4D/q7lrL50HyqshWsikNf1kYou4A5qypYtdpI9rc/puuzfwUhsLS24nnnO7CvW4fO6z2pNggh6I53s21gG9v86rZrcFepXtumt9HiauHK5itpcbUw162K22PyTOSPYuZSyEOke1jQR0r7yImgDDa17to7B1ouU4+HarFdDaAfnTIrLY+2NcTm9i1jlkdbVOvghlX16pD5RhezvNZjrmIlmTocU+iKovwMeD3QL4RYMs7zCnAvcDWQAG4VQmya6Iae6Rwe6OC/tnwagxYuqfBRm0iwYfc16ONVLE9YieR0tCXnUD3bzVnnWdA+/AsGv/NXFKMRz6234nnXO9FXVZ3wfcPpMDv8O9jq38p2/3a2+beVhrIbNAYWehdy07ybWOpbylLfUurt9dNifpWykgwNi/pIaYfaYeTyayMngpr/uhHCnqUeWzxHHUCTyxfY2x15zeXRzprlKXVcTsTyaJLycjwR+i+A7wO/OsrzVwFzi9vZwH8V95IJIpfN8uk/3ECPGd4gZqPpqmSLv4n5KR+FbI6O2GyclS4uu8KB/clfEX2PKnLv7bfhue22E4rGe2I9PN/9PBv7NrLdv53DkcOl52Y7Z3N+3fks8y1jScUS5rnmTdpCu9OaXKZYLXJ4fHGnwqOvH5pXpGYZLLp2dJTtrIfj+Bkf7/JoVyyuntTl0STl5ZhCF0I8oyhK82tcch3wK6FOCvOSoiguRVFqhBA9r/EayQlw989vZIslxdpYDabBpbjTdTQkM3TEqjDbKjjnMgeVrzxA/J6/EDOZVJHffjs6z7HTHOl8mo29G3mu+zle6HqBA+EDgJrzXupbynUt17HEt4TF3sVylORIkkEIHITAIQgeGp0WOXK6Va2hmLduhvo1o4XtbgLTiXcAH8/yaDevaTjty6NJystE5NDrgI4RjzuL58YIXVGUO4A7ABobGyfg1jOfr/3xUzxjOMjShJGFvetojunoSViJ6hex/Gw7Dbv/ROpzfyYxFJEfQ+RCCA5HDvN81/M81/0cG3s3ksqnMGgMtFa38sa5b+T8uvOZ7Zx9ZgugUFDnyA4eGpb2yP2Rq9DYqlRBN51XFHXzsLTtNac0TD1fEOztU5dHe7U9yOaOEPv6Ry+Pdn6LryTvE1oeTTKjOK2dokKI+4H7QZ1t8XTeezry9w1/4a+hP1NVULi4+wbMISMdmQU0z3Uyv+9Rct/8PWmjEc9tt+K9/fajplayhSzre9bzRPsTPN/1PN3xbgCaHc3cNO8mzqs9j9bqVsy66bvs2kmRyxTnxh5H2sHDkBsxMZeiVTsZ3bNgyY3gmaUee4q5bMPETcjVH0mxqX0o8g6ytTNMIjOcOlnR4OLqpTVqx2WD67WXR5OcUUyE0LuAhhGP64vnJKfAgL+X/9r4KRIGhXUDl5DuXYDRW8Va905MP/8ueb0ez6234n33+CLP5rO82PMif2/7O0+2P0kkE8Gis3BOzTm8e+m7WVu3ljpbXRk+2WkmkyimRg6MlXa4c3RqRG9RJe1tgZbLR0vb2XBcuewTJZnJs707zOb2EK92BNncHqI7PLrq5E2r69Xl0RrcMnUieU0mQugPA+9XFOVB1M7QsMyfnzqf+O2b2GcTXBJegLvtehbNy1H9l89Cfzeum26i4q4PovP5Rr0mk8/wQvcL/L3t7/yz/Z9Es1HsejuXNF7CuqZ1nFt7LkbtDKwhzmXUTsfB/TB4oLjfr4o8ckRsYfGqkm44G5a9ZbS0bVWTOuVqoSA4NBgflndHiN09UXLFspN6t5lVTW5ub3CxstEtq04kJ8zxlC0+AFwM+BRF6QT+E9ADCCHuA/6GWrK4H7Vs8bbJauyZwt0/vJn1thBrYk4uCH2IBck/oPvpY5gWL6b6u9/EvHx56dp0Ps3zXc/zeNvjPN3xNLFsDLvBzqWNl3JF8xWcU3MOBu0M+EpeyKsR9ZC0AweGj0Pto0dAmj1qXfasC8EzRz32zFalfRIdkCdLMJ5R895DHZftQSIpdXoDm1HHsnon77lodnGNSzlgR3LqHE+Vy1uP8bwA3jdhLTrD+f5vvshz5u3MTWl5c+/NNP7vv6G1Wqj87H/ietObSsPyBxID/Hrnr/nD3j8QzUZxGp1c0XwF65rWcXb12dO3nDARgIHd4N83Wt6Bg6PXfTTYVEnXroSlN6lpEm+Les5y+gcxZXIFdvVEShUnr7YHOTyojtrUKDCvys41y4by3m5aKuVcJ5KJR44UnUK8uu1F/i/xICYNvG7HCpoe/yHOG2+g8iMfKVWuRDNRfr795/x656/JFDKsa1rHDS03sKZmDXrNNJG4EGoFycBuGNgL/j0wUNwS/uHrtEZV0N4WmHdlMdpuUSPuSU6PvHbzBZ3BZFHcasfl9hGLE1fa1cWJ37ymgZUNbpbVO7HKaWIlpwH5WzZFyKTTfP2599Nnhqt6V3B5e5Tq//kfLKtWAmpq5cHdD/LjbT8mnA5z1ayreP+K99PomMLln4W8mtsekrV/77DEM9Hh60wuqFgAC64G33z12DdXHVSjKX8OeWTN95DA/TH124JRp2FpnZN3ndvEigY3Kxtd1DhNsuNSUhak0KcId/34WrbZM6yN1HFPxaV4/vAuFJ2OfCHPXw7+hR9s/gE98R7Oqz2Pu1bdxSLvonI3eRgh1PlH+rZD7zbo31kU+D4YucSbrRoq5sOKt4JvniruivlgrZgy6z+OrPke6rwcWfM9u8LKhfMqWFnsuJxfbUevlUuhSaYGUuhTgM/84F95wdbFsoSJr1x2L65FCxBC8EznM3x747fZH9rPIu8iPr/285xTc055G5tNqVF233bo26EKvG/76MUPXI2qrOdcUoy456sCN7vK1uyj0R9J8eqIyHtbZ5j4ETXf1yytVcsG6104LdMkrSU5I5FCLzN/eOh+nja9QE1W4c6lX8W1aAHbBrbxjQ3fYFP/JhrtjXz9oq9zRdMVaJTTHAnG+qF3K/RuL0bf29W0yVBFic4MVYtg4bVQvRSqlqiPT2MlyYmQyubZ1qXWfA91XA7VfOu1CotqHNxUrPle2eCmSdZ8S6YZUuhlpLvzAL/p+z4pA1xfuJ7Frav47Auf5Y/7/ojX5OUz53yGN8594+np7MwmoWcLdL4CnRuga6M6wdQQjnqoWqzmuauWqAL3zJ4SOe7xON6a73c3qiWDsuZbMhOQQi8jn/7zu9hvE1wWWUzDlct5w0NvIJ6Jc+viW3nv8vdi1U/ccPJRFApqKWDnBujaoEq8bwcUikvAORuhvhXOfi/ULFdFXoZSwBMhnMiyqSM4vFBDR4hwUp2GVtZ8S84UpNDLxF3fu4lXHGHWxFz0NWn5/Iufp7WqlX8/+99pcbdM7M3yOTX6PvwsHH4OOtcPT+FqsEPdSjjvg+pMgHWrwX7i86afTvIFwf7+GJvag2xqC7KpPciBgTgwXPN99VJ1geKVjW7myPUtJWcIUuhl4Ds/+RQv2HYzL6VlHzl0qV6+csFXuHrW1ROTsz1S4O0vDZcJ+ubDouvVCLx+jdpZOUXTJkOUou+2IJva1eg7mla/TbgtelY1urlhVT0rG10sr3fJmm/JGYv8zT/NvPzyP/gbf8ZSAFd0AWsuXMn7Vrzv1OYaL+She/MIgb8ImZj6nG8+LHszNJ8PTWunfPRdKAj2vUb0Pb/awbUralnV6GZVk5ysSiIZiRT6aSQej3Lvpo/Rb1a4NLiSd73rHpZXLD/2C8cjl4HDz8DOh2H3X4dHWPrmw7Kbp43AR0bfrxZrv4+Mvt+4so5VjW6WNbiwyehbIjkq8q/jNPKRn9/INnuW86MNfOWDPz3xSbOySTjwpCrxvY+oeXCDDeZeAQuugeYLprTAhRAcHkyw4XCAjW1BNrQF2d+vfpOQ0bdEcupIoZ8mPvG9W3nR3s3yhJlvvOv3xy/zXAb2/wO2/Q72Pg7ZuDpUfv416vqTsy8BvWlS236ypHN5tndF2NgWYMNhNX0yNGTeYdKxqsnN9UWBy+hbIjl15F/QaeAXD36L562vUJtVeM/yL2G12177BUJA1ybY8gBs/yMkA+o83sveDAvfoE4LOwVnUwzGM6XIe2NbgC2d4dKEVU1eCxfOq6C1yUNrs5uWChsaWXkikUwoUuiTzMEDO3ko8gsyeri08AYuOG/d0S8OtsHW38HWB9WpY7VGdSDPsrdAy2VTSuJCCA7642w8HGRDW4ANbUEOFjsv9VqFxbVO3nlOE63Navqk0j41v0VIJDMJKfRJ5guP/isHbILLwov56Ae/PPaCbAp2/R9s+qVapQJqZ+bau2DRdVNmGH2hINjdG2X9oUHWHw6w/lCglD5xmvWsbnJz46p6WpvcLG9wyVGXEkkZkEKfRD74vTeywRHhrJibb3/gt6OfTEXguW/Dxp+rE1u5m+GST6tpFXdTWdo7kly+wI7uCC8fGmT9IVXgQ6vt1LnMXDi3gjWzPLQ2qQN3ZPpEIik/UuiTxFfu+zAv2PYxP6Xlc9f+arhao5CHzb+BJz4Pcb+aE2+9HWZdBJryTcOazuXZ2hnm5YODvHwowKa2YGnWwdk+K1cvreGsWR7OmuWh3m0pWzslEsnRkUKfBJ7450M8qfs7toLgBved1Dc0q0+0vQiPflwdxdlwNrztd1C3qixtzOYLbO0M8fz+QZ7f7+fVjlCpA3NBtZ0bV9erAm/2UOmQ+W+JZDoghT7BRCJBfrL78wyY4eroWt727veqixv//T/UihVHHdz4U1hy42ld1EEIwZ6+aEngLx8cJJ7JoyiwuNbBO89p4qxZHtY0e3BbZ8Ci0hLJGYgU+gTz0V++me2OLBdEGvl/770XnvqqmitHwEUfVzs7DZM0i+IRdAQSPL/fz/MHBnnxgL/UiTnLZ+WNq+pYO8fHObO9UuASyQxBCn0C+fh338WLjh6Wxy18/aIPwg/PheAhWPxGWPd5dSWfSSSVzfPSwUGe2jPAP/f001Zcdb7CbuSCuRWcN8fL2hYftS7zpLZDIpGUByn0CeKnD3yd520baMgqvF+3CuufblYXgHjnwzD7okm7b0cgwT/39PPUngFeOOAnlS1g0ms4b46PW89r5vwWHy2VNjmEXiI5A5BCnwAOHNjOw9FfkdPDZYPLOCf9Ozj/brjoY6Cf2Gg4my+w/lCAf+7u5597+kszETZ5LbxlTSOXLKjk7FkeWQcukZyBSKFPAF947F85aIXLgou429MN1z6tLtE2QSQzeZ7eO8DjO3p5Ync/4WQWg07DObO93HJ2E5csqGSW7/Tk5SUSydRFCv0U+cD3rmOjI8bZUQ/fOftiddm2CVgwIpzI8sTuPh7d3ssz+wZIZQs4zXouW1jJlYuruWCuD4tB/vNJJJJhpBFOgS99/9940XaA+Skdn7vg87D81HLl0VSWx3b08efNXbx4YJBcQVDtMPHm1gauXFzNWbM86LXlG3wkkUimNlLoJ8nfH/tvnjQ9jb0Ab3LdTt1JyjyVzfPP3f08vKWbJ3b3k8kVqHebefcFs3jd4mqW17vksHqJRHJcSKGfBJHQID89+E0GzQpviJzLze/+4Am9Ppcv8MKBQR7e0s1j23uJpnP4bAbedlYjb1hey6pGl6xKkUgkJ4wU+klwz3+/mR32HBdGmvn8B3983K/b3RvhwfUd/GVrN/5YBrtRx5VLqrluRS3nzvaik+kUiURyChyX0BVFeR1wL6AFfiKE+MoRz98KfB3oKp76vhDiJxPYzinDR+99Gy85+1gRt/D1Wx885vXxdI6/bO3mgfUdbO4IYdBquGxhJdetqOXi+ZWyvFAikUwYxxS6oiha4AfAOqATeEVRlIeFEDuPuPS3Qoj3T0Ibpwz3/+KzvGDfQmNGwwdXfxXLa6w8tK0zzP+sb+Phzd3EM3laKm18+pqF3LCqHo8cai+RSCaB44nQzwL2CyEOAiiK8iBwHXCk0Gc0u3e8zF8yf6Sgg8vF61lz9iVjrskXBI/v6OWnzx1iQ1sQk17DNUtreetZDaxucsu8uEQimVSOR+h1QMeIx53A2eNcd6OiKBcCe4EPCyE6jrxAUZQ7gDsAGhsnd16TieYrT32IQza4PLSUD901euWhaCrL7zZ08osXDtERSNLgMfOZ1y/iptX1OM1TZ9k4iUQys5moTtH/Ax4QQqQVRXkP8Evg0iMvEkLcD9wP0NraKibo3pPO+797LRudMc6Jefn2XcN5845Agl++cJjfvtJBNJ1jTbObf796IesWVaOVpYYSieQ0czxC7wIaRjyuZ7jzEwAhxOCIhz8BvnbqTZsafOH7d/Ki/SALkjq+eMN/AzAYS/PlR3bzp02dKIrCNUtrePf5s1je4CpvYyUSyRnN8Qj9FWCuoiizUEX+FuBtIy9QFKVGCNFTfHgtsGtCW1km/vqXn/G06RmcBXhLxZ1UVNXx4Pp2vvzIbhKZHLevncXt58+S09FKJJIpwTGFLoTIKYryfuAx1LLFnwkhdiiK8nlggxDiYeCDiqJcC+SAAHDrJLb5tDDo7+FXnd8jYFJ4fWQti695K2/60YtsbAty1iwP/+/6Jcytspe7mRKJRFJCEaI8qezW1laxYcOGstz7eLjj+5fyon2ACyPN1Ld8jZ8+ewi7Sce/X7OIG1fVyYoViURSFhRF2SiEaB3vOTlSdBzu+e7beNE5wMq4hU3B9/LXpw9yc2sDn7hqgVyuTSKRTFmk0I/ghz/7NM/bttCc1tDd8Xb0bgu/ffsyzp7tLXfTJBKJ5DWRQh/Bts3P80juz6CD5v5LsLZexKdfvwibUf6YJBLJ1EeaqkgqkeAbL9zNYStcFlzGNTf8O+sWVZW7WRKJRHLcSKEXueenN7PJkeCcaAWf/pdf4LMZy90kiUQiOSHkfK3AZ+69gxfsh1iY1PGpa38uZS6RSKYlZ3yE/vs//ogXbM/jzsFNFf/GrMamcjdJIpFIToozOkLv7+vm9wP/RVCrcF78fN5847+Wu0kSiURy0pzRQv/339/CLnOec6Oz+cJdPyp3cyQSieSUOGOFfve9b+Elu59VcSvfe99D5W6ORCKRnDJnpNC/dd/HeNG+jVlp+MBZX0OjOSN/DBKJZIZxxpls/Sv/5EnNIyjAZVxHa+uF5W6SRCKRTAhnlNCT8Tjff+UTtBsE50aXc9cdXyx3kyQSiWTCOKOEfs/PbuZVa4JzYlV8867/KXdzJBKJZEI5Y4T+6Xv/hRfsh1mU1PGVtz147BdIJBLJNOOMGFj0wO9+wPO2F/Hm4C3VH8TjqSh3kyQSiWTCmfERem9PJ38K/JiIRmFt/ELeeP1t5W6SRCKRTAozXuif+dPb2W3Oc250Dp+767/K3RyJRCKZNGa00O++92Zesg2yOmbjex94qNzNkUgkkkllxgr96/d9jBcc25mdhg+t/ZZcA1Qikcx4ZqTQX3rxMZ7S/g2tgMt5IytWnFvuJkkkEsmkM+OEHo9G+cGrn6FDD+dGVvKBOz5f7iZJJBLJaWHGCf2jv3gLm61Jzo1V840P/Xe5myORSCSnjRkl9H//zrt50d7GkqSer94iBw9JJJIzixkzsOjXD9zL8/aX8OXg5roP4nL7yt0kiUQiOa3MiAi9s/Mgf478jJhG4fzERVz/hlvL3SSJRCI57cwIoX/2odvYYypwbnQu//nBH5a7ORKJRFIWpr3QP3Tvm3jZHmB1zM73Pvi/5W6ORCKRlI1pLfSv/fAeXnTsZE5a4WMXf7fczZFIJJKyMm2F/vSzf+Up/aPoBVypvYlFi1vL3SSJRCIpK8cldEVRXqcoyh5FUfYrivKJcZ43Kory2+LzLyuK0jzhLR1BPBrlx9s+S5cezous4s53/8dk3k4ikUimBccUuqIoWuAHwFXAIuCtiqIsOuKydwNBIUQL8G3gqxPd0JHc84ub2WJNcU60hq996NeTeSuJRCKZNhxPhH4WsF8IcVAIkQEeBK474prrgF8Wj/8AXKZM0mxYn/zO7bxkb2dJQs9X3/7AZNxCIpFIpiXHI/Q6oGPE487iuXGvEULkgDDgPfKNFEW5Q1GUDYqibBgYGDipBps0JuamdLyt6W45eEgikUhGcFpHigoh7gfuB2htbRUn8x6yzlwikUjG53gi9C6gYcTj+uK5ca9RFEUHOIHBiWigRCKRSI6P4xH6K8BcRVFmKYpiAN4CPHzENQ8D7yoe3wQ8KYQ4qQhcIpFIJCfHMVMuQoicoijvBx4DtMDPhBA7FEX5PLBBCPEw8FPg14qi7AcCqNKXSCQSyWnkuHLoQoi/AX874tx/jDhOAW+a2KZJJBKJ5ESYtiNFJRKJRDIaKXSJRCKZIUihSyQSyQxBCl0ikUhmCEq5qgsVRRkA2k7y5T7AP4HNmQ7Iz3xmID/zmcGpfOYmIUTFeE+UTeingqIoG4QQZ9R8ufIznxnIz3xmMFmfWaZcJBKJZIYghS6RSCQzhOkq9PvL3YAyID/zmYH8zGcGk/KZp2UOXSKRSCRjma4RukQikUiOQApdIpFIZgjTTujHWrB6pqEoys8URelXFGV7udtyulAUpUFRlH8qirJTUZQdiqLcVe42TTaKopgURVmvKMqW4mf+XLnbdDpQFEWrKMqriqL8pdxtOR0oinJYUZRtiqJsVhRlw4S//3TKoRcXrN4LrENdCu8V4K1CiJ1lbdgkoijKhUAM+JUQYkm523M6UBSlBqgRQmxSFMUObASun+H/zgpgFULEFEXRA88BdwkhXipz0yYVRVHuBloBhxDi9eVuz2SjKMphoFUIMSkDqaZbhH48C1bPKIQQz6DOMX/GIIToEUJsKh5HgV2MXcd2RiFUYsWH+uI2faKtk0BRlHrgGuAn5W7LTGG6Cf14FqyWzCAURWkGVgIvl7kpk04x/bAZ6Af+LoSY6Z/5O8DHgEKZ23E6EcDjiqJsVBTljol+8+kmdMkZhKIoNuCPwIeEEJFyt2eyEULkhRArUNftPUtRlBmbYlMU5fVAvxBiY7nbcpo5XwixCrgKeF8xpTphTDehH8+C1ZIZQDGP/EfgN0KIP5W7PacTIUQI+CfwujI3ZTJZC1xbzCk/CFyqKMp/l7dJk48Qoqu47wf+FzWNPGFMN6Efz4LVkmlOsYPwp8AuIcS3yt2e04GiKBWKoriKx2bUjv/dZW3UJCKE+KQQol4I0Yz6d/ykEOLtZW7WpKIoirXYyY+iKFbgCmBCq9emldCFEDlgaMHqXcDvhBA7ytuqyUVRlAeAF4H5iqJ0Kory7nK36TSwFngHatS2ubhdXe5GTTI1wD8VRdmKGrj8XQhxRpTynUFUAc8pirIFWA/8VQjx6ETeYFqVLUokEonk6EyrCF0ikUgkR0cKXSKRSGYIUugSiUQyQ5BCl0gkkhmCFLpEIpHMEKTQJRKJZIYghS6RSCQzhP8PTVGGGBwQtecAAAAASUVORK5CYII=\n" + }, + "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", + "source": [ + "Value function at each aggregate market resources-to-labor ratio gridpoint" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 20, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Value function at each aggregate market resources-to-labor ratio gridpoint:\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "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()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Summary Statistics for Agents' Wealth and Income" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 21, + "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.209977576559044; the standard deviation is 4.400319630466247; the median is 16.418608939597988.\n", + "The mean of individual wealth is 14.981784923214564; the standard deviation is 4.153142622717666; the median is 14.23444667903301.\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": "code", + "execution_count": 22, + "id": "4a61f5a0-c60e-41bd-ada6-0efe880cb0b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Lorenz Curve of Wealth Distribution: So far, the model does not seem to generate enough wealth inequality:\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,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", + "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)." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8615e5e7-338b-4219-a563-22409e5d0c5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.0\n", + "The mean of individual market resources is 3.375362172060929; the standard deviation is 1.4259230889521275; the median is 3.4263567807499244.\n", + "The mean of individual wealth is 1.6152166383978621; the standard deviation is 1.1373366189717646; the median is 1.5973516839615254.\n", + "The median level of market resources is: 3.4263567807499244\n", + "0.0 13.943289665216982\n", + "The market resources of the median agent is 3.4264, \n", + " and the value function for the median-wealth voter at tax rate 0.0000 is -0.1802. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.08110787241333293\n", + "The mean of individual market resources is 3.30973484275261; the standard deviation is 1.3377244879603751; the median is 3.3693657351839854.\n", + "The mean of individual wealth is 1.556438903761209; the standard deviation is 1.0639438888899186; the median is 1.5509309897522723.\n", + "The median level of market resources is: 3.3693657351839854\n", + "0.049999999999999996 13.943289665216982\n", + "The market resources of the median agent is 3.3694, \n", + " and the value function for the median-wealth voter at tax rate 0.0500 is -0.1846. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.16200780821136587\n", + "The mean of individual market resources is 3.246673866636698; the standard deviation is 1.2520229927395188; the median is 3.3121183901728566.\n", + "The mean of individual wealth is 1.5002526337341997; the standard deviation is 0.9929035918870248; the median is 1.5043015329549145.\n", + "The median level of market resources is: 3.3121183901728566\n", + "0.09999999999999999 13.943289665216982\n", + "The market resources of the median agent is 3.3121, \n", + " and the value function for the median-wealth voter at tax rate 0.1000 is -0.1890. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.24271391541611823\n", + "The mean of individual market resources is 3.1862828615693752; the standard deviation is 1.168962166474006; the median is 3.2599266750250537.\n", + "The mean of individual wealth is 1.447124303151485; the standard deviation is 0.9235623554628882; the median is 1.4619065950416985.\n", + "The median level of market resources is: 3.2599266750250537\n", + "0.15 13.943289665216982\n", + "The market resources of the median agent is 3.2599, \n", + " and the value function for the median-wealth voter at tax rate 0.1500 is -0.1935. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.323242175823087\n", + "The mean of individual market resources is 3.128825931710148; the standard deviation is 1.0875222965598483; the median is 3.2089354374967316.\n", + "The mean of individual wealth is 1.3967319396276536; the standard deviation is 0.856063635366787; the median is 1.421066631614395.\n", + "The median level of market resources is: 3.2089354374967316\n", + "0.19999999999999998 13.943289665216982\n", + "The market resources of the median agent is 3.2089, \n", + " and the value function for the median-wealth voter at tax rate 0.2000 is -0.1981. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.40360485629261217\n", + "The mean of individual market resources is 3.07393519696484; the standard deviation is 1.008347389535206; the median is 3.1599702422309206.\n", + "The mean of individual wealth is 1.348727844891705; the standard deviation is 0.7909224641555209; the median is 1.3822909271162092.\n", + "The median level of market resources is: 3.1599702422309206\n", + "0.24999999999999997 13.943289665216982\n", + "The market resources of the median agent is 3.1600, \n", + " and the value function for the median-wealth voter at tax rate 0.2500 is -0.2028. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.48381901664775584\n", + "The mean of individual market resources is 3.021939153897076; the standard deviation is 0.9308118958455757; the median is 3.1123073181313043.\n", + "The mean of individual wealth is 1.303351396879359; the standard deviation is 0.7276814207959237; the median is 1.3445554595844542.\n", + "The median level of market resources is: 3.1123073181313043\n", + "0.3 13.943289665216982\n", + "The market resources of the median agent is 3.1123, \n", + " and the value function for the median-wealth voter at tax rate 0.3000 is -0.2074. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.5638962650656257\n", + "The mean of individual market resources is 2.972537878019223; the standard deviation is 0.8547369801052926; the median is 3.0584366817672937.\n", + "The mean of individual wealth is 1.2603246492264513; the standard deviation is 0.6661794316634178; the median is 1.3019052511083558.\n", + "The median level of market resources is: 3.0584366817672937\n", + "0.35 13.943289665216982\n", + "The market resources of the median agent is 3.0584, \n", + " and the value function for the median-wealth voter at tax rate 0.3500 is -0.2129. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.6438478874783078\n", + "The mean of individual market resources is 2.9255583363848894; the standard deviation is 0.7803144004751789; the median is 3.0054928143252972.\n", + "The mean of individual wealth is 1.2196091096449893; the standard deviation is 0.606333217089106; the median is 1.2599887797922569.\n", + "The median level of market resources is: 3.0054928143252972\n", + "0.39999999999999997 13.943289665216982\n", + "The market resources of the median agent is 3.0055, \n", + " and the value function for the median-wealth voter at tax rate 0.4000 is -0.2183. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.7236851242592217\n", + "The mean of individual market resources is 2.8809012749374263; the standard deviation is 0.7077378310325457; the median is 2.956161355805598.\n", + "The mean of individual wealth is 1.1812726415471329; the standard deviation is 0.5481037226319276; the median is 1.2209323079867593.\n", + "The median level of market resources is: 2.956161355805598\n", + "0.44999999999999996 13.943289665216982\n", + "The market resources of the median agent is 2.9562, \n", + " and the value function for the median-wealth voter at tax rate 0.4500 is -0.2235. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.8034210360557753\n", + "The mean of individual market resources is 2.838609761062614; the standard deviation is 0.6366522892047719; the median is 2.9130137756022285.\n", + "The mean of individual wealth is 1.1451538268900965; the standard deviation is 0.4916602363506698; the median is 1.1867717074236241.\n", + "The median level of market resources is: 2.9130137756022285\n", + "0.49999999999999994 13.943289665216982\n", + "The market resources of the median agent is 2.9130, \n", + " and the value function for the median-wealth voter at tax rate 0.5000 is -0.2282. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.8830690706795172\n", + "The mean of individual market resources is 2.7987308377426485; the standard deviation is 0.5669560252924258; the median is 2.8728163545868233.\n", + "The mean of individual wealth is 1.1111850978846975; the standard deviation is 0.4365733784929202; the median is 1.1549467931062227.\n", + "The median level of market resources is: 2.8728163545868233\n", + "0.5499999999999999 13.943289665216982\n", + "The market resources of the median agent is 2.8728, \n", + " and the value function for the median-wealth voter at tax rate 0.5500 is -0.2327. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 0.962642905712668\n", + "The mean of individual market resources is 2.761306448547628; the standard deviation is 0.49887367155268225; the median is 2.8327661123090184.\n", + "The mean of individual wealth is 1.0795317262763333; the standard deviation is 0.3831093614174129; the median is 1.1232384024511646.\n", + "The median level of market resources is: 2.8327661123090184\n", + "0.6 13.943289665216982\n", + "The market resources of the median agent is 2.8328, \n", + " and the value function for the median-wealth voter at tax rate 0.6000 is -0.2377. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.0421487412559023\n", + "The mean of individual market resources is 2.7260404831100815; the standard deviation is 0.43186109416598456; the median is 2.7938732035092264.\n", + "The mean of individual wealth is 1.049937019896209; the standard deviation is 0.33062122613343714; the median is 1.0931465191989214.\n", + "The median level of market resources is: 2.7938732035092264\n", + "0.6499999999999999 13.943289665216982\n", + "The market resources of the median agent is 2.7939, \n", + " and the value function for the median-wealth voter at tax rate 0.6500 is -0.2427. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.121600099657847\n", + "The mean of individual market resources is 2.6930167672331202; the standard deviation is 0.3661997508951041; the median is 2.755504621852627.\n", + "The mean of individual wealth is 1.0224886887816542; the standard deviation is 0.27935478620487086; the median is 1.0641344919259825.\n", + "The median level of market resources is: 2.755504621852627\n", + "0.7 13.943289665216982\n", + "The market resources of the median agent is 2.7555, \n", + " and the value function for the median-wealth voter at tax rate 0.7000 is -0.2479. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.2010022594379157\n", + "The mean of individual market resources is 2.661986177298545; the standard deviation is 0.3017720534853086; the median is 2.7179561053238777.\n", + "The mean of individual wealth is 0.9970310684195496; the standard deviation is 0.2295028302673594; the median is 1.0357425488685024.\n", + "The median level of market resources is: 2.7179561053238777\n", + "0.7499999999999999 13.943289665216982\n", + "The market resources of the median agent is 2.7180, \n", + " and the value function for the median-wealth voter at tax rate 0.7500 is -0.2530. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.2803630006666817\n", + "The mean of individual market resources is 2.6328500972210453; the standard deviation is 0.23857079928341574; the median is 2.6811030255663866.\n", + "The mean of individual wealth is 0.9734673583559486; the standard deviation is 0.18084029906989046; the median is 1.0078764535151385.\n", + "The median level of market resources is: 2.6811030255663866\n", + "0.7999999999999999 13.943289665216982\n", + "The market resources of the median agent is 2.6811, \n", + " and the value function for the median-wealth voter at tax rate 0.8000 is -0.2582. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.3596960073172408\n", + "The mean of individual market resources is 2.6057291292873526; the standard deviation is 0.17688282902136962; the median is 2.6440079967422445.\n", + "The mean of individual wealth is 0.9517781407121343; the standard deviation is 0.13356511804653823; the median is 0.9798274107444546.\n", + "The median level of market resources is: 2.6440079967422445\n", + "0.85 13.943289665216982\n", + "The market resources of the median agent is 2.6440, \n", + " and the value function for the median-wealth voter at tax rate 0.8500 is -0.2634. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.4390209077517238\n", + "The mean of individual market resources is 2.5809033838648774; the standard deviation is 0.11653107959120272; the median is 2.6070662834442087.\n", + "The mean of individual wealth is 0.9323428488168439; the standard deviation is 0.08782708639327413; the median is 0.9518942960074035.\n", + "The median level of market resources is: 2.6070662834442087\n", + "0.8999999999999999 13.943289665216982\n", + "The market resources of the median agent is 2.6071, \n", + " and the value function for the median-wealth voter at tax rate 0.9000 is -0.2688. \n", + "\n", + "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "The lump-sum transfer in terms of permanent income is: 1.5183703433420366\n", + "The mean of individual market resources is 2.5589804659305084; the standard deviation is 0.05764036899369175; the median is 2.5724961701970654.\n", + "The mean of individual wealth is 0.9155420032979318; the standard deviation is 0.04356736107282193; the median is 0.9257544434235597.\n", + "The median level of market resources is: 2.5724961701970654\n", + "0.95 13.943289665216982\n", + "The market resources of the median agent is 2.5725, \n", + " and the value function for the median-wealth voter at tax rate 0.9500 is -0.2740. \n", + "\n" + ] + } + ], + "source": [ + "rates = 20\n", + "tax_rates = np.linspace(0.00, 0.95, num=rates)\n", + "v_at_median_wealth = []\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','cNrm','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 lump-sum transfer in terms of permanent income is: \" + str(AggShockAgent_tax_tau.calc_transfers()))\n", + "\n", + " print(\"The mean of individual market resources is \" + str(sim_market_resources_tau.mean()) + \"; the standard deviation is \"\n", + " + str(sim_market_resources_tau.std()) + \"; the median is \" + str(np.median(sim_market_resources_tau)) + \".\")\n", + " print(\"The mean of individual wealth is \" + str(sim_wealth_tau.mean()) + \"; the standard deviation is \"\n", + " + str(sim_wealth_tau.std()) + \"; the median is \" + str(np.median(sim_wealth_tau)) + \".\")\n", + "\n", + " print(\"The median level of market resources is: \" + str(np.median(AggShockAgent_tax_tau.state_now['mNrm'])))\n", + "\n", + " # Tax rate as determined by median agent (pre-tax)'s wealth and income\n", + " sim_median_wealth_tau = np.median(sim_wealth_tau)\n", + " sim_median_market_resources_tau = np.median(sim_market_resources_tau)\n", + "\n", + " # Find value function of post-tax median wealth agent/voter\n", + " # vFunc arguments: Median agent's level of market resources\n", + " # and median agent's capital-labor ratio (assumed as 1.0 for now)\n", + " v_at_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau,\n", + " 1.0)\n", + "\n", + " v_at_median_wealth.append(v_at_median_wealth_tau)\n", + "\n", + " print(EconomyExample_tau.tax_rate, EconomyExample_tau.kSS)\n", + "\n", + " print(\"The market resources of the median agent is \"\n", + " + str(mystr(sim_median_market_resources_tau)) + \", \\n and the value function for the median-wealth voter at tax rate \"\n", + " + str(mystr(AggShockAgent_tax_tau.tax_rate))\n", + " + \" is \" + str(mystr(v_at_median_wealth_tau)) + \". \\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1ce75045-7f2e-4248-82bb-4f9a15d12303", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.18024185069296117, -0.18455806238930317, -0.18903355172658706, -0.19346392517460834, -0.19814098520933243, -0.2027751787467651, -0.20742596341089536, -0.21285529753227597, -0.21827310064074493, -0.22347902643837517, -0.22816895274298954, -0.23265702523122397, -0.2376641480947056, -0.24272278380653958, -0.24785487654852859, -0.2530183142248006, -0.25817331887361744, -0.2634471807019704, -0.26884297005638635, -0.27402664188836884]\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": 25, + "id": "c9f6f0a4-0155-4f25-b15b-9a26ccddc502", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "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()" + ] + } + ], + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/REMARKs/KRR99/readme.txt b/REMARKs/KRR99/readme.txt new file mode 100644 index 00000000..ac0ac522 --- /dev/null +++ b/REMARKs/KRR99/readme.txt @@ -0,0 +1,10 @@ +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.py: ConsAggShockModel with new classes (AggShockConsumerType_tax, CobbDouglasEconomy_tax) that incorporate flat income tax rate and lump-sum transfers + - 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.py b/REMARKs/KRR99/reproduce.py new file mode 100644 index 00000000..1bf7dacf --- /dev/null +++ b/REMARKs/KRR99/reproduce.py @@ -0,0 +1,92 @@ +# Run a Jupyter notebook in a Docker container in order to test it +import argparse +import subprocess + + +def reproduce_quark(): + # Take the file as an argument + parser = argparse.ArgumentParser() + parser.add_argument( + "--local", help="reproduce local jupyter notebook", action='store_true' + ) + parser.add_argument( + "--pr", help="add the PR number to test" + ) + parser.add_argument( + "--timeout", help="indvidual cell timeout limit, default 600s" + ) + parser.add_argument( + "notebook", help="path to notebook" + ) + args = parser.parse_args() + + RUN_LOCAL = args.local + PR = args.pr + if args.pr is None and RUN_LOCAL is False: + print("Please provide a PR number if you want to test your PR to QuARK or use the command `$ python reproduce.py --local` to test the local notebook.") + return + if args.notebook is not None and args.notebook[-6:] != '.ipynb': + print("Make sure you have provided a notebook file (.ipynb) as input file") + return + # remove .ipynb extension from the name + NOTEBOOK_NAME = args.notebook[:-6] + #NOTEBOOK_NAME = f"notebooks/LifeCycleModelExample-Problems-And-Solutions" + + ORIGIN = f"https://github.com/econ-ark/QuARK" + DOCKER_IMAGE = f"econark/econ-ark-notebook" + TIMEOUT = args.timeout if args.timeout is not None else 600 + + pwd = subprocess.run(["pwd"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + mount = str(pwd.stdout)[2:-3] + ":/home/jovyan/work" + # mount the present directory and start up a container + print('Fetching the docker copy for reproducing results, this may take some time if running the reproduce.py command for the first time') + container_id = subprocess.run( + ["docker", "run", "-v", mount, "-d", DOCKER_IMAGE], stdout=subprocess.PIPE, stderr=subprocess.PIPE + ) + container_id = container_id.stdout.decode("utf-8")[:-1] + print('A docker container is created to execute the notebook') + if not RUN_LOCAL: + PATH_TO_NOTEBOOK = f"/home/jovyan/QuARK/" + # fetch the PR + subprocess.run( + [ + f'docker exec -it {container_id} bash -c "git clone {ORIGIN}; cd QuARK; git fetch {ORIGIN} +refs/pull/{PR}/merge; git checkout FETCH_HEAD"' + ], + shell=True, + ) + else: + PATH_TO_NOTEBOOK = f"/home/jovyan/work/" + + # if running using local command make it just [notebook]-reproduce.ipynb + if PR is None: + PR = "local" + # copy the notebook file to reproduce notebook + subprocess.run( + [ + f"docker exec -it {container_id} bash -c 'cp {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}.ipynb {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb'" + ], + shell=True, + ) + + # execute the reproduce notebook + subprocess.run( + [ + f"docker exec -it {container_id} bash -c 'jupyter nbconvert --ExecutePreprocessor.timeout={TIMEOUT} --to notebook --inplace --execute {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb'" + ], + shell=True, + ) + + if not RUN_LOCAL: + # copy the reproduce notebook back to local machine + subprocess.run( + [f"docker exec -it {container_id} bash -c 'cp {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb /home/jovyan/work/notebooks/'"], + shell=True, + ) + else: + # the notebook is already running locally + pass + + subprocess.run([f"docker stop {container_id}"], shell=True) + + +reproduce_quark() 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..0d09eaad --- /dev/null +++ b/REMARKs/KRR99/requirements.txt @@ -0,0 +1,11 @@ +matplotlib +numpy +ipywidgets +scipy +cite2c +pandas +pandas-datareader +statsmodels +tqdm +nbval +git+https://github.com/econ-ark/hark@master From 96e1f487576812fdbfcdef753d1eac161e009daa Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Fri, 20 May 2022 21:43:04 +0900 Subject: [PATCH 2/9] Edit files --- REMARKs/KRR99/reproduce.py | 92 -------------------------------------- 1 file changed, 92 deletions(-) delete mode 100644 REMARKs/KRR99/reproduce.py diff --git a/REMARKs/KRR99/reproduce.py b/REMARKs/KRR99/reproduce.py deleted file mode 100644 index 1bf7dacf..00000000 --- a/REMARKs/KRR99/reproduce.py +++ /dev/null @@ -1,92 +0,0 @@ -# Run a Jupyter notebook in a Docker container in order to test it -import argparse -import subprocess - - -def reproduce_quark(): - # Take the file as an argument - parser = argparse.ArgumentParser() - parser.add_argument( - "--local", help="reproduce local jupyter notebook", action='store_true' - ) - parser.add_argument( - "--pr", help="add the PR number to test" - ) - parser.add_argument( - "--timeout", help="indvidual cell timeout limit, default 600s" - ) - parser.add_argument( - "notebook", help="path to notebook" - ) - args = parser.parse_args() - - RUN_LOCAL = args.local - PR = args.pr - if args.pr is None and RUN_LOCAL is False: - print("Please provide a PR number if you want to test your PR to QuARK or use the command `$ python reproduce.py --local` to test the local notebook.") - return - if args.notebook is not None and args.notebook[-6:] != '.ipynb': - print("Make sure you have provided a notebook file (.ipynb) as input file") - return - # remove .ipynb extension from the name - NOTEBOOK_NAME = args.notebook[:-6] - #NOTEBOOK_NAME = f"notebooks/LifeCycleModelExample-Problems-And-Solutions" - - ORIGIN = f"https://github.com/econ-ark/QuARK" - DOCKER_IMAGE = f"econark/econ-ark-notebook" - TIMEOUT = args.timeout if args.timeout is not None else 600 - - pwd = subprocess.run(["pwd"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) - mount = str(pwd.stdout)[2:-3] + ":/home/jovyan/work" - # mount the present directory and start up a container - print('Fetching the docker copy for reproducing results, this may take some time if running the reproduce.py command for the first time') - container_id = subprocess.run( - ["docker", "run", "-v", mount, "-d", DOCKER_IMAGE], stdout=subprocess.PIPE, stderr=subprocess.PIPE - ) - container_id = container_id.stdout.decode("utf-8")[:-1] - print('A docker container is created to execute the notebook') - if not RUN_LOCAL: - PATH_TO_NOTEBOOK = f"/home/jovyan/QuARK/" - # fetch the PR - subprocess.run( - [ - f'docker exec -it {container_id} bash -c "git clone {ORIGIN}; cd QuARK; git fetch {ORIGIN} +refs/pull/{PR}/merge; git checkout FETCH_HEAD"' - ], - shell=True, - ) - else: - PATH_TO_NOTEBOOK = f"/home/jovyan/work/" - - # if running using local command make it just [notebook]-reproduce.ipynb - if PR is None: - PR = "local" - # copy the notebook file to reproduce notebook - subprocess.run( - [ - f"docker exec -it {container_id} bash -c 'cp {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}.ipynb {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb'" - ], - shell=True, - ) - - # execute the reproduce notebook - subprocess.run( - [ - f"docker exec -it {container_id} bash -c 'jupyter nbconvert --ExecutePreprocessor.timeout={TIMEOUT} --to notebook --inplace --execute {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb'" - ], - shell=True, - ) - - if not RUN_LOCAL: - # copy the reproduce notebook back to local machine - subprocess.run( - [f"docker exec -it {container_id} bash -c 'cp {PATH_TO_NOTEBOOK}{NOTEBOOK_NAME}-reproduce-{PR}.ipynb /home/jovyan/work/notebooks/'"], - shell=True, - ) - else: - # the notebook is already running locally - pass - - subprocess.run([f"docker stop {container_id}"], shell=True) - - -reproduce_quark() From 3686e3ee70b0a80f1b9f5fa9ad529493e9342269 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Sat, 21 May 2022 20:46:15 +0900 Subject: [PATCH 3/9] Edit Files 20220521 --- .../code/python/ConsAggShockModel_tax.py | 87 +++++++ REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 160 ++++++------ REMARKs/KRR99/code/python/Koh_KRR99.py | 233 ++++++++++++++++++ REMARKs/KRR99/code/python/__init__.py | 0 REMARKs/KRR99/requirements.txt | 1 + 5 files changed, 410 insertions(+), 71 deletions(-) create mode 100644 REMARKs/KRR99/code/python/Koh_KRR99.py create mode 100644 REMARKs/KRR99/code/python/__init__.py diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py index dd095180..e1646571 100644 --- a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py +++ b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py @@ -1,4 +1,91 @@ +""" +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 diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index 006bbadb..ab2a2a34 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -192,15 +192,19 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 1, "id": "ac322ba6-510b-438b-837e-dde9a4ee2ee9", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "import HARK\n", "import sys\n", - "from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, AggShockConsumerType_tax,\n", - " CobbDouglasEconomy, CobbDouglasEconomy_tax)\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, CobbDouglasEconomy)\n", + "\n", + "from ConsAggShockModel_tax import (AggShockConsumerType_tax, CobbDouglasEconomy_tax)\n", + "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", @@ -214,19 +218,19 @@ }, { "cell_type": "markdown", - "source": [ - "I first set the parameters for each agent as follows, with the addition of a flat income tax rate (`tax_rate`):" - ], + "id": "fffc487a", "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "I first set the parameters for each agent as follows, with the addition of a flat income tax rate (`tax_rate`):" + ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 2, "id": "c9645f21-92f8-436e-b794-ea26aa0f29de", "metadata": { "tags": [] @@ -289,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "id": "6b59cab9-deec-4cd2-8ff5-7f13297dc6b8", "metadata": {}, "outputs": [], @@ -304,24 +308,25 @@ }, { "cell_type": "markdown", - "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" - ], + "id": "167dacd2", "metadata": { - "collapsed": false, "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": 29, + "execution_count": 4, "id": "d476e500-624c-4bc8-ae78-4d22901fd8dd", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "\n", "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)" @@ -329,16 +334,15 @@ }, { "cell_type": "markdown", + "id": "183e4573", + "metadata": {}, "source": [ "I then solve for the model." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "id": "f5592aac-9677-4951-9c3c-8b675d7c971f", "metadata": {}, "outputs": [], @@ -356,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "id": "71c66623-6ff5-485a-8815-431c2be0764a", "metadata": { "tags": [] @@ -366,12 +370,15 @@ "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.41054440806001213, slope=1.1255917552697523, r-sq=0.8751220283100425\n", + "intercept=-0.5773773336944878, slope=1.1758308616806987, r-sq=0.7832480696460751\n", + "intercept=-0.6143577175394329, slope=1.176935454341733, r-sq=0.7775438351465409\n", "intercept=-0.600736339017846, slope=1.1626718040790442, r-sq=0.7970695854316202\n", "intercept=-0.5690387254827874, slope=1.144596971056191, r-sq=0.8063777583962061\n", "intercept=-0.5468314979996045, slope=1.1330227287075485, r-sq=0.8063809444926031\n", "intercept=-0.5361412473190589, slope=1.127502039450247, r-sq=0.8088097539216077\n", - "intercept=-0.5311542259396478, slope=1.1249304315188215, r-sq=0.8099901725510609\n", - "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\n" + "intercept=-0.5311542259396478, slope=1.1249304315188215, r-sq=0.8099901725510609\n" ] } ], @@ -383,19 +390,19 @@ }, { "cell_type": "markdown", - "source": [ - "Consumption function at each aggregate market resources-to-labor ratio gridpoint" - ], + "id": "f56a211b", "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "Consumption function at each aggregate market resources-to-labor ratio gridpoint" + ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "id": "6b247866", "metadata": {}, "outputs": [ @@ -408,8 +415,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -431,16 +440,25 @@ }, { "cell_type": "markdown", + "id": "8e041354", + "metadata": {}, "source": [ "Value function at each aggregate market resources-to-labor ratio gridpoint" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, + "id": "3141f9c5", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", @@ -451,8 +469,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -470,29 +490,23 @@ " 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()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", - "source": [ - "Summary Statistics for Agents' Wealth and Income" - ], + "id": "8f2e560d", "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "Summary Statistics for Agents' Wealth and Income" + ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 9, "id": "bf1f7e9b-1ee3-43a4-a313-264e13c90dd0", "metadata": { "tags": [] @@ -531,14 +545,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 10, "id": "4a61f5a0-c60e-41bd-ada6-0efe880cb0b1", "metadata": {}, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -567,6 +583,12 @@ }, { "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", @@ -575,17 +597,11 @@ "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)." - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "id": "8615e5e7-338b-4219-a563-22409e5d0c5b", "metadata": {}, "outputs": [ @@ -850,7 +866,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "id": "1ce75045-7f2e-4248-82bb-4f9a15d12303", "metadata": {}, "outputs": [ @@ -874,7 +890,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 13, "id": "c9f6f0a4-0155-4f25-b15b-9a26ccddc502", "metadata": { "tags": [] @@ -882,8 +898,10 @@ "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n", + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" @@ -921,4 +939,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.py b/REMARKs/KRR99/code/python/Koh_KRR99.py new file mode 100644 index 00000000..76aab734 --- /dev/null +++ b/REMARKs/KRR99/code/python/Koh_KRR99.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python +# coding: utf-8 + +# Import IndShockConsumerType +import HARK +import sys +from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, + CobbDouglasEconomy) +from ConsAggShockModel_tax import (AggShockConsumerType_tax, CobbDouglasEconomy_tax) +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 = ['aNrm','pLvl','mNrm','cNrm','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, 10, 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.ylim(0.0, 3.5) +# plt.show() +# +# AggShockAgent_tax.unpack('vFunc') +# +# print("Value function at each aggregate market resources-to-labor ratio gridpoint:") +# m_grid = np.linspace(0, 10, 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() +# +# +# # Code for finding optimal tax rate given vFunc of median AggShockConsumerType agent in Cobb-Douglas Economy +# +# # Put this in loop in order to find optimal tax rate for median (wealth) voter + +rates = 20 +tax_rates = np.linspace(0.00, 0.95, num=rates) +v_at_median_wealth = [] + +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','cNrm','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 lump-sum transfer in terms of permanent income is: " + str(AggShockAgent_tax_tau.calc_transfers())) + + print("The mean of individual market resources is " + str(sim_market_resources_tau.mean()) + "; the standard deviation is " + + str(sim_market_resources_tau.std()) + "; the median is " + str(np.median(sim_market_resources_tau)) + ".") + print("The mean of individual wealth is " + str(sim_wealth_tau.mean()) + "; the standard deviation is " + + str(sim_wealth_tau.std()) + "; the median is " + str(np.median(sim_wealth_tau)) + ".") + + print("The median level of market resources is: " + str(np.median(AggShockAgent_tax_tau.state_now['mNrm']))) + print("And also with median wealth + income: " + str(np.median(sim_wealth_tau + sim_income_tau))) + + + # print("The mean of post-tax individual income is " + str(sim_post_income_tau.mean()) + "; the standard deviation is " + # + str(sim_post_income_tau.std()) + "; the median is " + str(np.median(sim_post_income_tau)) + ".") + # print("The aggregate pre-tax wealth-income ratio is " + str(sim_wealth_tau.mean() / sim_pre_income_tau.mean()) + ".") + # print("The aggregate post-tax wealth-income ratio is " + str(sim_wealth_tau.mean() / sim_post_income_tau.mean()) + ".") + + # Tax rate as determined by median agent (pre-tax)'s wealth and income + + sim_median_wealth_tau = np.median(sim_wealth_tau) + # sim_median_income_tau = np.median(sim_income_tau) + sim_median_market_resources_tau = np.median(sim_market_resources_tau) + + # Find value function of median wealth agent/voter + # vFunc arguments: Median agent's level of market resources + # and median agent's capital-labor ratio (assumed as 1.0 for now) + v_at_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau, + 1.0) + + v_at_median_wealth.append(v_at_median_wealth_tau) + + print("The market resources of the median agent is " + + str(mystr(sim_median_market_resources_tau)) + + ".\n The value function for the median-wealth voter at tax rate " + + str(mystr(AggShockAgent_tax_tau.tax_rate)) + + " is " + str(mystr(v_at_median_wealth_tau)) + ".") + + +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() 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/requirements.txt b/REMARKs/KRR99/requirements.txt index 0d09eaad..23c949b7 100644 --- a/REMARKs/KRR99/requirements.txt +++ b/REMARKs/KRR99/requirements.txt @@ -1,3 +1,4 @@ +hark == 0.12 matplotlib numpy ipywidgets From 1f76905efd21203f857a1995d00ed2ffe1428de8 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Sun, 22 May 2022 11:00:53 +0900 Subject: [PATCH 4/9] Edit Files 20220522 --- .../KRR99/code/python/ConsAggShockModel.py | 3413 ----------------- .../code/python/ConsAggShockModel_tax.py | 276 +- REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 133 +- REMARKs/KRR99/requirements.txt | 2 +- 4 files changed, 318 insertions(+), 3506 deletions(-) delete mode 100644 REMARKs/KRR99/code/python/ConsAggShockModel.py diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel.py b/REMARKs/KRR99/code/python/ConsAggShockModel.py deleted file mode 100644 index 1ad261a2..00000000 --- a/REMARKs/KRR99/code/python/ConsAggShockModel.py +++ /dev/null @@ -1,3413 +0,0 @@ -""" -Consumption-saving models with aggregate productivity shocks as well as idiosyn- -cratic income shocks. Currently only contains one microeconomic model with a -basic solver. Also includes a subclass of Market called CobbDouglas economy, -used for solving "macroeconomic" models with aggregate shocks. -""" -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.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType -from HARK import MetricObject, Market, AgentType -from copy import deepcopy -import matplotlib.pyplot as plt - -__all__ = [ - "AggShockConsumerType", - "AggShockConsumerType_tax", - "AggShockMarkovConsumerType", - "CobbDouglasEconomy", - "SmallOpenEconomy", - "CobbDouglasMarkovEconomy", - "CobbDouglasMarkovEconomy_tax", - "SmallOpenMarkovEconomy", - "AggregateSavingRule", - "AggShocksDynamicRule", - "init_agg_shocks", - "init_agg_mrkv_shocks", - "init_cobb_douglas", - "init_mrkv_cobb_douglas", -] - -utility = CRRAutility -utilityP = CRRAutilityP -utilityPP = CRRAutilityPP -utilityP_inv = CRRAutilityP_inv -utility_invP = CRRAutility_invP -utility_inv = CRRAutility_inv - -class MargValueFunc2D(MetricObject): - """ - A class for representing a marginal value function in models where the - standard envelope condition of dvdm(m,M) = u'(c(m,M)) holds (with CRRA utility). - """ - - distance_criteria = ["cFunc", "CRRA"] - - def __init__(self, cFunc, CRRA): - """ - Constructor for a new marginal 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 utilityP(self.cFunc(m, M), gam=self.CRRA) - -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 -init_agg_shocks = init_idiosyncratic_shocks.copy() -del init_agg_shocks["Rfree"] # Interest factor is endogenous in agg shocks model -del init_agg_shocks["CubicBool"] # Not supported yet for agg shocks model -# del init_agg_shocks["vFuncBool"] # Not supported yet for agg shocks model -init_agg_shocks["vFuncBool"] = True -init_agg_shocks["PermGroFac"] = [1.0] -# Grid of capital-to-labor-ratios (factors) -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] -) -init_agg_shocks["MgridBase"] = MgridBase -init_agg_shocks["aXtraCount"] = 24 -init_agg_shocks["aNrmInitStd"] = 0.0 -init_agg_shocks["LivPrb"] = [0.98] - - -class AggShockConsumerType(IndShockConsumerType): - """ - A class to represent consumers who face idiosyncratic (transitory and per- - manent) shocks to their income and live in an economy that has aggregate - (transitory and permanent) shocks to labor productivity. As the capital- - to-labor ratio varies in the economy, so does the wage rate and interest - rate. "Aggregate shock consumers" have beliefs about how the capital ratio - evolves over time and take aggregate shocks into account when making their - decision about how much to consume. - """ - - def __init__(self, **kwds): - """ - Make a new instance of AggShockConsumerType, an extension of - IndShockConsumerType. Sets appropriate solver and input lists. - """ - self.vFunc = None - params = init_agg_shocks.copy() - params.update(kwds) - - AgentType.__init__( - self, - solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), - pseudo_terminal=False, - **params - ) - - # Add consumer-type specific objects, copying to create independent versions - self.time_vary = deepcopy(IndShockConsumerType.time_vary_) - self.time_inv = deepcopy(IndShockConsumerType.time_inv_) - self.del_from_time_inv("Rfree", "CubicBool") - - self.solve_one_period = solveConsAggShock - self.update() - - def reset(self): - """ - Initialize this type for a new simulated history of K/L ratio. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.initialize_sim() - self.state_now['aLvlNow'] = self.kInit * np.ones(self.AgentCount) # Start simulation near SS - self.state_now['aNrm'] = self.state_now['aLvlNow'] / self.state_now['pLvl'] # ??? - - def pre_solve(self): - # AgentType.pre_solve() - self.update_solution_terminal() - - def update_solution_terminal(self): - """ - Updates the terminal period solution for an aggregate shock consumer. - Only fills in the consumption function and marginal value function. - - 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 get_economy_data(self, economy): - """ - Imports economy-determined objects into self from a Market. - Instances of AggShockConsumerType "live" in some macroeconomy that has - attributes relevant to their microeconomic model, like the relationship - between the capital-to-labor ratio and the interest and wage rates; this - method imports those attributes from an "economy" object and makes them - attributes of the ConsumerType. - - Parameters - ---------- - economy : Market - The "macroeconomy" in which this instance "lives". Might be of the - subclass CobbDouglasEconomy, which has methods to generate the - relevant attributes. - - Returns - ------- - None - """ - self.T_sim = ( - economy.act_T - ) # Need to be able to track as many periods as economy runs - self.kInit = economy.kSS # Initialize simulation assets to steady state - self.aNrmInitMean = np.log( - 0.00000001 - ) # Initialize newborn assets to nearly zero - self.Mgrid = ( - economy.MSS * self.MgridBase - ) # Aggregate market resources grid adjusted around SS capital ratio - self.AFunc = economy.AFunc # Next period's aggregate savings function - self.Rfunc = economy.Rfunc # Interest factor as function of capital ratio - self.wFunc = economy.wFunc # Wage rate as function of capital ratio - self.DeprFac = economy.DeprFac # Rate of capital depreciation - self.PermGroFacAgg = ( - economy.PermGroFacAgg - ) # Aggregate permanent productivity growth - self.add_AggShkDstn( - economy.AggShkDstn - ) # Combine idiosyncratic and aggregate shocks into one dstn - self.add_to_time_inv( - "Mgrid", "AFunc", "Rfunc", "wFunc", "DeprFac", "PermGroFacAgg" - ) - - def add_AggShkDstn(self, AggShkDstn): - """ - Updates attribute IncShkDstn by combining idiosyncratic shocks with aggregate shocks. - - Parameters - ---------- - AggShkDstn : [np.array] - Aggregate productivity shock distribution. First element is proba- - bilities, second element is agg permanent shocks, third element is - agg transitory shocks. - - Returns - ------- - None - """ - if len(self.IncShkDstn[0].X) > 2: - self.IncShkDstn = self.IncShkDstnWithoutAggShocks - else: - self.IncShkDstnWithoutAggShocks = self.IncShkDstn - self.IncShkDstn = [ - combine_indep_dstns(self.IncShkDstn[t], AggShkDstn) - for t in range(self.T_cycle) - ] - - def sim_birth(self, which_agents): - """ - Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as - well as time variables t_age and t_cycle. Normalized assets and permanent income levels - are drawn from lognormal distributions given by aNrmInitMean and aNrmInitStd (etc). - - Parameters - ---------- - which_agents : np.array(Bool) - Boolean array of size self.AgentCount indicating which agents should be "born". - - Returns - ------- - None - """ - IndShockConsumerType.sim_birth(self, which_agents) - if 'aLvl' in self.state_now and self.state_now['aLvl'] is not None: - self.state_now['aLvl'][which_agents] = ( - self.state_now['aNrm'][which_agents] * self.state_now['pLvl'][which_agents] - ) - else: - self.state_now['aLvl'] = self.state_now['aNrm'] * self.state_now['pLvl'] - - def sim_death(self): - """ - Randomly determine which consumers die, and distribute their wealth among the survivors. - This method only works if there is only one period in the cycle. - - Parameters - ---------- - None - - Returns - ------- - who_dies : np.array(bool) - Boolean array of size AgentCount indicating which agents die. - """ - # Divide agents into wealth groups, kill one random agent per wealth group - # order = np.argsort(self.aLvlNow) - # how_many_die = int(self.AgentCount*(1.0-self.LivPrb[0])) - # group_size = self.AgentCount/how_many_die # This should be an integer - # base_idx = self.RNG.randint(0,group_size,size=how_many_die) - # kill_by_rank = np.arange(how_many_die,dtype=int)*group_size + base_idx - # who_dies = np.zeros(self.AgentCount,dtype=bool) - # who_dies[order[kill_by_rank]] = True - - # Just select a random set of agents to die - how_many_die = int(round(self.AgentCount * (1.0 - self.LivPrb[0]))) - base_bool = np.zeros(self.AgentCount, dtype=bool) - base_bool[0:how_many_die] = True - who_dies = self.RNG.permutation(base_bool) - if self.T_age is not None: - who_dies[self.t_age >= self.T_age] = True - - # Divide up the wealth of those who die, giving it to those who survive - who_lives = np.logical_not(who_dies) - wealth_living = np.sum(self.state_now['aLvl'][who_lives]) - wealth_dead = np.sum(self.state_now['aLvl'][who_dies]) - Ractuarial = 1.0 + wealth_dead / wealth_living - self.state_now['aNrm'][who_lives] = self.state_now['aNrm'][who_lives] * Ractuarial - self.state_now['aLvl'][who_lives] = self.state_now['aLvl'][who_lives] * Ractuarial - return who_dies - - def get_Rfree(self): - """ - Returns an array of size self.AgentCount with self.RfreeNow in every entry. - - Parameters - ---------- - None - - Returns - ------- - RfreeNow : np.array - Array of size self.AgentCount with risk free interest rate for each agent. - """ - RfreeNow = self.RfreeNow * np.ones(self.AgentCount) - return RfreeNow - - - - def get_shocks(self): - """ - Finds the effective permanent and transitory shocks this period by combining the aggregate - and idiosyncratic shocks of each type. - - Parameters - ---------- - None - - Returns - ------- - None - """ - IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks - self.shocks['TranShk'] = ( - self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow - ) - self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow - - - def get_controls(self): - """ - Calculates consumption for each consumer of this type using the consumption functions. - - Parameters - ---------- - None - - Returns - ------- - None - """ - cNrmNow = np.zeros(self.AgentCount) + np.nan - MPCnow = np.zeros(self.AgentCount) + np.nan - MaggNow = self.get_MaggNow() - for t in range(self.T_cycle): - these = t == self.t_cycle - cNrmNow[these] = self.solution[t].cFunc(self.state_now['mNrm'][these], MaggNow[these]) - MPCnow[these] = self.solution[t].cFunc.derivativeX( - self.state_now['mNrm'][these], MaggNow[these] - ) # Marginal propensity to consume - - self.controls['cNrm'] = cNrmNow - self.MPCnow = MPCnow - return None - - def get_MaggNow(self): # This function exists to be overwritten in StickyE model - return self.MaggNow * np.ones(self.AgentCount) - - def market_action(self): - """ - In the aggregate shocks model, the "market action" is to simulate one - period of receiving income and choosing how much to consume. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.simulate(1) - - def calc_bounding_values(self): - """ - Calculate human wealth plus minimum and maximum MPC in an infinite - horizon model with only one period repeated indefinitely. Store results - as attributes of self. Human wealth is the present discounted value of - expected future income after receiving income this period, ignoring mort- - ality. The maximum MPC is the limit of the MPC as m --> mNrmMin. The - minimum MPC is the limit of the MPC as m --> infty. - - NOT YET IMPLEMENTED FOR THIS CLASS - - Parameters - ---------- - None - - Returns - ------- - None - """ - raise NotImplementedError() - - def make_euler_error_func(self, mMax=100, approx_inc_dstn=True): - """ - Creates a "normalized Euler error" function for this instance, mapping - from market resources to "consumption error per dollar of consumption." - Stores result in attribute eulerErrorFunc as an interpolated function. - Has option to use approximate income distribution stored in self.IncShkDstn - or to use a (temporary) very dense approximation. - - NOT YET IMPLEMENTED FOR THIS CLASS - - Parameters - ---------- - mMax : float - Maximum normalized market resources for the Euler error function. - approx_inc_dstn : Boolean - Indicator for whether to use the approximate discrete income distri- - bution stored in self.IncShkDstn[0], or to use a very accurate - discrete approximation instead. When True, uses approximation in - IncShkDstn; when False, makes and uses a very dense approximation. - - Returns - ------- - None - - Notes - ----- - This method is not used by any other code in the library. Rather, it is here - for expository and benchmarking purposes. - - """ - raise NotImplementedError() - - - -# 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. - """ - - 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 - self.update() - - # def get_shocks(self): - # """ - # Same as in AggShockConsumerType, but with transitory income shocks decreased by the tax rate. - # - # Parameters - # ---------- - # None - # - # Returns - # ------- - # None - # """ - # IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks - # self.shocks['TranShk'] = ( - # self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow - # ) - # self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow - - - 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 * (1 - 0.05) - return transfers - - -# This example makes a high risk, low growth state and a low risk, high growth state -MrkvArray = np.array([[0.90, 0.10], [0.04, 0.96]]) -PermShkAggStd = [ - 0.012, - 0.006, -] # Standard deviation of log aggregate permanent shocks by state -TranShkAggStd = [ - 0.006, - 0.003, -] # Standard deviation of log aggregate transitory shocks by state -PermGroFacAgg = [0.98, 1.02] # Aggregate permanent income growth factor - -# Make a dictionary to specify a Markov aggregate shocks consumer -init_agg_mrkv_shocks = init_agg_shocks.copy() -init_agg_mrkv_shocks["MrkvArray"] = MrkvArray - - -class AggShockMarkovConsumerType(AggShockConsumerType): - """ - A class for representing ex ante heterogeneous "types" of consumers who - experience both aggregate and idiosyncratic shocks to productivity (both - permanent and transitory), who lives in an environment where the macroeconomic - state is subject to Markov-style discrete state evolution. - """ - - def __init__(self, **kwds): - params = init_agg_mrkv_shocks.copy() - params.update(kwds) - kwds = params - AggShockConsumerType.__init__(self, **kwds) - - self.shocks['Mrkv'] = None - - self.add_to_time_inv("MrkvArray") - self.solve_one_period = solve_ConsAggMarkov - - def add_AggShkDstn(self, AggShkDstn): - """ - Variation on AggShockConsumerType.add_AggShkDstn that handles the Markov - state. AggShkDstn is a list of aggregate productivity shock distributions - for each Markov state. - """ - if len(self.IncShkDstn[0][0].X) > 2: - self.IncShkDstn = self.IncShkDstnWithoutAggShocks - else: - self.IncShkDstnWithoutAggShocks = self.IncShkDstn - - IncShkDstnOut = [] - N = self.MrkvArray.shape[0] - for t in range(self.T_cycle): - IncShkDstnOut.append( - [ - combine_indep_dstns(self.IncShkDstn[t][n], AggShkDstn[n]) - for n in range(N) - ] - ) - self.IncShkDstn = IncShkDstnOut - - def update_solution_terminal(self): - """ - Update the terminal period solution. This method should be run when a - new AgentType is created or when CRRA changes. - - Parameters - ---------- - None - - Returns - ------- - None - """ - AggShockConsumerType.update_solution_terminal(self) - - # Make replicated terminal period solution - StateCount = self.MrkvArray.shape[0] - self.solution_terminal.cFunc = StateCount * [self.solution_terminal.cFunc] - self.solution_terminal.vPfunc = StateCount * [self.solution_terminal.vPfunc] - self.solution_terminal.mNrmMin = StateCount * [self.solution_terminal.mNrmMin] - - def reset_rng(self): - MarkovConsumerType.reset_rng(self) - - def get_shocks(self): - """ - Gets permanent and transitory income shocks for this period. Samples from IncShkDstn for - each period in the cycle. This is a copy-paste from IndShockConsumerType, with the - addition of the Markov macroeconomic state. Unfortunately, the get_shocks method for - MarkovConsumerType cannot be used, as that method assumes that MrkvNow is a vector - with a value for each agent, not just a single int. - - Parameters - ---------- - None - - Returns - ------- - None - """ - PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays - TranShkNow = np.zeros(self.AgentCount) - newborn = self.t_age == 0 - for t in range(self.T_cycle): - these = t == self.t_cycle - N = np.sum(these) - if N > 0: - IncShkDstnNow = self.IncShkDstn[t - 1][ - self.shocks['Mrkv'] - ] # set current income distribution - PermGroFacNow = self.PermGroFac[t - 1] # and permanent growth factor - - # Get random draws of income shocks from the discrete distribution - ShockDraws = IncShkDstnNow.draw(N, exact_match=True) - # Permanent "shock" includes expected growth - PermShkNow[these] = ShockDraws[0] * PermGroFacNow - TranShkNow[these] = ShockDraws[1] - - # That procedure used the *last* period in the sequence for newborns, but that's not right - # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. - N = np.sum(newborn) - if N > 0: - these = newborn - IncShkDstnNow = self.IncShkDstn[0][ - self.shocks['Mrkv'] - ] # set current income distribution - PermGroFacNow = self.PermGroFac[0] # and permanent growth factor - - # Get random draws of income shocks from the discrete distribution - ShockDraws = IncShkDstnNow.draw(N, exact_match=True) - - # Permanent "shock" includes expected growth - PermShkNow[these] = ShockDraws[0] * PermGroFacNow - TranShkNow[these] = ShockDraws[1] - - # Store the shocks in self - self.EmpNow = np.ones(self.AgentCount, dtype=bool) - self.EmpNow[TranShkNow == self.IncUnemp] = False - self.shocks['TranShk'] = TranShkNow * self.TranShkAggNow * self.wRteNow - self.shocks['PermShk'] = PermShkNow * self.PermShkAggNow - - def get_controls(self): - """ - Calculates consumption for each consumer of this type using the consumption functions. - For this AgentType class, MrkvNow is the same for all consumers. However, in an - extension with "macroeconomic inattention", consumers might misperceive the state - and thus act as if they are in different states. - - Parameters - ---------- - None - - Returns - ------- - None - """ - cNrmNow = np.zeros(self.AgentCount) + np.nan - MPCnow = np.zeros(self.AgentCount) + np.nan - MaggNow = self.get_MaggNow() - MrkvNow = self.getMrkvNow() - - StateCount = self.MrkvArray.shape[0] - MrkvBoolArray = np.zeros((StateCount, self.AgentCount), dtype=bool) - for i in range(StateCount): - MrkvBoolArray[i, :] = i == MrkvNow - - for t in range(self.T_cycle): - these = t == self.t_cycle - for i in range(StateCount): - those = np.logical_and(these, MrkvBoolArray[i, :]) - cNrmNow[those] = self.solution[t].cFunc[i]( - self.state_now['mNrm'][those], MaggNow[those] - ) - # Marginal propensity to consume - MPCnow[those] = ( - self.solution[t] - .cFunc[i] - .derivativeX(self.state_now['mNrm'][those], MaggNow[those]) - ) - self.controls['cNrm'] = cNrmNow - self.MPCnow = MPCnow - return None - - def getMrkvNow(self): # This function exists to be overwritten in StickyE model - return self.shocks['Mrkv'] * np.ones(self.AgentCount, dtype=int) - - -init_KS_agents = { - "T_cycle": 1, - "DiscFac": 0.99, - "CRRA": 1.0, - "LbrInd": 1.0, - "aMin": 0.001, - "aMax": 50.0, - "aCount": 32, - "aNestFac": 2, - "MgridBase": np.array( - [0.1, 0.3, 0.6, 0.8, 0.9, 0.95, 0.98, 1.0, 1.02, 1.05, 1.1, 1.2, 1.6, 2.0, 3.0] - ), - "AgentCount": 5000, -} - - -class KrusellSmithType(AgentType): - """ - A class for representing agents in the seminal Krusell-Smith (1998) model from - the paper "Income and Wealth Heterogeneity in the Macroeconomy". All default - parameters have been set to match those in the paper, but the equilibrium object - is perceptions of aggregate assets as a function of aggregate market resources - in each macroeconomic state (bad=0, good=1), rather than aggregate capital as - a function of previous aggregate capital. This choice was made so that some - of the code from HARK's other HA-macro models can be used. - """ - - def __init__(self, **kwds): - """ - Make a new instance of the Krusell-Smith type. - """ - params = init_KS_agents.copy() - params.update(kwds) - - AgentType.__init__(self, pseudo_terminal=False, **params) - - # Add consumer-type specific objects - self.time_vary = [] - self.time_inv = [ - "DiscFac", - "CRRA", - ] - # need better handling of this - self.state_now = { - "aNow" : None, - "mNow" : None, - "EmpNow" : None - } - self.state_prev = { - "aNow" : None, - "mNow" : None, - "EmpNow" : None - } - - self.shock_vars = { - "Mrkv" : None - } - - self.solve_one_period = solve_KrusellSmith - self.update() - - def pre_solve(self): - self.update() - self.precompute_arrays() - - def update(self): - """ - Construct objects used during solution from primitive parameters. - """ - self.make_grid() - self.update_solution_terminal() - - def get_economy_data(self, Economy): - """ - Imports economy-determined objects into self from a Market. - - Parameters - ---------- - Economy : KrusellSmithEconomy - The "macroeconomy" in which this instance "lives". - - Returns - ------- - None - """ - self.T_sim = ( - Economy.act_T - ) # Need to be able to track as many periods as economy runs - self.kInit = Economy.KSS # Initialize simulation assets to steady state - self.MrkvInit = Economy.sow_init[ - "Mrkv" - ] # Starting Markov state for the macroeconomy - self.Mgrid = ( - Economy.MSS * self.MgridBase - ) # Aggregate market resources grid adjusted around SS capital ratio - self.AFunc = Economy.AFunc # Next period's aggregate savings function - self.DeprFac = Economy.DeprFac # Rate of capital depreciation - self.CapShare = Economy.CapShare # Capital's share of production - self.LbrInd = Economy.LbrInd # Idiosyncratic labor supply (when employed) - self.UrateB = Economy.UrateB # Unemployment rate in bad state - self.UrateG = Economy.UrateG # Unemployment rate in good state - self.ProdB = Economy.ProdB # Total factor productivity in bad state - self.ProdG = Economy.ProdG # Total factor productivity in good state - self.MrkvIndArray = ( - Economy.MrkvIndArray - ) # Transition probabilities among discrete states - self.MrkvAggArray = ( - Economy.MrkvArray - ) # Transition probabilities among aggregate discrete states - self.add_to_time_inv( - "Mgrid", - "AFunc", - "DeprFac", - "CapShare", - "UrateB", - "LbrInd", - "UrateG", - "ProdB", - "ProdG", - "MrkvIndArray", - "MrkvAggArray", - ) - - def make_grid(self): - """ - Construct the attribute aXtraGrid from the primitive attributes aMin, - aMax, aCount, aNestFac. - """ - self.aGrid = make_grid_exp_mult(self.aMin, self.aMax, self.aCount, self.aNestFac) - self.add_to_time_inv("aGrid") - - def update_solution_terminal(self): - """ - Construct the trivial terminal period solution (initial guess). - """ - cFunc_terminal = 4 * [IdentityFunction(n_dims=2)] - vPfunc_terminal = [ - MargValueFuncCRRA(cFunc_terminal[j], self.CRRA) for j in range(4) - ] - self.solution_terminal = ConsumerSolution( - cFunc=cFunc_terminal, vPfunc=vPfunc_terminal - ) - - def precompute_arrays(self): - """ - Construct the attributes ProbArray, mNextArray, MnextArray, and RnextArray, - which will be used by the one period solver. - """ - # Get array sizes - aCount = self.aGrid.size - Mcount = self.Mgrid.size - - # Make tiled array of end-of-period idiosyncratic assets (order: a, M, s, s') - aNow_tiled = np.tile( - np.reshape(self.aGrid, [aCount, 1, 1, 1]), [1, Mcount, 4, 4] - ) - - # Make arrays of end-of-period aggregate assets (capital next period) - AnowB = self.AFunc[0](self.Mgrid) - AnowG = self.AFunc[1](self.Mgrid) - KnextB = np.tile(np.reshape(AnowB, [1, Mcount, 1, 1]), [1, 1, 1, 4]) - KnextG = np.tile(np.reshape(AnowG, [1, Mcount, 1, 1]), [1, 1, 1, 4]) - Knext = np.concatenate((KnextB, KnextB, KnextG, KnextG), axis=2) - - # Make arrays of aggregate labor and TFP next period - Lnext = np.zeros((1, Mcount, 4, 4)) # shape (1,Mcount,4,4) - Lnext[0, :, :, 0:2] = (1.0 - self.UrateB) * self.LbrInd - Lnext[0, :, :, 2:4] = (1.0 - self.UrateG) * self.LbrInd - Znext = np.zeros((1, Mcount, 4, 4)) - Znext[0, :, :, 0:2] = self.ProdB - Znext[0, :, :, 2:4] = self.ProdG - - # Calculate (net) interest factor and wage rate next period - KtoLnext = Knext / Lnext - Rnext = 1.0 + Znext * CapShare * KtoLnext ** (CapShare - 1.0) - DeprFac - Wnext = Znext * (1.0 - CapShare) * KtoLnext ** CapShare - - # Calculate aggregate market resources next period - Ynext = Znext * Knext ** CapShare * Lnext ** (1.0 - CapShare) - Mnext = (1.0 - DeprFac) * Knext + Ynext - - # Tile the interest, wage, and aggregate market resources arrays - Rnext_tiled = np.tile(Rnext, [aCount, 1, 1, 1]) - Wnext_tiled = np.tile(Wnext, [aCount, 1, 1, 1]) - Mnext_tiled = np.tile(Mnext, [aCount, 1, 1, 1]) - - # Make an array of idiosyncratic labor supply next period - lNext_tiled = np.zeros([aCount, Mcount, 4, 4]) - lNext_tiled[:, :, :, 1] = self.LbrInd - lNext_tiled[:, :, :, 3] = self.LbrInd - - # Calculate idiosyncratic market resources next period - mNext = Rnext_tiled * aNow_tiled + Wnext_tiled * lNext_tiled - - # Make a tiled array of transition probabilities - Probs_tiled = np.tile( - np.reshape(self.MrkvIndArray, [1, 1, 4, 4]), [aCount, Mcount, 1, 1] - ) - - # Store the attributes that will be used by the solver - self.ProbArray = Probs_tiled - self.mNextArray = mNext - self.MnextArray = Mnext_tiled - self.RnextArray = Rnext_tiled - self.add_to_time_inv("ProbArray", "mNextArray", "MnextArray", "RnextArray") - - def make_emp_idx_arrays(self): - """ - Construct the attributes emp_permute and unemp_permute, each of which is - a 2x2 nested list of boolean arrays. The j,k-th element of emp_permute - represents the employment states this period for agents who were employed - last period when the macroeconomy is transitioning from state j to state k. - Likewise, j,k-th element of unemp_permute represents the employment states - this period for agents who were unemployed last period when the macro- - economy is transitioning from state j to state k. These attributes are - referenced during simulation, when they are randomly permuted in order to - maintain exact unemployment rates in each period. - """ - # Get counts of employed and unemployed agents in each macroeconomic state - B_unemp_N = int(np.round(self.UrateB * self.AgentCount)) - B_emp_N = self.AgentCount - B_unemp_N - G_unemp_N = int(np.round(self.UrateG * self.AgentCount)) - G_emp_N = self.AgentCount - G_unemp_N - - # Bad-bad transition indices - BB_stay_unemp_N = int( - np.round(B_unemp_N * self.MrkvIndArray[0, 0] / self.MrkvAggArray[0, 0]) - ) - BB_become_unemp_N = B_unemp_N - BB_stay_unemp_N - BB_stay_emp_N = int( - np.round(B_emp_N * self.MrkvIndArray[1, 1] / self.MrkvAggArray[0, 0]) - ) - BB_become_emp_N = B_emp_N - BB_stay_emp_N - BB_unemp_permute = np.concatenate( - [ - np.ones(BB_become_emp_N, dtype=bool), - np.zeros(BB_stay_unemp_N, dtype=bool), - ] - ) - BB_emp_permute = np.concatenate( - [ - np.ones(BB_stay_emp_N, dtype=bool), - np.zeros(BB_become_unemp_N, dtype=bool), - ] - ) - - # Bad-good transition indices - BG_stay_unemp_N = int( - np.round(B_unemp_N * self.MrkvIndArray[0, 2] / self.MrkvAggArray[0, 1]) - ) - BG_become_unemp_N = G_unemp_N - BG_stay_unemp_N - BG_stay_emp_N = int( - np.round(B_emp_N * self.MrkvIndArray[1, 3] / self.MrkvAggArray[0, 1]) - ) - BG_become_emp_N = G_emp_N - BG_stay_emp_N - BG_unemp_permute = np.concatenate( - [ - np.ones(BG_become_emp_N, dtype=bool), - np.zeros(BG_stay_unemp_N, dtype=bool), - ] - ) - BG_emp_permute = np.concatenate( - [ - np.ones(BG_stay_emp_N, dtype=bool), - np.zeros(BG_become_unemp_N, dtype=bool), - ] - ) - - # Good-bad transition indices - GB_stay_unemp_N = int( - np.round(G_unemp_N * self.MrkvIndArray[2, 0] / self.MrkvAggArray[1, 0]) - ) - GB_become_unemp_N = B_unemp_N - GB_stay_unemp_N - GB_stay_emp_N = int( - np.round(G_emp_N * self.MrkvIndArray[3, 1] / self.MrkvAggArray[1, 0]) - ) - GB_become_emp_N = B_emp_N - GB_stay_emp_N - GB_unemp_permute = np.concatenate( - [ - np.ones(GB_become_emp_N, dtype=bool), - np.zeros(GB_stay_unemp_N, dtype=bool), - ] - ) - GB_emp_permute = np.concatenate( - [ - np.ones(GB_stay_emp_N, dtype=bool), - np.zeros(GB_become_unemp_N, dtype=bool), - ] - ) - - # Good-good transition indices - GG_stay_unemp_N = int( - np.round(G_unemp_N * self.MrkvIndArray[2, 2] / self.MrkvAggArray[1, 1]) - ) - GG_become_unemp_N = G_unemp_N - GG_stay_unemp_N - GG_stay_emp_N = int( - np.round(G_emp_N * self.MrkvIndArray[3, 3] / self.MrkvAggArray[1, 1]) - ) - GG_become_emp_N = G_emp_N - GG_stay_emp_N - GG_unemp_permute = np.concatenate( - [ - np.ones(GG_become_emp_N, dtype=bool), - np.zeros(GG_stay_unemp_N, dtype=bool), - ] - ) - GG_emp_permute = np.concatenate( - [ - np.ones(GG_stay_emp_N, dtype=bool), - np.zeros(GG_become_unemp_N, dtype=bool), - ] - ) - - # Store transition matrices as attributes of self - self.unemp_permute = [ - [BB_unemp_permute, BG_unemp_permute], - [GB_unemp_permute, GG_unemp_permute], - ] - self.emp_permute = [ - [BB_emp_permute, BG_emp_permute], - [GB_emp_permute, GG_emp_permute], - ] - - def reset(self): - self.initialize_sim() - - def market_action(self): - self.simulate(1) - - def initialize_sim(self): - self.shocks['Mrkv'] = self.MrkvInit - AgentType.initialize_sim(self) - self.state_now["EmpNow"] = self.state_now["EmpNow"].astype(bool) - self.make_emp_idx_arrays() - - def sim_birth(self, which): - """ - Create newborn agents with randomly drawn employment states. This will - only ever be called by initialize_sim() at the start of a new simulation - history, as the Krusell-Smith model does not have death and replacement. - The sim_death() method does not exist, as AgentType's default of "no death" - is the correct behavior for the model. - """ - N = np.sum(which) - if N == 0: - return - - if self.shocks['Mrkv'] == 0: - unemp_N = int(np.round(self.UrateB * N)) - emp_N = self.AgentCount - unemp_N - elif self.shocks['Mrkv'] == 1: - unemp_N = int(np.round(self.UrateG * N)) - emp_N = self.AgentCount - unemp_N - else: - assert False, "Illegal macroeconomic state: MrkvNow must be 0 or 1" - EmpNew = np.concatenate( - [np.zeros(unemp_N, dtype=bool), np.ones(emp_N, dtype=bool)] - ) - - self.state_now["EmpNow"][which] = self.RNG.permutation(EmpNew) - self.state_now["aNow"][which] = self.kInit - - def get_shocks(self): - """ - Get new idiosyncratic employment states based on the macroeconomic state. - """ - # Get boolean arrays for current employment states - employed = self.state_prev["EmpNow"].copy().astype(bool) - unemployed = np.logical_not(employed) - - # derive from past employment rate rather than store previous value - mrkv_prev = int((unemployed.sum() / float(self.AgentCount)) != self.UrateB) - - # Transition some agents between unemployment and employment - emp_permute = self.emp_permute[mrkv_prev][self.shocks['Mrkv']] - unemp_permute = self.unemp_permute[mrkv_prev][self.shocks['Mrkv']] - # TODO: replace poststate_vars functionality with shocks here - EmpNow = self.state_now["EmpNow"] - - # It's really this permutation that is the shock... - # This apparatus is trying to 'exact match' the 'internal' Markov process. - EmpNow[employed] = self.RNG.permutation(emp_permute) - EmpNow[unemployed] = self.RNG.permutation(unemp_permute) - - def get_states(self): - """ - Get each agent's idiosyncratic state, their household market resources. - """ - self.state_now["mNow"] = self.Rnow * self.state_prev['aNow'] + self.Wnow * self.LbrInd * self.state_now["EmpNow"] - - def get_controls(self): - """ - Get each agent's consumption given their current state.' - """ - employed = self.state_now["EmpNow"].copy().astype(bool) - unemployed = np.logical_not(employed) - - # Get the discrete index for (un)employed agents - if self.shocks['Mrkv'] == 0: # Bad macroeconomic conditions - unemp_idx = 0 - emp_idx = 1 - elif self.shocks['Mrkv'] == 1: # Good macroeconomic conditions - unemp_idx = 2 - emp_idx = 3 - else: - assert False, "Illegal macroeconomic state: MrkvNow must be 0 or 1" - - # Get consumption for each agent using the appropriate consumption function - cNow = np.zeros(self.AgentCount) - Mnow = self.Mnow * np.ones(self.AgentCount) - cNow[unemployed] = self.solution[0].cFunc[unemp_idx]( - self.state_now["mNow"][unemployed], Mnow[unemployed] - ) - cNow[employed] = self.solution[0].cFunc[emp_idx]( - self.state_now["mNow"][employed], Mnow[employed] - ) - self.controls["cNow"] = cNow - - def get_poststates(self): - """ - Gets each agent's retained assets after consumption. - """ - self.state_now['aNow'] = self.state_now["mNow"] - self.controls["cNow"] - - -############################################################################### - - - -def solveConsAggShock( - solution_next, - IncShkDstn, - LivPrb, - DiscFac, - CRRA, - PermGroFac, - PermGroFacAgg, - aXtraGrid, - BoroCnstArt, - Mgrid, - AFunc, - Rfunc, - wFunc, -): - """ - Solve one period of a consumption-saving problem with idiosyncratic and - aggregate shocks (transitory and permanent). This is a basic solver that - can't handle cubic splines, nor can it calculate a value function. - - 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 - - - -def solve_ConsAggShock_new(solution_next, IncShkDstn, LivPrb, DiscFac, CRRA, PermGroFac, - PermGroFacAgg, aXtraGrid, BoroCnstArt, Mgrid, AFunc, Rfunc, wFunc, DeprFac): - ''' - Solve one period of a consumption-saving problem with idiosyncratic and - aggregate shocks (transitory and permanent). This is a basic solver that - can't handle cubic splines, nor can it calculate a value function. This - version uses calc_expectation to reduce code clutter. - - 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) and marginal value function vPfunc. - ''' - # Unpack the income shocks and get grid sizes - PermShkValsNext = IncShkDstn.X[0] - TranShkValsNext = IncShkDstn.X[1] - PermShkAggValsNext = IncShkDstn.X[2] - TranShkAggValsNext = IncShkDstn.X[3] - aCount = aXtraGrid.size - Mcount = Mgrid.size - - # Define a function that calculates M_{t+1} from M_t and the aggregate shocks; - # the function also returns the wage rate and effective interest factor - def calcAggObjects(M,Psi,Theta): - A = AFunc(M) # End-of-period aggregate assets (normalized) - kNext = A/(PermGroFacAgg*Psi) # Next period's aggregate capital/labor ratio - kNextEff = kNext/Theta # Same thing, but account for *transitory* shock - R = Rfunc(kNextEff) # Interest factor on aggregate assets - wEff = wFunc(kNextEff)*Theta # Effective wage rate (accounts for labor supply) - Reff = R/LivPrb # Account for redistribution of decedents' wealth - Mnext = kNext*R + wEff # Next period's aggregate market resources - return Mnext, Reff, wEff - - # Define a function that evaluates R*v'(m_{t+1},M_{t+1}) from a_t, M_t, and the income shocks - def vPnextFunc(a,M,psi,theta,Psi,Theta): - Mnext, Reff, wEff = calcAggObjects(M,Psi,Theta) - PermShkTotal = PermGroFac * PermGroFacAgg * psi * Psi # Total / combined permanent shock - mNext = Reff*a/PermShkTotal + theta*wEff # Idiosyncratic market resources - vPnext = Reff*PermShkTotal**(-CRRA)*solution_next.vPfunc(mNext, Mnext) - return vPnext - - # Make an array of a_t values at which to calculate end-of-period marginal value of assets - BoroCnstNat_vec = np.zeros(Mcount) # Natural borrowing constraint at each M_t - aNrmNow = np.zeros((aCount,Mcount)) - for j in range(Mcount): - Mnext, Reff, wEff = calcAggObjects(Mgrid[j], PermShkAggValsNext, TranShkAggValsNext) - aNrmMin_cand = (PermGroFac*PermGroFacAgg*PermShkValsNext*PermShkAggValsNext/Reff) * \ - (solution_next.mNrmMin(Mnext) - wEff*TranShkValsNext) - aNrmMin = np.max(aNrmMin_cand) # Lowest valid a_t value for this M_t - aNrmNow[:,j] = aNrmMin + aXtraGrid - BoroCnstNat_vec[j] = aNrmMin - - # Compute end-of-period marginal value of assets - MaggNow = np.tile(np.reshape(Mgrid,(1,Mcount)),(aCount,1)) # Tiled Mgrid - EndOfPrdvP = DiscFac*LivPrb*calc_expectation(IncShkDstn,vPnextFunc,[aNrmNow,MaggNow]) - - # Calculate optimal consumption from each asset gridpoint and endogenous m_t gridpoint - cNrmNow = EndOfPrdvP**(-1.0/CRRA) - mNrmNow = aNrmNow + 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)) - - # 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 = MargValueFunc2D(cFuncNow, CRRA) - - # Construct the value function using the envelope condition - vFuncNow = ValueFunc2D(cFuncNow, CRRA) - - # Pack up and return the solution - solution_now = ConsumerSolution(cFunc=cFuncNow, vPfunc=vPfuncNow, vFunc=vFuncNow, mNrmMin=mNrmMinNow) - return solution_now - - -############################################################################### - - -def solve_ConsAggMarkov( - solution_next, - IncShkDstn, - LivPrb, - DiscFac, - CRRA, - MrkvArray, - PermGroFac, - PermGroFacAgg, - aXtraGrid, - BoroCnstArt, - Mgrid, - AFunc, - Rfunc, - wFunc, -): - """ - Solve one period of a consumption-saving problem with idiosyncratic and - aggregate shocks (transitory and permanent). Moreover, the macroeconomic - state follows a Markov process that determines the income distribution and - aggregate permanent growth factor. This is a basic solver that can't handle - cubic splines, nor can it calculate a value function. - - Parameters - ---------- - solution_next : ConsumerSolution - The solution to the succeeding one period problem. - IncShkDstn : [distribution.Distribution] - A list of - discrete approximations to the income process between the period being - solved and the one immediately following (in solution_next). Order: - idisyncratic 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. - MrkvArray : np.array - Markov transition matrix between discrete macroeconomic states. - MrkvArray[i,j] is probability of being in state j next period conditional - on being in state i this period. - PermGroFac : float - Expected permanent income growth factor at the end of this period, - for the *individual*'s productivity. - PermGroFacAgg : [float] - Expected aggregate productivity growth in each Markov macro state. - 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, for each - Markov macro state. - 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) and marginal value function vPfunc. - """ - # Get sizes of grids - aCount = aXtraGrid.size - Mcount = Mgrid.size - StateCount = MrkvArray.shape[0] - - # Loop through next period's states, assuming we reach each one at a time. - # Construct EndOfPrdvP_cond functions for each state. - EndOfPrdvPfunc_cond = [] - BoroCnstNat_cond = [] - for j in range(StateCount): - # Unpack next period's solution - vPfuncNext = solution_next.vPfunc[j] - mNrmMinNext = solution_next.mNrmMin[j] - - # Unpack the income shocks - ShkPrbsNext = IncShkDstn[j].pmf - PermShkValsNext = IncShkDstn[j].X[0] - TranShkValsNext = IncShkDstn[j].X[1] - PermShkAggValsNext = IncShkDstn[j].X[2] - TranShkAggValsNext = IncShkDstn[j].X[3] - ShkCount = ShkPrbsNext.size - aXtra_tiled = np.tile( - np.reshape(aXtraGrid, (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) - ) - - # Make a tiled grid of end-of-period aggregate assets. These lines use - # next prd state j's aggregate saving rule to get a relevant set of Aagg, - # which will be used to make an interpolated EndOfPrdvP_cond function. - # After constructing these functions, we will use the aggregate saving - # rule for *current* state i to get values of Aagg at which to evaluate - # these conditional marginal value functions. In the strange, maybe even - # impossible case where the aggregate saving rules differ wildly across - # macro states *and* there is "anti-persistence", so that the macro state - # is very likely to change each period, then this procedure will lead to - # an inaccurate solution because the grid of Aagg values on which the - # conditional marginal value functions are constructed is not relevant - # to the values at which it will actually be evaluated. - AaggGrid = AFunc[j](Mgrid) - AaggNow_tiled = np.tile( - np.reshape(AaggGrid, (Mcount, 1, 1)), (1, aCount, ShkCount) - ) - - # Calculate returns to capital and labor in the next period - kNext_array = AaggNow_tiled / ( - PermGroFacAgg[j] * PermShkAggValsNext_tiled - ) # Next period's aggregate capital to 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[j] - * 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[j] - * 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) - - # Make the conditional end-of-period marginal value function - BoroCnstNat = LinearInterp( - np.insert(AaggGrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0) - ) - EndOfPrdvPnvrs = np.concatenate( - (np.zeros((Mcount, 1)), EndOfPrdvP ** (-1.0 / CRRA)), axis=1 - ) - EndOfPrdvPnvrsFunc_base = BilinearInterp( - np.transpose(EndOfPrdvPnvrs), np.insert(aXtraGrid, 0, 0.0), AaggGrid - ) - EndOfPrdvPnvrsFunc = VariableLowerBoundFunc2D( - EndOfPrdvPnvrsFunc_base, BoroCnstNat - ) - EndOfPrdvPfunc_cond.append(MargValueFuncCRRA(EndOfPrdvPnvrsFunc, CRRA)) - BoroCnstNat_cond.append(BoroCnstNat) - - # Prepare some objects that are the same across all current states - aXtra_tiled = np.tile(np.reshape(aXtraGrid, (1, aCount)), (Mcount, 1)) - cFuncCnst = BilinearInterp( - np.array([[0.0, 0.0], [1.0, 1.0]]), - np.array([BoroCnstArt, BoroCnstArt + 1.0]), - np.array([0.0, 1.0]), - ) - - # Now loop through *this* period's discrete states, calculating end-of-period - # marginal value (weighting across state transitions), then construct consumption - # and marginal value function for each state. - cFuncNow = [] - vPfuncNow = [] - mNrmMinNow = [] - for i in range(StateCount): - # Find natural borrowing constraint for this state by Aagg - AaggNow = AFunc[i](Mgrid) - aNrmMin_candidates = np.zeros((StateCount, Mcount)) + np.nan - for j in range(StateCount): - if MrkvArray[i, j] > 0.0: # Irrelevant if transition is impossible - aNrmMin_candidates[j, :] = BoroCnstNat_cond[j](AaggNow) - aNrmMin_vec = np.nanmax(aNrmMin_candidates, axis=0) - BoroCnstNat_vec = aNrmMin_vec - - # Make tiled grids of aNrm and Aagg - aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec, (Mcount, 1)), (1, aCount)) - aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled - AaggNow_tiled = np.tile(np.reshape(AaggNow, (Mcount, 1)), (1, aCount)) - - # Loop through feasible transitions and calculate end-of-period marginal value - EndOfPrdvP = np.zeros((Mcount, aCount)) - for j in range(StateCount): - if MrkvArray[i, j] > 0.0: - temp = EndOfPrdvPfunc_cond[j](aNrmNow_tiled, AaggNow_tiled) - EndOfPrdvP += MrkvArray[i, j] * temp - - # Calculate consumption and the endogenous mNrm gridpoints for this state - cNrmNow = EndOfPrdvP ** (-1.0 / CRRA) - mNrmNow = aNrmNow_tiled + cNrmNow - - # Loop through the values in Mgrid and make a piecewise linear consumption function for each - cFuncBaseByM_list = [] - for n in range(Mcount): - c_temp = np.insert(cNrmNow[n, :], 0, 0.0) # Add point at bottom - m_temp = np.insert(mNrmNow[n, :] - BoroCnstNat_vec[n], 0, 0.0) - cFuncBaseByM_list.append(LinearInterp(m_temp, c_temp)) - # Add the M-specific consumption function to the list - - # Construct the 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) - - # Combine the constrained consumption function with unconstrained component - cFuncNow.append(LowerEnvelope2D(cFuncUnc, cFuncCnst)) - - # Make the minimum m function as the greater of the natural and artificial constraints - mNrmMinNow.append(UpperEnvelope(BoroCnstNat, ConstantFunction(BoroCnstArt))) - - # Construct the marginal value function using the envelope condition - vPfuncNow.append(MargValueFuncCRRA(cFuncNow[-1], CRRA)) - - # Pack up and return the solution - solution_now = ConsumerSolution( - cFunc=cFuncNow, vPfunc=vPfuncNow, mNrmMin=mNrmMinNow - ) - return solution_now - - -############################################################################### - - -def solve_KrusellSmith( - solution_next, - DiscFac, - CRRA, - aGrid, - Mgrid, - mNextArray, - MnextArray, - ProbArray, - RnextArray, -): - """ - Solve the one period problem of an agent in Krusell & Smith's canonical 1998 model. - Because this model is so specialized and only intended to be used with a very narrow - case, many arrays can be precomputed, making the code here very short. See the - method KrusellSmithType.precompute_arrays() for details. - - Parameters - ---------- - solution_next : ConsumerSolution - Representation of the solution to next period's problem, including the - discrete-state-conditional consumption function and marginal value function. - DiscFac : float - Intertemporal discount factor. - CRRA : float - Coefficient of relative risk aversion. - aGrid : np.array - Array of end-of-period asset values. - Mgrid : np.array - A grid of aggregate market resources in the economy. - mNextArray : np.array - Precomputed array of next period's market resources attained from every - end-of-period state in the exogenous grid crossed with every shock that - might attain. Has shape [aCount, Mcount, 4, 4] ~ [a, M, s, s']. - MnextArray : np.array - Precomputed array of next period's aggregate market resources attained - from every end-of-period state in the exogenous grid crossed with every - shock that might attain. Corresponds to mNextArray. - ProbArray : np.array - Tiled array of transition probabilities among discrete states. Every - slice [i,j,:,:] is identical and translated from MrkvIndArray. - RnextArray : np.array - Tiled array of net interest factors next period, attained from every - end-of-period state crossed with every shock that might attain. - - Returns - ------- - solution_now : ConsumerSolution - Representation of this period's solution to the Krusell-Smith model. - """ - # Loop over next period's state realizations, computing marginal value of market resources - vPnext = np.zeros_like(mNextArray) - for j in range(4): - vPnext[:, :, :, j] = solution_next.vPfunc[j]( - mNextArray[:, :, :, j], MnextArray[:, :, :, j] - ) - - # Compute end-of-period marginal value of assets - EndOfPrdvP = DiscFac * np.sum(RnextArray * vPnext * ProbArray, axis=3) - - # Invert the first order condition to find optimal consumption - cNow = EndOfPrdvP ** (-1.0 / CRRA) - - # Find the endogenous gridpoints - aCount = aGrid.size - Mcount = Mgrid.size - aNow = np.tile(np.reshape(aGrid, [aCount, 1, 1]), [1, Mcount, 4]) - mNow = aNow + cNow - - # Insert zeros at the bottom of both cNow and mNow arrays (consume nothing) - cNow = np.concatenate([np.zeros([1, Mcount, 4]), cNow], axis=0) - mNow = np.concatenate([np.zeros([1, Mcount, 4]), mNow], axis=0) - - # Construct the consumption and marginal value function for each discrete state - cFunc_by_state = [] - vPfunc_by_state = [] - for j in range(4): - cFunc_by_M = [LinearInterp(mNow[:, k, j], cNow[:, k, j]) for k in range(Mcount)] - cFunc_j = LinearInterpOnInterp1D(cFunc_by_M, Mgrid) - vPfunc_j = MargValueFuncCRRA(cFunc_j, CRRA) - cFunc_by_state.append(cFunc_j) - vPfunc_by_state.append(vPfunc_j) - - # Package and return the solution - solution_now = ConsumerSolution(cFunc=cFunc_by_state, vPfunc=vPfunc_by_state) - return solution_now - - -############################################################################### - -CRRA = 2.0 -DiscFac = 0.96 - -# Parameters for a Cobb-Douglas economy -PermGroFacAgg = 1.00 # Aggregate permanent income growth factor -PermShkAggCount = ( - 3 # Number of points in discrete approximation to aggregate permanent shock dist -) -TranShkAggCount = ( - 3 # Number of points in discrete approximation to aggregate transitory shock dist -) -PermShkAggStd = 0.0063 # Standard deviation of log aggregate permanent shocks -TranShkAggStd = 0.0031 # Standard deviation of log aggregate transitory shocks -DeprFac = 0.025 # Capital depreciation rate -CapShare = 0.36 # Capital's share of income -DiscFacPF = DiscFac # Discount factor of perfect foresight calibration -CRRAPF = CRRA # Coefficient of relative risk aversion of perfect foresight calibration -intercept_prev = 0.0 # Intercept of aggregate savings function -slope_prev = 1.0 # Slope of aggregate savings function -verbose_cobb_douglas = ( - True # Whether to print solution progress to screen while solving -) -T_discard = 200 # Number of simulated "burn in" periods to discard when updating AFunc -DampingFac = 0.5 # Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new -max_loops = 20 # Maximum number of AFunc updating loops to allow - - -# Make a dictionary to specify a Cobb-Douglas economy -init_cobb_douglas = { - "PermShkAggCount": PermShkAggCount, - "TranShkAggCount": TranShkAggCount, - "PermShkAggStd": PermShkAggStd, - "TranShkAggStd": TranShkAggStd, - "DeprFac": DeprFac, - "CapShare": CapShare, - "DiscFac": DiscFacPF, - "CRRA": CRRAPF, - "PermGroFacAgg": PermGroFacAgg, - "AggregateL": 1.0, - "intercept_prev": intercept_prev, - "slope_prev": slope_prev, - "verbose": verbose_cobb_douglas, - "T_discard": T_discard, - "DampingFac": DampingFac, - "max_loops": max_loops, -} - - - - -class CobbDouglasEconomy(Market): - """ - A class to represent an economy with a Cobb-Douglas aggregate production - function over labor and capital, extending HARK.Market. The "aggregate - market process" for this market combines all individuals' asset holdings - into aggregate capital, yielding the interest factor on assets and the wage - rate for the upcoming period. - - Note: The current implementation assumes a constant labor supply, but - this will be generalized in the future. - - Parameters - ---------- - agents : [ConsumerType] - List of types of consumers that live in this economy. - tolerance: float - Minimum acceptable distance between "dynamic rules" to consider the - solution process converged. Distance depends on intercept and slope - of the log-linear "next capital ratio" function. - act_T : int - Number of periods to simulate when making a history of of the market. - """ - - 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, "DampingFac"): - self.DampingFac = 0.5 - if not hasattr(self, "max_loops"): - self.max_loops = 20 - if not hasattr(self, "T_discard"): - self.T_discard = 200 - if not hasattr(self, "verbose"): - self.verbose = True - - - def mill_rule(self, aLvl, pLvl): - """ - Function to calculate the capital to labor ratio, interest factor, and - wage rate based on each agent's current state. Just calls calc_R_and_W(). - - See documentation for calc_R_and_W for more information. - """ - return self.calc_R_and_W(aLvl, pLvl) - - def calc_dynamics(self, MaggNow, AaggNow): - """ - Calculates a new dynamic rule for the economy: end of period savings as - a function of aggregate market resources. Just calls calc_AFunc(). - - See documentation for calc_AFunc for more information. - """ - return self.calc_AFunc(MaggNow, AaggNow) - - 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) - ) - / 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) - - def get_PermGroFacAggLR(self): - """ - A trivial function that returns self.PermGroFacAgg. Exists to be overwritten - and extended by ConsAggShockMarkov model. - - Parameters - ---------- - None - - Returns - ------- - PermGroFacAggLR : float - Long run aggregate permanent income growth, which is the same thing - as aggregate permanent income growth. - """ - return self.PermGroFacAgg - - def make_AggShkDstn(self): - """ - Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. - Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.TranShkAggDstn = MeanOneLogNormal(sigma=self.TranShkAggStd).approx( - N=self.TranShkAggCount - ) - self.PermShkAggDstn = MeanOneLogNormal(sigma=self.PermShkAggStd).approx( - N=self.PermShkAggCount - ) - self.AggShkDstn = combine_indep_dstns(self.PermShkAggDstn, self.TranShkAggDstn) - - def reset(self): - """ - Reset the economy to prepare for a new simulation. Sets the time index - of aggregate shocks to zero and runs Market.reset(). - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.Shk_idx = 0 - Market.reset(self) - - def make_AggShkHist(self): - """ - Make simulated histories of aggregate transitory and permanent shocks. - Histories are of length self.act_T, for use in the general equilibrium - simulation. - - Parameters - ---------- - None - - Returns - ------- - None - """ - sim_periods = self.act_T - Events = np.arange(self.AggShkDstn.pmf.size) # just a list of integers - EventDraws = self.AggShkDstn.draw(N=sim_periods, X=Events) - PermShkAggHist = self.AggShkDstn.X[0][EventDraws] - TranShkAggHist = self.AggShkDstn.X[1][EventDraws] - - # Store the histories - self.PermShkAggHist = PermShkAggHist * self.PermGroFacAgg - self.TranShkAggHist = TranShkAggHist - - - - def calc_R_and_W(self, aLvlNow, pLvlNow): - """ - Calculates the interest factor and wage rate this period using each agent's - capital stock to get the aggregate capital ratio. - - Parameters - ---------- - aLvlNow : [np.array] - Agents' current end-of-period assets. Elements of the list correspond - to types in the economy, entries within arrays to agents of that type. - - Returns - ------- - MaggNow : float - Aggregate market resources for this period normalized by mean permanent income - AaggNow : float - Aggregate savings for this period normalized by mean permanent income - RfreeNow : float - Interest factor on assets in the economy this period. - wRteNow : float - Wage rate for labor in the economy this period. - PermShkAggNow : float - Permanent shock to aggregate labor productivity this period. - TranShkAggNow : float - Transitory shock to aggregate labor productivity this period. - KtoLnow : float - Capital-to-labor ratio in the economy this period. - """ - # Calculate aggregate savings - AaggPrev = np.mean(np.array(aLvlNow)) / np.mean( - pLvlNow - ) # End-of-period savings from last period - # Calculate aggregate capital this period - AggregateK = np.mean(np.array(aLvlNow)) # ...becomes capital today - # This version uses end-of-period assets and - # permanent income to calculate aggregate capital, unlike the Mathematica - # version, which first applies the idiosyncratic permanent income shocks - # and then aggregates. Obviously this is mathematically equivalent. - - # Get this period's aggregate shocks - PermShkAggNow = self.PermShkAggHist[self.Shk_idx] - TranShkAggNow = self.TranShkAggHist[self.Shk_idx] - self.Shk_idx += 1 - - AggregateL = np.mean(pLvlNow) * PermShkAggNow - - # Calculate the interest factor and wage rate this period - KtoLnow = AggregateK / AggregateL - self.KtoYnow = KtoLnow ** (1.0 - self.CapShare) - RfreeNow = self.Rfunc(KtoLnow / TranShkAggNow) - wRteNow = self.wFunc(KtoLnow / TranShkAggNow) - MaggNow = KtoLnow * RfreeNow + wRteNow * TranShkAggNow - self.KtoLnow = KtoLnow # Need to store this as it is a sow variable - - # Package the results into an object and return it - return ( - MaggNow, - AaggPrev, - RfreeNow, - wRteNow, - PermShkAggNow, - TranShkAggNow, - KtoLnow, - ) - - - def calc_AFunc(self, MaggNow, AaggNow): - """ - Calculate a new aggregate savings rule based on the history - of the aggregate savings and aggregate market resources from a simulation. - - Parameters - ---------- - MaggNow : [float] - List of the history of the simulated aggregate market resources for an economy. - AaggNow : [float] - List of the history of the simulated aggregate savings for an economy. - - Returns - ------- - (unnamed) : CapDynamicRule - Object containing a new savings rule - """ - verbose = self.verbose - discard_periods = ( - self.T_discard - ) # Throw out the first T periods to allow the simulation to approach the SS - update_weight = ( - 1.0 - self.DampingFac - ) # Proportional weight to put on new function vs old function parameters - total_periods = len(MaggNow) - - # Regress the log savings against log market resources - logAagg = np.log(AaggNow[discard_periods:total_periods]) - logMagg = np.log(MaggNow[discard_periods - 1 : total_periods - 1]) - slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg, logAagg) - - # Make a new aggregate savings rule by combining the new regression parameters - # with the previous guess - intercept = ( - update_weight * intercept + (1.0 - update_weight) * self.intercept_prev - ) - slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev - AFunc = AggregateSavingRule( - intercept, slope - ) # Make a new next-period capital function - - # Save the new values as "previous" values for the next iteration - self.intercept_prev = intercept - self.slope_prev = slope - - # Print the new parameters - if verbose: - print( - "intercept=" - + str(intercept) - + ", slope=" - + str(slope) - + ", r-sq=" - + str(r_value ** 2) - ) - - return AggShocksDynamicRule(AFunc) - - - -# Make a dictionary to specify a Cobb-Douglas economy - -init_cobb_douglas_tax = init_cobb_douglas.copy() -init_cobb_douglas_tax["tax_rate"] = 0.00 - - - -class CobbDouglasEconomy_tax(CobbDouglasEconomy): - """ - A class to represent an economy with a Cobb-Douglas aggregate production - function over labor and capital, extending HARK.Market. The "aggregate - market process" for this market combines all individuals' asset holdings - into aggregate capital, yielding the interest factor on assets and the wage - rate for the upcoming period. - - Note: The current implementation assumes a constant labor supply, but - this will be generalized in the future. - - Parameters - ---------- - tax_rate: - """ - - 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) - - - - -class SmallOpenEconomy(Market): - """ - A class for representing a small open economy, where the wage rate and interest rate are - exogenously determined by some "global" rate. However, the economy is still subject to - aggregate productivity shocks. - - Parameters - ---------- - agents : [ConsumerType] - List of types of consumers that live in this economy. - tolerance: float - Minimum acceptable distance between "dynamic rules" to consider the - solution process converged. Distance depends on intercept and slope - of the log-linear "next capital ratio" function. - act_T : int - Number of periods to simulate when making a history of of the market. - """ - - def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): - agents = agents if agents is not None else list() - Market.__init__( - self, - agents=agents, - sow_vars=[ - "MaggNow", - "AaggNow", - "RfreeNow", - "wRteNow", - "PermShkAggNow", - "TranShkAggNow", - "KtoLnow", - ], - reap_vars=[], - track_vars=["MaggNow", "AaggNow", "KtoLnow"], - dyn_vars=[], - tolerance=tolerance, - act_T=act_T, - ) - self.assign_parameters(**kwds) - self.update() - - def update(self): - """ - Use primitive parameters to set basic objects. - This is an extremely stripped-down version - of update for CobbDouglasEconomy. - - Parameters - ---------- - none - - Returns - ------- - none - """ - self.kSS = 1.0 - self.MSS = 1.0 - self.sow_init["KtoLnow_init"] = self.kSS - self.Rfunc = ConstantFunction(self.Rfree) - self.wFunc = ConstantFunction(self.wRte) - self.sow_init["RfreeNow"] = self.Rfunc(self.kSS) - self.sow_init["wRteNow"] = self.wFunc(self.kSS) - self.sow_init["MaggNow"] = self.kSS - self.sow_init["AaggNow"] = self.kSS - self.sow_init["PermShkAggNow"] = 1.0 - self.sow_init["TranShkAggNow"] = 1.0 - self.make_AggShkDstn() - self.AFunc = ConstantFunction(1.0) - - def make_AggShkDstn(self): - """ - Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. - Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.TranShkAggDstn = MeanOneLogNormal(sigma=self.TranShkAggStd).approx( - N=self.TranShkAggCount - ) - self.PermShkAggDstn = MeanOneLogNormal(sigma=self.PermShkAggStd).approx( - N=self.PermShkAggCount - ) - self.AggShkDstn = combine_indep_dstns(self.PermShkAggDstn, self.TranShkAggDstn) - - def mill_rule(self): - """ - No aggregation occurs for a small open economy, because the wage and interest rates are - exogenously determined. However, aggregate shocks may occur. - - See documentation for get_AggShocks() for more information. - """ - return self.get_AggShocks() - - def calc_dynamics(self, KtoLnow): - """ - Calculates a new dynamic rule for the economy, which is just an empty object. - There is no "dynamic rule" for a small open economy, because K/L does not generate w and R. - """ - return MetricObject() - - def reset(self): - """ - Reset the economy to prepare for a new simulation. Sets the time index of aggregate shocks - to zero and runs Market.reset(). This replicates the reset method for CobbDouglasEconomy; - future version should create parent class of that class and this one. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.Shk_idx = 0 - Market.reset(self) - - def make_AggShkHist(self): - """ - Make simulated histories of aggregate transitory and permanent shocks. Histories are of - length self.act_T, for use in the general equilibrium simulation. This replicates the same - method for CobbDouglasEconomy; future version should create parent class. - - Parameters - ---------- - None - - Returns - ------- - None - """ - sim_periods = self.act_T - Events = np.arange(self.AggShkDstn.pmf.size) # just a list of integers - EventDraws = self.AggShkDstn.draw(N=sim_periods, X=Events) - PermShkAggHist = self.AggShkDstn.X[0][EventDraws] - TranShkAggHist = self.AggShkDstn.X[1][EventDraws] - - # Store the histories - self.PermShkAggHist = PermShkAggHist - self.TranShkAggHist = TranShkAggHist - - def get_AggShocks(self): - """ - Returns aggregate state variables and shocks for this period. The capital-to-labor ratio - is irrelevant and thus treated as constant, and the wage and interest rates are also - constant. However, aggregate shocks are assigned from a prespecified history. - - Parameters - ---------- - None - - Returns - ------- - MaggNow : float - Aggregate market resources for this period normalized by mean permanent income - AaggNow : float - Aggregate savings for this period normalized by mean permanent income - RfreeNow : float - Interest factor on assets in the economy this period. - wRteNow : float - Wage rate for labor in the economy this period. - PermShkAggNow : float - Permanent shock to aggregate labor productivity this period. - TranShkAggNow : float - Transitory shock to aggregate labor productivity this period. - KtoLnow : float - Capital-to-labor ratio in the economy this period. - - """ - # Get this period's aggregate shocks - PermShkAggNow = self.PermShkAggHist[self.Shk_idx] - TranShkAggNow = self.TranShkAggHist[self.Shk_idx] - self.Shk_idx += 1 - - # Factor prices are constant - RfreeNow = self.Rfunc(1.0 / PermShkAggNow) - wRteNow = self.wFunc(1.0 / PermShkAggNow) - - # Aggregates are irrelavent - AaggNow = 1.0 - MaggNow = 1.0 - KtoLnow = 1.0 / PermShkAggNow - - return ( - MaggNow, - AaggNow, - RfreeNow, - wRteNow, - PermShkAggNow, - TranShkAggNow, - KtoLnow, - ) - - -# Make a dictionary to specify a Markov Cobb-Douglas economy -init_mrkv_cobb_douglas = init_cobb_douglas.copy() -init_mrkv_cobb_douglas["PermShkAggStd"] = [0.012, 0.006] -init_mrkv_cobb_douglas["TranShkAggStd"] = [0.006, 0.003] -init_mrkv_cobb_douglas["PermGroFacAgg"] = [0.98, 1.02] -init_mrkv_cobb_douglas["MrkvArray"] = MrkvArray -init_mrkv_cobb_douglas["MrkvNow_init"] = 0 -init_mrkv_cobb_douglas["slope_prev"] = 2 * [slope_prev] -init_mrkv_cobb_douglas["intercept_prev"] = 2 * [intercept_prev] - - -class CobbDouglasMarkovEconomy(CobbDouglasEconomy): - """ - A class to represent an economy with a Cobb-Douglas aggregate production - function over labor and capital, extending HARK.Market. The "aggregate - market process" for this market combines all individuals' asset holdings - into aggregate capital, yielding the interest factor on assets and the wage - rate for the upcoming period. This small extension incorporates a Markov - state for the "macroeconomy", so that the shock distribution and aggregate - productivity growth factor can vary over time. - - Parameters - ---------- - agents : [ConsumerType] - List of types of consumers that live in this economy. - tolerance: float - Minimum acceptable distance between "dynamic rules" to consider the - solution process converged. Distance depends on intercept and slope - of the log-linear "next capital ratio" function. - act_T : int - Number of periods to simulate when making a history of of the market. - """ - - def __init__( - self, - agents=None, - tolerance=0.0001, - act_T=1200, - sow_vars=[ - "MaggNow", - "AaggNow", - "RfreeNow", - "wRteNow", - "PermShkAggNow", - "TranShkAggNow", - "KtoLnow", - "Mrkv", # This one is new - ], - **kwds - ): - agents = agents if agents is not None else list() - params = init_mrkv_cobb_douglas.copy() - params.update(kwds) - - CobbDouglasEconomy.__init__( - self, - agents=agents, - tolerance=tolerance, - act_T=act_T, - sow_vars=sow_vars, - **params - ) - - self.sow_init["Mrkv"] = params["MrkvNow_init"] - - 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 - """ - CobbDouglasEconomy.update(self) - StateCount = self.MrkvArray.shape[0] - AFunc_all = [] - for i in range(StateCount): - AFunc_all.append( - AggregateSavingRule(self.intercept_prev[i], self.slope_prev[i]) - ) - self.AFunc = AFunc_all - - def get_PermGroFacAggLR(self): - """ - Calculates and returns the long run permanent income growth factor. This - is the average growth factor in self.PermGroFacAgg, weighted by the long - run distribution of Markov states (as determined by self.MrkvArray). - - Parameters - ---------- - None - - Returns - ------- - PermGroFacAggLR : float - Long run aggregate permanent income growth factor - """ - # Find the long run distribution of Markov states - w, v = np.linalg.eig(np.transpose(self.MrkvArray)) - idx = (np.abs(w - 1.0)).argmin() - x = v[:, idx].astype(float) - LR_dstn = x / np.sum(x) - - # Return the weighted average of aggregate permanent income growth factors - PermGroFacAggLR = np.dot(LR_dstn, np.array(self.PermGroFacAgg)) - return PermGroFacAggLR - - def make_AggShkDstn(self): - """ - Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. - Draws on attributes TranShkAggStd, PermShkAddStd, TranShkAggCount, PermShkAggCount. - This version accounts for the Markov macroeconomic state. - - Parameters - ---------- - None - - Returns - ------- - None - """ - TranShkAggDstn = [] - PermShkAggDstn = [] - AggShkDstn = [] - StateCount = self.MrkvArray.shape[0] - - for i in range(StateCount): - TranShkAggDstn.append( - MeanOneLogNormal(sigma=self.TranShkAggStd[i]).approx( - N=self.TranShkAggCount - ) - ) - PermShkAggDstn.append( - MeanOneLogNormal(sigma=self.PermShkAggStd[i]).approx( - N=self.PermShkAggCount - ) - ) - AggShkDstn.append(combine_indep_dstns(PermShkAggDstn[-1], TranShkAggDstn[-1])) - - self.TranShkAggDstn = TranShkAggDstn - self.PermShkAggDstn = PermShkAggDstn - self.AggShkDstn = AggShkDstn - - def make_AggShkHist(self): - """ - Make simulated histories of aggregate transitory and permanent shocks. - Histories are of length self.act_T, for use in the general equilibrium - simulation. Draws on history of aggregate Markov states generated by - internal call to make_Mrkv_history(). - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.make_Mrkv_history() # Make a (pseudo)random sequence of Markov states - sim_periods = self.act_T - - # For each Markov state in each simulated period, draw the aggregate shocks - # that would occur in that state in that period - StateCount = self.MrkvArray.shape[0] - PermShkAggHistAll = np.zeros((StateCount, sim_periods)) - TranShkAggHistAll = np.zeros((StateCount, sim_periods)) - for i in range(StateCount): - AggShockDraws = self.AggShkDstn[i].draw(N=sim_periods) - PermShkAggHistAll[i, :] = AggShockDraws[0, :] - TranShkAggHistAll[i, :] = AggShockDraws[1, :] - - # Select the actual history of aggregate shocks based on the sequence - # of Markov states that the economy experiences - PermShkAggHist = np.zeros(sim_periods) - TranShkAggHist = np.zeros(sim_periods) - for i in range(StateCount): - these = i == self.MrkvNow_hist - PermShkAggHist[these] = PermShkAggHistAll[i, these] * self.PermGroFacAgg[i] - TranShkAggHist[these] = TranShkAggHistAll[i, these] - - # Store the histories - self.PermShkAggHist = PermShkAggHist - self.TranShkAggHist = TranShkAggHist - - def make_Mrkv_history(self): - """ - Makes a history of macroeconomic Markov states, stored in the attribute - MrkvNow_hist. This version ensures that each state is reached a sufficient - number of times to have a valid sample for calc_dynamics to produce a good - dynamic rule. It will sometimes cause act_T to be increased beyond its - initially specified level. - - Parameters - ---------- - None - - Returns - ------- - None - """ - if hasattr(self, "loops_max"): - loops_max = self.loops_max - else: # Maximum number of loops; final act_T never exceeds act_T*loops_max - loops_max = 10 - - state_T_min = 50 # Choose minimum number of periods in each state for a valid Markov sequence - logit_scale = ( - 0.2 # Scaling factor on logit choice shocks when jumping to a new state - ) - # Values close to zero make the most underrepresented states very likely to visit, while - # large values of logit_scale make any state very likely to be jumped to. - - # Reset act_T to the level actually specified by the user - if hasattr(self, "act_T_orig"): - act_T = self.act_T_orig - else: # Or store it for the first time - self.act_T_orig = self.act_T - act_T = self.act_T - - # Find the long run distribution of Markov states - w, v = np.linalg.eig(np.transpose(self.MrkvArray)) - idx = (np.abs(w - 1.0)).argmin() - x = v[:, idx].astype(float) - LR_dstn = x / np.sum(x) - - # Initialize the Markov history and set up transitions - MrkvNow_hist = np.zeros(self.act_T_orig, dtype=int) - loops = 0 - go = True - MrkvNow = self.sow_init["Mrkv"] - t = 0 - StateCount = self.MrkvArray.shape[0] - - # Add histories until each state has been visited at least state_T_min times - while go: - draws = Uniform(seed=loops).draw(N=self.act_T_orig) - markov_process = MarkovProcess(self.MrkvArray,seed=loops) - for s in range(self.act_T_orig): # Add act_T_orig more periods - MrkvNow_hist[t] = MrkvNow - MrkvNow = markov_process.draw(MrkvNow) - t += 1 - - # Calculate the empirical distribution - state_T = np.zeros(StateCount) - for i in range(StateCount): - state_T[i] = np.sum(MrkvNow_hist == i) - - # Check whether each state has been visited state_T_min times - if np.all(state_T >= state_T_min): - go = False # If so, terminate the loop - continue - - # Choose an underrepresented state to "jump" to - if np.any( - state_T == 0 - ): # If any states have *never* been visited, randomly choose one of those - never_visited = np.where(np.array(state_T == 0))[0] - MrkvNow = np.random.choice(never_visited) - else: # Otherwise, use logit choice probabilities to visit an underrepresented state - emp_dstn = state_T / act_T - ratios = LR_dstn / emp_dstn - ratios_adj = ratios - np.max(ratios) - ratios_exp = np.exp(ratios_adj / logit_scale) - ratios_sum = np.sum(ratios_exp) - jump_probs = ratios_exp / ratios_sum - cum_probs = np.cumsum(jump_probs) - MrkvNow = np.searchsorted(cum_probs, draws[-1]) - - loops += 1 - # Make the Markov state history longer by act_T_orig periods - if loops >= loops_max: - go = False - print( - "make_Mrkv_history reached maximum number of loops without generating a valid sequence!" - ) - else: - MrkvNow_new = np.zeros(self.act_T_orig, dtype=int) - MrkvNow_hist = np.concatenate((MrkvNow_hist, MrkvNow_new)) - act_T += self.act_T_orig - - # Store the results as attributes of self - self.MrkvNow_hist = MrkvNow_hist - self.act_T = act_T - - def mill_rule(self, aLvl, pLvl): - """ - Function to calculate the capital to labor ratio, interest factor, and - wage rate based on each agent's current state. Just calls calc_R_and_W() - and adds the Markov state index. - - See documentation for calc_R_and_W for more information. - - Params - ------- - aLvl : float - pLvl : float - - Returns - ------- - Mnow : float - Aggregate market resources for this period. - Aprev : float - Aggregate savings for the prior period. - KtoLnow : float - Capital-to-labor ratio in the economy this period. - Rnow : float - Interest factor on assets in the economy this period. - Wnow : float - Wage rate for labor in the economy this period. - MrkvNow : int - Binary indicator for bad (0) or good (1) macroeconomic state. - """ - MrkvNow = self.MrkvNow_hist[self.Shk_idx] - temp = self.calc_R_and_W(aLvl, pLvl) - - return temp + (MrkvNow,) - - def calc_AFunc(self, MaggNow, AaggNow): - """ - Calculate a new aggregate savings rule based on the history of the - aggregate savings and aggregate market resources from a simulation. - Calculates an aggregate saving rule for each macroeconomic Markov state. - - Parameters - ---------- - MaggNow : [float] - List of the history of the simulated aggregate market resources for an economy. - AaggNow : [float] - List of the history of the simulated aggregate savings for an economy. - - Returns - ------- - (unnamed) : CapDynamicRule - Object containing new saving rules for each Markov state. - """ - verbose = self.verbose - discard_periods = ( - self.T_discard - ) # Throw out the first T periods to allow the simulation to approach the SS - update_weight = ( - 1.0 - self.DampingFac - ) # Proportional weight to put on new function vs old function parameters - total_periods = len(MaggNow) - - # Trim the histories of M_t and A_t and convert them to logs - logAagg = np.log(AaggNow[discard_periods:total_periods]) - logMagg = np.log(MaggNow[discard_periods - 1 : total_periods - 1]) - MrkvHist = self.MrkvNow_hist[discard_periods - 1 : total_periods - 1] - - # For each Markov state, regress A_t on M_t and update the saving rule - AFunc_list = [] - rSq_list = [] - for i in range(self.MrkvArray.shape[0]): - these = i == MrkvHist - slope, intercept, r_value, p_value, std_err = stats.linregress( - logMagg[these], logAagg[these] - ) - - # Make a new aggregate savings rule by combining the new regression parameters - # with the previous guess - intercept = ( - update_weight * intercept - + (1.0 - update_weight) * self.intercept_prev[i] - ) - slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev[i] - AFunc_list.append( - AggregateSavingRule(intercept, slope) - ) # Make a new next-period capital function - rSq_list.append(r_value ** 2) - - # Save the new values as "previous" values for the next iteration - self.intercept_prev[i] = intercept - self.slope_prev[i] = slope - - # Print the new parameters - if verbose: - print( - "intercept=" - + str(self.intercept_prev) - + ", slope=" - + str(self.slope_prev) - + ", r-sq=" - + str(rSq_list) - ) - - return AggShocksDynamicRule(AFunc_list) - - -class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy, SmallOpenEconomy): - """ - A class for representing a small open economy, where the wage rate and interest rate are - exogenously determined by some "global" rate. However, the economy is still subject to - aggregate productivity shocks. This version supports a discrete Markov state. All - methods in this class inherit from the two parent classes. - """ - - def __init__(self, agents=None, tolerance=0.0001, act_T=1000, **kwds): - agents = agents if agents is not None else list() - CobbDouglasMarkovEconomy.__init__( - self, agents=agents, tolerance=tolerance, act_T=act_T, **kwds - ) - self.reap_vars = [] - self.dyn_vars = [] - - def update(self): - SmallOpenEconomy.update(self) - StateCount = self.MrkvArray.shape[0] - self.AFunc = StateCount * [IdentityFunction()] - - def make_AggShkDstn(self): - CobbDouglasMarkovEconomy.make_AggShkDstn(self) - - def mill_rule(self): - MrkvNow = self.MrkvNow_hist[self.Shk_idx] - temp = SmallOpenEconomy.get_AggShocks(self) - temp(MrkvNow=MrkvNow) - return temp - - def calc_dynamics(self, KtoLnow): - return MetricObject() - - def make_AggShkHist(self): - CobbDouglasMarkovEconomy.make_AggShkHist(self) - - -init_KS_economy = { - "verbose": True, - "act_T": 11000, - "T_discard": 1000, - "DampingFac": 0.5, - "intercept_prev": [0.0, 0.0], - "slope_prev": [1.0, 1.0], - "DiscFac": 0.99, - "CRRA": 1.0, - "LbrInd": 0.3271, # Not listed in KS (1998), but Alan Lujan got this number indirectly from KS - "ProdB": 0.99, - "ProdG": 1.01, - "CapShare": 0.36, - "DeprFac": 0.025, - "DurMeanB": 8.0, - "DurMeanG": 8.0, - "SpellMeanB": 2.5, - "SpellMeanG": 1.5, - "UrateB": 0.10, - "UrateG": 0.04, - "RelProbBG": 0.75, - "RelProbGB": 1.25, - "MrkvNow_init": 0, -} - - -class KrusellSmithEconomy(Market): - """ - A class to represent an economy in the special Krusell-Smith (1998) model. - This model replicates the one presented in the JPE article "Income and Wealth - Heterogeneity in the Macroeconomy", with its default parameters set to match - those in the paper. - - Parameters - ---------- - agents : [ConsumerType] - List of types of consumers that live in this economy. - tolerance: float - Minimum acceptable distance between "dynamic rules" to consider the - solution process converged. Distance depends on intercept and slope - of the log-linear "next capital ratio" function. - act_T : int - Number of periods to simulate when making a history of of the market. - """ - - def __init__(self, agents=None, tolerance=0.0001, **kwds): - agents = agents if agents is not None else list() - params = deepcopy(init_KS_economy) - params.update(kwds) - - Market.__init__( - self, - agents=agents, - tolerance=tolerance, - sow_vars=["Mnow", "Aprev", "Mrkv", "Rnow", "Wnow"], - reap_vars=["aNow", "EmpNow"], - track_vars=["Mrkv", "Aprev", "Mnow", "Urate"], - dyn_vars=["AFunc"], - **params - ) - self.update() - - def update(self): - """ - Construct trivial initial guesses of the aggregate saving rules, as well - as the perfect foresight steady state and associated objects. - """ - StateCount = 2 - AFunc_all = [ - AggregateSavingRule(self.intercept_prev[j], self.slope_prev[j]) - for j in range(StateCount) - ] - self.AFunc = AFunc_all - self.KtoLSS = ( - (1.0 ** self.CRRA / self.DiscFac - (1.0 - self.DeprFac)) / self.CapShare - ) ** (1.0 / (self.CapShare - 1.0)) - self.KSS = self.KtoLSS * self.LbrInd - self.KtoYSS = self.KtoLSS ** (1.0 - self.CapShare) - self.WSS = (1.0 - self.CapShare) * self.KtoLSS ** (self.CapShare) - self.RSS = ( - 1.0 + self.CapShare * self.KtoLSS ** (self.CapShare - 1.0) - self.DeprFac - ) - self.MSS = self.KSS * self.RSS + self.WSS * self.LbrInd - self.convertKtoY = lambda KtoY: KtoY ** ( - 1.0 / (1.0 - self.CapShare) - ) # converts K/Y to K/L - self.rFunc = lambda k: self.CapShare * k ** (self.CapShare - 1.0) - self.Wfunc = lambda k: ((1.0 - self.CapShare) * k ** (self.CapShare)) - self.sow_init["KtoLnow"] = self.KtoLSS - self.sow_init["Mnow"] = self.MSS - self.sow_init["Aprev"] = self.KSS - self.sow_init["Rnow"] = self.RSS - self.sow_init["Wnow"] = self.WSS - self.PermShkAggNow_init = 1.0 - self.TranShkAggNow_init = 1.0 - self.sow_init["Mrkv"] = 0 - self.make_MrkvArray() - - def reset(self): - """ - Reset the economy to prepare for a new simulation. Sets the time index - of aggregate shocks to zero and runs Market.reset(). - """ - self.Shk_idx = 0 - Market.reset(self) - - def make_MrkvArray(self): - """ - Construct the attributes MrkvAggArray and MrkvIndArray from the primitive - attributes DurMeanB, DurMeanG, SpellMeanB, SpellMeanG, UrateB, UrateG, - RelProbGB, and RelProbBG. - """ - # Construct aggregate Markov transition probabilities - ProbBG = 1.0 / self.DurMeanB - ProbGB = 1.0 / self.DurMeanG - ProbBB = 1.0 - ProbBG - ProbGG = 1.0 - ProbGB - MrkvAggArray = np.array([[ProbBB, ProbBG], [ProbGB, ProbGG]]) - - # Construct idiosyncratic Markov transition probabilities - # ORDER: BU, BE, GU, GE - MrkvIndArray = np.zeros((4, 4)) - - # BAD-BAD QUADRANT - MrkvIndArray[0, 1] = ProbBB * 1.0 / self.SpellMeanB - MrkvIndArray[0, 0] = ProbBB * (1 - 1.0 / self.SpellMeanB) - MrkvIndArray[1, 0] = self.UrateB / (1.0 - self.UrateB) * MrkvIndArray[0, 1] - MrkvIndArray[1, 1] = ProbBB - MrkvIndArray[1, 0] - - # GOOD-GOOD QUADRANT - MrkvIndArray[2, 3] = ProbGG * 1.0 / self.SpellMeanG - MrkvIndArray[2, 2] = ProbGG * (1 - 1.0 / self.SpellMeanG) - MrkvIndArray[3, 2] = self.UrateG / (1.0 - self.UrateG) * MrkvIndArray[2, 3] - MrkvIndArray[3, 3] = ProbGG - MrkvIndArray[3, 2] - - # BAD-GOOD QUADRANT - MrkvIndArray[0, 2] = self.RelProbBG * MrkvIndArray[2, 2] / ProbGG * ProbBG - MrkvIndArray[0, 3] = ProbBG - MrkvIndArray[0, 2] - MrkvIndArray[1, 2] = ( - ProbBG * self.UrateG - self.UrateB * MrkvIndArray[0, 2] - ) / (1.0 - self.UrateB) - MrkvIndArray[1, 3] = ProbBG - MrkvIndArray[1, 2] - - # GOOD-BAD QUADRANT - MrkvIndArray[2, 0] = self.RelProbGB * MrkvIndArray[0, 0] / ProbBB * ProbGB - MrkvIndArray[2, 1] = ProbGB - MrkvIndArray[2, 0] - MrkvIndArray[3, 0] = ( - ProbGB * self.UrateB - self.UrateG * MrkvIndArray[2, 0] - ) / (1.0 - self.UrateG) - MrkvIndArray[3, 1] = ProbGB - MrkvIndArray[3, 0] - - # Test for valid idiosyncratic transition probabilities - assert np.all( - MrkvIndArray >= 0.0 - ), "Invalid idiosyncratic transition probabilities!" - self.MrkvArray = MrkvAggArray - self.MrkvIndArray = MrkvIndArray - - def make_Mrkv_history(self): - """ - Makes a history of macroeconomic Markov states, stored in the attribute - MrkvNow_hist. This variable is binary (0 bad, 1 good) in the KS model. - """ - # Initialize the Markov history and set up transitions - self.MrkvNow_hist = np.zeros(self.act_T, dtype=int) - MrkvNow = self.MrkvNow_init - - markov_process = MarkovProcess(self.MrkvArray, seed= 0) - for s in range(self.act_T): # Add act_T_orig more periods - self.MrkvNow_hist[s] = MrkvNow - MrkvNow = markov_process.draw(MrkvNow) - - - def mill_rule(self, aNow, EmpNow): - """ - Method to calculate the capital to labor ratio, interest factor, and - wage rate based on each agent's current state. Just calls calc_R_and_W(). - - See documentation for calc_R_and_W for more information. - - Returns - ------- - Mnow : float - Aggregate market resources for this period. - Aprev : float - Aggregate savings for the prior period. - MrkvNow : int - Binary indicator for bad (0) or good (1) macroeconomic state. - Rnow : float - Interest factor on assets in the economy this period. - Wnow : float - Wage rate for labor in the economy this period. - """ - - return self.calc_R_and_W(aNow, EmpNow) - - def calc_dynamics(self, Mnow, Aprev): - """ - Method to update perceptions of the aggregate saving rule in each - macroeconomic state; just calls calc_AFunc. - """ - return self.calc_AFunc(Mnow, Aprev) - - def calc_R_and_W(self, aNow, EmpNow): - """ - Calculates the interest factor and wage rate this period using each agent's - capital stock to get the aggregate capital ratio. - - Parameters - ---------- - aNow : [np.array] - Agents' current end-of-period assets. Elements of the list correspond - to types in the economy, entries within arrays to agents of that type. - EmpNow [np.array] - Agents' binary employment states. Not actually used in computation of - interest and wage rates, but stored in the history to verify that the - idiosyncratic unemployment probabilities are behaving as expected. - - Returns - ------- - Mnow : float - Aggregate market resources for this period. - Aprev : float - Aggregate savings for the prior period. - MrkvNow : int - Binary indicator for bad (0) or good (1) macroeconomic state. - Rnow : float - Interest factor on assets in the economy this period. - Wnow : float - Wage rate for labor in the economy this period. - """ - # Calculate aggregate savings - Aprev = np.mean(np.array(aNow)) # End-of-period savings from last period - # Calculate aggregate capital this period - AggK = Aprev # ...becomes capital today - - # Calculate unemployment rate - Urate = 1.0 - np.mean(np.array(EmpNow)) - self.Urate = Urate # This is the unemployment rate for the *prior* period - - # Get this period's TFP and labor supply - MrkvNow = self.MrkvNow_hist[self.Shk_idx] - if MrkvNow == 0: - Prod = self.ProdB - AggL = (1.0 - self.UrateB) * self.LbrInd - elif MrkvNow == 1: - Prod = self.ProdG - AggL = (1.0 - self.UrateG) * self.LbrInd - self.Shk_idx += 1 - - # Calculate the interest factor and wage rate this period - KtoLnow = AggK / AggL - Rnow = 1.0 + Prod * self.rFunc(KtoLnow) - self.DeprFac - Wnow = Prod * self.Wfunc(KtoLnow) - Mnow = Rnow * AggK + Wnow * AggL - self.KtoLnow = KtoLnow # Need to store this as it is a sow variable - - # Returns a tuple of these values - return Mnow, Aprev, MrkvNow, Rnow, Wnow - - def calc_AFunc(self, Mnow, Aprev): - """ - Calculate a new aggregate savings rule based on the history of the - aggregate savings and aggregate market resources from a simulation. - Calculates an aggregate saving rule for each macroeconomic Markov state. - - Parameters - ---------- - Mnow : [float] - List of the history of the simulated aggregate market resources for an economy. - Anow : [float] - List of the history of the simulated aggregate savings for an economy. - - Returns - ------- - (unnamed) : CapDynamicRule - Object containing new saving rules for each Markov state. - """ - verbose = self.verbose - discard_periods = ( - self.T_discard - ) # Throw out the first T periods to allow the simulation to approach the SS - update_weight = ( - 1.0 - self.DampingFac - ) # Proportional weight to put on new function vs old function parameters - total_periods = len(Mnow) - - # Trim the histories of M_t and A_t and convert them to logs - logAagg = np.log(Aprev[discard_periods:total_periods]) - logMagg = np.log(Mnow[discard_periods - 1 : total_periods - 1]) - MrkvHist = self.MrkvNow_hist[discard_periods - 1 : total_periods - 1] - - # For each Markov state, regress A_t on M_t and update the saving rule - AFunc_list = [] - rSq_list = [] - for i in range(self.MrkvArray.shape[0]): - these = i == MrkvHist - slope, intercept, r_value, p_value, std_err = stats.linregress( - logMagg[these], logAagg[these] - ) - - # Make a new aggregate savings rule by combining the new regression parameters - # with the previous guess - intercept = ( - update_weight * intercept - + (1.0 - update_weight) * self.intercept_prev[i] - ) - slope = update_weight * slope + (1.0 - update_weight) * self.slope_prev[i] - AFunc_list.append( - AggregateSavingRule(intercept, slope) - ) # Make a new next-period capital function - rSq_list.append(r_value ** 2) - - # Save the new values as "previous" values for the next iteration - self.intercept_prev[i] = intercept - self.slope_prev[i] = slope - - # Print the new parameters - if verbose: - print( - "intercept=" - + str(self.intercept_prev) - + ", slope=" - + str(self.slope_prev) - + ", r-sq=" - + str(rSq_list) - ) - - return AggShocksDynamicRule(AFunc_list) - - -class AggregateSavingRule(MetricObject): - """ - A class to represent agent beliefs about aggregate saving at the end of this period (AaggNow) as - a function of (normalized) aggregate market resources at the beginning of the period (MaggNow). - - Parameters - ---------- - intercept : float - Intercept of the log-linear capital evolution rule. - slope : float - Slope of the log-linear capital evolution rule. - """ - - def __init__(self, intercept, slope): - self.intercept = intercept - self.slope = slope - self.distance_criteria = ["slope", "intercept"] - - def __call__(self, Mnow): - """ - Evaluates aggregate savings as a function of the aggregate market resources this period. - - Parameters - ---------- - Mnow : float - Aggregate market resources this period. - - Returns - ------- - Aagg : Expected aggregate savings this period. - """ - Aagg = np.exp(self.intercept + self.slope * np.log(Mnow)) - return Aagg - - -class AggShocksDynamicRule(MetricObject): - """ - Just a container class for passing the dynamic rule in the aggregate shocks model to agents. - - Parameters - ---------- - AFunc : CapitalEvoRule - Aggregate savings as a function of aggregate market resources. - """ - - def __init__(self, AFunc): - self.AFunc = AFunc - self.distance_criteria = ["AFunc"] diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py index e1646571..a50d7cd4 100644 --- a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py +++ b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py @@ -99,6 +99,8 @@ def __init__(self, **kwds): AggShockConsumerType. Sets appropriate solver and input lists. """ + self.vFunc = None + params = init_agg_shocks_tax.copy() params.update(kwds) @@ -106,28 +108,9 @@ def __init__(self, **kwds): self.add_to_time_inv("tax_rate") - self.solve_one_period = solveConsAggShock + self.solve_one_period = solveConsAggShock_tax self.update() - # def get_shocks(self): - # """ - # Same as in AggShockConsumerType, but with transitory income shocks decreased by the tax rate. - # - # Parameters - # ---------- - # None - # - # Returns - # ------- - # None - # """ - # IndShockConsumerType.get_shocks(self) # Update idiosyncratic shocks - # self.shocks['TranShk'] = ( - # self.shocks['TranShk'] * self.TranShkAggNow * self.wRteNow - # ) - # self.shocks['PermShk'] = self.shocks['PermShk'] * self.PermShkAggNow - - def transition(self): """" Same as in AggShockConsumerType, but with flat income tax and lump-sum transfers @@ -168,6 +151,242 @@ def calc_transfers(self): transfers = taxrevenue * (1 - 0.05) 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() @@ -175,18 +394,13 @@ def calc_transfers(self): class CobbDouglasEconomy_tax(CobbDouglasEconomy): """ - A class to represent an economy with a Cobb-Douglas aggregate production - function over labor and capital, extending HARK.Market. The "aggregate - market process" for this market combines all individuals' asset holdings - into aggregate capital, yielding the interest factor on assets and the wage - rate for the upcoming period. - - Note: The current implementation assumes a constant labor supply, but - this will be generalized in the future. - - Parameters + 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: + tax_rate: float [0,1] """ def __init__(self, agents=None, tolerance=0.0001, act_T=1200, **kwds): diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index ab2a2a34..41260277 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -201,9 +201,15 @@ "source": [ "import HARK\n", "import sys\n", - "from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, CobbDouglasEconomy)\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 (AggShockConsumerType_tax, CobbDouglasEconomy_tax)\n", + "\n", + "from ConsAggShockModel_tax import *\n", + "# import ConsAggShockModel_tax\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -371,14 +377,14 @@ "output_type": "stream", "text": [ "Now solving for the equilibrium of a Cobb-Douglas economy. This might take a few minutes...\n", - "intercept=-0.41054440806001213, slope=1.1255917552697523, r-sq=0.8751220283100425\n", - "intercept=-0.5773773336944878, slope=1.1758308616806987, r-sq=0.7832480696460751\n", - "intercept=-0.6143577175394329, slope=1.176935454341733, r-sq=0.7775438351465409\n", - "intercept=-0.600736339017846, slope=1.1626718040790442, r-sq=0.7970695854316202\n", - "intercept=-0.5690387254827874, slope=1.144596971056191, r-sq=0.8063777583962061\n", - "intercept=-0.5468314979996045, slope=1.1330227287075485, r-sq=0.8063809444926031\n", - "intercept=-0.5361412473190589, slope=1.127502039450247, r-sq=0.8088097539216077\n", - "intercept=-0.5311542259396478, slope=1.1249304315188215, r-sq=0.8099901725510609\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" ] } ], @@ -415,7 +421,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -451,7 +457,6 @@ "execution_count": 8, "id": "3141f9c5", "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false }, @@ -469,7 +474,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -517,8 +522,8 @@ "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.209977576559044; the standard deviation is 4.400319630466247; the median is 16.418608939597988.\n", - "The mean of individual wealth is 14.981784923214564; the standard deviation is 4.153142622717666; the median is 14.23444667903301.\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" ] } @@ -551,7 +556,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -603,14 +608,16 @@ "cell_type": "code", "execution_count": 11, "id": "8615e5e7-338b-4219-a563-22409e5d0c5b", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.0\n", "The mean of individual market resources is 3.375362172060929; the standard deviation is 1.4259230889521275; the median is 3.4263567807499244.\n", "The mean of individual wealth is 1.6152166383978621; the standard deviation is 1.1373366189717646; the median is 1.5973516839615254.\n", @@ -619,8 +626,8 @@ "The market resources of the median agent is 3.4264, \n", " and the value function for the median-wealth voter at tax rate 0.0000 is -0.1802. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.08110787241333293\n", "The mean of individual market resources is 3.30973484275261; the standard deviation is 1.3377244879603751; the median is 3.3693657351839854.\n", "The mean of individual wealth is 1.556438903761209; the standard deviation is 1.0639438888899186; the median is 1.5509309897522723.\n", @@ -629,8 +636,8 @@ "The market resources of the median agent is 3.3694, \n", " and the value function for the median-wealth voter at tax rate 0.0500 is -0.1846. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.16200780821136587\n", "The mean of individual market resources is 3.246673866636698; the standard deviation is 1.2520229927395188; the median is 3.3121183901728566.\n", "The mean of individual wealth is 1.5002526337341997; the standard deviation is 0.9929035918870248; the median is 1.5043015329549145.\n", @@ -639,8 +646,8 @@ "The market resources of the median agent is 3.3121, \n", " and the value function for the median-wealth voter at tax rate 0.1000 is -0.1890. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.24271391541611823\n", "The mean of individual market resources is 3.1862828615693752; the standard deviation is 1.168962166474006; the median is 3.2599266750250537.\n", "The mean of individual wealth is 1.447124303151485; the standard deviation is 0.9235623554628882; the median is 1.4619065950416985.\n", @@ -649,8 +656,8 @@ "The market resources of the median agent is 3.2599, \n", " and the value function for the median-wealth voter at tax rate 0.1500 is -0.1935. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.323242175823087\n", "The mean of individual market resources is 3.128825931710148; the standard deviation is 1.0875222965598483; the median is 3.2089354374967316.\n", "The mean of individual wealth is 1.3967319396276536; the standard deviation is 0.856063635366787; the median is 1.421066631614395.\n", @@ -659,8 +666,8 @@ "The market resources of the median agent is 3.2089, \n", " and the value function for the median-wealth voter at tax rate 0.2000 is -0.1981. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.40360485629261217\n", "The mean of individual market resources is 3.07393519696484; the standard deviation is 1.008347389535206; the median is 3.1599702422309206.\n", "The mean of individual wealth is 1.348727844891705; the standard deviation is 0.7909224641555209; the median is 1.3822909271162092.\n", @@ -669,8 +676,8 @@ "The market resources of the median agent is 3.1600, \n", " and the value function for the median-wealth voter at tax rate 0.2500 is -0.2028. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.48381901664775584\n", "The mean of individual market resources is 3.021939153897076; the standard deviation is 0.9308118958455757; the median is 3.1123073181313043.\n", "The mean of individual wealth is 1.303351396879359; the standard deviation is 0.7276814207959237; the median is 1.3445554595844542.\n", @@ -679,8 +686,8 @@ "The market resources of the median agent is 3.1123, \n", " and the value function for the median-wealth voter at tax rate 0.3000 is -0.2074. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.5638962650656257\n", "The mean of individual market resources is 2.972537878019223; the standard deviation is 0.8547369801052926; the median is 3.0584366817672937.\n", "The mean of individual wealth is 1.2603246492264513; the standard deviation is 0.6661794316634178; the median is 1.3019052511083558.\n", @@ -689,8 +696,8 @@ "The market resources of the median agent is 3.0584, \n", " and the value function for the median-wealth voter at tax rate 0.3500 is -0.2129. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.6438478874783078\n", "The mean of individual market resources is 2.9255583363848894; the standard deviation is 0.7803144004751789; the median is 3.0054928143252972.\n", "The mean of individual wealth is 1.2196091096449893; the standard deviation is 0.606333217089106; the median is 1.2599887797922569.\n", @@ -699,8 +706,8 @@ "The market resources of the median agent is 3.0055, \n", " and the value function for the median-wealth voter at tax rate 0.4000 is -0.2183. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.7236851242592217\n", "The mean of individual market resources is 2.8809012749374263; the standard deviation is 0.7077378310325457; the median is 2.956161355805598.\n", "The mean of individual wealth is 1.1812726415471329; the standard deviation is 0.5481037226319276; the median is 1.2209323079867593.\n", @@ -709,8 +716,8 @@ "The market resources of the median agent is 2.9562, \n", " and the value function for the median-wealth voter at tax rate 0.4500 is -0.2235. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.8034210360557753\n", "The mean of individual market resources is 2.838609761062614; the standard deviation is 0.6366522892047719; the median is 2.9130137756022285.\n", "The mean of individual wealth is 1.1451538268900965; the standard deviation is 0.4916602363506698; the median is 1.1867717074236241.\n", @@ -719,8 +726,14 @@ "The market resources of the median agent is 2.9130, \n", " and the value function for the median-wealth voter at tax rate 0.5000 is -0.2282. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.8830690706795172\n", "The mean of individual market resources is 2.7987308377426485; the standard deviation is 0.5669560252924258; the median is 2.8728163545868233.\n", "The mean of individual wealth is 1.1111850978846975; the standard deviation is 0.4365733784929202; the median is 1.1549467931062227.\n", @@ -729,8 +742,8 @@ "The market resources of the median agent is 2.8728, \n", " and the value function for the median-wealth voter at tax rate 0.5500 is -0.2327. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 0.962642905712668\n", "The mean of individual market resources is 2.761306448547628; the standard deviation is 0.49887367155268225; the median is 2.8327661123090184.\n", "The mean of individual wealth is 1.0795317262763333; the standard deviation is 0.3831093614174129; the median is 1.1232384024511646.\n", @@ -739,8 +752,8 @@ "The market resources of the median agent is 2.8328, \n", " and the value function for the median-wealth voter at tax rate 0.6000 is -0.2377. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.0421487412559023\n", "The mean of individual market resources is 2.7260404831100815; the standard deviation is 0.43186109416598456; the median is 2.7938732035092264.\n", "The mean of individual wealth is 1.049937019896209; the standard deviation is 0.33062122613343714; the median is 1.0931465191989214.\n", @@ -749,8 +762,8 @@ "The market resources of the median agent is 2.7939, \n", " and the value function for the median-wealth voter at tax rate 0.6500 is -0.2427. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.121600099657847\n", "The mean of individual market resources is 2.6930167672331202; the standard deviation is 0.3661997508951041; the median is 2.755504621852627.\n", "The mean of individual wealth is 1.0224886887816542; the standard deviation is 0.27935478620487086; the median is 1.0641344919259825.\n", @@ -759,8 +772,8 @@ "The market resources of the median agent is 2.7555, \n", " and the value function for the median-wealth voter at tax rate 0.7000 is -0.2479. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.2010022594379157\n", "The mean of individual market resources is 2.661986177298545; the standard deviation is 0.3017720534853086; the median is 2.7179561053238777.\n", "The mean of individual wealth is 0.9970310684195496; the standard deviation is 0.2295028302673594; the median is 1.0357425488685024.\n", @@ -769,8 +782,8 @@ "The market resources of the median agent is 2.7180, \n", " and the value function for the median-wealth voter at tax rate 0.7500 is -0.2530. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.2803630006666817\n", "The mean of individual market resources is 2.6328500972210453; the standard deviation is 0.23857079928341574; the median is 2.6811030255663866.\n", "The mean of individual wealth is 0.9734673583559486; the standard deviation is 0.18084029906989046; the median is 1.0078764535151385.\n", @@ -779,8 +792,8 @@ "The market resources of the median agent is 2.6811, \n", " and the value function for the median-wealth voter at tax rate 0.8000 is -0.2582. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.3596960073172408\n", "The mean of individual market resources is 2.6057291292873526; the standard deviation is 0.17688282902136962; the median is 2.6440079967422445.\n", "The mean of individual wealth is 0.9517781407121343; the standard deviation is 0.13356511804653823; the median is 0.9798274107444546.\n", @@ -789,8 +802,8 @@ "The market resources of the median agent is 2.6440, \n", " and the value function for the median-wealth voter at tax rate 0.8500 is -0.2634. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.4390209077517238\n", "The mean of individual market resources is 2.5809033838648774; the standard deviation is 0.11653107959120272; the median is 2.6070662834442087.\n", "The mean of individual wealth is 0.9323428488168439; the standard deviation is 0.08782708639327413; the median is 0.9518942960074035.\n", @@ -799,8 +812,8 @@ "The market resources of the median agent is 2.6071, \n", " and the value function for the median-wealth voter at tax rate 0.9000 is -0.2688. \n", "\n", - "intercept=-0.5288444895735469, slope=1.1237386173871755, r-sq=0.810535437461125\n", - "intercept=-0.5277773305948628, slope=1.123187165460313, r-sq=0.8107863137511149\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5277773305948623, slope=1.1231871654603125, r-sq=0.8107863137511139\n", "The lump-sum transfer in terms of permanent income is: 1.5183703433420366\n", "The mean of individual market resources is 2.5589804659305084; the standard deviation is 0.05764036899369175; the median is 2.5724961701970654.\n", "The mean of individual wealth is 0.9155420032979318; the standard deviation is 0.04356736107282193; the median is 0.9257544434235597.\n", @@ -856,8 +869,6 @@ "\n", " v_at_median_wealth.append(v_at_median_wealth_tau)\n", "\n", - " print(EconomyExample_tau.tax_rate, EconomyExample_tau.kSS)\n", - "\n", " print(\"The market resources of the median agent is \"\n", " + str(mystr(sim_median_market_resources_tau)) + \", \\n and the value function for the median-wealth voter at tax rate \"\n", " + str(mystr(AggShockAgent_tax_tau.tax_rate))\n", @@ -898,7 +909,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -934,7 +945,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/REMARKs/KRR99/requirements.txt b/REMARKs/KRR99/requirements.txt index 23c949b7..fd4bc7c5 100644 --- a/REMARKs/KRR99/requirements.txt +++ b/REMARKs/KRR99/requirements.txt @@ -1,4 +1,4 @@ -hark == 0.12 +econ-ark == 0.12 matplotlib numpy ipywidgets From 3ba1733cd07678224f547e2cd46e59e8aff3fec0 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Mon, 23 May 2022 11:52:11 +0900 Subject: [PATCH 5/9] Edit Files 20220523 --- REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 627 +++++++++++++++++++--- REMARKs/KRR99/readme.txt | 1 - 2 files changed, 566 insertions(+), 62 deletions(-) diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index 41260277..df4a985e 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -207,9 +207,7 @@ " AggregateSavingRule\n", ")\n", "\n", - "\n", "from ConsAggShockModel_tax import *\n", - "# import ConsAggShockModel_tax\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -251,7 +249,7 @@ " \"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 - no shocks of this kind!\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 - 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", @@ -369,6 +367,7 @@ "execution_count": 6, "id": "71c66623-6ff5-485a-8815-431c2be0764a", "metadata": { + "scrolled": true, "tags": [] }, "outputs": [ @@ -506,7 +505,7 @@ } }, "source": [ - "Summary Statistics for Agents' Wealth and Income" + "Summary Statistics for Agents' Wealth and Income " ] }, { @@ -548,6 +547,14 @@ "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 does not seem to generate enough wealth inequality, as seen by the graph of the Lorenz curve of the wealth distribution below:" + ] + }, { "cell_type": "code", "execution_count": 10, @@ -556,7 +563,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -568,7 +575,7 @@ } ], "source": [ - "# Lorenz Curve of Wealth Distribution: So far, the model does not seem to generate enough wealth inequality:\n", + "# 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", @@ -579,6 +586,7 @@ "\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", @@ -618,207 +626,187 @@ "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.0\n", "The mean of individual market resources is 3.375362172060929; the standard deviation is 1.4259230889521275; the median is 3.4263567807499244.\n", "The mean of individual wealth is 1.6152166383978621; the standard deviation is 1.1373366189717646; the median is 1.5973516839615254.\n", - "The median level of market resources is: 3.4263567807499244\n", - "0.0 13.943289665216982\n", "The market resources of the median agent is 3.4264, \n", " and the value function for the median-wealth voter at tax rate 0.0000 is -0.1802. \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.08110787241333293\n", "The mean of individual market resources is 3.30973484275261; the standard deviation is 1.3377244879603751; the median is 3.3693657351839854.\n", "The mean of individual wealth is 1.556438903761209; the standard deviation is 1.0639438888899186; the median is 1.5509309897522723.\n", - "The median level of market resources is: 3.3693657351839854\n", - "0.049999999999999996 13.943289665216982\n", "The market resources of the median agent is 3.3694, \n", " and the value function for the median-wealth voter at tax rate 0.0500 is -0.1846. \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.16200780821136587\n", "The mean of individual market resources is 3.246673866636698; the standard deviation is 1.2520229927395188; the median is 3.3121183901728566.\n", "The mean of individual wealth is 1.5002526337341997; the standard deviation is 0.9929035918870248; the median is 1.5043015329549145.\n", - "The median level of market resources is: 3.3121183901728566\n", - "0.09999999999999999 13.943289665216982\n", "The market resources of the median agent is 3.3121, \n", " and the value function for the median-wealth voter at tax rate 0.1000 is -0.1890. \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.24271391541611823\n", "The mean of individual market resources is 3.1862828615693752; the standard deviation is 1.168962166474006; the median is 3.2599266750250537.\n", "The mean of individual wealth is 1.447124303151485; the standard deviation is 0.9235623554628882; the median is 1.4619065950416985.\n", - "The median level of market resources is: 3.2599266750250537\n", - "0.15 13.943289665216982\n", "The market resources of the median agent is 3.2599, \n", " and the value function for the median-wealth voter at tax rate 0.1500 is -0.1935. \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.323242175823087\n", "The mean of individual market resources is 3.128825931710148; the standard deviation is 1.0875222965598483; the median is 3.2089354374967316.\n", "The mean of individual wealth is 1.3967319396276536; the standard deviation is 0.856063635366787; the median is 1.421066631614395.\n", - "The median level of market resources is: 3.2089354374967316\n", - "0.19999999999999998 13.943289665216982\n", "The market resources of the median agent is 3.2089, \n", " and the value function for the median-wealth voter at tax rate 0.2000 is -0.1981. \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.40360485629261217\n", "The mean of individual market resources is 3.07393519696484; the standard deviation is 1.008347389535206; the median is 3.1599702422309206.\n", "The mean of individual wealth is 1.348727844891705; the standard deviation is 0.7909224641555209; the median is 1.3822909271162092.\n", - "The median level of market resources is: 3.1599702422309206\n", - "0.24999999999999997 13.943289665216982\n", "The market resources of the median agent is 3.1600, \n", " and the value function for the median-wealth voter at tax rate 0.2500 is -0.2028. \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.48381901664775584\n", "The mean of individual market resources is 3.021939153897076; the standard deviation is 0.9308118958455757; the median is 3.1123073181313043.\n", "The mean of individual wealth is 1.303351396879359; the standard deviation is 0.7276814207959237; the median is 1.3445554595844542.\n", - "The median level of market resources is: 3.1123073181313043\n", - "0.3 13.943289665216982\n", "The market resources of the median agent is 3.1123, \n", " and the value function for the median-wealth voter at tax rate 0.3000 is -0.2074. \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.5638962650656257\n", "The mean of individual market resources is 2.972537878019223; the standard deviation is 0.8547369801052926; the median is 3.0584366817672937.\n", "The mean of individual wealth is 1.2603246492264513; the standard deviation is 0.6661794316634178; the median is 1.3019052511083558.\n", - "The median level of market resources is: 3.0584366817672937\n", - "0.35 13.943289665216982\n", "The market resources of the median agent is 3.0584, \n", " and the value function for the median-wealth voter at tax rate 0.3500 is -0.2129. \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.6438478874783078\n", "The mean of individual market resources is 2.9255583363848894; the standard deviation is 0.7803144004751789; the median is 3.0054928143252972.\n", "The mean of individual wealth is 1.2196091096449893; the standard deviation is 0.606333217089106; the median is 1.2599887797922569.\n", - "The median level of market resources is: 3.0054928143252972\n", - "0.39999999999999997 13.943289665216982\n", "The market resources of the median agent is 3.0055, \n", " and the value function for the median-wealth voter at tax rate 0.4000 is -0.2183. \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.4500\n", "The lump-sum transfer in terms of permanent income is: 0.7236851242592217\n", "The mean of individual market resources is 2.8809012749374263; the standard deviation is 0.7077378310325457; the median is 2.956161355805598.\n", "The mean of individual wealth is 1.1812726415471329; the standard deviation is 0.5481037226319276; the median is 1.2209323079867593.\n", - "The median level of market resources is: 2.956161355805598\n", - "0.44999999999999996 13.943289665216982\n", "The market resources of the median agent is 2.9562, \n", " and the value function for the median-wealth voter at tax rate 0.4500 is -0.2235. \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.8034210360557753\n", "The mean of individual market resources is 2.838609761062614; the standard deviation is 0.6366522892047719; the median is 2.9130137756022285.\n", "The mean of individual wealth is 1.1451538268900965; the standard deviation is 0.4916602363506698; the median is 1.1867717074236241.\n", - "The median level of market resources is: 2.9130137756022285\n", - "0.49999999999999994 13.943289665216982\n", "The market resources of the median agent is 2.9130, \n", " and the value function for the median-wealth voter at tax rate 0.5000 is -0.2282. \n", "\n", - "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\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.5500\n", "The lump-sum transfer in terms of permanent income is: 0.8830690706795172\n", "The mean of individual market resources is 2.7987308377426485; the standard deviation is 0.5669560252924258; the median is 2.8728163545868233.\n", "The mean of individual wealth is 1.1111850978846975; the standard deviation is 0.4365733784929202; the median is 1.1549467931062227.\n", - "The median level of market resources is: 2.8728163545868233\n", - "0.5499999999999999 13.943289665216982\n", "The market resources of the median agent is 2.8728, \n", " and the value function for the median-wealth voter at tax rate 0.5500 is -0.2327. \n", "\n", - "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "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: 0.962642905712668\n", "The mean of individual market resources is 2.761306448547628; the standard deviation is 0.49887367155268225; the median is 2.8327661123090184.\n", "The mean of individual wealth is 1.0795317262763333; the standard deviation is 0.3831093614174129; the median is 1.1232384024511646.\n", - "The median level of market resources is: 2.8327661123090184\n", - "0.6 13.943289665216982\n", "The market resources of the median agent is 2.8328, \n", " and the value function for the median-wealth voter at tax rate 0.6000 is -0.2377. \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.0421487412559023\n", "The mean of individual market resources is 2.7260404831100815; the standard deviation is 0.43186109416598456; the median is 2.7938732035092264.\n", "The mean of individual wealth is 1.049937019896209; the standard deviation is 0.33062122613343714; the median is 1.0931465191989214.\n", - "The median level of market resources is: 2.7938732035092264\n", - "0.6499999999999999 13.943289665216982\n", "The market resources of the median agent is 2.7939, \n", " and the value function for the median-wealth voter at tax rate 0.6500 is -0.2427. \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.121600099657847\n", "The mean of individual market resources is 2.6930167672331202; the standard deviation is 0.3661997508951041; the median is 2.755504621852627.\n", "The mean of individual wealth is 1.0224886887816542; the standard deviation is 0.27935478620487086; the median is 1.0641344919259825.\n", - "The median level of market resources is: 2.755504621852627\n", - "0.7 13.943289665216982\n", "The market resources of the median agent is 2.7555, \n", " and the value function for the median-wealth voter at tax rate 0.7000 is -0.2479. \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.2010022594379157\n", "The mean of individual market resources is 2.661986177298545; the standard deviation is 0.3017720534853086; the median is 2.7179561053238777.\n", "The mean of individual wealth is 0.9970310684195496; the standard deviation is 0.2295028302673594; the median is 1.0357425488685024.\n", - "The median level of market resources is: 2.7179561053238777\n", - "0.7499999999999999 13.943289665216982\n", "The market resources of the median agent is 2.7180, \n", " and the value function for the median-wealth voter at tax rate 0.7500 is -0.2530. \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.2803630006666817\n", "The mean of individual market resources is 2.6328500972210453; the standard deviation is 0.23857079928341574; the median is 2.6811030255663866.\n", "The mean of individual wealth is 0.9734673583559486; the standard deviation is 0.18084029906989046; the median is 1.0078764535151385.\n", - "The median level of market resources is: 2.6811030255663866\n", - "0.7999999999999999 13.943289665216982\n", "The market resources of the median agent is 2.6811, \n", " and the value function for the median-wealth voter at tax rate 0.8000 is -0.2582. \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.3596960073172408\n", "The mean of individual market resources is 2.6057291292873526; the standard deviation is 0.17688282902136962; the median is 2.6440079967422445.\n", "The mean of individual wealth is 0.9517781407121343; the standard deviation is 0.13356511804653823; the median is 0.9798274107444546.\n", - "The median level of market resources is: 2.6440079967422445\n", - "0.85 13.943289665216982\n", "The market resources of the median agent is 2.6440, \n", " and the value function for the median-wealth voter at tax rate 0.8500 is -0.2634. \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.9000\n", "The lump-sum transfer in terms of permanent income is: 1.4390209077517238\n", "The mean of individual market resources is 2.5809033838648774; the standard deviation is 0.11653107959120272; the median is 2.6070662834442087.\n", "The mean of individual wealth is 0.9323428488168439; the standard deviation is 0.08782708639327413; the median is 0.9518942960074035.\n", - "The median level of market resources is: 2.6070662834442087\n", - "0.8999999999999999 13.943289665216982\n", "The market resources of the median agent is 2.6071, \n", " and the value function for the median-wealth voter at tax rate 0.9000 is -0.2688. \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.5183703433420366\n", "The mean of individual market resources is 2.5589804659305084; the standard deviation is 0.05764036899369175; the median is 2.5724961701970654.\n", "The mean of individual wealth is 0.9155420032979318; the standard deviation is 0.04356736107282193; the median is 0.9257544434235597.\n", - "The median level of market resources is: 2.5724961701970654\n", - "0.95 13.943289665216982\n", "The market resources of the median agent is 2.5725, \n", " and the value function for the median-wealth voter at tax rate 0.9500 is -0.2740. \n", "\n" @@ -827,11 +815,10 @@ ], "source": [ "rates = 20\n", - "tax_rates = np.linspace(0.00, 0.95, num=rates)\n", - "v_at_median_wealth = []\n", + "tax_rates = np.linspace(0.00, 0.95, num=rates) # Each tax rate from 0.00, 0.05, 0.10, ... , 0.95\n", + "v_at_median_wealth = [] # Vector for value function of median 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", @@ -841,13 +828,15 @@ " AggShockAgent_tax_tau.solve()\n", " AggShockAgent_tax_tau.initialize_sim()\n", " AggShockAgent_tax_tau.simulate()\n", - " AggShockAgent_tax_tau.track_vars = ['aNrm','pLvl','mNrm','cNrm','TranShk']\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: \" + str(AggShockAgent_tax_tau.calc_transfers()))\n", "\n", " print(\"The mean of individual market resources is \" + str(sim_market_resources_tau.mean()) + \"; the standard deviation is \"\n", @@ -855,8 +844,6 @@ " print(\"The mean of individual wealth is \" + str(sim_wealth_tau.mean()) + \"; the standard deviation is \"\n", " + str(sim_wealth_tau.std()) + \"; the median is \" + str(np.median(sim_wealth_tau)) + \".\")\n", "\n", - " print(\"The median level of market resources is: \" + str(np.median(AggShockAgent_tax_tau.state_now['mNrm'])))\n", - "\n", " # Tax rate as determined by median agent (pre-tax)'s wealth and income\n", " sim_median_wealth_tau = np.median(sim_wealth_tau)\n", " sim_median_market_resources_tau = np.median(sim_market_resources_tau)\n", @@ -870,7 +857,8 @@ " v_at_median_wealth.append(v_at_median_wealth_tau)\n", "\n", " print(\"The market resources of the median agent is \"\n", - " + str(mystr(sim_median_market_resources_tau)) + \", \\n and the value function for the median-wealth voter at tax rate \"\n", + " + str(mystr(sim_median_market_resources_tau)) \n", + " + \", \\n and the value function for the median-wealth voter at tax rate \"\n", " + str(mystr(AggShockAgent_tax_tau.tax_rate))\n", " + \" is \" + str(mystr(v_at_median_wealth_tau)) + \". \\n\")" ] @@ -927,6 +915,523 @@ "plt.ylabel('Value function of median wealth agent')\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "9e14a0e8-efab-4647-850e-a8909e965d09", + "metadata": {}, + "source": [ + "### So far, the problem is that median wealth is greater than mean 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": "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 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.0811\n", + "The mean of individual wealth is 1.5564; the standard deviation is 1.0639438888899186; the median is 1.5509.\n", + "The mean of individual market resources is 3.3097; the standard deviation is 1.3377244879603751; the median is 3.3694.\n", + "The 90th percentile of individual wealth is 3.0308.\n", + "The 80th percentile of individual wealth is 2.4744.\n", + "The 70th percentile of individual wealth is 1.9491.\n", + "The 60th percentile of individual wealth is 1.7425.\n", + "The 40th percentile of individual wealth is 1.0392.\n", + "The 30th percentile of individual wealth is 0.8120.\n", + "The 20th percentile of individual wealth is 0.5807.\n", + "The 10th percentile of individual wealth is 0.3985.\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.1620\n", + "The mean of individual wealth is 1.5003; the standard deviation is 0.9929035918870248; the median is 1.5043.\n", + "The mean of individual market resources is 3.2467; the standard deviation is 1.2520229927395188; the median is 3.3121.\n", + "The 90th percentile of individual wealth is 2.8697.\n", + "The 80th percentile of individual wealth is 2.3182.\n", + "The 70th percentile of individual wealth is 1.8833.\n", + "The 60th percentile of individual wealth is 1.6912.\n", + "The 40th percentile of individual wealth is 1.0218.\n", + "The 30th percentile of individual wealth is 0.8140.\n", + "The 20th percentile of individual wealth is 0.5916.\n", + "The 10th percentile of individual wealth is 0.4145.\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.2427\n", + "The mean of individual wealth is 1.4471; the standard deviation is 0.9235623554628882; the median is 1.4619.\n", + "The mean of individual market resources is 3.1863; the standard deviation is 1.168962166474006; the median is 3.2599.\n", + "The 90th percentile of individual wealth is 2.7158.\n", + "The 80th percentile of individual wealth is 2.1776.\n", + "The 70th percentile of individual wealth is 1.8193.\n", + "The 60th percentile of individual wealth is 1.6405.\n", + "The 40th percentile of individual wealth is 1.0059.\n", + "The 30th percentile of individual wealth is 0.8092.\n", + "The 20th percentile of individual wealth is 0.6035.\n", + "The 10th percentile of individual wealth is 0.4331.\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.3232\n", + "The mean of individual wealth is 1.3967; the standard deviation is 0.856063635366787; the median is 1.4211.\n", + "The mean of individual market resources is 3.1288; the standard deviation is 1.0875222965598483; the median is 3.2089.\n", + "The 90th percentile of individual wealth is 2.5645.\n", + "The 80th percentile of individual wealth is 2.0467.\n", + "The 70th percentile of individual wealth is 1.7570.\n", + "The 60th percentile of individual wealth is 1.5891.\n", + "The 40th percentile of individual wealth is 0.9908.\n", + "The 30th percentile of individual wealth is 0.8041.\n", + "The 20th percentile of individual wealth is 0.6184.\n", + "The 10th percentile of individual wealth is 0.4288.\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.4036\n", + "The mean of individual wealth is 1.3487; the standard deviation is 0.7909224641555209; the median is 1.3823.\n", + "The mean of individual market resources is 3.0739; the standard deviation is 1.008347389535206; the median is 3.1600.\n", + "The 90th percentile of individual wealth is 2.4291.\n", + "The 80th percentile of individual wealth is 1.9366.\n", + "The 70th percentile of individual wealth is 1.6949.\n", + "The 60th percentile of individual wealth is 1.5377.\n", + "The 40th percentile of individual wealth is 0.9764.\n", + "The 30th percentile of individual wealth is 0.8004.\n", + "The 20th percentile of individual wealth is 0.6332.\n", + "The 10th percentile of individual wealth is 0.4201.\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.4838\n", + "The mean of individual wealth is 1.3034; the standard deviation is 0.7276814207959237; the median is 1.3446.\n", + "The mean of individual market resources is 3.0219; the standard deviation is 0.9308118958455757; the median is 3.1123.\n", + "The 90th percentile of individual wealth is 2.2938.\n", + "The 80th percentile of individual wealth is 1.8543.\n", + "The 70th percentile of individual wealth is 1.6298.\n", + "The 60th percentile of individual wealth is 1.4840.\n", + "The 40th percentile of individual wealth is 0.9637.\n", + "The 30th percentile of individual wealth is 0.7987.\n", + "The 20th percentile of individual wealth is 0.6481.\n", + "The 10th percentile of individual wealth is 0.4303.\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.5639\n", + "The mean of individual wealth is 1.2603; the standard deviation is 0.6661794316634178; the median is 1.3019.\n", + "The mean of individual market resources is 2.9725; the standard deviation is 0.8547369801052926; the median is 3.0584.\n", + "The 90th percentile of individual wealth is 2.1641.\n", + "The 80th percentile of individual wealth is 1.7748.\n", + "The 70th percentile of individual wealth is 1.5639.\n", + "The 60th percentile of individual wealth is 1.4315.\n", + "The 40th percentile of individual wealth is 0.9540.\n", + "The 30th percentile of individual wealth is 0.7982.\n", + "The 20th percentile of individual wealth is 0.6564.\n", + "The 10th percentile of individual wealth is 0.4476.\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.6438\n", + "The mean of individual wealth is 1.2196; the standard deviation is 0.606333217089106; the median is 1.2600.\n", + "The mean of individual market resources is 2.9256; the standard deviation is 0.7803144004751789; the median is 3.0055.\n", + "The 90th percentile of individual wealth is 2.0408.\n", + "The 80th percentile of individual wealth is 1.6976.\n", + "The 70th percentile of individual wealth is 1.5006.\n", + "The 60th percentile of individual wealth is 1.3810.\n", + "The 40th percentile of individual wealth is 0.9458.\n", + "The 30th percentile of individual wealth is 0.7990.\n", + "The 20th percentile of individual wealth is 0.6715.\n", + "The 10th percentile of individual wealth is 0.4671.\n", + "\n", + "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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.7237\n", + "The mean of individual wealth is 1.1813; the standard deviation is 0.5481037226319276; the median is 1.2209.\n", + "The mean of individual market resources is 2.8809; the standard deviation is 0.7077378310325457; the median is 2.9562.\n", + "The 90th percentile of individual wealth is 1.9194.\n", + "The 80th percentile of individual wealth is 1.6157.\n", + "The 70th percentile of individual wealth is 1.4403.\n", + "The 60th percentile of individual wealth is 1.3318.\n", + "The 40th percentile of individual wealth is 0.9391.\n", + "The 30th percentile of individual wealth is 0.8013.\n", + "The 20th percentile of individual wealth is 0.6871.\n", + "The 10th percentile of individual wealth is 0.4883.\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.8034\n", + "The mean of individual wealth is 1.1452; the standard deviation is 0.4916602363506698; the median is 1.1868.\n", + "The mean of individual market resources is 2.8386; the standard deviation is 0.6366522892047719; the median is 2.9130.\n", + "The 90th percentile of individual wealth is 1.8022.\n", + "The 80th percentile of individual wealth is 1.5227.\n", + "The 70th percentile of individual wealth is 1.3822.\n", + "The 60th percentile of individual wealth is 1.2842.\n", + "The 40th percentile of individual wealth is 0.9326.\n", + "The 30th percentile of individual wealth is 0.8047.\n", + "The 20th percentile of individual wealth is 0.7002.\n", + "The 10th percentile of individual wealth is 0.5163.\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.8831\n", + "The mean of individual wealth is 1.1112; the standard deviation is 0.4365733784929202; the median is 1.1549.\n", + "The mean of individual market resources is 2.7987; the standard deviation is 0.5669560252924258; the median is 2.8728.\n", + "The 90th percentile of individual wealth is 1.6927.\n", + "The 80th percentile of individual wealth is 1.4483.\n", + "The 70th percentile of individual wealth is 1.3212.\n", + "The 60th percentile of individual wealth is 1.2380.\n", + "The 40th percentile of individual wealth is 0.9266.\n", + "The 30th percentile of individual wealth is 0.8091.\n", + "The 20th percentile of individual wealth is 0.7138.\n", + "The 10th percentile of individual wealth is 0.5489.\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: 0.9626\n", + "The mean of individual wealth is 1.0795; the standard deviation is 0.3831093614174129; the median is 1.1232.\n", + "The mean of individual market resources is 2.7613; the standard deviation is 0.49887367155268225; the median is 2.8328.\n", + "The 90th percentile of individual wealth is 1.5876.\n", + "The 80th percentile of individual wealth is 1.3739.\n", + "The 70th percentile of individual wealth is 1.2602.\n", + "The 60th percentile of individual wealth is 1.1935.\n", + "The 40th percentile of individual wealth is 0.9212.\n", + "The 30th percentile of individual wealth is 0.8146.\n", + "The 20th percentile of individual wealth is 0.7312.\n", + "The 10th percentile of individual wealth is 0.5823.\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.0421\n", + "The mean of individual wealth is 1.0499; the standard deviation is 0.33062122613343714; the median is 1.0931.\n", + "The mean of individual market resources is 2.7260; the standard deviation is 0.43186109416598456; the median is 2.7939.\n", + "The 90th percentile of individual wealth is 1.4846.\n", + "The 80th percentile of individual wealth is 1.3030.\n", + "The 70th percentile of individual wealth is 1.2037.\n", + "The 60th percentile of individual wealth is 1.1518.\n", + "The 40th percentile of individual wealth is 0.9172.\n", + "The 30th percentile of individual wealth is 0.8214.\n", + "The 20th percentile of individual wealth is 0.7485.\n", + "The 10th percentile of individual wealth is 0.6182.\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.1216\n", + "The mean of individual wealth is 1.0225; the standard deviation is 0.27935478620487086; the median is 1.0641.\n", + "The mean of individual market resources is 2.6930; the standard deviation is 0.3661997508951041; the median is 2.7555.\n", + "The 90th percentile of individual wealth is 1.3868.\n", + "The 80th percentile of individual wealth is 1.2383.\n", + "The 70th percentile of individual wealth is 1.1551.\n", + "The 60th percentile of individual wealth is 1.1122.\n", + "The 40th percentile of individual wealth is 0.9139.\n", + "The 30th percentile of individual wealth is 0.8307.\n", + "The 20th percentile of individual wealth is 0.7671.\n", + "The 10th percentile of individual wealth is 0.6569.\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.2010\n", + "The mean of individual wealth is 0.9970; the standard deviation is 0.2295028302673594; the median is 1.0357.\n", + "The mean of individual market resources is 2.6620; the standard deviation is 0.3017720534853086; the median is 2.7180.\n", + "The 90th percentile of individual wealth is 1.2969.\n", + "The 80th percentile of individual wealth is 1.1760.\n", + "The 70th percentile of individual wealth is 1.1076.\n", + "The 60th percentile of individual wealth is 1.0739.\n", + "The 40th percentile of individual wealth is 0.9108.\n", + "The 30th percentile of individual wealth is 0.8409.\n", + "The 20th percentile of individual wealth is 0.7872.\n", + "The 10th percentile of individual wealth is 0.6963.\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.2804\n", + "The mean of individual wealth is 0.9735; the standard deviation is 0.18084029906989046; the median is 1.0079.\n", + "The mean of individual market resources is 2.6329; the standard deviation is 0.23857079928341574; the median is 2.6811.\n", + "The 90th percentile of individual wealth is 1.2083.\n", + "The 80th percentile of individual wealth is 1.1155.\n", + "The 70th percentile of individual wealth is 1.0622.\n", + "The 60th percentile of individual wealth is 1.0367.\n", + "The 40th percentile of individual wealth is 0.9080.\n", + "The 30th percentile of individual wealth is 0.8517.\n", + "The 20th percentile of individual wealth is 0.8079.\n", + "The 10th percentile of individual wealth is 0.7358.\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.3597\n", + "The mean of individual wealth is 0.9518; the standard deviation is 0.13356511804653823; the median is 0.9798.\n", + "The mean of individual market resources is 2.6057; the standard deviation is 0.17688282902136962; the median is 2.6440.\n", + "The 90th percentile of individual wealth is 1.1215.\n", + "The 80th percentile of individual wealth is 1.0583.\n", + "The 70th percentile of individual wealth is 1.0191.\n", + "The 60th percentile of individual wealth is 1.0001.\n", + "The 40th percentile of individual wealth is 0.9045.\n", + "The 30th percentile of individual wealth is 0.8630.\n", + "The 20th percentile of individual wealth is 0.8285.\n", + "The 10th percentile of individual wealth is 0.7754.\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.9000\n", + "The lump-sum transfer in terms of permanent income is: 1.4390\n", + "The mean of individual wealth is 0.9323; the standard deviation is 0.08782708639327413; the median is 0.9519.\n", + "The mean of individual market resources is 2.5809; the standard deviation is 0.11653107959120272; the median is 2.6071.\n", + "The 90th percentile of individual wealth is 1.0448.\n", + "The 80th percentile of individual wealth is 1.0019.\n", + "The 70th percentile of individual wealth is 0.9774.\n", + "The 60th percentile of individual wealth is 0.9653.\n", + "The 40th percentile of individual wealth is 0.9016.\n", + "The 30th percentile of individual wealth is 0.8749.\n", + "The 20th percentile of individual wealth is 0.8500.\n", + "The 10th percentile of individual wealth is 0.8142.\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.9500\n", + "The lump-sum transfer in terms of permanent income is: 1.5184\n", + "The mean of individual wealth is 0.9155; the standard deviation is 0.04356736107282193; the median is 0.9258.\n", + "The mean of individual market resources is 2.5590; the standard deviation is 0.05764036899369175; the median is 2.5725.\n", + "The 90th percentile of individual wealth is 0.9699.\n", + "The 80th percentile of individual wealth is 0.9502.\n", + "The 70th percentile of individual wealth is 0.9380.\n", + "The 60th percentile of individual wealth is 0.9321.\n", + "The 40th percentile of individual wealth is 0.9006.\n", + "The 30th percentile of individual wealth is 0.8875.\n", + "The 20th percentile of individual wealth is 0.8747.\n", + "The 10th percentile of individual wealth is 0.8562.\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", + "\n", + "\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", + " #print(sim_wealth_tau)\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)) + \".\")# + \"; the standard deviation is \")\n", + " print(\"The 60th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,60)) + \".\")\n", + " print(\"The 40th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,40)) + \".\")# + \"; the standard deviation is \")\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_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 median wealth agent/voter\n", + " # vFunc arguments: Median 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_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_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": 15, + "id": "29ebd769-075f-45a9-af40-23fcabd8b2d1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(9,5))\n", + "plt.plot(tax_rates, v_at_p90_wealth, 'r--', label = 'Value function of p40 wealth agent')\n", + "plt.plot(tax_rates, v_at_p80_wealth, 'g--', label = 'Value function of p30 wealth agent')\n", + "plt.plot(tax_rates, v_at_p70_wealth, 'b--', label = 'Value function of p20 wealth agent')\n", + "plt.plot(tax_rates, v_at_p60_wealth, 'y--', label = 'Value function of p10 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": "code", + "execution_count": 16, + "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.0000.\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). 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.\n", + "\n", + "In this simulation, we find that the bottom 30th percent of voters would vote for (nearly) full redistribution, whereas the rest would vote for zero redistribution. This would lead to a politically determined tax rate of 0\\%." + ] } ], "metadata": { diff --git a/REMARKs/KRR99/readme.txt b/REMARKs/KRR99/readme.txt index ac0ac522..c35c5034 100644 --- a/REMARKs/KRR99/readme.txt +++ b/REMARKs/KRR99/readme.txt @@ -5,6 +5,5 @@ by Kyung Woong Koh (180.604 Advanced Macro II Spring 2022) Contents: code/python: Contains python notebook for Krusell and Rios-Rull (1999) - - ConsAggShockModel.py: ConsAggShockModel with new classes (AggShockConsumerType_tax, CobbDouglasEconomy_tax) that incorporate flat income tax rate and lump-sum transfers - 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 From d7112299c385de0f2b4396e82c77c46c0e52d31d Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Tue, 24 May 2022 10:31:31 +0900 Subject: [PATCH 6/9] 20220524 Edit --- .../code/python/ConsAggShockModel_tax.py | 2 +- REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 936 +++++++----------- 2 files changed, 382 insertions(+), 556 deletions(-) diff --git a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py index a50d7cd4..380dbf57 100644 --- a/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py +++ b/REMARKs/KRR99/code/python/ConsAggShockModel_tax.py @@ -148,7 +148,7 @@ def calc_transfers(self): # 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 * (1 - 0.05) + transfers = taxrevenue return transfers def update_solution_terminal(self): diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index df4a985e..c289615b 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -6,9 +6,10 @@ "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\", AER 89 (5) p.1156-1181, 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 17, 2022)" + "### Kyung Woong Koh (May 24, 2022)" ] }, { @@ -166,7 +167,7 @@ "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)
\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)

" ] }, @@ -176,8 +177,8 @@ "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", + "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" ] }, @@ -187,7 +188,8 @@ "metadata": {}, "source": [ "**Stumbling Blocks:**\n", - "1. *Updating agents' asset levels after taxes and transfers*: I tried multiplying the transitory income shock with (1-tax_rate), but then I had difficulty in locating exactly which part of the code updates individuals' asset levels (aLvl) or normalized asset levels (aNrm). So far, the asset levels (and therefore aggregate capital stock) of the agents are exactly the same for each level of tax rate. Once I figure this part out, the value function for the median agent in each tax rate would be accurate, and hopefully show that the median (wealth) agent's value function is maximized at some middle tax rate between 0 (no redistribution and no distortive taxation) and 1 (total redistribution and totally distortive taxation)" + "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." ] }, { @@ -229,7 +231,7 @@ } }, "source": [ - "I first set the parameters for each agent as follows, with the addition of a flat income tax rate (`tax_rate`):" + "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`):" ] }, { @@ -319,7 +321,7 @@ } }, "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" + "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" ] }, { @@ -552,7 +554,7 @@ "id": "47704b66", "metadata": {}, "source": [ - "So far, the model does not seem to generate enough wealth inequality, as seen by the graph of the Lorenz curve of the wealth distribution below:" + "So far, the model generatse far too little wealth inequality, as seen by the graph of the Lorenz curve of the wealth distribution below:" ] }, { @@ -603,7 +605,7 @@ } }, "source": [ - "The method for determining the optimal tax rate for the median voter is as follows:\n", + "### 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", @@ -612,323 +614,19 @@ "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": "code", - "execution_count": 11, - "id": "8615e5e7-338b-4219-a563-22409e5d0c5b", - "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.0\n", - "The mean of individual market resources is 3.375362172060929; the standard deviation is 1.4259230889521275; the median is 3.4263567807499244.\n", - "The mean of individual wealth is 1.6152166383978621; the standard deviation is 1.1373366189717646; the median is 1.5973516839615254.\n", - "The market resources of the median agent is 3.4264, \n", - " and the value function for the median-wealth voter at tax rate 0.0000 is -0.1802. \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.08110787241333293\n", - "The mean of individual market resources is 3.30973484275261; the standard deviation is 1.3377244879603751; the median is 3.3693657351839854.\n", - "The mean of individual wealth is 1.556438903761209; the standard deviation is 1.0639438888899186; the median is 1.5509309897522723.\n", - "The market resources of the median agent is 3.3694, \n", - " and the value function for the median-wealth voter at tax rate 0.0500 is -0.1846. \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.16200780821136587\n", - "The mean of individual market resources is 3.246673866636698; the standard deviation is 1.2520229927395188; the median is 3.3121183901728566.\n", - "The mean of individual wealth is 1.5002526337341997; the standard deviation is 0.9929035918870248; the median is 1.5043015329549145.\n", - "The market resources of the median agent is 3.3121, \n", - " and the value function for the median-wealth voter at tax rate 0.1000 is -0.1890. \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.24271391541611823\n", - "The mean of individual market resources is 3.1862828615693752; the standard deviation is 1.168962166474006; the median is 3.2599266750250537.\n", - "The mean of individual wealth is 1.447124303151485; the standard deviation is 0.9235623554628882; the median is 1.4619065950416985.\n", - "The market resources of the median agent is 3.2599, \n", - " and the value function for the median-wealth voter at tax rate 0.1500 is -0.1935. \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.323242175823087\n", - "The mean of individual market resources is 3.128825931710148; the standard deviation is 1.0875222965598483; the median is 3.2089354374967316.\n", - "The mean of individual wealth is 1.3967319396276536; the standard deviation is 0.856063635366787; the median is 1.421066631614395.\n", - "The market resources of the median agent is 3.2089, \n", - " and the value function for the median-wealth voter at tax rate 0.2000 is -0.1981. \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.40360485629261217\n", - "The mean of individual market resources is 3.07393519696484; the standard deviation is 1.008347389535206; the median is 3.1599702422309206.\n", - "The mean of individual wealth is 1.348727844891705; the standard deviation is 0.7909224641555209; the median is 1.3822909271162092.\n", - "The market resources of the median agent is 3.1600, \n", - " and the value function for the median-wealth voter at tax rate 0.2500 is -0.2028. \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.48381901664775584\n", - "The mean of individual market resources is 3.021939153897076; the standard deviation is 0.9308118958455757; the median is 3.1123073181313043.\n", - "The mean of individual wealth is 1.303351396879359; the standard deviation is 0.7276814207959237; the median is 1.3445554595844542.\n", - "The market resources of the median agent is 3.1123, \n", - " and the value function for the median-wealth voter at tax rate 0.3000 is -0.2074. \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.5638962650656257\n", - "The mean of individual market resources is 2.972537878019223; the standard deviation is 0.8547369801052926; the median is 3.0584366817672937.\n", - "The mean of individual wealth is 1.2603246492264513; the standard deviation is 0.6661794316634178; the median is 1.3019052511083558.\n", - "The market resources of the median agent is 3.0584, \n", - " and the value function for the median-wealth voter at tax rate 0.3500 is -0.2129. \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.6438478874783078\n", - "The mean of individual market resources is 2.9255583363848894; the standard deviation is 0.7803144004751789; the median is 3.0054928143252972.\n", - "The mean of individual wealth is 1.2196091096449893; the standard deviation is 0.606333217089106; the median is 1.2599887797922569.\n", - "The market resources of the median agent is 3.0055, \n", - " and the value function for the median-wealth voter at tax rate 0.4000 is -0.2183. \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.4500\n", - "The lump-sum transfer in terms of permanent income is: 0.7236851242592217\n", - "The mean of individual market resources is 2.8809012749374263; the standard deviation is 0.7077378310325457; the median is 2.956161355805598.\n", - "The mean of individual wealth is 1.1812726415471329; the standard deviation is 0.5481037226319276; the median is 1.2209323079867593.\n", - "The market resources of the median agent is 2.9562, \n", - " and the value function for the median-wealth voter at tax rate 0.4500 is -0.2235. \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.8034210360557753\n", - "The mean of individual market resources is 2.838609761062614; the standard deviation is 0.6366522892047719; the median is 2.9130137756022285.\n", - "The mean of individual wealth is 1.1451538268900965; the standard deviation is 0.4916602363506698; the median is 1.1867717074236241.\n", - "The market resources of the median agent is 2.9130, \n", - " and the value function for the median-wealth voter at tax rate 0.5000 is -0.2282. \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.8830690706795172\n", - "The mean of individual market resources is 2.7987308377426485; the standard deviation is 0.5669560252924258; the median is 2.8728163545868233.\n", - "The mean of individual wealth is 1.1111850978846975; the standard deviation is 0.4365733784929202; the median is 1.1549467931062227.\n", - "The market resources of the median agent is 2.8728, \n", - " and the value function for the median-wealth voter at tax rate 0.5500 is -0.2327. \n", - "\n", - "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "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: 0.962642905712668\n", - "The mean of individual market resources is 2.761306448547628; the standard deviation is 0.49887367155268225; the median is 2.8327661123090184.\n", - "The mean of individual wealth is 1.0795317262763333; the standard deviation is 0.3831093614174129; the median is 1.1232384024511646.\n", - "The market resources of the median agent is 2.8328, \n", - " and the value function for the median-wealth voter at tax rate 0.6000 is -0.2377. \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.0421487412559023\n", - "The mean of individual market resources is 2.7260404831100815; the standard deviation is 0.43186109416598456; the median is 2.7938732035092264.\n", - "The mean of individual wealth is 1.049937019896209; the standard deviation is 0.33062122613343714; the median is 1.0931465191989214.\n", - "The market resources of the median agent is 2.7939, \n", - " and the value function for the median-wealth voter at tax rate 0.6500 is -0.2427. \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.121600099657847\n", - "The mean of individual market resources is 2.6930167672331202; the standard deviation is 0.3661997508951041; the median is 2.755504621852627.\n", - "The mean of individual wealth is 1.0224886887816542; the standard deviation is 0.27935478620487086; the median is 1.0641344919259825.\n", - "The market resources of the median agent is 2.7555, \n", - " and the value function for the median-wealth voter at tax rate 0.7000 is -0.2479. \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.2010022594379157\n", - "The mean of individual market resources is 2.661986177298545; the standard deviation is 0.3017720534853086; the median is 2.7179561053238777.\n", - "The mean of individual wealth is 0.9970310684195496; the standard deviation is 0.2295028302673594; the median is 1.0357425488685024.\n", - "The market resources of the median agent is 2.7180, \n", - " and the value function for the median-wealth voter at tax rate 0.7500 is -0.2530. \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.2803630006666817\n", - "The mean of individual market resources is 2.6328500972210453; the standard deviation is 0.23857079928341574; the median is 2.6811030255663866.\n", - "The mean of individual wealth is 0.9734673583559486; the standard deviation is 0.18084029906989046; the median is 1.0078764535151385.\n", - "The market resources of the median agent is 2.6811, \n", - " and the value function for the median-wealth voter at tax rate 0.8000 is -0.2582. \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.3596960073172408\n", - "The mean of individual market resources is 2.6057291292873526; the standard deviation is 0.17688282902136962; the median is 2.6440079967422445.\n", - "The mean of individual wealth is 0.9517781407121343; the standard deviation is 0.13356511804653823; the median is 0.9798274107444546.\n", - "The market resources of the median agent is 2.6440, \n", - " and the value function for the median-wealth voter at tax rate 0.8500 is -0.2634. \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.9000\n", - "The lump-sum transfer in terms of permanent income is: 1.4390209077517238\n", - "The mean of individual market resources is 2.5809033838648774; the standard deviation is 0.11653107959120272; the median is 2.6070662834442087.\n", - "The mean of individual wealth is 0.9323428488168439; the standard deviation is 0.08782708639327413; the median is 0.9518942960074035.\n", - "The market resources of the median agent is 2.6071, \n", - " and the value function for the median-wealth voter at tax rate 0.9000 is -0.2688. \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.5183703433420366\n", - "The mean of individual market resources is 2.5589804659305084; the standard deviation is 0.05764036899369175; the median is 2.5724961701970654.\n", - "The mean of individual wealth is 0.9155420032979318; the standard deviation is 0.04356736107282193; the median is 0.9257544434235597.\n", - "The market resources of the median agent is 2.5725, \n", - " and the value function for the median-wealth voter at tax rate 0.9500 is -0.2740. \n", - "\n" - ] - } - ], - "source": [ - "rates = 20\n", - "tax_rates = np.linspace(0.00, 0.95, num=rates) # Each tax rate from 0.00, 0.05, 0.10, ... , 0.95\n", - "v_at_median_wealth = [] # Vector for value function of median wealth agent at each level of flat income tax rate\n", - "\n", - "for tau in tax_rates:\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: \" + str(AggShockAgent_tax_tau.calc_transfers()))\n", - "\n", - " print(\"The mean of individual market resources is \" + str(sim_market_resources_tau.mean()) + \"; the standard deviation is \"\n", - " + str(sim_market_resources_tau.std()) + \"; the median is \" + str(np.median(sim_market_resources_tau)) + \".\")\n", - " print(\"The mean of individual wealth is \" + str(sim_wealth_tau.mean()) + \"; the standard deviation is \"\n", - " + str(sim_wealth_tau.std()) + \"; the median is \" + str(np.median(sim_wealth_tau)) + \".\")\n", - "\n", - " # Tax rate as determined by median agent (pre-tax)'s wealth and income\n", - " sim_median_wealth_tau = np.median(sim_wealth_tau)\n", - " sim_median_market_resources_tau = np.median(sim_market_resources_tau)\n", - "\n", - " # Find value function of post-tax median wealth agent/voter\n", - " # vFunc arguments: Median agent's level of market resources\n", - " # and median agent's capital-labor ratio (assumed as 1.0 for now)\n", - " v_at_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau,\n", - " 1.0)\n", - "\n", - " v_at_median_wealth.append(v_at_median_wealth_tau)\n", - "\n", - " print(\"The market resources of the median agent is \"\n", - " + str(mystr(sim_median_market_resources_tau)) \n", - " + \", \\n and the value function for the median-wealth voter at tax rate \"\n", - " + str(mystr(AggShockAgent_tax_tau.tax_rate))\n", - " + \" is \" + str(mystr(v_at_median_wealth_tau)) + \". \\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "1ce75045-7f2e-4248-82bb-4f9a15d12303", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-0.18024185069296117, -0.18455806238930317, -0.18903355172658706, -0.19346392517460834, -0.19814098520933243, -0.2027751787467651, -0.20742596341089536, -0.21285529753227597, -0.21827310064074493, -0.22347902643837517, -0.22816895274298954, -0.23265702523122397, -0.2376641480947056, -0.24272278380653958, -0.24785487654852859, -0.2530183142248006, -0.25817331887361744, -0.2634471807019704, -0.26884297005638635, -0.27402664188836884]\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": { - "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": "9e14a0e8-efab-4647-850e-a8909e965d09", + "id": "0e4f4099", "metadata": {}, "source": [ - "### So far, the problem is that median wealth is greater than mean wealth, and so the median voter most prefers an income tax rate of 0.\n", + "For tax rates, I create a 20 $\\times$ 1 grid of tax rates from 0.00 to 0.95.\n", "\n", - "What would be the optimal tax rate for agents with wealth / market resources of other percentiles?" + "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": 14, + "execution_count": 11, "id": "8e6d627b-c3c7-4ab5-ab3f-97f6687a8d74", "metadata": { "scrolled": true @@ -948,6 +646,7 @@ "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", @@ -956,278 +655,280 @@ "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.0811\n", - "The mean of individual wealth is 1.5564; the standard deviation is 1.0639438888899186; the median is 1.5509.\n", - "The mean of individual market resources is 3.3097; the standard deviation is 1.3377244879603751; the median is 3.3694.\n", - "The 90th percentile of individual wealth is 3.0308.\n", - "The 80th percentile of individual wealth is 2.4744.\n", - "The 70th percentile of individual wealth is 1.9491.\n", - "The 60th percentile of individual wealth is 1.7425.\n", - "The 40th percentile of individual wealth is 1.0392.\n", - "The 30th percentile of individual wealth is 0.8120.\n", - "The 20th percentile of individual wealth is 0.5807.\n", - "The 10th percentile of individual wealth is 0.3985.\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.1620\n", - "The mean of individual wealth is 1.5003; the standard deviation is 0.9929035918870248; the median is 1.5043.\n", - "The mean of individual market resources is 3.2467; the standard deviation is 1.2520229927395188; the median is 3.3121.\n", - "The 90th percentile of individual wealth is 2.8697.\n", - "The 80th percentile of individual wealth is 2.3182.\n", - "The 70th percentile of individual wealth is 1.8833.\n", - "The 60th percentile of individual wealth is 1.6912.\n", - "The 40th percentile of individual wealth is 1.0218.\n", - "The 30th percentile of individual wealth is 0.8140.\n", - "The 20th percentile of individual wealth is 0.5916.\n", - "The 10th percentile of individual wealth is 0.4145.\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.2427\n", - "The mean of individual wealth is 1.4471; the standard deviation is 0.9235623554628882; the median is 1.4619.\n", - "The mean of individual market resources is 3.1863; the standard deviation is 1.168962166474006; the median is 3.2599.\n", - "The 90th percentile of individual wealth is 2.7158.\n", - "The 80th percentile of individual wealth is 2.1776.\n", - "The 70th percentile of individual wealth is 1.8193.\n", - "The 60th percentile of individual wealth is 1.6405.\n", - "The 40th percentile of individual wealth is 1.0059.\n", - "The 30th percentile of individual wealth is 0.8092.\n", - "The 20th percentile of individual wealth is 0.6035.\n", - "The 10th percentile of individual wealth is 0.4331.\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.3232\n", - "The mean of individual wealth is 1.3967; the standard deviation is 0.856063635366787; the median is 1.4211.\n", - "The mean of individual market resources is 3.1288; the standard deviation is 1.0875222965598483; the median is 3.2089.\n", - "The 90th percentile of individual wealth is 2.5645.\n", - "The 80th percentile of individual wealth is 2.0467.\n", - "The 70th percentile of individual wealth is 1.7570.\n", - "The 60th percentile of individual wealth is 1.5891.\n", - "The 40th percentile of individual wealth is 0.9908.\n", - "The 30th percentile of individual wealth is 0.8041.\n", - "The 20th percentile of individual wealth is 0.6184.\n", - "The 10th percentile of individual wealth is 0.4288.\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.4036\n", - "The mean of individual wealth is 1.3487; the standard deviation is 0.7909224641555209; the median is 1.3823.\n", - "The mean of individual market resources is 3.0739; the standard deviation is 1.008347389535206; the median is 3.1600.\n", - "The 90th percentile of individual wealth is 2.4291.\n", - "The 80th percentile of individual wealth is 1.9366.\n", - "The 70th percentile of individual wealth is 1.6949.\n", - "The 60th percentile of individual wealth is 1.5377.\n", - "The 40th percentile of individual wealth is 0.9764.\n", - "The 30th percentile of individual wealth is 0.8004.\n", - "The 20th percentile of individual wealth is 0.6332.\n", - "The 10th percentile of individual wealth is 0.4201.\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.4838\n", - "The mean of individual wealth is 1.3034; the standard deviation is 0.7276814207959237; the median is 1.3446.\n", - "The mean of individual market resources is 3.0219; the standard deviation is 0.9308118958455757; the median is 3.1123.\n", - "The 90th percentile of individual wealth is 2.2938.\n", - "The 80th percentile of individual wealth is 1.8543.\n", - "The 70th percentile of individual wealth is 1.6298.\n", - "The 60th percentile of individual wealth is 1.4840.\n", - "The 40th percentile of individual wealth is 0.9637.\n", - "The 30th percentile of individual wealth is 0.7987.\n", - "The 20th percentile of individual wealth is 0.6481.\n", - "The 10th percentile of individual wealth is 0.4303.\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.5639\n", - "The mean of individual wealth is 1.2603; the standard deviation is 0.6661794316634178; the median is 1.3019.\n", - "The mean of individual market resources is 2.9725; the standard deviation is 0.8547369801052926; the median is 3.0584.\n", - "The 90th percentile of individual wealth is 2.1641.\n", - "The 80th percentile of individual wealth is 1.7748.\n", - "The 70th percentile of individual wealth is 1.5639.\n", - "The 60th percentile of individual wealth is 1.4315.\n", - "The 40th percentile of individual wealth is 0.9540.\n", - "The 30th percentile of individual wealth is 0.7982.\n", - "The 20th percentile of individual wealth is 0.6564.\n", - "The 10th percentile of individual wealth is 0.4476.\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.6438\n", - "The mean of individual wealth is 1.2196; the standard deviation is 0.606333217089106; the median is 1.2600.\n", - "The mean of individual market resources is 2.9256; the standard deviation is 0.7803144004751789; the median is 3.0055.\n", - "The 90th percentile of individual wealth is 2.0408.\n", - "The 80th percentile of individual wealth is 1.6976.\n", - "The 70th percentile of individual wealth is 1.5006.\n", - "The 60th percentile of individual wealth is 1.3810.\n", - "The 40th percentile of individual wealth is 0.9458.\n", - "The 30th percentile of individual wealth is 0.7990.\n", - "The 20th percentile of individual wealth is 0.6715.\n", - "The 10th percentile of individual wealth is 0.4671.\n", - "\n", - "intercept=-0.5288444895735478, slope=1.1237386173871755, r-sq=0.810535437461125\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.7237\n", - "The mean of individual wealth is 1.1813; the standard deviation is 0.5481037226319276; the median is 1.2209.\n", - "The mean of individual market resources is 2.8809; the standard deviation is 0.7077378310325457; the median is 2.9562.\n", - "The 90th percentile of individual wealth is 1.9194.\n", - "The 80th percentile of individual wealth is 1.6157.\n", - "The 70th percentile of individual wealth is 1.4403.\n", - "The 60th percentile of individual wealth is 1.3318.\n", - "The 40th percentile of individual wealth is 0.9391.\n", - "The 30th percentile of individual wealth is 0.8013.\n", - "The 20th percentile of individual wealth is 0.6871.\n", - "The 10th percentile of individual wealth is 0.4883.\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.8034\n", - "The mean of individual wealth is 1.1452; the standard deviation is 0.4916602363506698; the median is 1.1868.\n", - "The mean of individual market resources is 2.8386; the standard deviation is 0.6366522892047719; the median is 2.9130.\n", - "The 90th percentile of individual wealth is 1.8022.\n", - "The 80th percentile of individual wealth is 1.5227.\n", - "The 70th percentile of individual wealth is 1.3822.\n", - "The 60th percentile of individual wealth is 1.2842.\n", - "The 40th percentile of individual wealth is 0.9326.\n", - "The 30th percentile of individual wealth is 0.8047.\n", - "The 20th percentile of individual wealth is 0.7002.\n", - "The 10th percentile of individual wealth is 0.5163.\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.8831\n", - "The mean of individual wealth is 1.1112; the standard deviation is 0.4365733784929202; the median is 1.1549.\n", - "The mean of individual market resources is 2.7987; the standard deviation is 0.5669560252924258; the median is 2.8728.\n", - "The 90th percentile of individual wealth is 1.6927.\n", - "The 80th percentile of individual wealth is 1.4483.\n", - "The 70th percentile of individual wealth is 1.3212.\n", - "The 60th percentile of individual wealth is 1.2380.\n", - "The 40th percentile of individual wealth is 0.9266.\n", - "The 30th percentile of individual wealth is 0.8091.\n", - "The 20th percentile of individual wealth is 0.7138.\n", - "The 10th percentile of individual wealth is 0.5489.\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: 0.9626\n", - "The mean of individual wealth is 1.0795; the standard deviation is 0.3831093614174129; the median is 1.1232.\n", - "The mean of individual market resources is 2.7613; the standard deviation is 0.49887367155268225; the median is 2.8328.\n", - "The 90th percentile of individual wealth is 1.5876.\n", - "The 80th percentile of individual wealth is 1.3739.\n", - "The 70th percentile of individual wealth is 1.2602.\n", - "The 60th percentile of individual wealth is 1.1935.\n", - "The 40th percentile of individual wealth is 0.9212.\n", - "The 30th percentile of individual wealth is 0.8146.\n", - "The 20th percentile of individual wealth is 0.7312.\n", - "The 10th percentile of individual wealth is 0.5823.\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.0421\n", - "The mean of individual wealth is 1.0499; the standard deviation is 0.33062122613343714; the median is 1.0931.\n", - "The mean of individual market resources is 2.7260; the standard deviation is 0.43186109416598456; the median is 2.7939.\n", - "The 90th percentile of individual wealth is 1.4846.\n", - "The 80th percentile of individual wealth is 1.3030.\n", - "The 70th percentile of individual wealth is 1.2037.\n", - "The 60th percentile of individual wealth is 1.1518.\n", - "The 40th percentile of individual wealth is 0.9172.\n", - "The 30th percentile of individual wealth is 0.8214.\n", - "The 20th percentile of individual wealth is 0.7485.\n", - "The 10th percentile of individual wealth is 0.6182.\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.1216\n", - "The mean of individual wealth is 1.0225; the standard deviation is 0.27935478620487086; the median is 1.0641.\n", - "The mean of individual market resources is 2.6930; the standard deviation is 0.3661997508951041; the median is 2.7555.\n", - "The 90th percentile of individual wealth is 1.3868.\n", - "The 80th percentile of individual wealth is 1.2383.\n", - "The 70th percentile of individual wealth is 1.1551.\n", - "The 60th percentile of individual wealth is 1.1122.\n", - "The 40th percentile of individual wealth is 0.9139.\n", - "The 30th percentile of individual wealth is 0.8307.\n", - "The 20th percentile of individual wealth is 0.7671.\n", - "The 10th percentile of individual wealth is 0.6569.\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.2010\n", - "The mean of individual wealth is 0.9970; the standard deviation is 0.2295028302673594; the median is 1.0357.\n", - "The mean of individual market resources is 2.6620; the standard deviation is 0.3017720534853086; the median is 2.7180.\n", - "The 90th percentile of individual wealth is 1.2969.\n", - "The 80th percentile of individual wealth is 1.1760.\n", - "The 70th percentile of individual wealth is 1.1076.\n", - "The 60th percentile of individual wealth is 1.0739.\n", - "The 40th percentile of individual wealth is 0.9108.\n", - "The 30th percentile of individual wealth is 0.8409.\n", - "The 20th percentile of individual wealth is 0.7872.\n", - "The 10th percentile of individual wealth is 0.6963.\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.2804\n", - "The mean of individual wealth is 0.9735; the standard deviation is 0.18084029906989046; the median is 1.0079.\n", - "The mean of individual market resources is 2.6329; the standard deviation is 0.23857079928341574; the median is 2.6811.\n", - "The 90th percentile of individual wealth is 1.2083.\n", - "The 80th percentile of individual wealth is 1.1155.\n", - "The 70th percentile of individual wealth is 1.0622.\n", - "The 60th percentile of individual wealth is 1.0367.\n", - "The 40th percentile of individual wealth is 0.9080.\n", - "The 30th percentile of individual wealth is 0.8517.\n", - "The 20th percentile of individual wealth is 0.8079.\n", - "The 10th percentile of individual wealth is 0.7358.\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.3597\n", - "The mean of individual wealth is 0.9518; the standard deviation is 0.13356511804653823; the median is 0.9798.\n", - "The mean of individual market resources is 2.6057; the standard deviation is 0.17688282902136962; the median is 2.6440.\n", - "The 90th percentile of individual wealth is 1.1215.\n", - "The 80th percentile of individual wealth is 1.0583.\n", - "The 70th percentile of individual wealth is 1.0191.\n", - "The 60th percentile of individual wealth is 1.0001.\n", - "The 40th percentile of individual wealth is 0.9045.\n", - "The 30th percentile of individual wealth is 0.8630.\n", - "The 20th percentile of individual wealth is 0.8285.\n", - "The 10th percentile of individual wealth is 0.7754.\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.9000\n", - "The lump-sum transfer in terms of permanent income is: 1.4390\n", - "The mean of individual wealth is 0.9323; the standard deviation is 0.08782708639327413; the median is 0.9519.\n", - "The mean of individual market resources is 2.5809; the standard deviation is 0.11653107959120272; the median is 2.6071.\n", - "The 90th percentile of individual wealth is 1.0448.\n", - "The 80th percentile of individual wealth is 1.0019.\n", - "The 70th percentile of individual wealth is 0.9774.\n", - "The 60th percentile of individual wealth is 0.9653.\n", - "The 40th percentile of individual wealth is 0.9016.\n", - "The 30th percentile of individual wealth is 0.8749.\n", - "The 20th percentile of individual wealth is 0.8500.\n", - "The 10th percentile of individual wealth is 0.8142.\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" ] }, @@ -1235,34 +936,50 @@ "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.5184\n", - "The mean of individual wealth is 0.9155; the standard deviation is 0.04356736107282193; the median is 0.9258.\n", - "The mean of individual market resources is 2.5590; the standard deviation is 0.05764036899369175; the median is 2.5725.\n", - "The 90th percentile of individual wealth is 0.9699.\n", - "The 80th percentile of individual wealth is 0.9502.\n", - "The 70th percentile of individual wealth is 0.9380.\n", - "The 60th percentile of individual wealth is 0.9321.\n", - "The 40th percentile of individual wealth is 0.9006.\n", - "The 30th percentile of individual wealth is 0.8875.\n", - "The 20th percentile of individual wealth is 0.8747.\n", - "The 10th percentile of individual wealth is 0.8562.\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", + "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", - "\n", - "\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", @@ -1285,7 +1002,7 @@ "\n", " sim_market_resources_tau = AggShockAgent_tax_tau.state_now['mNrm']\n", " sim_wealth_tau = AggShockAgent_tax_tau.state_now['aNrm']\n", - " #print(sim_wealth_tau)\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", @@ -1296,9 +1013,10 @@ " + 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)) + \".\")# + \"; the standard deviation is \")\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 40th percentile of individual wealth is \" + mystr(np.percentile(sim_wealth_tau,40)) + \".\")# + \"; the standard deviation is \")\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", @@ -1312,6 +1030,8 @@ " 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", @@ -1320,13 +1040,14 @@ " 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 median wealth agent/voter\n", - " # vFunc arguments: Median agent's level of market resources\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", @@ -1336,6 +1057,7 @@ " 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", @@ -1344,15 +1066,91 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "29ebd769-075f-45a9-af40-23fcabd8b2d1", + "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1362,11 +1160,11 @@ } ], "source": [ - "plt.figure(figsize=(9,5))\n", - "plt.plot(tax_rates, v_at_p90_wealth, 'r--', label = 'Value function of p40 wealth agent')\n", - "plt.plot(tax_rates, v_at_p80_wealth, 'g--', label = 'Value function of p30 wealth agent')\n", - "plt.plot(tax_rates, v_at_p70_wealth, 'b--', label = 'Value function of p20 wealth agent')\n", - "plt.plot(tax_rates, v_at_p60_wealth, 'y--', label = 'Value function of p10 wealth agent')\n", + "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", @@ -1379,9 +1177,19 @@ "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": 16, + "execution_count": 15, "id": "064044b2-8897-4d41-bac0-c5f3fd10a199", "metadata": {}, "outputs": [ @@ -1394,7 +1202,7 @@ "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.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" @@ -1428,9 +1236,27 @@ "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). 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.\n", + "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", - "In this simulation, we find that the bottom 30th percent of voters would vote for (nearly) full redistribution, whereas the rest would vote for zero redistribution. This would lead to a politically determined tax rate of 0\\%." + "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." ] } ], From 7e333ea8c037609ab439b62dafe8a173a837f352 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Wed, 25 May 2022 00:16:46 +0900 Subject: [PATCH 7/9] 20220525 Edit Files --- REMARKs/KRR99/code/python/Koh_KRR99.py | 242 ++++++++++++++++++------- 1 file changed, 176 insertions(+), 66 deletions(-) diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.py b/REMARKs/KRR99/code/python/Koh_KRR99.py index 76aab734..b188f2b9 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.py +++ b/REMARKs/KRR99/code/python/Koh_KRR99.py @@ -4,9 +4,13 @@ # Import IndShockConsumerType import HARK import sys -from HARK.ConsumptionSaving.ConsAggShockModel import (AggShockConsumerType, - CobbDouglasEconomy) -from ConsAggShockModel_tax import (AggShockConsumerType_tax, CobbDouglasEconomy_tax) +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 @@ -18,6 +22,8 @@ def mystr(number): return "{:.4f}".format(number) + + # **Krusell and Rios-Rull's parameters for income and wealth distribution:** # # Sorted by Wealth @@ -127,43 +133,80 @@ def mystr(number): # Solve for aggregate shock consumer model AggShockAgent_tax.solve() -AggShockAgent_tax.track_vars = ['aNrm','pLvl','mNrm','cNrm','TranShk'] - +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 -# AggShockAgent_tax.unpack('cFunc') -# -# print("Consumption function at each aggregate market resources-to-labor ratio gridpoint:") -# m_grid = np.linspace(0, 10, 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.ylim(0.0, 3.5) -# plt.show() -# -# AggShockAgent_tax.unpack('vFunc') -# -# print("Value function at each aggregate market resources-to-labor ratio gridpoint:") -# m_grid = np.linspace(0, 10, 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() -# -# -# # Code for finding optimal tax rate given vFunc of median AggShockConsumerType agent in Cobb-Douglas Economy -# -# # Put this in loop in order to find optimal tax rate for median (wealth) voter +# 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_median_wealth = [] + +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: @@ -176,58 +219,125 @@ def mystr(number): AggShockAgent_tax_tau.solve() AggShockAgent_tax_tau.initialize_sim() AggShockAgent_tax_tau.simulate() - AggShockAgent_tax_tau.track_vars = ['aNrm','pLvl','mNrm','cNrm','TranShk'] + 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 lump-sum transfer in terms of permanent income is: " + str(AggShockAgent_tax_tau.calc_transfers())) - - print("The mean of individual market resources is " + str(sim_market_resources_tau.mean()) + "; the standard deviation is " - + str(sim_market_resources_tau.std()) + "; the median is " + str(np.median(sim_market_resources_tau)) + ".") - print("The mean of individual wealth is " + str(sim_wealth_tau.mean()) + "; the standard deviation is " - + str(sim_wealth_tau.std()) + "; the median is " + str(np.median(sim_wealth_tau)) + ".") - - print("The median level of market resources is: " + str(np.median(AggShockAgent_tax_tau.state_now['mNrm']))) - print("And also with median wealth + income: " + str(np.median(sim_wealth_tau + sim_income_tau))) - - - # print("The mean of post-tax individual income is " + str(sim_post_income_tau.mean()) + "; the standard deviation is " - # + str(sim_post_income_tau.std()) + "; the median is " + str(np.median(sim_post_income_tau)) + ".") - # print("The aggregate pre-tax wealth-income ratio is " + str(sim_wealth_tau.mean() / sim_pre_income_tau.mean()) + ".") - # print("The aggregate post-tax wealth-income ratio is " + str(sim_wealth_tau.mean() / sim_post_income_tau.mean()) + ".") - - # Tax rate as determined by median agent (pre-tax)'s wealth and income - + + 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_income_tau = np.median(sim_income_tau) sim_median_market_resources_tau = np.median(sim_market_resources_tau) - - # Find value function of median wealth agent/voter - # vFunc arguments: Median agent's level of market resources + 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_median_wealth_tau = AggShockAgent_tax_tau.vFunc[0](sim_median_market_resources_tau, - 1.0) - + 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) - print("The market resources of the median agent is " - + str(mystr(sim_median_market_resources_tau)) - + ".\n The value function for the median-wealth voter at tax rate " - + str(mystr(AggShockAgent_tax_tau.tax_rate)) - + " is " + str(mystr(v_at_median_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)) + ".") + From 8b4270949895e44abd8f03ca19fa0307a787d9e4 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Wed, 25 May 2022 00:31:10 +0900 Subject: [PATCH 8/9] 20220525 Edit Files 2 --- REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index c289615b..db8c2c45 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -249,7 +249,7 @@ " \"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 - 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", From 86e7e2d77bf7358777c347ad635d0cbccbb61965 Mon Sep 17 00:00:00 2001 From: Kyung Woong Koh Date: Wed, 25 May 2022 01:48:50 +0900 Subject: [PATCH 9/9] 20220525 Edit Files 3 --- REMARKs/KRR99/code/python/Koh_KRR99.ipynb | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb index db8c2c45..8ccc4ebb 100644 --- a/REMARKs/KRR99/code/python/Koh_KRR99.ipynb +++ b/REMARKs/KRR99/code/python/Koh_KRR99.ipynb @@ -125,9 +125,7 @@ "(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\n", - "\n", - "Distribution of wealth / permanent income / preferences" + "- 3. utility of different groups with different tax rates" ] }, {