College of Computer & Information Science Fall 2007 Northeastern University 13 November 2007 CS G399: Algorithmic Power Tools I Scribe: Abhishek Chaubey

Lecture Outline:

• Goemans-Williamson Algorithm for Max-Cut

In this lecture we will use semi-definite programming (SDP) approach as a black box to solve the Max-Cut problem. The SDP machinery used to solve this problem has developed the whole new class of approach to solve a bunch of problems. Both the algorithm and analysis by Goemans and Williamson are very simple and short.

The approach would be to write a Strict Quadratic Program for Max-Cut and convert it to Vector Program. And then solve the Vector Program using SDP solver. In fact most of the machinery that has been developed using SDP in approximation algorithms uses vector programs.

1 Introduction

In this section we introduce and review some notions related to various mathematical programs.

• Semi-Definite Programs where we have positive semi-definite matrix constraints.

• Strict Quadratic Programs are quadratic programs (i.e. the constraints and the objective function could be quadratic) where sum of power of the variables in each term is either 0 or 2.

• Vector Programs (refer to last lecture)

Relationship of Vector Programs with Strict Quadratic Programs: In Vector Programs, in each constraint and objective function, each term is of the form constant c or v_{i}.v_{j} where v_{i} and v_{j} are vectors and operation is dot product. We can take a Strict Quadratic Program, replace the scalars (or variables) by vectors to get Vector Program.

Machinery to solve a problem: Take the problem, write it as Strict Quadratic Program and then replace the variables by vectors to get Vectors. And we know the fact that semi-definite programming can solve Vector Programs.

2 Max-Cut Problem

Problem: Given a graph G = (V, E) and w : E → Z^{+}. Determine cut (S, S̄) where w(S, S̄) is maximized.

2.1 Algorithms

There can be various approaches to solve Max-Cut Problem:

(i) Local Greedy Algorithm:

We discussed a 1/2-approximation algorithm in the last class. In this approach, we start with a cut and greedily try to improve the size of the cut.

(ii) ”Naive” Randomized Algorithm:

Place v in S independently with probability 1/2.

P r[(u, v) crosses the cut] = 1/2

By linearity of expectation,

E[w(S, S̄)] = \frac{∑_{i>j} w_{ij}}{2}

Approximation Ratio = \frac{E[w(S, S̄)]}{OP T}

= \frac{\frac{∑_{i>j} w_{ij}}{2}}{OP T}

≥ \frac{\frac{∑_{i>j} w_{ij}}{2}}{∑_{i>j} w_{ij}}
= 1/2  (1)

So here we have the trivial algorithm, in which we are not even looking at the graph. To get (1), we bounded OP T i.e. OP T is at most ∑_{i>j} w_{ij}. Now, if we can provide a better bound for OP T, we will get a better approximation ratio. In this analysis the bound for OP T is naive. One attempt to get a good approximation ratio is to improve this bound. So, there is a possibility that this algorithm might be a better algorithm, but our analysis is not perfect. A question to address: Is the algorithm really an 1/2-approximation? One can easily come up with an example where this algorithm (or minor variant) is indeed no better than an 1/2-approximation.

(iii) Goemans Williamson Method:

It seems very hard to write an LP for Max-Cut problem. One way to write a LP can be the following:

We have variable x_{S,S̄} for cut (S, S̄).

max x_{S,S̄} · w_{S,S̄}
such that ∑ x_{S,S̄} = 1

It is not a very useful LP. This LP is just an enumeration of all the cuts. It doesn’t capture any structure of the graph. And also we don’t know how to solve it in polynomial time.

We should move away from restricting our notion to LPs because there can be more problems which can be written in more general programs than LPs and can be solved in polynomial time. So we should not constraint ourself to LPs.

One another approach might be to have a variable x_{e} for each edge e such that x_{e} = 1 if it crosses the cut and 0 otherwise. Objective function would be to maximize ∑_{e} w_{e}.x_{e}. What are our constraints? These edges should define a cut. But capturing a cut using a linear constraint seems to be difficult.

Now instead of assigning variables for cuts or edges, we will assign a variable to each vertex and write a strict quadratic program as follows:

Assign variables to vertices (say y_{i} for vertex i).

y_{i} = \{ \begin{matrix}+1 : & if i ∈ S \\ −1 : & if i ∉ S \end{matrix}

Strict Quadratic Program [Q][MC]:

max ∑_{i>j} w_{ij} \frac{1 − y_{i}.y_{j}}{2}

such that y_{i} ∈ {−1, 1}

Note that if (i, j) ∈ S, then \frac{1−y_{i}.y_{j}}{2} =1. Also, we can write y_{i} ∈ \{-1,1\} as y_{i}^{2} = 1. So we have written a Strict Quadratic Program (SQP) for our problem.

Goemons and Williamson relaxed the notion of scalars in [Q] by vectors and wrote the following vector program.

Vector Program [P]:

max \frac{1}{2} ∑_{i>j} w_{ij} · (1 − v_{i}.v_{j})

such that v_{i} · v_{i} = 1

Since there are n vertices, we have n vectors. W.l.o.g we can can assume these vectors to be ndimensional i.e. v_{i} ∈ R^{n} . Note that the constraint v_{i}·v_{i} = 1 says that all these n-dimensional vectors are on an n-dimensional sphere. Now we know how to solve this Vector Program in polynomial time using SDP.

Z_{MC}^{∗} = Z_{Q}^{∗} = Optimal Max Cut

Z_{P}^{∗} can be found by SDP to an additive error of ϵ.