Sample Complexity of Tree Search Configuration: Cutting Planes and Beyond
Year: 2022

Abstract:
Cutting-plane methods have enabled remarkable successes in integer programming over the last few decades. State-of-the-art solvers integrate a myriad of cutting-plane techniques to speed up the underlying tree-search algorithm used to find optimal solutions. In this paper we provide sample complexity bounds for cut-selection in branch-and-cut (B&C). Given a training set of integer programs sampled from an application-specific input distribution and a family of cut selection policies, these guarantees bound the number of samples sufficient to ensure that using any policy in the family, the size of the tree B&C builds on average over the training set is close to the expected size of the tree B&C builds. We first bound the sample complexity of learning cutting planes from the canonical family of Chvátal-Gomory cuts. Our bounds handle any number of waves of any number of cuts and are fine tuned to the magnitudes of the constraint coefficients. Next, we prove sample complexity bounds for more sophisticated cut selection policies that use a combination of scoring rules to choose from a family of cuts. Finally, beyond the realm of cutting planes for integer programming, we develop a general abstraction of tree search that captures key components such as node selection and variable selection. For this abstraction, we bound the sample complexity of learning a good policy for building the search tree.

heading: 1 Introduction
text: Integer programming is one of the most broadly-applicable tools in computer science, used to formulate problems from operations research (such as routing, scheduling, and pricing), machine learning (such as adversarially-robust learning, MAP estimation, and clustering), and beyond. Branchand-cut (B&C) is the most widely-used algorithm for solving integer programs (IPs). B&C is highly configurable, and with a deft configuration, it can be used to solve computationally challenging problems. Finding a good configuration, however, is a notoriously difficult problem.
We study machine learning approaches to configuring policies for selecting cutting planes, which have an enormous impact on B&C’s performance. At a high level, B&C works by recursively partitioning the IP’s feasible region, searching for the locally optimal solution within each set of the partition,
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
until it can verify that it has found the globally optimal solution. An IP’s feasible region is defined by a set of linear inequalities Ax ≤ b and integer constraints x ∈ Zn, where n is the number of variables. By dropping the integrality constraints, we obtain the linear programming (LP) relaxation of the IP, which can be solved efficiently. A cutting plane is a carefully-chosen linear inequality αTx ≤ β which refines the LP relaxation’s feasible region without separating any integral point. Intuitively, a well-chosen cutting plane will remove a large portion of the LP relaxation’s feasible region, speeding up the time it takes B&C to find the optimal solution to the original IP. Cutting plane selection is a crucial task, yet it is challenging because many cutting planes and cut-selection policies have tunable parameters, and the best configuration depends intimately on the application domain.
We provide the first provable guarantees for learning high-performing cutting planes and cut-selection policies, tailored to the application at hand. We model the application domain via an unknown, application-specific distribution over IPs, as is standard in the literature on using machine learning for integer programming [e.g., 21, 23, 31, 36, 43]. For example, this could be a distribution over the routing IPs that a shipping company must solve day after day. The learning algorithm’s input is a training set sampled from this distribution. The goal is to use this training set to learn cutting planes and cut-selection policies with strong future performance on problems from the same application but which are not already in the training set—or more formally, strong expected performance.

heading: 1.1 Summary of main contributions and overview of techniques
text: As our first main contribution, we provide sample complexity bounds of the following form: fixing a family of cutting planes, we bound the number of samples sufficient to ensure that for any sequence of cutting planes from the family, the average size of the B&C tree is close to the expected size of the B&C tree. We measure performance in terms of the size of the search tree B&C builds. Our guarantees apply to the parameterized family of Chvátal-Gomory (CG) cuts [10, 17], one of the most widely-used families of cutting planes.
The overriding challenge is that to provide guarantees, we must analyze how the tree size changes as a function of the cut parameters. This is a sensitive function—slightly shifting the parameters can cause the tree size to shift from constant to exponential in the number of variables. Our key technical insight is that as the parameters vary, the entries of the cut (i.e., the vector α and offset β of the cut αTx ≤ β) are multivariate polynomials of bounded degree. The number of terms defining the polynomials is exponential in the number of parameters, but we show that the polynomials can be embedded in a space with dimension sublinear in the number of parameters. This insight allows us to better understand tree size as a function of the parameters. We then leverage results by Balcan et al. [8] that show how to use structure exhibited by dual functions (measuring an algorithm’s performance, such as its tree size, as a function of its parameters) to derive sample complexity bounds.
Our second main contribution is a sample complexity bound for learning cut-selection policies, which allow B&C to adaptively select cuts as it solves the input IP. These cut-selection policies assign a number of real-valued scores to a set of cutting planes and then apply the cut that has the maximum weighted sum of scores. Tree size is a volatile function of these weights, though we prove that it is piecewise constant, as illustrated in Figure 1, which allows us to prove our sample complexity bound.
Finally, as our third main contribution, we provide guarantees for tuning weighted combinations of scoring rules for other aspects of tree search beyond cut selection, including node and variable selection. We prove that there is a set of hyperplanes splitting the parameter space into regions such that if tree search uses any configuration from a single region, it will take the same sequence of actions. This structure allows us to prove our sample complexity bound. This is the first paper to provide guarantees for tree search configuration that apply simultaneously to multiple different aspects of the algorithm—prior research was specific to variable selection [5].
Sample complexity bounds are important because if the parameterized class of cuts or cut-selection policies that we optimize over is highly complex and the training set is too small, the learned cut or cut-selection policy might have great average empirical performance over the training set but terrible future performance. In other words, the parameter configuration procedure may overfit to the training set. The sample complexity bounds we provide are uniform-convergence: we prove that given enough samples, uniformly across all parameter settings, the difference between average and empirical performance is small. In other words, these bounds hold for any procedure one might use to optimize over the training set: manual or automated, optimal or suboptimal. No matter what
parameter setting the configuration procedure comes up with, the user can be guaranteed that so long as that parameter setting has good average empirical performance over the training set, it will also have strong future performance.

