Document not found! Please try again

Separating the eraser Turing machine classes I+ ... - Semantic Scholar

7 downloads 3514 Views 589KB Size Report
Theoretical Computer Science 86 (1991) 267-275. Elsevier. 267. Separating the eraser Turing machine classes I+, NIL,, co-N!+_ and P,. Matthias Krause and ...
Theoretical Elsevier

Computer

Science

267

86 (1991) 267-275

Separating the eraser Turing machine classes I+, NIL,, co-N!+_ and P, Matthias

Krause

and Christoph

Sektion Mathematik, Humbold?

Stephan

Uniuersirlit

Meinel

Berlin, DDR-1086

Berlin, PF, Germany

Waack

Karl- Weierstrass-lnstiiut fiir Mathematik, Akademie der Wissenschaften der DDR, DDR-1086 Berlin, PF 1304, Germany Communicated by M.S. Paterson Received February 1988 Revised March 1989

Abstract Krause, M., C. Meinel and S. Waack, Computer Science 86 (1991) 267-275.

Separating

the eraser Turing

machine

classes,

Theoretical

By means of exponential lower and polynomial upper bounds for read-once-only n-branching programs we separate the logarithmic space-bounded complexity classes L,, NL,, co-NL, and P, for eraser Turing machines.

Introduction One of the most important problems in complexity theory is that of separating complexity classes such as L, NL, or P (or to prove their coincidence). Recently the following approach turned out to be quite successful. One describes (the nonuniform counterparts of) the complexity classes under consideration by means of Boolean circuits or branching programs [ 13,3, lo] and proves exponential lower bounds for Boolean circuits or branching programs with certain resource constraints. In the case of Boolean circuits for example such lower bounds were obtained for monotone circuits [12,2] or for bounded depth circuits [16,5]. In the case of branching programs, up to now exponential lower bounds have been proved only for read-once-only branching programs [ 1,9,8]. In the following we investigate read-once-only a-branching programs which generalize the concept of read-once-only branching programs. Briefly speaking, 0304-3975/91/$03.50

0

1991-Elsevier

Science

Publishers

B.V

268

M. Krause et

a-branching

programs

are branching

with devices for evaluating functions.

If Pn.sP

o-branching

denotes

programs

some of whose nodes are equipped

w E 0 from a set fl G El2 of 2-argument

the class of languages

acceptable

Boolean

by polynomial

size

then we have [ll]

L/poly -E--

P-BP

programs

functions

Al.

NLlpoly

-k-

PlPOlY =

~{V,A,.RP

where Llpoly, NL/poly, and Plpoly denote the nonuniform counterparts of the logarithmic space-bounded complexity classes L, NL, and I? Hence, lower bounds for branching programs, disjunctive {v}-branching programs, or conjunctive {A}branching programs would essentially contribute to a separation of these classes. We start with a separation of the corresponding read-once-only classes. We prove (Theorem

3.1) that

since the read-onceinteresting correspond to the logarithmic only classes gBpl, Piv~-~pI,P~n)-B~l and Ptv,n)-~~~ space-bounded eraser Turing machine classes L,, NL,, co-NL, and P, = P (Theorem However,

1.3). Hence

these separation

Theorems

results

are especially

1.3 and 3.1 yield

With L, 5 NL,, L, s co-NL, and NL, 5 P,, co-NL, 5 P, we have taken further steps in separating larger and larger complexity classes by means of exponential lower bounds. On the other hand we obtain NL, 5 NL and co-NL, 5 co-NL = NL as a corollary of NL, # co-NL, and of the Immerman/Szelepcsenyi result, NL= co-NL [6, 141. This shows that the eraser concept causes proper restrictions of the computational power not only in the deterministic case but also in the nondeter-

Eraser Turing machine classes

ministic

cases. Similarly

we obtain

9(“I.RPI 5 q”)-RP which

proves

branching

The paper R-branching read-once-only ministic,

that

programs

and

269

and

