# Convex mixed-integer optimization with Frank-Wolfe methods

Deborah Hendrych, Hannah Troppens, Mathieu Besançon, Sebastian Pokutta

► To cite this version:

Deborah Hendrych, Hannah Troppens, Mathieu Besançon, Sebastian Pokutta. Convex mixed-integer optimization with Frank-Wolfe methods. Mathematical Programming Computation, 2025, pp.1-49.
10.1007/s12532-025-00288-w. hal-05136465

HAL Id: hal-05136465

https://hal.science/hal-05136465v1

Submitted on 8 Jul 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
Convex mixed-integer optimization with Frank-Wolfe methods

**Deborah Hendrych**

Freie Universität Berlin, Germany
Zuse Institute Berlin, Germany

HENDRYCH@ZIB.DE

**Hannah Troppens**

Freie Universität Berlin, Germany
Zuse Institute Berlin, Germany

TROPPENS@ZIB.DE

**Mathieu Besançon**

Zuse Institute Berlin, Germany

BESANCON@ZIB.DE

**Sebastian Pokutta**

Technische Universität Berlin, Germany
Zuse Institute Berlin, Germany

POKUTTA@ZIB.DE

Abstract

Mixed-integer nonlinear optimization encompasses a broad class of problems that present both theoretical and computational challenges. We propose a new type of method to solve these problems based on a branch-and-bound algorithm with convex node relaxations. These relaxations are solved with a Frank-Wolfe algorithm over the convex hull of mixed-integer feasible points instead of the continuous relaxation via calls to a mixed-integer linear solver as the linear minimization oracle. The proposed method computes feasible solutions while working on a single representation of the polyhedral constraints, leveraging the full extent of mixed-integer linear solvers without an outer approximation scheme and can exploit inexact solutions of node subproblems.

1. Introduction

Mixed-integer nonlinear optimization problems (MINLP) are a challenging class combining both combinatorial structures and nonlinearities which can model a broad range of problems arising in engineering, transportation, and more generally operations and other application contexts. Combinatorial constraints can capture rich properties required for a solution, e.g., solutions that must be a path, cycle, or tour in a graph, or solutions with maximum support or guaranteed sparsity. The dominant algorithmic frameworks for solving such problems are combinations of branch-and-bound (BnB) with spatial and integer branching, and cutting planes added iteratively.

We focus in this paper on mixed-integer convex problems in which the nonlinear constraints and objectives are convex and present a new algorithmic framework for solving these problems that exploit recent advances in so-called Frank-Wolfe (FW) or Conditional Gradient (CG) methods. The problem class we consider is of the type:

$$ \min_{\mathbf{x} \in \mathbb{R}^n} f(\mathbf{x}) \quad \text{s.t.} \quad \mathbf{x} \in \mathcal{X}, \qquad (1) $$

where $\mathcal{X}$ is a compact nonconvex set admitting a *boundable linear minimization oracle* (BLMO), i.e., a set over which optimizing a linear function can be done efficiently (comparatively to the original problem), even when bounds are added or modified. Formally, we consider we have access to an oracle taking new bounds $(\mathbf{l}, \mathbf{u})$ and a direction $\mathbf{d}$:

$$ (\mathbf{l}, \mathbf{u}, \mathbf{d}) \in \mathbb{R}^n \times \mathbb{R}^n \times \mathbb{R}^n \rightarrow \underset{\mathbf{v} \in \mathbb{R}^n}{\operatorname{argmin}} \langle \mathbf{v}, \mathbf{d} \rangle \quad \text{s.t.} \quad \mathbf{v} \in \mathcal{X} \cap [\mathbf{l}, \mathbf{u}]. \qquad (\text{B-LMO}) $$
We assume that one source of nonconvexity of $\mathcal{X}$ stems from integrality constraints and will formalize that requirement in the following section. Given $J \subseteq \{1...n\}$, we will denote:

$$ \mathcal{X} = \bar{\mathcal{X}} \cap \mathbb{Z}_J, \\ \text{where } \mathbb{Z}_J = \{\mathbf{x} \in \mathbb{R}^n, \mathbf{x}_j \in \mathbb{Z} \forall j \in J\}, $$

with $\bar{\mathcal{X}}$ a continuous relaxation of $\mathcal{X}$ (which is in general not unique). A typical example for $\mathcal{X}$ includes polyhedral and integrality constraints, and combinatorial structures (which we will detail in the following sections). The objective $f: \mathrm{conv}(\mathcal{X}) \to \mathbb{R}$ is a differentiable Lipschitz-smooth convex function with a gradient accessed as an oracle, i.e., we do not require an expression graph. The proposed framework extends to nonconvex objectives when the nonconvexity affects only binary variables and exact convexifiers can be built by adding convex terms vanishing on $\{0, 1\}$ (Crama et al., 2022). It can also be extended to non-smooth generalized self-concordant functions using the methods proposed in Carderera et al. (2021; 2024). In the more general non-convex case, the framework can be used as a heuristic to compute high-quality solutions.

Several families of MINLP methods have been developed over the last decades, rooted in both nonlinear and discrete optimization approaches; see Kronqvist et al. (2019) for a recent review of methods for convex MINLPs. Some solvers such as Knitro (Byrd et al., 2006) implement a BnB algorithm that solves a nonlinear relaxation at each node of the tree. These subproblems are however expensive: typical algorithms are interior points or sequential quadratic programming, both relying on expensive second-order information and yielding high-accuracy solutions. An alternative family of approaches was introduced in Quesada & Grossmann (1992), solving Linear Programs (LPs) at each node and nonlinear problems only to compute feasible solutions and additional cuts when integer solutions are found. An LP-based method is also at the core of the solution process of COUENNE (Belotti, 2009) and SCIP (Bestuzheva et al., 2021; 2023), with additional techniques handling nonconvex nonlinearities. The solvers SHOT (Lundell et al., 2022; Kronqvist et al., 2016) and Pavito.jl (JuMP-dev, 2018) use single-tree polyhedral outer approximation approaches, relying on the Mixed-Integer Programming (MIP) solver to build the main relaxation of the problem, similar to the framework proposed in Bertsimas et al. (2021) for mixed-binary convex problems. Bonmin (Bonami et al., 2008) uses a hybrid approach with both outer polyhedral approximations and BnB. As noteworthy commercial MINLP solvers, Antigone (Misener & Floudas, 2014) hybridizes MIP and LP relaxations and NLP subproblems to compute feasible solutions, while BARON (Sahinidis, 1996) primarily solves LP relaxations in a BNB with polyhedral under- and overestimators for nonlinearities, but exploits a portfolio of MIP and NLP bounds to selectively improve on the LP relaxation at nodes (Kılınç & Sahinidis, 2018). Early termination techniques have been exploited for other convex relaxations. In Fletcher & Leyffer (1998) and Buchheim et al. (2016), mixed-integer quadratic problems are handled with early termination and warm starts in the context of active set methods, while Liang et al. (2020) consider infeasible interior-point methods. In Chen & Goulart (2022), mixed-integer conic problems are tackled with ADMM using inexact termination and a safe dual bound recovery in a BnB framework. Unlike ADMM, Frank-Wolfe is a primal approach with a lower bound computed at each iteration that can be used to terminate node processing and derive a global tree bound. Furthermore, our BLMO-based solver avoids projections onto cones which can be expensive (requiring eigendecompositions) or numerically unstable (for exponential and positive semidefinite cones for instance). It is important to note that in many MINLP solution approaches, nonlinearities are handled through separation (via gradient cuts or supporting hyperplane cuts). Separation is not possible if the nonlinearity is in the objective and most solvers therefore allow for nonlinearities in the constraints only, requiring an epigraph formulation of the objective function losing the initial structure of Problem (1). Some lines of work focused on specialized BnB approaches for some Sparse Regression or best subset selection problems (Bertsimas et al., 2016; Hazimeh & Mazumder, 2020; Gómez & Prokopyev, 2021; Moreira Costa et al., 2022). These approaches however rely on the properties of the quadratic loss and/or of the constraint set and do not extend to other loss functions (e.g., logistic or Poisson regression), additional constraints (arbitrary linear constraints on the features, grouped subset selection, integer predictor), or other MINLPs of the form (1).

Ideas for warm-starting Frank-Wolfe variants based on the active set representation of the solution (i.e., as a convex combination of vertices) have been explored in the past; in Moondra et al. (2021), an Away-step
FW (AFW) variant leveraging active sets from previous iterations in an online optimization setting. In Joulin et al. (2014), FW or variants thereof are called over the integer hull of combinatorial problems, calling a MIP solver as BLMO and additional roundings to compute feasible solutions of good quality. The hardness of optimization over the integer hull motivated lazified conditional gradient approaches in Braun et al. (2017), i.e., FW-based approaches which at some steps replace the Linear Minimization Oracle (LMO) with an inexact procedure yielding an improving direction, as long as these directions provide sufficient progress. The control of the expected progress ensures lazified methods converge at a rate similar to their exact counterpart, while drastically reducing the number of linear minimization oracle calls. We however generalize lazification techniques to consider the whole tree. BnB with AFW has been explored in Buchheim et al. (2018) for a portfolio problem, each subproblem is solved inexact to compute lower bounds from the FW gap, and each branching performs fixing to all possible values of the integer variable instead of adding bounds. In contrast, we leverage the Blended Pairwise Conditional Gradient (BPCG) algorithm (Tsuji et al., 2022) which enables us to aggressively reuse information (from computed vertices); its convergence speed is typically higher than AFW while the iterates remain sparser. This sparsity greatly benefits branching as the fractionality of solutions is lower in most cases. We point interested readers to Braun et al. (2022) for a general overview of FW methods.

## OUR APPROACH AND CONTRIBUTION

We propose a different solution approach to Problem (1), consisting of a branch-and-bound process over the convex hull of the feasible region with inexact node processing. A key feature is that at each node, FW solves the nonlinear subproblem over the convex hull of integer-feasible solutions or *integer hull* and not over the continuous relaxation. This is allowed by solving a MIP as the LMO within the FW solving process, thus resulting in vertices of the integer hull. No other access to the feasible region (e.g., complete description as linear inequalities) or the objective function (e.g., Hessian information or expression graph) is required. In particular, we do not require epigraph formulations, and we retain the original polyhedral structure; see also Figure 1 for a schematic overview. The central novel elements of our approach are:

1. Instead of solving weaker continuous relaxations at each node of the branch-and-bound tree, we optimize over the convex hull of integer-feasible solutions by solving mixed-integer linear problems in the BLMO, obtaining stronger relaxations, several feasible solutions at each node, and reducing the size of the tree;

2. We replace exact convex solvers with a Frank-Wolfe-based error-adaptive solution process, i.e., a solution process for which the amount of computations performed is increasing for higher accuracies;

3. We leverage the active set representation of the solution at each node to warm-start the children iterates and reduce the number of calls to the Mixed-Integer Programming (MIP) solver;

4. We develop new lazification techniques and strong branching strategies for our framework;

5. We exploit the convexity and Frank-Wolfe gap to tighten bounds at each node, further reducing the search space.

One motivation for outer approximation is the ability to leverage a MIP solver through single-tree approaches i.e., the MIP solver is called only once and coordinates the whole solving process with separation callbacks. This approach however carries several issues: in its pure form, only near-feasible and near-optimal solutions are obtained in the limit towards the end of the solution process. Solvers thus typically rely on MIP heuristics for primal feasible solutions. Furthermore, the separation constraints for the nonlinear feasible set, often linear cutting planes, can, in general, be dense for multivariate nonlinear expressions. These dense cuts slow down the MIP solving process and yield numerically ill-conditioned LP relaxations. We face none of these issues since we do not rely on outer approximations at all but rather on nonlinear relaxations. While this may seem inefficient at first and naive realizations would require a very large number of MIP subproblems to be solved, our framework allows utilizing recent advances in FW and MIP methods to considerably reduce the number of MIP subproblems. Specifically, our method is the first one, to the best of our knowledge, that
<figure><img src="image_2.png" /><figcaption>Figure 1: Three main algorithmic frameworks for MINLPs. Diamond blocks represent the nodal relaxations in the given framework. Figure 1a corresponds to a classic BnB framework on top of NLP relaxations, Figure 1c represents the mechanism of LP-based MINLP frameworks and outer approximations, Figure 1b is our proposed approach with the linearized models solved as MIPs within the Frank-Wolfe algorithm on top of which we branch.</figcaption></figure>

exploits the flexibility and advances of modern MIP solvers within the NLP solving process, maintaining
feasibility throughout the process.

We complement the above with extensive computational results to demonstrate the effectiveness of our approach. The algorithm is available as a registered Julia package Boscia.jl<fnref n="1" /> open-sourced under the MIT license.

## 2. Nonlinear branch-and-bound over integer hulls with linear oracles

In this section, we present the main paradigm for our framework. Our approach is primarily based on branch-and-bound, the feasible region handled at each node is identical except for updated fixings and bounds on the variables that must take integer values. At each node, we solve a convex relaxation with updated local bounds for the integer variables using a FW-based algorithm providing a relaxed primal solution and lower bound. This family of algorithms only requires a gradient oracle for the objective function $f$, and not a full analytical expression nor Hessian information. It accesses the feasible region $P$ through the LMO, which, given a direction $d$, solves $v \leftarrow \operatorname*{argmin}_{x \in P} \langle d, x \rangle$, where $v$ is an extreme point or vertex of the feasible set. This means in particular that the feasible region does not have to be given in closed form, e.g., with constraint matrix and right-hand side, as long as the LMO is well-defined with a suitable algorithm implementing it. Instead of optimizing over the continuous relaxation of Problem (1) with updated bounds at each node, we optimize over the convex hull of feasible solutions at each node. For that purpose, the LMO called within the FW procedure is the MIP solver with bounds updated for the node and objective given by the gradient information at the current solution. This design choice is illustrated in Figure 2.

The main algorithm we propose is presented in Algorithm 2.1, containing at its core a BnB procedure with approximate subproblems. The procedure `near-optimal_relaxation_solve` solves the relaxation to approximate optimality with a specified FW gap and returns a tuple including the relaxation $\hat{x}$, FW gap $g$, active and shadow sets $\mathcal{A}$, $\mathcal{S}$, and set of primal solutions $\mathcal{H}$ computed through heuristics of our methods or of the MIP solver. More details on the subproblem solution method are provided in Appendix A. `best_bound_node(N)` returns the node with the lowest dual bound.

<footnote n="1">1. https://github.com/ZIB-IOL/Boscia.jl</footnote>
<caption>**Algorithm 2.1 Boscia algorithm for Problem (1)**</caption>

**Require:** Primal-dual tolerance $\delta$, feasible set $\mathcal{X}$ as a boundable LMO, $J$ the set of integer variables, objective $f$, initial point $v_0$, FW gap tolerance $\{\varepsilon_t\}_{t \ge 0}$.

