# Improving strong branching by domain propagation

- 476 Downloads
- 1 Citations

## Abstract

One of the essential components of a branch-and-bound based mixed-integer linear programming (MIP) solver is the branching rule. *Strong branching* is a method used by many state-of-the-art branching rules to select the variable to branch on. It precomputes the dual bounds of potential child nodes by solving auxiliary linear programs and thereby helps to take good branching decisions that lead to a small search tree. In this paper, we describe how these dual bound predictions can be improved by including *domain propagation* into strong branching. Domain propagation is a technique that MIP solvers usually apply at every node of the branch-and-bound tree to tighten the local domains of variables. Computational experiments on standard MIP instances indicate that our improved strong branching method significantly improves the quality of the predictions and causes almost no additional effort. For a full strong branching rule, we are able to obtain substantial reductions of the branch-and-bound tree size as well as the solving time. Moreover, the state-of-the-art hybrid branching rule can be improved this way as well.

## Keywords

Mixed-integer programming Branch-and-bound Branching rule Variable selection Strong branching Domain propagation## Mathematics Subject Classification (2000)

90C10 90C11 90B40 9008 90C57## Introduction

Since the invention of the linear programming (LP)-based branch-and-bound method for solving mixed-integer linear programs (MIPs) in the 1960s by Land and Doig (1960) and Dakin (1965), branching rules have been an important field of research in that context, being one of the core parts of the method (for surveys, see Mitra 1973; Linderoth and Savelsbergh 1999; Achterberg et al. 2005). Their task is to split the current problem into two or more disjoint subproblems if the solution to the LP relaxation of the current problem does not fulfill the integrality restrictions. Thereby, it should exclude the LP solution from all subproblems while keeping at least one optimal solution.

The most common way to split the problem is to branch on trivial inequalities, which split the domain of a single variable into two parts (called *variable branching*). Alternatively, branching can be performed on general linear constraints (see, e.g., Ryan and Foster 1981; Owen and Mehrotra 2001; Mahajan and Ralphs 2009; Karamanov and Cornuéjols 2011) or can create more than two subproblems, cf. Borndörfer et al. (1998), Lodi et al. (2009). In case of variable branching, the variable to actually branch on is typically chosen with the goal of improving the local dual bound of both created subproblems (also called *child nodes*). This helps to tighten the global dual bound and prune nodes early. For recent research on alternative criteria, see, e.g., Patel and Chinneck (2007), Kılınç et al. (2009), Fischetti and Monaci (2011), Gilpin and Sandholm (2011).

*pseudo-cost branching*(Benichou 1971) uses history information about the change of the dual bound caused by previous branchings. More accurate, but also more expensive, is

*strong branching*(Gauthier and Ribière 1977; Applegate et al. 1998; Linderoth and Savelsbergh 1999), which explicitly computes dual bounds of potential child nodes by solving auxiliary LPs with the branching bound change temporarily added. The

*full strong branching rule*does this at every node for each integer variable with fractional LP value which empirically leads to very small branch-and-bound trees (Achterberg 2007; Achterberg et al. 2005). Modern branching rules typically combine these two approaches and use strong branching in case of uninitialized or unreliable pseudo-cost values (see Achterberg et al. 2005; Achterberg and Berthold 2009). Often, they also impose an iteration limit to restrict the effort for solving the strong branching LPs, see, e.g., Gauthier and Ribière (1977). In case this limit is reached, the current (possibly suboptimal) LP value is used as a prediction for the child node’s dual bound.

^{1}An important example for a modern branching rule is

*reliability pseudo-cost branching*(Achterberg et al. 2005), which considers the history information for a variable unreliable if the number of pseudo-cost updates for this variable is below a given threshold. What this all amounts to is that strong branching is an important component of state-of-the-art branching rules, predicting the bounds of potential children when no other information is available yet.