Pfn)_BP1 5 ~~~~~BP= p,V~-~~

read-once-only

disjunctive

are less powerful

than those not assumed

is organized programs branching alternating

as follows.

In Section

and relate ordinary, programs eraser

machines,

read-once-only

conjunctive, nondeterministic,

respectively

conjunctive

to be read-once-only.

1 we introduce

disjunctive,

to deterministic,

Turing

and

read-once-only and alternating co-nondeter-

(Theorem

1.3). In

Section 2 we prove an exponential lower bound (Lemma 2.1) and a polynomial upper bound (Lemma 2.3) for the problem of deciding whether a given Boolean matrix is a permutation matrix. Finally, in Section 3 we use these bounds for separating complexity classes defined by the above-mentioned eraser Turing machines (Theorems 3.1 and 3.3).

1. Eraser Turing machines complexity classes and their branching program descriptions Ajtai et al. [l] introduced the eraser Turing machine model and proved that the class of languages accepted by (nonuniform) logarithmic space-bounded eraser Turing machines and the class of languages accepted by polynomial size read-onceonly branching programs coincide. In the following we generalize this relation. Our investigations of logarithmic space-bounded deterministic, nondeterministic, conondeterministic, and alternating eraser Turing machines are also based on descriptions by certain types of branching programs. Following [ll] we can relate these machines to polynomial size deterministic, disjunctive, conjunctive, and alternating read-once-only branching programs, respectively. Unifying this approach we consider polynomial size read-once-only o-branching programs, 0 G I&. In order to define read-once-only o-branching programs, recall the definition of a branching program. A branching program is a directed acyclic graph where each node has outdegree

2 or 0. Nodes with outdegree

0 are called sinks and are labelled

by Boolean constants. The remaining nodes are labelled by Boolean variables taken fromasetX={x,,..., x,}. There is a distinguished node, called the source, which has indegree 0. A branching program computes an n-argument Boolean function as follows: Starting with the source, the value of the variable labelling the current node is tested. If this is 0 (1) the next node tested is the left (right) successor to the current node. The path from the starting node to a sink traced in this way is called a computation path. The branching program P accepts A c (0, 1)” if for all w E (0, 1)” the computation path under w halts at a sink labelled xA( w), where xA denotes the characteristic function of A. An Ll-branching program P is a branching program some of whose nonsink nodes are equipped with devices for evaluating functions w, w E 0, from a set 0 E B2 of 2-argument Boolean functions. Formally, this can be described by labelling some

270

M. Krause et al.

nodes of P by Boolean

of the nonsink The Boolean

values

functions

w E 0 instead

to the sinks of P extend

assigned

with all nodes of P in the following

of Boolean

to Boolean

way: if the successor

nodes

values

variables. associated

u,, and v, of a node

u of P carry the Boolean values 6, and 6,) respectively, and if v is labelled by a Boolean variable xi we associate with v the value &, or 6, iff xi = 0 or xi = 1. If v is labelled

by a Boolean

function

is said to accept (reject) (0) under

w. An a-branching

alternating

branching

o then we associate

an input

P is called

6,). P

