How Chemistry Computes: Language Recognition by Non-Biochemical Chemical Automata. From Finite Automata to Turing Machines.

Every problem in computing can be cast as decision problems of whether strings are in a language or not. Computations and language recognition are carried out by three classes of automata, the most complex of which is the Turing machine. Living systems compute using biochemistry; in the artificial, computation today is mostly electronic. Thinking of chemical reactions as molecular recognition machines, and without using biochemistry, we realize one automaton in each class by means of one-pot, table top chemical reactors: from the simplest, Finite automata, to the most complex, Turing machines. Language acceptance/rejection criteria by automata can be formulated using energy considerations. Our Turing machine uses the Belousov-Zhabotinsky chemical reaction and checks the same symbol in an Avogadro's number of processors. Our findings have implications for chemical and general computing, artificial intelligence, bioengineering, the study of the origin and presence of life on other planets, and for artificial biology.

Introduction

Computation is everywhere around us (Moore and Mertens, 2011, Rich, 2008) and is central to life on Earth. Computation takes place not only in the myriad of electronic devices we use daily but also in living systems. In life, biochemistry implements computation via the chemical properties of “organic” matter (Conrad, 1972, Katz, 2012), i.e., using chemical support: inputs are chemical substances, the mechanical processing occurs via chemical reaction mechanisms, and the result is chemical before its transduction into specific functionalities, chemical or otherwise.

More specifically, a computation is (Rich, 2008, Katz, 2012) the process by which information in sequences belonging to a language and consisting of “symbols” in an alphabet are fed to a computing device (“automaton”) that recognizes the symbols and is endowed with some rules that allow the automaton to process the symbols according to these rules to eventually deliver an output, such as Acceptance or Rejection of the sequence as belonging or not to the language recognized by the automaton. The pattern of symbols in the sequence is characteristic of the language to which the sequence belongs. We can interpret this process as a metaphor for a chemical reaction or combination of chemical reactions, as one can think of chemical reactions as the result of molecular recognition events that occur precisely, predictably, and repeatably.

Then, we can ask if the power and complexity of biochemistry are necessary to carry out computations using only chemistry. To do so it is useful to recall that languages are classified into an inclusive hierarchy, the Chomsky hierarchy (Rich, 2008, Hopcroft et al., 2007, Chomsky, 1956, Sudkamp, 2006) (cf. Table 1), and that there is a direct correspondence between language complexity and the capabilities of the automata that recognize the language. The most powerful automata are the Turing machines (Turing, 1936).

Table 1

The Chomsky Hierarchy

Grammars	Languages	Accepting Automata
Type 0 grammars, phase-structure grammars, unrestricted grammars	Recursively enumerable	Turing machine, Non-deterministicTuring machine
Type 1 grammars, context-sensitive grammars	Context-sensitive	Linear-bounded automata (Bounded tape-length Turing machine)
Type 2 grammars, context-free grammars	Context-free	One-Stack Pushdown Automata
Type 3 grammars, regular grammars, left-linear grammars, right-linear grammars	Regular	Deterministic FiniteAutomata, Non-deterministic FiniteAutomata

Languages are generated by grammars. By gradually imposing restrictions on them (Hopcroft et al., 2007), grammars are categorized into an inclusive four-level hierarchy, the Chomsky hierarchy. Type-0 are unrestricted grammars and Type-3 the most restricted. Type-1 grammars correspond to Type-1 Languages, which are also called Context Sensitive Languages (CSL). Type-2 and Type-3 correspond to Context Free (CFL) and Regular (RL) languages, respectively. Each class of languages in the Chomsky hierarchy has been characterized as the languages generated by a family of grammars and accepted by a type of machine. The relationships developed between generation and recognition are summarized in this table, which is adapted from p. 338 of Sudkamp (2006). Type 0 and Type 1 grammars are accepted by Turing machines, hence the horizontal line in the Table that separates them from Types 2 and 3.

We answer the aforementioned question by providing non-biochemical realizations of the automata using non-biochemical reactions running in a “one-pot reactor,” that is, in a single well-mixed container where multiple rounds of reactions can take place. We do not need any intermediation from either external geometrical aids to channel and direct the chemical fluids or from reactions involving complex biomolecules. To carry out computations we rely fully on the power of molecular recognition associated with the occurrence of chemical reactions and the robustness provided by an Avogadro′s number of “processors” working simultaneously. For this, we will introduce in our experimental examples the means for the chemical rendering (translation) of alphabet symbols, the chemical copy of the sequence (transcription), a means to feed the sequence (i.e., input the individual symbols), a means to sequentially read the output of the processed sequence, and an autonomous physicochemical indicator to identify the patterns corresponding to sequences in the language recognized by the automaton. After the symbols are fed to the reactor, all the processing and energy used are exclusively chemical. Our purpose is to explore and show how chemical reactions, without using bio-chemistry, reaction-diffusion constructs, or any external auxiliary guidance, do chemical sequence identification in a way equivalent to automata in abstract computations. (We will call this “native chemical computation.”) We will not attempt to establish any theory of the correspondence between reaction complexity and automata.