heading: 1.2 Related work
text: Applied research on tree search configuration. Over the past decade, a substantial literature has developed on the use of machine learning for integer programming and tree search [e.g., 2, 7, 9, 13, 19, 23–25, 29, 31–33, 35, 36, 41–43]. This has included research that improves specific aspects of B&C such as variable selection [2, 13, 24, 29, 32, 41], node selection [19, 35, 44], and heuristic scheduling [25]. These papers are applied, whereas we focus on providing theoretical guarantees.
With respect to cutting plane selection, the focus of this paper, Sandholm [36] uses machine learning techniques to customize B&C for combinatorial auction winner determination, including cutting plane selection. Tang et al. [37] and Huang et al. [20] study machine learning approaches to cutting plane selection. The former work formulates this problem as a reinforcement learning problem and shows that their approach can outperform human-designed heuristics for a variety of tasks. The latter work studies cutting plane selection in the multiple-instance-learning framework and proposes a neural-network architecture for scoring and ranking cutting planes. Meanwhile, the focus of our paper is to provide the first provable guarantees for cutting plane selection via machine learning.
Ferber et al. [15] study a problem where the IP objective vector c is unknown, but an estimate ĉ can be obtained from data. Their goal is to optimize the quality of the solutions obtained by solving the IP defined by ĉ, with respect to the true vector c. They do so by formulating the IP as a differentiable layer in a neural network. The nonconvex nature of the IP does not allow for straightforward gradient computation for the backward pass, so they obtain a continuous surrogate using cutting planes.
Provable guarantees for algorithm configuration. Gupta and Roughgarden [18] initiated the study of sample complexity bounds for algorithm configuration. In research most related to ours, Balcan et al. [5] provide sample complexity bounds for learning tree search variable selection policies (VSPs). They prove their bounds by showing that for any IP, hyperplanes partition the VSP parameter space into regions where the B&C tree size is a constant function of the parameters. The analysis in this paper requires new techniques because although we prove that the B&C tree size is a piecewiseconstant function of the CG cutting plane parameters, the boundaries between pieces are far more complex than hyperplanes: they are hypersurfaces defined by multivariate polynomials.
Kleinberg et al. [26, 27] and Weisz et al. [38, 39] design configuration procedures for runtime minimization that come with theoretical guarantees. Their algorithms are designed for the case where there are a finitely-many parameter settings to choose from (although they are still able to provide guarantees for infinite parameter spaces by running their procedure on a finite sample of configurations; Balcan et al. [5, 6] analyze when discretization approaches can and cannot be gainfully employed). In contrast, our guarantees are designed for infinite parameter spaces.

heading: 2 Problem formulation
text: In this section we give a more detailed technical overview of branch-and-cut, as well as an overview of the tools from learning theory we use to prove sample complexity guarantees.

