A PCT model of vision

[From (Rupert Young 290497.2100 BST)]

For anyone interested here's a working paper about the PCT based vision system
I'm working on.

"A fixation and viewpoint measure for object-based gaze control"

see http://www.ee.surrey.ac.uk/Personal/R.Young/docs/papers/internal/internal.h
tml

I'd welcome any general comments anyone has to make as well as comments in
these areas,

1) Any misrepresentations of PCT

2) Evidence anyone has come across, in animal or human studies, that would
support the 'pixel count' use of the foveal representation for stabilising the
perceptual variable.

3) Techniques for 2-D control. Specifically how does the controller know
which _direction_ to go. In 1-D problems the sign of the error signal tells
you, in 2-D problems as in my paper the error signal is unsigned and so
doesn't contain info about direction.

4) Are there any areas of my model as it is that you would have done
differently or think could be done better ?

Regards,
Rupert

···

--------------------------------------------------------------------------
Centre for Vision, Speech and Signal Processing University of Surrey
World Wide Web: http://www.ee.surrey.ac.uk/Personal/R.Young/
Email: R.Young@surrey.ac.uk
Office Telephone: 01483 259838 Home Telephone: 01483 533120
--------------------------------------------------------------------------

[From Bill Powers (970429.1500 MST)]

(Rupert Young 290497.2100 BST)--

3) Techniques for 2-D control. Specifically how does the controller know
which _direction_ to go. In 1-D problems the sign of the error signal
tells you, in 2-D problems as in my paper the error signal is unsigned and
so doesn't contain info about direction.

In PCT we use one control system per degree of freedom, so each control
system always has error magnitude and sign information. The Little Man
model, for example, uses two control systems at the shoulder joint, one for
pitch and the other for yaw, and a third at the elbow joint for controlling
mainly distance. The set of all control systems at the second kinesthetic
level is used by the visual systgems by setting three reference signals:
pitch, yaw, and distance of the tip of the "finger". The visual systems also
detect x direction, y direction, and distance (relative to a movable target)
as three perceptual signals. The outputs of the three control systems at the
visual level set the three reference signals for the top kinesthetic
systems, which in turn act by setting reference signals for the three
"spinal reflex" systems.

Have you tried either of the "Arm" demos? They might give you some ideas.
The writeups may be of some use. Let me know if you need help understanding
the code.

Best,

Bill P.

[From Avery Andrews, 970429]

(Rupert Young 290497.2100 BST)--

3) Techniques for 2-D control. Specifically how does the controller know
which _direction_ to go. In 1-D problems the sign of the error signal
tells you, in 2-D problems as in my paper the error signal is unsigned and
so doesn't contain info about direction.

