How to read this lecture...

Code should execute sequentially if run in a Jupyter notebook

• See the set up page to install Jupyter, Julia (1.0+) and all necessary libraries
• Please direct feedback to contact@quantecon.org or the discourse forum
• For some notebooks, enable content with "Trust" on the command tab of Jupyter lab
• If using QuantEcon lectures for the first time on a computer, execute ] add InstantiateFromURL inside of a notebook or the REPL

# Optimal Taxation without State-Contingent Debt¶

## Overview¶

In an earlier lecture we described a model of optimal taxation with state-contingent debt due to Robert E. Lucas, Jr., and Nancy Stokey [LS83]

Aiyagari, Marcet, Sargent, and Seppälä [AMSS02] (hereafter, AMSS) studied optimal taxation in a model without state-contingent debt

In this lecture, we

• describe assumptions and equilibrium concepts
• solve the model
• implement the model numerically
• conduct some policy experiments
• compare outcomes with those in a corresponding complete-markets model

We begin with an introduction to the model

### Setup¶

In :
using InstantiateFromURL
github_project("QuantEcon/quantecon-notebooks-julia", version = "0.3.0")

In :
using LinearAlgebra, Statistics


## Competitive Equilibrium with Distorting Taxes¶

Many but not all features of the economy are identical to those of the Lucas-Stokey economy

Let’s start with things that are identical

For $t \geq 0$, a history of the state is represented by $s^t = [s_t, s_{t-1}, \ldots, s_0]$

Government purchases $g(s)$ are an exact time-invariant function of $s$

Let $c_t(s^t)$, $\ell_t(s^t)$, and $n_t(s^t)$ denote consumption, leisure, and labor supply, respectively, at history $s^t$ at time $t$

Each period a representative household is endowed with one unit of time that can be divided between leisure $\ell_t$ and labor $n_t$:

$$n_t(s^t) + \ell_t(s^t) = 1 \tag{1}$$

Output equals $n_t(s^t)$ and can be divided between consumption $c_t(s^t)$ and $g(s_t)$

$$c_t(s^t) + g(s_t) = n_t(s^t) \tag{2}$$

Output is not storable

The technology pins down a pre-tax wage rate to unity for all $t, s^t$

A representative household’s preferences over $\{c_t(s^t), \ell_t(s^t)\}_{t=0}^\infty$ are ordered by

$$\sum_{t=0}^\infty \sum_{s^t} \beta^t \pi_t(s^t) u[c_t(s^t), \ell_t(s^t)] \tag{3}$$

where

• $\pi_t(s^t)$ is a joint probability distribution over the sequence $s^t$, and
• the utility function $u$ is increasing, strictly concave, and three times continuously differentiable in both arguments

The government imposes a flat rate tax $\tau_t(s^t)$ on labor income at time $t$, history $s^t$

Lucas and Stokey assumed that there are complete markets in one-period Arrow securities; also see smoothing models

It is at this point that AMSS [AMSS02] modify the Lucas and Stokey economy

AMSS allow the government to issue only one-period risk-free debt each period

Ruling out complete markets in this way is a step in the direction of making total tax collections behave more like that prescribed in [Bar79] than they do in [LS83]

### Risk-free One-Period Debt Only¶

In period $t$ and history $s^t$, let

• $b_{t+1}(s^t)$ be the amount of the time $t+1$ consumption good that at time $t$ the government promised to pay
• $R_t(s^t)$ be the gross interest rate on risk-free one-period debt between periods $t$ and $t+1$
• $T_t(s^t)$ be a nonnegative lump-sum transfer to the representative household 

That $b_{t+1}(s^t)$ is the same for all realizations of $s_{t+1}$ captures its risk-free character

The market value at time $t$ of government debt maturing at time $t+1$ equals $b_{t+1}(s^t)$ divided by $R_t(s^t)$.

The government’s budget constraint in period $t$ at history $s^t$ is

\begin{aligned} b_t(s^{t-1}) & = \tau^n_t(s^t) n_t(s^t) - g_t(s_t) - T_t(s^t) + {b_{t+1}(s^t) \over R_t(s^t )} \\ & \equiv z(s^t) + {b_{t+1}(s^t) \over R_t(s^t )}, \end{aligned} \tag{4}

where $z(s^t)$ is the net-of-interest government surplus

To rule out Ponzi schemes, we assume that the government is subject to a natural debt limit (to be discussed in a forthcoming lecture)

The consumption Euler equation for a representative household able to trade only one-period risk-free debt with one-period gross interest rate $R_t(s^t)$ is

$${1 \over R_t(s^t)} = \sum_{s^{t+1}\vert s^t} \beta \pi_{t+1}(s^{t+1} | s^t) { u_c(s^{t+1}) \over u_c(s^{t}) }$$

Substituting this expression into the government’s budget constraint (4) yields:

$$b_t(s^{t-1}) = z(s^t) + \beta \sum_{s^{t+1}\vert s^t} \pi_{t+1}(s^{t+1} | s^t) { u_c(s^{t+1}) \over u_c(s^{t}) } \; b_{t+1}(s^t) \tag{5}$$

Components of $z(s^t)$ on the right side depend on $s^t$, but the left side is required to depend on $s^{t-1}$ only

This is what it means for one-period government debt to be risk-free

Therefore, the sum on the right side of equation (5) also has to depend only on $s^{t-1}$

This requirement will give rise to measurability constraints on the Ramsey allocation to be discussed soon

If we replace $b_{t+1}(s^t)$ on the right side of equation (5) by the right side of next period’s budget constraint (associated with a particular realization $s_{t}$) we get

$$b_t(s^{t-1}) = z(s^t) + \sum_{s^{t+1}\vert s^t} \beta \pi_{t+1}(s^{t+1} | s^t) { u_c(s^{t+1}) \over u_c(s^{t}) } \, \left[z(s^{t+1}) + {b_{t+2}(s^{t+1}) \over R_{t+1}(s^{t+1})}\right]$$

After making similar repeated substitutions for all future occurrences of government indebtedness, and by invoking the natural debt limit, we arrive at:

