[From Bill Powers (980416.0332 MDT)]

When I learned long division, I learned it as a program. First, set up the

problem in a standard configuration:

## ···

_____

12 / 637

Then, starting with the leftmost digits of the dividend, find the number

that is greater than the divisor (in this case, 63). Guess how many times

the divisor will go into that number (here, 5), and write that number down

in the "appropriate" position:

5

_____

12/637

60

___

37

... and so on. The "and so on" shows us that we're dealing with a program.

From here on, we can repeat the same operations and tests until the result

comes out even or we have as much accuracy as we want.

Obviously, I had to reorganize to learn this program. I was given endless

pairs of numbers and told to divide one by the other using long division,

so I had to go through the program again and again, gradually learning how

to estimate the trial divisors and how to "bring down" the numbers

correctly. I had to make mistakes, and get punished for making them (as if

the mistakes weren't embarrassing enough), and eventually install this

program in my brain so I could apply it to any pairs of numbers, including

those with decimal fractions.

A while later, I learned a similar procedure for taking square roots. It

involved "bringing down" pairs of digits, and a lot of other processes

similar to those in long division. But I don't remember those processes any

more, because I learned a simpler way, Newton's method, and more important,

I learned the _principle_ behind Newton's method, so I could recreate it if

I forgot it. The principle was successive approximation. Basically, I

wanted a number R such that R*R = N, N being the number I want the square

root of and R being the root. This involves another principle: if R1*R2 =

N, then a closer approximation to the trial root can be found from (R1 +

R2)/2. Given a "randomly" chosen trial root R1, R2 then can be found from

R2 = N/R1, so

R1(new) = (R1(old) + N/R1(old))/2,

... and there's the program. Just keep running it over and over until

R1(new) stops changing by a significant amount, and R1 will be the square

root of N.

Notice that I could simply teach you that program, and after you had

learned it you would "know how to take a square root using Newton's method"

just as you can "know how to do long division" without understanding the

principle. But if you forgot it, you would have to find me and ask me to

remind you of it, and you would have to relearn it. You would be dependent

on me and on re-memorizing the program, because of not knowing the

principle of successive approximation that's behind it. If you couldn't

find me, you'd just have to experiment and rediscover the program by trial

and error -- i.e., reorganization.

Learning that principle also required reorganization, but reorganization at

a higher level. The big advantage of learning at the higher level is that

you could then recreate the program _without reorganizing_. In fact, if you

forgot the program for long division, you could apply the same principle to

recreate that program, too, because the long division procedure is also a

method of successive approximation. Later on, you would find that the same

principle is part of the concept of a control system, so if you ever forgot

how a control system works, you could recreate that, too, with the help of

the same principle.

This longish example illustrates a number of principles of reorganization.

First, if you have a systematic way to achieve a result you don't need the

less efficient method of reorganization to achieve it. In fact, because the

systematic method is installed as an automatic control system, it will

correct errors as soon as they appear, leaving insufficient error to turn

on the reorganizing process.

Second, reorganizing at a higher level, if possible, is more useful than

reorganizing at a lower level. In some respects, the higher level system

can "work out" what is needed at the lower level without the need for rote

memorization or (random) trial-and-error. New situations can be dealt with

without the need for reorganization.

And third, you use reorganization only when there is NO systematic way to

get what you want. This is why reorganization has to be a random process --

random meaning "not according to any known systematic scheme." If you have

tried all existing systematic schemes and none of them corrects the error,

all that is left is a non-systematic -- random -- scheme. That is why, in

PCT, the output of the reorganizing system is a random process.

So -- when does reorganization occur? Apparently, whenever there is a

perception that we want to recreate, and we have no ready-made method of

recreating it.

All this is simply a description of what seems to happen. It's not a model.

The reorganizing system, with its intrinsic variables, reference signals,

comparators, and output functions is a model devised to explain what we see

happening.

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

Peter Burke has asked me to look at the paper with the following URL:

http://burkep.libarts.wsu.edu/Papers/Identity%20Levels%20and%20Agency.pdf

It is a study of the program and principle levels in 30 young mothers. It

shows how the interview technique can be used with profit in studying

higher-level organizations. I think it's a ground-breaking paper.

Best,

Bill P.