In practice, however, one can often observe a difference between the dual bound that strong branching computes for a node and the actual dual bound obtained later when this particular node is processed. An example is shown in Fig. 1, which depicts the differences for instance aflow30a from MIPLIB 2003. The *y*-axis ranges from the root node dual bound up to the optimum objective value which was provided at the beginning. The instance was solved with full strong branching after 87 nodes, each of which is represented by one bar. All strong branching LPs were solved to optimality, but still for almost half of the nodes, the bound obtained during node processing is better than the predicted bound, on average, 10 % of the gap between predicted and primal bound is closed by the node LP. This restrains the effectiveness of strong branching, since with more accurate predictions, better branching variables could have been selected. There are various reasons for the difference, most prominently *domain propagation* and global domain changes found in the meantime. The task of domain propagation (or *node preprocessing*) is to tighten the local domains of variables by inspecting the constraints and current domains of other variables at the local subproblem. It is the essential part of each constraint programming solver (Apt 2003) and has also proven to improve MIP solvers significantly by tightening the LP relaxation, resulting in better dual bounds and detecting infeasibilities earlier (Achterberg 2007; Savelsbergh 1994; Fügenschuh and Martin 2005).

While strong branching cannot do anything about the difference in the dual bounds caused by global domain changes, it should react upon the continuous improvement in domain propagation techniques. In this paper, we examine how strong branching can be improved by combining it with domain propagation in order to compute better dual bound predictions. This means that we perform the same domain propagation steps that are already performed at each node of the branch-and-bound tree also during strong branching, prior to solving the strong branching LP of a potential child node. The general idea and an evaluation of the direct effects on single strong branching calls are presented in the next section. We implemented the modified strong branching method within the MIP solver itself instead of using external methods of the LP solver. This allows us to apply additional tricks to further improve the strong branching performance which are discussed in “Additional strong branching improvements”. After that, we provide detailed computational results on a collection of MIPLIB instances (Bixby et al. 1998; Achterberg et al. 2006; Koch et al. 2011). In a setting which focuses on the branching performance of a full strong branching rule, we achieve significant reductions of both number of nodes and solving time, but also with default settings, both the full strong branching rule as well as a hybrid branching method combining strong branching and pseudo-costs can be improved.

## Strong branching with domain propagation

*down child*) and \(P_\mathrm{u}\) (the

*up child*) by adding to \(P\) the bound changes \(x_i \le \lfloor \hat{x}_i \rfloor \) and \(x_i \ge \lceil \hat{x}_i \rceil \), respectively, and solves their LP relaxations. Strong branching with domain propagation (

*SBDP*) improves this by applying domain propagation to tighten the variable domains of \(P_\mathrm{d}\) and \(P_\mathrm{u}\) after adding the bound changes. The strong branching dual bound for each of the children is then either set to \(+\infty \), if propagation detected infeasibility, or obtained by solving the (tightened) LP relaxation of the respective child node. Computing these two dual bound predictions for a given variable with fractional value will be referred to as a

*strong branching call*in the following.

- (a)
How does the strong branching effort change?

- (b)
By how much can SBDP improve the strong branching predictions?

- (c)
What is the effect of SBDP on the overall performance of a MIP solver?

For answering these questions, we performed computational experiments using an implementation of SBDP based on the MIP solver SCIP 3.0 (Achterberg 2007, 2009) with underlying LP solver SoPlex 1.7 (Wunderling 1996). They were performed on a cluster of Intel Xeon E5420 2.5 GHz computers, with 6 MB cache and 16 GB RAM, running Linux (in 64 bit mode). A time limit of 2 h per instance was imposed. We use full strong branching to measure the impact of our changes for each candidate variable at each node and concentrate on the branch-and-bound performance by providing the optimal objective value as objective cutoff and disabling primal heuristics and cutting plane separation as well as the components presolver^{2} of SCIP. We will refer to this setting as the *sandbox* setting in the following. As test set, we used the MMM test set consisting of all instances from MIPLIB 3.0 (Bixby et al. 1998), MIPLIB 2003 (Achterberg et al. 2006), and the benchmark set of MIPLIB 2010 (Koch et al. 2011). We excluded all instances for which no significant amount of strong branching was performed—either because the instance was solved in presolving or at the root node prior to branching or because the time limit of 2 h was hit before strong branching was performed on at least ten variables. In addition, we excluded the three infeasible instances from MIPLIB 2010 in order to be able to compute the additional gap closed by SBDP, which left us with a total number of 147 instances. With respect to the other measures, however, the results on the infeasible instances were consistent with those presented here.

