Small Universal Bacteria and Plasmid Computing Systems

Abstract

Bacterial computing is a known candidate in natural computing, the aim being to construct “bacterial computers” for solving complex problems. In this paper, a new kind of bacterial computing system, named the bacteria and plasmid computing system (BP system), is proposed. We investigate the computational power of BP systems with finite numbers of bacteria and plasmids. Specifically, it is obtained in a constructive way that a BP system with 2 bacteria and 34 plasmids is Turing universal. The results provide a theoretical cornerstone to construct powerful bacterial computers and demonstrate a concept of paradigms using a “reasonable” number of bacteria and plasmids for such devices.

1. Introduction

In cell biology, bacteria, despite their simplicity, contain a well-developed cell structure that is responsible for some of their unique biological structures and pathogenicity. The bacterial DNA resides inside the bacterial cytoplasm, for which transfer of cellular information, transcription, and DNA replication occurs within the same compartment [1,2]. Along with chromosomal DNA, most bacteria also contain small independent pieces of DNA called plasmids, which can be conveniently obtained and released by a bacterium to act as a gene delivery vehicle between bacteria in the form of horizontal gene transfer [3].

Bacterial computing was coined with the purpose of building biological machines, which are developed to solve real-life engineering and science problems [4]. Practically, bacterial computing proves mechanisms and the possibility of using bacteria for solving problems in vivo. If an individual bacterium can perform computation work as a computer, this envisions a way to build millions of computers in vivo. These “computers”, combined together, can perform complicated computing tasks with efficient communication via plasmids. Using such conjugation, DNA molecules, acting as information carriers, can be transmitted from one cell to another. On the basis of the communication, information in one bacteria can be moved to another and can be used for further information processing [5,6].

Bacterial computing models belong to the field of bio-computing models, such as DNA computing models [7,8,9] and membrane computing models [10,11,12]. Because of the computational intelligence and parallel information processing strategy in biological systems, most of the bio-computing models have been proven to have the desired computational power. Most of these can do what a Turing machine can do (see, e.g., [13,14,15,16,17,18,19]). The proposed bacterial computing models can provide powerful computing models at the theoretical level but a lack of practical results. Current bacterial computing models are designed for solving certain specific biological applications, such as bacteria signal pathway detecting, but give no result for computing power analysis.

In general bacterial computing models, information to be processed is encoded by DNA sequences, and conjugation is the tool for communicating among bacteria. The biological process is shown in Figure 1.

Looking for small universal computing devices, such as small universal Turing machines [20,21], small universal register machines [22], small universal cellular automata [23], small universal circular Post machines [24], and so on, is a natural and well-investigated topic in computer science. Recently, this topic started to be considered also in the framework of bio-computing models [25,26,27,28,29,30,31].

In this work, we focus on designing small universal bacteria and plasmid computing systems (BP systems); that is, we construct Turing universal BP systems with finite numbers of bacteria and plasmids. Specifically, we demonstrate that a BP system with 2 bacteria and 34 plasmids is universal for computing recursively enumerable functions and families of sets of natural numbers. In the universality proofs, 2 bacteria are sufficient, as in [32], but the numbers of plasmids needed are reduced to about 10 from a possible infinite number. The results provide a theoretical cornerstone to construct powerful “bacterial computers” and demonstrate a concept of paradigms using a “reasonable” number of bacteria and plasmids for these devices.

2. The Bacteria and Plasmid System

In this work, as for automata in automata theory, the BP system is formally designed and defined. In general, the system is composed of three main components:

–

a set of bacteria;

–

a set of plasmids;

–

a set of evolution rules in each bacterium, including conjugation rules and gene-editing (inserting/deleting) rules.

The evolution rules are in the form of productions in formal language theory, which are used to process and communicate information among bacteria. Such a system is proven to be powerful for a number of computing devices; that is, they can compute the sets of natural numbers that are Turing computable. However, in the universality proof, the number of plasmids involved is not limited. It is possible to use an infinite number of plasmids for information processing and exchanging. Such a feature is acceptable (as for the infinite tape in Turing machines) in mathematic theory but is not feasible with the biological facts.

A BP system of degree m is a construct of the following form:

$$\mathrm{\Pi }=(O,b_1,b_2,\dots ,b_m,P,b_{out}),\mathrm{where}\mathrm{the}\mathrm{following}\mathrm{are}\mathrm{true}.$$

• $O=\{g_1,g_2,\dots ,g_n\}$ is a set of genes in the chromosomal DNA of bacteria.
• $P=P_{crispr}\cup P_{temp}\cup \{p_{null}\}$ is a set of plasmids.

  –

  Plasmids in $P_{crispr}$ are of the form $(cas9,gRN{A}_{g_i}^{\alpha })$ with $\alpha \in \{insert,delete\}$, which is used for cutting specific genes.

  –

  Plasmids in $P_{temp}$ are of the form $(gRN{A}_{g_i}^{template})$, which takes templates of genes to be inserted.

  –

  Plasmid $p_{null}$ is of the form $(Pr{o}_{Rap}^{Rel})$ for bacteria conjugation.

