Mutual annihilation protocol.

In some of the authors’ previous work [26], we proposed a stochastic bacterial system for reconstructing and amplifying a chemical signal constituted of two species A and B. If A is in excess, the signal is logical 1, while an excess of B encodes a logical 0. Desired is a large gap between concentrations of A and B by a mutual annihilation reaction between A and B. Concurrently, the concentrations of both species are amplified by replication reactions.

We show a simulation of the system in two phases: one deterministic growth phase that establishes high concentrations of species A and B with the replication reactions and without the annihilation reaction, and a subsequent stochastic phase that enables the annihilation reaction. The first phase can be defined as follows:

from mobspy import

* import os

A, B = BaseSpecies()

# Replication reactions

A >> 2 * A [1.05 / u.h]

B >> 2 * B [1 / u.h]

# Initial counts

A(1 / u.ml), B(1 / u.ml)

# First phase

S1 = Simulation(A | B)

S1.duration = 3*u.h

S1.volume = 1*u.ml

The second phase is modeled by adding the annihilation reaction to meta-species A and B and creating a new simulation object S2 with the additional reaction. The complete two-phase model S is obtained as the sum of S1 and S2.

# Annihilation reaction

A + B >> Zero [0.1/u.h]

S2 = Simulation(A | B)

S2.duration = (A <= 0) | (B <= 0)

S2.method = ’stochastic’

S2.volume = 1*u.ml

The results (Fig 3) are consistent with what is expected from our previous analysis: Since the second phase is stochastic, there is a non-zero, although small, probability that the concentration of B surpasses that of A and B survives even though it is in a lower concentration than A at the beginning of the second phase.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Simulated dynamics of the Mutual Annihilation protocol [26].

By default, for stochastic simulations, MobsPy plots the runs of each species as well as the mean and standard deviation. The dotted gray line represents the transition from the deterministic only-growth phase to the stochastic annihilation. The species A survives in the majority of the runs.

https://doi.org/10.1371/journal.pcbi.1013024.g003

Bistable gut inflammation detector.

Riglar et al. [27] implemented a system designed to detect intestinal inflammation within the mammalian gut. It is composed of a trigger element and a memory element. The trigger element detects the presence of one of the gut inflammation byproducts (tetrathionate, TTR). The introduction of TTR results in the phosphorylation of TtrS which then triggers a chain reaction that up-regulates the production of Cro. The memory element is based on the interaction of two proteins, Cro and CI, which function as mutual repressors of each other, establishing a state of bistability where either Cro is high and CI low, or vice versa. The chemical species Cro then represses CI, going from a low-Cro high-CI state to a high-Cro low-CI state. After the state transition, the high-Cro low-CI state remains stable even if the inflammation byproduct TTR leaves the system. It returns to a low-Cro high-CI state if CI is added to the system. In MobsPy we define:

The phosphorylation reactions that trigger the production of cro are specified via:

TtrR.phospho >> TtrR.dephospho [5*1e-3*1/u.second]

TtrR.phospho >> Cro + TtrR.phospho [50*0.02*1/u.min]

To simulate the delayed addition of CI, we use a placeholder meta-species Dummy. Starting with an initial count of zero, the Dummy meta-species is set to one during the execution of the simulation, triggering an influx of CI.

One can validate that the introduction of the inflammation byproduct results in the low-Cro state transitioning to a high-Cro state that remains after the event that removes the byproduct. MobsPy’s event syntax uses the keyword with and the Simulation object with the methods event_time for time-based triggers or event_condition for conditional-based triggers. The species concentrations to be set in an event are stated inside the with block, similar to setting initial values.

The simulation (Fig 4) shows that the introduction of the inflammation byproduct (at 25 hours) results in a transition from a low-Cro high-CI state to a high-Cro low-CI state, with the latter state persisting after the inflammation marker removal (at 60 hours). Moreover, the reintroduction of CI results in a transition back to the low-Cro high-CI state (at 80 hours).

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Results obtained from the Bistable Gut Inflammation Detector model.