The experiments were conducted as follows: after each standard strong branching call, we additionally performed a call of SBDP on the same variable, running the default domain propagation techniques of SCIP (see Achterberg 2007). We collected statistics about the differences, but did not use any of the information produced by SBDP within the branch-and-bound search. We chose this approach instead of running twice, one time with each variant, to isolate the impact of the new method on each single strong branching call and avoid noise introduced by differences in the branch-and-bound tree created by different branching choices.

For analyzing the impact of SBDP, we divide the strong branching calls into three categories: *cutoff* if at least one of the two potential child nodes was detected to be infeasible by any of the methods, *better bound* if no infeasibility was detected and SBDP computed a better dual bound for at least one of the potential child nodes, and *same bound* if both strong branching variants computed the same (finite) bounds for both potential child nodes.

*shifted geometric mean*.

^{3}We use a shift of \(100\) for the number of strong branching calls, \(10\) for time, iteration number and domain changes, and \(1\) for the number of child nodes declared infeasible per call. For the closed gap, having only values between \(0\) and \(100\), the average over the instances is determined by arithmetic mean.

Impact of domain propagation on the strong branching calls

category | calls | strong branching | strong branching with propagation | ||||||
---|---|---|---|---|---|---|---|---|---|

inf | iters | time | domchgs | inf | cl. gap ( %) | iters | time | ||

better bound | 376.0 | – | 44.0 | 19.5 | 38.9 | – | 20.7 | 57.2 | 23.1 |

same bound | 23,802.0 | – | 82.3 | 39.7 | 23.7 | – | – | 79.0 | 40.6 |

cutoff | 3,342.6 | 0.92 | 56.8 | 27.3 | 35.7 | 1.11 | 8.5 | 46.7 | 25.6 |

all | 30,469.4 | 0.14 | 81.0 | 40.2 | 26.3 | 0.17 | 2.7 | 77.5 | 40.5 |

As expected, the *better bound* case—which happens only rarely—is typically caused by a high number of domain changes during propagation and leads to an increase in both the average sum of LP iterations and time per strong branching call, thereby closing the gap by more than 20 % on average. In the most common case, the *same bound* category, a smaller, but still relevant number of domains, is changed by propagation. But instead of slowing down the simplex warm start, these bound changes even reduce the average number of LP iterations, e.g., by fixing variables that would otherwise need to be rendered feasible by some simplex pivots. Last, in the *cutoff* case, SBDP detects infeasibility of more potential child nodes—on average \(1.11\) of the two children regarded per call are declared infeasible compared to \(0.92\) otherwise. In about 15 % of the cases, infeasibility is detected already during propagation, leading to a reduction of the average number of LP iterations and strong branching time. On average over all strong branching calls, SBDP can declare every twelfth instead of nearly every fourteenth strong branching child node infeasible and closes the gap by 2.66 %. The average number of LP iterations is slightly decreased, while the time per strong branching call increases marginally. This demonstrates that the domain propagation time is relatively small compared to the total strong branching time; on average, it was less than 5 %.

Summing up, the increase in the strong branching effort is negligible—which answers question (a)—while also question (b) can be answered positively: the strong branching predictions are improved both by detecting infeasibilities more often as well as computing more accurate LP bounds. For the aflow30a instance which served as our motivating example, this helps to reduce the difference between predicted and LP bound during node processing by 74 %. In a branch-and-bound search, this should lead to more variable fixings and help us taking better branching decisions. This assumption will be examined further in “Computational results”, based on computational experiments showing the impact of SBDP on the performance of SCIP, thereby also answering the remaining question (c).

## Additional strong branching improvements

