Towards a generalized theory comprising digital, neuromorphic and unconventional computing

I begin my detailed investigation with a discussion of DC formalisms and models. A first overview: the how-formalisms include abstract descriptors of algorithmic processing which are mainly used for theoretical analysis (like the Turing machine or certain grammar formalisms), as well as formalisms which are destined for practical use, most importantly programming languages. Some abstract how-formalisms are useful also for practical programming, in particular lambda calculus (which directly spins off the so-called functional programming languages) and the random-access machine model (which is close to assembler programming languages).—The what-formalisms are logic formalisms, with Boolean logic and first-order logic the standard textbook representatives. What-models are sets of logical formulas that specify what a program should compute. Such specifications are needed when one wants to formally verify that a written computer program actually fulfills its purpose—an important objective in many application domains. A special case are the so-called declarative programming languages, like Prolog or functional programming languages, which can be dually regarded as how- and what-formalisms and allow the user to write programs directly in terms of 'what' tasks shall be computed by the program. All of the above is explained in any textbook of theoretical computer since, such as my own online lecture notes [Jaeger 2019a, 2019b].

There are further formalisms that belong to the wider circles of DC theory which do not fall into the how- and what-classes that I mentioned here. For example, I exclude from consideration formal communication protocols between different computers. The formalisms that I mentioned however can be considered the bone and marrow of theoretical computer science.

Take-home message 1: the separation between how- and what-formalisms and models is not entirely clear-cut. Some how-formalisms can climb to levels of cognitively interpretable abstraction that they could also be considered what-formalisms.

Formalism interrelations. Both how- and what-models in DC are noted down using tools from discrete mathematics, being based on finite alphabets of symbols. How-models describe computing processes in terms of step-wise, rule-based updates of compound symbol configurations. There is a well understood hierarchy of how-formalisms, defined by different levels of expressiveness. A formalism A is at least as expressive as a formalism B if every input–output task that can be solved with models formalized in B can also be solved with a model formalized in A. This can be equivalently stated in a 'syntactic' way, as follows. Consider a model $\mathcal{B}$ formalized in B (think of a computer program $\mathcal{B}$ written in a programming language B). Then there exists a model $\mathcal{A}$ formalized in A and an encoding function ${\tau }_{\mathcal{B}{< }\mathcal{A}}$ which translates any symbolic configuration b that can occur in a 'run' of $\mathcal{B}$ into an $\mathcal{A}$-configuration a (that is ${\tau }_{\mathcal{B}{< }\mathcal{A}}(b)=a$) such that, when b → b' is a configuration update step that can occur when running $\mathcal{B}$, there is a sequence of update steps in $\mathcal{A}$ of the form ${\tau }_{\mathcal{B}{< }\mathcal{A}}(b)\to {a}_{1}\to \cdots \to {a}_{n}\to {\tau }_{\mathcal{B}{< }\mathcal{A}}({b}^{\prime })$. In technical terminology: every run of $\mathcal{B}$ can be simulated by $\mathcal{A}$. This leads to a hierarchy of classes of formalisms, where within each class, all formalisms have the same expressivity (they can mutually simulate each other), and where formalisms in less expressive classes can be simulated by formalisms in more expressive classes but not vice versa. This hierarchy, often referred to as the Chomsky hierarchy, is explained in every computer science textbook and is a pillar of theoretical computer science. The most expressive class known today is the class of Turing-equivalent formalisms. It comprises all practically used programming languages and many abstract mathematical formalisms, including of course the formalism of Turing machines. According to the Church–Turing hypothesis, no more expressive kind of how-formalism exists.

While all Turing-equivalent how-formalisms are equally expressive, it is nonetheless useful to arrange them, within their class, in an abstraction hierarchy, with 'low-level' formalisms close to the fine-grained 0–1 switching of transistors in digital hardware (for instance assembler programming languages), and with 'high-level' formalisms (like declarative programming languages or Microsoft Excel) closer to the human programmer's cognitive representations of what it means to process information. When one writes a program in a high-level language and starts it from a high-level user interface, behind the scene it becomes level-wise compiled into lower-level ones until a version specified by the microchip manufacturer is reached, which can directly address the hardware α, crossing the modeling mirror shown in figure 3.

Trained computer scientists can easily create new, again equivalent how-formalisms tailored to their particular needs. This flexibility and transparency to move up and down in the abstraction hierarchy is unique in DC and is one reason for the current intellectual and practical dominance of DC over all other approaches to 'computing'.

Take-home message 2: DC how-formalisms can be systematically ordered by their expressiveness. A formalism A is more expressive than a formalism B when all B models can be simulated by A models. Within the class of most expressive formalisms—the Turing-equivalent ones—one can furthermore roughly order them according to how close they are to 'low' levels bordering to the physical 0–1-switching of digital circuits, or to 'high' levels that are more interpretable in terms of human cognitive operations.

As to what-formalisms (formal logics), we find a wealth of different logics (plural) in the DC domain. Besides the two logics which are standardly taught to students of computer science (Boolean and first-order logic), there is also second-order logic, trimmed-down fragments of first-order logic, and indeed infinitely many more. A core theme of contemporary theoretical computer science is to work out logical frameworks [Rabe 2008] to navigate in this richly populated landscape. A key ordering principle is logic translations, that is meta-formalisms which allow one to specify how one logic A can 'express' everything that another logic B can. This is only superficially similar to the expressiveness hierarchy we saw for Turing-equivalent how-formalisms. The expressiveness hierarchy for how-formalisms is defined on the basis of the syntax of symbolic configurations, while for logic translations a semantical account is needed of what the symbolic expressions that can be written down in a logic formalism mean. This renders the study of expressiveness relations between what-formalisms much more involved than it is for how-formalisms. Research in this area is far from being canonically completed.

Take-home message 3: what-formalisms in DC are formal logics, of which there are many. Like how-formalisms they can be ordered according to their expressiveness, but here 'expressiveness' is defined in terms of formal intrinsic semantics, not in terms of syntactically describable transformations of symbol configurations.

