Fractional Decomposition Tree Algorithm: A tool for studying the integrality gap of Integer Programs
FFractional Decomposition Tree Algorithm: A tool for studyingthe integrality gap of Integer Programs
Robert Carr ∗ Arash Haddadan † Cynthia A. Phillips ‡ August 12, 2020
Abstract
We present a new algorithm, Fractional Decomposition Tree (FDT) for finding afeasible solution for an integer program (IP) where all variables are binary. FDT runsin polynomial time and is guaranteed to find a feasible integer solution provided theintegrality gap is bounded. The algorithm gives a construction for Carr and Vempala’stheorem that any feasible solution to the IP’s linear-programming relaxation, whenscaled by the instance integrality gap, dominates a convex combination of feasiblesolutions. FDT is also a tool for studying the integrality gap of IP formulations.We demonstrate that with experiments studying the integrality gap of two problems:optimally augmenting a tree to a 2-edge-connected graph and finding a minimum-cost2-edge-connected multi-subgraph (2EC). We also give a simplified algorithm, Dom2IP,that more quickly determines if an instance has an unbounded integrality gap. Weshow that FDT’s speed and approximation quality compare well to that of feasibilitypump on moderate-sized instances of the vertex cover problem. For a particular set ofhard-to-decompose fractional 2EC solutions, FDT always gave a better integer solutionthan the best previous approximation algorithm (Christofides). ∗ University of New Mexico [email protected] . This material is based upon research supported in part bythe U.S. Office of Naval Research under award number N00014-18-1-2099. † University of Virginia [email protected] . This work was mainly done when this author was agraduate student at Carnegie Mellon University. ‡ Sandia National Laboratories [email protected] . Sandia National Laboratories is a multi-missionlaboratory managed and operated by National Technology and Engineering Solutions of Sandia, LLC., awholly owned subsidiary of Honeywell International, Inc., for the U.S. Department of Energy’s NationalNuclear Security Administration under contract DE-NA0003525. a r X i v : . [ c s . D M ] A ug Introduction
In this paper we focus on finding feasible solutions to binary Integer Linear Programs(IP). Informally, an integer program is the optimization of a linear objective functionsubject to linear constraints, where the variables must take integer values. Binary variablesrepresent yes/no decisions. Integer Programming (and more generally Mixed Integer LinearProgramming (MILP)) can model many practical optimization problems including scheduling,logistics and resource allocation.It is NP-hard even to determine if an IP instance has a feasible solution [GJ90]. Givenits practical importance, however, there are many commercial (e.g. CPLEX, GUROBI,XPRESS) and free (e.g. CBC) solvers that for specific IP instances can often find solutionsthat are optimal within a given tolerance. Still we have formulated moderate-sized IPinstances that no commercial solver can currently solve. Thus there is value in heuristicsto find feasible solutions for general IP instances (see e.g. [HT17]). These heuristics, suchas the popular Feasibility pump algorithm [FGL05, FS09], are often effective and fast inpractice. However, the heuristics can sometimes fail to find a feasible solution. Moreover,these heuristics do not provide any bounds on the quality of the solution they find.A major tool for finding feasible solutions for discrete optimization problems expressed asIPs is the linear-programming (LP) relaxation for the IP formulation. This is a new problemcreated by relaxing the integrality constraints for an IP instance, allowing the variablesto take continuous (rational) values. Linear programs can be solved in polynomial time.The objective value of the linear-programming relaxation provides a bound (lower boundfor a minimization problem and upper bound for a maximization problem) on the optimalsolution to the IP instance. The solutions can also provide some useful global structure,even though the fractional values might not be directly meaningful.
LP-based approximation algorithms use LP relaxations to find provably good approximatefeasible solutions to IP problems in polynomial time. At the highest level, they involvesolving the LP relaxation, using special structure from the problem to find a feasible solution,and proving that the objective value of the solution is no more than C times worse than thebound from the LP relaxation. The approximation factor C can be a constant or depend onthe input parameters of the IP, e.g. O (log( n )) where n is the number of variables in theformulation of the IP (the dimension of the problem).There is an inherent limit to how small C can be for a given IP. The integrality gapfor an IP instance is the ratio of the best integer solution to the best solution of the LPrelaxation. Any LP-based approximation cannot have an approximation factor C smallerthan the integrality gap because there is no feasible solution with an objective value betterthan a factor of C worse than the optimal solution of the LP relaxation.2f the integrality gap for an IP formulation is large, it is sometimes possible to addfamilies of constraints to the formulation to reduce the integrality gap. These constraintsare redundant for the integer problem, but can make some fractional solutions no longerfeasible for the LP. These families of constraints (cuts) can have exponential size (number ofconstraints) as long as we can provide a polynomial-time separation algorithm. A separationalgorithm for a family of constraints takes an optimal solution to an LP instance thatexplicitly enforces only a (potentially empty) subset of the family. It either confirms thatall constraints are satisfied or returns a most violated constraint. Thus one can add thisconstraint and repeat at most a polynomial number of times until all are satisfied.Reducing the integrality gap of an IP formulation has two advantages. It can lead tobetter LP-based approximation algorithm bounds as described above. It can also help exactsolvers run faster or solve instances it could not before. Exact IP solvers are based onintelligent branch-and-bound strategies. As mentioned above, commercial and open-sourceMILP solvers can find exact solutions (or near-optimal solutions with a provable bound) tomany specific instances of NP-hard combinatorial optimization problems. These solvers usethe LP relaxation to get lower bounds (for minimization problems). The search requiresexponential time in the worst case. But this search is practically feasible when the solvercan prune large amounts of the search space. This happens when the lower bound for aregion of the search space (subproblem) is worse than the value of a known feasible solution.This requires a way to find a good heuristic solution and it requires good lower bounds thatare as close to the actual optimal value of an IP subproblem as possible.In this paper, we give a method to find feasible solutions for IPs if the integrality gapis bounded. The method is also a tool for evaluating the integrality gap for a formulation.Researcher can use it to determine whether they should expend effort to find new classes ofcuts. They can also use it to help guide theory for finding tighter bounds on the integralitygap for classic problems like the traveling salesman problem.We now describe IPs and our methods more formally. The set of feasible points for apure IP (henceforth IP) is the set S ( A, b ) = { x ∈ Z n : Ax ≥ b } , (1)where matrix A of rationals has m constraints on n variables and b ∈ R m . If we drop theintegrality constraints, we have the linear relaxation of set S ( A, b ), P ( A, b ) = { x ∈ R n : Ax ≥ b } . (2)Let I = ( A, b ) denote an instance. Then S ( I ) and P ( I ) denote S ( A, b ) and P ( A, b ),respectively. Given a linear objective function c , an IP is min { cx : x ∈ S ( I ) } .3elaxing the integrality constraints gives the polynomial-time-solvable linear-programmingrelaxation: min { cx : x ∈ P ( I ) } . The optimal value of this linear program (LP), denoted z LP ( I, c ), is a lower bound on the optimal value for the IP, denoted z IP ( I, c ).Many researchers (see [WS11, Vaz01]) have developed polynomial time LP-based ap-proximation algorithms that find solutions for special classes of IPs whose cost are provablyat most C · z LP ( I, c ) for some (possibly constant) function C . If the analysis uses the LPbound to prove the approximation quality, then C is at least the integrality gap. Definition 1.
The integrality gap g ( I ) for instance I is: g ( I ) = max c ≥ z IP ( I, c ) z LP ( I, c ) , where z IP ( I, c ) is the optimal solution to the integer program and z LP ( I, c ) is the solution tothe linear-programming relaxation. In general the integrality gap is defined similarly for any objective function, but we wishto be explicit about the class of problems we assume in this paper. For example considerthe minimum cost : Given a graph G = ( V, E ) and c ∈ R E ≥ , 2EC asks for the minimum cost 2-edge-connected subgraph of G ,with multi-edges allowed. A graph is 2-edge-connected if there are at least two edge-disjointpaths between every pair of vertices. A linear-programming relaxation for this problem,known as the subtour-elimination relaxation, ismin { cx : (cid:88) e ∈ δ ( U ) x e ≥ ∅ (cid:40) U (cid:40) V, x ∈ [0 , E } , (3)where δ ( U ) for vertex subset U is the set of edges that cross the cut defined by U . Thatis, each e ∈ δ ( U ) has one endpoint in U and the other endpoint in V − U . In this case theinstance-specific integrality gap is the integrality gap of the subtour-elimination relaxation forthe 2EC on a graph with n vertices. Alexander et al. [ABE06] showed this instance-specificintegrality gap is at most for instances with n = 10 .The value of g ( I ) depends on the constraints in (1). We cannot hope to find solutionsfor the IP with objective values better than g ( I ) · z LP ( I, c ). More generally we can definethe integrality gap for a class of instances I as follows. g ( I ) = max c ≥ ,I ∈I z IP ( I, c ) z LP ( I, c ) . (4)For example, the integrality gap of the subtour-elimination relaxation for the 2EC is atmost [Wol80] and at least [ABE06]. Therefore, we cannot hope to obtain an LP-based4 − (cid:15) )-approximation algorithm for this problem using this LP relaxation to bound thequality of a feasible solution.Our methods apply theory connecting integrality gaps to sets of feasible solutions.Instances I with g ( I ) = 1 have P ( I ) = conv( S ( I )), the convex hull of the lattice of feasiblepoints. In this case, P ( I ) is an integral polyhedron. The spanning tree polytope of graph G , ST( G ), and the perfect-matching polytope of graph G , PM( G ), have this property([Edm70, Edm65]). Thus the linear-programming relaxation for minimum-cost spanningtree has basic feasible solutions (vertices) that are integral solutions, i.e. spanning trees. Forsuch problems there is an algorithm to express vector x ∈ P ( I ) (a feasible LP solution) as aconvex combination of points in S ( I ) (feasible IP solutions) in polynomial time [GLS93]. Proposition 2. If g ( I ) = 1 , then for x ∈ P ( I ) there exists a positive integer k and θ ∈ [0 , k ,where (cid:80) ki =1 θ i = 1 and ˜ x i ∈ S ( I ) for i ∈ [ k ] such that (cid:80) ki =1 θ i ˜ x i ≤ x . Moreover, we can findsuch a convex combination in polynomial time. An equivalent way of describing Proposition 2 is the following Theorem of Carr andVempala [CV04]. The dominant of P ( I ), which we denote by D ( P ( I )), is the set of points x (cid:48) such that there exists a point x ∈ P with x (cid:48) ≥ x in every component. A polyhedron is of blocking type if it is equal to its dominant. Theorem 3 (Carr, Vempala [CV04]) . We have g ( I ) ≤ C if and only if for x ∈ P ( I ) thereexists θ ∈ [0 , k where (cid:80) ki =1 θ i = 1 and ˜ x i ∈ D ( S ( I )) for i ∈ [ k ] such that (cid:80) ki =1 θ i ˜ x i ≤ Cx . Goemans [Goe95] first introduced Theorem 3 for blocking-type polyhedra. While thereis an exact algorithm for problems with gap 1, as stated in Proposition 2, Theorem 3 isexistential, with no construction. To study integrality gaps, we wish to decompose a suitablyscaled linear-programming solution into a convex combination of feasible integer solutions constructively . That is, we ask: assuming reasonable complexity assumptions, given aspecific problem I with 1 < g ( I ) < ∞ , and x ∈ P ( I ) for some I ∈ I , can we find θ ∈ [0 , k ,where (cid:80) ki =1 θ i = 1 and ˜ x i ∈ S ( I ) for i ∈ [ k ] such that (cid:80) ki =1 θ i ˜ x i ≤ Cx in polynomial time?We wish to find the smallest factor C possible. We give a general approximation framework for solving binary IPs. Consider the set ofpoints described by sets S ( I ) and P ( I ) as in (1) and (2), respectively. Assume in additionthat S ( I ) ∈ { , } n and P ( I ) ⊆ [0 , n . For a vector x ∈ R n ≥ such that x ∈ P ( I ), let the support of x be supp( x ) = { i ∈ [ n ] : x i (cid:54) = 0 } . For an integer β let { β } n be the vector y ∈ R n with y i = β for i ∈ [ n ]. 5n Section 3 we introduce the Fractional Decomposition Tree Algorithm (FDT) which runsin polynomial time algorithm. Given a point x ∈ P ( I ) FDT produces a convex combinationof feasible points in S ( I ) that are dominated coordinatewise by a “factor” C times x . If C = g ( I ), it would be optimal. However we can only guarantee a factor of g ( I ) | supp( x ) | . FDTiteratively solves linear programs that are about the same size as the description of P ( I ). Theorem 4.
Assume ≤ g ( I ) < ∞ . The Fractional Decomposition Tree (FDT) algorithm,given x ∗ ∈ P ( I ) , produces in polynomial time λ ∈ [0 , k and z , . . . , z k ∈ S ( I ) such that k ≤| supp( x ∗ ) | , (cid:80) ki =1 λ i z i ≤ min( Cx ∗ , { } n ) , and (cid:80) ki =1 λ i = 1 . Moreover, C ≤ g ( I ) | supp( x ∗ ) | . In Section 2 we describe a subroutine of the FDT, called the DomToIP algorithm, whichfinds feasible solutions to any IP with finite gap. This can be of independent interest,especially in proving that a model has unbounded gap.
Theorem 5.
Assume ≤ g ( I ) < ∞ . The DomToIP algorithm finds ˆ x ∈ S ( I ) in polynomialtime. Here is how the FDT algorithm works at a high level for an instance I with LP feasibleregion P ( I ): in iteration i the algorithm maintains a convex combination of vectors in D ( P ( I )) that have a 0 or 1 value for coordinates indexed 0 , . . . , i −
1. Let y be a vector inthe convex combination from iteration i −
1. We solve a linear-programming problem thatgives us θ , θ ∈ [0 ,
1] and y , y ∈ D ( P ( I )) such that y ≥ θ y + θ y , θ + θ ≤ g ( I ), y i = 0and y i = 1. We then replace y in the convex combination with θ θ + θ y + θ θ + θ y . Repeatingthis for every vector in the convex combination from the previous iteration yields a newconvex combination of points. It is “more” integral because now all vectors in the convexcombination are integral in their first i + 1 elements. If in any iteration there are too manypoints in the convex combination, we solve a linear-programming problem that “prunes” theconvex combination. At the end we have a convex combination of integer solutions D ( P ( I )).For each such solution z we invoke the DomToIP algorithm to find z (cid:48) ∈ S ( I ) where z (cid:48) ≤ z .One can extend the FDT algorithm for binary IPs into covering { , , } IPs by losinga factor 2 | supp( x ) | on top of the loss for FDT. To eradicate this extra factor, we must treatthe coordinate i with x i = 1 differently. In Section 4 we focus on the 2-edge-connectedmulti-subgraph graph problem (2EC) defined above. It’s subtour-elimination LP relaxationis given in (3). For input graph G , let Subtour( G ) denote the feasible region of this LP. Let2EC( G ) be the convex hull of incidence vectors of 2-edge-connected multi-subgraphs of A covering IP has nonnegative constraint matrix, objective coefficients and right-hand side (
A, b, c ). The incidence vector x of a 2-edge-connected multi-subgraph has an element for each edge e , with x e ∈ { , , } indicating the number of times edge e appears in the solution. G . Following the definition in (4) have g (2EC) = max c ≥ ,G min x ∈ G ) cx min x ∈ Subtour( G ) cx . (5) Theorem 6.
Let G = ( V, E ) and x be an extreme point of Subtour( G ) . The FDT algorithmfor 2EC produces λ ∈ [0 , k and 2-edge-connected multi-subgraphs F , . . . , F k such that k ≤ | V | − , (cid:80) ki =1 λ i χ F i ≤ min( Cx, { } n ) , and (cid:80) ki =1 λ i = 1 . Moreover, C ≤ g (2EC) | E x | . Although the bounds guaranteed in both Theorems 4 and 6 are large, in Section 5 we showthat in practice, the algorithm can work well for network design problems like those describedabove. We also show how one might use FDT to investigate the integrality gap for suchwell-studied problems.
In the minimum vertex cover problem (VC) we are given a graph G = ( V, E ) and c ∈ R E ≥ . A subset of U of V is a vertex cover if for all e ∈ E at least one endpoint of e isin U . The goal in VC is to find the minimum-cost vertex cover. The linear-programmingrelaxation for VC ismin { cx : x u + x v ≥ e = uv ∈ E, x ∈ [0 , V } . (6)The integrality gap of this formulation is exactly 2 [WS11]. Austrin, Khot and Safra [AKS11]show that it is UG-hard to approximate VC within any factor strictly better than 2. Wecompare FDT and the feasbility pump heuristic [FGL05] on the small instances of thePACE In the
Tree Augmentation Problem (TAP) we are given a graph G = ( V, E ), a spanningtree T of G and a cost vector c ∈ R E \ T ≥ . A subset F of E \ T is called a feasible augmentation if ( V, T ∪ F ) is a 2-edge-connected graph. In TAP we seek the minimum cost feasible Parameterized Algorithms and Computational Experiments: https://pacechallenge.org/2019/ { cx : (cid:88) (cid:96) ∈ cov( e ) x (cid:96) ≥ e ∈ T, x ∈ [0 , E \ T } . (7)where cov( e ) for e ∈ T is the set of edges (cid:96) ∈ E \ T such that e is in the unique cycleof T ∪ { (cid:96) } . Another way to think of cov( e ) is that if we remove edge e from tree T , thispartitions the vertices into two connected sets U and V − U . Then cov( e ) = δ ( U ) is the setof edges (cid:96) (cid:54) = e that cross the cut between U and V − U , and whose addition would reconnectthe tree. We call the LP above the cut LP. The integrality gap of the cut LP is known to bebetween [CKKK08] and 2 [FJ81]. We create random fractional extreme points of the cutLP and apply FDT to find integral solutions. For our instances, the ratio of the value of thefeasible solution to the LP lower bound is always below . This provides evidence that theintegrality gap for such instances may be less than . Known polyhedral structure makes it easier to study integrality gaps for such problems. Weuse the idea of fundamental extreme point [CR98, BC11, CV04] to create the “hardest” LPsolutions to decompose.There are fairly good bounds for the integrality gap for the Traveling Salesman Problem(TSP, see [ABCC06]) or 2EC. Benoit and Boyd [BB08] used a quadratic program to showthe integrality gap of the subtour-elimination relaxation for the TSP, g (TSP), is at most for graphs with at most 10 vertices. Alexander et al. [ABE06] used the same ideas toprovide an upper bound of for g (2EC) on graphs with at most 10 vertices.Consider a graph G = ( V, E ). A
Carr-Vempala point x ∈ R E is a fractional point inSubtour( G ) where the edges e with 0 < x e < G and the vertices onthe cycle are connected via vertex-disjoint paths of edges e with x e = 1 (see Figure 2).Carr and Vempala [CV04] showed that g (2EC) is achieved for instances where the optimalsolution to min x ∈ Subtour( G ) cx is a Carr-Vempala point. Multiple groups of researchers haveconjectured that g (2EC) ≤ (see [ABE06, BL17, HN18], but the only known upper boundon g (2EC) stands at [Wol80]. We show that the integrality gap is at most for Carr-Vempala points with at most 12 vertices on the cycle formed by the fractional edges, therebyconfirming the conjecture for these instances. Note that the number of vertices in theseinstances can be arbitrarily high since the paths of edges with x -value 1 can be arbitrarilylong. 8 .3 Contribution summary In summary, this papers’s contributions are: • We give an algorithm to express any feasible point for the LP relaxation of a binaryIP as a convex combination of feasible solutions, provided the IP integrality gap isbounded. This is the Fractional Decomposition Tree (FDT) algorithm. • We give a simple algorithm to give a feasible solution for any binary IP with boundedintegrality gap. If this algorithm fails, then the integrality gap is infinite. • We experimentally show that FDT can give good approximate solutions to smallinstances of vertex-cover and tree augmentation problems. • We show that the integrality gap for 2EC (minimum 2-edge-connected sub-multigraph)is at most for Carr-Vempala points with at most 12 vertices on the cycle formed bythe fractional edges, matching the lower bound for integrality gap for 2EC for theseinstances. • We demonstrate (with tree augmentation and 2EC) how FDT exeriments can supporttheoretical work on integrality gaps for specific problems.
In this section we give the algorithm for DomToIP and prove its performance (Theorem 5).Consider an IP instance I = ( A, b ). Define sets S ( I ) and P ( I ) as in (1) and (2),respectively. Assume S ( I ) ⊆ { , } n and P ( I ) ⊆ [0 , n . For simplicity in the notation weassume an instance I and denote P ( I ) , S ( I ) , and g ( I ) by P , S , and g for this section andthe next section. Also, for both sections let x ∗ be the optimal solution to the LP formulationand assume t = | supp( x ∗ ) | . Reorder variables as necessary to put all the nonzero variablesinto the first t indices. So we can assume x ∗ i = 0 for i = t + 1 , . . . , n .In this section we prove Theorem 5. In fact, we prove a stronger result. Lemma 7.
Given an integral vector in the dominant of an LP relaxation ( ˜ x ∈ D ( P ) and ˜ x ∈ { , } n ) for an IP instance that has integrality gap g < ∞ , there is an algorithm (theDomToIP algorithm) that finds ¯ x ∈ S in polynomial time such that ¯ x ≤ ˜ x . Lemma 7 implies Theorem 5, since it is easy to obtain an integer point in D ( P ):numerically rounding up x ∗ (or any fractional point in P ) gives us a point in D ( P ). Hence,we can assume in the proof below that ˜ x i = 0 for i = t + 1 , . . . , n .9 .1 Proof of Lemma 7: The DomToIP Algorithm We introduce an algorithm that builds a solution from the input integral point ˜ x . It finalizesa binary value for each variable iteratively, starting from the first coordinate and endingat the t -th coordinate. In iteration (cid:96) ∈ { , . . . , t − } , if ˜ x (cid:96) +1 = 1, the algorithm reducesthe (cid:96) + 1st coordinate of the solution to 0 if there is an LP-feasible point x (cid:48) that respectsthe decisions made so far, and has x (cid:48) (cid:96) = 0. Intuitively, we can fix this coordinate to 0 inthe partial solution and still set the remaining coordinates to find the solution promised inLemma 7. . More specifically, in iteration (cid:96) ∈ { , . . . , t − } we produce x ( (cid:96) ) ∈ D ( P ) suchthat x ( (cid:96) ) i ∈ { , } for i = 1 , . . . , (cid:96) . These (cid:96) components will not change for the remainder ofthe algorithm.We can set x (0) = ˜ x . We now show how to find x ( (cid:96) +1) from x ( (cid:96) ) . Consider the followinglinear program. The variables of this linear program are the z ∈ R n .FixNextVarLP( x ( (cid:96) ) ) min z (cid:96) +1 (8)s.t. Az ≥ b (9)s.t. z j = x ( (cid:96) ) j j = 1 , . . . , (cid:96) (10)s.t. z j ≤ x ( (cid:96) ) j j = (cid:96) + 1 , . . . , n (11)s.t. z ≥ x ( (cid:96) ) ) is 0, then let x ( (cid:96) +1) (cid:96) +1 = 0. Otherwise if theoptimal value is strictly positive let x ( (cid:96) +1) (cid:96) +1 = 1. Let x ( (cid:96) +1) j = x ( (cid:96) ) j for j ∈ [ n ] \ { (cid:96) + 1 } . TheDomToIP algorithm initializes with x (0) = ˜ x and iteratively calls this procedure in order toobtain x ( t ) (See Algorithm 1). Algorithm 1:
The DomToIP algorithm
Input: ˜ x ∈ D ( P ), ˜ x ∈ { , } n Output: x ( t ) ∈ S , x ( t ) ≤ ˜ x x (0) ← ˜ x for (cid:96) = 0 to t − do x ( (cid:96) +1) ← x ( (cid:96) ) η ← optimal value of FixNextVarLP( x ( (cid:96) ) ) if η = 0 then x ( (cid:96) +1) (cid:96) +1 ← else x ( (cid:96) +1) (cid:96) +1 ← end end
10e prove that indeed x ( t ) ∈ S . First, we need to show that in any iteration (cid:96) = 0 , . . . , t − x ( (cid:96) ) ) is feasible. We show something stronger. For (cid:96) =0 , . . . , t − ( (cid:96) ) = { z ∈ P : z ≤ x ( (cid:96) ) and z j = x ( (cid:96) ) j for j ∈ [ (cid:96) ] } , andIP ( (cid:96) ) = { z ∈ LP ( (cid:96) ) : z ∈ { , } n } . If LP ( (cid:96) ) is a non-empty set then FixNextVarLP( x ( (cid:96) ) ) is feasible. We show by induction on (cid:96) that LP ( (cid:96) ) and IP ( (cid:96) ) are not empty sets for (cid:96) = 0 , . . . , t −
1. First, LP (0) is feasible sinceby definition x (0) ∈ D ( P ), meaning there exists z ∈ P such that z ≤ x (0) . By Theorem 3,there exists ˜ z i ∈ S and θ i ≥ i ∈ [ k ] such that (cid:80) ki =1 θ i = 1 and (cid:80) ki =1 θ i ˜ z i ≤ gz . (Thisassumes a finite integrality gap g ). Hence, (cid:80) ki =1 θ i ˜ z i ≤ gz ≤ gx (0) . So if x (0) j = 0, then (cid:80) ki =1 θ i ˜ z ij = 0, which implies that ˜ z ij = 0 for all i ∈ [ k ] and j ∈ [ n ] where x (0) j = 0. Hence,˜ z i ≤ x (0) for i ∈ [ k ]. Therefore ˜ z i ∈ IP (0) for i ∈ [ k ], which implies IP (0) (cid:54) = ∅ .Now assume IP ( (cid:96) ) is non-empty for some (cid:96) ∈ [ t − ( (cid:96) ) ⊆ LP ( (cid:96) ) we have LP ( (cid:96) ) (cid:54) = ∅ and hence the FixNextVarLP( x ( (cid:96) ) ) has an optimal solution z ∗ .We consider two cases. In the first case, we have z ∗ (cid:96) +1 = 0. In this case we set x ( (cid:96) +1) (cid:96) +1 = 0.Since z ∗ ≤ x ( (cid:96) +1) , we have z ∗ ∈ LP ( (cid:96) +1) . Also, z ∗ ∈ P . By Theorem 3 there exists˜ z i ∈ S and θ i ≥ i ∈ [ k ] such that (cid:80) ki =1 θ i = 1 and (cid:80) ki =1 θ i ˜ z i ≤ gz ∗ . We have (cid:80) ki =1 θ i ˜ z i ≤ gz ∗ ≤ gx ( (cid:96) +1) . So for j ∈ [ n ] where x ( (cid:96) +1) j = 0, we have z ij = 0 for i ∈ [ k ].This implies ˜ z i ≤ x ( (cid:96) +1) for i = 1 , . . . , k . Hence, there exists z ∈ S such that z ≤ x ( (cid:96) +1) .We claim that z ∈ IP ( (cid:96) +1) . If z / ∈ IP ( (cid:96) +1) we must have 1 ≤ j ≤ (cid:96) such that z j < x ( (cid:96) +1) j ,and thus z j = 0 and x ( (cid:96) +1) j = 1. Without loss of generality assume j is the minimumindex (between 1 and (cid:96) ) satisfying z j < x ( (cid:96) +1) j . Consider iteration j of the DomToIPalgorithm. We have z ≤ x ( (cid:96) +1) ≤ x ( j ) . We also have x ( j ) j = 1 which implies when wesolved FixNextVarLP( x ( j − ) the optimal value was strictly larger than zero. However, z is a feasible solution to FixNextVarLP( x ( j − ) and gives an objective value of 0. This is acontradiction, so z ∈ IP ( (cid:96) +1) .Now for the second case, assume z ∗ (cid:96) +1 >
0. We set x ( (cid:96) +1) (cid:96) +1 = 1. For each point z ∈ LP ( (cid:96) ) we have z (cid:96) +1 >
0, so for each z ∈ IP ( (cid:96) ) we have z (cid:96) +1 >
0, i.e. z (cid:96) +1 = 1. This means that z ∈ IP ( (cid:96) +1) , and IP ( (cid:96) +1) (cid:54) = ∅ .Now consider x ( t ) . Let z be the optimal solution to LP ( t − . If x ( t ) t = 0, we have x ( t ) = z ,which implies that x ( t ) ∈ P , and since x ( t ) ∈ { , } n we have x ( t ) ∈ S . If x ( t ) t = 1, it mustbe the case that z t >
0. By the argument above there is a point z (cid:48) ∈ IP ( t − . We showthat x ( t ) = z (cid:48) . For j ∈ [ t −
1] we have z (cid:48) j = x ( t − j = x ( t ) j . We just need to show that z (cid:48) t = 1. Assume z (cid:48) t = 0 for contradiction. Then z (cid:48) ∈ LP ( t − has objective value 0 for11ixNextVarLP( x ( t − ). This is a contradiction to z being the optimal solution to LP ( t − .This concludes the proof of Lemma 7. Recall that x ∗ was the optimal solution to minimizing a cost function cx over set P , whichprovides a lower bound on min ( x,y ) ∈ S ( I ) cx . In this section, we prove Theorem 4 by describingthe Fractional Decomposition Tree (FDT) algorithm. We also remark that if g ( I ) = 1, thenthe algorithm gives an exact decomposition of any feasible solution.The FDT algorithm grows a tree similar to the classic branch-and-bound search tree forinteger programs. Each node represents a partially integral vector ¯ x in D ( P ) together witha multiplier ¯ λ . The solutions contained in the nodes of the tree become progressively moreintegral at each level. In each level of the tree, the algorithm maintain a conic combinationof points with the properties mentioned above. Leaves of the FDT tree contain integralsolutions that dominate a point in P . In Lemma 7 we saw how to turn these into points in S . Branching on a node.
We begin with the following lemmas that show how the FDTalgorithm branches on a variable.
Lemma 8.
Given x (cid:48) ∈ D ( P ) and (cid:96) ∈ [ n ] where x (cid:48) (cid:96) < , in polynomial time we can findvectors ˆ x , ˆ x and scalars γ , γ ∈ [0 , such that: (i) γ + γ ≥ /g , (ii) ˆ x and ˆ x are in P , (iii) ˆ x (cid:96) = 0 and ˆ x (cid:96) = 1 , and (iv) γ ˆ x + γ ˆ x ≤ x (cid:48) .Proof. Consider the following linear program which we denote by LPC( (cid:96), x (cid:48) ). The variablesof LPC( (cid:96), x (cid:48) ) are λ , λ , x and x .LPC( (cid:96), x (cid:48) ) max λ + λ (13)s.t. Ax j ≥ bλ j for j = 0 , ≤ x j ≤ λ j for j = 0 , x (cid:96) = 0 , x (cid:96) = λ (16)s.t. x + x ≤ x (cid:48) (17)s.t. λ , λ ≥ y , y , λ ∗ , and λ ∗ be an optimal solution to the LP above. Set γ = λ ∗ and γ = λ ∗ .Let ˆ x = y /λ ∗ , ˆ x = y /λ ∗ . This choice satisfies (ii), (iii), (iv). To show that (i) is alsosatisfied we prove the following claim. Claim 1.
We have γ + γ ≥ /g . roof. We show that there is a feasible solution that achieves the objective value of g .By Theorem 3 there exists θ ∈ [0 , k , with (cid:80) ki =1 θ i = 1 and ˜ x i ∈ S for i ∈ [ k ] such that (cid:80) ki =1 θ i ˜ x i ≤ gx (cid:48) . So x (cid:48) ≥ k (cid:88) i =1 θ i g ˜ x i = (cid:88) i ∈ [ k ]:˜ x i(cid:96) =0 θ i g ˜ x i + (cid:88) i ∈ [ k ]:˜ x i(cid:96) =1 θ i g ˜ x i . (19)For j = 0 ,
1, let x j = (cid:80) i ∈ [ k ]:˜ x i(cid:96) = j θ i g ˜ x i . Also let λ = (cid:80) i ∈ [ k ]:˜ x i(cid:96) =0 θ i g and λ = (cid:80) i ∈ [ k ]:˜ x i(cid:96) =1 θ i g .Note that λ + λ = 1 /g . Constraint (17) is satisfied by Inequality (19). Also, for j = 0 , Ax j = (cid:88) i ∈ [ k ] , ˜ x i(cid:96) = j θ i g A ˜ x i ≥ b (cid:88) i ∈ [ k ] , ˜ x i(cid:96) = j θ i g = bλ j . (20)Hence, Constraints (14) holds. Constraint (16) also holds since x (cid:96) is obviously 0 and x (cid:96) = (cid:80) i ∈ [ k ]:˜ x i(cid:96) =1 θ i g = λ . The rest of the constraints trivially hold. ♦ This concludes the proof of Lemma 8.We now show if x (cid:48) in the statement of Lemma 8 is partially integral, we can find solutionswith more integral components. Lemma 9.
Given x (cid:48) ∈ D ( P ) where x (cid:48) , . . . , x (cid:48) (cid:96) − ∈ { , } and x (cid:48) (cid:96) < for some (cid:96) ≥ wecan find in polynomial time vectors ˆ x , ˆ x and scalars γ , γ ∈ [0 , such that: (i) /g ≤ γ + γ ≤ , (ii) ˆ x and ˆ x are in D ( P ) , (iii) ˆ x (cid:96) = 0 and ˆ x (cid:96) = 1 , (iv) γ ˆ x + γ ˆ x ≤ x (cid:48) ,(v) ˆ x ij ∈ { , } for i = 0 , and j ∈ [ (cid:96) − .Proof. By Lemma 8 we can find ¯ x , ¯ x , γ and γ that satisfy (i), (ii), (iii), and (iv). Wedefine ˆ x and ˆ x as follows. For i = 0 ,
1, for j ∈ [ (cid:96) − x ij = (cid:100) ¯ x ij (cid:101) , for j = (cid:96), . . . , t letˆ x ij = ¯ x ij .We now show that ˆ x , ˆ x , γ , and γ satisfy all the conditions. Note that conditions (i),(ii), (iii), and (v) are trivially satisfied. Thus we only need to show (iv) holds. We needto show that γ ˆ x j + γ ˆ x j ≤ gx (cid:48) j . If j = (cid:96), . . . , t , then this clearly holds. Hence, assume j ≤ (cid:96) −
1. By the property of x (cid:48) we have x (cid:48) j ∈ { , } . If x (cid:48) j = 0, then by Constraint (17) wehave ¯ x j = ¯ x j = 0. Therefore, ˆ x ij = 0 for i = 0 ,
1, so (iv) holds. Otherwise if x (cid:48) j = 1, then wehave γ ˆ x j + γ ˆ x j ≤ γ + γ ≤ ≤ x (cid:48) j . Therefore (v) holds.
Growing and Pruning FDT tree.
The FDT algorithm maintains nodes L i in iteration i of the algorithm. The nodes in L i correspond to the nodes in level L i of the FDT tree.The points in the leaves of the FDT tree, L t , are points in D ( P ) and are integral for allinteger variables. 13 emma 10. There is a polynomial time algorithm that produces sets L , . . . , L t of pairs of x ∈ D ( P ) together with multipliers λ with the following properties for i = 0 , . . . , t : (a) If x ∈ L i , then x j ∈ { , } for j ∈ [ i ] , i.e. the first i coordinates of a solution in level i areintegral, (b) (cid:80) [ x,λ ] ∈ L i λ ≥ g i , (c) (cid:80) [ x,λ ] ∈ L i λx ≤ x ∗ , (d) | L i | ≤ t .Proof. We prove this lemma using induction but one can clearly see how to turn this proofinto a polynomial time algorithm. Let L be the set that contains a single node ( root of theFDT tree ) with x ∗ and multiplier 1. All the requirements in the lemma are satisfied for thischoice.Suppose by induction that we have constructed sets L , . . . , L i . Let the solutionsin L i be x j for j ∈ [ k ] and λ j be their multipliers, respectively. For each j ∈ [ k ] if x ji +1 = 1 we add the pair ( x j , λ j ) to L (cid:48) . Otherwise, applying Lemma 9 (setting x (cid:48) = x j and (cid:96) = i + 1) we can find x j , x j , λ j and λ j with the properties (i) to (v) in Lemma 9.Add the pairs ( x j , λ j λ j ) and ( x j , λ j λ j ) to L (cid:48) . It is easy to check that set L (cid:48) is a suitablecandidate for L i +1 , i.e. set L (cid:48) satisfies (a), (b) and (c). However we can only ensure that | L (cid:48) | ≤ k ≤ t , and might have | L (cid:48) | > t . We call the following linear program Pruning( L (cid:48) ).Let L (cid:48) = { [ x , γ ] , . . . , [ x | L (cid:48) | , γ | L (cid:48) | ] } . The variables of Pruning( L (cid:48) ) are scalar variables θ j foreach node j in L (cid:48) .Pruning( L (cid:48) ) { max | L (cid:48) | (cid:88) j =1 θ j : | L (cid:48) | (cid:88) j =1 θ j x ji ≤ x ∗ i for i ∈ [ t ] , θ ≥ } (21)Setting θ = γ gives a feasible solution to Pruning( L (cid:48) ). Let θ ∗ be the optimal vertexsolution to this LP. Since the problem is in R | L (cid:48) | , θ ∗ has to satisfy | L (cid:48) | linearly independentconstraints at equality. However, there are only t constraints of type (cid:80) | L (cid:48) | j =1 θ j x ji ≤ x ∗ i .Therefore, there are at most t coordinates of θ ∗ j that are non-zero. Set L i +1 which consistsof x j for j = 1 , . . . , | L (cid:48) | and their corresponding multipliers θ ∗ j satisfy the properties in thestatement of the lemma. We can discard the nodes in L i +1 that have θ ∗ j = 0, so | L i +1 | ≤ t .Also, since θ ∗ is optimal and γ is feasible for Pruning( L (cid:48) ), we have (cid:80) | L (cid:48) | j =1 θ ∗ j ≥ (cid:80) | L (cid:48) | j =1 γ j ≥ g i +1 . From leaves of FDT to feasible solutions.
For the leaves of the FDT tree, L t , wehave that every solution x in L t has x ∈ { , } n and x ∈ D ( P ). By applying Lemma 7 wecan obtain a point x (cid:48) ∈ S such that x (cid:48) ≤ x . This concludes the description of the FDT14lgorithm and proves Theorem 4. See Algorithm 2 for a summary of the FDT algorithm. Algorithm 2:
Fractional Decomposition Tree Algorithm
Input: P = { x ∈ R n : Ax ≥ b } and S = { x ∈ P : x ∈ { , } n } such that g = max c ∈ R n + min x ∈ S cx min x ∈ P cx is finite, x ∗ ∈ P Output: z i ∈ S and λ i ≥ i ∈ [ k ] such that (cid:80) ki =1 λ i = 1, and (cid:80) ki =1 λ i z i ≤ g t x ∗ L ← [ x ∗ , for i = 1 to t do L (cid:48) ← ∅ for [ x, λ ] ∈ L i do Apply Lemma 9 to obtain [ˆ x , γ ] and [ˆ x , γ ] L (cid:48) ← L (cid:48) ∪ { [ˆ x , λ · γ ] } ∪ { [ˆ x , λ · γ ] } end Apply Lemma 10 to prune L (cid:48) to obtain L i +1 . end for [ x, λ ] ∈ L t do Apply Algorithm 1 to x to obtain z ∈ S F ← F ∪ { [ z, λ ] } end return F There are O ( n ) nodes in the FDT tree. A faster way to achieve feasible solutions withgood quality for an IP with bounded integrality gap is an algorithm that takes a randomdive into the FDT tree, hence only visiting O ( n ) nodes. Algorithm 3:
Dive FDT Algorithm
Input: P = { x ∈ R n : Ax ≥ b } and S = { x ∈ P : x ∈ { , } n } such that g = max c ∈ R n + min x ∈ S cx min x ∈ P cx is finite, x ∗ ∈ P Output: z ∈ S y = x ∗ for i = 1 to t do Apply Lemma 9 to obtain [ˆ x , γ ] and [ˆ x , γ ] i ∼ Bernoulli( γ γ + γ ) y → ˆ x i end Apply Algorithm 1 to y to obtain z ∈ S return z FDT for 2EC
In Section 3 our focus was on binary IPs. In this section, in an attempt to extend FDT to { } problems we introduce an FDT algorithm for a 2-edge-connected multi-subgraphproblem. Given a graph G = ( V, E ) a multi-subset of edges F of G is a 2-edge-connectedmulti-subgraph of G if for each set ∅ ⊂ U ⊂ V , the number of edges in F that have oneendpoint in U and one not in U is at least 2. In 2EC, we are given non-negative costs onthe edges of G and the goal is to find the minimum cost 2-edge-connected multi-subgraph of G . We want to prove Theorem 6. Theorem 6.
Let G = ( V, E ) and x be an extreme point of Subtour( G ) . The FDT algorithmfor 2EC produces λ ∈ [0 , k and 2-edge-connected multi-subgraphs F , . . . , F k such that k ≤ | V | − , (cid:80) ki =1 λ i χ F i ≤ min( Cx, { } n ) , and (cid:80) ki =1 λ i = 1 . Moreover, C ≤ g (2EC) | E x | . We do not know the exact value for g (2EC), but we know ≤ g (2EC) ≤ [ABE06,Wol80]. The FDT algorithm for 2EC is very similar to the one for binary IPs, but there aresome differences as well. A natural thing to do is to have three branches for each node ofthe FDT tree, however, the branches that are equivalent to setting a variable to 1, mightneed further decomposition. That is the main difficulty when dealing with { , , } -IPs.First, we need a branching lemma. Observe that the following branching lemma isessentially a translation of Lemma 8 for { , , } problems except for one additional clause. Lemma 11.
Given x ∈ Subtour( G ) , and e ∈ E we can find in polynomial time vectors x , x and x and scalars γ , γ , and γ such that: (i) γ + γ + γ ≥ /g (2EC) , (ii) x , x , and x are in Subtour( G ) , (iii) x e = 0 , x e = 1 , and x e = 2 , (iv) γ x + γ x + γ x ≤ x ,(v) for f ∈ E with x f ≥ , we have x jf ≥ for j = 0 , , .Proof. Consider the following LP with variables λ j and x j for j = 0 , , (cid:88) j =0 , , λ j (22)s.t. x j ( δ ( U )) ≥ λ j for ∅ ⊂ U ⊂ V , and j = 0 , , ≤ x j ≤ λ j for j = 0 , , x je = j · λ j for j = 0 , , x jf ≥ λ j for f ∈ E where x f ≥
1, and j = 0 , , x + x + x ≤ x (27)s.t. λ , λ , λ ≥ x j , γ j for j = 0 , , x j = x j /γ j for j = 0 , , γ j >
0. If γ j = 0, let ˆ x j = 0. Observe that (ii), (iii), (iv), and (v) are16atisfied with this choice. We can also show that γ + γ + γ ≥ /g (2EC), which meansthat (i) is also satisfied. The proof is similar to the proof of the claim in Lemma 8, but weneed to replace each f ∈ E with x f ≥ Claim 2.
We have γ + γ + γ ≥ g (2EC) .Proof. Suppose for contradiction (cid:80) j =0 , , γ j = g (2EC) − (cid:15) for some (cid:15) >
0. Construct graph G (cid:48) by removing edge f with x f ≥ P f of length (cid:100) (cid:15) (cid:101) . Define x (cid:48) h = x h for each edge h such that x h <
1. For each h ∈ P f let x (cid:48) h = x f for all f with x f ≥
1. It is easy to check that x (cid:48) ∈ Subtour( G (cid:48) ). By Theorem 3 there exists θ ∈ [0 , k ,with (cid:80) ki =1 θ i = 1 and 2-edge-connected multi-subgraphs F (cid:48) i of G (cid:48) for i = 1 , . . . , k such that (cid:80) ki =1 θ i χ F (cid:48) i ≤ g (2EC) x (cid:48) .Each F (cid:48) i contains at least one copy of every edge in any path P f , except for at most oneedge in the path. We will obtain 2-edge-connected multi-subgraphs F , . . . , F k of G using F (cid:48) , . . . , F (cid:48) k , respectively. To obtain F i first remove all P f paths from F (cid:48) i . Suppose there isan edge h in P f such that χ F (cid:48) i h = 0, this means that for any edge p ∈ P f such that p (cid:54) = h , χ F (cid:48) i p = 2. In this case, let χ F i f = 2, i.e. add two copies of f to F i . If there are at least oneedge h ∈ P f with χ F (cid:48) i h = 1, let χ F i f = 1, i.e. add one copy of f to F i . If for all edges h ∈ P f ,we have χ F (cid:48) i h = 2, then let χ F i f = 2. For f ∈ E with x f < k (cid:88) i =1 θ i χ F i f = k (cid:88) i =1 θ i χ F (cid:48) i f ≤ g (2EC) x (cid:48) f = g (2EC) x f . (29)In addition for f ∈ E with x f ≥ χ F i f ≤ (cid:80) h ∈ Pf χ F (cid:48) ih (cid:100) (cid:15) (cid:101)− by construction. k (cid:88) i =1 θ i χ F i f ≤ k (cid:88) i =1 θ i (cid:80) h ∈ P f χ F (cid:48) i h (cid:100) (cid:15) (cid:101) − (cid:80) h ∈ P f (cid:80) ki =1 θ i χ F (cid:48) i h (cid:100) (cid:15) (cid:101) − ≤ (cid:80) h ∈ P f g (2EC) x (cid:48) h (cid:100) (cid:15) (cid:101) − (cid:80) h ∈ P f g (2EC) x f (cid:100) (cid:15) (cid:101) − (cid:100) (cid:15) (cid:101)(cid:100) (cid:15) (cid:101) − g (2EC) x f . (cid:100) (cid:15) (cid:101)(cid:100) (cid:15) (cid:101)− ≥
1, we have x ≥ (cid:88) i ∈ [ k ]: χ Fie =0 θ i ( (cid:100) (cid:15) (cid:101) − g (2EC) (cid:100) (cid:15) (cid:101) χ F i + (cid:88) i ∈ [ k ]: χ Fie =1 θ i ( (cid:100) (cid:15) (cid:101) − g (2EC) (cid:100) (cid:15) (cid:101) χ F i + (cid:88) i ∈ [ k ]: χ Fie =2 θ i ( (cid:100) (cid:15) (cid:101) − g (2EC) (cid:100) (cid:15) (cid:101) χ F i . (30)Let x j = (cid:80) i ∈ [ k ]: χ Fie = j θ i ( (cid:100) (cid:15) (cid:101)− g (2EC) (cid:100) (cid:15) (cid:101) χ F i and θ j = (cid:80) i ∈ [ k ]: χ Fie = j θ i ( (cid:100) (cid:15) (cid:101)− g (2EC) (cid:100) (cid:15) (cid:101) for j = 0 , ,
2. It iseasy to check that x j , θ j for j = 0 , , (cid:80) j =0 , , θ j = (cid:100) (cid:15) (cid:101)− g (2EC) (cid:100) (cid:15) (cid:101) . By assumption, we have (cid:100) (cid:15) (cid:101)− g (2EC) (cid:100) (cid:15) (cid:101) ≤ g (2EC) − (cid:15) , which is acontradiction. ♦ This concludes the proof.In contrast to FDT for binary IPs where we round up the fractional variables that arealready branched on at each level, in FDT for 2EC we keep all coordinates as they areand perform a rounding procedure at the end. Formally, let L i for i = 1 , . . . , | supp( x ∗ ) | be collections of pairs of feasible points in Subtour( G ) together with their multipliers. Let t = | supp( x ∗ ) | and assume without loss of generality that supp( x ∗ ) = { e , . . . , e t } . Lemma 12.
The FDT algorithm for 2EC in polynomial time produces sets L , . . . , L t of pairs x ∈ G ) together with multipliers λ with the following properties for i ∈ [ t ] :(a) If x ∈ L i , then x e j = 0 or x e j ≥ for j = 1 , . . . , i , (b) (cid:80) ( x,λ ) ∈ L i λ ≥ g (2EC) i , (c) (cid:80) ( x,λ ) ∈ L i λx ≤ x ∗ , (d) | L i | ≤ t . The proof is similar to Lemma 10, but we need to use property (v) in Lemma 11 toprove that (a) also holds.
Proof.
We proceed by induction on i . Define L = { ( x ∗ , } . It is easy to check all theproperties are satisfied. Now, suppose by induction we have L i − for some i = 1 , . . . , t thatsatisfies all the properties. For each solution x (cid:96) in L i − apply Lemma 11 on x (cid:96) and e i toobtain x (cid:96)j and λ (cid:96)j for j = 0 , ,
2. Let L (cid:48) be the collection that contains ( x (cid:96)j , λ (cid:96) · λ (cid:96)j ) for j = 0 , ,
2, when applied to all ( x (cid:96) , λ (cid:96) ) in L i − . Similar to the proof in Lemma 10 one cancheck that L i satisfies properties (b), (c). We now verify property (a). Consider a solution x (cid:96) in L i − . For e ∈ { e , . . . , e i − } if x (cid:96)e = 0, then by property (iv) in Lemma 11 we have x (cid:96)j = 0 for j = 0 , ,
2. Otherwise by induction we have x (cid:96)e ≥ x (cid:96)je ≥ j = 0 , ,
2. Also, x (cid:96)je i = j , so x (cid:96)je i = 0 or x (cid:96)je i ≥ j = 0 , , | L (cid:48) | ≤ t we let L i = L (cid:48) , otherwise apply Pruning( L (cid:48) ) to obtain L i .Consider the solutions x in L t . For each variable e we have x e = 0 or x e ≥ emma 13. Let x be a solution in L t . Then (cid:98) x (cid:99) ∈ Subtour( G ) .Proof. Suppose not. Then there is a set of vertices ∅ ⊂ U ⊂ V such that (cid:80) e ∈ δ ( U ) (cid:98) x e (cid:99) < x ∈ Subtour( G ) we have (cid:80) e ∈ δ ( U ) x e ≥
2. Therefore, there is an edge f ∈ δ ( U ) suchthat x f is fractional. By property (a) in Lemma 12, we have 1 < x f <
2. Therefore, thereis another edge h in δ ( U ) such that x h >
0, which implies that x h ≥
1. But in this case (cid:80) e ∈ δ ( U ) (cid:98) x e (cid:99) ≥ (cid:98) x f (cid:99) + (cid:98) x h (cid:99) ≥
2. This is a contradiction.The FDT algorithm for 2EC iteratively applies Lemmas 11 and 12 to variables x , . . . , x t to obtain leaf point solutions L t . Finally, we just need to apply Lemma 13 to obtain the2-edge-connected multi-subgraphs from every solution in L t . Since x is an extreme point wehave t ≤ | V | − (cid:88) ( x,λ ) ∈ L t λ (cid:80) ( x,λ ) ∈ L t λ (cid:98) x (cid:99) ≤ (cid:80) ( x,λ ) ∈ L t λ (cid:88) ( x,λ ) ∈ L t λx ≤ g t x ∗ . We ran FDT on three network design problems: VC, TAP and 2EC.We implemented the experiments for VC and TAP in Python running on a linuxworkstation (Ubuntu 18.04.3) with 8 cores of Intel(R) Core(TM) i7-8565U CPU 1.80GHzprocessors and 1Mb of cache. We used the CPLEX 12.9.0.0 solver to solve the pyomo LPmodels. We ran the experiments for 2EC on a Windows machine, coded in AMPL withCPLEX as the solver.
FDT on VC instances from (PACE 2019) [DFH19].
We compared Dive FDT (Algo-rithm 3) with feasbility pump [FGL05] in terms of running time and the quality of solutionprovided by each algorithm. We used the small (200 vertex) test cases from the PACE 2019vertex-cover challenge. The results are presented in Figure 1a.
FDT on randomly generated instances of TAP.
Recall that in the tree augmentationproblem (TAP) we are given a tree T = ( V, E ), a set of non-tree links L between vertices in V and costs c ∈ R L ≥ . A feasible augmentation is L (cid:48) ⊆ L such that T + L (cid:48) is 2-edge-connected.In TAP we wish to find the minimum-cost feasible augmentation. The integrality gap of thecut LP for TAP (given in (7)) is g (TAP) = max c ∈ R L ≥ min x ∈ TAP(
T,L ) cx min x ∈ CUT(
T,L ) cx , a) Dive FDT vs feasbility pump on the instancesof PACE 2019 [DFH19] with 200 vertices. (b) TAP on our random instances: FDT run on LPoptimal vs the 2-approximation for TAP[FJ81]. Figure 1: Computational experiments with the FDT algorithmwhere TAP(
T, L ) is the feasible set for the IP and CUT(
T, L ) is the feasible set for the cutLP (relaxation). We know ≤ g (TAP) ≤ x ∈ TAP(
T,L ) cx isbinary.As input for our experiments, we considered full binary trees with 3 to 7 levels with alink for each pairs of leaves. We set the link costs uniformly at random. We summarize thesetest instances in Table 1. We ran binary FDT on each test instance and chose the solutionwith minimum cost. We compare the FDT solutions to those from the circulation-based2-approximation algorithm of Frederickson and J´aJ´a [FJ81] in Figure 1b. The simple FJheuristic was faster than FDT, from about 8x to about 60x on our examples. However, FDTstill ran in less than a minute on the bigger problems and less than 10 seconds on the others.FDT (in the worst case) solves Ω( m ) LPs, where m is the number of edges, and FJ solvesone LP. So the difference in running time, which depends on instance size, is not surprising.FDT runs in polynomial time and usually gives much better solutions than FJ. number of edges in T number of links in L number of instances ( T, L )6 6 10014 28 10030 120 10062 496 100126 2016 100
Table 1: Summary of the randomly generated instances of TAP.For all 500 instances in our experiments, running FDT on the LP optimal (fractional20xtreme point) of the cut LP gave a feasible solution with value at most a factor largerthan the LP lower bound. Such a feasible solution gives an upper bound on the integralitygap g (TAP) of that specific instance of at most . In fact, the integrality gap upper boundderived this way was equal to for only one instance. For 480 instances, the integrality gapupper bound was , for 16 instances it was , for 2 instances it was , for 1 instance it was . Computational comparison between Christofides’ algorithm and FDT for 2ECon Carr-Vempala points.
As described in Section 1.2.3, when the LP optimum for (3)is a Carr-Vempala point (see Figure 2), the integrality gap of that instance is equal tothat of 2EC. So in that sense, these are the hardest fractional points to round to a feasiblesolution. We now compare the quality of FDT’s solution from a Carr-Vempala point tothat of Christofides, the best known approximation algorithm. In the classic graph-basedChristofides algorithm for TSP, find a minimum spanning tree of the graph. Then, since TSPruns on a complete graph, add a perfect matching on the vertices that have odd degree inthe spanning tree to make the (multi)-subgraph 2-edge-connected. If we stop that algorithmwithout shortcutting, we have a feasible solution for Metric-2EC (given a complete graph,find the minimum-cost 2-edge-connected subgraph, with no multiedges). For 2EC, insteadof a matching, we add an O -join, where O is the set of odd-degree vertices in the spanningtree . The best-of-many Christofides (BOMC) algorithm [AKS15] works better than theclassic Christofides algorithm in practice [GW17]. The BOMC algorithm samples manyspanning trees from the LP relaxation (with edges chosen proportionally to the LP value),augments each spanning tree with the matching, and takes the best solution.The polyhedral analysis of Christofides shows that if x ∈ Subtour( G ), then x dominatesa convex combination of connected Eulerian (hence 2-edge-connected) multi-subgraphsof G [Wol80, SW90]. This bound holds for any point x ∈ Subtour( G ) for any graph G ,including any Carr-Vempala point. We show how this bound can be improved for specificinstances by doing a slightly improved analysis of the algorithm.Let x be a Carr-Vempala point (from (3)) defined on a graph G = ( V, E ). If x ∈ Subtour( G ), then | V |− | V | x can be written as a convex combination of spanning trees of G (See Proposition 2 in [Vyg12] for instance). More explicitly, | V | − | V | · x = k (cid:88) i =1 λ i χ T i , (31) For graph G = ( V, E ) and O ⊆ V with | O | even, an O -join of G is a subgraph of G that has odd degreeon the vertices in O and even degree on vertices in V \ O . Graphs always have an even number of odd verticessince every edge has two endpoints, giving an even number of endpoints. T i is spanning tree of G , χ T i is its incidence vector, (cid:80) ki =1 λ i = 1, and λ i ≥ i ∈ [ k ].The spanning-tree polytope is integral so there are polynomial-time algorithms to constructthis decomposition (See Proposition 2 and surrounding discussion).Let O i be the set of odd-degree vertices of spanning tree T i . Adding an O i -join to tree T i gives a solution to 2EC. We solve the following LP that allows us to find edges thatsimultaneously augment all the spanning trees to solutions to 2EC.min { α : k (cid:88) i =1 λ i y i = α · x, y i ∈ D ( O i - JOIN( G )) for i ∈ [ k ] } . (32)The variables in the above LP are y i ∈ R E ≥ for i ∈ [ k ], where E is the number of edges inthe graph. The parameters λ i are those we computed in (31). For each i ∈ [ k ], we require y i to be in the dominant of O i - JOIN( G ). We enforce this by adding a set of constraintsfor each i from [Sch03, p. 490]. These constraints force the inclusion of at least one edgefrom the cut associated with each set of vertices that have an even number of elements from O i . The y i need not be integer vectors. Because the O i -join polytope is integral, we canreplace y i with a convex combination of O i -joins of G (proposition 2). Setting y i = x and α = gives a feasible solution to this LP, yielding an integrality gap of at most for thesubtour-elimination relaxation for the TSP [Wol80]. More generally, this method gives a( | V |− | V | + α )-approximation for the specific instance x .Figure 3 shows FDT’s solutions on all Carr-Vempala points that have 10 vertices onthe cycle formed by fractional edges. We show for these points the apporoximation factorprovided by FDT is always better than those from the polyhedral version of Christofides’algorithm. In Figure 3 the horizontal axis of the plot is indexed with the 60 Carr-Vempalapoints that we considered. For each Carr-Vempala point x , there are two data points. Thevalue of the first data point depicted by a circle on the vertical axis is | V |− | V | + α where α isthe optimal solution to (32). The value of the second data point depicted by a cross on thevertical axis is C where C is obtained from applying Theorem 6 to x . In other words, Figure3 is comparing the instance-specific upper bound on integrality gap certified by Christofides’algorithm to the approximation factor of the FDT algorithm for 2EC. FDT for 2EC on Carr-Vempala points.
We ran FDT for 2EC on 963 fractionalextreme points of Subtour( G ). We enumerated all (fractional) Carr-Vempala points with 10and 12 vertices. Table 2 shows that again FDT found solutions better than the integrality-gaplower bound for most instances. 22 2 34567 8Figure 2: A Carr-Vempala point with 8 vertices on its cycle. Solid lines are edges with valuestrictly between 0 and 1. Dashed edges represent paths where each edge on the path has x e = 1. There can be an arbitrary number of degree-2 vertices on the dashed paths.Figure 3: Polyhedral version of Christofides’ algorithm vs FDT on all Carr-Vempala pointsthat have 10 vertices on the single cycle formed by fractional edges. C ∈ [1 . , . C ∈ (1 . , . C ∈ (1 . , . C ∈ (1 . , . Table 2: FDT for 2EC implemented applied to all Carr-Vempala with 10 or 12 vertices.A Carr-Vempala point with k vertices has k edges. Thus, the upper bound provided byTheorem 6 is g (2EC) k/ . The lower bound on g (2EC) is . The results in Sections 2, 3 and 4 hold if the intial integer program has some auxilliarycontinuous variables . That is, when we have S ( A, b ) = { x ∈ Z n × R p : Ax ≥ b } , Here by auxilliary variables we mean a variable that does not participate in the objective function p variables are continous, P ( A, b ) = { x ∈ R n + p : Ax ≥ b } and define g ( I ) = max c ∈ R n + min x ∈ S ( A,b ) (cid:80) ni =1 c i x i min x ∈ P ( A,b ) (cid:80) ni =1 c i x i , our main results work. In fact our implementation of the subtour-elimination relaxation isbased on an extended formulation with auxiliary variables (see [CKL + References [ABCC06] David L. Applegate, Robert E. Bixby, Vaˇsek Chvat´al, and William J. Cook.
The Traveling Salesman Problem: A Computational Study . Princeton UniversityPress, 2006.[ABE06] Anthony Alexander, Sylvia Boyd, and Paul Elliott-Magwood. On the integralitygap of the 2-edge connected subgraph problem. Technical report, TR-2006-04,SITE, University of Ottawa, 2006.[AKS11] Per Austrin, Subhash Khot, and Muli Safra. Inapproximability of vertex coverand independent set in bounded degree graphs.
Theory of Computing , 7(3):27–43,2011.[AKS15] Hyung-Chan An, Robert Kleinberg, and David B. Shmoys. Improving christofides’algorithm for the s-t path TSP.
J. ACM , 62(5), November 2015.24BB08] Genevi`eve Benoit and Sylvia Boyd. Finding the exact integrality gap for smallTraveling Salesman Problems.
Mathematics of Operations Research , 33(4):921–931, 2008.[BC11] Sylvia Boyd and Robert Carr. Finding low cost TSP and 2-matching solutionsusing certain half-integer subtour vertices.
Discrete Optimization , 8(4):525 – 539,2011.[BL17] Sylvia Boyd and Philippe Legault. Toward a 6/5 bound for the minimum cost2-edge connected spanning subgraph.
SIAM J. Discrete Math. , 31:632–644, 2017.[BP90] S Boyd and W. R. Pulleyblank. Optimizing over the subtour polytope of thetravelling salesman problem.
Mathematical Programming , 49:163–187, 1990.[CCZ14] Michele Conforti, Gerard Cornuejols, and Giacomo Zambelli.
Integer Program-ming . Springer Publishing Company, Incorporated, 2014.[CKKK08] J. Cheriyan, H. Karloff, R. Khandekar, and J. K¨onemann. On the integralityratio for tree augmentation.
Operations Research Letters , 36(4):399 – 401, 2008.[CKL +
07] Robert D. Carr, Goran Konjevod, Greg Little, Venkatesh Natarajan, and OjasParekh. Compacting cuts: A new linear formulation for minimum cut. In
Proceedings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algo-rithms , SODA ’07, page 43–52, USA, 2007. Society for Industrial and AppliedMathematics.[CR98] Robert Carr and R. Ravi. A new bound for the 2-edge connected subgraphproblem. In
IPCO , 1998.[CV04] Robert Carr and Santosh Vempala. On the Held-Karp relaxation for the asym-metric and symmetric traveling salesman problems.
Mathematical Programming ,100(3):569–587, Jul 2004.[DFH19] M. Ayaz Dzulfikar, Johannes K. Fichte, and Markus Hecher. The PACE 2019Parameterized Algorithms and Computational Experiments Challenge: TheFourth Iteration (Invited Paper). In Bart M. P. Jansen and Jan Arne Telle,editors, , volume 148 of
Leibniz International Proceedings in Informatics(LIPIcs) , pages 25:1–25:23, Dagstuhl, Germany, 2019. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik.[Edm65] Jack Edmonds. Maximum matching and a polyhedron with 0, 1-vertices.
Journalof Research of the National Bureau of Standards B , 69:125–130, 1965.25Edm70] Jack Edmonds.
Submodular Functions, Matroids, and Certain Polyhedra , pages11–26. Springer Berlin Heidelberg, Berlin, Heidelberg, 1970.[FGL05] Matteo Fischetti, Fred Glover, and Andrea Lodi. The feasibility pump.
Mathe-matical Programming , 104(1):91–104, Sep 2005.[FJ81] Greg N. Frederickson and Joseph J´aJ´a. Approximation algorithms for severalgraph augmentation problems.
SIAM Journal on Computing , 10(2):270–283,1981.[FS09] Matteo Fischetti and Domenico Salvagnin. Feasibility pump 2.0.
MathematicalProgramming Computation , 1(2):201–222, Oct 2009.[GJ90] Michael R. Garey and David S. Johnson.
Computers and Intractability; A Guideto the Theory of NP-Completeness . W. H. Freeman & Co., USA, 1990.[GLS93] Martin Gr¨otschel, L´aszl´o Lov´asz, and Alexander Schrijver.
Geometric Algorithmsand Combinatorial Optimization , volume 2. Second corrected edition edition,1993.[Goe95] Michel X. Goemans. Worst-case comparison of valid inequalities for the TSP.
Mathematical Programming , 69(1):335–349, Jul 1995.[GW17] Kyle Genova and David P. Williamson. An experimental evaluation of the best-of-many Christofides’ algorithm for the traveling salesman problem.
Algorithmica ,78:1109–1130, 2017.[HN18] Arash Haddadan and Alantha Newman. Polynomial-time algorithms for 2-edge-connected subgraphs on fundamental classes by top-down coloring.
CoRR ,abs/1811.09906, 2018.[HT17] Sa¨ıd Hanafi and Raca Todosijevi´c. Mathematical programming based heuristicsfor the 0-1 mip: a survey.
Journal of Heuristics , 23(4):165–206, Aug 2017.[Sch03] A. Schrijver.
Combinatorial Optimization - Polyhedra and Efficiency . Springer,2003.[SW90] David B. Shmoys and David P. Williamson. Analyzing the held-karp tspbound: a monotonicity property with application.
Information ProcessingLetters , 35(6):281 – 285, 1990.[Vaz01] Vijay V. Vazirani.
Approximation Algorithms . Springer-Verlag, Berlin, Heidel-berg, 2001. 26Vyg12] Jens Vygen. New approximation algorithms for TSP.
Optima , 90:1–12, 2012.[Wol80] Laurence A. Wolsey.
Heuristic analysis, linear programming and branch andbound , pages 121–134. Springer Berlin Heidelberg, Berlin, Heidelberg, 1980.[WS11] David P. Williamson and David B. Shmoys.