Integer programming column generation: accelerating branch-and-price using a novel pricing scheme for finding high-quality solutions in set covering, packing, and partitioning problems

Large-neighbourhood search (LNS) heuristics are important mathematical programming techniques that search for primal feasible solutions by solving an auxiliary problem with a restricted feasible region. Extending such powerful generic LNS heuristics to the branch-and-price context is inherently challenging. The most prominent challenges arise from the fact that in branch-and-price algorithms, columns are generated with the sole aim to solve linear programming relaxations. Hence, the ability to form integer feasible solutions is not considered during the generation of columns. Without any changes to the standard pricing schemes, the potential of deploying generic LNS heuristics within a branch-and-price procedure is severely limited. This paper proposes a matheuristic, based on an LNS heuristic framework, where the novelty is a customised pricing scheme for generating columns to solve an auxiliary problem. The theoretical foundation for this pricing scheme is a set of optimality conditions for integer programs. From this foundation, a column generation strategy is developed for finding columns that are likely to be of use in high-quality primal feasible solutions for the original problem. The proposed matheuristic is implemented in the generic branch-price-and-cut solver GCG. On a broad test set comprising classical block diagonal structured instances and general instances from the MIPLIB 2017 Collection, the computational results show a significant improvement to the solving performance of GCG.


Introduction
Branch-and-price [6] is a mathematical programming technique for solving Mixed-Integer Programming (MIP) problems comprising a huge number of variables. When branch-and-price is applied to such problems, the variable set is not explicitly given but implicitly defined as the feasible solutions to a pricing problem. These variablesor columns as they are called interchangeably-are generated when solving Linear Programming (LP) relaxations of the MIP by column generation [26] at each node of a branch-and-bound tree. The problem formulation used in the branch-and-price context is often referred to as an extended formulation. This extended formulation is derived through a Dantzig-Wolfe reformulation of its compact counterpart, where the variables are explicitly given. An important characteristic of an extended formulation is that it is always at least as strong as the compact formulation. In particular, when the pricing problem does not have integrality property it is stronger, and in practice often much stronger. A price paid for this strength is the dramatic increase in the number of variables and the fact that a pricing problem needs to be solved to generate each variable.
A critical factor for the success of methods based on column generation is that only a small subset of the variables need to be generated to find an optimal solution. When designing a branch-and-price scheme, it is therefore important to avoid wasting computational time on generating columns that are of no use in high-quality solutions to the MIP. Note that when new columns are generated only to solve the LP relaxations in the branch-and-bound nodes, this is done without considering if they are of use for solving the MIP or if they can even be part of an integer feasible solution. Hence, any heuristic applied to find integer feasible solutions based on using such columns is always limited. In particular, if the root node integrality gap is large, there is a greater risk that the branching tree becomes large and many columns will need to be generated during the tree search-negatively impacting the effectiveness of the branch-and-price algorithm.
In this paper, we present a matheuristic, in the form of a Large Neighbourhood Search (LNS) heuristic, which is designed to generate columns that are likely to be of use for near-optimally solving the MIP. The proposed LNS heuristic can preferably be used to complement other components in generic branch-price-and-cut solvers. It can be applied both in the root node to decrease the integrality gap already there, and also during the tree search to find better integer solutions to prune the tree. For our computational experiments, we have implemented the LNS heuristic in the generic branch-price-and-cut solver GCG [10], which is an extension of the constraint integer programming solver SCIP [20]. As the computational results show, our LNS heuristic performs especially well on challenging instances for which the integrality gap in the root node is large. Furthermore, it is also effective in finding high-quality integer feasible solutions for a broad range of problems, including instances with and without known underlying block diagonal structures.

Related work
Since branch-and-price has traditionally been viewed as an application-specific algorithm, the development of generic heuristics has been limited. The emergence of general purpose branch-price-and-cut solvers, such as BaPCod [33], Coluna.jl [16], DIP [19], GCG [10] and VRPSolver [28], has provided valuable platforms for the development and deployment of generic column generation-specific heuristics. However, this development is far behind that for general MIP solvers that are applied directly to compact formulations. In those, generic heuristics are capable of finding high-quality integer feasible solutions without any prior knowledge of the problem structure. A class of generic heuristics that are integral to the success of modern MIP solvers for compact formulations are LNS heuristics [12].
Extending generic heuristics to the branch-and-price context is extremely challenging, see Sadykov et al. [34] and Zhao et al. [45]. A major barrier is the difficulty defining neighbourhoods with respect to variables that are yet to be generated. Additionally, imposing upper bounds on variables, which is common practice in generic LNS heuristics, is well known to induce complicating changes to pricing problems in branch-and-price algorithms.
We have categorised our matheuristic as an LNS heuristic (described within a destroy-repair framework [29]) and therefore the first part of our literature review is focused on LNS heuristics and sub-MIPing for extended formulations. An important aspect of our heuristic design is to adapt the pricing problem with the aim to generate columns that are different to those typically found when relying on regular LP pricing. The second part of the literature review therefore addresses other work with such intentions.

LNS and sub-MIPing for extended formulations
LNS heuristics have been developed and deployed both as components within MIP solvers and as stand-alone solution methods. A central component of LNS heuristics, regardless of the method of deployment, is the formation of an auxiliary problem with a restricted feasible region, also referred to as a sub-MIP. The restriction of the feasible region is achieved through the addition of constraints that are typically in the form of variable fixings, but they may also be more general, such as local branching constraints [18]. In general, it is desired that the auxiliary problem has a feasible region that makes the problem easy to solve while containing high-quality primal solutions. As indicated above, the standard methods for forming sub-MIPs cannot be directly adopted in a branch-and-price context.
An elementary form of auxiliary problem in a branch-and-price context is to define a MIP over the columns generated to solve the LP relaxation of the master problem. Solving this sub-MIP by branch-and-bound tends to be simpler than performing branch-and-price, and will hopefully find an integer feasible solution. This is referred to as the restricted master heuristic [25] or price-and-branch [17]. Since the included columns are generated only to solve the LP relaxation, the potential of this heuristic is rather limited. In particular, there is no guarantee that it will find a feasible solution [26].
Previous work related to more sophisticated heuristics to be applied in generalpurpose branch-price-and-cut solvers has involved adaptations of generic heuristics available in MIP solvers. Successful examples of LNS heuristics for branch-and-price includes adaptations of the feasibility pump [27], crossover [25], and diving heuristics [23,34]. Most importantly, these generic heuristics demonstrate the increased potential of finding high-quality integer solutions when executing a column generation scheme during the solution of LNS auxiliary problems for extended formulations.
A technical challenge of LNS heuristics for branch-and-price is that the addition of constraints to form the auxiliary problem potentially induces changes that may not be amenable to the pricing problem solver. As highlighted in Pesneau et al. [27] and Sadykov et al. [34], the use of variable upper bounds or the addition of general constraints introduce additional dual variables that must be taken into account in the pricing problem for the correctness of the column generation algorithm. This imposes significant limitations on the restrictions that can be used to form an LNS auxiliary problem within branch-and-price algorithms. This is a particular concern when developing LNS heuristics using the destroy-and-repair framework, since the destroy step typically imposes upper bounds to fix variables to zero.
The issues raised by Pesneau et al. [27] and Sadykov et al. [34] related to the formation of LNS heuristic auxiliary problems are not encountered in the generic LNS heuristics presented in Lübbecke and Puchert [25]. The LNS heuristics discussed in Lübbecke and Puchert [25] exploits the feature of GCG where the pricing problem is formulated and solved as a MIP. Thus, any modifications to the pricing problem that are required as a result of restrictions imposed to form the auxiliary problem are simply accounted for by changes to the corresponding pricing problem MIP. This feature of GCG is also exploited in the LNS heuristic developed in this paper-avoiding the limitations of LNS heuristics encountered in Pesneau et al. [27] and Sadykov et al. [34].
A major feature of our proposed heuristic, which further avoids the issues raised by Pesneau et al. [27] and Sadykov et al. [34], is that variable fixings imposed in the destroy step are handled in a way that does not affect the feasible set of the pricing problem. Instead, the restrictions imposed on the variables of the extended formulation are accounted for with respect to their impact in the set covering, packing or partitioning constraints. Based on this impact, the objective coefficients of the pricing problem are modified to favour columns that comply with the variable fixings. As such, the developed pricing scheme can be applied in general branch-and-price algorithms.
An important characteristic of the generic LNS heuristics developed in Pesneau et al. [27], Lübbecke and Puchert [25] and Sadykov et al. [34] is that the generation of columns is performed to solve the LP relaxation of the auxiliary problem. Therefore, the generated columns are still only suitable for solving LP relaxations and the aspect of integrality is then delegated to the branching scheme. The modifications to the pricing problem proposed in this paper addresses this limitation by developing a pricing scheme that searches for columns that are expected to be part of integer feasible solutions.
A method that extends the heuristic search beyond the columns considered within a restricted master heuristic, but without the involvement of a branch-and-bound tree, is the SearchCol strategy [1,2]. This method iterates between column generation for an LP relaxation of a restricted master problem to find profitable columns and a metaheuristic search on the available columns. The outcome of the latter is used to select restrictions to impose on the pricing problems in the next iteration with the purpose to guide and diversify the search for promising columns.
Extensions to the restricted master heuristic, that guarantee that an optimal solution of the MIP can be found, have been presented by Sweeney and Murphy [38], Baldacci et al. [4], and Baldacci et al. [5]. The central idea of the presented approaches [4,5,38] is to generate a set of columns for the restricted master problem such that a subset of which is guaranteed to form an integer optimal solution. This solution can then be found by performing branch-and-bound on the restricted master problem using only the generated columns. A general description of optimality conditions for this context is found in Rönnberg and Larsson [32]. The benefit of this type of method is that no pricing is needed during the branch-and-bound process. The challenge is instead to generate a small-enough set of columns for the restricted master problem while still ensuring that this set contains an optimal solution.
Common for all the papers reviewed above is that column generation is used to solve an auxiliary problem, but pricing is still performed with respect to the LP relaxation. The primary differences between these papers are how this auxiliary problem is obtained and how the solution of the auxiliary problem is integrated with a branching scheme. Another related line of work involves to, in a more fundamental way, change the pricing scheme such that integrality is explicitly considered during the solving of the restricted master problem and while generating columns. Such approaches are reviewed in the following section.

