[Martin Taylor 2014.06.01.19.18]

```
I guess you aren't understanding me! I was setting up an extreme
```

case in which moving the mouse would immediately influence the

cursor, but that the loop transport lag would be very long, so that

the feedback effect would be delayed by hours.

Although in the long term, control would be established, at least

for very slowly moving disturbances, any more rapid mouse changes

would be closely correlated with cursor changes.

Yes. That has been the result whenever the simple “leaky-integral”

control loop has been used to model simple human tracking such as

you asked about. It usually seems to be about 18 msec (at least for

Bill and me). Physically, every connection in the loop MUST involve

some transport lag, but that’s probably not where most of the lag

occurs. It’s probably mostly processing time. The leaky integral

also imposes its own delay, but that’s not included in the transport

lag. The leaky integral just determines how fast the effect of a

change dies away. Transport lag determines how long it is before the

effect of the change *begins to* dies away.

That’s not right. There’s no such definition, and C must correlate

with both. Here’s a geometrical way of looking at why this is. If you are

visually inclined, as I am, this way of looking at it makes for much

clarity. If you aren’t, I guess it won’t help. But it’s worth a try.

If X = Y+Z, where X, Y, and Z are sequences of samples of

variables, X will be correlated with both Y and Z unless Y = -Z + k

(k is a constant), in which case X = k is constant. The degree of

correlation of X with each of the other two depends on their

relative range of variation and the correlation between them. For

example, if Y and Z are uncorrelated and have equal range of

variation, X is correlated 0.707 = 1/sqrt(2) with each.

-------- more detail ------

More generally, any sequence of N values identifies a point in

N-dimensional space, or a vector from zero to the point. Two such

sequences represent two vectors. Since any three points in space

define a plane, these two vectors lie in a plane. By doing the

algebra, you can prove that the cosine of the angle between them is

the correlation between the two sequences.

The difference between two vectors defines another vector that is

also in the same plane. So, if X = Y-Z, X is a vector that connects

the points defined by Y and Z. The points defined by Y, Z, and zero

are the corners of a triangle, whose sides are the vectors X, Y, and

Z. Hence, if one knows the lengths of Y and Z (square root of the

sum of squares of the sequence values y1, y2 … yN, and similarly

for Z) together with the correlation between them, one can find the

length of X and its correlation with Y and with Z using the formulae

