Hierarchies and undecidability results for iterative arrays with sparse communication

Iterative arrays with restricted internal inter-cell communication are investigated. A quantitative measure for the communication is defined by counting the number of uses of the links between cells and it is differentiated between the sum of all communications of an accepting computation and the maximum number of communications per cell occurring in accepting computations. The computational complexity of both classes of devices is investigated and put into relation. In addition, a strict hierarchy depending on the maximum number of communications per cell is established. Furthermore, it is shown that almost all commonly studied decidability questions are not semidecidable for iterative arrays with restricted communication. Finally, non-recursive trade-offs are proved among the iterative arrays providing the strict hierarchy depending on the maximum number of communications per cell.


Introduction
Devices of homogeneous, interconnected, parallel acting automata have extensively been investigated from a computational capacity point of view.The specification of such a system includes the type and specification of the single automata (sometimes called cells), their interconnection scheme (which can imply a dimension to the system), a local and/or global transition function, and the input and output modes.Multidimensional devices with nearest neighbor connections whose cells are finite automata are commonly called cellular automata (CA).If the input mode is sequential to a distinguished communication cell, they are called iterative arrays (IA).In connection with formal language recognition IA have been introduced in Cole (1969), where it was shown that the language family accepted by realtime-IA forms a Boolean algebra not closed under concatenation and reversal.In Chang et al. (1987) it is shown that for every context-free grammar a two-dimensional lineartime-IA parser exists.A realtime acceptor for prime numbers has been constructed in B Andreas Malcher andreas.malcher@informatik.uni-giessen.de 1 Institut für Informatik, Universität Giessen, Arndtstr.2, 35392 Giessen, Germany Fischer (1965).A characterization of various types of IA in terms of restricted Turing machines and several results, especially speed-up theorems, are given in Ibarra and Palis (1985), Ibarra and Palis (1988).Several more results concerning formal languages can be found, for example, in Smith (1972), Kutrib (2009).
Communication is an essential resource for cellular automata and can be measured in a qualitative way and a quantitative way.In the first case, the number of different messages to be communicated by an IA is bounded by some fixed constant.Iterative arrays with this restricted inter-cell communication have been investigated in Umeo andKamikawa (2002, 2003), with respect to the algorithmic design of sequence generation.In particular, it is shown that several infinite, non-regular sequences such as exponential or polynomial, Fibonacci, and prime sequences can be generated in real time.In connection with language recognition and decidability questions multi-dimensional iterative arrays and one-dimensional (one-way) cellular automata with restricted communication are intensively studied in Kutrib and Malcher (2009a, 2011), Worsch (2000).
To measure the communication in cellular automata in a quantitative way we count the number of uses of the links between cells and we consider, on the one hand, bounds on the sum of all communications of an accepting computation and, on the other hand, bounds on the maximum number of communications per cell that may appear in accepting computations.Many results on this quantitative measure have been obtained for cellular automata in Kutrib and Malcher (2010a, b), and cellular automata that are restricted with respect to the qualitative and the quantitative measure are investigated in Kutrib andMalcher (2009b, 2010b), as well.
As main results we would like to mention hierarchy results and the undecidability of almost all commonly studied decidability questions such as emptiness, finiteness, equivalence, inclusion, regularity, and context-freeness.It is of particular interest that even a small amount of communication is sufficient to obtain undecidability results.
In this paper, we want to continue the investigation of the quantitative measure by studying iterative arrays with quantitatively restricted communication.In the next section, we present some basic notions and definitions and we introduce the two classes of communication bounded iterative arrays, namely, sum communication bounded IA and max communication bounded IA.Moreover, we discuss several examples whose construction ideas are also helpful for other constructions in the sequel.In Sect.3, we study the computational capacity of the introduced devices and obtain proper inclusions inside the classes of sum communication bounded IA and max communication bounded IA.Furthermore, results separating both classes are given as well.Sections 4 and 5 are devoted to studying decidability questions for sum communication bounded IA and max communication bounded IA.For the former class we obtain the non-semidecidability of emptiness, finiteness, equivalence, inclusion, regularity, and context-freeness for devices that have at most O(n) communications on accepted inputs of length n, whereas for the latter class all questions are not semidecidable as well for devices that have at most O(invfac(n)) communications per cell on accepted inputs of length n.Here, invfac(n) denotes the inverse function to the factorial function n!.Moreover, we can show for both classes that it is not semidecidable whether an arbitrary IA belongs to either class.Finally, in Sect.6 we study the descriptional complexity of max communication bounded IA.One main goal in the field of descriptional complexity, see, for example Holzer and Kutrib (2010), is to compare different descriptional systems and to establish so-called trade-offs which describe the increase in size when changing from one system to another.Apart from recursive trade-offs, where the increase in size is bounded by some recursive function, it is known that there exist non-recursive trade-offs where the increase in size when changing from one system to another cannot be bounded by any recursive function.Such non-recursive trade-offs are already known, see, for example Kutrib and Malcher (2018), Malcher (2004), between several types of cellular automata and IA.Here, we complement these results by establishing some non-recursive trade-offs between the types of max communication bounded IA that lead to proper inclusions shown in Sect.3.