Pricing for integrality
A method-not related to LNS heuristics nor to the formulation of auxiliary problems-that is designed to increase the chances of finding columns that can be part of a high-quality integer solution within a branch-and-price context is presented in Bredström et al. [13]. They propose adding a surrogate constraint to the restricted master problem to tweak the column generation process used for solving the corresponding LP relaxation. A subgradient technique is then applied to a Lagrangian dual formulation of the master problem. The multipliers are heuristically adjusted to favour columns that are needed for forming an integer solution. This multiplier adjustment is constructed such that the method converges to a standard subgradient method, hence ensuring convergence to solving the LP relaxation of the restricted master problem.
Beyond the work of Bredström et al. [13], we have only found that pricing for integrailty has been proposed outside the scope of branch-and-price. The first line of work uses the quasi-integrality property of problems with only set packing and set partitioning constraints [42]. This property of set packing and partitioning problems means that the edges of the convex hull of the integer feasible solutions are also edges of the polytope of feasible solutions to the LP relaxation of the problem. Thanks to this property it is possible to make simplex iterations that visit only integer extreme points. However, it is not straightforward to find the variables that yield these iterations. Methods for finding such pivots for compact formulations have been proposed in Trubin [42], Thompson [40], and Zaghrouti et al. [44]. By making special adaptations of the pricing problem it is possible to extend such methods to generate columns that can be used to pivot between integer solutions as proposed in Rönnberg and Larsson [30,31] and Tahir et al. [39].
Another line of work, with an alternative view on pricing for integer programs, is proposed in Zhao et al. [45]. Based on the optimality conditions in Larsson and Patriksson [24], Zhao et al. [45] formulate a pricing problem designed to greedily find one column that, when replacing a column in an integer feasible solution to a restricted master problem, is likely to yield an improved integer feasible solution. The focus of the paper was the theoretical derivation and justification that the pricing problem has these properties. The theoretical results of Zhao et al. [45] were supported by some computational illustrations based on a simple heuristic implementation. The design and implementation of a computationally competitive method were left for future work. The theoretical results in Zhao et al. [45] and Larsson and Patriksson [24] are a part of the foundation for the method proposed in this paper. Because of their importance, and the need for notation to discuss them further, they are addressed more extensively among the preliminaries in Sect. 2.

Outline and contribution
This paper proposes a column generation-based matheuristic for MIP that can be applied to any problem where the master problem includes set covering, packing or partitioning constraints. Our design is based on the destroy-and-repair LNS framework [29] and it extends the work in Zhao et al. [45] to perform pricing for integrailty based on the global optimality conditions presented in Larsson and Patriksson [24]. Section 2 reviews this previous work after introducing the relevant notation.
In the proposed LNS heuristic, the destroy method forms a partial solution by removing columns from a current primal feasible solution to a restricted master problem. The repair method consists of two steps: The first is to execute a customised repair pricing scheme and the second is to solve a repair problem to search for an improved integer solution. The novelty in this design is the repair pricing scheme that carefully selects columns to increase the chances of a successful outcome of solving the repair problem. The design of the LNS heuristic and the theoretical derivation of the repair pricing scheme is presented in Sect. 3.
The proposed heuristic has been implemented to complement the suite of heuristics within the branch-price-and-cut solver GCG [10]. This integration is addressed in Sect. 4. While the general destroy-and-repair principles underlying this heuristic can be applied as a stand-alone procedure, the integration with GCG brings many challenges and benefits. This paper will highlight the aspects that must be considered when balancing the exploration of integer feasible solutions against proving optimality within a general-purpose branch-price-and-cut solver.
The integration with GCG is used to show the general nature of the proposed heuristic and its wide applicability to many different problem types. This is supported by the results from the two types of computational evaluations presented in Sect. 5. First, a set of computational experiments to investigate key performance features is performed using publicly available instances originating from problem types with known block diagonal structures. A second set of experiments makes use of the automatic structure detection of GCG. Using a set of general instances from MIPLIB 2017 [21], GCG is applied to detect structures, perform a Dantzig-Wolfe reformulation and then solve the instances by branch-price-and-cut. The inclusion of the proposed heuristic within GCG is shown to significantly improve the effectiveness of branch-price-and-cut on both instance test sets. The paper is ended with some concluding comments in Sect. 6. With its inclusion in the distribution of GCG, the proposed LNS heuristic will be publicly available to the academic community.

Preliminaries
This section introduces notation and provides a foundation for the theoretical contributions of this paper. In particular, we review the results from Larsson and Patriksson [24] and Zhao et al. [45] that are used in Sect. 3.

Notation
Consider the binary program which is assumed to be an extended formulation derived by applying the discretisation approach [22,43] to an original compact formulation of a binary program. As such, [MP] is referred to as a master problem. To simplify notation, we have omitted the details of the decomposition that results in this extended formulation. Instead, we refer to standard derivations such as the one found in Lübbecke and Desrosiers [26] and note that for binary programs, discretisation and convexification coincide. The columns (c j , a j ), a j = (a i j ) i∈I , j ∈ J , are implicitly given as elements of a set A ⊆ R × {0, 1} |I | and they correspond to feasible solutions to a pricing problem. The explicit constraints are of set covering and set packing type and indexed by the sets I c and I p , respectively. In our formulation, a set partitioning constraint is represented by including both its covering and packing counterparts in [MP]. Further, let I = I c ∪ I p index the complete set of explicit constraints of [MP].
Before introducing the implicit constraints given by the set L, some further notation is needed. It is assumed that the original problem can have a block diagonal structure. As such, the pricing problem separates into independent pricing problems. Let the set K index the independent pricing problems. To take into account that some of the pricing problems can be identical, the set K is partitioned into subsets-the set Q indexes these subsets. Then, for q ∈ Q, let the set K q index pricing problems that are identical. Hence, there is a pricing problem for each q ∈ Q and this problem can generate columns for the identical pricing problems indexed by K q . Let the complete set of columns for pricing problem q ∈ Q be indexed by the set J q . Using this notation, the implicit constraints of [MP] are defined by Further, let the set that implicitly defines the columns (c j , a j ), j ∈ J q , be denoted by A q . Next we will introduce the two types of reduced costs that are of relevance when generating columns in our setting. Let u i ≥ 0, i ∈ I , be dual multipliers associated with the explicit constraints of [MP]. By performing a Lagrangian relaxation of these constraints, the corresponding Lagrangian reduced costs arẽ A pricing problem for q ∈ Q with respect to this partial Lagrangian relaxation is The corresponding LP reduced costs of the columns are derived as follows. Let [MP-LP] denote the LP relaxation of [MP], where λ j ∈ {0, 1}, j ∈ J is replaced by λ j ≥ 0, j ∈ J . Let the multipliers u i ≥ 0, i ∈ I take the role of the LP dual variables of the explicit constraints of [MP-LP]. We introduce v q as the LP dual variables associated with the constraints j∈J q λ j = |K q |, q ∈ Q in [MP-LP]. The LP reduced costs of the columns arē A master problem restricted to include only a subset of columns, indexed by J q ⊆ J q for each subset q ∈ Q of identical pricing problems, is referred to as a Restricted Master Problem [RMP]. Let J = ∪ q∈Q J q index the full set of columns at hand in [RMP], and note that it typically holds that |J | |J |. Let [RMP-LP] denote the LP relaxation of [RMP], where λ j ∈ {0, 1}, j ∈ J is replaced by λ j ≥ 0, j ∈ J .