The exposure of the system to TTR (at 25 hours) shifts the system to a high-Cro state, which remains even after the removal of TTR (at 60 hours). The system only returns to a low-Cro state when introducing CI (at 80 hours).

https://doi.org/10.1371/journal.pcbi.1013024.g004

Phage transmission system.

Pathania et al. [5] studied a bacterial system that utilizes bacteriophages for transmitting antibiotic resistance. In their work, a bacterial population (Donor) secretes phages carrying an antibiotic resistance gene, which infects a bacterial population (Receiver) devoid of such.

Cell duplication was modeled using two distinct resources (R1 and R2). Resources R1 and R2 are consumed for bacterial replication with a faster uptake rate for R1. Further, R1 is also the only resource consumed by a Donor for phage production. The discrepancy in consumption rates leads to the depletion of R1 with only R2 being available afterward.

Like the Mutual Annihilation protocol, this experiment is sectioned into two phases with antibiotics being introduced in the second phase. If Donor species can produce sufficient phages to transmit the antibiotic resistance to the Receiver species, the Receiver species will survive the introduction of antibiotics; otherwise, they die.

In the model, a Phage can bind a dead Receiver, resulting in the loss of a phage. We keep track of dead Receiver species through a reaction transforming a Receiver into Dead.

In the second phase Antibiotics is introduced into the system:

The simulation results (Fig 5) are in accordance with the original work: One observes that the Receiver population has survived the introduction of Antibiotics due to a successful transmission of antibiotic resistance.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Simulation results for the phage communication circuit from Pathania et al. [5].

The gray line separates between the simulation phase dedicated to resource dynamics (S1) and the simulation phase with an antibiotic introduction (S2) Top The resource availability achieved in this model. Resource R1 is consumed faster than R2, resulting in a window of time where mostly R2 is available, and R1 is depleted. Bottom Resulting infection progress. Only infected Receiver species remain.

https://doi.org/10.1371/journal.pcbi.1013024.g005

Synchronized cycles of bacterial lysis.

Omar Din et al. [28] designed a bacterial system for in vivo drug delivery through the synchronized death of a bacterial population. Each bacterium produces N-acyl homoserine lactone (AHL) and secretes it into the medium. Consequently, the concentration of AHL increases as the number of bacteria increases. If the concentration of AHL passes a threshold, it triggers a lysis process via quorum sensing that kills most of the bacterial population, leaving only a slim fraction compared to its pre-lysis size. This process creates a cyclic behavior.

Model-wise, meta-species LuxI is a protein that dictates the secretion rate of AHL by a cell. Meta-species Lysis models the intracellular enzyme responsible for the lysis process. This enzyme inhibits peptidoglycan biosynthesis [29], causing cellular death. The production of Lysis increases as a consequence of an increase in the AHL concentration. Bacterial cells are modeled by the meta-species Cell.

The BCRN does not exclusively use mass-action-kinetic reaction rates. In MobsPy this can be expressed by Python functions that return expressions that include reactants (see the following example). Such expressions are compatible with units and checked for consistency.

Omar Din et al. [28] experimentally showed that the number of cells oscillate over time, which is reproduced by the above model (Fig 6).

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Simulation results of the quorum sensing circuit by Omar Din et al. [28].

The simulation shows a synchronized lysis of bacteria. As the AHL levels and population size increase, eventually, a threshold is reached, and the lysis process starts killing the majority of the population. The cycle then repeats.

https://doi.org/10.1371/journal.pcbi.1013024.g006

Logical XOR gate.