Formal time surfaces in distinctively different ways in how- versus what-formalisms. For how-formalisms the story is quickly told. The formal, discrete update rules acting on symbolic configurations become ultimately mirrored in the physical clock cycles of digital microchips. For what-formalisms it is more difficult to understand time. Explaining how time arises in what-formalisms is intimately connected to intrinsic semantics. What-formalisms cast and connect the segments a, b, c from figure 3 with the mathematical constructs of formal logic, often first-order logic. In logic-based what-formalisms, the model c of the world γ around the physical computing system α is usually characterized in terms of certain set-theoretic structures, called S -structures, where S stands for the symbol alphabet of the formalism. Working out this universal connection between logic and set theory early in the 20th century was a milestone for mathematics. Logical inference (that which happens, for instance, in Aristotle's syllogisms) became formalized through inclusion relations between classes of S-structures. This modern mathematical re-construction of logical inference reached its final form in the work of Tarski (1936). Neither S-structures themselves, nor inclusion relations between classes of them, incorporate a reflection of time. These set-theoretic world models can be intuitively seen as a collection of interrelated facts embodied in structured sets, a static picture, not a dynamical history. The 'computing' that is formalized in segment a and that physically happens in segment α is cast as a process of logical reasoning about the structures modeled in segment c through S-structures. In the 2370 year-old perspective of logic, computing and reasoning are very much the same thing. Logical reasoning proceeds by carrying out steps of logical inference, like in syllogistic arguments. The premises and the conclusion of each such an inference step are written down as symbolic logic expressions. The conclusion that comes out of executing one inference step become incorporated in the premises of the next step, leading to inference chains. Inference chains are stepwise transformations of symbolic configurations, a fact which establishes the connection to how-formalisms. A 'run' (or 'execution') of an algorithm can be understood as an inference chain which leads from an initial premise to a final conclusion. The initial premise is the input to the algorithm and the final conclusion is the output. These two symbolic configurations lie in the interface boundary b; they are the only items that are passed to and fro between the reasoning system a and the environment c that is being reasoned about. I return to the topic of time. Logical inference is not temporal. The relation between a premise and a conclusion is not that the former comes first in time and is temporally followed by the latter. Instead, the relation is semantical-implicational: if the former is true, then the latter is true too. Turing (1936) himself put this into plastic wording: it is always possible for the computer to break off from his work, to go away and forget all about it, and later to come back and go on with it.

By chaining, if the first input to an inference chain holds true in the set-theoretic world model c, then so does the ultimate output. This is the very same structure as of mathematical proofs in general, which likewise proceed from initial premises or axioms to the final claim in a series of argumentation steps. Hence, the parlance in theoretical computer science to call certain high-level algorithm formalisms inference engines or theorem provers. But, if inference steps are natively a-temporal, how then does time enter the picture? This is a natural question to ask, since after all human reasoning—the original inspiration for logic formalisms—evolves in real physical time. Any computational neuroscience that tries to understand human logical reasoning in terms of physical brain dynamics must provide an answer. But, in fact, this question is ignored in logic and computer science textbooks. Here is how I see it. In a dramatic abstraction, parts of reasoning in a physical brain can be regarded as a-temporal: namely, if it is assumed that a reasoning human can store symbolic configurations in un-alterable, one could say platonically immutable ways. An essential characteristic of symbols is that they just stay identically the same once 'written'. Symbols are what does not change; they are exempted from time. These two facts are two sides of the same coin: (i) that logic-based what-formalisms capture a-temporal logical inference relations, which become 'update' operations in how-formalisms, and (ii) that the native substrate of how- and what formalisms are symbol alphabets. When such how-formalisms are 'run' on physical computing systems, the physical hardware must necessarily provide for temporally unbounded, unaltering memory mechanisms where 'written' symbols defy the mutations of time. In physics terminology this means that digital hardware must incorporate subsystems that have timescales far longer than the use-time of the system.

This is also the right context to remark that by realizing logical theorem provers, digital computers can carry out anything that can be found in a mathematical proof. To the extent that some other, non-digital model of 'computing' can be mathematically formalized, it can be simulated by digital computers—except for the real-world temporal aspects of the simulatee. In this sense, the DC paradigm is and will remain the master of all others.

Take-home message 4: DC derives much of its superior powers from the very fact that semiconductor engineers have found ways to locally realize extremely large time constants, namely non-volatile memory devices wherein time virtually comes to standstill.

Hierarchical structuring of formal constructs. The formalisms used in DC for modeling 'computing' all admit to compose symbolic configurations into more compounded ones, which then can be used as building blocks in yet higher levels of compositionality. That human cognitive processing admits the creation of compositional entities is regarded as constitutional for human intelligence by proponents of classical AI and (Chomskian) linguistics.

Compositional hierarchies of formal constructs are present both in how- and what-formalisms. I discuss the former first. Virtually all programming languages (assembler languages possibly excepted) admit the definition of compound configurations (from 'lists' and 'arrays' to 'modules', 'objects', 'scripts') which bind together more elementary symbolic configurations into larger ones. Abstract models of 'computing' systems likewise all have provisions for defining compositional hierarchies, for instance by joining symbols into nested sequences on a Turing machine tape, by applying the lambda operator in lambda calculus, or by constructing parse trees in grammar-based formalisms. Compositional hierarchies of symbolic configurations in how-models correspond to an execution hierarchy of configuration update operations: 'executing' or 'evaluating' a higher-level, defined construct means to execute a sequence of lower-level update operations that happen inside the defined construct. The higher a compound formal construct in a compositional hierarchy, the larger the number of physical operations that are needed to realize the execution of the formal construct on a physical computing system. This multiplied physical effort leads to longer processing real time for higher-level construct execution—unless some parallelization scheme can delegate the required physical operations to a multiplicity of physical sites that operate simultaneously. Such time–space tradeoffs are an important topic in theoretical compute science. It is generally desirable, but not easy, to find formalisms and models of symbolic computing which lend themselves to high degrees of parallelization. In contrast to current models of symbolic computing, the human brain operates in an extremely parallel fashion. We see a face together with its nose, mouth and eyes. This is a lasting intellectual challenge for DC theorizing, and has motivated the title 'parallel distributed processing' for the bible book [Rumelhart and McClelland 1986] that marks the start of neural network research as we know it today.

A root mechanism in DC what-formalisms (formal logics) to capture the composition of cognitive entities is to construct nested functional expressions, as for instance Ta keoffWeig ht(AirbusA320 , Fu elfill(FlightLH237) , Nu m berPassengers(Fligh tLH237 , Ja nuary24_202 0)). In formal semantic theories of logic, such functional expressions refer to elements of the structured sets that make up S-structures. Such functional terms yield the root building blocks for syntactic expression-building in most logic formalisms. In a cognitive interpretation, such terms represent object concepts. Arbitrarily complex and varied syntactic composites can be built on top of them with other syntactic elements, like logical connectives AN D, N OT, relation symbols, variables or extensive assertives like FOR ALL ... , as in this first-order logic example: F OR ALL x : I F (x is Fruit AN D Co lor(x) = Ye llow AN D Sh ape(x) = Cu rved ) T HE N x is Banana. All of these constructions are cognitively interpretable—they can even be (mis)taken for the essence of cognitive processing.

Take-home message 5: compositional formal structures are constitutive for DC models of computation. This makes DC how- and what-formalisms immediately suited to capture the (widely claimed but not uncontroversial) compositionality of human cognitive entities.

I now turn to probabilistic models of computation, marked with P in figure 3. As stated earlier, in my view an important criterion to call a physical system 'computing' is that its operations admit some kind of cognitive interpretation. For DC, this cognitive aspect is rational logical inference. In probabilistic 'computing' models the cognitive core aspect is the ability of animals and humans to make probabilistic inferences. These are formalized in probability formalisms through conditional probabilities of the kind, 'if the sky is cloudy, then the probability of rain is 0.3'. Stating and evaluating such conditional probabilities requires to have mental representations of probability distributions. I consider them the primary 'mental' or 'cognitive' objects in probabilistic reasoning and formalisms, analog to symbolic configurations in DC formalisms. Specifically, but not exclusively, the need for evaluating conditional probabilities arises when agents assess the chances that their actions will lead to the desired outcome. This view of biological cognition is one of the leading paradigms in cognitive science today and is referred to as predictive brain [Clark 2013], free energy model of cognition [Friston et al 2010], or the Bayesian brain [Tenenbaum et al 2006] hypothesis. In mathematics and machine learning we find a diversity of worked-out computational frameworks which formalize selected aspects of the predictive brain perspective. They include models of computing with probabilistic logic [von Neumann 1956], logic-oriented accounts of Bayesian statistics [Jaynes 2003], observable operator models and predictive state representations of probability distributions [Jaeger 2000, Littman et al 2001], Boltzmann machines [Ackley et al 1985, Hinton and Salakuthdinov 2006], reinforcement learning approaches to modeling intelligent agents [Basye et al 1995], or the neural engineering framework [Eliasmith et al 2012]. Here I restrict myself to formalisms and models which use stochastic sampling to represent and update distributions. In methods for sampling-based processing of probability distributions (SPPD for short), a probability distribution is not mathematically represented by a closed formula. Instead, it is approximately represented by a sample, that is a set of example points drawn from the distribution. Complex, high-dimensional distributions cannot in general be represented by analytical formulae. SPPD methods have become a major enabler for the simulation-based study of complex systems in physics [Metropolis et al 1953], for solving optimization problems, and in some branches of machine learning. They are often referred to as Monte Carlo or Monte Carlo Markov Chain [Neal 1993] or as particle swarm methods [Dellaert et al 1999]. The requisite random sampling processes still are mostly simulated on digital computers. SPPD techniques have however became also realized in non-digital physical computing systems, namely in DNA computing [van Noort et al 2002] for solving optimization and search problems, and more recently and with a wider application range in analog spiking neuromorphic hardware [Indiveri et al 2011, Haessig et al 2018, Moradi et al 2018, Neckar et al 2019, He et al 2019b]. According to the neural sampling [Buesing et al 2011, Pecevski et al 2011] view forwarded in theoretical neuroscience, temporal or spatial collectives of neuronal spike events can be interpreted (or used by the brain) as samples. Due to this inviting analogy to biological brains and the low-power characteristics of analog spiking neurochips, research in such hardware and corresponding 'algorithms' is expanding. But the main reason why I want to focus on sampling-based versions of probabilistic models is that they open views on 'computing' that differ from the DC views in interesting ways.

In order to preclude a false impression, I emphasize that there are many other ways to represent distributions besides via sampling. For instance, the procedural mechanics of certain (non-spiking, non-sampling) ANN models can be interpreted to compute parameters of distributions, or probability distributions can be approximately characterized and algorithmically processed through variational calculus. Both methods are widely used in current machine learning. Furthermore, firing sequences of neural spikes have been interpreted to encode 'information' in other ways than as delivering stochastic samples. Precise neural firing time patterns can be considered as carrying information in a variety of ways [Thorpe et al 2001, Izhikevich 2006, Deneve 2008].

Brushing over many specific differences between SPPD models, I will now give an account of their common traits and place them in the schematic of figure 3.

Formalism interrelations. I consider how-formalisms first. There are two kinds of how-formalisms and how-models in SPPD, depending on whether the targeted physical computing systems α are digital computers or not. In the first case, how-models are symbolic algorithms which, when executed, generate sequences of pseudo-random data points which accumulate over processing time into samples. Such algorithms are called sampling algorithms or just samplers. After down-compilation into low-level assembler programs these sampling algorithms can be passed to physical digital computers, crossing the modeling mirror. When the targeted hardware is non-digital, how-models describe the physical mechanics of the stochastic physical processes that are viewed as sampling processes. For biological brains, theoretical neuroscience offers a range of such models, from detailed physiological models of how spikes are created in neurons to more abstract castings like integrate-and-fire models of neurons or just Poisson spike trains. For analog spiking neuromorphic microchips, the sample-generating, physical stochastic processes in such microchips is modeled with electronic engineering formalisms on the device and circuit level [Indiveri et al 2011]. I would think that there also exist biochemical stochastic formalisms for modeling the reaction dynamics in DNA computing microreactors, but I am unfamiliar with that field.

The situation for all the sampling algorithms that have been proposed is markedly different from the situation in DC. In the DC domain, how-formalisms and models can all be precisely related to each other by mutual simulations. In SPPD I am not aware of a way how a stochastic sampling algorithm A could 'simulate' another such algorithm B. The representation of a distribution by a sample is inherently imprecise. The more data point examples are added to a sample, the more precisely it captures the distribution. Different sampling algorithms could possibly become related to each other by comparing their statistical efficiency (how many sample points are needed for a given accuracy level of representing a distribution). While this is an important optimization objective in practical SPPD designs [Neal 1993], I am not aware of a meta-theory or just attempts to systematically set different SPPD algorithms in relation to each other by comparing their statistical efficiency.

Turning to what-formalisms, these are the formalisms whose prime mathematical objects are probability distributions, considered as abstract objects independent of their concrete representation through samples or other formats. What-models are written down in the notation which students learn in probability or statistics courses. They gain their expressive powers mostly from stating and combining conditional probability relations. The analogy to the picture I drew for DC is obvious. The if-then format of conditional probability statements matches the if-then format of logical inference rules. In fact, according to one influential view of Bayesian statistics [Jaynes 2003], probabilistic what-formalisms can be considered and worked out along the guidelines of formal logic. There is however a noteworthy difference between DC and SPPD what-formalisms. In the DC domain, different logics can be related to each other through logic translations, yielding a (yet only partially explored) ordering along an expressiveness scale. Nothing like this can be found in probabilistic what-formalisms. There are no more or less 'expressive' formalisms of probability theory. It makes some sense to claim that there exists only a single probability what-formalism, namely the one that is taught in probability theory textbooks.

Take-home message 6: in both DC and SPPD domains, formal models for computing systems came as how- or what-formalisms. Unlike in DC, how-formalisms in SPPD are not related to each other, and cannot be transformed into each other in an obvious way, and one might also say that there exists only a single probabilistic what-formalism.

Intrinsic semantics. SPPD what-formalisms are expressed using the notation of mathematical probability theory. There are two major epistemological schools of thinking about 'probability', the frequentist (or objectivist) and the subjectivist (Bayesian) one. Their mathematical theorems mostly coincide in their surface format but are interpreted differently. In frequentist interpretations 'probability' means a physical property of real-world systems, namely a system's propensity to deliver varying measurement outcomes under repeated measurements, while in Bayesian interpretations, 'probability' means subjective degrees of belief. The frequentist account of probability directly arises from formal models of the physical environment (segment c in figure 3). These formal models of physical reality are a probability spaces, three-component mathematical structures standardly written as $({\Omega},\mathcal{F},P)$, where Ω (called 'Universe' or 'population' among other namings) is a set of elementary events which can be intuitively understood as locations in spacetime where measurements could possibly be made; $\mathcal{F}$ is a certain set-theoretic structuring (a sigma-field) imposed on Ω; and P assigns objective probabilities to certain elements (called events) of this structuring. The formal connection between such world models $({\Omega},\mathcal{F},P)$ and the descriptive what-formalisms that capture the probabilistic cognizing about the world (segment a) is established by random variables which create segment b. I remark that the term 'random variable' is entirely misleading. Mathematically, random variables are functions, not variables; and they are not random, but deterministic. To make this clearer: a statement like 'Peter is male' would be formalized in probability theory as Ge nder(Peter) = Ma le , where Ge nder is the random variable, a function which deterministically returns the gender value from every concrete person (formally: from every element ω ∈ Ω). The randomness of random variables results not from that they somehow return random values, but that random arguments are given to them, following the probabilities prescribed by the item P in the world model $({\Omega},\mathcal{F},P)$. The mathematics behind this is involved and I allow myself at this point to recommend my probability lecture notes [Jaeger 2019c] where I attempt to give an intuitive, yet rigorous introduction to the basic concepts of probabilistic and statistical modeling for readers who are not mathematicians.

Summing up the frequentist account of probability: the outside world c is cast as a structured set Ω of observation opportunities; observation apparatuses and procedures are abstracted into random variables; measured values (from ticked gender boxes in questionnaires to high-volume sensor data streams, filling segment b) become the data points of samples which are one way of formalizing probability distributions (segment a), which in turn can be seen as the key formal correlates of concepts in probabilistic accounts of cognition.

There are similarities and dissimilarities between the formalizations of intrinsic semantics in DC versus SPPD. The what-formalisms in both areas cast the physical world as highly structured sets (S-structures and sigma-fields) which represent, one might say, the preshaped substance of the modeled piece of the world. Both DC and SPPD what-formalisms are mathematically built around their respective intrinsic semantics. However, the meaning of 'meaning', that is, how some symbol or formula (in segment a) relates to something in the modeled world c, very much differs between DC and SPPD. Frequentist probability theory includes formal correspondents of measurement or observation procedures and their values as first-class citizens, namely random variables and the values that they can take. Segment b is central in probability theory, containing what is called sample spaces. Probability theory universally separates the measurable quality (like 'gender', 'speed') from the quantitative values that this measurement categories can take, like 'male' or '100 km h⁻¹'. Qualities become cast as random variables, quantities as the possible values of these variables. In contrast, the primary view adopted by logic formalisms identifies quality with quantity. That Peter is male would be formalized as Ma le(Peter). The symbol Ma le is a so-called predicate symbol, and predications (stating that certain objects have certain properties) are elementary operations in first-order logic. It is however also possible to express Ge nder(Peter) = Ma le in logic. To do this one has to introduce Ge nder as a function symbol. Still there is an important difference. In the logical understanding of Ge nder(Peter) = Ma le , all three items (the argument Pe ter, the function Ge nder and the value Ma le) are contained in the S-structure, that is they are both located inside the world model in c. In a probabilistic interpretation of the same English statement, Pe t er is an element of the Universe Ω, sitting in segment c; Ma le is an observation value which is mathematically placed outside of the world model $({\Omega},\mathcal{F},P)$ (I created the segment b to host it), and Ge nder links the two. This difference between logic and probability modeling grows from deep historical roots.

Take-home message 7: probability theory gives an account of how we observe the world; logic is about how we reason about an already observed world.

There is one more similarity between logic and probability modeling worth pointing out. Both SPPD and logic formalisms introduce separate symbols for every observable quality of the elements of the world-substance sets in segment c: random variables and function symbols, respectively (like Ge nder). An implicit assumption behind this symbolic naming of qualities is that the named quality is well-defined and remains the same throughout the time when the formalism unfolds in formal time (logic derivations or formalizing sampling in a), and/or when this computational process becomes physically instantiated (segment α), and/or as long as the real time evolves for the 'meant' interpretation in the real world environment γ or its model c. This is a highly nontrivial assumption and I will argue in section 3 that it bars the way to a generalized theory of computing.

Formal time is knitted into SPPD formalisms and models in intricate ways, often involving further theoretical elements reflecting space and temporal hierarchies. In physical computing systems (segment α), real time is consumed on a fast timescale to generate individual sample points, and on slower timescales to accumulate sample points into samples. In the view of neural sampling theories, where neural spikes (or possibly groupings of spikes) correspond to sample points, the fast timescale is the one of single spikes and the slow timescale the one of accumulating the effects of single spikes by mechanisms of temporal integration, for instance via building up neuron potentials or modulating synaptic efficiencies. Formal models of spike event generation (in segment a) can be expressed on different levels of granularity, ranging from modeling the electrophysiology of spike generation with differential equations to abstract representations of spike trains as Poisson processes. The accumulation of spike events into samples requires extensions of these formalisms to include some kind of temporal integration.—When running sampling-based algorithms on digital computers, the fast timescale reflects the runtime of program subroutines to generate sample points; these subroutines contain sub-subroutines to generate pseudo-random numbers which are typically encapsulated as primitives (the rand function) in programming languages. Generated sample points are formally accumulated in lists or arrays in program loops on the slow timescale of sample build-up.—This picture becomes more complex when sample points are generated in parallel strands, leading, among others, to neural population representations of samples in spiking neural network models, or to Markov random field models in non-neural algorithms (though the latter are mostly used for purposes other than sampling). But no degree of parallelization can entirely cancel the necessity for generating and accumulating sample points on respective fast and slower timescales.

Because the creation of samples needs time (formal or real, segment a or α), the cognitive core items in SPPD, namely distributions, are not defined for single moments of time or created instantaneously. A sample-based representation (segment a) or realization (in α) of a distribution becomes the more precisely defined the more sampling time is devoted to its generation. Sample-based representations of distributions are 'smeared' over time. If one adopts neural sampling views in cognitive neuroscience, this has nontrivial consequences for the notion of mental states which I will not further pursue here. The fact that samples develop over time leads to a spectrum of ways of how SPPD models of computation can be used for practical exploits, with different schemes for administering input. On one end of the spectrum we find scenarios where the computing system is 'clamped' to an unchanging input for the entire duration of the computation. Formally this means that some random variables of the model are frozen to fixed values. The sampling process is then run (in formal abstraction a or physical realization α) for an extended period of time, allowing the sampling to grow the sample large enough to decode from it the result with the desired degree of accuracy (I skip the complications of initial transients and ensuring ergodicity [Neal 1993]). Typical examples are classification tasks (for instance, input is an image, desired result is a probability distribution over possible classifications [Hinton et al 2006]) or optimization tasks (the archetype example: input is a roadmap, desired result is a round trip itinerary through all cities which with high probability is the shortest one [Kirkpatrick et al 1983]). On the other end of the spectrum, the input is itself temporal, for instance a sensor data stream, and the desired output is likewise temporal, for instance generated motor commands in a robot or a brain, or an estimation of an agent's motion relative to its visually perceived environment [Haessig et al 2018], or speech-to-text recognition tasks. This is the generic situation in adaptive online signal processing and control [Farhang-Boroujeny 1998] and in the study of situated agents [Steels and Brooks 1993], which comprise humans, animals, robots, software avatars or computer game characters. Solving such tasks, where input patterns or output patterns are themselves temporally evolving, requires sampling mechanisms where the next generated sample point depends on the history of previously generated ones. Important classes of formalisms of this kind include spiking recurrent neural networks (RNNs) [He et al 2019b], temporal restricted Boltzmann machines [Sutskever et al 2009] and sampling-based instantiations of dynamical Bayesian networks [Murphy 2002].—Intermediates between these two extreme ends of the spectrum (single fixed input versus nonstationary input streams) also occur, for instance when the input is a sequence of fixed patterns which are clamped each for some time before it is replaced by the next one.

Take-home message 8: the phenomenology of formal time in SPPD models is much richer than in DC. In DC, time reduces to discrete jumps from one well-defined, symbolic configuration the next, and these configurations are by themselves atemporal. In SPPD models, the core cognitively interpretable constructs, namely distributions, are themselves temporally defined through the sampling process. As a consequence, formal how-models must account for at least two timescales, and the formal interpretation of generated sample point sequences as distributions must account for nontrivial conditions like duration-precision tradeoffs or temporally overlapping realizations of different distributions. All of this is alien to the fundamental DC conception of executing algorithms.

Hierarchical structuring of formal constructs. Human cognitive processing admits—or in some views [Newell and Simon 1976], is even constituted by—the compounding, or 'chunking' [Newell 1990], of representational or procedural mental states or mechanisms into larger compositional items which then can again be composed again into even more comprehensive items, giving rise to compositional hierarchies of representations, mechanisms or processes. In DC this is accounted for by hierarchically organized symbolic configurations (in how-formalisms) and nested functional expressions in logic what-formalism. I can see three main ways how probability distributions can become hierarchically organized.

First, some how-formalisms explicitly arrange their random variables in layers, with 'low' layers modeling the sensor data periphery and 'high' layers modeling the cognitive interpretations of sensor input. This is the case for many instantiations of Boltzmann machines [Ackley et al 1985, Hinton and Salakuthdinov 2006]; furthermore, the conditional dependency graph of random variables in Bayesian networks and graphical models [Wainwright and Jordan 2003] can be hierarchically organized in reflection of a 'cognitive' stratification. These are generic probabilistic information processing formalisms. Task-specific layered spiking neural architectures, where deep feedforward neural networks are being re-coded into spiking neural substrates, have recently been receiving much interest, for instance in visual object recognition tasks [Yousefzadeh et al 2018]. Furthermore, I am aware of two complex information processing architectures which model complex human cognitive dynamics on the basis of spiking neural network substrates, namely Shastri's SHRUTI [Shastri 1999] series of connectionist models human reasoning and language processing and Eliasmith's almost-entire-human-brain models [Eliasmith et al 2012].

In these hierarchically or modularly structured systems, all random variables in all levels or modules are, in principle, sampled from with the same frequency. This is in agreement with the spiking dynamics in biological brains, which likewise has roughly the same timescale everywhere—neurons in the visual cortex do not fire orders of magnitude faster than neurons in the prefrontal cortex, although a hierarchy of processing levels lies between them. The 'cognitive' constructs, namely distributions determined through samples, are formally the same throughout levels or modules. Higher-level distributions are not made from, or composed of, lower-level ones. This is different from the compositional hierarchies in DC models, where higher-level symbolic configurations are made by binding lower-level ones into compounds. In the SPPD models pinpointed above, the assignment of being a 'higher' or 'lower' distribution is only in the eye of the human inventor of the model.

Second, hierarchies of distributions canonically arise in probabilistic models as conceived in Bayesian probability [Jaynes 2003, Jaeger 2019c], where distributions become themselves distributed in hyperdistributions. In the original motivation of Bayesian probability, these higher-level hyperdistributions reflect the subjective prior beliefs of an intelligent agent about which lower-level distributions are more or less plausible. Applying this principle to modeling probabilistic cognitive systems one obtains formalisms that are hierarchical in a substantial sense. The relationship between a distribution and a hyperdistribution is asymmetric. A hyperdistribution could be said to control, modulate or bias its lower-level children distributions. This gives rise to cognitive processing models whose dynamics unfolds in an interplay of bottom-up pathways (from sensor input to their cognitive interpretations) and top-down pathways (cognitive expectations modulating the perceptive filtering below). Prominent representatives of such bidirectional cognitive processing systems are Grossberg's adaptive resonance theory models [Grossberg 2013], Friston's free-energy models of processing hierarchies in brains [Friston 2005] and Tenenbaum's models of human cognition [Tenenbaum et al 2006]. However, although Friston's writings contain passing remarks on spiking neural dynamics, neither his nor other's models of Bayesian cognitive architectures appear to have been formulated or simulated (let alone physically realized) on the basis of sampling processes. Instead, when these authors (as most other neuro-cognitive modelers) want to capture temporal processing phenomena, they use formalisms that abstract from sampling processes by time-averaged neuronal firing rates governed by differential equations (Grossberg, Friston). Or, when their focus is on the a-temporal structure of hierarchies of (static) mental concepts, they adopt the formalism of Bayesian probability theory. The Bayesian distribution–hyperdistribution hierarchization should be analyzable in terms of sampling—meta-sampling hierarchies, at least if it is cognitively-biologically adequate and if brains actually use spikes for sampling. This would be a potentially rewarding mathematical project. Most likely this has already been done, but I am not aware of it.

Third, more elementary (lower-dimensional) distributions can always and precisely be mathematically combined into compound (higher-dimensional) distributions by product operations. Conversely, high-dimensional distributions can sometimes be approximately factorized into products of low-dimensional ones. Such factorizations are a major enabler to construct and evaluate high-dimensional probabilistic models of real-world systems in machine learning, computer graphics and physics [Huang and Darwiche 1994]. Factorization algorithms for distributions are being widely explored. Unfortunately, many real-world distributions cannot be satisfactorily factorized. A generalization of products of distributions is provided by tensor product representations, a standard operation in quantum mechanics [Coecke 2012] which also has been proposed as a paradigm for achieving analogs of symbolic compositionality in distributed neural activation patterns [Smolensky 1990]. However, the computational efficiency gains of factorizations are lost when the component distributions become entangled in tensor products. Like with Bayesian hierarchization, I am not aware of sampling-based accounts of product and tensor product operations, but again, this should be possible if such product operations are cognitively adequate and if the brain indeed exploits sampling for representing distributions.

Take-home message 9: compositionality of cognitive representations, mechanisms and processes—constitutive for symbolic computing—has currently no clear analog in sampling-based models of computing. When sampling is used as the core process for enacting 'computing' (as in Boltzmann machines or sampling-based evaluations of other graphical models), hierarchically organized interrelations between distributions exist only in the eye of the system designer but are not formally modeled on the level of interrelations between samples. To the extent that neural sampling is a valid view of information processing in biological brains, this means that either compositionality is not an inherent aspect of 'computing', or it means that mathematicians still have to work out—if they have not already—how hierarchies of distributions (distribution–hyperdistribution relations or factorizations of distributions) can be formally expressed through samples.

I now turn to formalizations of 'computing' that are rooted in concepts and formalisms of dynamical systems theory, marked D in figure 3. Since almost a century, biological systems—neural and others—have been studied in a line of investigations which is referred to as general systems theory [von Bertalanffy 1968] or cybernetics [Wiener 1948]. This tradition co-evolved with the engineering science of signal processing and control [Wunsch 1985]. A landmark in interpreting the human brain as a dynamical (self-)control system is Ashby's classic Design for a Brain [Ashby 1952]. In another co-evolving strand, neural dynamics became modeled in a theoretical physics spirit, by isolating and abstracting dynamical neural phenomena into systems of differential equations, exemplified in the Hodgkin–Huxley model of a neuron [Hodgkin and Huxley 1952]. Later, when the mathematical theory of qualitative behavior of dynamical systems [Abraham and Shaw 1992] had matured and in particular after chaos and self-organization in dynamical systems became broadly studied, dynamical systems modeling rose to a commonly accepted perspective in cognitive psychology and cognitive science [Smith and Thelen 1993, van Gelder and Port 1995]. Today the separations between these historical traditions have almost dissolved. Mathematical tools from dynamical systems theory are ubiquitously employed in modeling neural and cognitive phenomena on all scales and abstraction levels, in a diversity that defies a survey. Even when seen only from within mathematics, dynamical systems theory is a highly diversified field. Its formalisms range from finite-state switching systems to field equations; time can be discrete or continuous; the state spaces on which dynamics are described can be finite or infinite sets, vector spaces, manifolds, function spaces, graphs or abstract topological spaces, etc. Furthermore, this mathematical field has overlaps with statistical physics, information theory, stochastic processes, signal processing and control, game theory, quantum mechanics and many more.

Here I will only consider models expressed with ODEs which have the familiar look $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{u}(t),\mathbf{a})$, where $\mathbf{x}\in {\mathbb{R}}^{n}$ is an n-dimensional real-valued state vector, $t\in \mathbb{R}$ captures continuous time, the dot notation $\dot {\mathbf{x}}$ is a shorthand for the first temporal derivative dx/dt and the optional terms u(t) and a denote input signals and control parameters. The function f defines a vector field on the state space ${\mathbb{R}}^{n}$ which indicates the local direction and velocity of state motion. Higher-order ODEs which contain higher-order derivatives like dⁿ x/dtⁿ can be transformed to first-order ODEs by introducing auxiliary variables. Such ODE models are by far the most widely used and most deeply studied kind of dynamical systems models; they are what mathematics students find in introductory textbooks like Strogatz (1994). The mathematical theory of qualitative behavior in dynamical systems—attractors, bifurcations, chaos, modes, 'self-organization', etc—has been first and foremostly been developed for $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{a})$ system models. ODEs is the most broadly used kind of formalism in the modeling of continuous-time dynamics in biological and ANNs and cognitive processing; and it is the formalism used by electrical engineers when they design analog neuromorphic circuits [Indiveri et al 2011].