Greedy integer programming column generation
The method presented in this paper will use a pricing problem inspired by the Greedy Integer Programming Column Generation (GIP-CG) subproblem introduced in Zhao et al. [45]. To establish a relation to this previous work and to present a foundation for the results to be presented in this paper, we begin with a derivation of a GIP-CG pricing problem for [MP]. Following the derivation, we give a brief description of the theoretical justifications for its design.
The work in Zhao et al. [45] addresses a setting where a destroy-and-repair heuristic is used to find improving integer solutions to a restricted master problem. Each iteration of the heuristic involves removing one column and then immediately adding one new column to a current, not necessarily feasible, integer solution. Such current integer solution is simply defined by a set of columns that are active in the solution. The new column to add is generated and tailored to match the so-called partial solution, which is obtained after a column has been removed. Such partial solution is defined by the index setsĴ q ⊆ J q , q ∈ Q, chosen such that |Ĵ q | ≤ |K q | and q∈Q |Ĵ q | < |K | hold.
The partial solution is referred to by the index setĴ = ∪ q∈QĴq .
The GIP-CG pricing problem in Zhao et al. [45] was derived based on the global optimality conditions presented in Larsson and Patriksson [24]. Its objective comprises two parts: The first is related to the quality of the resulting master problem solution. The other concerns the feasibility in the restricted master problem. The formulation of the latter part, which is critical for finding high-quality integer solutions, depends on the problem structure. The general description in Zhao et al. [45] does not prescribe how to do this for general integer programming problems. To derive a formulation for [MP] in our paper, the following notation is introduced, which indicates the feasibility of the explicit constraints of [RMP] in a partial solution given by the setĴ . For the covering constraints, let the set of rows that are not covered in a partial solution be indexed by the setÎ To reach feasibility with respect to these rows will require the use of columns that cover these rows. For the packing constraints, let the set of rows where the partial solution already fills or even violates the packing constraints be indexed by the set To maintain feasibility with respect to the rows that are fulfilled with equality, and to not create more infeasibility with respect to the rows that are already violated, only columns that do not cover these rows can be used to repair the partial solution. The following proposition shows how to restate a GIP-CG in our setting.

Proposition 1 Let the setĴ index columns that defines a partial solution to [RMP]
and letū i ≥ 0, i ∈ I , be a dual solution to [RMP-LP]. For a given γ ∈ [0, 1] and an M ≥ 0, an optimal solution to GIP-CG as defined in [45, p. 672] can be found by solving the problem [GIP] Proof We begin by translating the result in Zhao et al. [45] to the notation and setting used in our paper. In the generic definition of GIP-CG [45, p. 672], a partial solution is given. The columns of the corresponding partial solution in the current paper is indexed by the setĴ . The general derivation in Zhao et al. [45] considers the case of generating one new column to be added to a restricted master problem such that a violation of the implicit constraints is not introduced. The corresponding assumption in our setting is that for the partial solution, there exists aq ∈ Q such that |Ĵq | ≤ |Kq | − 1 holds. Further, GIP-CG is defined only for the columns that will not increase the violation of the implicit constraints of [RMP]. This general requirement translates to our setting as only considering columns j ∈ J q for q ∈ Q such that |Ĵ q | < |K q | hold. Using the notation of the current paper, and also including ≤-constraints by changing the appropriate signs, GIP-CG can be stated as Note that the first three terms are the same as those in [GIP] and that the last two terms penalise infesibility with respect to the explicit constraints in the restricted master problem. Consider these last two terms further. Since j∈Ĵ a i j = 0 for i ∈Î c and Since j∈Ĵ a i j ≥ 1 for i ∈Î p and j∈Ĵ a i j = 0 for i ∈ I p \Î p , it also holds that Hence, the two terms that penalise infesibility in GIP-CG can equivalently be expressed as which differs only by constant terms from the last two terms in [GIP]. Since GIP-CG and [GIP] are defined over the same sets of columns and their objective functions differ only by constant terms, an optimal solution to GIP-CG can be found by solving [GIP].
The objective of GIP-CG has one component, given as the last two terms in [GIP], that, in a l 1 -norm sense, penalises columns that will violate the explicit constraints in [RMP]. The purpose of this component is to promote columns that can be part of a primal feasible solution to [RMP].
The other component in the objective of GIP-CG promotes columns that are likely to yield an improvement of the objective value if included in a solution to [RMP]. This component is given by the first three terms and it differs from the objective function of [CG q ], q ∈ Q, only by the parameter γ . We will not provide a full derivation that explains the inclusion of the parameter γ ; instead, we refer to Sects. 2.1-2.2 in Zhao et al. [45] and provide here only a brief discussion and explain how the parameter can be chosen depending on the properties of the problem to be solved.
In Zhao et al. [45], GIP-CG is derived from the optimality conditions presented in Larsson and Patriksson [24]. These optimality conditions extend the general primaldual optimality conditions (see Theorem 2 in Zhao et al. [45] and Theorem 6.2.5 in Bazaraa et al. [8]) to be valid also for problems with a positive dual gap. A key facilitator for the extension in [24] is to introduce the quantity δ-complementarity that accounts for the deviation from complementarity in the explicit constraints; it can be expressed as as for extreme point solutions to a linear program. When complementarity is expected to hold in an optimal solution, the derivation in Zhao et al. [45] shows that γ = 1 should be used in GIP-CG. This corresponds to using the standard Lagrangian reduced costs as in [CG q ], q ∈ Q. However, if complementarity is not expected to hold, as can be the case for integer programs, it is reasonable to use a γ < 1. The exact value to choose for γ is not known, as it depends on the degree of δ-complementarity for the specific instance of a problem.
The pricing problem that will be described for the heuristic introduced in Sect. 3 will, similar to above, have an objective function that comprises two parts. The first part will have to do with the quality of the solution and this will also consider δ-complementarity, but in another sense than for GIP-CG. The second part of the objective will concern feasibility, but-again-in a different way than described above.

IPCOLGEN -An integer programming column generation matheuristic
The core component of the LNS heuristic presented in this section is a repair method that uses a novel pricing scheme specifically designed to generate columns that repair a partial integer solution to [RMP]. This section introduces the heuristic design and provides a theoretical derivation and justification for the design of the pricing scheme.
To aid the exposition, Appendix A presents a numerical example that can be read alongside this section. The proposed LNS heuristic is intended to be applied in a generic branch-price-and-cut solver but it is presented, and can also be used, as a stand-alone procedure. The integration with the generic branch-price-and-cut solver GCG is addressed separately in Sect. 4.

Method framework
Our method will be described within the LNS framework, see Pisinger and Ropke [29] for details. LNS is a metaheuristic search method introduced in Shaw [37] where, in each iteration, a large neighbourhood is explored by first destroying a current solution and then repairing it. The general LNS framework is displayed in Algorithm 1. The key design considerations are the definitions of the destroy and repair methods as these implicitly define the neighbourhoods and direct the search for feasible solutions.