Tamsir et al. [11] implemented an XOR gate across three bacterial colonies, each colony functioning as a NOR gate (Fig 7). In the BCRN model, the XOR and NOR gates take the concentration of two species as inputs and produce another species as output. NOR gate C1 takes inputs Ara and aTc, outputting AHL. NOR gates C2 and C3 both take AHL as input, with C2’s second input being Ara and C3’s second input being aTc. The outputs of C2 and C3, named OC12, serve as input for a buffer that outputs yellow fluorescent protein YFP.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. Left schematic of the XOR gate implementation [11].

Right Truth table of the circuit, equivalent to the specification of a XOR gate.

https://doi.org/10.1371/journal.pcbi.1013024.g007

We define a meta-species Location, with characteristics c1, c2, c3, and c4 representing the location of the three colonies and the buffer. The NOR gates are fixed in place; in contrast, the BCRN species Ara, aTc, AHL, and OC12 can move between colonies, serving as inputs to subsequent gates. We model this with a species Movable that inherits from Location and that contains location transitions.

from mobspy import *

import numpy as np

max_plas, max_pbad, max_ptet = (1, 1, 1)

Mortal, Location = BaseSpecies()

Location.c1, Location.c2, Location.c3, Location.c4

PBad, PTet, Pcl, PLas, Movable = New(Location)

Ara, aTc, Cl, YFP, AHL, OC12 = New(Mortal*Movable)

In this model, we measure the YFP output concentration for different input concentrations through a parametric sweep using the ModelParameters constructor. If a parameter has multiple values, MobsPy will run a parametric sweep using all values. Moreover, if multiple parameters have multiple values, MobsPy sweeps all possible combinations. In the model below, ara_r and atc_r are examples, controlling the concentration of Ara and aTc respectively.

The function promoter_activation represents the production of a BCRN species. It takes arguments such as the Promoter (the chemical species binding to NOR gate inputs for production), the Ligand (a NOR gate input), constants regulating input binding tf_max, n, and K_d, an expression controlling production rate protein_production_rate, and a list of locations where this reaction occurs locations. The third argument (Protein) is the species produced.

The advantage of promoter_activation is that Ara, aTc, and AHL undergo similar reactions within their respective bacterial colonies. However, these reactions involve different rate expressions, constants, and locations. MobsPy retains similar aspects within the function definition, and the differences can be passed as function arguments.

The function inverter_wire represents the NOT part of the NOR gate. The first argument (P) is a meta-species that binds to the meta-species in the second argument (R) to repress the production of the meta-species in the third argument (Signal). When the concentration of R is high, Signal will not be produced, and when the concentration is low, Signal will be produced.

We finish the model by passing the arguments to the respective functions:

The simulated data (Fig 8) clearly shows the characteristics of a XOR gate.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 8. Heatmap showing the simulated output of the XOR circuit by Tamsir et al. [11].

Only the regions with low-aTc and high-Ara as well as high-aTc and low-Ara show a high output as expected from a XOR gate.

https://doi.org/10.1371/journal.pcbi.1013024.g008

Comparison to Kappa.

We take the first model in the Kappa tutorial [31] (we removed the definition of observations for brevity). The model involves phosphorylation of the binding sites of a BCRN species C. The phosphorylation occurs twice, firstly when a species C reacts with A bound to a species B, and again when C reacts with A alone:

As Kappa revolves around the occupancy of binding sites of a BCRN species, we represent the binding sites through meta-species Link1 and Link2. The meta-species Link1 is reserved for interactions involving A and B, while Link2 is reserved for interactions involving A and C. Both Link1 and Link2 meta-species have two characteristics, not linked (nl_2 and nl_1) and linked (l_2 and l_1). Further, the meta-species Phos represents the phosphorylation states.

Furthermore, the Kappa graph-based algorithm also alleviates the burden of state space explosion by using graph connections instead of states for representation, while MobsPy simply focuses on syntax simplification. For instance, when representing the links of polymers in reactions, MobsPy would still be capable of writing the model. However, compilation would require a larger amount of time.

Comparison to BioCRNpyler.

