# Time _ Tape Complexity of Turing Machines by malj

VIEWS: 9 PAGES: 26

• pg 1
```									Time & Tape Complexity of
Turing Machines
Space Complexity
• Consider the offline Turing Machine M. M has
a read only input tape with n markers and k
infinite storage tapes. If for every input word
of length n, M scans at most S(n) cells on any
storage tape, then M is said to be an S(n)
space bounded Turing machine, or of space
complexity S(n). The language recognised by
M is also said to be of space complexity S(n).
Time Complexity
• Consider the Multi tape Turing Machine M
which has k two way infinite tapes, one of
which contains the input. If for every input
word of length n, M makes at most T(n) moves
before halting, then M is said to be a T(n) time
bounded Turing machine, or of time
complexity T(n). The language recognized by
M is said to be of time complexity T(n).
space complexity
• Every TM uses at least one cell on all inputs, so if
S(n) is a space complexity measure, we may
assume S(n) >= 1 for all n. We make the useful
assumption that when we talk of space
complexity S(n), we really mean max (1, ⌈S(n)⌉).
• Similarly, it is reasonable to assume that any time
complexity function T(n) is at least n+1, for this is
the time needed just to read the input and verify
that the end has been reached by reading the
first blank. We thus make the convention that
time complexity T(n) means max (n+1,⌈T(n)⌉).
Nondeterministic Time and Space
Complexity
• The concepts of time and space complexity
apply equally well to nondeterministic
machines. A nondeterministic TM is of time
complexity T(n) if no sequence of choices of
moves causes the machine to make more than
T(n) moves. It is of space complexity S(n) if no
sequence of choices enables it to scan more
than S(n) cells on any storage tape.
Complexity Classes
• The family of languages of space complexity
S(n) is denoted by DSPACE(S(n)); the
languages    of     nondeterministic     space
complexity S(n) are collectively called
NSPACE(S(n)). The family of languages of time
complexity T(n) is denoted DTIME(T(n)) and
that of nondeterministic time complexity T(n)
is denoted NTIME(T(n)). All these families of
languages are called complexity classes.
• Theorem : If L is accepted by an S(n) space-
bounded Turing machine with k storage tapes,
then for any c > 0, L is accepted by a cS(n)
space bounded TM.
• Theorem : If a language L is accepted by an
S(n) space bounded TM with k storage tapes,
it is accepted by an S(n) space bounded TM
with a single storage tape.
• A function S(n) is said to be space
constructible, if there is some Turing machine
M that is S(n) space bounded, and for each n,
there is some input of length n on which M
actually uses S(n) tape cells. The set of space
constructible functions includes log n, nk , 2n
and n!. If S1(n) and S2(n) are space
constructible, then so are S1(n) S2(n), 2 S1(n).
• Note that M above need not use S(n) space on
all inputs of length n, just on some one input
of that length. If for all n, M in fact uses
exactly S(n) cells on any input of length n, then
we say S(n) is fully space constructible.
• If S2(n) is a space constructible function,
S1(n)
inf ------   =0
n ∞ S2(n)

and S1(n) and S2(n) are each at least log2(n), then
there is a language DSPACE(S2(n)) not in
DSPACE(S1(n)).
• If T2(n) is a fully time constructible function
and
T1(n) log T1(n)
inf ------------------ = 0
n ∞       T2(n)

then there is a language in DTIME(T2(n) ) but not
DTIME(T1(n) ).
• Savitch’s Theorem :
If L is in NSPACE(S(n)), then L is in
DSPACE(S2(n)) provided S(n) is fully space
constructible and S(n) ≥ log2(n)
⋃ i≥1 DTIME(ni) = ℘

⋃ i≥1 NTIME(ni) = N℘

⋃ i≥1 DSPACE(ni) = PSPACE

⋃ i≥1 NSPACE(ni) = NSPACE
• DSPACE (log n) ⋤ DSPACE(log2n) ⋤ DSPACE
(log3n) ⋤…
and
• NSPACE (log n) ⋤ NSPACE(log2n) ⋤ NSPACE
(log3n) ⋤…
• Clearly, DSPACE (logkn) ⋤ NSPACE (logkn) and
thus by Savitch’s theorem,
• ⋃ k≥1 NSPACE(logkn) = ⋃ k≥1 DSPACE(logkn)
• Although one can show that
℘ ≠ ⋃k≥=1DSPACE(logkn)
containment of either class in the other is
unknown.
• DSPACE(log n) ⊑ ℘ ⊑ N℘ ⊑ PSPACE, and at
least one of the containments is proper,
since DSPACE(log n) ⋤ PSPACE by the space
hierarchy theorem.
• We say that L’ is polynomial time reducible to L
if there is a polynomial time bounded TM that
for each input x produces an output y that is
in L if and only if x is in L’
• Let L’ be polynomial time reducible to L. Then
• L’ is in N℘ if L is in N℘
• L’ is in ℘ if L is in ℘.
• Let C be a class of languages. We say language
L is complete for C with respect to polynomial
time reductions if L is in C, and every language
in C is polynomial time reducible to L.
• We say L is hard for C with respect to
polynomial time reductions if every language
in C is polynomial time reducible to L, but not
necessarily in C.
• Theorem : the satisfiability problem is NP
complete.
The problem of determining whether a Boolean expression is
satisfiable is NP complete

• Proof : The satisfiability problem is in NP. Thus we
need to show that every language L in NP is
polynomially transformable to the satisfiability
problem. Let M be a nondeterministic Turing
machine of polynomial time complexity that accepts
L, and let w be an input to M. From M and w we can
construct a Boolean expression w0 such that w0 is
satisfiable if and only if M accepts w. The crux of the
proof is in showing that for each M there is a
polynomial time bounded algorithm to construct the
Boolean experssion w0 from w. The polynomial depends
on machine M.
• Every language in N℘ is accepted by a
nondeterministic single tape Turing machine
of polynomial time complexity. Thus we may
assume M has a single tape.
• Suppose M has states q1,q2,…,qs and tape
symbols X1,X2,…,Xm. Let p(n) be the time
complexity of M. We shall construct a Boolean
expression w0 that “simulates” a sequence of
IDs entered by M.
• C<i,j,t> is 1 if and only if the ith cell on M’s
input tape contains the tape symbol Xj at time
t. Here 1 ≤i ≤ p(n), 1 ≤j ≤m, and 0 ≤t ≤
p(n).
• S<k,t> is 1 if and only if M is in state qk at
time t. Here 1 ≤k ≤ s and 0 ≤t ≤ p(n)
• H<i,t> is true if and only if at time t the tape
head is scanning tape cell i. Here 1 ≤i ≤ p(n)
and 0 ≤t ≤ p(n).
• U(x1 , …, xr ) = (x1 + …+ xr ) (Π (¬xi +¬xj ))
i,j, i ≠ j
• The tape head is scanning exactly one cell in each ID
• Each ID has exactly one tape symbol in each tape cell
• Each ID has exactly one state
• At most one tape cell, the cell scanned by the tape
head, is modified from one ID to the next
• The change in state, head location and tape cell
contents between successive ID’s is allowed by the
move function of M,
• The first ID is an initial ID, and
• The state in the last ID is the final state.

```
To top