On acceptance conditions for membrane systems: characterisations of L and NL

In this paper we investigate the affect of various acceptance conditions on recogniser membrane systems without dissolution. We demonstrate that two particular acceptance conditions (one easier to program, the other easier to prove correctness) both characterise the same complexity class, NL. We also find that by restricting the acceptance conditions we obtain a characterisation of L. We obtain these results by investigating the connectivity properties of dependency graphs that model membrane system computations.

💡 Research Summary

The paper investigates how different acceptance conditions affect the computational power of recogniser membrane systems that do not use dissolution. The authors focus on two particular acceptance criteria and show that, despite their differing operational intuitions, both characterize the same complexity class, namely nondeterministic logarithmic space (NL). They then demonstrate that by tightening the acceptance condition they obtain a precise characterization of deterministic logarithmic space (L). The analysis proceeds by modeling the dynamics of a membrane system as a directed dependency graph, where vertices correspond to objects (or membranes) and edges represent the application of a rule that transforms one object into another. This graph‑theoretic abstraction makes it possible to translate questions about the behaviour of the membrane system into standard graph‑reachability problems, which are well‑studied in complexity theory.

The first acceptance condition, which the authors call “any‑time acceptance,” declares a computation successful as soon as a distinguished object ‘yes’ appears anywhere in the system, regardless of whether the computation continues afterwards. From a programming perspective this condition is very convenient: a programmer can simply insert a rule that generates ‘yes’ at the moment a desired property is detected, and the system halts with acceptance. In terms of the dependency graph, any‑time acceptance reduces to the existence of at least one directed path from the start vertex (representing the initial multiset of objects) to a vertex labelled ‘yes’. Because the system may nondeterministically choose which rule to apply at each step, the existence of such a path can be decided by a nondeterministic log‑space Turing machine that guesses a path and verifies it using only O(log n) work tape. Consequently, the class of languages recognised by membrane systems under any‑time acceptance coincides exactly with NL.

The second condition, termed “final‑state acceptance,” requires that the computation be examined only after it has terminated, and the result is accepted if and only if the distinguished object ‘yes’ is present in the final multiset. This condition is more amenable to formal correctness proofs because it forces the analyst to consider the entire computation tree rather than a single early success. In the dependency‑graph view, final‑state acceptance translates to the question: does every maximal directed walk that starts at the initial vertex eventually end in a vertex labelled ‘yes’? Equivalently, one must verify that there is no reachable configuration that leads to a dead‑end without ‘yes’. The authors show that this verification can be performed deterministically in logarithmic space by a depth‑first search that records the current vertex and a logarithmic‑size bit‑vector indicating which vertices have been visited on the current search branch. Because the graph is of size polynomial in the input, the DFS uses only O(log n) space, and the algorithm either finds a counterexample (a path ending without ‘yes’) or confirms that all paths terminate with ‘yes’. Hence, the class of languages accepted under final‑state acceptance is precisely L.

A crucial technical contribution of the paper is the formal proof that the two acceptance conditions, while yielding different algorithmic characterisations (NL versus L), are both sound and complete with respect to the underlying membrane‑system model. The authors construct reductions in both directions: given any NL language, they build a membrane system that accepts it under any‑time acceptance; conversely, given any language accepted by a membrane system under any‑time acceptance, they show how to simulate its computation with an NL Turing machine. A similar pair of reductions is provided for L and final‑state acceptance. These constructions rely heavily on the structure of the dependency graph: the authors exploit the fact that, without dissolution, the graph is acyclic except for self‑loops introduced by certain rule patterns, which simplifies the analysis of reachability and termination.

To substantiate the theoretical results, the paper presents several concrete membrane‑system examples. One example encodes the classic directed‑reachability problem, demonstrating that any‑time acceptance captures NL‑complete behaviour. Another example implements a deterministic traversal of a binary tree, showing that final‑state acceptance can be used to recognise a language in L. The authors also discuss how the choice of acceptance condition influences the ease of programming versus the ease of proving correctness: any‑time acceptance leads to shorter, more intuitive rule sets, while final‑state acceptance yields rule sets that are more amenable to formal verification because the computation’s entire evolution must be accounted for.

In the concluding discussion, the authors reflect on the broader implications of their findings. By showing that a modest change in the definition of acceptance can shift the computational power of membrane systems from NL down to L, they highlight the sensitivity of unconventional computational models to semantic details. Moreover, the dependency‑graph methodology introduced here provides a unifying framework for analysing other variants of membrane systems, such as those with dissolution, division, or more elaborate communication primitives. The paper suggests that future work could explore whether similar characterisations hold for higher complexity classes (e.g., P or PSPACE) when richer rule sets are permitted, or whether alternative graph‑theoretic abstractions might capture the power of stochastic or probabilistic membrane systems. Overall, the work deepens our understanding of the relationship between biologically inspired computation and classical complexity theory, offering both rigorous proofs and practical insights for designers of membrane‑based algorithms.