(you may click the number of the subfile to be viewed, or scroll down)

This file contains the following subfiles:

62 - internal conversation
62.4 - de-fragmentation of puss-memory
64 - direct reinforcement
66.6 - efficient questioning


 (subfile 62: more details)


Even the simplest conversation requires considerable internal discussion on  the parts of both participants. If you tell me “Spot ran home” I know that we’re talking about the past, that Spot wasn’t home before this, that Spot was at least at home for a moment at some point after running there, that you can see Spot or that someone told you about him, and so on. I expect the program to spend a good deal of time talking to itself like this, and that its arrival at output will be like the arrival of CHANTER at a series of pitches and symbols known to be “cadential”, that is, ones which signal an ending.

On the other hand, since we humans will be able to watch the entire process as it happens, we can intervene whenever we choose – whenever we think that sufficient work has been done, so that the current ur-path looks like output. Since the algorithm fundamentally operates by making predictions based on past experience, each time the Teacher intervenes, the algorithm will learn something about “when it is appropriate to stop” and say something “out loud”.

Eventually, then, as the program learns other stuff, it will also learn to stop and output its current state. (The intervention by Teacher in the middle of internal calculations may be more like schizophrenic (or bicameral?) “voices” than like a conversational interruption - this might  turn out to be counterproductive.)



(subfile 62.4 - puss-memory defragmentation )

This is a process made necessary by the addition of features to Andreae's original Puss structure. His method is perfectly well known, and is venerable enough to have mention in the "hashing" section of Knuth's classic volumes.

The feature vector is decomposed into a series of decimal digits and is treated like a single integer. This integer is then divided by the index of the largest memory location available. The remainder can't be larger than this number, and is therefore useful  as the hash-memory location for that feature vector.

Since multiple integers can give the same remainder when divided by a number, some method for handling these 'collisions' must exist. Andreae used a series of prime numbers, the largest of which is the maximum memory size. Every datum is stored thrice, using different primes as divisors. When a collision occurs (that is, when a remainder is calculated that hashes to an already-occupied  memory location), the next prime in the sequence is taken, and another remainder calculated. Thus before storage takes place, the system may skip over numerous used places. The use of three primes reduces nearly to zero the probability of confusion among entries.

The problem arises when one erases a datum's three storage points.  If, in the process of storing X, a location for Y is skipped over, and then if Y's data is removed from the memory, the system will lose the ability to find X. The temporary solution is the assignment of a dummy value that tells the system "keep going!", but when the memory gets filled up with these dummies, search time actually does become exponential.

Fortunately, actual data can be moved back up into the locations vacated by erasures,  in a de-fragmenting process that can either run as the system probes for data or as a crawler.



(subfile #64: some examples of intrinsic reinforcement)

Any reply from a human that starts “No,...” or “Yes, that’s right,.....” is an unambiguous message that the program’s behavior has succeeded or failed. Additionally, any continuation of a conversational tack (without some corrective or negative word) is itself intrinsically positive – in answering a statement that is nonsense, no reply is possible that is honest, kind, sane, and non-humorous except one that somehow recognizes the nonsensical nature of the stimulus. It will be amusing (!) to watch instanciations of this program be driven insane by ill-conceived or incompetently executed habits of reinforcement.


(subfile #66.6 MS regions and efficient questioning )

Engineers use a particular gimmick to help with creative thinking: make a spreadsheet and figure why some boxes are empty. For example,  list all the ingredients that are available to your cook on both columns and rows. In each box list menu items that use both items represented by that box’s intersection. You might see a blank box under “sugar” across from “chicken”, leading you to decide to add The General’s Chicken to your menu. Adding a third dimension would allow you to see that the 3-way intersection at “chocolate”, “vinegar” and “oranges” was blank – with good reason, perhaps, but you would have a clue about inventing a unique dish, and your clue came from a purely mechanical process requiring neither heuristic sophistication nor complex decision processes.

Meaning space comes with no definitions for columns and rows that are as automatic as a cook’s resources. The surfaces that separate regions of MS (that are analogous to the spreadsheet "boxes" above) must be defined by analytical means. Some methods, and the sets of surfaces defined by them, are available as soon as words have been defined:
        *start with any point and its list of non-zero axes
        *move away from that point systematically, inflating the postulated region as you go, but stopping in
           any direction when another defined object is found that, for instance, has a value on an un-listed axis.


Recall that clusters can serve as indicators for divisions within paths (see subfile 16.5): the translation of this idea across levels leads to a way to find boundaries within MS. The process has the same outline as that above, but the point at which one ends the expansion is determined by the sort of cluster-output-discontinuity that defined phrases at the lower level.