Grand Challenge 7 : Journeys in Non-Classical Computation

We review progress in Grand Challenge 7 : Journeys in Non-Classical Computation. We overview GC7-related events, review some background work in certain aspects of GC7 (hypercomputation, bio-inspired computation, and embodied computation) and identify some of the unifying challenges. We review the progress in implementations of one class of non-classical computers: reaction-diffusion systems. We conclude with warnings about "regression to the classical".


INTRODUCTION
In 2002, the UK Computing Research Committee (UKCRC) issued a call for "grand challenges in Computer Science", to help focus and direct research. More than one hundred responses were received, and over a 2 day workshop these were amalgamated and boiled down into seven distinct Grand Challenges. GC7, Journeys in Non-Classical Computation, is one of those original seven. Subsequently some challenges have been merged, and others suggested; see the Grand Challenges website for current details 1,2 .
The GC7 Challenge is to produce a fully mature science of all forms of computation, that unifies the classical and non-classical paradigms. The non-classical paradigms include computation under non-classical laws of physics (quantum theory, general relativity), biological computing, embodied computing, in materio computing, and more. Details of the Challenge, and some suggested research directions, can be found in [Stepney et al 2005a] [Stepney et al 2006a]. Here we report on some of the progress made in specific challenge areas.
Caveat: not all the research discussed here has been explicitly done as part of GC7, and some of the authors referenced may well never even have heard of GC7. Our purpose here is simply to survey some of the background work that we wish to synthesise into the overall vision of GC7. We start by listing some recent GC7related activities ( §2), then discuss some challenges in more detail ( §3), and some implementations of nonclassical computers ( §4). We conclude with a warning against comfort, and a reminder of the goals of GC7 ( §5).