w(6,,

of P is associated

with 1

a disjunctive, a conjunctive,

or an

if 0 = { v}, R = {A}, or 0 = {v, A}, respectively.

The

program

program

with u the value

w E (0, l}” if the source

most important complexity measure of an a-branching program P is the number of its nonsink nodes, the size of l? By P’n_aP, R E B,, we denote the set of all languages acceptable by sequences of polynomial size o-branching programs. In order to relate Turing machine classes and R-branching program classes, 0 E lEb2, we have to consider the nonuniform counterparts L/pol_v, NL/poly, coNL/poly, and AL/poly of the class L, NL, co-NL, and AL consisting of all languages A E (0, l}* for which there exists a polynomial length-restricted advice (Y: N + (0, 1)” and a logarithmic space-bounded deterministic, nondeterministic, co-nondeterministic,

or alternating

Theorem

1.1 (Meinel

nondeterministic, of polynomial

Turing [ll]).

machine

Logarithmic

co-nondeterministic, size ordinary,

= PBP,

co- NL/poly

Theorem

1.1 along

= p{ ,, +Bp,

conjunctive,

corollary.

Corollary

1.2. Sequences branching

nonuniform

deterministic, and sequences

and alternating

branching

pro-

power. That is, WPO~Y

= Pc~)~RP,

ALlpo1.v

= p{v,

of polynomial programs

w # CX(~W()iff w E A.

Turing machines

*)-BP.

with the Immerman/Szelepcsenyi

following

size conjunctive

space-bounded

and alternating

disjunctive,

grams are of the same computational

Ll POlY

M such that M accepts

size disjunctive

result

[6, 141 yields

and seauences

are of the same computational

the

of polynomial

power. That is,

g{(v)-BP = p{(n}-BP. Now we introduce

the restricted

mode1 of eraser Turing

machines

which is the

subject of this paper. A deterministic, non-deterministic, co-nondeterministic, or alternating Turing machine is called an eraser Turing machine if each computation path in its computation tree contains for all i, is n, at most one configuration properly depending on the ith input bit. Indeed, these eraser Turing machines generalize the concept of eraser Turing machines introduced in [l] which erase an input bit after having read it. By L,, NL,, co-NL,, and AL, we denote the classes of languages acceptable by logarithmic space-bounded deterministic, nondeterministic, co-nondeterministic, and alternating eraser Turing machines, respectively.

Eraser Turing machine classes

271

The various types of nonuniform eraser Turing machines are related to read-onceonly O-branching programs, a G Bz. An R-branching program is said to be readonce-only

xi, 1 < i G n, is tested at most once on every computation

if every variable

path. By Pfl_BP, we denote the class of all languages sequences of polynomial size read-once-only a-branching Theorem 1.3. Logarithmic co-nondeterministic,

space-bounded

and alternating

nomial size ordinary, disjunctive, programs

conjunctive,

are of the same computational L,lPOlY

=

~BP,,

co-NL,lpoly

nonuniform

eraser

= P{~)-BP,,

Turing

A G {0, 1)” acceptable

deterministic, machines

nondeterministic,

and sequences

and alternating read-once-only

power.

by

programs.

of polybranching

That is,

NL,lpob

= ~{)(~I-BP,,

AL,lpol~

= p(v,ni-w,.

The proof can be obtained by similar arguments as have been used by [I] and [ 111. Interestingly, the Chandra/Kozen/Stockmeyer result [4] which relates alternating logarithmic space to deterministic polynomial time remains true also in the case of eraser Turing machines. Proposition machines

1.4. Logarithmic

space-bounded

are as powerful as nonunzform AL,/poly

nonunzform

polynomial

alternating

time-bounded

eraser

Turing

ones. That is,

= P/poly.

Proof. Due to Theorems

However, this inclusion of alternating branching

1.1 and 1.3 it suffices to prove

immediately follows from the computational equivalence programs and Boolean circuits, and from the fact that each

Boolean circuit can be simulated gram of equal size [ll]. q

by an alternating

read-once-only

branching

pro-

2. The lower and the upper bound In the following section we prove disjunctive read-once-only branching Boolean n x n matrix is a permutation conjunctive read-once-only branching task (Lemma 2.3).

an exp(a(n)) lower bound for the size of programs which decide whether a given matrix (Lemma 2.1). Additionally, we give programs of size O(n’) which perform this

272

M. Krause

Let F = { fn}be the sequence n x n matrices A with fn(A)

of Boolean

= 1 iff A is a permutation

contains

et al.

functions

matrix,

fndefined on the set of Boolean

i.e. A

exactly one 1 in every row

and in every column. Recall that there is a l-l correspondence n-permutations

between

n x n permutation

matrices

and

DE S,

a-A”

= (a,,)

with aij =

1

ifj=a(i),

0

otherwise.

Lemma 2.1. Every disjunctive read-once-only of size 2ncn’.

branching

program

which computes f, is

Proof. First let us observe that in a disjunctive read-once-only branching program every computation path p, which starts at the source v,, and leads to a nonsink node v can be combined with every computation path starting in u. That is, if p2 and p3 are computation paths starting in v then p1p2 as well as p1p3 are computation paths starting in uO. Now we let P be a disjunctive read-once-only branching program over x,,} which computes fn. Without loss of generality let n be even. We show {x 11,..*, Size(P)

2 2”/(2&).

Let p be an accepting path in P. Since P is read-once-only and since fn is critical (i.e. for all w ~fl*(l) and all w’ of Hamming distance 1 from w it holds fn(w’) = 0) there is exactly one permutation matrix A = A” realized by p. For each permutation mu S, we fix an accepting path pa which belongs to the input A”. To each UE Sn we assign a nonsink node v, via pW in the following way. If e = (0, v’) is the in-edge of p,, with label 1, then v, := u’. We denote that part of pU part of pu by pe’. Let V = {v, 1u E S,} which ends in v, by pc’ and the remaining and let VE V be an arbitrary node of V Then we investigate S,,, the set of all permutations

u with v, = v,

By renumbering we can assume without loss of generality that idE S, and xii is (‘I iff is-n. Let UE S,. According to our first observation the paths tested on pid p$‘pc’ and pi,“pli’ are accepting paths in addition to nd and pm. If xii is tested and if i G&I and j > in then p:‘p$’ (or p$‘p$?‘) is an positively on plf’ (or p?), accepting path where xii and xjj (or xii and xii) are tested positively. However, this is a contradiction, since the disjunctive branching program P accepts only permutation matrices. Hence, S, contains merely permutations g with cr(i) s in iff i S fn.

Eraser Turing machine classes

273

This implies #S,

ZG[(in)!]‘.

Now we are done since

max,,”

(due to Stirling’s Corollary

ifn is

~-!c-=

#S”

#VZ

#sV

formula)

(> *

and Size(P)

2.2. Every conjunctive

2 2”/(2&).

$I

[($n)!]’

> # V.

read-once-only

0 branching

program

which computes

of size 2O’“‘.

Proof. For every conjunctive read-once-only branching program computing 1 fn we obtain a disjunctive read-once-only branching program of equal size computing l(l fn) = fn if we replace the conjunctive A-nodes by disjunctive v-nodes, the 1-sinks q by O-sinks and the O-sinks by l-sinks. Hence, Lemma 2.1 implies the corollary. Lemma 2.3. fn can be computed program

Proof.

by means of a conjunctive

read-once-only

branching

of size 0( n’).

Let e, be the Boolean e,(w)=1

function

defined

by

iff /WI=1

for w E (0, 1)“. Using

e, we can write fn as

fn(X1l,...,Xln,...,Xnl,...,Xnn) = ,{,

G(xi,,

. . . T Xin)

Since e, can be computed O(n) in a straightforward of size O(n*) In analogy

A

i; ,=I

by means manner,

can be constructed with the Corollary

%(x,j,.

. .3

xnj).

of a read-once-only

a conjunctive

branching

read-once-only which computes fn. q

2.2, we obtain the following

program

branching

corollary

to Lemma 2.3.

Corollary 2.4. 1 fn can be computed by means of a disjunctive read-once-only program

of size program

branching

of size O(n’).

3. The separation result Due to the lower

and the upper

F = {fn} and 1 F = (1 fn} of deciding

we can

separate

the read-once-only

bound proved in Section 2 for the problems whether a given matrix is a permutation matrix, branching program classes .9)BPL, ~~V~_BPI,

M. Krause et al.

214

P)(*j-BP,and ~{v.nJ-BP1as well as the eraser Turing and P, from each other. Theorem 3.1. There are strong diflerences disjunctive,

conjunctive,

Proof. Trivially,

Lemmas

and alternating

classes L,, NL,,

in the computational

read-once-only

co-NL,,

power of ordinary,

branching

programs.

It holds

we have

2.1 and 2.3 show that

while their corollaries

These two noninclusions

show

immediately

Moreover, due to Theorem following corollary. Corollary

machine

3.2.

ing programs

yield all the other noninclusions.

1.1 and

Corollary

1.2, Theorem

0

3.1 implies

Polynomial size disjunctive as well as conjunctive read-once-only are less powerful

than those not assumed

to be read-once-only.

the

branchIt holds

Since nonuniform lower bounds are stronger than uniform ones, and since the upper bound of Lemma 2.3 can be described uniformly we can conclude, similar to Theorem 3.1, separation results for the uniform eraser Turing machine classes. Theorem 3.3. There are strong differences nondeterministic,

co-nondeterministic,

in the computational

and alternating

power of deterministic,

eraser Turing machines.

It holds

Eraser

Turing

machine

classes

21s

Acknowledgment We would like to thank very carefully. important

Mike Paterson

In particular

improvement

and Ingo Wegener

we are grateful

of the proof

to Ingo

of Lemma

who refereed

Wegener

this paper

for suggesting

an

2.1.

References t11 M. Ajtai, L. Babai, P. Hajnal, J. Komlos, P. Pudlak, V. Rodl, E. Szemeredi and G. Turan, Two lower bounds for branching programs, in: Proc. 18th ACM Symp. on Theory of Compufing (1986) 30-38. r21 A.E. Andreev, On a method of obtaining lower bounds for the complexity of individual monotone functions, Dokl. Akad. Nauk SSSR 282(S) (1985) 1033-1037. Bounded-width polynomial size branching programs recognize exactly those [31 D.A. Barrington, languages in NC’, in: Proe. 18th ACM Symp. on Theory of Computing (1986) 1-5. D.C. Kozen and L.J. Stockmeyer, Alternation, 1. ACM 28 (1981) 114-133. [41 A.K. Chandra, [51 J. Hastad, Improved lower bounds for small depth circuits, in: Proc. 18th ACM Symp. on Theory of Computing N. Immerman,

(1986)

6-20.

space is closed under complement, Techn. Report 552, Yale Univ., 1987. between non-uniform and uniform complexity t71 R.M. Karp and R.J. Lipton, Some connections classes, in: Proc. 12th ACM Symp. on Theory of Computing (1980) 302-309. lower bounds on the complexity of local and real-time branching programs, [81 M. Krause, Exponential EIK 24 (1988) 3. lower bounds for real-time branching programs, Inform. [91 K. Kriegel and S. Waack, Exponential

[61

Thbr.

Nondeterministic

Appl. 22(4)

(1988)

441-459.

reducibility and the complexity classes L(nonuniform) and NL(nonunit101 Ch. Meinel, p-projection form), in: Proc. 12th MFCS, Bratislava, Lecture Notes in Computer Science 233 (Springer, Berlin, 1986) 527-535; Extended version in EIK 23 (1987) 545-558. size R-branching programs, in: Proc. STAC ‘88, Bourdeaux, [Ill Ch. Meinel, The power of polynomial Lecture Notes in Computer Science 294 (Springer, Berlin, 1988) 81-90; Inform. and Comput., to appear. A lower bound for the monotone network complexity of the logical permanent, 1121 A.A. Razborov, Mat. Zametki

[I31 S. Skyum

37(6)

(1985).

and L.G. Valiant,

Symp. on Foundations

A complexity

of Computer

Science

theory (1981)

based

on Boolean

algebra,

in: Proc. 22nd IEEE

244-253.

automata, Bull. EATC’S 33 (1987) 96-99. [I41 R. Szelepcsenyi, The method of forcing for nondeterministic rt51 1. Wegener, The Complexity of Boolean Funcrions (Teubner, Stuttgart, 1987). the polynomial-time hierarchy by oracles, in: Proc. 26th IEEE Symp. on [I61 A.C. Yao, Separating Foundations of Computer Science (1985) l-10.