1: $\mathbf{l}^{(0)}, \mathbf{u}^{(0)} \leftarrow \text{global\_bounds}(\mathcal{X})$
2: $\hat{\mathbf{x}}^{(0)} \leftarrow v_0$
3: UB $\leftarrow f(v_0)$
4: $g_0 \leftarrow \max_{v \in \mathcal{X}} \langle \nabla f(x_0), v_0 - v \rangle$
5: $n_0 \leftarrow (l^{(0)}, u^{(0)}, \mathcal{A}_0, S_0, g_0, f(\hat{\mathbf{x}}^{(0)}) - g_0)$
6: $\mathcal{N}_0 \leftarrow \{n_0\}$
7: UB $\leftarrow \min\{\text{UB}, \min_{v \in \mathcal{A}_0 \cup S_0 \cup \mathcal{H}_0} f(v)\}$
8: LB $\leftarrow f(\hat{\mathbf{x}}^{(0)}) - g_0$
9: $t \leftarrow 0$
10: **while** UB - LB > $\delta$ and $\mathcal{N}_t \neq \emptyset$ **do**
11:     $n_t \leftarrow \text{best\_bound\_node}(\mathcal{N}_t)$
12:     $(\mathbf{l}^{(t)}, \mathbf{u}^{(t)}, \bar{\mathcal{A}}_t, \bar{S}_t, \bar{g}_t, \bar{b}_t) \leftarrow n_t$
13:     $\bar{\mathcal{N}}_t \leftarrow \mathcal{N}_t \setminus \{n_t\}$
14:     $(\hat{\mathbf{x}}^{(t)}, g_t, \mathcal{A}_t, S_t, \mathcal{H}_t) \leftarrow \text{near-optimal\_relaxation\_solve}(\mathbf{l}^{(t)}, \mathbf{u}^{(t)}, \bar{\mathcal{A}}_t, \bar{S}_t, \text{UB}, \varepsilon_t)$
15:     UB $\leftarrow \min\{\text{UB}, \min_{v \in \mathcal{A}_0 \cup S_0 \cup \mathcal{H}_0} f(v)\}$
16:     $b_t \leftarrow f(\hat{\mathbf{x}}^{(t)}) - g_t$
17:     **if** $b_t > \text{UB}$ **then**
18:         prune suboptimal node
19:         **else if** $\hat{\mathbf{x}}^{(t)} \in \mathcal{X}$ **then**
20:             UB $\leftarrow \min\{\text{UB}, f(\hat{\mathbf{x}}^{(t)})\}$
21:             close node
22:         **else**
23:             $\hat{\mathbf{l}}^{(t)}, \hat{\mathbf{u}}^{(t)} \leftarrow \text{dual\_bound\_tightening}(\mathbf{l}^{(t)}, \mathbf{u}^{(t)}, \nabla f(\hat{\mathbf{x}}^{(t)}), \text{UB}, b_t)$
24:             $j \in \{j \in J \mid \hat{\mathbf{x}}_j^{(t)} \notin \mathbb{Z}\}$
25:             $\mathbf{l}_r^{(t)} \leftarrow \hat{\mathbf{l}}^{(t)} + \mathbf{e}_j (\lceil \hat{\mathbf{x}}_j^{(t)} \rceil - \hat{\mathbf{l}}_j^{(t)})$
26:             $\mathbf{u}_l^{(t)} \leftarrow \hat{\mathbf{u}}^{(t)} + \mathbf{e}_j (\lfloor \hat{\mathbf{x}}_j^{(t)} \rfloor - \hat{\mathbf{u}}_j^{(t)})$
27:             $\mathcal{A}_l, S_l, \mathcal{A}_r, S_r \leftarrow \text{partition\_vertices}(\mathcal{A}_l, S_l, j)$
28:             $n_l \leftarrow (\mathbf{l}^{(t)}, \mathbf{u}_l^{(t)}, \mathcal{A}_l, S_l, g_l, b_l)$
29:             $n_r \leftarrow (\mathbf{l}_r^{(t)}, \mathbf{u}^{(t)}, \mathcal{A}_r, S_r, g_r, b_r)$
30:             $\mathcal{N}_{t+1} \leftarrow \bar{\mathcal{N}}_t \cup \{n_l, n_r\}$
31:         **end if**
32:     $t \leftarrow t + 1$
33: **end while**
<figure><img src="image_3.png" /><figcaption>Figure 2: Branching over the convex hull. Figure 2a shows the baseline problem with the level curves of the objective, polyhedron, the optimum over the relaxation $\tilde{x}$, and examples of potentially active vertices for a near-optimal solution (the top vertex is dropped in an optimal solution). Branching over the continuous relaxation is shown in Figure 2b. Our approach is shown in Figure 2c and Figure 2d, optimizing over the convex hull with the help of the MIP solver. Branching only once results in an optimal solution in the left part in Figure 2d, with the right part being pruned once $\tilde{x}_l$ is found.</figcaption></figure>

**Constraint representability with integer hulls.** Optimizing over the integer hull at each node automatically makes all vertices computed across FW iterations feasible for the original problem. The feasible region itself is tightened, greatly reducing the tree size for problems that have a weak continuous relaxation. This approach also allows us to integrate other nonconvex constraints as long as the integer points of their convex hull respect the combinatorial constraint, an assumption formalized below.

**Assumption 1 (non-extreme integer points feasibility).** Let $\mathcal{X}$ be the feasible set, $\bar{\mathcal{X}}$ its continuous relaxation, $\text{conv}(\mathcal{X})$ the convex hull of $\mathcal{X}$, $\mathbb{Z}_J$ the set of points respecting integrality constraints, and $(\mathbf{l}, \mathbf{u})$ the local bounds at the node. We assume that:

$$x \in \text{conv}(\mathcal{X}) \cap \mathbb{Z}_J \cap [\mathbf{l}, \mathbf{u}] \Rightarrow x \in \mathcal{X}.$$

In other words, there exists no integer point in the convex hull of $\mathcal{X}$ which is not feasible.

Assumption 1 ensures that if the relaxed solution obtained at a node is integer-feasible, it is feasible for $\mathcal{X}$ since it is obtained as a convex combination of extreme points of $\mathcal{X}$ intersected with local bounds. On a relaxed solution, the algorithm thus branches if $x \notin \mathcal{X}$ or closes the node with an admissible solution, it cannot terminate on an integer point that would not be feasible for $\mathcal{X}$, ensuring its exactness and global convergence. We illustrate this condition with two families of constraints that respect this condition and one that does not.

**Indicators.** Indicator constraints are nonconvex constraints of the form $(z, \mathbf{x}) \in \{0, 1\} \times \mathbb{R}^n : z = 1 \Rightarrow \langle \mathbf{a}, \mathbf{x} \rangle \le b$. They can represent, among others, logical, disjunctive, or SOS1 constraints and are crucial in MIP and MINLP applications. Vertices of the integer hull respect the binary constraint, thus $z \in \{0, 1\}$ on a vertex. If for a given solution, vertices of the active set all have $z = 0$ or all have $z = 1$, the indicator constraint is respected; otherwise, the relaxed solution $\hat{z}$ is fractional and will be branched on. This means that our
<figure><img src="image_4.png" /><figcaption>Figure 3: Positive and negative illustrations for Assumption 1. The blue solid curve represents the boundary of $\bar{X}$, the red dashed shaded area is $\text{conv}(\mathcal{X})$.</figcaption></figure>

framework natively handles indicator constraints by branching on the binary variable only. This extends to indicators with convex functions or convex superindicator expressed as:

$$ (z, \mathbf{x}) \in \{0, 1\} \times \mathbb{R}^n : z = 1 \Rightarrow g(\mathbf{x}) \le 0 $$

with g convex. Indeed, vertices are feasible by definition, so $z = 0$ or $z = 1$, $g(v) \le 0$ for any vertex v in the active set. If $z = 1$ in the solution, convexity implies that $g(\sum_k \lambda_k v_k) \le 0$ with $\lambda_k$ weights of the vertices in the final convex combination.

**Logical constraints.** Other constraints that are directly representable are logical constraints (or, and, and xor constraints) or more broadly arbitrary constraints of pure binary variables. Although these can typically be represented with linear constraints, most MIP solvers include specialized forms for these which helps presolving, propagation, conflict analysis and separation.

**Special Ordered Sets.** Special Ordered Sets of type 1 (SOS1) and 2 (SOS2) are defined for a vector of variables $\mathbf{x} \in \mathbb{R}^n$ as:

$$ \mathbf{x} \in \text{SOS1} \Leftrightarrow \|\mathbf{x}\|_0 \le 1, $$

$$ \mathbf{x} \in \text{SOS2} \Leftrightarrow \|\mathbf{x}\|_0 \le 2, x_i x_j = 0 \forall (i, j) \in [n]^2, |i - j| > 1. $$

For SOS1 or SOS2 constraints over non-binary variables, integrality of discrete variables is not sufficient to ensure feasibility, they would therefore require additional branching or reformulations. An example with an SOS1 constraint violating the assumption is illustrated in Figure 3c.

Our framework can also incorporate nonlinear constraints in the feasible set $\mathcal{X}$, as long as Assumption 1 is respected. From the computational perspective, however, we must note that this makes sense only if the BLMO subproblems remain inexpensive compared to the original problem. We illustrate examples where Assumption 1 may or may not hold in Figure 3.

**Blended Pairwise Conditional Gradient (BPCG).** The classic FW algorithm calls an LMO once per iteration. Even though this is acceptable in contexts where the LMO is inexpensive compared to gradient evaluations or in large dimensions in which storage of vertices is an issue, it is not the best-suited one when optimizing over polytopes. The first reason is the descent direction which can be significantly misaligned with the negative of the gradient. The second and essential one in our context is that the LMO is particularly expensive (consisting of solving a MIP). Instead, we employ methods that exploit the active set decomposition of the iterate $\mathbf{x}$, i.e., its representation as a convex combination of vertices obtained from the LMO $\mathbf{x}_t := \sum_k \lambda_k v_k$. Typical algorithms leveraging this representation are the Away Frank-Wolfe, Pairwise Conditional Gradient, and Blended Conditional Gradient algorithms (Guélat & Marcotte, 1986; Lacoste-Julien & Jaggi, 2015; Braun et al., 2019). The variant we focus on is the recently proposed Blended Pairwise Conditional
Gradient (BPCG) algorithm (Tsuji et al., 2022) which blends Frank-Wolfe steps in which a vertex is added to the active set with pairwise steps which do not require any LMO call and only perform inner products between vertices and the gradient. Empirically, BPCG produces iterates with a smaller active set across all iterations compared to other FW algorithms. We use more specifically a modification of the lazified BPCG from (Tsuji et al., 2022) with the novel adaptive step size from Pokutta (2024) implemented in FrankWolfe.jl; the algorithm is presented in detail in the supplement.

**Active and shadow set branching.** We accelerate the solving process of individual nodes through warm starts. At the end of each BPCG call, the optimal solution is given as a convex combination of vertices in an active set. All these vertices are obtained by calls to the BLMO and are thus extreme points of the integer hull. When branching, the vertices can be partitioned to form starting active sets for the left and right children. As the relaxed solution is fractional in the variable branched on, it always contains at least one vertex for each of the children. The weights are also transferred to each child for the corresponding vertex and renormalized. BPCG can also drop vertices from the active set, in a single run of the algorithm, a dropped vertex is not part of the optimal active set and will not be re-added. However, we solve subproblems across different nodes. As such, a dropped vertex can be relevant for another subproblem further down the tree when the bounds have been updated, adding computational burden by redundant calls to the BLMO. We therefore maintain a *shadow set*, i.e., a set of discarded vertices collected within each node when they are removed from the active set. The shadow set can be partitioned in a fashion similar to the active set. At all non-root nodes, an extra lazification layer is added to BPCG: if no suitable pair of vertices can be found in the pairwise step, the algorithm searches the shadow set for a vertex with a suitable inner product with the gradient, using identical criteria as in the lazy BPCG algorithm. Only if this additional step fails does the algorithm perform a BLMO call computing a new vertex. By propagating both the active and shadow set, we significantly reduce the number of calls to the BLMO, ensuring we never recompute a given vertex twice within a run for our algorithm.

## 3. Branch-and-bound techniques for error-adaptive convex relaxations

In this section, we present the techniques derived from branch-and-bound techniques that can be used in our framework. In particular, we highlight the advantages of the error-adaptivity of BPCG, i.e., the property of the computational cost decreasing gradually when the error tolerance increases, and how the various components of modern MIP solvers can be used to enhance the higher-level branch-and-bound process. MIP solvers are implementations of complex algorithms with several key components including presolving, heuristics, bound tightening, and conflict analysis. This is usually also a main motivation for single-tree MINLP solvers handling nonlinearities as a special case of separation within a MIP solving process. We can however also leverage this additional information about the feasible set within our framework by transferring it across nodes.

**FW gap-based termination.** Frank-Wolfe methods produce at each iteration a primal feasible iterate and a so-called FW gap upper-bounding the optimality gap. They feature many inexpensive iterations (unlike e.g., interior points which require few expensive iterations), with a dual bound gradually increasing with iterations. We leverage this fact to adapt the solving process at each node. Whenever the dual bound reaches the objective value of the best incumbent (or becomes close to the gap tolerance), the node can be terminated early. A significant part of the solving process can be avoided in this manner which is not necessarily the case when nodes are processed with other nonlinear solvers. Pushing this further, the solution process of a node can be stopped at any point to produce a dual bound, even if the solution is not an exact but approximate optimum. The only strict requirement is that the dual bound after solving the current node becomes high enough to yield progress in the overall tree dual bound.

**Tree state-dependent termination and evolving error.** We implement additional termination criteria for node processing which do not guarantee the node should be pruned but that save on the total number of iterations. One of them is the number of open nodes with a lower bound (obtained from the parent) that is lower than the dual bound of the node being processed during the BPCG run. This set of more promising nodes will be processed before the children of the current node are. If the number of these more promising nodes is high enough, there is a higher probability for the children of the current node not to be processed at
all, for instance, if an incumbent is found elsewhere that prunes them. We also add an adaptive Frank-Wolfe gap criterion, increasing the precision with the depth in the BnB tree: $\epsilon_n = \epsilon_0 \rho^n$, with $\rho \in ]0, 1]$ where $n$ is the depth of the current node, starting from the root at depth 0, and clipping when reaching a sufficient depth. With some convex solvers, using a reduced precision could slow down the search, as approximate solutions might exhibit a much higher fractionality when a weaker stopping criterion is used, requiring more branching. In the case of BPCG however, the iterates are a convex combination of a few integer extreme points. Furthermore, if the optimal solution at a node is an extreme point itself, the process converges rapidly by dropping the other extreme points from the active set once the optimal one has been added. As such, solutions obtained from low-precision runs do not necessarily exhibit a higher fractionality.