• Variables $b_1,b_2,\dots ,b_m$ are m bacteria of the form $b_i=(w_i,R_i)$, where

  –

  $w_i$ is a set of genes over O initially placed in bacterium $b_i$;

  –

  $R_i$ is a set of rules in bacterium $b_i$ of the following forms:

  (1)

  Conjugation rule is of the form $(\mathrm{ATP}-P_c,b_i/b_j,\mathrm{ATP}-P_c^{\prime })$, by which ATP in bacterium $b_i$ is consumed and a set of plasmids $P_c^{\prime }\subseteq P$ associated with ATP is transmitted into bacterium $b_j$.

  (2)

  CRISPR/Cas9 gene inserting rule is of the form $p_i{p}_{s_i}\times (g_j,g_k)$, where $p_i\in P_{crispr}$, $\alpha =insert$, $p_{s_i}\in P_{temp}$, and $g_j$ and $g_k$ are two neighboring genes. The insertion is operated if and only if $g_j$ and $g_k$ are neighboring genes and plasmids $p_i{p}_{s_i}$ are present in the bacterium.

  (3)

  CRISPR/Cas9 gene deleting rule is of the form $p_i\times (g_j,g_k)$ with $p_i{p}_{null}\in P_{crispr}$, $\alpha =detele$, and $g_j$ and $g_k$ being two neighboring genes. The rule can be used if and only there exists gene $g_i$ placed between the two neighboring genes.

• Variable $b_{out}$ is the output bacterium.

It is possible to have more than one enabled conjugation rule at a certain moment in a bacterium, but only one is non-deterministically chosen for use. This is due to the biological fact that ATP can support the transmission of one plasmid but not all of the plasmids. If a bacterium has more than one CRISPR/Cas9 operating rule associated with a certain common plasmid, only one of the rules is non-deterministically chosen for use; if the enabled CRISPR/Cas9 operating rules are associated with different plasmids, all of them will be used to edit the related genes.

