Chemical reaction network designs for asynchronous logic circuits

Chemical Reaction Networks (CRNs) are traditionally used to capture the behaviour of inorganic and organic chemical reactions in a well-mixed solution. Recently, a paradigm shift in the scientific community has seen the use of CRNs extend to that of a high-level programming language for molecular computing devices (Cook et al. 2009), where the fundamental computational process differs from conventional digital electronics in that it involves transformation of input chemicals into output via reaction rules, as opposed to processing discrete signals (voltage bands) interpreted as Boolean values. Several digital and analogue circuits (Magnasco 1997; Soloveichik et al. 2008) have been designed in CRNs and their computational power studied (Soloveichik et al. 2010; Chen et al. 2013). It has also been demonstrated in principle that any CRN can be physically realised in DNA (Soloveichik et al. 2010; Cardelli 2010; Chen et al. 2013). CRNs are therefore particularly attractive as a programming language for use in nanotechnology and biomedical applications, where it is difficult to integrate traditional electronics.

Chemical systems can store and process information in several ways. We focus on finite systems of molecules interacting in a well-mixed solution under mass-action kinetics and emulate Boolean circuits by encoding information through molecular concentrations reaching a particular threshold. The computation proceeds by transforming input species concentrations into outputs according to the reactions of a finite CRN. It is known that the computational power of CRNs is affected by the choice of the semantics, deterministic or stochastic. In particular, assuming a small probability of error, (finite) stochastic CRNs have been shown to be Turing universal (Soloveichik et al. 2008). The deterministic semantics interprets the reactions as a system of differential equations, which describe the evolution of the system as a vector of real-valued species concentrations over time (Chen et al. 2013). The stochastic semantics, on the other hand, views the state of the system as a vector of (non-negative) integer molecular counts and state transitions as a reaction which has a non-zero probability of occurring (Cook et al. 2009). The stochastic evolution of the system over time is obtained as a solution of the Chemical Master Equation (CME) (Kampen 1992). It is well known that the deterministic semantics is not accurate for small populations. While the stochastic semantics is exact, it is infeasible for large molecular counts. One scalable alternative is the Linear Noise Approximation, which is a real-valued approximation of the CME (Cardelli et al. 2015). The correctness of the behaviour of a circuit described by a finite CRN can be analysed by inspecting its stochastic and deterministic evolution over time. In addition, techniques such as model checking can be employed to analyse the temporal ordering of events.

While CRN designs for synchronous sequential logic circuits have been proposed, to mention (Magnasco 1997; Soloveichik et al. 2010, 2008), a physical realisation of these devices is challenging because of their reliance on a clock to synchronise events in order to ensure the correct temporal order of the phases of the computation. Clocks are difficult to make, since they arise from unique conditions of chemical concentrations and kinetic constants, and must control a large number of events. In electronics, an alternative circuit design technology is asynchronous sequential logic (Spars and Furber 2002; Myers 2004), which instead of a clock relies on handshaking protocols to synchronise events. Asynchronous circuits are widely used for low-power microprocessor designs, e.g., by ARM, though require a larger circuit area. The key component is the Muller C-element, which is used to synchronise multiple independent processes in a manner insensitive to the delays on wires and individual components. To ensure Turing completeness of asynchronous circuits, we also require an isochronous fork in addition to the Muller C-element. An isochronous fork is a component which produces a fan-out of signals that reach the target at virtually the same time. This assumption is difficult to achieve in conventional electronics, because of the need to make the wires the same length, but is straightforward in chemical kinetics because of the well-mixed assumption.

This paper provides novel CRN designs for the construction of an asynchronous computing device based on a bi-molecular reaction motif inspired by the Approximate Majority network (Angluin et al. 2008; Cardelli and Csikász-Nagy 2012). The motif employs catalytic reactions to achieve bistable switching of molecular concentrations, which emulates high and low voltage signals in digital electronics. All components are produced with simple reactions and uniform reaction rates, where we assume a well-mixed solution under mass action kinetics, and are independent of a universal clock. Moreover, any design provided in this paper could in principle be realised as a DNA strand displacement device (Cardelli 2010). We work with the dual-rail design methodology and employ a variant of the diagrammatic language of Cardelli (2014) to represent the designs at the high level. Starting from the Muller C-element, we design the main components of a complete asynchronous computing device in terms of CRNs in a principled way, including logic gates, control flow and basic arithmetic, as well as more complex structures such as queues. We validate the designs by exploring their time evolution for all possible combinations of inputs using Microsoft’s Visual GEC tool,¹ with the latter also approximated using an experimental implementation of the Linear Noise Approximation (LNA) of Cardelli et al. (2015) provided by Visual GEC that offers better scalability. We use the LNA to highlight a flaw with a key design component. Further, we demonstrate the correct behaviour of the circuits against temporal logic specifications with the probabilistic model checker PRISM² (Kwiatkowska et al. 2011). Our designs constitute the first feasible implementation of asynchronous computational components as CRNs, and are relevant for a multitude of applications in synthetic biology and biosensing.