**Strong branching.** When tackling large discrete problems, the choice of variables to branch on can yield drastic differences in how fast the lower and upper bounds evolve and the overall size of the branch-and-bound tree. A powerful technique to estimate the lower bound increase when branching on a given variable is strong branching which solves the children subproblems of a given node for all candidate variables, selecting the variable to branch on that improves the lowest lower bound across children. Other techniques like pseudo-cost branching or recent machine learning approaches try to construct surrogate models to avoid solving the multiple convex subproblems induced by strong branching (Nair et al., 2020).

We propose a new family of branching techniques that leverage the properties of FW algorithms to obtain a partial estimate of the lower bound improvement while greatly reducing the cost. In our context, strong branching with nonlinear subproblems over the integer hull would be too costly to perform variable selection. However, we can (a) relax the strong branching over the integer hull to the continuous relaxation (solving LPs for the LMO instead of MIPs), (b) run few iterations of the subproblem (and/or set a very high FW gap tolerance). In the limit case, on the one extreme end this corresponds to performing a single FW iteration for the strong branching estimation and the optimal value of a single linear problem is used to select the branching variable. On the other extreme end, the complete high-accuracy solve would correspond to using the continuous relaxation of the node. By carefully limiting the precision we can interpolate between these two regimes.

This new partial strong branching technique will not be beneficial for all problems, i.e., it can still be too computationally expensive. Thus, we also developed a hybrid strong branching technique which performs partial strong branching only to a certain depth in the Branch-and-Bound tree and then switches to the default strategy, i.e., most fractional branching. The idea is that strong branching is effective mainly for the first couple of branching decisions.

**Dual fixing and tightening.** In a lot of subproblems, many variables are at their (local) bounds. We can then leverage convexity and primal solutions to deduce safe dual fixings or at least dual tightening of the bounds, a procedure originally established for MIPs going back to Dantzig (see Grötschel & Nemhauser (2008) and Achterberg et al. (2020)) and extended to mixed-integer conic problems in Gally et al. (2018) or MINLPs in Mahajan et al. (2021). Dual fixing in these frameworks is a presolving technique, applied in a static manner to a problem to reduce its size before the solving phase. Our approach is slightly different though as we do not explicitly use dual solutions as customary but rather convexity of the objective and availability of the FW gap. These connect to a property of Frank-Wolfe methods developed in Braun & Pokutta (2021), namely that for every Frank-Wolfe vertex v in a polytope, the dual gap is equal to the inner product of the dual variables with the slack of the polytope, in the case dual solutions exists. Our approach is more general and even works when dual solutions are not readily available e.g., when the BLMO is given via a MIP. We confine ourselves here to tightening the upper bound (potentially fixing it to the lower bound); the case for tightening the lower bound is analogous.

**Theorem 1.** Let us assume that the bounds are $[\mathbf{l}, \mathbf{u}] \supseteq \mathcal{X}$ and that we have a relaxed solution $\mathbf{x}^{(t)}$ and a variable $j \in J$ such that $\mathbf{x}^{(t)} = \mathbf{l}_j$ and $\nabla f(\mathbf{x}^{(t)})_j \ge 0$. Then, if there exists $M \in \{1, \dots, \mathbf{u}_j - \mathbf{l}_j\}$, such that:

$$M \nabla f(\mathbf{x}^{(t)})_j > \text{UB} - f(\mathbf{x}^{(t)}) + g(\mathbf{x}^{(t)}) \quad (2)$$
with $g(\cdot)$ the Frank-Wolfe gap:

$$g(\mathbf{x}) := \max_{\mathbf{x} \in \mathcal{X}} \left\langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x}^{(t)} - \mathbf{x} \right\rangle,$$

then the upper bound can be tightened to $\mathbf{x}_j^{(t)} \le \mathbf{l}_j + M - 1$.

*Proof.* By convexity, we have:

$$\left\langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x} - \mathbf{x}^{(t)} \right\rangle \le f(\mathbf{x}) - f(\mathbf{x}^{(t)}) \quad \forall \mathbf{x} \in \mathcal{X}.$$

If $\mathbf{x}_j > \mathbf{l}_j$, we can rewrite $\mathbf{x}_j = \mathbf{l}_j + M$, with $M \in \{1, \dots, \mathbf{u}_j - \mathbf{l}_j\}$. Then:

$$\begin{aligned} & \nabla f(\mathbf{x}^{(t)})_j (\mathbf{x} - \mathbf{x}^{(t)})_j + \sum_{k \neq j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x} - \mathbf{x}^{(t)})_k \\ &= M \nabla f(\mathbf{x}^{(t)})_j + \sum_{k \neq j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x} - \mathbf{x}^{(t)})_k \le f(\mathbf{x}) - f(\mathbf{x}^{(t)}) \quad \forall \mathbf{x} \in \mathcal{X} \end{aligned}$$

Let us denote $\mathcal{X}_M := \{\mathbf{x} \in \mathcal{X} | \mathbf{x}_j \ge \mathbf{l}_j + M\}$ for $M \in \{1, \dots, \mathbf{u}_j - \mathbf{l}_j\}$. Taking the minimum over all solutions $\mathbf{x} \in \mathcal{X}_M$, we obtain:

$$\begin{aligned} \min_{\mathbf{x} \in \mathcal{X}_M} f(\mathbf{x}) - f(\mathbf{x}^{(t)}) &\ge \min_{\mathbf{x} \in \mathcal{X}_M} \mathbf{u}_j \nabla f(\mathbf{x}^{(t)})_j + \min_{\mathbf{x} \in \mathcal{X}_M} \sum_{k \neq j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x} - \mathbf{x}^{(t)})_k \\ &= M \nabla f(\mathbf{x}^{(t)})_j - \max_{\mathbf{x} \in \mathcal{X}_M} \sum_{k \neq j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x}^{(t)} - \mathbf{x})_k \\ &\ge M \nabla f(\mathbf{x}^{(t)})_j - \max_{\mathbf{x} \in \mathcal{X}} \sum_{k \neq j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x}^{(t)} - \mathbf{x})_k. \end{aligned}$$

The last inequality holds since $\mathcal{X}_M \subseteq \mathcal{X}$. Since:

$$\min_{\mathbf{x} \in \mathcal{X}} \nabla f(\mathbf{x}^{(t)})_j (\mathbf{x} - \mathbf{x}^{(t)})_j = 0,$$

we can extend the sum to all variables:

$$\begin{aligned} \min_{\mathbf{x} \in \mathcal{X}_M} f(\mathbf{x}) - f(\mathbf{x}^{(t)}) &\ge M \nabla f(\mathbf{x}^{(t)})_j - \max_{\mathbf{x} \in \mathcal{X}} \left\langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x}^{(t)} - \mathbf{x} \right\rangle \\ &= M \nabla f(\mathbf{x}^{(t)})_j - g(\mathbf{x}^{(t)}), \end{aligned}$$

with $g(\cdot)$ is the Frank-Wolfe gap:

$$g(\mathbf{x}) := \max_{\mathbf{x} \in \mathcal{X}} \left\langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x}^{(t)} - \mathbf{x} \right\rangle.$$

If the optimal solution is in $\mathcal{X}_M$, then:

$$\mathrm{UB} - f(\mathbf{x}^{(t)}) \ge \min_{\mathbf{x} \in \mathcal{X}} f(\mathbf{x}) - f(\mathbf{x}^{(t)}) = \min_{\mathbf{x} \in \mathcal{X}_M} f(\mathbf{x}) - f(\mathbf{x}^{(t)}) \ge M \nabla f(\mathbf{x}^{(t)})_j - g(\mathbf{x}^{(t)}), \quad (3)$$

with UB the best primal value. Therefore, if (3) does not hold, i.e.:

$$M \nabla f(\mathbf{x}^{(t)})_j > \mathrm{UB} - f(\mathbf{x}^{(t)}) + g(\mathbf{x}^{(t)}),$$

we can deduce $\mathbf{x}_j \le \mathbf{l}_j + M - 1$.

□
We exploit Theorem 1 in two ways within our algorithm. First, we strengthen the local bounds at nodes, using the final relaxed solution. Because we incrementally add bounds on integer variables as the algorithm runs further down in the tree, more variables terminate at their bounds, leading to further fixings. We note that tightening reduces the upper bound when a variable is at its lower bound, which implies that all vertices of the active set are at the same bound, and that the active set vertices can be partitioned as described in Section 2, unlike shadow set vertices which may be discarded by the tightening. Tightening not only reduces the number of nodes to solve the problem but may also accelerate BLMO calls through the reduction of the integer variable domains. We also provide a stronger version when a strong convexity constant $\mu$ is known for the objective in Theorem 2 of Appendix B.

Second, we exploit the root-node relaxation $\bar{x}$, for which we store the gradient $\nabla f(\bar{x})$ and the dual bound $f(\bar{x}) - g(\bar{x})$. Whenever the upper bound decreases with a new primal solution, we can verify whether the inequality (2) holds and create a set of tighter bounds that are used to preemptively prune out nodes. This method may be extended in future work to incorporate other tightening techniques, such as the Lagrangian bound from optimization-based bound tightening from Gleixner et al. (2017).

**Strong convexity node bound tightening.** For several important classes of problems, a strong convexity parameter $\mu$ is known for the objective. In such cases, we can exploit the minimum increase of the objective from a current fractional solution $\hat{x}$ to preemptively prune nodes or increase their bound. We will illustrate this by branching down on (i.e., flooring) the fractional variable $j$. The same reasoning applies when branching up (i.e., ceiling). Let us denote $\mathbf{x}_i^*$ the optimal solution of the subproblem created after branching on the variable, and $\hat{J} \subseteq J\{j\}$ the set of other integer variables at fractional values. Our goal is to derive a lower bound for $f(\mathbf{x}_i^*)$ which potentially allows us to prune the node.

$$ 
\begin{aligned}
f(\mathbf{x}_i^*) &\ge f(\hat{\mathbf{x}}) + \frac{\mu}{2} \|\mathbf{x}_i^* - \hat{\mathbf{x}}\|_2^2 + \langle \nabla f(\hat{\mathbf{x}}), \mathbf{x}_i^* - \hat{\mathbf{x}} \rangle \\
&\ge f(\hat{\mathbf{x}}) + \frac{\mu}{2} (\hat{\mathbf{x}}_j - \lfloor \hat{\mathbf{x}}_j \rfloor)^2 + \frac{\mu}{2} \sum_{k \in \hat{J}} \min \{(\hat{\mathbf{x}}_k - \lfloor \hat{\mathbf{x}}_k \rfloor)^2, (\lfloor \hat{\mathbf{x}}_k \rfloor - \hat{\mathbf{x}}_k)^2\} - \langle \nabla f(\hat{\mathbf{x}}), \mathbf{x}_i^* - \hat{\mathbf{x}} \rangle \\
&\ge f(\hat{\mathbf{x}}) + \frac{\mu}{2} (\hat{\mathbf{x}}_j - \lfloor \hat{\mathbf{x}}_j \rfloor)^2 + \frac{\mu}{2} \sum_{k \in \hat{J}} \min \{(\hat{\mathbf{x}}_k - \lfloor \hat{\mathbf{x}}_k \rfloor)^2, (\lfloor \hat{\mathbf{x}}_k \rfloor - \hat{\mathbf{x}}_k)^2\} - \max_{v \in X} \langle \nabla f(\hat{\mathbf{x}}), \hat{\mathbf{x}} - v \rangle \\
&= f(\hat{\mathbf{x}}) + \frac{\mu}{2} (\hat{\mathbf{x}}_j - \lfloor \hat{\mathbf{x}}_j \rfloor)^2 + \frac{\mu}{2} \sum_{k \in \hat{J}} \min \{(\hat{\mathbf{x}}_k - \lfloor \hat{\mathbf{x}}_k \rfloor)^2, (\lfloor \hat{\mathbf{x}}_k \rfloor - \hat{\mathbf{x}}_k)^2\} - g(\hat{\mathbf{x}}).
\end{aligned}
$$

We also note that the strong convexity parameter can be computed only on the integer variables, which can result in a stronger value of $\mu$ than on the whole function. Furthermore, strongly convex terms can be added to binary variables when they do not change the value of $f$ on $\{0, 1\}$, for instance by replacing a linear expression $\sum_i c_i \mathbf{x}_i$ with $c \ge 0$ by a quadratic one $\sum_i c_i \mathbf{x}_i^2$.

The obtained improved bounds have several use cases; they can be used directly to find a branching decision removing one of the two branches or maximizing a lower bound on the improvement. Given the form of the inequality, the branching decision maximizing the lower bound improvement is equivalent to most fractional branching. We can also increase the lower bound of the node as the maximum of the bound improvement over all variables (i.e., the bound obtained from the most fractional branching).

The technique is complementary to dual bound tightening: dual bound tightening can be leveraged when a variable is at one of its bounds, tightening the variable domain, while strong convexity improves the dual bound based on fractional variables. A more generic version of the technique only assuming sharpness (Hölderian error bound) of the function is developed in Appendix B.

# 4. Computational experiments

We use the FrankWolfe.jl framework (Besançon et al., 2022; Besançon et al., 2024) to solve the node subproblems. All features specific to our BnB framework are implemented in the open-source Julia package Boscia.jl. The BnB core structures are implemented in Bonobo.jl and Boscia.jl supports all MIP solvers through MathOptInterface (Legat et al., 2022). The underlying MIP solver used in the experiments
is SCIP 0.11.14 (Bestuzheva et al., 2021) run single-threaded, strong branching uses HiGHS v1.9.0 (Huangfu & Hall, 2018) as the LP solver. All experiments were carried out in a 64-core compute node equipped with an Intel Xeon Gold 6338 2.00GHz and 1024GB RAM. The time limit was half an hour, i.e., 1800 s. We use Julia 1.10.2. The package versions used are FrankWolfe.jl v0.3.4, Bonobo.jl v0.1.3, SCIP.jl v0.11.14.

## Problem classes

These problems and additional examples are available in the package repository.

**Sparse Regression Problems.** Sparsity is a desirable property for prediction models for reasons of robustness, explainability, computational efficiency or other underlying motivations. Our framework allows for solving all cardinality-constrained regression models including linear regression, sparse Poisson regression, and logistic regression, as long as the loss function is convex and its gradient available. In Boscia.jl, there are examples of regression models where the predictor coefficients themselves are constrained to take integer values. The flexible computational model further allows for richer constraint structures encoding more domain knowledge than sparsity alone. In particular, we can encode group sparsity and constraints similar to group lasso (Friedman et al., 2010).

**Sparse Tailed Regression.** Another example of constraint structure we can directly encode is thresholded or two-tailed cardinality-constrained optimization as considered in Ahn et al. (2022): given a compact convex set $\mathcal{X}$, a convex loss $f$ and a cardinality penalty $\lambda$, the tailed cardinality-penalized model they propose is:

$$ \min_{\mathbf{x} \in \mathcal{X}} f(\mathbf{x}) + \lambda \| \max\{|\mathbf{x}_i| - \tau_i, 0\}_{i \in [n]} \|_0 + \mu \|\mathbf{x}\|_2^2 $$

which can be reformulated using indicator constraints as:

$$ \begin{array}{ll} \min_{\mathbf{x},\mathbf{z},\mathbf{s}} & f(\mathbf{x}) - \lambda \sum_{i} \mathbf{z}_i + \mu \|\mathbf{x}\|_2^2 & (TCMP) \\ \text{s.t.} & \mathbf{z}_i = 1 \Rightarrow \mathbf{s}_i \le 0 \\ & \mathbf{s}_i \ge \mathbf{x}_i - \tau_i \\ & \mathbf{s}_i \ge -\mathbf{x}_i - \tau_i \\ & \mathbf{x} \in \mathcal{X}, \mathbf{z} \in \{0, 1\}^n, \mathbf{s} \in \mathcal{X} \cap \mathbb{R}_+^n. \end{array} $$

When the indicator variable $\mathbf{z}_i$ equals one and the slack $\mathbf{s}_i$ are zero, $\mathbf{x}_i$ is constrained in the interval $[-\tau_i, \tau_i]$, the model hence penalizes the number of predictor values above a threshold in absolute value, while ignoring all smaller values. We can provide guaranteed optimal, near-optimal solutions, relaxations and bounds for Problem (TCMP) or a cardinality-constrained version without additional assumptions, replacing the complementarity constraints of Ahn et al. (2022) with polyhedral and combinatorial constraints.

**Portfolio Optimization.** We revisit the example of Buchheim et al. (2018), selecting a portfolio with budget $b$, integrality requirements on shares for some assets, and with a generic convex differentiable risk penalty term $h(\cdot)$:

$$ \min_{\mathbf{x}} h(\mathbf{x}) = \mathbf{x}^T M \mathbf{x} - \langle \mathbf{r}, \mathbf{x} \rangle \quad \text{s.t.} \quad \langle \mathbf{c}, \mathbf{x} \rangle \le b, \mathbf{x}_j \in \mathbb{Z} \forall j \in J. $$

We investigate both the case where all variables are integers, the Pure Integer Portfolio Problem, and where only half of the variables are integers, the Mixed Integer Portfolio Problem.

**MIPLIB Instances.** Our framework can process standard instance formats out of the box through the MathOptInterface library (Legat et al., 2022). We take instances from the MIPLIB 2017 (Gleixner et al., 2021) with a bounded feasible region and set a convex quadratic objective that minimizes the sum of distances to several random vertices. This ensures a sufficient curvature and a continuous optimum in the interior, avoiding a single MIP call to be optimal. The instances used are pg5_34, ran14x18-disj-8, neos5 and 22433. The purpose of the MIPLIB instances is to have problems with computationally expensive BLMOs.
## Results

To evaluate Boscia.jl, we compare its performance on the aforementioned problems to four other solution methods.

**BnB-Ipopt.** First, we have implemented a nonlinear BnB approach using the Ipopt interior point solver for the nonlinear node relaxations. For NLPs of moderate size, Ipopt is one of the most robust and well-tested open-source interior point solvers. The purpose of comparisons against BnB-Ipopt is primarily to show the impact of FW-based relaxations for different types of instances compared to an interior point method. We use Bonobo.jl as the base BNB framework on top of Ipopt, which is the same one as the one used for Boscia.jl.

**SCIP+OA.** The next solution method is an Outer Approximation approach utilizing the open source solver SCIP with a custom constraint handler to generate the cutting planes from the gradient of the objective. Note that SCIP could be used as-is but would require the objective function in an expression format. The purpose of this setup is to keep the objective function as a first-order oracle.