heading: 2.1 Branch-and-cut
text: We study integer programs (IPs) in canonical form given by max { cTx : Ax ≤ b,x ≥ 0,x ∈ Zn } , (1)
where A ∈ Zm×n, b ∈ Zm, and c ∈ Rn. Branch-and-cut (B&C) works by recursively partitioning the input IP’s feasible region, searching for the locally optimal solution within each set of the partition until it can verify that it has found the globally optimal solution. It organizes this partition as a search tree, with the input IP stored at the root. It begins by solving the LP relaxation of the input IP; we denote the solution as x∗LP ∈ Rn. If x∗LP satisfies the IP’s integrality constraints (x∗LP ∈ Zn), then the procedure terminates—x∗LP is the globally optimal solution. Otherwise, it uses a variable selection policy to choose a variable x[i]. In the left child of the root, it stores the original IP with the additional constraint that x[i] ≤ bx∗LP[i]c, and in the right child, with the additional constraint that x[i] ≥ dx∗LP[i]e. It then uses a node selection policy to select a leaf of the tree and repeats this procedure—solving the LP relaxation and branching on a variable. B&C can fathom a node, meaning that it will stop searching along that branch, if 1) the LP relaxation satisfies the IP’s integrality constraints, 2) the LP relaxation is infeasible, or 3) the objective value of the LP relaxation’s solution is no better than the best integral solution found thus far. We assume there is a bound κ on the size of the tree we allow B&C to build before we terminate, as is common in prior research [5, 21, 26, 27].
Cutting planes are a means of ensuring that at each iteration of B&C, the solution to the LP relaxation is as close to the optimal integral solution as possible. Formally, let P = {x ∈ Rn : Ax ≤ b,x ≥ 0} denote the feasible region obtained by taking the LP relaxation of IP (1). Let PI = conv(P ∩ Zn) denote the integer hull of P . A valid cutting plane is any hyperplane αTx ≤ β such that if x is in the integer hull (x ∈ PI), then x satisfies the inequality αTx ≤ β. In other words, a valid cut does not remove any integral point from the LP relaxation’s feasible region. A valid cutting plane separates x ∈ P \ PI if it does not satisfy the inequality, or in other words, αTx > β. At any node of the search tree, B&C can add valid cutting planes that separate the optimal solution to the node’s LP relaxation, thus improving the solution estimates used to prune the search tree. However, adding too many cuts will increase the time it takes to solve the LP relaxation at each node. Therefore, solvers such as SCIP [16], the leading open-source solver, bound the number of cuts that will be applied.
A famous class of cutting planes is the family of Chvátal-Gomory (CG) cuts1 [10, 17], which are parameterized by vectors u ∈ Rm. The CG cut defined by u ∈ Rm is the hyperplane buTAcx ≤ buT bc, which is guaranteed to be valid. Throughout this paper we primarily restrict our attention to u ∈ [0, 1)m. This is without loss of generality, since the facets of P ∩ {x ∈ Rn : buTAcx ≤ buT bc ∀u ∈ Rm} can be described by the finitely many u ∈ [0, 1)m such that uTA ∈ Zn (Lemma 5.13 of Conforti et al. [11]).
Some IP solvers such as SCIP use scoring rules to select among cutting planes, which are meant to measure the quality of a cut. Some commonly-used scoring rules include efficacy [4] (score1), objective parallelism [1] (score2), directed cutoff distance [16] (score3), and integral support [40] (score4) (defined in Appendix A). Efficacy measures the distance between the cut αTx ≤ β and x∗LP: score1(α
Tx ≤ β) = (αTx∗LP − β)/ ‖α‖2 , as illustrated in Figure 2a. Objective parallelism measures the angle between the objective c and the cut’s normal vector α: score2(αTx ≤ β) =∣∣cTα∣∣ /(‖α‖2 ‖c‖2), as illustrated in Figures 2b and 2c. Directed cutoff distance measures the distance between the LP optimal solution and the cut in a more relevant direction than the efficacy scoring rule. Specifically, let x be the incumbent solution, which is the best-known feasible solution to the input IP. The directed cutoff distance is the distance between the hyperplane (α, β) and the current LP solution x∗LP along the direction of the incumbent x, as illustrated in Figures 2d and 2e: score3(αTx ≤ β) = ‖x− x∗LP‖2 · (α Tx∗LP − β)/ ∣∣αT (x− x∗LP)∣∣ . SCIP uses the scoring rule 3 5score1 + 1 10score2 + 1 2score3 + 1 10score4 [16].
1The set of CG cuts is equivalent to the set of Gomory (fractional) cuts [12], another commonly studied family of cutting planes with a slightly different parameterization.

heading: 2.2 Learning theory background and notation
text: The goal of this paper is to learn cut-selection policies using samples in order to guarantee, with high probability, that B&C builds a small tree in expectation on unseen IPs. To this end, we rely on the notion of pseudo-dimension [34], a well-known measure of a function class’s intrinsic complexity. The pseudo-dimension of a function class F ⊆ RY , denoted Pdim(F), is the largest integer N for which there exist N inputs y1, . . . , yN ∈ Y and N thresholds r1, . . . , rN ∈ R such that for every (σ1, . . . , σN ) ∈ {0, 1}N , there exists f ∈ F such that f(yi) ≥ ri if and only if σi = 1. Function classes with bounded pseudo-dimension satisfy the following uniform convergence guarantee [3, 34]. Let [−κ, κ] be the range of the functions in F , let NF (ε, δ) = O(κ 2 ε2 (Pdim(F) + ln( 1 δ ))), and let N ≥ NF (ε, δ). For all distributionsD on Y , with probability 1−δ over the draw of y1, . . . , yN ∼ D, for every function f ∈ F , the average value of f over the samples is within ε of its expected value: | 1N ∑N i=1 f(yi)− Ey∼D[f(y)]| ≤ ε. The quantity NF (ε, δ) is the sample complexity of F .
We use the notation ‖A‖1,1 to denote the sum of the absolute values of all the entries in A.

heading: 3 Learning Chvátal-Gomory cuts
text: In this section we bound the sample complexity of learning CG cuts at the root node of the B&C search tree. In many IP settings, similar IPs are being solved and there can be good cuts that carry across instances—for example, in applications where the constraints stay the same or roughly the same across instances,2 and only the objective changes. One high-stakes example of this is the feasibility checking problem in the billion-dollar incentive auction for radio spectrum, where prices change but the radiowave interference constraints do not change.
We warm up by analyzing the case where a single CG cut is added at the root (Section 3.1), and then build on this analysis to handle w sequential waves of k simultaneous CG cuts (Section 3.3). This means that all k cuts in the first wave are added simultaneously, the new (larger) LP relaxation is solved, all k cuts in the second wave are added to the new problem simultaneously, and so on. B&C adds cuts in waves because otherwise, the angles between cuts would become obtuse, leading to numerical instability. Moreover, many commercial IP solvers only add cuts at the root because those cuts can be leveraged throughout the tree. However, in Section 5, we also provide guarantees for applying cuts throughout the tree. In this section, we assume that all aspects of B&C (such as node selection and variable selection) are fixed except for the cuts applied at the root of the search tree.