(from Wikipedia "Solution of Triangles):

**Wiki quote****

**end Wiki quote***

In correlational terms using X, Y, Z as above, and taking “x”, “y”,

and “z” to be their lengths (or total energies if X, Y, and Z

represent signal values):

x = sqrt(y^2 + z^2 - 2y*z*corr(y,z))

corr(x,z) = (x^2+z^2-y^2)/2(x*z)*

corr(x,y) = (x^2+y^2-z^2)/2(xy)

You can scale the lengths by dividing by the number of samples if

you want to use sequences extended indefinitely over time (using

power instead of total energy).

If Y and Z are uncorrelated and of the same length, the triangle is

a right-isosceles triangle. Scaling the lengths of Y and Z so that y

= z = 1, corr(x,z) = (2+1-1)/2(sqrt(2)) = 1/sqrt(2) = 0.707

-----------end extra detail--------

Now consider the control situation about which you asked. C = M+D corresponds to X = Y+Z above, but for the vectorial analysis

the triangle was described with X = Y-Z, so let’s put V = -D and say

C = M-V.

If control is very good, M and D have almost the same length and are

correlated nearly -1, so M and V are correlated nearly +1. Putting

these into the correlation formula in the “extra detail” section

above, we get

C = sqrt(M^2+V^2 - 2M*V*(1-eps)) where eps is a positive number much

less than 1.

Since M and V are almost the same length, C ~ M*sqrt(2*eps), which

is very small compared to M (or D), where ~ means “almost equal to”.

corr(C,M) = (C^2 + M^2 - V^2)/2(C*M)*

Since M and V are almost the same,

corr(C,M) ~ -corr(C,D) ~ C^2/2(CM) = C/2M = sqrt(eps/2)

For the trial in the diagram you showed in [From Rupert Young

(2014.05.31 17.00)], eps = 0.03, which gives corr

corr(C,M) = -corr(C,D) ~ 0.12

corr(C,D) is shown as -0.16, which, given the single-digit accuracy

of eps, is quite close.

But corr(C,M) is shown as 0.38, which is too big. Why is this?

The answer is implicit in the actual traces displayed. Sqrt(eps/2)

is a minimum value, which assumes that there is no autonomous

(noise) mouse motion. But in the traces shown, there is a lot of

variation in M that has no counterpart in D, and that variation,

which is reflected in C, is what caused you to ask your question in

the first place. This extra variation is additional to the variation

that opposes the disturbance, which means M^2 > D^2 (or V^2).

Looking back at the correlation formula, corr(C,M) was taken to be

nearly (C^2)/2(C*M), but that was under the assumption that M^2 =

D^2. Since M^2 > V^2, the difference is an added term that

increases corr(C,M).

The added variation in the displayed traces is clearly not only a

consequence of transport lag or of the delay induced by integration.

It’s too irregular for that, but they do have an effect that is

included in the correlation between cursor and mouse. As I said

earlier [Martin Taylor 2014.05.31.17.09]: “…rapid disturbance

changes are less well controlled than slow ones, and … more of the

cursor signal is due to the mouse at high frequencies than at low.

So, in the correlations, you see the effect of cursor changes more

than of cursor values.”

Martin

## ···

```
I'm not sure I am understanding you. You'd see the cursor moving,
```

but moving the mouse would have no effect.

```
Take the other extreme, with a loop transport lag
```

of zero. In this case, an arbitrary movement of the mouse would,

like a change in the disturbance, be immediately compensated,

and in fact you wouldn’t see it at all, except for the fact that

integration takes time (the output stage is usually taken to be

an integrator).

```
In the real case, there is a finite loop transport lag. In many
```

of Bill’s and my experiments, our results were best fitted by

loop transport lags of around 18 ms. This means that changes in

the mouse are indeed reflected momentarily (and it’s a short

moment) in the movement of the cursor, so that if you

differentiate the cursor trace and the mouse trace, they will

correlate more than will the simple values.

```
Do you mean there is a lag due to the processing time of the
```

system?

```
Or due to the non-zero resolution of the visual
```

system? Are you saying that there is a correlation?

```
Perhaps there is a simple answer to my question, in that C = f(M)
```

- f(D), so by definition C does not correlate with f(M)?

### Two sides

and the included angle given (SAS)

Here the lengths of sides and the angle between these

sides are known. The third side can be determined from the law of

cosines:^{}

Now we use law of cosines to find the second angle:

Finally,

```
[From Rupert Young (2014.06.01
```

17.00)]

([Martin Taylor 2014.05.31.17.09)

```
Rupert, imagine an extreme case. Suppose that the loop transport
```

lag were measured in hours rather than milliseconds. The cursor

position is the sum of the disturbance and the mouse. If, in

this extreme case, the mouse were to move 1 mm, no matter what

the disturbance did, the cursor would move 1 mm more in the

mouse direction than would be caused by the disturbance

movement, and that extra movement would not be compensated until

hours later. You would see a correlation between rapid (quicker

than hours-long) movements of the mouse and movements of the

cursor, regardless of what the disturbance does.

[From Rupert Young (2014.05.31 17.00)]

```
Hi Rick,
Looking at the tracking task I notice that although the
```

correlation C-M is poor it does look if the cursor trace goes

up and down when does the mouse. Has the correlation between

the *change* in the mouse value and the *change* in the cursor

value been computed? In other words, is there a good

correlation between the change in output and the change in

input? What would be the significance if this were the case?