Notes on Complexity Theory Last updated: September, 2007

Lecture 5
Jonathan Katz

1 Lower Bounds via Crossing Sequence Arguments

We show two lower bounds that are proved using related ideas. The results are not neces-
sarily so interesting in their own right, but the proofs are interesting as rare examples in
complexity theory when we can prove a direct lower bound on the power of a (uniform)
complexity class!

1.1 One-Tape Turing Machines

We first show a language L requiring quadratic time to decide on a one-tape Turing machine.
Besides being interesting in its own right, it separates the power of one-tape and two-tape
machines (since L can be decided in linear time on a two-tape Turing machine).
For a finite string x over any alphabet, let x̄ be the reverse of x. Taking Σ = {0, 1, #},
define the language of palindromes as:
def
L = {xx̄ | x ∈ Σ∗ }.

Theorem 1 Deciding L requires time Ω(n2 ) on a one-tape Turing machine.

Proof Let M be a one-tape Turing machine deciding L. For each n which is a multiple
of four, consider the following subset of L:
def n n
Ln = {x # 2 x̄ | x ∈ {0, 1} 4 }.

For any x ∈ Ln and position i ∈ {1, . . . , n} on the tape of M , let Ci (x), the crossing
sequence on x at position i, denote the ordered sequence of states that M is in as the head
of M crosses over the line between the ith and (i + 1)th cells (in either direction). Define
 
def n 3n
C(x) = Ci (x) | ≤ i ≤ .
4 4

It is easy to verify that C(x) cannot be empty for any x ∈ Ln .

The main observation is that if x, y ∈ Ln and x 6= y, then C(x) ∩ C(y) = ∅. The reason
is as follows: say C(x) ∩ C(y) 6= ∅. Then there are some i, j with n4 ≤ i, j ≤ 3n 4 such
that Ci (x) = Cj (y). Let x′ be the prefix of x of length i, and let y ′ be the suffix of y of
length n − j. If we follow the computation of M on the input string x′ y ′ , we see that M
will accept. (This is not obvious, and convincing yourself of this requires some thought.)
However, x′ y ′ 6∈ L and so this contradicts the fact that M decides L.
Let tx denote the length of the shortest crossing sequence in C(x), and let tmax (n) =
maxx∈Ln {tx }. We show that tmax (n) = Ω(n). Since C(x) contains Ω(|x|) crossing sequences,

5-1
and each element in each crossing sequence corresponds to a move of M , this implies that
M runs in time Ω(n2 ).1
The number of crossing sequences of length ≤ t is:
t
X |QM |t+1 − 1
|QM |i = .
|QM | − 1
i=0

Since no crossing sequence can appear in C(x) and C(y) for distinct x, y ∈ Ln , but there
n
are 2 4 distinct strings in Ln , we must have

|QM |tmax (n)+1 − 1 n

≥ 24,
|QM | − 1

where QM is the set of states of M . Since |QM | is constant, this implies tmax = Ω(n).

1.2 Sublogarithmic Space

Next, we explore what can be done in sub-logarithmic space. We state the following two
results without proof.

Theorem 2 There exists a language L such that L ∈ space(log log n) but L 6∈ space(1).
That is, space(1) is a proper subset of space(log log n).

For proof, see [1, Lecture 4].

Theorem 3 space(1) is exactly the class of regular languages.

It is not hard to show that regular languages can be decided with zero workspace (simply
encode the states of the finite automaton as states of the Turing machine). It is also not
too difficult to show that any constant-space Turing machine can be simulated by a 0-space
Turing machine (simply include states for all possible strings that can be written on the
work-tape). The difficult part is to show that any language decided by a 0-space Turing
machine is regular; the difficulty is that the Turing machine may go back and forth across
its input tape, while a finite automaton is allowed only one “pass” over its input. However,
0-space Turing machines are equivalent to so-called two-way finite automata and the latter
are known to be equivalent to (regular) finite automata [4] (see [3, Section 2.6]).
What about classes below space(log log n)? We show that all classes below this level
collapse to space(1).

Theorem 4 space(o(log log n)) = space(1).

Proof Fix a machine M using space s(n) on inputs of length n, with s(n) = o(log log n).
If M accepts only a finite number of strings (or, in particular, if M accepts nothing) we
are done. Let a semi-configuration of M , during its computation on some input, consist
1
Note: we do not prove that M runs in time Ω(n2 ) for all x ∈ Ln , only that it runs in time Ω(n2 ) for at
least one x ∈ Ln .

5-2
of (1) the current state of M ; (2) the symbol being scanned by the input head; (3) the
contents of the work tape; and (4) the position of the work head on the work tape. (Note
that, in contrast to a usual configuration, we do not include the position of the input
head.) On input of length n, the number of possible semi-configurations of M is at most
def
N = |QM | · (|ΣM | + 1)s(n)+1 · s(n) = 2O(s(n)) .
For any x accepted by M of length |x| = n, and any i ∈ [n], define the crossing sequence
on x at position i, denoted C i (x), to be the ordered sequence of semi-configurations of M
whenever the input head is on the ith position of the input tape. The length of any such
sequence is at most N : if it is longer than that, then some semi-configuration repeats (with
the input head being at the same location) and so M would go into an infinite loop —
contradicting the fact that M accepts x. The total number of possible crossing sequences
is therefore at most
N
N N +1 − 1 2O(s(n)) 
X   O(s(n)) 
ℓ
N = N
= O(N ) = O 2O(s(n))
= O 22 = o(n),
N −1
ℓ=0

using the fact that s(n) = o(log log n).

Let n0 be such that for all n > n0 the number of possible crossing sequences on inputs
of length n is less than n/3; such an n0 must exist because the number of possible crossing
sequences in o(n). Let n1 ≥ n0 be such that s(n) < s(n1 ) for all n < n1 ; if such an n1 does
not exist then the function s is upper-bounded by a constant (and we are done). We show
that M never uses more than space s(n1 ) on strings of any length, and hence M is in fact
a constant-space machine.
Assume the contrary. Let x be a string of minimum length satisfying: (1) x is accepted
by M ; (2) |x| ≥ n1 ; and (3) the space used by M (x) is greater than s(n1 ). (Recall our
assumption that M accepts an infinite number of strings.) Let |x| = n. For any i ∈ [n], the
number of possible crossing sequences on x at position i is less than n/3, and so there must
exist at least three positions i, j, k ∈ [n] (with i < j < k) on the input tape such that

C i (x) = C j (x) = C k (x).

Write x as αaβaγaδ where the positions with symbol a correspond to positions i, j, k

(note that these positions must share the same input symbol since that is part of a semi-
configuration and the input tape is read-only). Let C i (x) = C j (x) = C1i , . . . , Cℓi for some ℓ,
and recall that all the semi-configurations in this sequence must be distinct (since otherwise
M goes into an infinite loop). Call a semi-configuration right-moving if M moves its input
head to the right on this semi-configuration, and left-moving otherwise. Now, look at the
def
execution of M on input x′ = αaγaδ. The executions of M (x) and M (x′ ) are identical
until they come to the first right-moving semi-configuration in the sequence C i (x); say this
is semi-configuration Cri 1 . The execution of M (x′ ) after this point is now identical to the
execution of M (x) beginning at semi-configuration Crj1 until M (x′ ) comes to the next left-
moving semi-configuration following Crj1 ; call it Crj2 . The execution of M (x′ ) after this point
is now identical to the execution of M (x) beginning at semi-configuration Cri 2 , etc. Things
continue in this way until M (x′ ) reaches semi-configuration Cℓi = Cℓj (since r1 < r2 < · · · this
eventually happens) and then the execution of M (x′ ) will be identical to the execution of

5-3
M (x) after this point. In particular, M (x′ ) accepts. A similar argument shows that M (x′′ )
def
accepts, where we define x′′ = αaβaδ.
Let sw denote the maximum number of work cells used by M on input the string w.
If sx work cells are being used by M (x) when its input head is within the substring αa or
the substring δ, then sx′ , sx′ ≥ sx . If sx work cells are being used by M (x) when its input
head is within the substring γa then sx′ ≥ sx ; similarly, if sx work cells are being used by
M (x) when its input head is within the substring βa then sx′′ ≥ sx . In any case, then, one
of the strings x′ , x′′ (call it x̃) is a shorter string than x which is accepted by M , and for
which M (x̃) uses space at least sx ≥ s(n1 ). By choice of n1 , we have |x̃| ≥ n1 . But this
contradicts our choice of x as the shortest string satisfying these properties.

Bibliographic Notes
Section 1.1 is based on [2, Lecture 1]. Section 1.2 is adapted from [1, Lecture 4] and [2,
Lecture 1].

References
[1] O. Goldreich. Lecture notes for Introduction to Complexity Theory, 1999. Available at
http://www.wisdom.weizmann.ac.il/˜oded/cc99.html.

[2] D. Kozen. Lecture notes for CS682: Theory of Computation, Spring 2004. Available at
http://www.cs.cornell.edu/Courses/cs682/2004sp/.

[3] J.E. Hopcroft and J.D. Ullman. Introduction to Automata Theory, Languages, and Com-
putation. Addison-Wesley Publishing Company, 1979.

[4] J.C. Shepherdson. The Reduction of Two-Way Automata to One-Way Automata. IBM
Res. and Dev. 3, pp. 198–200 (1959).

5-4