We next implement the two initial models from BioCRNpyler GitHub repository [10]. The first basic example is:

The initial model consists of a simple BCRN where a BCRN species A reacts alone, resulting in two of species B, and B reacts alone, resulting in species C and D.

from mobspy import *

A, B, C, D = BaseSpecies()

A >> 2*B [3]

B >> C + D [1.4]

S = Simulation(A | B | C | D)

print(S.compile())

Unlike the model provided in BioCRNpyler’s GitHub [10], MobsPy’s automated variable naming eliminates the step of naming a BCRN using a string equal to its variable name. Additionally, in BioCRNpyler, to define reactions with mass action kinetics rates, the user must call the method from_massaction from the class Reaction. MobsPy’s expressions and default mass-action kinetics make this step more succinct.

The second example showcases a more complex network:

For this model, BioCRNpyler uses an automated reaction rate assignment strategy that relies on the names of the species. Such a strategy is not used in MobsPy. Thus, we set all rates arbitrarily and focus on syntax comparison. The model involves DNA translation and RNA transcription. For DNA translation, the DNA polymerase (DNA_Poly) binds to promoters (P2, Ptet) in a DNA strand and moves along the DNA to produce strands of messenger RNA (Mrna_P2, Mrna_Ptet). For RNA transcription, the ribosome (Ribo) binds to a messenger RNA and moves along it to produce proteins (GFP, RFP, CFP, GFP_F_RFP).

We start by defining the species:

from mobspy import *

Promoter, Start_Positions, Tet, Mortal = BaseSpecies()

Promoter.inactive, Promoter.active

Ribo, DNA_Poly = New(Start_Positions)

P2, Ptet = New(Promoter)

Mrna_P2, Mrna_Ptet, GFP, RFP, CFP, GFP_F_RFP = New(Mortal)

Further, we add death reactions:

# Death reactions

Mortal >> Zero [1]

In this model, promoters can either always be available for binding with the DNA polymerase (P2) or require binding with a BCRN species beforehand to bind to the DNA polymerase (Ptet). This is abstracted through the active and inactive characteristics:

# Promoter activation - only Ptet is activated. P2 is always

    active Rev[Ptet.inactive + Tet >> Ptet.active][1, 1]

Translation and transcription are both implemented within a single function named read. DNA polymerase or ribosome meta-species are passed as the second argument of the function R for translation and transcription, respectively. The first parameter (Pro) is the binding target for R, being either a promoter located in the DNA strand for translation or a messenger RNA for transcription.

The product depends on the position where R initially binds on the DNA or RNA strand and where it stops reading. For instance, the protein GFP_F_RFP is generated when the ribosome begins at the GFP encoding position and continues into the RFP encoding without terminating, resulting in a fusion protein combining GFP and RFP. This is implemented inside the function using a for loop by passing the positions and respective products as the third argument strand.

Finally, we assign initial values to meta-species.

The resulting model has a similar length as the BioCRNpyler model. For MobsPy all the reactions are explicit in the model.

Comparison to PySB.

To compare MobsPy syntax to PySB syntax, we take the hello_pysb.py model from the PySB GitHub repository [36]:

Implementing this model in MobsPy, we get:

from mobspy import *

L, R = BaseSpecies()

L_0, R_0, kf, kr = ModelParameters(100, 200, 1e-3, 1e-3)

L.sl_0 + R.sr_0 >> L.sl_1 + R.sr_1 [kf, lambda r: kr*r]

L(L_0), R(R_0)

S = Simulation(L | R)

print(S.compile())

Multiple differences in syntax choices are evident in this comparison. Firstly, the BaseSpecies constructor in MobsPy allows for the simultaneous definition of multiple meta-species, streamlining the process of declaring several monomers simultaneously. Additionally, characteristics that define bindings are implicitly added to reactions, eliminating the need for users to manually define these characteristics when creating base species and typing them again in subsequent reactions.