The implementation of the two previous setups can be found on the Boscia.jl repository in the rerun_experiments branch (https://github.com/ZIB-IOL/Boscia.jl/tree/rerun_experiments).

**Pavito.** Apart from our customized approaches, we also want to compare Boscia.jl to established solvers. One of those is the mixed-integer convex solver Pavito (JuMP-dev, 2018) written in Julia. As SCIP+OA, it is an Outer Approximation approach using SCIP as a MIP solver and Ipopt as the NLP solver.

The summary of the performance comparison can be found in Table 1. For a more detailed comparison for each problems class, see Tables 2 to 12 in Appendix C. Due to the indicator constraints in the Tailed Sparse Regression Problem, this can only be solved by the SCIP+OA framework and Boscia.jl.

The performance of Boscia.jl is overall good across a large range of instances. For most problems, it is the best or second best in terms of instances solved and average solving time. The exceptions are the MIPLIB pg5_34 and ran14x18-disj-8 instances of which none could be solved by Boscia.jl. For these problems, the corresponding MIP is expensive to solve and thus, Boscia.jl is, as expected, not a good approach. Note though that all solver setups struggle with the two problems which point to them being hard to solve in general.

On many instances of the Poisson Regression Problem and Sparse Log Regression Problem Boscia.jl times out as well. Looking at progress plots for each problem in Figure 4, we see that the incumbent does not change drastically after the first 200 nodes. Thus, the closing of the optimality gap has to be achieved by improving the lower bound. Observe that the lower bound is improving very slowly. This points to the continuous relaxation in the nodes being too loose. On the other hand, the progress of the lower bound could be improved by potentially exploiting either sharpness or strong convexity.

The effect strong convexity can have on the solution process is showcased in Figure 5 on two MIPLIB neos5 instances. The lower bound is tightened and the solving time is thus reduced significantly, in the case of Figure 5a even halved. The number of processed nodes decreases by roughly a quarter.

It is interesting to note that BnB-Ipopt shows better performance on both types of the portfolio problem, see Figure 6 and Table 1. The evaluation of an individual node is faster within BnB-Ipopt than in Boscia.jl. But the total number of nodes to evaluate is significantly smaller for Boscia.jl than for BnB-Ipopt. Notice that Boscia.jl has to evaluate roughly two-thirds fewer nodes than BnB-Ipopt, see Figure 7. Consequently, if BnB-Ipopt performs better on instances (of larger dimension), we can conclude that Boscia.jl has to process a comparatively large number of nodes and hence, the solution time increases. In Figure 8, we can see the progress plot for a Pure Integer Portfolio instance. The incumbent continuously improves for the first 200 nodes, hinting that problem-specific heuristics could be beneficial.

With regards to SCIP+OA, one main observation is that it performs well on small instances. For larger instances, the addition of cutting planes can lead to numerically ill-conditioned problems. In particular for the Sparse Regression Problem, the Sparse Log Regression Problem and the Poisson Regression Problem, there were instances for which SCIP reported optimality but Boscia.jl had a better primal bound. It seems that numerical instabilities lead to SCIP+OA cutting away the actual optimal solution and returning a
<figure><img src="image_5.png" /><figcaption>(a) Poisson Regression of dimension 70.</figcaption></figure>

<figure><img src="image_6.png" /><figcaption>(b) Sparse Log Regression of dimension 75.</figcaption></figure>

<figure><img src="image_7.png" /><figcaption>(a) MIPLIB neos5 example with the objective being formed from 5 vertices.</figcaption></figure>

<figure><img src="image_8.png" /><figcaption>(b) MIPLIB neos5 example with the objective being formed from 8 vertices.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Figure 6: Termination on the Mixed Integer Portfolio instances</figcaption></figure>
<figure><img src="image_10.png" /><figcaption>(a) MIPLIB neos5 example with the objective being formed from 6 vertices.</figcaption></figure>

<caption>(b) MIPLIB neos5 example with the objective being formed from 8 vertices.</caption>

<figure><img src="image_11.png" /><figcaption>Figure 8: Progress of the lower bound, incumbent and accumulated number of LMO calls over the number of nodes for a Pure Integer Portfolio instance with 35 integer variables.</figcaption></figure>
<figure><img src="image_12.png" /><figcaption>Figure 9: Termination on the Poisson Regression instances.</figcaption></figure>

<figure><img src="image_13.png" /><figcaption>Figure 10: Termination on the Sparse Regression instances.</figcaption></figure>

suboptimal solution. Note that we counted instances not solved by *SCIP+OA* if the reported solution had an absolute difference of 0.01 to the primal bound of *Boscia.jl*. Given the magnitude of the objectives, this is equivalent to a relative gap of 0.05.

*SCIP+OA* shows a very good performance on the Poisson Regression instances, see Figure 9. Given the occurrence of false positives in the Poisson Regression instances, we should take these results with a grain of salt.

The last of the solvers is *Pavito*. Its performance is similar or worse to *SCIP+OA*. Notable exceptions are the Sparse Regression instances and the Mixed Integer Portfolio instances on which *Pavito* performs better than *SCIP+OA*, see Figures 6 and 10. It outperforms *Boscia.jl* only on the MIPLIB ran14x18-disj-8 instance. Like *SCIP+OA*, the addition of cutting planes causes the internal MIP to become increasingly numerically difficult to solve.

Lastly, we experiment with the various settings of *Boscia.jl* to investigate their impact on the performance. The detailed results can be found in Table 13, comparing the impact of tightening and strong convexity,
<figure><img src="image_14.png" /><figcaption>Figure 11: Comparing the effect of warm start, shadow and used Frank-Wolfe variant on the performance of Boscia.jl on the Pure Integer Portfolio instances. Per default, Boscia.jl uses both warm starting and the shadow set. The default Frank-Wolfe is BPCG.</figcaption></figure>

Table 14, comparing the effect of the warm-start settings, and Table 15, comparing the performance of the different branching strategies.

Figure 11 compares the number of solved instances for the different warm start and shadow set settings as well as comparing using BPCG vs using Away-Frank-Wolfe (AFW). Disabling warm starting has a visible negative effect on the performance. The effect of not utilizing the shadow set is not so pronounced pointing to the BLMO being relatively cheap. Using AFW instead of BPCG impacts the performance significantly. This is expected since BPCG converges faster than AFW and requires fewer BLMO calls.

The effects of the global and local tightening are problem-dependent as seen in Figure 12. While local tightening has a positive effect on the Sparse Regression Problem, see Figure 12a, it increases both the solving time as well as the number of BLMO calls for the Pure Integer Portfolio problem (Figure 12b). This is explained by the fact that tightening can render vertices of the shadow set infeasible and discard them, these vertices cannot be used anymore and have to be replaced by new BLMO calls on the updated feasible region.

In Figure 13, the progress of the lower bound for the different branching strategies is displayed. As expected, the strong branching rule is prohibitively expensive. The hybrid branching rule fares better than the strong branching rule in terms of progress per node. Nevertheless, it is expensive to perform even for a shallow depth. Time-wise, the most fractional branching rule is still the best choice. Although this is far from being the case in MILP, where most fractional branching performs on par with random branching, we can highlight that previous studies (Gamrath et al., 2020) showed that dual degeneracy can partly explain the weakness of variable fractionality for branching. Because of the nonlinear convexity of the MINLPs we consider, dual degeneracy is much less likely and fractionality is a reasonable choice. We leave studies of other branching rules applied to the Boscia.jl algorithm to future work.

# 5. Conclusion

In this paper, we proposed a novel algorithm for mixed-integer convex optimization relying only on gradient and function evaluations of the objective, and linear optimization over the feasible set. By embedding a FW-based subsolver within a branch-and-bound framework, our method does not rely on separation or projection subproblems. Since FW algorithms rely on LMO calls to handle the constraint set, we significantly strengthen convex relaxations by optimizing over the local integer hull, leveraging the capabilities of modern MIP solvers. Lazification techniques within and across nodes avoid expensive MIP solves by exploiting all vertices that
<figure><img src="image_15.png" /><figcaption>(a) Sparse Regression instance with 115 integer variables. (b) Pure Integer Portfolio instance with 120 variables.</figcaption></figure>

<figure><img src="image_16.png" /><figcaption>Figure 13: Comparing the branching strategies on a Mixed Integer Portfolio instance with 25 integer variables. In the hybrid branching, the depth setting is # integer variables/20 is reached.</figcaption></figure>
<table><caption>Table 1: Comparing the relative number of terminations and the time of all solver setups on all problems. The average time is taken using the geometric mean shifted by 1 second. Also, note that this is the average time over all instances in that group, i.e., it includes the time outs.</caption><thead><tr><th rowspan="2">Problem</th><th rowspan="2"># inst.</th><th colspan="2">Boscia</th><th colspan="2">B&B Ipopt</th><th colspan="2">SCIP+OA</th><th colspan="2">Pavito</th></tr><tr><th>% solved</th><th>Time (s)</th><th>% solved</th><th>Time (s)</th><th>% solved</th><th>Time (s)</th><th>% solved</th><th>Time (s)</th></tr></thead><tbody><tr><td>MIPLIB 22433</td><td>15</td><td>100 %</td><td>5.33</td><td>100 %</td><td>30.32</td><td>100 %</td><td>1.69</td><td>100 %</td><td>6.64</td></tr><tr><td>MIPLIB neos5</td><td>15</td><td>93 %</td><td>30.66</td><td>100 %</td><td>19.0</td><td>33 %</td><td>517.4</td><td>33 %</td><td>460.85</td></tr><tr><td>MIPLIB pg5_34</td><td>15</td><td>0 %</td><td>1800.0</td><td>0 %</td><td>1800.07</td><td>0 %</td><td>1800.04</td><td>0 %</td><td>1800.0</td></tr><tr><td>MIPLIB ran14x18-disj-8</td><td>15</td><td>0 %</td><td>1802.86</td><td>0 %</td><td>1800.16</td><td>0 %</td><td>1800.09</td><td>7 %</td><td>1797.79</td></tr><tr><td>Poisson Regression</td><td>120</td><td>25 %</td><td>406.01</td><td>28 %</td><td>516.04</td><td>81 %</td><td>81.74</td><td>24 %</td><td>885.84</td></tr><tr><td>Pure Integer Portfolio</td><td>210</td><td>75 %</td><td>236.29</td><td>93 %</td><td>26.97</td><td>14 %</td><td>1162.41</td><td>5 %</td><td>1656.61</td></tr><tr><td>Mixed Integer Portfolio</td><td>210</td><td>95 %</td><td>19.47</td><td>100 %</td><td>2.82</td><td>21 %</td><td>903.36</td><td>60 %</td><td>137.68</td></tr><tr><td>Sparse Regression</td><td>160</td><td>92 %</td><td>25.14</td><td>86 %</td><td>48.01</td><td>1 %</td><td>1720.39</td><td>35 %</td><td>547.69</td></tr><tr><td>Sparse Log Regression</td><td>48</td><td>31 %</td><td>387.38</td><td>29 %</td><td>592.41</td><td>17 %</td><td>665.15</td><td>15 %</td><td>1121.07</td></tr><tr><td>Tailed Sparse Regression</td><td>160</td><td>100 %</td><td>0.3</td><td></td><td></td><td>49 %</td><td>52.59</td><td></td><td></td></tr><tr><td>Tailed Sparse Log Regression</td><td>48</td><td>100 %</td><td>0.85</td><td></td><td></td><td>75 %</td><td>129.89</td><td></td><td></td></tr></tbody></table>
have been discovered and further MIP information, while tightening and stronger dual bounds reduce the size
of the branch-and-bound tree and tighten the feasible region.

Acknowledgments

Research reported in this paper was partially supported through the Research Campus Modal funded by the German Federal Ministry of Education and Research (fund numbers 05M14ZAM,05M20ZBM) and the Deutsche Forschungsgemeinschaft (DFG) through the DFG Cluster of Excellence MATH+.

References

Achterberg, T., Bixby, R. E., Gu, Z., Rothberg, E., and Weninger, D. Presolve reductions in mixed integer programming. *INFORMS Journal on Computing*, 32(2):473–506, 2020.

Ahn, M., Gangammanavar, H., and Troxell, D. Tractable continuous approximations for constraint selection via cardinality minimization, 2022.

Belotti, P. COUENNE: a user's manual, 2009.

Bertsimas, D., King, A., and Mazumder, R. Best subset selection via a modern optimization lens. *The annals of statistics*, 44(2):813–852, 2016.

Bertsimas, D., Cory-Wright, R., and Pauphilet, J. A unified approach to mixed-integer optimization problems with logical constraints. *SIAM Journal on Optimization*, 31(3):2340–2367, 2021.

Besançon, M., Carderera, A., and Pokutta, S. FrankWolfe.jl: A high-performance and flexible toolbox for frank-wolfe algorithms and conditional gradients. *INFORMS Journal on Computing*, 2022.

Besançon, M., Designolle, S., Halbey, J., Hendrych, D., Pokutta, S., Troppens, H., Viladrich, D., and Wirth, E. Improved algorithms and novel applications of the FrankWolfe.jl library, 2024. In preparation.

Bestuzheva, K., Besançon, M., Chen, W.-K., Chmiela, A., Donkiewicz, T., van Doornmalen, J., Eifler, L., Gaul, O., Gamrath, G., Gleixner, A., et al. The SCIP Optimization Suite 8.0. *arXiv preprint arXiv:2112.08872*, 2021.

Bestuzheva, K., Besançon, M., Chen, W.-K., Chmiela, A., Donkiewicz, T., Van Doornmalen, J., Eifler, L., Gaul, O., Gamrath, G., Gleixner, A., et al. Enabling research through the scip optimization suite 8.0. *ACM Transactions on Mathematical Software*, 49(2):1–21, 2023.

Bonami, P., Biegler, L. T., Conn, A. R., Cornuéjols, G., Grossmann, I. E., Laird, C. D., Lee, J., Lodi, A., Margot, F., Sawaya, N., and Wächter, A. An algorithmic framework for convex mixed integer non-linear programs. *Discrete Optimization*, 5(2):186–204, 2008. ISSN 1572-5286. doi: https://doi.org/10.1016/j.disopt.2006.10.011. URL https://www.sciencedirect.com/science/article/pii/S1572528607000448. In Memory of George B. Dantzig.

Braun, G. and Pokutta, S. Dual prices for Frank-Wolfe algorithms. *arXiv preprint arXiv:2101.02087*, 2021.

Braun, G., Pokutta, S., and Zink, D. Lazifying conditional gradient algorithms. In *International conference on machine learning*, pp. 566–575. PMLR, 2017.

Braun, G., Pokutta, S., Tu, D., and Wright, S. Blended conditional gradients. In *International Conference on Machine Learning*, pp. 735–743. PMLR, 2019.

Braun, G., Carderera, A., Combettes, C. W., Hassani, H., Karbasi, A., Mokthari, A., and Pokutta, S. Conditional gradient methods. preprint, 8 2022.
Buchheim, C., Santis, M. D., Lucidi, S., Rinaldi, F., and Trieu, L. A feasible active set method with reoptimization for convex quadratic mixed-integer programming. *SIAM Journal on Optimization*, 26(3): 1695–1714, 2016.

Buchheim, C., De Santis, M., Rinaldi, F., and Trieu, L. A Frank-Wolfe based branch-and-bound algorithm for mean-risk optimization. *Journal of Global Optimization*, 70(3):625–644, 2018.

Byrd, R. H., Nocedal, J., and Waltz, R. A. Knitro: An integrated package for nonlinear optimization. In *Large-scale nonlinear optimization*, pp. 35–59. Springer, 2006.

Carderera, A., Besançon, M., and Pokutta, S. Simple steps are all you need: Frank-Wolfe and generalized self-concordant functions. *Advances in Neural Information Processing Systems*, 34:5390–5401, 2021.

Carderera, A., Besançon, M., and Pokutta, S. Scalable frank-wolfe on generalized self-concordant functions via simple steps. *SIAM Journal on Optimization*, 34(3):2231–2258, 2024.

Chen, Y. and Goulart, P. An early termination technique for ADMM in mixed integer conic programming. In *2022 European Control Conference (ECC)*, pp. 60–65. IEEE, 2022.

Crama, Y., Elloumi, S., Lambert, A., and Rodriguez-Heck, E. Quadratization and convexification in polynomial binary optimization. 2022.

Fletcher, R. and Leyffer, S. Numerical experience with lower bounds for MIQP branch-and-bound. *SIAM Journal on Optimization*, 8(2):604–616, 1998.

Friedman, J., Hastie, T., and Tibshirani, R. A note on the group lasso and a sparse group lasso. *arXiv preprint arXiv:1001.0736*, 2010.

Gally, T., Pfetsch, M. E., and Ulbrich, S. A framework for solving mixed-integer semidefinite programs. *Optimization Methods and Software*, 33(3):594–632, 2018.

Gamrath, G., Berthold, T., and Salvagnin, D. An exploratory computational analysis of dual degeneracy in mixed-integer programming. *EURO Journal on Computational Optimization*, 8(3):241–261, 2020.

Gleixner, A., Hendel, G., Gamrath, G., Achterberg, T., Bastubbe, M., Berthold, T., Christophel, P., Jarck, K., Koch, T., Linderoth, J., et al. MIPLIB 2017: data-driven compilation of the 6th mixed-integer programming library. *Mathematical Programming Computation*, pp. 1–48, 2021.

Gleixner, A. M., Berthold, T., Müller, B., and Weltge, S. Three enhancements for optimization-based bound tightening. *Journal of Global Optimization*, 67:731–757, 2017.

Gómez, A. and Prokopyev, O. A. A mixed-integer fractional optimization approach to best subset selection. *INFORMS Journal on Computing*, 33(2):551–565, 2021.

Grötschel, M. and Nemhauser, G. L. George Dantzig’s contributions to integer programming. *Discrete Optimization*, 5(2):168–173, 2008.

Guélat, J. and Marcotte, P. Some comments on Wolfe’s ‘away step’. *Mathematical Programming*, 35(1): 110–119, 1986.

Hazimeh, H. and Mazumder, R. Fast best subset selection: Coordinate descent and local combinatorial optimization algorithms. *Operations Research*, 68(5):1517–1537, 2020.

Hendrych, D., Besançon, M., and Pokutta, S. Solving the optimal experiment design problem with mixed-integer convex methods. In Liberti, L. (ed.), *22nd International Symposium on Experimental Algorithms (SEA 2024)*, volume 301 of *Leibniz International Proceedings in Informatics (LIPIcs)*, pp. 16:1–16:22, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. ISBN 978-3-95977-325-6. doi: 10.4230/LIPIcs.SEA.2024.16. URL https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.SEA.2024.16.
Hoffman, A. J. On approximate solutions of systems of linear inequalities. In *Selected Papers Of Alan J Hoffman: With Commentary*, pp. 174–176. World Scientific, 2003.

Huangfu, Q. and Hall, J. A. J. Parallelizing the dual revised simplex method. *Mathematical Programming Computation*, 10(1):119–142, 2018. doi: 10.1007/s12532-017-0130-5.

Joulin, A., Tang, K., and Fei-Fei, L. Efficient image and video co-localization with Frank-Wolfe algorithm. In *European Conference on Computer Vision*, pp. 253–268. Springer, 2014.

JuMP-dev. Pavito, a gradient-based outer approximation solver for convex mixed-integer nonlinear programming, 2018. https://github.com/jump-dev/Pavito.jl.

Kerdreux, T., d'Aspremont, A., and Pokutta, S. Restarting frank-wolfe: faster rates under hölderian error bounds. *Journal of Optimization Theory and Applications*, 192(3):799–829, 2022.

Kılınç, M. R. and Sahinidis, N. V. Exploiting integrality in the global optimization of mixed-integer nonlinear programming problems with BARON. *Optimization Methods and Software*, 33(3):540–562, 2018.

Kronqvist, J., Lundell, A., and Westerlund, T. The extended supporting hyperplane algorithm for convex mixed-integer nonlinear programming. *Journal of Global Optimization*, 64(2):249–272, 2016.

Kronqvist, J., Bernal, D. E., Lundell, A., and Grossmann, I. E. A review and comparison of solvers for convex MINLP. *Optimization and Engineering*, 20(2):397–455, 2019.

Lacoste-Julien, S. and Jaggi, M. On the global linear convergence of Frank-Wolfe optimization variants. *Advances in neural information processing systems*, 28, 2015.

Legat, B., Dowson, O., Garcia, J., and Lubin, M. MathOptInterface: a data structure for mathematical optimization problems. *INFORMS Journal on Computing*, 2022.

Liang, J., Di Cairano, S., and Quirynen, R. Early termination of convex qp solvers in mixed-integer programming for real-time decision making. *IEEE Control Systems Letters*, 5(4):1417–1422, 2020.

Lundell, A., Kronqvist, J., and Westerlund, T. The supporting hyperplane optimization toolkit for convex MINLP. *Journal of Global Optimization*, pp. 1–41, 2022.

Mahajan, A., Leyffer, S., Linderoth, J., Luedtke, J., and Munson, T. Minotaur: A mixed-integer nonlinear optimization toolkit. *Mathematical Programming Computation*, 13:301–338, 2021.

Misener, R. and Floudas, C. A. ANTIGONE: algorithms for continuous/integer global optimization of nonlinear equations. *Journal of Global Optimization*, 59(2):503–526, 2014.

Moondra, J., Mortagy, H., and Gupta, S. Reusing combinatorial structure: Faster iterative projections over submodular base polytopes. *Advances in Neural Information Processing Systems*, 34:25386–25399, 2021.

Moreira Costa, C., Kreber, D., and Schmidt, M. An alternating method for cardinality-constrained optimization: A computational study for the best subset selection and sparse portfolio problems. *INFORMS Journal on Computing*, 2022.

Nair, V., Bartunov, S., Gimeno, F., von Glehn, I., Lichocki, P., Lobov, I., O'Donoghue, B., Sonnerat, N., Tjandraatmadja, C., Wang, P., et al. Solving mixed integer programs using neural networks. *arXiv preprint arXiv:2012.13349*, 2020.

Nemirovskii, A. S. and Nesterov, Y. Optimal methods of smooth convex minimization. *USSR Computational Mathematics and Mathematical Physics*, 25(2):21–30, 1985.

Pokutta, S. The Frank-Wolfe algorithm: a short introduction. *Jahresbericht der Deutschen Mathematiker-Vereinigung*, 126(1):3–35, 2024.
Polyak, B. T. Sharp minima. institute of control sciences lecture notes, Moscow, USSR, 1979. In *IIASA workshop on generalized Lagrangians and their applications*, IIASA, Laxenburg, Austria, 1979.

Quesada, I. and Grossmann, I. E. An LP/NLP based branch and bound algorithm for convex MINLP optimization problems. *Computers & chemical engineering*, 16(10-11):937-947, 1992.

Sahinidis, N. V. BARON: A general purpose global optimization software package. *Journal of global optimization*, 8:201-205, 1996.

Sharma, K., Hendrych, D., Besançon, M., and Pokutta, S. Network design for the traffic assignment problem with mixed-integer frank-wolfe. In *Proceedings of the INFORMS Optimization Society Conference*, 2024.

Tsuji, K. K., Tanaka, K., and Pokutta, S. Pairwise conditional gradients without swap steps and sparser kernel herding. In *International Conference on Machine Learning*, pp. 21864-21883. PMLR, 2022.
# Appendix A. Blended Pairwise Conditional Gradient

We present in Algorithm A.1 the modified Lazy Blended Pairwise Conditional Gradient (L-BPCG) from Tsuji et al. (2022) to solve relaxations at each node, combined with the adaptive step size proposed in Pokutta (2024) which dynamically estimates a local bound on the Lipschitz constant. The procedure populates the shadow set with dropped vertices and starts from the warm-started active set. The convergence follows from that of BPCG, we use the same progress measure on whether a shadow vertex offers sufficient decrease as FW direction (vertex the iterates moves towards) as we do for a classic pairwise step. The additional shadow vertex selection can be viewed as a special case of a pairwise step where the initial weight in the active set is zero.

# Appendix B. Tighter lower bound and dual tightening inequalities

In this appendix, we provide a modified lower-bound inequality when the function is sharp, and strengthen the dual tightening condition when it is strongly convex.

For many objective functions of interest, strong convexity is too strong of a requirement, if they are not strongly convex or if it offers a loose inequality. We derive an equivalent improved dual bound for functions presenting a Hölder error bound or sharpness property (Hoffman, 2003; Nemirovskii & Nesterov, 1985; Polyak, 1979). We also highlight that Frank-Wolfe algorithms benefit from accelerated rates under a sharpness assumption (Kerdreux et al., 2022).

**Definition 1** (Hölder Error Bound). Let $f$ be a function $f: X \to \mathbb{R}$ and $C$ a compact neighborhood around the minimizer set $X^* := \operatorname*{argmin}_{x \in X} f(x)$. The function $f$ satisfies a $(\theta, M)$ Hölder Error Bound on $C$ if $\exists \theta \in [0, 1/2]$ and $M > 0$, such that:

$$ \min_{\mathbf{x}^* \in X^*} \|\mathbf{x} - \mathbf{x}^*\| \leq M(f(\mathbf{x}) - f^*)^\theta. \quad (4) $$

We will further assume that the optimum is unique $X^* := \{\mathbf{x}^*\}$. Denoting by $\mathbf{x}_l^*$ the optimal value of the solution after branching, we have:

$$ \begin{aligned} \|\mathbf{x}_l^* - \mathbf{x}^*\| &\leq M(f(\mathbf{x}_l^*) - f^*)^\theta \\ f(\mathbf{x}_l^*) &\geq M^{-1/\theta} \|\mathbf{x}_l^* - \mathbf{x}^*\|^{1/\theta} + f(\hat{\mathbf{x}}) - g(\hat{\mathbf{x}}). \end{aligned} $$

Furthermore:

$$ \begin{aligned} \|\mathbf{x}_l^* - \mathbf{x}^*\| &\geq \|\mathbf{x}_l^* - \hat{\mathbf{x}}\| - \|\hat{\mathbf{x}} - \mathbf{x}^*\| \\ &\geq \|\mathbf{x}_l^* - \hat{\mathbf{x}}\| - M(f(\hat{\mathbf{x}}) - f^*)^\theta \\ &\geq \|\mathbf{x}_l^* - \hat{\mathbf{x}}\| - M(g(\hat{\mathbf{x}}))^\theta, \end{aligned} $$

resulting in the following bound:

$$ f(\mathbf{x}_l^*) \geq M^{-1/\theta} (\|\hat{\mathbf{x}} - \mathbf{x}^*\| - M(g(\hat{\mathbf{x}}))^\theta)^{1/\theta} + f(\hat{\mathbf{x}}) - g(\hat{\mathbf{x}}), \quad (5) $$

where a lower bound on $\|\hat{\mathbf{x}} - \mathbf{x}^*\|$ can be obtained similarly to the strong convexity result. We can also improve the dual bound tightening in case the function is $\mu$-strongly convex.

**Theorem 2.** Let us assume that the bounds are $[\mathbf{l}, \mathbf{u}] \supseteq X$ and that we have a relaxed solution $\mathbf{x}^{(t)}$ and a variable $j \in J$ such that $\mathbf{x}_j^{(t)} = \mathbf{l}_j$ and $\nabla f(\mathbf{x}^{(t)})_j \geq 0$. Furthermore, if $f$ is $\mu$-strongly convex, then, if there exists $M \in \{1, \dots, \mathbf{u}_j - \mathbf{l}_j\}$, such that:

$$ M \nabla f(\mathbf{x}^{(t)})_j > \text{UB} - f(\mathbf{x}^{(t)}) + g(\mathbf{x}^{(t)}) - \frac{\mu}{2} M^2, \quad (6) $$
<caption>**Algorithm A.1** Lazy Blended Pairwise Conditional Gradient with Shadow Set and Cutoff</caption>

**Require:** Starting active set $\mathcal{A}_0$ and weights $\lambda$, shadow set $\mathcal{S}_0$, function $f$, feasible set of current node $P$, $\varepsilon_{\text{tol}}$, accuracy $K \ge 1$, primal bound $\hat{f}$.

**Ensure:** Final iterate $\mathbf{x}$ such that $f(\mathbf{x}) \le f^* + \varepsilon_{\text{tol}}$ or a dual bound greater than $\hat{f}$

1: $\mathbf{x}_0 \leftarrow \sum_{k=1}^{|\mathcal{A}_0|} \lambda_k \mathbf{v}_k$
2: $\mathbf{\Phi}_0 \leftarrow \max_{\mathbf{v} \in P} \langle \nabla f(\mathbf{x}_0), \mathbf{v} \rangle / 2$
3: $t = 0$
4: **while** $\mathbf{\Phi}_t > \varepsilon_{\text{tol}}$ and $f(\mathbf{x}_t) - \mathbf{\Phi}_t < \hat{f}$ **do**
5: &nbsp;&nbsp;&nbsp;&nbsp;$a_t \leftarrow \operatorname*{argmax}_{\mathbf{v} \in \mathcal{A}_t} \langle \nabla f(\mathbf{x}_t), \mathbf{v} \rangle$ &nbsp;&nbsp;&nbsp;&nbsp;▶ Near-optimal or pruned by the bound
6: &nbsp;&nbsp;&nbsp;&nbsp;$s_t \leftarrow \operatorname*{argmin}_{\mathbf{v} \in \mathcal{A}_t} \langle \nabla f(\mathbf{x}_t), \mathbf{v} \rangle$ &nbsp;&nbsp;&nbsp;&nbsp;▶ away vertex
7: &nbsp;&nbsp;&nbsp;&nbsp;**if** $\langle \nabla f(\mathbf{x}_t), a_t - s_t \rangle \ge \mathbf{\Phi}_t$ **then**
8: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$d_t \leftarrow a_t - s_t$
9: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\gamma_{\max} \leftarrow \text{weight\_of}(\mathcal{A}_t, a_t)$
10: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\gamma_t \leftarrow \operatorname*{argmin}_{\gamma \in [0, \gamma_{\max}]} f(x - \gamma d_t)$
11: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{x}_{t+1} \leftarrow \mathbf{x}_t - \gamma_t d_t$
12: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{\Phi}_{t+1} \leftarrow \mathbf{\Phi}_t$
13: &nbsp;&nbsp;&nbsp;&nbsp;**if** $\gamma_t < \gamma_{\max}$ **then**
14: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t$ &nbsp;&nbsp;&nbsp;&nbsp;▶ descent step
15: &nbsp;&nbsp;&nbsp;&nbsp;**else**
16: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t \setminus \{a_t\}$
17: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$S_{t+1} \leftarrow S_t \cup \{a_t\}$
18: &nbsp;&nbsp;&nbsp;&nbsp;**end if**
19: **else**
20: &nbsp;&nbsp;&nbsp;&nbsp;$s_t \leftarrow \operatorname*{argmin}_{\mathbf{v} \in S_t} \langle \nabla f(\mathbf{x}_t), \mathbf{v} \rangle$ &nbsp;&nbsp;&nbsp;&nbsp;▶ forward vertex from dropped vertices
21: **if** $\langle \nabla f(\mathbf{x}_t), a_t - s_t \rangle \ge \mathbf{\Phi}_t$ **then**
22: &nbsp;&nbsp;&nbsp;&nbsp;$\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t \cup \{s_t\}$
23: &nbsp;&nbsp;&nbsp;&nbsp;$S_{t+1} \leftarrow S_t \setminus \{s_t\}$
24: &nbsp;&nbsp;&nbsp;&nbsp;descent or drop step
25: **else**
26: &nbsp;&nbsp;&nbsp;&nbsp;$w_t \leftarrow \operatorname*{argmin}_{\mathbf{v} \in P} \langle \nabla f(\mathbf{x}_t), \mathbf{v} \rangle$ &nbsp;&nbsp;&nbsp;&nbsp;▶ global LMO
27: **if** $\langle \nabla f(\mathbf{x}_t), \mathbf{x}_t - w_t \rangle \ge \mathbf{\Phi}_t / K$ **then**
28: &nbsp;&nbsp;&nbsp;&nbsp;$d_t = \mathbf{x}_t - w_t$
29: &nbsp;&nbsp;&nbsp;&nbsp;$\gamma_t \leftarrow \operatorname*{argmin}_{\gamma \in [0,1]} f(x - \gamma d_t)$
30: &nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{x}_{t+1} \leftarrow \mathbf{x}_t - \gamma_t d_t$
31: &nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{\Phi}_{t+1} \leftarrow \mathbf{\Phi}_t$
32: &nbsp;&nbsp;&nbsp;&nbsp;$\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t \cup \{w_t\}$
33: **else**
34: &nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{x}_{t+1} \leftarrow \mathbf{x}_t$
35: &nbsp;&nbsp;&nbsp;&nbsp;$\mathbf{\Phi}_{t+1} \leftarrow \mathbf{\Phi}_t / 2$
36: &nbsp;&nbsp;&nbsp;&nbsp;$\mathcal{A}_{t+1} \leftarrow \mathcal{A}_t$
37: **end if**
38: **end if**
39: **end if**
40: $t \leftarrow t + 1$
41: **end while**
with g(·) the Frank-Wolfe gap:

$$g(\mathbf{x}) := \max_{\mathbf{x} \in \mathcal{X}} \langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x}^{(t)} - \mathbf{x} \rangle,$$

