Local Computation and Reducibility

Kenji Christopher Obata

Electrical Engineering and Computer SciencesUniversity of California at Berkeley

Technical Report No. UCB/EECS-2006-62

http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-62.html

May 17, 2006

Copyright © 2006, by the author(s).All rights reserved.

Permission to make digital or hard copies of all or part of this work forpersonal or classroom use is granted without fee provided that copies arenot made or distributed for profit or commercial advantage and that copiesbear this notice and the full citation on the first page. To copy otherwise, torepublish, to post on servers or to redistribute to lists, requires prior specificpermission.

Acknowledgement

See body of thesis.

Local computation and reducibility

by

Kenji Christopher Obata

B.Sc. (Yale University) 1999

A dissertation submitted in partial satisfaction of the

requirements for the degree of

Doctor of Philosophy

in

Computer Science

in the

GRADUATE DIVISION

of the

UNIVERSITY OF CALIFORNIA, BERKELEY

Committee in charge:Professor Luca Trevisan, Chair

Professor Satish RaoProfessor David Aldous

Spring 2006

The dissertation of Kenji Christopher Obata is approved:

Chair Date

Date

Date

University of California, Berkeley

Spring 2006

Local computation and reducibility

Copyright 2006

by

Kenji Christopher Obata

1

Abstract

Local computation and reducibility

by

Kenji Christopher Obata

Doctor of Philosophy in Computer Science

University of California, Berkeley

Professor Luca Trevisan, Chair

A large body of recent work has been concerned with algorithms requiring access to only a

sublinear, or even constant, sample of input bits. We study fundamental limitations in this

model of computation and relationships to classical problems in combinatorial optimization.

Professor Luca TrevisanDissertation Committee Chair

i

For my parents,

ii

Contents

1 Introduction 1

2 Local computation 3

3 Lower bounds for CSPs 73.1 Probabilistic constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.2 Explicit constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.3 Lower bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.4 Approximation algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4 Local reducibility 224.1 Local reducibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2 Local 3-colorability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5 Locally decodable codes 295.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.2 Blocking game and matchings . . . . . . . . . . . . . . . . . . . . . . . . . . 365.3 Lower bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

6 Integral flows 476.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476.2 Three graph decompositions . . . . . . . . . . . . . . . . . . . . . . . . . . . 516.3 Max-integral-flow/min-multicut approximation ratios . . . . . . . . . . . . . 576.4 Related applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.5 Tightness of bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

Bibliography 69

iii

Acknowledgments

I gratefully acknowledge the guidance and support of my academic advisor Luca Trevisan,

whose generous supply of insight and patience was essential to the development of virtually

all of the ideas contained in this work. I also thank my dissertation committee members

Satish Rao and David Aldous for their valuable feedback and encouragement.

I enjoyed countless memorable experiences and enlightening discussions while study-

ing at Berkeley. I must especially thank Andrej Bogdanov – variously cook, co-author,

antagonist, therapist, and drinking partner – for his consistent friendship. Many thanks are

due to my fellow graduate students, including Scott Aaronson, Kamalika Chaudhuri, Kevin

Chen, Holly Fait, Chris Harrelson, Matthew Harren, Lawrence Ip, James Lee, David Mol-

nar, David Ratajczak, Samantha Riesenfeld, Stephen Sorkin, Kunal Talwar, and Hoeteck

Wee. I was fortunate as an undergraduate to have enjoyed the inspiration of many out-

standing educators, of whom I particularly acknowledge Michael Fischer, Ravi Kannan, and

Laszlo Lovasz. I am indebted to the Antolin family for their warm hospitality and support.

Finally, I thank my parents, to whom this dissertation is dedicated.

This work was supported by an NSF Graduate Research Fellowship.

1

Chapter 1

Introduction

Sampling is a powerful technique for estimating properties of large systems. Mo-

tivated by the revolution in probabilistically checkable proofs, Goldreich, Goldwasser and

Ron [GGR98] initiated a study of the application of sampling techniques to traditional algo-

rithmic problems, such as graph coloring and connectivity. When available, such algorithms

offer astonishing performance advantages over traditional computational methods.

In this work, we study fundamental limitations in this model of computation.

In particular, we show that 3CNF satisfiability and related problems are uncomputable

by sampling-based algorithms. The core of our proof is the construction of families of

constraint problems for which global satisfiability cannot be estimated from local consid-

erations. We then introduce a notion of local reducibility between combinatorial problems

analogous to Turing reducibility in traditional complexity theory, and apply this to derive

explicit combinatorial constructions of graphs for which 3-colorability is undecidable by

local algorithms.

2

Finally, we consider two variations on the theme of local computability. We study

error-correcting codes for which decoding can be performed by local algorithms, and prove

exponential lower bounds on the size of such local coding schemes. We then explore re-

lationships between our analysis of local coloring and classical problems in combinator-

ial optimization, yielding new approximation algorithms for integral multicommodity flow

problems and related integral-flow/multicut duality relationships.

3

Chapter 2

Local computation

We begin by making precise our notions of local computability and approximation.

Throughout, we assume standard definitions and notations from computational

complexity theory (Turing Machines, oracles, asymptotic notation, and so forth). The

reader is referred to [Pap93] for these standard definitions. We work always with some finite

alphabet Σ. For a given Σ, we denote by Σn the set of all ordered n-tuples of elements of

Σ and by Σ∗ the union⋃

n Σn. A language L on Σ is some particular subset L ⊆ Σ∗ (the

set of encodings of instances having some property of interest).

Roughly speaking, a language L is locally computable if there exists an algorithm

which determines whether a given string x ∈ Σn lies in L and which queries only a sublinear

number of entries of x. For many non-trivial problems, it turns out that the number of

queries may even be independent of the size of the input.

Clearly, for non-trivial problem domains L, such algorithms must be randomized

and allowed some probability of failure. Also, we can only demand that sublinear algorithms

4

distinguish between inputs in L and inputs which are far from L in the sense that a constant

fraction of entries must be modified to carry the input into L.

(The situation is closely analogous to that of classical statistical sampling – one

is able to count the number of objects having a given property from among a large set by

inspecting only a constant number of randomly selected objects. However, this tremendous

efficiency comes at the expense of a small probability of failure and a small error in one’s

estimate of the number of objects.)

We shall use standard notions of distance between strings and sets.

Definition 1 (Distance) For any alphabet Σ and x, y ∈ Σn for n ∈ N, we say that x and

y are at distance d(x, y) = ε if x and y disagree on εn entries. For sets X,Y ⊆ Σn, we

define

d(X,Y ) = minx∈X,y∈Y

d(x, y).

In particular, if L is a language on alphabet Σ and x ∈ Σn for some n ∈ N, then

d(x,L) = miny∈L

d(x, y).

(In our applications, Σn⋂L will always be non-empty so this distance is well-defined.)

Combining this with an allowance for (one- or two-sided) error, we have the fol-

lowing natural definition for local computability.

Definition 2 (Local computability) We say that a language L is locally computable

with complexity c(n) and distance parameter ε if there exists a probabilistic algorithm A(n)

5

and constants δ1, δ2, ε ≥ 0 such that, given access to an oracle O for input x ∈ Σn, AO(n)

has the following properties:

(i) AO(n) makes at most c(n) invocations to the oracle O.

(ii) For all x ∈ Σn, if x ∈ L then AO(n) accepts with probability at least 1− δ1.

(iii) For all x ∈ Σn, if d(x,L) ≥ ε then AO(n) rejects with probability at least 1− δ2.

(This definition was introduced by Goldreich, Goldwasser, and Ron [GGR98], who

used the term property testing to describe this setting. We believe the term local computabil-

ity is somewhat more general and descriptive, so we use this term throughout.)

In the special case where δ1 = 0, we say that A has one-sided error. Otherwise, A

has two-sided error.

We are especially interested in languages L for which c(n) is a sublinear function

in n; that is, c(n) = o(n). In this case, we say simply that L is locally computable. Gol-

dreich and Ron [GR97, GR99] showed, for example, that in an appropriate representation,

connectivity is locally computable with c(n) = O(1) and bipartiteness with c(n) = O(√

n).

Encodings and representation dependency

In the traditional computational setting, the particular choice of representation for

the input is typically irrelevant to the computational complexity of the problem domain.

For instance, whether a graph is represented in an adjacency list or an adjacency matrix

representation is insignificant, since either representation can be converted to the other in

polynomial time. In local computational models, however, we do not enjoy the luxury of

6

even linear time in which to perform this transformation, so one must be careful to specify

the particular representation to be used.

Note also that our notion of distance is strongly dependent on the choice of rep-

resentation – two objects which are close in one representation may be far in another. For

example, consider the set of connected graphs: If represented as a bounded-degree adja-

cency list, the empty graph on n vertices is ε-far from the set of connected graphs for any

ε < 1 and sufficiently large n; on the other hand, any graph is asymptotically ε-close to a

connected graph when represented as an adjacency matrix.

Throughout this work, we will deal frequently with simple, bounded-degree graphs

and (3, k)CNF formulas. We shall use always sparse representations of our graphs and

formulas. That is, for graphs G with degree bound ∆, we encode G in an adjacency list

representation. Similarly, for (3, k)CNF formulas, we encode the instance as a membership

list which provides, for each variable, the indices of the clauses in which the variable appears,

along with the list of clauses, encoded as the indices of each variable in the clause along

with a bit indicating whether each variable appears negated.

For more information and results related to alternate representations, the reader

is referred to [GR97], [AFKS99], and [KKR04].

7

Chapter 3

Lower bounds for CSPs

We consider the local computability of constraint satisfaction problems (CSPs). In

particular, we prove that there cannot exist local algorithms to decide graph 3-colorability

and E3LIN2 satisfiability. The results in this chapter are joint work with Andrej Bogdanov

and Luca Trevisan [BOT02].

As a first step, we show that no local algorithm with one-sided error, given a degree

∆ graph with n vertices, can view fewer than δn entries of the adjacency list representation

of the graph, yet reject with constant probability graphs that are ε-far from 3-colorable. To

this end, a simple observation is that a one-sided local algorithm must accept whenever its

view of the graph is 3-colorable. In other words, it is sufficient to construct a graph G that

is ε-far from 3-colorable, yet every one of its induced subgraphs on δn edges is 3-colorable.

In Section 3.1 we give a probabilistic construction of such graphs based on a

technique due to Erdos [Erd62]. For every α > 0, there exist constants ∆ = O(1/α2) and

δ > 0 such that some ∆-regular graph on n vertices is (1/3 − α)-far from 3-colorable, yet

8

every subgraph induced by up to δn edges is 3-colorable. As a consequence, we obtain:

Theorem 3 For every α > 0 there exist constants ∆ and δ > 0 such that if A is a lo-

cal algorithm for distinguishing 3-colorability on degree ∆ graphs with one-sided error and

distance parameter 1/3 − α, then the query complexity of A is at least δn, where n is the

number of vertices.

Notice that no graph is more than 1/3-far from being 3-colorable, so our result applies to

the full spectrum of gaps for which the problem is well defined. Furthermore, for small

enough α, the distinguishing problem is solvable deterministically in polynomial time with

the Frieze-Jerrum algorithm [FJ97]. This gives a separation between the distinguishing

ability of polynomial time versus (one-sided error) sublinear time algorithms for a natural

problem.

To prove a lower bound for two-sided error algorithms, by Yao’s principle, it is

enough to construct two distributions G3col and Gfar over bounded-degree graphs such

that graphs in G3col are always 3-colorable, graphs in Gfar are typically far from being

3-colorable, and the two distributions are indistinguishable by algorithms with sublinear

query complexity.

Towards this goal, we will first construct two distributions of instances of E3LIN2,

Dsat and Dfar, such that instances in Dsat are always satisfiable and instances in Dfar

are typically far from satisfiable, yet the two distributions are indistinguishable by algo-

rithms with sublinear query complexity. Using the notion of local reducibility introduced

in Chapter 4, we will later reduce E3LIN2 to 3-coloring and argue that the transformation

preserves, respectively, satisfiability and 3-colorability, as well as farness from satisfiabil-

9

ity and 3-colorability. Moreover, an oracle for a reduced instance can be implemented in

constant time given the original instance.

In order to define Dsat and Dfar, we show that for every c there exists δ > 0 such

that there is an E3LIN2 instance I with n variables and cn equations such that any subset

of δn equations are linearly independent. We do so using a probabilistic argument. We then

define Dsat to be the distribution of instances obtained by first picking an assignment to the

variables, and then setting the right-hand side of I to be consistent with the assignment.

In Dfar we set the right-hand side of I uniformly at random. For algorithms that look at

less than a δ fraction of equations, the two distributions are identical. However instances

in Dsat are always satisfiable while instances in Dfar are about (1/2 − O(1/√

c))-far from

satisfiable, except with negligibly small probability. Thus we obtain:

Theorem 4 There exist universal constants δ, ε such that if A is a local algorithm for

