Complexity-Theoretic Aspects of Expanding Cellular Automata

The expanding cellular automata (XCA) variant of cellular automata is investigated and characterized from a complexity-theoretical standpoint. The respective polynomial-time complexity class is shown to coincide with ${\le_{tt}^p}(\textbf{NP})$, that is, the class of decision problems polynomial-time truth-table reducible to problems in $\textbf{NP}$. Corollaries on select XCA variants are proven: XCAs with multiple accept and reject states are shown to be polynomial-time equivalent to the original XCA model. Meanwhile, XCAs with diverse acceptance behavior are classified in terms of ${\le_{tt}^p}(\textbf{NP})$ and the Turing machine polynomial-time class $\textbf{P}$.


Introduction
Traditionally, cellular automata (CAs) are defined as a rigid and immutable lattice of cells; their behavior is dictated exclusively by a local transition function operating on homogeneous local configurations. This can be generalized, for instance, by mutable neighborhoods (Rosenfeld and Wu 1981) or by endowing CAs with the ability to shrink, that is, delete their cells (Rosenfeld et al. 1983). When shrinking, the automaton's structure and dimension are preserved by ''gluing'' the severed parts and reconnecting their delimiting cells as neighbors. When employed as language recognizers, shrinking CAs (SCAs) can be more efficient than standard CAs (Rosenfeld et al. 1983;Kutrib et al. 2015).
Other variants of CAs with dynamically reconfigurable neighborhoods have emerged throughout the years. In the case of two-dimensional CAs, there is the structurally dynamical CA (SDCA) due to Ilachinski and Halpern (1987), in which the connections between neighbors are created and dropped depending on the local configuration. In the one-dimensional case, further variants in this sense are considered in the work of Dubacq (1994), where one finds, in particular, CAs whose neighborhoods vary over time. Dubacq also proposes the dynamically reconfigurable CA (DRCA), a CA whose cells are able to exchange their neighbors for neighbors of their neighbors. Dantchev (2008) later points out a drawback in the definition of DRCAs and proposes an alternative dubbed the dynamic neighborhood CA (DNCA).
By relaxing the arrangement of cells as a lattice, CAs may be generalized to graphs (Tomita et al. 2002). Graph automata are related to CAs in that each vertex in the graph corresponds to a cell; thus, graphs whose vertices have finite degrees provide a natural generalization of CAs. Tomita et al. (2002) also define a rule based on topological refinements of graphs, which may be used as a model for biological cell division. An additional example of cell division in this sense is the ''inflating grid'' of Arrighi and Dowek (2013).
Parts of this paper have been submitted (Modanese 2016(Modanese , 2018 in partial fulfillment of the requirements for the degrees of Bachelor of Science and Master of Science at the Karlsruhe Institute of Technology (KIT).
Modeling cell division and growth, in fact, was one of the driving motivations towards the investigation of the expanding CA (XCA) in Modanese (2016). An XCA is, in a way, the opposite of an SCA; instead of cells vanishing, new cells can emerge between existing ones. This operation is topologically similar to the cell division of graph automata; as in the SCA model, however, it maintains the overall arrangement and connectivity of the automaton's cells as similar as possible to that of standard CAs (i.e., a bi-infinite, one-dimensional array of cells).
We mention a few aspects in which XCAs differ from the aforementioned variants. Contrary to SDCAs or CAs with dynamic neighborhoods such as DRCAs and DNCAs, XCAs enable the creation of new cells, not simply new links between existing ones. In addition, the XCA model does not focus as much on the reconfiguration of cells; in it, the neighborhoods are homogeneous and predominantly immutable. Furthermore, in contrast to the far more general graph automata, XCAs are still one-dimensional CAs; this ensures basic CA techniques (e.g., synchronization) function the same as they do in standard CAs.
Finally, shrinking and expanding are not mutually exclusive. Combining them yields the shrinking and expanding CA (SXCA). The polynomial-time class of SXCA language deciders was shown to coincide with PSPACE (Modanese 2016; Modanese and Worsch 2016).
A previous result by Modanese (2016) is that, for the class XCAP of polynomial-time XCA language deciders, we have NP [ coNP XCAP PSPACE. A precise characterization of XCAP, however, remained outstanding. Such was the topic of the author's master's thesis (Modanese 2018), the results of which are summarized in this paper. The main result (Theorem 8) is XCAP being equal to the class of decision problems which are polynomialtime truth-table reducible to NP, denoted p tt ðNPÞ. The rest of the paper is organized as follows: Sect. 2 covers the fundamental definitions and results needed for the subsequent discussions. Following that, Sect. 3 recalls the main result of Modanese (2016) concerning XCAP and presents two characterizations of XCAP, one based on p tt ðNPÞ (Theorem 8) and another (Theorem 14) based on a variant of non-deterministic Turing machines (NTMs). Section 4 covers some immediate corollaries, in particular by considering an XCA variant with multiple accept and reject states as well as two other variants with diverse acceptance conditions. Finally, Sect. 5 concludes. This is an extended and revised version of a preliminary paper presented at the AUTOMATA 2019 (Modanese 2019). Section 3 has been expanded to provide a complete proof of Proposition 7 (instead of only an outline), which is now found in Sect. 3.1, while the material in Sect. 3.3 is entirely novel. Other improvements include a full proof of Lemma 5, an updated abstract, broader discussions of concepts and results, and minor text edits.

Definitions
This section recalls basic concepts and results needed for the proofs and discussions in the later sections and is broken down in two parts. The first is concerned with basic topics regarding formal languages, Turing machines, and Boolean formulas. The second part covers the definition of expanding CAs.

Formal languages and turing machines
It is assumed the reader is familiar with the fundamentals of cellular automata and complexity theory (see, e.g., standard references such as Delorme and Mazoyer 1999 and Arora and Barak 2009). Unless stated otherwise, all words have length at least one. For sets A and B, B A denotes the set of functions A ! B. For an alphabet R, R Ã is the set of words over R. A xx-word is a biinfinite word w 2 R Z . The notion of a complete language is employed strictly in the sense of polynomial-time many-one reductions by deterministic Turing machines.

Boolean formulas
Let V be a language of variables over an alphabet R which, without loss of generality, is disjoint from fF; T; :;^; _; ð; Þg. BOOL V denotes the formal language of Boolean formulas over the variables of V. For better readability, we shall prefer prefix notation when writing out formulas (e.g.,^ðf ; gÞ for formulas f and g instead of the more common infix notation f^g).
An interpretation of V is a map I : V ! fF; Tg. Each such I gives rise to an evaluation E I : BOOL V ! fF; Tg which, given a formula f 2 BOOL V , substitutes each variable x 2 V with the truth value I(x) and reduces the resulting formula using standard propositional logic. A formula f is satisfiable if there is an interpretation I such that E I ðf Þ ¼ T, and f is a tautology if this holds for every I.
In order to define the languages SAT of satisfiable formulas and TAUT of tautologies, a language V of variables must first be agreed on. In this paper, variables are encoded as binary strings prefixed by a special symbol x, that is, V ¼ fxg Á f0; 1g þ . The language SAT contains exactly the satisfiable formulas of BOOL V . Similarly, TAUT contains exactly the tautologies of BOOL V . The following is a classical result concerning SAT and TAUT: Theorem 1 (Cook 1971) SAT is NP-complete, and TAUT is coNP-complete.

Truth-table reductions
The theory of truth-table reductions was established by Ladner et al. (1975) and Ladner and Lynch (1976). Later, Wagner (1990) showed the class of decision problems polynomialtime truth-table (i.e., Boolean-circuit) reducible to NP, denoted p tt ðNPÞ, remains the same even if the reduction is in terms of Boolean formulas (instead of circuits). We refer to Buss and Hay (1991) for a series of alternative characterizations of p tt ðNPÞ. The inclusions NP [ coNP p tt ðNPÞ and p tt ðNPÞ PSPACE are known to hold. A more formal treatment of the class p tt ðNPÞ is not necessary to establish the results of this paper; it suffices to note p tt ðNPÞ has complete languages. In particular, we are interested in Boolean formulas with NP and coNP predicates. To this end, we employ SAT and TAUT to define membership predicates of the form , where f is a Boolean formula, L 2 fSAT; TAUTg, and is a purely syntactic construct which stands for the statement ''f 2 L''.
The language SAT^-TAUT _ BOOL^_ SAT;TAUT contains all formulas which are true under the interpretation mapping to the truth value of the statement ''f 2 L''.
For example, given f 1 ; f 2 ; f 3 ; f 4 2 BOOL V , the following formula f is in BOOL^_ SAT;TAUT : Then, f 2 SAT^-TAUT _ if, for instance, f 1 2 SAT and f 2 2 TAUT holds.
From the results of Buss and Hay (1991) it follows: Theorem 3 SAT^-TAUT _ is p tt ðNPÞ-complete.

Cellular automata
Here, we are strictly interested in one-dimensional cellular automata (CAs) with the standard neighborhood and employed as language deciders. CA deciders possess a quiescent state q; cells which are not in this state are said to be active and may not become quiescent. The input for a CA decider is provided in its initial configuration surrounded by quiescent cells. As deciders, CAs are Turing complete, and, more importantly, CAs can simulate TMs in real-time (Smith 1971). Conversely, it is known a TM can simulate a CA with time complexity t in time at most t 2 . A corollary is that the class of problems decidable in polynomial time by CAs is exactly P.

Expanding cellular automata
First considered in Modanese (2016), the expanding CA (XCA) is similar to the shrinking CA (SCA) in that it is dynamically reconfigurable; instead of cells being deleted, however, in an XCA new cells emerge between existing ones. This does not alter the underlying topology, which remains one-dimensional and biinfinite. For modeling purposes, the new cells are seen as hidden between the original (i.e., visible) ones, with one hidden cell placed between any two neighboring visible cells. These latter cells serve as the hidden cell's left and right neighbors and are referred to as its parents. In each CA step, a hidden cell observes the states of its parents and either assumes a non-hidden state, thus becoming visible, or remains hidden. In the former case, the cell assumes the position between its parents and becomes an ordinary cell (i.e., visible), and the parents are reconnected so as to adopt the new cell as a neighbor. Visible cells may not become hidden, and we refer to hidden cells neither as active nor as quiescent (i.e., we treat them as a tertium quid).
Definition 4 (XCA) Let N ¼ fÀ1; 0; 1g be the standard neighborhood. An expanding CA (XCA) is a CA A with state set Q and local transition function d : Q N ! Q and which possesses a distinguished hidden state 2 Q. For any local configuration ' : N ! Q, dð'Þ ¼ is allowed only if 'ð0Þ ¼ .
For a global configuration c : Z ! Q, let h c : Z ! Q N be such that h c ðzÞðÀ1Þ ¼ cðzÞ, h c ðzÞð0Þ ¼ , and h c ðzÞð1Þ ¼ cðz þ 1Þ for any z 2 Z. Define a : Q Z ! Q Z as follows, where D is the standard CA global transition function (as induced by d): Finally, with c still arbitrary, let U : Q Z ! Q Z be the map 1 that acts as a homomorphism on c deleting any occurrence 1 Strictly speaking, the codomain of U (as here defined) is not only Q Z but actually larger (since, for c 2 Q Z arbitrary, UðcÞðzÞ may be undefined for certain z 2 Z). However, since the configurations that arise in our context of XCAs have infinitely many occurrences of q in either direction (i.e., cðiÞ ¼ q holds for infinitely many i [ 0 as well as infinitely many i\0), in this case UðcÞðzÞ is guaranteed to be defined for every z 2 Z, that is, UðcÞ 2 Q Z . Hence, to simplify the presentation, we write only ''Q Z '' here.
of (and contracting the remaining states towards zero), formally: UðcÞðzÞ ¼ cðm þ ðzÞÞ; z ! 0 cðm À ðÀz À 1ÞÞ; otherwise where m þ ðzÞ is the maximum i 2 Z for which jfj 2 ½0; iÞ j cðjÞ 6 ¼ gj ¼ z and m À ðzÞ is the minimum i 2 Z for which jfj 2 ði; À1 j cðjÞ 6 ¼ gj ¼ z. Then the global transition function of A is D X ¼ U a. Figure 1 illustrates an XCA A and its operation for input 001010 as an example. The local transition function d of A is as follows: where È denotes the bitwise XOR operation, that is, addition modulo 2. The initial configuration is marked as c.
The hidden cells are those in state . Starting from c, a applies d to each local configuration, where h c specifies the local configurations for the hidden cells; a also promotes all originally hidden cells to visible ones. Finally, U then eliminates cells having the state , as such cells are per definition not allowed to be visible (rather, they are present only implicitly in the global configuration). The supply of hidden cells is never depleted; whenever a hidden cell becomes visible, new hidden cells appear between it and its neighbors. Thus, the number of active cells in an XCA may increase exponentially: Lemma 5 Let A be an XCA. For an input of size n, A has at most aðtÞ ¼ ðn þ 3Þ2 t À 3 active cells after t 2 N 0 steps. This upper bound is sharp.
Proof The claim is proven using induction on t 2 N 0 . The induction basis is evident since A has exactly n active cells in time step t ¼ 0. For the induction step, assume the claim holds for some t 2 N 0 . Without loss of generality, it may also be assumed that the number of active cells in A is maximal (i.e., equal to a(t)). Then A can have at most 2aðtÞ þ 3 active cells in time step t þ 1 since a(t) many cells were already active, and a maximum of two quiescent and aðtÞ þ 1 hidden cells may become active in the transition to the next step. The proof is complete by using We have postponed defining the acceptance condition for XCAs until now. Usually, a CA possesses a distinguished cell, often cell 0, which dictates the automaton's accept or reject response (Kutrib 2009). In the case of XCAs, however, under a reasonable complexity-theoretical assumption (i.e., P 6 ¼ p tt ðNPÞ) such an acceptance condition results in XCAs not making full use of the efficient cell growth indicated in Lemma 5 (see Sect. 4.3). This phenomenon does not occur if the acceptance condition is defined based on unanimity, that is, in order for an XCA to accept (or reject), all its cells must accept (or reject) simultaneously. This acceptance condition is by no means novel (Rosenfeld 1979;Sommerhalder and van Westrhenen 1983;Ibarra et al. 1985;Kim and McCloskey 1990). As an aside, note all (reasonable) CA time complexity classes (including, in particular, linear-and polynomialtime) remain invariant when using this acceptance condition instead of the standard one.
Also of note is that, for the standard acceptance condition, we insist on unique accept and reject states. This serves to not only simplify some arguments in Sect. 3 but also to show that unique states already suffice to decide problems in p tt ðNPÞ. We revisit this topic in Sect. 4.1, where we consider XCAs with multiple accept and reject states (and prove that the class of problems that can be decided efficiently remains the same).
Definition 6 (Acceptance condition, time complexity) Each XCA has a unique accept state a and a unique reject state r. An XCA A halts if all active (and visible) cells are either all in state a, in which case the XCA accepts, or they are all in state r, in which case it rejects; if neither is the case, the computation continues. L(A) denotes the set of words accepted by A.
The time complexity of an XCA (for an input w) is the number of elapsed steps until it halts. An XCA decider is an XCA which halts on every input. A language L is in XCAP if there is an XCA decider A 0 with polynomial time complexity (in the length |w| of w) and such that L ¼ LðA 0 Þ.
In summary, the decision result of an XCA decider is the one indicated by the first configuration in which its active cells are either all in the accept or all in the reject state. This agrees with our aforementioned notion of a unanimous decision.

Characterizing XCAP
This section covers the main result of this paper, that is, characterizing XCAP as being equal to p tt ðNPÞ (Theorem 8). It is subdivided into three parts: First, we address a result from Modanese (2016) which is relevant towards proving the aforementioned characterization. Next, we state and prove Theorem 8. Finally, we discuss an alternative characterization of XCAP based on NTMs.

An XCA for TAUT
In this section, we cover the following result from Modanese (2016), which provides the starting point towards proving Theorem 8: Since many-one reductions by TMs can be simulated by (X)CAs in real-time, it suffices to show XCAP contains NPand coNP-complete problems. We construct XCAs for SAT and TAUT which run in polynomial time and apply Theorem 1. Since acceptance and rejection are defined symmetrically (as per Definition 6), if L can be accepted by an XCA A, then swapping the accept and reject states of A we obtain an XCA that decides the complement of L with the exact same complexity as A. Hence, as NP and coNP are complementary classes, it suffices to show coNP XCAP.
The key idea towards the result is that an XCA can efficiently duplicate portions of its configuration: Let a block denote a subconfiguration #w# where # is a (special) separator symbol and w is a word not containing #. In particular, starting from any such block, the XCA can, in a single step, produce the block #w 2 $# where $ is a separator symbol different from # and w 2 ¼ ðwð0Þ; 0Þðwð0Þ; 1Þ Á Á Á ðwðjwj À 1Þ; 0Þðwðjwj À 1Þ; 1Þ duplicates the word w (i.e., we have jw 2 j ¼ 2jwj). Using a stable sorting algorithm (following, e.g., techniques from Gordillo and Luna (1994)), the XCA then sorts the symbols into place according to the second component of the tuples above and obtains the subconfiguration #w$w# in a linear number of steps.
Proof In accordance with the previous discussion, we construct an XCA A for TAUT.
Firstly, A verifies the input f is a syntactically correct formula; this can be done, for instance, simply by simulating a TM for this task. Following that, the operation of A can be subdivided into two large steps. In the first of them, A iteratively expands its configuration (in a way we shall describe in more detail) so as to cover every possible truth assignment of the variables of f and arrives at a configuration c f (detailed below). The second step starts from c f , computes the evaluations of f under the respective truth assignments in parallel, and accepts or rejects according to whether the results are all ''true'' or not. Both procedures require time polynomial in the length |f | of f; thus, A runs in polynomial time.
Step 1 Given a Boolean formula f over m variables, let x 0 ; . . .; x mÀ1 be the ordering of its variables according to their first appearance in f when this is read from left to right. Furthermore, letting s 0 ; . . .; s 2 m À1 be the lexicographic ordering of the strings in fF; Tg m (under the convention that F precedes T), we obtain a natural ordering I 0 ; . . .; I 2 m À1 of the 2 m possible interpretations of the x i by identifying each s j with the interpretation I j that satisfies We let c f be the following configuration: , an element of the alphabet fF; Tg).
We now further specify how c f is reached. A starts by surrounding f with # delimiters. Each block #f # of A repeats the following procedure as long as f contains at least one variable: 1. Duplicate f (as described previously), yielding the subconfiguration #f $f 0 #. 2. Determine the first variable v ¼ xy in f, where y 2 f0; 1g þ , and replace every occurrence of v in f (resp., f 0 ) with F k (resp., T k ), where k ¼ jvj ¼ 1 þ jyj. 3. Replace the middle delimiter $ with # and synchronize the two blocks corresponding to f and f 0 (so they continue their operation at the same time).
When f no longer contains a variable, the block evaluates it directly (e.g., by simulating a TM for this task). The correctness of the above is shown by induction on m. The case m ¼ 0 is trivial, so assume m [ 0. The above procedure replaces the variables of f such that precisely 2 m copies are produced, each corresponding to an I j (and according to the ordering described above). Also note the blocks of A always have the same length and, because of step 3 above and using transitivity, any two blocks are synchronized with each other. Thus, when f has no variables left, the evaluations all happen and terminate at the same time, thus producing the desired configuration. Finally, it is straightforward to show the above procedure requires polynomial time.
Step 2 We now describe the second procedure of A which, starting from the configuration c f of, leads A to accept or reject depending on the results present in c f .
Notice that, in the first step above, we ensured that c f is reached in such a way that the blocks corresponding to the E i are all synchronized. Hence, from this point each block (including the delimiting # cells) initiates a synchronization, following which all cells in the block simultaneously enter the accept (resp., reject) state if the respective evaluation's result was T (resp., F). The reject state is maintained while accept states yield to a reject state, that is, we have dðq 1 ; r; q 2 Þ ¼ r and dðq 1 ; a; q 2 Þ ¼ r for the local transition function d of A and arbitrary states q 1 and q 2 . Thus, if all evaluations are ''true'' (i.e., their result is T), the cells all simultaneously enter the accept state; otherwise, all cells necessarily enter the reject state. Since this process also takes only polynomial time, the claim follows. h We conclude this section by stressing that step 2 above builds on a ''trick'' that is only possible due to the unanimous acceptance condition of XCAs. Assume, for the moment, that the XCA A of before can continue computing (i.e., does not halt) even if it has reached a configuration in which it accepts or rejects. Then A is guaranteed to eventually reach a configuration in which it rejects regardless of what the results for the evaluations of f are. This means the only case in which A is prevented from rejecting is when it accepts (namely when all of the E i are ''true''); that is, A is capable of rejecting under the condition it has not accepted. This kind of behavior is quite different from, say, an NTM (seen as an alternating Turing machine with only existential states), where the result of each computation branch is completely independent of the other branches. We shall come back to this point later in Sect. 3.3 and address it from another perspective.

A first characterization
In this section, we prove the main result of this paper: Theorem 8 XCAP ¼ p tt ðNPÞ. The equality in Theorem 8 is proven by considering the two inclusions (Propositions 9 and 12).

Proposition 9
p tt ðNPÞ XCAP. Proof The claim is shown by constructing an XCA A that decides SAT^-TAUT _ (see Definition 2 and Theorem 3) in polynomial time. The actual inclusion follows from the fact that CAs can simulate polynomial-time many-one reductions by TMs in real-time.
Given a problem instance f, A evaluates f recursively. Without loss of generality, we may assume , where f 0 is a further problem instance; other instances of SAT^-TAUT _ are obtained by replacing f 1 , f 2 , or f 0 with a trivial formula (e.g., a trivial tautology).
To evaluate , A emulates the behavior of the XCA for SAT (see Proposition 7); however, special care must be taken to ensure A does not halt prematurely. All computation branches retain a copy of f. Whenever a branch obtains a ''true'' result, the respective cells do not directly accept (as in the original construction); instead, they proceed with evaluating the formula's next connective. Conversely, if the result is false, the respective cells simply enter the reject state. The behavior for is analogous, with A emulating the XCA for TAUT instead (and with exchanged accept and reject states, accordingly). Additionally, we require dðq 1 ; r; q 2 Þ ¼ a and dðq 1 ; a; q 2 Þ ¼ r for every states q 1 and q 2 , that is, once a cell enters the accept or reject state, it is forced to unconditionally alternate between the two. To ensure A is still able to accept or reject, we (arbitrarily) enforce accept states only exist in even-numbered steps and reject states only in odd-numbered ones. 2 If f 1 6 2 SAT, all branches of A transition into the reject state, and A rejects. Otherwise, f 1 is satisfiable; thus, at least one branch obtains a ''true'' result, and A continues to evaluate f until the (aforementioned) base case is reached. An analogous argument applies for f 2 . Note the synchronicity of the branches guarantee they operate exactly the same and terminate at the same time. The repeated transition between accept and reject states guarantee the only cells relevant for the final decision of A are those in the branches which are still ''active'' (in the sense they are still evaluating f).
In conclusion, A accepts f if and only if it evaluates to true; otherwise, A rejects f. A runs in polynomial time since f has at most |f | predicates and since evaluating a predicate requires polynomial time in |f |. h For the converse, we express an XCA computation as a SAT^-TAUT _ instance. The main effort here lies in defining the appropriate ''variables'': Definition 10 (STATE 8 ) Let A be an XCA, and let V A be the set of triples (w, t, z), w being an input for A, t 2 f0; 1g þ a (standard) binary representation of s 2 N 0 , and z a state of A. STATE 8 ðAÞ V A is the subset of triples such that, if A is given w as input, then after s steps all active cells are in state z.
Lemma 11 For any XCA A with polynomial time complexity, STATE 8 ðAÞ 2 coNP: Proof Let p : N þ ! N 0 be a polynomial bounding the time complexity of A, that is, for an input of size n, A always terminates after at most p(n) many steps. Suppose there is an NTM T which covers all active cells in step s of A for input w, that is, for each such active cell r there is at least one computation branch of T corresponding to r.
Furthermore, assume T can then compute the state z 0 of r in polynomial time and accepts if and only if z 0 ¼ z. Without restriction, we may assume s pðjwjÞ; this can be enforced by T, for instance, by computing p(|w|) and rejecting whenever s [ pðjwjÞ. Then, the claim follows immediately from the existence of T: If all computation branches of T accept, then in step s all cells of A are in state z; otherwise, there is a cell in a state which is not z, and T rejects.
The rest of the proof is concerned with the construction of a T with the properties just described. First, we describe the construction, followed by arguing it has the desired complexity (which is fairly straightforward). The last part of the proof concerns the correctness of T which, although fairly evident, calls for a more technical argument. 3 Construction To compute the state of a (in particular, active) cell in step s, T computes a series of subconfigurations c 0 ; . . .; c s of A, that is, contiguous excerpts of the global configuration of A. As the number of cells in an XCA may increase exponentially in the number of computation steps, bounding c i is essential to ensure T runs in polynomial time; in particular, T maintains jc i j ¼ 1 þ 2ðs À iÞ (for i ! 1), thus ensuring the lengths of the c i are linear in s (which, in turn, is polynomial in |w|). This choice of length for the c i ensures each of the subconfigurations correspond to a cell of A surrounded by s À i cells on either side (i.e., each c i corresponds to the extended neighborhood of radius s À i of said cell). The nondeterminism of T is used exclusively in picking the cells from c i which are to be included in the next subconfiguration c iþ1 .
The initial subconfiguration c 0 is set to be q 2s wq 2s , thus containing the input word as well as (as shall be proven) a sufficiently large number of surrounding quiescent cells. To obtain c iþ1 from c i , T applies the transition function of A to c i and obtains a new temporary subconfiguration c 0 iþ1 . The next state of the two ''boundary'' cells (i.e, those belonging to indices 0 and jc i j À 1) cannot be determined, and they are excluded from c 0 iþ1 . As a result, c 0 iþ1 contains jc i j À 2 cells from the previous configuration c i , plus a maximum of jc i j À 1 additional cells which were previously hidden. Therefore, to maintain jc iþ1 j ¼ 1 þ 2ðs À ði þ 1ÞÞ, T non-deterministically sets c iþ1 to a contiguous subset of c 0 iþ1 containing exactly 1 þ 2ðs À ði þ 1ÞÞ jc i j À 2 cells.
The process of selecting a next subconfiguration c iþ1 from c i is depicted in Fig. 2. In the illustration, jc i j has been replaced with n for legibility. T at first applies the global transition function of A to obtain an intermediate subconfiguration c 0 iþ1 with m ¼ jc 0 iþ1 j cells. Because of hidden cells, c 0 iþ1 may consist of n À 2 m 2n À 3 cells. Nondeterminism is used to select a contiguous subconfiguration of n À 2 cells, thus giving rise to c iþ1 .
Complexity T runs in polynomial time since the invariant jc i j ¼ 1 þ 2ðs À iÞ guarantees the number of states T computes in each step is bounded by a multiple of s, which, in turn, we assumed to be bounded by p(|w|). Only |w| has to be taken into account when estimating the time complexity of T since the encoding of z is O(1) long, while that of t has length Oðlog pðjwjÞÞ ¼ Oðlog jwjÞ; as a result, the problem instance (w, t, z) has length O(|w|).
Correctness To show T covers all active cells of A in step s, it suffices to prove the following by induction: Let i 2 f0; . . .; sg, and let z 1 ; . . .; z m be the active cells of A in step i; then T covers all subconfigurations of q 2ðsÀiÞ z 1 Á Á Á z m q 2ðsÀiÞ of size 1 þ 2ðs À iÞ, that is, for every such subconfiguration s there is a branch of T in which it picks s as its c i . Note this corresponds to T covering all subconfigurations of A in step i which contain at least one active cell; thus, when T reaches step s, it covers all subconfigurations of z 1 Á Á Á z m of size 1, that is, all active cells.
The induction basis follows from c 0 ¼ q 2s wq 2s . For the induction step, fix a step 0\i s and assume the claim holds for all steps prior to i. To each subconfiguration of q 2ðsÀiÞ z 1 Á Á Á z m q 2ðsÀiÞ having size 1 þ 2ðs À iÞ corresponds a cell r which is located in its center; thus, we may unambiguously denote every such subconfiguration by s i ðrÞ. Now let s i ðrÞ be given and consider the following three cases: r was active in step i À 1; r was a hidden cell which became active in the transition to step i; or r was a Fig. 2 Illustration of how T obtains the next subconfiguration c iþ1 from c i 3 The main reason for this is that our construction of T nondeterministically picks cells starting at the initial configuration of A instead of (picking a final computation step and then) an arbitrary cell from the final configuration. The issue with the latter approach is that then, in order to compute the chosen cell's state, we would require a procedure that, given an arbitrary cell z in the final configuration of A and without simulating A directly, determines whether z was already present in the initial configuration and, provided it was not, in which step exactly did it turn from a hidden cell into an active one. This is indeed feasible if we constructed A ourselves but virtually impossible in case A is arbitrary (which is the setting of the proof). quiescent cell in step i À 1 and, since js i ðrÞj ¼ 1 þ 2ðs À iÞ and r is the middle cell of s i ðrÞ, r is at most s À i cells away from z 1 or z m .
In the first case, by the induction hypothesis, there is a value of c iÀ1 corresponding to s iÀ1 ðrÞ; since only the two boundary cells are present in c iÀ1 but not in c 0 i , T can choose c i from c 0 i with r as its middle cell and obtain s i ðrÞ. In the second case, for any of the two parents p 1 and p 2 of r, there are, by the induction hypothesis, values of c iÀ1 which equal s iÀ1 ðp 1 Þ and s iÀ1 ðp 2 Þ; in either case, choosing c i from c 0 i with r as its middle cell again yields s i ðrÞ. Finally, if r was a quiescent cell, then, without loss of generality, consider the case in which r was located to the left of the active cells in step i À 1. By the induction hypothesis, for each cell r 0 up to s À i þ 1 cells away from the leftmost active cell z 1 there is a value of c iÀ1 corresponding to s iÀ1 ðr 0 Þ, and the first case applies; the only exception is if c i would then contain only quiescent cells, in which case r would be located strictly more than s À i cells away from z 1 , thus contradicting our previous assumption. The claim follows. h Proposition 12 XCAP p tt ðNPÞ. Proof Let L 2 XCAP, and let A be an XCA for L whose time complexity is bounded by a polynomial p : N þ ! N 0 . Additionally, let w be an input for A, V A be as in Definition 10, and let , where is a syntactic symbol standing for membership in STATE 8 ðAÞ (cf. Definition 2). Define f 0 ðwÞ; . . .; f pðnÞ ðwÞ 2 BOOL V recursively by for i\pðnÞ and Lemma 11 together with the coNP-completeness of TAUT (see Theorem 1) ensures each subformula of the form is polynomial-time many-one reducible to an equivalent (in the sense of evaluating to the same truth value under the respective interpretations; see Definition 2) SAT^-TAUT _ formula , g being a TAUT instance.
Similarly, each subformula is reducible to an equivalent formula . Since each of the f i ðwÞ may contain only polynomially (respective to |w|) many connectives, each is polynomial-time (many-one) reducible to an equivalent SAT^-TAUT _ instance f 0 i ðwÞ.
By the definition of XCA (i.e., Definitions 4 and 6) and our choice of p, f 0 ðwÞ ¼ f 0 0 ðwÞ is true if and only if A accepts w. Since f 0 ðwÞ is such that jf 0 ðwÞj is polynomial in |w|, this provides a polynomial-time (many-one) reduction of L to a problem instance of SAT^-TAUT _ 2 p tt ðNPÞ.

The claim follows. h
This concludes the proof of Theorem 8.

A turing machine characterization
We now turn to a closer investigation of the relation between XCA polynomial-time computations and the class p tt ðNPÞ. In this section, we shall view NTMs as a special case of alternating Turing machines (ATMs), that is, as possessing a computation tree in which all branches are existential. Recall the computational strategy of the XCA in Proposition 7 essentially consists of creating multiple computation branches, each corresponding to a possible variable assignment of the input formula. In a sense, this merely replicates the standard NTM construction used to show SAT 2 NP (or, equivalently, TAUT 2 coNP).
Nevertheless, it is widely suspected that XCAP ¼ p tt ðNPÞ is a strictly larger class than NP, and it is a fair point to question exactly why it is that we obtain such a class (instead of merely NP). The explanation ultimately lies in the acceptance condition of XCAs. Consider that, for instance, the presence of a non-accepting cell prevents acceptance; thus, by the automaton not halting, would-be accepting branches are made aware of the existence of this cell. This enables a form of information transfer between computation branches which is not possible in NTMs. In fact, this form of interaction is not exclusive to a model based on CAs but, as we shall see, may also be expressed in terms of a model based on Turing machines.
In the following definition, we extract the essence of this interaction and embed it into the NTM model. The novelty consists in a modification to the acceptance condition, which, as is the case for XCAs (see Definition 6), requires a simultaneous decision across all computation branches. Unsurprisingly, the condition is that of a unanimous decision across the branches (instead of a single branch being accepting) and actually resembles more a characterization of coNP than of NP (by an NTM variant which accepts if and only if all non-deterministic branches are accepting or, equivalently, an ATM possessing only universal states). However, note this by no means deviates from our goal, that is, defining a model based (exclusively) on TMs that features the form of information transfer discussed above.
Definition 13 (SimulNTM) A simultaneous NTM (SimulNTM) is an NTM T having the property that, for any input w of T, there is t 2 N 0 such that, in step t, the A. Modanese computation branches of T are either all accepting or all rejecting. Furthermore, if t is minimal with this property, then T accepts (resp., rejects) if all branches in step t are accepting (resp., rejecting). SimulNP denotes the class of languages decided by SimulNTMs in polynomial time. Fig. 3 for an example illustrating the computation of a SimulNTM T with accept state a and reject state r. Upon reaching step number t 0 , T does not yet terminate since some of the computation branches are accepting while some are still rejecting, that is, there is no unanimity. T accepts in step t since then all its branches are in state a (assuming this was not the case in any step prior to step t).

Refer to
Theorem 14 SimulNP ¼ XCAP ¼ p tt ðNPÞ. The proof uses techniques fairly similar to the previous ones in this section.
Proof The claim is shown by proving the two inclusions, both of which, in turn, are proven by polynomial-time simulation of either model by the other one.
For the inclusion SimulNP XCAP, let T be a SimulNTM whose running time is bounded by a polynomial p : N þ ! N 0 , to which we shall construct a polynomial-time XCA A with LðAÞ ¼ LðTÞ. Strictly speaking, A is not as in Definition 6 since it has multiple accept and reject states (i.e., A is an MAR-XCA; see Sect. 4.1); as mentioned in Sect. 2.2 and proven in Theorem 18, however, this is equivalent to the original definition (i.e., Definition 6). As is the case for ATMs, we may assume T always creates one additional branch in each step, that is, if its computation is viewed as a tree, then each node has outdegree precisely 2.
A maintains a separate block of cells for each branch in the computation of T. Each block contains the respective instantaneous configuration of T and is updated according to the rules of T. The simulation of T is advanced every m ¼ mðbÞ steps, where b denotes the current length of the respective block and m we shall yet specify. After each simulated step of T, one blank symbol is created on either end of the represented configuration; this is so that T has (theoretically) unbounded space while ensuring any two blocks always have the same length. When the computation of T creates an additional branch, the respective block creates a copy of itself and updates it so as to reflect the instantaneous configuration of the new branch (parallel to updating its own configuration). Additionally, if the head of T becomes accepting or rejecting, the cell representing it sends signals to the other cells in the block so that they mark themselves as such accordingly. Here, ''mark'' means the respective cell changes into a state in which it behaves exactly the same way as before (i.e., as if it was not marked), only this state is an accepting or rejecting state (as determined by the respective state of T). Once all cells in a block have marked themselves, they wait for an additional step (so that A may possibly accept or reject), after which all cells in the block are unmarked again.
We now set m to be the total number of steps required by the two aforementioned procedures, that is, creating a new branch and (if applicable) marking cells as accepting or rejecting and subsequently unmarking them. Note that m 2 HðbÞ is computable in real-time (by a block) as a function of b. As an aside, also note the entire procedure described above does not require any synchronization between the blocks whatsoever since it consists solely of operations that each require a fixed number of steps and, in addition, the simulation is advanced every m steps, which is also fixed.
If the branches of T are all accepting at the same time, then so are all cells of A (at the respective simulation step). The converse also holds: If the branches of T all reject at the same time, then so do the cells of A. In addition, because m 2 HðbÞ and b 2 OðpðnÞÞ for an input of length n, the running time of A is polynomial, and SimulNP XCAP follows.
To prove the converse inclusion, given an XCA A with running time bounded by a polynomial p : N þ ! N 0 , we construct a polynomial-time SimulNTM T with LðTÞ ¼ LðAÞ. Given an input w for A, T first sets t ¼ 0 and then executes the following procedure: Step 0 Step 1 Step 2 Fig. 3 Illustration of the operation of a SimulNTM. States other than a or r have been omitted for simplicity Complexity-theoretic aspects of expanding cellular automata 1. Branch over all active cells of A in time step t (using, e.g., the non-deterministic procedure described in the proof of Lemma 11) and compute the state z of the cell that was chosen. 2. If z is the accept state of A, assume an accepting state for exactly one computation step and then a nonrejecting state for exactly one step. If z is the reject state of A, assume a non-accepting state followed by a rejecting state. If z is the quiescent state, assume an accepting state followed by a rejecting state. If none of the cases above hold (i.e., z is an active state that is neither the accept nor the reject state), wait for two steps in a state that is neither accepting nor rejecting. 3. Increment t and repeat.
Since the lengths of the configurations c i (see the proof of Lemma 11) are the same regardless of how they are chosen, the branches of T can all be synchronized in their computation of the c i so that they advance the simulation of the respective cell block at the same time and, therefore, arrive at the respective state z simultaneously. The subsequent instruction ensures LðTÞ ¼ LðAÞ since, if A accepts (resp., rejects) its input in step s, then so do all branches of T accept (resp., reject) simultaneously for t ¼ s, and the converse also holds. In addition, note that, by definition of STATE 8 ðAÞ, T is guaranteed to halt since ðw; s; zÞ 2 STATE 8 ðAÞ must hold for some s pðjwjÞ and z 2 fa; rg. Since T is only slower than the NTM in the proof of Lemma 11 by a factor O(p(|w|)), it also runs in polynomial time. h

Immediate implications
This section covers some immediate corollaries of Theorem 8 regarding XCA variants. In particular, we address XCAs with multiple accept and reject states, followed by XCAs with acceptance conditions differing from that in Definition 6, in particular the two other classical acceptance conditions for CAs (Rosenfeld 1979).

XCAs with multiple accept and reject states
Recall the definition of an XCA specifies a single accept and a single reject state (see Sect. 2.2). Consider XCAs with multiple accept and reject states. As shall be proven, the respective polynomial-time class (MAR -XCAP) remains equal to XCAP. In the case of TMs, the equivalent result (i.e., TMs with a single accept and a single reject state are as efficient as standard TMs) is trivial, but such is not the case for XCAs. Recall the acceptance condition of an XCA requires orchestrating the states of multiple, possibly exponentially many cells. In addition, an XCA with multiple accept states may, for instance, attempt to accept whilst saving its current state (i.e., a cell in state z may assume an accept state a z while simultaneously saving state z). Such is not the case for standard XCAs (i.e., as specified in Definition 6), in which all accepting cells have necessarily the same state.
Definition 15 (MAR-XCA) A multiple accept-reject XCA (MAR-XCA) A is an XCA with state set Q and which admits subsets Q acc ; Q rej Q of accept and reject states, respectively. A accepts (resp., rejects) if its active cells all have states in Q acc (resp., Q rej ), and it halts upon accepting or rejecting. In addition, A is required to either accept or reject its input after a finite number of steps. MAR -XCAP denotes the MAR-XCA analogue of XCAP.
The following generalizes STATE 8 (see Definition 10 and Lemma 11) to the case of MAR-XCAs: Definition 16 (STATE MAR 8 ) Let A be an MAR-XCA with state set Q, and let V A be the set of triples (w, t, Z), w being an input for A, t 2 f0; 1g þ a binary encoding of s 2 N 0 , and Z Q. STATE MAR 8 ðAÞ V A is the subset of triples such that, if A is given w as input, after t steps all active cells have states in Z.

Existential XCA
The remainder of this section is concerned with XCAs variants which use the two other classical acceptance conditions for CAs (Rosenfeld 1979). The first is that of a single final state being present in the CA's configuration sufficing for termination. We use the term existential as an allusion to the existential states of ATMs.
Definition 19 (EXCA) An existential XCA (EXCA) is an XCA with the following acceptance condition: If at least one of its cells is in the accept (resp., reject) state a (resp., r), then the EXCA accepts (resp., rejects). The coexistence of accept and reject states in the same global configuration is disallowed (and any machine contradicting this requirement is, by definition, not an EXCA). EXCAP denotes the EXCA analogue of XCAP.
Disallowing the coexistence of accept and reject states in the global configuration of an EXCA is necessary to ensure a consistent condition for acceptance. An alternative would be to establish a priority relation between the two (e.g., an accept state overrules a reject one); nevertheless, this behavior can be emulated by our chosen variant with only constant delay. This is accomplished by introducing binary counters to delay state transitions and assure, for instance, that accept and reject states exist only in evenand odd-numbered steps, respectively.
Theorem 20 EXCAP ¼ XCAP ¼ p tt ðNPÞ. Note this is an equivalence between two disparately complex acceptance conditions: As specified in Definition 6, all cells of an XCA must agree on the final decision; on the other hand, in an EXCA, a single, arbitrary cell suffices. We ascribe this phenomenon to XCAP ¼ p tt ðNPÞ being equal to its complementary class. As for the proof of Theorem 20, first note that Proposition 9 may easily be restated in the context of EXCAs:
Proof By adapting the XCA A for SAT^-TAUT _ from the proof of Proposition 9, we obtain a polynomial-time EXCA B for TAUT^-SAT _ . Here, TAUT^-SAT _ is the problem analogous to SAT^-TAUT _ and which is obtained simply by exchanging ''TAUT'' and ''SAT'' in Definition 2. As SAT^-TAUT _ , it is straightforward to show TAUT^-SAT _ is p tt ðNPÞ-complete (see also Theorem 3). To evaluate a predicate of the form , B proceeds as A and emulates the behavior of the XCA deciding TAUT (see Proposition 7); however, unlike A, the computation branches of B which evaluate to false reject immediately while it is those that evaluate to true that continue evaluating the input formula. As a result, if f 2 TAUT, all branches of B evaluate to true and continue evaluating the input in a synchronous manner; otherwise, there is a branch evaluating to false, and, since a single rejecting cell suffices for it to reject, B rejects immediately. The evaluation of is carried out analogously. The modifications to A to obtain B do not impact its time complexity whatsoever; thus, B also has polynomial time complexity. h For the converse inclusion, consider the following NP analogue of the STATE 8 language (cf. Definition 10 and Lemma 11): Definition 22 (STATE 9 ) Let A be an XCA and V be the set of triples (w, t, z) as in Definition 10. STATE 9 V is the subset of triples such that, for the input w, after t steps at least one of the active cells of A is in state z.
Lemma 23 For any XCA A with polynomial time complexity, STATE 9 ðAÞ 2 NP: Proof Consider the NTM T from Lemma 11 and notice that, if any of the active cells of A in step s have state z, then T will have at least one accepting branch; otherwise, none of the active cells of A in step s have state z; thus, all branches of T are rejecting. h Using Lemma 23 to proceed as in Proposition 12 yields the following, from which Theorem 20 follows: Proposition 24 EXCAP p tt ðNPÞ.

One-cell-decision XCA
We turn to the discussion of XCAs whose acceptance condition is defined in terms of a distinguished cell which directs the automaton's decision, considered the standard acceptance condition for CAs (Kutrib 2009). This condition is similar to the existential variant in the sense that the automaton's termination is triggered by a single cell entering a final state. The difference is that, here, the position of this cell is fixed. We consider only the case in which the decision cell is the leftmost active cell in the initial configuration (i.e., cell 0). By a one-cell-decision XCA (1XCA) we refer to an XCA which accepts if and only if 0 is in the accept state and rejects if and only if cell zero is in the reject state. Let 1XCAP denote the polynomial-time class of 1XCAs.
The position of the decision cell is fixed; with a polynomial-time restriction in place, it can only communicate with cells which are a polynomial (in the length of the input) number of steps apart. As a result, despite a 1XCA being able to efficiently increase its number of active cells exponentially (see Lemma 5), any cells impacting its decision must be at most a polynomial number of cells away from the decision cell. Thus: Theorem 25 1XCAP ¼ P.
Proof The inclusion 1XCAP P is trivial. For the converse, recall the construction of the NTM T in Lemma 11. T can be modified so that it works deterministically and always chooses the next configuration c iþ1 from c i by selecting cell zero as the middle cell. If cell zero is accepting, then T accepts immediately; if it is rejecting, then T also rejects immediately. This yields a simulation of a 1XCA by a (deterministic) TM which is only polynomially slower, thus implying 1XCAP P. h

Conclusion
This paper summarized the results of Modanese (2018) and also presented related and previously unpublished results from Modanese (2016). The main result was the characterization XCAP ¼ p tt ðNPÞ (Theorem 8) in Sect. 3, which also gave an alternative characterization based on NTMs (Theorem 14). In Sect. 4, XCAs with multiple accept and reject states were shown to be equivalent to the original model (Theorem 18). Also in Sect. 4, two other variants based on varying acceptance conditions were considered: the existential (EXCA), in which a single, though arbitrary cell may direct the automaton's response; and the one-cell-decision XCA (1XCA), in which a fixed cell does so. In the first case, it was shown that the polynomial-time class EXCAP equals XCAP (Theorem 20); in the latter, it was shown that the polynomial-time class 1XCAP of 1XCAs equals P (Theorem 25). This paper has covered some XCA variants with diverse acceptance conditions. A topic for future work might be considering further variations in this sense (e.g., XCAs whose acceptance condition is based on majority instead of unanimity, which appears to lead to a model whose polynomial-time class equals PP). Another avenue of research lies in restricting the capabilities of XCAs and analyzing the effects thereof (e.g., restricting 1XCAs or SXCAs to a polynomial number of cells). A final open question is determining what polynomial speedups, if any, 1XCAs provide with respect to 1CAs. encouragement, and support during the writing of this paper. I would also like to thank Dennis Hofheinz for pointing out a crucial mistake in a preliminary version of this paper as well as the anonymous referees for their valuable remarks and suggestions. Open Access funding enabled and organized by Projekt DEAL.
Funding Open Access funding enabled and organized by Projekt DEAL.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons. org/licenses/by/4.0/.