EURO Journal on Computational Optimization

, Volume 2, Issue 3, pp 99–122 | Cite as

Improving strong branching by domain propagation

  • Gerald Gamrath
Original Paper


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.


Mixed-integer programming Branch-and-bound Branching rule  Variable selection Strong branching Domain propagation 

Mathematics Subject Classification (2000)

90C10 90C11 90B40 9008 90C57 


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).

A very popular branching rule called 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.
Fig. 1

Comparison of the dual bounds computed during strong branching and those obtained later during node processing for instance aflow30a from MIPLIB 2003

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

In the following, we consider mixed-integer linear programs of the form:
$$\begin{aligned} \min \left\{ c^{T}x \mid A x \ge b, x \ge 0, x_{i} \in \mathbb {Z}\ \quad \forall i \in I\right\} \text {.} \end{aligned}$$
A basic implementation of strong branching works as follows: given the current problem \(P\) of form (1) and an integer variable \(x_i, i\in I\), with fractional LP solution value \(\hat{x}_i\), it computes dual bounds of the two potential child nodes that would be created by branching on \(x_i\). Therefore, it creates two temporary subproblems \(P_\mathrm{d}\) (the 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.
Since the additional domain propagation step can only tighten the LP relaxation, the dual bounds obtained by SBDP are always greater than or equal to the ones computed by standard strong branching as long as we solve the LPs to optimality. This is the case for the full strong branching rule we focus on in this section, later, in “Computational results”, we will also regard a hybrid branching rule which imposes an iteration limit for the strong branching LPs. The questions we want to consider in the remainder of this paper are the following:
  1. (a)

    How does the strong branching effort change?

  2. (b)

    By how much can SBDP improve the strong branching predictions?

  3. (c)

    What is the effect of SBDP on the overall performance of a MIP solver?

Question (a) addresses the time spent for domain propagation as well as the change in the number of LP iterations (and therewith the LP solving time). The simplex warmstart normally allows to solve the strong branching LPs with just a few iterations as there is only one bound tightened, but additional changes performed by domain propagation might change this. On the other hand, infeasibility can already be detected by domain propagation so that we do not need to solve the strong branching LP afterwards. Question (b) addresses both the detection of infeasibilities as well as the computed dual bounds of potential child nodes. While answering the first two questions will give us an indication concerning the profitability of SBDP, the final question (c) should assess it by taking into account the changes of tree size and solving time caused by SBDP.

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 presolver2 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.

The results for each of these categories are presented in one line in Table 1, with an additional line that summarizes these results for all strong branching calls. Besides the number of strong branching calls (column “calls”), we show for both strong branching variants the number of potential subproblems detected to be infeasible (column “inf”), the number of LP iterations for solving the LPs of the two subproblems (column “iters”), and the strong branching time in milliseconds (column “time”). Furthermore, we present the number of additional domain changes performed by SBDP (column “domchgs”) and the percentage of the gap between primal bound and strong branching dual bound closed using SBDP instead of standard strong branching (column “cl. gap (%)”). Except for the entries in column “cl. gap (%)”, each of the numbers listed is computed by taking the arithmetic mean over all strong branching calls for a single instance and averaging over the instances by taking the 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.
Table 1

Impact of domain propagation on the strong branching calls



strong branching

strong branching with propagation






cl. gap ( %)



better bound








same bound



























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 %.

We also repeated our motivating example from the introduction using SBDP and illustrate the results in Fig. 2. The differences between the predicted bounds and the bounds obtained when processing the nodes are much smaller now: the prediction was inaccurate for only 17 % rather than 47 % of the nodes, the average gap closed by the node LP reduces from 10 to 2.6 %. This also leads to solving the instance after 81 instead of 87 branch-and-bound nodes.
Fig. 2

Comparison of the dual bounds computed by SBDP and those obtained later during node processing for instance aflow30a from MIPLIB 2003

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.

The results are summarized in Table 2. They are promising: with SBDP, SCIP is able to solve 105 out of the 168 instances of the MMM test set within the time limit of 2 h, 7 instances more than with standard strong branching. The shifted geometric mean of the solving time is reduced by 13 %. For the subset of instances that both versions solved to optimality (row “solved by both”), the average number of nodes and the solution time are reduced by 25 and 11 %, respectively. Since we are testing a branching rule, we are mainly interested in instances of this subset for which at least one of the variants built a branch-and-bound tree and did not solve the instance at the root node already. The results for these instances (row “solved with tree”) are slightly better: the number of branch-and-bound nodes and the solving time are reduced by 27 and 12 % in the shifted geometric mean, respectively. The running times are also illustrated by the performance diagram shown in Fig. 3. We see that in this experiment, full strong branching with domain propagation clearly dominated the version without propagation: for every possible time limit between 10 s and 2 h, it solved more instances to optimality within this time. Finally, let us mention that we also did an experiment with SBDP without the additional improvements to single out their effects. It turned out that they only have a small impact in this setting, causing a change of 1 % in running time and number of nodes; the main improvement comes from applying domain propagation.
Table 2

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

test set


full strong branching

full strong with SBDP







all instances








solved by both








solved with tree








Fig. 3

Performance diagram for full strong branching on the MMM test set. The graph indicates the number of instances solved within a certain time when using the sandbox setting to focus on the branching performance

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?

In order to answer this question, we performed additional experiments. In the first one, we used full strong branching, as well as—except for the branching rule—the default settings of SCIP, i.e., we did not disable cutting plane separation, heuristics, or the components presolver, neither did we provide the optimum objective value as the cutoff bound. Thus, branching is still based on strong branching only, but we do not focus on proving optimality of a given solution by branching anymore, as we did before; instead, we also investigate how the branching rule interacts with cutting plane separation and performs with respect to finding good solutions during the search. As was to be expected, this results in a smaller impact of SBDP on the overall SCIP performance as can be seen in Table 3. It helps to solve 95 instances to optimality within the time limit, compared to only 87 without SBDP, and leads to a reduction of the shifted geometric mean of the solving time by 5 % for the complete MMM test set. For the instances solved to optimality by both variants (row “solved by both”), the average numer of nodes and the solution time are reduced by 12 and 5.5 %, respectively. For the set of instances which were solved after some branching (row “solved with tree”), the results are slightly better: the number of nodes is reduced by 13 %, the solving time by 6 %. The performance diagram shown in Fig. 4 shows that full strong branching with domain propagation dominates the version without propagation also with default settings, the number of instances solved after a certain time is never smaller with SBDP than without. However, as the average numbers already indicated, the difference is smaller compared to full strong branching with sandbox settings, because more time is spent for other components like cutting plane separation or primal heuristics which are not improved by SBDP and the optimal solution needs to be found during the search, which is not necessarily promoted by a better branching rule focussing on the dual bound improvement. Nevertheless, we can conclude that also when using full strong branching with default settings, SBDP is able to improve the performance of SCIP.
Fig. 4

Performance diagram for full strong branching with SCIP default settings on the MMM test set. The graph indicates the number of instances solved within a certain time

Table 3

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

test set


full strong branching

full strong with SBDP







all instances








solved by both








solved with tree








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

The overall effects of SBDP on the performance of the hybrid branching rule are the subject of our final computational experiment. Table 4 illustrates the same type of information as Tables 2 and 3 for the experiment running hybrid branching with default SCIP settings. The performance improvement is only slightly smaller than for the full strong branching rule with default SCIP settings: the shifted geometric mean of the solving time over all instances is reduced by 4 %. This shows that the early branchings, when strong branching is still used and SBDP can improve the branching decision, are the most important ones. The performance diagram illustrated in Fig. 5 shows that the improvement is consistent for almost every possible time limit between 10 s and 2 h. The difference in the reduction of the number of nodes is almost halved compared to our previous experiment: the tree size is reduced by 7 % on average for those instances solved to optimality and slightly more for those not already solved at the root node. Taking into account that most branching decisions are taken based on history information after some time—and the therefore less important role of strong branching within hybrid branching—these results are consistent to our previous results for full strong branching.
Table 4

Comparison of hybrid branching with and without SBDP, default settings

test set


hybrid branching

hybrid branching with SBDP







all instances








solved by both








solved with tree








Fig. 5

Performance diagram for hybrid branching with SCIP default settings on the MMM test set. The graph indicates the number of instances solved within a certain time

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).


  1. 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. 2.

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

  3. 3.

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

  4. 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. 5.

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

  6. 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.



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.


  1. Achterberg T (2007) Constraint integer programming. PhD thesis, Technische Universität BerlinGoogle Scholar
  2. Achterberg T (2009) SCIP: solving constraint integer programs. Math Program Comput 1(1):1–41CrossRefGoogle Scholar
  3. 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
  4. 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
  5. Achterberg T, Koch T, Martin A (2005) Branching rules revisited. Oper Res Lett 33:42–54CrossRefGoogle Scholar
  6. Achterberg T, Koch T, Martin A (2006) MIPLIB 2003. Oper Res Lett 34(4):1–12CrossRefGoogle Scholar
  7. 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
  8. Apt KR (2003) Principles of constraint programming. Cambridge University Press, CambridgeCrossRefGoogle Scholar
  9. 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
  10. 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
  11. Bixby RE, Ceria S, McZeal CM, Savelsbergh MWP (1998) An updated mixed integer programming library: MIPLIB 3.0. Optima 58:12–15Google Scholar
  12. Borndörfer R, Ferreira CE, Martin A (1998) Decomposing matrices into blocks. SIAM J Optim 9(1): 236–269Google Scholar
  13. Dakin RJ (1965) A tree-search algorithm for mixed integer programming problems. Comput J 8(3):250–255CrossRefGoogle Scholar
  14. 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
  15. Fischetti M, Monaci M (2012) Branching on nonchimerical fractionalities. OR Lett 40(3):159–164Google Scholar
  16. 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
  17. 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
  18. Gauthier J-M, Ribière G (1977) Experiments in mixed-integer linear programming using pseudo-costs. Math Program 12(1):26–47CrossRefGoogle Scholar
  19. Gilpin A, Sandholm T (2011) Information-theoretic approaches to branching in search. Discret Optim 8(2):147–159CrossRefGoogle Scholar
  20. Karamanov M, Cornuéjols G (2011) Branching on general disjunctions. Math Program 128:403–436CrossRefGoogle Scholar
  21. 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
  22. 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
  23. Land AH, Doig AG (1960) An automatic method of solving discrete programming problems. Econometrica 28(3):497–520CrossRefGoogle Scholar
  24. Linderoth JT, Savelsbergh MWP (1999) A computational study of search strategies in mixed-integer programming. INFORMS J Comput 11(2):173–187CrossRefGoogle Scholar
  25. Lodi A, Ralphs T, Rossi F, Smriglio S (2009) Interdiction branching. Technical Report OR/09/10, DEIS, Università di BolognaGoogle Scholar
  26. 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
  27. Mitra G (1973) Investigation of some branch and bound strategies for the solution of mixed integer linear programs. Math Program 4:155–170CrossRefGoogle Scholar
  28. 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
  29. Patel J, Chinneck J (2007) Active-constraint variable ordering for faster feasibility of mixed integer linear programs. Math Program 110:445–474CrossRefGoogle Scholar
  30. 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
  31. Savelsbergh MWP (1994) Preprocessing and probing techniques for mixed integer programming problems. ORSA J Comput 6:445–454CrossRefGoogle Scholar
  32. 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
  33. 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
  34. Wunderling R (1996) Paralleler und objektorientierter Simplex-Algorithmus. PhD thesis, Technische Universität BerlinGoogle Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg and EURO - The Association of European Operational Research Societies 2014

Authors and Affiliations

  1. 1.Zuse Institute BerlinBerlinGermany

Personalised recommendations