distinguishing E3LIN2 satisfiability with distance parameter ε, then the query complexity of

A is at least δn, where n is the number of variables.

3.1 Probabilistic constructions

In this section we provide probabilistic constructions of combinatorial objects

(graphs and 3-hypergraphs) that will be used to obtain problem instances for 3-colorability

and E3LIN2 for which it is difficult to distinguish, respectively, colorability and satisfiability.

We shall make frequent use of standard constructs and techniques from probability

theory such as martingales, tail inequalities, and so forth. The reader is referred to [MR95]

for these definitions and proofs.

10

Graphs and hypergraphs with no small dense subgraph

For purposes of this section, it will be somewhat more convenient to work with

multigraphs instead of graphs. We consider a distribution G on n-vertex multigraphs G

(where n is even) obtained as follows:

Let C1, . . . , C∆ be independent random perfect matchings on the vertices of G.

The edge set of G is the multiset union of the Ci, so that the multiplicity of an edge equals

the number of matchings Ci in which it appears. If (u, v) ∈ Ci, we say that v is the i-th

neighbor of u in G.

We denote by G|S the restriction of multigraph G on vertex set S ⊆ V (G). Let

XS be the number of edges in G|S . Then E(XS) = ∆(|S|

2

)1

n−1 . Fix a partition S1, S2, S3

of V (G). We are interested in bounding the probability that this partition is 1/3-close to a

valid coloring of G. Let X = XS1 + XS2 + XS3 .

Lemma 5 For every partition S1, S2, S3 of V (G) and every constant α > 0,

Pr(X < (1/6− α)∆n) ≤ exp(−(α− o(1))2∆n).

Proof Consider the random process I1, . . . , I∆n/2 on G, which reveals the edges of G

one by one. For a fixed partition S1, S2, S3, the random variable X determines a Doob

martingale with respect to this process. A simple computation shows that for 1 < j ≤ ∆n/2,

|E(X|I1, . . . , Ij)− E(X|I1, . . . , Ij−1)| ≤ 1.

By convexity, E(X) ≥ ∆n6

n−3n−1 (this value is attained when |S1| = |S2| = |S3| = n/3).

11

Azuma’s inequality yields

Pr(

X <

(16

n− 3n− 1

− α′)

∆n

)≤ exp(−α′2∆n).

The conclusion follows, with α = α′ + 13(n−1) .

Denote by G the graph obtained by identifying every multiedge of G with an

ordinary edge.

Lemma 6 For any constant α > 0 there exists a constant ∆ such that, with probability

1− o(1), any 3-coloring of the vertices of G has at least (1/6− α)∆n violating edges.

Proof First we show that the conclusion holds for G. The number of tripartitions of

V (G) is 3n. By combining a union bound with the bound from Lemma 5, it follows that

any such partition has (1/6− α)∆n violating edges if ∆ > ln 3/α2.

For any pair of vertices (u, v), let Mu,v indicate the event that (u, v) is an edge of

G with multiplicity two or more. Then Pr(Mu,v = 1) = O(∆/n2). By Markov’s inequality,

the probability that there are ∆ log n or more pairs (u, v) with Mu,v = 1 is o(1). Since no

edge of G has multiplicity more than ∆, it follows that |E(G)| − |E(G)| ≤ ∆2 log n = o(n).

Therefore, the conclusion of the lemma carries over to G.

Lemma 7 For every K > 1 there exists δ > 0 such that with probability 1−o(1), all graphs

G|S with |S| ≤ δn have at most K|S| edges.

Proof Suppose some set S of cardinality s contains Ks edges (u1, v1), . . . , (uKs, vKs).

Denote by Xi,k, Yi,k the vertices matched to ui and vi, respectively, in the matching Ck.

12

Then

Pr (∃k : Xi,k = vi ∧ Yi,k = ui|Xp,q, Yp,q : 1 ≤ p ≤ i− 1, 1 ≤ q ≤ ∆) ≤ ∆/(n− 2s),

since for any fixed q, the variables Xp,q and Yp,q determine the neighbors of at most 2s

vertices in matching Ck. It follows that

Pr(∀i, 1 ≤ i ≤ ∆ : ∃k : Xi,k = bi ∧ Yi,k = ai)

≤(

∆n− 2s

)Ks

<

(∆

(1− 2δ)n

)Ks

.

For fixed s, the set S can be chosen in(ns

)ways, while the set (u1, v1), . . . , (uKs, vKs) can

be chosen in((s

2)Ks

)ways. Therefore, for some constant s0,

Pr(∃S, s0 ≤ |S| < δn : |E(G|S)|K|S|)

≤δn∑

s=s0

(n

s

)((s2

)

Ks

)(∆

(1− 2δ)n

)Ks

≤δn∑

s=s0

(ne

s

)s(

s2e/2Ks

)Ks (∆

(1− 2δ)n

)Ks

=

(e2∆2

(e∆

2K(1− 2δ)

)K ( s

n

)K−1)s

= o(1).

It is easy to see that the contribution of sets S of size less than s0 is also o(1).

We define an analogous distribution H on 3-hypergraphs (hypergraphs with mul-

tiple hyperedges where each hyperedge has cardinality 3) with n vertices, where n is a

13

multiple of 3. To obtain a graph H ∼ H, we choose ∆ independent uniformly random

partitions of the vertex set V (H) into 3-hyperedges (3-element subsets). With probability

1 − o(1), all hyperedges of H have multiplicity one. An argument similar to the proof of

Lemma 7 shows the following.

Lemma 8 For every K > 1/2 there exists δ > 0 such that with probability 1 − o(1), all

3-hypergraphs H|S with |S| ≤ δn have at most K|S| edges.

Hard instances

We now show the existence of graphs that are almost 1/3-far from 3-colorable yet,

for some δ > 0, all vertex-induced subgraphs of size δn are 3-colorable.

Choose a multigraph G according to the distribution G of Section 3.1, and let G

denote the graph obtained from G by ignoring multiplicities. We show that the graph G

has the desired property. As in [Erd62], we use the fact that every vertex in any minimal

non-3-colorable subgraph has degree at least three.

Theorem 9 For every α > 0 there exists δ > 0 such that with probability 1−o(1), the graph

G is (1/3− α)-far from 3-colorable, yet all subgraphs G|S with |S| < δn are 3-colorable.

Proof By Lemma 6 with parameter α/2, every tripartition of V (G) has at least (1/3−

α)∆n/2 violating edges, so G is 1/3-far from 3-colorable.

Suppose that there exists a set S of size s < δn such that G|S is not 3-colorable.

We may assume that S is a minimal set with this property. Suppose that G|S contains a

vertex v of degree two or less (with respect to G|S). By the minimality of S, there is a

3-coloring of the graph G|S−v. However, this coloring extends to a 3-coloring of G|S , by

14

picking a color for v that does not match any of its neighbors. It follows that any vertex

in G|S must have degree at least 3. Therefore, G|S must contain at least 3s/2 edges. By

Lemma 7 with K = 3/2, this is not possible.

Using the 3-hypergraph construction, we prove the existence of certain matrices

that will later be used as the left hand side of hard E3LIN2 instances.

Theorem 10 For every c > 0 there exists a δ > 0 such that for every n there exists a

matrix A ∈ 0, 1n×cn with n columns and cn rows, such that each row has exactly three

non-zero entries, each column has exactly 3c non-zero entries, and every collection of δn

rows is linearly independent.

Proof By Lemma 8, there exists a 3c-regular 3-hypergraph H on n vertices such that any

H|S with |S| ≤ 3δn has strictly fewer than 2|S|/3 edges. Let A be the incidence matrix of

H: The columns of A correspond to vertices of H, the rows of A correspond to hyperedges

of H, and Ave = 1 if and only if v ∈ e. Suppose that there is a set R of δn rows of A (or

hyperedges of H) that are linearly dependent. We may assume that R is a minimal set with

this property. Let S ⊆ V (H) denote the set of vertices incident to hyperedges in R, so that

|S| ≤ 3δn. By minimality of R, every element of S must appear in at least two rows of R.

Therefore, R contains at least 2|S|/3 hyperedges. Contradiction.

3.2 Explicit constructions

In this section, we give an explicit construction of an infinite family of CSPs on n

variables and m = O(n) clauses over a fixed boolean predicate such that any subset of δm

15

clauses is satisfiable, but no assignment satisfies more than (1− ε)m clauses. By applying

the gap-preserving local reductions presented in Chapter 4, we shall achieve an explicit

construction of an infinite family of bounded degree graphs G on n vertices and m edges

such that every subgraph induced by δm edges is 3-colorable, but any 3-coloring of G has

at least εm monochromatic edges.

(In the previous section we used the probabilistic method to prove only the exis-

tence of such graphs.)

Since we will deal frequently with partially satisfiable constraint satisfaction prob-

lems, we introduce the following notation.

Definition 11 ((δ, 1− ε)-satisfiability) A constraint satisfaction problem on m clauses is

(δ, 1− ε)-satisfiable if any subset of at most δm constraints is satisfiable, but no assignment

satisfies more than (1− ε)m constraints.

For a fixed ∆, we will consider 2∆-ary constraints of the form

h : 0, 1∆ × 0, 1∆ → 0, 1,

where h(x1, . . . , x∆, y1, . . . , y∆) is satisfied exactly when∑∆

i=1 xi =∑∆

i=1 yi + 1, and we

identify the boolean 0, 1 inputs with the integers 0 and 1 in the obvious way.

Let G(V, E) be an undirected multigraph. We write Γ(v) for the neighbor set of

vertex v ∈ V , Γ(v, i) for the i-th neighbor of v (where we index Γ(v) in an arbitary way),

and Γ(S) for the neighbor set of a vertex-subset S ⊆ V .

16

Our constructions shall make extensive use of expander graphs, particularly graphs

with the following strong expansion property.

Definition 12 ((n,∆)-Expander) A multigraph G is an (n,∆)-expander if it is ∆-regular

and if, for every subset S ⊂ V with |S| ≤ 12 |V |, |Γ(S)| ≥ |S|.

Explicit constructions of (n,∆)-expanders are known [Mar73, GG81], and we as-

sume that we have an infinite family of (n,∆)-expanders for some universal constant ∆.

Define the constraint satisfaction problem fn on ∆n variables and n clauses over

h as follows: Let G(V, E) be an (n, ∆)-expander. Begin by converting G into a directed

multigraph G′(V, E′) by replacing each undirected edge (i, j) ∈ E with two directed edges

(i, j), (j, i) ∈ E′. Each edge (i, j) ∈ E′ is identified with a boolean variable xi,j in fn. One

constraint h is introduced for each v ∈ V , with the predicate variables mapped to the edges

incident to v:

fn =∧

v∈V

h(xv,Γ(v,1), . . . , xv,Γ(v,∆), xΓ(v,1),v, . . . , xΓ(v,∆),v)

Theorem 13 There exist constants δ, ε > 0 such that the CSP formulas fn are (δ, 1 − ε)-

satisfiable.

Proof We begin by finding ε such that no subset of more than (1− ε)n constraints can

be satisfied. Suppose there is an assignment satisfying some subset S of constraints with

|S| > (1− ε)n. Then the following network flow problem is solvable: Contract the vertices

corresponding to S into a single sink vertex t, create a source vertex s with unit capacity

edges from s to every vertex in S, and interpret the remaining edges of G as unit capacity

17

edges. The assignment can then be interpreted as an (s, t)-flow of weight greater than

(1 − ε)n on this network. However, the cut (t, G\t) has weight at most ∆εn, so this is

impossible if we choose ε < 1∆+1 .

On the other hand, for δ ≤ 12 , any subset S of constraints with |S| = δn can be

satisfied. To see this, we define the following network flow problem: Contract the vertices

of G corresponding to the (1− δ)n constraints in S to a sink vertex t, create a source vertex

s with unit capacity edges from s to every node in S, and interpret the remaining edges

of G as unit capacity edges. We claim that there is a flow of weight at least δn in this

system. By the max-flow/min-cut theorem, it is enough to show that there is no (s, t)-cut

with weight less than δn (the cut (s,G\s) has weight δn). Let C be an arbitrary (s, t)-cut,

and denote by Cs, Ct the vertices of S in the partitions containing s and t respectively.

Each node in Ct incurs a cut cost of weight one due to the unit constraint edges we added

from s. By the strong expansion property, |Γ(Cs)| ≥ |Cs|, and each of the edges connecting

Cs to Γ(Cs) also incurs a cut cost of weight one. Summing up, |C| ≥ |Cs| + |Ct| = δn, so

there must exist an flow of weight δn in this system. Furthermore, the integrality property

of flows implies that we can assume the flow solution is (0, 1)-valued. Assigning this flow

to the edge variables gives a satisfying assignment to the constraints in S.

3.3 Lower bounds

We are now prepared to prove Theorems 3 and 4.

18

Proof of Theorem 3