then the upper bound can be tightened to $\mathbf{x}_j^{(t)} \le \mathbf{1}_j + M - 1$.

**Proof.** Given the iterate $\mathbf{x}^{(t)}$, we starting from the strong convexity property:

$$\langle \nabla f(\mathbf{x}^{(t)}), \mathbf{x} - \mathbf{x}^{(t)} \rangle + \frac{\mu}{2} \|\mathbf{x} - \mathbf{x}^{(t)}\|^2 \le f(\mathbf{x}) - f(\mathbf{x}^{(t)}) \quad \forall \mathbf{x} \in \mathcal{X}.$$

Taking the minimum over all solutions $\mathbf{x} \in \mathcal{X}_M$, we obtain:

$$\begin{aligned}
\min_{\mathbf{x} \in \mathcal{X}_M} f(\mathbf{x}) - f(\mathbf{x}^{(t)}) &\ge \min_{\mathbf{x} \in \mathcal{X}_M} \mathbf{x}_j \nabla f(\mathbf{x}^{(t)})_j + \sum_{k \ne j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x} - \mathbf{x}^{(t)})_k + \frac{\mu}{2} \|\mathbf{x} - \mathbf{x}^{(t)}\|^2 \\
&\ge \min_{\mathbf{x} \in \mathcal{X}_M} \mathbf{x}_j \nabla f(\mathbf{x}^{(t)})_j + \min_{\mathbf{x} \in \mathcal{X}_M} \sum_{k \ne j} \nabla f(\mathbf{x}^{(t)})_k (\mathbf{x} - \mathbf{x}^{(t)})_k + \min_{\mathbf{x} \in \mathcal{X}_M} \frac{\mu}{2} \|\mathbf{x} - \mathbf{x}^{(t)}\|^2 \\
&\ge M \nabla f(\mathbf{x}^{(t)})_j - g(\mathbf{x}^{(t)}) + \frac{\mu}{2} M^2,
\end{aligned}$$

since the optimum in $\mathcal{X}_M$ has at least the j-th variable at distance M from $\mathbf{x}^{(t)}$. This results in the following modification of inequality (3):

$$\mathrm{UB} - f(\mathbf{x}^{(t)}) \geq M \nabla f(\mathbf{x}^{(t)})_j - g(\mathbf{x}^{(t)}) + \frac{\mu}{2} M^2. \qquad (7)$$

Therefore, if (7) does not hold, i.e.:

$$M \nabla f(\mathbf{x}^{(t)})_j > \mathrm{UB} - f(\mathbf{x}^{(t)}) + g(\mathbf{x}^{(t)}) - \frac{\mu}{2} M^2,$$

we can deduce $\mathbf{x}_j \le \mathbf{1}_j + M - 1$.

□

## Appendix C. Detailed and extended experiments results

In this section, we present a more detailed overview of the computational experiments. Tables 2 to 12 compare the performance of the different solver setups. In addition to the solver listed in Section 4, we present here also the results using SHOT. SHOT is another well established Outer Approximation solver (Lundell et al., 2022; Kronqvist et al., 2016). Observe that SHOT requires the nonlinear objective in expression form and stores it in expression trees. Thus, it explicitly knows the objective and can utilize this knowledge in the problem-solving process.

In contrast, Boscia.jl only has access to the objective and its gradient via an oracle. The oracle structure is useful in cases where the expression format is hard to generate. An example is the A-criterion for Optimal Design Problems which amounts to minimizing the trace of the inverse of a matrix, see Hendrych et al. (2024). This difference in access and knowledge of the objective should be noted then comparing the performance of Boscia.jl to SHOT.

In addition, Hendrych et al. (2024) showcases how combinatorial solution methods can be used as the BLMO within Boscia.jl. Another usage of the solver is in Sharma et al. (2024) which tackles a Network Design Problem. For this problem, instances were also tackled with SCIP directly as a MINLP solver. The experiments showed that SCIP could suffer from numerical instabilities in the LP resulting from the polyhedral approximation (Sharma et al., 2024).

All tables have the same format. The instances for each problem are split into increasingly smaller subsets depending on their minimum solve time, i.e., the minimum time any of the solvers took to solve it. The
cut-offs are at 0 seconds (all problems), took at least 10 seconds to solve, 300 s, 600 s and lastly 1200 s. Note
that if none of the solvers terminates on any instance of a subset, the corresponding row is omitted from the
table. The same procedure applies if there are no changes between rows. For each solver, the relative number
of terminations, the average time and the average relative gap with respect to the lower bound of Boscia.jl
are displayed. The average time is taken using the geometric mean shifted by 1 second. Also, note that this is
the average time over all instances in that group, i.e., it includes the time outs.

In Table 13, we compare the effect of the different dual tightening settings and strong convexity utilization.
Tightening can be performed locally as well as globally. Per default, both local and global tightening are
activated. The tightening of the lower bound via strong branching was only tested on the MIPLIB instances.
As seen in Figure 5, using strong convexity can reduce the number of nodes to be processed and thus the time.
It seems that for instances of small size, however, it is not very effective. The effects of the tightenings differ
between the problem classes. For some examples, local tightening seems to cause computational overhead.
e.g. for the Pure Integer and Mixed Integer Portfolio. On the other hand, for the Sparse Regression Problem,
it has a clear positive effect. For the many problems, using both types of tightening is advisable.

Table 14 showcases the impact of the warm starting settings as well as comparing BPCG to Away-Frank-Wolfe as the node solver. Per default, both the warm start and the usage of the shadow set are activated. The results clearly show that enabling both warm start and the usage of the shadow set is a good choice. Disabling the shadow set can be useful if the BLMO is very cheap like in Hendrych et al. (2024) where the feasible region is simply a scaled probability simplex intersected with a hypercube. In this scenario, both the storing of the shadow set as well as the inner product computation between the gradient and vertices in the shadow set are more expensive compared to the BLMO calls.

Lastly, in Table 15, the performance of the different branching strategies is displayed. As expected, the
most fractional branching rule performs the best. As mentioned before, the nonlinear convexity counteracts
the dual degeneracy. Hence, most fractional branching is a reasonable choice. The partial strong branching
rule is still too expensive as expected. The hybrid strong branching rule with a shallow depth does seem more
promising. Nevertheless, it is time intensive. Our assumption is that problems with a very cheap BLMO
might benefit from this branching rule. Further experiments have to be done.

Figures 14 to 22 showcase the number of terminations over time for, at the top, the different solver setups, and, at the bottom, for the warm start settings and Away-Frank-Wolfe as node solver. In Figures 23 to 26, the progress of the lower bound and the incumbent of the tree are displayed for some instances, on the left with the BLMO calls accumulated and on the right, the BLMO calls per node. Figures 28 to 30 show the evolution in terms of size for the active set, shadow set and the accumulated number of BLMO calls over the node depth. An example of the effect of the tightening is shown in Figure 31. In Figures 33 and 34, the lower bound progress over the number of nodes and time is displayed for the most fractional branching rule, the partial strong branching rule and the hybrid strong branching rule with a depth of # integer variables/20.

