College of Computer & Information Science Fall 2007 Northeastern University Handout 16 October 2007 CS G399: Algorithmic Power Tools I Scribe: Hooman Javaheri

Lecture Outline:

• Generalized Steiner Network

• Jain’s Algorithm (2-Approximation)

In this lecture, we will study a generalized form of Steiner network problem. We will present Jain’s Algorithm, a 2-approximation algorithm for this problem.

1 Generalized Steiner Network

In the previous class we covered the Steiner Forest problem. A generalization of this problem is the following:

Problem 1. Given a graph G(V, E), a cost function c : E → Z^{+}, and a connectivity requirement r_{uv} for each pair (u, v), find a min-cost subgraph of G satisfying the connectivity requirement for all (u, v), where u_{e} is maximum number of copies you can pick for edge e

We can write the problem as the following linear program:

min ∑ c_{e}x_{e}

s.t. ∑_{e∈δ(S)} x_{e} ≥ f(S)

0 ≤ x_{e} ≤ u_{e}

where,

f(S) = max_{u,v_{u∈S,v∈S̄}} r_{uv}

δ(S) is the set of edges connecting S to \overline{S}.

2 Jain’s algorithm for generalized steiner network problem

Jain’s algorithm is an 2-approximation algorithm for Generalized Steiner Network. This algorithm use the following approach to solve the problem: Solve LP, construct part of the solution by selecting edges for which x_{e} is large, and redefine a new LP and repeat until the whole connectivity requirements are satisfied.

More formally, we can write the algorithm as Algorithm 1.

This algorithm looks neat, but here are some issues:

Algorithm 1: Jain’s algorithm for generalized steiner network problem

1. F ← Ø , Define f according to r_{uv}s. f′ ← f.

2. repeat 2.1. Solve LP for f′ to obtain a solution x with desired property: ∃e s.t. x_{e} ≥ 1/2 2.2. Add ⌈x_{e}⌉ copies of all e s.t. x_{e} ≥ 1/2 to F 2.3. Remove the above edges e from G. 2.4. f′(S) ← max(0, f(S) − δ_{F} (S)) where, δ_{F} (S) is set of edges of F crossing S.

until f′(S) = 0

3. Return F

• How do we solve the LP efficiently? Looking at the definition, the number of the constraints in the LP is exponential. To obtain a poly-time algorithm we need to solve LP in poly-time. Can we do that?

• It might be the case that in some iteration the redefined LP cannot be solved (infeasible).

• How do we calculate f′(S) in poly-time? It’s easy to see that we have exponential number of the sets in each iteration.

• Does the algorithm terminate? Is the termination time polynomial?

In order to prove that this algorithm is a 2-approximation algorithm, we need to answer above questions. Our approach to answer the questions is as following. We want to prove that:

1. LP can be solved in Poly-Time ,in fact, we will find an optimal BFS in each iteration.

2. The algorithm is a 2-approximation assuming the desired property in state 2.1 is TRUE.

3. Desired Property: for all BFSs, ∃e s.t. x_{e} ≥ 1/2 Actually, we will prove it for 1/3 rather than 1/2. The approach for 1/2 is the similar, but requires some complicated case analysis for which we refer to the original paper.

These proofs can answer the issues we faced. Part 1 answers the issue about solving LP. Part 1 and 2 together prove the termination of the algorithm. Looking at step 2.3 in algorithm, we can easily see if we find BFS with desired property, at least one edge will be removed from our graph. so the termination time of the algorithm will be Poly(E). The most important part of the proof is establishing the desired property (desired property). we will go through a complete proof.

Claim 1. We can solve LP in poly-time.

Proof. We know our LP has exponential number of constraints, therefore it is impossible to solve this LP going through all constraints. Our proof is based on Seperation Oracle Method.

Theorem 1. An LP

min C^{T} x
s.t. x ∈ P

which has exponential number of constraints can be solved (and also BFS can be yield) in Poly-Time if ∃ a Poly-Time procedure (oracle) that determines for a given x, either x ∈ P or gives a hyperplane (e.g. violating constraint) which separate x from P.

All we need to show is our LP has this property. Let’s look at the LP again.

min ∑ C_{e}x_{e}

s.t. ∑_{e∈δ(S)}(x_{e}) ≥ f(S)

0 ≤ x_{e} ≤ u_{e}

where,

f(S) = max_{u,v_{u∈S,v∈S̄}} r_{uv}

