Reversible parallel communicating finite automata systems

We study the concept of reversibility in connection with parallel communicating systems of finite automata (PCFA in short). We define the notion of reversibility in the case of PCFA (also covering the non-deterministic case) and discuss the relationship of the reversibility of the systems and the reversibility of its components. We show that a system can be reversible with non-reversible components, and the other way around, the reversibility of the components does not necessarily imply the reversibility of the system as a whole. We also investigate the computational power of deterministic centralized reversible PCFA. We show that these very simple types of PCFA (returning or non-returning) can recognize regular languages which cannot be accepted by reversible (deterministic) finite automata, and that they can even accept languages that are not context-free. We also separate the deterministic and non-deterministic variants in the case of systems with non-returning communication. We show that there are languages accepted by non-deterministic centralized PCFA, which cannot be recognized by any deterministic variant of the same type.

In PCFA, spontaneous transitions are allowed so that different automata of a system can read different symbols of the input word at the same time during computations. This is similar to multi-head finite automata [20] which are shown to be computationally equivalent to PCFA, see [17] and [7] for the non-deterministic case and [4] for the deterministic case. Inspired by parallel communicating grammar systems which have been investigated as string generating variants of the classroom model known from artificial intelligence [8], one distinguishes between the returning and non-returning working modes. In PCFA, these working modes refer to the state in which an automaton continues its computation after it has sent its state to another automaton upon request: In the returning mode, the automaton is set back to its initial state, while in the non-returning mode, it just keeps the state it has communicated to another automaton. An interesting special case is centralized PCFA, where only one designated automaton is allowed to send communication requests to other automata of the system. This models a particular, star-like network architecture with restricted power, leading to subclasses in the hierarchy of language families, strict in most cases [4].
In the present paper, the concept of reversibility is added to PCFA. Roughly, reversibility means that no information is lost during the computation. This is of interest due to the physical observation that loss of information involves heat dissipation [2,16]. In abstract models, a computation is reversible if every configuration has a unique predecessor configuration. Thus, in deterministic devices the computation step relation is injective. For example, reversible Turing machines have been investigated in [2] where it is shown that for every Turing machine, there is an equivalent reversible one. Many other automata models have been considered under the restriction of reversibility such as the massively parallel cellular automata, see, e.g., [18], pushdown automata [13], their input driven variants [15], two-way multi-head finite automata [1,19] and one-way multi-head finite automata [14]. In [10], reversible nondeterministic finite automata have been considered. Different aspects of reversibility in a setting of computing devices with a finite number of discrete internal states and a read-only input tape are addressed in [12]. This work also contains many further references about reversibility in automata models.
PCFA were also considered from the point of view of reversibility in [9] where the authors showed that parallel communicating systems of reversible (deterministic) finite automata are able to accept all regular languages. They also considered an intuitive notion of the reversibility of PCFA systems when they remarked that such a system is not necessarily reversible as a whole, although all of its components are reversible.
In the present paper, we first give a definition of the notion of reversibility for PCFA by formalizing the way the predecessor configurations are computed, particularly in the case when communication may have happened. We also discuss the relation between the reversibility of parallel communicating systems and the reversibility of their components, and then, we focus on the computational power of reversible systems. Throughout the paper, both the deterministic and non-deterministic variants are taken into consideration.