Our enhanced strong branching method uses the domain propagation methods of the MIP solver which also exploit integrality information. Thus, we implemented it within SCIP itself and do not use the highly optimized strong branching interface methods provided by many LP solvers such as CPLEX or XPRESS. On the one hand, this might slightly deteriorate the performance of the LP solver for the strong branching LPs; on the other hand, it allows us to tailor the strong branching method to our needs even more. In this section, we present three such improvements. Some of them may be considered common sense, but at least they have not been implemented in the state-of-the-art non-commercial MIP solver SCIP so far. The first two improvements were already discussed in the proceedings paper (Gamrath 2013) extended by this article while the third one was newly added.

The first improvement treats the case of an *infeasible strong branching subproblem*, which traditionally leads to simply tightening the domain of the candidate variable at the current node (or cutting off the current node if both subproblems are infeasible). While, e.g., the strong branching interface method of CPLEX always regards both subproblems,^{4} we interrupt a strong branching call when the first potential child is found infeasible, saving the effort we would spend for the second child node. As usual, the domain change of the second subproblem is then applied at the current node either directly or after a certain number of domain changes has been collected this way. This causes a reoptimization of the node LP, after which branching is started again, if needed. Any information we would get by solving the second strong branching child, e.g., an improved bound for the current node or a proof for its infeasibility, is obtained when reoptimizing the node LP, anyway. A simple trick helps to exploit this even further: in our computational experiments presented in the last section, about 69 % of the infeasible subproblems were up children. This is not surprising since problems are often modeled in a way such that changing a variable’s lower bound—in particular, fixing a binary variable to one—has more impact than changing its upper bound (fixing a binary variable to zero). Thus, we investigate the potential *up child first* in order to profit from infeasible child nodes more often.

Secondly, we can often identify *valid local bounds* for some variables even if neither of the two potential child nodes is infeasible. Suppose that during the investigation of the two potential child nodes for a candidate variable, the domain of another variable \(x_i\) was tightened to \(\left[ \mathrm{lb}_{\mathrm{d}},\mathrm{ub}_{\mathrm{d}}\right] \) and \(\left[ \mathrm{lb}_{\mathrm{u}},\mathrm{ub}_{\mathrm{u}}\right] \), respectively. Then, without branching on this candidate variable, the domain of \(x_i\) at the current node can be tightened to \(\left[ \min \{\mathrm{lb}_{\mathrm{d}}, \mathrm{lb}_{\mathrm{u}}\},\max \{\mathrm{ub}_{\mathrm{d}},\mathrm{ub}_{\mathrm{u}}\}\right] \). Similar to the bound changes deduced from infeasible strong branching subproblems, these domain changes then cause a reoptimization of the node LP, followed by another branching call if needed. This means that we essentially perform *probing preprocessing* (Savelsbergh 1994) locally as a side product of SBDP with negligible additional cost. For 94 of the 147 instances considered in the last section, this technique was able to identify tighter bounds, identifying on average \(3.15\) bounds that could have been tightened per strong branching call with both subproblems feasible.

Finally, we exploit the fact that we get *LP solutions during strong branching* instead of just the LP objective value as would be the case when using the external strong branching methods of CPLEX or XPRESS.^{5} Because the changed bound of the investigated variable typically forces this variable to an integer value in the strong branching LP solution, we are optimistic that this solution is “more integral” than the node LP solution. Therefore, we check this solution for integrality, hoping to find a new primal feasible solution. Moreover, we even run the fast *simple rounding heuristic* (Achterberg et al. 2012) implemented in SCIP on the optimal strong branching LP solution. In the next section, we will answer the question of how often solutions are found this way and how good they are.

## Computational results

In this section, we present computational experiments illustrating the effect of SBDP on the overall performance of SCIP and will finally answer question (c) posed in “Strong branching with domain propagation”. The results significantly extend those presented in Gamrath (2013) and use new features implemented in the meantime, e.g., the third improvement discussed in the last section, so that we use a new development version of SCIP 3.0.1 (Achterberg 2007, 2009) (git hash 9e5a0ff) with underlying LP solver SoPlex 1.7.1 (Wunderling 1996) (git hash 82b4e30). The experiments were performed on a cluster of Intel Xeon E5672 3.2 GHz computers, with 12 MB cache and 48 GB RAM, running Linux (in 64 bit mode). As test set, we used the MMM set as in “Strong branching with domain propagation”, this time without excluding any instances.