Algorithm 1 Large-neighbourhood search
Require: A primal feasible solution Ensure: An updated primal feasible solution 1: Let the current solution be the input primal feasible solution 2: Let the best solution be the current solution 3: repeat 4: Apply a destroy method to the current solution 5: Apply a repair method to the destroyed solution 6: if Acceptance criterion is met then 7: Let the current solution be the repaired solution 8: end if 9: if The current solution is better than the best solution then 10: Let the best solution be the current solution 11: end if 12: until Stop criterion is met Our LNS heuristic is applied to an [RMP] where the repair method uses a customised pricing scheme and solves a repair problem to find improving integer solutions to [MP]. This customised pricing scheme is a major difference from previous work [25,27,34] on generic LNS heuristics for branch-and-price. To define the destroy and repair methods for a given [RMP], the following notation is introduced.
-A primal feasible solution to [RMP] is referred to by the columns that are active in the solution. For each q ∈ Q, let the set J IP q ⊆ J q index all active columns from subset q of identical pricing problems, that is, the columns j ∈ J q for which it holds that λ j = 1. Further, use the set J IP = ∪ q∈Q J IP q to index all active columns and the corresponding primal feasible solution.
-A partial solution to [RMP] is defined by a set of columns that is obtained by removing columns from a primal feasible solution. Let the setsĴ q ⊆ J IP q , q ∈ Q, index columns chosen such that |Ĵ q | ≤ |K q | and q∈Q |Ĵ q | < |K | hold. A partial solution is then referred to by the index setĴ = ∪ q∈QĴq . Note that this definition differs slightly from that presented in Sect. 2.2, where the partial solution did not need to originate from a feasible solution.
The destroy method forms a partial solutionĴ by removing columns from a current primal feasible solution J IP . The repair method consists of two steps: The first is to generate a set of repair columns indexed by the set and the second is to solve the repair problem has an optimal solution with a better objective value than that of the current primal feasible solution defined by J IP , the solution to [REP]-together with the columns indexed byĴ -becomes the new primal feasible solution. This is the acceptance criterion on line 6 in Algorithm 1. If the new solution is not accepted, the procedure is repeated by further destroying the partial solution and then the repair method is applied again. The stop criterion on line 12 in Algorithm 1 is fulfilled after a prespecified number of iterations or if a local optimum is found. A local optimum, with respect to the neighbourhood defined by our destroy and repair methods, is reached when the partial solution becomes empty after applying the destroy method. This happens after repeatedly applying the destroy and repair methods without obtaining an improved feasible solution. Note that it holds that an optimal solution to the original problem will be a local optimum in this sense. This follows from the fact that when an optimal solution is destroyed, the repair method can never find a better solution. Thus, the destroy method will be repeatedly applied until the partial solution becomes empty.
Given a partial solutionĴ , the quality of the best primal feasible solution to [RMP] that can be obtained by solving [REP] depends on the repair columns, indexed by J R . The next two sections provide a derivation of how we generate these columns. First, Sect. 3.2 gives a theoretical justification for the design of our repair pricing scheme. Section 3.3 then discusses how to choose values for the parameters included in the repair pricing objective.

Repair pricing scheme for [REP]
The repair pricing scheme is designed to generate a set of repair columns, indexed by J R , to be included in [REP] with the goal that the solution to [REP] is an improved integer feasible solution for [RMP]. Note that an important difference to the setting in Zhao et al. [45] is that instead of greedily choosing a single best possible column to replace a removed one we want to generate a set of columns and then solve [REP] to find a new solution to [RMP].
Ideally, we would like to generate a set of columns that are active in an optimal solution to [REP] when it is solved over the set of columns indexed by J \Ĵ . Such a set of columns, termed ideal columns, would yield a best possible new solution to [RMP] and is defined as follows.
This set of columns cannot be found without evaluating all possible columns to include in [REP]. Therefore, our strategy is to instead generate columns that are chosen such that they are likely to be part of a high-quality solution to [REP]. This generation is made iteratively, adding one new column at a time. We refer to this procedure as a repair pricing scheme, and it relies on the following property of the set J R * .

Remark 1
The set J R * can be used to index the ideal columns even if these columns are not known. This follows since, in any solution to [REP] for a fixed partial solution, the last set of constraints in [REP] implies that the number of columns from pricing problem q ∈ Q is |K q | − |Ĵ q |.
Our repair pricing scheme generates a set of columns indexed by L j for each j ∈ J R * so that the total set of columns generated after applying the scheme, for a given partial solution, is indexed by L = ∪ j∈J R * L j . Then, [REP] is defined for J R = L. In iteration l = 0, . . . , |L|−1 of the repair pricing scheme, letL jl ⊆ L j index the set of generated columns. Note that L j =L jl for l = |L| − 1, j ∈ J R * .
The derivation of our repair pricing scheme is based on considering the contributions of the columns inL jl , l = 0, . . . , |L| − 1, j ∈ J R * , in an average sense. Therefore, we begin by making the following definition.

Definition 2
Let J index a set of columns. The average column for the set J is the column 1 |J | j∈J c j , a j . The aim of the repair pricing scheme is that the average column for the set L j approximates the ideal column indexed by j ∈ J R * so that (c j , a j ) ≈ 1 Using this concept of an average column means that we do not consider which of the generated columns will actually be active in a solution to [REP]. What we do consider is that the generated columns have profitable properties on average. This is advantageous since the set of active columns can only be known after [REP] has been solved for the full set L. To iteratively improve this approximation during a round of repair pricing, we consider the contribution from the columns generated up to the current round and let these influence the further search as follows.
The approximation of the ideal columns can be considered as trying to mimic important properties of these columns. Feasibility in the explicit constraints of [MP] is a property that is fundamental in the search for integer feasible solutions. Let c * = j∈J R * c j and use the notation to refer to the contribution that a set of ideal columns would make to the left-hand side of the constraints for i ∈ I c and i ∈ I p in [REP]. To achieve feasibility with respect to these constraints, terms are included in the pricing problem objective to penalise infeasibility. In the following, we provide a derivation of these terms and highlight the differences to the approach described in Sect. 2.2. For the covering constraints, let the set of rows that are not covered in a partial solution be indexed by the set and let the set of rows that are covered in a partial solution be indexed by the set Similarly, for the packing constraints, let the set of rows that are not filled by the partial solution be indexed by the set and let the set of rows where the partial solution already satisfies the packing constraints with equality be indexed by the set Using this notation, a necessary property of the ideal columns can be described as follows.
Proof Together, the columns indexed by the setsĴ and J R * constitute a feasible solution to [REP] and therefore j∈Ĵ a i j + j∈J R * a i j ≥ 1, i ∈ I c0 ∪ I c1 and j∈Ĵ a i j + j∈J R * a i j ≤ 1, i ∈ I p0 ∪ I p1 hold. Then, the definition of the setÎ c0 yields that j∈J R * a i j ≥ 1 − j∈Ĵ a i j = 1, i ∈Î c0 , holds. Similarly, the definition of the setÎ p0 yields that j∈J R * a i j ≤ 1 − j∈Ĵ a i j = 1, i ∈Î p0 , holds. Further, for i ∈Î p1 it holds that j∈Ĵ a i j = 1 implying that j∈J R * a i j ≤ 1 − j∈Ĵ a i j = 0 also holds, which together with a i j ≥ 0, j ∈ J , yields that j∈J R * a i j = 0. Lastly, since a i j ≥ 0, j ∈ J , it holds that j∈J R * a i j ≥ 0, i ∈Î c1 .
The following lemma introduces the properties of a column that will later be used as the benchmark when assessing, in an average sense, the properties of columns that have been generated. This column is constructed such that if this is the column generated in each iteration of the repair pricing scheme, then, together the average columns for the sets of columns generated for each j ∈ J R * would yield the same objective value in [REP] as the ideal columns.

Lemma 2 Let [REP] be defined for a partial solution indexed byĴ such that [REP]
is feasible. For each j ∈ J R * , letL j index a set of identical columns with coefficients Let c j , ã j i∈I denote the average column for the setL j , j ∈ J R * . The set of columns c j , ã j i∈I j∈J R * is an ideal set of columns for [REP].