To prove Theorem 3, we observe that any local algorithm with one-sided error must

accept whenever the subgraph it has queried is 3-colorable. In particular, when presented

with the graphs constructed in Theorem 9, any algorithm with query complexity at most δn

must accept with probability 1. However, these graphs are (1/3− α)-far from 3-colorable,

so we cannot have a local algorithm for 3-colorability with parameter 1/3− α.

Proof of Theorem 4

Our families of hard instances for two-sided error algorithm are derived from the

matrix A constructed in Theorem 10.

We consider the following two families of distributions on instances of E3LIN2

with n variables, cn equations, and each variable appearing in exactly 3c equations:

(i) Distribution Dfar consists of instances Ax = b, where b ∈ 0, 1cn is chosen uniformly

at random.

(ii) Distribution Dsat consists of instances Ax = Az, where z ∈ 0, 1n is chosen uniformly

at random.

By construction, every instance in Dsat is satisfiable. On the other hand, instances in Dfar

are far from satisfiable.

Lemma 14 For every α > 0, there exists c such that, with probability 1− o(1), an instance

sampled from Dfar is (1/2− α)-far from satisfiable.

Proof For a fixed assignment x, the vector Ax − b is uniformly distributed in 0, 1cn.

19

By a Chernoff bound, with probability 1− exp(−Ω(α2cn)), Ax− b has Hamming weight at

least (1/2− α)cn. A union bound over all 2n possible assignments for x yields the desired

result, as long as c = Θ(1/α2).

Lemma 15 For every α > 0 there exist constants c and δ > 0 such that every local al-

gorithm for E3LIN2 satisfiability on n variables and at most c occurrences with distance

parameter 1/2− α must have query complexity at least δn.

Proof Consider an instance Ax = b of cn E3LIN2 equations. Obtain a subinstance

A′x′ = b′ by choosing any subset of δn equations. By Theorem 10, the rows of A′ are

linearly independent. Therefore, for a uniformly random z′ ∈ 0, 1n, A′z′ is uniformly

distributed in 0, 1δn. It follows that the instances A′x′ = b′ and A′x′ = A′z′ are generated

with the same probability; that is, PrDfar(A′x′ = b′) = PrDsat(A′x′ = b′).

Let D be any algorithm of query complexity less than δn. If D can decide whether

a given instance Ax = b is satisfiable with any constant probability, then D has an advantage

at distinguishing instances sampled from Dsat (which are always satisfiable) from instances

sampled from Dfar (which are (1/2−α)-far from satisfiable with high probability). However,

the queries of D only reveal a subinstance A′x′ = b′ of at most δn equations, and the two

distributions are statistically indistinguishable on such a subinstance.

Theorem 4 follows immediately.

20

3.4 Approximation algorithms

We note some applications of our constructions to approximation algorithms for

coloring. The following theorem follows directly from Lemma 15.

Theorem 16 For every ε > 0, every (1/2+ε)-approximate algorithm for Max-E3LIN2 and

every (7/8+ε)-approximate algorithm for Max E3SAT has query complexity Ω(n+m), where

n is the number of variables and m is the number of equations/clauses. The theorem applies

to the special case where every variable occurs in O(1) equations/clauses and m = O(n).

Indeed, Lemma 15 is the unconditional version for sublinear time algorithms of the

hardness of approximation proved in [Has97] for Max-E3LIN2. Hastad [Has97] then uses

approximation preserving reductions to show that the hardness of Max-E3LIN2 implies

hardness of approximation results for other problems. Since the reductions used in [Has97]

preserve the existence of sublinear time algorithms (for proper instance representation),

we also have unconditional inapproximability results for other problems, with respect to

sublinear-time algorithms.

The standard [FGL+96] reduction from Max-E3LIN2 to Vertex Cover is such that

if every variable occurs in O(1) equations in the E3LIN2 instance, then the graph produced

by the reduction has constant degree. Therefore, the following result also follows from

Lemma 15 (see [Has97] for a calculation of the inapproximability factor).

Theorem 17 For every ε > 0, there are constants d, δ such that every (7/6+ε)-approximate

algorithm for Minimum Vertex Cover in graphs of degree ≤ δ has query complexity at least

δn.

21

Similarly, we have a linear query complexity lower bound for every (21/22 + ε)-

approximate algorithm for Max-2SAT, even for the restricted case where every variable

occurs in O(1) clauses.

Regarding Max-CUT, the reduction used in [Has97] does not create a bounded-

degree graph, even if in the original E3LIN2 instance every variable occurred in a bounded

number of equations. However the reduction in [Tre01] can be used to show that every

(16/17+ε)-approximate algorithm for Max-CUT in bounded-degree graphs has linear query

complexity.

22

Chapter 4

Local reducibility

In this chapter, we define a notion of reducibility between constraint satisfaction

problems which preserves, up to modification of constants, the property that a decision

problem has a sublinear algorithm, and exhibit such a reduction from (3, k)SAT to 3-

colorability in bounded degree graphs.

By applying this reduction to the construction of Section 3.2, we achieve an explicit

construction of an infinite family of bounded degree graphs G on n vertices and m edges

such that every subgraph induced by δm edges is 3-colorable, but any 3-coloring of G has

at least εm monochromatic edges. (In the proof of Theorem 9 we used the probabilistic

method to prove only the existence of such graphs.) While natural in our context, the use

of reductions in the explicit construction of combinatorial objects is a novel approach which

seems interesting in its own right.

Similarly, applying this reduction to the constructions of Lemma 15 yields a gen-

eralization of Theorem 3 to local algorithms with two-sided error.

23

4.1 Local reducibility

For our purposes, the following notion of reduction will be appropriate.

Definition 18 (Gap-preserving local reduction) Let L1,L2 be two languages. We say

that a mapping ϕ is a gap-preserving local reduction from L1 to L2 if there exist universal

constants c1, c2 > 0 such that the following properties hold:

(i) If x ∈ L1, then ϕ(x) ∈ L2.

(ii) If d(x,L1) ≥ ε then d(ϕ(x),L2) ≥ ε/c1.

(iii) The answer to an oracle query to ϕ(x) can be computed by making at most c2 oracle

queries to x.

We note three easy lemmas, which will allow us to move between various CSP

formulations.

Lemma 19 Let H be an arbitrary fixed set of boolean predicates on a finite number of

variables. There exists a gap-preserving local reduction from CSPs defined on H which

carries an instance f with n variables and m clauses into a 3CNF formula with O(n + m)

variables and O(m) clauses.

Proof It is a basic fact that an arbitrary boolean predicate on a finite number of variables

can be expressed as a 3CNF formula, possibly with introduction of a constant number of

auxiliary variables. It is easy to check that applying this transformation to each clause of

f gives a reduction which has the claimed properties.

24

Lemma 20 Gap-preserving local reductions are closed under composition.

Proof Trivially, if ϕ,ϕ′ are gap-preserving local reductions with distortion constants

c1, c2 and c′1, c′2 respectively, then ϕ ϕ′ is a gap-preserving local reduction with distortion

constants c1c′1, c2c

′2.

Lemma 21 If ϕ : L1 → L2 is a gap-preserving local reduction with distortion constants

c1, c2 and f is a (δ, 1− ε)-satisfiable CSP, then ϕ(f) is a (δ/c2, 1− ε/c1)-satisfiable CSP.

Proof Let fA be a (δ, 1 − ε)-satisfiable instance of A, and fB = ϕ(fA). That the prob-

lem fB is εc1

-far from satisfiable is immediate from the definition of a gap-preserving local

reduction. Now, let m be the number of clauses in problem fB and consider any subset

C ′1, . . . , C

′k′ of δ

c2m of these clauses. By the locality property, these clauses are a function of

some set of clauses C1, . . . , Ck of fA with k ≤ c2δc2

m = δm. Since fA is (δ, 1− ε)-satisfiable,

the clauses C1, . . . , Ck are satisfiable, and we can extend these clauses to a new, satisfiable

instance f ′A of A by setting every clause other than C1, . . . , Ck to a satisfiable clause on

fresh variables. ϕ must send f ′A into a satisfiable instance, and this instance contains clauses

C ′1, . . . , C

′k′ . In particular, the clauses C ′

1, . . . , C′k′ must be satisfiable.

4.2 Local 3-colorability

We now exhibit a gap-preserving local reduction ϕ from (3, k)SAT to 3-coloring in

bounded degree graphs. We comment that a reduction with essentially the same properties

was given by Petrank in [Pet94]. However, Petrank’s construction does not yield a bounded

25

Figure 4.1: Gadgets for Theorem 22

degree graph, which is essential in our context. Also, our construction is somewhat simpler

to describe and analyze.

Construction: Let f be the (3, k)CNF formula on n variables and m clauses to be mapped.

First, we introduce a large set of nodes which are independent of the clauses of f which we

label Di, Ti, and Fi for i = 1, . . . , 2kn. The nodes Di will all assume the color corresponding

to the “dummy” color (this color is used as in the standard 3-coloring reduction), Ti to the

“true” color, and Fi to the “false” color. To assure that nodes in a given color class are the

same color, we introduce equality gadgets (Figure 4.1.a) between nodes Di and Dj for all

(i, j) ∈ E2kn where G2kn(V2kn, E2kn) is a (2kn,∆)-expander as in Lemma 2 (similarly for

the classes T and F ). To assure that nodes in distinct color classes have distinct colors, for

i = 1, . . . , 2kn we introduce triangles (Di, Ti), (Di, Fi), (Ti, Fi).

For each variable xi in f , we introduce 2k literal nodes x1i , . . . , x

ki , x

1i , . . . , x

ki . Lit-

eral nodes for a particular variable and sign should be colored identically, so we introduce

equality constraints between xji and xj′

i for all 1 ≤ i, j ≤ k with i 6= j (similarly for xji and

xj′i ). We fix some one-to-one correspondence between the literal nodes and the color class

26

nodes for each color class (we can do so since we have 2kn nodes in each color class). Since

literal nodes should be colored only with “true” or “false”, every literal node is connected to

its corresponding node Di. Since only one of xi, xi can be true, we introduce edges (xji , x

ji )

for all i, j. Finally, for each clause in f , we introduce a clause gadget (Figure 4.1.b) on the

literals appearing in the clause. We can do so in such a way that each literal node is used

in at most one clause gadget since we have k literal nodes for each literal, and each variable

appears in at most k clauses. Similarly, we can have each T node used in at most one

clause gadget, since the gadgets consume at most kn < 2kn T nodes. The clause gadget

allows any coloring of the literal nodes with “true” or “false” other than the coloring which

corresponds to an assignment where all literals are false (and the clause goes unsatisfied).

Theorem 22 The mapping ϕ is a gap-preserving local reduction from (3, k)SAT to 3-

coloring in bounded degree graphs. In particular, if f is a (δ, 1 − ε)-satisfiable (3, k)CNF

formula, then the graph ϕ(f) has degree bounded by some universal constant b and the

3-coloring CSP of ϕ(f) is (δ/bc, 1− ε/8)-satisfiable.

Proof It is clear by observation that the mapping ϕ always produces graphs bounded by

some constant degree b, and that there exists a constant c such that ϕ converts a (3, k)CNF

formula on n variables to a graph on at most cn nodes. Furthermore, one can answer

a query for an edge of ϕ(f) making at most one query into f , namely, for the clause in

which the queried edge is a part (if any). Write n′ for the number of nodes in ϕ(f), and

m′ < bn′ ≤ bcn for the number of edges.

Suppose that the original (3, k)CNF formula is (δ, 1 − ε)-satisfiable. Clearly any

subgraph of ϕ(f) induced by δn edges is 3-colorable – such a subgraph contains nodes

27

participating in at most δn clause gadgets, where we say that a node participates in a

clause gadget if it is contained in the clause gadget, or is a color class node corresponding

to a literal node contained in the clause gadget. By definition, there exists a boolean

assignment satisfying these δn clauses of f . The coloring which sets all color classes to their

intended colors and colors the literal nodes “true” or “false” as in this assignment satisfies

these δn > δbcm

′ 3-coloring constraints.

Note that if we delete γt edges from the expander graph Gt with γ ≤ 12 , then

there must remain a connected component of size at least (1− γ)t, for disconnecting a set

S of nodes with |S| ≤ 12 t requires at least |Γ(S)| edge deletions which, by the expansion

property, is at least |S|. Applying this to the equality gadgets between color class nodes,

we see that deletion of γ(2kn) edges leaves each color class with at least (1− γ)(2kn) color

class nodes in a connected component with equality constraints intact. Therefore, it leaves

at least (1− 3γ)(2kn) triples Di, Ti, Fii∈S such that the Di must be colored the same as

Dj for i, j ∈ S (similarly for Ti and Fi). The disconnected triples S participate in at most

2 · 3γ(2kn) clause gadgets. Furthermore, deleting γ(2kn) edges modifies constraints about

nodes participating in at most 2 ·γ(2kn) clauses of f . Summing up, deletion of γ(2kn) edges