The configuration of the system is described by chromosomal DNA encoding the information in each bacterium. Thus, the initial configuration is $\langle (w_1,w_2,\dots ,w_m\rangle$. Using the conjugation and CRISPR/Cas9 rules defined above, we can define the transitions among configurations. Any sequence of transitions starting from the initial configuration is called a computation. A computation is called successful if it reaches a halting configuration, that is, no rule can be used in any bacterium. The computational result is encoded by the chromosomal DNA in bacterium $b_{out}$ when the system halts, where $b_{out}\in \{b_1,b_2,\dots ,b_m\}$ denotes the output bacterium. There are several ways to encode numbers by the chromosomal DNA. We use the number of genes in the chromosomal DNA to encode different numbers computed by the system.

The set of numbers computed by system $\mathrm{\Pi }$ is denoted by $N(\mathrm{\Pi })$. We denote by $NBP(bac{t}_j,pla{s}_k)$ the family of sets of numbers computed/generated by BP systems with m bacteria and k plasmids (if no limit is imposed on the values of parameters m and k, then the notation is replaced by *).

We need an input bacterium to receive genetic signals in the form of short DNA segments from the environment or certain bacteria, as well as an output bacteria, with which the system can compute functions. The input bacterium is denoted by $b_{in}$ with $b_{in}\in \{b_1,b_2,\dots ,b_m\}$. Input bacterium $b_{in}$ can read/receive information from the environment, where information is encoded by DNA segments or a string of genes. When a BP system has both input and output bacteria, it starts by reading/receiving information from the environment through input bacterium $b_{in}$. After reading the input information, the system starts its computation by using the conjugation and CRISPR/Cas9 gene inserting/deleting rules; it then finally halts. The computational result is stored in the output bacterium $b_{out}$ encoded by a number of certain genes.

Mathematically, if the input information is x, which is encoded by DNA segments composed of x genes, when the system halts, bacterium $b_{out}$ holds y genes. It is said that the BP system can compute the function $f(x)=y$. In general, if the inputs are $x_1,x_2,\dots ,x_n$ in the form of DNA strands containing $x_i$ copies of gene $g_i$ with $i=1,2,\dots ,n$, when the system halts, we obtain the computational result y in the output bacterium in the form of y copies of genes. The system is said to compute the function $f(x_1,x_2,\dots ,x_n)=y$.

3. Universality Results

In this section, we construct two small universal BP systems. Specifically, we construct a Turing universal BP system with 2 bacteria and 34 plasmids to compute recursively enumerable functions. As a natural-number computing device, a universal BP system with 2 bacteria and 34 plasmids is achieved.

In the following universality proofs, the notion of a register machine is used. A register machine is a construct of the form $M=(m,H,l_0,l_h,R)$, where m is the number of registers, H is the set of instruction labels, $l_0$ is the start label, $l_h$ is the halt label (assigned to instruction HALT), and R is the set of instructions; each label from H labels only one instruction from R, thus precisely identifying it. The instructions are of the following forms:

• $l_i:($ADD$(r),l_j,l_k)$ (add 1 to register r and then go to one of the instructions with labels $l_j$ and $l_k$);
• $l_i:($SUB$(r),l_j,l_k)$ (if register r is non-zero, then subtract 1 from it, and go to the instruction with label $l_j$; otherwise, go to the instruction with label $l_k$);
• $l_h:$ HALT (the halt instruction).

A register machine M generates a set $N(M)$ of numbers in the following way: it starts with all registers being empty (i.e., storing the number zero) and then applies the instruction with label $l_0$; it continues to apply instructions as indicated by the labels (and made possible by the contents of registers). If the register machine finally reaches the halt instruction, then the number n present in specified register 0 at that time is said to be generated by M. If the computation does not halt, then no number is generated. It is known (e.g., see [33]) that register machines generate all sets of numbers that are Turing computable.

A register machine can also compute functions. In [22], register machines are proposed for computing functions, with the universality defined as follows: Let ${\phi }_x(y)$ be a fixed admissible enumeration of the unary partial recursive functions. A register machine M is said to be universal if there is a recursive function g such that for all natural numbers x and y, it holds ${\phi }_x(y)=M(g(x),y)$; that is, with input $g(x)$ and y introduced in registers 1 and 2, the result ${\phi }_x(y)$ is obtained in register 0 when M halts.

A specific universal register machine $M_u$ shown in Figure 2 is used here, which was modified by a universal register machine from [22]. Specifically, the universal register machine from [22] contains a separate check for zero of register 6 of the form $l_8:$ (SUB(6), $l_0,l_{10}$); this instruction was replaced in $M_u$ by $l_8:$ (SUB(6), $l_9,l_0)$, $l_9:$(ADD(6), $l_{10})$ (see Figure 2). Therefore, in the modified universal register machine, there are 8 registers (numbered from 0 to 7) and 23 instructions (hence 23 labels), the last instruction being the halting instruction. The input numbers are introduced in registers 1 and 2, and the result is obtained in register 0.

3.1. A Small Universal BP System as Function Computing Device

Theorem 1.

There exists a Turing universal BP system with 2 bacteria and 34 plasmids that can compute Turing-computable recursively enumerable functions.

Proof. 

To this aim, we construct a BP system $\mathrm{\Pi }$ with 2 bacteria and 34 plasmids to simulate the register machine $M_u$ shown in Figure 2. The system $\mathrm{\Pi }$ is of the following form:

$$\mathrm{\Pi }=(O,b_1,b_2,P,b_{in},b_{out}),\mathrm{where}\mathrm{the}\mathrm{following}\mathrm{are}\mathrm{true}.$$

• $O=\{g_0,g_1,\dots ,g_7,g_m\}$ is set of genes in chromosomal DNA of bacteria.
• $P=P_{crispr}\cup P_{temp}\cup \{p_{null}\}$ is a set of plasmids shown in

  Table 1. Plasmids in system $\mathrm{\Pi }$.

  Plasmid	Forms of Plasmids	Plasmid	Forms of Plasmids
  $p_0$	$p_0=(cas9,gRN{A}_{g_1}^{delete})$	$p_{16}$	$p_{16}=(cas9,gRN{A}_{g_4}^{insert})$
  $p_1$	$p_1=(cas9,gRN{A}_{g_7}^{insert})$	$p_{17}$	$p_{17}=(cas9,gRN{A}_{g_2}^{insert})$
  $p_2$	$p_2=(cas9,gRN{A}_{g_6}^{insert})$	$p_{18}$	$p_{18}=(cas9,gRN{A}_{g_4}^{delete})$
  $p_3$	$p_3=(cas9,gRN{A}_{g_5}^{delete})$	$p_{19}$	$p_{19}=(cas9,gRN{A}_{g_3}^{delete})$
  $p_4$	$p_4=(cas9,gRN{A}_{g_6}^{delete})$	$p_{20}$	$p_{20}=(cas9,gRN{A}_{g_0}^{insert})$
  $p_5$	$p_5=(cas9,gRN{A}_{g_5}^{insert})$	$p_{21}$	$p_{21}=(cas9,gRN{A}_{g_3}^{insert})$
  $p_6$	$p_6=(cas9,gRN{A}_{g_7}^{delete})$	$p_h$	$p_h=(cas9,gRN{A}_{g_h}^{delete})$
  $p_7$	$p_7=(cas9,gRN{A}_{g_1}^{insert})$	$p_{s_1}$	$p_{s_1}=(gRN{A}_{g_7}^{template})$
  $p_8$	$p_8=(cas9,gRN{A}_{g_6}^{delete})$	$p_{s_2}$	$p_{s_2}=(gRN{A}_{g_6}^{template})$
  $p_9$	$p_9=(cas9,gRN{A}_{g_6}^{insert})$	$p_{s_5}$	$p_{s_5}=(gRN{A}_{g_5}^{template})$
  $p_{10}$	$p_{10}=(cas9,gRN{A}_{g_4}^{delete})$	$p_{s_7}$	$p_{s_7}=(gRN{A}_{g_1}^{template})$
  $p_{11}$	$p_{11}=(cas9,gRN{A}_{g_5}^{delete})$	$p_{s_9}$	$p_{s_9}=(gRN{A}_{g_6}^{template})$
  $p_{12}$	$p_{12}=(cas9,gRN{A}_{g_5}^{delete})$	$p_{s_{16}}$	$p_{s_{16}}=(gRN{A}_{g_4}^{template})$
  $p_{13}$	$p_{13}=(cas9,gRN{A}_{g_2}^{delete})$	$p_{s_{17}}$	$p_{s_{17}}=(gRN{A}_{g_2}^{template})$
  $p_{14}$	$p_{14}=(cas9,gRN{A}_{g_5}^{delete})$	$p_{s_{20}}$	$p_{s_{20}}=(gRN{A}_{g_0}^{template})$
  $p_{15}$	$p_{15}=(cas9,gRN{A}_{g_3}^{delete})$	$p_{s_{21}}$	$p_{s_{21}}=(gRN{A}_{g_3}^{template})$
  $p_{null}$	$(Pr{o}_{Rap}^{Rel})$	$p_{s_h}$	$p_{s_h}=(Pr{o}_{Rap}^{Rel})$

  , where

  –

  $P_{crispr}=\{p_1,p_2,\dots ,p_{22},p_h\}$, whose elements associated with the labels of instructions are used for gene cutting;

  –

  $P_{temp}=\{p_{s_i}\mid i=1,2,5,7,9,16,17,20,21\}$ are plasmids taking templates of genes to be inserted, which are used for simulating ADD instructions;

  –

  plasmid $p_{null}$ for bacteria conjugation is used for simulating SUB instructions.

• $b_1=(w_1,R_1)$, where $w_1=\lambda$, meaning no initial chromosomal DNA is placed in bacteria $b_1$; the set of rules $R_1$ is shown in

  Table 2. Rules in each bacterium of system $\mathrm{\Pi }$.

  Sim.	Rules	Bac.
  $l_0$	$(\mathrm{ATP}-p_0{p}_{null},b_1/b_2,\mathrm{ATP}-p_0{p}_{null})$	$b_1$
  	$p_0\times (g_1,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_1{p}_{s_1})$, $(\mathrm{ATP}-p_0{p}_{null},b_2/b_1,\mathrm{ATP}-p_2{p}_{s_2})$	$b_2$
  $l_1$	$(\mathrm{ATP}-p_1{p}_{s_1},b_1/b_2,\mathrm{ATP}-p_1{p}_{s_1})$	$b_1$
  	$p_1\times (g_7,g_m)$, $(\mathrm{ATP}-p_{s_1},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$	$b_2$
  $l_2$	$(\mathrm{ATP}-p_2{p}_{s_2},b_1/b_2,\mathrm{ATP}-p_2{p}_{s_2})$	$b_1$
  	$p_2\times (g_6,g_m)$, $(\mathrm{ATP}-p_{s_2},b_2/b_1,\mathrm{ATP}-p_3{p}_{null})$	$b_2$
  $l_3$	$(\mathrm{ATP}-p_3{p}_{null},b_1/b_2,\mathrm{ATP}-p_3{p}_{null})$	$b_1$
  	$p_3\times (g_5,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_2{p}_{s_2})$, $(\mathrm{ATP}-p_3{p}_{null},b_2/b_1,\mathrm{ATP}-p_4{p}_{null})$	$b_2$
  $l_4$	$(\mathrm{ATP}-p_4{p}_{null},b_1/b_2,\mathrm{ATP}-p_4{p}_{null})$	$b_1$
  	$p_4\times (g_6,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_5{p}_{s_5})$, $(\mathrm{ATP}-p_4{p}_{null},b_2/b_1,\mathrm{ATP}-p_3{p}_{null})$	$b_2$
  $l_5$	$(\mathrm{ATP}-p_5{p}_{s_5},b_1/b_2,\mathrm{ATP}-p_5{p}_{s_5})$	$b_1$
  	$p_1\times (g_5,g_m)$, $(\mathrm{ATP}-p_{s_5},b_2/b_1,\mathrm{ATP}-p_6{p}_{null})$	$b_2$
  $l_6$	$(\mathrm{ATP}-p_6{p}_{null},b_1/b_2,\mathrm{ATP}-p_6{p}_{null})$	$b_1$
  	$p_6\times (g_7,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_7{p}_{s_7})$, $(\mathrm{ATP}-p_6{p}_{null},b_2/b_1,\mathrm{ATP}-p_8{p}_{null})$	$b_2$
  $l_7$	$(\mathrm{ATP}-p_7{p}_{s_7},b_1/b_2,\mathrm{ATP}-p_7{p}_{s_7})$	$b_1$
  	$p_7\times (g_1,g_m)$, $(\mathrm{ATP}-p_4{p}_{null},b_2/b_1,\mathrm{ATP}-p_4{p}_{null})$	$b_2$
  $l_8$	$(\mathrm{ATP}-p_8{p}_{null},b_1/b_2,\mathrm{ATP}-p_8{p}_{null})$	$b_1$
  	$p_8\times (g_6,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_9{p}_{s_9})$, $(\mathrm{ATP}-p_0{p}_{null},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$	$b_2$
  $l_9$	$(\mathrm{ATP}-p_9{p}_{s_9},b_1/b_2,\mathrm{ATP}-p_9{p}_{s_9})$	$b_1$
  	$p_9\times (g_6,g_m)$, $(\mathrm{ATP}-p_{10}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{10}{p}_{null})$	$b_2$
  $l_{10}$	$(\mathrm{ATP}-p_{10}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{10}{p}_{null})$	$b_1$
  	$p_{10}\times (g_4,g_m)$, $(\mathrm{ATP}-p_0{p}_{null},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$, $(\mathrm{ATP}-p_{10}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{11}{p}_{null})$	$b_2$
  $l_{11}$	$(\mathrm{ATP}-p_{10}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{11}{p}_{null})$	$b_1$
  	$p_{11}\times (g_5,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_{12}{p}_{null})$, $(\mathrm{ATP}-p_{11}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{13}{p}_{null})$	$b_2$
  $l_{12}$	$(\mathrm{ATP}-p_{12}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{12}{p}_{null})$	$b_1$
  	$p_{12}\times (g_5,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_{14}{p}_{null})$, $(\mathrm{ATP}-p_{12}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{15}{p}_{null})$	$b_2$
  $l_{13}$	$(\mathrm{ATP}-p_{13}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{13}{p}_{null})$	$b_1$
  	$p_{13}\times (g_2,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_{18}{p}_{null})$, $(\mathrm{ATP}-p_{13}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{19}{p}_{null})$	$b_2$
  $l_{14}$	$(\mathrm{ATP}-p_{14}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{14}{p}_{null})$	$b_1$
  	$p_{14}\times (g_5,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_{16}{p}_{s_{16}})$, $(\mathrm{ATP}-p_{14}{p}_{null},b_2/b_1,\mathrm{ATP}-p_{17}{p}_{s_{17}})$	$b_2$
  $l_{15}$	$(\mathrm{ATP}-p_{15}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{15}{p}_{null})$	$b_1$
  	$p_{15}\times (g_3,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_{18}{p}_{null})$, $(\mathrm{ATP}-p_{15},b_2/b_1,\mathrm{ATP}-p_{20}{p}_{s_{20}})$	$b_2$
  $l_{16}$	$(\mathrm{ATP}-p_{16}{p}_{s_{16}},b_1/b_2,\mathrm{ATP}-p_{16}{p}_{s_{16}})$	$b_1$
  	$p_{16}\times (g_4,g_m)$, $(\mathrm{ATP}-p_{s_{16}},b_2/b_1,\mathrm{ATP}-p_{11}{p}_{null})$	$b_2$
  $l_{17}$	$(\mathrm{ATP}-p_{17}{p}_{s_{17}},b_1/b_2,\mathrm{ATP}-p_{17}{p}_{s_{17}})$	$b_1$
  	$p_{17}\times (g_2,g_m)$, $(\mathrm{ATP}-p_{s_{17}},b_2/b_1,\mathrm{ATP}-p_{21}{p}_{s_{21}})$	$b_2$
  $l_{18}$	$(\mathrm{ATP}-p_{18}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{18}{p}_{null})$	$b_1$
  	$p_{18}\times (g_4,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$, $(\mathrm{ATP}-p_{18}{p}_{null},b_2/b_1,\mathrm{ATP}-p_h{p}_{s_h})$	$b_2$
  $l_{19}$	$(\mathrm{ATP}-p_{19}{p}_{null},b_1/b_2,\mathrm{ATP}-p_{19}{p}_{null})$	$b_1$
  	$p_{19}\times (g_3,g_m)$, $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$, $(\mathrm{ATP}-p_{15},b_2/b_1,\mathrm{ATP}-p_{18}{p}_{null})$	$b_2$
  $l_{20}$	$(\mathrm{ATP}-p_{20}{p}_{s_{20}},b_1/b_2,\mathrm{ATP}-p_{20}{p}_{s_{20}})$	$b_1$
  	$p_{20}\times (g_0,g_m)$, $(\mathrm{ATP}-p_{s_{20}},b_2/b_1,\mathrm{ATP}-p_0{p}_{null})$	$b_2$
  $l_{21}$	$(\mathrm{ATP}-p_{21}{p}_{s_{21}},b_1/b_2,\mathrm{ATP}-p_{21}{p}_{s_{21}})$	$b_1$
  	$p_0\times (g_3,g_m)$, $(\mathrm{ATP}-p_{s_{21}},b_2/b_1,\mathrm{ATP}-p_{18}{p}_{null})$	$b_2$
  $l_h$	$(\mathrm{ATP}-p_h{p}_{s_h},b_1/b_2,\mathrm{ATP}-p_h{p}_{s_h})$

  .
• $b_2=(w_2,R_2)$, where $w_2=g_0{g}_m{g}_1{g}_m{g}_2{g}_m{g}_3{g}_m{g}_4{g}_m{g}_5{g}_m{g}_6{g}_m{g}_7{g}_m$, indicating the initially placed chromosomal DNA in bacterium $b_2$; the set of rules $R_2$ is shown in Table 2.
• $b_{in}=b_{out}=b_2$, which means bacterium $b_2$ can read signals from the environment, and when the system halts, the computational result is stored in bacterium $b_2$.

In general, for each add instruction $l_i$ acting on register $r\in \{0,1,2,3,4,5,6,7\}$, plasmids $p_i=(cas9,gRN{A}_{g_r}^{insert})$ and $p_{s_i}=(gRN{A}_{g_r}^{template})$ are associated; for any SUB instruction $l_i$ acting on register $r\in \{0,1,2,3,4,5,6,7\}$, a plasmid $p_i=(cas9,gRN{A}_{g_r}^{delete})$ is associated in system $\mathrm{\Pi }$. The numbers stored in register r are encoded by the number of copies of gene $g_r$ with $r\in \{0,1,2,3,4,5,6,7\}$ in chromosomal DNA of bacterium $b_2$. Specifically, if the number stored in register r is $n\ge 0$, then bacterium $b_2$ contains $n+1$ copies of gene $g_r$.

During the simulation of register machine $M_u$ by system $\mathrm{\Pi }$, when bacterium $b_1$ holds a pair of plasmids $p_i{p}_{s_i}$ (respectively $p_i{p}_{null}$) and ATP, the system starts to simulate an ADD instruction (respectively a SUB instruction) $l_i$ of $M_u$: plasmids $p_i{p}_{s_i}$ (respectively $p_i{p}_{null}$) are transmitted to bacterium $b_2$ by the conjugation rule; then one copy of gene $g_r$ between neighboring genes $g_r$ and $g_m$ is inserted (respectively deleted) to simulate increasing (respectively decreasing) the number in register r by 1; after this, bacterium $b_2$ sends ATP and plasmids $p_j{p}_{null}$ to bacterium $b_1$ if the proceeding instruction $l_j$ is a SUB instruction or plasmids $p_j{p}_{s_j}$ if the proceeding $l_j$ is an ADD instruction.

Initially, there is no chromosomal DNA initially placed in bacterium $b_1$, but bacterium $b_2$ has genes $w_2=g_0{g}_m{g}_1{g}_m{g}_2{g}_m{g}_3{g}_m{g}_4{g}_m{g}_5{g}_m{g}_6{g}_m{g}_7{g}_m$. At the beginning, the system receives $g(x)$ copies of gene $g_1$ and y copies of gene $g_2$ from the environment through input bacterium $b_2$, which simulates the numbers $g(x)$ and y being introduced in registers 1 and 2 for register machine $M_u$. In this way, the chromosomal DNA of bacterium $b_2$ becomes

$$g_0{g}_m{g}_1^{g(x)+1}{g}_m{g}_2^{y+1}{g}_m{g}_3{g}_m{g}_4{g}_m{g}_5{g}_m{g}_6{g}_m{g}_7{g}_m.$$

Once completing the reading of information from the environment, a pair of plasmids $p_0{p}_{s_0}$ and one unit of ATP is placed in bacterium $b_1$ to trigger the computation; meanwhile no plasmid or ATP is initially contained in bacterium $b_2$. The transition of system $\mathrm{\Pi }$ by reading input signals encoded by $g(x)$ copies of genes $g_1$ and y copies of gene $g_2$ through input bacterium $b_2$ is shown in Figure 3.

In what follows, we explain how system $\mathrm{\Pi }$ simulates ADD instructions and SUB instructions and outputs the computational result.

Simulating the ADD instruction:$l_i:$ (DD(r), $l_j)$.

We assume at a certain moment that system $\mathrm{\Pi }$ starts to simulate an ADD instruction $l_i$ of $M_u$, acting on register $r\in \{0,1,2,\dots ,7\}$. At that moment, bacterium $b_1$ holds two plasmids $p_i{p}_{s_i}$ and ATP, such that the conjugation rule $(\mathrm{ATP}-p_i{p}_{s_i},b_1/b_2,\mathrm{ATP}-p_i{p}_{s_i})$ is used. By using the conjugation rule, plasmids $p_i{p}_{s_i}$ and ATP are transmitted to bacterium $b_2$. In system $\mathrm{\Pi }$, plasmids $p_i$ and $p_{s_i}$ are associated with the ADD instruction $l_i$, where plasmid $p_i$ is of the form $p_i=(cas9,gRN{A}_{g_r}^{insert})$ for cutting a certain site of chromosomal DNA, and $p_{s_i}$ is of the form $p_i=(gRN{A}_{g_r}^{template})$ carrying the gene to be inserted.

In bacterium $b_2$, the CRISPR/Cas9 inserting rule $p_i\times (g_r,g_m)$ is used to insert gene $g_r$ between neighboring genes $g_r$ and $g_m$. In this way, the number of gene $g_r$ of bacterium $b_2$ is increased by 1, which simulates the number in register r being increased by 1. We note that there is a unique position at which gene $g_r$ can be inserted with the context of neighboring $g_r$ and $g_m$.

By using the CRISPR/Cas9 inserting rule, plasmid $p_i$ is consumed, and plasmid $p_{s_i}$ and ATP remain in bacterium $b_2$. The conjugation rule in bacterium $b_2$ is designed by the operation of the proceeding instruction $l_j$. One of the following two cases occurs in bacterium $b_2$.

• If instruction $l_j$ is an ADD instruction, then bacterium $b_2$ has the conjugation rule $(\mathrm{ATP}-p_{si},b_2/b_1,\mathrm{ATP}-p_j{p}_{s_j})$. By using the rule, plasmids $p_j{p}_{s_j}$ and ATP are conjugated to bacterium $b_1$. In this case, system $\mathrm{\Pi }$ starts to simulate the proceeding ADD instruction $l_j$.
• If instruction $l_j$ is a SUB instruction, then bacterium $b_2$ has the conjugation rule $(\mathrm{ATP}-p_{si},b_2/b_1,\mathrm{ATP}-p_j{p}_{null})$, by which plasmids $p_j{p}_{null}$ and ATP are transmitted to bacterium $b_1$. In this case, system $\mathrm{\Pi }$ starts to simulate the proceeding SUB instruction $l_j$.

Therefore, system $\mathrm{\Pi }$ can correctly simulate the ADD instruction of $M_u$. The system starts from bacterium $b_1$ having plasmid $p_i{p}_{s_i}$ and ATP, which are transmitted to bacterium $b_2$ by the conjugation rule. In bacterium $b_2$, the number of gene $g_r$ in chromosomal DNA is increased by 1 using the CRISPR/Cas9 gene inserting rule, and plasmids $p_j{p}_{s_j}$ (if the proceeding instruction $l_j$ is an ADD instruction) or $p_j{p}_{null}$ (if the proceeding instruction $l_j$ is a SUB instruction) are transmitted to bacterium $b_1$, which means that system $\mathrm{\Pi }$ starts to simulate instruction $l_j$.

Simulating the SUB instruction:$l_i:$ (SUB(r), $l_j,l_k)$.

We suppose at a certain computation step that system $\mathrm{\Pi }$ has to simulate a SUB instruction $l_i:$ (SUB(r), $l_j,l_k)$. For any SUB instruction $l_i$, plasmid $p_i$ of the form $p_i=(cas9,gRN{A}_{g_r}^{delete})$ is associated in system $\mathrm{\Pi }$. In bacterium $b_1$, there are plasmids $p_i{p}_{null}$ and ATP such that the conjugation rule $(\mathrm{ATP}-p_i{p}_{null},b_1/b_2,\mathrm{ATP}-p_i{p}_{null})$ can be used. In bacterium $b_2$, it has the following two cases.

–

If there is at least one gene $g_r$ existing between neighboring genes $g_r$ and $g_m$ in chromosomal DNA of bacterium $b_2$ (corresponding to the case that the number stored in register r is $n>0$), then the CRISPR/Cas9 deleting rule $p_i\times (g_1,g_m)$ is used to delete one copy of gene $g_r$ from chromosomal DNA. This simulates the number stored in register r being decreased by 1. By consuming plasmid $p_i$, bacterium $b_2$ retains plasmid $p_{null}$ and ATP such that a conjugation rule $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_j{p}_{s_j})$ or $(\mathrm{ATP}-p_{null},b_2/b_1,\mathrm{ATP}-p_j{p}_{null})$ is used, which depends on whether the proceeding instruction would be an ADD or a SUB instruction. In this way, plasmids $p_j{p}_{s_j}$ or $p_j{p}_{null})$ and ATP are transmitted to bacterium $b_1$. The system starts to simulate instruction $l_j$.

–

If there is no gene $g_r$ existing between neighboring genes $g_r$ and $g_m$ in chromosomal DNA of bacterium $b_2$ (corresponding to the case that the number stored in register r is 0), then the CRISPR/Cas9 deleting rule $p_i\times (g_1,g_m)$ cannot be used, but a conjugation rule $(\mathrm{ATP}-p_i{p}_{null},b_2/b_1,\mathrm{ATP}-p_k{p}_{s_k})$ or $(\mathrm{ATP}-p_i{p}_{null},b_2/b_1,\mathrm{ATP}-p_k{p}_{null})$ is able to be used. Plasmids ($p_k{p}_{s_k}$ or $p_k{p}_{null}$) and ATP are conjugated to bacterium $b_1$, which means the system starts to simulate instruction $l_k$.

We note that when plasmids $p_i{p}_{null}$ are conjugated to bacterium $b_2$ from bacterium $b_1$, it may happen that both the CRISPR/Cas9 deleting rule $p_i\times (g_1,g_m)$ and $(\mathrm{ATP}-p_i{p}_{null},b_2/b_1,\mathrm{ATP}-p_k{p}_{s_k})$ (or $(\mathrm{ATP}-p_i{p}_{null},b_2/b_1,\mathrm{ATP}-p_k{p}_{null})$) can be used. In this case, the CRISPR/Cas9 deleting rule $p_i\times (g_1,g_m)$ will be applied because of the fact that it has priority over the plasmid transferring rule.

The simulation of a SUB instruction is correct: System $\mathrm{\Pi }$ starts from bacterium $b_1$ having plasmid $p_i{p}_{null}$ and ATP and ends with plasmid $p_j{p}_{s_j}$ or $p_j{p}_{null}$ and ATP (if the number stored in register r is $n>0$) to start the simulation of instruction $l_j$; otherwise it ends with plasmid $p_k{p}_{s_k}$ or $p_k{p}_{null}$ and ATP (if the number stored in register r is 0) to start the simulation of instruction $l_k$.

Simulating the halt instruction:$l_h:$ HALT.

When register machine $M_u$ reaches the halt instruction $l_h:$ HALT, the computation of register machine $M_u$ halts. At that moment, bacterium $b_1$ in system $\mathrm{\Pi }$ holds plasmids $p_h{p}_{s_h}$ and ATP, and the conjugation rule $(\mathrm{ATP}-p_h{p}_{sh},b_1/b_2,\mathrm{ATP}-p_h{p}_{s_h})$ can be used. By using the rule, plasmids $p_h{p}_{s_h}$ and ATP are transmitted to bacterium $b_2$; no gene can be edited by plasmid $p_h$, and no rule can be used. Hence, the computation of system $\mathrm{\Pi }$ finally halts.

The number of gene $g_0$ in chromosomal DNA of bacterium $b_2$ encodes the number stored in register 0 of $M_u$. If the number stored in register 0 is $n>0$, then there are $n+1$ copies of gene $g_0$ in chromosomal DNA of bacterium $b_2$. The computational result can be obtained by counting the number of gene $g_0$ in chromosomal DNA of bacterium $b_2$.

From the above description of system $\mathrm{\Pi }$ and its work, it is clear that system $\mathrm{\Pi }$ can simulate each computation of $M_u$. We can check that the constructed system $\mathrm{\Pi }$ has

• 2 bacterium for conjugation with each other;
• 22 plasmids $p_i$ for the 22 ADD and SUB instructions with $i=0,1,2,\dots 21$;
• 9 plasmids $p_{s_i}$ for 9 ADD instructions with $i=1,2,5,7,9,16,17,20,21$;
• 1 plasmid $p_{null}$ for the 13 SUB instructions;
• 2 plasmids $p_h$ and $p_{s_h}$ for the HALT instruction;
• 8 genes $g_i$ for encoding numbers in registers i with $i=0,1,2\dots 7$;
• 1 gene $g_m$ for separating gene $g_i$ in chromosomal DNA.

This gives, in total, 2 bacteria, 34 plasmids, and 9 genes.

This concludes the proof. ☐

3.2. A Small Universal BP System as a Number Generator

In this section, we construct a small universal BP system as a number generator. A BP system ${\mathrm{\Pi }}_u$ is universal if, given a fixed admissible enumeration of the unary partial recursive functions $({\phi }_0,{\phi }_1,\dots )$, there is a recursive function g such that for each natural number x, whenever we input the number $g(x)$ in ${\mathrm{\Pi }}_u$, the set of numbers generated by the system is equal to {$n\in N|{\phi }_x(n)$ is defined}. In other words, after introducing the “code” $g(x)$ of the partial recursive function ${\phi }_x$ in the form of $g(x)$ copies of certain genes in chromosomal DNA of the input bacterium, the BP system generates all numbers n for which ${\phi }_x(n)$ is defined.

System ${\mathrm{\Pi }}_u$ has the same topological structure, plasmids, and evolution rules as system $\mathrm{\Pi }$ constructed in Section 3.1, but the input bacterium is $b_2$ and the output bacterium is $b_1$. Differently from the universal computing devices considered in Section 3.1, the strategy to simulate a universal register machine as a number generator is as follows.

Step 1. The output bacterium $b_1$ initially has n copies of gene $g_m$.

Step 2. System ${\mathrm{\Pi }}_u$ starts by loading $g(x)$ copies of gene $g_1$ and n copies of gene $g_2$ in the input bacterium $b_2$.

Step 3. The computation of ${\mathrm{\Pi }}_u$ is activated by using plasmid $p_0{p}_{null}$ to simulate the register machine $M_u$ from Figure 2, with $g(x)$ stored in register 1, and number n stored in register 2.

If the computation in register machine $M_u$ halts, instruction ${\sigma }_{l_h}$ can finally be activated. To simulate register machine $M_u$ reaching the HALT instruction, system ${\mathrm{\Pi }}_u$ holds plasmids $p_h{p}_{s_h}$ and transmits them to bacterium $b_2$. After this, system ${\mathrm{\Pi }}_u$ halts, as no rule can be used in bacterium $b_2$. When the system halts, the number of gene $g_m$ in the output bacterium $b_1$ is the computational result, which is exactly the number n. Hence, the number n can be computed/generated by system ${\mathrm{\Pi }}_u$.

The difference between systems $\mathrm{\Pi }$ and ${\mathrm{\Pi }}_u$ is the loading input information process. The initial configuration and transition of system ${\mathrm{\Pi }}_u$ by reading input signals encoded by $g(x)$ copies of genes $g_1$ and n copies of gene $g_2$ through input bacterium $b_2$ are shown in Figure 4.

We can check that the constructed system ${\mathrm{\Pi }}_u$ has

• 2 bacterium for the conjugation with each other;
• 22 plasmids $p_i$ for the 22 ADD and SUB instructions with $i=0,1,2,\dots 21$;
• 9 plasmids $p_{s_i}$ for 9 ADD instructions with $i=1,2,5,7,9,16,17,20,21$;
• 1 plasmid $p_{null}$ for the 13 SUB instructions;
• 2 plasmids $p_h$ and $p_{s_h}$ for the HALT instruction;
• 8 genes $g_i$ for encoding numbers in registers i with $i=0,1,2\dots 7$;
• 1 gene $g_m$ for separating gene $g_i$ in chromosomal DNA.

This gives, in total, 2 bacteria, 34 plasmids, and 9 genes.

Therefore, we have the following theorem.

Theorem 2.

There is a Turing universal BP system with 2 bacteria and 34 plasmids that can compute a Turing-computable set of natural numbers.

4. Conclusions

In this work, we construct two small universal BP systems. Specifically, it is obtained that a BP system with 2 bacteria, 34 plasmids, and 9 genes is universal for both computing recursively enumerable functions and computing/generating a family of sets of natural numbers. It is obtained that 34 plasmids are sufficient for constructing Turing universal BP systems. This provides theoretical support as well as paradigms using a reasonable number of bacteria and plasmids to construct powerful bacterial computers.

Following the research line, finding smaller universal BP systems deserves further research. A possible way to slightly decrease the number of plasmids used in small universal BP systems is using code optimization, exploiting some particularities of the register machine $M_u$. For example, as considered in [25], for the sequence of two consecutive ADD instructions $l_{17}$: (ADD$(2),l_{21})$ and $l_{21}$: (ADD$(3),l_{18})$, without any other instruction addressing the label $l_{21}$, the two ADD modules can be combined. However, a challenging problem regards what the minimum size of a universal BP system is—in other words, what the borderline between universality and non-universality is. Characterization of universality by BP systems is expected. A balance between the number of bacteria and plasmids in universal BP systems can be considered, that is, using more bacteria to reduce the number of plasmids.

It is worth developing the applications of BP systems. Bio-inspiring computing models perform well in computations, particularly in solving computational complex problems in feasible time [34,35,36]. It is of interest to use BP systems to solve computationally hard problems. Some specific applications using BP systems would be of interest to researchers from biological fields.

In artificial intelligence, there are many bio-inspired algorithms (see, e.g., [37,38]). It is worth designing bacteria-computing-inspired algorithms or introducing bacteria computing operators in classical algorithms. Additionally, it would be meaningful to construct powerful bacterial computers or computing devices in biological labs.