Embodied reaction logic in a simulated chemical computer

This work uses an ALife simulation to explore the implementation of embodied reaction logic in a chemical computer. Chemical systems have potential for computation. There are properties of a logical system that are desirable in any computational system, such as the ability of the system to change state in response to some input. An issue in chemistry is that the molecules must have some physical embodiment, which must somehow represent state; state is then interpreted as the presence or absence of certain molecular configurations in the system. The design of a chemical logic gate is a means of showing that a chemical system can change state appropriately and that the information encoded in the molecules is available to be processed as information. This paper compares two simulated chemical computing systems: Bindworld (a simple illustrative example) and Stringmol, (a fully implemented complex DNA-inspired evolutionary computing framework). The problems and design decisions involved in creating a NOT gate in each system are compared, showing that designed computational systems require a certain complexity and flexibility to be useful to human operators. Finally we discuss general extensions to the Stringmol reaction chemistry that would simplify the process of information processing in embodied systems. Computation is a fairly new concept to science. Although the word itself has been in use since 1447 or before, until the early 20th century it referred only to manual calculation performed by humans (this is why early machines were called “automatic computers” to distinguish them from their human counterparts). It is only since the development of the mechanical and electronic computer that the term has been applied to a process external to human thought. Artificial Life (ALife) is a simulation of biological life on a computer. These simulations are often considered to be “embodied thought experiments” (Di Paolo et al., 2000), which test whether the essential properties of biology have been captured. Simulations of biological processes are also seen as a step towards harnessing biological processes for our own ends (Brooks, 2001). (The successful simulation will process information in a similar, but more robust, manner to our electronic computers.) It is therefore legitimate to consider how a biological simulation is capable of information processing. The simplest form of this is logic. Models of conventional computing deliver programming languages, based on logic, that abstract the functionality away from the implementation of the logic on electrical circuitry. Programmers take this for granted when designing software using these programming languages. Similar abstractions may be needed to program computers based on other media. Generally, computation proceeds in the following context: 1. INPUT: An observer encodes a problem and passes it to some external system (be it electronic, neural, biological, molecular, or otherwise) via a setup function. 2. COMPUTE: The system evolves, ending in some changed state. Where the change in state has involved some notion of information processing, computation has occurred. 3. OUTPUT: The observer uses an output function to extract some useful information from the system and decode it into a useful response. The problem, or series of instructions, is encoded in a different way depending on the architecture of the computer. In electronic computers it is a program in a language such as C (or, equivalently, the machine code representation of that program). The usefulness of a computer is in the COMPUTE stage, when the computer performs a task so that we do not need to execute it ourselves. Systems requiring two-way data exchange (such as a search engine, which alternates between taking queries and returning results) can be seen as a series of input-computeoutput operations. We do not discuss parallelism and concurrency, but restrict our discussion to an input-computeoutput problem analogous to a batch processing command. The idea of a chemical computer is appealing: somehow encode the task in a solution of input molecules, place them in solution with the computational molecules, and find the result in the set of extractable output molecules. Molecular computing is massively parallel there is potential for billions of reactions to take place at the same time in a single container. For example, in DNA computing (Păun et al., 1998; Lee et al., 2004; Adleman, 1994), the setup function consists of encoding a problem in fragments of DNA. The computation occurs in vitro, in parallel, and without external interference. The output function often consists of using gel electrophoresis to extract and sequence DNA of a particular weight, which we know to encode a useful response. Importantly, the information is embodied – it is represented as a sequence of DNA that is processed via the laws of physical chemistry. This paper compares two embodied computers. The first is a small theoretical novel computer, Bindworld, in which simple “atoms” bind with each other to form complexes. The second is a larger, implemented novel computer, Stringmol, in which long RNA-like sequences interact according to their embedded programs. We use the comparison to highlight the challenges and tradeoffs involved in designing a novel embodied computer. It is important to emphasise the role of the molecules-asprograms in terms of their computing power. To demonstrate the importance of reactions within a chemical computation, we briefly describe some theoretical work based on the concept of complementary binding of molecules alone. We show the shortcomings of this approach, and extend it to incorporate the concept of reaction between molecules once they have bound together before presenting our experimental implementation of a NOT gate in an artificial chemistry. Stringmol is an artificial chemistry (AC) that is being developed to explore a method of evolutionary computation based on the “RNA-world” model of biology (Gilbert, 1986). This is a computational simulation in which the genome-carrier molecule is composed of the same molecular building blocks as the enzymes that are encoded therein. The system, called Stringmol (Hickinbotham et al., 2010a,b, 2009) abstracts the concept of stochastic mixing and molecular binding and reaction into a tractable model for ALife experiments. The link between computation and open-ended evolution is that both paradigms require that it is possible to generate an unbounded set of possible states. In related work (Clark et al., 2011), we have demonstrated that the sophisticated binding protocols in Stringmol are key to the diversity that the system is capable of producing. Here, we show that binding alone is not a convenient form for com-