leaves the 3-coloring construction for at least m − (2 · 3γ(2kn) + 2 · γ(2kn)) = m − 16γkn

clauses of f intact. If f is (δ, 1− ε)-satisfiable, then no coloring of the remaining graph can

be valid if m − 16γkn > (1 − ε)m or, equivalently, γ < ε16k . Changing notation so that

γ′m′ = γ(2kn) (ie we have deleted a fraction γ′ of the edges of ϕ(f) in the above discussion)

and noting that m′ > n, we get that ε16k > γ = γ′m′

2kn > γ′2k or γ′ < ε/8.

Combining the conclusions of the previous two paragraphs, we see that the graph

28

3-coloring problem ϕ(f) is (δ/bc, 1− ε/8)-satisfiable.

As immediate corollaries, we obtain the promised constructions for families of

3-coloring instances hard for one- and two-sided local algorithms.

Corollary 23 Let ϕ3CNF be the gap-preserving local reduction of Lemma 19, and ϕ3Col

that of Theorem 22. The (explictly constructed) set ϕ3Col(ϕ3CNF (fn))n is an infinite

family of bounded-degree graphs Gn on mn edges such that, for universal constants δ, ε > 0,

every subgraph induced by δmn edges is 3-colorable, but every 3-coloring of Gn has at least

εmn monochromatic edges.

Proof We need only note that the 3CNF formulas ϕ3CNF (fn)n are in fact (3, k)CNF

formulas. This is because the variable xi,j corresponding to edge (i, j) appears only in the

constraints around vertices i and j. In particular, if l is the number of clauses in a 3CNF

representation of the predicate h, then xi,j can appear in at most 2l clauses. The claim

then follows from Lemmas 20 and 21.

Corollary 24 There exist universal constants δ, ε, ∆ such that if A is a local algorithm

for deciding 3-colorability of degree ∆ graphs with distance parameter ε, then the query

complexity of A is at least δn, where n is the number of vertices.

Proof The canonical reduction from E3LIN2 to E3SAT is a gap-preserving local reduction

with c1 = c2 = 4. Apply this to the construction in Lemma 15 and compose with ϕ3Col.

29

Chapter 5

Locally decodable codes

In this chapter, we study linear codes C : 0, 1n → 0, 1m which have the

property that, for constants δ, ε > 0, any bit of the message can be recovered with probability

12+ε by an algorithm reading only 2 bits of a codeword corrupted in up to δm positions. Such

codes are known to be applicable to, among other things, the construction of scalable, fault-

tolerant data storage systems and the analysis of information-theoretically secure private

information retrieval schemes.

Unfortunately, we show in this work that such coding schemes cannot be space-

efficient. In particular, m must be at least exp(Ω (δn/(1− 2ε))).

The following construction, due to Trevisan, shows that this lower bound is optimal

within a constant factor in the exponent: Recall that the Hadamard code on x ∈ 0, 1n is

given by yi = ai · x where ai runs through all 2n vectors in 0, 1n. Hadamard codes are

locally decodable with 2 queries as, for any i ∈ 1, . . . , n and r ∈ 0, 1n,

xi = r · x + (r + ei) · x = ei · x

30

where ei is the ith canonical unit vector in 0, 1n. It is easy to see that the queries of this

decoder form perfect matchings on the n-dimensional hypercube, and the code has recovery

parameter ε = 12 − 2δ.

For given δ, ε, let c = 1−2ε4δ . It can be shown that for feasible values of δ, ε,

1 − 2ε ≥ 4δ so that c ≥ 1. We divide the input bits into c blocks of nc bits, and encode

each block with the Hadamard code on 0, 1nc . The resulting code has length 1−2ε

4δ 24δ

1−2εn

which is, say, less than 24.01 δ1−2ε

n for sufficiently large n. Finally, since each code block has

at most a fraction cδ of corrupt entries, the code achieves recovery parameter

12− 2cδ =

12− 2

(1− 2ε

4δ

)δ = ε

as required.

5.1 Background

Our results extend work by Goldreich, Karloff, Schulman, and Trevisan [GKST02],

who show that m must be at least exp(Ω(εδn)). Note that the prior bound does not grow

arbitrarily large as the error probability of the decoder goes to zero (ε → 12), as intuitively

it should; the results presented here have the correct qualitative behavior.

The key to our improved bounds is an analysis which bypasses an intermediate

reduction used in both prior works. The resulting improvement in the efficiency of the

overall analysis is sufficient to achieve a lower bound optimal within a constant factor in

the exponent.

31

Subsequent to the publication of this work in [Oba02], Kerenidis and de Wolf

[KdW03] applied quantum information techniques to obtain exponential lower bounds for

arbitrary locally decodable codes. We note that virtually all of the techniques presented

here can be carried over into the general case, the essential component in [KdW03] being the

use of the sub-additivity property of Von Neumann entropy to lower bound the dimension

of the space of codewords.

It remains an open problem to obtain strong lower bounds for locally decodable

codes with 3 or more queries. Such an analysis appears well beyond currently known

techniques.

Our work is structured as follows: In the remainder of this section, we briefly

review the definitions and techniques employed in [KT00] and [GKST02]. In Section 5.2,

we establish a relationship between the probability that an edge of a graph sampled from

any distribution intersects any vertex-subset of a given size, and the size of a maximum

matching in the graph. The analysis in this result seems independently interesting, and

may be applicable in other contexts. In Section 5.3, we show how the combination of this

result with the techniques of [GKST02] establishes lower bounds for this class of locally

decodable codes.

Locally decodable and smooth codes

Let Σ1, Σ2 be arbitrary finite alphabets. The following definition was introduced

in [KT00].

32

Definition 25 (Locally decodable code) For fixed constants δ, ε, q, a mapping

C : Σn1 → Σm

2

is a (q, δ, ε)-locally decodable code if there exists a probabilistic oracle machine A such that:

• A makes at most q queries (without loss of generality, A makes exactly q queries).

• For every x ∈ Σn1 , y ∈ Σm

2 with d(y,C(x)) ≤ δ, and i ∈ 1, . . . , n,

Pr (Ay(i) = xi) ≥ 1|Σ1| + ε

where the probability is over the randomness of A.

In this work, we consider codes C satisfying the above properties where, in addi-

tion, Σ1,Σ2 are fields and C is a linear mapping from Σn1 → Σm

2 . While all of our results

are applicable to finite fields in general, and some to non-linear codes, we will for simplicity

narrow our current discussion to linear codes on Z2. Also, while we have observed that our

results are equally applicable to reconstruction algorithms making queries adaptively, we

limit our comments in this abstract to algorithms making non-adaptive queries.

We begin by reviewing the techniques of [KT00] and [GKST02], which our results

build upon.

It was observed in [KT00] that a locally decodable code should have the property

that a decoding algorithm A reads from each location in the code word with roughly uniform

probability. This motivates the following definition.

33

Definition 26 (Smooth code) For fixed constants c, ε, q, a mapping

C : Σn1 → Σm

2

is a (q, c, ε)-smooth code if there exists a probabilistic oracle machine A such that:

• A makes at most q queries (without loss of generality, A makes exactly q queries).

• For every x ∈ Σn1 and i ∈ 1, . . . , n,

Pr(AC(x)(i) = xi

)≥ 1|Σ1| + ε.

• For every i ∈ 1, . . . , n, j ∈ 1, . . . ,m, the probability that on input i machine A

queries index j is at most c/m.

Intuitively, if a code is insufficiently smooth, so that a particular small subset

of indices is queried with too high a probability, then corrupting that subset causes the

decoding algorithm to fail with too high a probability. Thus, a locally decodable code must

have a certain smoothness. Specifically, [KT00] proved:

Theorem 27 If C : Σn1 → Σm

2 is a (q, δ, ε)-locally decodable code, then C is also a

(q, q/δ, ε)-smooth code.

The lower bounds for linear locally decodable codes in [GKST02] are proved by

establishing lower bounds for smooth codes. The result for locally decodable codes follows

by application of Theorem 27.

34

Smooth codes are closely related to the concept of information-theoretically secure

private information retrieval schemes introduced in [CGKS98]. Briefly, the idea in these

constructions is to allow a user to retrieve a value stored in a database in such a way that

the database server does not learn significant information about what value was queried.

It is easy to see that, in the information-theoretic setting, achieving privacy in this sense

with a single database server requires essentially that the entire database be transferred to

the user on any query. [CGKS98] showed, however, that by using 2 (non-colluding) servers,

one can achieve privacy in this sense with a single round of queries and communication

complexity O(n1/3). [KT00] observed that if one interprets the query bits sent to the

databases as indexes into a 2-query decodable code, then the smoothness parameter of a

code can be interpreted as a statistical indistinguishability condition in the corresponding

retrieval scheme. In this way, one can construct and analyze smooth codes, and therefore

locally decodable codes, from private information retrieval schemes and vice versa. We refer

the reader to [GKST02] for a detailed discussion.

The basic technique for proving lower bounds for smooth codes introduced in

[KT00] and extended in [GKST02] is to study, for each i ∈ 1, . . . , n, the recovery graph

Gi defined on vertex set 1, . . . , m where (q1, q2) is an edge of Gi iff for all x ∈ 0, 1n,

Pr(AC(x)(i) = xi|A queries (q1, q2)

)>

12.

Such edges are called good edges. Then, one shows a lower bound on the size of a maximum

matching in the recovery graphs Gi which is a function of the smoothness parameter of C:

35

Lemma 28 ([KT00], [GKST02]) If C is a (2, c, ε)-smooth code with recovery graphs

Gii then, for every i, Gi has a matching of size at least εm/c.

For linear smooth codes, it is easy to see that an edge (q1, q2) can be good for xi iff

xi is a linear combination of q1, q2. To simplify matters, one narrows the analysis to codes

in which these linear combinations are non-trivial:

Definition 29 (Normal code) A linear code C is normal if none of the entries in the

range of C is a scalar multiple of an input entry.

We can assume normality in smooth codes with only a constant factor modification

in length and recovery parameters:

Theorem 30 ([GKST02]) For n > 4c/ε, let C : 0, 1n → 0, 1m be a (q, c, ε)-smooth

code. Then there exists a (q, c, ε/2)-smooth code C′ : 0, 1n′ → 0, 1m′with n′ ≥ n/2,m′ ≤

m in which for all i ∈ 1, . . . , n′, j ∈ 1, . . . , m′, the j-th bit of C′(x) is not a scalar

multiple of xi.

Putting the pieces together, we have that a normal (2, c, ε)-smooth code has for

every i ∈ 1, . . . , n a recovery graph Gi containing a matching of size at least εm/c, and

for each of the edges (q1, q2) in this matching, xi is in the span of q1, q2, but is not a scalar

multiple of q1 or q2. Thus, the preconditions for the following key result of [GKST02] are

satisfied:

Lemma 31 Let q1, . . . , qm be linear functions on x1, . . . , xn ∈ 0, 1n such that for every

i ∈ 1, . . . , n there is a set Mi of at least γm disjoint pairs of indices j1, j2 such that

xi = qj1 + qj2. Then m ≥ 2γn.

36

Composing this with the normal reduction of Theorem 30, we have:

Theorem 32 ([GKST02]) Let C : 0, 1n → 0, 1m be a (2, c, ε)-smooth linear code.

Then m ≥ 2εn4c .

Finally, composing this with the locally decodable to smooth reduction, this says:

Theorem 33 ([GKST02]) Let C : 0, 1n → 0, 1m be a (2, δ, ε)-locally decodable linear

code. Then m ≥ 2εδn8 .

Note that Lemma 31 yields a lower bound which is exponential in the fraction of

vertices in 0, 1m covered by a matching in every recovery graph of the code. Thus, if we

can prove a tighter lower bound on the size of these matchings, then we get a corresponding

improvement in the exponent in the final lower bound. This is exactly the method used in

our work. In particular, we achieve an optimized bound on the size of the matchings in the

recovery graphs by bypassing the reduction to smooth codes and instead arguing directly

about locally decodable codes. The resulting direct reduction is strong enough to yield a

tight final lower bound.

5.2 Blocking game and matchings

In this section, we prove a combinatorial theorem regarding the relationship be-

tween the probability that an edge of a graph sampled from any distribution intersects any

vertex-subset of a given size, and the size of a maximum matching in the graph. We will

later see that this game captures completely the interplay between the encoder, decoder,

and channel adversary.

37

Let G(V, E) be an undirected graph on n vertices, w : E → R+ a probability

distribution on the edges of G, W the set of all such distributions, and S a subset of V .

Our concern in this section is to establish a bound on the following parameter of G based

on the size of a maximum matching in G:

Definition 34 (Blocking probability) Let Xw denote a random edge of G sampled ac-

cording to distribution w. Define the blocking probability βδ(G) as

βδ(G) = minw∈W

(max

S⊆V,|S|≤δnPr (Xw ∩ S 6= ∅)

).