Proof The result follows since
Note that these identical columns typically cannot be attained in practice as their constraint coefficients are not necessarily binary. Lemmas 1 and 2 state the properties of an ideal set of columns for [REP]. Note that in Lemma 1, the properties of a i j for i ∈Î p1 ∪Î c1 translates to each individual ideal column, while for i ∈Î p0 ∪Î c0 the property concerns all the ideal columns jointly. To better illustrate how to mimic these two properties when generating columns for the sets L j for each j ∈ J R * , we separate them into static and dynamic feasibility properties, respectively. In the following, we begin by focusing on the static feasibility properties and thereafter the dynamic feasibility properties are addressed.
Proof The columns included in a solution to [REP] must constitute a feasible solution in the same sense as the ideal columns. The result follows from Lemma 1 together with the requirement that a i j ∈ {0, 1}, i ∈ I , j ∈ J .
The result from Theorem 1 means that columns where a i = 1, i ∈Î p1 , must not be generated, since these can never be part of a feasible solution to [REP]. Therefore, in the formulation of the repair pricing problem below, there will be a large static penalty M to force a i = 0, i ∈Î p1 . Furthermore, Theorem 1 states that no restriction is needed with respect to the constraints i ∈Î c1 . Note that the result of Theorem 1 also holds if a column (c j , a j ), j ∈ L, is replaced by an average column for some set of columns.
For the remaining rows, indexed by i ∈Î p0 ∪Î c0 , it is not sufficient to consider the feasibility requirements with respect to individual columns. Instead, we study the average column for the set of columns generated this far to wisely direct the further search.
Theorem 2 (Dynamic feasibility properties) For j ∈ J R * and iteration l = 0, . . . , |L| − 1 of the repair pricing scheme -letL jl ⊆ L j index the sets of generated columns and denote the average column for the setL jl by ĉ jl ,â jl , and -letL jl : |L jl | = |L jl | index sets of identical ideal columns and denote the average column for the setL jl by c jl ,ã jl .
If the contribution to the left-hand side of the constraints i ∈ I c0 ∪ I p0 in [REP] is the same for the columns ĉ jl ,â jl and c jl ,ã jl , then it holds that Proof Since the contribution to the left-hand side of the constraints i ∈ I c0 ∪ I p0 in [REP] is the same for the columns ĉ jl ,â jl and c jl ,ã jl , j ∈ J R * , l = 0, . . . , |L|−1, it holds that Taking the sum over j ∈ J R * and using Lemma 1 yields and the conclusion follows.
The inequality presented in Theorem 2 can hence be used to assess an average feasibility status of the generated columns in comparison to an ideal set of columns. By doing so, the penalty for violating these constraints can be dynamically adjusted depending on the columns that have been generated this far. For this purpose, let β il denote the penalty for the row indexed by i ∈ I c0 ∪ I p0 in iteration l = 0, . . . , |L| − 1.
In line with the presented arguments, the repair pricing problem for the identical pricing problems indexed by q ∈ Q in iteration l = 0, . . . , |L|−1 of the repair pricing scheme is formulated as Note that the first three terms in the objective are the same as those for [GIP] in Proposition 1, even if the δ-complementarity that γ stems from has another origin than that for [GIP]. This will be further discussed in Sect. 3.3 and henceforth we will refer to γ as the complementarity parameter.
In [GIP], a penalty is used to force the constraint coefficients to have certain values. A major difference between [GIP] and [REP-CG ql ] is that the latter includes both a static penalty for properties that must be fulfilled by all generated columns and a dynamic penalty to guide the search to find columns that are likely to be part of a feasible solution to [REP].

Parameters in the repair pricing problem
The repair pricing problem includes parameters that need to be assigned appropriate values. The first is the complementarity parameter γ that was introduced for [GIP] in Proposition 1. In the context of [GIP], the value of γ corresponds to the amount of δ-complementarity to expect in [RMP] when greedily adding one new column. In this paper, and more specifically in the context of [REP-CG ql ], the δ-complementarity refers neither to [RMP] nor to [REP]. Instead, it refers to the effect that iterationl in the repair pricing scheme has on [REP].
In iterationl, the average columns for the setsL j(l−1) , j ∈ J R * are already known and some columns remain to be generated in iterations l =l + 1, . . . , |L| − 1. Note that during our repair pricing scheme, we always consider the average contributions from the columns that have been generated for each j ∈ J R * . Therefore, the δcomplementarity after iterationl will be Neither the average column for the setsL j(l−1) , nor the average columns for the setsL jl , j ∈ J R * , are expected to have only binary coefficients. On the contrary, it can be expected that they are fractional. Hence, it is expected that the value of δ((ū i ) i∈I ) is non-zero. Thus, the actual value of γ needs to be tuned with respect to the amount of δ-complementarity that is to be expected. The setting of γ in the practical application of the proposed heuristic is investigated computationally in Sect. 5.
The values of β il , i ∈ I c0 ∪ I p0 , l = 0, . . . , |L| − 1, need to be chosen with the aim to generate columns that comply with the inequality in Theorem 2. In our scheme, we choose an initial value to assign to β i0 , i ∈ I c0 ∪ I p0 , and then we make updates and assign values to β il , i ∈ I c0 ∪ I p0 , l = 1, . . . , |L| − 1 depending on if the conditions given by Theorem 2 are satisfied. When determining how to make these updates, there is a trade-off between feasibility in [REP] and the cost of the column. We propose to handle this trade-off by initialising with a small value of β i0 , i ∈ I c0 ∪ I p0 , and then rather rapidly increase the penalty for an i ∈ I c0 ∪ I p0 when the inequality in Theorem 2 is violated and to, similarly, decrease it rapidly when the inequality is satisfied.
An important note about the objective of [REP-CG ql ] is that there can be two objective coefficients for the same a i , i ∈ I , but with different origins. The coefficient γū i depend on the current solution to [RMP-LP] and if the constraint indexed by i ∈ I is not active in the solution to [RMP-LP] thenū i = 0. The other coefficient, either β il or M, does instead depend onĴ , the partial solution to [RMP]. Hence, the objective is influenced by an interplay between the dual solution to [RMP-LP] and the partial solution to [RMP] that is used.
In IPColGen, a set partitioning constraint is included through its covering and packing counterparts. During the repair pricing scheme, it is not likely that both of these constraints are complied with by the current average column. Instead, infeasibility is expected in one of them while there is a non-zero δ-complementarity in the other. It is likely that these roles will alternate between the two constraints. Thus, it is reasonable for δ to be non-zero for the set partitioning constraints during the execution of the repair pricing scheme.