Definitions and preliminaries
We denote the positive integers and zero {0, 1, 2, . ..} by N and the positive integers by N + .We write A * for the set of all words over the finite alphabet A. The empty word is denoted by λ, the reversal of a word w by w R , and for the length of w we write |w|.The set of non-empty words is defined as A * \ {λ}.We use ⊆ for inclusions and ⊂ for strict inclusions.By log(n) we denote the logarithm of n to base 2 and by n! we denote the factorial of n.In this paper, we define the inverse f −1 of a function f : In particular, the inverse of the factorial n! in this sense is denoted by invfac(n).Since n! grows asymptotically faster than 2 n , but slower than 2 2 n , it is clear that invfac(n) belongs to o(log(n)) ∩ ω(log(log(n))).Throughout the article two devices are said to be equivalent if and only if they accept the same language.
A one-dimensional iterative array is a linear, semi-infinite array of identical deterministic finite state machines, sometimes called cells.Except for the leftmost cell each one is connected to its both nearest neighbors.For convenience we identify the cells by their coordinates, that is, by non-negative integers.The distinguished leftmost cell at the origin is connected to its right neighbor and, additionally, equipped with a one-way read-only input tape.At the outset of a computation the input is written on the input tape with an infinite number of end-of-input symbols to the right, and all cells are in the so-called quiescent state.The finite state machines work synchronously at discrete time steps.The state transition of all cells but the communication cell depends on the current state of the cell itself and on the information which is currently sent by its neighbors.The information sent by a cell depends on its current state and is determined by so-called communication functions.The state transition of the communication cell additionally depends on the input symbol to be read next.The head of the one-way input tape is moved to the right in each step.A formal definition is:  Let M be an IA.A configuration of M at some time t ≥ 0 is a description of its global state which is a pair (w t , c t ), where w t ∈ A * is the remaining input sequence and c t : N → S is a mapping that maps the single cells to their current states.The configuration (w 0 , c 0 ) at time 0 is defined by the input word w 0 and the mapping c 0 that assigns the quiescent state to all cells, while subsequent configurations are chosen according to the global transition function Δ that is induced by δ and δ 0 as follows (Fig. 1): Let (w t , c t ), t ≥ 0, be a configuration.Then its successor configuration (w t+1 , c t+1 ) )) for all i ≥ 1, and c t+1 (0) δ 0 (a, c t (0), b l (c t (1))), where a and w t+1 λ if w t λ, as well as a a 1 and An input w is accepted by an IA M if at some time i during the course of its computation the communication cell enters an accepting state.The language accepted by M is denoted by L(M).Let t : N → N, t(n) ≥ n + 1 be a mapping.If all w ∈ L(M) are accepted with at most t(|w|) time steps, then L(M) is said to be of time complexity t.
The family of all languages which are accepted by some IA with time complexity t is denoted by L t (IA).If t is the function n + 1, acceptance is said to be in realtime and we write L rt (IA).Since for nontrivial computations an IA has to read at least one end-of-input symbol, realtime has to be defined as (n + 1)-time.
We remark that we obtain the classical definition of IA, if we set B S and b l (s) b r (s) s for all s ∈ S.
In the following we study the impact of communication in iterative arrays.The communication is measured by the number of uses of the links between cells.It is understood that whenever a communication symbol not equal to ⊥ is sent, a communication takes place.Here we do not distinguish whether either or both neighboring cells use the link.More precisely, the number of communications between cell i and cell i + 1 up to time step t is defined by For computations we now distinguish the maximal number of communications between two cells and the total number of communications.Let c 0 , c 1 , . . ., c |w|+1 be the sequence of configurations computed on input w by some realtime iterative array, that is, the computation on w.Then we define mcom(w) max{ com(i, |w|+1) | 0 ≤ i ≤ |w| } and scom(w) Let f : N → N be a mapping.If all w ∈ L(M) are accepted with computations where mcom(w) ≤ f (|w|), then M is said to be max communication bounded by f.Similarly, if all w ∈ L(M) are accepted with computations where scom(w) ≤ f (|w|), then M is said to be sum communication bounded by f.In general, it is not expected to have tight bounds on the exact number of communications but tight bounds on their numbers in the order of magnitude.For the sake of readability we denote the class of IA that are max communication bounded by some function g ∈ O( f ) by MC( f )-IA.In addition, we use the notation const for functions from O(1).The corresponding notation for sum communication bounded IA is SC( f )-IA.
To illustrate the definitions we start with some examples.Some of the ideas are also necessary for later constructions.
The idea of the construction is to start a signal with speed 1 / 2 to the right, that is, at every second time step the signal moves one cell to the right, when reading the first a.In addition, a signal with maximum speed to the right is started when the first b is read.When both signals meet, another signal with maximum speed is sent to the left and the input is accepted if and only if this signal reaches the communication cell one time step before the end-of-input symbol is read for the first time.Since there are two right signals and one left signal used, it is clear that the IA constructed is an MC(const)-IA.An example computation on input a 5 b 10 is depicted in Fig. 2 (left).
The construction is similar.We start right signals R 1 and R 2 with speed 1 / 2 resp. 1, when the first a resp.b is read.Additionally, a signal R 3 with speed 1 / 2 is started when reading the first b.Finally, signal R 4 with speed 1 is started when reading the first c.The languages of Examples 2 and 3 are not regular and not context-free, respectively.The following example shows that L rt (MC(const)-IA) contains even non-semilinear languages.