The effects of the initial tolerances for the Frank-Wolfe algorithm are shown in Figure 32 by plotting the
total solving time for each pair of initial epsilon and dual gap decay factor. As expected, starting with a high
tolerance and quickly decreasing it is not beneficial.
<figure><img src="image_17.png" /><figcaption>Figure 14: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the MIPLIB 22433 Problem.</figcaption></figure>
<figure><img src="image_18.png" /><figcaption>Figure 15: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the MIPLIB neos5 Problem.</figcaption></figure>
<figure><img src="image_19.png" /><figcaption>Figure 16: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Poisson Regression Problem.</figcaption></figure>
<figure><img src="image_20.png" /><figcaption>Figure 17: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Pure Integer Portfolio Problem.</figcaption></figure>
<figure><img src="image_21.png" /></figure>

<figure><img src="image_22.png" /><figcaption>Figure 18: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Mixed Integer Portfolio Problem.</figcaption></figure>
<figure><img src="image_23.png" /><figcaption>Figure 19: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Sparse Regression Problem.</figcaption></figure>
<figure><img src="image_24.png" /></figure>

<figure><img src="image_25.png" /><figcaption>Figure 20: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Sparse Log Regression Problem.</figcaption></figure>
<figure><img src="image_26.png" /><figcaption>Figure 21: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Tailed Sparse Regression Problem.</figcaption></figure>
<figure><img src="image_27.png" /></figure>

<figure><img src="image_28.png" /><figcaption>Figure 22: Comparing the number of terminations over time for the different solver set-ups and Boscia.jl settings for the Tailed Sparse Log Regression Problem.</figcaption></figure>

<figure><img src="image_29.png" /><figcaption>Figure 23: Progress plot of upper and lower bound for instances of the Sparse Regression Problem. On the left with the accumulated number of BLMO calls, and on the right with the BLMO calls per node.</figcaption></figure>
<figure><img src="image_30.png" /><figcaption>(a) Number of integers variables = 35</figcaption></figure>

<figure><img src="image_31.png" /><figcaption>(b) Number of integers variables = 20</figcaption></figure>

Figure 24: Progress plot of upper and lower bound for instances of the Pure Integer Portfolio Problem. On the left with the accumulated number of BLMO calls, and on the right with the BLMO calls per node.

<figure><img src="image_32.png" /><figcaption>(a) Number of integers variables = 22</figcaption></figure>

<figure><img src="image_33.png" /><figcaption>(b) Number of integers variables = 27</figcaption></figure>

Figure 25: Progress plot of upper and lower bound for instances of the Mixed Integer Portfolio Problem. On the left with the accumulated number of BLMO calls, and on the right with the BLMO calls per node.

<figure><img src="image_34.png" /><figcaption>(a) Number of integers variables 70 and big M = 1.0</figcaption></figure>

<figure><img src="image_35.png" /><figcaption>(b) Number of integers variables = 70 and big M = 10.0</figcaption></figure>

Figure 26: Progress plot of upper and lower bound for instances of the Poisson Regression Problem. On the left with the accumulated number of BLMO calls, and on the right with the BLMO calls per node.
<figure><img src="image_36.png" /><figcaption>Figure 27: Progress plot of upper and lower bound. On the left with the accumulated number of BLMO calls, and on the right with the BLMO calls per node.</figcaption></figure>

<figure><img src="image_37.png" /><figcaption>Figure 28: Evolution of the size of the active and discarded set in Boscia.jl and the accumulated number of BLMO calls for the Sparse Regression Problem with 75 integer variables.</figcaption></figure>
<figure><img src="image_38.png" /><figcaption>Figure 29: Evolution of the size of the active and discarded set in Boscia.jl and the accumulated number of BLMO calls for the Mixed Integer Portfolio Problem with 15 integer variables.</figcaption></figure>

<figure><img src="image_39.png" /><figcaption>Figure 30: Evolution of the size of the active and discarded set in Boscia.jl and the accumulated number of BLMO calls for the Pure Integer Portfolio Problem with 20 integer variables.</figcaption></figure>
<figure><img src="image_40.png" /><figcaption>Figure 31: Comparing the effect of tightening on the lower bound and the accumulated number of BLMO calls for the Mixed Integer Portfolio Problem with 37 integer variables.</figcaption></figure>
<figure><img src="image_41.png" /><figcaption>Figure 32: Comparing the effect of initial tolerance for Frank-Wolfe and dual decay factor on the solving time of the Sparse Regression Problem with 135 integer variables.</figcaption></figure>

<figure><img src="image_42.png" /><figcaption>Figure 33: Comparing the branching strategies on a Sparse Regression instance with 110 integer variables. In the hybrid branching, the depth setting is # integer variables/20 is reached.</figcaption></figure>

<figure><img src="image_43.png" /><figcaption>Figure 34: Comparing the branching strategies on a Pure Integer Portfolio instance with 120 integer variables. In the hybrid branching, the depth setting is # integer variables/20 is reached.</figcaption></figure>
<table><caption>Table 2: The MIPLIB instance 22433 with a quadratic objective. The problem is a mixed binary problem with 231 binary variables and 429 variables in total. We choose between 4 and 8 vertices randomly to form the objective.</caption><thead><tr><th colspan="3">MIPLIB 22433</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>15</td><td>100%</td><td>5.33</td><td>0.0</td><td>100%</td><td>30.32</td><td>0.0</td><td>100%</td><td>1.69</td><td>0.0</td><td>100%</td><td>6.64</td><td>0.0</td><td>100%</td><td>19.77</td><td>0.0</td></tr></tbody></table>

<table><caption>Table 3: The MIPLIB instance neos5 with a quadratic objective. The problem is a mixed binary problem with 53 binary variables and 63 variables in total. We choose between 4 and 8 vertices randomly to form the objective.</caption><thead><tr><th colspan="3">MIPLIB neos 5</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>15</td><td>93%</td><td>30.66</td><td>0.01</td><td>100%</td><td>19.0</td><td>0.01</td><td>33%</td><td>517.4</td><td>0.04</td><td>33%</td><td>460.85</td><td>0.05</td><td>100%</td><td>0.51</td><td>0.01</td></tr></tbody></table>
<table><caption>Table 4: The MIPLIB instance pg5_34 with a quadratic objective. The problem is a mixed binary problem with 100 binary variables and 2600 variables in total. We choose between 4 and 8 vertices randomly to form the objective.</caption><thead><tr><th colspan="3">MIPLIB pg5_34</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>15</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.07</td><td>Inf</td><td>0 %</td><td>1800.04</td><td>0.18</td><td>0 %</td><td>1800.0</td><td>Inf</td><td>80 %</td><td>685.26</td><td>0.01</td></tr><tr><td>300</td><td>13</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.08</td><td>Inf</td><td>0 %</td><td>1800.04</td><td>0.18</td><td>0 %</td><td>1800.0</td><td>Inf</td><td>77 %</td><td>795.4</td><td>0.01</td></tr><tr><td>600</td><td>10</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.08</td><td>Inf</td><td>0 %</td><td>1800.04</td><td>0.18</td><td>0 %</td><td>1800.0</td><td>Inf</td><td>70 %</td><td>896.47</td><td>0.01</td></tr></tbody></table>

<table><caption>Table 5: The MIPLIB instance ran14x18-disj-8 with a quadratic objective. The problem is a mixed binary problem with 252 binary variables and 504 variables in total. We choose between 4 and 8 vertices randomly to form the objective.</caption><thead><tr><th colspan="3">MIPLIB ran14x18-disj-8</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>15</td><td>0 %</td><td>1802.86</td><td>0.09</td><td>0 %</td><td>1800.16</td><td>Inf</td><td>0 %</td><td>1800.09</td><td>0.61</td><td>7 %</td><td>1797.79</td><td>0.01</td><td>100 %</td><td>16.65</td><td>0.04</td></tr><tr><td>10</td><td>13</td><td>0 %</td><td>1802.67</td><td>0.08</td><td>0 %</td><td>1800.18</td><td>Inf</td><td>0 %</td><td>1800.1</td><td>0.65</td><td>8 %</td><td>1797.45</td><td>0.01</td><td>100 %</td><td>18.19</td><td>0.03</td></tr></tbody></table>
<table><caption>Table 6: The Poisson Regression Problem. The instances have between 50 and 100 binary variables and the same number plus 1 of continuous variables.</caption><thead><tr><th colspan="3">Poisson Regression</th><th colspan="2">Boscia</th><th colspan="2">B&B Ipopt</th><th colspan="2">SCIP+OA</th><th colspan="2">Pavito</th><th colspan="2">SHOT</th></tr><tr><th>Solved after (s)</th><th># inst.</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>Time (s)</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>0</td><td>120</td><td>25 %</td><td>406.01</td><td>3.79</td><td>28 %</td><td>516.04</td><td>0.17</td><td><strong>81 %</strong></td><td><strong>81.74</strong></td><td>0.4</td><td>24 %</td><td>885.84</td><td>0.22</td><td><strong>83 %</strong></td><td>297.89</td><td><strong>0.04</strong></td></tr><tr><td>10</td><td>80</td><td>4 %</td><td>1508.16</td><td>6.09</td><td>9 %</td><td>1343.59</td><td>0.26</td><td><strong>80 %</strong></td><td><strong>125.57</strong></td><td>0.58</td><td>32 %</td><td>708.2</td><td>0.24</td><td><strong>91 %</strong></td><td>247.27</td><td><strong>0.05</strong></td></tr><tr><td>300</td><td>7</td><td>0 %</td><td>1800.03</td><td>75.92</td><td>0 %</td><td>1800.27</td><td>0.95</td><td><strong>57 %</strong></td><td><strong>732.71</strong></td><td>3.66</td><td>14 %</td><td>1649.29</td><td>4.91</td><td><strong>100 %</strong></td><td>774.04</td><td><strong>0.2</strong></td></tr><tr><td>600</td><td>2</td><td>0 %</td><td>1800.04</td><td>151.49</td><td>0 %</td><td>1800.25</td><td>1.32</td><td>0 %</td><td>1800.0</td><td>5.24</td><td>50 %</td><td>1325.4</td><td>4.91</td><td><strong>100 %</strong></td><td><strong>1190.21</strong></td><td><strong>0.46</strong></td></tr></tbody></table>
<table><caption>Table 7: The Pure Integer Portfolio Problem. The instances have between 20 and 120 integral variables.</caption><thead><tr><th colspan="3">Pure Integer Portfolio</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved after (s)</th><th># inst.</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>0</td><td>210</td><td>75 %</td><td>236.29</td><td><strong>1.86</strong></td><td><strong>93 %</strong></td><td><strong>26.97</strong></td><td>1.89</td><td>14 %</td><td>1162.41</td><td>54.59</td><td>5 %</td><td>1656.61</td><td>0.01</td><td><strong>100 %</strong></td><td>266.73</td><td>1.89</td></tr><tr><td>10</td><td>138</td><td>62 %</td><td>707.09</td><td><strong>2.94</strong></td><td><strong>90 %</strong></td><td><strong>64.69</strong></td><td>3.05</td><td>0 %</td><td>1800.0</td><td>88.38</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>708.59</td><td>2.99</td></tr><tr><td>300</td><td>26</td><td>0 %</td><td>1800.0</td><td>1.42</td><td><strong>46 %</strong></td><td><strong>985.21</strong></td><td>1.47</td><td>0 %</td><td>1800.0</td><td>1068.68</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1671.56</td><td>1.81</td></tr><tr><td>600</td><td>17</td><td>0 %</td><td>1800.0</td><td>1.41</td><td><strong>18 %</strong></td><td><strong>1598.82</strong></td><td>1.72</td><td>0 %</td><td>1800.0</td><td>2844.43</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1800.0</td><td>2.04</td></tr><tr><td>1200</td><td>15</td><td>0 %</td><td>1800.0</td><td>1.37</td><td><strong>7 %</strong></td><td><strong>1771.51</strong></td><td>Inf</td><td>0 %</td><td>1800.0</td><td>4265.04</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1800.0</td><td>2.08</td></tr></tbody></table>

<table><caption>Table 8: The Mixed Integer Portfolio Problem. The instances have between 20 and 120 variables with half of them being integral variables.</caption><thead><tr><th colspan="3">Mixed Integer Portfolio</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved after (s)</th><th># inst.</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>0</td><td>210</td><td>95 %</td><td>19.47</td><td><strong>0.72</strong></td><td><strong>100 %</strong></td><td><strong>2.82</strong></td><td>38.69</td><td>21 %</td><td>903.36</td><td>10034.36</td><td>60 %</td><td>137.68</td><td>64.96</td><td><strong>100 %</strong></td><td>842.95</td><td>38.69</td></tr><tr><td>10</td><td>12</td><td>42 %</td><td>889.18</td><td>0.36</td><td><strong>92 %</strong></td><td><strong>128.81</strong></td><td><strong>0.19</strong></td><td>0 %</td><td>1800.0</td><td>1919.83</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1750.16</td><td>0.2</td></tr><tr><td>300</td><td>4</td><td>0 %</td><td>1800.0</td><td>0.28</td><td><strong>75 %</strong></td><td><strong>876.48</strong></td><td><strong>0.21</strong></td><td>0 %</td><td>1800.0</td><td>1919.83</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1800.0</td><td><strong>0.21</strong></td></tr><tr><td>600</td><td>3</td><td>0 %</td><td>1800.0</td><td>0.35</td><td><strong>67 %</strong></td><td><strong>1152.68</strong></td><td><strong>0.26</strong></td><td>0 %</td><td>1800.0</td><td>Inf</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1800.0</td><td>0.27</td></tr><tr><td>1200</td><td>1</td><td>0 %</td><td>1800.0</td><td>0.31</td><td>0 %</td><td>1800.0</td><td><strong>0.23</strong></td><td>0 %</td><td>1800.0</td><td>Inf</td><td>0 %</td><td>1800.0</td><td>Inf</td><td><strong>100 %</strong></td><td>1800.0</td><td>0.25</td></tr></tbody></table>
<table><caption>Table 9: The Sparse Regression Problem. The instances have between 150 and 300 variables with half of them being binary variables.</caption><thead><tr><th colspan="3">Sparse Regression</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>160</td><td>92 %</td><td>25.14</td><td>0.01</td><td>86 %</td><td>48.01</td><td>0.01</td><td>1 %</td><td>1720.39</td><td>0.35</td><td>35 %</td><td>547.69</td><td>0.01</td><td>100 %</td><td>252.44</td><td>0.01</td><td>100 %</td><td>252.44</td><td>0.01</td><td>100 %</td><td>252.44</td></tr></tbody></table>

