[From Bill Powers (970425.0130 MST)]
Robert Kosara, 970424.2115 MEST--
Unless you assume that calculations by the
nervous system require no time, the negative feedback circuit will >>
always work faster than the open-loop arrangement you show.
Not when typing on a keyboard, for example, where the number of possible
perceptions is very limited, and can be predicted very accurately.
Yes, even in that case -- the control system works faster than the open-loop
system.
Let me explain how this can be true -- it is obviously counterintuitive for
most people, although that's only because they imagine a control system to
be something hard to understand and therefore complex. What is _really_
complex is a system that has to predict things, especially if it has to
predict them very accurately. But that's not the only reason control systems
are faster. The other reason is that control systems can reach a given final
state faster than open loop systems of equal complexity.
Suppose you consider just a single keystroke while typing. How do you move
the finger against the key and exert the right pressure to depress it,
without banging on it so hard that your finger hurts or you damage the keyboard?
The simple open-loop way depends on using a calibrated signal that is
calculated to produce the correct final force. There is a conflict between
speed and the requirement that the force not be too great. A force large
enough to generate a high speed will also be a force large enough to hurt or
damage something when the finger hits the keyboard. So the signal must be
set to just the magnitude that will produce the required final force, and
that reuqirement limits the speed of its movement.
In a control system, when the reference signal is set suddenly to a new
state, there is initially a very large error signal. This accelerates the
finger very rapidly to a high speed. But, with rate feedback of the kind
that exists in every motor control loop, as the error begins to get smaller
(as it immediately does), the driving force immediately starts to decline,
and in fact, due to the rate component of the feedback signal, actually goes
negative, starting to decelerate the finger. When the finger touches the
key, a new source of negative feedback appears at the spinal level -- the
touch receptors are wired directly to the spinal motor neurons, with a
time-delay of around five or ten milliseconds. This greatly increases the
deceleration, so the final bump, when the key hits bottom, is far less than
it would have been if the initial force had been maintained. This means that
in order to achieve the SAME final bump, the control system can start with a
far larger acceleration of the finger toward the key than the open-loop
system can afford to do. And this is why the control system can operate
faster than the simple open-loop system.
An open-loop system can be devised to have the same characteristics, but it
can no longer be a _simple_ open-loop system. Instead of just issuing a
command of constant magnitude, the system producing the command now must
issue a _timed pattern_ of commands. First it must generate a large brief
signal to get the finger moving rapidly. After a coasting period, while the
finger approaches the key, the signal must decline and go negative, creating
a large deceleration just in time to keep the finger from hitting the key
hard enough to split the skin or crack the plastic, but hard enough to
bottom the key. The magnitude and timing of these signal changes must be
produced fairly accurately, because the finger is, after all, a physical
object subject to physical laws -- you can't issue just any old signal.
The control system actually ends up issuing force signals that are patterned
just like the force signals from the ideal complex open-loop system -- but
the patterns are generated naturally by the effects of negative feedback and
do not have to be specifically computed. Whenever a computation is involved,
a little extra time is involved.
It
takes a lot of time to 'recover' from a typing error, and people usually
only interrupt their typing several keystrokes after the wrong one!
This shows that higher-level perceptions are slower than lower-level
perceptions. It takes longer to detect a wrong sequence than a wrong
configuration (letter on the screen or paper). But we can also see another
fact here that is implied by the HPCT model, the fact that there is more
than one control system acting at more than one level.
When you type, there are several variables being controlled at the same
time. One is spelling -- you are watching the result on the screen, and
checking to see if the word is spelled corrrrectly -- that is, if the
sequence that is perceived is the intended sequence. Still another is
grammar or syntax -- is this good English, or French, or German that is
appearing on the screen? And another still is meaning: as I read what I am
writing, does it evoke the perceptions I am trying to communicate? All these
control processes are going on at the same time.
And of course they are hierarchically related. A sequence error can be
corrected only by a higher-level system issuing another sequence command --
erasing the letters back to the mistake, repositioning the hands, and
repeating the same sequence if the error occurred at a lower level like that
of finger positioning, or altering the sequence if the cause was a
higher-level mistake in spelling. If the correct sequence is perceived
(i.e., it matches the reference sequence), another system might decide that
the wrong word has been chosen, choose a different word, and initiate a
correction cycle so that a _different_ sequence can be produced. Or a still
higher system can decide that the words on the screen imply something
unwanted, or fail to convey the wanted meaning, and the whole sentence is
deleted in favor of a completely different one.
Understand that this is a very rough approximation. A study of typing errors
would be a very nice way to study levels of control, but nobody has done
that with PCT in mind yet. There's probably a literature on this subject,
although it may be pretty frustrating to read.
In this example, many different perceptions are involved on a number of
different levels. In a more simple example --- typing on the keyboard
again --- when I hit the wrong key, there is a difference between the
planned perception and the actual one. But it takes time until that is
recognized, a new plan developed, and the first signal of the new plan
reaches the fingers. During this time, I hit another two keys, and then my
fingers suddenly stop (no more signals in the queue).
This depends on the cause of the error. If the lower-level system fails to
move the finger to the vertical position that is requested, you are in big
trouble, because something has happened to a low-level system that will not
be easy to fix. If you've been joggled by somebody (or by a body movement of
your own like a sneeze), moving the hands to the wrong position over the
keyboard, it can take a while for the sequence-control level to perceive
that the wrong letters are appearing on the screen and stop, and for a still
higher system to initiate the erasure sequence, and restart the sequence.
Remember that perception of _sequence_ is not like perception of a single
letter-configuration: it involves a _set_ of letters received in a certain
order. To detect an error in sequence requires perceiving more than one letter.
If there has been a mistake in controlling the sequence of letters, the
wrong sequence will appear on the screen even though the finger positioning
systems are working perfectly. You will type "hte" instead of "the" not
because your finger slipped but because the sequence system reversed the
order of two reference signals. The fingers simply produced the letters they
were told to produce. If you type "the the" instead of "and the", the
sequence level is generating exactly the two sequences requested of it, but
the request was in error at the output of the next level up: the sentence
construction system got ahead of itself, issued the wrong sequence command,
and before a higher system could react to the unwanted duplication of words,
re-issued it. (Or something).
This might be a good time for Rick Marken to comment on the basis of his
experiments with perceptions of various levels.
No problem with that, but the result is equivalent, no matter if
perceptions are planned, or actions (as far as the outside world is
concerned).
Not so. If you command an action and it has the wrong effect because of a
disturbance, you will need a higher order system to detect the error and
re-issue the command (it's altogether too easy to forget about
disturbances). But if there is feedback at the lower level, the lower-level
system can correct the error without any change in the command from the
higher system. In a control system, it is the _result_, not the action, that
is specified by the reference signal. When disturbances occur they affect
the result, not the action, and it is the effect on the result that is
sensed and corrected immediately through the effect on the error signal. But
in the open-loop system, disturbances can't be detected at the level where
they have their immediate effects, because only the action is being specified.
When you plan perceptions, your actions will change as they need to to
oppose the effects of disturbances; you will seldom see the same actions
occurring twice, although they will produce the same results again and
again. When you plan actions, the external observer will see repeated
actions, but varying results because of the disturbances.
The fastest possible reaction to disturbances occurs in a hierarchy of
control systems, because the disturbance is always opposed at the lowest
possible level of control, where the fastest possible sensing is done.
... it takes the perceptual signals considerable time
to reach the higher levels, that run at a speed far higher than would
allow to wait for the perception before issuing the next signal! That is
what I meant by 'tight circuits': Ones that don't involve the delays that
occur in the spinal cord and the afferent and efferent nerves (from the
spinal cord to the muscles).
The long delays you speak of (like waiting for the game program to get
through its introductory delay) are in the environment, not in the
perceptual systems. It takes only milliseconds for the lowest level
perceptual signals to reach the highest levels of the cortex, counting only
signal propagation speed. The delays that occur in the brain are due to the
processing time needed to _recognize_ a perception of a given kind, and to
recognize _changes_ in the perception. These can be shorter than the delays
in the environment, or longer. If they are shorter, then it is the
environment that holds up the control process. If the environment reacts
fast enough, then we see the minimum delays in the perceptual systems.
[I typed "instantly," and then, on rereading, changed that to "fast enough".]
A farmer growing wheat can imagine the process of planting, cultivating, and
harvesting in a second or two -- but doing it requires waiting for the
environment to carry out its part of the control loop at its own speed.
[I typed "waiting the the environment...". Happens more often as you get old.]
When feedback is very slow, there still will be the
same errors: DOS games, for example, often presented several 'welcome' and
'option' screens before the actual games started. You had to go through
them every time, and so, after a few times, you knew what keys to press,
and did that before the actual screen appeared (during the fade-out of one
and the fade-in of the next), thus reducing the startup time. But when a
friend came to visit me, and we wanted to play together, I still hit 's'
for 'single player' ... and I am talking of turn-around times of a second
or so.
Yes, this was an error in a higher-level system, wasn't it? You selected the
sequence appropriate to a single player, when there were several. With
practice you could probably learn not to do this.
The lower-level systems can handle disturbances much faster than
the higher ones can, so the planning system really doesn't have to take
them into account.
And when the higher-level system does not have to wait for the updated
perception, it can proceed faster (but with less accuracy, of course)!
It can proceed faster up to its own maximum speed. There is no reason it
should be less accurate as long as it is not approaching its speed limit.
I did not throw the cardboard laptop over my
head, but the movement sure looked strange (my friends couldn't stop
laughing).
The slowness with which we correct such mistakes shows that the problem is
in a higher-level system, not in the force-control system. If you expect to
lift a heavy load, you approach the lift very differently, and you may well
use force control in addition to position control. But if this happens very
often, you soon cease to have this problem (as in the case of a package
sorter). It isn't that you become clairvoyant so you can anticipate how
heavy each new package will be; you change the variable you're controlling,
so you plan a target position and let the force be whatever it is, instead
of planning how hard to lift, and letting the position be whatever it is.
Best,
Bill P.