One can think of βδ(G) as the value of a game in which the goal of the first

player (the decoding algorithm) is to sample an edge from G which avoids a vertex in a

δn-set selected by the second player (the channel adversary), whose goal is to maximize the

probability of blocking the edge selected by the first player.

Our goal is the following theorem:

Theorem 35 Let G be a graph with m(G) = (1− α)n. Then

βδ(G) ≥ min(

δ

1− α, 1

).

The key in the analysis is the following special family of graphs: For each n, α,

define the graph K(n, α) with vertex set

K1(n, α) ∪K2(n, α), |K1(n, α)| = αn, |K2(n, α)| = (1− α)n,

38

such that the edge set of K(n, α) is the union of the edge set of the complete bipartite graph

with bipartition (K1(n, α),K2(n, α)) and the (1− α)n-clique on K2(n, α).

Probabilistic proof of Theorem 35

We begin with a probabilistic proof of Theorem 35. This argument does not

characterize the optimal strategies for the blocking game, but is sufficient to prove our

ultimate result. In the next section, we give a derandomized analysis which explicitly

describes the optimal strategies.

Fix an arbitrary edge-distribution w on K(n, α) and, for δ < 1−α, select a subset

S of δn vertices of K2(n, α) uniformly at random. The resulting blocking probability β can

be written as a sum β =∑

e βe over edges e, where βe is a random variable with value we

if S intersects e, or 0 otherwise. By linearity of expectation,

E(β) =∑

e

E(βe) =∑

e

wePr (S ∩ e 6= ∅)

where the randomness is over the selection of the subset S. Clearly, S intersects each edge

e with probability at least δn(1−α)n = δ

1−α , so this expectation is at least

∑e

weδ

1− α=

δ

1− α

∑e

we =δ

1− α.

In particular, there must exist some subset S achieving this expectation, proving the theo-

rem.

39

Explicit proof of Theorem 35

We now give a longer, but explicit, proof of Theorem 35 which describes the

optimal strategy for any decoder subject to a given lower bound on the matching number

of G.

For a graph G, the independence number α(G) of G is the size of a maximum

independent set of vertices in G, and the matching number m(G) of G is the number of

vertices in a maximum matching in G (note that this definition differs from the standard

one by a factor of 2). We begin our analysis by observing that n−m(G) is a lower bound on

α(G). We then define a relaxation of the optimization problem for the blocking probability

on graphs with a given independence number. For this relaxed problem, we define a special

family of distributions and show that some distribution in this family optimizes the blocking

probability. Finally, we exhibit a lower bound on the blocking probability of a particular

set of δn vertices with respect to any distribution in this family of distributions.

Lemma 36 Let G be a graph with m(G) = (1− α)n. Then

βδ(G) ≥ βδ(K(n, α)).

Proof We begin by noting that α(G) ≥ n−m(g). To see this, fix any maximum matching

in G. The n−m(g) vertices left uncovered in this matching must be an independent set, for

an edge between any of these vertices would allow us to increase the size of the matching

by at least one.

By the assumption on m(G), then, we have α(G) ≥ αn. With a labeling of vertices

40

of K(n, α) which sets K1(n, α) to an arbitrary αn-subset of S, it is easy to see that the

edge set of K(n, α) contains the edge set of G. Therefore, the optimization of w on K(n, α)

is a relaxation of the optimization of w on G (a distribution w on G can be expressed as a

distribution w′ on K(n, α) in which any edge of K(n, α) not in G has probability 0). The

claim follows.

We will focus on the following special class of distributions on K(n, α) and show

that the blocking probability of K(n, α) is always optimized by some distribution in this

class:

Definition 37 ((λ1, λ2)-Symmetric Distribution) An edge distribution w on the graph

K(n, α) is (λ1, λ2)-symmetric if for every edge e ∈ (K1(n, α), K2(n, α)), w(e) = λ1, and for

every edge e ∈ (K2(n, α),K2(n, α)), w(e) = λ2.

Lemma 38 Let w1, . . . , wk be edge distributions on G such that

maxS⊆V,|S|≤δn

Pr (Xwi ∩ S 6= ∅) = βδ(G).

Then for any convex combination of the distributions w =∑

i γiwi,

maxS⊆V,|S|≤δn

Pr (Xw ∩ S 6= ∅) = βδ(G).

Proof For every S ⊆ V ,

Pr (Xw ∩ S 6= ∅) =∑

i

γiPr (Xwi ∩ S 6= ∅)

41

since this is simply the sum over edge weights of edges of G incident to S. By the condition

on the wi, for any subset S with |S| ≤ δn,

Pr (Xw ∩ S 6= ∅) ≤∑

i

γiβδ(G)

= βδ(G)∑

i

γi

= βδ(G).

Therefore,

maxS⊆V,|S|≤δn

Pr (Xw ∩ S 6= ∅) ≤ βδ(G).

However, by definition of βδ(G), this must be at least βδ(G). Therefore,

maxS⊆V,|S|≤δn

Pr (Xw ∩ S 6= ∅) = βδ(G).

Recall that the automorphism group of a graph G is the set of permutations π on

the vertices of G such that (π(i), π(j)) ∈ E ⇐⇒ (i, j) ∈ E. Let Γ be the automorphism

group of K(n, α).

Lemma 39 There exists a (λ1, λ2)-symmetric distribution w such that

maxS⊆V,|S|≤δn

Pr (Xw ∩ S 6= ∅) = βδ(K(n, α)).

Proof Let w′ be any distribution which optimizes the blocking probability of K(n, α). It

is obvious that if w′ is such a distribution, then so is π(w′) for π ∈ Γ (where we extend the

42

action of Γ to the edges of G in the natural way). By Lemma 38, the distribution

w =1|Γ|

∑

π∈Γ

π(w′)

optimizes the blocking probability of K(n, α). We claim that w is a (λ1, λ2)-symmetric

distribution: For any edge e ∈ E and σ ∈ Γ,

w(e) =1|Γ|

∑

π∈Γ

w′(π(e))

=1|Γ|

∑

π∈Γ

w′(πσ(e))

= w(σ(e))

where the second step is the usual group-theoretic trick of permuting terms in summations

over Γ. Therefore, if e, e′ ∈ E are in the same orbit under the action of Γ, w(e) = w(e′).

It is easy to verify that Γ is the direct product of the group of permutations of the vertices

of K1(n, α) and K2(n, α), and so there are exactly two edge-orbits of K(n, α) under Γ,

one consisting of the edges (K1(n, α),K2(n, α)) and the other (K2(n, α),K2(n, α)). This is

exactly the condition for a (λ1, λ2)-symmetric distribution.

Finally, we need to compute a lower bound on the blocking probability for a

(λ1, λ2)-symmetric distribution:

Lemma 40 Let w be a (λ1, λ2)-symmetric distribution on K(n, α). Then there exists a

43

subset S ⊆ V with |S| ≤ δn such that

Pr (Xw ∩ S 6= ∅) ≥ min(

δ

1− α, 1

).

Proof We will study a blocking set which selects any δn vertices of K2(n, α). Note that,

by (λ1, λ2)-symmetry, it does not matter which δn vertices we select. Further, we can

assume that δ < 1 − α, for if δ ≥ 1 − α we can cover all of K2(n, α) and thereby achieve

blocking probability 1.

Placing a blocking set in this manner and summing up over edges and weights, we

achieve blocking probability

(δn)(αn)λ1 +12(δn)(δn− 1)λ2 + (δn)(1− α− δ)nλ2.

Since w is a probability distribution, we must have

(αn)(1− α)nλ1 +12(1− α)n ((1− α)n− 1)λ2 = 1.

Using this to eliminate λ1 from the first expression, we obtain blocking probability

δ

(1

1− α+

12n2(1− α− δ)λ2

).

Since δ < 1 − α, the second term in the sum is positive (and, obviously, optimized when

λ2 = 0), so the blocking probability must be at least δ1−α .

It is now easy to prove Theorem 35.

44

By Lemma 36, βδ(G) ≥ βδ(K(n, α)). By Lemma 39, the blocking probability

of K(n, α) is optimized by some (λ1, λ2)-symmetric distribution. By Lemma 40, there

exists a subset of δn vertices which blocks any such distribution with probability at least

min(

δ1−α , 1

). Therefore,

βδ(G) ≥ βδ(K(n, α)) ≥ min(

δ

1− α, 1

).

5.3 Lower bounds

In this section, we apply Theorem 35 to our original problem of finding lower

bounds for locally decodable linear codes.

To simplify our analysis, we would again like to put the decoder into a canonical

normal form in which the decoder simply outputs the sum of two distinct input bits. The

following shows that we may make this assumption without loss of generality.

Lemma 41 Let C : 0, 1n → 0, 1m be a (2, δ, ε)-locally decodable linear code where n

is large enough so that 2(n+1)2n ≤ δ/201. Then there exists a normal (2, δ/2.01, ε)-locally

decodable linear code C′ : 0, 1n → 0, 12m.

Proof Write the ith entry yi of the codeword as yi = ai · x where ai ∈ 0, 1n. A

straightforward probabilistic argument shows that there exists a vector r ∈ 0, 1n such

that the Hamming weights of r and ai + r are at least 2 for a fraction at least(1− 2(n+1)

2n

)

of the yi. Let S be the set of yi satisfying this property. Note that for yi ∈ S, (ai + r) · x is

a not a scalar multiple of an input entry. We form a normal code C′ : 0, 1n → 0, 12m

from C by setting y′i = (ai + r) · x for yi ∈ S, y′i = (1, . . . , 1) · x for all other indices, and

45

adding a set of m codeword bits y′′i = r · x for all i ∈ 1, . . . , m.

We claim that C′ is a (2, δ/2.01, ε)-locally decodable code. Let A be a recovery

algorithm for C, and recall that an edge for A can be good only if the answer of A is a

linear combination of the entries it queries. Without loss of generality, we can assume that

A only queries good edges (otherwise, we can ignore the answers to the queries and output

a random coin flip). We implement a recovery algorithm A′ for C′ as follows: If A takes

a non-trivial linear combination of queries yi, yj , then A′ simulates A but executes queries

y′i, y′j ; if A is the identity on a query yi, then A′ makes queries y′i, y

′′i and takes the (non-

trivial) linear combination y′i + y′′i , which for i ∈ S equals (ai + r) · x + r · x = ai · x = yi.

Finally, we note that if at most δ/2.01 entries of a codeword of C′ are corrupted, then A′

exactly simulates the behavior of A when interacting with some code word with at most

δ

2.012m + |S| ≤ 200

201δm +

2(n + 1)2n

m ≤ 200201

δm +1

201δm = δm

corrupt entries. By the decoding condition on A, A′ succeeds with probability at least 12 +ε.

Therefore, we can essentially assume that we are working with a normal decoder.

We are now prepared to prove our lower bound.

Theorem 42 Let C : 0, 1n → 0, 1m be a (q, δ, ε)-locally decodable linear code for 0 <

δ, ε < 12 . Then for sufficiently large n, m ≥ 2

14.03

δ1−2ε

n.

Proof By Lemma 41, for sufficiently large n, the existence of C implies the existence of

a normal (2, δ/2.01, ε)-locally decodable code C′ : 0, 1n → 0, 12m. As before, we can

46

assume that the recovery algorithm A′ for C′ only queries good edges. On one hand, for all

i ∈ 1, . . . , n and y ∈ 0, 12m such that d(y,C′(x)) ≤ δ2.01(2m),

Pr(A′y(i) 6= xi

) ≤ 12− ε.

On the other, if (1−α)(2m) is the maximum over all i ∈ 1, . . . , n of the matching number

of the recovery graph Gi of A′, then

Pr(A′y(i) 6= xi

) ≥ 12

δ/2.011− α

for, by Theorem 35, there exists a fraction δ/2.01 of vertices S such that an adversary which

sets the values of S to random coin flips causes A′ to read a blocked edge, and therefore

have probability 12 of outputting an incorrect response, with probability at least δ/2.01

1−α .

Therefore,

12

δ/2.011− α

≤ 12− ε =⇒ α ≤ 1− δ/2.01

1− 2ε

which is equivalent to saying that there exists for all i ∈ 1, . . . , n a set of at least

12

δ/2.011−2ε (2m) disjoint pairs of indices j1, j2 such that xi = qj1 + qj2 . Then by Lemma 31,

2m ≥ 212

δ/2.011−2ε

n or m ≥ 21

4.02δ

1−2εn−1 which is at least, say, 2

14.03

δ1−2ε

n for sufficiently large n.

47

Chapter 6

Integral flows

We saw in Chapter 3 that integral flow systems can be applied to establish lower

bounds for local computations. We now approach this relationship from the opposite direc-

tion; that is, starting with the notion of approximation used in local computational models,

we derive new algorithms for multicommodity integral flow and max-integral-flow/min-

multicut duality relationships. This yields new approaches to classical combinatorial opti-