Definitions and basic properties
We assume that the reader is familiar with basic concepts and terminology of automata theory as it can be found, e.g., in [22]. We shall use the following notation. For a set S, its powerset is designated by 2 S and its cardinality by |S|. The symbols ⊆ and ⊂ are used for set inclusion and strict set inclusion, respectively. For a word w, its length is designated by |w|, w(i) denotes the i-th symbol of w, for 1 ≤ i ≤ |w|, and w R is the reverse (mirror image) of w. The symbol λ is used for the empty word. Let be an alphabet. The notation * is used for the set of all words over including λ, while + = * \ {λ}.
Let A = (S, , s 0 , δ, F) be a non-deterministic finite automaton (NFA), where S is the finite set of states, is the alphabet of input symbols, s 0 ∈ S is the initial state, δ : S × → 2 S is the transition function and F ⊆ S is the set of accepting states. The automaton is deterministic if |δ(s, a)| = 1 for all s ∈ S and a ∈ . A configuration of A is a pair in S × * . A computation of A on input word w is a sequence of configurations c 0 , c 1 , . . . c k , for some k ≥ 0 such that c 0 is the initial configuration (s 0 , w), and An NFA A = (S, , s 0 , δ, F) is reversible according to [10] if there is no internal state s ∈ S, such that s ∈ δ( p, a) ∩ δ(r , a) holds for some a ∈ and states p, r ∈ S with p = r .
A non-deterministic parallel communicating finite automata system of degree k (PCFA(k)) is a tuple A = ( , with S i being the set of states, s 0,i ∈ S i the initial state, F i ⊆ S i the set of accepting states, and δ i : represents the tape contents with input word w ∈ * , the current states s i ∈ S i , and the current positions p i ≥ 1 of the reading heads of the component automata An initial configuration is of the form (w, s 0,1 , 1, s 0,2 , 1, . . . , s 0,k , 1), that is, each component is in its initial state and scans the first symbol of an input word w ∈ * . The definition of the successor configuration relation A of A is defined as follows. (We may omit the subscript A in A if there is no risk of confusion.) For any w ∈ * , and s j / ∈ Q, then s i = s j ; furthermore, (a) s r = s r for all the other r , 1 ≤ r ≤ k (non-returning communication) or, alternatively, (b) s j = s 0, j , and s r = s r for all the other r , 1 ≤ r ≤ k (returning communication).
In a reading step, all components are in non-query states and perform an ordinary (noncommunicating) step independently (which may also be a λ-step). Notice that components with head positions greater than the input length will always scan the end-of-input symbol in non-λ reading steps. In a communication step, components in query states receive the requested states as long as the sender is not in a query state itself. This process is repeated until all requests are resolved, if possible. If the requests are cyclic, no successor configuration exists. As mentioned above, we distinguish non-returning communication, that is, the sender remains in its current state, and returning communication, that is, the sender is reset to its initial state. Both in returning and non-returning communication steps, the heads do not move. In what follows, every PCFA consistently work with either returning or non-returning communication steps; thus, we either have returning or non-returning systems. A computation halts when the successor configuration is not defined for the current situation. In particular, this may happen when cyclic communication requests appear, or when the transition function of one component is not defined. (We regard the transition function as undefined whenever it maps to the empty set.) The language L(A) accepted by a PCFA(k) A is precisely the set of words w such that there is some computation beginning with w on the input tape and halting with at least one component having an undefined transition function and being in an accepting state. Let * A denote the reflexive and transitive closure of A and set L( If all components A i are deterministic finite automata, that is, for all s ∈ S i and for all a ∈ , the transition function δ i (s, a) maps to a set of at most one state and is undefined whenever δ i (s, λ) is defined, then the whole system is called deterministic, and we add the prefix D (to PCFA) to denote it. The absence or presence of an R in the type of the system denotes whether it works in non-returning or returning mode, respectively. Finally, if there is just one component, say A 1 , that is allowed to query for states, that is, S i ∩ Q = ∅, for 2 ≤ i ≤ k, then the system is said to be centralized. In this case, we refer to A 1 as the master component and add a C to the notation of the type of the system. Whenever the degree is missing, we mean systems of arbitrary degree. The family of languages accepted by devices of type X (with degree k) is denoted by L (X ) (L (X (k))).
For the definition of reversibility of a PCFA, we introduce the following notion. A con- and (w, t 1 , r 1 , . . . , t k , r k ) (w, s 1 , p 1 , . . . , s k , p k ), then the following holds: Intuitively, if two reachable configurations cannot be distinguished by the states reached, then it is determined which positions have been increased in the previous computation step and which have not. This way one can identify the symbols which have been read in the previous computation step. If the read symbols are identical, then also the states of the two predecessor configurations have been the same.
In the definition, one might alternatively take all configurations into account instead of only reachable ones. Due to the motivation of the concept of reversibility, computations should be reversible that can be performed by the machine model. Therefore, we restrict to reachable configurations in the definition.
For all the language classes L(X PCFA) and L(X PCFA(k)) with X ∈ {λ, R, C, DR, DC, DRC}, we add the prefix "rev" in order to refer to the corresponding families of languages accepted by reversible PCFA.

Example 1 Consider the deterministic non-returning PCFA with two components (DCPCFA(2) in short)
and To see how A works, consider an initial configuration (α, s 0,1 , 1, s 0,2 , 1). Notice that α = ¢α or the second component cannot start reading the input which results in a nonaccepting blocking configuration. Moreover, α contains exactly one $ symbol or the second component cannot reach the end-of-input symbol , so the first component (hence, the system) cannot enter the accepting state. This means that the input string must be of the form ¢w$w with w, w ∈ {a, b} * .
The transition relations are defined in such a way that the computation must start with where ¢w$w (k) = $, that is, the kth symbol of the input is the $ symbol and it has just been read by the second component. We can check that this phase of the computation is reversible by considering the following.
-If the states of the components are (s 1 , s 1 ) or (s $ , s $ ), then the previous computational step must have been a communication step, so for any configuration (¢w$w , respectively. -If the states of the components are (q 2 , s 1 ), then the previous computational step must have been a reading step where the second component made a non-λ-move. As the second component is in s 1 , it has never sent a state from {s $ , s a , s b } to the first component by a communication step. Therefore, the first component must have entered state q 2 by a λ-move. If the symbol read by the second component was ¢, then for any configuration (¢w$w , q 2 , i, s 1 , j) with i ≥ 1, j > 1, the previous configuration must have been (¢w$w , s 0,1 , i, s 0,2 , j − 1) which is only reachable if it is the initial configuration (¢w$w , s 0,1 , 1, s 0,2 , 1). If the symbol read by the second component was a or b, then the previous configuration is (¢w$w , s 1 , i, s 1 , j − 1).
-Similarly, if the states of the components are (q 2 , s $ ), then the previous computational step must have been a reading step where the first component made a λ-move, and the second component made a non-λ-move. The symbol read by the second component must have been a $, so the previous configuration for any (¢w$w , Notice that i = 1 in any reachable configuration of these forms.
Continuing the computation, we have If the second symbol of the input is also x, the computation can continue with where x ∈ {a, b, } now depends on the (k + 2)nd symbol on the input tape. Repeating similar steps, the system now is able to check whether w = w in the input string ¢w$w . The first component can only read the jth symbol of w (which is the (1 + j)th symbol on the tape), if it is the same as the jth symbol of w (which is the (k + j)th symbol on the tape) that was read in the previous non-communication step by the second component and transferred in the previous communication step to the first component as the state This phase of the computation is also reversible, as can be seen by the following.
-If the states of the components are (s x , s x ) for some x ∈ {a, b, }, then the previous computational step must have been a communication step, so for any configuration (¢w$w , s x , i, s x , j) with i, j > 1, the previous configuration must have been (¢w$w , q 2 , i, s x , j). -If the states of the components are (q 2 , s x ) for some x ∈ {a, b, }, then the previous computational step must have been a reading step where both components made a non-λ-move. If the symbol read by the first component is y ∈ {a, b, $}, then for any configuration (¢w$w , q 2 , i, s x , j) with i, j > 1, the previous configuration must have been (¢w$w , s y , i − 1, s y , j − 1). (Note that configurations of the form (¢w$w , s x , i, s x , j) for x = x are not reachable by the system. Moreover, j = k + i holds in every reachable configuration of this form.) Now, we consider situations in which the second component reaches the end-of-input symbol . If the first component reaches the $ symbol before the second component reaches the end-of-input symbol , then the system is blocked in a non-accepting state of the form (¢w$w , s x , i, s x , j) where ¢w$w (i) = $, so in order for the computation to be successful, the second component must reach the end-of-input symbol first through a computational step followed by the communication Now, if the first component is scanning an a or b symbol, then the computation is blocked in a non-accepting state. On the other hand, if the first component is scanning the $ symbol (that is, if the input string is of the form ¢w$w), the system reaches the accepting configuration where the $ symbol is on the kth position of the input string, that is, j = k − 2 for |¢w$w| = 2k − 2.
The last step of the computation is also reversible, as having the current states (s acc , s f ) implies that the two components made a non-λ-move and a λ-move, respectively, and the states of the previous configuration must have been s for both of them.
The next example shows that a similar language can also be accepted by returning systems. Further, We show that A is reversible and accepts the language To see how A works, consider an initial configuration (α, s 0,1 , 1, s 0,2 , 1). Notice that α = ¢α or the first component cannot perform more than one computational step on the input, which results in a non-accepting blocking configuration of the form (α, s 0,1 , 1, s x , 2) with x ∈ {a, b, $ 1 , $ 2 }. Such computational step is reversible as it can only be reached from the initial configuration according to the definition of δ 1 . Moreover, the first component, thus the system, cannot read more than one ¢ symbol, so the leading ¢ is the only such symbol in the input string. Similarly, the first component must read exactly one $ 1 symbol, or it cannot reach the accepting state. As a consequence, α must contain exactly one $ 2 symbol, since the first component may read $ 2 only after receiving state s ¢ from the second component, which can happen only once, as there is only one ¢ symbol in the input string and A works in returning mode. Note also that the $ 1 , $ 2 symbols must be adjacent, or the first component cannot reach the accepting state. To see this, note that the first component initiates the first query after reading the symbol $ 1 . Since leftmost input symbol is ¢, the second component must respond to this query by sending the state s ¢ , and after receiving s ¢ , the first component can only continue by reading a $ 2 symbol. This means that the input string must be of the form ¢α where α contains exactly one occurrence of the substring $ 1 $ 2 .
The transition relations are defined in such a way that the computation must start with (¢w$ 1 $ 2 w , s 0,1 , 1, s 0,2 , 1) (¢w$ 1 $ 2 w , s 0,1 , 1, s ¢ , 2) (¢w$ 1 $ 2 w , s 1 , 2, s ¢ , 2) and then where ¢w$ 1 $ 2 w (k) = $ 1 , that is, the kth symbol of the input is the $ 1 symbol and it has just been read by the first component. To see that this phase of the computation is reversible, consider the following.
-If the states of the components are (s 0,1 , s ¢ ), then the previous computational step must have been a reading step where the first component made a λ-move, and the second component made a non-λ-move, so for any configuration (¢w$ 1 $ 2 w , s 0,1 , i, s ¢ , j) with i, j ≥ 1, the previous configuration must have been (¢w$ 1 $ 2 w , s 0,1 , i, s 0,2 , j −1). (This actually must be the initial configuration Continuing the computation, we have where x depends on the second symbol on the input tape. Now, if x ∈ {a, b} and the (k +2)nd symbol of the input is also x, the computation can continue with where x now depends on the third symbol on the input tape. Repeating similar steps, the system is now able to check whether w = w in the input string ¢w$ 1 $ 2 w . The first component can only read the jth symbol of w (which is the (k + 1 + j)th symbol on the tape), if it is the same as the jth symbol of w (which is the (1 + j)th symbol on the tape) that was read in the previous non-communication step by the second component and transferred in the previous communication step to the first component as the state s x , for x ∈ {a, b}. This phase of the computation is also reversible, as can be seen by the following.
-If the states of the components are (q 2 , s x ) for some x ∈ {a, b} then the previous computational step must have been a reading step where both components made a non-λ-move. To see that the first component must also have made a non-λ-move, note that this configuration cannot be the first configuration of the computation where q 2 appears, since if this was the case, then the second component would be in state s ¢ . This implies that the first component cannot enter the state q 2 with a λ-move from state s 1 , since it can only be in state s 1 before any communication happened. If the symbol read by the first component is y ∈ {a, b}, then for any configuration (¢w$ 1 $ 2 w , q 2 , i, s x , j) with i, j > 1, the previous configuration must have been (¢w$ 1 $ 2 w , s y , i − 1, s 0,2 , j − 1). -If the states of the components are (s x , s 0,2 ) for some x ∈ {a, b}, then the previous computational step must have been a communication step, so for any configuration (¢w$ 1 $ 2 w , s x , i, s 0,2 , j) with i, j ≥ 1, the previous configuration must have been (¢w$ 1 $ 2 w , q 2 , i, s x , j).
If the second component reaches the $ 2 symbol before the first component reaches the endof-input , that is, the configuration reached would be of the form (¢w$ 1 $ 2 w , s $ 1 , 2k, s 0,2 , k+ 1) where ¢w$ 1 $ 2 w (k + 1) = $ 2 and ¢w$ 1 $ 2 w (2k) = , then the system is blocked in non-accepting states, because the first component can continue from state s $ 1 only when reading the end-of-input symbol. If the first component reaches the end-of-input symbol before the second component reaches the $ 2 symbol, the system is blocked in (¢w$ 1 $ 2 w , s x , 2 j − 1, s 0,2 , j) for some x ∈ {a, b} and some j > k + 1 which is not accepting. Note also that the communication steps before these blocking configurations are reversible.
Thus, in order for the computation to be successful, the two components must reach the end-of-input symbol and the symbol $ 2 simultaneously through the computational steps These steps of the computation are also reversible, since -having the current states (q 2 , s $ 1 ) implies that the previous step was a reading step in which both heads have moved on, because in reachable configurations, the first component has already passed beyond $ 2 (k ≥ 2, so 2k > k + 1). The state of the first component must have been s x with x = α(2k − 1), x ∈ {a, b}, and the state of the second component must have been s 0,2 . -Having the current states (s $ 1 , s 0,2 ) implies that the previous step was a communication step, so for any configurations (¢w$ 1 $ 2 w , s $ 1 , i, s 0,2 , j), i, j ≥ 1, the previous configuration must have been (¢w$ 1 $ 2 w , q 2 , i, s $ 1 , j). -If the current states are (s acc , s $ 2 ), the two components performed reading move in the previous computational steps, and the states of previous configuration must have been s $ 1 and s 0,2 , respectively.
As the components of PCFA are non-deterministic finite automata (NFA), we may consider the relationship of the reversibility of a PCFA and the reversibility of its components. Since in PCFA, there is an end-of-input symbol and λ-steps are allowed in the component automata, we extend the definition of reversibility of NFA as it is given in [10] as follows: such that s ∈ δ( p, a) ∩ δ(r , a) holds for some a ∈ and states p, r ∈ S with p = r ; 2. there is no internal state s ∈ S, such that s ∈ δ( p, a)∩δ(r , λ) holds for some a ∈ ∪{λ} and states p, r ∈ S with p = r .
Note that the fact that systems of (deterministic) reversible automata are not necessarily reversible was already remarked in [9] without giving a formal definition of the notion of reversibility for PCFA systems. In the second part of the following proposition, we give a similar, but more simple demonstration than the one in [9].

If the states of the two components are
Notice that we used deterministic centralized systems of degree 2 in both cases.

Some results on the computational capacity
First, we prove that reversible deterministic PCFA are more powerful than reversible deterministic finite automata. It turns out that for accepting a non-reversible regular language with deterministic PCFA, communication is even unnecessary.
Theorem 1 There is a language in L(revDCPCFA(2)) ∩ L(revDRCPCFA (2)) that cannot be accepted by any reversible deterministic finite automaton.
Proof First, we prove that for the language L = { 01 k | k ≥ 1 }, there is no reversible deterministic finite state automaton. Let A be any deterministic finite automaton accepting L. Assume the number of states of A be n. Let 1 n−2 ) . . . ( p n−1 , 1) ( p n , λ) be the accepting computation for 01 n , in A, where n > 2, which is seen as follows. If q 0 = p i for some i, 0 ≤ i ≤ n, then the input word 1 n−i would be accepted. Hence, q 0 = p i for all i, 0 ≤ i ≤ n. Furthermore, state p 0 is not accepting, while every state p i with i > 1 is accepting. Thus, p 0 = p i , for 1 ≤ i ≤ n. Since A has n states, there are i and j, 1 ≤ i, j ≤ n, with i = j, and p i = p j . Consider the smallest such i, that is, let i be the smallest number greater than 0 such that there is j > i and p i = p j . Then, δ( p i−1 , 1) ∩ δ( p j−1 , 1) = p i and p i−1 = p j−1 . Therefore, A is not reversible.
It is left to show that L ∈ L(revDCPCFA(2)) ∩ L(revDRCPCFA (2)). For proving this, we consider the deterministic PCFA For any 01 k , k ≥ 1, the computation of A is as follows: This computation is accepting as δ 1 (s 2 , ) is undefined and s 2 is an accepting state of A 1 . As the set of query states is empty, one may consider the DPCFA A to be centralized and both returning and non-returning. It is left to prove that the PCFA A is reversible.
-If, in a configuration reached, the pair of states is (s 1 , p 1 ), then the first component has made a move reading 0 from s 0,1 , while the second component has made a λ-move coming from s 0,2 , and the predecessor configuration must have been the initial one. -If the states reached are (s 2 , p 2 ), then both components made a non-λ-move. If the symbol read by the second component was 0, then, for any configuration (01 k , s 2 , i, p 2 , j), the predecessor configuration must have been the configuration (01 k , s 1 , i − 1, p 1 , j − 1). In fact, in reachable configurations, i = 3 and j = 2 must hold. If the symbol read by the second component was 1, then the predecessor configuration of (01 k , s 2 , i, p 2 , j) must have been (01 k , s 2 , i − 1, p 2 , j − 1). -Configurations with other states are not reachable.
Examples 1 and 2 show that the following theorem holds.
Next, we study the relationship of deterministic and non-deterministic centralized systems. In the not necessarily reversible case, deterministic systems are strictly weaker both in returning and non-returning modes, see [4] for details. For reversible PCFA, we can show a similar result for the non-returning case.
is the family of languages accepted by k-head deterministic finite automata as defined in, e.g., [20]. But L nonpal / ∈ L(k-DFA) for any k ≥ 1. To see this, recall that L(k-DFA) is closed under complementation and under intersection with regular sets, thus, but this is not the case, as stated, for example, in [21].
To see that L nonpal ∈ L(revCPCFA), consider the centralized PCFA system where A 1 = ({s 0,1 , s a , s a , s b ,  We show that this system is reversible and it accepts the language L nonpal = { $w | w ∈ {a, b} + , w = w R } To see how A works, consider first an initial configuration (α, s 0,1 , 1, s 0,2 , 1, s 0,3 , 1). Notice that α = $α for some α ∈ (a + b) * or the second component cannot read through the input. Note also that if $w is accepted, then |w| ≥ 2. To see this, consider a computation on a (shorter) input of the form $x, x ∈ {λ, a, b}. The first step of the computation of A is ($ x, s 0,1 , 1, s 0,2 , 1, s 0,3 , 1) ($x, s, 1, s y , 2, s 0,3 , 2) where s ∈ {s 0,1 , q 2 }, y ∈ {a, b}. Note that this computational step is reversible, since the states imply that the first component made a λ-reading step with the previous state being s 0,1 , while the other two components made non-λ-reading steps. Considering that the $ symbol was read by these components, we can also deduce that their previous states were s 0,2 and s 0,3 , respectively. Now, if x = λ or y = x, then the system is in a non-accepting blocking configuration (or enters such a configuration with the following-also reversiblecommunication step) because of the definition of δ 2 . Because of these observations, it is sufficient to consider with s ∈ {s 0,1 , q 2 }, y ∈ {a, b, }. If y = , then the system is in a non-accepting blocking configuration (or enters such a configuration with the following communication), so we must have In both of these cases, the system is in a non-accepting blocking configuration (or enters such a configuration with the following communication step), and it is not difficult to see that all the above steps are also reversible. On the other hand, if in (1)  which is also a non-accepting blocking configuration, since, e.g., the first component has no transition for reading the end-of-input symbol in state s x . (Note that this last step is also reversible.) Consider now the computations on an input $w, |w| ≥ 2. These computations must start with ($ w, s 0,1 , 1, s 0,2 , 1, s 0,3 , 1) ($w, s, 1, s x , 2, s 0,3 , 2) for some s ∈ {s 0,1 , q 2 }, x ∈ {a, b}. If s = q 2 , we get , s x , 1, s x , 2, s 0,3 , 2).
Similarly, if the first component enters the query state q 2 in a later step, we have , s 0,1 , 1, s x , 2, s 0,3 , 2) . . . ($w, s 0,1 , 1, s x , k − 1, s 0,3 , k − 1) ($w, q 2 , 1, s y , k, s 0,3 , k) ($w, s y , 1, s y , k, s 0,3 , k) for x , y ∈ {a, b, } and some head position k. In any of these cases, the system reaches a configuration where x ∈ {a, b, } and k ≥ 2. If $w(k) = x, then this configuration is a non-accepting blocking one due to the definition of δ 2 . Otherwise, such a configuration records the information that the kth symbol on the input tape is x (where k is "nondeterministically chosen"). This ends the first phase of the computation. To see that this phase is reversible, consider the following.
-If the states of the components are (s 0,1 , recording the information that the kth symbol on the input tape is x for some k ≥ 2 and x ∈ {a, b}. (If $w(k) = x or x = , then the computation cannot continue.) The next phase of the computation makes sure that w is not a palindrome by checking that the symbol at position (|$w| − (k − 2)) of the input (the kth position counting from the end of the input) is different from x.
is performed, then $w( j +1) = x. Now, it remains to be seen that the accepting configuration can only be reached if j + 1 = (|$w| − (k − 2)), that is, if w is a non-palindrome. In order to successfully terminate, the configurations above must be with s y = s , s = s f and s = s acc , then we get ($w, q 3 , 1 + j + 1, s f , k + j + 1, s acc , k + j + 1) ($w, s acc , 1 + j + 1, s f , k + j + 1, s acc , k + j + 1) which is an accepting configuration. Since the position of the end-of-input symbol on the tape is the (k + j)th position, we have that |$w| = k + j − 1 which means that (|$w| − (k − 2)) = j + 1, so the input must have been a non-palindrome. If j has a different value as above, then either we have a non-accepting blocking configuration of the form ($w, s x , 1 + j + 1, s f , k + j + 1, s acc , k + j + 1), or we have ($w, q 3 , 1 + j + 1, s y , k + j + 1, s 0,3 , k + j + 1) for y ∈ {a, b, }, and then a non-accepting blocking configuration after the communication, namely ($w, s 0,3 , 1 + j + 1, s y , k + j + 1, s 0,3 , k + j + 1).
From these considerations, we can see that L(A) = L nonpal , what remains to be shown is the reversibility of the second phase of the computation. To this aim, consider the following.
-If the states of the components are (q 3 , s y , s 0,3 ) for some y ∈ {a, b, }, then all components performed non-λ reading steps. If the symbol read by the first and the second components was x and z in {a, b}, respectively, then for any configuration ($w, q 3 , 1 + i, s y , k + i, s 0,3 , k + i), the previous configuration must have been ($w, s y , i, s z , k + i − 1, s 0,3 , k + i − 1) where y = x. -If the states of the components are (s x , s f , s acc ), then all components performed nonλ reading steps. If the symbol read by the first component was $, then for any configuration ($w, s x , 1 + i, s f , k + i, s acc , k + i), the previous configuration must have been ($w, s x , i, s , k + i − 1, s 0,3 , k + i − 1). If the symbol read by the first component was different from $, then the previous configuration must have been ($w, s x , i, s , k + i − 1, s 0,3 , k + i − 1). -If the states of the components are (s acc , s f , s acc ) or (s 0,3 , s x , s 0,3 ) for some x ∈ {a, b, }, then the previous computational step was a communication. In this case, for any configuration ($w, s acc , 1 + i, s f , k + i, s acc , k + i) or ($w, s 0,3 , 1 + i, s x , k + i, s 0,3 , k + i), the previous configurations must have been ($w, q 3 , 1 + i, s f , k + i, s acc , k + i) or ($w, q 3 , 1 + i, s x , k + i, s 0,3 , k + i), respectively.
PCFA. It was shown that there are reversible PCFA that have non-reversible components and there are non-reversible PCFA in which every component is a reversible finite state automaton. Examples demonstrate that the weakest types of (non-trivial) reversible PCFA, namely reversible deterministic centralized PCFA of degree 2, can recognize non-contextfree languages, both in returning and in non-returning communication mode. Furthermore, there is a language which can be recognized with a reversible non-deterministic centralized PCFA in non-returning mode, but it cannot be accepted by any deterministic PCFA. The question whether or not the same statement is true also for reversible non-deterministic returning centralized PCFA is left open here. But there are many more questions regarding the computational power of reversible PCFA that are left for future research work, for instance: -What is the relation between reversible centralized and non-centralized PCFA (deterministic or not)? -What is the relation between reversible centralized returning and non-returning PCFA (deterministic or not)? -What is the relation between reversible PCFA and reversible one-way multi-head finite automata (deterministic or not)?
As to the latter question, it is obvious that deterministic (non-deterministic) reversible one-way multi-head finite automata can simulate any type of reversible deterministic (nondeterministic) PCFA. It is to be examined whether the proofs showing the other direction (e.g., see [4]) can be adapted to the reversible case.
Moreover, several decidability problems should be investigated in future research on reversible PCFA, such as: -Given a PCFA A, is A reversible? -Given a PCFA language L, can L be accepted by a reversible PCFA (of the same type)?
Funding Open Access funding enabled and organized by Projekt DEAL.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.