Of course partial differential equations (PDEs) are important too. They are needed for modeling spatiotemporal dynamics on continuously extended substrates, for instance in neural fields [Lins and Schöner 2014], in non-Boolean spin-wave devices [Csaba et al 2017], in analog computers that exploit the spatial nonlinear dynamics in macroscopic sheets of materials [Mills 2008], or reaction–diffusion computers [Adamatzky et al 2005]. The spatial organization of physical computing systems is obviously important to design and analyze them. Yet I have deliberately left out this aspect from this study (besides other important aspects, see section 2.2) in order to not make this article even longer than it already is. A halfway appropriate discussion of spatial organization would have to consider not only PDEs, which are the natural tool to characterize dynamical phenomena in homogeneous material substrates, but also many other mathematical tools (for instance cellular automata, cellular neural networks, finite-element methods, Petri nets, dynamics on networks, dynamics on topological spaces) most of which are better suited than PDEs when it comes to dynamics on inhomogeneous substrates or wire-connected discrete devices. Many of these modeling techniques however admit approximations through ODEs. For instance, PDE models can be approximated by ODEs with the tools of finite-element methods. Since furthermore the theory of ODEs is the most classical and the deepest worked-out one among all of these others, and since ODEs is the standard formalism in most work in NC, I opted for them on this occasion.

