#!/usr/bin/env python # coding: utf-8 # # 2018-02-01 Convergence to Balanced Growth Path # ## Setting up the Python/Jupyter environment # In[1]: get_ipython().run_cell_magic('javascript', '', '\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n return false;}\n') # In[2]: # keep output cells from shifting to autoscroll: little scrolling # subwindows within the notebook are an annoyance... # In[3]: # set up the environment by reading in every library we might need: # os... graphics... data manipulation... time... math... statistics... import sys import os from urllib.request import urlretrieve import matplotlib as mpl import matplotlib.pyplot as plt from IPython.display import Image import pandas as pd from pandas import DataFrame, Series from datetime import datetime import scipy as sp import numpy as np import math import random import seaborn as sns import statsmodels import statsmodels.api as sm import statsmodels.formula.api as smf # report library versions... # In[4]: get_ipython().run_line_magic('matplotlib', 'inline') # put graphs into the notebook itself... # In[5]: # graphics setup: seaborn-whitegrid and figure size... plt.style.use('seaborn-whitegrid') figure_size = plt.rcParams["figure.figsize"] figure_size[0] = 12 figure_size[1] = 10 plt.rcParams["figure.figsize"] = figure_size # ## 4.3.3 Understanding the Solow Model # # ### 4.3.3.1 Deriving the Balanced Growth Path for Output per Worker # # Along what path for output per worker will the balanced-growth equilibrium condition be satisfied? Y/L is, after all, our best simple proxy for the economy’s overall level of prosperity: for material standards of living and for the possession by the economy of the resources needed to diminish poverty. Let’s calculate the level of output per worker Y/L along the balanced-growth path. # # Begin with the capital-output ratio version of the production function that we just calculated above: # # (4.3.5) # $ \left(\frac{Y}{L}\right) = \left(\frac{K}{Y}\right)^{\frac{α}{1-α}} \left(E\right) $ # # Since the economy is on its balanced-growth path, it satisfies the equilibrium con dition K/Y = s/(n + g + δ). Substitute that in: # # (4.3.6) # $ \left(\frac{Y}{L}\right) = \left(\frac{s}{n+g+δ}\right)^{\frac{α}{1-α}} \left(E\right) $ # # s, n, g, δ, and α are all constants, and so [s/(n + g + δ)]^(α/(1-α));is a constant as well. This tells us that along the balanced-growth path, output per worker is simply a constant multiple of the efficiency of labor, with the multiple equal to: # # (4.3.7) # $ \left(\frac{s}{n+g+δ}\right)^{\frac{α}{1-α}} $ # # Over time, the efficiency of labor grows. Each year it is g percent higher than the last year. Since along the balanced-growth path output per worker Y/L is just a constant multiple of the efficiency of labor, it too must be growing at the same proportional rate g. # # Now it is time to introduce time subscripts, for we want to pay attention to where the economy is now, where it was whence, and where it will be when. So rewrite (4.3.6) as: # # (4.3.8) # $ \left(\frac{Y_t}{L_t}\right) = \left(\frac{s}{n+g+δ}\right)^{\frac{α}{1-α}} \left(E_t\right) $ # # Paying attention to the equations for how labor efficiency and the labor force grow over time, $ E_t = E_0(1 + g)^t $ and $ L_t = L_0(1 + n)^t $, we can plug in and solve for what Y/L and Y will be at any time t—as long as the economy is on its balanced-growth path. # # ---- # # # ### 4.3.3.2 Interpreting the Balanced Growth Path for Output per Worker # # We now see how capital intensity and technological and organizational progress drive economic growth. Capital intensity—the economy’s capital-output ratio—determines what is the multiple of the current efficiency of labor E that balanced-growth path output per worker Y/L is. Things that increase capital intensity—raise the capital-output ratio—make balanced-growth output per worker a higher multiple of the efficiency of labor. Thus they make the economy richer. Things that reduce capital intensity make balanced-growth output per worker a lower multiple of the efficiency of labor, and so make the economy poorer. # # Suppose that α is 1/2, so that α/(l—α) is 1, and that s is equal to three times n + g + δ, so that the balanced-growth capital-output ratio is 3. Then balanced-growth output per worker is simply equal to three times the efficiency of labor. If we consider another economy with twice the saving rate s, its balanced-growth capital-output ratio is 6, and its balanced-growth level of output per worker is twice as great a multiple of the level of the efficiency of labor. # # The higher is the parameter α—that is, the slower diminishing returns to investment set in—the stronger is the effect of changes in the economy’s balanced-growth capital intensity on the level of output per worker, and the more important are thrift and investment incentives and other factors that influence s relative to those that influence the efficiency of labor. # # Note—this is important- that changes in the economy’s capital intensity shift the balanced-growth path up or down to a different multiple of the efficiency of labor, but the growth rate of Y/L along the balanced-growth path is simply the rate of growth g of the efficiency of labor E. The material standard of living grows at the same rate as labor efficiency. # # To change the very long run growth rate of the economy you need to change how fast the efficiency of labor grows. Changes in the economy that merely alter the capital-output ratio will not do it. # # This is what tells us that technology, organization, worker skills—all those things that increase the efficiency of labor and keep on increasing it—are ultimately more important to growth in output per worker than saving and investment. The U.S. economy experienced a large increase in its capital-output ratio in the late nineteenth century. It may be experiencing a similar increase now, as we invest more and more in computers. But the Gilded Age industrialization came to an end, and the information technology revolution will run its course. Aside from these episodes, it is growth in the efficiency of labor E that sustains and accounts for the lion’s share of long-run economic growth. # # ---- # # # ### 4.3.3.3 Off the Balanced Growth Path # # To calculate what output per worker would be if the economy were to be on its balanced-growth path is a straightforward three-step procedure: # # 1. Calculate the balanced-growth equilibrium capital-output ratio s/(n + g + δ), the saving rate s divided by the sum of the labor-force growth rate n, the efficiency of labor growth rate g, and the depreciation rate δ. # 2. Raise the balanced-growth capital-output ratio to the α/(l-α) power, where α is the diminishing-retums-to-investment parameter in the production function. # 3. Multiply the result by the current value of the efficiency of labor E. The result is the current value of what output per worker would be if the economy were on its balanced growth path, and the path traced out by that result as E grows over time is the balanced-growth path for output per worker. # # But is this of use if the economy is not on its balanced growth path? # # How can we use a model which assumes that the economy is on its balanced-growth path to analyze a sit uation in which the economy is not on that path? We still can use the model—and this is an important part of the magic of economics—because being on the balanced-growth path is an equilibrium condition. In an economic model, the thing to do if an equilibrium condition is not satisfied is to wait and, after a while, look again. When we look again, it will be satisfied. # Whenever the capital-output ratio K/Y is above its balanced-growth equilibrium value s/(n + g + δ), K/Y is falling: Investment is insufficient to keep the capital stock growing as fast as output. Whenever K/Y is below its balanced-growth equilibrium value, K/Y is rising: Capital stock growth outruns output. And as the capital-output ratio converges to its balanced-growth value, so does the economy’s level of output per worker converge to its balanced-growth path. # # The fact that an economy converges to its balanced-growth path makes analyzing the long-run growth of an economy relatively easy as well even when the economy is not on its balanced-growth path: # # 1. Calculate the balanced-growth path. # 2. From the balanced-growth path, forecast the future of the economy: If the # economy is on its balanced-growth path today, it will stay on that path in the future (unless some of the parameters—n, g, δ, s, and α—change). # 3. If those parameters change, calculate the new, shifted balanced-growth path and predict that the economy will head for it. # 4. If the economy is not on its balanced-growth path today, it is heading for that path and will get there eventually. # # Thus _long run_ economic forecasting becomes simple. All you have to do is predict that the economy will head for its balanced-growth path, and calculate what the balanced-growth path is. # # ---- # # # ### 4.3.3.4 Converging to the Balanced Growth Path # # How fast does an economy head for its balanced-growth path? Does the convergence of an economy following the Solow growth model to its balanced-growth path take a year, or five years, or is it a matter of decades? # # It is a matter of decades. But to see this requires more algebra: # # Those of you for whom calculus is a tool and an intellectual force multiplier rather than a ritualistic obstacle to thought can start with the output form of the production function: # # (4.3.9) # $ Y = K^α(EL)^{(1-α)} $ # # Take first logarithms, and then derivatives to obtain: # # (4.3.10) # $\frac{d(ln(Y_{t}))}{dt} = \alpha\frac{d(ln(K_t))}{dt} + (1-\alpha)\frac{d(ln(E_t))}{dt} + (1-\alpha)\frac{d(ln(L_t))}{dt}$ # # Note that since the derivative of a logarithm is simply a proportional growth rate, that (4.3.10) is an equation that tells us that—on or off of the balanced-growth path—the proportional growth rate of output is a function of the parameter α and of the growth rates of the capital stock, the labor force, and the efficiency of labor. # # To keep those of you for whom math is not so much a tool and intellectual force multiplier on the same page, we are simply going to write "g_x" for the proportional growth rate of an economic variable X. Thus g_Y is the proportional growth rate of output Y. g_K is the proportional growth rate of the capital stock K. And so forth. # # (4.3.10) can then become a friendlier form: an equation about growth rates, an equation the truth of which isbuilt into the definitions of logarithms, proportional growth rates, and the Cobb-Douglas production function: # # (4.3.10') # $ g_Y = αg_K + (1-α)g_L + (1-α)g_E $ # # We know what the proportional growth rates of the labor force L and labor efficiency E are in the Solow model: they are n and g: # # (4.3.11) # $ g_Y = αg_K + (1-α)(n + g) $ # # Now subtract both sides of this from the growth rate of the capital stock: # # (4.3.12) # $ g_K - g_Y = (1-α)g_K - (1-α)(n + g) $ # # We are almost done. Then to determine what the growth rate of the capital stock is, we simply take its change, sY - δK, and divide it by its level, K—but only on the right hand side: # # (4.3.13) # $ g_K - g_Y = (1-α)\left(s\left(\frac{Y}{K}\right) - δ\right) - (1-α)(n + g) $ # # The proportional growth rate of the quotient of two variables is just the difference between the proportional growth rates of the numerator and the denominator. Thus the left hand side is: # # (4.3.14) # $ g_{K/Y} = (1-α)s\left(\frac{Y}{K}\right) - (1-α)(n + g + δ) $ # # And since the proportional growth rate of a variable is its rate of change divided by its level, the left hand side is: # # (4.3.15) # $ \frac{d(K/Y)/dt}{K/Y} = (1-α)s\left(\frac{Y}{K}\right) - (1-α)(n + g + δ) $ # # Getting rid of the denominator on the left-hand side: # # (4.3.16) # $ \frac{d(K/Y)}{dt} = (1-α)s - (1-α)(n + g + δ)\left(\frac{K}{Y}\right) $ # # (4.3.17) # $ \frac{d(K/Y)}{dt} = - (1-α)(n + g + δ)\left(\frac{K}{Y} - \frac{s}{n + g + δ}\right) $ # # This equation tells us three things: # # * When the capital-output ratio K/Y is equal to s/(n+g+δ), it is indeed the case that it is stable. # # * When K/Y is above that s/(n+g+δ) value, it is falling; when it is below, it is rising. # # * The speed with which it is falling or rising is always proportional to the gap between K/Y and s/(n+g+δ), with the factor of proportionality equal to (1-α)(n+g+δ) # # ---- # # # ### 4.3.3.5 Solving for the Time Path of the Capital-Labor Ratio # # This march through algebra has just confirmed the arguments made so far. So what extra good—besides serving as a check on correctness—has this algebra done us? # # It has done us good because equation (4.3.17) is a very special equation: it has a rate of change of something on the left hand side. It has the level of something on the right hand side. It has a negative constant multiplying the level. It is a _convergent exponential_. The function that satisfies this equation is: # # (4.3.18) # $ \frac{K_t}{Y_t} = \frac{s}{\delta + n + g} + \left(C - \frac{s}{\delta + n + g}\right) e^{-(1 - \alpha)(\delta + g + n)t} $ # # for the appropriate constant C. # # What is the value of this constant C? Well, we know what the capital-output ratio is right now, when we start our analysis, which we might as well take to be the time t = 0. If we do take now to be time t = 0, and take K₀/Y₀ for the capital output tday, then we can substitute in for the constant C: # # (4.3.19) # $ \frac{K_t}{Y_t} = \frac{s}{\delta + n + g} + \left(\frac{K_0}{Y_0} - \frac{s}{\delta + n + g}\right) e^{-(1 - \alpha)(\delta + g + n)t} $ # # This tells us that, when it is off the equilibrium balanced-growth path, the capital-output ratio of a Solow growth model economy is a weighted average of (a) its initial capital-output ratio K₀/Y₀ and (b) its long-run balanced-growth capital-output ratio s/(n+g+δ), with the weight placed on the first declining exponentially according to the function exp(-(1-α)(n + g + δ)t) # # This tells us that, in the Solow growth model, an economy will close a fraction (1 — α)(n + g + δ) of the gap between its current position and the balanced-growth path each year. If (1 — α)(n + g + δ) turns out to be equal to 0.05, the capital-output ratio will close 5 percent of the gap between its current level and its balanced-growth value each year. It would close half of the gap in fourteen years. It would close three-quarters of the gap in 28 years. # # The Solow growth model is thus definitely a long-run model. It predicts that in the short run things will pretty much stay as they have been. If that is not right—if there are interesting and important fluctuations in the short run—the Solow model knows nothing about them. For them we will have to turn to the models of Chapter 6 and beyond. # In[6]: # convergence to the balanced growth path # # we need to alter our dataframe in order to add a BGP line # # # we are going to want to see what happens for lots of # different model parameter values and initial conditions, # so stuff our small simulation program inside a function, so # we can then invoke it with a single line... def sgm_bgp_100yr_run(L0, E0, K0, n=0.01, g=0.02, s=0.15, alpha=0.5, delta=0.03, T = 100): sg_df = pd.DataFrame(index=range(T),columns=['Labor', 'Efficiency', 'Capital', 'Output', 'Output_per_Worker', 'Capital_Output_Ratio', 'BGP_Output', 'BGP_Output_per_Worker', 'BGP_Capital_Output_Ratio', 'BGP_Capital'], dtype='float') sg_df.Labor[0] = L0 sg_df.Efficiency[0] = E0 sg_df.Capital[0] = K0 sg_df.Output[0] = (sg_df.Capital[0]**alpha * (sg_df.Labor[0] * sg_df.Efficiency[0])**(1-alpha)) sg_df.Output_per_Worker[0] = sg_df.Output[0]/sg_df.Labor[0] sg_df.Capital_Output_Ratio[0] = sg_df.Capital[0]/sg_df.Output[0] sg_df.BGP_Capital_Output_Ratio[0] = (s / (n + g + delta)) sg_df.BGP_Output_per_Worker[0] = sg_df.Efficiency[0] * ( sg_df.BGP_Capital_Output_Ratio[0]*(alpha/(1 - alpha))) sg_df.BGP_Output[0] = sg_df.BGP_Output_per_Worker[0] * sg_df.Labor[0] sg_df.BGP_Capital[0] = sg_df.Labor[0] * sg_df.Efficiency[0] * ( sg_df.BGP_Capital_Output_Ratio[0]*(1/(1 - alpha))) for i in range(T): sg_df.Labor[i+1] = sg_df.Labor[i] + sg_df.Labor[i] * n sg_df.Efficiency[i+1] = sg_df.Efficiency[i] + sg_df.Efficiency[i] * g sg_df.Capital[i+1] = sg_df.Capital[i] - sg_df.Capital[i] * delta + ( sg_df.Output[i] * s) sg_df.Output[i+1] = (sg_df.Capital[i+1]**alpha * (sg_df.Labor[i+1] * sg_df.Efficiency[i+1])**(1-alpha)) sg_df.Output_per_Worker[i+1] = sg_df.Output[i+1]/sg_df.Labor[i+1] sg_df.Capital_Output_Ratio[i+1] = (sg_df.Capital[i+1]/ sg_df.Output[i+1]) sg_df.BGP_Capital_Output_Ratio[i+1] = (s / (n + g + delta)) sg_df.BGP_Output_per_Worker[i+1] = sg_df.Efficiency[i+1] * ( sg_df.BGP_Capital_Output_Ratio[i+1]**(alpha/(1 - alpha))) sg_df.BGP_Output[i+1] = (sg_df.BGP_Output_per_Worker[i+1] * sg_df.Labor[i+1]) sg_df.BGP_Capital[i+1] = (s / (n + g + delta))**(1/(1-alpha)) * ( sg_df.Efficiency[i+1] * sg_df.Labor[i+1]) fig = plt.figure(figsize=(12, 12)) ax1 = plt.subplot(3,2,1) sg_df.Labor.plot(ax = ax1, title = "Labor Force") plt.ylabel("Parameters") plt.ylim(0, ) ax2 = plt.subplot(3,2,2) sg_df.Efficiency.plot(ax = ax2, title = "Efficiency of Labor") plt.ylim(0, ) ax3 = plt.subplot(3,2,3) sg_df.BGP_Capital.plot(ax = ax3, title = "BGP Capital Stock") sg_df.Capital.plot(ax = ax3, title = "Capital Stock") plt.ylabel("Values") plt.ylim(0, ) ax4 = plt.subplot(3,2,4) sg_df.BGP_Output.plot(ax = ax4, title = "BGP Output") sg_df.Output.plot(ax = ax4, title = "Output") plt.ylim(0, ) ax5 = plt.subplot(3,2,5) sg_df.BGP_Output_per_Worker.plot(ax = ax5, title = "BGP Output per Worker") sg_df.Output_per_Worker.plot(ax = ax5, title = "Output per Worker") plt.xlabel("Years") plt.ylabel("Ratios") plt.ylim(0, ) ax6 = plt.subplot(3,2,6) sg_df.BGP_Capital_Output_Ratio.plot(ax = ax6, title = "BGP Capital-Output Ratio") sg_df.Capital_Output_Ratio.plot(ax = ax6, title = "Capital-Output Ratio") plt.xlabel("Years") plt.ylim(0, ) plt.suptitle('Solow Growth Model: Simulation Run', size = 20) plt.show() print(n, "is the labor force growth rate") print(g, "is the efficiency of labor growth rate") print(delta, "is the depreciation rate") print(s, "is the savings rate") print(alpha, "is the decreasing-returns-to-scale parameter") # In[7]: sgm_bgp_100yr_run(1000, 1, 100, n=0.005, g=0.01, s=0.225, alpha=0.5, delta=0.03) # In[8]: # convergence to the balanced growth path—log graphs # # we need to alter our dataframe in order to add a BGP line # # # we are going to want to see what happens for lots of # different model parameter values and initial conditions, # so stuff our small simulation program inside a function, so # we can then invoke it with a single line... def log_sgm_bgp_100yr_run(L0, E0, K0, n=0.01, g=0.02, s=0.15, alpha=0.5, delta=0.03, T=100): sg_df = pd.DataFrame(index=range(T),columns=['Labor', 'Efficiency', 'Capital', 'Output', 'Output_per_Worker', 'Capital_Output_Ratio', 'BGP_Output', 'BGP_Output_per_Worker', 'BGP_Capital_Output_Ratio', 'BGP_Capital'], dtype='float') sg_df.Labor[0] = L0 sg_df.Efficiency[0] = E0 sg_df.Capital[0] = K0 sg_df.Output[0] = (sg_df.Capital[0]**alpha * (sg_df.Labor[0] * sg_df.Efficiency[0])**(1-alpha)) sg_df.Output_per_Worker[0] = sg_df.Output[0]/sg_df.Labor[0] sg_df.Capital_Output_Ratio[0] = sg_df.Capital[0]/sg_df.Output[0] sg_df.BGP_Capital_Output_Ratio[0] = (s / (n + g + delta)) sg_df.BGP_Output_per_Worker[0] = sg_df.Efficiency[0] * sg_df.BGP_Capital_Output_Ratio[0]*(alpha/(1 - alpha)) sg_df.BGP_Output[0] = sg_df.BGP_Output_per_Worker[0] * sg_df.Labor[0] sg_df.BGP_Capital[0] = (s / (n + g + delta))**(1/(1-alpha)) * sg_df.Efficiency[0] * sg_df.Labor[0] for i in range(T): sg_df.Labor[i+1] = sg_df.Labor[i] + sg_df.Labor[i] * n sg_df.Efficiency[i+1] = sg_df.Efficiency[i] + sg_df.Efficiency[i] * g sg_df.Capital[i+1] = sg_df.Capital[i] - sg_df.Capital[i] * delta + sg_df.Output[i] * s sg_df.Output[i+1] = (sg_df.Capital[i+1]**alpha * (sg_df.Labor[i+1] * sg_df.Efficiency[i+1])**(1-alpha)) sg_df.Output_per_Worker[i+1] = sg_df.Output[i+1]/sg_df.Labor[i+1] sg_df.Capital_Output_Ratio[i+1] = sg_df.Capital[i+1]/sg_df.Output[i+1] sg_df.BGP_Capital_Output_Ratio[i+1] = (s / (n + g + delta)) sg_df.BGP_Output_per_Worker[i+1] = sg_df.Efficiency[i+1] * sg_df.BGP_Capital_Output_Ratio[i+1]**(alpha/(1 - alpha)) sg_df.BGP_Output[i+1] = sg_df.BGP_Output_per_Worker[i+1] * sg_df.Labor[i+1] sg_df.BGP_Capital[i+1] = (s / (n + g + delta))**(1/(1-alpha)) * sg_df.Efficiency[i+1] * sg_df.Labor[i+1] fig = plt.figure(figsize=(12, 12)) ax1 = plt.subplot(3,2,1) np.log(sg_df.Labor).plot(ax = ax1, title = "Labor Force") plt.ylabel("Log Values") plt.ylim(0, ) ax2 = plt.subplot(3,2,2) np.log(sg_df.Efficiency).plot(ax = ax2, title = "Efficiency of Labor") plt.ylim(0, ) ax3 = plt.subplot(3,2,3) np.log(sg_df.BGP_Capital).plot(ax = ax3, title = "BGP Capital Stock") np.log(sg_df.Capital).plot(ax = ax3, title = "Capital Stock") plt.ylabel("Log Values") plt.ylim(0, ) ax4 = plt.subplot(3,2,4) np.log(sg_df.BGP_Output).plot(ax = ax4, title = "BGP Output") np.log(sg_df.Output).plot(ax = ax4, title = "Output") plt.ylim(0, ) ax5 = plt.subplot(3,2,5) np.log(sg_df.BGP_Output_per_Worker).plot(ax = ax5, title = "BGP Output per Worker") np.log(sg_df.Output_per_Worker).plot(ax = ax5, title = "Output per Worker") plt.xlabel("Years") plt.ylabel("Log Ratios") plt.ylim(0, ) ax6 = plt.subplot(3,2,6) np.log(sg_df.BGP_Capital_Output_Ratio).plot(ax = ax6, title = "BGP Capital-Output Ratio") np.log(sg_df.Capital_Output_Ratio).plot(ax = ax6, title = "Capital-Output Ratio") plt.xlabel("Years") plt.ylim(0, ) plt.suptitle('Solow Growth Model: Simulation Run: Log Scale', size = 20) plt.show() print(n, "is the labor force growth rate") print(g, "is the efficiency of labor growth rate") print(delta, "is the depreciation rate") print(s, "is the savings rate") print(alpha, "is the decreasing-returns-to-scale parameter") log_sgm_bgp_100yr_run(1000, 1, 100, n=0.005, g=0.01, s=0.24, alpha=0.5, delta=0.03) # In[9]: log_sgm_bgp_100yr_run(1000, 1, 50000, n=0.005, g=0.01, s=0.24, alpha=0.5, delta=0.03) # In[10]: # suppose we started the economy on some balanced growth path, say # for s = 0.20. And then s jumped to 0.25. What would happen? # # n=0.01, g=0.01, delta=0.03, s=0.20, alpha=0.5... # SS K/Y = 4... # Y/L = 4 x E # K/L = 16 x E # # start the economy on its balanced growth path... log_sgm_bgp_100yr_run(1000, 1, 16000, n=0.01, g=0.01, s=0.20, alpha=0.5, delta=0.03) # In[11]: # yup... # we can look at it in levels too: sgm_bgp_100yr_run(1000, 1, 16000, n=0.01, g=0.01, s=0.20, alpha=0.5, delta=0.03) # In[12]: # Now, from the s = 0.20 BGP, what happens if we suddenly jump s to 0.25 # and keep it there? # # This happens: log_sgm_bgp_100yr_run(1000, 1, 16000, n=0.01, g=0.01, s=0.25, alpha=0.5, delta=0.03) # In[13]: # in levels: sgm_bgp_100yr_run(1000, 1, 16000, n=0.01, g=0.01, s=0.25, alpha=0.5, delta=0.03) # In[14]: # in the U.S. today: n = 0.01 g = 0.015 delta = 0.03 sinitial = 0.22 alpha = 0.333 KoverYstarinitial = sinitial/(n + g + delta) E = 65068 YoverLstarinitial = KoverYstarinitial**(alpha/(1-alpha)) * E print(KoverYstarinitial, "= KoverYstarinitial") print(YoverLstarinitial, "= YoverLstarinitial") # In[15]: # a "what if"—if the tax "reform" were to boost the savings rate by # 1.4% points... n = 0.01 g = 0.015 delta = 0.03 sfinal = 0.234 alpha = 0.333 KoverYstarfinal = sfinal/(n + g + delta) E = 65068 YoverLstarfinal = KoverYstarfinal**(alpha/(1-alpha)) * E print(KoverYstarfinal, "= KoverYstarfinal") print(YoverLstarfinal, "= YoverLstarfinal") print(np.log(YoverLstarfinal/YoverLstarinitial), "= long-run growth effect") # ---- # # # # **Quoting the four Stanford economists (plus five others):** # # A conventional approach

