Algorithmic Systems Ecology: Experiments on Multiple Interaction Types and Patches

Abstract

Dynamic behavior in ecosystems can emerge as a result of multiple interactions of different types as well as movements of the ecosystem species between different patches. The extinction behaviors in ecosystem models, which can result from the small species numbers, bring stochasticity to the foreground as they are often not observable in deterministic representations. To this end, we demonstrate an integrated approach to ecosystem modeling from an algorithmic systems biology point of view. We use a modeling interface, called LIME, which allows us to give biologically intuitive models of a plant-pollinator system’s descriptions with varying interaction types and patches. Our models, written in a narrative style, are automatically translated into stochastic programming languages. The discrete stochastic nature of the models brings about the possibility to analyze the models with respect to their simulations as well as various graph representations. Our analysis provides an assessment of the functional dynamics of ecosystems with respect to the influence of various interaction patterns and patch links.

Appendix A

BlenX shares features with the process algebra languages stochastic pi-calculus [25] and Beta-binders [4], it thus keeps a strong focus on the interactions of entities. Stochasticity is given by a continuous time Markov chain semantics, and it is realized by an efficient implementation of the Gillespie algorithm [8]. BlenX is a part of the software platform COSBILAB.

In BlenX, each individual of the modeled system is described as an abstract entity called box. Each box can interact with others via its connectivity interfaces called binders, and the result of the interactions and also other autonomous actions are determined by the user defined internal program of the box, which employs the stochastic semantics. As an example, consider the two boxes in Fig. 13, where each box has only one binder that is identified by its name, e.g., binder x and its type, e.g., X.

The internal program of a box describes the effect of the interactions and the autonomous actions that the box can undertake. Every time when such an action takes place with respect to the underlying stochastic semantics, the effect of the action is reflected to the interfaces, and this way the new state of the box is computed. This is performed by the simulation engine by picking an action of the model with respect to the Gillespie algorithm by taking the rates of the available actions of all the boxes at that state. This results in a model behavior in the form of a sequence of model actions that can be read as a time series of the model individuals, i.e., boxes.

Fig. 13.

Two BlenX boxes representing two interacting species A and B.

A BlenX model is written as two separate files, where the first file is the description of all the boxes of the model and their binders. The second file of the model contains a list of pairs of binder types together with their binding, unbinding, and interaction rates, which can all be $0$. With respect to the compatibilities given by this list, binders can bind or unbind with binders of other boxes, or interact to exchange information communications with other boxes. As an example for this, consider the model given in Fig. 13, where the expression $(X,Y,0,0,1)$ indicates that the binders with types $X$ and $Y$ can interact with a rate $1$. The third and forth parameters of this expression state the binding and unbinding rates are $0$.

The interaction of a predator $A$ and its prey $B$ can be described in a BlenX model with the boxes depicted in Fig. 13. The interaction rate, specified in the BlenX code, determines the rate of the predation being modeled. The internal program, which can be nil, describes this interaction and its consequences in terms of the actions the box can undertake. The nil action does nothing. Other stochastic actions that a BlenX box can perform are summarized as follows: a box can

• (i.) communicate with another box (or with itself) by performing an input action, e.g., x?(message) that is complementary to the output action, e.g., x!(message), of the other box, or vice versa, and this way send or receive a message;

• (ii.) perform a stochastic delay action;

• (iii.) change (ch) the type of one of its interfaces;

• (iv.) eliminate itself by performing a die action;

• (v.) expose a new binder;

• (vi.) hide one of its binders;

• (vii.) unhide a binder which is hidden.

In addition to these actions, there are also other programming constructs available such as if-then statements and state-checks. For example, let us consider the box $A$ in Fig. 13. We can define the program $P$ such that it changes the type $X$ to $Z$ if this box is bound to another species via its interface $x$:

$$\begin{aligned} \mathtt{{if \;(x,X)\; and \;(x,bound) \;then \;ch(x,Z) \;endif}} \end{aligned}$$

As BlenX is a process algebra based language, internal programs can be written as compositions of actions by using algebraic composition operators in order to define increasingly complex behaviors. We can sequentially compose actions by using the prefix-operator, written as an infix dot. For example, ch(x,Z).hide(x).nil denotes a program that first performs change action and then hides the changed binder. Programs can be composed in parallel. Parallel composition (denoted by the infix operator $\mathtt |$, for instance P|Q) allows the description of programs, which may run independently in parallel and also synchronize on complementary actions (i.e., input and output over the same channel). Programs can also be composed by stochastic choice, denoted with the summation operator “+". The sum of processes P and Q, P + Q behaves either as P or as Q, determined by their stochastic rates, and selection of one discards the other forever.