Formalism interrelations. When discussing DC and SPPD, I found it useful to distinguish how- from what-formalisms. I will follow this strategy again and discuss how- and what-formalisms, starting with the former.

In ODE modeling we find only a single how-formalism. It is the canonical textbook ODE formalism. Using its notation, a researcher or engineer can write down how-models $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{u}(t),\mathbf{a})$ (in segment a) which describe physical computing systems (in α). These models directly capture the real-time, metric dynamics of continuous variables in computing systems—voltages and currents in analog microchips and neuronal circuits, 'activations' of neural assemblies or concepts in models of neural cognitive processes. While there are inclusion hierarchies of classes of such ODEs—foremostly, ordering them by the highest order of derivatives, speaking of first-order, second-order etc ODEs—the ODE formalism per se is always the same. This is different from the situation in DC where different formalisms (like machine models, programming languages) are related to each other by simulation (encoding, compilation) relationships. Such inter-formalism translations play no role in ODE modeling.

This is however true only if we restrict the discussion to ODE modeling. If we would include other dynamical systems formalisms into our discussion, numerous mutual translation or simulation relations can be found. While in the DC domain such simulations are exact, in the dynamical systems world they typically entail approximations. In particular, PDE models can be approximated by ODEs through finite-element modeling, and continuous-time, continuous-space formalisms (ODEs, PDEs, field equations) can be arbitrarily well approximated by discrete-time, discrete-space formalisms (like numerical ODE solvers or cellular automata). Unlike in DC, where such formalism translations are student homework exercises, finding such continuous-to-discrete encodings in the dynamics domain is not trivial and analyzing the approximation quality can be demanding.