Implementation and integration with GCG
The proposed LNS heuristic has been implemented within the generic branch-priceand-cut solver GCG [10], which is an extension of the constraint integer programming solver SCIP [20]. GCG is a generic MIP solver. As such, given a general MIP instance, GCG will automatically detect decomposable structures, perform a Dantzig-Wolfe reformulation using a selected structure and then solve the resulting reformulated problem using branch-price-and-cut. It is also possible to skip the detection stage by supplying a known decomposition structure. Importantly, GCG contains a suite of column generation-specific primal heuristics, such as those described by Lübbecke and Puchert [25]. A major contribution of this paper is the incorporation of IPColGen into this suite of primal heuristics to improve the ability of GCG to find high quality integer solutions for difficult MIP problems.
Since GCG is a generic solver, the column generation pricing problem is usually formulated and solved as a MIP instance-typically using SCIP. Solving the pricing problem as a MIP avoids many of the issues related to LNS heuristics for branch-andprice that are highlighted by Pesneau et al. [27] and Sadykov et al. [34]. However, it is important to note that since IPColGen only modifies the subproblem objective, and not the subproblem constraints, the issues raised by Pesneau et al. [27] and Sadykov et al. [34] are not encountered in any application of the proposed heuristic.
The IPColGen algorithm has a high computational cost resulting from the execution of multiple repairing pricing rounds and solving of the repair problem [REP]. Thus, the point at which IPColGen is executed during the node processing must be selected carefully. An adaptive procedure, based on the identification of the column generation tailing-off effect [26] and current optimality gap, has been developed to determine when to first execute IPColGen. The previous work of Zhao et al. [45] identified that when the tailing-off effect is first observed the dual values tend to have stabilised. Preliminary experiments showed that a stable set of dual values improves the effectiveness of IPColGen. Additionally, IPColGen will only be executed if the optimality gap when the tailing-off effect is observed is suitably large, i.e. only for difficult instances. Computational experiments will be performed to identify the optimality gap level that can be regarded as suitably large.
In this paper, tailing-off is identified using a threshold based on the relative difference between the average LP objective value from the previous 5 iterations and the current LP objective value. If the relative difference is less than 0.01%, then the dual values have stabilised sufficiently for the execution of IPColGen. To avoid the noise in the dual solutions during the early stages of pricing, at least |K | pricing iterations must be performed before the first call to IPColGen at the root node. For all subsequent nodes, at least |K | × 0.1 pricing iterations must be performed before IPColGen is called.
A number of additional execution conditions must be met before IPColGen will be called at a node. These include: -A primal feasible solution must be available prior to the execution of IPColGen.
For all subsequent calls to IPColGen, a new incumbent solution must have been found since the previous call, except at the root node. -In the branch-and-price tree, a depth frequency of 5 is used. As such, IPColGen is only called at nodes at depths 0, 5, 10, 15, . . .. -IPColGen is only called when at least m nodes have been processed after the previous call. The value of m is updated based on the success of IPColGen. If IPColGen finds an improving integer solutions, then m is set to 0, otherwise m is set to 10(m + 1).
Since [REP] is a sub-MIP, the computational effort-in terms of nodes-is restricted to avoid unnecessarily long solution times. An esoteric formula is used for LNS heuristics within SCIP and GCG to determine the number of nodes supplied to sub-MIPs, which depends on the parameters h p , s, and e that are the number of nodes processed, the number of solutions found by IPColGen and the number of calls of IPColGen, respectively. This formula is given by where B ∈ [0, 1] is a factor of the total number of nodes processed, S ≥ 0 corresponds to a setup cost of IPColGen in terms of nodes and h 0 is a constant offset for the number of nodes to be processed. For IPColGen the default values are B = 0.5, S = 100 and h 0 = 500. If h is less than a minimum number of nodes, which is 50 by default, then there is not sufficient nodes to solve the [REP] and IPColGen is not executed.

Overview of IPCOLGEN algorithm
The IPColGen algorithm is presented in Algorithm 2. There are three main components of the Form a partial solution from the incumbent solution 5: // Set the complementarity weight and dynamic penalties 6: Set the weight, γ , for the dual values in the pricing problem objective 7: Set the initial dynamic penalties, β i0 , for each row i ∈ I c0 ∪ I p0 8: for n ← 0 to 2 do 9: // Perform pricing to generate repair columns 10: for l ← 0 to (|Q| − 1) do 11: Perform the repair pricing scheme by solving [REP-CG q(l)l ] 12: Add The partial solution is defined by the setĴ and it is formed by randomly selecting a subset of the columns in the incumbent primal solution J IP to be set to zero. The size of this subset is given by a run-time parameter that specifies a percentage of variables with respect to |Q| that must be fixed, by default this value is 20%. Since the variables are randomly selected, it is possible that a sufficient number of variables with nonzero solution values are found. If the fixing rate is not achieved, then IPColGen is not executed.
The most important step of the heuristic is the execution of the repair pricing scheme to generate repair columns. The repair pricing scheme is executed |Q| times so that a repair column is generated for each pricing problem. The order in which the pricing problems are solved is given by the function q(l), i.e. depending on the iteration of the repair pricing scheme. In practice, the order in which the pricing problems are solved is controlled internally by GCG. Each repair column that is generated during the repair pricing scheme is added to both [RMP-LP] and [REP]. The columns are added to [RMP-LP] so that after each round of repair pricing [RMP-LP] can be resolved and the dual multipliers updated. Additionally, after executing the repair pricing scheme in iteration l, the dynamic penalties β i(l+1) are updated based on the repair columns found. Solving [REP] with the set of repair columns enables the search for columns that combine with the partial solution in an attempt to form an improving integer feasible solution.
During the execution of the repair pricing scheme, simple heuristics, such as rounding heuristics, are also called to find updated incumbent solutions. As seen in Line 22, if the simple heuristics find an improving solution, then an intermediate update of the partial solution is triggered.
Each call to the heuristic in GCG involves multiple executions of the procedure described above. The number of executions is controlled through run time parameters that specify the number of iterations and the number of iterations since the last improving solution, max I ter and max N oI mprove in Algorithm 2 respectively. In the implementation, the default values for max I ter and max N oI mprove are set to 10 and 3 respectively. In practice, the max I ter limit is very rarely reached.

Updating the dynamic penalties
The method for setting the dynamic penalties given partial solutionĴ is described in Sect. 3.2. In the implementation of IPColGen, the initial dynamic penalties are set to β i0 = β 0 , ∀i ∈ I c0 ∪ I p0 , where β 0 is given by a run-time parameter. As shown in Line 14 of Algorithm 2, the dynamic penalties are updated after each pricing round. In iteration l of the repair column generation procedure, if the inequality of Theorem 2 is violated for constraint i ∈ I c0 ∪ I p0 , then β i(l+1) is set to αβ il . Conversely, if the inequality of Theorem 2 is satisfied for constraint i ∈ I c0 ∪ I p0 , then β i(l+1) is set to β il /α. The value of α used in the computational experiments is 3. Different values of β 0 are evaluated in the computational experiments.

Computational experiments
A major goal of this work is to develop an LNS heuristic that will improve the effectiveness of the branch-and-price algorithm across a broad range of instance types. The effectiveness of IPColGen will be evaluated through computational experiments performed on two different collections of instances that contain structures that are amenable to the application of IPColGen. The first set of experiments are performed on integer programming problems with known block diagonal structures that branchand-price has traditionally been an effective solution approach. These experiments will compare the default settings of GCG against various settings for the IPColGen heuristic. The second set of experiments will evaluate how the deployment of IPCol-Gen improves the effectiveness of applying branch-and-price to solve general MIP problems, without known block diagonal structures, using instances collected from MIPLIB 2017 [21].

Computational experiments setup
The computational experiments have been performed using a development version of GCG 3.1.0 (Git hash: f59eb93), that is based upon a development version of SCIP 7.0.0 (Git hash: 0bc4dc9), with SoPlex 5.0.0 (Git hash: 6535a3c) as LP solver. A computational cluster comprised of Intel(R) Xeon(R) CPU E5-2640 v3 @ 2.60GHz CPUs and 125GB RAM per node has been used to perform the experiments. For all test instances, a time limit of 3600 s has been applied.
The effectiveness of IPColGen is evaluated by comparing its use against the solving performance of default GCG. Throughout this section, IPColGen is used to denote the parameter settings where IPColGen is deployed within the branch-price-and-cut algorithm of GCG. The label Default is used to denote the experiments performed using the default settings of GCG.

Evaluation measures
The effectiveness of IPColGen will be primarily evaluated using the measures of optimality gap and primal integral. Additionally, for some experiments the solving time and primal gap will also be evaluated. The primal integral, first proposed by Berthold [11], aims to better capture the effect that primal heuristics have on solving performance by taking into account the quality of solutions and the time they are found.
Let δ p (t) and δ d (t) denote the primal and dual bounds, respectively, at time t. Thus, the optimality gap at time t is computed by otherwise.
Let T denote the run time to solve the instance or the time limit if the instance is unsolved. The final gap refers to the optimality gap at T , which is given by θ(T ). Also, first call gap is the label used to denote the optimality gap at the first time IPColGen is executed.
By substituting δ d (t) withδ p , which is the best know primal bound, θ p (t) is used to denote the primal gap. The primal integral is then given by To aid the comparison of parameter settings across a large diverse test set, the results will be aggregated using a shifted geometric mean. In the figures presented throughout this section, the values displayed are the ratio of the geometric mean between the evaluated setting for IPColGen and the default setting for GCG. A value greater than 1 indicates better performance by default GCG, where a value less than 1 corresponds to a performance improvement from deploying the IPColGen heuristic.