<table><caption>Table 10: The Sparse Log Regression Problem. The instances have between 50 and 200 variables with half of them being binary variables.</caption><thead><tr><th colspan="3">Sparse Log Regression</th><th colspan="3">Boscia</th><th colspan="3">B&B Ipopt</th><th colspan="3">SCIP+OA</th><th colspan="3">Pavito</th><th colspan="3">SHOT</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th></tr></thead><tbody><tr><td>0</td><td>48</td><td>31 %</td><td>387.38</td><td>0.19</td><td>29 %</td><td>592.41</td><td>0.17</td><td>17 %</td><td>665.15</td><td>0.53</td><td>15 %</td><td>1121.07</td><td>0.02</td><td>100 %</td><td>69.9</td><td>0.08</td><td>100 %</td><td>69.9</td><td>0.08</td><td>100 %</td><td>69.9</td></tr></tbody></table>
<table><caption>Table 11: The Tailed Sparse Regression Problem. The instances have 2 or 3 binary variables and 4 to 9 variables in total.</caption><thead><tr><th colspan="3">Tailed Sparse Regression</th><th colspan="3">Boscia</th><th colspan="3">SCIP+OA</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>#<br>nodes<br>cuts</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>#<br>nodes<br>cuts</th></tr></thead><tbody><tr><td>0</td><td>160</td><td>100%</td><td>0.3</td><td>0.0</td><td>59</td><td>49%</td><td>52.59</td><td>0.0</td><td>41</td></tr></tbody></table>

<table><caption>Table 12: The Tailed Sparse Log Regression Problem. The instances have between 20 and 100 binary variables and 60 to 300 variables in total.</caption><thead><tr><th colspan="3">Tailed Sparse Log Regression</th><th colspan="3">Boscia</th><th colspan="3">SCIP+OA</th></tr><tr><th>Solved<br>after<br>(s)</th><th>#<br>inst.</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>#<br>nodes<br>cuts</th><th>%<br>solved</th><th>Time (s)</th><th>Relative<br>Gap</th><th>#<br>nodes<br>cuts</th></tr></thead><tbody><tr><td>0</td><td>48</td><td>100%</td><td>0.85</td><td>0.0</td><td>36</td><td>75%</td><td>129.89</td><td>109.2</td><td>7130</td></tr></tbody></table>
<table><caption>Table 13: Investigating the effect of the tightening settings and exploitation of strong convexity on the performance.</caption><thead><tr><th rowspan="2">Problem</th><th colspan="3">Default</th><th colspan="3">Global Tightening</th><th colspan="3">Local Tightening</th><th colspan="3">No Tightening</th><th colspan="3">Strong Convexity</th></tr><tr><th># inst.</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>MIPLIB 22433</td><td>15</td><td>100%</td><td>5.33</td><td>0.0</td><td>100%</td><td>9.81</td><td>0.0</td><td>100%</td><td>10.26</td><td>0.0</td><td>100%</td><td>10.04</td><td>0.0</td><td>100%</td><td>9.73</td><td>0.0</td></tr><tr><td>MIPLIB neos5</td><td>15</td><td>93%</td><td>30.66</td><td>0.01</td><td>93%</td><td>44.21</td><td>0.01</td><td>93%</td><td>42.82</td><td>0.01</td><td>93%</td><td>45.73</td><td>0.01</td><td>93%</td><td>33.28</td><td>0.01</td></tr><tr><td>MIPLIB pg5_34</td><td>15</td><td>0%</td><td>1800.0</td><td>0.02</td><td>0%</td><td>1800.0</td><td>0.02</td><td>0%</td><td>1800.0</td><td>0.02</td><td>0%</td><td>1800.0</td><td>0.02</td><td>0%</td><td>1800.0</td><td>0.02</td></tr><tr><td>MIPLIB ran14x18-disj-8</td><td>15</td><td>0%</td><td>1802.86</td><td>0.09</td><td>0%</td><td>1804.77</td><td>0.09</td><td>0%</td><td>1804.7</td><td>0.09</td><td>0%</td><td>1804.79</td><td>0.09</td><td>0%</td><td>1804.71</td><td>0.09</td></tr><tr><td>Poisson Regression</td><td>120</td><td>25%</td><td>406.01</td><td>3.79</td><td>25%</td><td>451.8</td><td>0.31</td><td>25%</td><td>447.97</td><td>0.31</td><td>25%</td><td>501.87</td><td>0.31</td><td></td><td></td><td></td></tr><tr><td>Integer Portfolio</td><td>210</td><td>75%</td><td>236.29</td><td>1.86</td><td>83%</td><td>208.29</td><td>1.86</td><td>73%</td><td>312.1</td><td>1.86</td><td>83%</td><td>214.79</td><td>1.86</td><td></td><td></td><td></td></tr><tr><td>Mixed Portfolio</td><td>210</td><td>95%</td><td>19.47</td><td>0.72</td><td>96%</td><td>14.7</td><td>0.17</td><td>95%</td><td>19.67</td><td>0.72</td><td>96%</td><td>16.49</td><td>0.17</td><td></td><td></td><td></td></tr><tr><td>Sparse Regression</td><td>160</td><td>92%</td><td>25.14</td><td>0.01</td><td>90%</td><td>38.81</td><td>0.01</td><td>92%</td><td>26.18</td><td>0.01</td><td>91%</td><td>34.21</td><td>0.01</td><td></td><td></td><td></td></tr><tr><td>Sparse Log Regression</td><td>48</td><td>31%</td><td>387.38</td><td>0.19</td><td>29%</td><td>477.29</td><td>0.24</td><td>29%</td><td>471.22</td><td>0.24</td><td>29%</td><td>446.59</td><td>0.24</td><td></td><td></td><td></td></tr><tr><td>Tailed Sparse Regression</td><td>160</td><td>100%</td><td>0.3</td><td>0.0</td><td>100%</td><td>4.6</td><td>0.0</td><td>100%</td><td>4.35</td><td>0.0</td><td>100%</td><td>5.6</td><td>0.0</td><td></td><td></td><td></td></tr><tr><td>Tailed Sparse Log Regression</td><td>48</td><td>100%</td><td>0.85</td><td>0.0</td><td>100%</td><td>4.78</td><td>0.0</td><td>100%</td><td>4.81</td><td>0.0</td><td>100%</td><td>6.63</td><td>0.0</td><td></td><td></td><td></td></tr></tbody></table>
<table><caption>Table 14: Investigating the effect of the warm start settings on the performance.</caption><thead><tr><th rowspan="2">Problem</th><th colspan="3">Default</th><th colspan="3">Away Frank-Wolfe</th><th colspan="3">No Warm Start No Shadow Set</th><th colspan="3">No Warm Start</th><th colspan="3">No Shadow Set</th></tr><tr><th># inst.</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>MIPLIB 22433</td><td>15</td><td>100 %</td><td>5.33</td><td>0.0</td><td>100 %</td><td>8.74</td><td>0.0</td><td>100 %</td><td>6.6</td><td>0.0</td><td>100 %</td><td>7.45</td><td>0.0</td><td>100 %</td><td>8.57</td><td>0.0</td></tr><tr><td>MIPLIB neos5</td><td>15</td><td>93 %</td><td>30.66</td><td>0.01</td><td>93 %</td><td>49.89</td><td>0.01</td><td>93 %</td><td>43.26</td><td>0.01</td><td>93 %</td><td>49.27</td><td>0.01</td><td>93 %</td><td>43.56</td><td>0.01</td></tr><tr><td>MIPLIB pg5_34</td><td>15</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td></tr><tr><td>MIPLIB ran14x18-disj-8</td><td>15</td><td>0 %</td><td>1802.86</td><td>0.09</td><td>0 %</td><td>1804.68</td><td>0.11</td><td>0 %</td><td>1800.49</td><td>0.13</td><td>0 %</td><td>1803.26</td><td>0.12</td><td>0 %</td><td>1805.01</td><td>0.08</td></tr><tr><td>Poisson Regression</td><td>120</td><td>25 %</td><td>406.01</td><td>3.79</td><td>25 %</td><td>503.92</td><td>0.31</td><td>27 %</td><td>345.31</td><td>0.31</td><td>27 %</td><td>348.17</td><td>0.31</td><td>25 %</td><td>459.33</td><td>0.31</td></tr><tr><td>Pure Integer Portfolio</td><td>210</td><td>75 %</td><td>236.29</td><td>1.86</td><td>48 %</td><td>616.09</td><td>1.87</td><td>67 %</td><td>448.87</td><td>1.88</td><td>70 %</td><td>437.36</td><td>2.24</td><td>75 %</td><td>314.28</td><td>1.86</td></tr><tr><td>Mixed Integer Portfolio</td><td>210</td><td>95 %</td><td>19.47</td><td>0.72</td><td>76 %</td><td>48.11</td><td>1.75</td><td>94 %</td><td>25.59</td><td>0.89</td><td>94 %</td><td>19.46</td><td>0.83</td><td>95 %</td><td>20.24</td><td>0.1</td></tr><tr><td>Sparse Regression</td><td>160</td><td>92 %</td><td>25.14</td><td>0.01</td><td>89 %</td><td>23.25</td><td>0.01</td><td>89 %</td><td>20.13</td><td>0.01</td><td>89 %</td><td>21.4</td><td>0.02</td><td>92 %</td><td>26.35</td><td>0.01</td></tr><tr><td>Sparse Log Regression</td><td>48</td><td>31 %</td><td>387.38</td><td>0.19</td><td>29 %</td><td>469.42</td><td>0.18</td><td>29 %</td><td>428.38</td><td>0.29</td><td>29 %</td><td>411.88</td><td>0.29</td><td>31 %</td><td>472.98</td><td>0.24</td></tr><tr><td>Tailed Sparse Regression</td><td>160</td><td>100 %</td><td>0.3</td><td>0.0</td><td>100 %</td><td>0.97</td><td>0.0</td><td>100 %</td><td>0.36</td><td>0.0</td><td>100 %</td><td>0.35</td><td>0.0</td><td>100 %</td><td>4.33</td><td>0.0</td></tr><tr><td>Tailed Sparse Log Regression</td><td>48</td><td>100 %</td><td>0.85</td><td>0.0</td><td>100 %</td><td>1.36</td><td>0.0</td><td>100 %</td><td>0.77</td><td>0.0</td><td>100 %</td><td>0.84</td><td>0.0</td><td>100 %</td><td>4.8</td><td>0.0</td></tr></tbody></table>
<table><caption>Table 15: Investigating the effect of the different branching strategies on the performance.</caption><thead><tr><th rowspan="2">Problem</th><th rowspan="2"># inst.</th><th colspan="2">Most Fractional Branching</th><th colspan="2">Strong Branching</th><th colspan="2">hybrid branching depth = #int vars/1</th><th colspan="2">hybrid branching depth = #int vars/2</th><th colspan="2">hybrid branching depth = #int vars/5</th><th colspan="2">hybrid branching depth = #int vars/10</th><th colspan="2">hybrid branching depth = #int vars/20</th></tr><tr><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th><th>% solved</th><th>Time (s)</th><th>Relative Gap</th></tr></thead><tbody><tr><td>MIPLIB 22433</td><td>15</td><td>100 %</td><td>5.33</td><td>0.0</td><td>100 %</td><td>9.11</td><td>0.0</td><td>100 %</td><td>9.84</td><td>0.0</td><td>100 %</td><td>9.93</td><td>0.0</td><td>100 %</td><td>10.69</td><td>0.0</td><td>100 %</td><td>9.83</td><td>0.0</td></tr><tr><td>MIPLIB neos5</td><td>15</td><td>93 %</td><td>30.66</td><td>0.01</td><td>93 %</td><td>76.12</td><td>0.01</td><td>93 %</td><td>64.19</td><td>0.01</td><td>93 %</td><td>72.81</td><td>0.01</td><td>93 %</td><td>67.63</td><td>0.01</td><td>93 %</td><td>55.4</td><td>0.01</td></tr><tr><td>MIPLIB pg5_34</td><td>15</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td><td>0 %</td><td>1800.0</td><td>0.02</td></tr><tr><td>MIPLIB ran14x18-disj-8</td><td>15</td><td>0 %</td><td>1802.86</td><td>0.09</td><td>0 %</td><td>1805.62</td><td>0.1</td><td>0 %</td><td>1806.27</td><td>0.1</td><td>0 %</td><td>1806.1</td><td>0.1</td><td>0 %</td><td>1806.04</td><td>0.1</td><td>0 %</td><td>1806.04</td><td>0.1</td></tr><tr><td>Poisson Regression</td><td>120</td><td>25 %</td><td>406.01</td><td>3.79</td><td>25 %</td><td>576.79</td><td>0.34</td><td>25 %</td><td>580.72</td><td>0.34</td><td>25 %</td><td>559.74</td><td>0.34</td><td>25 %</td><td>571.63</td><td>0.33</td><td>25 %</td><td>567.96</td><td>0.32</td></tr><tr><td>Pure Integer Portfolio</td><td>210</td><td>75 %</td><td>236.29</td><td>1.86</td><td>65 %</td><td>449.74</td><td>1.96</td><td>62 %</td><td>459.39</td><td>1.88</td><td>66 %</td><td>454.27</td><td>1.96</td><td>73 %</td><td>342.97</td><td>1.88</td><td>75 %</td><td>315.37</td><td>1.86</td></tr><tr><td>Mixed Integer Portfolio</td><td>210</td><td>95 %</td><td>19.47</td><td>0.72</td><td>96 %</td><td>30.38</td><td>0.38</td><td>96 %</td><td>31.33</td><td>0.41</td><td>96 %</td><td>30.13</td><td>0.39</td><td>95 %</td><td>28.15</td><td>0.48</td><td>95 %</td><td>27.83</td><td>0.94</td></tr><tr><td>Sparse Regression</td><td>160</td><td>92 %</td><td>25.14</td><td>0.01</td><td>85 %</td><td>62.92</td><td>0.01</td><td>85 %</td><td>58.94</td><td>0.02</td><td>85 %</td><td>56.74</td><td>0.02</td><td>86 %</td><td>54.64</td><td>0.02</td><td>91 %</td><td>45.25</td><td>0.02</td></tr><tr><td>Sparse Log Regression</td><td>48</td><td>31 %</td><td>387.38</td><td>0.19</td><td>29 %</td><td>821.55</td><td>0.45</td><td>29 %</td><td>705.96</td><td>0.45</td><td>29 %</td><td>627.81</td><td>0.45</td><td>29 %</td><td>532.43</td><td>0.42</td><td>29 %</td><td>571.82</td><td>0.41</td></tr><tr><td>Tailed Sparse Regression</td><td>160</td><td>100 %</td><td>0.3</td><td>0.0</td><td>100 %</td><td>12.84</td><td>0.0</td><td>100 %</td><td>9.95</td><td>0.0</td><td>100 %</td><td>9.33</td><td>0.0</td><td>100 %</td><td>7.28</td><td>0.0</td><td>100 %</td><td>7.27</td><td>0.0</td></tr><tr><td>Tailed Sparse Log Regression</td><td>48</td><td>100 %</td><td>0.85</td><td>0.0</td><td>100 %</td><td>10.37</td><td>0.0</td><td>100 %</td><td>9.34</td><td>0.0</td><td>100 %</td><td>9.26</td><td>0.0</td><td>100 %</td><td>9.34</td><td>0.0</td><td>100 %</td><td>9.33</td><td>0.0</td></tr></tbody></table>