mization problems and insights into the behavior of the classic Edmonds-Karp algorithm

in the multicommodiy setting.

The results in this chapter appeared previously in [Oba04].

6.1 Background

A classic theorem of Ford and Fulkerson asserts that the maximum flow between

two vertices in a graph equals the weight of a minimum cut separating the two vertices

[FF56]. This flow/cut duality further enjoys a beautiful integrality property: If the capacities

48

of the edges of G are integers, then there exists an integral flow achieving the weight of the

minimum cut. Integrality is often a necessary or desirable property in applications. In

this chapter, we consider corresponding integrality results in the setting of multicommodity

flows.

Unfortunately, the analogous equality does not generally hold in the multicom-

modity setting. However, in a body of work initiated by Leighton and Rao ([LR99, PT93,

GVY93, KPR93, AR98, LLR95] and others), a number of approximate max-flow/min-cut

relations have been established. All of these results differ in a fundamental way from the

Ford-Fulkerson theorem in that they are based on dual rounding procedures. This approach

loses the guarantee of primal integrality and, indeed, the integrality gap for multicommodity

flows can be Ω(k), where k is the number of commodities.

In this chapter, we establish several approximate max-integral-flow/min-multicut

theorems. While in general this ratio can be trivially large, we prove strong approximation

ratios in the case where the min-multicut is a constant fraction ε of the total capacity of

the graph. This setting is motivated by several combinatorial and algorithmic applications.

Prior to this work, a general max-integral-flow/min-multicut bound was known only for the

special case where the graph is a tree [GVY97].

Our proofs are constructive in the sense that we give efficient algorithms which

compute either an integral flow achieving the claimed approximation ratios, or a witness

that the precondition is violated.

The main goal in this chapter shall be the following max-integral-flow/min-multicut

approximation theorem.

49

Theorem 43 Let G(V, E) be a graph with capacity function c : E → Z+, and K be a

demand graph on a k-element subset of V such that the weight of any multicut separating

all pairs of vertices (k1, k2) ∈ K is at least εC, where C =∑

e∈E c(e). Then

(i) The max-integral-flow/min-multicut ratio is O(ε−1 log k). If k∗ is the vertex cover

number of K, the ratio is improved to O(ε−1 log k∗).

(ii) If, for some constant r, G does not contain Kr,r as a minor (for instance, if G is

planar), then the ratio is improved to O(1/ε).

(iii) If c ∈ 0, 1E and G is δ-dense for some δ > 0, then the ratio is improved to O(1/√

εδ).

The proof of Theorem 43, as in previous work in this area, depends on efficient

low-radius decompositions in a graph metric. Prior to this work, the traditional approach

has been to decompose G using the metric induced by the minimum solution to the dual of

the maximum flow problem; the approximation ratio then follows by the strong duality the-

orem. The fundamental difference here is that G is decomposed according to the unweighted

distance metric on G, and this is used to construct a large primal solution; the ratio follows

by the promised lower bound on the minimum multicut. Two of the decompositions we use

are standard in the multicommodity flow literature; the third is a “new” one. The details

are discussed in Section 6.2.

The approximate max-integral-flow algorithm works roughly as follows: For a given

family of graphs (general, planar, dense, etc.), we define a “greed” function g(t) which is an

increasing function of time t. At time t, the algorithm greedily increases the primal value by

pushing a unit of flow along a path of length at most g(t). If this can repeated for sufficiently

50

many iterations then we are done. Otherwise, the algorithm constructs a witness multicut

by combining both primal and dual information. The details are presented in Section 6.3.

Section 6.4 describes some algorithmic and combinatorial applications of Theorem 43.

Definitions and notation

Throughout this chapter, G(V,E) denotes a simple, undirected graph, c : E →

Z+ denotes a Z+-valued capacity function on the edges of G, and K denotes a simple,

undirected, unweighted graph defined on a vertex-subset of V . A K-path in G is a simple

path in G between k1, k2 where (k1, k2) ∈ E(K), a K-cut is an edge-subset F ⊆ E such that

G \ F has no K-path, and a K-partition is a disjoint system of vertex-subsets (S1, . . . , St)

such that each k ∈ K is in some Si.

By the characteristic vector of a simple path P , we mean the vector in ZE which

is 1 on edges e ∈ P and 0 otherwise. A set p1, . . . , pt of characteristic vectors of K-paths

along with positive weights w1, . . . , wt is called a K-flow with respect to a capacity function

c when v =∑

i wipi is such that v(e) ≤ c(e) for all edges e. The weight of a K-flow is

the sum∑

wi of all path weights. By a maximum flow, we mean a K-flow with maximum

weight among all K-flows. A flow is integral when the all path weights wi are integer-valued.

A maximum integral flow is a flow with maximum weight among all integral K-flows.

Often, we identify c with the graph formed by including edges for which c is

non-zero. When G(V, E) is understood, we write (S1, S2) to denote the subset of edges

with one endpoint in S1 and the other in S2, where Si ⊆ V . For F ⊆ E, we define

c(F ) =∑

e∈F c(e), and for W ⊆ V, c(W ) = c((W,W )). If S ⊆ V , we write ∇(S) = (S, V \S)

and ∇(S1, . . . , St) =⋃

i∇(Si). For a capacity function c, ∇c(S) denotes the capacity

51

function which equals c on ∇(S)∩ e : c(e) > 0 and is zero elsewhere. By the norm ‖c‖ of

c we mean ‖c‖1 =∑

e c(e).

We use d(v1, v2) to denote the distance between vertices v1 and v2, B(v, ρ) = w ∈

V | d(v, w) ≤ ρ to denote the closed ball of radius ρ around v and B(v, ρ) = w ∈

V | d(v, w) = ρ to denote its boundary. The diameter diam(S) = maxvi,vj∈S d(vi, vj) and

the radius ρ(S) = 12diam(S). The radius of a K-partition (S1, . . . , St) is the maximum over

i of ρ(Si).

6.2 Three graph decompositions

The proof of Theorem 43 depends critically on low-radius decompositions of graphs.

In this section, we discuss three such decompositions, each of which correspond to the three

cases described in Theorem 43. The first is generic but gives the weakest bounds; the latter

two apply only to specialized cases, but give much stronger results. The first two have been

used previously to establish max-flow/min-multicut approximation ratios, while the third

one is “new” (the algorithm was used earlier, but we re-cast it in the more general setting

of multicommodity flows and provide a new analysis).

For all ρ ≥ 0 and families G of Z+-valued edge-functions on graphs, define

fG,k(ρ) = maxc∈G,C>0

K⊆V,|K|≤k

1C

(min

(S1,...,St)∈PρK

c (∇(S1, . . . , St))

)

where PρK denotes the set of all K-partitionings of V of radius ρ. For brevity, we will omit

the parameter k. Note that, for any G, fG(ρ) is monotonically decreasing in ρ since, for

ρ′ > ρ, a radius ρ decomposition is also a radius ρ′ decomposition. Each of the following

52

decompositions gives an algorithmic upper bound on fG(ρ) for particular values of G.

General graphs

We begin with the most generic decomposition algorithm, which is applicable to

arbitrary graphs. The essential idea behind this decomposition was introduced by Leighton

and Rao in their original work [LR99]. The version which follows is the special case of

a subsequent refinement by Garg, Vazirani, and Yannakakis [GVY93] in which the dual

variables are fixed to (1, . . . , 1).

Garg-Vazirani-Yannakakis Decomposition: Let α > 0 be a parameter, to

be selected later. While there exists any terminal vertex v in G repeat the following: Set

v ← an arbitrary terminal vertex in G, t ← 0; while c(∇(B(v, t))) + Ck > αc(B(v, t)), set

t ← t + 1; output B(v, t) and set G ← G \ B(v, t). The set of output subsets gives a

K-partition of V .

Lemma 44 Let S1, . . . , St denote the K-partition produced by the Garg-Vazirani-Yannakakis

algorithm with parameter α. Then

ρ(Si) ≤ ln(k + 1)α

and c(∇(S1, . . . , St)) ≤ 2αC.

Proof Apply Lemmas 4.1 and 4.2 from [GVY93] in the special case where the dual

variables are set to (1, . . . , 1).

53

Corollary 45 Let G∗ denote the set of all Z+-valued capacity functions. Then

fG∗(ρ) ≤ 2 ln(k + 1)ρ

.

Proof Set α = ln(k+1)ρ . Then ρ(Si) ≤ ρ and c(∇(S1, . . . , St)) ≤ 2 ln(k+1)

ρ C.

Graphs excluding Kr,r

We now consider the special case of graphs excluding a fixed minor. (For instance,

by the weak direction of Kuratowski’s Theorem, this includes the family of planar graphs.)

An ingenuous decomposition algorithm for this setting was designed by Klein, Plotkin, and

Rao [KPR93]. The version below is a variant in which, as before, we fix the input dual

variables to (1, . . . , 1). We also scan along possible cut points to assure the cut weight on

each iteration is at most a fixed fraction of the total capacity.

Klein-Plotkin-Rao Decomposition: Let α > 0 be a parameter, to be selected

later, and let r be such that Kr,r does not occur as a minor of G. While G is non-empty,

repeat the following: Set v ← an arbitrary vertex in G and t ← a value from 0, . . . , α− 1

to be selected later; for i = 1, . . . , n let Gi =⋃

q∈RiB(v, q) where Ri is the ith set in the

sequence [0, t), [t, t + α), [t + α, t + 2α), . . ., and recurse on Gi to a maximum depth r. For

each level of the recursion, select a value t such that the weight of the edges cut at that

level is ≤ C/α (such a value must exist because the cuts induced by each possible selection

of t partition E into α classes). Interpret the set of regions at the bottom of the recursion

as a vertex-partition of G, disregarding empty regions.

54

Lemma 46 Suppose that G does not contain Kr,r as a minor and let S1, . . . , St denote the

partition produced by the Klein-Plotkin-Rao algorithm. Then

ρ(Si) ≤ 2r2α and c (∇(S1, . . . , St)) ≤ r

αC.

Proof In [KPR93], it is proved that ρ(Si) ≤ 2r2α. By the selection of t, we introduce a

cut of weight at most C/α at each level of the recursion. Since the recursion has depth at

most r, the resulting cut must have weight at most rαC.

Corollary 47 Let Gr,r denote the set of Z+-valued capacity functions on graphs excluding

Kr,r. Then

fGr,r(ρ) ≤ 2r3

ρ.

Proof Set α = ρ2r2 . Then ρ(Si) ≤ ρ and c (∇(S1, . . . , St)) ≤ 2r3

ρ C.

Dense graphs

For a fixed constant 0 < δ ≤ 1, an unweighted graph is called δ-dense if |E| ≥ δn2.

In other words, a graph is dense when a constant fraction of all possible edges are included

in the graph. We achieve our tightest bounds when the capacity function c is 0-1-valued

and G is δ-dense.

We use a technique due to Komlos which was originally introduced to prove tight

bounds on the size of a minimum edge-set intersecting all odd cycles in a graph. We observe

that this method is applicable in the more general context of multicommodity flows. We

also provide a new and simpler proof of Komlos’ result.

55

Komlos Decomposition: Let α > 0 be a parameter, to be selected later. While

G is non-empty, repeat the following: Set v ← an arbitrary vertex in G, t ← 0; while

|B(v, t)||B(v, t + 1)| > α|B(v,∞)||B(v, t)| set t ← t + 1; output B(v, t) and set G ←

G \B(v, t). The set of output sets gives a partitioning of V .

Lemma 48 Let G be a δ-dense graph, and let S1, . . . , St denote the vertex-partition pro-

duced by the Komlos algorithm. If c ∈ 0, 1E, then

ρ(Si) ≤ 12√α

and c (∇(S1, . . . , St)) ≤ αC

δ.

(In [Kom97], Komlos achieves the better constant√

2e in place of 12, although our constant

is not optimized.)

Proof For brevity, set bi = |B(v, i)| and Bi = |B(v, i)|, so that Bi =∑

0≤j≤i bj . The

stopping rule requires that the sequence bi satisfy bibi+1 > αnBi. Then, for each i,

at least one of bi, bi+1 must be at least√

αnBi. So, consider alternating entries of Bi,

B′j = B2j+1. Then the sequence B′

j satisfies the recurrence

B′0 ≥ αn ; B′

j+1 ≥ B′j +

√αnB′

j .

We claim that B′j ≥ αn

9 j2. This is verified by observation for j = 0, 1. For larger j, induction

shows that

B′j+1 ≥

αn

9j2 +

√αn

αn

9j2 =

αn

9j2 +

αn

3j ≥ αn

9(j + 1)2

56

when j ≥ 1. Then for odd i,

Bi ≥ αn

9

(i− 1

2

)2

so for i ≥ 2,

Bi ≥ αn

9

(i− 2

2

)2

=αn

36(i− 2)2

and (crudely), since i− 2 ≥ i2 for i ≥ 4 and by inspection for i = 0, . . . , 3, for any i,

