https://www.youtube.com/watch?v=fEWcg_A5UZc

More on linear models of computation:

https://github.com/anhinga/fluid contains open source code, demo videos, and links to the reference paper and other preprints written by our group on this topic.

We finally have a model of computation which allows us to

*continuously deform programs*and, moreover, to

*represent large classes of programs by matrices of real numbers.*

We consider classes of computations which admit taking

*linear combinations of execution runs.*Two well known large classes of computations with this property are

*probabilistic sampling*and

*generalized animation*. Both allow for enough higher-order constructions to make us believe that limiting consideration to either of these two classes is not a restriction of generality compared to general-purpose computations.

Since both probabilistic sampling and generalized animation represent stream-based computing architecture, it is natural to consider

*dataflow programming*in this context. We experimented with several different dataflow architectures (the animation above demonstrates the first of the architectures we considered).

We eventually obtained the following solution. If one takes a countable number of built-in stream transformers of one's choice (usually, one takes a finite number of those, and then considers a countable number of copies of each), one can then take each input to be a countable sum of all outputs.

The way to think about this is to say that the set of built-in transformers defines a language, and the coefficients in the countable sums define a program in that language. So a

*program is defined by a countable-sized matrix*; usually one requires that only a finite number of those coefficients are non-zero in order to fit all this into a finite machine.

Then one can change the program in a continuous fashion by continuously changing the matrix coefficients. Because a countable-size matrix has a countable number of matrix elements, one can compute the matrix elements themselves via the streams of real numbers computed by the program itself, thus enabling a variety of higher-order mechanisms (the continuous version of self-modifying code).