In order to increase the reliability of our computational results, we ran each problem in four variants: the original instance and three random permutations of variables and constraints. Although this does not change the instance, it often results in a significantly different solving behavior. One main reason for this is imperfect tie breaking, leading to different decisions being taken because of small numerical differences caused by floating-point arithmetics. Moreover, computationally expensive methods are often stopped early after a certain number of unsuccessful tries, meaning that the order of variables and constraints—in particular which of them are considered before such a limit is reached—plays a major role. This effect is amplified in MIP solvers, where one choice made differently at the beginning can lead to a completely different branch-and-bound tree to be investigated. Such changes of performance due to seemingly performance-neutral changes in the environment or the input format are denoted *performance variability* (Koch et al. 2011) and affect all major MIP solvers. As proposed in Koch et al. (2011), we use permutations of variables and constraints as a good random generator affecting most instances and almost all components of a MIP solver. For each instance, we take the arithmetic mean of the solving time and number of branch-and-bound nodes over the four regarded permutations (including the original one). An instance is counted as solved only if all four permutations were solved to optimality within the time limit of 2 h.

We use a shifted geometric mean with shift 10 and 100 to average over the solving times and node numbers, respectively. Detailed instance-wise results of the computational experiments presented in this section are provided in Table 5 in the “Appendix”.

For our first experiment, we used the sandbox setting from “Strong branching with domain propagation” again: we provided the optimum as cutoff bound and disabled primal heuristics, cutting plane separation, and the components presolver in order to focus on the branch-and-bound search and to decrease performance variability. Moreover, we used full strong branching as a branching rule which completely relies on strong branching and uses no history information. Within the full strong branching rule, we exchanged the strong branching calls for SBDP using all improvements discussed in the last section. Note that the last improvement has no impact in this experiment because we provide the optimum right at the beginning and disable primal heuristics; its impact will be assessed later.

Comparison of full strong branching with and without SBDP, focusing on the branching performance using the sandbox setting

test set | size | full strong branching | full strong with SBDP | ||||
---|---|---|---|---|---|---|---|

solved | nodes | time | solved | nodes | time | ||

all instances | 168 | 98 | 1,832.7 | 549.2 | 105 | 1,376.7 | 479.4 |

solved by both | 98 | 98 | 710.1 | 80.0 | 98 | 534.4 | 71.2 |

solved with tree | 84 | 84 | 1,046.1 | 108.9 | 84 | 761.7 | 95.5 |

Our previous experiments give a first answer to question (c) posed in “Strong branching with domain propagation”: they indicate that SBDP is quite beneficial in our sandbox environment focusing on the branching performance. But does this also hold for default settings and a state-of-the-art branching rule?

Comparison of full strong branching with default settings, with and without SBDP

test set | size | full strong branching | full strong with SBDP | ||||
---|---|---|---|---|---|---|---|

solved | nodes | time | solved | nodes | time | ||

all instances | 168 | 87 | 1,025.5 | 710.5 | 95 | 909.1 | 673.7 |

solved by both | 87 | 87 | 555.3 | 74.4 | 87 | 487.5 | 70.3 |

solved with tree | 76 | 76 | 759.0 | 100.6 | 76 | 658.0 | 94.4 |

Finally, let us take the next step and check how SBDP performs when used within *hybrid branching*, the default branching rule of SCIP. Hybrid branching is an extension of reliability pseudo-cost branching which takes into account not only the predicted dual bounds but also other history information, e.g., the number of implied reductions of other variable domains and the number of (recent) conflicts a variable appears in. For more details on hybrid branching, we refer to Achterberg and Berthold (2009).

The main criterion for selecting the branching variable, however, is still the predicted child node dual bound, which in the beginning of the search is computed by strong branching. Thus, we expect SBDP to have a positive impact also on hybrid branching. Moreover, also some of the other regarded history information is automatically initialized when running SBDP on a variable. On the other hand, hybrid branching uses a reliability mechanism, i.e., strong branching will be performed only a limited number of times on each variable; later on, only history information is used. This is why we expect the effect of SBDP to be smaller for this branching rule than for full strong branching.

