Computing with Sublogarithmic Space - CiteSeerX

This is page 1 Printer: Opaque this

Computing with Sublogarithmic Space Maciej Liskiewicz Rudiger Reischuk ABSTRACT We investigate space complexity classes de ned by Turing machines that use less than logarithmic space. Because of the limited counting ability of such machines most of the standard simulation techniques do not work for sublogarithmic space classes. However, machines with such little space may still be quite powerful. Therefore, it was not obvious how to obtain analogues for inclusion and separation results known for classes above logspace. Known facts about small space-bounded machines for deterministic, nondeterministic and alternating Turing machine models and properties of the corresponding complexity classes are reviewed. Several recent results, which show that these classes really behave dierently, will be discussed. For example, certain closure properties do not hold. The restricted power of these machines makes it possible to prove explicit separations { even for alternating complexity classes { by combinatorial arguments. This way, we obtain a hierarchy of non-relativized complexity classes without any unproven assumption. These complexity classes are related to other classes within P, in particular to context-free languages. Finally, we consider extension of these computational models by randomness, that means interactive proofs, resp. Arthur-Merlin games with a small space-bounded veri er. A separation is obtained for the complexity classes on the second level of the round/alternation hierarchy.

1 Are Sublogarithmic Space Classes of any Interest? The logarithm seems to be the most crucial bound for space complexity. Since with less space one cannot implement a counter for a polynomial size range, neither a position within the input nor the number of steps of a computation can be recorded. Therefore, most of the standard techniques used for machine simulations did not work for sublogarithmic space, and it was not clear whether evident properties also hold for sublogarithmic space bounds. For example, a novel technique was necessary to prove for small bounds S that DSpace(S) is closed under complement [Si80], where DSpace(S) denotes the set of all languages that can be recognized by

2

Maciej Liskiewicz , Rudiger Reischuk

S{space-bounded deterministic Turing machines (DTM). And Savitch's technique to simulate nondeterministic machines (NTM) by deterministic machines requires space (maxflog; S g)2 because of the recursion depth and the necessity to specify machine con gurations. This gives a quadratic increase of the space for logarithmic or larger bounds. By some work the space can be reduced to S
maxflog; S g [MoSu82], but still one gets an exponential blowup for very small space bounds. Another important problem of this type is whether the closure under complement of nondeterministic space classes NSpace(S) = co-NSpace(S) shown by Immerman and Szelepcsenyi [Im88, Sz88] remains valid for space bounds S < log . If this equality were not valid then obviously DSpace(S) would be properly contained in NSpace(S). Do relations between sublogarithmic classes have impact for larger complexity classes? Let us use the shorthand llog for the twice iterated logarithmic function n 7! log2 log2 n. In general, the principles of upward collapse and downward separation, which can easily be proved by standard translation techniques for at least logarithmic space bounds, do not seem to hold in the sublogarithmic space world. However, by a more complicated argument Szepietowski could at least show the implication: Theorem 1 [Sz90] If DSpace(llog) = NSpace(llog) then DSpace(log) = NSpace(log). Hence equality between deterministic and nondeterministic space at a very low level still gives the identity for large space classes. Although because of the missing counters sublogarithmic space complexity classes are technically quite dicult to handle, at rst glance they may look very weak. For example, it has been known for quite a while that the deterministic context-free language COUNT := f1n01m j n = mg cannot be recognized with sublogarithmic space [LSH65], even by nondeterministic machines. This has been generalized in [AGM92] to the result that NSpace(o(log )) does not contain any deterministic context-free nonregular language. These results, however, do not extend to probabilistic classes. Freivalds has shown the surprising result [Fr81] that COUNT can be accepted by a probabilistic TM in constant space with an arbitrarily small constant for the error probability. Thus, why should one be interested in sublogarithmic space complexity classes? A deterministic or nondeterministic Turing machine (TM) that uses less than llog space can recognize regular languages only [SHL65, HoUl69]. Since there exist nonregular languages in DSpace(llog ) the function llog has turned out to be the smallest nontrivial space bound, at least

1. Computing with Sublogarithmic Space

3

for deterministic and nondeterministic TMs. Later, this lower space bound has been extended to alternating Turing machines (ATM) and their corresponding complexity classes ASpace, thus Theorem 2 [Su80, Iw93] DSpace(o(llog)) = NSpace(o(llog)) = ASpace(o(llog)) = REG : The machine model we will refer to is the standard one for space bounds, which is equipped with a separate 2-way read-only input tape and one (or more) work tape(s). Restricted machines that can read their input only 1-way, also called on-line machines, will not be considered here. For this model space complexity investigations are considerably easier. For example, the recognition of nonregular languages with 1-way input access requires at least logarithmic workspace, and simple tasks like the recognition of palindromes need linear space [SHL65]. However, Sudborough has shown the surprising result that the closure of the class ASpace(llog ) with 1-way restriction under logspace reducibility is quite strong [Su80]. It equals SC, the class of languages that can be recognized with simultaneous polynomial time and polylogarithmic space. Since in [CKS81] it has been shown that ASpace(log ) = P sublogarithmic space classes even de ned by alternating machines are contained in P. The best upper bound known for alternating sublogarithmic space classes seems to be: Theorem 3 [Su80] For any S ASpace(S)  DSpace(ExL(S)) : Here, ExL(S) denotes the set of all complexity bounds that are bounded exponentially with respect to S, i.e. by a function of the form exp(k
S) for some k 2 IN, and S itself has to ful ll certain weak constructibility conditions. In particular, for the smallest nontrivial space bound we get [ ASpace(llog )  DSpace(logk ) : k

However, this simulation of ATMs within polylogarithmic space takes more than polynomial time, and it is an open problem whether ASpace(llog ) is contained in SC. Thus, sublogarithmic alternating space classes may actually be quite strong. Even if we bound the number of alternations by some function A and let AAlterSpace(A; S) denote the corresponding complexity class the best known upper bound drops down to: Theorem 4 [MoSu82, To81, Su80] AAlterSpace(A; S)  DSpace(S
(S + A + log)) :

4

Maciej Liskiewicz , Rudiger Reischuk

This means for a constant number of alternations { denoted by the set

CON of all bounded functions { AAlterSpace(CON ; llog)  DSpace(log
llog) ;

and also this class may not be included in SC. Therefore, sublogarithmic space-bounded machines with the ability of alternations may be quite powerful devices. In the following we will investigate such machines in more detail and present combinatorial techniques to prove lower bounds. Let us denote the set of all nontrivial sublogarithmic space bounds by SUBLOG := (llog) \ o(log) : The remaining part of this contribution is organized as follows. In Section 2 we review the results about alternating sublogarithmic space-bounded machines. Section 3 discusses the question whether randomness can extend the power of such machines. In Section 4 and 5 we investigate the limitations of sublogarithmic space-bounded machines and give the general outline how some of the separations results for the alternating classes can be obtained (for more complete proofs see [LiRe93b]).

2 The Alternating Sublogarithmic Space World Complexity classes are typically described by nicely growing functions with values that can be computed easily. This includes powers and roots of the logarithmic function or iterated logarithms. However, logarithmic space seems to be necessary for this task. De nition 1 A function A : IN ! IN is computable in space S if there exists a DTM that for all inputs of the form 1n writes down the binary representation of A(n) on an extra 1-way output tape using no more than S(n) work space. A is approximable from below in space S if there exists a function A0 that is computable in space S with A0 (n)  A(n) for all n 2 IN and A0 (n) = A(n) for in nitely many n 2 IN. If S itself is computable in space S it is called fully space-constructible. An equivalent requirement would be the existence of a TM that on every input of length n uses exactly S(n) memory cells. There exists fully space-constructible functions in o(log ). The best known example is dlog (F(n) + 1)e, where F(n) := smallest integer that does not divide n, which due to the distribution of primes even belongs to O(llog). However, any such function has to equal some constant value in nitely often [FrLa75]. This means

1. Computing with Sublogarithmic Space

5

Fact 1 No fully space-constructible function belongs to SUBLOG . For monotone increasing space bounds S this property even generalizes to nondeterministic constructors [Ge91], where it is required that for each input X at least one computation path uses space S(jX j) and no path uses more than that. If a complexity bound S is fully space-constructible for any given input one could mark the number of available memory cells in advance to prevent that this space bound is exceeded. Thus assuming that for each string X in a language L an acceptor M for L has at least one accepting computation that uses space at most S(jX j) we can easily achieve that all computation paths stay within this bound. For sublogarithmic bounds, however, the following distinction becomes important. De nition 2 An ATM M is (strongly) S{space-bounded if on every input X M only enters con gurations that use at most S(jX j) space. M is weakly S{space-bounded if, for every input X that is accepted, it has an accepting computation tree all of whose con gurations use at most S(jX j) space. DSpace(S) denotes the class of languages accepted by S{space-bounded DTMs and weakDSpace(S) denotes the languages accepted by weakly S{ space-bounded DTMs. A corresponding notation is used for NTMs and ATMs. We will concentrate on the more natural strong requirement for space complexity, which is also the one used in the fundamental work of Hartmanis, Lewis and Stearns. When studying closure properties and alternating hierarchies the weak measure is not appropriate. To recognize a language L in the weak sense an acceptor for L may use arbitrary space for strings in L, while a machine for L has to be bounded on this set. Another important distinction is that a machine with space bound S  log can make at most exponentially in S many steps without getting into a loop. Thus, on a separate storage track one could also count the number of steps to detect in nite computation paths. This implies immediately that for such S the class DSpace(S) is closed under complement. This method cannot be applied in the sublogarithmic space world. Sipser, however, found another way to check whether the starting con guration can reach an accepting con guration without the danger of being trapped in a loop. He simulates "backwards\. As a consequence we obtain Theorem 5 [Si80] For arbitrary S it holds: DSpace(S) is closed under complement .

A special situation holds for bounded languages containing only strings of a certain block structure. De nition 3 Let Z : IN ! IN be a function. A language L  f0; 1g is Z {bounded if each X 2 L contains at most Z(jX j) zeros. L is bounded if it

6

Maciej Liskiewicz , Rudiger Reischuk

is Z{bounded for some constant function Z. The language COUNT de ned above is an example for 1-boundedness. Sublogarithmic space-bounded machines already face problems within a large block of identical symbols since they cannot record the exact length of such a block. The formal argument to show this is known as the n 7! n + n!{ technique developed by Stearns, Hartmanis, and Lewis in [SHL65]. For n large enough the machine will not notice any dierence between the blocks 1n and 1n+n!. In particular, if the TM obeys the space bound s = S(n) in the smaller block it will use no more than s space in the large block, too. Theorem 6 [AlMe76, CIRB87, LiRe93a] COUNT 62 weakNSpace(o(log)) ; COUNT 2 weakDSpace(llog ) ; COUNT; COUNT 62 ASpace(o(log)) : These bounds also show that with respect to the weak measure there can occur an exponential dierence between the space complexity of a language and its complement. Thus in contrast to the previous theorem weakly bounded deterministic classes are not closed under complement. Even an alternating machine cannot simulate a weakly bounded deterministic machine with less than an exponential increase of the space bound. The lower bound can be generalized to arbitrary deterministic contextfree languages. De nition 4 [St67] and [Gin72] A language L is called strictly nonregular if one can nd strings u; v; w; x and y such that L \fugfvgfwgfxgfyg is context-free, but nonregular.

Theorem 7 [AGM92, LiRe93b] If L is any nonregular deterministic context-free or strictly nonregular, or L is any nonregular context-free bounded language, then L 2= AAlterSpace(CON ; o(log)). Furthermore, it is not

possible that L and L both belong to ASpace(o(log )).

There are more nontrivial languages besides COUNT that can be recognized in sublogarithmic space. An interesting example is BIN := fbin(1)# bin(2)# : : :# bin(m) j m 2 INg ; where bin(i) denotes the binary representation of the natural number i. However, the theorem above implies that such languages cannot be too simple like being context-free and deterministic or bounded. The language BIN has the property that it can serve as an advice to construct the function llog, which as we have seen is not fully spaceconstructible. A machine can simply check the correctness of the sequence by looking at the i-th bit position of all subwords sequentially for i =

1. Computing with Sublogarithmic Space

7

0; 1; : : :. For this purpose counters of length log m suce, where m is roughly the logarithm of the input length. The inability to count in sublogarithmic space, however, has a positive eect, at least in case of bounded languages. As exploited in the proof of the theorem above within a block of identical input symbols the machine has to behave in a periodic fashion implying that important things only happen at the right and left boundary of a block. This observation can be used to prove Theorem 8 [HaBe76, CIRB87] Every in nite bounded language that belongs to NSpace(SUBLOG ) contains an in nite regular subset. This restricted behaviour of machines with small space complexity for bounded languages also allows one to implement the inductive counting method within the same space bound and yields: Theorem 9 [Ge93b, AGM92, Sz94] Let S 2 SUBLOG be arbitrary. Then for the class of Z {bounded languages, where Z is a constant or a small growing function not larger than exp O(S) and computable in space S , it holds

NSpace(S) = co-NSpace(S) : All the properties discussed till now concern the most extreme cases of ATMs, i.e. machines that do not alternate at all (DTMs, NTMs) or that make an unbounded number of alternations. One of the main aims of this contribution is to review techniques used to a more subtle analysis of the alternating sublogarithmic space world. In the remaining part of this section we discuss the most signi cant consequences of these methods. De nition 5 For k  1, the class k Space(S) and k Space(S) are de ned as all languages accepted by alternating S {space-bounded TMs that make at most k ? 1 alternations and start in an existential (resp. universal) state. We will also consider ATMs with a non-constant bound A for the number of alternations. In this case, the notation A Space(S) and A Space(S) is used. AAlterSpace(A; S) denotes A Space(S)[A Space(S). Obviously, 1Space(S) = NSpace(S). By standard techniques it follows from Immerman-Szelepcsenyi's result: Theorem 10 For S  log and for all k  1 1 Space(S) = k Space(S) = k Space(S) : Note that these techniques do not work for sublogarithmic space bounds. Chang et al. have shown in [CIRB87] that in the sublogarithmic space world the situation is really dierent. Theorem 11 There is a language in 2 Space(llog ) that does not belong to 1 Space(o(log )).

8

Maciej Liskiewicz , Rudiger Reischuk

Clearly, this proves that for space bounds S in SUBLOG the alternating S space hierarchy does not collapse to the rst level and that 1Space(S)  2 Space(S) : Does this relation also hold for higher levels? This question has received a lot of attention recently. Independently in a series of papers the answer was found [Br93, Ge93a, LiRe93a, BGR93, Ge93c, LiRe93b]. These classes indeed form a strict in nite hierarchy. A chronology of these results can be found in [Wa93]. Theorem 12 For all k > 1: k Space(llog ) n k Space(o(log )) = 6 ; k Space(llog ) n k Space(o(log )) = 6 ;:

and

The theorem implies that the alternating sublogarithmic space hierarchy is an in nite one, contrary to the case for logarithmic or larger space bounds. Corollary 1 For any S 2 SUBLOG and all k  1: k Space(S)  k+1 Space(S) ; k Space(S)  k+1 Space(S) : Observe that Theorem 12 gives a complete and best possible separation for the sublogarithmic space world, except for the rst level k = 1. It remains an open problem whether also 1 Space(S) 6= 1 Space(S) for S 2 SUBLOG . Although dierent methods have been used to separate k and k none of them seems to be applicable to the rst level. The proofs of the separation results above use in an essential way that counting to a certain extent can be replaced by alternating quanti ers. In the base case, however we have only a nondeterministic machine, that is a single existential quanti er. The possibility that both classes are equal is not completely unrealistic, which would give the novel result that a hierarchy is in nite, although its rst level collapses. However, we conjecture that for k = 1 the classes are dierent, but a proof seems to be signi cantly more dicult than for larger k. That the sublogarithmic space world is indeed very complex can be observed restricting oneself to bounded languages. In this case we have seen that 1 Space(S) is closed under complementation and that 1Space(S) and 1Space(S) are identical for any S 2 SUBLOG . The second and third level, however, can be separated by bounded languages [LiRe93a]. Nothing seems to be known for level 4 and higher. Thus, the sublogarithmic space hierarchies for bounded languages may be quite strange. We have made some observations leading to the conjecture that this hierarchy might indeed consist of only a nite number of distinct levels.

1. Computing with Sublogarithmic Space

9

Let us come back to the full class of languages without any boundedness restrictions. The separation of the alternating levels can be generalized to an unbounded number of alternations as long as the product of alternation and space bounds remains sublogarithmic. Theorem 13 [LiRe93b] For any pair of functions S 2 SUBLOG and A > 1 with A
S 2 o(log ), where A is approximable from below in space S, it holds that A Space(S) n A Space(S) 6= ; ; A Space(S) n A Space(S) 6= ; : Corollary 2 For any S and A as in the theorem above it holds: A Space(S)  A+1 Space(S) ; A Space(S)  A+1 Space(S) : Note that the class of functions that are approximable from below in space S 2 SUBLOG is quite large. For example, it contains the bounds blog c, blog1=2 c, bllog c and blog c. Thus one obtains: 1. llog Space(llog )  (llog )+1 Space(llog ). 2. 3. 4.

S Space(S)  S +1 Space(S) for S = log1=2? with 0 <  < 1=2. S  k2IN k Space(S)  log Space(S) for S 2 (llog) \ o(log = log ). For any k 2 IN it holds: AAlterSpace(llogk ; llog)  AAlterSpace(llogk+1; llog) :

Note that in the last case the corresponding question for logarithmic space bounds is still open, that is, whether for log {space-bounded ATMs logk+1 alternations yield more computing power than logk many. This question is equivalent to the question whether the AC hierarchy is in nite: AAlterSpace(logk ; log)  AAlterSpace(logk+1 ; log) ? For any function S the class 1 Space(S) is closed under union and intersection. More general, for arbitrary k the classes k Space(S) are closed under union, and symmetrically the k Space(S) are closed under intersection. In [LiRe93a] we have developed a technique showing that for S 2 SUBLOG and for k = 2; 3, k Space(S) and k Space(S) are not closed under complementation. Furthermore, k Space(S) is not closed under intersection, and k Space(S) not under union. Combining these ideas with the separation results of Theorem 12 we get the same closure properties for all levels. Theorem 14 [LiRe93b] For any S 2 SUBLOG and all k > 1:

10

Maciej Liskiewicz , Rudiger Reischuk

1. k Space(S) and k Space(S) are not closed under complementation, 2. k Space(S) is not closed under intersection, 3. k Space(S) is not closed under union, 4. k Space(S) and k Space(S) are not closed under concatenation.

However, it is still an open problem whether for S 2 SUBLOG the class 1Space(S) is closed under complementation. Note that non-closure under complementation for k and k classes is not trivially equivalent to Theorem 12, which says that sublogarithmic k Space and k Space are distinct, since sublogarithmic space-bounded machines cannot that easily detect an in nite computation path. And Sipser's method only works for deterministic machines. Thus, it is an interesting open problem whether k Space(S) = co-k Space(S) for k = 1; 2; : : : (for more details see [LiRe93a]). But at least one can obtain the following partial solution generalizing Theorem 5 to ATMs in case of bounded languages. Such acceptors can always be guaranteed to halt. This implies Theorem 15 [LiRe93b] Let S 2 SUBLOG be a space bound and Z be a function computable in space S with Z  exp S . Then for all k  1 and for every Z {bounded language L  f0; 1g it holds: L 2 k Space(S) () L 2 k Space(S) : This theorem is a straightforward consequence of the following extension of Sipser's space-bounded halting result to ATMs. Theorem 16 [LiRe93b] Let S; A; Z be bounds with A < 1 and Z  exp S computable in space S . Then for every S {space-bounded A TM M there exists a A TM M 0 of space complexity S such that for all inputs X  M 0 accepts X i M accepts X and X is Z {bounded, and  every computation path of M 0 on X is nite. Observe that for S  log the function Z can grow linearly and then Z does not put any restriction on the structure of the strings in L. Thus, Theorem 15 gives a smooth approximation of the fact that for at least logarithmic space bounds k and k are complementary for arbitrary languages. We conjecture that the computability of Z is needed in the theorem. Furthermore, there are some indications that the theorem might not be true in general for bounds Z much larger than exp S.

1. Computing with Sublogarithmic Space

11

3 Adding Randomness A Turing machine, to a certain extent, can compensate for little space by random bits if one is willing to tolerate a small probability of error. Let BPSpace(S) denote the class of languages that can be recognized by a probabilistic TM in space S with error probability at most 1=4. Theorem 17 [Fr81] BPSpace(CON ) contains nonregular languages. COUNT is an example which can be recognized by the following experiment that has to be repeated a lot of times till a signi cant number of successes has occurred: Separately for the two block of ones of an input X, toss a coin for each symbol in the block. Count as a success for the block if all coins show head. Accept X if the number of successes of both blocks are equal. Note that this strategy requires exponential (expected) time, whereas nonprobabilistic machines even with a logarithmic space bound can be assumed to be polynomial time bounded. Hence, DSpace(log ) is the best upper bound for the class BPSpace(CON ). An interesting question is if the same holds for any sublogarithmic space bound. The best upper bound known for languages recognized by probabilistic machines in space S seems to be DSpace(min(2S log ; log n(S+llog ))) (see [Ju84] and [Ma94]). However, the counting abilities of probabilistic machines are limited as has been shown recently by Freivalds and Karpinski using the language PALINDROME of all strings that are palindromes. Theorem 18 [FrKa94] PALINDROME 62 BPSpace(o(log )). What happens in the sublogarithmic space world if we combine nondeterminism and probabilism? If nondeterministic machines are extended with the ability to perform random moves one obtains the stochastic Turing machine model (STM) as introduced by Papadimitriou [Pa85]. Alternative characterizations can be given by interactive proof systems of Goldwasser, Micali and Racko [GMR89] and Arthur-Merlin-games of Babai [Ba85], see also [GoSi86] and [Co89]. In a probabilistic state a stochastic machine M chooses among the successor con gurations with equal probability. As for alternating machines, a computation of M on an input X can be described by a computation tree. To de ne acceptance of X, for each existential con guration one chooses a successor that maximizes the probability of reaching an accepting leaf. The acceptance probability of X is then given by the acceptance probability of the starting con guration in this truncated tree. M accepts a language L in space S if  for all X 2 L, the probability that M accepts X is more than 3=4,  every X 62 L is accepted with probability less than 1=4, and  M never uses more than S(jX j) space.

12

Maciej Liskiewicz , Rudiger Reischuk

De nition 6 Let MAkSpace(S) (resp. AMk Space(S)) denote the set of languages that can be accepted by such a machine in space S making at most k ? 1 alternations between existential and probabilistic con gurations

and starting in existential (resp. probabilistic) mode. For such a machine we also say that it works in space S and k rounds. Dwork and Stockmeyer were the rst who investigated interactive proof systems with small space-bounded veri ers [DwSt92]. The separation results presented in [DwSt92] are stated for constant space, but they can be extended to any sublogarithmic bound (see e.g. [Co93]). It has been shown that for sublogarithmic space bounds it makes a difference whether the random moves are known, as it is the case for a STM, resp. for Arthur-Merlin games, or whether they are hidden as in interactive proof systems. PALINDROME is an example that can easily be recognized by an interactive proof system with a constant space-bounded veri er and hidden random moves, but requires logarithmic space otherwise (see [DwSt92] and [Co93]). This property does not hold for the corresponding polynomialtime classes AMk Time(POL ). Here, POL denotes the set of all polynomials. Furthermore, it has been shown [Ba85] that any number of rounds can be reduced to two rounds, that is MA2Time(POL )  AM2 Time(POL) = AMCON Time(POL ) : One might expect that for at least logarithmic space bounds similar to ATMs the alternating stochastic hierarchy collapses to some level. On the other hand we have obtained some evidence that for space bounds S 2 SUBLOG the situation is dierent. Extending an impossibility result for 2-way probabilistic nite automata one can show that the language CENTER

:= fw0x j w; x 2 f0; 1g and jwj = jxjg

cannot be recognized by a sublogarithmic space-bounded probabilistic Turing machine with any error probability  < 21 [FrKa94]. However, there exists a constant space interactive proof system for this language. Hence, for any S in SUBLOG languages CENTER and PALINDROME yield the following separations:

Theorem 19

BPSpace(S) = AM1 Space(S)  AMSpace(S)  AMSpace(log ) = P : The last equivalence is due to Condon [Co89]. A sublogarithmic STM may require exponential expected time. It is shown in [DwSt92] that some languages cannot be recognized by such machines faster { CENTER is one of such example. On the other hand,

1. Computing with Sublogarithmic Space

13

the power of sublogarithmic space bounded STMs restricted to polynomial expected time is still an open problem. In this case we do not even know if stochastic nite automata can recognize nonregular languages. Let BIN(m) := bin(0)# bin(1)# bin(2)# : : :# bin(m), and de ne PATTERN

:= fBIN(2k )  w1  w2  : : :  wt  u j w1; : : :; wt 2 f0; 1gk for some t; k 2 IN and u 2 fw1; : : :; wtg g :

Combining the proof methods described above with some of [DwSt92] for probabilistic machines we can show Lemma 1 [LiRe95] For S 2 o(log ), an S{space-bounded STM cannot recognize PATTERN in 2 rounds starting in probabilistic mode, that is PATTERN

62 AM2 Space(o(log )) :

On the other hand, it is not hard to see that switching the quanti ers the problem can be solved within small space. Lemma 2 [LiRe95] For arbitrary small  > 0, there exists an llog{spacebounded STM M for PATTERN with error probability  that works in 2 rounds starting in nondeterministic mode, that is PATTERN

2 MA2 Space(llog ) :

Moreover, M works in polynomial time. Therefore, we obtain the following separation Theorem 20 MA2Space(llog) 6 AM2Space(o(log )) : We conjecture that the alternation hierarchy for sublogarithmic spacebounded STMs is in nite, similar as for standard ATMs, that means AM1 Space(S)  AM2 Space(S)  AM3 Space(S)  : : : It is interesting to notice that the AMk Space(S) and MAk Space(S) classes do not seem to be complementary, since

Lemma 3 [LiRe95] PATTERN

62 AM2 Space(o(log )) :

In the remaining part of this article we will present the main tools for obtaining lower bounds for sublogarithmic space-bounded machines.

14

Maciej Liskiewicz , Rudiger Reischuk

4 Special Limitations of Machines with a Sublogarithmic Space Bound 4.1 Technical Preliminaries

For a TM M, a memory state is an ordered triple  = (q; u; i), where q is a state of M, u a string over the work tape alphabet, and i a position in u (the location of the work tape head). A con guration of M on an input X is a pair (; j) consisting of a memory state  and a position j with 0  j  jX j + 1 of the input head. j = 0 or j = jX j + 1 means that this head scans the left, resp. the right end-marker. For a memory state  = (q; u; i) let jj denote the length of the memory inscription u. We may assume that for a successor (0; j 0 ) of a con guration (; j) it always holds j0j  jj. The state set of an ATM is partitioned into subsets of existential, universal, accepting, and rejecting states. We say that a con guration ((q; u; i); j) is existential (resp. universal, accepting, or rejecting) if q has the corresponding mode. All accepting and rejecting con gurations C are assumed to be terminating, i.e. there is no con guration that can be reached from C. Let (; i) j=?M;X ( ; j) denote the property that the ATM M with X on its input tape has a computation path of the form C1 = (; i); C2; : : :; Ct = ( ; j). (; i) j=M;X ( ; j) denotes the same fact, but with the following restriction: t  2 and the mode of the con gurations C2 ; : : :; Ct?1 is the same as that of C1 (i.e. if C1 is existential then all Cl for l = 2; : : :; t ? 1 are existential, otherwise they are all universal). The predicate acckM (; i; X) holds if M starting in con guration (; i) with X on its input tape accepts (i.e. has an accepting subtree), and on each computation path of that tree M makes at most k ? 1 alternations. Let SpaceM (; i; X) denote the maximum space used in con gurations M can reach on input X starting in con guration (; i) and SpaceM (X) := SpaceM (0; 0; X) ; where (0; 0) is the initial con guration of M. Similarly let AlterM (; i; X) denote the maximum number of alternations M can make on input X starting in con guration (; i) and AlterM (X) := AlterM (0 ; 0; X).

1. Computing with Sublogarithmic Space

4.2 Inputs with a Periodic Structure

15

Next, we will discuss some properties of TM computations for binary inputs of the form Z1 WW : : :WZ2 . In the following, let M denote an arbitrary ATM, and S a space bound in o(log ). Depending on M and S, we choose a constant NM;S  28 such that for all n  NM;S (M6n + 1)2 < n and S(n) < 21 log n ? 2 ; where Mn denotes the number of memory states  with jj  S(n). All claims following will hold for any integer n  NM;S . From the work in [SHL65, Ge91] it is known that for sublogarithmic space-bounded computations for any natural number ` the behaviour of a DTM or NTM on input 1n+`n! is exactly the same as on 1n. We will show that a corresponding property holds for ATMs and for all inputs of the form X = Z1 W n Z2 and Y = Z1 W n+`n! Z2 ; where Z1 ; Z2 ; W are arbitrary binary strings and ` 2 IN. Since in the following we will often compare computations on such an input X and a pumped version Y let us introduce a special notation for positions within these strings. If i is a position within X outside the pumped region W n , that means for the example above either in Z1 or in Z2 , then ^i denotes the corresponding position within Y . Thus  if i  jZ1j , ^i := i i + jY j ? jX j if i > jZ1W n j . The main technical tools for the analysis of sublogarithmic space-bounded ATMs are stated in the following ve lemmata. Here, X and Y denote strings as de ned above and M an arbitrary ATM. Note that n now is not necessarily identical to the length of the input X. Actually, X will in general be much larger than n. But by a repeated application of the following implications we can show that any machine M still obeys a sublogarithmic bound with respect to n. Lemma 4 (Pumping) Let ; be memory states with jj  j j  S(n), then for any i; j 2 [0 : : : jZ1 j ] [ [ jZ1 W n j + 1 : : : jX j + 1 ] it holds: 1. (; i) j=M;X ( ; j) () (; ^i) j=M;Y ( ; ^j ), 2. (; i) j=?M;X ( ; j) () (; ^i) j=?M;Y ( ; ^j ). First we apply the above Pumping Lemma to show that on the long input Y M uses the same space as on the short X.

Lemma 5 (Small Space Bound) SpaceM (X)  S(n) =)

SpaceM (Y ) = SpaceM (X) :

16

Maciej Liskiewicz , Rudiger Reischuk

Proof. Let SpaceM (X)  S(n). Assume, to the contrary, that SpaceM (Y ) 6= SpaceM (X). We will show that SpaceM (Y ) > SpaceM (X) cannot occur. A similar contradiction can be obtained for the case SpaceM (Y ) < SpaceM (X). Assume that SpaceM (Y ) > SpaceM (X). Hence, for Y there exists a computation path C that starts in the initial con guration (0 ; 0) and ends in a con guration (; ^j) with jj = SpaceM (X) such that from (; ^j ) M can reach a con guration ( ; ^j 0 ) with j j = SpaceM (X) + 1 in one step:

(0; 0) j=?M;Y (; ^j ) j=?M;Y ( ; ^j 0 ) : If j ful lls the condition j  jZ1j or j > jZ1W n j of the Pumping Lemma then one can conclude immediately: (0; 0) j=?M;X (; j) j=?M;X ( ; j 0 ) : Otherwise, using a similar pumping argument one can show that M on input X can reach a con guration (; j ), in which the input head is located on W n and reads the same symbol as in (; ^j ). Thus it can also get to memory state in one more step. We get a contradiction since j j > SpaceM (X). A similar property holds for the number of alternations. More precisely, one can prove that the maximal number of alternations made by M on input Y is the same as on X if on X the machine uses no more than S(n) space and no more than exp S(n) alternations.

4.3

Fooling ATMs

Exploiting these properties one can show that alternating machines are fooled when pumping the input.

Lemma 6 (1-Alternation) Let (; i) be an existential con guration for

which M with X = Z1 W n Z2 on the input tape scans a position within the pre x Z1 or within the sux Z2 . Moreover, assume that M starting in this con guration uses never more space than S(n). Then the following implication holds: if M accepts X with one alternation starting in (; i) then M making at most one alternation also accepts the input Y when it starts in (; ^i). The opposite implication holds for a universal (; i) con guration. Note that from the above property follows that if a 2 TM accepts an input of the form 1n in sublogarithmic space then it accepts 1n+n! , too. Similarly, if a 2 TM accepts 1n+n! in sublogarithmic space then it has to accept the short input 1n . In the following two lemmata we consider the in uence of shifting the input head between identical copies of a xed string W. For this purpose let us denote the shift distance by
:= jW j
n!.

1. Computing with Sublogarithmic Space

17

Lemma 7 (Con guration Shift) Let X = Z1 W n+n! W s W n Z2 be a binary input string of M with s  1 and let (; i) and ( ; j) be con gurations with jj  j j  S(n) such that M in (; i) scans a position within the pre x Z1 or sux Z2 and in ( ; j) scans a position within the in x W s . Then, there exists a computation path of M on X that starts in (; i) and ends in ( ; j) if and only if M has a computation path on X that starts in the same con guration and ends in ( ; j ?
). n+n! Z1 W W W

s

n

............ W W W ... W W ... W Z 2

( α, i )

( β, j- ∆ )

( β, j )

FIGURE 1. Con guration-Shift Lemma: the thin line describes a motion of the input head during a computation that starts in (; i) and ends in ( ;j ) and the bold one describes an input head movement during a computation between (;i) and ( ; j ?
).

Below we prove even more. Namely we show that (; i) j=M;X ( ; j) () (; i) j=M;X ( ; j ?
) ; i.e. we show in addition that M along both paths either does not alternate or makes only one alternation just in the last step. Proof. First note that the positions j and j ?
considered are at least n blocks W away from the boundaries Z1 and Z2 . De ne X 0 := Z1 W n W s W n Z2 and X 00 := Z1 W n W s W n+n! Z2 : Set ^i := i if i  jZ1j, otherwise ^i := i ?
. Using the Pumping Lemma twice { rst for the input pair X; X 0 and then for X 0 ; X 00 { we obtain: (; i) j=M;X ( ; j) () (; ^i) j=M;X 00 ( ; j ?
)

18

Maciej Liskiewicz , Rudiger Reischuk

The claim of the lemma follows because X 00 = X. In the inductive argument for the proof of Theorem 12 we have to guarantee a certain distance of the input head from the boundaries. For this purpose we de ne mk;n := k
(n + n!) : Lemma 8 (Accepting Tree Shift) Let k  2, r; s; t be integers with r; t  mk;n and s  1, and let Z1 ; Z2; W 2 f0; 1g be arbitrary strings. Then for an input X = Z 1 W r W s W t Z2 and for any con guration (; i) with the property that M in con guration (; i) scans a position within the in x W s and starting in (; i) uses never more space than S(n) it holds: M accepts in k ?2 alternations when it starts in (; i) if and only if M accepts with the same number of alternations when it starts in (; i ?
). r Z1 W W W

s

t

............ W W W ... W W W W ( α, i- ∆ ) T’

............ W W Z 2

( α, i) T

FIGURE 2. Accepting-Tree-Shift Lemma: M has an accepting computation T of k ? 2 alternations that starts in con guration (; i) if and only if it has an accepting computation T of the same number of alternations that starts in the same memory state  but with the input head moved
positions to the left. 0

5 A Survey of Lower Space Bound Proofs 5.1 Languages for Separating the Levels of the Alternation Hierarchy For a subset of the natural numbers A let LA be the language over the single letter alphabet f1g de ned by 1n 2 LA i n 2 A. De nition 7 De ne L2 := f1g+ , and for k  3 Lk := (Lk?1 f0g)+ . Let F be an in nite subset of the natural numbers with the properties:

1. Computing with Sublogarithmic Space

19

 n2F =) n + n! 2= F and  LF 2 2 Space(llog ) and LF 2 2Space(llog ). Then we de ne L2 := LF and L2 := f1g+ \ LF ; Lk := fw10w20 : : :0wp 0 j wi 2 Lk?1 and 9 i 2 [1:::p] wi 2 Lk?1g ; Lk := fw10w20 : : :0wp 0 j wi 2 Lk?1 and 8 i 2 [1:::p] wi 2 Lk?1g : Note that L2 and L2 are just complementary. For larger k the corresponding languages are \almost" complementary, that means if restricting to strings with a syntactically correct division into subwords by the 0-blocks (more formally Lk = Lk \ Lk ). An example for a set F is the following: F := fn > 2 j 8 ` 2 [3 : : : n ? 1] F(`) < F(n)g ; where F(n) denotes the smallest positive integer that does not divide n. It is easy to show that F is in nite. The property, n 2 F implies n + n! 2= F , holds since n + n! 2= F for any integer n > 2. Lemma 9 For the speci c F de ned above with the help of the function F it holds:

LF 2 2 Space(llog ) and LF 2 2 Space(llog ) : Proof. We describe llog{space-bounded 2 TMs M and 2TMs M that recognize the language LF , resp. the complement of LF . On input 1n, the machine M veri es the condition 8 ` 2 [3 : : : n ? 1] F(`) < F(n) as follows: { deterministically it computes F(n) and writes down the binary representation of F(n) on the tape; { universally it guesses an integer ` 2 [3 : : :n ? 1]: it moves its input head to the right and stops ` positions from the right end of the string 1n; { existentially it guesses k 2 [1 : : :F(n) ? 1] and then moving the input head to the right checks deterministically whether k divides `. M accepts if k does not divide `. The complementary machine M writes down on the work tape F(n) in binary and tests whether 9 ` 2 [3 : : : n ? 1] 8 k 2 [1 : : : F(n) ? 1] k divides `. Similarly as in M the input head position represents the integer `. The integer k is stored in binary on the work tape. It is obvious that M recognizes LF and that M recognizes LF in space O(llog).

20

Maciej Liskiewicz , Rudiger Reischuk

Thus, languages LF as described in De nition 7 exist. For the base case of the following inductive separation we also need the property that LF 2= 2Space(o(log )) and symmetrically that LF 2= 2 Space(o(log )). This has been shown for the example above explicitly in [LiRe93a]. Below we will give a general argument showing that this property simply follows from the condition n 2 F and n + n! 2= F .

5.2 ATMs with a Constant Number of Alternations

Let us start with the easily obtainable upper bounds. Lemma 10 For any k  2: Lk 2 k Space(llog ) ; Lk 2 k Space(llog ) : The proof of these properties is straightforward using the fact that LF 2 2Space(llog ) and LF 2 2 Space(llog ). The separation now follows from the following Theorem 21 For any k  2: Lk 2= k Space(o(log )) ; Lk 2= k Space(o(log )) : We will de ne speci c inputs that belong to Lk and Lk and show that any sublogarithmic space-bounded machine cannot work correctly on both inputs. Let L = LF be xed. Recall that in nitely many n 2 IN exist with n 2 F , 1n 2 L and 1n+n! 2= L. De nition 8 For n 2 F de ne words n := 1n+n! and W n := 1n ; and for k  3 W2 h n im 2n h im n Wk := Wk?1 0 Wk?1 0 Wnk?1 0 ; h im h im Wnk := Wnk?1 0 Wnk?1 0 Wnk?1 0 ; k;n

k;n

k;n

k;n

where the mk;n have been de ned in the Accepting-Tree-Shift Lemma. From the de nition follows easily Lemma 11 For k  2 and every n 2 F Wnk 2 Lk and Wnk 2= Lk ; Wnk 2 Lk and Wnk 2= Lk :

1. Computing with Sublogarithmic Space

21

Let k  2 and S 2 SUBLOG be a space bound. We will prove Theorem 21 by showing that if a k TM M accepts Lk in space S then for suciently large n 2 F M accepts Wnk , too. Similarly, if a k TM M accepts Lk in space S then for large n 2 F it accepts Wnk and hence makes a mistake. Recall that NM;S denotes the constant de ned for M and S above. Proposition 1 Let S 2 o(log ) and M be an ATM. Then for any k  2, for all n  NM;S , for all strings U; V 2 f0; 1g, and for any con guration (; i) with  i  jU j or i > jU Wnk j and  SpaceM (; i; UWnk V )  S(n) and SpaceM (; ^i; UWnk V )  S(n) it holds: acckM (; i; U Wnk V ) =) acckM (; ^i; U Wnk V ) if  is existential, acckM (; ^i; U Wnk V ) =) acckM (; i; U Wnk V ) if  is universal. Proof. Remember that ^i was de ned as  if i  jU j, ^i = i i + (jWnk j ? jWnkj) if i > jU Wnk j. For k = 2 the implications above follow from the 1-Alternation Lemma. To establish the proposition for k > 2 we consider the rst time when the machine M makes an alternation and inductively use the corresponding properties for the strings Wnk?1 and Wnk?1. The argument concentrates only on the block in the middle of a Wnk string, which is a Wnk?1 word, and analogously for Wnk strings with a Wnk?1 word in the middle. The main technical diculty is the possibility that in an accepting computation the machine may just make its rst alternation in the middle block, and therefore may notice the dierence between the Wnk and Wnk strings. But the Con guration and Accepting-Tree-Shift Lemmata imply that there also exist accepting computations with the rst alternation outside this critical region. For details see [LiRe93b]. Next, we will show that the second requirement of the proposition above is always ful lled. Proposition 2 Let k  2 and M be an ATM of space complexity S with S 2 o(log ). Then there exists a bound S 0 2 o(log ) such that for all n 

NM;S 0

SpaceM (Wnk )  S 0 (n) and SpaceM (Wnk )  S 0 (n) :

Proof. The idea of the proof is as follows. If in Wnk and Wnk all

substrings generated in the recursive construction that are multiplies of n!, are cancelled, then the remaining word has a length pk (n), which is polynomial in n. Using the Small-Space-Bound Lemma, which shows that

22

Maciej Liskiewicz , Rudiger Reischuk

a sublogarithmic space-bounded machine M does not notice a dierence when an arbitrary block of the input is added n! times, it follows that M must obey a space bound S(pk (n)) on Wnk and Wnk . If S grows sublogarithmically in n so does S(pk (n)). For the technical details of this proof see the paper [LiRe93b]. Now we are ready to prove Theorem 21. Let us assume that M is a k TM accepting Lk in sublogarithmic space S. By Proposition 2 there exists a function S 0 2 o(log ) such that for any n  NM;S 0 SpaceM (Wnk )  S 0 (n) and SpaceM (Wnk )  S 0 (n) :

Let n with n 2 F be an integer larger than NM;S 0 (such an n exists since F is in nite). By Lemma 11 Wnk 2 Lk , hence M has to accept Wnk , which means that acckM (0 ; 0; Wnk) is true, where (0; 0) is the initial con guration of M. From Proposition 1 we conclude that acckM (0; 0; Wnk) holds, too, and hence M accepts Wnk , which by Lemma 11 does not belong to Lk { a contradiction. In the same way one shows that if M is a k TM that accepts Lk in space S then M accepts Wnk .

5.3 Unbounded Number of Alternations

In the previous section we have proved the lower space bounds for recognizing Lk and Lk on ATMs with a constant number of alternations. These results hold for all languages Lk and Lk de ned on the base of a subset of natural numbers F with the properties as in De nition 7. In this section we x the set F to the example given at the beginning of this section: F := fn > 2 j 8 ` 2 [3 : : : n ? 1] F(`) < F(n)g : De nition 9 Let A : IN ! IN be a function with A(n)  2 for all n, and de ne L (A) := fX j X = W0r with W 2 Lk ; k  A(jX j); and r 2 INg ; L (A) := fX j X = W0r with W 2 Lk ; k  A(jX j); and r 2 INg : The separating results for A-alternation-bounded space classes (Theorem 13) follow from the propositions below. Lemma 12 For any S 2 SUBLOG and all functions A  2 computable in space S it holds: L (A) 2 A Space(S) ; L (A) 2 A Space(S) :

Proposition 3 For any S 2 SUBLOG and for all functions A and B with B
S 2 o(log) and A(m)  B(m) for all m 2 IN with equality for in nitely

1. Computing with Sublogarithmic Space

23

many m it holds: L (A) 62 B Space(S) ; L (A) 62 B Space(S) :

5.4 Closure Properties

In this section we discuss closure properties of the classes k Space(S) and k Space(S) for sublogarithmic bounds S. First for any integer k  2 we de ne the languages Ak := Lk f0g Lk ; Bk := Lk f0g Lk ; and symmetrically Ak := Lk f0g Lk ; Bk := Lk f0g Lk : It is easy to see that Ak ; Bk 2 k Space(llog ) and Ak ; Bk 2 k Space(llog ) : (1) Proposition 4 For all k  2 it holds: Ak \ Bk 2 k+1 Space(llog ) n k+1Space(o(log )); Ak [ Bk 2 k+1 Space(llog ) n k+1Space(o(log )): Proof. It is well known that for any function S the classes k Space(S) are closed under union, and symmetrically the k Space(S) are closed under intersection. Hence, Ak \ Bk 2 k+1Space(llog ) and Ak [ Bk 2 k+1Space(llog ). To prove that Ak \ Bk 62 k+1Space(o(log )) and Ak [ Bk 62 k+1Space(o(log )) rst we use the following modi cation of Proposition 2: Proposition 20 Let k  2 and M be an ATM of space complexity S with S 2 o(log). Then there exists a bound S 00 2 o(log ) such that for all n  NM;S 00 and words W1 ; W2 2 fWnk ; Wnk g SpaceM (W1 0 W2)  S 00 (n) : Let us assume, to the contrary, that Ak \ Bk 2 k+1Space(S), for some S 2 o(log n). Let M be an S{space-bounded k+1TM for Ak \ Bk . Choose n 2 F suciently large. By Lemma 11 Wnk 2 Lk hence M has to accept X = Wnk 0 Wnk ; which means that there exists an existential computation path starting in the initial con guration (0; 0) and ending in a universal con guration ( ; j), with (0; 0) j=M;X ( ; j) and acckM ( ; j; X) : (2) (The trivial case that M accepts X without alternation could be handled similarly.) Now let Y1 := Wnk 0 Wnk and Y2 := Wnk 0 Wnk . By Proposition 20 there exists S 00 2 o(log n) such that SpaceM (X); SpaceM (Y1 ); SpaceM (Y2 )  S 00 (n) :

24

Maciej Liskiewicz , Rudiger Reischuk

Therefore, by applying Proposition 1 to the situation described in (2) we obtain (0; 0) j=M;Y1 ( ; j) and acckM ( ; j; Y1) if j  jWnk 0j and otherwise (0; 0) j=M;Y2 ( ; ^j ) and acckM ( ; ^j ; Y2) ; where ^j = j + jY2j ? jX j. Hence M also accepts input Y1 or Y2. This yields a contradiction since, by Lemma 11, Y1; Y2 62 Ak \ Bk . Similarly, one can show that if a k+1 TM accepts Ak [ Bk within space S 2 o(log n), then it has to reject X, but it also rejects input Y1 or Y2, which both belong to Ak [ Bk { a contradiction! This result can be applied to prove Theorem 14. (1) follows immediately from Lemma 10, Theorem 21 and the following equations: Lk = Lk \ Lk , and Lk = Lk \ Lk , where Lk is the regular language introduced in De nition 7. We know Ak ; Bk 2 k Space(llog ) and Ak ; Bk 2 k Space(llog ). On the other hand, from Proposition 4 Ak \ Bk 62 k+1Space(o(log )) and Ak [ Bk 62 k+1 Space(o(log )). This proves 2. and 3. Property 4. for k classes follows from the fact that for any k  2 Lk f0g Lk = Ak \ Bk does not belong to k Space(o(log )), but Lk 2 k Space(llog ). To see that k Space(S) is not closed under concatenation de ne the languages L1k := Lk [f"g ; where " denotes the empty string and L2k := fw10w20 : : :0wp 0 j p 2 IN; wi 2 Lk?1 and w1 2 Lk?1g : Obviously, both languages belong to k Space(llog ), but from Theorem 21 follows L1k L2k = Lk 62 k Space(o(log )) :

5.5 Lower Bounds for Context-Free Languages

First, we will brie y sketch the proof for the last claim in Theorem 6 that COUNT 62 ASpace(o(log )) : Assume, to the contrary, that COUNT is recognized by an S{space-bounded ATM A for some S 2 o(log ). For S 0 (n) := S(2n + 1), it obviously holds S 0 2 o(log ). Let n^ := NM;S 0 . Then, the Small-Space-Bound Lemma implies that for all k; `  0 SpaceA (1n^ 01n^ ) = SpaceA (1n^+kn^! 01n^+`n^ ! ): (3) For this xed n^ we de ne the following language L^ := f1n^+kn^! 01n^+`n^ ! j k; ` 2 IN and k 6= `g ; and construct an ATM A^ that recognizes L^ . A^ performs the following algorithm:

1. Computing with Sublogarithmic Space

25

Step 1. it checks deterministically if the input X has the form 1n^+kn^! 01n^+`n^! for some integers k and `; it rejects and stops if not. Step 2. Then it moves the head to the rst symbol of the input and starts to simulate the machine A. It is obvious that A^ accepts an input X = 1n^+kn^ ! 01n^+`n^ ! i A accepts ^ = L^ : It is easy to see that step 1 can be performed within X. Hence L(A) space O(log n^!), which is a constant because n^ was xed. Moreover from (3) follows that step 2 also requires only constant space. Hence, A^ recognizes L^ within constant space, which yields a contradiction to L^ being nonregular. Similarly, one can show that also the language COUNT is not in ASpace(o(log )). The structure of a bounded language L can equivalently be represented using a nite alphabet fa1; : : :; ar g. Then L is a subset of fa1g : : : far g. De nition 10 Let V (L) denote the set f(v1 ; : : :; vr ) 2 INr j av11 : : :avr 2 Lg : Sets of the form r

f + n1 1 + : : : + nk k j n1; : : :; nk 2 INg with ; 1; : : :; k 2 INr are called linear sets. A nite union of linear sets is a semilinear set. A language L is semilinear if L  fa1g : : : far g and V (L) is a semilinear set. Theorem 7 can then be proved with the help of Theorem 16 and the following Proposition 5 Let L  fa1g : : : far g be a semilinear language and assume that L; L 2 ASpace(S) for some S 2 o(log). Then L is regular. Combining Theorem 7 with the other upper and lower bounds on nonregular context-free languages the situation concerning space complexity looks as follows. The best known upper bound is DSpace(log2 ) and the best lower bound NSpace( (llog )), that means llog is the minimal amount of nondeterministic space necessary and for some language this is also suf cient. Restricting to the subclass of deterministic context-free languages, however, the lower bound increases to AAlterSpace(CON ; (log)). Thus, even ATMs with a constant number of alternations require at least logarithmic space to accept these languages.

6 Conclusions and Open Problems Right now it seems that most phenomena about the sublogarithmic space world have been understood. Still, there are some open questions. It would be nice to exactly locate the classes ASpace(S) and AAlterSpace(CON ; S)

26

Maciej Liskiewicz , Rudiger Reischuk

for S 2 SUBLOG . Are they contained in SC? Is it true that they do not belong to NC1 and L = SC1? What is the relevance of the alternating sublogarithmic space hierarchy? Let us denote it by ASL := AAlterSpace(CON ; llog) : Several other alternating hierarchies have been de ned in the past. The alternating logarithmic time hierarchy AC0 = AAlterTime(CON ; O(log)) is also known to consist of an in nite number of distinct levels. It is contained in NC1 and hence in SC1 . At the moment ASL seems to be the most powerful sequence of alternating complexity classes, for which one can prove a strict inclusion without using relativations or unproven assumptions. However, AC0 and ASL are not comparable. The languages COUNT and PARITY are somehow extreme examples showing that neither class is contained in the other. What is the relation between the two lowest levels of ASL? Is the class 1Space(llog ) dierent from DSpace(llog ) and from 1 Space(llog )? The inability to record input head positions seems to be crucial if one wants to separate these classes. For a stronger notion of machine simulation that exploits this fact Kannan and Szepietowski have shown that such a kind of simulation of a nondeterministic TM is not possible within the same sublogarithmic space bound for a deterministic or co-nondeterministic machine [Ka83, Sz89]. Furthermore, characterize the alternating sublogarithmic space hierarchy for bounded languages completely. For the class of unbounded languages nd out the exact relationship between co-k Space(S) and k Space(S) for sublogarithmic space bounds S. Finally, concerning small space probabilistic classes is it true that { as for probabilistic polynomial time { machines with bounded error can be simulated nonuniformly in deterministic space? It is not obvious how to achieve exponentially small error probability in this case. Furthermore, using a simple simulation of space-bounded NTMs by one-sided-error probabilistic TMs (see e.g. [Gil77] or the survey paper [Ma95]) one can easily show that AM2 Space(log ) = AM1 Space(log ) ; that means the AM2 -class is quite weak in case of space bounds { contrary to time bounded classes. Is it also true that AM2 Space(SUBLOG ) = AM1 Space(SUBLOG ) ? Acknowledgments: Research of the rst author was supported by DFG

Grant Re 672/2 and KBN Grant 2 P301 034 07. The work was done while

1. Computing with Sublogarithmic Space

27

this author was visiting the Institut fur Theoretische Informatik, Med. Universitat zu Lubeck, Germany and International Computer Science Institute, Berkeley, CA.

References [Al79] H. Alt, Lower bounds on space complexity for context-free recognition, Acta Inform. 12, 1979, 33-61. [AGM92] H. Alt, V. Geert, and K. Mehlhorn, A lower bound for the nondeterministic space complexity of context-free recognition, Inform. Process. Lett. 42, 1992, 25-27. [AlMe76] H. Alt, and K. Mehlhorn, Lower bounds for the space complexity of context free recognition, Proc. 3rd ICALP, 1976, 339-354. [Ba85] L. Babai, Trading group theory for randomness, Proc. 17th STOC, 1985, 421-429. [Br93] B. von Braunmuhl, Alternation for two-way machines with sublogarithmic space, Proc. 10th STACS, 1993, 5-15. [BGR93] B. von Braunmuhl, R. Gengler, and R. Rettinger The alternation hierarchy for machines with sublogarithmic space is in nite, Research Report, Universitat Bonn, January, 1993. [CIRB87] J. Chang, O. Ibarra, B. Ravikumar, and L. Berman, Some observations concerning alternating Turing machines using small space, Inform. Proc. Letters 25, 1987, 1-9. [CKS81] A. Chandra, D. Kozen, L. Stockmeyer, Alternation, J. ACM 28, 1981, 114-133. [Co89] A. Condon, Computational model of games, MIT Press, 1989. [Co93] A. Condon, The complexity of space bounded interactive proof systems, in Complexity Theory: Current Research, S. Homer, U. Schoning, K. AmbosSpies (Ed.), Cambridge Univ. Press, 1993, 147-190. [DwSt92] S. Dwork, L. Stockmeyer, Finite state veri ers I: the power of interaction, J. ACM, 39, 1992, 800-828. [FrLa75] A. Freedman, R. Ladner, Space bounds for processing contentless inputs, J. Comput. System Sci. 11, 1975, 118-128. [Fr81] R. Freivalds, Probabilistic 2-way machines, Proc. 10th MFCS, 1981, 33-45. [FrKa94] R. Freivalds, M. Karpinski, Lower space bounds for randomized computation, Proc. 21st ICALP, 1994, 580-592. [Ge91] V. Geert, Nondeterministic computations in sublogarithmic space and space constructability, SIAM J. Comput. 20, 1991, 484-498. [Ge93a] V. Geert, Sublogarithmic 2 -space is not closed under complement and other separation results, Theoretical Informatics and Applications 27, 1993, 349-366.

28

Maciej Liskiewicz , Rudiger Reischuk

[Ge93b] V. Geert, Tally version of the Savitch and Immerman-Szelepcsenyi theorems for sublogarithmic space, SIAM J. Comput. 22, 1993, 102-113. [Ge93c] V. Geert, A hierarchy that does not collapse: alternations in low level space, manuscript. [Gil77] J. Gill, Computational complexity of probabilistic Turing machines, SIAM J. Comput. 7, 1977, 675-695. [Gin72] S. Ginsburg, The mathematical theory of context-free languages, McGraw-Hill, 1972. [GMR89] S. Goldwasser, S. Micali, C. Racko, The knowledge complexity of interactive proof systems, SIAM J. Comp. 18, 1989, 186-208. [GoSi86] S. Goldwasser, M. Sipser, Private coins versus public coins in interactive prove systems, Proc. 18th STOC, 1986, 59-68. [HaBe76] J. Hartmanis, L. Berman, On tape bounds for single-letter alphabet processing, Theor. Comput. Sci. 3, 1976, 213-224. [HoUl69] J. Hopcroft, J. Ullman, Some results on tape-bounded Turing machines, J. ACM 16, 1969, 168-177. [Im88] N. Immerman, Nondeterministic space is closed under complementation, SIAM J. Comput. 17, 1988, 935-938. [Iw93] K. Iwama, ASpace(o(log log n)) is regular, SIAM J. Comput. 22, 1993, 136-146. [Ju84] H. Jung, On probabilistic tape complexity and fast circuits for matrix inversion problems, Proc. 11th ICALP, 1984, 281-291. [Ka83] R. Kannan, Alternation and the power of nondeterminism, Proc. 15th STOC, 1983, 344-346. [LiRe93a] M. Liskiewicz, and R. Reischuk, Separating the lower levels of the sublogarithmic space hierarchy, Proc. 10th STACS, 1993, 16-27. [LiRe93b] M. Liskiewicz, and R. Reischuk, The sublogarithmic space world, Technical Report 048-93 ICSI Berkeley, to appear in SIAM J. Comput. [LiRe95] M. Liskiewicz, and R. Reischuk, Space bounds for interactive proof systems with public coins and bounded number of rounds, Technical Report, Med. Universitat zu Lubeck, 1995. [LSH65] P. Lewis, R. Stearns, J Hartmanis, Memory bounds for the recognition of context free and context sensitive languages, Proc. IEEE Conf. Switching Circuit Theory and Logical Design, 1965,191-202. [Ma94] I. Macarie, Space-ecient deterministic simulations of probabilistic automata, Proc. 11th STACS, 1994, 109-122. [Ma95] I. Macarie, Space-bounded probabilistic computation: old and new stories, SIGACT-News, vol. 26(3), 1995, 2-12. [MoSu82] B. Monien, H. Sudborough, On eliminating nondeterminism from Turing machines which use less than logarithm worktape space, Theor. Comput. Sci. 21, 1982, 237-253. [Pa85] C. Papadimitriou, Games against nature, J. Comput. System Sci, 31, 1985, 288-301.

1. Computing with Sublogarithmic Space

29

[Si80] M. Sipser, Halting space-bounded computations, Theor. Comput. Sci. 10, 1980, 335-338. [SHL65] R. Stearns, J. Hartmanis, R. Lewis, Hierarchies of memory limited computations, Proc. IEEE Conf. Switching Circuit Theory and Logical Design, 1965,179-190. [St67] R. E. Stearns, A regularity test for pushdown-machines, Information and Control 11, 1967, 323-340. [Su80] I. Sudborough, Ecient algorithms for path system problems and applications to alternating and time-space complexity classes, Proc. 21st FOCS, 1980, 62-73. [Sz88] R. Szelepcsenyi, The method of forced enumeration for nondeterministic automata, Acta Informatica 26, 1988, 279-284. [Sz89] A. Szepietowski, Some remarks on the alternating hierarchy and closure under complement for sublogarithmic space, Inform. Process. Lett. 33, 1989, 73-78. [Sz90] A. Szepietowski, If deterministic and nondeterministic space complexities are equal for log log n then they are also equal for log n, Theor. Comput. Sci. 74, 1990, 73-78. [Sz94] A. Szepietowski, Turing machines with sublogarithmic space, Springer Lec. Notes in Computer Science 843, 1994. [To81] M. Tompa, An extension of Savitch's theorem to small space bounds, Inform. Process. Lett. 12, 1981, 106-108. [Wa93] K. Wagner, Editorial note: The alternation hierarchy for sublogarithmic space: an exciting race to STACS'93, Proc. 10th STACS, 1993, 2-4.

This is page 30 Printer: Opaque this

Index AC, 9 alternation, 7 AMk Space, 12 approximable, 4 Arthur-Merlin-game, 11 ASpace, 3 ATM, 3

NSpace, 2 NTM, 2

BIN, 6

k Space, 7 pumping, 15

BPSpace, 11 CENTER, 12

closure, 23 complement, 2 intersection, 9 union, 9 computable, 4 CON , 4 con guration, 14 COUNT, 2, 6 DSpace, 1 DTM, 2 interactive proof system, 11 language bounded, 5 context-free, 2, 24 regular, 2 linear set, 25 llog, 2 MAk Space, 12 memory state, 14 NC, 26 nonregular strictly, 6

on-line machine, 3 P, 3

PALINDROME, 11 PATTERN, 13

SC, 3 set semilinear, 25 space hierarchy, 8 space-bounded, 5 space-constructible, 4 k Space, 7 state existential, 14 universal, 14 SUBLOG , 4 Turing machine alternating, 3 deterministic, 2 nondeterministic, 2 probabilistic, 11 stochastic, 11