This paper is an extended version of the conference paper Cardelli et al. (2016).

The computational power of Chemical Reaction Networks, viewed as a programming language for engineering biochemical systems, has been studied by a number of authors, to mention Cook et al. (2009) and Chen et al. (2013). There are a number of ways in which chemical systems can encode and process information. This includes simulating Boolean circuits, where information is encoded in binary form using high and low concentrations similarly to this paper, e.g. Magnasco (1997), Soloveichik et al. (2010) and Soloveichik et al. (2008), as well as geometric arrangements, for example self-assembly (Rothemund et al. 2004) and molecular walkers (Dannenberg et al. 2015) not considered here. Researchers have also investigated the power of CRNs to model distributed algorithms (Angluin et al. 2008).

Regarding synchronous logic circuits, much of the work to date considered abstract CRN schemes. One exception is Silva and McClenaghan (2004), where a system of actual chemical reactions is given, together with a precise molecular implementation for gates complete with a thermodynamic analysis of how the system would evolve, though only for simple gate designs. In Cook et al. (2009) we see the construction and composition of simple logic gates based upon catalytic reactions, but they do not mention control flow or systematic component design in a dual rail setting. In Senum and Riedel (2011) the authors propose CRNs for an inverter, an incrementer, a decrementer and a copier; their designs are based on two rate constants, “fast” and “slow”, and thus are not rate-independent, in contrast to the designs presented here.

CRNs can also be viewed as computing functions over reals or Booleans. A single CRN computes a function over a finite domain, which is analogous to Boolean circuits in the sense that any given circuit computes only on inputs of a particular size (Soloveichik et al. 2008). An implementation of dual-rail logic gates that are rate-independent is given in Chen et al. (2014). In contrast, our designs are composable and capable of performing non-trivial computation.

Since the behaviour of CRNs is asynchronous, a fact evident through their equivalence with Petri net models (Cook et al. 2009), the main difficulty with programming them is the need to control the order of reactions. In Cook et al. (2009) it is suggested that this “uncontrollability” can be handled by changing rate constants, an idea followed up in Napp and Adams (2013), where CRN designs for basic arithmetic are given based on two rate constants, “fast” and “slow”. Our designs, on the other hand, exploit the asynchrony of the underlying CRN model and work with uniform rates.

Designs for the Muller C-element, though not the remaining components of an asynchronous device, have been constructed from genetic logic gates (Nguyen et al. 2010) and a genetic toggle switch (Nguyen et al. 2007), but we are not aware of any other nanoscale designs for asynchronous circuits. Soloveichik et al. (2010) shows that any CRN, including those presented in this paper, can theoretically be implemented as a DNA Strand Displacement device. These devices have been demonstrated in the lab (Qian and Winfree 2011, 2011; Chen et al. 2013), and thus provide an indication of experimental feasibility of our designs.

In this section we present our dual-rail designs for an asynchronous computing device in CRNs. The key component is the Muller C-element, whose design is inspired by the well known Approximate Majority (AM) CRN (Angluin et al. 2008). We begin by providing a detailed justification for our C-element design, and then describe the remaining simple components, including latches, logic gates and control flow. Finally, we present complex circuits such as the pipeline, queue and adder.

To justify the designs, we demonstrate that each component we design exhibits correct behaviour. Considering as an example the C-element, this amounts to working with an informal specification of the C-element in terms of high/low signals as in Fig. 5, and then showing that our (continuous) CRN empirically satisfies that specification according to appropriate thresholding for high/low signals, as normally done in electronics for transistor logic. To this end, we explore the time evolution of the components under the deterministic and stochastic semantics, including also LNA for scalability. We additionally employ probabilistic model checking with PRISM, where temporal logic is used to express the temporal ordering of events. We remark that, although we validate the components for all possible input configurations, this does not amount to full verification of the correctness of the designs. We discuss the challenges of achieving full verification in Sect. 6.

4.1 Muller C-element as a CRN

The C-element design is based on the AM CRN, which computes the majority of two finite populations by converting the minority population into the majority population, so that a single population emerges as output. It uses a third ‘undecided’ state of the population, from where catalysis can drive the individuals into either of the final states. Interestingly, since approximate majority cannot be exactly computed by a bi-molecular CRN with less than 4 reactions (Mertzios et al. 2014), below we present the bi-molecular AM CRN with exactly four reactions:

$$\begin{aligned} X + Y \rightarrow X + \lambda \\ Y + X \rightarrow Y + \lambda \\ X + \lambda \rightarrow X + X \\ Y + \lambda \rightarrow Y + Y \end{aligned}$$

where X, Y are both the input and output species and \(\lambda\) is the aforementioned catalytic driver. The intuition behind this reaction network is that we have two competing initial populations of X and Y, both of which try to eliminate the other by transforming their counterpart into the intermediary \(\lambda\). If \(\lambda\) then interacts with X, it transforms itself into X, else into Y. Presented below in Fig. 7a is the same AM CRN in our diagrammatic notation.

Open image in new window

Deconstructed, if we consider the left-hand side of the diagram, the reaction \(X \rightarrow \lambda\) is catalysed by the species Y and so yields the bi-molecular reaction \(Y + X \rightarrow Y + \lambda\). Similarly, X catalyses the reaction \(\lambda \rightarrow X\) in the other direction and yields the reaction \(X + \lambda \rightarrow X + X\). On the right-hand side of the diagram, \(\lambda\) is again catalysed by X and Y to produce Y, yielding the other two reactions from the AM CRN. The CRN in Fig. 7b, with inputs X and Y and outputs W, Z, is similar to the AM CRN, except that we produce new arbitrary outputs W, Z instead of producing greater quantities of X and Y.

Since we wish to apply the dual-rail methodology, we represent each signal as a pair of species and encode the value 1 (0) as a molecular population of at least M for some population threshold M (population 0). We thus present in Fig. 8a a dual-rail CRN which computes approximate majority with four inputs \(X_{hi}, X_{lo}, Y_{lo}, Y_{hi}\) and outputs \(Z_{hi}, Z_{lo}\). Like before, our input catalyses an intermediary species \(\lambda\), but this is split over two reactions. In addition, \(Z_{lo}\) and \(Z_{hi}\) catalyse with reactions \(Z_{lo} \leftrightharpoons \lambda\) and \(Z_{hi} \leftrightharpoons \lambda\). This has the effect that, if there are larger numbers of either \(Z_{lo}\) or \(Z_{hi}\), the network enlarges its majority by converting the other into \(\lambda\). Two rounded arrows

Open image in new window

over a reaction (\(\uparrow\)) indicates that either species can act as a catalyst to that reaction. We demonstrate this AM effect in Fig. 8b, where, given the initial configuration of inputs \(X_{lo}, Y_{lo}\) of 10 molecules and output \(Z_{hi}\), we observe under deterministic semantics that, because \(|X_{lo}|, |Y_{lo}| > |X_{hi}|,|Y_{hi}|\), an output of \(Z_{lo}\) where \(|Z_{lo}| = 10\) molecules and \(|Z_{hi}| = 0\) is produced after 0.5 s.

Open image in new window

We now need to justify the correctness of the design against the C-element specification in Fig. 8a. Given a starting configuration of input X, Y both 1, and any starting output, the C-element should eventually output 1. Similarly, if X, Y are both 0, on any initial output our final output should be 0. For any other configuration of X, Y, the output signal should remain the same. Thus, given an input \(X_{hi},Y_{hi}\), and crucially any starting output configuration Z, we wish to reach a state where \(Z_{hi}\) has at least M molecules where M is a population threshold, and \(Z_{lo}\) has 0 molecules. Similarly, for \(X_{lo}, Y_{lo}\) and any Z we should to see a presence of \(Z_{lo}\) after some time t. For all other configurations of the inputs we wish the output species to remain the same.

When validated against this informal specification with a starting configuration of \(X_{lo}, Y_{hi}\) at 10 molecules and \(Z_{hi}\) at 10 molecules, our CRN unfortunately fails, seen in Fig. 9. More specifically, we observe that species \(Z_{hi}\) is at a concentration of 6 molecules and \(\lambda\) has a concentration of 4 molecules after 0.3 s. This simulation was produced using LNA, see Sect. 3.1, which outputs standard deviation of the mean concentrations of species, seen in the shaded regions. This output configuration is incorrect since \(Z_{hi}\) is below the required threshold, see Sect. 3.1, of 8 molecules to represent an output of \(Z = 1\).

Open image in new window

We present an amended CRN that resolves this issue in Fig. 11a. This CRN is composed of two approximate majority circuits connected to each other, with the outcome of the first AM amplifying the outcome of the second. As we can see from the plot in Fig. 9, we need to amplify the \(Z_{hi}\) species and suppress the \(\lambda\) species. The second AM corrects exactly this issue. Figure 11b is a simulation with inputs \(X_{lo}, Y_{hi}\) at 10 molecules and output \(Z_{hi}\) at 10 molecules. Here we can see that all three species are now at 10 molecules throughout the duration of the simulation.