What-formalisms and models in the ODE context are more complex and subtle. I will have to spend some paragraphs to explain how I see them.

What-models capture qualitative phenomena in dynamical systems. Such phenomena appear when state trajectories ${(\mathbf{x}(t))}_{t\in \mathbb{R}}$ fold into the state space ${\mathbb{R}}^{n}$, giving rise to phase portraits which are populated by a zoo of geometrically defined objects like point attractors or repellors or saddle-nodes, periodic orbits, chaotic attractors, stable and unstable manifolds, basins of attraction etc. The fascinating world of qualitative phenomena is most beautifully revealed in the copious picture-book of Ralph Abraham (pioneer of dynamical systems theory) and Christopher Shaw (graphics artist) which I enthusiastically recommend as first reading for novices in dynamical systems [Abraham and Shaw 1992]. Qualitative phenomena are preserved when the state space is smoothly distorted by 'rubber-sheet' transformations: if one draws a closed loop on the surface on a slack balloon and then stretches or inflates it, the drawn figure will remain a closed loop.

When (neural) dynamical systems are used to model cognitive processes, it is these geometrical objects which are stipulated as correlates of cognitive phenomena. The most widely explored correspondence of this kind is to consider cognitive concepts as represented by attractors. This is a richly worked-out theme with a long history. It can be traced back at least to the notion of cell assemblies formulated by Hebb (1949), reached a first culmination in the formal analysis of associative memories [Palm 1980, Hopfield 1982, Amit et al 1985], and has since then diversified into a range of increasingly complex models of interacting (partial) neural attractors and associated 'attractor-like' phenomena [Yao and Freeman 1990, Tsuda 2001, Rabinovich et al 2008, Sussillo and Barak 2013, Schöner 2019]. But other geometrical objects have also been selected as representatives of concepts, for instance solitons and waves [Lins and Schöner 2014] or algebraically defined regions in state space [Tino et al 1998, Jaeger 2017], and many other cognitive entities besides concepts have been modeled by qualitative phenomena in dynamical systems [van Gelder and Port 1995, Besold et al 2017]. Because I require interpretability in cognitive terms from what-models, the domain of qualitative-geometrical phenomena is the natural candidate to look for what-formalisms, models and theories in ODE systems.

