[From Frank Lenk (2009.09.06.20:32 CDT]
Well, Bill, since you’ve thrown down the gauntlet, I guess
I need to reply.
Of course, I am interested in pursuing this project, but I am
approaching it differently. I am attaching a draft of my
dissertation proposal for you (and the list) to peruse. Frankly, I wasn’t
quite ready to do this – I have only just given it to my dissertation
chair for comment – but at this point in the project it’s probably
best to put all the ideas on the table where we can discuss them.
WARNING: About 2/3 of the proposal is actually a review of the urban
sociology literature. The problem I (ultimately) want to solve is concentrated
poverty among minorities in urban areas (affecting mostly African-Americans in
Kansas City, but also Latinos). The model I am hoping develop is merely a tool
for understanding more clearly the nature of problem and the effectiveness of
proposed solutions. I think PCT and agent-based modeling give me the best
chance of developing such a tool. I attempt to use the literature review to
derive model specifications for an “adequate” model of concentrated
urban minority poverty. These requirements are summarized beginning on page 46,
and it is from this point on that most of the discussion pertaining to modeling
can be found.
While I have thought a lot about this, it seems that every time
I read an email from Bill P. I learn something new that somewhat alters my
thinking, and so please read the draft with the idea that this is a work in
progress. However, I welcome all criticism – the point is to
develop a working prototype model by the end of my dissertation, one that I can
continue as part of my job after the dissertation is complete (you will see how
it is related to my work if you read the Problem Statement section). So
anything that gets me a better working model faster will be greatly
appreciated.
I should also say that, while I did not know him, Bill Williams
was a professor at my school, the University of Missouri-Kansas City (UMKC).
I was introduced to PCT by a colleague of his, Dr. Jim Sturgeon. The UMKC econ
department is one of the few heterodox economics schools in the U.S., which
means that it is critical of mainstream neoclassical economic theory (and like
PCT, has trouble getting recognized as legitimate by the keepers of orthodox
viewpoints). In being critical of its theory, many heterodox economists
are also very critical of its tools – especially mathematical and econometric
modeling. However, I learned my economic theory and econometrics as an
undergrad and masters student at Stanford and believe math and statistics
remain useful tools, but that sometimes we let what is easy to do with the tool
dictate our analysis, bending the analysis to the tool rather than the tool to real-world
observations. So we economists make unrealistic assumptions about human
behavior so we can get the math to be solvable, or we model things as a single
regression equation when there are actually multiple things happening
simultaneously that should be modeled as a simultaneous system of equations (Rick,
I suspect this is one reason why the sign on your correlation between taxes and
growth is positive). PCT and agent-based modeling seem to me to be a way out of
the box of having to trade accuracy of representation for tractability. From
what I understand from Dr. Sturgeon, Bill Williams’ views on the
usefulness of models were similar to mine. If so, I would be grateful if I am
able to continue his work in some small way.
The major difference in my approach from Bill P.’s, at
least as I see it, is that I am doing the modeling at a couple of levels below the
economy itself. I understand the need for simplicity – In trying to
explain what I am doing to others, I have often to said that I would be
satisfied if I produced decent model of a family, let alone an entire economy
or society. But in our search for starting simple, Bill and I are starting
in different places. I would like to model at the level of, not just
individuals, but individuals who interact with each other within families and
communities. I want a model that starts from their basic (intrinsic)
needs and has the economy emerge from their social interactions and the interactions
with the available technology (which I would have to specify).
As I said in my earlier post, one can view the economy as simply
a set of behaviors we use to control the amount of food in our bellies, subject
to certain environmental constraints. My conception of the environment includes
the social as well as the natural and the technological, however. I want
my agents to figure out how to organize themselves to live in the virtual world
inside my computer, much as we have had to figure out how to organize ourselves
to live in this one.
There are several reasons for my wanting to model at this
level. First, I think that the only human behavior we truly understand is
that which we experience, which is that of ourselves and small groups of others
with whom we regularly associate. This is the level at which we have any
expertise to specify our model. Our common, every-day experience provides
the data we need to begin, though ideally this would be checked against results
from psychology, anthropology and sociology.
Second, human behavior is always in reference to others. Under
all but the rarest of circumstances, there is no such thing as an isolated
individual living alone. We depend upon others for our most basic needs - for
food, for sex and parenting of offspring to reproduce. A
model that begins with its “atom” an isolated individual is likely to
produce a different outcome from one that specifies interactions between
individuals from the beginning (perhaps a mother-child relationship is the atom
of social models). Obviously, to get interacting individuals one has to
start by identifying, specifying and debugging the control systems inside a
single individual, but those control systems should be built to perceive others
and let others influence the individual’s references (learning by
emulation or mimicry, for example) and perceptions (or at least what is important
to perceive).
Third, and this is especially important given my problem of
concentrated minority poverty, once we allow others to influence either our
references or our perceptions (and probably both), the notion of Power rears
its head. Who influences whom and how? There is much evidence that, at
least partially, we set our references according to the behavior of those more
powerful than we. This is certainly true of a child. It also probably
accounts (again, at least partially) for the transmission of stereotypes, roles
and norms.
So in my proposed approach, the economy is behavior we engage in
to control the food, shelter and water we need to survive while we engage in
other behavior to control for the other things that are important (perhaps more
important) to us – mating, parenting, gaining social position or esteem.
Clearly, these purposes are inter-related – one who controls the
resources for food and shelter also becomes powerful and desirable as a mate
and a parent. Some (many?) will argue that gaining esteem or social
position is really all about maximizing potential for mating, so in this sense
is only a behavior to control for mating probability or frequency rather than a
reference. I tend to think that while this may have originally been the
case, humans and their antecedents have been social creatures long enough that
some hardwiring of an intrinsic need for belonging to a group or being valued
by the group is likely.
Reading through Bill’s approach again, I think it is clear
that it is simpler and more achievable more quickly than mine. But one of
the things I uncover in my survey of the agent-based modeling literature is
that the models are very sensitive to assumptions, especially about what the
rules are that the agents follow. In PCT terms, where do our references actually
come from? If they are simply assumptions made by the modeler, they will be
subject to criticism. Some are intrinsic, yes. But the rest? We must learn
them. We likely learn them as kids, both from experience and from others. So
let’s model the learning process in families and groups of families and
see what kind of economy we can derive from members’ efforts to satisfy
their needs.
Waiting for the “fun” to begin . . .
Frank
Frank Lenk
Director of Research Services
Mid-America Regional Council
600 Broadway, Suite 200
Kansas City, MO 64105
www.marc.org
816.474.4240
flenk@marc.org
816.701.8237
Lenk - Draft Dissertation Proposal - formatted.docx (796 KB)
···
From: Control Systems
Group Network (CSGnet) [mailto:CSGNET@LISTSERV.ILLINOIS.EDU] On Behalf Of Bill
Powers
Sent: Sunday, September 06, 2009 3:39 PM
To: CSGNET@LISTSERV.ILLINOIS.EDU
Subject: Re: [CSGNET] economics
[From Bill Powers (2009.09.06.1229 MDT)]
Rick Marken (2009.09.06.1100) –
[re Bill Powers (2009.09.05.2315
MDT)]–
Again, missing from this (for me) is any description of the
data against which the behavior of the model will be evaluated.
Yes, it’s missing in a formal sense. However, as we put the model together
we’ll use informal understandings or placeholders at first just to get a
preliminary model that will run at all. Then I expect the revisions will start
and the model will be related more to real data.
Here’s one way it could begin.
People need food, clothing, shelter, and other things. Since we can’t say offhand
what the list really is, we can just say that people need G, where G is an
array of goods and services. Money is a good like any other.
type GoodsType = array[1…maxgoods] of record
NAME: string;
Perception, Reference, Error, Gain, Output,
UseRate, DepreciationRate,
Stock: double;
end;
Each item in the array is a record, which in turn is an arbitrary collection of
variables of different types, one collection per item in the array. The above
type definition says that there are “maxgoods” items in the array,
each item referring to one good. The constant “maxgoods”, defined and
given a value somewhere else in the program, merely tells the compiler how much
memory to reserve to hold the largest array of records we plan to use. I’m not
worried: I just bought a one-terabyte external disk drive for my desktop
computer, for a shade under $100. One terabyte is a thousand gigabytes or a
million megabytes.
Let’s say that the NAME entry in G[1] is “Peanut Butter” and in G[2]
it is “Bank Account Balance.” Those are “string” type
variables, meaning words that you can read.
The next line in the definition of GoodsType is used to store the current
values of the control system variables and parameters. There is one control
system per good.
The next line lists effects of disturbances (per day) on the stock of goods.
The final line before the end of the record, Stock, is the current balance on
hand of whatever the item is. We might also want to add a parameter indicating
how far negative the good can go. Money can go negative (if you have credit) up
to the credit limit. Material goods can’t go negative – though perhaps you
could say “I ow Jon Hancoc 3 pig”. You might also want to add
interest rates, one that makes G[2].stock increase (interest received), and
another that makes the same stock of money, if negative, go more negative
(interest paid). The last three lines of entries in the record list variables
of type “double,” meaning a double precision floating point number.
If a consumer buys n units of G[1], this will increase G[1].stock by n, and
decrease the cash reserve G[2].stock by nG[1].price. In a model that includes
a producer, the same transaction would decrease the goods stock of the
particular producer who sold the item by n units, and increase the cash stock
(i.e., bank account) of that producer by nG[1].price units. For those not
familiar with programming symbols, * means multiply. We don’t use x or X because
that looks like the name of a variable and is often used that way. “X
times Y” would come out as “X X Y,” which wouldn’t do. Note also
that G[1] means the first record in the array, and .Name (for example)
indicates one of the sub-items that is stored in that record. An array is just
a list, a record is an arbitrary collection of different types of variables.
Every time G[1].NAME is used by eating some of it, G[1].stock is reduced by the
amount eaten. If the item depreciates, its usable quantity is reduced by
G[1].stock * G[1].DepreciationRate every day, whether it’s being used or not.
If the consumer works H hours per PayPeriod at wage W, every PayPeriod days of
iterations of the model (where one iteration represents one day) the stock of
money will increase by H*W dollars. For those unfamiliar with this way of
talking, when I say “PayPeriod” in that odd way, I’m referring to a
variable that gets specified somewhere else in the program before this part of
it is run; “PayPeriod” is the name of the variable, and its magnitude
would be set to 7 (days) if the pay is distributed every week, or 28, 29, 30,
or 31 if distributed every month. The program would be adding a day to Daycount
on every iteration, and when DayCount equals PayPeriod, the pay would be calculated
and transferred, and Daycount would be reset to zero. PayPeriod can be changed,
too, if appropriate.
Very tedious details, but now we’re close to being able actually to run this
model and see how it behaves. We’d have to supply arbitrary starting values of
the stocks, the reference levels for the stocks, the gain, the depreciation
rates, the interest rates, the use rates, and so forth, but the variables would
begin to change right away and would come to some equilibrium value after a few
dozen iterations. Some auxiliary functions would be needed to implement the
control systems:
error := reference - perception;
output := gain*error;
Behind all this is the rest of the program, which does the iterations and
calculations over and over, perhaps plotting the values of the variables on the
screen so we can watch what is happening. I can suggest ways to handle these
details too for anyone trying to write the actual program and run it. Rick
Marken, Bruce Abbott, Martin Taylor, Richard Kennaway, and perhaps some others
who have been hiding to avoid being shanghaied can help, too.
Note that we could also define an array of consumers, with the above array of
records existing within each consumer. It would be possible to set up groups of
consumers who have different reference levels for the same goods, difference
goods preferences, different incomes, and so forth. This takes us closer to
matching the model up with reality.
This approach to modeling is very different from the way any economic models I
have seen are organized. It’s really a simulation like the simulations of
physical systems that engineers use all the time. The model itself is simply an
attempt to represent, quantitatively, the characteristics of the system that
really exists. There is no economic theory in it. Any economic theory will
emerge as a description of how the model behaves, not as an explanation for why
it behaves that way. Any explanation runs in the other direction: the
organization of the model explains why it behaves economically as it does.
This is Sunday, tomorrow is Labor Day in the USA. I hope I hear from
participants, whether programmers, non-programmers, or spectators, by the end
of the coming week. I’m not going to continue this if this doesn’t turn into a
real project.