To strengthen the validation of the final C-element design, we provide two further plots for selected initial configurations. We include in Fig. 11c a deterministic plot with starting configuration of input \(X_{lo}, Y_{lo}\) at 10 molecules and output \(Z_{hi}\) at 10 molecules. After 1 s the system converges to output \(Z_{lo}\) at 10 molecules. Figure 11d shows an LNA simulation with starting configuration of input \(X_{hi}, Y_{hi}\) at 10 molecules and output \(Z_{lo}\) at 10 molecules. After 1 s we reach output \(Z_{hi}\) with probability \(\approx\) 1. Both these simulations show that our output changes if both inputs change. From Fig. 11b we observe that the output does not change if both inputs are different.

An issue to address is the use of dual-rail systems in which our chemical output is precisely a value of 0 molecules or K molecules, where K is the largest number of molecules achievable by a population in the system. In reality, a species may not reach its maximum population and, due to variance, we may have a situation, as seen in Fig. 9, where one species has moderate probability of being higher than the output species we wish to present. Fortunately, we can use our approximate majority circuit to boost species. Figure 10 shows an example where species \(X_{hi}\) and \(Y_{hi}\) are weak, but the output is boosted by the C-element back to the maximum output of 10 molecules. The gates are also reusable: specifically, in Fig. 11d we can observe the inherent reusability of the C-element because the output reacts to the change in input.

Open image in new window

Open image in new window

4.2 Latch design

A latch is a device used in electronics to store a logical 0 or 1, which therefore needs to have at least two stable states that are cycled between. Latches are used in asynchronous computing both for storage and for synchronisation purposes. When an input of 1 is received a latch will ideally display an output of 1, and likewise for an input of 0. We present two latch designs in Fig. 12, each intended to interface in a specific way when used within a larger system. The first simple latch, shown in Fig. 12a(i), has input \(X_{lo}, X_{hi}\) and output species \(Y_{lo},Y_{hi}\), the intuition being that either \(X_{lo}\) catalyses \(Y_{hi}\) to \(Y_{lo}\) or \(X_{hi}\) catalyses \(Y_{lo}\) to \(Y_{hi}\). There are also two additional reactions that catalyse \(Y_{lo}\) to itself and \(Y_{hi}\) to itself, creating a feedback loop. These additional reactions ensure that, if there is a drop in the molecular concentrations of input species, the latch retains its state. For some larger systems we may need the output state of a latch to be neither \(Y_{lo}\) nor \(Y_{hi}\), to signify that no value is stored within the latch, known as a neutral state in electronics. A reset wire, to reset a latch to neutral state, is also commonly used in circuits. To this end, the latch in Fig.  12a(ii) has an input \(R_{hi},R_{lo}\) used to reset the latch to a central state \(\lambda\), as well as the standard inputs \(X_{hi},X_{lo}\) and outputs \(Y_{hi}, Y_{lo}\). The advantage of this central state, \(\lambda\), is that the latch can be in a state where neither \(Y_{hi}\) nor \(Y_{lo}\) are present, which is useful if these reactions are catalytic to any other component, in which case they will not be triggered directly. A comparison of the behaviour of the two latches is displayed in Fig. 12b, c. With the same initial conditions \(X_{hi}\) and output \(Y_{lo}\) at 10 molecules, the latch in Fig. 12a(ii) produces an output \(Y_{hi}\) at 10 molecules in 0.2 s. We contrast this with the latch in Fig. 12c, which outputs \(Y_{hi}\) at 10 molecules in the slower time of 0.5 s.

Open image in new window

4.3 AM as a control flow element

An arbiter is used to decide an output signal based on which signal arrived first or if one signal is dominant over another. They are used in error correction where a signal may have degraded. Essentially, an arbiter computes the well known function \(max(|X_1|,|X_2|)\) for two inputs. In terms of CRNs, this can be seen as either one species arriving before another or having higher molecular concentration. Since the AM circuit computes the \(max(|X_1|,|X_2|)\) function, as one population is biased over

Open image in new window

another depending upon which has the majority, it therefore serves as an appropriate candidate for an arbiter. The proposed arbiter design, seen in Fig. 13a, is the same as our AM CRN presented in Fig. 8a, except that there are two inputs, \(X_{hi}\) and \(X_{lo}\), and two outputs, \(Y_{hi}\) and \(Y_{lo}\), instead of four inputs. This works as desired since the output \(Y_{hi},Y_{lo}\) begins to be converted from \(\lambda\) as soon as either of \(X_{hi},X_{lo}\) arrives, therefore automatically biasing whichever species is present first. The ability for approximate majority to reach a consensus means that this circuit can deal with stochastic fluctuations in input. Although, within electronic circuits, an arbiter outputs which signal arrived first, we assume that this information is revealed through the promotion of an output species linked to an input species.