Another important difference with respect to our previous experiments is that hybrid branching imposes a limit on the number of iterations per strong branching LP. Therefore, tightening the LP relaxation might not pay off if this results in reaching the iteration limit where the untightened LP would be solved to optimality. Thus, we did an experiment similar to the one presented in “Strong branching with domain propagation”: running hybrid branching on each instance of the MMM test set with a time limit of 2 h, we additionally performed SBDP after each normal strong branching call and compared how often the LP could be solved to optimality (or infeasibility was detected) by the two variants. It turns out that for most of the instances, the iteration limit was reached more often by SBDP; only for four instances, SBDP performed slightly better than standard strong branching. On average over all the instances where branching was performed, standard strong branching reached the iteration limit for 4.9 % of the children while SBDP reached it for 9.8 % of them. Although the limit was reached twice as often with SBDP, the majority of strong branching LPs were still solved to optimality, so that we expect only a minor disadvantage for SBDP due to the LP iteration limit.^{6}

Comparison of hybrid branching with and without SBDP, default settings

test set | size | hybrid branching | hybrid branching with SBDP | ||||
---|---|---|---|---|---|---|---|

solved | nodes | time | solved | nodes | time | ||

all instances | 168 | 121 | 8,626.5 | 326.1 | 121 | 7,990.9 | 313.1 |

solved by both | 118 | 118 | 2,591.9 | 83.1 | 118 | 2,409.5 | 80.6 |

solved with tree | 107 | 107 | 3,672.5 | 03.9 | 107 | 3,391.6 | 100.6 |

Let us come back to our third improvement and evaluate the impact of running the simple rounding heuristic on the strong branching LP solutions: in our run on the original instances of the MMM test set, we can improve the incumbent this way for 19 instances at least once during search; in total, 53 solutions are found. Moreover, the first primal solution is found in this way for eight instances, and five times the optimum is obtained during strong branching. Similar observations can be made for the permuted instances. As for the full strong branching rule, about 1 % of the speedup is caused by the three improvements described in “Additional strong branching improvements”, so our general idea to include domain propagation into strong branching still has the highest impact.

Finally, we can conclusively answer question (c) posed in “Strong branching with domain propagation”: our experiments indicate that SBDP is also able to slightly improve the performance of the default hybrid branching rule when used within the state-of-the-art non-commercial MIP solver SCIP.

## Conclusions and outlook

This paper examined improvements of strong branching, one of the main components of most state-of-the-art branching rules for MIP. The primary improvement is the incorporation of domain propagation into the strong branching method in order to compute more accurate dual bound predictions. Our computational experiments on general MIP instances show that this comes with negligible cost and reduces the branch-and-bound tree size as well as the solving time. In addition, we presented three further enhancements which improve the strong branching performance.

The effect is most distinctive in a full strong branching rule, where our method might prove particulary useful when the branch-and-bound tree should be kept small, e.g., under tight memory restrictions or for massively parallel MIP solvers (see, e.g., Shinano et al. 2011, 2012), where reducing the tree size has the added advantage of reducing the message passing overhead. But also in a state-of-the-art branching rule like hybrid branching, the average tree size was reduced and the average solving time was decreased. Therefore, the new method is used by default in SCIP 3.1.

For “structured” or more general problem classes like MINLP or CIP (Achterberg 2007) for which the LP typically misses more information that can be exploited by domain propagation, we expect an even larger improvement by SBDP. A field for future research is the combination with other recent strong branching improvements such as cloud branching (Berthold and Salvagnin 2013) or nonchimerical branching (Fischetti and Monaci 2012).

## Footnotes

- 1.
Since strong branching LPs are typically solved with the dual simplex method, the LP value often provides a valid dual bound even if the iteration limit is reached. Note, however, that modern simplex implementations use pertubation to deal with degeneracy and need to do some final primal simplex pivots to undo this, in which case the LP value does not necessarily provide a valid dual bound after reaching the limit. Nevertheless, the value is often close to the optimal LP value so that it can be used as a prediction, anyway.