Unfortunately there is no canonical mathematical formalism or theory to comprehensively describe the world of geometric wonders that arise in general ODE systems. Only for special classes of dynamical systems, and mostly confined to low-dimensional ones, elementary qualitative phenomena and their geometrical relations to each other have been accessible to theoretical analyses, in particular in the context of Morse–Smale theory [Shub 2007]. Otherwise, mathematicians invariably use plain English and computer graphics besides formulas to describe how attractors and other geometrical objects become related to each other. New kinds of qualitative phenomena are continually being identified. Most insights into the geometry of dynamics that are today available have been discovered, defined and studied for autonomous dynamical systems only. These are systems whose equations $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{a})$ have no input term. The study of qualitative behavior in input-driven systems, which have an additional input term u(t) in their ODEs, is in its infancy [Kloeden and Rasmussen 2011, Manjunath and Jaeger 2014]. Current mathematical theory offers only painfully limited ways of inferring which qualitative phenomena will emerge from a given how-model $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{a})$ or $\dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{u}(t),\mathbf{a})$. This has to be worked out on a case-by-case basis. Analytical understanding is often impossible to achieve, and numerical, intuition-guided simulations on low-dimensional subspace projections afford the only window of insight.

Thus I cannot point to existing worked-out what-formalisms for ODE modeling. It might be well the case that a comprehensive what-formalism, and what-theory expressed on its basis, is principally impossible for ODE systems. Just like natural scientists will forever continue to discover new qualitative phenomena in nature, and just like biological evolution incessantly finds and exploits new qualitative phenomena on a 'keep anything that works' basis, mathematicians may be in for a principally open-ended discovery journey. This open-endedness may be intrinsic in an ill-definedness of what qualitative means. Just like biological evolution discovers ever more qualitatively new 'tricks' to enhance the powers of brains, where every newly found trick may fall out of the reach of a previously sufficient theory, GC theorists may find themselves always lagging behind inventive GC system engineers who find ever more ways to harness physical-dynamical phenomena for computing.

This is disconcerting. Physicists rely heavily on ODEs and other kinds of differential equations to model physical systems, and so do electrical engineers when they design circuits for analog microchips. ODE formalisms thus seem an inviting platform for developing a theory for GC which is naturally able to connect to the physics of computing systems. But the difficulties and possible open-endedness of formulating qualitative what-theories are a serious obstacle. I see four options to deal with this roadblock:

• (a)  
  Accept that a closed, complete what-theory is not possible and embark on GC theory building in the spirit of an open-ended discovery expedition, fencing the bestiary of qualitative phenomena with a forever expanding zoo of what-theories.
• (b)  
  Build a GC theory around an a priori restricted set of qualitative phenomena. This is what DC does in relying, deep down, only on the phenomenon of bistability which gives the 0–1 bits that symbolic computing is made of. This is also what we see in most neural network models in computational neuroscience and machine learning, when for instance a specific class of attractor-related phenomena is chosen to discuss aspects of cognitive processes. The obvious drawback is a limitation of perspective which will miss the majority of potentially relevant qualitative phenomena as well as the majority of aspects of cognitive processing.
• (c)  
  Not adopt a dynamical systems oriented perspective. This can be utterly successful as witnessed by DC, but I am afraid it bars the way to exploiting most of what physics can offer for 'computing'.
• (d)  
  Find a new foundational mathematical formalism for dynamical systems which makes qualities, not quantities, the objects of dynamical change. This is what I find the most promising route, and I will put forth initial ideas in the conclusion section.

In summary, the time is not ripe yet for a systematic discussion of what-formalisms, models and theories for ODE models or dynamical systems models in general—but it can be seen that here is a challenge that deserves to be addressed.

Take-home message 10: in dynamical systems oriented modeling of computing systems (restricted here to ODE modeling), the single how-formalism is the textbook ODE formalism. In computing systems modeled by ODEs, a plethora of geometrical, qualitative phenomena may arise. They are candidate formal objects to be interpreted in what-models as correlates of 'cognitive' phenomena. A few of them, in particular attractors, are already widely being perceived in the cognitive and neurosciences. A systematic organization of such studies in a compendium of interrelated what-theories remains a task for the future.

Intrinsic semantics. In L and P modeling there are canonical ways how the environment (γ in figure 3) is mathematically modeled (in segment c), namely by the set-theoretic constructs of S-structures and probability spaces. In dynamical systems oriented modeling no canonical view on how to model the environment exists. The question is rarely asked and I dare say under-researched. There are historical reasons for this semantic almost-blindness. Starting with Newton, dynamical systems modeling has for a long time been the homeground of physics. Experimental physicists try hard to isolate their system of interest from the environment. This made them use a kind of ODE which are, in mathematical terminology, autonomous, that is, their equations $\dot {\mathbf{x}}=f(\mathbf{x},\mathbf{a})$ have no input term. The historical development of dynamical systems mathematics was by and large confined to autonomous systems. Starting, say, in the 1960s, there was explosive mathematical progress in perceiving, analyzing and (importantly) visualizing [Peitgen 1986] qualitative phenomena like attractors or chaos. Other disciplines besides physics and even the general public became fascinated by dynamical systems and began to interpret their respective objects of study as qualitative dynamical phenomena. In the cognitive sciences this became an established perspective around the year 1990 [Schöner et al 1986, Smith and Thelen 1993, Port and van Gelder 1995, Jaeger 1996]. However, the available mathematical tools and metaphors were largely confined to autonomous input-free systems. This barred the way to develop dedicatedly semantic accounts of how the modeled systems interact with their environment. In neuro- or cognitive modeling, qualitative phenomena inside the modeled neural or cognitive system were not related to its outside environment, but were mapped to system-internal cognitive constructs and processes. An important theme was (and is) how symbols and 'concepts' can be interpreted by qualitative dynamical phenomena—the neuro-symbolic integration problem [Besold et al 2017].

In my opinion, in order to work out a genuine intrinsic semantics for dynamical systems models of 'computing' systems, one would have to move from autonomous system models like $\dot {\mathbf{x}}=f(\mathbf{x},\mathbf{a})$ to input-driven ones like $\dot {\mathbf{x}}=f(\mathbf{x},\mathbf{u},\mathbf{a})$. But, as I remarked earlier, mathematical theory development for qualitative phenomena in such non-autonomous systems is far less developed than for autonomous ones [Kloeden and Pötzsche 2013]. Even clarifying the notion of an attractor—the centrally focused dynamical phenomenon in current dynamical systems oriented cognitive modeling—is loaded with mathematical intricacies [Poetzsche 2011, Manjunath and Jaeger 2014]. It will take a while before this venue can be widely explored outside an inner circle of specialized mathematicians.

But of course, agent-environment interactions have been broadly studied from dynamical systems oriented perspectives. I highlight examples that I am familiar with.

• Two classical fundamental models of embedded living systems are von Neumann's model of self-replicating automata [von Neumann and Burks 1966] (which also marks the invention of cellular automata), and the model of autopoietic living systems by Varela and Maturana [Varela et al 1974]. Although both models are not formulated with ODEs but via discrete-time, finite-state cellular automata, I mention them here due to their dynamical systems look-and-feel. In both cases, the 'computing', rather: 'living' system is modeled as a delimited, moving, shape-changing and growing area within a cellular space–time grid.

