Iterative arrays with self-verifying communication cell

We study the computational capacity of self-verifying iterative arrays (SVIA\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\text {SVIA}}$$\end{document}). A self-verifying device is a nondeterministic device whose nondeterminism is symmetric in the following sense. Each computation path can give one of the answers yes, no, or do not know. For every input word, at least one computation path must give either the answer yes or no, and the answers given must not be contradictory. It turns out that, for any time-computable time complexity, the family of languages accepted by SVIA\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\text {SVIA}}$$\end{document}s is a characterization of the so-called complementation kernel of nondeterministic iterative array languages, that is, languages accepted by such devices whose complementation is also accepted by such devices. SVIA\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\text {SVIA}}$$\end{document}s can be sped-up by any constant multiplicative factor as long as the result does not fall below realtime. We show that even realtime SVIA\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\text {SVIA}}$$\end{document} are as powerful as lineartime self-verifying cellular automata and vice versa. So they are strictly more powerful than the deterministic devices. Closure properties and various decidability problems are considered.


Introduction
One of the central questions in complexity and language theory asks for the power of nondeterminism in boundedresource computations.Traditionally, nondeterministic devices have been viewed as having as many nondeterministic guesses as time steps.The studies of this concept of unlimited nondeterminism led, for example, to the famous open LBA-problem or the unsolved question whether or not P equals NP.In order to gain a better understanding of the nature of nondeterminism, in Fischer and Kintala (1979) and Kintala (1977) it has been viewed as an additional limited resource at the disposal of time or space bounded computations.
The concept of so-called self-verification at least dates back to the paper (Duris et al. 1997).It applies to automata for decision problems and makes use of stronger notions of acceptance and rejection of inputs.
A self-verifying device is a nondeterministic device whose nondeterminism is symmetric in the following sense.Each computation path can give one of the answers yes, no, or unknown.For every input word, at least one computation path must give either the answer yes or no, and the answers given must not be contradictory.So, if a computation path gives the answer yes or no, in both cases the answer is definitely correct.This justifies the notion self-verifying and is in contrast to the general case, where an answer different from yes does not allow to conclude whether or not the input belongs to the language.Here we study the computational capacity of self-verifying iterative arrays (SVIA).
Self-verifying finite automata have been introduced and studied in Duris et al. (1997) and Hromkovic andSchnitger (2001, (2003) mainly in connection with randomized Las Vegas computations.Descriptional complexity issues for self-verifying finite automata have been studied in Jira ´skova ´and Pighizzini (2011).In particular, the conversion of self-verifying finite automata to deterministic finite automata from a state complexity point of view is solved there.The main results are matching upper and lower bounds growing like 3 n=3 for the costs, in terms of the number of states, of such simulations.
Another question that motivates the concept of selfverification is as follows.Given a language such that also its complement belongs to the same family, the description of which of both is more economic (Ilie et al. 2000)?For example, in Jira ´skova ´ (2005) it is shown that a nondeterministic finite automaton can require 2 n states to accept the complement of a language accepted by an n-state nondeterministic finite automaton.So, a representation of the complement by the n-state automaton together with a bit that says that actually the complement of the language accepted is meant is much more economic.
The computational and descriptional complexity of selfverifying pushdown automata has been studied in Fernau et al. (2017).Self-verifying cellular automata have recently been introduced in Kutrib and Worsch (2020), where it turned out that realtime self-verifying one-way cellular automata (SVOCA) are strictly more powerful than realtime deterministic one-way cellular automata, since they can accept non-semilinear unary languages.Moreover, SVOCAs as well as their two-way variant can strongly be sped-up from lineartime to realtime and they are even capable to simulate any lineartime computation of deterministic two-way cellular automata in realtime.Closure properties of the family of languages accepted by realtime SVOCAs are considered as well, where the closure under concatenation, iteration (Kleene star), and non-erasing homomorphisms are left open.Furthermore, decidability problems are studied.
The paper is organized as follows.In Sect. 2 we present the basic notation and the definitions of self-verifying iterative arrays as well as an introductory example.In general, the symmetric conditions for acceptance/rejection of self-verifying devices imply immediately the effective closures of the language families accepted under complementation.In Sect. 3 this observation is turned in a characterization.Moreover, the strong speed-up by a multiplicative constant is derived for any time-computable time complexity.In Sect. 4 we explore the computational capacity of realtime SVIAs.In particular, its is shown that even realtime SVIAs are as powerful as lineartime self-verifying cellular automata and vice versa.So they are strictly more powerful than deterministic iterative arrays.By mutual simulations of iterative arrays and cellular automata it turns out that, in fact, the sequential input mode of iterative arrays and the parallel input mode of cellular automata as well as realtime and lineartime all lead to the same language family for nondeterministic devices and for self-verifying devices.This is certainly not true for larger time complexities, since cellular automata obey a linear space bound where iterative arrays are semi-infinite.
Several closure properties of the family of languages accepted by realtime SVIAs are inherited from the results on realtime SVOCAs.Moreover, the open property under concatenation can be shown in terms of iterative arrays in Sect. 5. Finally, decidability problems are considered in Sect.6.In particular, by a reduction of the emptiness problem it is shown that the property of being self-verifying is non-semidecidable.

Preliminaries and definitions
We denote the non-negative integers by N. Let R denote a finite set of letters.Then we write R Ã for the set of all finite words (strings) consisting of letters from R. The empty word is denoted by k, and R þ ¼ R Ã nfkg.For the reversal of a word w we write w R and |w| denotes its length.A subset of R Ã is called a language over R. In general, we use for inclusions and & for strict inclusions.
A one-dimensional iterative array is a linear, semi-infinite array of finite state machines (sometimes called cells) that are identical except for the leftmost one.All but the leftmost cells are connected to their both nearest neighbors, respectively (see Fig. 1).For convenience we identify the cells by their coordinates, that is, by non-negative integers.The leftmost cell is distinguished.This so-called communication cell is connected to its right neighbor and, additionally, to the input supply which feeds the input sequentially.We assume that once the whole input is consumed an end-of-input symbol is supplied permanently.At the outset of a computation all cells are in the so-called quiescent state.The cells work synchronously at discrete time steps.Here we assume that the communication cell is a nondeterministic finite automaton while all the other cells are deterministic ones (cf.Buchholz et al. 2003).Although this is a very restricted case, for easier writing we call such devices nondeterministic.
More formally, a nondeterministic iterative array (NIA, for short) is a system A configuration of M at time t !0 is a pair ðw t ; c t Þ, where w t 2 R Ã is the remaining input sequence and c t :

Fig. 1 Initial configuration of an iterative array
N !S is a mapping that maps the single cells to their current states.The initial configuration ðw 0 ; c 0 Þ is defined by the given input w 0 2 R Ã and the mapping c 0 ðiÞ ¼ s 0 , i !0. Subsequent configurations are computed by the global transition function D that is induced by d d and d nd as follows: Let ðw t ; c t Þ, t !0, be a configuration.Then the set of its possible successor configurations ðw tþ1 ; c tþ1 Þ is defined as follows: An input w is accepted by an NIA M if at some time step during the course of at least one computation for w the communication cell enters an accepting state.The language accepted by M is denoted by LðMÞ ¼ f w 2 R Ã j w is accepted by M g.Let t : N !N, tðnÞ !n þ 1 be a mapping.If for each w 2 LðMÞ there is an accepting computation with at most t(|w|) time steps, then M and L(M) are said to be of time complexity t.
In general, the family of all languages which are accepted by some type of device X with time complexity t is denoted by L t ðXÞ.If t is the function n þ 1, acceptance is said to be in realtime.Since for nontrivial computations an iterative array has to read at least one end-of-input symbol, realtime has to be defined as ðn þ 1Þ-time.We write L rt ðXÞ for realtime and L lt ðXÞ for lineartime.Now we turn to self-verifying iterative arrays (SVIA).Basically, an SVIA is an NIA, but the definition of acceptance is different.There are now three disjoint sets of states representing answers yes, no, and neutral.Moreover, for every input word, at least one computation path must give either the answer yes or no, and the answers given must not be contradictory.In order to implement the three possible answers the state set is partitioned into three disjoint subsets , where F þ is the set of accepting states, F À is the set of rejecting states, and For each input word w 2 R Ã , let S w denote the set of states entered by the communication cell during any computation on w, that is, In the sequel we will often utilize the possibility of iterative arrays to simulate the data structures pushdown stores (stacks) (Buchholz and Kutrib 1997;C ˇulik and Yu 1984), queues, and rings (Kutrib 2008) without any loss of time.Here a ring is a queue that can write and erase at the same time.For pushdown stores the communication cell simulates the top of the store, for queues it simulates the front, and for rings the front and the end of the store.
For the sake of completeness, we recall exemplarily the principle of a pushdown store simulation from Kutrib (2008).It suffices to use three additional racks for the simulation.Let the three pushdown registers of each cell be numbered one, two, and three from top to bottom, and suppose that the third register is connected to the first register of the right neighbor.The content of the pushdown store is identified by scanning the registers in their natural ordering beginning in the communication cell, whereby empty registers are ignored.The pushdown store dynamics of the transition function is defined such that each cell prefers to have only the first two registers filled.The third register is used as a buffer.In order to reach that charge it obeys the following rules (cf.Fig. 2).
1.If all three registers of its left (upper) neighbor are filled, it takes over the symbol from the third register of the neighbor and stores it in its first register.The old contents of the first and second registers are shifted to the second and third register.2. If the second register of its left neighbor is free, it erases its own first register.Observe that the erased symbol is taken over by the left neighbor.In addition, the cell stores the content of its second register into its first one, if the second one is filled.Otherwise, it takes the symbol of the first register of its right neighbor, if this register is filled.3. Possibly more than one of these actions are superimposed.
We illustrate the definitions with an example.
Example 1 The nondeterministic context-free language f w 2 fa; bg Ã j w ¼ w R g is accepted by the SVIA The basic idea is to simulate a stack whose top is the communication cell.So, we set S ¼ ðfs 0 ; s 1 ; s Here S pd are the register contents used by the communication cell to manage the top entries of the stack, while Ŝpd are the non-quiescent states of all but the communication cell, that realize the stack.So, the transition function d d just realizes the interior of the stack and is omitted here.
The idea of the construction of d nd is summarized in the following table and described below.See Fig. 3 for a transition diagram of the communication cell.Since we did not make S pd explicit in detail and since the state of the right neighbor of the communicating cell is only needed for updating its part of the stack, the right neighbor state is left out in the table and the figure.The current state of the communication cell is indicated as ðs i ; y. ..Þ or ðs i ; ?Þ meaning that at the top of the stack is a symbol y 2 fa; bg or the stack is empty.A transition to xy. . .means that x has been pushed onto, and a transition to ÁÁÁ means that y has been popped from the stack.
The communication cell enters the accepting state if it is in the quiescent state while reading the end-of-input symbol, that is, if the input is the empty word (Transition 1).If the input is non-empty, the communication cell enters state s 1 (in its first state register) which is used to read and push the symbols of the first part of the input (Transitions 2-5).Then by Transitions 6-9 it is guessed whether the length of the input is odd or even and whether the center of the input is reached.If the guess is odd then the sole symbol without matching mate at the center is simply read without pushing it (Transitions 6-7).If the guess is even then the last symbol of the left part has to be matched and is pushed (Transitions 8-9).Now, state s 2 is entered.Once in state s 2 , the SVIA M compares the pushdown contents with the remaining input by Transitions 10 and 11.If a mate is not matching, state s 3 is entered (Transitions 12 and 13).Once in state s 3 , the remaining input is further read, whereby one symbol is popped in each step (Transitions 14 and 15).
Consider the point in time after M is in state s 2 for the first time and let v denote the part of the input that has been pushed to the stack at that time and let u denote the part of the input that still has not been read.Then the input is vxu if the length of the input has been guessed to be odd, and the input is vu if the length of the input has been guessed to be even.If the communication cell switched from s 1 to s 2 ''at the right time and in the right way'', that is juj ¼ jvj, then it will for the first time see input C and the empty stack ?simultaneously.In this situation, M knows that the guess was correct and it can accept (Transition 16) or reject (Transition 17).
If the communication cell switched from s 1 to s 2 ''at the wrong time or in a wrong way'', that is juj 6 ¼ jvj, then it ðs À ; ?Þ reject since there was a mismatch cannot decide whether the input is a palindrome.This can be recognized by M since either all input symbols have been consumed but the stack is not empty or the stack is empty but not all input symbols have been consumed.In this case the computation blocks in one of the states from fs 1 ; s 2 ; s 3 g which are neutral states.
So, the communication cell comes to a decision yes or no if and only if it has guessed the center of the input correctly.Moreover, the answer is correct.

Structural properties and speed-up
Though we are mainly interested in fast computations, that is, realtime and lineartime computations, we allowed general time complexities in the definition of the devices (see Kutrib (2009) for a discussion of this general treatment of time complexity functions).However, it seems to be reasonable to consider only time complexities t that allow the communication cell to recognize the time step t(n).Such functions are said to be time-computable.For example, the function tðnÞ ¼ n þ 1 is trivially a time-computable time complexity for IAs.
Other examples are time complexities b y x Á nc, for any positive integers x\y, polynomials tðnÞ ¼ n k , and exponential time complexities tðnÞ ¼ k n , for any integer k ! 2.More details can be found in Mazoyer and Terrier (1999).
In general, the symmetric conditions for acceptance/rejection of self-verifying devices imply immediately the effective closures of the language families accepted under complementation.In order to turn this observation in a characterization, we first give evidence that self-verifying iterative arrays are in fact a generalization of deterministic x, y push(x) x, y Lemma 2 Any deterministic iterative array with a timecomputable time complexity t can effectively be converted into an equivalent self-verifying iterative array with the same time complexity t.
The proper inclusion L rt ðIAÞ & L rt ðNIAÞ is well known (Buchholz et al. 2003).So, nondeterminism strengthens the computational capacity of iterative arrays.On the other hand, it is an open problem whether the family L rt ðNIAÞ is closed under complementation.Therefore, the question whether the family L rt ðSVIAÞ is properly included in L rt ðNIAÞ, or whether both families coincide, is of natural interest.Next we turn to relate it to the open complementation closure of L rt ðNIAÞ.
Proposition 3 Let t be a time-computable time complexity.The family of languages L 2 L t ðNIAÞ, such that the complement L belongs to L t ðNIAÞ as well, coincides with the family L t ðSVIAÞ.
Proof Given a t-time SVIA M, it is straightforward to construct an NIA that accepts the complement of L(M) with the same time complexity t.
Conversely, let M 1 be an NIA accepting L and M 2 be an NIA accepting L with time complexity t.Now a t-time selfverifying iterative array M simulates M 1 and M 2 on different tracks, that is, it uses the same two channel technique of Dyer (1980) and Smith (1972).
Then it remains to define the set of accepting states as F þ ¼ f ðs; s 0 Þ j s 2 F 1 g and the set of rejecting states as F À ¼ f ðs; s 0 Þ j s 0 2 F 2 g, where F 1 is the set of accepting states of M 1 and F 2 is the set of accepting states of M 2 .h Proposition 3 implies that L rt ðSVIAÞ is properly included in L rt ðNIAÞ if and only if L rt ðNIAÞ is not closed under complementation; otherwise both families coincide.
While iterative arrays fetch their input sequentially through the communication cell, so-called cellular automata obey a parallel input mode.In a preinitial step their cells fetch an input symbol.That is, there are as many cells as input symbols.So, a deterministic two-way cellular automaton (CA) is a linear array of identical deterministic finite automata which are numbered 1; 2; . ..; n.Except for border cells the state transition depends on the current state of a cell itself and those of its both nearest neighbors.Border cells receive a boundary symbol # on their free input lines.In a one-way cellular automaton (OCA) the next state of each cell only depends on the state of the cell itself and the state of its immediate neighbor to the right.An input w is accepted by a cellular automaton if at some time step during some computation the leftmost cell enters an accepting state.For cellular automata, realtime is defined to be tðnÞ ¼ n.Cellular automata whose first state transitions are nondeterministic and whose further transitions are deterministic (NCA, NOCA) are studied in Buchholz et al. (2002).Cellular automata that have the self-verifying property (SVCA, SVOCA) are considered in Kutrib and Worsch (2020).
It is well known that deterministic (one-way) cellular automata and deterministic iterative arrays can be sped-up from ðn þ tðnÞÞ-time to ðn þ tðnÞ k Þ-time, for any integer k [ 0 (Bucher and C ˇulik 1984;Ibarra and Jiang 1987;Ibarra et al. 1985;Ibarra and Palis 1985).Thus, lineartime is close to realtime.However, for deterministic one-way cellular automata and iterative arrays, lineartime is strictly more powerful than realtime.The problem is still open for deterministic two-way cellular automata.Concerning nondeterministic cellular automata, the results in Buchholz et al. (2002) show that, in fact, one-way or two-way information flow and realtime or lineartime do not make a difference, that is, the family of languages accepted by realtime NOCAs coincides with the family of languages accepted by lineartime NCAs.However, to our knowledge, these properties and relations are not known for iterative arrays.In order to study them, next, we turn to strong speed-up results for self-verifying iterative arrays.
Theorem 4 Let k ! 1 be a constant and t be a time complexity.Then the families L kÁt ðSVIAÞ and L t ðSVIAÞ coincide.
Proof A given ðk Á tÞ-time SVIA M is simulated by a ttime SVIA M 0 as follows.Basically, M 0 performs two tasks in parallel on different tracks.
For the first task, assume that the input is fed to the communication cell of M 0 in k-symbol blocks, that is, k input symbols in each step.Then each k cells of M 0 are grouped together into one cell.In this well-known way the iterative array M 0 can simulate k steps of M in one step.That is, this task of M 0 has time complexity t and the selfverifying property, since M has time complexity k Á t and the self-verifying property.
The second task of M 0 is to make the assumption for the first task true.To this end, it simulates a ring store whose front (and end) is the communication cell.Now the communication cell starts to guess k input symbols in every step.These symbols are fed to the first task.Additionally, the communication step guesses when the end-of-input symbol appears.From that time step on no further input symbols are guessed.In order to verify that the guesses are correct, the k symbols are entered at the end of the ring store respectively.In each step, the symbol at the front of the ring is removed and compared with the actual input symbol.If both match, the guessed symbol is correct, otherwise it is not.In case of a mismatch or a wrongly guessed number of input symbols the second task remains in a neutral state.If it has guessed the input correctly, it enters a positive state.
Finally, M 0 accepts if and only if the second task guesses the input correctly and the first task accepts.That is, if the actual input is accepted by M. The iterative array M 0 rejects if and only if the second task guesses the input correctly and the first task rejects.That is, if the actual input is rejected by M. So, M 0 has the self-verifying property.h In particular, we conclude: Corollary 5 The families L rt ðSVIAÞ and L lt ðSVIAÞ coincide.

Computational capacity
The first question in connection with the computational capacity of realtime SVIA is the impact of the (restricted) nondeterminism.Does it increase the capacity?More precisely, we are interested in the question whether the computing power of realtime SVIA is strictly stronger than that of realtime IA.
Example 1 shows that the mirror language is accepted by a realtime SVIA.However, by using a completely different algorithm the language is accepted by some deterministic realtime IA as well (Cole 1969).So, it cannot be used as a witness for the strictness of the inclusion L rt ðIAÞ & L rt ðSVIAÞ.Nevertheless, the strictness follows from a more general result below and is stated in Proposition 11.
The context-free languages form another important language family.The possibility to simulate a pushdown store whose top is simulated by the self-verifying communication cell suggests to compare the family L rt ðSVIAÞ with the family of context-free languages.In Fernau et al. (2017) self-verifying pushdown automata are considered which accept a strict sub-family of the context-free languages.The simulation of a self-verifying pushdown automaton by a realtime SVIA is straightforward.On the other hand, even deterministic realtime iterative arrays accept non-context-free languages, for example the ''copy language'' f ww j w 2 fa; bg Ã g (Cole 1969).

Corollary 6
The family of languages accepted by selfverifying pushdown automata is strictly included in the family L rt ðSVIAÞ.
In order to discuss further comparisons we now turn to results that show the strong computational capacity of realtime SVIAs.First, we turn to nondeterministic devices and show that sequential or parallel input mode induce the same computational capacity as long as the time complexity is linearly bounded.
Lemma 7 The family L lt ðNIAÞ is included in L lt ðNCAÞ.
Proof Let M be some lineartime NIA with state set S and set of input symbols R. By the known speed-up results we can safely assume that M accepts in 2n-time.Now we construct an equivalent 2n-time NCA M 0 as follows (see Fig. 4).
Since M works in 2n-time, no more than 2n cells of the array are used (n denotes the length of the input).So, each of the n cells of M 0 simulates two cells of M. In particular, the leftmost cell of M 0 simulates the communication cell of M together with the first deterministic cell of M. Cell 2 i n of M 0 simulates cells 2ði À 1Þ and 2ði À 1Þ þ 1 of M (which are initially quiescent).
Basically, M 0 uses three tracks after the first time step.On the first track the input is successively shifted to the left to feed the simulated communication cell of M, where # symbols are appended at the right.On the third track, the cells of M are simulated, that is, each cell of M 0 provides two registers on the third track.Also on the second track each cell of M 0 is split into two registers.During the first time step, all cells on the second track nondeterministically compute two mappings from the finite set of mappings ðR [ fCgÞ Â S Â S ! S and store them into their two registers.These are the first 2n guesses of the communication cell of M. The leftmost cell of M 0 additionally applies the first of its guessed mappings to its actual input symbol and the states s 0 and s 0 in order to determine the new state of the communication cell of M.
In subsequent transitions, the guessed mappings are successively shifted to the left, register by register.The leftmost cell of M 0 deterministically simulates the nondeterministic behavior of the communication cell of M by applying the next mapping to the current local configuration.When the leftmost cell received the border symbol # in the nth step it simulates further steps of the communication cell of M on the end-of-input symbol C. In all but the left register of the leftmost cell M 0 simulates the deterministic transitions of M.
In this way, M 0 accepts if and only if M accepts.h Lemma 7 gives an upper bound for languages accepted by lineartime NIAs.It shows that a sequential input mode and one nondeterministic cell can be traded for parallel input mode and all cells nondeterministic once only.In fact, it will turn out that the upper bound is sharp.
Lemma 8 The family L lt ðNCAÞ is included in L rt ðNIAÞ.
Proof The possibility to speed-up NCAs by a constant factor is shown in Buchholz et al. (2002).That is, L lt ðNCAÞ ¼ L rt ðNCAÞ.So, given some realtime NCA M with state set S and set of input symbols R, we construct an equivalent realtime NIA M 0 as follows.Basically, M 0 works in three phases.First it guesses and generates a configuration that represents the fourfold packed initial configuration of M. Then this packed part is synchronized.Finally, the synchronized cells simulate M whereby four steps are simulated in one step.The phases are depicted in Fig. 5.In parallel, the guesses are verified.
Phase 1 Let n denote the length of the input.In the following we assume that n þ 1 is a multiple of four.The generalization of the simulation to the other cases is a straightforward adaption.In order to verify that the guesses are correct, the four symbols are entered at the end of a ring store respectively.In each step, the symbol at the front of the ring is removed and compared with the actual input symbol.If both match, the guessed symbol is correct, otherwise it is not.In case of a mismatch or a wrongly guessed number of input symbols the computation blocks in a neutral state.
Phase 2 At time step nþ1 4 þ 1 the communication cell initiates an FSSP synchronization of the leftmost n 4 cells.The blocks of four input symbols together with the corresponding mappings arrive at their destination cells 0 i nþ1 4 À 1 at time 2i þ 1.The initial signal for the FSSP arrives at cell i at time So, each cell starts Phase 2 after finishing Phase 1. Altogether, Phase 2 is finished when all cells are synchronized at time Phase 3 Due to the compressed representation, M 0 can simulate M with fourfold speed.In order to simulate the nondeterministic transitions which the cells of M perform during the first time step, the cells of M 0 apply the nondeterministically guessed mappings to their local configurations.Thus, M 0 simulates the nth step of M at time step 3 Since the verification of the guessed input takes n þ 1 time steps, we conclude that the total time complexity of Finally, M 0 accepts if and only if the input has been guessed correctly and M accepts.So, we have LðM 0 Þ ¼ LðMÞ.h Lemmas 7 and 8 reveal L lt ðNIAÞ L lt ðNCAÞ L rt ðNIAÞ.Together with the trivial inclusion L rt ðNIAÞ L lt ðNIAÞ and the results in Buchholz et al. (2002), we obtain the equality of the next theorem.
Since the linear functions tðnÞ !n are time computable by one-way cellular automata as well as by iterative arrays, Proposition 3 and a similar proposition for cellular automata from Kutrib and Worsch (2020) can be used to build the bridge from nondeterministic to selfverifying devices.
Proof By Theorem 9, all language families L rt ðNIAÞ, L lt ðNIAÞ, L lt ðNCAÞ, L rt ðNCAÞ, L rt ðNOCAÞ, and L lt ðNOCAÞ coincide.So, all families consisting of the complements of the languages from the original families coincide as well.Now Proposition 3 and a similar proposition for cellular automata from Kutrib and Worsch (2020) imply that all language families L rt ðSVIAÞ, L lt ðSVIAÞ, L lt ðSVCAÞ, L rt ðSVCAÞ, L rt ðSVOCAÞ, and L lt ðSVOCAÞ are identical.h In particular, now we can deduce that even the restricted nondeterminism gained in considering a self-verifying communication cell strictly increases the computational capacity of realtime iterative arrays.That is, the inclusion L rt ðIAÞ & L rt ðSVIAÞ is strict.Proof The relations L rt ðIAÞ & L lt ðIAÞ ¼ L lt ðCAÞ are known (see, for example, Kutrib 2009).Since L lt ðIAÞ L lt ðSVIAÞ ¼ L rt ðSVIAÞ the assertion follows.h Theorem 10 shows that a sequential input mode and one nondeterministic cell can be traded for parallel input mode and all cells nondeterministic once only, and vice versa.To this end, it does not matter whether the computations are in realtime or lineartime.But what about the world beyond lineartime?Are self-verifying arrays stronger than deterministic ones?Or weaker than nondeterministic ones?The open question of the strictness of one of the inclusions L lt ðIAÞ¼ L lt ðCAÞ L rt ðSVCAÞ LðSVCAÞ LðNCAÞ is strongly related to famous open problems in complexity theory (see Kutrib 2015).Note that at the top of this hierarchy are devices that may have an exponential time complexity (due to the space bound).
5 Closure of the realtime self-verifying language family under concatenation The closure properties of the family L rt ðSVOCAÞ have been investigated in Kutrib and Worsch (2020).By Theorem 10 we know that these are the closure properties of the identical language family L rt ðSVIAÞ.It is known that the family is closed under the Boolean operations and reversal.
In particular, the closure under reversal is of crucial importance.
It is an open problem for L rt ðCAÞ and, equivalently, for L lt ðOCAÞ.Moreover, it is linked with the open closure property under concatenation for the same family and, hence, with the question whether lineartime CAs are more powerful than realtime CAs.It is known that the family L rt ðIAÞ is not closed under reversal, while the family L lt ðIAÞ is closed.
Concerning the operations homomorphism and inverse homomorphism, the closure of L rt ðSVIAÞ under inverse homomorphism and the non-closure under homomorphisms is known.
The question whether the family L rt ðSVOCAÞ is closed under concatenation is stated as an open problem in Kutrib and Worsch (2020).Here we can solve the problem in terms of self-verifying iterative arrays.
Proposition 12 The family of languages accepted by realtime SVIA is closed under concatenation.
belongs to the language L 1 .If input symbol y iþ1 is marked accepting by the simulation of M R 2 , the word y n y nÀ1 Á Á Á y iþ1 ¼ x n x nÀ1 Á Á Á x iþ1 belongs to the language L R 2 and, thus, x iþ1 x iþ2 Á Á Á x n belongs to the language L 2 .So, the input x 1 x 2 Á Á Á x n belongs to the concatenation L 1 Á L 2 .In this way, M can accept any input from L 1 Á L 2 and only inputs from the concatenation L 1 Á L 2 .
Case 2 x 1 Á Á Á x n 6 2 L 1 L 2 .In this case for each i either x 1 Á Á Á x i 6 2 L 1 or x n Á Á Á x iþ1 6 2 L R 2 or both.That means that for each i there are computations by M 1 and M R 2 for the respective inputs such that at least one of both rejects.Hence, there will be a computation of M which correctly explicitly rejects an input, if for any two adjacent cells always at least one of them is marked rejecting.In detail, if the test finds neither two adjacent cells marked accepting, nor two adjacent cells that are marked accepting and unmarked, nor two adjacent cells unmarked the communication cell enters a rejecting state.In this case, no matter between which two adjacent symbols one assumes the cut between first and second factor, M has explicitly rejected at least one of them.Clearly, in this case the input cannot belong to the concatenation.On the other hand, if some input does not belong to the concatenation, then there is always a computation of M that results in such a marking.So, M rejects any input that does not belong to L 1 Á L 2 and only inputs that do not belong to L 1 Á L 2 .In any other case, the leftmost cell remains in a neutral state.
For the computation on input of length n the SVIA M takes n þ 1 steps to read (and guess) the input for the tasks, and further n þ 1 steps to verify the guesses and test the markings.So, M works in lineartime which can be sped-up to realtime.h The closure properties of L rt ðSVIAÞ with respect to iteration (Kleene star) and non-erasing homomorphisms are still open problems.They are settled for nondeterministic devices since, basically, for iteration it is sufficient to guess the positions in the input at which words are concatenated, and for non-erasing homomorphism it is sufficient to guess the pre-image of the input.However, self-verifying devices have to reject explicitly if the input does not belong to the language.Intuitively, this means that they have to 'know' that all possible guesses either do not lead to accepting computations or are 'wrong.'The closure properties are summarized in Table 1.

Decidability questions
First we note that the membership problem is obviously decidable for SVIAs obeying a time-computable time complexity.
On the other hand, in Kutrib (2009) it is observed that for any language family that effectively contains L rt ðIAÞ, the problems emptiness, universality, finiteness, infiniteness, regularity, and context-freeness are not semidecidable.Since we know L rt ðIAÞ & L lt ðIAÞ L lt ðSVIAÞ ¼ L rt ðSVIAÞ we derive the next corollary.
In Kutrib and Worsch (2020) it is shown that the problem to decide whether a given realtime one-way cellular automaton is self-verifying or not is undecidable.Unfortunately, the result has no direct implications for the same question for iterative arrays.However, the undecidability for cellular automata is shown by a reduction of the emptiness problem.We turn to prove the undecidability for iterative arrays as well.Moreover, we use a reduction of the emptiness and universality problem, but the reduction itself is different.Since general iterative arrays do not have neutral or rejecting states (only accepting and non-accepting states), there is no partitioning of the state set.So, the decidability can be asked for a given fixed partitioning or for the existence of a partitioning.We first consider the latter question.
Theorem 14 Given a realtime (non)deterministic iterative array M with state set S and accepting states F þ , it is not semidecidable whether there exists F À ðS n F þ Þ such that M is an SVIA with respect to the sets F þ and F À .
The intention is that a $ in the input causes the IA to simulate a step on the end-of-input symbol C (in restricted form) and to reinitialize the computation by letting the cells enter the quiescent state again (which is impossible in M 0 ).Therefore, the transition function d 0 nd is basically d nd extended by transitions for the input symbol $ and the states p þ and p 0 .When a $ appears in the input, the communication cell enters state p þ if it could enter an accepting state on the end-of-input symbol C. For all s 1 ; s 2 2 S, Otherwise, it enters state p 0 : or p 0 the computation continues as it would from the very beginning.For p 2 fp þ ; p 0 g, all a 2 R 0 [ fCg, and all s 2 S 0 , d 0 nd ða; p; sÞ ¼ d 0 nd ða; s 0 ; s 0 Þ: In order to implement the reinitialization of the other cells, recall that d d drives no non-quiescent cell into the quiescent state.So, we can utilize the quiescent state as a signal sent by the communication cell.The signal causes the reinitialization of the cells passed through.So, the transition function d 0 d is basically d d extended as follows.For p 2 fp þ ; p 0 g and all s 1 ; s 2 2 S, d 0 d ðp;s 1 ;s 2 Þ ¼ s 0 ; d 0 d ðs 0 ;s 1 ;s 2 Þ ¼ s 0 ; d 0 d ðs 1 ;s 0 ;s 2 Þ ¼ dðs 1 ;s 0 ;s 0 Þ: Therefore, LðM 1 Þ consists of all concatenations of $ separated words u i such that at least one u i is in LðM 0 Þ.In particular LðM 1 Þ \ R Ã ¼ LðM 0 Þ.We claim that there exists F 0 À ðS 0 n F 0 þ Þ such that the iterative array M 2 ¼ hS 0 ; R 0 ; F 0 þ ; F 0 À ; s 0 ; C; d 0 nd ; d 0 d i is selfverifying if and only if LðM 0 Þ is empty or coincides with R Ã .Observe that LðM 2 Þ ¼ LðM 1 Þ because both have the same set of accepting states.
If LðM 0 Þ is empty then LðM 1 Þ is empty.Therefore, the communication cell will never enter an accepting state from F 0 þ .So, we safely may set F 0 À ¼ ðS 0 n F 0 þ Þ and obtain that M 2 is self-verifying.Similarly, if LðM 0 Þ ¼ R Ã then LðM 1 Þ ¼ R 0 Ã , and we safely may set F 0 À ¼ ; to obtain a self-verifying IA.Now assume that LðM 0 Þ and, thus, LðM 2 Þ neither be empty nor contain all words over the input alphabet.Then there exists some u 2 LðM 0 Þ and some v 6 2 LðM 0 Þ.We consider the computation of M 2 on input u$v.Since M 0 accepts u, the IA M 2 enters an accepting state while processing the input prefix u$ (its computation is a simulation of M 0 on uC).Then the computation of M 2 is reinitialized and continues with a simulation of M 0 on input v. Since v 6 2 LðM 0 Þ, in this phase, M 2 cannot accept v.However, since it already was in an accepting state and its overall answer is already yes, M 2 cannot enter a contradictory rejecting state in this phase.This implies that the communication cell of M 2 on input v will only assume neutral states and, thus, neither accept nor reject v.That is, M 2 is not self-verifying and the claim follows.
From the construction of M 2 and the claim we conclude that the semidecidability of the problem in question implies the semidecidability of the emptiness or universality problem for realtime IAs contradicting Corollary 13. h What about the undecidability if we provide a partitioning of its state set?Can we test if this partitioning makes the IA self-verifying?The answer is no, since for a given realtime iterative array with accepting state set F þ there are only finitely many partitions induced by setting F À ðS n F þ Þ.All these could be tested in parallel.Now the problem in question can be semidecided if the test is successful for at least one partitioning.
Corollary 15 Given a realtime (non)deterministic iterative array M with state set S and partitioning S ¼ F þ _ [F À _ [F 0 , it is not semidecidable whether M is an SVIA with respect to the partitioning.
By Lemma 2, any deterministic iterative with a timecomputable time complexity can effectively be made selfverifying.But it is non-semidecidable whether it already is self-verifying.This non-semi-decidability carries immediately over to nondeterministic iterative arrays.However, it is an open problem whether any nondeterministic iterative with a time-computable time complexity can effectively be made self-verifying.In fact, it is an open problem whether the family of languages accepted by realtime nondeterministic iterative arrays is closed under complementation or 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/.
Funding Open Access funding enabled and organized by Projekt DEAL.

Fig. 2
Fig. 2 Principle of a pushdown store simulation.Subfigures are in row-major order

Fig. 3
Fig.3Transition diagram of the communication cell of an SVIA accepting the language f w 2 fa; bg Ã j w ¼ w R g. Edges corresponding to transitions d nd ðx; ðs; yÞ; Þ are labeled x, y in the first line, and by the corresponding operation on the pushdown store in the second line.Here, x 2 fa; bg and x;x means a, b or b, a

Fig. 5
Fig. 5 Simulation phases R Ã , S w \ F þ is empty if and only if S w \ F À is nonempty.So, similarly as for acceptance, an input w is rejected by an SVIA if at some time step during the course of at least one computation on w the communication cell enters a rejecting state.Note that by the self-verifying property every input is either accepted or rejected.If all w 2 LðMÞ are accepted and all w 6 2 LðMÞ are rejected after at most t(|w|) time steps, then the self-verifying iterative array M is said to be of time complexity t.

Table 1
Closure properties of the language family L rt ðSVIAÞ ¼ L lt ðSVCAÞ in comparison with the families L rt ðIAÞ, L lt ðIAÞ ¼ L lt ðCAÞ, and L rt ðOCAÞ, where h k denotes k-free homomorphisms Proof Let M 0 ¼ hS; R; F þ ; s 0 ; C; d nd ; d d i be an arbitrary realtime IA.We safely may assume that a cell which has left the quiescent state will never enter the quiescent state again.This behavior can be implemented by adding a new state that plays the role of the quiescent state.If necessary, the new state can be entered instead of s 0 .We modify M 0 to M 1 ¼ hS 0 ; R 0 ; F 0 þ ; s 0 ; C; d 0 nd ; d 0 d i by adding a new input symbol $ and two new states p þ and p 0 .So, we set S 0