Catalytic P systems (CP systems, for short) represent a branch of membrane computing, i.e., abstract computing models based mostly on operations with multisets. They are freely inspired by the structure of (eukaryotic) cells and by the regulatory role of their membranes delimiting various compartments. CP systems primarily characterize the computational potential of certain abstract operations inspired by those in living cells and thus can help to understand information processes in the nature. They could also possibly serve for cellular modeling and synthetic biology purposes (including biocomputers). The most comprehensive recent monograph is The Oxford Handbook of Membrane Computing, for up-to-date information please visit the P Systems Webpage.

Contents

Description and function

A CP system is formed by a hierarchical membrane structure with uniquely labeled membranes. The
whole structure is embedded in a single skin membrane, see
the figure bellow. Each membrane contains a multiset of primitive abstract
objects. The objects are members of a finite alphabet \(O\)
which is divided into two parts: the set of catalysts \(C,\)
and the set \(O\setminus C\) of non-catalytic objects. Each
membrane has assigned an initial multiset of objects and a fixed set
of evolution rules of two possible types: (1) \(ca \rightarrow cv\)
(catalytic rules), (2) \(a \rightarrow v\) (non-cooperative rules), where \(c\) is a catalyst, \(a\) is a non-catalyst, and \(v\) is
a (possibly empty) multiset of non-catalysts. The rule transforms the
object \(a\) into the multiset of objects \(v\) in one step. In the case
of catalytic rules also the catalyst \(c\) participates in the rule application but it passes intact. A CP system
is called purely catalytic if it contains only catalytic
rules.

Furthermore, each object resulting from an application of a rule
(i.e., an element of the multiset \(v\)) can be transported through a
membrane. It has assigned a target
here, out or in\(_j\) denoting its target
membrane after the rule application (\(j\) is a label of an inner
membrane). The target here is usually omitted.

The whole system evolves in discrete computational steps. Each
object can evolve due to at most one rule at a given step. The rules
are usually applied in the maximally parallel mode (click here for other modes): at each
computational step and in each membrane, the selected multiset of
applicable rules must be maximal, i.e., unused objects do not
allow for an application of another rule. For example, let a
membrane contain non-catalysts \(a,b\) and a catalyst \(c.\) Let there
be rules \(ca \rightarrow cu,\) \(cb \rightarrow cv\) and \(a \rightarrow w.\) Then the selected
multiset of rules can contain either (i) only the rule \(ca \rightarrow cu\)
or (ii) both rules \(cb \rightarrow cv\) and \(a \rightarrow w.\)

The computation continues until no rule can be applied in any of the membranes
and the system halts (or it can compute ad infinitum).

Consider a CP system starting its computation from an initial configuration where each membrane contains a pre-defined initial multiset of objects. After a sequence of parallel steps, the system eventually
halts. The final number of objects present in a specific
output membrane is the result of the computation.
Sometimes we take instead the Parikh vector of the
multiset of objects present in the output membrane (i.e., a numerical vector whose components equal the multiplicity of individual objects in the multiset). Hence, the
result is a non-negative integer or a vector of integers.
As a CP system is generally non-deterministic, it can perform
various computations with different results. The collection of all
these results forms a set of numbers (or vectors) generated
by the system.

Consider the CP system depicted on the right-hand side, working with alphabet
\(O=\{a,b,c,d,e\}\ ,\) where \(c\) is a catalyst and the remaining objects are non-catalysts. Objects \(a,b,c\) are initially present in membrane 1. At most one of the two catalytic rules can be used at each computational step. Hence, due to the maximal parallelism, the rule \(a\rightarrow\lambda\) or \(b\rightarrow\lambda\) (or both) must be also used in the first step. (Note that \(\lambda\) represents the empty multiset.) Then an arbitrary number of steps using the same catalytic rule can follow until a \(\lambda\)-rule is used second
time and the system halts. Each application of a catalytic rule transports the multiset \(\{d,e\}\) (or \(\{d,e,e\}\ ,\) respectively) into membrane 2. Let membrane 2 be the output membrane. The system generates the set \(\{2n\, |\, n\ge
0\}\cup \{3n\, |\, n\ge 0\}.\) If Parikh vectors were considered instead, the
generated set would be \(\{(0,0,0,n,n)\, |\, n\ge 0\}\cup \{(0,0,0,n,2n)\, |\,
n\ge 0\}.\)