Selectively deploying IPCOLGEN
Since the IPColGen heuristic is potentially highly time-consuming, due to solving multiple LP and MIP problems, it is necessary to be discriminating in its deployment. It can be expected that instances with a large optimality gap in the root node have the most to gain from deploying the proposed heuristic, while for instances with a very small optimality gap in the root node it is likely that the heuristic will deteriorate performance. Recall from Sect. 4 that the first call to IPColGen is made when the tailing off effect is first observed. At this point in the method, it is possible to use the optimality gap as a proxy for instance difficulty and decide whether to run the heuristic or not. To illustrate the importance of this threshold value, all plotted results are reported as a function of this value with the label First call gap on the horizontal axis. When results based on the shifted geometric mean are reported, the shifted geometric mean is computed using all instances with a first call gap greater than the threshold value reported on the horizontal axis.

Instances with known block diagonal structures
The first set of experiments evaluates the effectiveness of IPColGen on instances for which Dantzig-Wolfe reformulation has traditionally been effective. All problem instances, except for the optimal interval scheduling problem, have been collected from strIPLib [7]. The following instances were used for the computational experiments.
-Bin packing problem (BPP): A generator for bin packing problem instance, BPP-GEN, was introduced in Schwerin and Wäscher [35], which is labelled BISON in strIPLib. Three different classes of test sets are available in strIPLib, grouped by difficulty. Instances are labelled with categories N ∈ {1, 2, 3, 4} corresponding to the number of items. Categories 3 and 4, which have 200 and 500 items respectively, were selected from the second class of instances, since within this subset some instances were solvable in less than 3600 s and others were unsolvable. The master problem is a set covering problem. 480 instances. -Capacitated p-median (CPMP): The instances were first presented by Ceselli [14] and Ceselli and Righini [15]. The master problem is a set partitioning problem. 271 instances. -Generalised assignment problem (GAP): The GAP instances available in strIPLib have been collected from the OR Library [9]. For each instance, a maximisation and minimisation problem has been defined. The master problem is a set partitioning problem. 168 instances. -Vertex coloring (Coloring): Two different sets of instances have been collected for the vertex coloring problem. These come from a compilation of instances provided by Trick [41] (101 instances) and an instance set from the OR Library [9] (20 instances). The master problem is a set covering problem. 121 instances. -Optimal interval scheduling problem (OISRC): A scheduling problem proposed by Angelelli et al. [3] where n jobs have to be processed on m parallel machines. Additionally, multiple jobs can be processed on the same machine at one time provided resource constraints are respected. This problem tries to identify the subset of jobs that can be feasibly completed within a given time frame. Instances have been collected from http://www.or-brescia.unibs.it. The master problem is a set packing problem. 165 instances.
A total of 1205 instances form the basis of the computational experiments. From this complete test set, only the instances where IPColGen is executed at least once are considered. When IPColGen is not executed during the branch-and-price algorithm, the performance is identical to default GCG, and hence there is no performance gain or loss.

Evaluating different values of andˇ0
The values of γ and β 0 are critical parameters of IPColGen that affect the search for repair columns. Figure 1 presents the ratio between the geometric means of the primal integral for Default and IPColGen. The figures present the geometric mean for all instances with a first call gap greater than the value on the horizontal axis. As explained above, only instances where IPColGen is called at least once are included in the analysis. The number of instances used to compute the geometric mean at each of the first call gap levels is displayed in Fig. 1f. Note that, as explained in Sect. 5.1.2, the horizontal axis is given by the First call gap, which is a presented in decimal form. It can be observed that for all (γ , β 0 ) settings, deploying IPColGen on the complete set of instance results in a degradation in the solving performance of GCG. However, as the first call gap increases-removing the easiest instances from the test set-the potential to improve the primal bound by deploying IPColGen is observed. Importantly, parity with Default is achieved by all (γ , β 0 ) settings for IPColGen when the first call gap is at least 13%. This indicates that for even moderately difficult instances, the use of IPColGen does not degrade the performance of GCG with respect to the primal integral.
The benefits of deploying IPColGen within GCG is best observed in Figs. 1b and 1d, which correspond to γ = 0.25 and γ = 0.9. A 5% improvement in the primal integral is achieved by IPColGen compared to Default on average for instances with a first call gap greater than 14 and 25% for the (γ , β 0 ) settings (0.25, 0.1) and (0.9, 0.5), respectively. Further, by selecting instances with a first call gap greater than 77 and 82%, at least a 10% improvement is achieved on average for the primal integral for the (0.25, 0.1) and (0.9, 0.5) settings of IPColGen, respectively. These results represent a significant improvement of the performance of default GCG given the diversity of the test instances.
The ability of IPColGen to find high quality solutions is highlighted by the geometric mean of the final gaps, presented in Fig. 2. The most important result from Fig. 2 is that all (γ , β 0 ) settings achieve an average improvement in the final gap, regardless of the first call gap limit. As the first call gap limit increases, the magnitude of this improvement increases. Comparing Figs. 1 and 2, for all instances with a first call gap greater than 13%, IPColGen not only achieves a better final gap, but also achieves the corresponding primal bound improvements faster than Default.
The comparison between IPColGen and default GCG in regards to solving time is presented in Fig. 3. Across the full test set, the number of instances solved to optimality  Fig. 3 only the instances that are solved to optimality by both IPColGen and Default are considered. It must be noted that these are the easiest instances of the test set. Hence, these are not the target instances of IPColGen, but the solving time results are included for completeness. The number of instances used to compute the geometric mean of solving time for each first call gap limit is displayed in Fig. 3f. The high computational cost of IPColGen is evident from Fig. 3, where the average solving time is greater for IPColGen compared to Default for many of the evaluated settings. However, for the best performing settings identified from Figs. 1 and 2, given by the (γ , β 0 ) pairs (0.25, 0.1) and (0.9, 0.5), as the first call gap increases the difference in the solving time decreases. In particular, for (γ , β 0 ) = (0.25, 0.1), the average solving time of IPColGen equals or betters that of Default when the first call gap limit is at least 19%. This shows that as the difficulty of the instances increases, IPColGen is more capable of achieving an improvement in the solving time of GCG.

Comparison against the restricted master heuristic
The restricted master heuristic, as described by Lübbecke and Puchert [25], is a heuristic that performs branch-and-bound to find integer feasible solutions by using only the columns generated while solving [RMP-LP]. Since IPColGen generates morepotentially better-columns at the root node, deploying the restricted master heuristic aims to evaluate whether these columns are capable of forming higher quality integer  Figure 4a shows that deploying IPColGen significantly improves the ability of the restricted master heuristic to find high quality feasible solutions compared to Default. On the complete set of instances, IPColGen achieves 15% improvement in the primal gap. When considering all instances with a first call gap greater than 25%, the improvement in the primal gap is at least 29%. This result highlights the potential of the repair pricing scheme to generate columns that are capable of forming high quality feasible solutions.
This improvement in the primal gap comes at a cost in regards to the solving time. As seen in Fig. 4b, the primal integral for IPColGen tends to be greater than that achieved by Default. This is due to the additional effort invested by IPColGen to generate columns that will form high quality integer solutions. Considering the results for the primal gap, presented in Fig. 4a, the increase in the computational effort can be justified given the significant improvement in solution quality that is achieved.