PySB automatically generates Python variables using the string names provided in its Monomer constructor, blending string literals with variable references. While this approach works and compiles correctly, it can lead to namespace pollution. Namespace pollution occurs when dynamically injected variables create conflicts or unintended overwrites, especially in environments where multiple modules are imported or interact. It can result in hard-to-debug issues, as variable name conflicts may propagate across modules [37].

MobsPy achieves the same functionality by using the variable name itself as the internal string representation. This eliminates the need for the user to manage or interact with string representations directly. Instead, users work exclusively with variables. Also, users can import MobsPy’s global variables with import mobspy as ms instead of from mobspy import * if namespace pollution is ever presented as an issue.

On the other hand, PySB has more synthesis capabilities due to its high-level modularity features. For MobsPy to achieve a similar level of syntax reduction, a necessary step is to implement ways to combine high-level models.

Comparison to BioNetGen.

In this section, we compare MobsPy to BioNetGen. To differentiate with the comparison with Kappa, we chose a multi-state model available in VCell’s introductory example list [24, 38]:

Translated into MobsPy, this model becomes:

Some syntax advantages gained from inheritance can be seen in the definition of R, L, A. Since all three inherit from r_link, there is no need to repeatedly redefine binding states when creating the molecules. Furthermore, MobsPy implicit state definition is used to define:

• Phosphorylation of A is represented by y_p (phosphorylated) and n_p (unphosphorylated).
• R binding to A is a_0 (unbound) and a_1 (bound).

Finally, observables do not need to be explicitly defined in MobsPy. Instead, the user can query the simulation results directly from the generated data.

In the third meta-reaction, which is complex-based, BioNetGen uses its graph rewriting algorithm to identify and count complexes, defining the reaction rate accordingly. In MobsPy, we achieve the same effect by explicitly defining a complex species (C) assigned the number of receptor-ligand complexes containing unphosphorylated A. The reaction rate is based on C, ensuring that only A.n_p inside a complex contributes to the phosphorylation reaction, rather than all A.n_p in the system. This expression is simple to write for small complexes. However, as the complex grows in size, so does the expression in the assignment.

It is vital to note that this model considers the binding rate of molecules linked to other parts of the complex equal to the binding rate of the molecules when they are not bound. One example lies in the dephosphorylation of A, which is of equal rate when A is in a complex or not. It qualifies as an approximation, as in most chemical systems, the binding of other complexes and the size of the complexes affect the reaction rate constant both due to electromagnetic interactions between adjacent bond sites and changes in overall complex mass [39–41].

Comparison to antimony.

Unlike the other languages presented in this section, Antimony does not provide reaction modularity. Instead, it serves as a human-readable alternative to SBML, offering additional features such as modifying the CRN structure mid-simulation[18]. Since MobsPy supports Antimony model generation through the generate_antimony method, we employ this feature for comparison.

The following MobsPy script generates an Antimony model:

from mobspy import *

Replicator, Mortal = BaseSpecies()

Replicator >> 2*Replicator [lambda r: 2*(100 - r)*r]

Mortal >> Zero [1]

A, B, C = New(Replicator*Mortal)

A + B >> C [1]

S = Simulation(A | B | C)

print(S.generate_antimony()[0])

This script produces the following Antimony model:

model mobspy_25681

A = 0 dimensionless

B = 0 dimensionless

C = 0 dimensionless

_vol = 1 dimensionless

reaction_0: A -> ; A * 1

reaction_1: B -> ; B * 1

reaction_2: C -> ; C * 1

reaction_3: A + B -> C; A * B * 1 * _vol^-1

reaction_4: A -> 2 A; ((2*(100-A))*A)

reaction_5: B -> 2 B; ((2*(100-B))*B)

reaction_6: C -> 2 C; ((2*(100-C))*C)

end

This output demonstrates how MobsPy expressions integrate with Antimony, as both directly encode reaction rates using mathematical expressions.