# # # In[16]: # what is (1 - alpha)(n + g + delta) here? # # (1 - alpha) = 2/3 # (n + g + delta) = .045 convergence_speed = 2/3 * .045 print(convergence_speed, "= convergence speed") for i in range(11): print(.03 - .03 * np.exp(-convergence_speed * i), "= growth over", i, "years") # In[17]: # what if we raise alpha to the "DeLong Summers" value? # # note: Brad DeLong and Larry Summers do **not** believe # that the tax "reform" will raise the savings rate by # 1.34%: this is a "what if" exercise that, as far as I # know, is not the analytical position of anybody: n = 0.01 g = 0.015 delta = 0.03 sinitial = 0.22 sfinal = 0.234 alpha = 0.5 KoverYstarinitial = sinitial/(n + g + delta) KoverYstarfinal = sfinal/(n + g + delta) E = 30555 YoverLstarfinal = KoverYstarfinal**(alpha/(1-alpha)) * E YoverLstarinitial = KoverYstarinitial**(alpha/(1-alpha)) * E print(KoverYstarfinal, "= KoverYstarfinal") print(YoverLstarfinal, "= YoverLstarfinal") print(np.log(YoverLstarfinal/YoverLstarinitial), "= long-run growth effect") # In[18]: # raising the alpha parameter even further... n = 0.01 g = 0.015 delta = 0.03 sinitial = 0.22 sfinal = 0.234 alpha = 0.667 KoverYstarinitial = sinitial/(n + g + delta) KoverYstarfinal = sfinal/(n + g + delta) E = 7151 YoverLstarfinal = KoverYstarfinal**(alpha/(1-alpha)) * E YoverLstarinitial = KoverYstarinitial**(alpha/(1-alpha)) * E print(KoverYstarfinal, "= KoverYstarfinal") print(YoverLstarfinal, "= YoverLstarfinal") print(np.log(YoverLstarfinal/YoverLstarinitial), "= long-run growth effect") # In[25]: # a baseline case sgm_bgp_100yr_run(L0 = 1000, E0 = 1, K0 = 9000, g = 0.015, n = 0.01, delta = 0.03, s = 0.22, alpha = 0.5) # # # ----