I am finding a creative idea for presenting mathematics without losing its preciseness.

1. An O(log k)­Approximation
2
Algorithm for Vertex Connected
Spanning Subgraph
Bundit Laekhanukit
C&O Department, University of Waterloo
Joint work with
Jittat Fakcharoenphol, Kasetsart University
1

2. Outline of This Talk
●
Problem Formulation
●
Structural Properties
●
Main Algorithm
●
Important Subroutines
2

3. Motivation
3

4. Design a Network
4

5. A Survivable Network
5

6. Given network­nodes and possible
connections (with cost).
C
6

7. We want to pay cheap cost to make
all nodes connected.
C
7

8. Is this good enough?
C
8

9. What if one node is broken?
C
9

10. Network break apart
C
10

11. We want more than just connected.
C
11

12. We require a network to be
survivable even if some nodes fail.
C
12

13. A network that can survive
after one node fail.
C
13

14. A network that can survive
after one node fail.
C
14

15. Formulate as a Graph problem
15

16. Min­cost k­Vertex Connected Spanning
Subgraph Problem (k­VCSS)
16

17. k­Vertex Connected Spanning
Subgraph Problem (k­VCSS)
Input:
● Graph G=(V, E) with non­negative cost on edges
● An integer k, a requirement
Goal:
● Find a min­cost subgraph H=(V, E').
● Removing < k vertices does not disconnect H.
k=1: Minimunm Spanning Tree, k>1: NP­Hard
17

18. History of Results
18

19. Results since 2002
n = number of vertices
m = number of edges
Year Authors Approximation Ratio
2002 Cheriyan, Vempala, Vetta O(log k) for n > 6k2
n
2004 Kortsarz, Nutov O(min{ log k, }log k)
n−k k
2008 Fakcharoenphol, L. O(log2 k)
n
2009 Nutov O(log( ) log k)
n−k
Important early result: Ravi, Williamson 1995
19

20. Results since 2002
n = number of vertices
m = number of edges
Year Authors Approximation Ratio
2002 Cheriyan, Vempala, Vetta O(log k) for n > 6k2
n
2004 Kortsarz, Nutov O(min{ log k, }log k)
n−k k
2008 Fakcharoenphol, L. O(log2 k)
n
2009 Nutov O(log( ) log k)
n−k
Important early result: Ravi, Williamson 1995
20

21. Negative Results: APX­Hard for k > 1
Czumaj­Lingas 1999, Gabow (unpublished)
21

22. All results listed have a common framework.
22

23. Increase connectivity from L=1, 2,.., k
23

24. Start from connectivity = 1
Edge in current graph
Edge that can be added
24

25. Increase connectivity to 2
Edge in current graph
Edge that can be added
25

26. Increase connectivity to 3
Edge in current graph
Edge that can be added
26

27. T(n, k)­approx. algo. for increasing connectivity,
implies
O(T(n, k) log k)­approx. algo. for k­VCSS.
27

28. Assume a graph is L­connected,
and we want to increase connectivity to L+1
28

29. Structure of L­connected graph
29

30. (Vertex) Separator
● Set S of vertices: removing S leaves G disconnected.
● An L­connected graph that is not (L+1)­connected has
separator of size L.
30

31. Cover Separator
●
Add an edge crossing it.
31

32. Covering all separators =
increasing connectivity
● Naive idea: add an edge to cover each separator
● But, the cost can be blown up.
32

33. Covering all separators =
increasing connectivity
● Naive idea: add an edge to cover each separator
● But, the cost can be blown up.
33

34. Covering all separators =
increasing connectivity
● Naive idea: add an edge to cover each separator
● But, the cost can be blown up.
34

35. Our plan is to find a systematic way
to cover all separators
35

36. Hard to work with separators
Better to deal with fragments
36

37. Fragment
● Removing separator disconnects graph into parts.
● Each part is called a fragment.
37

38. Fragment
● Removing separator disconnects graph into parts.
● Each part is called a fragment.
38

39. Fragment
● Precisely, fragment F has L neighbours, say N(F), and
V – (F ∪ N(F)) is not empty.
● V – (F ∪ N(F)) is a complementary fragment.
Not empty
Fragment
Complementary Fragment,
39

40. Cover Fragment
●
Add an edge between fragment and its
complementary fragment.
40

41. Small fragment
● A fragment F, F ≤ (|V| ­ L)/2
41

42. Property of small fragment
●
The non­empty intersection of two small
fragments is also a small fragment.
42

43. Property of small fragment
●
The non­empty intersection of two small
fragments is also a small fragment.
43

44. Property of small fragment
●
The non­empty intersection of two small
fragments is also a small fragment.
44

45. Property of small fragment
●
The non­empty intersection of two small
fragments is also a small fragment.
45

46. Core and Halo­set (AC )
46

47. Core
●
An inclusionwise minimal small fragment
Core contains no
other small fragments
47

48. Halo­family A(C)
●
A(C) = {U : U is a small fragment that contains
C and contains no other cores}
C
48

49. Halo­family A(C)
●
A(C) = {U : U is a small fragment that contains
C and contains no other cores}
not in Halo­family
C
49

50. Halo­set AC
● AC = a union of fragments in Halo­family A(C)
AC
C
50

51. Disjointness Property
●
Members of different Halo­families are disjoint.
51

52. Disjointness Property
●
Thus, cores and Halo­sets are disjoint.
52

53. Connection to Connectivity
●
(L+1)­connected graph has no small fragments
and thus has no cores.
53

54. Cores and Halo­sets (but not Halo­families) are
polytime computable.
54

55. We use the number of cores to measure
how close graph is to be (L+1)­connected.
55

56. Our plan is to add cheap edges
to decrease the number of cores.
56

57. Algorithm
While the number of cores > 0
For each core C
–Add set of edges to cover all fragments in
Halo­family of C
End For
End While
57

58. Overview of Analysis
●
In each while loop,
●
The number of core decreases by half.
● Cost paid is ≤ 4opt
●
Thus, it give O(log n) opt.
58

59. The number of cores
decreases by half.
●
Cores in the next iteration are small fragments
in the previous one.
Edge in current graph
Edge that can be added
59

60. The number of cores
decreases by half.
●
Cores in the next iteration are small fragments
in the previous one.
Edge in current graph
Edge that can be added
60

61. The number of cores
decreases by half.
●
Cores in the next iteration are small fragments
in the previous one.
Edge in current graph
Edge that can be added
61

62. The number of cores
decreases by half.
●
Fragments having one core are in some Halo­
family, so all of them must be covered.
Edge in current graph
Edge that can be added
62

63. The number of cores
decreases by half.
●
Fragments having one core are in some Halo­
family, so all of them must be covered.
Edge in current graph
Edge that can be added
63

64. The number of cores
decreases by half.
● Remaining small fragments contains ≥ 2 cores
64
Core in the next iteration

65. The number of cores
decreases by half.
●
Thus, the number of cores in the next iterations
is at most half of the previous one.
65

66. Cost paid is at most 4opt
●
Claim: There is a 2­approximation algorithm for
covering Halo­families. [proof later]
●
Idea: Edges that cover each Halo­families are
almost disjoint (share by at most 2).
66

67. Cost paid is at most 4opt
●
An edge that covers a fragment must go from
the fragment to its complementary.
Edge in current graph
Edge that can be added
67

68. Cost paid is at most 4opt
● Edges that cover small fragments:
(1) has ≥ 1 endpoints in Halo­sets (2) share by ≤ 2 Halo­sets.
share by ≤ 2 Halo­sets
≥ 1 endpoint in Halo­Set
Edge in current graph
Edge that can be added
68

69. Cost paid is at most 4opt
● OPT(C) = {e ∈ OPT : e has endpoint in A(C)}
●
I(C) = min­cost set of edges that cover A(C)
● Then cost(I(C)) ≤ cost(OPT(C))
●
Thus, ∑ cost  I C ≤∑ cost OPT C =2 opt
●
2­approx for covering Halo­family implies that
cost paid ≤ 4opt.
69

70. Subroutines needed
70

71. Cover Halo­family
71

72. Subroutine Needed
Theorem [Frank '99] There is a polynomial time
algorithm that increasing rooted connectivity of
directed graph by 1.
●
Particularly, Frank's algorithm covers all
fragments that contain a root vertex r.
Note: We use Frank­Tardos Algorithm in the original paper.
72

73. Cover Halo­Family A(C)
● Set cost of edges with no endpoints in AC to zero.
● Run Frank's algorithm rooted at r ∈ C (bi­directed graph)
● Choose edges with endpoints in AC
cost 0
original cost
r
C AC
73

74. Correctness
Edges that cover small fragments in
Halo­family A(C) have endpoints in A(C)
74

75. Cost
Frank's algorithm give an optimal solution
Running it in bi­directed graph pays factor of 2.
75

76. Computing Cores and Halo­sets
76

77. Compute Cores
For each pair of vertices
●
Compute Vertex­Capacitated Max­flow
●
Choose vertices reachable from source.
●
Save fragment found to the list
End for
Remove fragments in list that contain others.
77

78. Compute Halo­set AC
For each vertex v
● Run testing procedure to check if v is in AC
End For
78

79. We need Testing Procedure.
79

80. Testing Procedure (core C, vertex v)
● Add an edge from a vertex r ∈ C to v.
●
Add edges forming a clique on neighbours of v.
v
Padding Edges Padded Graph
r 80

81. Testing Procedure (core C, vertex v)
●
Compute minimal small fragment U that
contains C by running Max­Flow.
v
U
r 81

82. Testing Procedure (core C, vertex v)
● If U contains both C and v but no other cores, accept v.
● Otherwise, reject v.
v
U
ACCEPT
r 82

83. Testing Procedure (core C, vertex v)
● If U contains both C and v but no other cores, accept v.
● Otherwise, reject v.
v
U
REJECT
r 83

84. Correctness of Testing Procedure
●
Let U be any small fragment containing C.
U
84

85. Correctness of Testing Procedure
● If v ∈U, then a neighbour of v is either in U or a
separator of U. So, U is still a fragment.
v
U
r 85

86. Correctness of Testing Procedure
● If v ∈a separator of U, then v has one neighbour in U and
one in its complement. So, padding edges cover U.
v
cover U
U
r 86

87. Correctness of Testing Procedure
● If v ∉U, then an edge (r, v) covers U.
v
cover U
U
r 87

88. Correctness of Testing Procedure
●
Thus, any small fragment containing C, if exists,
must contain v in the padded graph.
v
U
r 88

89. Correctness of Testing Procedure
● U has unique core C ⇔ U is in Halo­family A(C)
v
U
r 89

90. Correctness of Testing Procedure
● U has unique core C ⇔ U is in Halo­family A(C)
v
U
r 90

91. Side Remarks (not in paper)
●
Our algorithm give factor of O(log t), where t is the
number of cores.
● Running Frank's algorithm from r ∈ C reduce the
number of cores to ≤ k.
● Preprocessing cost ≤ 2opt
In the original paper, we apply Kortsarz­Nutov's algorithm when k ≤ o(n), e.g., k ≤ n/2.
91

92. Conclusion
●
We present O(log2 k)­approximation algorithm
for k­VCSS
●
New techniques not in this talk:
●
The number of cores can be decreased to L.
●
We can avoid Halo­sets computation.
92

93. Open Problems
●
Is there O(log k)­approximation algorithm for
all value of k, n?
●
Can we get hardness better than APX­hard?
●
Can we apply LP rounding technique to this
problem? ­­ What is ratio IP/LP?
93

94. Questions?
94

95. Thank you for your attention.
95