Chemical computing has an interesting and very rich history, making it impossible to offer here a proper review (for more detailed material cf., e.g., Katz, 2012). We will only highlight a few of its many key developments as they relate to the work we present here. In the early 1970s, Conrad (1972) studied how information processing in molecular systems differs from electronic digital computing. The concept of a theoretical chemical diode first suggested by Okamoto et al. (1987) was further developed theoretically by Hjelmfelt et al. (1991) to suggest that neural networks and chemical automata could be constructed connecting several chemical diodes. The Turing completeness of chemical kinetics was theoretically studied by Magnasco (1997). The first experimental realization of chemical AND and OR logic gates using reaction-diffusion was achieved by Tóth and Showalter (1995), followed by XOR gates (Adamatzky and Costello, 2002) and counters (Gorecki et al., 2003). Chemical logic gates are indeed still an active area of research (Gentili et al., 2012, Wang et al., 2016) owing to the difficulties associated with linking many gates to carry out more advanced or meaningful computations such as the ones required to Accept/Reject languages in the Chomsky hierarchy (cf. Table 1). Native strictly chemistry-based computation can be argued (Katz, 2012) to occur in life and has been demonstrated in practice using DNA (Adleman, 1994, Benenson, 2009) or the properties of chromatin (Prohaska et al., 2010, Bryant, 2012). The computational power of DNA has also been studied theoretically (Soloveichik et al., 2010). In summary, most artificial approaches to chemical computing, inspired by living systems, focus on reaction-diffusion systems mostly representing logic gates or use complex biomolecules to solve very specific problems. Finally, an example of a purely chemical, one-pot, non-reaction-diffusion Turing Machine (Turing, 1936) implemented using the Belousov-Zhabotinsky chemical reaction is contained in Pérez-Mercader et al. (2017).

In what follows we demonstrate native “one-pot-reactor” experimental realizations of computations for the recognition of well-known languages at different levels in the Chomsky hierarchy and provide a comparison of the corresponding chemical and abstract automata. We also present a suitable physico-chemical metric to characterize the result of the automaton′s computation.

Results and Discussion

Methodology Used to Implement One-Pot Native Chemical Computation

The input to be computed is represented by a sequence of symbols from a chemical alphabet in which each letter corresponds (is translated) to a certain constant amount, or aliquot, of a carefully chosen reacting chemical species. The input is added aliquot after aliquot to a one-pot reactor at constant time intervals (Pérez-Mercader et al., 2017).

The processing of each letter (which is exclusively carried out by chemistry) consists of its chemical species selectively activating specific pathways (Dueñas-Díez and Pérez-Mercader, 2019) in a chemical reaction mechanism and, correspondingly, altering the extent of reaction in a systematic way. Every symbol is allotted a common time interval for processing before adding the next symbol. This interval was experimentally selected on the basis of transient dissipation. Finally, the output of the computation is in the form of a distinct chemical response; that is, for a given automata/language combination, the chemical behavior associated with rejected sequences is different from the chemical behavior associated to accepted sequences or “words in the language of the automaton” (Pérez-Mercader et al., 2017) (cf. Figure 1). The Result of the computation are reaction-generated signatures that do (Accept) or do not (Reject) match a predetermined language and automaton-dependent physico-chemical pattern. Naturally, we expect that such distinct chemical responses correspond to some distinct thermodynamic signatures as well as pathways (Dueñas-Díez and Pérez-Mercader, 2019).

Figure 1

Schematics of Language Recognition by a Chemical Automaton

The chemical automaton comprises three subsystems: (1) a well-mixed reactor where computation takes place; (2) an input scheduler that feeds sequentially the translation into chemical aliquots of the input word letters, one symbol at a time with an individual processing time τ; and (3) a monitoring system to record and follow the automaton′s response as a chemical metric. The chemical automaton produces distinct chemical signatures for accepted and rejected inputs (cf. Figures 2 and 4). Just as its abstract counterpart, the chemical machine can reject strings during computation or at the end of computation.

Figure 2

Experimental Recognition of Words in L1 and L2 by a Chemical Finite Automaton and a Chemical One-Stack Pushdown Automaton, Respectively