In Fig. 13b we demonstrate the operation of this arbiter by LNA simulation on inputs of \(X_{hi}\) at a concentration of 5 molecules and \(X_{lo}\) with a concentration of 0 molecules. After 0.4 s we see \(Y_{hi}\) (in red) at a concentration of 10 molecules, representing the majority.

4.4 Other control flow circuits

Control flow is used to mediate or propagate the flow of information throughout the computing device. In digital circuitry forks and joins, both control flow elements, are naturally implemented using wires. Unfortunately, there is no natural fork or join within CRNs and consequently we present designs for them. The fork, shown Fig. 14a, is used to split signals. It has two input species \(X_{hi}, X_{lo}\) and four output species, \(Y_{hi}(1), Y_{hi}(2)\) to represent the splitting of \(X_{hi}\) and \(Y_{lo}(1), Y_{lo}(2)\) to represent the splitting of \(X_{lo}\). The join, see Fig. 14b, joins two input signals to create one output signal. There are 4 inputs \(X_{hi}(1), X_{hi}(2)\) with output \(Y_{hi}\) to represent the merging of the two input signals and \(X_{lo}(1), X_{lo}(2)\) to merge to an output \(Y_{lo}\).

Open image in new window

4.5 Dual rail asynchronous logic gate designs

Although gate designs for Boolean operators have been proposed in CRNs (Soloveichik et al. 2008), we present dual-rail implementations of logic gates in line with other designs proposed within this paper. In contrast to the gates in Soloveichik et al. (2008), our gates account for all inputs \(X_{hi},X_{lo}\), \(Y_{hi}, Y_{lo}\) and outputs \(Z_{hi}, Z_{lo}\). They are also reusable and respond to changes in input.

The simplest gate, NOT, in Fig. 15a(i), inverts the inputs \(X_{hi}, X_{lo}\) to outputs \(Y_{lo}, Y_{hi}\). The AND-gate, shown in Fig. 15a(iii), has initial concentrations of \(\lambda _1,\lambda _2\) as well as input concentrations. With a presence of species \(Y_{hi}\) we can catalyse \(\lambda _2\) into the state \(\lambda _1\), and with the species \(X_{hi}\) we can catalyse \(\lambda _1\) to \(Z_{hi}\); thus both species are needed for the gate to output the signal \(Z_{hi}\). The state \(Z_{hi}\) catalyses a reaction between species \(Z_{lo}\) and \(\lambda _3\), therefore showing that only one output signal can be present at any time. Conversely, with either \(X_{lo},Y_{lo}\) we can convert \(\lambda _3\) to \(Z_{lo}\), which in turn can convert \(Z_{hi}\) back to \(\lambda _2\) and \(\lambda _2\) to \(\lambda _1\). Using a similar trail of thought we can see how the other gates are devised, with OR (Fig. 15a(ii)) having initial concentrations of \(\lambda _2, \lambda _3\), NOR (Fig. 15a(vi)) having initial concentrations of \(\lambda _2, \lambda _3\) and NAND (Fig. 15a(iv)) having initial concentrations of \(\lambda _1, \lambda _2\). We provide an example, showing a deterministic simulation of the AND gate, seen in Fig. 15b, in which inputs \(X_{hi},Y_{hi}\) at 10 molecules and initial output \(Z_{lo}\) is converted to \(Z_{hi}\) after 0.8 s.

Open image in new window

XOR is slightly different. XOR, traditionally a gate that requires a composition of many other logic gates, has to be constructed with all combinations of inputs considered. The XOR gate (Fig. 15a(v)) has initial concentrations of \(\lambda _1,\lambda _2,\lambda _3,\lambda _4\). In Fig. 16 we show an example validation of the XOR gate for all four input configurations using LNA.

Open image in new window

4.6 Muller C-pipeline

We construct a CRN to emulate the behaviour of the C-pipeline outlined in Sect. 3.2. The pipeline is a mechanism to relay handshakes between components, for example latches to store data. We construct the pipeline by placing three of our C-element CRNs, shown Fig. 11a, in series. At each intermediate stage between the C-elements we add a fork. One path of the fork is negated and fed back into the previous C-element, and the other path is fed into the new C-element. The key interaction between the components of the C-pipeline is that no C-element can output a positive species or negative species without the previous displaying a positive or negative one.