The theory of autopoietic systems is even explicitly anti-semantic. According to their originators, what happens inside such a system is not reflecting, or representing, outside givens: 'In this sense we will always find that one cannot understand the phenomenon of cognition as if there were "facts" and objects "out there", which one only would have to fetch and put into the head.' (my translation from a German translation [Maturana and Varela 1984] of Maturana and Varela's book El árbol del concocimiento). Instead, an autopoietic system constructs its own internal world, which is shaped and connected to the outside only because this organization has to meet requirements of self-stabilization and survival. Maturana and Varela have coined the term structural coupling for this principle [Maturana and Varela 1984]. Their biologically motivated theory has given rise to schools of epistemology called (radical) constructivism [Schmidt 1987] and enactivism [Wilson and Foglia 2017]. As far as I am aware, a mathematical formalization of structural coupling in terms of qualitative phenomena in dynamical systems has not been attempted.

• Ashby's 'Design for a Brain' [Ashby 1952] proposes a fundamental explanation of the brain's function and purpose in the tradition of cybernetics. Modeling both the brain and its environment through differential equations, he focuses on mechanisms of homeostatic self-regulation and adaptation to changing environmental conditions. In an extensive methodological discussion (chapter 3) he defends the mathematical approach to model both the brain and its environment by coupled differential equations.
• Beer's model of a situated (insect-level) agent [Beer 1995], formulated much later than Ashby's model but in the same spirit and explicitly referring back to it, engages in the scientific controversies of the time where behavior-based robotics [Brooks 1989] or new AI [Pfeifer and Scheier 1999] developed in opposition to traditional, logic-based, symbolic AI. In a long section, Beer (1995) refutes the idea to call a brain 'computing' (at least if understood in the Turing/DC sense), rejecting the symbol-referent semantic paradigm, and renews Ashby's approach of modeling the agent in its environment as two coupled dynamical systems, each modeled by ODEs. Using mathematical concepts and simulation technology that were not available to Ashby, Beer explores how geometric structures in the phase portrait of the agent are influenced/shaped in response to geometric information obtained from the phase portrait of the environment. In a nutshell, he argues in favor of replacing the semantic reference relation by a dynamical interaction relation between two equal partners.
• In nonlinear control theory we find an analog of the agent-environment relation, namely between a controller and the controlled plant. This analogy is in fact directly instantiated in the machine learning field of reinforcement learning, which on the one hand is usually presented as an agent acting in an environment and on the other hand is a special sort of an optimal control problem, with substantial cross-fertilization between the two fields. However, the optimal control setting requires a probabilistic treatment which would lead out of the present context.

Controller-plant systems can often be formalized as two coupled ODE subsystems. Call the state vectors of the controller and the plant x_c and x_p, respectively. The controller can monitor the plant through observations $\mathcal{O}({\mathbf{x}}_{\mathrm{p}})$, and the plant is influenced by controls $\mathcal{C}({\mathbf{x}}_{\mathrm{c}})$. This leads to coupled equations ${\dot {\mathbf{x}}}_{\mathrm{c}}={f}_{\mathrm{c}}({\mathbf{x}}_{\mathrm{c}},\mathcal{O}({\mathbf{x}}_{\mathrm{p}})),\enspace {\dot {\mathbf{x}}}_{\mathrm{p}}={f}_{\mathrm{p}}({\mathbf{x}}_{\mathrm{p}},\mathcal{C}({\mathbf{x}}_{\mathrm{c}}))$, which is a special format of two coupled ODE systems. The controller furthermore typically receives an external target input, which I omit here (it would represent the user of the system). This simple controller–plant schema is a stark simplification; practical designs usually include several more modules serving specific subtasks [Jordan 1996]. In control engineering and also in the motor control research in neuroscience and robotic, the focus of modeling lies on understanding conditions for dynamical stability of the controller–plant system, which naturally leads to analyzing convergence conditions to attractors. There are two ways how attractors become important in control theory. First, they can express the mathematical condition that the coupled controller–plant system behaves in a stable way, being robust against perturbations. They are then a characteristic of the dynamical behavior of the coupled system in its joint state space x_c ⊗ x_p and not a carrier of semantic relations. Second, the controller may become subdivided into a path planner and an execution controller. While the planner module is mostly formalized with mathematical tools other than ODEs, sometimes ODEs are used also for this module. The attractors are then located inside the planner and represent objects or conditions in the external task space of the plant, for instance target positions or paths for a reaching motion [Bizzi and Mussa-Ivaldi 1995, Khansari-Zadeh and Billard 2011]. This would be in line with the view that I advocated for ODE what-formalisms above, namely that geometric objects in the phase portrait should be cognitively interpretable and amenable to a semantic interpretation. I am however not aware of work aiming at a formalization the relationships between attractors in control planning modules and external givens.

In my understanding of the term, for a relationship between two formally modeled domains to be called 'semantic' it is necessary that there is a difference in kind between the two domains ((a) and (c) in figure 3). The models (a) of brains, agents, controllers—that is, GC systems—should contain formal elements that can be understood as forming representations of some sort: descriptors, percepts, words, concepts, formulas, symbols, statements, etc which can be formally interpreted as referring to referents in the external world domain (c): objects, situations, materials, events, etc. In dynamical systems oriented modeling, one typically finds that these are made of the same mathematical substance as the models of their environment—often ODEs, and semantics collapses to interaction between two subsystems of a single dynamical system.

Take-home message 11: the study of how cognitively interpretable, qualitative phenomena arising in the internal dynamics of an agent relate to dynamical models of its environment has barely begun for ODE formalisms. Appropriate ways of achieving this may have to wait for a further development of non-autonomous dynamical systems theory. Existing dynamical models of agent–environment interaction use the same formalism for both, namely dynamical (sub)systems described with the same formalism. While this helps to understand living or artificial autonomous agents and stability or viability conditions, it does not express or explain the agent-internal processes as 'computing'.

Formal time. The formal time model is hidden in the dot in $\dot {\mathbf{x}}$, the shorthand for the derivative dx/dt with respect to time t. By inserting time constants τ in the governing equations $\tau \enspace \dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{u}(t),\mathbf{a})$, the system evolution can be proportionally sped up or slowed down by making τ smaller or larger.

When a natural scientist or engineer sees an equation $\tau \dot {\mathbf{x}}(t)=f(\mathbf{x}(t),\mathbf{u}(t),\mathbf{a})$, without further thinking he or she will understand the variable t to stand for the continuous arrow of real-world physical time, one of the reasons why ODE formalisms are so natural for physicists and engineers. This is fundamentally different from the formal time in DC modeling, which is logical-inferential in its origin and becomes mapped to the physical time of physical computers in essentially arbitrary scalings, depending on the clock frequency of the digital processor. One will not find the word 'second' mentioned in any textbook of theoretical computer science! The fact that a formal '1 s' segment of t really means one physical second in ODE analog circuit models has important consequences for analog computing practice. First, the designer of analog circuits must match time constants in his/her formal ODE models to the physical time on board of the microchip. Second, assigning different time constants to different system variables is an utterly delicate affair, because slightly different settings of these time constants may lead to qualitatively different system dynamics. Third, analog computing systems must be timescale-matched to their physical task environment because both operate in the same physical time. On the positive side, this makes it natural to design analog computing systems that are physically embedded in their environment through continuous input- and output signals. DC faces deep-rooted difficulties with continuous real-time processing and the common solution there is to build or buy machines whose digital clock frequency is so fast that the inevitable delays of 'processing' the current input value become non-disruptive for the task at hand. It is however technically difficult to construct analog hardware that is both small-sized and slow. In analog electronics, small-sizedness conflicts with slowness because slow time constants spell out into large capacitors or very low voltages, both of which quickly hit limits. In our own work with analog neuromorphic microchips we found this the most challenging obstacle when we wanted to realize an online heartbeat monitoring system—human heartbeats is much slower than time constants in nanoscale electronic circuits [He et al 2019b].

These difficulties render the practice of designing and using analog (especially neuromorphic) computers in 'situated' online processing tasks markedly different from how digital machinery is used. One cannot use the same machine and neural network model for fast and for slow tasks. The formal model timescales must match the physical machine's which in turn must match the ones of the task. In DC, the only limit regarding timing in situated online processing scenarios is given by the digital clock frequency. Provided that an adequate 'real-time' operating system is available, any task with slower timescales can be solved with digital machines by buffering variable values for waiting times as long as the slow task timescale demands. Furthermore, the qualitative behavior of analog circuitry and their how-models depends sensitively on the settings of numerical parameters in the models, especially (but not exclusively) on time constants. On the plus side: analog computing systems that have been successfully embedded in their task environment with matched time constants and internal processing entrained by the driving input can cope with broad-band signal interfacing with virtually zero delay.

