Loading in 5 sec....

Circuit and Communication ComplexityPowerPoint Presentation

Circuit and Communication Complexity

- 471 Views
- Updated On :

Circuit and Communication Complexity Given The communication game G f : Alice gets s.t. f ( x ) = 1 Bob gets s.t. f ( y ) = 0 Goal : Find i s.t. Karchmer – Wigderson Games has a boolean circuit C that computes it.

Related searches for Communication Complexity

Download Presentation
## PowerPoint Slideshow about 'Communication Complexity' - benjamin

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Circuit and Communication Complexity

The communication game Gf :

- Alice gets s.t. f(x)=1
- Bob gets s.t. f(y)=0
- Goal: Find i s.t.

Karchmer – Wigderson Games

has a boolean circuit C that computes it.

The deterministic communication complexity of a game G:

The minimal CC of a protocol for G.

CC of a protocol: the maximal number of bits

(over all inputs) exchanged when running the protocol

Boolean circuits using AND,OR,NOT gates with fan-in=2

Depth(C): The longest path from input to output in a boolean circuit C

Depth(f): The minimal depth of a circuit that computes f

- by induction on Depth(C)

then f(z) is zi or zi for some i

Base:Depth(C )=0

Alice and Bob can simply answer: i

(No need to exchange bits)

CC(Gf ) = Depth( f )

C : circuit with minimal depth that computes f

Lemma 1:

Proof:

CC(Gf ) = Depth(f)

Induction step: look at C’s top gate

f1, f2 : the functions computed by C1, C2

By inductive hypothesis:

f(x)=1

f1(x) = f2(x) = 1

f1(y) = 0or f2(y) = 0

f(y)=0

f1(x) = f2(x) = 1 f1(y) = 0or f2(y) = 0

f(x)=1

f(y)=0

Bob and Alice can apply a protocol for

Bob and Alice can apply a protocol for

CC(Gf ) = Depth(f)

Protocol for Gf:

- Bob sends a value in {1,2} indicating whether
- f1(y) = 0or f2(y) = 0

- If Bob sends 1, Alice and Bob know:

f1(y) = 0 , f1(x) = 1

- If Bob sends 2, Alice and Bob know:

f2(y) = 0 , f2(x) = 1

CC(Gf ) = Depth(f)

Either way, we get a protocol for Gf with one additional bit

f(x)=1

f1(x) = 1or f2(x) = 1

f1(y) = f2(y) = 0

f(y)=0

By the same idea, Alice sends a value in {1,2}

indicating whether f1(x) = 1or f2(x) = 1

For any two disjoint sets: GA,B is:

- Alice gets
- Bob gets
- Goal: Find i s.t.

f -1(1)={x | f(x)=1}

f -1(0)={y | f(y)=0}

Gfis the same as

CC(Gf ) = Depth(f)

We’ll define a more general communication game:

Claim: if CC(GA,B )=d then there’s a function

such that:

- f(x)=1 for every

- f(y)=0 for every

, such a function is f itself

For

Hence,

CC(Gf ) = Depth(f)

f separates A from B

We’ll prove the claim by induction on d =CC(GA,B )

So there’s i such that

for every and every ,

The functions f=zi or f= satisfy the claim requirements.

For both, Depth(f )=0.

CC(Gf ) = Depth(f)

We’ll prove the claim by induction on d =CC(GA,B )

Base:d=0

Bob and Alice don’t need to exchange bits

This bit partitions A into two disjoint sets

If Alice sends 0, the rest of the protocol

is a protocol for

If Alice sends 1, the rest of the protocol

is a protocol for

For and we have protocols P1, P2 s.t.

CC(Gf ) = Depth(f)

Induction step:

All x in A for which the first bit Alice sends is 0

We have a protocol P with CC(P)=d for GA,B

Assume Alice sends the first bit.

All x in A for which the first bit Alice sends is 1

- f0(x)=1 for every

- f1(x)=1 for every

- f0(y)= f1(y)=0 for every

We define

Then:

- for every , we have

- for every , we have

CC(Gf ) = Depth(f)

By the inductive hypothesis, we have f0 and f1 that satisfy:

f satisfies the requirements.

Similarly, if Bob sends the first bit, B is partitioned into

two disjoint sets

The rest of the protocol is either for or

(depending on the bit Bob sent)

- g0(y)=0 for every

- g1(y)=0 for every

- g0(x)= g1(x)=1 for every

CC(Gf ) = Depth(f)

By the inductive hypothesis, we have g0 and g1 that satisfy:

Then:

- for every , we have

- for every , we have

We have seen:

,

CC(Gf ) = Depth(f)

g satisfies the requirements.