The inputs to the C-pipeline CRN are \(Req_{hi}, Req_{lo}, Acc_{hi}\) and \(Acc_{lo}\). The only output is \(C_{hi}, C_{lo}\), which is the output species of the third C-element. However, for the sake of clarity, we also include four other species \(A_{hi}, A_{lo}\) corresponding to the output of the first C-element and \(B_{hi}, B_{lo}\) corresponding to the second. On an input of \(Req_{hi}\) at 10 molecules we would expect to see that \(A_{hi}\), \(B_{hi}\) and \(C_{hi}\) are all at 10 molecules after a staggered amount of time. If we then changed the input to \(Req_{lo}\) we would expect to see \(A_{hi}\), \(B_{hi}\), \(C_{hi}\) diminish with \(A_{lo}\), \(B_{lo}\), \(C_{lo}\), reaching 10 molecules to reflect the change in input. This is seen as a ‘wave’ through the pipeline propagating a high signal and then a low signal.

We design an experiment, see Fig. 17, where we initialise the pipeline with the input species \(Req_{hi}\) at 10 molecules, and all C-elements are initialized with the intermediary species \(\lambda\) at 10 molecules such that no C-element yet outputs a species. From both the deterministic and LNA simulations of this we can observe how the species \(A_{hi}, B_{hi}, C_{hi}\) approach 10 molecules one after another, showing that indeed the value of \(Req_{hi}\) is being propagated along the pipeline. In order to show that our pipeline design is continuously reactive, we convert all of the species \(Req_{hi}\) to \(Req_{lo}\) via the introduction of a reaction \(Req_{hi} \rightarrow Req_{lo}\). This effect occurs at around 1 s and we can observe that the pipeline responds by reducing the species \(A_{hi}, B_{hi}, C_{hi}\) to a molecular count of 0. We also observe (not shown on the simplified plot) that the species \(A_{lo}, B_{lo}, C_{lo}\) reach 10 molecules at the same time as \(A_{hi}, B_{hi}, C_{hi}\) reach 0 molecules (2 s). The LNA plot reveals that all output species are separated by a significant time difference such that no two species can be conflated.

Open image in new window

In addition to simulation experiments which plot expected concentrations of species over time, we also check temporal properties concerning the interactions between species and components. Using the PRISM model checker we interrogate the CTMC models of the pipeline with specific queries. We give some important examples of such queries in Table 1, which are verified by PRISM as being true with very high probability by checking 20 paths against the property. “Th” refers to the required population threshold which can be set by the user. PRISM also has the ability to track and plot concentrations of species over specific time intervals and number of samples. For example, for the C-pipeline we may wish to focus specifically on species concentrations of the second C-element whilst ignoring the others. We can isolate the species in question starting at a time \(> 0\) and simulating only the species of the second C-element. We demonstrate this property on the pipeline with initial input species \(Req_{hi}\) at 10 molecules in Fig. 18.

Table 1

Temporal properties for the C-pipeline verified by the PRISM model checker. Each property was checked on 20 paths for the pipeline with inputs at 10 molecules

Property in English	Initial condition	PRISM query	Prob. of Success
“Probability that the first C-element always outputs a high signal before the second within 3 s”	\(Req_{hi} > Th\)	\(P=?[(B_{hi} < Th) {\mathcal {U}}^{[0 , 3]}\) \((A_{hi} > Th)]\)	0.97
“Probability that the C-element only changes when both inputs change within 10 s”	(1) \(Req_{hi} Acc_{lo}\) (2) \(Req_{lo} Acc_{hi}\) (3) \(Req_{hi} Acc_{hi}\)	\(P=?[\text {true }{\mathcal {U}}^{[0,10]} Z_{hi} > Th ]\)	0.96
“Probability that the species \(A_{hi}\) reach their maximum population within 10 s”	\(A_{hi} < Th\)	\(P=?[\text {true } {\mathcal {U}}^{[0,10]} A_{hi} >= Th]\)	1
“Probability that request signal is propagated to the end of the pipeline within 10 s”	\(Req_{hi} > Th\), \(A_{hi}> Th\)	\(P=?[F^{[0,10]} C_{hi} > Th]\)	1

Open image in new window

4.7 Queue

We have also designed and validated a queue, the schematic for which is shown in Fig. 19, built by the addition of latches at each C-element block to the Muller pipeline. The queue is used in electronics to regulate and store the flow of information. The asynchronous queue uses the pipeline as a control mechanism to propagate signals between the latches. We use the latch with reset seen in Fig. 12 for this purpose. As the species \(Req_{hi}\) is propagated along the pipeline, it sends a signal to the queue to read and store the value in the next latch along. Each latch represents some computation that could be completed within each time interval.

For the latches of our queue we have input species \(Am_{hi}\) and \(Am_{lo}\) and output species \(Ams_{hi}, Bms_{hi},Cms_{hi}\) representing the output of each latch. Deterministic simulation the queue pipeline is shown in Fig. 19. In this experiment we propagate a 1 (represented as \(Am_{hi}\) at 10 molecules) followed by 0 (\(Am_{lo}\) at 10 molecules). We can observe the species \(Ams_{hi}, Bms_{hi}\), which represent the outputs of the first and second latches, noting an oscillatory pattern of cycling between 1 and 0.