In our realization of an FA (cf. Figure S1), the chemical signature for an accepted word in L1 is the formation of a white AgIO3 precipitate: sequence “aab” is accepted (A, top), whereas sequence “aaa” (A, bottom) is rejected. The chemical signature for an accepted word in L2 by our realization of a one-stack PDA is that the pH lies above or at the midpoint during the computation and exactly at the midpoint at the end of computation: sequences ()()(), (())(), and ((())) are all accepted (see plots Ba to Bc), whereas sequences)()()( and ())()) are rejected upon reading the first and third symbol, respectively, as the pH falls below the midpoint value (see plots Bd and Be). Sequence ()()(( is rejected at the end of computation since the final pH is above the midpoint (Bf). By using an appropriate pH indicator, the chemical computation can be followed also by observing the color.

Figure 4

L3 Language Recognition by the BZ Turing Machine Operating Using a Limited CO2 Production Recipe (Recipe 1)

Thirteen sequences were each processed three times (cf. Figures S3 and S4) by the L3-recognizing chemical machine described in the text. In these experiments, eight strings were not in L3 and five were. (A) shows the completed sequence final frequency f# vs. final distance D# for these input strings. (B) and (C) show the evolution of the redox potential during sequence processing for rejected strings a3b2c2 and a2b3c2 [note how in the latter f# and D# are not on the locus of f(D#)]. (D) and (E) show the same for accepted words a2b2c2 and a3b3c3, which are seen to satisfy f# = f(D#).

Our methodology is the following. First, we choose a specific and well-known language from a level in the Chomsky hierarchy to be recognized by the chemical automaton. We then identify the class of abstract automaton needed to recognize the language. We translate this into specific requirements for the automaton′s chemical reaction mechanism and the nature of the involved chemical species (whether they are reactants, products or intermediates). In turn, the chemical requirements guide us in the appropriate selection of chemicals to represent the symbols in the alphabet. Then, the specific quantitative recipes for the initial conditions and alphabet aliquots are selected taking into account practical experimental realization considerations (for example, so that the chemical reaction monitoring system allows the unimpeded detection of automaton responses). Finally, a comprehensive set of sequences, some belonging to the language accepted by the automaton and others not belonging to the language are tested experimentally.

Automata Hierarchy

As already mentioned, input of information for a computation involves (Rich, 2008, Hopcroft et al., 2007, Brookshear, 1989, Cohen, 1991, Linz, 2012) sequences of symbols (strings) expressing said information in some formal language L using an alphabet Σ. The strings are fed to an automaton that Rejects or Accepts (recognizes) them as words in that language. This result can then be used for subsequent actions or functions. Languages are generated by grammars and they can be classified in a multi-level inclusive hierarchy, the Chomsky hierarchy (cf. Table 1).

Computing automata (Rich, 2008, Hopcroft et al., 2007, Cohen, 1991) consist of at least one “Finite Automaton” (FA), one or more “tapes” and can have one or more “stacks.” The FA is a machine responding to symbols in Σ, assumes a finite number of predetermined states, and produces some specific response depending on tape-supplied input. The tape is a construct through which a problem-sequence of symbols is sequentially fed to the FA. The tape can have specific symbols, such as “#”, to indicate beginning and end of sequence. When required by the nature of L, an FA can be complemented with a “stack” (Oettinger, 1961): another construct endowed with additional rules enabling temporary storage (memory) and retrieval of information during computation.

In correspondence with the languages they accept and their place in the Chomsky hierarchy, automata themselves can be classified into a hierarchy (Rich, 2008, Hopcroft et al., 2007, Brookshear, 1989, Cohen, 1991, Linz, 2012), which is shown in Table 1. The simplest, Finite Automata (FA), recognize Regular Languages. Next up in the hierarchy are one-stack Push Down Automata (1-PDA) recognizing Context Free Languages. At the top of this hierarchy are Turing Machines (equivalent to a PDA with two or more stacks [Minsky, 1961, Minsky, 1967]) which recognize Context Sensitive, Recursive, and Recursive Enumerable Languages.

A Turing machine (TM) is an FA with a finite but potentially unbounded read-write tape and head (Harrison, 1978). Because in general it uses an unbounded tape the TM is a theoretical construction. However, in any actual physical realization of a TM the tape is necessarily bounded (Minsky, 1967) and can, therefore, be built from two stacks (Cohen, 1991, Searls, 2012, Floyd and Beigel, 1994). Such Turing Machines are called Linear Bounded Automata (Harrison, 1978, Searls, 2012) and accept Context Sensitive Languages. (Note that if the tape in this class of Turing machine is limited to n squares of tape then, by suitably enlarging its alphabet to k-tuples, the automata can increase its effective tape size to k×n for any fixed k. Hence the word “linear” in its name [Harrison, 1978].)

Next we provide detailed “one-pot-reactor” experimental realizations for one automaton in each of the above-mentioned automata classes capable of recognizing well-known standard languages in the hierarchy.

Chemical Finite Automaton

Chemistry easily carries out an FA computation. Any elementary bimolecular reaction in an aqueous mediumA + B → C

recognizes a regular language (RL), the simplest languages (Hopcroft et al., 2007, Cohen, 1991). In fact, this reaction recognizes the regular language L of all words with a pattern of at least one a and at least one b (Hopcroft et al., 2007, Cohen, 1991). (Note this does not involve counting or memory.) Before the computation starts, the automaton, a continuously stirred reactor, contains only deionized water (cf. Figure 2). The input string can be chemically transcribed by rendering (translating) the a′s and b′s as aliquots of species A and B. An input string (e.g., “aab”, “baa”, “ab”, “aaabbbb”) is sequentially fed to the reactor from the left, at regular time intervals much longer than the (common) symbol-feed time. The chemical state of the reactor changes accordingly. Words in L will generate chemical C. Thus, the presence of C in the reactor indicates that the machine has Accepted the string and becomes the result of this computation.

A chemical realization of this FA is provided, for example, by the precipitation reaction:KIO

If during the computation a white precipitate of silver iodate is observed, the input string has been Accepted, whereas if at the end of the string the solution is free from precipitate the string has been Rejected (cf. Figure 2A, Transparent Methods Section 1 and Figure S1).

Alternatively, since we do our experiments at constant pressure and temperature, we could look at the enthalpy yield (Dueñas-Díez and Pérez-Mercader, 2019) defined as the ratio of reaction (precipitation) enthalpy at the end of computation to the total enthalpy in the reactants. As expected, we find that any word Not-Accepted by the FA gives , whereas for Accepted words (Dueñas-Díez and Pérez-Mercader, 2019). (Note also that an ON-OFF switch is an FA [Hopcroft et al., 2007] that can be appropriately represented by a straightforward combination of simple reactions.)

Chemical One-Stack Push-down Automaton

Next in the language hierarchy are Context Free Languages (CFL) (Bar-Hillel et al., 1961). These require counting and are recognized by one-stack PDAs: essentially an FA provided with one “stack.” The stack can be used to store and read a string of arbitrary length but can only be modified at its top (think of the stack as a cafeteria tray dispenser [Oettinger, 1961]). Operation “push” adds a new symbol to the top of the stack, and operation “pop” removes a symbol from the top of the stack (Hopcroft et al., 2007, Cohen, 1991). By analogy with its computer science counterpart the chemical realization of a stack requires chemical intermediates acting as the product of one reaction (“push”) and as reactant for other reactions (“pop”). We therefore need a system of multiple reactions that are interconnected through common intermediate chemical species.

A typical CFL is the language L2 of well-balanced bracket-pairs (or Dyck words [Weisstein, 2009]): strings of open “(“ and closed “)” parentheses are well-balanced if during computation the number of “)” never exceeds the number of “(“, and, at the end of computation the number of “(“ equals the number of “)”. The sequences ()()(), ((())), and (()()) are examples of Dyck words.

For a chemical realization of a one-stack PDA parenthesis checker we can use a pH-reaction network (cf. Transparent Methods Section 2). We transcribe the input string so that each “(” is an aliquot of a strong base, such as Sodium Hydroxide, and the “)” is an aliquot of a weak (diprotic) acid, for example, Malonic Acid, with volume selected to neutralize one aliquot of base to the first midpoint (Petrucci et al., 2011). Finally, the beginning and end of expression symbol “#” will be an aliquot of a pH indicator, e.g., Methyl Red for the acid-base system used below (which changes color around the first midpoint).

At the beginning of a computation, the pH-PDA reaction vessel contains deionized water and an aliquot of the pH indicator. As before, an input string is then fed sequentially. This leads to changes in pH whose value we assign to the stack. The pH-PDA will Accept the input string if during the computation the pH ≥ Midpoint-pH but is at Midpoint-pH (empty stack) at the end of computation, i.e., after adding “#”. Conversely, the pH-PDA Rejects an input string if the pH falls below the Midpoint-pH at any stage during computation (excess of “)”, and attempting to “pop” from an already empty stack) or if the pH is larger than the Midpoint-pH at the end of computation (excess of “(“, or the stack is “not empty”) (cf. Figure 2B).

The Result can again be inferred in two different ways, (1) by tracking the evolution of pH as the problem sequence is processed and then comparing this with the midpoint pH value at maximum reaction extent for this automaton/recipe combination or, equivalently, (2) by looking at the enthalpy yield (Dueñas-Díez and Pérez-Mercader, 2019) of the problem sequence. In the latter case we discover that is maximum (Dueñas-Díez and Pérez-Mercader, 2019) and independent of word length for every word accepted by the one-stack PDA.

Chemical Turing Machine (I). Formulation

At the top levels of the language hierarchy are the most complex languages requiring increasingly flexible memory and grammars (Cohen, 1991): Context-Sensitive, Recursive, and Recursive Enumerable Languages (REL). These are recognized by Turing machines, a class of automata containing automata equivalent to a two or more stacks PDA (Hopcroft et al., 2007, Cohen, 1991, Minsky, 1961, Minsky, 1967), including the Linear Bounded Automata (Linz, 2012, Harrison, 1978) (LBA), which, as already mentioned, are a class of Turing machines with predictable memory requirement: the computation uses exclusively the tape cells occupied by the input, and not an unbounded length tape, a clear restriction suitable for physical machines as in the case of our experimental realizations (Minsky, 1967). The two stacks must be in the same automaton and interact. To generalize from a one- to a two-stacks chemical PDA we can chose a chemical system with at least two interdependent chemical observables. The necessity to handle non-linearity in the computation (Lloyd, 1992) together with the interrelation among reaction observables point us in the direction of non-linear chemistry and, for example, redox oscillators (Tyson, 1985, Field et al., 1972). During the computation, the instantaneous oscillation frequency, f, and the difference D between the mean of redox potential in each oscillation and its maximum redox potential, will each be in one of two stacks. The non-linear chemical kinetics manifests as a non-linear relationship (f(D)) between f and D (cf. Figure 4A).

A classical textbook example of a Context Sensitive language recognized by Turing machines (Hopcroft et al., 2007, Cohen, 1991) in the Linear Bounded Automaton class, but not by any automaton at the lower levels of the hierarchy, is the language L = {abc, where n ≥ 1} over the three-symbol alphabet Σ = {a,b,c}. This is the language of all strings consisting of n a`s followed by n b′s and n c′s; for example, “abc”, “aabbcc”, “aaabbbccc”, “aaaabbbbcccc”. We chose L as the language for our experimental implementation of a chemical Turing machine.

To implement a chemical Turing machine (Pérez-Mercader et al., 2017) we can use the non-linear oscillatory chemistry in the Belousov-Zhabotinsky (BZ) reaction network, whose major overall process when using malonic acid and sodium bromate (Field et al., 1972) is3BrO

Discovered by Belousov in the early 1950s (Belousov, 1959, Winfree, 1984) when he was trying to find a non-biochemical analog for glycolysis (Ball, 1999), the BZ reaction is arguably the best studied chemical oscillator. Although any other BZ recipe can be used, we will use a standard recipe with ruthenium as catalyst and sodium bromate and malonic acid (MA) as oxidizing and reducing reactants, respectively (cf. Transparent Methods Section 3), all in the presence of an acidic environment provided, in our recipes, by sulfuric acid.

A key aspect in the design and implementation of chemical automata is the selection and assignment of chemicals representing the input alphabet and machine symbols (cf. Transparent Methods Sections 1, 2 and 3). A chemical is adequately assigned if it predominantly enhances a pathway within the reaction mechanism that maps to a distinct, repeatable, and systematic (observable) chemical response. Based on extensive computer simulations (cf. Transparent Methods Section 4) and experimental testing of the BZ system, we identified aliquots of the BZ reactants A (sodium bromate) and B (MA) with symbols a and b in the language, respectively (cf. Supplemental Information section 4). For c, we need a substance acting on the two interrelated stacks differently from A and B. In fact, the reaction′s pH-value provides room for symbol c, which we can render chemically (translate) by using an aliquot of sodium hydroxide C. We can also identify an aliquot of the catalyst (Ru-tris(bpy)) as the begin-end of sequence tape-symbol #. This assignment of alphabet symbols provides a mapping to distinct dominant pathways in the well-known Field-Körös-Noyes (FKN) kinetic mechanism (Field et al., 1972) of BZ (cf. Transparent Methods Section 5, and Figure 3) and leads to distinct dynamical behaviors for the observed redox potential. Finally, each symbol will be processed in the reactor during a common time interval, τ, chosen in our experiments to be 7.5 min, which we found provides ample time for fast reaction transients to dissipate.

Figure 3

Effect of Symbol Aliquots on Dominantly Affected Pathways in the Extended FKN Model of Belousov-Zhabotinsky

In the FKN mechanism shown in the four panels, reactions consuming H+ are shown in blue, reactions producing H+ are shown in green, and reactions that are pH independent are in gray. The colored background areas indicate the predominantly enhanced or diminished pathways by the aliquot symbols, and the tables show the effect on the two key descriptors of the oscillations, f and D. (A) corresponds to bromate aliquots where the light blue pathway is predominantly enhanced; (B) corresponds to malonic acid (MA) aliquots where the purple pathway is predominantly enhanced; (C) corresponds to NaOH aliquots where the red pathways is predominantly diminished; and (D) corresponds to the catalyst aliquots where the orange pathway is enhanced (c.f. Transparent Methods sections 4 and 5).

When the computation starts, the BZ-TM reactor contains only deionized water and a strong acid (sulfuric acid in our recipes). Beginning with “#”, and as the chemical input string is sequentially fed to the reactor, the amplitude and frequency of oscillations vary systematically in a manner (the frequency for each group of oscillations behaves [Tyson, 1985] as ) whereby (cf. Supplemental Information section 6) that depends on the nature and order of the symbols we feed (that is, on the order of the aliquot sequence of a, b, c, or #). During computation, the instantaneous oscillation frequency of the redox oscillator, f, and the difference D between the mean of redox potential in each oscillation and its maximum redox potential (cf. Transparent Methods Section 3), will each “be” in one of two stacks. The non-linear chemical kinetics manifests as a non-linear relationship, f(D), between f and D. We denote the value of f(D) after the processing of the end-of-word symbol # (Hopcroft et al., 2007), by f = f(D). The more a′s the higher the initial frequency upon onset of oscillations; then, as b′s are added, the frequency increases (that is, an element is “pushed” on the stack) and finally, as c′s are added, the frequency decreases (an element is “popped” from the stack) (cf. Figure 4 and Video S1). We also see (cf. Figure 4 and Transparent Methods Section 7) that D functions as a counter for the total number of symbols that have been processed so far.

Video S1. BZ_TM_OperationInTheLaboratory.avi for Figure 4

This video shows the recognition of word “aabbcc” in the BZ-based Turing Machine (cf. Figure 4). Each symbol aliquot (see main text) is added at 7.5-min intervals. Chemical redox potential oscillations in the BZ reaction can be visually followed by the changes of color in the reaction medium between orange (reduced state) and green (oxidized state). Initially the reactor contains deionized water, sulfuric acid, and an aliquot of the ruthenium catalyst as an aqueous solution of Ru (bpy)3, which corresponds with symbol #. This solution is transparent. Aliquot addition is shown in the movie by a filled pipette tip coming from the upper part of the right-hand side of the movie frame. As “a” aliquots are added the redox potential of the solution is displaced and remains at the green oxidized state. Upon the addition of the first “b” aliquot (malonic acid) the reaction starts to oscillate, and additional “b” aliquots accelerate the frequency of oscillations. The “c” aliquots decelerate the frequency of oscillations, and the final symbol “#” (catalyst) decelerates them even further while increasing the amplitude (color range or redox potential range) of oscillations. The features of these final oscillations depend on the complete sequence being tested and correspond in this example to an accepted word.

Chemical Turing Machine (II): Sequence-Word Acceptance or Rejection

With each symbol fed into the reactor, the BZ reaction network is driven through symbol-specific (as already emphasized sequence-dependent) pathways (refs. Dueñas-Díez and Pérez-Mercader [2019] and Transparent Methods Section 5). Thus, as the letter sequence is processed, the reactor produces a specific recipe-dependent and sequence-dependent profile of concentrations of products and intermediates. This affects the extent of reaction and manifests as specific BZ-oscillation frequency/amplitude combinations (cf. Figures 4, S3, and S4 and Video S1). That is, the extent of reaction depends on the order of aliquots in the sequence being fed to the TM reactor, i.e., on the particular word being processed.

The various “out-of-order” signatures for words not in L can be explained as follows. Each symbol has an associated distinct pathway in the reaction network. Hence, if the aliquot added is for the same symbol as the previous one, the pathway is not changed but reinforced. In contrast, when the aliquot is different, the reaction is shifted from one dominant pathway to another pathway, thus reconfiguring the key intermediate concentrations and, in turn, leading to distinctive changes in the oscillatory patterns. The change from one pathway, say 1, to say pathway 2 impacts the oscillations differently than going from pathway 2 to pathway 1. This is what allows the machine to give unique distinctive behaviors for out-of-order substrings (as discussed and shown in Transparent Methods Section 7).

For sequences with symbol order not in L (e.g., “bca”, “abc”, “abccb”, …) our L-specific chemical TM rejects them as soon as the letter in the wrong order is detected by the reaction because they generate distinct dynamic oscillatory profiles, see cf. Figure S3 and Transparent Methods Section 7, which are consistent with the abstract L-specific LBA-TM counterpart (Cohen, 1991). The sequences tested in our experiments not only covered all distinct scenarios leading to a reject, but we also tested “worst-case” sequences, i.e., sequences not recognized but nearest, both abstractly and chemically, to accepted words.

To select the recipe for symbol aliquots we may require, for example, that considered as a function of word length the production in our semi-batch TM-reactor of the final product of the overall BZ reaction, CO2, be minimal (a useful requirement for our experimental realization since produced gas interferes with accurate redox potential monitoring for long n′s). The parabolic curve in Figure 4 displays how for a recipe so selected the two stacks are non-linearly interrelated after the end-of- sequence symbol is processed for words in the machine′s language. However, to provide a physico-chemical understanding of these results we introduce an equivalent presentation of the experimental data that makes more direct the interpretation of the Acceptance/Rejection of words in a language by its chemical TM.

As noted earlier, the reaction extent is sequence dependent. We also know that the frequency and amplitude of the redox oscillations in BZ result from chemical competition between the oxidation and reduction subnetworks (pathways) of the reaction (Zhabotinsky, 1964, Zhabotinsky, 2007). We use this feature to design a more direct and visual method to determine sequence Acceptance or Rejection for the TM we are discussing, which also brings out the physical interpretation of a computation by a chemical TM. With this in mind, we introduce a chemical variable related to the flux of chemicals in the reaction as alphabet symbols are processed during a computation by the specific BZ-reaction/TM combination. Then as the letters in a word go through the BZ-TM, we measure, register, and plot the redox potential as a function of time. Finally, for a fully processed word, we obtain the difference in area swept by the highest redox voltage reached during the processing of the letters in the word and the area subtended by the redox potential profile during only the processing of the “end-of-word” symbol #, but, in order to allow for the decay of “fast” reaction transients, we excluded the first 30 s of this processing. This area, Area(Word), cf. Figure 5, equals the product of the #-processing time interval after fast-transient decay, , multiplied by the free-energy difference between the oxidized and reduced states of the catalyst after the processing of #, i.e., . We note in passing, that the dimensions of this area are those of the action in physics.

Figure 5

Experimental Results and Interpretation of Our Chemical TM Responses before and after Recipe Optimization to a Zero-Slope Line for Words in the TM-L3 Combination, and the Relation between Free Energy and Subtended Area A(Word)

(A)–(C) display the experimental results for the sequences that are accepted or rejected upon processing the “end-of-word” symbol #. (A) is the bivariate [f#, D#] oscillatory description, (B) is the fully equivalent univariate A(Word) oscillatory description, and (C) shows how after tuning the recipe (by increasing the concentration of aliquot “a”) (cf. Transparent Methods and Figures S2 and S5) A(Word) is rendered constant for words in L3. The bottom panel illustrates the graphical definition of A(Word) as the difference between the area swept by the fully oxidized potential (Vmax) and the area encompassed by the oscillations after the end-of-word symbol aliquot is added and processed during time τ′, together with the physico-chemical description and thermodynamic meaning of A(Word). Note how for the optimized recipe the area is constant and independent of string length only for accepted words. Additionally, rejected strings cluster either above or below this constant value, showing how the Area vs. String Length plot clearly discriminates between the machine′s word Acceptance/Rejection regions.

To further optimize the acceptance criteria, using computer simulations of BZ we identified for various aliquot recipes which of them had the most impact on the slope of the Area(Word) vs. string length plot (cf. Transparent Methods Section 6 and Figure S2). Then, we determined experimentally the chemical recipe for the symbols in the alphabet, optimized under the condition that all the words in the language accepted by our TM subtend an area that is independent of the language index n. In other words, cf. Figures 5 and S5, the free-energy difference is the same for all words in the language accepted by the chemical TM. Chemically this is because the changes in the extents of oxidation and reduction cancel each other for words in the language accepted by the BZ-recipe/TM/language combination. For words not in L, the chemical pathways and the degrees to which they are visited during word processing are such that the oxidation and reduction extents do not compensate and, as a consequence, there is an n-dependence in the flux magnitude previously introduced and represented by the value of Area(Word) (cf. Figure 5).

This means that the entropy produced during the processing of the end-of-word symbol for any word in the language accepted by our isothermal chemical Turing machine is such that it compensates in the same amount the internal chemical energy dissipated for every such word and the free energy is, therefore, independent of n. This is not true for words not in the machine′s language. (Note that the methodology to tune the acceptance criteria in terms of constant or linear energy dependence on string length can be extended to other Context-Sensitive languages, specifically the family of languages L = {ab c} for α ≥ 0, β ≥ 0, γ ≥ 0, and n ≥ 1).

Finally, any chemical automaton, as is the case for its abstract counterpart inclusive hierarchy, should recognize languages at its hierarchy level and lower (Motwani et al., 2010). Indeed, the B-Z TM can recognize L (presence of redOx oscillations = Acceptance and no redox oscillations = Rejection) and the Dyck language L (Pérez-Mercader et al., 2017).

Conclusions

Without using any biochemistry or external auxiliary geometrical constructs, only “one pot” inorganic chemistry, we have implemented experimentally strictly native chemical realizations of automata in the classical automata hierarchy: a Finite Automaton, a one-stack Push-Down Automaton, and a Turing machine (in the Limited Bounded Automaton subclass). Each automaton recognizes a well-defined representative language, L, L, and L, respectively.

As in Automata Theory, the computations consist on processing for Acceptance or Rejection by the chemical automaton of chemically transcribed symbols ordered in a sequence belonging to a language at the appropriate level in the Chomsky hierarchy.

The computations are carried out by the molecules of substances recognizing each other while participating in suitable reactions. They use chemical energy and output the results of the computation through unambiguous physico-chemical signatures of the state of the reaction during and at the end of the computation. The information in a sequence (originally digital information) is transcribed into a sequence of chemical aliquots of specific composition and concentration (analog information), which is examined in parallel, molecule by molecule, by the chemical reaction underlying the automaton. The output of this recognition of analog information is digital and consists of either Acceptance or Rejection of the information fed between the Start- and End-of-word symbol depending on whether said information belongs or does not belong to the language associated with the automaton.

Experimental realization of chemical automata poses challenges since, for example, the monitoring system or specific chemical recipes and mode of operation affect the maximum reliably testable string lengths. These limitations can be overcome by aliquot optimization and by running the BZ reaction in a Continuously Stirred Tank Reactor mode, with the input to be computed still fed sequentially at regular intervals, but with a continuous inflow and outflow of the liquid medium to avoid excessive intermediate accumulation and time-dependent dilution effects.

Since only the oscillatory nature of the reaction is involved (in word Acceptance/Rejection) Chemical TMs recognizing L (or other suitable decidable languages) may be designed using three-reactant non-linear chemical oscillators other than BZ, including DNA or other organic oscillators. The ability to implement different instances of automata translates into practical suggestions, including the use of the automata′s chemical output as signals to communicate to the external world the result of a computation using BZ-coupled hydrogels, or feeding the output of one automaton as input to other automata down the line to implement complex information architectures, or to function, for example, as transponders or chemoactivators. These automata use Avogadro′s number of processors and therefore we can expect robustness in their operation. The design methodology for the automaton′s sequence acceptance criteria based on a free-energy measure opens a path to control the energetics of computation (Bennett, 1982). The free energy spent for every word accepted by this isothermal chemical automaton was rendered constant by an appropriate formulation of the chemical recipe associated with the pair machine-language and, for accepted words, the entropy rate offsets the energy dissipation in the same amount.

The implementation of native chemical computation beyond the level of logic gates (which are themselves Finite Automata [Hopcroft et al., 2007]) is usually assumed to require the complexity of biochemistry. However, our results demonstrate that this widely held belief is not true: chemical computation does not necessitate the presence of life-related chemistry. Chemical computation is a property of matter and not exclusive to life. We also note that chemical computation opens the door for the involvement of baryonic matter in computation, a feature shared with quantum computation.

The fact that chemical automata do not require biochemistry has deep implications for many fields, including the origin of life and advanced biomimetic applications, as it shows that information processing by chemistry is not exclusive to biochemistry, and therefore, albeit in a primitive form, chemical information processing could have existed independently of when DNA/RNA-based life or chemistry appeared on Earth. By increasing the number of stacks and the alphabet length a path emerges where the evolution of chemical complexity in habitable (or proto-habitable) environments brings about a transition in chemistry-based computation, from simple FAs to networks of Turing machines and, eventually, to their combination into more powerful molecular computers. That is, a path for the sequential/hierarchical origin of information handling in nature and the transition from non-biochemical to biochemical and extant life-related computation.

Recently, polymerization-induced self-assembly (PISA) of polymersomes using the radicals produced in BZ has been demonstrated experimentally (Bastakoti and Pérez-Mercader, 2017a, Bastakoti and Pérez-Mercader, 2017b) showing how, in a suitable environment, BZ can generate its own polymeric enclosure and a corresponding free-energy gradient. This leads to soft microrobots with an entrapped BZ (or another oscillatory chemistry) running as a wet automaton that controls its own encapsulation with a cargo capable of further specific computations, and, more importantly, meaningful functions. These programmable soft robots are now closer to being built ex-novo in a laboratory.

Limitations of the Study

The maximum input word length that we tested experimentally in our Turing machine setup was limited to about 20 letters because of a variety of factors. These factors include the chosen chemical recipes, dilution effects, reactor operation mode, operating conditions, and monitoring method (gas produced during the reaction in the BZ reaction interferes with the precision of the redox monitoring). Further optimization of the chemical recipes, reactor operation mode, and operating conditions, as well as advances in monitoring methods, can provide means to extend this maximum word length.

Methods

All methods can be found in the accompanying Transparent Methods supplemental file.