=>CC(Gf ) = Depth( f )

- Alice gets a graphx on n vertices that contains
- a clique of size n/2.

- Bob gets a graph y on n vertices that doesn’t contain
- a clique of size n/2

- Goal: Find an edge in x that doesn’t exist in y
- (or vice versa)

By lemma 1:

the Communication Complexity of this game =

the circuit depth of the (n/2)-Clique function.

By proving lower bounds on the CC of such games,

It would be possible to find lower bounds for certain

functions’ circuit depth.

for every

,

implies

iff

For every i

A vector

corresponds to the set

iff

Monotone Complexity

Monotone functions:

This order (called Hamming partial order) can be thought of

as the containment order between sets:

be a monotone function.

- A minterm of f is

s.t. f(x) = 1

and for every x’< x , f(x’) = 0

- A maxterm of f is

s.t. f(y) = 0

and for every y’> y , f(y’) = 1

f(x)=

1 otherwise

Example:

(0,0,…,0,1), (0,1,0,…,0) are maxterms

(1,1,0,…,0), (1,0,…,0,1) are minterms

is monotone iff it can be computed by a monotone circuit

Monotone boolean circuit:

A circuit which uses only AND and OR gates

Monotone circuits can’t compute all functions: it’s impossible to simulate NOT by using AND and OR

Monotone circuits can compute all monotone functions.

For example, this can be done by taking the DNF of all 1’s in all minterms, or the CNF of all 0’s in all maxterms

For a monotone function

For a monotone function f,

- Mon-Size(f ): the minimal size of a monotone circuit for f

- Mon-Depth(f ): the minimal depth of a monotone circuit for f

Several lower bounds were proved for the monotone size

and the monotone depth of certain functions.

For the non-monotone case, there are no non-trivial

lower bounds.

There is no lower bound better than linear for the circuit size

of any explicit function, and no lower bound better than logarithmic for the circuit depth of any explicit function.

Given a monotone function

The communication game Mf :

- Alice gets s.t. f(x)=1
- Bob gets s.t. f(y)=0
- Goal: Find i s.t.

The goal is always achievable, otherwise, which means

Monotone Karchmer – Wigderson Games

That is:

Find i s.t. xi=1 and yi=0

Lemma 2: for every monotone function

CC(Mf) = Mon-Depth(f )

Proof: similar to the non-monotone case with the following

modifications:

- When constructing a protocol from a given circuit:

Base case: if Depth(f ) = 0, f(z) = zi.

So xi=1, yi=0, and Alice and Bob always answer: i

Induction step: When dividing the circuit into two

sub-circuits, each is monotone and has a suitable protocol.

Bob or Alice (depending on the top gate) send the first bit,

and decide which of the two monotone games to solve.

Base case: if there is no communication, Alice and Bob

both know an i for which xi>yi, so the circuit is f(z)=zi

Induction step: Each communication bit splits the game

Into two sub-games of smaller CC.

Since the original game is monotone, so are the two sub-games.

The circuits for these games are monotone.

Since we only add an AND or an OR gate, the entire circuit

Remains monotone.

A lower bound of was proved for the monotone depth of the (n/2)-Clique function

Example:

- Alice gets a graph x on n vertices that contains
- a clique of size n/2

- Bob gets a graph x on n vertices that doesn’t contain
- a clique of size n/2

- Goal: find an edge in x that doesn’t exist in y

By lemma 2:

the Communication Complexity of this game =

the monotone circuit depth of the (n/2)-Clique function.

