Applying some built-in functions of Mathematica, this note provides some graphics derived from convergent paths in "Solow Model." The main aim is to attarct other economists and introduces alternative analyzing tools but I also expect that this material helps teaching economics (programming codes are all shown in the appendix).Mathematica

Tetsuya Saito

English

Research Papers in Economics

Fine Arts in Solow Model 
Tetsuya Saito
Department of Economics, SUNY at Buffalo
Abstract
Applying some built-in functions of Mathematica, this note provides some graphics derived
from convergent paths in "Solow Model." The main aim is to attarct other economists and
introduces alternative analyzing tools but I also expect that this material helps teaching
economics (programming codes are all shown in the appendix).
I am grateful to the anonymous referee and Dr John Conley, the editor of this journal, for some helpful comments to improve the
initial version of this note and programming codes. All remaining errors and bugs in programming codes are mine.
Citation: Saito, Tetsuya, (2007) "Fine Arts in Solow Model." Economics Bulletin, Vol. 1, No. 3 pp. 1-20
Submitted: November 19, 2007.  Accepted: December 15, 2007.
URL: http://economicsbulletin.vanderbilt.edu/2007/volume1/EB-07A10007A.pdf1 Introduction
This paper is just for fun using one of the best known models in economics, \Solow Model
(Solow 1957)," which is taught in almost all economics classes of all over the World. Applying
functions (mainly DensityPlot and 3DPlot) built in Mathematica, I draw pictures showing
how many steps take to the steady state with respect to some combinations of parameters such
as initial capital stock and saving rate. Then we ¯nd some fascinating pictured derived from
this best known growth model. I also expect that this material helps teaching this exogenous
growth model and some elementary dynamics. All programming codes are provided in the
appendix.
2 Solow Model
Consider an economy producing and consuming a commodity Y . They produce Y using
capital K labor L with a technology represented by a neo-classical production function F :
pL;Kq ÞÑ Y such that Fp0;Kq  FpL;0q  0 with Inada Condition. Because technological
growth cannot be identi¯ed in simulations from other growth rates, I assume there is no
technological change. Then consider motions of each factor 9 K and 9 L:
9 L  nL and 9 K  I  ±K; (1)
where I is the investment of this period, so that, it is I  Y  C when C represents the
consumption of this period. In Solow Model, C is exogenously given in terms of the saving
rate s P r0;1s as C  sY , so that, I  p1  sqY .
For simplicity of the analysis, as a convention, consider the model in terms of per capita
variables that are denoted by corresponding lower case letters{i.e., y  Y {L. Then, for the
production function, we have
y 
1
L
 FpK;Lq  Fpk;1q : fpkq: (2)
For the motion of K, substituting I  p1  sqY , we have
9 K
L
 p1  sqy  ±k: (3)
Now note
k 
K
L
ùñ
9 k
k

9 K
K

9 L
L

9 K
K
 n; (4)
and then the left-hand side of (3) is given by
9 K
L

9 K
K

K
L


9 k
k
  n

 k  9 k   nk: (5)
1Therefore (3) is rewritten as
9 k  p1  sq  fpkq  pn   ±q  k: (6)
If 9 k  0, then we call it \steady state equilibrium" and denote such k by k.
3 Speci¯cation and Computing
Consider specifying the model for computing. Note f1pkq ¡ 0 and f2pkq   0, and still Inada
Condition holds because
f
1pkq 
dFpK{L;1q
dK
1
dk{dK

FKpK;Lq
L
 L  FKpK;Lq ¡ 0; (7)
and
f
2pkq 
dFKpK;Lq
dK

1
dk{dK
 L  FKKpK;Lq   0: (8)
Noticing this, we have q well known and explicitly solvable candidate: fpkq  k® for ® P p0;1q
(notice, multiplying those functions by scalars just produces homeomorphic functions). For
computation, because we cannot reach the steady state unless we start from the steady state,
we need to clarify what is \convergence."
De¯nition 1 For su±ciently small " ¡ 0, we say the model have reached its steady state
when |k  k| ¤ ".
The simplest computable model is given by fpkq  k® for ® P p0;1q and then k is given
by
k
 

1  s
n   ±

 1
1®
(9)
Then consider an algorithm for computing. Let kj be the capital stock at j-th stage of
computing for j  0;1;2;:::, where k0 is the initial capital stock and it is given. Starting
from k0 ¡ 0, evaluate whether |k  kt| is larger than " or not. While it returns \TRUE"
then proceed to the next stage with accumulating capital stock in accordance with
kj 1  kj   9 kj  kj   p1  sq  fpkjq  pn   ±q  kj: (10)
Once |k  kj| ¡ " turns to \FALSE," then stop computing to return the total number of
steps. Applying this algorithm to some combinations of parameters for each range, then we get
density maps which take numbers of steps as their densities with respect to each combination
of selected parameters. Appendix A provides the corresponding programming code.
24 Reviewing Graphics
In order to draw graphics, when they are given as parameters for each simulation, most cases
applies ps; ±; n;k0 ;®; "; maxq  p0:4; 0:01; 0:01; 1 or 10; 0:3; 0:00001; 5000q, where max is
the largest number of recursions when it does not converge (it avoids endless loops). However,
for Figure 9 { Figure 13 apply parameters p±; n; "; maxq  p0:1; 0:1; 0:001; 1000q instead
of those of others because these computations take too long time. Results are visualized by
DensityPlot which expresses numbers of steps to steady states as color gradations on the
2D surface for each combination of two parameters (each ¯gure has the legend of colors).
Figure 1 shows the graphics derived by k0 and n given other parameters. The thin curve
represents locus of pn;k0q such that k0  k. Around that locus, he dynamics converge very
fast comparing to other points and that is depicted by Figure 2 for the case k0  5. It
looks like a limestone cave. Figure 3 shows the 3D view below the surface (heights indicate
respective steps to converge). Figure 4 depicts the relation between k0 and s and it also have
a canyon around the locus of ps;k0q such that k0  k (the red diagonal area). As a 3D,
Figure 5 shows its surface.
Next consider some cases k0 is given. For the case k0  10, Figure 6 depicts how combi-
nations of s (horizontal) and ± (vertical) a®ect convergent paths. Because k0 is su±ciently
large, k0  k does not occur in this case. However, there is something on the ¯gure that
may be in°uenced by k (I don't know what is it). However, when k0  1, we can identify the
line k0  k as shown by Figure 7. Figure 8 shows in°uences of ± and n and that indicates
number of steps are similar when ±  n. It also shows too low combinations bring too long
way to the steady state but too high combinations does not indicate earlier convergence as
well.
The most fascinating patterns appear when we see relations between input share ® (ver-
tical) and other parameters (horizontal). The ¯rst case is the relation with s and ® when
k0  1 (Figure 9) and when k0  10 (Figure 10). And the second case is the relation with ±
and ® when k0  1 (Figure 11) and when k0  10 (Figure 12). Those ¯gures show we may
encounter very long paths to converge in some applications that put high capital shares like
® ¥ 0:8 (highly capital intensive society) around plausible s and ±. The last one (Figure 13)
depicts the relation with k0 and ® that shows smaller ® brings shorter paths than longer ones.
References
Solow, Robert (1957) `Technical change and the aggregate production function.' Journal of
Economics and Statistics 39(3), 312{320
Wolfram, Stephan (2003) The Mathematica Book, 5th ed. (Wolfram Media)
3Appendix
A Programming Code
This is the source code for this paper.1 I recommend readers who are willing to reproduce
the same graphics to consider the size of mesh of the density map because large meshes con-
sume computer resources and take too long to ¯nish computing. In particular, commanding
PlotPoints -> f800, 800g for DensityPlot and PlotPoint -> f300, 300g for 3DPlot
require over one hour to ¯nish (1.42G PowerPC G4). It is reasonable to set PlotPoints ->
f100, 100g initially and then increase them if something interesting patterns appear. In ad-
dition, e and max in°uence on the time of computing and I recommend readers not to increase
those numbers larger than I give here unless higher spec machines are implemented.
(* Definition of each variable *)
(*
s : saving rate,
n : population growth rate,
d : capital depreciation rate,
k0 : initial per - capita capital stock ,
a : parameter on production function ,
e : epsilon to determine convergence ,
max : maximum number of iterations
*)
Solow[s_, n_, d_, k0_, a_, e_, max_] :=
(
(* Initializing parameters *)
j = 0; (* Steps to the steady state *)
k = k0; (* Initial capital stock *)
b = 1/(1 - a); (* Just for convenience *)
z = ((1 - s)/(n + d))^b; (* Steady state capital stock *)
(* Loop while convergence *)
While[
Abs[z - k] > e && j < max, (* Evaluate whether close enough *)
k = k + (1 - s)*k^a - (n + d)*k; (* Accumulate capital stock *)
j++ (* Count each step *)
];
(* Return total steps as the result *)
Return[j];
)
SolowLegend[T_] :=
(
max = Max[T];
DensityPlot[
x/max, {x, 0, max}, {y, 0, 1},
PlotPoints -> {100, 100},
Axes -> {True, False},
Ticks -> Automatic ,
Mesh -> False ,
ColorFunction -> Hue,
Frame -> False ,
1See, for example, Wolfram (2003) for detailed explanations about each function.
4AspectRatio -> 0.05,
TextStyle -> {FontSize -> 12}
]
)
(* Draw pictures *)
(* Drawing initial capital vs depreciation rate *)
DensityPlot[
Solow[0.4, x, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0.001, 25},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
(*
This process generates legend as follows;
(1) Apply Solow function to get maximum steps;
(2) Principally minimum is always zero--consider the case k0 = k*;
(3) Then draw legend applying DensityPlot and Hue functions
*)
T = Table[
Solow[0.4, x, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1, 0.1}, {y, 0.001, 25, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Plot steps w.r.t. depreciation rate*)
ListPlot[
Table[
Solow[0.4, x, 0.01, 5, 0.3, 0.00001, 5000], {x, 0, 1, 0.0001}
]
]
(* Generate legend *)
T = Table[
Solow[x, 0.1, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1, 0.1}, {y, 0.001, 25, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing 2D for initial capital vs depreciation rate *)
ListPlot[
Table[
Solow[0.4, x, 0.01, 5, 0.3, 0.00001, 5000], {x, 0, 1, 0.0001}
]
]
(* Drawing 3D for initial capital vs depreciation rate *)
graph = Plot3D[
Solow[0.4, x, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0.001, 25},
PlotPoints -> {300, 300}, Mesh -> False
]
(* Change viewpoint *)
Show[graph , ViewPoint -> {-1, -0.5, -0.5}, PlotRange -> {0, 300}]
(* Drawing initial capital vs saving rate *)
DensityPlot[
Solow[x, 0.1, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0.001, 25},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Flatten[T];
SolowLegend[T];
5(* Drawing 3D for capital vs saving rate *)
Plot3D[
Solow[x, 0.1, 0.01, y, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0.001, 25},
PlotPoints -> {300, 300}, Mesh -> False
]
(* Drawing saving rate vs depreciation rate for k0=10 *)
DensityPlot[
Solow[x, y, 0.01, 10, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[x, y, 0.01, 10, 0.3, 0.00001, 5000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing saving rate vs depreciation rate for k0=1 *)
DensityPlot[
Solow[x, y, 0.01, 1, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[x, y, 0.01, 1, 0.3, 0.00001, 5000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing depreciation rate vs population growth *)
DensityPlot[
Solow[0.4, x, y, 1, 0.3, 0.00001, 5000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[0.4, x, y, 1, 0.3, 0.00001, 5000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(*
d and n are redefined as 0.1 for computational reason.
By the same reason , e = 0.001 and max = 1000 are also redefined.
*)
(* Drawing saving rate vs share of capital input for k0=1 *)
(* NOTE: Ignore some errors caused by dividing 0 *)
DensityPlot[
Solow[x, 0.1, 0.1, 1, y, 0.001, 1000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[x, 0.1, 0.1, 1, y, 0.001, 1000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing saving rate vs share of capital input for k0=10 *)
(* NOTE: Ignore some errors caused by dividing 0 *)
6DensityPlot[
Solow[x, 0.1, 0.1, 10, y, 0.001, 1000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[x, 0.1, 0.1, 10, y, 0.001, 1000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing depreciation rate vs share of capital input for k0=1 *)
(* NOTE: Ignore some errors caused by dividing 0 *)
DensityPlot[
Solow[0.4, x, 0.1, 1, y, 0.001, 1000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[0.4, x, 0.1, 1, y, 0.001, 1000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing depreciation rate vs share of capital input for k0=10 *)
(* NOTE: Ignore some errors caused by dividing 0 *)
DensityPlot[
Solow[0.4, x, 0.1, 10, y, 0.001, 1000], {x, 0, 1}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[0.4, x, 0.1, 10, y, 0.001, 1000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
(* Drawing Initial capital vs share of capital input *)
(* NOTE: Ignore some errors caused by dividing 0 *)
DensityPlot[
Solow[0.4, 0.1, 0.1, x, y, 0.001, 1000], {x, 0, 200}, {y, 0, 1},
PlotPoints -> {800, 800}, Mesh -> False , ColorFunction -> Hue
]
(* Generate legend *)
T = Table[
Solow[0.4, 0.1, 0.1, x, y, 0.001, 1000], {x, 0, 1, 0.1}, {y, 0, 1, 0.1}
];
T = Flatten[T];
SolowLegend[T];
7Legend: Number of steps to the steady state
Figure 1: Initial capital stock vs population growth rate
8Figure 2: Initial capital stock vs population growth rate
Figure 3: Initial capital stock vs population growth rate
9Legend: Number of steps to the steady state
Figure 4: Initial capital stock vs saving rate
10Figure 5: Initial capital stock vs saving rate
11Legend: Number of steps to the steady state
Figure 6: Saving rate vs depreciation rate (k0  10)
12Legend: Number of steps to the steady state
Figure 7: Saving rate vs depreciation rate (k0  1)
13Legend: Number of steps to the steady state
Figure 8: Depreciation rate vs population growth
14Legend: Number of steps to the steady state
Figure 9: Saving rate vs share of capital input (k0  1)
15Legend: Number of steps to the steady state
Figure 10: Saving rate vs share of capital input (k0  10)
16Legend: Number of steps to the steady state
Figure 11: Depreciation rate vs share of capital input (k0  1)
17Legend: Number of steps to the steady state
Figure 12: Depreciation rate vs share of capital input (k0  10)
18Legend: Number of steps to the steady state
Figure 13: Initial capital vs share of capital input
19

0.1} ]; T = Flatten[T]; SolowLegend[T]; (* Drawing depreciation rate vs share of capital input for k0=1 *) (* NOTE: Ignore some errors caused by dividing 0

0.1} ]; T = Flatten[T]; SolowLegend[T]; (* Drawing depreciation rate vs share of capital input for k0=10 *) (* NOTE: Ignore some errors caused by dividing 0

0.1} ]; T = Flatten[T]; SolowLegend[T]; (* Drawing Initial capital vs share of capital input *) (* NOTE: Ignore some errors caused by dividing 0

0.1} ]; T = Flatten[T]; SolowLegend[T]; (* Drawing saving rate vs share of capital input for k0=10 *) (* NOTE: Ignore some errors caused by dividing 0

Technical change and the aggregate production function.'

Fine Arts in Solow Model

http://www.accessecon.com/pubs/EB/2007/Volume1/EB-07A10007A.pdf

Fine Arts in Solow Model

Abstract

Similar works

Full text

Available Versions

Research Papers in Economics