Example 4
The language { a 2n+ We use the construction given in Mazoyer and Terrier (1999) where a cellular automaton is described such that the nth cell enters a designated state exactly at time step 2n + √ n .Now, we implement this construction twice and start the first version of the construction with speed 1 / 2 when the first a is read.The second version is started with speed 1 when the first b is read.Clearly, both constructions meet in the nth cell at time 4n + 2 √ n by each entering the designated state.In this case, a left signal is started with speed 1 and the input is accepted if this signal reaches the communication cell when the last b-symbol is read.Hence, the language is accepted by a realtime-IA.Moreover, each construction needs by the construction given in Mazoyer and Terrier (1999) three right signals.Thus, six right signals and one left signal are sufficient to accept the language.This shows that the IA constructed is a realtime-MC(const)-IA.
The next example shows that a binary counter can already be implemented by an SC(n)-IA.
An obvious approach to accept the language is to simulate the data structure of a pushdown or a queue.It is shown in Kutrib (2008) how an IA can simulate such data structures.However, it is not clear whether such constructions can be realized by realtime-SC(n)-IA.Hence, we choose another approach and implement the usual construction of a binary counter for IA [see, for example, Kutrib andMalcher (2009a, 2011)], where the first log(n) cells store the binary encoding of some number n and the communication cell carries the least significant bit.To increase or decrease the counter we possibly have to send carry-overs in order to update the current encoding.Additionally, we mark the cell carrying the most significant bit suitably and this mark may move to the right while increasing the counter and may move to the left while decreasing the counter.Thus, to accept an input a n b n we start with a counter 0, we increase the counter by one for every read a and decrease the counter by one for every read b.If in the end the counter is 0 again, which can be detected with help of the mark of the most significant bit, and the input format is correct, we accept the input and reject in all other cases.An example computation may be found in Fig. 3, where + resp.-denote carry-overs for increasing resp.decreasing the counter.Furthermore, the gray cells mark the cells carrying the most significant bit.
To calculate the number of necessary communications on an accepted input a n b n we observe that the only information sent to the right are the carry-overs, while the only information sent to the left is the position of the most significant bit.For the latter we have that there always is exactly one cell carrying the most significant bit which gives 2n communications.For the carry-overs it easy to see that the communication cell (cell 0) sends a carry-over in every second time step, while cell 1 sends a carry-over in every fourth time step, cell 2 sends a carry-over in every eighth time step and so on.Altogether, the number of communications for the carry-overs is bounded by Hence, the number of communications on input The rough idea is to implement a binary counter as in Example 5 which is increased for every input symbol a.When the first b is read, a right signal is started which inspects the counter and checks whether all cells are carrying a carryover except the cell carrying the most significant bit.If so, the number of a's is 2 n for some n ≥ 1 and the signal is sent back to the left with maximum speed.When it reaches the communication cell exactly when the end-of-input symbol is read, then the input is accepted and in all other cases rejected.

Separability results
In this section, we will separate several classes of max communication bounded and sum communication bounded iterative arrays.We start by showing that realtime-SC(n)-IA are less powerful than realtime-SC(n 2 )-IA.We remark that a similar result is shown in Kutrib and Malcher (2010a) to exist between realtime-SC(n)-CA and realtime-SC(n 2 )-CA.
Here, the notion realtime-SC( f )-CA denotes a realtime-CA where the sum of communications in accepting computations is bounded by the function f.A precise definition can be found in Kutrib and Malcher (2010a) as well.
Proof The inclusion follows from structural reasons.To show the properness of the inclusion we consider the language L { wcw | w ∈ {a, b} + }, which can be accepted by using a queue store in which the first w part is enqueued.After the separating symbol c the queue store is symbolwise dequeued and matched with the second w part.It is shown in Kutrib (2008) how an IA can simulate such a queue store without any loss of time.Thus, L ∈ L rt (IA) which implies that L ∈ L rt (SC(n 2 )-IA).Another construction idea for L may be found in Cole (1969).Now, we will adapt the proof given in (Kutrib and Malcher 2010a, Thm.7) and show that L does not belong to The proof is by contradiction.Thus, we assume that L is accepted by some realtime-SC(n)-IA M with state set S and we consider accepting computations on wcw.This means in particular that there is a constant p > 0 depending on M such that the sum of all communications on every input wcw is at most p • (2|w|+1).
First, we set m |S|+1 and show that there is a constant k > 0 such that for any integer n ≥ 2 and all w ∈ {a, b} m•n there is a cell j(w), where 1 ≤ j(w) ≤ n − 1, such that the number of communications occurring between cells j(w) and j(w) + 1 is at most k.Assume that such a cell would not exist.Then, for every constant k > 0 there would be an n ≥ 2 and a word w of length m • n such that the number of communications of every cell i with 1 ≤ i ≤ n − 1 on input wcw is larger than k.Thus, the sum of all communications on input wcw is larger than k • (n − 1) k • (|w|/m − 1).Since for every k > 0 such words wcw can be found, we obtain a contradiction to the fact that the total number of communications on input wcw is bounded by p • (2|w|+1).
Second, from the proof given in (Kutrib and Malcher 2010a, Thm.7) we know that the number of possibilities to choose time steps and to use communication links for communications between two cells in a realtime-SC( f )-CA on input length n is bounded by 2 k 0 log(n) , for some constant k 0 ≥ 1.This results holds for realtime-SC( f )-IA as well as long as we consider cells which are different from the communication cell.Thus, the upper bound on the possibilities in M for k communications between two cells on input length m • n is bounded by Third, we note that there are 2 m•n different words of length m • n over {a, b} which we denote by W. For each word w ∈ W there is a cell 1 ≤ j(w) ≤ n − 1 such that the number of communications between cells j(w) and j(w) + 1 is at most k.Thus, there is a subset W ⊆ W of 2 m•n /(n − 1) different words and some cell 1 ≤ i ≤ n − 1 such that the number of communications between cells i and i + 1 is at most k for every word from W .
Next, we want to analyze the number of different possible configurations at time m • n after having processed an input from W . Due to the above considerations the number of possibilities for some cell i with 1 ≤ i ≤ n −1 to choose time steps and to use communication links on input length m • n is bounded by k 1 • n k 2 .Hence, there are at most k 1 • n k 2 different configurations at time m • n, when we take into account only those cells of the configurations which are to the right of cell i.Moreover, the cells to the left of i and cell i itself at time m • n can enter at most |S| i+1 different combinations of states.Altogether, we obtain that M can enter at most Finally, we want to show that the number of words in W is larger than the number of different configurations at time m • n after having processed those words.Since m |S|+1, we have that 2 m•n /(n − 1) 2 |S| n 2 n /(n − 1).Hence, we obtain the inequality by choosing n large enough.Thus, there are at least two different words w 1 , w 2 ∈ W such that the configurations at time m • n after processing w 1 and w 2 , respectively, are identical.Since ∈ L is accepted as well.This gives the contradiction and shows that L does not belong to L rt (SC(n)-IA).
For the separation of classes of max communication bounded iterative arrays we will use in the following the notion of time constructability.For general information on time-constructible functions we refer to Kutrib (2009), Mazoyer and Terrier (1999).We say that an increasing function f : N → N is time-constructible by an MC-IA M, if for all n ≥ 1 the communication cell of M enters a certain state exactly at the time steps f (n) having read the unary input a f (n) .We say that f (n) is time-constructible by an MC(g(n))-IA M for some function g(n), if f (n) is time-constructible by an MC-IA M which in addition is an MC(g(n))-IA, where g(n) refers to the length of the input f (n) processed by M, that is, the allowed number of communications is in O(g(f (n))).

Lemma 8
The function 2 n can be time constructed by an MC(log(n))-IA.The function n 2 can be time constructed by an MC( √ n)-IA.
Proof For the first claim we use the construction given in Choffrut and Culik (1984).Hence, the communication cell starts a signal which moves with speed 1 / 3 to the right.Additionally, another signal is started which moves with maximum speed and bounces between the slow signal and the communication cell.It is easy to observe that the latter signal reaches the communication cell exactly at time steps 2 n for all n ≥ 1 (see Fig. 4).It is also easy to observe that the maximum number of communications per cell after 2 n time steps is bounded by one communication for the slow signal and 2n communications for the bouncing signal.So we have 2n + 1 communications on input length 2 n which gives that the construction can be realized by an MC(log(n))-IA.
For the second claim we consider the construction presented in Mazoyer and Terrier (1999).Signal S 1 is started in the communication cell and is shifted one cell to the right if and only if it is met by signal S 2 which is also started in the communication cell and bounces between S 1 and the communication cell.It is again an easy observation that S 2 reaches the communication cell exactly at time steps n 2 for all n ≥ 1 (see Fig. 4) and that the maximum number of communications per cell after n 2 time steps is bounded by 2n + 1 communications.Thus, the construction can be realized by an MC( √ n)-IA.
The following general lemma shows a proper inclusion between two classes of max communication bounded iterative arrays provided that the communication bounds meet some general constraints.To show the properness of the inclusion we consider the language L { c f (|w|) wcw | w ∈ {a, b} + } for which we show that it can be accepted by a realtime-MC( f −1 (n))-IA, but does not belong to L rt (MC(g(n))-IA).For the construction of a realtime-MC( f −1 (n))-IA M for L we implement on track 1 the construction of f (n) according to the fact that f can be time constructed by a realtime-MC( f −1 (n))-IA.Additionally, we simulate on track 2 a queue store, where the top of the queue is located in the communication cell, and enter some symbol $ into the queue at every time step at which the communication cell recognizes a time step f (n) for n ≥ 1.Finally, we simulate on track 3 another queue store.As soon as the communication cell processes the first input symbol a or b from the first w, we check whether a time step f (n) has been identified in the last time step and we stop the computation on track 1.Additionally, we start to enter w to the queue on track 3 while for every symbol of w a symbol $ from the queue on track 2 is removed.When the separating symbol c is processed by the communication cell, we check whether the queue on track 2 is empty.If so, the number of initial c's has exactly been f (|w|) and we can continue to check the remaining input against the contents of the queue on track 3. Finally, the input is accepted if the check is positive and in all other cases the input is rejected.Next, we want to estimate the maximum number of communications per cell.An accepted input has a length of n f (|w|) + 2|w|+1.Since f can be time constructed by a realtime-MC( f −1 (n))-IA, we know that at most O(|w|) communications take place on the first track.To enter |w| symbols into the queue on track 2 needs at most |w| communications per cell.Finally, at most 2|w|+1 communications per cell can take place on track 2 and track 3 while processing the input suffix wcw.Altogether, at most O(|w|) communications take place per cell.Thus, L can be accepted by a realtime-MC( f −1 (n))-IA.

Lemma 9 Let f be time constructed by an
To show that L is not accepted by any realtime-MC(g(n))-IA we combine two techniques which have suc-cessfully been applied for SC-CA Kutrib and Malcher (2010a) and for IA with a bounded constant number of different messages to be communicated Kutrib and Malcher (2011).First, we derive an upper bound for the number of different communications that the communication cell can perform while processing an input of length n and performing communications.We have to take into account the information to be communicated and the time steps at which the communication takes place.Since there are n possibilities to choose time steps and |B| different messages to be sent, we obtain, for some constant k 0 ≥ 1, at most possibilities.Now, we assume that L is accepted by realtime-MC(g(n))-IA M.Moreover, let c p be the configuration after processing the complete c-prefix of the input.We know that f −1 (n) ∈ O(n/ log(n)) which means that there is a constant c 1 > 0 and an integer n 1 such that f −1 (n) • log(n)/n ≤ c 1 for all n ≥ n 1 .Moreover, we know that g ∈ o( f −1 ), which means that for every constant c > 0 there is an integer n c such that g(n)/ f −1 (n) < c for all n ≥ n c .In particular, choosing an arbitrary constant c 2 > 0 and setting d c 2 /c 1 gives that g(n Then, we know that there are two different words w w such that |w| |w | and M enters the same configuration after processing c f (|w|) w as well as after processing c f (|w|) w .Since the input c f (|w|) wcw is accepted, input c f (|w|) w cw is accepted as well which is a contradiction.
The next lemma provides an additional witness language for the hierarchy results claimed in Theorem 11.
Proof A realtime-MC(invfac(n))-IA M accepting L consists of four different tracks.On track 1 as well as on track 2 a queue store is implemented where the top of the queue is located in the communication cell.On track 3 we check as in Example 2 whether the number of d's is twice the number of c's.Finally, in track 4 we implement the construction of n! described in Mazoyer and Terrier (1999).According to this construction the communication cell enters a designated state exactly at time steps n! for n ≥ 1.However, the implementation of the construction is slightly changed: in every odd time step, the cells are updated according to the construction given in Mazoyer and Terrier (1999).In every other time step, all cells of the track are shifted one cell to the right.This implies that the original communication cell moves with speed 1 / 2 to the right.In particular, we have that cell n! enters a designated state at time 2 • n!.Whenever the original communication cell has been shifted through a cell, the quiescent state of M is entered.Now, in the first time step M starts the check in track 3 as well as the computation of n! in track 4. Whenever some cell in track 4 enters a designated state, a signal S 1 is sent with maximum speed to the left which implies that some symbol $ is entered into the queue in track 1 when S 1 reaches the communication cell.When the first symbol d is read, a signal S 2 is sent with maximum speed to the right which stops the computation in track 4 when it reaches the simulated communication cell in track 4.
As soon as the communication cell processes the first input symbol a or b from the first w, we start to enter w into the queue on track 2. When the separating symbol c is processed by the communication cell, we check the remaining input against the contents of the queue on track 2. Additionally, for every symbol of w a symbol $ from the queue on track 1 is removed.When the end-of-input symbol is processed by the communication cell, we check whether the queue on track 1 as well as on track 2 have been emptied exactly one time step before and whether the check on track 3 has been positive.If all checks are positive, we know that the number of initial c's has exactly been |w|!, the number of d's has exactly been 2 • |w|!, and the suffix has been wcw.Hence, the input is accepted and in all other cases the input is rejected.
Since an accepted input has a length of 3 • |w|! + 2|w|+1, we have to show that M needs at most O(|w|) communications per cell.According to the argumentation in the proof of Lemma 9 and the fact that |w| many $-symbols are entered into and dequeued from the queue in track 1, we know that at most O(|w|) communications take place on track 1 and track 2. In addition, due to Example 2 at most O(1) communications take place on track 3. So, it remains to be shown that at most 123 O(|w|) communications take place on track 4 as well.The different computations that require communication are the calculation of the factorial, the shifting of the cells, and the signals S 1 and S 2 .The construction of n! given in Mazoyer and Terrier (1999) Proof The inclusion claimed in (1) is clear, since the communication cell of an IA can simulate a deterministic finite automaton accepting a given regular language without using any communication.The inclusion is proper, since Example 2 provides a non-regular language accepted by a realtime-MC(const)-IA.
For the inclusion claimed in (2) we use This can be done almost identically to the proof given for Lemma 9. We assume that L is accepted by realtime-MC(const)-IA M. Every word w ∈ L is of the form w c |w|! d 2•|w|!wcw.Then, we let c p be the configuration after processing the complete prefix consisting of c's followed by all d's.Following the argumentation in the proof of Lemma 9, we can conclude that the number of different configurations of M starting in c p and processing the first w part of an input is bounded by where k 0 is the constant from the proof of Lemma 9, k is some constant due to the fact that M has constant communication only, and S denotes the state set of M. On the other hand, there are 2 |w| different words w.Now, we consider the inequality (|S|) and holds for considering |w| large enough.Thus, we know that there are two different words w w such that |w| |w | and M enters the same configuration after processing c |w|! d 2•|w|!w as well as after processing The inclusion claimed in (3) follows from Lemma 9 by choosing f (n) 2 n and g(n) invfac(n) and observing that invfac , and 2 n can be time constructed by an MC(log(n))-IA due to Lemma 8. Hence, the inclusion claimed in (3) holds.For the inclusion claimed in (4) we choose f (n) , and n 2 can be time constructed by an MC( √ n)-IA due to Lemma 8, and apply again Lemma 9.
Finally, we show (5) by considering language L { wcw | w ∈ {a, b} + } which is obviously accepted by a realtime-MC(n)-IA.On the other hand, assume that L is accepted by some realtime-MC( √ n)-IA M with state set S. Again, similar to the proof of Lemma 9, it is possible to show that there are at most |w| k 0 • √ |w| •|S| different configurations that can be obtained by M after processing the first w part of an input.On the other hand, there are 2 |w| different words w.Thus, we have to choose |w| large enough such that 2 |w| > |w| k 0 √ |w| •|S| which is equivalent to and holds for |w| large enough.Hence, there are two different words w w such that |w| |w | and M enters the same configuration after processing w as well as after processing w .Since the input wcw is accepted, input w cw is accepted as well which is a contradiction.

Undecidability results for sum communication bounded IA
In this section, we will show that almost all commonly studied decidability questions such as emptiness, finiteness, equivalence, inclusion, regularity, and context-freeness are not semidecidable for realtime-SC(n)-IA.Here, we say that a decision problem is decidable (undecidable) if the set of all instances for which the answer is "yes" is recursive (not recursive).A decision problem is said to be semidecidable if the set of all instances for which the answer is "yes" is recur-sively enumerable.It is known that the above-mentioned decidability questions are not semidecidable for realtime-IA (Malcher 2004).Thus, the basic idea in the following is to find suitable languages that relate realtime-IA with realtime-SC(n)-IA.Let M be a realtime-IA over some alphabet A and a, b be symbols such that A ∩ {a, b} ∅.Then, we define language Lemma 12 Let M be a realtime-IA.Then, a realtime-SC(n)-IA accepting L M can effectively be constructed.
Proof We sketch the construction of a realtime-SC(n)-IA M accepting L M .The IA M uses three tracks.Track 1 is used to simulate M where two cells of M are grouped into one cell of M .Track 2 is used to store in a queue for every input symbol from A a certain symbol $.When the first a-symbol is read, the first |w| cells of track 2 are marked with $.At this moment, we send a signal with maximum speed into track 1 that stops the simulation of M on track 1.Additionally, we start to increase a binary counter on track 3 as long as the input symbols are a.If the first b is read, we send a signal which checks whether the number of a's has been 2 |w| .This can be done by inspecting the counter as it is done in Example 6 and checking whether the valued stored is a power of two.Moreover, it is checked whether exactly all cells marked with $ have been used.Additionally, we start to decrease the counter for every input symbol b.Finally, we accept the input if the counter has been decreased to zero exactly when the end-of-input symbol is read and w has been accepted in track 1.The input is rejected in all other cases.
The number of communications for the simulation of M on track 1 and the signal that stops the simulation is bounded by O(|w| 2 ).The number of communications to mark the first |w| cells by $ is bounded by O(|w| 2 ) as well.By observing that binary counters can be realized by SC(n)-IA (see, e.g., Example 5), we know that the number of communications to increase the binary counter is bounded by O(2 |w| ).The number of communications to check that the number of a's has been 2 |w| is bounded by O(|w|).Finally, the number of communications to decrease the binary counter is bounded by O(2 |w| ) as well.Altogether, the number of all communications is bounded by in O(2 |w|+1 ).Since the input length is |w|+2 |w|+1 , we obtain that the IA constructed is an SC(n)-IA.Now, the non-semidecidable property of realtime-IA M to accept the empty or a finite language, respectively, is reflected in properties of language L M which enable us in the next theorem to obtain the desired non-semidecidability results for realtime-SC(n)-IA.
Lemma 13 Let M be a realtime-IA.

L M is regular if and only if L(M) is finite. 4. L M is context-free if and only if L(M) is finite.
Proof Claims 1 and 2 are obvious.It can be shown by a standard application of the pumping lemma that the language L M is not context-free, if L(M) is infinite.On the other hand, if L(M) is finite, L M is finite as well.This shows claim 3 and claim 4.
Proof It is known that emptiness and finiteness are not semidecidable for realtime-IA due to the results given in Malcher (2004).By applying Lemmas 12 and 13 we can directly translate the non-semidecidability results to realtime-SC(n)-IA.
Moreover, we cannot even semidecide the property of being sum communication bounded by n.
Theorem 15 It is not semidecidable for an arbitrary realtime-IA M whether or not M is a realtime-SC(n)-IA.
Proof Let M be a realtime-SC(n)-IA and consider the language where c is some new alphabet symbol.A realtime-IA M accepting L M can be described as follows by using two tracks.The correct number of c-and non-c-symbols can be checked on one track in the same way as it is done in Example 5 for the language { a n b n | n ≥ 1 }.Thus, M is a realtime-SC(n)-IA if and only if L M is empty.Since emptiness is not semidecidable for realtime-SC(n)-IA due to Theorem 14, we obtain that the question whether M is a realtime-SC(n)-IA is not semidecidable as well.
Finally, we can apply similar construction ideas as in the proof of Lemma 12 to separate the classes of realtime-MC(const)-IA and realtime-SC(n)-IA.
Proof The inclusion claimed is obvious.For the properness of the inclusion we consider language L {c 2 |w| wcw | w ∈ {a, b} + } and show by a similar construction as in Lemma 12 that L is accepted by a realtime-SC(n)-IA M. We sketch the construction of M that uses two tracks.Track 1 is used to implement a binary counter and track 2 is implemented as a queue store.While reading c's we increase the binary counter on track 1.When reading the first non-csymbol we stop increasing the counter and we start to enter the following input w in the queue on track 2. When the separating symbol c is read, we start a signal which checks that the length of the queue is exactly the length of the counter and, by inspection of the counter as is done in Example 6, that the number of c's is 2 |w| .The outcome of the check is sent back to the communication cell.Additionally, we compare the remaining w in the input against the w in the queue.If this is successful as well as the check, we accept the input and reject in all other cases.The increase of the binary counter needs at most O(2 |w| ) communications.The realization of the queue needs at most (2|w|+1) 2 ∈ O(|w| 2 ) communications and the signal for inspecting the counter needs at most O(|w|) communications.Since the input length is 2 |w| + 2|w|+1 and we use at most O(2 |w| ) communications, we obtain that M is a realtime-SC(n)-CA.
On the other hand, we have to show that L / ∈ L rt (MC(const)-IA).It has been shown in the proof of Theorem 11 that L rt (MC(invfac(n))-IA is properly included in L rt (MC(log(n))-IA by using L as witness language.This implies that L / ∈ L rt (MC(const)-IA), since it is not even in L rt (MC(invfac(n))-IA).

Undecidability results for max communication bounded IA
In this section, we prove similar non-semidecidability results for MC(invfac(n))-IA by using similar methods as in the previous section.Let M be a realtime-IA over some alphabet A and c, d be symbols such that A ∩ {c, d} ∅.Then, we define language Lemma 17 Let M be a realtime-IA.Then, a realtime-MC(invfac(n))-IA accepting L M can effectively be constructed.

Proof
The construction is almost identical to the construction for language L given in the proof of Lemma 10.The only difference is to provide an additional track 5 in which the simulation of M on input w takes place and to accept the input if in addition w belongs to L(M).Since for the simulation in track 5 at most O(|w|) communications are necessary, we obtain that at most O(|w|) communications take place per cell and that the IA constructed is an MC(invfac(n))-IA.
The proof of the following lemma is nearly identical to the proof of Lemma 13.
Lemma 18 Let M be a realtime-IA.

L M is empty if and only
Theorem 19 The properties of emptiness, finiteness, infiniteness, equivalence, inclusion, regularity, context-freeness are not semidecidable for realtime-MC(invfac(n))-IA.
Proof It is known that emptiness and finiteness are not semidecidable for realtime-IA due to the results given in Malcher (2004).By applying Lemmas 17 and 18 we can directly translate the non-semidecidability results to realtime-MC(invfac(n))-IA.
Finally, we cannot even semidecide the property of being max communication bounded by invfac(n).
Theorem 20 It is not semidecidable for an arbitrary realtime-IA M whether or not M is a realtime-MC(invfac(n))-IA.
Proof Let M be a realtime-MC(invfac(n))-IA and consider the language L M wc 2|w| | w ∈ L(M ) , where c is some new alphabet symbol.A realtime-IA M accepting L M can be described as follows by using two tracks.The correct number of c-and non-c-symbols can be checked on one track in the same way as it is done in Example 2 for the language { a n b 2n | n ≥ 1 }.This check needs O(1) communications per cell.Additionally, M is simulated on the other track.As soon as M reads the first c and the simulated IA M would enter an accepting state, the communication cell sends in every of the remaining 2|w| time step two alternating signals with maximum speed into the array.Finally, the input is accepted if the check on track 1 has been successful.It can be observed that the maximum communication per cell is in O(|w|), if w ∈ L M , and is in O(1) otherwise.Thus, M is a realtime-MC(invfac(n))-IA if and only if L M is finite.Since finiteness is not semidecidable for realtime-MC(invfac(n))-IA due to Theorem 19, we obtain that the question of whether M is a realtime-MC(invfac(n))-IA is not semidecidable as well.

Non-recursive trade-offs
In this section, we look at the descriptional complexity of max communication bounded IA and show that non-recursive trade-offs exist among the IA whose language classes are properly included owing to Theorem 11.
First, we recall some notions of descriptional complexity as presented, e.g., in Holzer and Kutrib (2010), Kutrib and Malcher (2018).We say that a descriptional system S is a set of finite descriptors such that each D ∈ S describes a formal language L(D), and the underlying alphabet alph(D) over which D represents a language can be read off from D. The family of languages represented (or described) by S is For every language L , the set S(L ) { D ∈ S | L(D) L } is the set of its descriptors in S. A complexity measure for a descriptional system S is a total computable mapping c : S → N.
We note that IA can be encoded over some fixed alphabet such that their input alphabets can be extracted from the encodings.The set of these encodings is a descriptional system S, and L (S) is L (IA).Examples for complexity measures for IA are the total number of symbols, that is, the length of the encoding (length), or the total number of transitions in δ and δ 0 .Here, we only use complexity measures that (with respect to the underlying alphabets) are related to length by a computable function.If there is a total computable function g : N × N → N such that, for all D ∈ S, length(D) ≤ g(c(D), |alph(D)|), then c is said to be an s-measure.If, in addition, for any alphabet A, the set of descriptors in S describing languages over A is recursively enumerable in order of increasing size, then c is said to be an sn-measure.Clearly, length is an sn-measure for IA.
Whenever we consider the relative succinctness of two descriptional systems S 1 and S 2 , we assume the intersection L (S 1 ) ∩ L (S 2 ) to be non-empty.Let S 1 and S 2 be descriptional systems with complexity measures c 1 and c 2 , respectively.A total function f : N → N is an upper bound for the increase in complexity when changing from a descriptor in S 1 to an equivalent descriptor in S 2 , if for all D 1 ∈ S 1 with L(D 1 ) ∈ L (S 2 ), there exists a D 2 ∈ S 2 (L(D 1 )) such that c 2 (D 2 ) ≤ f (c 1 (D 1 )).
If there is no recursive, that is, computable function serving as an upper bound, the trade-off is said to be non-recursive and we write S 1 nonrec − −−− → S 2 .That is, whenever the trade-off from one descriptional system to another is non-recursive, one can choose an arbitrarily large recursive function f, but the gain in economy of description eventually exceeds f when changing from the former system to the latter.
To obtain non-recursive trade-offs we will us the following general theorem.
Theorem 21 (Holzer and Kutrib 2010)Let S 1 and S 2 be two descriptional systems for recursive languages such that any descriptor D in S 1 and S 2 can effectively be converted into a Turing machine that decides L(D), and let c 1 be a measure for S 1 and c 2 be an sn-measure for S 2 .If there exists a descriptional system S 3 and a property P that is not semidecidable for descriptors from S 3 , such that, given an arbitrary D 3 ∈ S 3 , (i) there exists an effective procedure to construct a descriptor D 1 in S 1 , and (ii) D 1 has an equivalent descriptor in S 2 if and only if D 3 does not have property P, then the trade-off between S 1 and S 2 is non-recursive.
An application of the above theorem gives the following lemma.
Proof We want to apply Theorem 21 and consider realtime-IA as descriptional system S 3 and use infiniteness as property P which is known to be not semidecidable for realtime-IA due to Malcher (2004).To obtain a non-recursive trade-off between realtime-MC( f −1 (n))-IA and realtime-MC(g(n))-IA, we have to show that (i) for every realtime-IA M a realtime-MC( f −1 (n))-IA accepting some language L M, f can effectively be constructed and (ii) L M, f is accepted by realtime-MC(g(n))-IA if and only if L(M) is finite.
First, we define language L M, f .Let M be a realtime-IA over an alphabet A. We consider a primed version A and a homomorphism h such that h(a) a for a ∈ A and h(a ) a for a ∈ A .Since L rt (IA) is closed under inverse homomorphism, the language h −1 (L(M)) is accepted by some realtime-IA as well.This prerequisite ensures that for any w ∈ L(M), there are at least 2 |w| different words of length |w| in h −1 (L(M)).Now, we define the language L M, f { c f (|w|) wcw | w ∈ h −1 (L(M)) }.Second, we show that a realtime-MC( f −1 (n))-IA accepting L M, f can effectively be constructed.This can essentially be done the same way as for language L in the proof of Lemma 9. Additionally, it has to be checked that w ∈ h −1 (L(M)) by implementing another track where a realtime-IA simulating h −1 (L(M)) on input w is started.This additional track causes at most O(|w|) additional communications per cell.Hence, L M, f can be accepted by a realtime-MC( f −1 (n))-IA.
where S is the finite, non-empty set of cell states, F ⊆ S is the set of accepting states, A ⊆ S is the finite, non-empty set of input symbols, B is the set of communication symbols, / ∈ A is the end-of-input symbol, s 0 ∈ S is the quiescent state, b l , b r : S → B ∪ {⊥} are communication functions which determine the information to be sent to the left and right neighbors, where ⊥ means nothing to send and b l (s 0 ) b r (s 0 ) ⊥, δ : (B ∪ {⊥}) × S × (B ∪ {⊥}) → S is the local transition function for noncommunication cells satisfying δ(⊥, s 0 , ⊥) s 0 , and δ 0 :

Fig. 2
Fig. 2 Two example computations for Example 2 (left) on input a 5 b 10 and Example 3 (right) on input a 4 b 4 c 8

Fig. 3
Fig. 3 Example computation for the construction given in Example 5 on input a 9 b 9 .The symbols + resp.-denote carry-overs for increasing resp.decreasing the counter.The cells carrying the most significant bit are marked gray and g denotes an accepting state Next, we want to calculate the number of different configurations of M starting in c p and processing the first w part of an input.Such a configuration depends on the information that has been sent to the IA via the communication cell and the current state of the communication cell.Hence, there are at most |w| k 0 •g(|w|) •|S| different configurations, where S denotes the state set of M. On the other hand, there are 2 |w| different words w.Now, we claim that the inequality 2 |w| > |w| k 0 •g(|w|) •|S| which is equivalent to |w|> k 0 •g(|w|)• log(|w|) + log(|S|) holds for considering |w| large enough.To show the latter claim it remains for us to show that g(n)•log(n) belongs to o(n).
uses five different signals, called C, M, S, T, and V. Let us first consider only signals C, M, T, and V.A close look on the construction shows that these signals use at most the first 2n cells to calculate 2 • n!.Thus, after grouping two cells together at most the first n cells are used.Since any cell on track 4 enters the quiescent state when the original communication cell has been shifted through, we have that a block of at most n cells is shifted through track 4 of M. Therefore we know that up to time step 2 • n! every cell in track 4 communicates at most O(n) times due to the calculation of the factorial and at most O(n) times due to the shifting.For an accepted input c |w|! d 2•|w|!wcw, we know that the calculation of the factorial and the shifting is stopped by signal S 2 in all cells of track 4 at the latest at time step 2 • |w|! +2|w|.Hence, the maximum number of communications per cell is bounded by O(|w|) for the calculation of the factorial, by O(|w|) for the shifting, and by a constant for signal S 2 .It remains to consider signals S and S 1 .The former signal is sent with speed 1 / 3 to the right and is shifted in every other time step which causes a constant number of communications per cell.The latter signal is started |w| many times and causes at most O(|w|) communications per cell.Altogether, we obtain that at most O(|w|) communications take place on track 4. Now, we can apply both lemmas and we can state the hierarchy of max communication bounded iterative arrays.Theorem 11 (1) REG cellular automata with 1-bit inter-cell communications.Fundam Inform 52:257-275 Umeo H, Kamikawa N (2003) Real-time generation of primes by a 1-bit-communication cellular automaton.Fundam Inform 58:421-435 Worsch T (2000) Linear time language recognition on cellular automata with restricted communication.In: Gonnet GH, Panario D, Viola A (eds) Theoretical informatics (LATIN 2000), LNCS, vol 1776.Springer, Berlin, pp 417-426 When signals R 1 and R 2 meet, a left signal L 1 with speed 1 / 2 is started in the next time step, and a left signal L 2 with speed 1 is started in the next time step after signals R 3 and R 4 have met.Finally, the input is accepted if and only if signals L 1 and L 2 meet in the communication cell one time step before the end-of-input symbol is read for the first time.Since there are altogether four right signals and two left signals used, the IA constructed is an MC(const)-IA.An The check needs O(|w|) communications.Additionally, M is simulated on the other track.As soon as M reads the first c and the simulated IA M would enter an accepting state, the communication cell sends in every of the remaining |w| time steps two alternating signals with maximum speed into the array.Finally, the input is accepted if the check on track 1 has been successful.