Monotone KW Game, depth of the (

Given a monotone function

The communication game :

- Alice gets s.t. x is a minterm of f (so f(x)=1)
- Bob gets s.t. y is a maxterm of f (so f(y)=0)
- Goal: Find i s.t.

That is:

Find i s.t. xi=1 and yi=0

is a restriction of to a subset of inputs. depth of the (

Hence, any protocol for is also a protocol for

So:

In fact, for every monotone

We have to prove

: depth of the (

Given a protocol for , we will construct a protocol

for with the same communication complexity.

Alice gets x s.t. f(x)=1, and finds a minimal x’ s.t.

.

And f(x’)=1

In the same way, Bob finds a maxterm

This is done by successively changing 1’s to 0’s in x

x’ is a minterm

Alice and bob run the protocol for on depth of the (x’ and y’, and find

i s.t. x’i = 1 and y’i = 0

Since

and

we have xi=1 and yi=0

We get: for every monotone

We will prove a lower bound of for the monotone depth of the (

depth of the Matching function.

Match(x) =

- 1 x contains k independent edges
- 0 otherwise

Lower Bound for Matching

The function Match:

Let n=3k, and x a graph on n vertices.

By Lemma 2: depth of the (

The monotone KW game M0 for Match :

- Alice gets a graph x on n vertices that contains a k-matching

- Bob gets a graph y on n vertices that doesn’t contain
- a k-matching

- Goal: find an edge in x that doesn’t exist in y

To prove a lower bound for

Mon-Depth(Match) it’s enough to prove a lower bound for CC(M0)

Claim depth of the (:

The game M1:

- Alice gets k independent edges x on n vertices (k-matching)

- Bob gets a set y of k-1 vertices

- Goal: find an edge in x that doesn’t touch
- any of the vertices in y

Proof:

- Every k-matching is a minterm of Match

- Every set of k-1 vertices is a maxterm of Match, by
- considering all edges that touch y.

- Every protocol for M0 can by applied on x,y to solve
the game M1.

We get: depth of the (

To prove a lower bound for

Mon-Depth(Match) it’s enough to prove a lower bound for CC(M1)

P- a protocol for M1.

We can assume that P outputs each possible answer

with the same probability.

Alice and Bob can use a common random string to permute the vertices before applying P

Claim depth of the (: for any there exists a constant a s.t.

The minimal CC of a probabilistic protocol P for which:

Pr[P answers right]

The game M2:

- Alice gets a k-matching x

- Bob gets a set y of k vertices

- Goal: output 1 if there’s an edge in x that doesn’t touch
- any of the vertices, and 0 otherwise.

Claim depth of the (: for any there exists a constant a s.t.

Bob has a set y of k vertices, and will randomly choose

and remove it.

Alice and Bob can apply P1 for M1 on (x,y’) and get

That doesn’t touch any of the vertices in y’.

Assume we have a deterministic protocol P1 for M1

Proof:

We will construct a probabilistic protocol P2 for M2,

with the same CC as P1

Bob is left with a set y’ of k-1 vertices.

- If the edge depth of the (edoesn’t touchv then P2 outputs 1.

e doesn’t touch any vertex in y

- If etouchesv then P2 outputs 0.

P2assumes all edges in x touch y

Analysis:

If P2 outputs 1: e doesn’t touch v or any other vertex in y.

In this case, there is no mistake

If P2 outputs 0: there may be an edge e’ in x that doesn’t

touch any of the vertices in y, P1 outputs e that touches v.

v depth of the (

e

y

e’

y’

Since the edges are independent, there’s at most one

edge e that touches v.

We are analyzing the case where there’s at least one

edge e’ that doesn’t touch any of the vertices in y.

An error occurs if e was output instead of any e’.

- for any error prob. there exists a constant depth of the (a s.t.

The probability of that is at most 1/2

P1 outputs each answer with the same probability.

If there are m answers, the probability is 1/m.

To reduce the error probability, we can repeat this

protocol any number of times.

We have: depth of the (

We’ll show:

The communication complexity of this problem is

The 3-Distinctness problem:

- Alice and Bob each get a string of n letters from {a,b,c}

- Goal: decide whether or not there’s i s.t. xi=yi.

?

To prove the lower bound for M2, We’ll show a reduction

from the 3-distinctness problem.

a depth of the (

c

b

b

c

a

Alice and Bob convert their input from the 3-distinctness

Problem to the following graph:

For each coordinate construct an independent triangle

with vertices labeled a,b,c.

Denote each edge by the same letter as the vertex it

doesn’t touch

a depth of the (

a

a

c

b

c

b

c

b

c

b

c

b

a

a

c

b

a

1 2 n

a

a

a

c

b

c

b

c

b

b

c

b

c

b

c

a

a

a

1 2 n

- Alice interprets her n coordinates of x as thecorresponding
- n edges in the n triangles.

Example: Alice’s input is {a,c,…,b}

- Bob interprets his n coordinates of y as the corresponding
- n vertices in the n triangles.

Example: Bob’s input is {b,b,…,a}

We’ve obtained a lower bound of for the depth of the (

Probabilistic communication complexity of M2

We’ll call Alice’s set of edges x’,

and Bob’s set of vertices y’

There’s an edge in x’ that doesn’t touch y’

iff there’s a coordinate i such that xi=yi

In each triangle, vertex d doesn’t touch edge d

CC depth of the ((3-Distinctness) is

By reduction from the Disjointness problem,

which has CC :

- Alice gets

- Bob gets

- Goal: return 1 iff there’s i s.t. xi=yi=1

!

In the disjointness problem:

There’s i for which xi=yi=1 iff there’s i for which x’i=y’i

To get a 3-distinctness problem:

- Alice turns each 0 to b and each 1 to aand gets x’

- Bob turns each 0 to c and each 1 to aand gets y’

Download Presentation

Connecting to Server..