Bi ≥ αn

36

(i

2

)2

=αn

144i2.

But Bi ≤ n which implies that the maximum possible index i in such a sequence,

which is also the maximum possible radius in a region, is at most√

144α = 12√

α.

For the second part of the lemma, notice that the stopping rule implies that

c(∇(Si)) ≤ α|Si|n. Then

c(∇(S1, . . . , St)) ≤∑

i

c(∇(Si)) ≤∑

i

α|Si|n ≤ αn2 ≤ αC/δ.

Corollary 49 Let Gδ denote the set of δ-dense graphs with capacity functions c ∈ 0, 1E.

Then

fGδ(ρ) ≤ 144δρ2

.

Proof Set α = 144ρ2 . Then ρ(Si) ≤ ρ and c(∇(S1, . . . , St)) ≤ 144

δρ2 C.

57

6.3 Max-integral-flow/min-multicut approximation ratios

In this section, we apply the low-radius decompositions of Section 6.2 to prove our

approximate max-integral-flow/min-multicut theorems. In fact, we show that there exist

efficient algorithms which, given a lower bound on the weight of a min-multicut, either

construct an integral flow achieving the claimed approximation ratio, or output a proof

that the promise is violated in the form of a multicut with weight less than the asserted

lower bound.

Proof of Theorem 43

Suppose we have an efficiently computable upper bound f∗G(ρ) ≥ fG(ρ) on f (from

this point, we omit the subscript G). Without loss of generality, we may assume f∗ is

monotonically decreasing in ρ. For all ε > 0, define

g(ε) = minf∗(ρ)<ε

2ρ

where g(ε) is defined as∞ if no such ρ exists. Note that g(ε) is also monotonically decreasing

in ε and that h can be efficiently constructed using O(n) invocations of f∗.

Theorem 43 is proved using the following integral flow algorithm.

58

Approximate Max-Integral-Flow:

set ε0 ← ε, v0 ← (0, . . . , 0), c0 ← c

for t = 0, . . . ,∞

if εt ≤ 0 set F ∗ ← t and break

set εt+1 ← εt − g(εt)/C

for t = 0, . . . ,∞

if ∃ kj ∈ Bct(ki, g(εt)) for some (ki, kj) ∈ K

set pt ← characteristic vector of any path of length ≤ g(εt) from ki → kj

set vt+1 ← vt + pt, ct+1 ← ct − pt

else break

if t ≥ F ∗

output vt and accept

else

set m ← ∇ct(S1, . . . , Sl) s.t. ρct(Si) ≤ 12g(εt) and ct(∇(S1, . . . , Sl)) < εtC

output W = e ∈ E | [vt + m](e) = c(e), c(e) > 0 and reject

We claim that if the weight of a minimum K-cut of G is εC, then the algorithm

produces a flow of weight F ∗ on input ε.

Assuming this for a moment, it is immediate that the max-integral-flow/min-

multicut ratio is bounded by εC/F ∗ and so, to complete the proof of Theorem 43, we

need only compute estimates of F ∗ given the functions f∗G∗ , f∗Gr,r , f∗Gδ from Section 6.2. The

following lemma states appropriate estimates.

59

Lemma 50 Let F ∗G(ε) denote the value of F ∗ computed using function f∗G for density ε.

Then we have the following bounds:

(i) F ∗G∗(ε) ≥ ε2

16 ln(k+1)C

(ii) F ∗Gr,r(ε) ≥ ε2

16r2 C

(iii) F ∗Gδ(ε) ≥ ε3/2δ1/2

48√

2C

Proof In each case, the bound follows easily by applying the estimates in Section 6.2 to

upper bound the radius ρ∗ of a decomposition inducing a multicut of weight at most εC/2.

The number of iterations F ∗ must then be at least εC/4ρ∗.

(A factor of 2 improvement is possible by iterating this procedure over radii of at

all orders of magnitude.)

The asserted approximation ratios follow immediately from Lemma 50. We now

prove the claim. Because the inner loop of the algorithm is an augmenting path process,

the algorithm clearly produces an integral flow of weight t∗, where t∗ is the last value of t

reached in the main loop. Therefore, it is enough to show that, when the algorithm rejects,

the algorithm outputs a K-cut of weight less than εC.

We begin by showing that W is a K-cut; that is, W intersects every K-path. There

are two cases. First, we observe that every K-path in ct∗ intersects m. By the loop condition,

there is no K-path in ct∗ of length ≤ g(εt∗). Let (S1, . . . , St) be any K-partitioning of V with

ct∗-radius ≤ 12g(εt∗). If p is a K-path in ct∗ which does not intersect ∇ct∗ (S1, . . . , St) then

the entire path must lie in the same partition Si. But diamct∗ (Si) ≤ 2ρct∗ (Si) ≤ g(εt∗).

Contradiction. Further, each edge e ∈ m is also in W since m(e) = ct∗(e) implies that

60

[m + vt∗ ](e) = [ct∗ + vt∗ ](e) = c(e). Second, we consider a K-path p such that p intersects

an edge e ∈ c but 6∈ ct∗ . Then c(e) = ct∗(e) + vt∗(e) = vt∗(e), so e ∈ W and p intersects W .

We next need to bound c(W ). Clearly, c(W ) ≤ ‖m‖ + ‖vt∗‖. When t∗ < F ∗,

εt∗ > 0 and, since ‖pi‖ ≤ g(εi) for all i, ‖vt∗‖ =∑

j=0,...,t∗−1 ‖pi‖ ≤∑

j=0,...,t∗−1 g(εj) =

(ε − εt∗)C. By definition of f∗ and g, the K-cut ∇ct∗ (S1, . . . , St) giving m exists (and,

as in our case when the bounds on f∗ are algorithmic, can be efficiently computed) and

has ‖m‖ = ct∗(∇(S1, . . . , St)) ≤ f∗(12g(εt∗))‖ct∗‖ < εt∗‖ct∗‖ ≤ εt∗C. Summing these,

c(W ) < (ε− εt∗)C + εt∗C = εC.

To prove the claim concerning vertex covers in case (i), note that, as observed by

Gunluk [Gun02] for the case of the fractional max-flow/min-multicut approximation ratio, it

is sufficient to seed the partition selection step in the Garg-Vazirani-Yannakakis algorithm

using a vertex cover K∗ of K rather than the entire vertex set of K. The proof of the

flow/cut approximation bound carries through in this case as well, since a K∗-partitioning

is sufficient to intersect every sufficiently long shortest path between vertex-pairs in K.

Thus, if k∗ is the size of a minimum vertex cover of K, the approximation ratio is improved

to O(ε−1 log k∗). In an extreme case, for instance a star graph, k = O(n) while setting K∗

to the center vertex of the star gives k∗ = 1.

It still remains to remove the assumption that we give the algorithm as input the

weight εC of a min-multicut of G. Since g(εt) is an increasing function in t, we can remove

the computation of the sequence εi altogether and replace the augmentation loop with a

pure greedy algorithm; that is, while there exists a path between any two vertex-pairs of K

in ct, push one unit of flow along the shortest such path. This variant clearly produces at

61

least as large a flow as the original algorithm on any input ε, in particular the true value of

ε. However, this version, as with the original, runs in time only weakly polynomial in the

input size. This is easily corrected by modifying the greedy algorithm to push mine∈p ct(e)

units of flow along the path p selected on each iteration. Then clearly there can be at most

O(|E|) augmentation steps.

6.4 Related applications

In this section, we observe that the proof of Theorem 43 yields efficient approxi-

mation algorithms for maximum integral and fractional multicommodity flow and related

problems. We also observe some natural but less obvious combinatorial applications.

Approximation algorithms for flow and edge-disjoint path problems

In traditional applications of multicommodity max-flow/min-cut inequalities, the

maximum flow problem is polynomial-time computable (via polynomial-time linear pro-

gramming algorithms) while the corresponding cut problem is NP-hard. However, in the

integral case, both the flow [GVY97] and cut [DJP+94] problems are NP-hard. In the case

where the min-multicut has weight at least εC, the approximate maximum integral flow

algorithm used to prove Theorem 43 and the weak duality relations give the following.

Corollary 51 Let G be a graph with Z+-valued capacity function c, and K be a demand

graph on a k-element subset of V such that the weight of any multicut separating all pairs

of vertices (k1, k2) ∈ K is at least εC. Then

(i) There is a polynomial-time algorithm which constructs an integral flow within a factor

62

O(ε−1 log k) of the optimum. If k∗ is the vertex cover number of K, the ratio is

improved to O(ε−1 log k∗).

(ii) If G excludes Kr,r for some constant r, the ratio is improved to O(1/ε).

(iii) If c ∈ 0, 1E and G is δ-dense, the ratio is improved to O(1/√

εδ).

A natural variation on the above is to apply scaling methods to recast the general

(fractional) multicommodity flow problem as an integral flow problem. That is, fix some

large integer Q and, for a non-negative real-valued capacity function c, let c′(e) = bc(e)Qc.

If v′ is an integral flow in c′, then v′/Q is a feasible (possibly fractional) flow in c. Further,

the scaling distorts the relative weight ε of the minimum cut and the original capacity

function by a factor which goes to 1 as Q →∞.

Given a fractional capacity function c, consider the following greedy heuristic for

the maximum multicommodity flow problem: Select a shortest K-path in G and push as

much flow as possible along the path until it is saturated; repeat until there are no K-paths

remaining.

Corollary 52 Let G be a graph with a non-negative real-valued capacity function c, and

let ε, k∗ be as above. Then the greedy heuristic constructs a flow of weight within a factor

O(ε−1 log k∗) of the optimum. If G excludes Kr,r for some constant r, then the factor is

improved to O(ε−1).

Proof It is easy to see that the greedy heuristic corresponds to the pure greedy variant of

the approximate max-integral-flow algorithm above when Q is an arbitrarily large integer.

63

Note that we cannot apply scaling techniques to the family of δ-dense graphs.

Unconditional versions of these approximation ratios were already known [GVY93, Gun02,

KPR93], but it is interesting that the greedy heuristic constructs a flow achieving these

ratios when the min-multicut has constant density.

Integral flows are closely related to edge-disjoint paths in unweighted graphs. The

problem of connecting a maximum number of endpoints in K along edge-disjoint paths was

one of the original NP-hard problems [Kar72]. The following consequence of Theorem 43

will be used later.

Corollary 53 Let G be an unweighted graph with m edges and maximum degree ∆ such

that at least εm edges must be removed to separate all vertex-pairs in K. Then

(i) Ω(ε2m/∆log k

)vertex-pairs in K can be connected along mutually edge-disjoint paths,

and these paths can be computed in polynomial time.

(ii) If G excludes Kr,r for some constant r, then the same is true for Ω(ε2m/∆

)pairs.

(iii) If G is δ-dense, then the same is true for Ω(ε3/2δ1/2m/∆

)pairs.

Proof Edge-disjoint paths in an unweighted graph are equivalent to the special case of

integral flow where edge capacities are 0-1-valued. If G has maximum degree ∆, then at

most ∆ routed paths between a pair (k1, k2) in a K-flow can correspond to a single terminal

pair.

64

Intersecting odd cycles

Let G be an unweighted graph, and let og(G) denote the odd girth of G, that is,

the length of the shortest odd cycle in G. In [BESS78], Bollobas, Erdos, Simonovits, and

Szemeredi considered the problem of determining the minimum cardinality of an edge-subset

F ⊂ E such that F intersects every odd cycle in G. They showed that |F | = O(n2/og(G)

)

and conjectured that |F | = Θ(n2/og2(G)

). This conjecture was proved by Komlos [Kom97]

using the eponymous decomposition in Section 6.2.

It turns out that odd cycles in a graph have a very natural formulation in terms

of integral multicommodity flows. The relation is summarized in the following lemma.

Lemma 54 Let G(V, E) be an unweighted graph, and let (V0, V1) be a bipartition of V such

that |(V0, V0)|+ |(V1, V1)| is minimized. Let E = E0 ∪E1 where E0 = (V0, V0)∪ (V1, V1) and

E1 = (V0, V1), and set K = E0. Then

(i) Every K-path in G1 = G(V, E1) can be extended by an edge in E0 into an odd cycle

in G.

(ii) For all S ⊂ V , |∇G1(S)|/|∇K(S)| ≥ 1.

(iii) Any K-cut of G1 has size at least |E(K)|.

Proof Let p be a K-path in G1, say, between (k1, k2) ∈ E0. By definition, G1 is bipartite,

so p has even length. Then p ∪ (k1, k2) is an odd cycle in G. Next, suppose there exists

S ⊂ V such that |∇G1(S)| < |∇K(S)|. Then setting V ′i = Vi − (Vi ∩ S) + (Vi ∩ S) gives

|(V ′0 , V

′0)|+ |(V ′

1 , V′1)| = |(V0, V0)|+ |(V1, V1)|+ |∇G1(S)| − |∇K(S)| < |(V0, V0)|+ |(V1, V1)|,