- 2.
The components presolver solves small independent subproblems in advance, excluding them from the main branch-and-bound search.

- 3.
See Achterberg (2007, “Appendix A3”) for a definition and discussion of the shifted geometric mean.

- 4.
Also with other LP solvers that do not provide a strong branching interface method—in particular SoPlex, which we use in our computational experiments—the LP interface implemented in SCIP behaves the same way.

- 5.
Also with other LP solvers like SoPlex, SCIP did not use the strong branching LP solution before.

- 6.
We also tried to increase the iteration limit for SBDP, hoping that the benefit caused by domain propagation would outweigh the additional LP solving effort, but did not succeed in improving the performance of hybrid branching with SBDP this way.

## Notes

### Acknowledgments

The author would like to thank Tobias Achterberg and Michael Winkler for fruitful discussions, and Ambros Gleixner, Timo Berthold, and the anonymous reviewers for constructive criticism and helpful suggestions.

## References

- Achterberg T (2007) Constraint integer programming. PhD thesis, Technische Universität BerlinGoogle Scholar
- Achterberg T (2009) SCIP: solving constraint integer programs. Math Program Comput 1(1):1–41CrossRefGoogle Scholar
- Achterberg T, Berthold T (2009) Hybrid branching. In: van Hoeve WJ, Hooker JN (eds) Integration of AI and OR techniques in constraint programming for combinatorial optimization problems, 6th international conference, CPAIOR 2009. Lecture notes in computer science, vol. 5547. Springer, New York, pp 309–311Google Scholar
- Achterberg T, Berthold T, Hendel G (2012) Rounding and propagation heuristics for mixed integer programming. In: Klatte D, Lüthi H-J, Schmedders K (eds) Operations research proceedings 2011. Operations research proceedings. Springer, Berlin, pp 71–76Google Scholar
- Achterberg T, Koch T, Martin A (2005) Branching rules revisited. Oper Res Lett 33:42–54CrossRefGoogle Scholar
- Achterberg T, Koch T, Martin A (2006) MIPLIB 2003. Oper Res Lett 34(4):1–12CrossRefGoogle Scholar
- Applegate DL, Bixby RE, Chvátal V, Cook WJ (1998) On the solution of traveling salesman problems. Documenta Mathematica J der Deutschen Mathematiker-Vereinigung Extra Volume ICM III: 645–656Google Scholar
- Apt KR (2003) Principles of constraint programming. Cambridge University Press, CambridgeCrossRefGoogle Scholar
- Benichou M, Gauthier JM, Girodet P, Hentges G, Ribiere G, Vincent O (1971) Experiments in mixed-integer linear programming. Math Program 1:76–94CrossRefGoogle Scholar
- Berthold T, Salvagnin D (2013) Cloud branching. In: Gomes C, Sellmann M (eds) Integration of AI and OR techniques in constraint programming for combinatorial optimization problems. Lecture notes in computer science, vol 7874. Springer, Berlin, pp 28–43CrossRefGoogle Scholar
- Bixby RE, Ceria S, McZeal CM, Savelsbergh MWP (1998) An updated mixed integer programming library: MIPLIB 3.0. Optima 58:12–15Google Scholar
- Borndörfer R, Ferreira CE, Martin A (1998) Decomposing matrices into blocks. SIAM J Optim 9(1): 236–269Google Scholar
- Dakin RJ (1965) A tree-search algorithm for mixed integer programming problems. Comput J 8(3):250–255CrossRefGoogle Scholar
- Fischetti M, Monaci M (2011) Backdoor branching. In: Günlück O, Woeginger GJ (eds) Integer programming and combinatorial optimization. Lecture notes in computer science, vol 6655. Springer, Berlin, pp 183–191Google Scholar
- Fischetti M, Monaci M (2012) Branching on nonchimerical fractionalities. OR Lett 40(3):159–164Google Scholar
- Fügenschuh A, Martin A (2005) Computational integer programming and cutting planes. In: Aardal K, Nemhauser GL, Weismantel R (eds) Discrete optimization. Handbooks in operations research and management science, vol. 12, chapter 2. Elsevier, London, pp 69–122Google Scholar
- Gamrath G (2013) Improving strong branching by propagation. In: Gomes C, Sellmann M (eds) Integration of AI and OR techniques in constraint programming for combinatorial optimization problems. Lecture notes in computer science, vol 7874. Springer, Berlin, pp 347–354CrossRefGoogle Scholar
- Gauthier J-M, Ribière G (1977) Experiments in mixed-integer linear programming using pseudo-costs. Math Program 12(1):26–47CrossRefGoogle Scholar
- Gilpin A, Sandholm T (2011) Information-theoretic approaches to branching in search. Discret Optim 8(2):147–159CrossRefGoogle Scholar
- Karamanov M, Cornuéjols G (2011) Branching on general disjunctions. Math Program 128:403–436CrossRefGoogle Scholar
- Kılınç Karzan F, Nemhauser GL, Savelsbergh MW (2009) Information-based branching schemes for binary linear mixed integer problems. Math Program Comput 1:249–293CrossRefGoogle Scholar
- Koch T, Achterberg T, Andersen E, Bastert O, Berthold T, Bixby RE, Danna E, Gamrath G, Gleixner AM, Heinz S, Lodi A, Mittelmann H, Ralphs T, Salvagnin D, Steffy DE, Wolter K (2011) MIPLIB 2010. Math Program Comput 3(2):103–163CrossRefGoogle Scholar
- Land AH, Doig AG (1960) An automatic method of solving discrete programming problems. Econometrica 28(3):497–520CrossRefGoogle Scholar
- Linderoth JT, Savelsbergh MWP (1999) A computational study of search strategies in mixed-integer programming. INFORMS J Comput 11(2):173–187CrossRefGoogle Scholar
- Lodi A, Ralphs T, Rossi F, Smriglio S (2009) Interdiction branching. Technical Report OR/09/10, DEIS, Università di BolognaGoogle Scholar
- Mahajan A, Ralphs TK (2009) Experiments with branching using general disjunctions. In: Chinneck JW, Kristjansson B, Saltzman MJ (eds) Operations research and cyber-infrastructure. Operations research/computer science interfaces series, vol 47. Springer, US, pp 101–118CrossRefGoogle Scholar
- Mitra G (1973) Investigation of some branch and bound strategies for the solution of mixed integer linear programs. Math Program 4:155–170CrossRefGoogle Scholar
- Owen JH, Mehrotra S (2001) Experimental results on using general disjunctions in branch-and-bound for general-integer linear programs. Comput Optim Appl 20:159–170CrossRefGoogle Scholar
- Patel J, Chinneck J (2007) Active-constraint variable ordering for faster feasibility of mixed integer linear programs. Math Program 110:445–474CrossRefGoogle Scholar
- Ryan DM, Foster BA (1981) An integer programming approach to scheduling. In: Wren A (ed) Computer scheduling of public transport urban passenger vehicle and crew scheduling. North Holland, Amsterdam, pp 269–280Google Scholar
- Savelsbergh MWP (1994) Preprocessing and probing techniques for mixed integer programming problems. ORSA J Comput 6:445–454CrossRefGoogle Scholar
- Shinano Y, Achterberg T, Berthold T, Heinz S, Koch T (2012) ParaSCIP—a parallel extension of SCIP. In: Bischof C, Hegering H.-G, Nagel WE, Wittum G (eds) Competence in high performance computing 2010, pp 135–148Google Scholar
- Shinano Y, Berthold T, Heinz S, Koch T, Winkler M, Achterberg T (2011) ParaSCIP—a parallel extension of SCIP. Technical Report ZR 11–10, Zuse Institute BerlinGoogle Scholar
- Wunderling R (1996) Paralleler und objektorientierter Simplex-Algorithmus. PhD thesis, Technische Universität BerlinGoogle Scholar