Open image in new window

4.8 Adder

We have also designed a three bit ripple-carry adder, which operates in a similar fashion to the queue but instead of latches we compose adders in series, seen in Fig. 20b. An adder, the circuit design for which is seen in Fig. 20a, is a composition of two XOR gates, two OR gates and an AND gate. The adder produces two outputs, the value of the summation and the carry. Within the ripple-carry adder, the carry output of each adder is fed into the next adder, which outputs the sum and a carry. In this way, with three adders, we can add three two-bit numbers together.

Open image in new window

Our ripple-carry CRN has four input species per adder representing the two inputs, and two output species representing the output. In Fig. 21 we show that the adder exhibits correct behaviour by producing the desired output species for a specific input, where each sum is calculated only in the next stage in the pipeline. If we view each C-element and adder as one stage in the pipeline, labelled A, B and C, then we can view the output species of each adder as a bridge to the next adder. The six output species, representing the carry-bit output, are denoted by \(A_{abridgeOneOut}, B_{bbridgeOneOut}, C_{cbridgeOneOut}\) and \(A_{abridgeZeroOut}, B_{bbridgeZeroOut}, C_{cbridgeZeroOut}\). In order to show correct operation the output of the adders (represented in this case by 10 molecules) should be interleaved with the control species of the C-pipeline (\(A_{hi},B_{hi},C_{hi}\)), allowing time for the carry species to catalyse with the input of the following adder.

Open image in new window

Whilst a simulation provides the intuition behind the ripple-carry adder, using the PRISM model checker we can query the output of all three adders after 10 s to confirm if the correct output is present. We have four input species per adder, excluding the carry, which represent two numbers. We expect one species from each adder as output, representing the addition of two inputs, plus the carry. The third adder relies on the previous adder’s carry being correct. We therefore only need to look at the desired output of each adder plus the carry of the final adder. We summarise this with the following example PRISM property:

$$\begin{aligned}&P =? [ \text { true } U <= 10 ( (A_{abridgeOneOut}> Th) \text { and }\\&(B_{bbridgeZeroOut}> Th) \text { and } ( C_{cbridgeOneOut}> Th) \text { and }\\&(C_{cbridgeCarryOneOut} > Th) ) ] \end{aligned}$$

With this example we can only satisfy these three outputs and the carry, by seeing each of their molecular concentrations rise above the threshold Th, based on a specific input configuration. This particular input are the species representing 0 and 1 for the first adder (for example \(A_{aOneZeroIn}\) and \(A_{aTwoOneIn}\)), the species representing inputs 1,1 for the second adder and 1,1 for the third adder. \(0 + 1\) in the first adder should give us an outcome of 1 carry 0 and so satisfies \(A_{abridgeOneOut} > Th\). \(1 + 1\) plus the 0 carry from the first adder gives an output of 0 carry 1, and so satisfies \(B_{bbridgeZeroOut} > Th\). An input of 1 + 1 plus 1 carry from the second adder means that our output should be 1 as well as the final carry should be 1, represented by \(C_{cbridgeOneOut} > Th\) and \(C_{cbridgeCarryOneOut} > Th\). Our adder satisfies this property based upon the inputs given and therefore shows correct operation for an adder.

All designs³ presented in this paper have been validated using both Microsoft’s Visual GEC tool (Pedersen and Phillips 2009) and the PRISM model checker (Kwiatkowska et al. 2011), both for the deterministic and stochastic semantics of the CRNs. Visual GEC provides a programming language, LBS, for designing and simulating any given CRN. We systematically tested each component in isolation by simulating its behaviour against all input and output configurations. Next, we examined how a component might behave in a larger system, where it will be exposed to a change in input. To this end, we introduced new reactions to emulate a signal change. For instance, if we wished to change a carrier signal from high to low, we would introduce an additional reaction \(X_{hi} \overset{k}{\rightarrow } X_{lo}\), which converts all of the signal \(X_{hi}\) into a signal \(X_{lo}\) while the component is operating.