ACTIVITIES SUMMARY
Several conferences and workshops have been organised around GC7, or in collaboration with GC7, or have featured GC7 discussions or presentations (see referenced websites and publications for more details): • The Grand Challenge in Non-Classical Computation International Workshop (18-19 April 2005 [Adamatzky et al 2007] • Thinking Through Computing workshop (2-3 November 2007, Warwick UK) 8 • Automata 2008 (12-14 June 2008, Bristol UK) 9 [Adamatzky et al 2008] [JCA 2009] Further events are planned, including a broader network of participants to work on GC7's overall goals.

CHALLENGES
GC7 is an umbrella activity. Its aim is to bring together individual journeys in non-classical computation that are being made by various researchers, both within and without the GC7 community, to ensure that a complete and coherent map of the territory is developed. We start here by reviewing activity in a variety of GC7 areas, and identifying the challenges they are exposing.

Hypercomputation
One way to challenge the underlying assumptions of the Turing model (for example [MacLennan 2004]) is in the details of its abstraction from the laws of physics. Investigation of this abstraction reveals that its underlying physical model is implicitly Newtonian.
If we instead consider the underlying physical laws to be quantum, we can have a situation where tape symbols can exist in superposition, can be entangled, and where quantum interference along different computational paths is crucial. Quantum computers allow for some quantum algorithms to exhibit exponential speedup over their most efficient classical counterparts, and for truly non-classical computations, such as genuine random numbers.
If we take general relativity into consideration, we can allow the Turing machine and the user who waits for it to halt to experience qualitatively different amounts of proper time (the user experiencing finite proper time whilst the Turing Machine experiences infinite proper time [Hogarth 1992]), such that the Halting Problem can (at least in principle) be solved. (Note that this approach subverts the classical proof of impossibility of the Halting Problem by requiring the computational device here to be a Turing Machine plus a space-time singularity: the program of this larger device cannot be encoded as a string that is fed back into itself; part of the implementation is physical.) Considering the underlying laws of physics, as opposed to relying on the mathematical abstraction, can also outlaw certain challenges to the Turing model. For example, some researchers attempt to get "more than Turing" computation by challenging the assumption that the tape symbols are drawn from a finite set, and allowing real numbers into the computation. Real number analogue computers have (theoretically) more power than Turing machines. The reason why is easy to see: a single real number (given to infinite precision) contains an infinite amount of information. However, can such infinite precision quantities exist in the physical world? Can arbitrarily fine distinctions be made? At the very least, the enormous complexity of preparing such inputs, and measuring such outputs, needs to be taken it consideration [Blakey 2007]. But one also has to recognise that higher precision measurements require larger measuring devices and higher energies. Once the size of the measuring device reaches the size of the universe, no further precision is possible. Infinite precision real number computing is a physical impossibility.
One must be careful in arguing what is and is not physically possible. For example, consider accelerating Turing Machines [Copeland 2002]. The Turing model assumes an essentially constant time taken for each step in the computation. Challenging this, one can argue that an implementation that could do each step in half the time of the previous one could accomplish an infinite amount of computation in a finite time. Such classical accelerating Turing Machines can live in a Newtonian universe, but not in our relativistic one where the speed of light is a limiting factor, and infinite (or even unbounded) speed is a physical impossibility. However, general relativistic solutions, with the user and computer separated, such as mentioned above, that allow different proper times, have a similar effect.
In September 2006, an International Interdisciplinary Workshop on Future Trends in Hypercomputation was held at Sheffield UK, partly under the auspices of GC7. It was devoted to exploring many different ways to challenge the assumptions underlying the Turing Model. Several of the presentations were invited to be expanded for a special issue of the International Journal of Unconventional Computing [IJUC 2009], including one discussing hypercomputation from the perspective of GC7 [Stepney 2009]. Out of this workshop has grown the HyperNet: the Hypercomputation Research Network (EPSRC grant EP/E064183/1), run by Stannett.
Researchers have, of course, been speculating on the importance of physics in terms of limits on what a physical computer can do [Landauer 1961] [Lloyd 2000]. Some have speculated that computation is more fundamental than physics [Wheeler 1990]. The challenges include: how can new models of computation be abstracted from the underlying physics? How expressive can these models be? Are proposed models of computation implementable given the constraints of physics? Precisely what assumptions about the physical laws are being made? What other undiscovered assumptions underlie the Turing model?

Interactive Computing
In some sense, the underlying model of physics is the simplest assumption to recognise and challenge, but there are others. For example, one can challenge the notion that the computation proceeds uninterrupted until it halts, at which point the answer is revealed. After all, biological organisms, often considered to be performing computation, do not "halt" (while they are alive, at least). [Wegner 1997] discusses interaction machines: "Turing machines extended by addition of input and output actions that support dynamic interaction with an external environment", and claims that they are more powerful than Turing machines. Whether or not this is the case, what we want to challenge here is the very notion of what it means to be "more powerful" than a Turing machine. If we play by the rules of the Turing paradigm, this is limited merely to considerations of halting, computability and computational complexity. These notions are certainly important, but so are other notions, including naturalness of models, of composition, of implementation, of proof, and so on. If an interactive approach is a more natural way of modelling or reasoning about a problem, then it is in some sense more powerful than a less amenable non-interactive model.
In this age of the Internet and the Web, and of pervasive and ubiquitous computing, interaction and information flow between multiple agents are key notions of computation. One approach to interaction is to cast the problem in terms of games, with two or more players interacting via strategies (where the environment can be cast as a player if required). For example, the 7th Augustus de Morgan Workshop (2005) was dedicated to this topic of "Interactive Logic, Games, and Social Software", with the manifesto: Traditionally, logic has dealt with the zero-agent notion of truth and the one-agent notion of reasoning. In the last decades, research focus in logic shifted from these topics to the vast field of "interactive logic", encompassing logics of communication and interaction. The main applications of this move to n-agent notions are logical approaches to games and social software. The wealth of applications in these areas will be the focus of the 7th Augustus de Morgan Workshop. 10 [Abramsky 2006] discusses the logic and semantics of n-player games. Game semantics is yielding new approaches to compositional model-checking, and to analysis for programs with state, concurrency, probability and other features.

Bio-inspired Computing
The ultimate interactive computing is that performed by biological organisms. They are constantly interacting (exchanging matter, energy and information) with their environment, which may include other organisms. Viewing biological systems as performing computation, and taking inspiration from them to develop analogous algorithms, is possibly the most well-represented non-classical computation paradigm.
Computation today is rife with bio-inspired models (neural networks, evolutionary algorithms, artificial immune systems, swarm algorithms, social insect algorithms, and so on). However, many of these models are naïve and out of date with respect to the underlying biology. Without too much exaggeration, one could say that the area has been cherry-picked for over-simplistic ideas, which have been implemented into algorithms of dubious biological relevance. Initial attempts applied to small or very specialised problems were very successful (or were not published), but attempts for more general applicability, and for scalability, repeatedly hit snags.
The field is now maturing [Banzhaf et al 2006]  . Computer scientists are working closely with biologists to understand the full complexity of the systems they are attempting to emulate, and to work out principled abstractions that will allow properly engineered algorithms. As part of this process, we have suggested a conceptual framework for structuring the analysis of biological systems and the development of domain-specific engineered algorithms inspired by them [Stepney et al 2005b].
We have laid out a vision for how this would work in one particular domain, that of Immuno-engineering . It can be argued that the immune system's speed, flexibility and multiple response options rely on a parallel-processing system which has "wasteful" use of resources, countless back-up systems, and requires the ability to immediately and continuously monitor physical sites. This has massive implications for the engineer, who is constrained by processing speeds, communication overheads, and physical resources, and furthermore hindered by hardware requirements such as transmitting signals from sensors, but who can freely make numerous copies of software agents, subject only to storage constraints. Immuno-engineering crucially takes into account these differences between artificial systems and biological systems: for example, the different numbers, kinds, and rates of signals that need to be monitored and processed; the different kinds of decisions that need to be made; the different effectors available to support and implement those decisions; and the different constraints of embodiment, either physically or virtually engineered. The Immuno-engineering approach takes steps to address these issues.
Computer scientists are seeking inspiration from all levels of biology, from DNA transcription and gene regulatory networks, metabolic networks, immune systems, endocrine systems, neural systems, slime moulds, plant growth, fungal mycelia, social insect behaviours, to populations and ecologies. As a small example, we are currently progressing the ideas in the field of evolutionary algorithms, by building more detailed models of bacterial genome structure and their evolutionary processes, in order to develop novel evolutionary algorithms with richer analogical computational structures, that are more suitable to solve complex dynamic control tasks [Stepney et al 2007], as part of the Plazzmid project (EPSRC grant EP/F031033/1).
The challenges here are grand indeed, not least because this work is progressing in parallel with the biological research itself. What are the underlying bio-computational mechanisms? What of these are contingent on the organism being an embodied carbon-based lifeform? Are there general principles that can be abstracted to other situations? How can this abstraction and mapping be performed when the application domain is radically different from the biological one? Can this work help the biological research programme?

Massive parallelism
One of the major features of biological systems is their massive parallelism, on multiple scales. Cells contain millions of molecules, organisms contain trillions of cells, ecosystems contain billions of organisms, all acting and interacting on different length-and timescales. In the Turing model, a parallel TM has no more computational power than a sequential one, since a parallel machine can be simulated by a sequential one. However, this argument applies only under the assumptions of the Turing model, which does not include considerations of realtime performance, naturalness of description, or fault tolerance and redundancy, among others.
One of the original areas discussed in the context of GC7 is concurrency [Stepney et al 2006a], where we argue that classical computer science has taken a wrong turn by focussing on sequential machines, and how concurrency, when approached correctly, should be the natural way to describe, model, and implement systems. We argue the case for process algebra-based languages, specifically, CSP [Hoare 1985] and π-calculus [Milner 1999]. (See also [Abramsky 2005] for a different take on some of the problems.) The TUNA feasibility project (EPRSC grant EP/C516966/1) investigated the use of these languages, and of an executable implementation in a process-oriented language (specifically occam- The massive parallelism in TUNA/CoSMoS is achieved by timeslicing tens to hundreds of thousands of processes on a single processor, and distributing over several tens of processors (a rack of Linux boxes connected by Ethernet). The implementation language allows this distribution to be achieved relatively transparently. True concurrency on a single processor can be achieved on FPGAs (Field Programmable Gate Arrays), programmable hardware that allows different parts of a single chip to be executing different parts of a program at the same time. FPGAs can be linked together in large numbers (for example, the BioWall [Tempesti & Teuscher 2003]), allowing massive parallelism to be achieved relatively cheaply. The CSP-based language Handel-C can be used to program multiple FPGAs in a process-oriented style.
Such classical parallelism is relatively straightforward technologically, it merely requires a change in mindset to move from a "sequential-first" to a "concurrent-first" style. (Although this might be considered to be equivalent to saying that a more efficient keyboard is relatively straightforward technologically, it merely requires a change in mindset to move from a qwerty to a Dvorak style.) More challenging is the parallelism provided by many forms of analogue computing. These can provide a more immediate massive parallelism, implemented directly by the underlying physical properties of the substrate being exploited. There is a wide range of problem-specific analogue computers, but there are also general purpose analogue computers. Mills has built implementations of Ruebel's extended analog computer [Rubel 1993], where the computational substrate is a conductive sheet [Mills et al 2006] [Mills 2008b] and has developed a computational metaphor to aid its programming by analogy [Mills 2008a]. It is clear, however, that there is still challenging work to be done to provide the level of support for programming such devices as we currently enjoy in the classical realm. What are suitable models for programming by analogy? How expressive can these models be?

Embodiment and in materio computing
We choose to distinguish embodiment (real-time close coupling of a computational device with its complex environment) from in materio computing (computation directly by physical and chemical processes of a complex substrate, with little or no abstraction to a virtual machine). Most authors choose to conflate these properties (for example [MacLennan 2008]), requiring embodiment to be physical. However, separation of these concepts allows us to consider virtual embodied systems [Stepney 2007], for example, the embodiment of software agents closely coupled with a complex but virtual internet environment, and to consider non-embodied in materio computation (computation by a physical medium [Miller & Downing 2002] [Harding et al 2008]), where the computation performed by that medium need not be real-time, nor closely coupled with a complex environment.
With this view, embodied computation can be implemented either as embedded computation (a classical computer embedded in a body that interacts with the environment via classical sensors and actuators), or as in materio computation (computation by the physical properties and processes of its body). Biological systems, "wetware", are embodied (where their complex environment comprises the physical world, other biological organisms, and other parts of the organism that the biological system of concern, such as a cell, inhabits) and in materio (implemented in a complex material substrate that directly performs the relevant computation and information processing). Hybrid embodiment is becoming more common, where some of the processing is embedded (a classical embedded computational "brain"), and some is in materio (any computation performed directly by the rest of the physical body  2008b] has this hybrid nature too: a combination of explicit logic circuits and implicit analogue computation. In the hybrid embodied case, the behaviours of the sensors and actuators are not so easily separated from the computation: they too are part of the body and can be considered to be performing in materio computation (for example, complex signal transduction, or even the case of a "slinky" toy spring that can "walk" downstairs with no controller or motor). An excellent review of some of these aspects applied to robotics can be found in [Pfeifer et al 2007]. The fact that controller, body, sensors and actuators cannot easily be separated (and co-evolve in biological systems) is being investigated in information theoretic terms by Polani and colleagues, for example [Olsson et al 2006] [Polani et al 2007.
The direct computation performed in materio can be extremely efficient compared to simulating similar processes classically: the material merely does what comes naturally, on timescales directly controlled by the physical laws.
[MacLennan 2008] discusses how physical systems can efficiently implement massively parallel diffusion, sigmoid functions, negative feedback, and randomisation. Another example is the so called "protein folding problem", intractable classically, but computable by physical proteins in a few seconds. The challenge here is to discover how to exploit various complex material substrates to do computation [Bechmann et al 2007]  , to explore the range of possibilities exhibited, and to discover what (if any) generalisations can be made. For this efficiency comes with a price: we currently have to trade off efficiency for abstraction (the computation is performed directly by the physical medium, with little or no abstraction into virtual levels, which can be argued to be essential for certain forms of computation [Sloman & Chrisley 2003]), and (often) for universality. So the broader challenge is to discover what abstractions can be made: what are appropriate abstract models of classes of in materio computation? In other words, what kind of in materio computations have at least some degree of substrateindependence? (They might require some complex non-linear dynamical behaviour, but that kind of behaviour might be exhibited by many substrates; [MacLennan 2004] calls this multiple instantiability). How many essentially different kinds of models are there? Do any provide universality? Do any provide the self-referentiality that allows meta-programming and Strange Loops [Hofstadter 2007]? How expressive can these models be? Is material embodiment essential to ground the semantics of the system [Rosen 1991], or can virtual systems exhibit the same kind of properties? 3.6 Growth and self assembly Biological systems are able to self assemble and grow: their environment provides a flux of energy, matter, and information, which they can process to form further material computational substrate (for example, more cells).
Ideas from biological growth and development are beginning to influence evolutionary computation. The fact that biological organisms have a complex non-linear mapping from their genotype (DNA) to their phenotype (body) has been taken on board in "evo-devo" algorithms: evolutionary algorithms that "evolve" a digital genotype, that then develops, or "grows" into the desired phenotype. Here the genotype is a "generative encoding": it encodes an indirect description of the result, which when decoded generates the phenotype. Genetic Programming [Koza 1992], where the genotype is a computer program, and the phenotype is the result of the execution of that program, may be thought of as an early instance of this idea. Newer ideas focus on kinds of generative rules for how the genotype decodes to the phenotype. ]. In all these cases, the genotype is subject to evolution (mutation, crossover, etc), whilst the generated phenotype is evaluated for fitness.
The complex non-linear genotype-phenotype mapping can be considered as an attractive feature to add to evolutionary algorithms, or the generative process can be considered as the main focus, in order to "grow" Recently, Christopher Alexander, the architect whose work inspired Software Engineering Pattern Languages [Alexander et al 1977] [ Gamma et al 1995], has more recently been working on morphological ideas in architecture, and looking for a computational description of them [Alexander 2009].
Computational growth and development ideas are not restricted to software. Much exciting work is taking place in the area of growing and self-assembling nanotech computational artefacts. Adelman's original DNA computer idea [Adleman 1994] used DNA synthesis to grow the computer, and the chemistry of DNA matching to perform the computation (path finding). Sometimes the growth process is the computation (growing, or self-assembling, certain structures or patterns, etc); more exotic approaches grow a system that then computes ("programmable matter"  [Seeman 2007]. As with all these non-classical approaches, there are no hard-and-fast dividing lines: it is not (and need not be) clear where growth stops and computation begins.
The challenges here are numerous, and only beginning to be articulated. How can software systems be made rich enough so that new structures and behaviours, and new kinds of structures and behaviours, can "grow" naturally out of these systems? Dynamical systems theory is a staple of non-linear systems analysis, yet it assumes that dimensionality is given, and constant, and that the dimensions are (relatively) homogeneous. What are the mathematical techniques for modelling systems whose dimensionality changes and grows in essentially unpredictable (because contingent and emergent) ways as the system develops, where the dimensions are hybrid (a mix of discrete and continuous), and where new dimensions may be of new types?

Other GC7 activities
The reviews here by no means cover all aspects of GC7. In particular, we have concentrated on what might be called "hard" non-classical computing, perhaps somewhat betraying the main interests of the authors. Additionally, there are many "softer" non-classical issues. For example, the "Thinking Through Computing" workshop ( §2) is part of a process for bridging the gap (nay, gulf?) between the Computer Science and the Arts and Humanities view of computing, to promote a broader view of computing. As computers become more embedded and ubiquitous, being used in ways we cannot yet even conceive, views of what computers are, what they are for, and how they should and could be used, will inevitably become ever broader.
Criteria for success of an open-ended challenge like GC7 are difficult to formulate. Nevertheless, one activity of the GC7 community should be to develop a set of partial success criteria, some directed to particular journeys (covering development of theory, and development of implementations), some directed to the integration and unification of different journeys. These criteria should allow a good balance between providing discipline and structure to the challenge, and giving free rein to novel ideas.

IMPLEMENTATIONS OF REACTION-DIFFUSION COMPUTERS
Many discussions of non-classical computation can remain highly theoretical and conceptual. After all, exotic space-time singularities are not easily come by to implement general relativistic computations. Even quantum computers are proving challenging to implement. We have mentioned above some material realisations: Mills' implementation of Rubel's extended analog computer, and various embodied DNA devices. Here we review one class of implementations in some detail: reaction-diffusion computers. The class of reaction-diffusion computers can be implemented in a wide range of substrates, from single-electron nano circuits, through chemicals, to slime moulds. The larger, and slower, devices provide a relatively cheap way to investigate the general principles of this computational paradigm.

Reaction-diffusion chemical computers
A reaction-diffusion computer [Adamatzky 2001] [Adamatzky et al 2005] is a spatially extended chemical system, which processes information using interacting growing patterns of excitable and diffusive waves. In reactiondiffusion processors, both the data and the results of the computation are encoded as concentration profiles of the reagents. The computation is performed via the spreading and interaction of wave fronts.
The reaction-diffusion computers are parallel because myriads of their micro-volumes update their states simultaneously, and molecules diffuse and react in parallel. Liquid-phase chemical media are wet-analogues of massively-parallel (millions of elementary processors in a small chemical reactor) and locally-connected (every micro-volume of the medium changes its state depending on states of its closest neighbours) processors. They have parallel input and outputs, e.g. optical input --control of initial excitation dynamics by illumination masks, and output is parallel because the concentration profile representing results of the computation is visualised by indicators. The reaction-diffusion computers are fault-tolerant and capable of automatic reconfiguration, namely if we remove some quantity of the computing substrate, the topology is restored almost immediately.
Reaction-diffusion computers are based on three principles of physics-inspired computing [Margolus 1984]. First, physical action measures the amount of information: we exploit active processes in non-linear systems and interpret the dynamics of the systems as computation. Second, physical information travels only a finite distance: this means that computation is local and we can assume that the non-linear medium is a spatial arrangement of elementary processing units connected locally, i.e. each unit interacts with its closest neighbours. Third, nature is governed by waves and spreading patterns: computation is therefore spatial. Cellular automata and numerical models of reaction-diffusion computers are well-described in [Adamatzky, 2001] [ ; real-world implementations of reaction-diffusion computer are worth further mention.
Image processing: The first ever experimental prototype of a chemical image processor was designed by Kuhnert, who used light-sensitive modification of the Belousov-Zhabotinsky reaction to implement basic operations of image processing [Kuhnert 1986] [Kuhnert et al 1989]. Experimental reaction-diffusion processors were implemented capable of contouring, negative and positive image alteration, removal or enhancement of minor features, image filtration and image restoration; see [Adamatzky 2001] [Adamatzky et al 2005] and references therein.
Graph problems/path planning: Chemical processor for approximation of a shortest path in planar labyrinths or rooms with obstacles were produced by Steinbock et al. [1995], Agladze et al. Rambidi &Yakovenchuk [2001]. In all versions of the processors impassable barriers and obstacles are represented either by physically removed parts of the substrate, drops of chemical inhibitors, or inhibiting illumination. Steinbock & Agladze's implementations employed classical trigger waves, initiated firs at the source and then at the destination, two scenarios of wave propagation were recorded on camera, and analysed. A shortest path was extracted from topologies of intersecting wave-fronts. Two passes of wave propagation are unavoidable, as was demonstrated in theoretical studies [Adamatzky 1996]. Rambidi & Yakovenchuk have used phase waves, where propagation was controlled by lights; additional image processing was required nevertheless. The problem of shortest path calculation was solved in laboratory prototypes of excitable medium processor: Belousov-Zhabotinsky medium interfaced with excitable cellular automaton [Adamatzky & De Lacy Costello 2002], and precipitating chemical medium, palladium processor, [Adamatzky et al 2003].
Computational geometry: The Voronoi diagram, or a tessellation of a plane from a given finite planar set, is a classical hard problem of computational geometry. The planar data set is represented by a configuration of drops of one reactant, and another reactant is contained within the gel substrate. The data-reactant diffuses and forms a coloured precipitate when reacting with the substrate-reactant. When waves of data-reactants meet up they exhaust the substrate-reactant and no precipitate is formed. The uncoloured sites of the medium represent edges of the Voronoi diagram; see descriptions of experimental prototypes in [Tolmachev & Adamatzky, 1996] [Adamatzky et al 2005]. In contrast to conventional approaches, even those implemented in massively-parallel VLSI processors, the exact type of data-objects does not affect the complexity of Voronoi diagram computation in reaction-diffusion processors. The same precipitating chemical medium processes planar sets, sets of arbitrary planar objects , and even calculates the skeleton [Adamatzky & Tolmachev 1997]   of a planar shape in linear time.
Universal computation: There two classes of universal reaction diffusion computers (computers experimentally implemented in spatially extended chemical media that implement a functionally complete set of logical functions): geometrically constrained and free-space devices.
In geometrically-constrained devices, excitation waves travel along channels, interact with each other at the junctions of the channels, and execute logical operations as the result of their interactions; see e.g.    2004]. Constrained by stationary wires and gates, chemical processors mimic conventional silicon computing devices, their novelty is only in the chemical medium implementation.
Free-space 11 , or architectureless, chemical computers employ the paradigm of collision-based computing; see the overview in ]. These originated from the computational universality of Game of Life [Berlekamp et al 1982], conservative logic, and the billiard-ball model [Fredkin & Toffoli 1982] [Margolus 1984. A collision-based, or dynamical, computation employs mobile compact finite patterns, mobile self-localised excitations, or simply localisations, in an active non-linear medium. Information values (for example, truth values of logical variables) are given either by absence (or presence) of the localisations, or by other parameters of the localisations. The localisations travel in space, and do computation when they collide with each other. There are no predetermined stationary wires, a trajectory of the travelling pattern is a momentary wire. Almost any part of the medium space can be used as such a wire. Localisations can collide anywhere within a space: there are no fixed positions at which specific operations occur, nor location-specified gates with fixed operations. The localisations undergo transformations, form bound states, and annihilate or fuse when they interact with other mobile patterns. Information values of localisations are transformed as a result of collision, and thus a computation is implemented ].
Chemical laboratory implementation of collision-based computers is possible thanks to a photosensitive subexcitable Belousov-Zhabotinsky medium that exhibits propagating wave-fragments that preserve their shapes over substantial periods of time. The presence (or absence) of wave-fragments is interpreted as a truth value of a Boolean variable. When two or more wave fragments collide they may annihilate, fuse, split or deviate from their original paths; the corresponding values of the logical variables are changed, and logical gates are realised as a result of the collision. The exact types of logical gates implemented in the collisions between excitation wavefragments depend on the size of the wave-fragments, their phase, and the relative configuration of their velocity vectors at the moment of collision ] . Complicated cascaded logical circuits can be designed in hybrid systems, where excitable chemical media co-evolve with massively-parallel automata networks [Bull et al 2007] [Toth et al 2008]. There is a high chance that soon we will be able to produce laboratory prototypes of Belousov-Zhabotinsky arithmetical processors, as demonstrated already in scoping computational experiments with binary adders in excitable media [Zhang & .
Robotics: Spatially extended excitable chemical media can accept parallel optical inputs, perform computation simultaneously in many sites of their substrates, and, thanks to indicators, can generate outputs in parallel. This makes them unique candidates for the role of decentralised 'wetware' controllers for robotic devices. We have demonstrated the concept in two experimental prototypes of chemical media coupled with hardware robotic devices. To control navigation of a wheeled robot, we installed a chemical reactor on board the robot, allowing the robot to observe the space-time dynamics of the excitation waves. When the waves are triggered by direct application of chemicals, or a light, the robot detects the relative position of the stimulator from the topology of the excitation waves, updates parameters of its movement, and thus progresses towards the source of stimulation [Adamatzky et al 2004]. To investigate closed-loop interaction between the chemical medium and a robot, we interfaced a Belousov-Zhabotinsky medium with a robotic hand in such a manner that excitation wave fronts propagating in the medium triggered movement of the hand's fingers, which in turn physico-chemically perturbed the Belousov-Zhabotinsky medium [Yokoi et al 2004]. Complex patterns of non-trivial hand finger motions were demonstrated experimentally. Large-scale simultaneous manipulation of several objects by an excitable chemical medium can be achieved if every micro-volume of the medium is coupled with a micro-actuator; propagating wavefronts generate force fields, which can sort, orient, transport and assemble arbitrarily-shaped objects [Adamatzky et al 2005a].

Encapsulated reaction-diffusion computers: Physarum machines
There still remains a range of problems where chemical reaction-diffusion processors cannot cope without the external support from conventional silicon-based computing devices. The shortest path computation is one such problem. As discussed above, one can use excitable media to outline a set of all collision-free paths in a space with obstacles, but to select and visualise the shortest path amongst all these possible paths, one needs to use external computing power. Experimental setups that claim to directly compute a shortest path in a chemical medium [Steibock et al 1995] [Agladze et al 1997] employ external computing resources to store time-lapsed snapshots of propagating wave-fronts and to analyse the dynamics of the wave-front propagation. Such usage of external resources dramatically reduces the fundamental value of computing with propagating patterns. Graphtheoretical computations pose even more difficulties for spatially-extended non-linear computers. For example, one can compute the Voronoi diagram of a planar set, but cannot invert this diagram ].
Let us consider a spanning tree, the most famous of classical proximity graphs. Given a set of planar points one wants to connect the points with edges, such that the resultant graph has no cycles, and there is a path between any two points of the set. So far, no algorithms of spanning tree construction have been experimentally implemented in spatially extended non-linear chemical systems. This is caused mainly by the uniformity of spreading wave-fronts, their inability to sharply select directions toward locations of data points, and also because excitable systems usually do not form stationary structures. To overcome these difficulties, we should allow reaction-diffusion computers to be geometrically self-constrained while still capable operating in geometrically unconstrained, architectureless, or 'free', space ]. We have demonstrated that the vegetative state, or plasmodium, of Physarum polycephalum is a reaction-diffusion system constrained by a membrane, capable of solving graph-theoretical problems ] ]. When raised on a nutrientpoor substrate, the plasmodium of Physarum polycephalum can also implement basic operations of the Kolmogorov-Uspensky machine, mother of modern storage modification machines, thus being capable of general purpose computation [Adamatzky 2008a].

CONCLUSION: BEWARE "REGRESSION TO THE CLASSICAL"
As we can see from this review, research into a wide range of aspects of non-classical computation is prevalent, and is gaining maturity. However, we end on a note of caution. We have noticed certain distressing tendencies of a subset of non-classical computation researchers, which we dub "regression to the classical" (this section is deliberately light on references, to protect the accused, who include ourselves at times).
One particular such tendency is to reimplement a universal Turing machine in whatever weird substrate is being considered as a computational medium. We have argued ] that this tells us very little new about computation, and even less about non-classical computation. As noted above ( §4.1), the only novelty of this is in the choice of medium. Non-classical research into strange substrates should uncover what computational behaviour they can do naturally, not merely torture them to do what silicon can do better.
Another tendency is to develop non-classically inspired theoretical models that are essentially indistinguishable from classical models. For example, DNA or enzymes (proteins) routinely get modelled as strings, and the operations that the molecules perform then get modelled as string operators. Then the string model is exhaustively investigated from a theoretical standpoint, often to demonstrate that it is Turing universal. But what often happens along the way is that the abstractions and approximations to build that model go a step too far, and lose any connection with their original inspiration (for example, enzyme binding being modelled as string operations with completely unbiological characteristics).