\begin{aligned} b_t(s^{t-1}) &= \sum_{j=0}^\infty \sum_{s^{t+j} | s^t} \beta^j \pi_{t+j}(s^{t+j} | s^t) { u_c(s^{t+j}) \over u_c(s^{t}) } \;z(s^{t+j}) \end{aligned} \tag{6}

Now let’s

• substitute the resource constraint into the net-of-interest government surplus, and
• use the household’s first-order condition $1-\tau^n_t(s^t)= u_{\ell}(s^t) /u_c(s^t)$ to eliminate the labor tax rate

so that we can express the net-of-interest government surplus $z(s^t)$ as

$$z(s^t) = \left[1 - {u_{\ell}(s^t) \over u_c(s^t)}\right] \left[c_t(s^t)+g_t(s_t)\right] -g_t(s_t) - T_t(s^t)\,. \tag{7}$$

If we substitute the appropriate versions of right side of (7) for $z(s^{t+j})$ into equation (6), we obtain a sequence of implementability constraints on a Ramsey allocation in an AMSS economy

Expression (6) at time $t=0$ and initial state $s^0$ was also an implementability constraint on a Ramsey allocation in a Lucas-Stokey economy:

$$b_0(s^{-1}) = \mathbb{E}\,_0 \sum_{j=0}^\infty \beta^j { u_c(s^{j}) \over u_c(s^{0}) } \;z(s^{j}) \tag{8}$$

Indeed, it was the only implementability constraint there

But now we also have a large number of additional implementability constraints

$$b_t(s^{t-1}) = \mathbb{E}\,_t \sum_{j=0}^\infty \beta^j { u_c(s^{t+j}) \over u_c(s^{t}) } \;z(s^{t+j}) \tag{9}$$

Equation (9) must hold for each $s^t$ for each $t \geq 1$

### Comparison with Lucas-Stokey Economy¶

The expression on the right side of (9) in the Lucas-Stokey (1983) economy would equal the present value of a continuation stream of government surpluses evaluated at what would be competitive equilibrium Arrow-Debreu prices at date $t$

In the Lucas-Stokey economy, that present value is measurable with respect to $s^t$

In the AMSS economy, the restriction that government debt be risk-free imposes that that same present value must be measurable with respect to $s^{t-1}$

In a language used in the literature on incomplete markets models, it can be said that the AMSS model requires that at each $(t, s^t)$ what would be the present value of continuation government surpluses in the Lucas-Stokey model must belong to the marketable subspace of the AMSS model

### Ramsey Problem Without State-contingent Debt¶

After we have substituted the resource constraint into the utility function, we can express the Ramsey problem as being to choose an allocation that solves

$$\max_{\{c_t(s^t),b_{t+1}(s^t)\}} \mathbb{E}\,_0 \sum_{t=0}^\infty \beta^t u\left(c_t(s^t),1-c_t(s^t)-g_t(s_t)\right)$$

where the maximization is subject to

$$\mathbb{E}\,_{0} \sum_{j=0}^\infty \beta^j { u_c(s^{j}) \over u_c(s^{0}) } \;z(s^{j}) \geq b_0(s^{-1}) \tag{10}$$

and

$$\mathbb{E}\,_{t} \sum_{j=0}^\infty \beta^j { u_c(s^{t+j}) \over u_c(s^{t}) } \; z(s^{t+j}) = b_t(s^{t-1}) \quad \forall \, s^t \tag{11}$$

given $b_0(s^{-1})$

#### Lagrangian Formulation¶

Let $\gamma_0(s^0)$ be a nonnegative Lagrange multiplier on constraint (10)

As in the Lucas-Stokey economy, this multiplier is strictly positive when the government must resort to distortionary taxation; otherwise it equals zero

A consequence of the assumption that there are no markets in state-contingent securities and that a market exists only in a risk-free security is that we have to attach stochastic processes $\{\gamma_t(s^t)\}_{t=1}^\infty$ of Lagrange multipliers to the implementability constraints (11)

Depending on how the constraints bind, these multipliers can be positive or negative:

\begin{aligned} \gamma_t(s^t) &\;\geq\; (\leq)\;\, 0 \quad \text{if the constraint binds in this direction } \\ & \mathbb{E}\,_{t} \sum_{j=0}^\infty \beta^j { u_c(s^{t+j}) \over u_c(s^{t}) } \;z(s^{t+j}) \;\geq \;(\leq)\;\, b_t(s^{t-1}). \end{aligned}

A negative multiplier $\gamma_t(s^t)<0$ means that if we could relax constraint (11), we would like to increase the beginning-of-period indebtedness for that particular realization of history $s^t$

That would let us reduce the beginning-of-period indebtedness for some other history 

These features flow from the fact that the government cannot use state-contingent debt and therefore cannot allocate its indebtedness efficiently across future states

### Some Calculations¶

It is helpful to apply two transformations to the Lagrangian

Multiply constraint (10) by $u_c(s^0)$ and the constraints (11) by $\beta^t u_c(s^{t})$

Then a Lagrangian for the Ramsey problem can be represented as