It’s easy to see that any solution for LP satisfies all cut constraints. That means x allows a flow of size r_{uv} from u to v. Now we can define our Poly-Time oracle.

Given x, set the x_{e} to be capacity of edge e. Run MAX-FLOW from u to v. If flow ≤ r_{uv}, return MIN-CUT separating u and v which has capacity < r_{uv}. If ∀u, vflow ≥ r_{uv} say x is feasible (x ∈ P).

We know MAX-FLOW runs in Poly-time. To solve our LP we need O(n^{2}) MAX-FLOW totally. (This number can be improved to n − 1 using Gomory-Hutrees.)

So in the first iteration we can solve our LP in poly-time.

Now suppose we are in the second iteration. We have already selected some edges and added them to our solution F. The second iteration gives us x′ as a new solution according to f′. We can solve LP defined by f′ by running O(n^{2}) MAX-FLOW computation on the graph given by x′ + F. The oracle is defined as before. If the oracle confirms that x′ + F is feasible, we can make sure that in each iteration our accumulative solution would be feasible for the original problem.

We can solve this LP using the separated oracle method, which in fact, yields an optimal BFS in poly-time.

Theorem 2. Jain’s algorithm is a 2-approximation algorithm assuming we can always find an optimal BFS satisfying desired property of part 3.

Proof. (Proof by induction on number of iterations) Base case: Suppose we have only one iteration in our algorithm. (i.e. the algorithm give the final solution after one iteration.)

Cost(F) = ∑_{e∈F,x_{e}≥1/2} c_{e}.⌈x_{e}⌉

≤ 2 · ∑_{e∈F,x_{e}≥1/2} c_{e}.x_{e}

≤ ∑_{e∈F} c_{e}.x_{e}

= 2LPOPT ≤ 2.OPT

Suppose for a given f′, our solution F′ is obtained in t iterations and has Cost ≤ 2.LPOPT(f′). We are solving the problem for f. Suppose, in the first iteration, solution returned is x.

LPOPT = ∑_{e} c_{e}.x_{e}

F_{1} = edges picked in the first iteration (⌈x_{e}⌉ copies of each edge with x_{e} ≥ 1/2)

f′(S) = f(S) − δ_{F_{1}}(S)

Solving LP for f′, we get solution F′ and our final solution will be F_{1} ⋃ F′.

Cost(F) ≤ Cost(F_{1}) + Cost(F′)

≤ ∑_{e∈F,x_{e}≥1/2} c_{e}.⌈x_{e}⌉ + 2 · LPOPT(f′)

we need to prove that

Cost(f) ≤ 2 · LPOPT(f)

this holds true if

LPOPT(f′) ≤ LPOPT(f) − ∑_{e∈F,x_{e}≥1/2} c_{e}.x_{e}

Define:

x̃ = \{ \begin{matrix}⌈ & x_{e} & ⌉ \\ 0 \end{matrix} \begin{matrix}x_{e} > 1/2 \\ o/w \end{matrix}

x − x̃ = \{ \begin{matrix}x_{e} \\ 0 \end{matrix} \begin{matrix}x_{e} < 1/2 \\ x_{e} ≥ 1/2 \end{matrix}

x − x̃ is a feasible solution for LP(f′), so we can say

LPOPT(f′) ≤ LPOPT(f) − ∑_{e:x_{e}≥1/2} c_{e}.x_{e}

and we are done.

Theorem 3. For every BFS for the generalized steiner network problem’s LP, ∃e s.t. x_{e} ≥ 1/2.

Figure 1: Example of a Laminar family

Figure 2: Example of a Laminar family

Note that this theorem has nothing to do with objective function and only concerns the ”Polytope” constructed by set of constraints. We will prove this theorem in two steps:

1.

Theorem 4. Further assume x_{e} ∈ (0, 1) (i.e. not including 0 and 1). Suppose there are m such edges. There exist a set of m ”TIGHT” constraints that are independent and form a laminar family.

2. if 1 then, ∃e s.t. x_{e} ≥ 1/2.

By independent, we mean none of the constraints can be written as linear combination of others. A laminar family is defined as follows:

Definition 1: Two sets S and T cross if S − T, T − S, S ∩ T are all non-empty. Look at Figure 1.

Definition 2: A laminar family is a collection of sets no two of which cross. Figure 2 shows an example of a laminar family. In some sense, a laminar family looks like a hierarchy of sets.(This observation helps us to prove the theorem later on)

We will discuss more about laminar families and complete the proof of part 3 in the next class.