heading: 3.1 Learning a single cut
text: To provide sample complexity bounds, as per Section 2.2, we bound the pseudo-dimension of the set of functions fu for u ∈ [0, 1]m, where fu(c, A, b) is the size of the tree B&C builds when it applies the CG cut defined by u at the root. To do so, we take advantage of structure exhibited by the class of dual functions, each of which is defined by a fixed IP (c, A, b) and measures tree size as
2We assume that constraints are generated in the same order across instances; see Appendix B for a discussion.
a function of the parameters u. In other words, each dual function f∗c,A,b : [0, 1] m → R is defined as f∗c,A,b(u) = fu(c, A, b). Our main result in this section is a proof that the dual functions are well-structured (Lemma 3.2), which then allows us to apply a result by Balcan et al. [8] to bound Pdim({fu : u ∈ [0, 1]m}) (Theorem 3.3). Proving that the dual functions are well-structured is challenging because they are volatile: slightly perturbing u can cause the tree size to shift from constant to exponential in n, as we prove in the following theorem. The full proof is in Appendix C.
Theorem 3.1. For any integer n, there exists an integer program (c, A, b) with two constraints and n variables such that if 12 ≤ u[1]− u[2] < n+1 2n , then applying the CG cut defined by u at the root causes B&C to terminate immediately. Meanwhile, if n+12n ≤ u[1]− u[2] < 1, then applying the CG cut defined by u at the root causes B&C to build a tree of size at least 2(n−1)/2.
Proof sketch. Without loss of generality, assume that n is odd. Consider an IP with constraints 2(x[1] + · · · + x[n]) ≤ n, −2(x[1] + · · · + x[n]) ≤ −n, x ∈ {0, 1}n, and any objective. This IP is infeasible because n is odd. Jeroslow [22] proved that without the use of cutting planes or heuristics, B&C will build a tree of size 2(n−1)/2 before it terminates. We prove that when 1 2 ≤ u[1]− u[2] < n+1 2n , the CG cut halfspace defined by u = (u[1], u[2]) has an empty intersection with the feasible region of the IP, causing B&C to terminate immediately. On the other hand, we show that if n+12n ≤ u[1]− u[2] < 1, then the CG cut halfspace defined by u contains the feasible region of the IP, and thus leaves the feasible region unchanged. In this case, due to Jeroslow [22], applying this CG cut at the root will cause B&C to build a tree of size at least 2(n−1)/2 before it terminates.
This theorem shows that the dual tree-size functions can be extremely sensitive to perturbations in the CG cut parameters. However, we are able to prove that the dual functions are piecewise-constant.
Lemma 3.2. For any IP (c, A, b), there areO(‖A‖1,1 +‖b‖1 +n) hyperplanes that partition [0, 1]m into regions where in any one region R, the dual function f∗c,A,b(u) is constant for all u ∈ R.
Proof. Let a1, . . . ,an ∈ Rm be the columns of A. Let Ai = ‖ai‖1 and B = ‖b‖1, so for any u ∈ [0, 1]m, ⌊ uTai ⌋ ∈ [−Ai, Ai] and ⌊ uT b ⌋ ∈ [−B,B]. For each integer ki ∈ [−Ai, Ai], we
have ⌊ uTai ⌋ = ki ⇐⇒ ki ≤ uTai < ki + 1. There are ∑n i=1 2Ai + 1 = O(‖A‖1,1 + n) such halfspaces, plus an additional 2B + 1 halfspaces of the form kn+1 ≤ uT b < kn+1 + 1 for each kn+1 ∈ {−B, . . . , B}. In any region R defined by the intersection of these halfspaces, the vector (buTa1c, . . . , buTanc, buT bc) is constant for all u ∈ R, and thus so is the resulting cut.
Combined with the main result of Balcan et al. [8], this lemma implies the following bound.
Theorem 3.3. Let Fα,β denote the set of all functions fu for u ∈ [0, 1]m defined on the domain of IPs (c, A, b) with ‖A‖1,1 ≤ α and ‖b‖1 ≤ β. Then, Pdim(Fα,β) = O(m log(m(α+ β + n))).
This theorem implies that Õ(κ2m/ε2) samples are sufficient to ensure that with high probability, for every CG cut, the average size of the tree B&C builds upon applying the cutting plane is within of the expected size of the tree it builds (the Õ notation suppresses logarithmic terms).