This picture of online-entrained operations of analog computing circuits corresponds to reflexive, automated operation modes of biological brains, of particular importance in motor control. But brains of not all-too-primitive animals also command working memory and long-term memory mechanisms where information packets can be encoded and stored for extended durations. Biological brains apparently use a variety of mechanisms for such extended-time memory functionalities [Durstewitz et al 2000, Kistler and de Zeeuw 2002, Baddeley 2003, Tetzlaff et al 2012, Preston and Eichenbaum 2013, Fusi and Wang 2016]. These mechanisms allow biological brains to integrate information input over timespans that are much longer than the transient timescales given by time constants in ODEs, and realize processing procedures that are akin to DC procedures. Formalizing and analyzing mechanisms of encoding, storing, addressing, accessing and decoding information packets lies beyond the possibilities of pure ODE models and requires additional descriptions of multi-module architectures, encoding principles and learning processes. These additional descriptive components are typically provided in plain English or graphical flow diagrams [O'Reilly et al 1999, Howard 2009, Markert et al 2009, Pascanu and Jaeger 2011] since there exists no formal theory yet which captures information encoding, storing and retrieving in continuous-time dynamical systems.

Take-home message 12: in ODE-based how-models the timescales of the model must match the physical timescales of the I/O signals if the physical computing system is used in online tasks. This is similar to the operating conditions of biological brains when they are entrained in online processing tasks, but very different from DC. However, ODE models can be used as modules in complex memory architectures which mirror structural and procedural principles known from symbolic computing. In the absence of a general theory of persistent information encoding in ODE models, such architectures are informally described on a case-by-case basis.

The hierarchical structuring of formal constructs is intimately connected with timescales in ODE modeling. When researchers in cognitive neuroscience, robotics and autonomous agents or machine learning conceive of their respective intelligent agent architectures as dynamical systems, they almost by reflex assign fast timescales to subprocesses that operate close to the sensory–motor interface boundary (segments b, β), and the assign slow timescales to subprocesses operating at 'higher' levels of the cognitive processing hierarchy. In my opinion, timescale hierarchies are key for finding hierarchicity in dynamical systems.

Compared to the state of the art in characterizing geometry-defined qualitative phenomena, the study of timescale-defined qualitative phenomena is in an early stage. Most qualitative phenomena arising in ODE systems are described via static geometric-topological conditions in phase portraits. Time is by and large factored out in the definitions of phenomena like fixed points, attractors or bifurcations. The 'speed' of state variable evolution is irrelevant for the mathematical definition of these constructs. Time enters these definition at best in the form of asymptotic (infinite duration) characterizations of convergence.

Multiple timescale dynamics are of general interest for complex systems modeling in all natural sciences. A rich body of mathematical theory has grown [Kuehn 2015]. When writing down ODEs, slow versus fast timescales can be imposed on system variables by multiplying time constants into their differential equation. But as we have seen in the previous subsection, this freedom is not granted to hardware or brain modelers because the time constants in their models must match a given physical reality. However, in ODE and other dynamical systems all of whose variables are fast, new descriptive variables can be discovered through mathematical analyses which reflect slowly changing collective characteristics of the underlying system. The most common strategy is to use mean-field methods where many system variables are averaged, but it can be done in many other ways. For instance, complex chaotic attractors can be described in terms of their make-up from connected lobes, which can be discerned from each other geometrically (by approximating them with periodic attractors) or by registering dwelling times (the dynamics stays for some time in one lobe before it moves to another) or by the possibility to stabilize the lobes [Babloyantz and Lourenço 1994]. A method developed in computational neuroscience and machine learning is slow feature analysis [Wiskott and Sejnowski 2002] where slowness of derived variables is directly used as criterion to identify them. In physical systems, the emergence of multiple timescales is often connected to mechanisms that cannot be captured with ODEs, in particular delays in system-internal signal propagation and spatial extension of systems.

Mathematical and applied research on multiple timescale dynamics in ODE models is so rich that a comprehensive treatment cannot be attempted here. I single out one kind of system model which offers relevant insights for understanding ODE systems as 'computing'. These are RNN models where a stack of neuronal layers corresponds to a sequence of increasingly slower timescales, starting from a 'low' fast sensor–motor interface layer to 'higher' layers whose increasingly slower neuronal state variables are interpreted as representing increasingly compounded 'features' or 'concepts'. Examples are RNN based robot control systems where these timescale differentiations are predesigned into the neuronal hierarchy through time constants [Yamashita and Tani 2008]; or a hierarchical RNN model for the unsupervised discovery learning of increasingly slower components in multiple-timescale input signals, where the different timescales are predesigned by way of using faster or slower 'leaking' in the used neuron model [Jaeger 2007]. In neuroscience, the idea that biological brains operate at fast timescales close to their sensor–motor periphery, and at increasingly slower timescales as one moves 'upward' in the anatomical hierarchy toward forebrain structures, has been advanced on the basis of theoretical argument corroborated by simulation studies [Kiebel et al 2008], and it also has been confirmed by physiological measurement [Murray et al 2014]. In machine learning architectures the formal neurons in higher layers are made slow by adorning their ODEs with slower time constants—'higher' neurons are slower neurons. With regards to biological brains, it is still unclear to which extent (and on the basis of what physiological mechanisms) individual neurons in different brain regions are slower or faster; or how or to what extent different timescales of neural integration of information arises from collective mechanisms [Goldman et al 2008]. Even when all neurons across the hierarchy are individually equally fast, slowness in higher layers can arise as a property of derived variables like spiketrain autocorrelation timescales [Murray et al 2014] or collective variables like local field potentials [Kiebel et al 2008]. The low-to-high layering in hierarchical RNN architectures can be feedforward (lower layers feed only to higher layers but not vice versa) or bidirectional (with both 'bottom-up' and 'top-down' couplings between the layers). Biological brains are eminently bidirectional, as are many formal models in computational neuroscience and a few in machine learning. I will only consider bidirectional models here. With regards to timescales there are noteworthy similarities and dissimilarities between bidirectional hierarchical RNN models and digital computer programs. Large computer programs are written by professional programmers in a hierarchically organized fashion, with higher-level program modules (scripts, functions, objects) calling lower-level ones as subroutines. Such programs are bidirectional: the higher-level module 'calls' the lower-level one and typically sends down initialization or configuration parameters; and the lower-level subroutines send the results of their computation upwards to the calling module. This automatically leads to a runtime hierarchy: executing higher-level modules necessarily takes longer than executing the lower-level because the latter are called inside the higher-level one. The resulting timescale hierarchy could be called a waiting-time hierarchy: the symbolic configuration update step assigned to the higher-level module is pending in an indeterminate status as long as the called lower-level subroutines are being executed. In contrast, in bidirectional RNN systems, all neurons on all levels are active simultaneously, and the top-down and bottom-up information flows are continually streaming without need (or opportunity) for waiting. This is yet another reason why brains cannot easily be likened to symbolic computing machines, and why timescales are a key issue when one wants to develop conceptualizations of 'computing' that extend beyond the DC paradigm and include brains.

For mathematical analyses of top-down influences from higher to lower layers it is decisive how much slower the higher layer develops. If the timescale separation is very large (say two orders of magnitude or more), the slow evolution speed in the higher layer can be approximately regarded as standing still compared to the fast lower layer. It is then widespread but not entirely rigorous practice to consider the variables fed to the lower from the higher layer as constant control parameters in the equations governing the lower layer, and study different processing modes of the lower layer separately by considering different static settings of these control parameters. A rigorous mathematical analysis of such slow–fast systems needs the tools of singular perturbation theory [Kuehn 2015]. If the timescale separation is not very large, analyses become difficult and rely on heuristic assumptions, as in the proposal of Wernecke et al (2018) where the emergence and decay of transient qualitative phenomena in the lower fast layer is regarded as being guided by the attractor structure that would be defined if the timescales were widely separated.

Strictly layered architectures are popular in machine learning, AI and control engineering [Albus 1993]. When they are bidirectional, they contest the limits of today's mathematical analyses. Biological brains [Felleman and Van Essen 1991] and complex practical control architectures [Thrun et al 2006] have a modular structure which is more complex than a linear ordering of processing layers, with many lateral and diagonal processing pathways. Furthermore, it may happen that a variable that is fast at some time may turn into a slow one later and vice versa. Analyzing, or merely characterizing such timescale meta-dynamics is beyond the reach of today's mathematics as far as I can see.

How does all of this relate to my distinction between how- and what-models? An answer is not easy because timescales are investigated and formalized in many ways in different contexts. I would say that timescale hierarchies are relevant both for how- and what-modeling, but unfold their full power especially in what-modeling. When electrical engineers write down their device or circuit specifications in ODEs, adjusting their time constants to their target systems, they are doing a how-modeling job. But in doing this they will not be considering the cognitive-representational implications of what will happen when their systems start 'computing'. Computing theorists on the other hand will consider timescales a qualitative property that admits a cognitive interpretation. Then these models appear as what-models. This view is immanent in the intuitions about physical intrinsic semantics held by cognitive modelers who posit that brain-internal variables represent objects or situations in the external environment, as revealed in this quote: 'Many aspects of brain function can be understood in terms of a hierarchy of temporal scales at which representations of the environment evolve. The lowest level of this hierarchy corresponds to fast fluctuations associated with sensory processing, whereas the highest levels encode slow contextual changes in the environment, under which faster representations unfold.' [Kiebel et al 2008].

Take-home message 13: timescale hierarchies, possibly structurally reflected in layered architecture designs, are an important ingredient of dynamical systems models to qualify them as 'computing'. Different timescales in (neuromorphic) analog hardware and their mathematical models can arise from a variety of formal and physical effects for which we still lack a comprehensive understanding. The formal nature of multiple timescales differs fundamentally between digital computers (waiting time hierarchies) and parallel analog systems (continually interpenetrating bottom-up and top-down streams of information with different time constants).