contradicting the minimality in the choice of (V0, V1). Finally, let M be a K-cut of G1, and

65

let S1, . . . , St denote the connected components of G1 \M . Then∑

i∇K(Si) = 2|E(K)| ≤∑

i∇G1(Si) ≤ 2|M |.

Theorem 55 If G ∈ G then |F | = O (m log n/og(G)) and |F | = O(n2/og2(G)

). If G

excludes Kr,r for some constant r, then |F | = O (m/og(G)).

Proof By definition of fG , there exists a vertex-partition (S1, . . . , St) with

|∇(S1, . . . , St)| ≤ fG(12(og(G)− 3))m

such that ρ(Si) < 12(og(G)− 1). It is easy to see that such a multicut intersects every odd

cycle of length at least og(G). The claims follow by applying the upper bounds f∗ proved

in Section 6.2.

Each of these bounds can also be interpreted as an upper bound on og(G) in terms

of |F |. Note that the first bound is stronger when G is a sparse graph; the second is Komlos’

result; the third is a stronger bound for sparse graphs in the case of graphs excluding Kr,r.

Local 2-colorability

We note an application to local decidability of bipartiteness. That is, we would

like to find an algorithm which, given a graph which is ε-far from bipartite, locates an odd

cycle in G. Such an algorithm obviously has one-sided error, and the probability of error is

exactly the probability that it fails to find an odd cycle in a far-from-bipartite graph. The

following lemma states that a graph which is ε-far from bipartite is dense in small witnesses

to this fact (odd cycles).

66

Lemma 56 Let G be a graph with constant maximum degree which is ε-far from bipartite.

Then G contains Ω(ε2m/ log n) edge-disjoint odd cycles of length O(ε−2 log n). If G excludes

Kr,r for some constant r, then it contains Ω(ε2m) edge-disjoint odd cycles of length O(ε−2).

Proof With notation as earlier, |F | ≥ εm. Apply Corollary 53 to the construction in

Lemma 54. That a constant fraction of these cycles have at most the given length follows

by Markov’s inequality.

Lemma 56 implies an efficient local algorithm for bipartiteness in the special case

of graphs excluding Kr,r:

Theorem 57 Let G be a graph with constant maximum degree ∆ such that G excludes

Kr,r for some constant r and G is ε-far from bipartite. Then there exists an algorithm

which locates an odd cycle in G with probability 1 − δ using exp(O(ε−2)) log(1/δ) queries;

in particular, the algorithm requires a number of queries which is independent of n.

Proof In the case of graphs excluding Kr,r, Lemma 56 implies that we can locate an odd

cycle with constant probability by sampling O(ε−2) random vertices and doing a breadth-

first search about each vertex to radius O(ε−2). Repeating this O(log(1/δ)) times re-

duces the failure probability to 1 − δ. The overall query complexity of this procedure is

∆O(ε−2) log(1/δ).

On the other hand, Goldreich and Ron [GR97] showed that locating an odd cycle

requires Ω(√

n) queries in general. A slightly modified argument shows that a graph with

|F | ≥ εn2 must contain Ω(ε3/2n2) edge-disjoint odd cycles. Alternatively, one can argue

directly from Lemma 46 that bipartiteness as well as other properties on bounded-degree

67

graphs, including 3-colorability (which we saw earlier is not computable with a sublinear

number of queries), are distinguishable in constant time on graphs excluding a fixed minor.

6.5 Tightness of bounds

With respect to the usual parameter k, the bounds of Theorem 43 are optimal.

For general graphs, this follows from the lower bound in [GVY93], which is similar to the

lower bound construction used in [LR99]: G is a ∆-regular expander graph on n vertices, all

edges have unit capacity, and K is the set of all vertex-pairs (k1, k2) such that d(k1, k2) ≥

log∆(n/2). It is easy to check that the maximum (fractional) flow is O(n/ log n) while the

minimum multicut has weight Ω(n) = Ω(m). Fractional flow is a relaxation of integral flow,

so the bound holds in our case as well, even though the min-multicut has constant density.

For the other families considered, the assertion is trivial.

It is not clear, however, whether Theorem 43 always captures correctly the optimal

dependence of the max-integral-flow/min-multicut ratio on ε. For planar graphs, the grid

example used in [GVY97] to establish the Ω(k) integrality gap shows that our dependence

on ε for planar graphs is optimal. More generally, a potential problem in our approach is

illustrated by the following example, which is the construction of Lemma 54 applied to the

lower bound construction used in [BESS78]. Let G′ be a path on l = O(1/√

β) vertices

v′1, . . . , v′l and let G be the “blow-up” of G′ by t = O(

√βn) vertices; that is, replace each

vertex v′i of G′ by t vertices vji for j = 1, . . . , t, and let G be the graph formed by connecting

all pairs (vi1j , vi2

j+1) for all i1, i2, j. Set K to the set of pairs (vi11 , vi2

l ) for all i1, i2. Then

G is δ-dense, with δ =√

β, and it is easy to see that any K-cut has weight Ω(√

βC).

68

Applying Theorem 43 with ε =√

β gives that there exists a flow of weight O(βC) when,

in fact, there exists a flow with weight equal to the min-multicut – the optimum flow is

achieved by pushing a unit flow along all paths P = (a1, . . . , al) where P is a pairwise

independent family of vectors on 1, . . . , tl of size t2 (this flow strategy was observed by

Luca Trevisan). The problem is that, when we augment along a path, it may be the case that

the path intersects a min-multicut at a single edge, while the approximate max-integral-flow

algorithm reduces its lower bound on the weight of the unknown min-multicut by the length

of the path. In this example, the worst case occurs on every augmentation, leading to a loss

of a factor l = O(1/√

β). On the other hand, the same example shows that our bound on

fGδ in this case is optimal within a constant factor.

69

Bibliography

[AFKS99] N. Alon, E. Fischer, M. Krivelevich, and M. Szegedy. Efficient testing of large

graphs. In IEEE Symposium on Foundations of Computer Science, pages 656–

666, 1999.

[AFNS99] N. Alon, E. Fischer, I. Newton, and M. Szegedy. Regular languages are testable

with a constant number of queries. In IEEE Symposium on Foundations of

Computer Science, pages 645–655, 1999.

[AK02] N. Alon and M. Krivelevich. Testing k-colorability. SIAM Journal on Discrete

Mathematics, 15:211–227, 2002.

[AR98] Y. Aumann and Y. Rabani. An O(log k) approximate min-cut max-flow theorem

and approximation algorithm. SIAM Journal on Computing, 27(1):291–301,

1998.

[BESS78] B. Bollobas, P. Erdos, M. Simonovits, and E. Szemeredi. Extremal graphs with-

out large forbidden subgraphs. Annals of Discrete Mathematics, 3:29–41, 1978.

[BOT02] A. Bogdanov, K. Obata, and L. Trevisan. A lower bound for testing 3-

70

colorability. In IEEE Symposium on Foundations of Computer Science, pages

93–102, 2002.

[BR00] M. Bender and D. Ron. Testing acyclicity of directed graphs in sublinear time.

In International Conference on Automata, Languages, and Programming, 2000.

[CGKS98] B. Chor, O. Goldreich, E. Kushilevitz, and M. Sudan. Private information

retrieval. Journal of the ACM, 45(6):965–982, 1998.

[CRT00] B. Chazelle, R. Rubinfeld, and L. Trevisan. Approximating the minimum span-

ning tree weight in sublinear time. In International Conference on Automata,

Languages, and Programming, 2000.

[DJP+94] E. Dahlhaus, D. Johnson, C. Papadimitriou, P. Seymour, and M. Yannakakis.

The complexity of multiterminal cuts. SIAM Journal on Computing, 23:864–894,

1994.

[Erd62] P. Erdos. On circuits and subgraphs of chromatic graphs. Mathematika, 9:170–

175, 1962.

[FF56] L. Ford and D. Fulkerson. Maximal flow through a network. Canadian Journal

of Mathematics, 8, 1956.

[FGL+96] U. Feige, S. Goldwasser, L. Lovasz, S. Safra, and M. Szegedy. Approximating

clique is almost np-complete. Journal of the ACM, 43:268–292, 1996.

[FJ97] A. Frieze and M. Jerrum. Improved approximation algorithms for MAX k CUT

and MAX BISECTION. Algorithmica, 18:61–77, 1997.

71

[FK99] A. Frieze and S. Kannan. Quick approximation to matrices and applications.

Combinatorica, 19:175–220, 1999.

[GG81] O. Gabber and Z. Galil. Explicit construction of linear sized superconcentrators.

Journal of Computer and System Sciences, 22:407–425, 1981.

[GGR98] O. Goldreich, S. Goldwasser, and D. Ron. Property testing and its connections

to learning and approximation. Journal of the ACM, 45:653–750, 1998.

[GKST02] O. Goldreich, H. Karloff, L. Schulman, and L. Trevisan. Lower bounds for linear

locally decodable codes and private information retrieval. In IEEE Conference

on Computational Complexity, 2002.

[GR97] O. Goldreich and D. Ron. Property testing in bounded degree graphs. In ACM

Symposium on Theory of Computing, pages 406–415, 1997.

[GR99] O. Goldreich and D. Ron. A sublinear bipartitness tester for bounded degree

graphs. volume 19, pages 335–373, 1999.

[Gun02] O. Gunluk. A new min-cut max-flow ratio for multicommodity flows. In Integer

Programming and Combinatorial Optimization, pages 54–66, 2002.

[GVY93] N. Garg, V. Vazirani, and M. Yannakakis. Approximate max-flow min-(multi)cut

theorems and their applications. In ACM Symposium on Theory of Computing,

pages 698–707, 1993.

[GVY97] N. Garg, V. Vazirani, and M. Yannakakis. Primal-dual approximation algorithms

for integral flow and multicut in trees. Algorithmica, 18:3–20, 1997.

72

[Has97] J. Hastad. Some optimal inapproximability results. In ACM Symposium on

Theory of Computing, pages 1–10, 1997.

[Kar72] R. Karp. Reducibility among combinatorial problems. In R. E. Miller and J. W.

Thatcher, editors, Complexity of Computer Computations, pages 85–103, New

York, NY, 1972. Plenum Press.

[KdW03] I. Kerenidis and R. de Wolf. Exponential lower bound for 2-query locally decod-

able codes. In ACM Symposium on Theory of Computing, 2003.

[KKR04] T. Kaufman, M. Krivelevich, and D. Ron. Tight bounds for testing bipartiteness

in general graphs. SIAM Journal on Computing, pages 1441–1483, 2004.

[Kom97] J. Komlos. Covering odd cycles. Combinatorica, pages 393–400, 1997.

[KPR93] P. Klein, S. Plotkin, and S. Rao. Excluded minors, network decomposition,

and multicommodity flow. In ACM Symposium on Theory of Computing, pages

682–690, 1993.

[KT00] J. Katz and L. Trevisan. On the efficiency of local decoding procedures for

error-correcting codes. In ACM Symposium on Theory of Computing, 2000.

[LLR95] N. Linial, E. London, and Y. Rabinovich. The geometry of graphs and some of

its algorithmic applications. Combinatorica, 15:215–245, 1995.

[LR99] F. Leighton and S. Rao. An approximate max-flow min-cut theorem for uniform

multi-commodity flow problems with applications to approximation algorithms.

Journal of the ACM, 46(6), 1999.

73

[Mar73] G. Margulis. Explicit construction of a concentrator. Problems of Information

Transmission, 9:71–80, 1973.

[MR95] R. Motwani and P. Raghavan. Randomized Algorithms. Cambridge University

Press, 1995.

[Oba02] K. Obata. Optimal lower bound for 2-query locally decodable linear codes. In

6th International Workshop on Randomization and Approximation Techniques,

pages 39–50, 2002.

[Oba04] K. Obata. Approximate max-integral-flow/min-multicut theorems. In ACM

Symposium on Theory of Computing, pages 539–545, 2004.

[Pap93] C. Papadimitriou. Computational Complexity. Addison-Wesley, 1993.

[Pet94] E. Petrank. The hardness of approximations: Gap location. Computational

Complexity, 4:133–157, 1994.

[PS94] A. Polishchuk and D. Spielman. Nearly-linear size holographic proofs. In ACM

Symposium on Theory of Computing, pages 194–203, 1994.

[PT93] S. Plotkin and E. Tardos. Improved bounds on the max-flow min-cut ratio for

multicommodity flows. In ACM Symposium on Theory of Computing, pages

691–697, 1993.

[PY91] C. Papadimitriou and M. Yannakakis. Optimization, approximation, and com-

plexity classes. Journal of Computer and System Sciences, 43:425–440, 1991.

74

[Tre01] L. Trevisan. Non-approximability results for optimization problems on bounded

degree instances. In ACM Symposium on Theory of Computing, pages 453–461,

2001.