Revert "Update sources from lecture-python-advanced (ce9441dad2ec187b4c93cfca6225aa68818dd033) using sphinx-tomyst + adjustment"

This reverts commit 5f277a1.

Author: mmcky

lectures/opt_tax_recur.md

@@ -31,7 +31,6 @@ In addition to what's in Anaconda, this lecture will need the following librarie
 tags: [hide-output]
 ---
 !pip install --upgrade quantecon
-!pip install interpolation
 ```
 
 ## Overview
@@ -71,12 +70,6 @@ Let's start with some standard imports:
 import numpy as np
 import matplotlib.pyplot as plt
 %matplotlib inline
-from scipy.optimize import root
-from quantecon import MarkovChain
-from quantecon.optimize.nelder_mead import nelder_mead
-from interpolation import interp
-from numba import njit, prange, float64
-from numba.experimental import jitclass
 ```
 
 ## A Competitive Equilibrium with Distorting Taxes
@@ -724,7 +717,7 @@ $$
 
 ### Sequence Implementation
 
-The above steps are implemented in a class called SequentialLS
+The above steps are implemented in a class called SequentialAllocation
 
 ```{code-cell} python3
 :load: _static/lecture_specific/opt_tax_recur/sequential_allocation.py
@@ -739,7 +732,7 @@ appears to be a purely “forward-looking” variable.
 
 But $x_t(s^t)$ is  a  natural candidate for a state variable in
 a recursive formulation of the Ramsey problem, one that records history-dependence and so is
-`backward-looking`.
+``backward-looking''.
 
 ### Intertemporal Delegation
 
@@ -1026,7 +1019,7 @@ through them, the value of initial government debt $b_0$.
 
 ### Recursive Implementation
 
-The above steps are implemented in a class called `RecursiveLS`.
+The above steps are implemented in a class called `RecursiveAllocation`.
 
 ```{code-cell} python3
 :load: _static/lecture_specific/opt_tax_recur/recursive_allocation.py
@@ -1094,31 +1087,39 @@ We can now plot the Ramsey tax  under both realizations of time $t = 3$ governme
 * red when $g_3 = .2$
 
 ```{code-cell} python3
-π = np.array([[0, 1, 0,   0,   0,  0],
-              [0, 0, 1,   0,   0,  0],
-              [0, 0, 0, 0.5, 0.5,  0],
-              [0, 0, 0,   0,   0,  1],
-              [0, 0, 0,   0,   0,  1],
-              [0, 0, 0,   0,   0,  1]])
-
-g = np.array([0.1, 0.1, 0.1, 0.2, 0.1, 0.1])
-crra_pref = CRRAutility()
+time_π = np.array([[0, 1, 0,   0,   0,  0],
+                   [0, 0, 1,   0,   0,  0],
+                   [0, 0, 0, 0.5, 0.5,  0],
+                   [0, 0, 0,   0,   0,  1],
+                   [0, 0, 0,   0,   0,  1],
+                   [0, 0, 0,   0,   0,  1]])
+
+time_G = np.array([0.1, 0.1, 0.1, 0.2, 0.1, 0.1])
+# Θ can in principle be random
+time_Θ = np.ones(6)
+time_example = CRRAutility(π=time_π, G=time_G, Θ=time_Θ)
 
 # Solve sequential problem
-seq = SequentialLS(crra_pref, π=π, g=g)
+time_allocation = SequentialAllocation(time_example)
 sHist_h = np.array([0, 1, 2, 3, 5, 5, 5])
 sHist_l = np.array([0, 1, 2, 4, 5, 5, 5])
-sim_seq_h = seq.simulate(1, 0, 7, sHist_h)
-sim_seq_l = seq.simulate(1, 0, 7, sHist_l)
+sim_seq_h = time_allocation.simulate(1, 0, 7, sHist_h)
+sim_seq_l = time_allocation.simulate(1, 0, 7, sHist_l)
+
+# Government spending paths
+sim_seq_l[4] = time_example.G[sHist_l]
+sim_seq_h[4] = time_example.G[sHist_h]
 
-fig, axes = plt.subplots(3, 2, figsize=(14, 10))
+# Output paths
+sim_seq_l[5] = time_example.Θ[sHist_l] * sim_seq_l[1]
+sim_seq_h[5] = time_example.Θ[sHist_h] * sim_seq_h[1]
+
+fig, axes = plt.subplots(3, 2, figsize=(12, 8))
 titles = ['Consumption', 'Labor Supply', 'Government Debt',
           'Tax Rate', 'Government Spending', 'Output']
 
 for ax, title, sim_l, sim_h in zip(axes.flatten(),
-                                   titles,
-                                   sim_seq_l[:6],
-                                   sim_seq_h[:6]):
+        titles, sim_seq_l, sim_seq_h):
     ax.set(title=title)
     ax.plot(sim_l, '-ok', sim_h, '-or', alpha=0.7)
     ax.grid()
@@ -1226,16 +1227,18 @@ $t=0$ and time $t\geq1$ as functions of the initial government debt
 above)
 
 ```{code-cell} python3
