Lecture 2

*** Key viewpoint: f as a matrix or 2d array, called M_f 

RECTANGLE: combinatorial rectangle in X x Y is X’ in X, Y’ in Y, X’ x Y’.

(x, y) and (x’, y’) both in rectangle, then (x, y’) and (x’, y) are.

Claim: Every leaf in the protocol tree corresponds to a monochromatic rectangle
	[those (x,y) pairs that lead to that leaf]

Claim: protocol partitions X x Y into monochromatic rectangles. 

Example from book (p. 10)

N.B. not every partition corresponds to a protocol. Example from top of p. 17 in book

Let C^P(f) be the smallest partition over all protocols for f. This characterizes
	D(f) up to constants. 

Lemma: D(f) \ge log_2 C^P(f). 

Proof: number of leaves of protocol tree is at least C^p(f).
	binary tree -> depth at least log of that. Depth is D(f). 


Lemma: D(f) \le O(log C^P(f)). 

Proof: we have to show how to achieve O(log C^P(f)) in a protocol. Let m = C^p(f). 

	Key: find a node v in tree t with subtree of size between 1/3m and 2/3m

	Let R be rectangle in X x Y of inputs that reach this node.
	
	Alice and Bob spend 2 bits to determine if (x,y) is in R.

	If yes, then recursively solve f restricted to R 
		(using protocol with at most m_v leaves)
	If no, then recursively solve f’ agreeing with f outside R, and 0 inside R. 
		(using a protocol with at most m - m_v leaves [can replace v with 0-leaf])

	Defining T(m) = worst depth starting with m leaves,

	T(m) \le 2 + T(2/3 m) 	and T(1) = 0. Solve recurrence.

Great. Now how do we lower bound number of rectangles? 


*** Fooling Set lower bound method

Definition (1.19)
Lemma: fooling set of size t implies D(f) \ge log_2 t.

[for later: note that this actually gives a lower bound on only z-rectangles]

* Example: equality: S = {(x,x)}

* Example: greater-than (same)

* Example: Disjointness: S = {(A, complement of A): A a subset}



*** Rectangle Size lower bound method

Idea: if all monochromatic rectangles are small, must be a lot of them. 

Proposition 1.24 from the book

Show this is a special case of Fooling Set by putting all mass on Fooling Set.

Typical: take uniform measure. Or, uniform measure on only 0’s or only 1’s

* Example: Inner product mod 2 (prove 0-monochromatic rectangle size is at most 2^n)

	[idea: given two subsets, take linear span. Still monochromatic.
		orthogonal subspaces so dimensions sum to at most n]

* Example: Disjointness (prove 1-monochromatic rectangle size is at most 2^n)

	[idea: look at union of sets on one side, and union of sets on other. 
		must be disjoint. at most 2^k and at most 2^ell for k + l \le n]



*** Rank lower bound method

Brief digression. Rank of matrices over different fields. 

If K subfield of F, then Rank_K(M) = Rank_F(M).

[Follows because F is a vectorspace over K… omitting details to avoid algebra]

Claim: rank_F(M) \le rank_R(M), for any field F

Proof: By first lemma, can replace R with Q. Suppose we have \sum_i \lamda_i c_i = 0 
	so c_i’s are linearly dependent. Then clear denominators.
	key: can assume gcd{\lamda_i} = 1. 
	Then replacing k with (1 + 1 + 1 … + 1) in field F, we get same sum.
	And not all the replaced \lamda_i are 1, because of GCD assumption

Definition 1.27

Lemma: D(f) \ge log_2 rank(f).

Proof: write each 1-rectangle as rank 1 matrix, and sum

Note, can do this for 0-rectangles via doing 1-rectangles of J - M_f

So actually, Lemma: D(f) \ge log_2 (2rank(f) - 1)

* Example: EQ, GT

* Example: IP (look at square)

* Example: DISJ (consider as tensor product of {1,1;1,0} )