Since deterministic semantics is not accurate for low molecular populations, we additionally explored stochastic semantics. Visual GEC exports models to the probabilistic model checker PRISM, which then enables verification of the induced continuous-time Markov chain against temporal logic properties. This allows one to check that the circuits ensure the correct temporal ordering of the events, for example, for the Muller pipeline seen in Fig. 6, that the species in the first stage of the pipeline is present before the species in the second, i.e. with probability 1, and that the signal is eventually propagated to the end of the pipeline. PRISM implements numerical solution of the CME, which is exponential in the initial number of molecules and hence not scalable, and analysis based on stochastic simulation, which is time consuming. We thus additionally used an experimental implementation of the LNA within Visual GEC, based on Cardelli et al. (2015). As well as being capable of checking temporal logic properties (Cardelli et al. 2015; Bortolussi et al. 2016), the LNA can plot the species concentration over time together with standard deviation, and is fast and reasonably accurate even for low molecule counts. Moreover, compared to the deterministic semantics, LNA provides important information about stochasticity that may affect the robustness of the circuits, and which can be explored further with CME, stochastic simulation, or verifying that the circuit converges with probability 1 to a single value.

When modelling asynchronous circuits as a chemical system, the wires are chemical species from the output set of one gate component to the input set of another. We cannot bound the time for a gate to transform an input species to an output species. This excludes the class of self-timed circuits. Under deterministic semantics, we could guarantee an isochronous fork since two chemical species, either high or low, could theoretically reach the threshold M at precisely the same time given equal rates and initial concentrations, and therefore under deterministic semantics we have a Turing-complete method of computation. We cannot guarantee this under stochastic semantics (Cook et al. 2009). This is because there is a non-zero probability that one species could reach M before the other. We thus conclude that our circuits, at worst, can be classified as speed independent. We can calculate approximately the delay on wires based upon rates and concentrations for each semantics.

Direct chemical implementations of CRNs have been theorised and realised, but involve complicated reaction mechanisms (Shin 2011). The most common substrate for chemical kinetics is DNA strand displacement (DSD), which involves the displacement of DNA strands in solution. These strands are labelled with the chemical species and, once the reaction has taken place, an outputting strand represents an output from the CRN that the strand displacement system is trying to emulate. DNA strand displacement has been shown to be a universal substrate for chemical kinetics, specifically for bi-molecular reactions used here (Soloveichik et al. 2010). Most importantly, the AM circuit seen in Fig. 8b has been implemented as a strand displacement device (Lakin et al. 2012). However, a potential difficulty with this approach is scalability: as the number of components increases, the number of chemical species representing them also increases. Large numbers of chemical species result in large numbers of DSD complexes in solution, and consequently crosstalk needs to be accounted for. Fortunately, a recent experiment with the implementation of a square-root circuit in solution provided a new experimental ceiling on the number of species that can be used (Qian and Winfree 2011).

Another challenge is to provide formal verification of the correctness of the designs. We remark that, although we have validated the behaviour of the components for all possible input configurations and verified that correct outputs are produced and in the correct order using simulation and simulation-based probabilistic model checking with PRISM, this does not amount to full verification. Asynchronous diagrams are represented using a variety of notations, see Fig. 5, and correspond to certain classes of (safe) Petri nets (Myers 2004) known as Signal Transition Graphs (STGs), representing the rise and fall of signals. Our designs are systems containing many molecules which exhibit stochastic behaviour. Firstly, one would need to show that our CRN designs meet the specification given as a Petri net, which would involve relating the two formally via a refinement relation, where one needs to relate structures with many molecules of a given a species to structures with at most one. This presents us with two major challenges: scalability and stochasticity. Scalability can be addressed using compositional verification, which has been developed for (non-probabilistic) process algebraic specifications of asynchronous circuits (Wang and Kwiatkowska 2007) (equivalent to STGs) and it would be interesting to see if they can be applied in this setting. However, no probabilistic extension of this approach is known. Another possibility is to capture stochasticity by employing stochastic Petri nets to model the designs as done for molecular walkers in Barbot and Kwiatkowska (2015), and then perform temporal logic verification using the tool Cosmos. Cosmos relies on an implementation of statistical model checking that exploits parallelism of the Petri net specifications and achieves greater scalability than PRISM.

We have proposed a novel design for an asynchronous computing device based on Chemical Reaction Networks. CRNs are inherently asynchronous, and thus particularly well suited to this computational paradigm. Our designs are based on a simple, bi-molecular reaction motif inspired by Approximate Majority (Angluin et al. 2008; Cardelli and Csikász-Nagy 2012), employ catalytic reactions and assume well-mixed solution and constant, uniform rates. Moreover, they do not rely on the universal clock which is difficult to realise. Since an arbitrary CRN can be physically realised using DNA strand displacement (Soloveichik et al. 2010), as recently demonstrated experimentally in Chen et al. (2013), the proposed designs are in principle implementable, and we have confirmed this in theory by modelling them in the two-domain setting (Cardelli 2010) using Visual DSD (Phillips and Cardelli 2009; Lakin et al. 2011). Our designs are the first feasible implementation of an asynchronous computing device in chemical kinetics and are relevant for a multitude of applications in nanotechnology and synthetic biology. As future work we would like to investigate alternative experimental settings.