Computational nucleic acid devices show great potential for enabling a broad range of biotechnology applications, including smart probes for molecular biology research, in vitro assembly of complex compounds, high-precision in vitro disease diagnosis and, ultimately, computational theranostics inside living cells. This diversity of applications is supported by a range of implementation strategies, including nucleic acid strand displacement, localization to substrates, and the use of enzymes with polymerase, nickase, and exonuclease functionality. However, existing computational design tools are unable to account for these strategies in a unified manner. This paper presents a logic programming language that allows a broad range of computational nucleic acid systems to be designed and analyzed. The language extends standard logic programming with a novel equational theory to express nucleic acid molecular motifs. It automatically identifies matching motifs present in the full system, in order to apply a specified transformation expressed as a logical rule. The language supports the definition of logic predicates, which provide constraints that need to be satisfied in order for a given rule to be applied. The language is sufficiently expressive to encode the semantics of nucleic strand displacement systems with complex topologies, together with computation performed by a broad range of enzymes, and is readily extensible to new implementation strategies. Our approach lays the foundation for a unifying framework for the design of computational nucleic acid devices.

Abstract. We develop a theory of bisimulations for a simple language containing communicating transactions, obtained by dropping the isolation requirement of standard transactions. Such constructs have emerged as a useful programming abstraction for distributed systems. In systems with communicating transactions actions are tentative, waiting for certain transactions to commit before they become permanent. Our theory captures this by making bisimulations history-dependent, in that actions performed by transactions need to be recorded. The main requirement on bisimulations is the systems being compared need to match up exactly in the permanent actions but only those. The resulting theory is fully abstract with respect to a natural contextual equivalence and, as we show in examples, provides an e↵ective verification technique for comparing systems with communicating transactions.

The dynamic behavior of synthetic gene circuits plays a key role in ensuring their correct function. However, our ability to accurately predict this dynamic behavior is limited by our quantitative understanding of the circuits being constructed. This understanding can be represented as a mathematical model, which can be used to optimize circuit performance and inform the design of future circuits. Previous inference methods have used fluorescent reporters to quantify average behaviors over an extended time window, resulting in a static characterization which is a poor predictor of dynamics. Here we present a method for characterizing the dynamic behavior of synthetic gene circuits. The method relies on parameter inference techniques applied to timeseries measurements of cell cultures growing in microtiter plates. We use our method to design and characterize gene circuits in E. coli that provide core functionality for engineering cell behavior at the population level. We arrange 23 biological parts into 9 devices and combine them to construct and measure 9 gene circuits including relays, receivers and a degrader. We demonstrate that the behaviors of simple devices can be modeled dynamically and used to predict the behaviors of more complex circuits. Furthermore, our method allows incremental inference of models as new circuits are constructed, and lays the foundation for iteratively learning dynamic models from data in a scalable manner.

Nucleic acids are a powerful engineering material that can be used to implement a broad range of computational circuits at the nanoscale, with potential applications in high-precision biosensing, diagnostics, and therapeutics. However, nucleic acid circuits are prone to leaks, which result from unintended displacement interactions between nucleic acid strands. Such leaks can grow combinatorially with circuit size, are challenging to mitigate, and can significantly compromise circuit behavior. While several techniques have been proposed to partially mitigate leaks, computational methods for designing new leak mitigation strategies and comparing their effectiveness on circuit behavior are limited. Here we present a general method for the automated leak analysis of nucleic acid circuits, referred to as DSD Leaks. Our method extends the logic programming functionality of the Visual DSD language, developed for the design and analysis of nucleic acid circuits, with predicates for leak generation, a leak reaction enumeration algorithm, and predicates to exclude low probability leak reactions. We use our method to identify the critical leak reactions affecting the performance of control circuits, and to analyze leak mitigation strategies by automatically generating leak reactions. Finally, we design new control circuits with substantially reduced leakage including a sophisticated proportional-integral controller circuit, which can in turn serve as building blocks for future circuits. By integrating our method within an open-source nucleic acid circuit design tool, we enable the leak analysis of a broad range of circuits, as an important step toward facilitating robust and scalable nucleic acid circuit design.

Abstract. Consensus is an often occurring problem in concurrent and distributed programming. We present a programming language with simple semantics and build-in support for consensus in the form of communicating transactions. We motivate the need for such a construct with a characteristic example of generalized consensus which can be naturally encoded in our language. We then focus on the challenges in achieving an implementation that can efficiently run such programs. We setup an architecture to evaluate different implementation alternatives and use it to experimentally evaluate runtime heuristics. This is the basis for a research project on realistic programming language support for consensus.