-tax_seq = SequentialLS(CRRAutility(), g=np.array([0.15]), π=np.ones((1, 1)))
+tax_sequence = SequentialAllocation(CRRAutility(G=0.15,
+                                                π=np.ones((1, 1)),
+                                                Θ=np.ones(1)))
 
 n = 100
 tax_policy = np.empty((n, 2))
 interest_rate = np.empty((n, 2))
 gov_debt = np.linspace(-1.5, 1, n)
 
 for i in range(n):
-    tax_policy[i] = tax_seq.simulate(gov_debt[i], 0, 2)[3]
-    interest_rate[i] = tax_seq.simulate(gov_debt[i], 0, 3)[-1]
+    tax_policy[i] = tax_sequence.simulate(gov_debt[i], 0, 2)[3]
+    interest_rate[i] = tax_sequence.simulate(gov_debt[i], 0, 3)[-1]
 
 fig, axes = plt.subplots(2, 1, figsize=(10,8), sharex=True)
 titles = ['Tax Rate', 'Gross Interest Rate']
@@ -1295,16 +1298,18 @@ Ramsey planner and what a new Ramsey planner would choose for its
 time $t=0$ tax rate
 
 ```{code-cell} python3
-tax_seq = SequentialLS(CRRAutility(), g=np.array([0.15]), π=np.ones((1, 1)))
+tax_sequence = SequentialAllocation(CRRAutility(G=0.15,
+                                                π=np.ones((1, 1)),
+                                                Θ=np.ones(1)))
 
 n = 100
 tax_policy = np.empty((n, 2))
 τ_reset = np.empty((n, 2))
 gov_debt = np.linspace(-1.5, 1, n)
 
 for i in range(n):
-    tax_policy[i] = tax_seq.simulate(gov_debt[i], 0, 2)[3]
-    τ_reset[i] = tax_seq.simulate(gov_debt[i], 0, 1)[3]
+    tax_policy[i] = tax_sequence.simulate(gov_debt[i], 0, 2)[3]
+    τ_reset[i] = tax_sequence.simulate(gov_debt[i], 0, 1)[3]
 
 fig, ax = plt.subplots(figsize=(10, 6))
 ax.plot(gov_debt, tax_policy[:, 1], gov_debt, τ_reset, lw=2)
@@ -1363,32 +1368,38 @@ The figure below plots a sample path of the Ramsey tax rate
 ```{code-cell} python3
 log_example = LogUtility()
 # Solve sequential problem
-seq_log = SequentialLS(log_example)
+seq_log = SequentialAllocation(log_example)
 
 # Initialize grid for value function iteration and solve
-x_grid = np.linspace(-3., 3., 200)
-
+μ_grid = np.linspace(-0.6, 0.0, 200)
 # Solve recursive problem
-rec_log = RecursiveLS(log_example, x_grid)
+bel_log = RecursiveAllocation(log_example, μ_grid)
 
-T_length = 20
-sHist = np.array([0, 0, 0, 0, 0,
-                  0, 0, 0, 1, 1,
-                  0, 0, 0, 1, 1,
-                  1, 1, 1, 1, 0])
+T = 20
+sHist = np.array([0, 0, 0, 0, 0, 0, 0,
+                  0, 1, 1, 0, 0, 0, 1,
+                  1, 1, 1, 1, 1, 0])
 
 # Simulate
-sim_seq = seq_log.simulate(0.5, 0, T_length, sHist)
-sim_rec = rec_log.simulate(0.5, 0, T_length, sHist)
+sim_seq = seq_log.simulate(0.5, 0, T, sHist)
+sim_bel = bel_log.simulate(0.5, 0, T, sHist)
 
-fig, axes = plt.subplots(3, 2, figsize=(14, 10))
+# Government spending paths
+sim_seq[4] = log_example.G[sHist]
+sim_bel[4] = log_example.G[sHist]
+
+# Output paths
+sim_seq[5] = log_example.Θ[sHist] * sim_seq[1]
+sim_bel[5] = log_example.Θ[sHist] * sim_bel[1]
+
+fig, axes = plt.subplots(3, 2, figsize=(10, 6))
 titles = ['Consumption', 'Labor Supply', 'Government Debt',
           'Tax Rate', 'Government Spending', 'Output']
 
-for ax, title, sim_s, sim_b in zip(axes.flatten(), titles, sim_seq[:6], sim_rec[:6]):
-                                   ax.plot(sim_s, '-ob', sim_b, '-xk', alpha=0.7)
-                                   ax.set(title=title)
-                                   ax.grid()
+for ax, title, sim_s, sim_b in zip(axes.flatten(), titles, sim_seq, sim_bel):
+    ax.plot(sim_s, '-ob', sim_b, '-xk', alpha=0.7)
+    ax.set(title=title)
+    ax.grid()
 
 axes.flatten()[0].legend(('Sequential', 'Recursive'))
 fig.tight_layout()