If non-catalytic objects are interpreted as symbols of the
alphabet \(O\setminus C\ ,\) CP systems can also be used to
generate formal languages. At each step, a multiset of symbols can
be sent out through the skin membrane. We take all possible strings
obtained by permutations of elements of this multiset as the result
of this particular step. By concatenating the results of all steps
of a halting computation, we obtain a set of strings generated
during this computation. Similarly as above, the union of results of
all possible halting computations of a CP system gives the set of strings
(i.e., a formal language) it generates. CP systems with
the parameters specified in the previous paragraph can generate all
recursively enumerable languages.

Accepting catalytic P systems

A CP system can also act as an accepting device (or automaton):
an input (a non-negative integer or a vector
of integers) can be represented as the Parikh vector of a multiset of
designated objects. This multiset is inserted into a specific input membrane at
the beginning of computation. The input is accepted by a given CP system if
there exists a halting computation with this input. Freund et al. (2005) showed that any
computably enumerable set of natural numbers can be accepted by a CP system
with a single membrane and two catalysts (or three catalysts for purely
catalytic systems). CP systems can also accept all the computably enumerable
sets of vectors of natural numbers. The minimal number of catalysts needed in
this case equals the dimension of the input vector plus a constant.

The situation is different when we consider deterministic CP
systems (DCP systems), i.e., having exactly one computation for any
given input. The computational power of DCP systems has to be
investigated yet but it is known that any DCP system can accept only
a semilinear set of (vectors of) natural numbers and its
halting problem is decidable in polynomial time
(Ibarra and Yen, 2006).

To regain the universal computing power (i.e., that of the
Turing machine), two extensions of DCP systems have been considered.
Paun (2000) introduces priorities among rules, i.e., a
strict partial order.
If two or more rules compete for object(s), the
rule with the highest priority is chosen. DCP systems with
priorities among rules can accept all computably enumerable sets.
Further variants of priorities (strongly prioritized or statically
prioritized DCP systems) have been also considered by Ibarra and Yen (2006).

An interesting extension is the concept of \(k\)-determinism introduced in
(Oswald, 2003): a \(k\)-deterministic CP system behaves deterministically
provided that it can, at each step, scan all the branches of its computational
tree \(k\) steps ahead. It was shown that 4-deterministic CP systems can accept
all computably enumerable set of (vectors of) natural numbers.

Further variants

Bistable catalysts

A bistable catalyst has two forms and switches
reversibly from one to another. Its rules are of the form
\(ca \rightarrow c'v\) and \(c'b \rightarrow
cu,\) where \(c,c'\) are two forms of a catalyst, \(a, b\) are
non-catalysts and \(u, v\) are multisets of non-catalysts. Bistable
catalysts are more powerful than the basic ones: one bistable
catalysts grants to a CP system the power of universal computer (Alhazov, 2006).

Mobile catalysts

This variant of CP systems allows catalysts to migrate between membranes in the
same manner as non-catalysts. Also this variant is more powerful than standard
catalysts – one catalyst is enough to obtain the universal computing power
provided that we use at least three membranes (Krishna and Paun, 2004).

Sequential and asynchronous mode

Various derivation modes, as well as variants of halting, were systematically described first by
Freund and Verlan (2007).
In the sequential mode, at each computational step only one randomly chosen
rule is applied out of all applicable rules in the whole system. In the
asynchronous mode, a randomly chosen multiset of applicable rules is used. CP systems can only generate semilinear sets in both
these modes (Freund et al., 2009), pointing out the importance of synchronization. The P system described in
the example above would generate the set of all natural numbers except 1 if it
worked in the sequential or asynchronous (or minimally parallel) mode.

Minimally parallel mode

Similarly as in the asynchronous mode, a randomly chosen multiset of applicable
rules is used in each step. However, for each membrane and each step the
following condition must hold: if there are applicable rules in the membrane,
then at least one of them must be used. These CP systems are computationally
universal with least two membranes and an unlimited number of bistable
catalysts (Freund et al., 2009). It is not known whether an analogous result can be achieved with
standard catalysts. Further refined variants have been also studied, as the
\(k\)-restricted minimal parallelism (Freund and Verlan, 2008) where the set of all rules \(R\) is
partitioned into disjoint subsets and at most \(k\)
rules is used from each subset.

Variants of halting

Consider again a partitioning of \(R\) into disjoint subsets. The partial halting condition states that during each derivation step, exactly one rule
from each subset must be applied, otherwise the system halts. Interestingly
enough, in the asynchronous and minimally parallel modes with partial halting,
CP systems can generate only Parikh images of matrix languages. Other
conditions of halting have been considered, as the appearance of certain
objects in a certain membrane or a repeated cycle of configurations.
Eventually, one can ignore halting at all and consider the set of all contents
of the output membrane at all steps as the result of computation. More details of these and further variants can be found in (Freund et al., 2009).