Perhaps my postings on the subject of `transpose cartesian blues' might
be helpful too (the point of which is that the ease or difficulty of
getting simple feedback to work well in a 2D setting is quite dependent
on choice of coordinate systems, e.g. the perceptual system).

Avery.Andrews@anu.edu.au

[From Rupert Young 970522.1800 BST)]

(Bill Powers (970429.1500 MST)]

Have you tried either of the "Arm" demos? They might give you some ideas.
The writeups may be of some use. Let me know if you need help understanding
the code.

I've had a look at the lman demos and code and do have a few queries, if I may?

What is meant by time integration ? As in "The output function is a pure
time-integrator: the output signal accumulates according to the size and
direction of the error signal." on page 4 of arm1calc.doc. Is it taking the
mean of a sequence of past values of a variable ?

In lman1 the elevation (y axis) and azimuth (x axis) parameters of fixation
are handled by different control systems. It seems that estimates are made of
how far the target is away from the centre of the retina. How would such an
estimate be made in a real system ? How does a neural system "measure" an
angle or a distance ? Also where on a complex object, such as a face, would
the measurement be made to ?

Looking at the lman1 description suggests to me that maybe I have been
misunderstanding a basic concept of PCT. I have been assuming that since PCT
is about controlling input that there does not need to be a direct link
between the error signal and the output, ie. the error signal does not _need_
to be an estimate of the output required to take the error signal to zero.
This seems to me still like controllling the output. The way I understood
things was that the important aspect of PCT was that the output behaviour,
whatever it may be, should reduce the error signal and that there needn't
(necessarily) be any (direct) relationship between the the output and the
error signal. The error need not be a measure or estimate of how much output
is required. Is this right ?

Also, why is it necessary to calculate the absolute distances to the finger
and target (procedure distance2) ? Wasn't the relative depth already
computed, which could be used as the error signal ? Would you agree that
natural systems don't need to measure absolute distances in this (or any ?)
context ?

I hope my questions are coherent.

···

--
Regards,
Rupert

[From Bill Powers (970522.1201 MDT)]

Rupert Young 970522.1800 BST)--

What is meant by time integration ? As in "The output function is
a pure time-integrator: the output signal accumulates according
to the size and direction of the error signal." on page 4 of >arm1calc.doc.

Is it taking the mean of a sequence of past values of >a variable?

No, it's simply a running sum, with no forgetting. In programming language,
it's expressed

y := y + f(x)*dt

where dt is the physical time duration of one iteration. The running sum y
is then (nearly) the time-integral of the variable x.

In lman1 the elevation (y axis) and azimuth (x axis) parameters
of fixation are handled by different control systems. It seems >that

estimates are made of how far the target is away from the >centre of the
retina. How would such an estimate be made in a

real system?

That's a good question that I can't answer. I simply assume that there is
such a capability. This part of the model is unavoidably schematic. Actually
I think that the real neural circuits may prove to work quite differently
from the implied system in Lman, although they will function in an
equivalent way. Rather than analog signals indicating by their magnitude the
position of a signal relative to the center of vision, I suspect that the
signals will be treated according to where they are in a more central map of
the retina. The same will probably prove to be true of the reference signals
sent to lower systems: rather than the magnitude of the signal determining
the reference position, it will be the choice of which reference signal
receives the information that determines which subset of lower-level systems
will be acting.

This is a very much more complicated kind of model to simulate on a
computer, and I have never tried it. I should mention, however, that the
Neuroinformatics group at Cal Tech, which has been building analog retinas
on VLSI chips, has actually produced circuits that will generate analog
position signals of the kind assumed in Lman 1 and 2, including depth
signals from binocular vision, so maybe the schematic model of Lman is not
so far off, after all.

How does a neural system "measure" an angle or a distance ?

All measures must be relative to the visual field, with the fovea providing
a natural center. But as to how the position of a spot on the retina could
be turned into a signal having a magnitude (neural frequency) that depends
on that position, this is a matter of neural circuitry and I don't know of
any one answer. A possible method would be through a higher circuit scanning
a retinal map in some systematic way, so position would be indicated by time
delays during the scan. Or there could be weighting schemes that produce
signals weighted according to position in the map, and summed together. Or
there might be an internal tracking window that can be positioned in the
neural map, with position indicated by where the window is as it tracks an
active spot. There must be many more schemes that would be neurally
feasible, but of course there's no way to pick one without reference to the
neural facts of vision, which I don't know. Also, as I mentioned, the coding
might actually be by position in a neural map, although that just puts off
the problem of how that position becomes a single variable, or pair of
variables.

Also where on a complex object, such as a face, would the >measurement be

made to?

I suppose any feature to which you want to assign a position.

Looking at the lman1 description suggests to me that maybe I have >been

misunderstanding a basic concept of PCT. I have been assuming >that since
PCT is about controlling input that there does not need >to be a direct link
between the error signal and the output, ie. the >error signal does not
_need_ to be an estimate of the output >required to take the error signal to
zero. This seems to me still >like controllling the output.

The error signal drives the output. See my web page for a post on what
"computing output" means. What's needed is an output function that will turn
an error into a change _in the right direction_, but not necessarily a
complete correction of the error in a single jump (as in Hans Blom's
discussion of MCT).

The reason we don't say that a control system controls its output is that
when disturbances occur, the output will automatically change in the way
that counteracts the effects of the disturbance. So setting the reference
signal to a particular value does make the _input_ come to that value, but
there's no predicting what the output will be unless you also know the
amount and direction of the disturbance.

The way I understood
things was that the important aspect of PCT was that the output >behaviour,

whatever it may be, should reduce the error signal and >that there needn't
(necessarily) be any (direct) relationship >between the the output and the
error signal. The error need not be >a measure or estimate of how much
output is required. Is this >right?

This will all be a lot easier to talk about when we have Wolfgang Zocher's
new simulator to play with. He says he'll bring it to the meeting. The
problem here is that there _is_ a direct relation between the error signal
and the output -- there has to be one -- but this doesn't have to be a
simple proportionality. In fact, in the human systems for tracking, the
output function seems to be an integrator. That is, if there is a certain
steady amount of error, the output just keeps getting larger and larger. Of
course that will be changing the perceptual signal and the error signal,
reducing the error signal. But since any error at all will cause the output
to keep increasing, the output will not stop increasing until the error
signal is exactly zero, so in the end, there will be enough output to cancel
the disturbance, and the error signal will be zero.

Words are a terrible medium for communicating these relationships. It's much
easier to see what they are in a simulation.

Also, why is it necessary to calculate the absolute distances to the
finger and target (procedure distance2) ? Wasn't the relative depth
already computed, which could be used as the error signal ? Would >you

agree that natural systems don't need to measure absolute >distances in this
(or any ?) context?

In Lman, the depth signal is computed from the angular disparity of the
views from the two eyes. The relation between signal magnitude and actual
distance is very nonlinear, so it's not really a "measure of distance."
However, what we really want is the _difference_ in the distances between
the finger and the target, so if we look at the difference between the depth
signals, we get a measure (still nonlinear) of the _difference_ in distance,
and that's the perception that is controlled. To place the finger on the
target, the visual systems control for a _zero_ difference between the two
depth signals. As you can see, this means that the absolute calibration and
the linearity don't matter. Since the same "distance" computation is used
for both the finger and the target, zero difference in distance means that
the finger is on the target, regardless of calibration or linearity.

Check out the Little Man model on my web page -- I've cleaned out the
unfinished stuff and simplified it, so it works better. The new source code
(in C) is included.

Best,

Bill P.

[From Rupert Young 970528.1100 BST)

(Bill Powers (970522.1201 MDT)]

>What is meant by time integration ? As in "The output function is
>a pure time-integrator: the output signal accumulates according
>to the size and direction of the error signal." on page 4 of >arm1calc.doc.
Is it taking the mean of a sequence of past values of >a variable?

No, it's simply a running sum, with no forgetting. In programming language,
it's expressed

y := y + f(x)*dt

Ok, I'm nearly there. What does f(x) do ? If x (is that the error signal) is
90 and y is 50 what is the new y ?

>Looking at the lman1 description suggests to me that maybe I have >been
misunderstanding a basic concept of PCT. I have been assuming >that since
PCT is about controlling input that there does not need >to be a direct link
between the error signal and the output, ie. the >error signal does not
_need_ to be an estimate of the output >required to take the error signal to
zero. This seems to me still >like controllling the output.

The error signal drives the output. See my web page for a post on what
"computing output" means. What's needed is an output function that will turn
an error into a change _in the right direction_, but not necessarily a
complete correction of the error in a single jump (as in Hans Blom's
discussion of MCT).

To briefly recap then. PCT is a more realistic model than one which corrects
the
estimate on each loop because a) instantaneous correction is not possible, b)
t
here are unknown disturbances c) calibration is not necessary, anything else?

I think the trouble I'm having with this is a topic dear to my own heart, that
o
f open-loop saccades which do seem to be a case of the position estimate being
c
orrected in a single step. I'm trying to understand how saccades work in a
feed
back control context. Perhaps the velocity of eye movements are being
controlle
d along with a system which suppresses the processing of the input when the
velo
city is high ?

>The way I understood
>things was that the important aspect of PCT was that the output >behaviour,
whatever it may be, should reduce the error signal and >that there needn't
(necessarily) be any (direct) relationship >between the the output and the
error signal. The error need not be >a measure or estimate of how much
output is required. Is this >right?

This will all be a lot easier to talk about when we have Wolfgang Zocher's
new simulator to play with. He says he'll bring it to the meeting. The
problem here is that there _is_ a direct relation between the error signal
and the output -- there has to be one -- but this doesn't have to be a
simple proportionality.

What I mean in this context is, for example, controlling an iris. The error
signal measures the amount of light from a desired value. However, this is
not an estimate of the output, the output behaviour is a different operation
of opening or closing the aperture, ie. there isn't a _direct_ relationship
between the error signal and the amount of aperture adjustment.
Another example of this is something that happened to me the other day. I was
walking along the pavement with someone ahead of me. He was sauntering along
the centre of the pavement oblivious to everything around him. I was quickly
catching him up and it was clear that to achieve my perception/goal/reference
of continuing along the pavement I would have to take a detour on to the road.
However, what I actually did was (my output) to jingle some coins in my
pocket, he heard it, looked round, stepped to one side and I carried on
without faltering. The output, jingling coins, bears absolutely no
relationship to the the required goal but still played a part in its
resolution. This may be a bit obscure but I bring it up to suggest that there
is only one necessary property of the output of a control system, which is
that it should reduce the error signal.

In Lman, the depth signal is computed from the angular disparity of the
views from the two eyes. The relation between signal magnitude and actual
distance is very nonlinear, so it's not really a "measure of distance."
However, what we really want is the _difference_ in the distances between
the finger and the target, so if we look at the difference between the depth
signals, we get a measure (still nonlinear) of the _difference_ in distance,
and that's the perception that is controlled.

Ok, but why not (if I understand you correctly) have an output function that
converts a parallax angular disparity error signal to an output, moving the
finger, which would reduce the error signal in the same way. It just seems
unnecessary to actually work out the distances, when they are computed from
the parallax.

···

--
Regards,
Rupert

[From Bill Powers (970528.0720 MDT)]

Rupert Young 970528.1100 BST--

In programming language, it's expressed

y := y + f(x)*dt

Ok, I'm nearly there. What does f(x) do ? If x (is that the error
signal) is 90 and y is 50 what is the new y ?

Yes, x would be the error signal if y is the output. Suppose f(x) is 0.5*x,
and dt is 0.01 seconds. Then the value of f(x) for x = 90 is 0.45, and the
new value of y is 50 + 0.45 or 50.45. In the next hundredth of a second, y
will change from 50 to 50.45, so it's changing at the rate of 45 units per
second (0.45/0.01).

To briefly recap then. PCT is a more realistic model than one which
corrects the estimate on each loop because a) instantaneous >correction

is not possible, b) there are unknown disturbances c) >calibration is not
necessary, anything else?

Yes, the question of accuracy of computation. If the output function loses
sensitivity by a factor of two, the only effect on the PCT model will be to
change the speed of error correction; the final error will still be small.
In the MCT model, if the link from the reference signal to the output is
not exactly the inverse of the world-model, there will be a control error
of exactly the size of the computational error. I showed that in the
"bare-bones" model Hans supplied that the PCT model was somewhat sensitive
to this computation error, but that the MCT model was 20 times as sensitive.

I think the trouble I'm having with this is a topic dear to my own >heart,

that of open-loop saccades which do seem to be a case of the >position
estimate being corrected in a single step. I'm trying to >understand how
saccades work in a feedback control context. Perhaps >the velocity of eye
movements are being controlled along with a >system which suppresses the
processing of the input when the

velocity is high ?

This is somewhat like the model of saccades I worked out some years ago. I
do recommend that you ask Wolfgang Zocher about it -- he has all my
materials on this, including the derivation of the mathematical model. What
struck me is that when saccades occur while pursuit tracking is going on,
the eye returns instantly to the same velocity after the saccade,
immediately locking on to the moving target again. My postulate was that
the normal mode is pursuit tracking, where the eye locks onto the object
whether moving or not. An off-axis target for the saccade is selected, and
at the moment of the saccade, the pursuit tracking system is simply
disabled, allowing the position control system to snap the eye to the newly
selected position. Then pursuit tracking is turned back on, and the eye
continues to be locked onto the (new) target. Errors in the saccades (which
can be several degrees) then reflect only errors in selecting a target in
peripheral vision.

My model seemed to reflect all the major phenomena of visual position
control, including subjective effects occurring when torques are applied to
the eyeball. There was even a prediction: just after a subject is told to
select a new target in peripheral vision, but prior to the start of the
saccade, the eyeball should start a slow drift toward the new target. The
speed of the drift would depend on the relative loop gains in the pursuit
and position control systems, so I couldn't put a number to it. A careful
experiment should be able to test this prediction.

···

----------------

What I mean in this context is, for example, controlling an iris. >The

error signal measures the amount of light from a desired value. >However,
this is not an estimate of the output, the output behaviour >is a different
operation of opening or closing the aperture, ie. >there isn't a _direct_
relationship between the error signal and the >amount of aperture adjustment.

I think you're trying to describe integral control. The iris opens or
closes at a _rate_ that depends on the error signal., so the iris opening
is the integral of the error signal.

Another example of this ...
However, what I actually did was (my output) to jingle some coins in >my

pocket, he heard it, looked round, stepped to one side and I >carried on
without faltering. The output, jingling coins, bears >absolutely no
relationship to the the required goal but still played >a part in its
resolution. This may be a bit obscure but I bring it >up to suggest that
there is only one necessary property of the >output of a control system,
which is that it should reduce the error >signal.

That's shorthand for saying "it should affect the world in such a way as to
reduce the error signal." You picked a clever output, but it still depended
on the error signal (that is, you jingled the keys when there was an error,
and I suppose you stopped when there was no longer an error). The other
person's reaction to the keys was part of the environmental feedback
function: jingling alerts person, person steps out of the way, you perceive
an open path. Same function as an automobile horn or the bell on a bicycle.

Your example brings up something that is not yet part of HPCT: the
selection, in real time, of different lower-level control systems as part
of the way a higher-level system corrects its errors. I think this may be a
missing level. It shows up in language too -- picking the words that are to
be output in the process of constructing a sentence, for example. The
system is not hard-wired; the error-driven output of a higher-level system
can apparently be switched so it enters the reference inputs of different
lower-level systems on different occasions. This switching is part of the
process of control, probably up there somewhere where planning takes place.
So the SAME higher-level control system can use DIFFERENT lower-level
control systems. The process of switching is independent of the process of
control that happens once the switching is done. I haven't gone any farther
than that.

In Lman, the depth signal is computed from the angular disparity >>of

the views from the two eyes. The relation between signal >>magnitude and
actual distance is very nonlinear, so it's not really >>a "measure of
distance." However, what we really want is the >>_difference_ in the
distances between the finger and the target, so >>if we look at the
difference between the depth signals, we get a >>measure (still nonlinear)
of the _difference_ in distance,

and that's the perception that is controlled.

Ok, but why not (if I understand you correctly) have an output >function

that converts a parallax angular disparity error signal to >an output,
moving the finger, which would reduce the error signal in >the same way.
It just seems unnecessary to actually work out the >distances, when they
are computed from the parallax.

You're quite right about that. When I say that the "distance" signal is
nonlinear with respect to actual distance, I'm really saying that the
signal isn't a distance measure at all -- it's just a function of angular
parallax.

There is some reason, however, to try to make this perceptual function
yield a signal that is reasonably linear with actual distance. The loop
gain of the control system includes the sensitivity of the perceptual input
function, and if this function is nonlinear, the loop gain and hence the
accuracy of control will depend on how far away the finger is. At nearly
full extension of the arm the angle changes slowly with distance, so the
system is less sensitive to distance changes. You'll notice that when
Lman's fingertip is close to the eyes, the control tends to get a little
unstable -- the loop gain is too high. If you reduce the overall gain to
compensate, then control gets sluggish when the fingertip is far from the
eyes.

It would be possible, by a number of means, to make the loop gain vary with
distance of the fingertip from the eyes, but that gets to be an ad-hoc
patch on the model. I'd rather fix the problem in a more natural way. What
seems more natural is that the distance measure, as well as the x and y
measures, should be transformed into a perceptual space that is reasonably
linear in relation to laboratory space. The inertial and kinematic
properties of the arm, after all, exist in laboratory space. If the
perceptual systems adapt until control is about equally good over the whole
range of distances and angles, we would expect the perceptions to become
pretty linear relative to laboratory space.

If we were to postulate that the visual map becomes linear relative to
external space, we could just use the actual positions of the fingertip and
target as visual perceptual signals! I wasn't ready to go that far, and
anyway I wanted to make it clear that this correspondence doesn't HAVE to
be exact (as you have intuited), so I left the model with a nonlinear
relation between visual and real space. It would be nice to start with just
the visual angles, and work out a scheme whereby the visual perceptual
space would gradually adjust for equally good control in all positions. If
we could do the same for the kinesthetic perceptions of arm position, then
it might be possible to work out a way for the kinesthetic and visual
spaces to be brought gradually into exact correspondence -- that's what the
"mapping" idea in the earlier version was aimed at, although I didn't get
very far with it.

There's a hint that the visual space does contain corrections for geometry:
size constancy. Objects appear to have the same lateral dimensions (and
perhaps constant depth dimension) as they move nearer and farther away.
This suggests that the visual input functions correct lateral visual angles
and perhaps depth signals for distance, just as I would do when trying to
preserve constant loop gain at various distances in the control model. We
really need to check out the properties of human arm control systems in
three dimensions, to see if the control parameters seem to be anchored in
objective space rather than the space we get directly from visual angles.
It would be interesting to vary the distance between the eyes (using
prisms, not surgery) to see if this distorts the control parameters, and if
the parameters then adapt again for equal control accuracy at all
distances. This doesn't tell us where in the system the adaptation takes
place, but maybe we would get some suggestions from the experimental results.

You ask good questions.

Best,

Bill P.

[From Rupert Young 970605.1900 BST]

(Bill Powers (970528.0720 MDT))

>> y := y + f(x)*dt

Yes, x would be the error signal if y is the output. Suppose f(x) is 0.5*x,
and dt is 0.01 seconds. Then the value of f(x) for x = 90 is 0.45, and the
new value of y is 50 + 0.45 or 50.45. In the next hundredth of a second, y
will change from 50 to 50.45, so it's changing at the rate of 45 units per
second (0.45/0.01).

So the output is the 0.45 ? Or is it the 50.45 ? Is the 0.45 the _change_ in
output ?

Is a proportional controller then, y := y + f(x) ? ie. some propoetion of the
error signal, irrespective of time. Could a proportional controller be called
an integrator (but not a time-integrator) ?

···

--
Regards,
Rupert

[From Bill Powers (970605.2209 MDT)]

Rupert Young 970605.1900 BST --

Hi, Rupert.

(Bill Powers (970528.0720 MDT))

>> y := y + f(x)*dt

Yes, x would be the error signal if y is the output. Suppose f(x) >>is

0.5*x, and dt is 0.01 seconds. Then the value of f(x) for x = 90 >>is 0.45,
and the new value of y is 50 + 0.45 or 50.45. In the next >>hundredth of a
second, y will change from 50 to 50.45, so it's >>changing at the rate of
45 units per second (0.45/0.01).

So the output is the 0.45 ? Or is it the 50.45 ? Is the 0.45 the >_change_

in output ?

The output is the 50.45, and the 0.45 is the amount by which the output
changes in the interval dt (0.01 sec).The output function, which lies
between the error signal and the output, continually carries on the process
of time integration, always producing an output equal to the result.

Is a proportional controller then, y := y + f(x) ? ie. some >proportion of

the error signal, irrespective of time. Could a >proportional controller
be called an integrator (but not a time->integrator)?

No, a proportional controller would be one in which the output is
proportional to the error signal: y = k*x, where k is the proportionality
factor. In other words, y := f(x) (not y := y + f(x)), where f(x) is simply
k*x. In a proportional controller, a change in the input (error signal) is
reflected immediately as a proportional change in the output.

Maybe it would help if we used a more appropriate notation -- the "x" in
the equations above really means time, so we ought to be saying y := y +
f(t)*dt. The error signal is f(t), a function of time. This function gives
us the value of the error signal at any time t. Since the output is
accumulating the values of the error signal, the output will change during
the time interval between t and t + dt. If we assume that the error signal
doesn't change appreciably during that short interval, we can say that the
output is changing at a rate f(t) for a time dt, so multiplying the rate
times the time gives us the total change during that time. In other words,
f(t)*dt is simply the amount by which the output changes during the
interval dt. So if we add f(t)*dt to the old value of y, we will get the
new value of y.

At the end of that interval, the error signal will be different: it will
have changed by some amount, so now we have a new f(t) where t has advanced
by one interval dt. This is the new value of the error signal, which we
again assume to be constant during the interval. We multiply this new value
by dt, add the result to y, and get the new value of y, and so on.
Obviously this is not quite right, because the error signal is (in the
general case) changing during the interval dt; it's not really constant.
That's why we use as small a value of dt as possible; the smaller it is,
the less error is introduced by assuming that f(t) is constant during the
interval dt. There are more complex integration methods that can eliminate
some of this error even for rather large values of dt, but this simple
method works quite well, especially if we can make dt very small (if we can
live with the slowness brought on by having to do many computations to
cover each second of elapsed time).

An example of a physical process that involves time integration would be a
pump that runs at variable speeds to fill a tank with water. The input
variable (corresponding to the error signal) would be the rate at which
water is pumped in. The output variable would be the height of the water in
the (cylindrical) tank. Suppose we say that the speed of the pump (the
intake flow rate) is a function of time, f(t). We measure the height of the
water in the tank at intervals dt, say every tenth of a second (dt = 0.1).
We also measure the rate of inflow, f(t), every tenth of a second. We can
then see that the height of the water, y, will increase by an amount f(t),
the flow rate, times the interval before we measure it again, dt. We need a
proportionality factor k to account for the diameter of the tank (a
large-diameter tank will fill more slowly than a small-diameter tank, at
the same rate of inflow). So we would say that

y = y + k*f(t)*dt

Now suppose that the inflow rate is constant (f(t) = c). This will lead to
y increasing by the same amount, k*c*dt, in every interval. The tank will
keep getting fuller and fuller at a constant rate, as long as the inflow
remains constant. If we stop the inflow (c = 0), the height of the water
will just remain constant. If we _reverse_ the inflow, making the inflow
rate -c instead of c, the tank will empty -- the height of the water will
fall -- at the same constant rate.

What would happen if we made the inflow increase linearly from zero with
time? This is like saying the inflow rate is c*t -- at t = 0 the inflow
rate is zero, and it increases at the rate of c gallons per minute every
second. How will the height of the water vary with time?

The function f(t) is now c*t, so this gives us the program step

y := y + k*(c*t)*dt.

The calculus shows that we will have

y = (1/2)*k*c(t^2).

In other words, the height of the water will increase as a parabolic
function of time. Notice that the form of the output variation is NOT the
same as the form of the input variation. The input rises linearly with
time; the output rises as the square of the time.

What if we make the inflow vary as a sine function of time, going equally
positive and negative? The height of the water will then vary as a cosine
function of time. And so on, through all the forms of integrals you learn
in the calculus. For every way in which the input (the error signal) varies
with time, there is a corresponding way in which the output varies with
time, and if we can represent the variations in the input by some simple
analytical function, we can predict, by integrating that function with
respect to time, how the output will be varying.

When we're analyzing a real system, we may not be able to find the integral
of the actual time function according to which the input varies -- there
may be no analytical form that's close enough, or we may not know in
advance how the input is going to vary (some other unknown process is
varying the speed of the water pump). But using simulations, we can still
compute the value of the integral numerically, step by step, by computing

y := y + k*f(t)*dt.

That's what we're doing in our simulations. We say the output function is
an integrator, which means that the output y is related to the error signal
input f(t) by the above incremental relationship. By making dt small
enough, we can compute the value of y, very nearly, that would result from
ANY error waveform f(t). Of course the error signal depends on the
perceptual signal and reference signal, and the perceptual signal depends
on the output and the disturbance, all of which are time-varying functions.
What our simulation does is tell us HOW those variable will change with
time, given only the variations in the disturbance and (if any) the
reference signal.

I hope this isn't overkill --

Bill