[From Bill Powers (960109.0030 MST)]
Remi Cote (960107) --
Welcome to CSGnet, Remi!
Maybe somebody on the list can tell me if there is a fundamental
difference between an "if then" routine in computer program and a
control sequence.
Your hunch is correct: there is a close relationship. But to understand
it takes a bit of attention to details.
The if-then process in a computer program involves a perception, a
reference condition, and a comparison process that produces an error
signal, and possibly an output function that produces an actual
physical output (translating into PCT terms).
Take a statement like
if A > B then C = 1 else C = 0.
To evaluate the conditional if-clause, the program must be given two
inputs: the state of A and the state of B. These generally depend on
what is happening elsewhere in the program, so this part of the program
has to receive the current values of A and B from other processes.
From the representations of A and B, the computer constructs a
perception of a relation between A and B: "A > B." This perception has
only two possible values: true or false, 1 or 0.
The phrase "if A > B then" really means "if the relation A > B _is true_
then. " The perceptual signal is either 1 (A is currently greater than
B) or 0 (A is currently less than or equal to B). To this we add a
reference condition: the error will be zero only if the perceptual
signal is 1, meaning that the reference state of this perception is set
to 1. The reference state could just as easily be set to 0, so the error
would be zero only if the perceptual signal is 0. In that case, there
would be no error signal only if A is NOT greater than B.
In the original form, "if A > B then C," we are saying that if the value
of the perception "A > B" matches a reference condition of _true_, the
error will be zero, and that if the error is zero, C is to be set to
_true_. The converse is also specified: if the error is 1, C is to be
set to _false_. This is with a reference condition of _true_ or 1. If
the reference condition is set to 0, C will be set to 1 or _true_ only
if A is NOT greater than B.
Setting C to _true_ does not necessarily result in any action. Let C be
the statement "buy 100 shares of IBM." Let A represent the percentage
rise in IBM stock prices yesterday, and B represent the percentage rise
in the Dow-Jones average yesterday.
The perception A > B will be _true_ only if IBM prices were reported to
rise by a greater percentage than the Dow-Jones average did. If the
reference condition is set to 1, the result will be a statement "Buy 100
shares of IBM stock." But that is all that will happen: the statement
will be made. No shares of IBM stock will actually be bought unless this
statement is converted into goals for more detailed actions, like
picking up the phone and calling one's stockbroker. There is no
predicting what the actions will be: the phone might be out of order,
the stockbroker might be sick, or the call might be made on a Saturday,
Sunday, or other market holiday. Trading in IBM stock might have been
halted, or your margin account may have reached its limit. The world is
a variable place, so to achieve a given goal often requires different
actions each time the same goal is to be reached.
My point here is that the if-then process describes _part_ of a
_particular kind_ of control process, one that involves discrete
manipulation of symbols. But a control process is completely specified
only when the error is converted to an action, by setting sub-goals and
sub-sub goals, and when the effect of doing so is a perception of the
desired change in the perceived state of the world: you now own an
additional 100 shares of IBM. The phrase "buy 100 shares of IBM" is not
a command to perform some particular act, but a request that a certain
perception be provided through whatever actions will provide it, given
the current state of the environment. It really means, when given to a
lower-level system, "Perceive that you own 100 more shares of IBM." The
means of achieving this perception will vary with circumstances, and are
up to the lower systems.
The other kind of control process is _continuous_. Here the perception
has more than just two states, true or false: it varies from zero to
some maximum magnitude, and can have any magnitude between the limits.
The reference condition, too, can specify any particular magnitude in
this range. The comparison process is now like an algebraic subtraction,
with the error signal representing the _amount_ of difference between
reference and perception, and also its sign. When the error is converted
into action, the action doesn't just occur or not occur: it has a
magnitude and direction that are continuously dependent on the magnitude
and direction of the error signal. And the effect of the action on the
world is also continuously variable, not on-off.
For making logical conditions true or false, the first kind of control
system is required. But to produce physical control of the environment,
the second kind, the analog kind, is needed.
Consider a control system that perceives the positions of a target and a
cursor on a computer screen. The reference condition is "target on
cursor", and the error is converted into handle movements. The handle
affects the cursor, of course.
Suppose we tried to model this tracking process using a symbolic kind of
control system. We would say, perhaps "If cursor left of target then
move handle right; if cursor on target then don't move handle; if cursor
right of target then move handle left."
The problem here is that the condition "cursor on target", as a logical
state, never actually occurs. If the target is at position 3.0000... on
the screen, and the cursor is at position 3.0000000000000000001, then
the cursor is not on the target, and the handle should move left (or
right, depending on the coordinate system). A logical statement is
either true or false; when you say "on the target" that is what you
mean, not "nearly on." The result is that physical control systems
designed like a logical control system never can settle down to a steady
state: in this case, the handle would end up switching back and forth
between "moving right" and "moving left." Since we have only those two
choices of action, there is no way to vary the amount of action. Even if
the cursor crossed the target position, before any change in the action
could happen the cursor would no longer be on the target.
In an analog control system, the _speed_ of handle movement would depend
on the _amount_ of error. As the cursor neared the target, the size of
the error would decrease and the speed of movement would decrease. By
the time the cursor was on the target, the speed of movement would have
become zero. So an analog control system can easily come to a steady
state, with no oscillation. This is the sort of control that works best
in controlling variables in the physical world.
In the hierarchical model build on PCT, there is some agreement that the
higher levels probably do involve control of logical conditions through
manipulation of discrete symbols, as in buying IBM shares. But the
errors inf these higher control processes have to be corrected by
varying _continuous_ reference signals, and producing actions that are
_continuously_ proportional to error. Systems of the analog kind are
necessary if you're going to reach out and pick up the phone, and guide
your fingertip so it contacts a specific button, and form the phonemes
that both you and your broker will hear as "UBB aaah eeeee , ooo uh
nnn, hhhh uh nnnn duh err edd shhhh ..." -- while you're chewing
gum.
When Miller, Galanter, and Pribram published "Plans and the organization
of behavior" in 1960, they introduced a logical control system called
the TOTE unit. Their only serious mistake was in trying to apply this
same sort of control system at all levels of organization, even those
that work on analog principles. They were riding the crest of the
computer revolution wave, and their idea has appealed to many people
since then whose only knowledge of automatic computing is of the digital
type. Unfortunately, digital logic is a lot easier to learn than analog
processes; few people outside engineering actually learn anything about
analyzing continuous systems. So there are many people whose only
concept of behavior is in terms of discrete states and logical
conditions, as in a computer program.
Sometimes, to paraphrase Ken Orr, asking me a question is like trying to
get a drink from a fire hose. I hope that after you dry off, you will
know a little more than you did.
···
-----------------------------------------------------------------------
Best,
Bill P.