(A follow-up on
Continuous state storage.)

An hour after posting that, I realized that of course my described mechanism for filtering out false hits by re-applying the key stored with the result will not in fact work, precisely because a holographic memory is a linear device, yielding a linear superposition of the various answers. If we have false positives mixed in with the 'correct' answer, we will have false keys linearly mixed in with the correct key, and feeding the key through a linear amplifier and re-trying should yield exactly zero progress: We should get exactly the same mixture of false and correct positives back the second time around.

The key observation, I think, is "linear amplifier". We -must- introduce a non-linear element into the system at some point if we are to have an general-purpose optical computer, and not just a computational vacuum in which information streams linearly pass in the night without interacting to compute anything new. The amplifier appears to be an obvious place to look for this non-linearity, given that holographic memories tend to be implacably linear (and that we probably -want- this) while amplifiers seem in general to love being non-linear, and to get teased into some approximation of linearity only by dint of considerable engineering...?

Suppose for conceptual simplicity that our keys were all normalized to consist of spatial patterns light and dark areas, the light areas being one brightness and the dark areas being another brightness, and each key having an equal area of brightness. (We may be able to relax these requirements later, but I think they make a good starting point.)

Let's now feed a defective (i.e., approximate) query into our holographic store, which we suppose to be linear and to store the read/write key as part of each datum, in a particular spatial part of the result. For now, let's ignore the payload area and examine only the returned key area.

Since our key was approximate, we should suppose that our returned key will consist of the linear superposition of several keys; The strongest is by definition the "correct" answer, and the other keys are by definition "false positives". What we would like to do is to weed out the "false positives" so in the end we have only the "correct" key.

This doesn't seem an impossibly difficult task, given a suitable non-linear amplifier. What we need is for

- Weak signal elements to be amplified less (proportionally that strong signal elements.
- Over-all signal output power to be controlled via some limiting (feedback?) process.

Is this a difficult design task? Seems to me that if you have a finite pumping rate, output power is inherently limited to that pumping rate on a given cycle (assuming equilibrium operation), and that nonlinear behavior in an amplifier is common, which means there must be some parts of the output curve in which the nonlinearity runs the way we want.

The above mechanism can be seen in a number of different if related lights (heh):

- Introducing quantization into our continuous computer. One always needs this in the end. (Jerry will note that we're essentially locating an attractor of an iterated function system, which I proposed as a/the general mechanism for imposing quantization on a continuous mechanism.)
- Doing noise elimation / signal restoration. Any computing
system (well ...
*most*anyhow) introduces noise into the signal as it operates, requiring periodic restoration of the signal, typically by "rounding off" to a nearest canonical value: If done before the signal can random-walk half the distance separating canonical values in the computational space, this will correctly eliminate noise but not signal. - Doing mutual exclusion. In both classical von Neumann computing (e.g., the Dining Philosophers problem) and biological computing (e.g., mutual inhibition of surround fields in the retina, or recollection of memories from a given set of cues) one frequently needs to be able to pick exactly one of a set of alternatives.
- Making a decision. In both classical AI and introspective concious thought, one frequently is faced with several possible courses of action, and the need to try at most one next. (The Lady or the Tiger?) One needs a mechanism for weighing several appealing alternatives and settling on exactly one.

If we had both of the above, I think we'd have about 2/3 of
a general-purpose optical computer. (I'm still pondering
recursive functions with parameters *grin*.) We
*might* have all of it. That would be nice...