Scanning integer points with lex-inequalities: a finite cutting plane algorithm for integer programming with linear objective

We consider the integer points in a unimodular cone K ordered by a lexicographic rule defined by a lattice basis. To each integer point x in K we associate a family of inequalities (lex-inequalities) that define the convex hull of the integer points in K that are not lexicographically smaller than x. The family of lex-inequalities contains the Chvátal–Gomory cuts, but does not contain and is not contained in the family of split cuts. This provides a finite cutting plane method to solve the integer program min{cx:x∈S∩Zn}\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\min \{cx: x\in S\cap \mathbb {Z}^n\}$$\end{document}, where S⊂Rn\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$S\subset \mathbb {R}^n$$\end{document} is a compact set and c∈Zn\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$c\in \mathbb {Z}^n$$\end{document}. We analyze the number of iterations of our algorithm.


Introduction
The area of integer nonlinear programming is rich in applications but quite challenging from a computational point of view. We refer to the articles (Belotti et al. 2013b;Burer and Letchford 2012) for comprehensive surveys on these topics. The tools that are mainly used are sophisticated techniques that exploit relaxations, constraint enforcement (e.g., cutting planes) and convexification of the feasible set. Reformulations in an extended space and cutting planes for integer nonlinear programs have been investigated and proposed for some time, see e.g. Ceria and Soares (1999), Frangioni and Gentile (2006), Stubbs and Mehrotra (1999). This line of research mostly provides a nontrivial extension of the theory of disjunctive programming to the nonlinear case. To the best of our knowledge, these results are obtained under some restrictive conditions: Typically, the feasible set is assumed to be convex or to contain 0/1 points only (these cases cover some important areas of application).
In this paper we present a finite cutting plane algorithm for problems of the form min{cx : x ∈ S ∩ Z n }, (1.1) where S is a compact subset of R n (not necessarily convex or connected) and c ∈ Z n . Our algorithm uses a new family of cutting planes which do not make any use of a description of the set S. The cutting planes employed in our algorithm are obtained as follows. We consider the integer points in a unimodular cone K , ordered by a lexicographic rule, associated with a lattice basis. To each integer point x in K , we associate a family of inequalities (lex-inequalities) that, in a sense, is best possible, as it defines the convex hull of the integer points in K that are not lexicographically smaller than x. Our family of cuts includes the Chvátal-Gomory cuts, but it does not contain, nor is it contained in, the family of split cuts. Our algorithm recursively solves optimization problems of the form min{cx : x ∈ S ∩ P}, where P is a polyhedron, and we assume that an algorithm for problems of this type is available as a black box. We remark that as long as this black box is available, no assumption on S other than compactness is required by our algorithm. To the best of our knowledge, this is in contrast to the rest of the literature where convexity (or even polyhedrality) is a common assumption.
The cuts we introduce are linear inequalites. As the convex hull of the integer points in a bounded subset of R n is a polytope, a finite number of linear inequalities suffices for its characterization, and only n such inequalities determine an optimal point. Furthermore a finite number of linear inequalities suffices to describe some relevant relaxations of the convex hull of the integer points in a bounded set: Most notably, Dadush et al. (2014) proved that the Chvátal-Gomory closure of a compact convex set is a polytope (whereas this is not the case for the split closure of the set).
However, nonlinear inequalities have also been successfully used to provide elegant convex hull characterizations. We mention the work by Andersen and Jensen (2013) where a formula to describe the convex hull of a split disjunction applied to a second-order cone is provided. Their work is related to the paper by Modaresi et al. (2016), where the authors derive split cuts for convex sets described by a single conic quadratic inequality and extend general intersection cuts to a wide variety of quadratic sets. Belotti et al. (2013aBelotti et al. ( , 2017 introduce the so called disjunctive conic cuts studying families of quadratic surfaces intersected with two given hyperplanes. Burer and Kılınç-Karzan (2017) extend the works cited above and show that the convex hull of the intersection of a second-order-cone representable set and a single homogeneous quadratic inequality can be described by adding a single nonlinear inequality, defining an additional second-order-cone representable set.
From an algorithmic perspective, deriving a finite cutting plane procedure that uses a well defined family of inequalities does not seem to be straightforward. The oldest and most notable example is Gomory's finite cutting plane algorithm for integer linear programming over bounded sets based on fractional cuts (Gomory 1958(Gomory , 1963. Other finite cutting plane algorithms (again for bounded sets) can be found in Armstrong et al. (1979), Bell (1973), Bowman and Nemhauser (1970), He and Lee (2017) for integer linear programming and in Lee and Wiegele (2017) for mixed integer linear programming.
While in all the papers cited above the correctness of the algorithms is based on a specific procedure for solving the continuous relaxation, there are methods that only assume that an optimal solution of the continuous relaxation is given by a black box. This is the case for the lift-and-project method of Balas et al. (1993) for mixed 0/1 linear problems, the procedure described by Orlin (1985) for 0/1 integer linear programming, and the algorithm presented by Neto (2012) for integer linear programming over bounded sets.
The family of cuts used in Neto's algorithm is related to ours. As it will be clarified later, the inequalities introduced in Neto (2012) are weaker than the lex-inequalities and, in particular, they are derived under the assumption that a box containing the set S is known.
We notice that a common feature of the above papers is the (explicit or implicit) use of some lexicographic rule for the choice of an optimal solution of the continuous relaxation or the selection of the cut. This seems to be a key tool to prove finite convergence of this type of algorithms.
The paper is organized as follows. In Sect. 2, we introduce the lex-inequalities with their properties. In Sect. 3, we present the cutting plane algorithm and we show that it terminates in a finite number of iterations. In Sect. 4, an instance where the algorithm stops after an exponential number of iterations is provided. Furthermore, we compare the performance of our algorithm with a natural enumeration approach. A comparison with Chvátal-Gomory cuts and split cuts is presented in Sect. 5. Section 6 concludes the paper.

Lexicographic orderings and lex-inequalities
A lattice basis of Z n is a set of n linearly independent vectors c 1 , . . . , c n ∈ Z n such that for every v ∈ Z n we have that λ 1 , . . . , λ n ∈ Z in the unique expression v = n i=1 λ i c i . The lex-inequalities that we introduce in this paper are defined for a given lattice basis of Z n . To simplify the presentation, we first work with the standard basis and then extend the results to general lattice bases.
We will use standard notions in the theory of polyhedra, for which we refer the reader to Schrijver (1986).

Standard basis
We consider the lexicographic ordering ≺ associated with the standard basis e 1 , . . . , e n : Given x 1 , x 2 ∈ R n , x 1 ≺ x 2 if and only if x 1 = x 2 and x 1 i < x 2 i , where i is the smallest index for which x 1 i = x 2 i . We use , , with the obvious meaning.
We consider the cone K = R n where "conv" denotes the convex hull operator. Givenx ∈ K \ {0}, we define the leading indexî(x) as the largest index i such that x i > 0.
conv(X i ) . As any rational polyhedral cone is an integral polyhedron, we have conv(K ∩ Z n ) = K . As v i ∈ Z n , this implies conv(X i ) = v i + K for every i, and thus these sets are integer translates of K . Therefore conv(X ) = conv{v 1 , . . . , vˆı (x) } + K . This shows that conv(X ) is a full-dimensional polyhedron with recession cone K and its vertices are contained in {v 1 , . . . , vˆı (x) }. It is easy to verify that v 1 , . . . , vˆı (x) are actually all vertices of conv(X ).
Letx ∈ K be given. Our aim is to derive the inequalities that fully describe the convex hull of the integer points in K not lexicographically smaller thanx.
For every k ∈ {1, . . . , n} and i ∈ {1, . . . , k} we define (Note that the d k i 's depend on the choice ofx, but we omit the dependence onx to keep notation simpler: This will never generate any ambiguity.) For every k ∈ {1, . . . , n}, the k-th lex-inequality associated withx is the inequality Note that whenx k = 0, (2.1) is the inequality x k ≥ 0.
Proof As K is the recession cone of Q(x) (Lemma 1) and Q(x) ⊆ K , it follows that every facet inducing inequality for Q(x) (indeed every valid inequality) is of the type Therefore the facet inducing inequalities of Q k (x) are the facet inducing inequalities of Q(x) such that a j = 0 for j = k+1, . . . , n. (This can be seen, e.g., as a consequence of the method of Fourier-Motzkin to compute projections.) As the theorem trivially holds for Q 1 (x), to prove the result by induction on n it suffices to characterize the facets with a n > 0. As the only facet inducing inequality with a n > 0 and a 0 = 0 is x n ≥ 0, from now on we consider a facet inducing inequality (2.2) with a n > 0 and a 0 > 0.

Claim 1x satisfies (2.2) at equality.
Since v k n = 0 for k = 1, . . . , n − 1, ifx does not satisfy (2.2) at equality, the inequality 2) is the sum of εx n ≥ 0 and the above inequality, and these inequalities are not multiples of each other as a 0 > 0, (2.2) does not induce a facet of Q(x). This proves Claim 1.
By Claim 1 we have that Subtracting the above equation from this inequality, we obtain where the strict inequality follows because a i ≥ 0 for i = 1, . . . , n and a nxn > 0. This proves Claim 2.
Claim 2 shows that if x = x , x ≥ x (componentwise) and x satisfies (2.2), then x cannot satisfy (2.2) at equality. In particular, if x satisfies (2.2) at equality and r is a nonzero ray of Q(x) then x + r cannot satisfy (2.2) at equality. Note that Q(x) is a full dimensional polyhedron with exactly n vertices and (2.2) induces a facet containing no nonzero rays. Therefore, inequality (2.2) must be satisfied at equality by v 1 , . . . , v n . By imposing these n equations and considering the expression of v 1 , . . . , v n (see Lemma 1), one obtains a linear system in a 0 , . . . , a n whose solution is, up to scaling, a i = d n i , for all i = 1, . . . , n and a 0 = n i=1 d n ix i . This implies that and the theorem is proven.

Remark 3
In the description given by Theorem 2, for every k such thatx k = 0 the k-th lex-inequality is redundant, as it is the inequality x k ≥ 0. Furthermore, ifx 1 > 0 then also the inequality x 1 ≥ 0 is redundant, as it is dominated by the first lex-inequality (which is x 1 ≥x 1 ). It can be verified that the remaining inequalities provide an irredundant description of Q(x).

General lattice bases
Let {c 1 , . . . , c n } be a lattice basis of Z n . Then the n × n matrix C whose rows are c 1 , . . . , c n is unimodular, i.e., it is an integer matrix with determinant 1 or −1. The unimodular transformation x → C x and its inverse map integer points to integer points. By applying the transformation x → C x, the results of the previous subsection can be immediately extended to the lattice basis {c 1 , . . . , c n }.
In particular, the lexicographic ordering defined by the lattice basis is as follows: The unimodular cone K is defined as Lemma 1 now reads as follows: (2. 3) The k-th lex-inequality associated withx is the following: Theorem 2 now reads as follows: Proposition 5 Ifx ∈ K ∩ Z n , then the lex-inequalities (2.4) for k = 1, . . . , n and the inequalities c i x ≥ 0 for i = 1, . . . , n provide a description of the polyhedron Q(x).
Neto (2012) describes a family of inequalities that, although presented in a different setting, can be seen to be valid for Q(x) when the lattice basis {c 1 , . . . , c n } is the standard basis. However, those inequalities in general do not induce facets of Q(x) and are therefore weaker than the lex-inequalities. In particular, the inequalities in Neto (2012) are derived under the assumption that a box containing the continuous set S is known, and their coefficients depend on the size of the box. In contrast, our inequalities only depend on the current fractional solutionx. As a consequence, we obtain inequalities with smaller dynamism (i.e., with smaller ratio between the largest and the smallest absolute value of the coefficients), which is a desirable property in practice.
It should also be noted that in Neto (2012) the inequalities are described only for the case in which the continuous set S is a bounded polyhedron, although it is not difficult to extend them to the case of a compact set.
Furthermore, we remark that a linear-inequality description of the set Q(x) can be inferred from a result proved by Gupte (2016, Theorem 2) in the context of superincreasing knapsack problems: One needs to apply a change of variables and observe that by removing the lower bounds appearing in Gupte (2016) the remaining facet inducing inequalities are unaffected.

The cutting plane algorithm
Let S be a family of compact (not necessarily connected or convex) subsets of R n with the following property: Linear optimization over S is the following problem: Given S ∈ S and c ∈ Z n , determine an optimal solution to the problem min{cx : x ∈ S} or certify that S = ∅. (Since S is compact, either S = ∅ or the minimum is well defined.) Integer linear optimization over S is defined similarly, but the feasible region is S ∩ Z n , the set of integer points in S.
We prove that an oracle for solving linear optimization over S suffices to design a finite cutting plane algorithm that solves integer linear optimization over S.
We now make this statement more precise. Given a compact subset S of R n and c ∈ Z n , letx ∈ S be an optimal solution of the program min{cx : x ∈ S}. A cutting plane is a linear inequality that is valid for S ∩ Z n and is violated byx. Note that a cutting plane exists if and only ifx / ∈ conv(S ∩ Z n ). In particular, this is certainly the case ifx is a non-integral extreme point of conv(S).
A (pure) cutting plane algorithm for integer linear optimization over S is an iterative procedure of the following type: -Let S ∈ S and c ∈ Z n be given.
-If S = ∅, then S ∩ Z n = ∅. Otherwise, find an optimal solutionx of min{cx : x ∈ S}. -Ifx ∈ S ∩ Z n , stop:x is an optimal solution to min{cx : x ∈ S ∩ Z n }. Otherwise, detect a cutting plane and let H denote the corresponding half-space. Replace S with S ∩ H and iterate.
Assume without loss of generality that the objective function vector c is nonzero and has relatively prime entries. Then there exists a lattice basis {c 1 , . . . , c n } of Z n such that c 1 = c. The optimal solutionx of min{cx : x ∈ S} found by our algorithm will be a lexicographically minimum or lex-min solution in S with respect to the lattice basis: i.e.,x ≺ x for every x ∈ S \{x}. The lex-min vectorx in S satisfies the following conditions: Since S is nonempty and compact, the above minima are well-defined and can be computed by applying the oracle n times. Furthermore these conditions uniquely definex. One verifies thatx is an extreme point of conv(S).

Algorithm 1: Resolution of integer linear optimization over S
Input: S ∈ S with S = ∅, c ∈ Z n \ {0} with relatively prime entries, and a lattice basis {c 1 , . . . , c n } of Z n with c 1 = c. Output: an optimal integer solutionx for the problem min{cx : x ∈ S} or a certificate that S ∩ Z n = ∅. 1 Compute * i := min{c i x : x ∈ S} and i := * i for 1 ≤ i ≤ n, and apply a translation so that i = 0 for 1 ≤ i ≤ n. Let K := {x ∈ R n : c i x ≥ 0, i = 1, . . . , n} and replace S with S ∩ K . 2 If S = ∅, stop: The given problem is infeasible. 3 Else, compute the lex-min solutionx in S with respect to {c 1 , . . . , c n }. 4 Ifx ∈ Z n , returnx. 5 Else, let k be the smallest index such that c kx / ∈ Z and compute Replace S with S ∩ H , where H is the halfspace defined by the inequality (3.2) and go to step 2.
Algorithm 1 describes the procedure in detail. Note that since S is compact, numbers * 1 , . . . , * n (as defined in Algorithm 1) exist and can be determined by querying the linear optimization oracle n times. Moreover, as {c 1 , . . . , c n } is a lattice basis of Z n , an index k as in step 5 always exists whenx / ∈ Z n . Given x ∈ K , let x ↑ be the lex-min vector in K ∩ Z n such that x x ↑ . Obviously x = x ↑ if and only if x ∈ Z n . If x / ∈ Z n , let k be the smallest index such that c k x / ∈ Z. It is easy to see that x ↑ is the unique point satisfying the following conditions: (3.1) Definition 6 Letx / ∈ S ∩ Z n and let k be the smallest index such that c kx / ∈ Z. The k-th lex-cut is the k-th lex-inequality associated withx ↑ : (This is the cut introduced at step 5 of Algorithm 1).
Proposition 7 Inequality (3.2) defines a cutting plane. Algorithm 1 terminates after a finite number of iterations.
Proof Since, after the preprocessing of step 1, S ⊆ K andx is the lex-min point in S, x x ↑ ≺ x for every x ∈ S ∩ Z n \ {x ↑ }. Thus S ∩ Z n ⊆ Q(x ↑ ) and by Proposition 5 inequality (3.2) is valid for S ∩ Z n . As c kx / ∈ Z and d k k > 0, the inequality is violated byx. This shows that (3.2) defines a cutting plane.
As different iterations of the algorithm use cuts (3.2) associated with lexicographically increasing vectors in S ∩ Z n , and S is bounded, the number of iterations of the algorithm is finite.
We mention that Akshay Gupte (personal communication) has elaborated an algorithm to solve min{cx : x ∈ S}, assuming that a box B containing S is given. His algorithm iteratively constructs the convex hull of a set of the form {x ∈ B ∩ Z n : x x} for somex ∈ Z n , which can be seen as a truncated version of Q(x). However, while in Algorithm 1 at each iteration we usex =x ↑ , wherex is the optimal solution of the continuous relaxation, in Gupte's algorithmx is obtained by "rounding" the point optimizing an objective function with superincreasing coefficients that is different from the original objective function. As a consequence, in Gupte's algorithm one can havex ≺x ↑ , which makes Q(x) (or its truncated version) weaker.

Lexicographic enumeration and the number of iterations
Recall the notation x ↑ introduced in (3.1). We extend that definition to sets as follows: Given S ⊆ R n , let S ↑ := {x ↑ : x ∈ S}. Since S is bounded, S ↑ is a finite set, as, given y ∈ S ↑ and i ∈ {1, . . . , n}, c i y is an integer value satisfying min{c i x : x ∈ S} ≤ c i y ≤ max{c i x : x ∈ S} .

Observation 8 Given a nonempty set S ∈ S, let (x) be the sequence of points in S computed at step 3 of Algorithm 1. Then the sequence (x ↑ ) is the lex-ordering of some distinct points in S ↑ .
Proof Ifx is a point computed at step 3 of Algorithm 1, then clearlyx ↑ ∈ S ↑ , as x ∈ S. Thus we only have to show that ifx andx are points computed at step 3 in two consecutive iterations (say iterations q and q + 1), thenx ↑ ≺x ↑ . Assume not. Then x ↑ =x ↑ and therefore the cuts introduced at these two iterations would be exactly the same. But then the cut generated at iteration q would already cut offx, contradicting the fact that at iteration q + 1 the point computed at step 3 isx.

Corollary 9 |S ↑ | is an upper bound on the number of cuts produced by Algorithm 1.
We next construct a convex body containing no integer points for which the bound |S ↑ | on the number of cuts is exponential and tight.
Proposition 10 For every n ∈ N, there is a convex subset S of [0, 1] n (described by a single convex constraint plus variable bounds) on which Algorithm 1 computes |S ↑ | = 2 n − 1 cuts.
Proof We choose the standard basis {e 1 , . . . , e n } as lattice basis of Z n . Let 1 be the point in R n with all entries equal to 1, and let · denote the Euclidean norm. Define Note that S ∩ Z n = ∅ and i = 0 for i = 1, . . . , n. Furthermore, for every x ∈ {0, 1} n \ {1}, S contains the point z(x) obtained from x by setting to 1 4 the entry with largest index that is 0. As S ⊆ [0, 1] n , this shows that S ↑ = {0, 1} n \ {0}, and thus |S ↑ | = 2 n − 1.
We now show that every point in S ↑ is of the formx ↑ for some pointx found in step 3. Letx be the point computed at some iteration of step 3 and assumex ↑ = 1. By Theorem 2, the lex-cut associated withx ↑ is satisfied by all x ∈ {0, 1} n such that x x ↑ . As the lex-cut associated withx ↑ is an inequality with nonnegative coefficients, it is also satisfied by the point z(x ↑ ). This implies that, if we denote bỹ x the point computed in step 3 at the next iteration,x ↑ is the lex-min point in {0, 1} n that is lexicographically larger thanx ↑ . Thus every point in S ↑ is of the formx ↑ for some pointx found in step 3. Together with Observation 8, this shows that precisely |S ↑ | cuts are needed to discover that S contains no integer points, which happens at step 2 immediately after the iteration in whichx ↑ = 1.
Corollary 9 gives a guarantee on the maximum number of iterations of Algorithm 1 and Proposition 10 shows that there are instances for which the performance of this algorithm is of the same order as that of an enumerative algorithm.
In order to better understand how Algorithm 1 compares to simple enumeration, in the following we define Algorithm 2, which we think is the best candidate for an enumerative algorithm.
In Algorithm 2, for ease of description S is assumed to be contained in the nonnegative orthant. The variables α 1 , . . . , α n and i * are used to impose restrictions on S, as now illustrated. At the first iteration, α 1 = · · · = α n = 0 and i * = 1, and therefore S * = S (step 2). This implies that (assuming S = ∅)x is the lex-min point in S (step 7). Clearly, ifx ↑ ∈ S * = S thenx ↑ is the lex-min point in S ∩ Z n and in this case the algorithm stops (step 8). Otherwise, we know that the lex-min point in S ∩ Z n is lexicographically larger thanx ↑ . Thus, we call the continuous optimization oracle to find the lex-min point in S that is lexicographically larger thanx ↑ : this is done by redefining S * with the restrictions c i x = c ix ↑ for i = 1, . . . , n − 1 and c n x ≥ c nx ↑ (step 9 and step 2 of the next iteration, with i * = n). We proceed this way until S * becomes empty. When this happens, in order to find the lex-min point in S that is Algorithm 2: Resolution of integer linear optimization over S via lex-enumeration Input: S ∈ S, c ∈ Z n \ {0} with relatively prime entries and a lattice basis {c 1 , . . . , c n } of Z n , with c 1 = c. Output: an optimal integer solutionx for the problem min{cx : x ∈ S} or a certificate that S ∩ Z n = ∅. 1 Translate S so that S ⊆ {x ∈ R n : c i x ≥ 0, i = 1, . . . , n}. Set α 1 := · · · := α n := 0 and i * := 1.

8
Ifx ↑ ∈ S * , stop:x ↑ is the lex-min point in S ∩ Z n .
lexicographically larger thanx ↑ we have to increase c n−1 x and remove the restricion on c n x (step 5 with i * = n − 1). If S * is empty also when c n−1 x is increased, we have to increase c n−2 x and remove the restrictions on c n−1 x and c n x (again step 5, this time with i * = n − 2). This process continues until a feasible (and thus optimal) x ↑ is detected or S * = ∅ with i * = 1: in the latter case, S ∩ Z n = ∅ (step 4).
The above discussion proves the correctness of Algorithm 2. In particular, the following property has been established.

Lemma 11
In Algorithm 2, ifx andx denote the points computed at two consecutive executions of line 7, thenx is the lex-min point in S that is lexicographically larger thanx ↑ .
To analyze the performance of Algorithm 2, we need the following definitions. Let C be the n × n matrix whose rows are c 1 , . . . , c n and let S ∈ S be given. For everȳ x ∈ S ↑ , let V (x) be the set of the following n vectors α 1 , . . . , α n : For k = 1, . . . , n−1, α k is defined as . Notice that, givenx,ȳ ∈ S ↑ , the set V (x) ∩ V (ȳ) may be nonempty.

Proposition 12
Given a set S ∈ S, let (α) be the sequence of vectors used to define the sequence of sets (S * ) in step 2 of Algorithm 2.
-If S ∩ Z n = ∅, then (α) is the lex-ordering of all points in V (S) ∪ {0} with respect to the standard basis. -If S ∩ Z n = ∅, the sequence is truncated to the lex-min vector α (with respect to the standard basis) such that C −1 α ∈ S ∩ Z n = S ∩ S ↑ .
Proof Clearly the sequence (α) starts with α = 0 and is lexicographically increasing with respect to the standard basis. Let α = 0 be a vector used in step 2 at some iteration q > 1 and letx be the last point computed at line 7 before iteration q; say thatx is computed at iteration q < q. If q = q − 1, then α = Cx ↑ and therefore α ∈ V (S). If q = q − t for some t > 1, then line 5 is executed t − 1 times between iterations q and q. In this case, α is the vector defined by α i = c ix ↑ for i ≤ n − t, α n−t+1 = c n−t+1x ↑ + 1, α i = c ix ↑ for i ≥ n − t + 2, and therefore α ∈ V (S).
We now show that every point in V (S) is in the sequence (α). By Lemma 11, the sequence (α) contains all points of the form C x for x ∈ S ↑ . Let now α ∈ V (S), where α is not of the form C x for any x ∈ S ↑ . Then there existx ∈ S ↑ and an index k < n such that α i = c ix for i < k, α k x = c kx + 1, and α i = 0 for i > k. Consider the last iteration of line 7 in whichx ↑ satisfies c ix ↑ = c ix for i ≤ k (this definition makes sense because, as shown above,x =x ↑ at some iteration of line 7). The algorithm now sets α = Cx ↑ and executes line 5 k consecutive times. After this, we have α = C x. This shows that every point in V (S) is in the sequence (α).
We remark that in the definition of α at line 9, we could impose the stronger condition α n := c nx ↑ + 1. However, this would not change substantially the bounds on the number of iterations shown above. Moreover, when S is convex the number of iterations is precisely the same in both cases.
By Observation 8 and Proposition 12, the number of iterations of Algorithms 1 and 2 is upper-bounded by |S ↑ | and |V (S)| + 1, respectively. Note that these bounds are sharp, in the sense that they can be attained, and that the latter bound is always larger than the former: indeed, by definition of V (S), we have |S ↑ | ≤ |V (S)| ≤ n|S ↑ |. In particular, for the example in Proposition 10 we have |V (S)| = 2 n + 2 n−1 − 2, thus in that case Algorithm 2 executes roughly 50% more iterations than Algorithm 1. It is not clear to us whether there are instances in which |V (S)| is close to n|S ↑ |.
We also remark that comparing the two algorithms by counting the number of iterations may not be "fair", as the computational effort varies from iteration to iteration: For instance, the computation of a lex-min solution (line 3 of Algorithm 1 and line 7 of Algorithm 2) requires up to n oracle calls, while the iterations of Algorithm 2 in which S * is empty only require a single oracle call. Nonetheless the results on the number of iterations at least indicate that, from the theoretical point of view, Algorithm 1 tends to be more efficient than Algorithm 2.

Comparison with Gomory and split cuts
Given a set S, a Chvátal-Gomory inequality for S is a linear inequality of the form gx ≥ γ for some g ∈ Z n and γ ∈ R such that the inequality gx ≥ γ is valid for S. We call gx ≥ γ a proper Chvátal-Gomory inequality if gx ≥ γ is violated by at least one point in S.

Proposition 13
Given S ∈ S, every proper Chvátal-Gomory inequality for S is a lex-cut for some lattice basis {c 1 , . . . , c n } of Z n .
Proof Let gx ≥ γ be a proper Chvátal-Gomory inequality for S. Without loss of generality, we assume that the entries of g are relatively prime integers. Letx be the lexmin solution found at the first iteration of Algorithm 1 with respect to some lattice basis {c 1 , . . . , c n }, with c 1 = g. Since gx ≥ γ is a proper Chvátal-Gomory inequality for S, we have γ ≤ gx < γ . In particular, gx / ∈ Z. Then the corresponding lex-cut is (equivalent to) gx ≥ gx = γ .
The converse of the above proposition is false; this will follow from a stronger result.
A linear inequality is a split cut for S if there exist π ∈ Z n and π 0 ∈ Z such that the inequality is valid for both {x ∈ S : π x ≤ π 0 } and {x ∈ S : π x ≥ π 0 + 1}. It is known that every Chvátal-Gomory inequality is a split cut but not vice versa (see e.g. Conforti et al. 2014).
The next result shows that our family of cuts is not included in and does not include the family of split cuts. Combined with the previous proposition, this implies that our family of cuts strictly contains the Chvátal-Gomory inequalities.
Suppose now k = 2, i.e., c 1x ∈ Z and c 2x / ∈ Z. Then the inequality given by the algorithm is We claim that c 1 1 = 0. If this is not the case, then c 1 1 = 0 and c 2 1 = 0 (as {c 1 , c 2 } is a basis), and inequality (5.1) does not reduce to the desired cut x 2 ≥ 0, as the coefficient of x 1 is d 2 1 c 1 1 + c 2 1 = c 2 1 = 0. Thus c 1 1 = 0. This implies that either the point (0, −1) or the point (1, −1) satisfies the strict inequality c 1 x > c 1x . We assume that this holds forx := (0, −1) (the other case is similar). Note that c 1x ≥ c 1x + 1, as c 1x ∈ Z and c 1 ,x ∈ Z 2 . Furthermore, the slope of the line defined by the equation c 1 x = c 1x is positive.
Therefore we assume c 2x < 2 . Since c 2x ≥ 2 , the line defined by the equation c 2 x = 2 intersects the line segments [x,x] in a point distinct fromx. Then, because (0, 0) satisfies the inequality c 2 x ≥ 2 (as it is in S), the slope of the line defined by the equation c 2 x = 2 is negative. Furthermore, since c 2 ,x ∈ Z 2 , we have c 2x ≤ 2 , and thus the line defined by the equation c 2 x = 2 intersects [x,x] in some point x * . Now consider the system c 1 x = c 1x , c 2 x = 2 . Since the constraint matrix is unimodular (as {c 1 , c 2 } is a lattice basis of Z 2 ) and the right-hand sides are integer, the unique solution to this system is an integer point. However, the first equation defines a line with positive slope containingx and the second equation defines a line with negative slope containing x * . From this we see that the intersection of the two lines is a point satisfying 0 < x 1 ≤ 1/2 and therefore cannot be an integer point, a contradiction. This shows that also in this case (5.1) is not equivalent to x 2 ≥ 0. This concludes the proof that there is a split cut that cannot be obtained via an iteration of Algorithm 1.
Therefore π 2 ≤ 4 √ 2 3 2 = 32 9 < 4. Since π is an integer vector, we deduce that π 1 , π 2 ∈ {0, 1, −1}. It can be verified that if |π 1 | = |π 2 | = 1 then S is not contained in the strip. Therefore one entry of π is 0 and the other is 1 or −1. It can be checked that the only strip of this type containing S is {x ∈ R 2 : 0 ≤ x 1 ≤ 1}. However, the inequality 2x 1 + x 2 ≥ 2 is not valid for all the points in {x ∈ S : x 1 ≤ 0} ∪ {x ∈ S : x 1 ≥ 1}, as the point (0, 3/2) is in this set but violates the inequality. The inequality x 2 ≥ 0 is a split cut for the shadowed triangle, but is not of the type (3.2).

Concluding remarks
An obvious variant of Algorithm 1 is the following: Instead of being computed only once at the beginning of the procedure, the lower bounds i can be updated at every iteration or whenever it seems convenient. It can be verified that the bounds of Observation 8 and Proposition 10 also hold for this variant of the algorithm: The proofs are the same.
In view of Observation 8 and Proposition 10, the cardinality of S ↑ truncated to the lex-min point in S ↑ ∩ S plays a crucial role in the performance of Algorithm 1. This number is dependent on the choice of the lattice basis and its ordering. It is easy to see that different choices of the lattice basis (or different choices of the ordering of the elements of the same lattice basis) may result in a different number of iterations of the algorithm. However, this is not always the case: For instance, in the example in Proposition 10 Algorithm 1 would produce the same number of iterations regardless of the ordering of the standard basis.
A natural question is whether the approach described in this paper can be generalized to the mixed integer case, i.e., to problems of the form min{cx + dy : (x, y) ∈ S ∩ (Z n × R p )}, where S ⊆ R n+ p is a compact set. However, it does not seem that our algorithm can be easily extended to deal with this case.