*Background:*

Classical AI has a consistent problem with fragility
and difficulty of learning, which I trace in large
part to the use of discrete data spaces (in particular,
boolean and small integer), which among other things
prevent the application of hill-climbing algorithms.
I'm interested in understanding how one programs
using continuous data spaces and types.

*Focus: Control structures*

At the moment, I'm particularly interested in how
one replaces conventional von Neuman control
structures (*if-then-else* and *while-do*
and such) with control structures more in the spirit
of continuous domains -- energy minimization algorithms
and such.

Straight *if-then-else* seems relatively
straight-forward. For example, a mixing function
controlled by a (0,1) parametrix mixing function
can output a linear mix of two input data functions.
Interation constructs seem less obvious.

*Approach:*

I spent the evening rereading *CommonLisp the Language 2nd Ed*'s
section on Series. This provides in essence a classification of
what interactive control structures are used for in practice.
Three general categories are identified:

- Functions producing a (finite or infinite series) from scalar inputs.
- Functions combining or transforming series.
- Functions producing scalar results from series inputs.

The first category includes such functions as the whole numbers in order, and all the elements of a list, tree, vector or similar aggregate datastructure in some (possibly somewhat arbitrary) order.

The second category includes functions which selectively drop or insert elements from series to produce new series, functions which merge multiple series to produce a single one, and functions which split a single series into multiple ones.

The third category includes functions which store a series in a list, vector, tree or other aggregate datastructure, and functions which compute some scalar summary or property of a series, such as max, min, sum, average or mean.

The Series appendix provides a set of functions in the above category which is claims satisfy >90% of all iteration needs, based on about 100,000 lines of programming experience by several people of the course of a year.

Whereas conventional Algolic von Neumann iteration constructs do not have immediately obvious continuous counterparts, I think that it is reasonably clear that all of the series functions have quite natural counterparts in the continuous domain:

- Fourier, wavelet, noise and similar functions provide generation of continuous functions from small input sets;
- Convolution, Fourier transforms and such provide rich sets of operators for combining, transforming and splitting continuous functions. In most cases fairly direct analogues can be identified. Dropping or inserting members of a series corresponds to dilation or contraction of a continuous function, for example, and dropping members of a series based on some predicate (or splitting into multiple sequences based on some predicate) corresponds to separation by convolution, bandpass filters, or such.
- Max and min carry over directly from the discrete to the continuous domain, if desired, and low-pass filters can provide sort of a running measures of such functions over recent history (instead of over all history). Numerical integration is the straight-forward analogue of the sum, etc.

I'm quite encouraged: From the control structure point of view, moving programming from the discrete to the continuous domain looks to be conceptually quite straightforward, at least on brief consideration.

Next problem: Recursion and parameters. :)