MIPLIB 2017 instances
To evaluate the broad applicability of IPColGen, the automatic structure detection of GCG is used to apply Dantzig-Wolfe reformulation to instances from the MIPLIB 2017 Collection. Using the MIPLIBing package [36], instances with the tags decomposition, set_covering, set_packing and set_partitioning were selected from the MIPLIB 2017 Collection. These tags were used to select instances that are most likely to have a decomposable structure and comprise constraint types necessary for the application of IPColGen. In addition, all instances for which a primal feasible solution is yet to be found, i.e. with the tag no_solution, were discarded from the test set. These latter instances were discarded because without a known primal bound it is not possible to compute the primal gap and, subsequently, the primal integral. This selection of the MIPLIB 2017 Collection results in a test set comprising of 190 instances. The list of instances used in the computational experiments is provided in Appendix B In order to trigger performance variability and diversify the results, 5 different random seeds are used to permute the test instances. Each different random seed will result in a different ordering of the rows and columns when the test instance is read into GCG. In the computational results, each instance with a different random seed is considered to be a separate instance. Thus, the computational experiments have been performed using 950 instances.
Experiments have been performed using the default structure detection settings in combination with Default and IPColGen. The values for γ and β 0 are set to 0.25 and 0.1, respectively, which are the best performing settings from the previous experiments.
The results evaluating the improvement in the primal integral and primal gap are presented in Fig. 5. Interestingly, these results show very similar behaviour to that observed in Sect. 5.2.1. Specifically, for the primal integral when the instances with a small first call gap are removed, i.e. the easy instances, IPColGen achieves an improvement over Default. It can be observed in Fig. 5a that parity in the primal integral between Default and IPColGen is achieved when the first call gap is 45%, which covers more than 100 out of the 319 instances where IPColGen is deployed. Considering the primal gap, the results presented in Fig. 5b highlight the great ability of IPColGen to find high quality solutions. The minimum average improvement in the primal bound is 4.5% and the highest reported average improvement is 21.3%. The ability of IPColGen to find higher quality solutions on average across the complete test set is a valuable result for the IPColGen heuristic.
The comparison of the solving time between Default and IPColGen is presented in Fig. 6. In the presented results, only the instances that were solved in 3600 s were used to compute the geometric means. The number of instances used to compute the geometric means is displayed in Fig. 6b. Comparing Figs. 5a and 6a, very similar behaviour is observed in improvement in the primal integral and solving time, respectively, when deploying IPColGen. In particular, parity is achieved for the solving time at 41%, compared to 45% for the primal integral. The reduction in the solving time when deploying IPColGen suggests that much of the improvement in the primal integral is related to the early detection of high quality integer solutions-not just improved bounds. As such, as the overall solving performance of GCG improves, IPColGen will continue to remain relevant since it is capable to finding higher quality solutions more quickly than the existing heuristics. Considering the results for the primal integral, primal gap and solving time, there is a clear benefit from deploying IPColGen within branch-price-and-cut algorithms.

Conclusions
Although there are many efficient heuristics for finding high-quality primal feasible solutions to mixed-integer programs, it is inherently challenging to extend them to the branch-and-price context. The main reason is that generic heuristics are typically designed for a compact formulation where all variables are available, while in a branchand-price setting useful variables need to be generated. By design, the generation of new variables within branch-and-price is traditionally only done for an LP relaxation via the use of column generation that relies on LP reduced costs of the variables. For this reason, the generated variables are not created with a search for high-quality primal feasible integer solutions in mind.
The contribution in our paper is IPColGen-a generic heuristic approach that can be applied when the master problem comprises set covering, set packing, or set partitioning constraints. The proposed heuristic approach is capable of being deployed as a stand-alone procedure or within a generic branch-price-and-cut solver. We handle the challenge of generating columns that have a high potential to be used in a highquality primal feasible integer solution by generating a set of columns in each round of the repair pricing scheme such that these columns, in an average sense, have profitable properties. The question of which properties to aim for was first addressed in Zhao et al. [45], where they were derived from the optimality conditions introduced in Larsson and Patriksson [24]. Our paper is the first to present a computationally efficient method based on these properties IPColGen is implemented within the generic branch-price-and-cut solver GCG. The integration of IPColGen within GCG highlights the many challenges and tradeoffs in the effective use of computational effort. The broad potential of IPColGen is demonstrated through an extensive computational study involving test sets with and without known block diagonal structures. On instances with large optimality gaps, significant reductions are observed in the primal integral and the final optimality and primal gaps. In comparison to the restricted master heuristic, a 29% reduction in the final primal gap is observed for instances with a first call optimality gap greater than 25%. Finally, the deployment of IPColGen when solving general MIPLIB 2017 instances is shown to improve the performance of GCG on average. The computational results highlight the significant potential to improve the effectiveness of GCG on a broad range of instances.
The design of the repair pricing problem and the choice of parameter values in its objective are both important for the performance of IPColGen. Even if some tuning and design choices have been done for this paper, we believe that improvements of IPColGen can be made through further studies. Of particular interest is the choice of dual solution. In this paper, we have simply used the dual solution obtained when solving [RMP-LP] since it was readily available and gave good performance. From a theoretical perspective-and in contrast to the case of column generation for linear programs-it is not required to use an LP-optimal solution. Instead, one interesting option is to use a dual solution for a basic solution in the extreme point for the current primal feasible solution, since it might carry relevant information for solving the integer program. Furthermore, and despite which extreme point the dual solution belongs to, it is of interest to study which of the dual solutions for an extreme point to use, since [MP-LP] is typically expected to be highly degenerate.

A Illustration of the pricing scheme
The example is derived to illustrate the theoretical aspects of the method design as introduced in Sect. 3.2. The figures do not originate from a real instance. Instead a small example that covers interesting cases treated in the lemmas and theorems of Sect. 3.2 is created just for illustration purposes. The costs of the columns are not considered.
Let [MP] have a block diagonal structure such that there are six pricing problems with two identical pairs of each of them. This means that Q = {1, 2, 3} and that the set of pricing problems is partitioned into subsets such that |K q | = 2, q ∈ Q, hold.
The introduced [MP] has nine constraints, six of covering type and three of packing type, hence |I c | = 6 and |I p | = 3. Let the partial solutionĴ consist of three columns such that |Ĵ 1 | = 1, |Ĵ 2 | = 0, and |Ĵ 3 | = 2 hold. Then, a solution to [REP] will consist of one new column from pricing problem q = 1, two new columns from q = 2 and none from q = 3. Note that even if the set J R * is unknown, the number of columns for each q ∈ Q to include in a solution to [REP] is always known. Table 1 provides information about the columns inĴ and introduces an ideal set of columns for [REP] to serve as reference. Such set of columns is never known when applying the repair pricing scheme, but it is included here for comparison as the existence of such set is used in the theoretical derivations.
Let the repair pricing scheme be implemented such that it, in turn for each q ∈ Q, generates |K q | − |Ĵ q | columns. This is repeated 3 times to obtain 9 iterations. After these iterations, the set L q contains the columns from iterations l = 0, 3, 6, l = 1, 4, 7, and l = 2, 5, 8 for q = 1, q = 2, and q = 3, respectively. The generated columns are given in Table 2.
According to Theorem 1, a column j ∈ J R can be included in a solution to [REP] only if it holds that a i j = 0 for i ∈Î p1 . Since this is the case for the columns in Table 2, all of them are acceptable in this respect and the penalty M that has been used in [REP-CG ql ] appears to have been sufficient. There is no requirement on a i j = 0, i ∈Î c1 , for a column j ∈ J R to be included in [REP], so any value is acceptable for these coefficients.
To further analyse the behaviour of the repair pricing scheme, Tables 3, 4, and 5 provide information about the progress of the scheme with an interval of |Q| iterations. In these tables,â jl is the average column for the setL jl and the notation LHS l = j∈J R * j ∈L jl a i j and RHS l = 1 |J R * | j∈J R * |L jl | is used for the left-hand-side and the right-hand-side, respectively, of the inequality in Theorem 2. All values, except those for a * that are included for reference, are known from the repair pricing scheme.
After iteration l = 2, the inequality in Theorem 2 is violated in the third and the fifth penalty rows in Table 3, and hence the penalties for the corresponding constraints are increased. After iteration l = 5, the inequality is still violated for the third and the fifth rows (see Table 4) and the penalty is further increased. After iteration l = 8 (see Table 5), all rows comply with the inequality in Theorem 2.
Since the columns generated during these nine iterations comply with the conditions in Theorems 1 and 2, it is likely that some of them are good candidates for inclusion in a high-quality solution to [REP]. One possible solution is to use the columns from iterations l = 0, 7, 8. Note, however, that the ideal columns have not been gener- ated. There is never a guarantee that the repair pricing scheme will generate the ideal columns.

B MIPLIB 2017 Instances
The instances from the MIPLIB 2017 Collection that were chosen for the computational experiments are given in Table 6. The MIPLIBing package [36] was used for selecting and downloading the instances from the MIPLIB 2017 Collection.   Data availability Detailed results are found at https://gitlab.liu.se/eliro15/ipcolgen_detailed_results.

Code availability
The code for the IPColGen heuristic has been submitted to the GCG repository for inclusion in the next release. The development version of GCG used for the computational experiments is available in the repository https://gitlab.liu.se/eliro15/ipcolgen_code.

Conflict of interest
The authors have no competing interests to declare.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.