heading: 3.2 Learning a sequence of cuts
text: We now determine the sample complexity of making w sequential CG cuts at the root. The first cut is defined by m parameters u1 ∈ [0, 1]m for each of the m constraints. Its application leads to the addition of the row buT1 Acx ≤ buT1 bc to the constraint matrix. The next cut is then be defined by m+ 1 parameters u2 ∈ [0, 1]m+1 since there are now m+ 1 constraints. Continuing in this fashion, the wth cut is be defined by m+w− 1 parameters uw ∈ [0, 1]m+w−1. Let fu1,...,uw(c, A, b) be the size of the tree B&C builds when it applies the CG cut defined by u1, then applies the CG cut defined by u2 to the new IP, and so on, all at the root of the search tree.
As in Section 3.1, we bound the pseudo-dimension of the functions fu1,...,uw by analyzing the structure of the dual functions f∗c,A,b, which measure tree size as a function of the parameters u1, . . . ,uw. Specifically, f∗c,A,b : [0, 1]
m × · · · × [0, 1]m+w−1 → R, where f∗c,A,b(u1, . . . ,uw) = fu1,...,uw(c, A, b). The analysis in this section is more complex because the s th cut (with s ∈
{2, . . . ,W}) depends not only on the parameters us but also on u1, . . . ,us−1. We prove that the dual functions are again piecewise-constant, but in this case, the boundaries between pieces are defined by multivariate polynomials rather than hyperplanes. The full proof is in Appendix C. Lemma 3.4. For any IP (c, A, b), there are O(w2w ‖A‖1,1 + 2w ‖b‖1 + nw) multivariate polynomials in ≤ w2 +mw variables of degree ≤ w that partition [0, 1]m× · · · × [0, 1]m+w−1 into regions where in any one region R, f∗c,A,b(u1, . . . ,uw) is constant for all (u1, . . . ,uw) ∈ R.
Proof sketch. Let a1, . . . ,an ∈ Rm be the columns of A. For u1 ∈ [0, 1]m, . . . ,uw ∈ [0, 1]m+w−1, define ã1i ∈ [0, 1]m, . . . , ãwi ∈ [0, 1]m+w−1 for each i ∈ [n] such that ãsi is the ith column of the constraint matrix after applying cuts u1, . . . ,us−1. Similarly, define b̃s to be the constraint vector after applying the first s− 1 cuts. More precisely, we have the recurrence relation
ã1i = ai b̃ 1 = b
ãsi =
[ ãs−1i
uTs−1ã s−1 i
] b̃s = [ b̃s−1
uTs−1b̃ s−1 ] for s = 2, . . . ,W . We prove that ⌊ uTs ã s i ⌋ ∈ [−2s−1 ‖ai‖1 , 2s−1 ‖ai‖1]. For each integer ki in this
interval, ⌊ uTs ã s i ⌋ = ki ⇐⇒ ki ≤ uTs ãsi < ki + 1. The boundaries of these surfaces are defined by polynomials over us in ≤ ms+ s2 variables with degree ≤ s. Counting the total number of such hypersurfaces yields the lemma statement.
We now use this structure to provide a pseudo-dimension bound. The full proof is in Appendix C. Theorem 3.5. Let Fα,β denote the set of all functions fu1,...,uw for u1 ∈ [0, 1]m, . . . ,uw ∈ [0, 1]m+w−1 defined on the domain of integer programs (c, A, b) with ‖A‖1,1 ≤ α and ‖b‖1 ≤ β. Then, Pdim(Fα,β) = O(mw2 log(mw(α+ β + n))).
Proof sketch. The space of 0/1 classifiers induced by the set of degree ≤ w multivariate polynomials in w2 + mw variables has VC dimension O((w2 + mw) logw) [3]. However, we more carefully examine the structure of the polynomials considered in Lemma 3.4 to give an improved VC dimension bound of 1 +mw. For each j = 1, . . . ,m define ũ1[j], . . . , ũw[j] recursively as
ũ1[j] = u1[j]
ũs[j] = us[j] + s−1∑ `=1 us[m+ `]ũ`[j] for s = 2, . . . , w
The space of polynomials induced by the sth cut is contained in span{1, ũs[1], . . . , ũs[m]}. The intuition for this is as follows: consider the additional term added by the sth cut to the constraint matrix, that is, uTs ã s i . The first m coordinates (us[1], . . . ,us[m]) interact only with ai—so us[j] collects a coefficient of ai[j]. Each subsequent coordinate us[m+ `] interacts with all coordinates of ãsi arising from the first ` cuts. The term that collects a coefficient of ai[j] is precisely us[m+ `] times the sum of all terms from the first ` cuts with a coefficient of ai[j]. Using standard facts about the VC dimension of vector spaces and their duals in conjunction with Lemma 3.4 and the framework of Balcan et al. [8] yields the theorem statement.
The sample complexity (defined in Section 2.2) of learning W sequential cuts is thus Õ(κ2mw2/ 2).

heading: 3.3 Learning waves of simultaneous cuts
text: We now determine the sample complexity of making w sequential waves of cuts at the root, each wave consisting of k simultaneous CG cuts. Given vectors u11, . . . ,u k 1 ∈ [0, 1]m,u12, . . . ,uk2 ∈ [0, 1]m+k, . . . ,u1w, . . . ,u k w ∈ [0, 1]m+k(w−1), let fu11,...,uk1 ,...,u1w,...,ukw(c, A, b) be the size of the tree B&C builds when it applies the CG cuts defined by u11, . . . ,u k 1 , then applies the CG cuts defined by u12, . . . ,u k 2 to the new IP, and so on, all at the root of the search tree. The full proof of the following theorem is in Appendix C, and follows from the observation that w waves of k simultaneous cuts can be viewed as making kw sequential cuts with the restriction that cuts within each wave assign nonzero weight only to constraints from previous waves.
Theorem 3.6. Let Fα,β be the set of all functions fu11,...,uk1 ,...,u1w,...,ukw for u 1 1, . . . ,u k 1 ∈ [0, 1]m, . . . ,u1w, . . . ,u k w ∈ [0, 1]m+k(w−1) defined on the domain of integer programs (c, A, b) with ‖A‖1,1 ≤ α and ‖b‖1 ≤ β. Then, Pdim(Fα,β) = O(mk2w2 log(mkw(α+ β + n))).
This result implies that the sample complexity of learning W waves of k cuts is Õ(κ2mk2w2/ 2).

heading: 3.4 Data-dependent guarantees
text: So far, our guarantees have depended on the maximum possible norms of the constraint matrix and vector in the domain of IPs under consideration. The uniform convergence result in Section 2.2 for Fα,β only holds for distributions over A and b with norms bounded by α and β, respectively. In Appendix C.1, we show how to convert these into more broadly applicable data-dependent guarantees that leverage properties of the distribution over IPs. These guarantees hold without assumptions on the distribution’s support, and depend on E[maxi ‖Ai‖1,1] and E[maxi ‖bi‖1] (where the expectation is over N samples), thus giving a sharper sample complexity guarantee that is tuned to the distribution.

heading: 4 Learning cut selection policies
text: In Section 3, we studied the sample complexity of learning waves of specific cut parameters. In this section, we bound the sample complexity of learning cut-selection policies at the root, that is, functions that take as input an IP and output a candidate cut. Using scoring rules is a more nuanced way of choosing cuts since it allows for the cut parameters to depend on the input IP.
Formally, let Im be the set of IPs withm constraints (the number of variables is always fixed at n) and letHm be the set of all hyperplanes in Rm. A scoring rule is a function score : ∪m(Hm × Im)→ R≥0. The real value score(αTx ≤ β, (c, A, b)) is a measure of the quality of the cutting plane αTx ≤ β for the IP (c, A, b). Examples include the scoring rules discussed in Section 2.1. Suppose score1, . . . , scored are d different scoring rules. We now bound the sample complexity of learning a combination of these scoring rules that guarantee a low expected tree size. Our highlevel proof technique is the same as in the previous section: we establish that the dual tree-size functions are piecewise structured, and then apply the general framework of Balcan et al. [8] to obtain pseudo-dimension bounds. Theorem 4.1. Let C be a set of cutting-plane parameters such that for every IP (c, A, b), there is a decomposition of C into ≤ r regions such that the cuts generated by any two vectors in the same region are the same. Let score1, . . . , scored be d scoring rules. For µ ∈ Rd, let fµ(c, A, b) be the size of the tree B&C builds when it chooses a cut from C to maximize µ[1]score1(·, (c, A, b)) + · · ·+ µ[d]scored(·, (c, A, b)). Then, Pdim({fµ : µ ∈ Rd}) = O(d log(rd)).
Proof. Fix an integer program (c, A, b). Let u1, . . . ,ur ∈ C be representative cut parameters for each of the r regions. Consider the hyperplanes ∑d i=1 µ[i]scorei(us) = ∑d i=1 µ[i]scorei(ut) for each s 6= t ∈ {1, . . . , r} (suppressing the dependence on c, A, b). These O(r2) hyperplanes partition Rd into regions such that as µ varies in a given region, the cut chosen from C is invariant. The desired pseudo-dimension bound follows from the main result of Balcan et al. [8].
Theorem 4.1 can be directly instantiated with the class of CG cuts. Combining Lemma 3.2 with the basic combinatorial fact that k hyperplanes partition Rm into at most km regions, we get that the pseudo-dimension of {fµ : µ ∈ Rd} defined on IPs with ‖A‖1,1 ≤ α and ‖b‖1 ≤ β is O(dm log(d(α + β + n))). Instantiating Theorem 4.1 with the set of all sequences of w CG cuts requires the following extension of scoring rules to sequences of cutting planes. A sequential scoring rule is a function that takes as input an IP (c, A, b) and a sequence of cutting planes h1, . . . , hw, where each cut lives in one higher dimension than the previous. It measures the quality of this sequence of cutting planes when applied one after the other to the original IP. Every scoring rule score can be naturally extended to a sequential scoring rule score defined by score(h1, . . . , hw, (c0, A0, b0)) =∑w−1 i=0 score(hi+1, (c i, Ai, bi)), where (ci, Ai, bi) is the IP after applying cuts h1, . . . , hi−1. Corollary 4.2. Let C = [0, 1]m × · · · × [0, 1]m+w−1 denote the set of possible sequences of w Chvátal-Gomory cut parameters. Let score1, . . . , scored : C × Im × · · · × Im+w−1 → R
be d sequential scoring rules and let fµ(c, A, b) be as in Theorem 4.1 for the class C. Then, Pdim({fwµ : µ ∈ Rd}) = O(dmw2 log(dw(α+ β + n))).
Proof. In Lemma 3.4 and Theorem 3.5 we showed that there are O(w2wα+ 2wβ+nw) multivariate polynomials that belong to a family of polynomials G with VCdim(G∗) ≤ 1 +mw (G∗ denotes the dual of G) that partition C into regions such that resulting sequence of cuts is invariant in each region. By Claim 3.5 by Balcan et al. [8], the number of regions is O(w2wα + 2wβ + nw)VCdim(G
∗) ≤ O(w2wα+ 2wβ + nw)1+mw. The corollary then follows from Theorem 4.1.
These results bound the sample complexity of learning cut-selection policies based on scoring rules, which allow the cuts B&C that selects to depend on the input IP.

heading: 5 Sample complexity of generic tree search
text: In this section, we study the sample complexity of selecting high-performing parameters for generic tree-based algorithms, which are a generalization of B&C. This abstraction allows us to provide guarantees for simultaneously optimizing key aspects of tree search beyond cut selection, including node selection and branching variable selection. We also generalize the previous sections by allowing actions (such as cut selection) to be taken at any stage of the tree search—not just at the root.
Tree search algorithms take place over a series of κ rounds (analogous to the B&B tree-size cap κ in the previous sections). There is a sequence of t steps that the algorithm takes on each round. For example, in B&C, these steps include node selection, cut selection, and variable selection. The specific action the algorithm takes during each step (for example, which node to select, which cut to include, or which variable to branch on) typically depends on a scoring rule. This scoring rule weights each possible action and the algorithm performs the action with the highest weight. These actions (deterministically) transition the algorithm from one state to another. This high-level description of tree search is summarized by Algorithm 1. For each step j ∈ [t], the number of possible actions is Tj ∈ N. There is a scoring rule scorej , where scorej(k, s) ∈ R is the weight associated with the action k ∈ [Tj ] when the algorithm is in the state s.
Algorithm 1 Tree search Input: Problem instance, t scoring rules score1, . . . , scoret, number of rounds κ.
1: s1,1 ← Initial state of algorithm 2: for each round i ∈ [κ] do 3: for each step j ∈ [t] do 4: Perform the action k ∈ [Tj ] that maximizes scorej (si,j , k) 5: si,j+1 ← New state of algorithm 6: si+1,1 ← si,t+1 . State at beginning of next round equals state at end of this round
Output: Incumbent solution in state sκ,t+1, if one exists.
There are often several scoring rules one could use, and it is not clear which to use in which scenarios. As in Section 4, we provide guarantees for learning combinations of these scoring rules for the particular application at hand. More formally, for each step j ∈ [t], rather than just a single scoring rule scorej as in Step 4, there are dj scoring rules scorej,1, . . . , scorej,dj . Given parameters µj = (µj [1], . . . , µj [dj ]) ∈ Rdj , the algorithm takes the action k ∈ [Tj ] that maximizes∑dj i=1 µj [i]scorej,i(k, s). There is a distribution D over inputs x to Algorithm 1. For example, when this framework is instantiated for branch-and-cut, x is an integer program (c, A, b). There is a utility function fµ(x) ∈ [−H,H] that measures the utility of the algorithm parameterized by µ = (µ1, . . . ,µt) on input x. For example, this utility function might measure the size of the search tree that the algorithm builds. We assume that this utility function is final-state-constant: Definition 5.1. Let µ = (µ1, . . . ,µt) and µ′ = (µ′1, . . . ,µ′t) be two parameter vectors. Suppose that we run Algorithm 1 on input x once using the scoring rule scorej = ∑dj i=1 µj [i]scorej,i and
once using the scoring rule scorej = ∑dj i=1 µ ′ j [i]scorej,i. Suppose that on each run, we obtain the same final state sκ,t+1. The utility function is final-state-constant if fµ(x) = fµ′(x).
We provide a sample complexity bound for learning the parametersµ. The full proof is in Appendix D. Theorem 5.2. Let d = ∑t j=1 dj denote the total number of tunable parameters of tree search. Then,
Pdim ({ fµ : µ ∈ Rd }) = O ( dκ
t∑ j=1 log Tj + d log d
) .
Proof sketch. We prove that there is a set of hyperplanes splitting the parameter space into regions such that if tree search uses any parameter setting from a single region, it will always take the same sequence of actions (including node, variable, and cut selection). The main subtlety is an induction argument to count these hyperplanes that depends on the current step of the tree-search algorithm.
In the context of integer programming, Theorem 5.2 not only recovers the main result of Balcan et al. [5] for learning variable selection policies, but also yields a more general bound that simultaneously incorporates cutting plane selection, variable selection, and node selection. In B&C, the first action of each round is to select a node. Since there are at most 2n+1 − 1 nodes, T1 ≤ 2n+1 − 1. The second action is to choose a cutting plane. As in Theorem 4.1, let C be a family of cutting planes such that for every IP (c, A, b), there is a decomposition of the parameter space into ≤ r regions such that the cuts generated by any two parameters in the same region are the same. So T2 ≤ r. The last action is to choose a variable to branch on at that node, so T3 = n. Applying Theorem 5.2, Pdim({fµ : µ ∈ Rd}) = O(dκn + dκ log r + d log d). Ignoring T1 and T2, thereby only learning the variable selection policy, recovers the O(dκ log n+ d log d) bound of Balcan et al. [5].

heading: 6 Conclusions and future research
text: We provided the first provable guarantees for using machine learning to configure cutting planes and cut-selection policies. We analyzed the sample complexity of learning cutting planes from the popular family of Chvátal-Gomory (CG) cuts. We then provided sample complexity guarantees for learning parameterized cut-selection policies, which allow the branch-and-cut algorithm to adaptively apply cuts as it builds the search tree. We showed that this analysis can be generalized to simultaneously capture various key aspects of tree search beyond cut selection, such as node and variable selection.
This paper opens up a variety questions for future research. For example, which other cut families can we learn over with low sample complexity? Section 3 focused on learning within the family of CG cuts (Sections 4 and 5 applied more generally). There are many other families, such as Gomory mixed-integer cuts and lift-and-project cuts, and a sample complexity analysis of these is an interesting direction for future research (and would call for new techniques). In addition, can we use machine learning to design improved scoring rules and heuristics for cut selection? The bounds we provide in Section 4 apply to any choice of scoring rules, no matter how simple or complex. Is it possible to obtain even better bounds by taking into account the complexity of the scoring rules? Finally, the bounds in this paper are worst case, but a great direction for future research is to develop data-dependent bounds that improve based on the structure of the input distribution.

heading: Acknowledgements
text: This material is based on work supported by the National Science Foundation under grants IIS1618714, IIS-1718457, IIS-1901403, CCF-1733556, CCF-1535967, CCF-1910321, SES-1919453, the ARO under award W911NF2010081, DARPA under cooperative agreement HR00112020003, an AWS Machine Learning Research Award, an Amazon Research Award, a Bloomberg Research Grant, and a Microsoft Research Faculty Fellowship.

Review summaries:
The paper focuses on the sample complexity of learning to select Chvatal-Gomory cuts for integer linear programming. We assume that there is an unknown distribution that generates ILP instances. CG cuts are parametrized by a set of weights, one per constraint. How large should the set of training instances be for one to accurately estimate the "goodness" of a given parametrization? This is the main question tackled here.  Using the data-driven algorithm design framework of Balcan et al. [8], this paper shows that three flavors of the learning problem can be analyzed effectively. The main contribution is to show that there is structure to the cut generation process as its parameters vary; the space of possible cuts can be partitioned, the form of the boundaries that determine the partition is identified, and the behavior of the cut generation is constant within each region. These can be plugged into a very general PAC learning bound from Balcan et al. [8].  Additionally, the sample complexity of generic tree search is analyzed. It is shown that variable, node, and cut selection can be parameterized simultaneously, each with its own additive scoring function, and sample complexity bounds can be derived accordingly. This result generalizes a previous branching-only bound from Balcan et al. [5]. 

This paper studies the sample complexity of cutting plane selection in branch-and-cut algorithms for integer programming problems. The authors study a handful of different settings, with the goal of characterizing the intrinsic difficulty of learning: (i) the tree size upon adding a single cut at the root, (ii) the tree size upon adding a sequence of cuts at the root, (iii) the tree size upon adding a series of waves of cuts at the root, and (iv) the score of cuts according to a set of predefined scoring rules. Finally, the authors generalize the results to bound the sample complexity of generic tree search policies with sequential operations that can be scored.

Linear integer programming is an incredibly important algorithmic tool that is used widely in practice.  In general the problem is NP-hard and so we have to resort to heuristics. These heuristics often use the branch-and-cut framework: we branch on "guesses" on variables and we cut by adding valid inequalities that tightens the linear relaxation of the integer program.  When dealing with such heuristics, an obvious question arises: which cut should I add and on which variable should I branch? The goal here is to limit  the size of the search tree and therefore getting a good running time. There has been a growing amount of experimental work on using ML algorithms to guide this choice.    The paper under submission considers this problem from a more theoretical perspective. The main results bound the sample complexity for finding "good" cuts complementing and generalizing a prior work that studied this question for variable selection.

Combinatorial optimization solvers often add cutting planes during solving, which are additional constraints in the problem that accelerate solving. These cutting planes have a major impact on the size of the final branch-and-bound tree, and therefore of the speed of the overall solving, but their impact is badly understood theoretically. At minimum, it is empirically understood that the size of the branch-and-bound tree is a complicated and sensitive function of the parameters of the cutting planes that were added during solving: a slightly different cutting plane might have been much more, or much less, effective.  In this paper the authors look at the problem of trying to learn these functions that relate the size of the branch-and-bound tree (a measure of solving performance) as a function of the instance data (A, b, c) when cuts with given parameters u_1, ..., u_k are added to the problem. They compute an order of magnitude of samples required to learn well this function, both for a single cut, a sequence of cuts, or rounds of sequences of cuts (as are used in practice). They also compute the number of samples required for the generalized problem of predicting tree size as a function of the instance data (A, b, c) for an algorithm that would pick the cut parameters to maximize a convex combination of scores, for given algorithm hyperparameters (the convex weights.) Finally, they do the same for more general algorithms that would pick an action, during solving, by maximizing a convex combination of scores, such as when doing node selection or variable selection.