\begin{aligned} J &= \mathbb{E}\,_{0} \sum_{t=0}^\infty \beta^t \biggl\{ u\left(c_t(s^t), 1-c_t(s^t)-g_t(s_t)\right)\\ & \qquad + \gamma_t(s^t) \Bigl[ \mathbb{E}\,_{t} \sum_{j=0}^\infty \beta^j u_c(s^{t+j}) \,z(s^{t+j}) - u_c(s^{t}) \,b_t(s^{t-1}) \biggr\} \\ &= \mathbb{E}\,_{0} \sum_{t=0}^\infty \beta^t \biggl\{ u\left(c_t(s^t), 1-c_t(s^t)-g_t(s_t)\right) \\ & \qquad + \Psi_t(s^t)\, u_c(s^{t}) \,z(s^{t}) - \gamma_t(s^t)\, u_c(s^{t}) \, b_t(s^{t-1}) \biggr\} \end{aligned} \tag{12}

where

$$\Psi_t(s^t)=\Psi_{t-1}(s^{t-1})+\gamma_t(s^t) \quad \text{and} \quad \Psi_{-1}(s^{-1})=0 \tag{13}$$

In (12), the second equality uses the law of iterated expectations and Abel’s summation formula (also called summation by parts, see this page)

First-order conditions with respect to $c_t(s^t)$ can be expressed as

\begin{aligned} u_c(s^t)-u_{\ell}(s^t) &+ \Psi_t(s^t)\left\{ \left[ u_{cc}(s^t) - u_{c\ell}(s^{t})\right]z(s^{t}) + u_{c}(s^{t})\,z_c(s^{t}) \right\} \\ & \hspace{35mm} - \gamma_t(s^t)\left[ u_{cc}(s^{t}) - u_{c\ell}(s^{t})\right]b_t(s^{t-1}) =0 \end{aligned} \tag{14}

and with respect to $b_t(s^t)$ as

$$\mathbb{E}\,_{t} \left[\gamma_{t+1}(s^{t+1})\,u_c(s^{t+1})\right] = 0 \tag{15}$$

If we substitute $z(s^t)$ from (7) and its derivative $z_c(s^t)$ into first-order condition (14), we find two differences from the corresponding condition for the optimal allocation in a Lucas-Stokey economy with state-contingent government debt

1. The term involving $b_t(s^{t-1})$ in first-order condition (14) does not appear in the corresponding expression for the Lucas-Stokey economy
• This term reflects the constraint that beginning-of-period government indebtedness must be the same across all realizations of next period’s state, a constraint that would not be present if government debt could be state contingent
1. The Lagrange multiplier $\Psi_t(s^t)$ in first-order condition (14) may change over time in response to realizations of the state, while the multiplier $\Phi$ in the Lucas-Stokey economy is time invariant

We need some code from our an earlier lecture on optimal taxation with state-contingent debt sequential allocation implementation:

In :
using QuantEcon, NLsolve, NLopt

import QuantEcon.simulate

mutable struct Model{TF <: AbstractFloat,
TM <: AbstractMatrix{TF},
TV <: AbstractVector{TF}}
β::TF
Π::TM
G::TV
Θ::TV
transfers::Bool
U::Function
Uc::Function
Ucc::Function
Un::Function
Unn::Function
n_less_than_one::Bool
end

struct SequentialAllocation{TP <: Model,
TI <: Integer,
TV <: AbstractVector}
model::TP
mc::MarkovChain
S::TI
cFB::TV
nFB::TV
ΞFB::TV
zFB::TV
end

function SequentialAllocation(model::Model)
β, Π, G, Θ = model.β, model.Π, model.G, model.Θ
mc = MarkovChain(Π)
S = size(Π, 1)   # Number of states
# Now find the first best allocation
cFB, nFB, ΞFB, zFB = find_first_best(model, S, 1)

return SequentialAllocation(model, mc, S, cFB, nFB, ΞFB, zFB)
end

function find_first_best(model::Model, S::Integer, version::Integer)
if version != 1 && version != 2
throw(ArgumentError("version must be 1 or 2"))
end
β, Θ, Uc, Un, G, Π =
model.β, model.Θ, model.Uc, model.Un, model.G, model.Π
function res!(out, z)
c = z[1:S]
n = z[S+1:end]
out[1:S] = Θ .* Uc.(c, n) + Un.(c, n)
out[S+1:end] = Θ .* n .- c .- G
end
res = nlsolve(res!, 0.5 * ones(2 * S))

if converged(res) == false
error("Could not find first best")
end

if version == 1
cFB = res.zero[1:S]
nFB = res.zero[S+1:end]
ΞFB = Uc(cFB, nFB)         # Multiplier on the resource constraint
zFB = vcat(cFB, nFB, ΞFB)
return cFB, nFB, ΞFB, zFB
elseif version == 2
cFB = res.zero[1:S]
nFB = res.zero[S+1:end]
IFB = Uc(cFB, nFB) .* cFB + Un(cFB, nFB) .* nFB
xFB = \(LinearAlgebra.I - β * Π, IFB)
zFB = [vcat(cFB[s], xFB[s], xFB) for s in 1:S]
return cFB, nFB, IFB, xFB, zFB
end
end

function time1_allocation(pas::SequentialAllocation, μ::Real)
model, S = pas.model, pas.S
Θ, β, Π, G, Uc, Ucc, Un, Unn =
model.Θ, model.β, model.Π, model.G,
model.Uc, model.Ucc, model.Un, model.Unn
function FOC!(out, z::Vector)
c = z[1:S]
n = z[S+1:2S]
Ξ = z[2S+1:end]
out[1:S] = Uc.(c, n) - μ * (Ucc.(c, n) .* c + Uc.(c, n)) - Ξ # FOC c
out[S+1:2S] = Un.(c, n) - μ * (Unn(c, n) .* n .+ Un.(c, n)) + Θ .* Ξ # FOC n
out[2S+1:end] = Θ .* n - c .- G # resource constraint
return out
end
# Find the root of the FOC
res = nlsolve(FOC!, pas.zFB)
if res.f_converged == false
error("Could not find LS allocation.")
end
z = res.zero
c, n, Ξ = z[1:S], z[S+1:2S], z[2S+1:end]
# Now compute x
I  = Uc(c, n) .* c +  Un(c, n) .* n
x = \(LinearAlgebra.I - β * model.Π, I)
return c, n, x, Ξ
end

function time0_allocation(pas::SequentialAllocation,
B_::AbstractFloat, s_0::Integer)
model = pas.model
Π, Θ, G, β = model.Π, model.Θ, model.G, model.β
Uc, Ucc, Un, Unn =
model.Uc, model.Ucc, model.Un, model.Unn

# First order conditions of planner's problem
function FOC!(out, z)
μ, c, n, Ξ = z, z, z, z
xprime = time1_allocation(pas, μ)
out .= vcat(
Uc(c, n) .* (c - B_) + Un(c, n) .* n + β * dot(Π[s_0, :], xprime),
Uc(c, n) .- μ * (Ucc(c, n) .* (c - B_) + Uc(c, n)) .- Ξ,
Un(c, n) .- μ * (Unn(c, n) .* n + Un(c, n)) + Θ[s_0] .* Ξ,
(Θ .* n .- c .- G)[s_0]
)
end

# Find root
res = nlsolve(FOC!, [0.0, pas.cFB[s_0], pas.nFB[s_0], pas.ΞFB[s_0]])
if res.f_converged == false
error("Could not find time 0 LS allocation.")
end
return (res.zero...,)
end

function time1_value(pas::SequentialAllocation, μ::Real)
model = pas.model
c, n, x, Ξ = time1_allocation(pas, μ)
U_val = model.U.(c, n)
V = \(LinearAlgebra.I - model.β*model.Π, U_val)
return c, n, x, V
end

function Τ(model::Model, c::Union{Real,Vector}, n::Union{Real,Vector})
Uc, Un = model.Uc.(c, n), model.Un.(c, n)
return 1. .+ Un./(model.Θ .* Uc)
end

function simulate(pas::SequentialAllocation,
B_::AbstractFloat, s_0::Integer,
T::Integer,
sHist::Union{Vector, Nothing}=nothing)

model = pas.model
Π, β, Uc = model.Π, model.β, model.Uc

if isnothing(sHist)
sHist = QuantEcon.simulate(pas.mc, T, init=s_0)
end
cHist = zeros(T)
nHist = zeros(T)
Bhist = zeros(T)
ΤHist = zeros(T)
μHist = zeros(T)
RHist = zeros(T-1)
# time 0
μ, cHist, nHist, _  = time0_allocation(pas, B_, s_0)
ΤHist = Τ(pas.model, cHist, nHist)[s_0]
Bhist = B_
μHist = μ
# time 1 onward
for t in 2:T
c, n, x, Ξ = time1_allocation(pas,μ)
u_c = Uc(c,n)
s = sHist[t]
ΤHist[t] = Τ(pas.model, c, n)[s]
Eu_c = dot(Π[sHist[t-1],:], u_c)
cHist[t], nHist[t], Bhist[t] = c[s], n[s], x[s] / u_c[s]
RHist[t-1] = Uc(cHist[t-1], nHist[t-1]) / (β * Eu_c)
μHist[t] = μ
end
return cHist, nHist, Bhist, ΤHist, sHist, μHist, RHist
end

mutable struct BellmanEquation{TP <: Model,
TI <: Integer,
TV <: AbstractVector,
TM <: AbstractMatrix{TV},
TVV <: AbstractVector{TV}}
model::TP
S::TI
xbar::TV
time_0::Bool
z0::TM
cFB::TV
nFB::TV
xFB::TV
zFB::TVV
end

function BellmanEquation(model::Model, xgrid::AbstractVector, policies0::Vector)
S = size(model.Π, 1) # number of states
xbar = [minimum(xgrid), maximum(xgrid)]
time_0 = false
cf, nf, xprimef = policies0
z0 = [vcat(cf[s](x), nf[s](x), [xprimef[s, sprime](x) for sprime in 1:S])
for x in xgrid, s in 1:S]
cFB, nFB, IFB, xFB, zFB = find_first_best(model, S, 2)
return BellmanEquation(model, S, xbar, time_0, z0, cFB, nFB, xFB, zFB)
end

function get_policies_time1(T::BellmanEquation,
i_x::Integer, x::AbstractFloat,
s::Integer, Vf::AbstractArray)
model, S = T.model, T.S
β, Θ, G, Π = model.β, model.Θ, model.G, model.Π
U, Uc, Un = model.U, model.Uc, model.Un

c, xprime = z, z[2:end]
n=c+G[s]
Vprime = [Vf[sprime](xprime[sprime]) for sprime in 1:S]
return -(U(c, n) + β * dot(Π[s, :], Vprime))
end
c, xprime = z, z[2:end]
n=c+G[s]
return x - Uc(c, n) * c - Un(c, n) * n - β * dot(Π[s, :], xprime)
end
lb = vcat(0, T.xbar * ones(S))
ub = vcat(1 - G[s], T.xbar * ones(S))
opt = Opt(:LN_COBYLA, length(T.z0[i_x, s])-1)
min_objective!(opt, objf)
equality_constraint!(opt, cons)
lower_bounds!(opt, lb)
upper_bounds!(opt, ub)
maxeval!(opt, 300)
maxtime!(opt, 10)
init = vcat(T.z0[i_x, s], T.z0[i_x, s][3:end])
for (i, val) in enumerate(init)
if val > ub[i]
init[i] = ub[i]
elseif val < lb[i]
init[i] = lb[i]
end
end
(minf, minx, ret) = optimize(opt, init)
T.z0[i_x, s] = vcat(minx, minx + G[s], minx[2:end])
return vcat(-minf, T.z0[i_x, s])
end

function get_policies_time0(T::BellmanEquation,
B_::AbstractFloat, s0::Integer, Vf::Array)
model, S = T.model, T.S
β, Θ, G, Π = model.β, model.Θ, model.G, model.Π
U, Uc, Un = model.U, model.Uc, model.Un
c, xprime = z, z[2:end]
n = c+G[s0]
Vprime = [Vf[sprime](xprime[sprime]) for sprime in 1:S]
return -(U(c, n) + β * dot(Π[s0, :], Vprime))
end
c, xprime = z, z[2:end]
n = c + G[s0]
return -Uc(c, n) * (c - B_) - Un(c, n) * n - β * dot(Π[s0, :], xprime)
end
lb = vcat(0, T.xbar * ones(S))
ub = vcat(1-G[s0], T.xbar * ones(S))
opt = Opt(:LN_COBYLA, length(T.zFB[s0])-1)
min_objective!(opt, objf)
equality_constraint!(opt, cons)
lower_bounds!(opt, lb)
upper_bounds!(opt, ub)
maxeval!(opt, 300)
maxtime!(opt, 10)
init = vcat(T.zFB[s0], T.zFB[s0][3:end])
for (i, val) in enumerate(init)
if val > ub[i]
init[i] = ub[i]
elseif val < lb[i]
init[i] = lb[i]
end
end
(minf, minx, ret) = optimize(opt, init)
return vcat(-minf, vcat(minx, minx+G[s0], minx[2:end]))
end

Out:
get_policies_time0 (generic function with 1 method)

To analyze the AMSS model, we find it useful to adopt a recursive formulation using techniques like those in our lectures on dynamic Stackelberg models and optimal taxation with state-contingent debt

## Recursive Version of AMSS Model¶

We now describe a recursive formulation of the AMSS economy

We have noted that from the point of view of the Ramsey planner, the restriction to one-period risk-free securities

• leaves intact the single implementability constraint on allocations (8) from the Lucas-Stokey economy, but
• adds measurability constraints (6) on functions of tails of allocations at each time and history

We now explore how these constraints alter Bellman equations for a time $0$ Ramsey planner and for time $t \geq 1$, history $s^t$ continuation Ramsey planners

### Recasting State Variables¶

In the AMSS setting, the government faces a sequence of budget constraints

$$\tau_t(s^t) n_t(s^t) + T_t(s^t) + b_{t+1}(s^t)/ R_t (s^t) = g_t + b_t(s^{t-1})$$

where $R_t(s^t)$ is the gross risk-free rate of interest between $t$ and $t+1$ at history $s^t$ and $T_t(s^t)$ are nonnegative transfers

Throughout this lecture, we shall set transfers to zero (for some issues about the limiting behavior of debt, this makes a possibly important difference from AMSS [AMSS02], who restricted transfers to be nonnegative)

In this case, the household faces a sequence of budget constraints

$$b_t(s^{t-1}) + (1-\tau_t(s^t)) n_t(s^t) = c_t(s^t) + b_{t+1}(s^t)/R_t(s^t) \tag{16}$$

The household’s first-order conditions are $u_{c,t} = \beta R_t \mathbb{E}\,_t u_{c,t+1}$ and $(1-\tau_t) u_{c,t} = u_{l,t}$

Using these to eliminate $R_t$ and $\tau_t$ from budget constraint (16) gives

$$b_t(s^{t-1}) + \frac{u_{l,t}(s^t)}{u_{c,t}(s^t)} n_t(s^t) = c_t(s^t) + {\frac{\beta (\mathbb{E}\,_t u_{c,t+1}) b_{t+1}(s^t)}{u_{c,t}(s^t)}} \tag{17}$$

or

$$u_{c,t}(s^t) b_t(s^{t-1}) + u_{l,t}(s^t) n_t(s^t) = u_{c,t}(s^t) c_t(s^t) + \beta (\mathbb{E}\,_t u_{c,t+1}) b_{t+1}(s^t) \tag{18}$$

Now define

$$x_t \equiv \beta b_{t+1}(s^t) \mathbb{E}\,_t u_{c,t+1} = u_{c,t} (s^t) {\frac{b_{t+1}(s^t)}{R_t(s^t)}} \tag{19}$$

and represent the household’s budget constraint at time $t$, history $s^t$ as

$${\frac{u_{c,t} x_{t-1}}{\beta \mathbb{E}\,_{t-1} u_{c,t}}} = u_{c,t} c_t - u_{l,t} n_t + x_t \tag{20}$$

for $t \geq 1$

### Measurability Constraints¶

Write equation (18) as

$$b_t(s^{t-1}) = c_t(s^t) - { \frac{u_{l,t}(s^t)}{u_{c,t}(s^t)}} n_t(s^t) + {\frac{\beta (\mathbb{E}\,_t u_{c,t+1}) b_{t+1}(s^t)}{u_{c,t}}} \tag{21}$$

The right side of equation (21) expresses the time $t$ value of government debt in terms of a linear combination of terms whose individual components are measurable with respect to $s^t$

The sum of terms on the right side of equation (21) must equal $b_t(s^{t-1})$

That implies that it is has to be measurable with respect to $s^{t-1}$

Equations (21) are the measurablility constraints that the AMSS model adds to the single time $0$ implementation constraint imposed in the Lucas and Stokey model

### Two Bellman Equations¶

Let $\Pi(s|s_-)$ be a Markov transition matrix whose entries tell probabilities of moving from state $s_-$ to state $s$ in one period

Let

• $V(x_-, s_-)$ be the continuation value of a continuation Ramsey plan at $x_{t-1} = x_-, s_{t-1} =s_-$ for $t \geq 1$
• $W(b, s)$ be the value of the Ramsey plan at time $0$ at $b_0=b$ and $s_0 = s$

We distinguish between two types of planners:

For $t \geq 1$, the value function for a continuation Ramsey planner satisfies the Bellman equation

$$V(x_-,s_-) = \max_{\{n(s), x(s)\}} \sum_s \Pi(s|s_-) \left[ u(n(s) - g(s), 1-n(s)) + \beta V(x(s),s) \right] \tag{22}$$

subject to the following collection of implementability constraints, one for each $s \in {\cal S}$:

$${\frac{u_c(s) x_- }{\beta \sum_{\tilde s} \Pi(\tilde s|s_-) u_c(\tilde s) }} = u_c(s) (n(s) - g(s)) - u_l(s) n(s) + x(s) \tag{23}$$

A continuation Ramsey planner at $t \geq 1$ takes $(x_{t-1}, s_{t-1}) = (x_-, s_-)$ as given and before $s$ is realized chooses $(n_t(s_t), x_t(s_t)) = (n(s), x(s))$ for $s \in {\cal S}$

The Ramsey planner takes $(b_0, s_0)$ as given and chooses $(n_0, x_0)$.

The value function $W(b_0, s_0)$ for the time $t=0$ Ramsey planner satisfies the Bellman equation

$$W(b_0, s_0) = \max_{n_0, x_0} u(n_0 - g_0, 1-n_0) + \beta V(x_0,s_0) \tag{24}$$

where maximization is subject to

$$u_{c,0} b_0 = u_{c,0} (n_0-g_0) - u_{l,0} n_0 + x_0 \tag{25}$$

### Martingale Supercedes State-Variable Degeneracy¶

Let $\mu(s|s_-) \Pi(s|s_-)$ be a Lagrange multiplier on constraint (23) for state $s$

After forming an appropriate Lagrangian, we find that the continuation Ramsey planner’s first-order condition with respect to $x(s)$ is

$$\beta V_x(x(s),s) = \mu(s|s_-) \tag{26}$$

Applying the envelope theorem to Bellman equation (22) gives

$$V_x(x_-,s_-) = \sum_s \Pi(s|s_-) \mu(s|s_-) {\frac{u_c(s)}{\beta \sum_{\tilde s} \Pi(\tilde s|s_-) u_c(\tilde s) }} \tag{27}$$

Equations (26) and (27) imply that

$$V_x(x_-, s_-) = \sum_{s} \left( \Pi(s|s_-) {\frac{u_c(s)}{\sum_{\tilde s} \Pi(\tilde s| s_-) u_c(\tilde s)}} \right) V_x(x(s), s) \tag{28}$$

Equation (28) states that $V_x(x, s)$ is a risk-adjusted martingale

Saying that $V_x(x, s)$ is a risk-adjusted martingale means that $V_x(x, s)$ is a martingale with respect to the probability distribution over $s^t$ sequences that is generated by the twisted transition probability matrix:

$$\check \Pi(s|s_-) \equiv \Pi(s|s_-) {\frac{u_c(s)}{\sum_{\tilde s} \Pi(\tilde s| s_-) u_c(\tilde s)}}$$

Exercise: Please verify that $\check \Pi(s|s_-)$ is a valid Markov transition density, i.e., that its elements are all nonnegative and that for each $s_-$, the sum over $s$ equals unity

### Absence of State Variable Degeneracy¶

Along a Ramsey plan, the state variable $x_t = x_t(s^t, b_0)$ becomes a function of the history $s^t$ and initial government debt $b_0$

In Lucas-Stokey model, we found that

• a counterpart to $V_x(x,s)$ is time invariant and equal to the Lagrange multiplier on the Lucas-Stokey implementability constraint
• time invariance of $V_x(x,s)$ is the source of a key feature of the Lucas-Stokey model, namely, state variable degeneracy (i.e., $x_t$ is an exact function of $s_t$)

That $V_x(x,s)$ varies over time according to a twisted martingale means that there is no state-variable degeneracy in the AMSS model

In the AMSS model, both $x$ and $s$ are needed to describe the state

This property of the AMSS model transmits a twisted martingale component to consumption, employment, and the tax rate

### Digression on Nonnegative Transfers¶

Throughout this lecture we have imposed that transfers $T_t = 0$

AMSS [AMSS02] instead imposed a nonnegativity constraint $T_t\geq 0$ on transfers

They also considered a special case of quasi-linear preferences, $u(c,l)= c + H(l)$

In this case, $V_x(x,s)\leq 0$ is a non-positive martingale

By the martingale convergence theorem $V_x(x,s)$ converges almost surely

Furthermore, when the Markov chain $\Pi(s| s_-)$ and the government expenditure function $g(s)$ are such that $g_t$ is perpetually random, $V_x(x, s)$ almost surely converges to zero

For quasi-linear preferences, the first-order condition with respect to $n(s)$ becomes

$$(1-\mu(s|s_-) ) (1 - u_l(s)) + \mu(s|s_-) n(s) u_{ll}(s) =0$$

When $\mu(s|s_-) = \beta V_x(x(s),x)$ converges to zero, in the limit $u_l(s)= 1 =u_c(s)$, so that $\tau(x(s),s) =0$

Thus, in the limit, if $g_t$ is perpetually random, the government accumulates sufficient assets to finance all expenditures from earnings on those assets, returning any excess revenues to the household as nonnegative lump sum transfers

### Code¶

The recursive formulation is implemented as follows

In :
using Dierckx

mutable struct BellmanEquation_Recursive{TP <: Model, TI <: Integer, TR <: Real}
model::TP
S::TI
xbar::Array{TR}
time_0::Bool
z0::Array{Array}
cFB::Vector{TR}
nFB::Vector{TR}
xFB::Vector{TR}
zFB::Vector{Vector{TR}}
end

struct RecursiveAllocation{TP <: Model,
TI <: Integer,
TVg <: AbstractVector,
TT <: Tuple}
model::TP
mc::MarkovChain
S::TI
T::BellmanEquation_Recursive
μgrid::TVg
xgrid::TVg
Vf::Array
policies::TT
end

function RecursiveAllocation(model::Model, μgrid::AbstractArray)
G = model.G
S = size(model.Π, 1)             # number of states
mc = MarkovChain(model.Π)
# now find the first best allocation
Vf, policies, T, xgrid = solve_time1_bellman(model, μgrid)
T.time_0 = true                  # Bellman equation now solves time 0 problem
return RecursiveAllocation(model, mc, S, T, μgrid, xgrid, Vf, policies)
end

function solve_time1_bellman(model::Model{TR}, μgrid::AbstractArray) where {TR <: Real}
Π = model.Π
S = size(model.Π, 1)

# First get initial fit from lucas stockey solution.
# Need to change things to be ex_ante
PP = SequentialAllocation(model)

function incomplete_allocation(PP::SequentialAllocation,
μ_::AbstractFloat,
s_::Integer)
c, n, x, V = time1_value(PP, μ_)
return c, n, dot(Π[s_, :], x), dot(Π[s_, :], V)
end

cf = Array{Function}(undef, S, S)
nf = Array{Function}(undef, S, S)
xprimef = Array{Function}(undef, S, S)
Vf = Vector{Function}(undef, S)
xgrid = Array{TR}(undef, S, length(μgrid))

for s_ in 1:S
c = Array{TR}(undef, length(μgrid), S)
n = Array{TR}(undef, length(μgrid), S)
x = Array{TR}(undef, length(μgrid))
V = Array{TR}(undef, length(μgrid))
for (i_μ, μ) in enumerate(μgrid)
c[i_μ, :], n[i_μ, :], x[i_μ], V[i_μ] =
incomplete_allocation(PP, μ, s_)
end
xprimes = repeat(x, 1, S)
xgrid[s_, :] = x
for sprime = 1:S
splc = Spline1D(x[end:-1:1], c[:, sprime][end:-1:1], k=3)
spln = Spline1D(x[end:-1:1], n[:, sprime][end:-1:1], k=3)
splx = Spline1D(x[end:-1:1], xprimes[:, sprime][end:-1:1], k=3)
cf[s_, sprime] = y -> splc(y)
nf[s_, sprime] = y -> spln(y)
xprimef[s_, sprime] = y -> splx(y)
# cf[s_, sprime] = LinInterp(x[end:-1:1], c[:, sprime][end:-1:1])
# nf[s_, sprime] = LinInterp(x[end:-1:1], n[:, sprime][end:-1:1])
# xprimef[s_, sprime] = LinInterp(x[end:-1:1], xprimes[:, sprime][end:-1:1])
end
splV = Spline1D(x[end:-1:1], V[end:-1:1], k=3)
Vf[s_] = y -> splV(y)
# Vf[s_] = LinInterp(x[end:-1:1], V[end:-1:1])
end

policies = [cf, nf, xprimef]

# Create xgrid
xbar = [maximum(minimum(xgrid)), minimum(maximum(xgrid))]
xgrid = range(xbar, xbar, length = length(μgrid))

# Now iterate on Bellman equation
T = BellmanEquation_Recursive(model, xgrid, policies)
diff = 1.0
while diff > 1e-4
PF = (i_x, x, s) -> get_policies_time1(T, i_x, x, s, Vf, xbar)
Vfnew, policies = fit_policy_function(T, PF, xgrid)

diff = 0.0
for s=1:S
diff = max(diff, maximum(abs, (Vf[s].(xgrid) - Vfnew[s].(xgrid)) ./
Vf[s].(xgrid)))
end

println("diff = $diff") Vf = copy(Vfnew) end return Vf, policies, T, xgrid end function fit_policy_function(T::BellmanEquation_Recursive, PF::Function, xgrid::AbstractVector{TF}) where {TF <: AbstractFloat} S = T.S # preallocation PFvec = Array{TF}(undef, 4S + 1, length(xgrid)) cf = Array{Function}(undef, S, S) nf = Array{Function}(undef, S, S) xprimef = Array{Function}(undef, S, S) TTf = Array{Function}(undef, S, S) Vf = Vector{Function}(undef, S) # fit policy fuctions for s_ in 1:S for (i_x, x) in enumerate(xgrid) PFvec[:, i_x] = PF(i_x, x, s_) end splV = Spline1D(xgrid, PFvec[1,:], k=3) Vf[s_] = y -> splV(y) # Vf[s_] = LinInterp(xgrid, PFvec[1, :]) for sprime=1:S splc = Spline1D(xgrid, PFvec[1 + sprime, :], k=3) spln = Spline1D(xgrid, PFvec[1 + S + sprime, :], k=3) splxprime = Spline1D(xgrid, PFvec[1 + 2S + sprime, :], k=3) splTT = Spline1D(xgrid, PFvec[1 + 3S + sprime, :], k=3) cf[s_, sprime] = y -> splc(y) nf[s_, sprime] = y -> spln(y) xprimef[s_, sprime] = y -> splxprime(y) TTf[s_, sprime] = y -> splTT(y) end end policies = (cf, nf, xprimef, TTf) return Vf, policies end function Tau(pab::RecursiveAllocation, c::AbstractArray, n::AbstractArray) model = pab.model Uc, Un = model.Uc(c, n), model.Un(c, n) return 1. .+ Un ./ (model.Θ .* Uc) end Tau(pab::RecursiveAllocation, c::Real, n::Real) = Tau(pab, [c], [n]) function time0_allocation(pab::RecursiveAllocation, B_::Real, s0::Integer) T, Vf = pab.T, pab.Vf xbar = T.xbar z0 = get_policies_time0(T, B_, s0, Vf, xbar) c0, n0, xprime0, T0 = z0, z0, z0, z0 return c0, n0, xprime0, T0 end function simulate(pab::RecursiveAllocation, B_::TF, s_0::Integer, T::Integer, sHist::Vector=simulate(pab.mc, T, init=s_0)) where {TF <: AbstractFloat} model, mc, Vf, S = pab.model, pab.mc, pab.Vf, pab.S Π, Uc = model.Π, model.Uc cf, nf, xprimef, TTf = pab.policies cHist = Array{TF}(undef, T) nHist = Array{TF}(undef, T) Bhist = Array{TF}(undef, T) xHist = Array{TF}(undef, T) TauHist = Array{TF}(undef, T) THist = Array{TF}(undef, T) μHist = Array{TF}(undef, T) #time0 cHist, nHist, xHist, THist = time0_allocation(pab, B_, s_0) TauHist = Tau(pab, cHist, nHist)[s_0] Bhist = B_ μHist = Vf[s_0](xHist) #time 1 onward for t in 2:T s_, x, s = sHist[t-1], xHist[t-1], sHist[t] c = Array{TF}(undef, S) n = Array{TF}(undef, S) xprime = Array{TF}(undef, S) TT = Array{TF}(undef, S) for sprime=1:S c[sprime], n[sprime], xprime[sprime], TT[sprime] = cf[s_, sprime](x), nf[s_, sprime](x), xprimef[s_, sprime](x), TTf[s_, sprime](x) end Tau_val = Tau(pab, c, n)[s] u_c = Uc(c, n) Eu_c = dot(Π[s_, :], u_c) μHist[t] = Vf[s](xprime[s]) cHist[t], nHist[t], Bhist[t], TauHist[t] = c[s], n[s], x/Eu_c, Tau_val xHist[t], THist[t] = xprime[s], TT[s] end return cHist, nHist, Bhist, xHist, TauHist, THist, μHist, sHist end function BellmanEquation_Recursive(model::Model{TF}, xgrid::AbstractVector{TF}, policies0::Array) where {TF <: AbstractFloat} S = size(model.Π, 1) # number of states xbar = [minimum(xgrid), maximum(xgrid)] time_0 = false z0 = Array{Array}(undef, length(xgrid), S) cf, nf, xprimef = policies0, policies0, policies0 for s in 1:S for (i_x, x) in enumerate(xgrid) cs = Array{TF}(undef, S) ns = Array{TF}(undef, S) xprimes = Array{TF}(undef, S) for j = 1:S cs[j], ns[j], xprimes[j] = cf[s, j](x), nf[s, j](x), xprimef[s, j](x) end z0[i_x, s] = vcat(cs, ns, xprimes, zeros(S)) end end cFB, nFB, IFB, xFB, zFB = find_first_best(model, S, 2) return BellmanEquation_Recursive(model, S, xbar, time_0, z0, cFB, nFB, xFB, zFB) end function get_policies_time1(T::BellmanEquation_Recursive, i_x::Integer, x::Real, s_::Integer, Vf::AbstractArray{Function}, xbar::AbstractVector) model, S = T.model, T.S β, Θ, G, Π = model.β, model.Θ, model.G, model.Π U,Uc,Un = model.U, model.Uc, model.Un S_possible = sum(Π[s_, :].>0) sprimei_possible = findall(Π[s_, :].>0) function objf(z, grad) c, xprime = z[1:S_possible], z[S_possible+1:2S_possible] n = (c .+ G[sprimei_possible]) ./ Θ[sprimei_possible] Vprime = [Vf[sprimei_possible[si]](xprime[si]) for si in 1:S_possible] return -dot(Π[s_, sprimei_possible], U.(c, n) + β * Vprime) end function cons(out, z, grad) c, xprime, TT = z[1:S_possible], z[S_possible + 1:2S_possible], z[2S_possible + 1:3S_possible] n = (c .+ G[sprimei_possible]) ./ Θ[sprimei_possible] u_c = Uc.(c, n) Eu_c = dot(Π[s_, sprimei_possible], u_c) out .= x * u_c/Eu_c - u_c .* (c - TT) - Un(c, n) .* n - β * xprime end function cons_no_trans(out, z, grad) c, xprime = z[1:S_possible], z[S_possible + 1:2S_possible] n = (c .+ G[sprimei_possible]) ./ Θ[sprimei_possible] u_c = Uc.(c, n) Eu_c = dot(Π[s_, sprimei_possible], u_c) out .= x * u_c / Eu_c - u_c .* c - Un(c, n) .* n - β * xprime end if model.transfers == true lb = vcat(zeros(S_possible), ones(S_possible)*xbar, zeros(S_possible)) if model.n_less_than_one == true ub = vcat(ones(S_possible) - G[sprimei_possible], ones(S_possible) * xbar, ones(S_possible)) else ub = vcat(100 * ones(S_possible), ones(S_possible) * xbar, 100 * ones(S_possible)) end init = vcat(T.z0[i_x, s_][sprimei_possible], T.z0[i_x, s_][2S .+ sprimei_possible], T.z0[i_x, s_][3S .+ sprimei_possible]) opt = Opt(:LN_COBYLA, 3S_possible) equality_constraint!(opt, cons, zeros(S_possible)) else lb = vcat(zeros(S_possible), ones(S_possible)*xbar) if model.n_less_than_one == true ub = vcat(ones(S_possible)-G[sprimei_possible], ones(S_possible)*xbar) else ub = vcat(ones(S_possible), ones(S_possible) * xbar) end init = vcat(T.z0[i_x, s_][sprimei_possible], T.z0[i_x, s_][2S .+ sprimei_possible]) opt = Opt(:LN_COBYLA, 2S_possible) equality_constraint!(opt, cons_no_trans, zeros(S_possible)) end init[init .> ub] = ub[init .> ub] init[init .< lb] = lb[init .< lb] min_objective!(opt, objf) lower_bounds!(opt, lb) upper_bounds!(opt, ub) maxeval!(opt, 10000000) maxtime!(opt, 10) ftol_rel!(opt, 1e-8) ftol_abs!(opt, 1e-8) (minf, minx, ret) = optimize(opt, init) if ret != :SUCCESS && ret != :ROUNDOFF_LIMITED && ret != :MAXEVAL_REACHED && ret != :FTOL_REACHED && ret != :MAXTIME_REACHED error("optimization failed: ret =$ret")
end

T.z0[i_x, s_][sprimei_possible] = minx[1:S_possible]
T.z0[i_x, s_][S .+ sprimei_possible] = minx[1:S_possible] .+ G[sprimei_possible]
T.z0[i_x, s_][2S .+ sprimei_possible] = minx[S_possible .+ 1:2S_possible]
if model.transfers == true
T.z0[i_x, s_][3S .+ sprimei_possible] = minx[2S_possible + 1:3S_possible]
else
T.z0[i_x, s_][3S .+ sprimei_possible] = zeros(S)
end

return vcat(-minf, T.z0[i_x, s_])
end

function get_policies_time0(T::BellmanEquation_Recursive,
B_::Real,
s0::Integer,
Vf::AbstractArray{Function},
xbar::AbstractVector)
model = T.model
β, Θ, G = model.β, model.Θ, model.G
U, Uc, Un = model.U, model.Uc, model.Un

c, xprime = z, z
n = (c + G[s0]) / Θ[s0]
return -(U(c, n) + β * Vf[s0](xprime))
end

c, xprime, TT = z, z, z
n = (c + G[s0]) / Θ[s0]
return -Uc(c, n) * (c - B_ - TT) - Un(c, n) * n - β * xprime
end

if model.transfers == true
lb = [0.0, xbar, 0.0]
if model.n_less_than_one == true
ub = [1 - G[s0], xbar, 100]
else
ub = [100.0, xbar, 100.0]
end
init = vcat(T.zFB[s0], T.zFB[s0], T.zFB[s0])
init = [0.95124922, -1.15926816,  0.0]
opt = Opt(:LN_COBYLA, 3)
equality_constraint!(opt, cons)
else
lb = [0.0, xbar]
if model.n_less_than_one == true
ub = [1-G[s0], xbar]
else
ub = [100, xbar]
end
init = vcat(T.zFB[s0], T.zFB[s0])
init = [0.95124922, -1.15926816]
opt = Opt(:LN_COBYLA, 2)
equality_constraint!(opt, cons_no_trans)
end
init[init .> ub] = ub[init .> ub]
init[init .< lb] = lb[init .< lb]

min_objective!(opt, objf)
lower_bounds!(opt, lb)
upper_bounds!(opt, ub)
maxeval!(opt, 100000000)
maxtime!(opt, 30)

(minf, minx, ret) = optimize(opt, init)

if ret != :SUCCESS && ret != :ROUNDOFF_LIMITED && ret != :MAXEVAL_REACHED &&
ret != :FTOL_REACHED

• Share page