Implications, conflicts, and reductions for Steiner trees

The Steiner tree problem in graphs (SPG) is one of the most studied problems in combinatorial optimization. In the past 10 years, there have been significant advances concerning approximation and complexity of the SPG. However, the state of the art in (practical) exact solution of the SPG has remained largely unchallenged for almost 20 years. While the DIMACS Challenge 2014 and the PACE Challenge 2018 brought renewed interest into Steiner tree problems, even the best new SPG solvers cannot match the state of the art on the vast majority of benchmark instances. The following article seeks to advance exact SPG solution once again. The article is based on a combination of three concepts: Implications, conflicts, and reductions. As a result, various new SPG techniques are conceived. Notably, several of the resulting techniques are (provably) stronger than well-known methods from the literature that are used in exact SPG algorithms. Finally, by integrating the new methods into a branch-and-cut framework, we obtain an exact SPG solver that is not only competitive with, but even outperforms the current state of the art on an extensive collection of benchmark sets. Furthermore, we can solve several instances for the first time to optimality.

with T ⊆ V (S) such that c(E(S)) is minimized. The SPG is a classic N P-hard problem [23], and one of the most studied problems in combinatorial optimization. Part of its theoretical appeal might be attributed to the fact that the SPG generalizes two other classic combinatorial optimization problems: Shortest paths, and minimum spanning trees. On the practical side, many applications can be modeled as SPG or closely related problems, see e.g. [6,27].
The SPG has seen numerous theoretical advances in the last 10 years, bringing forth significant improvements in complexity and approximability. See e.g. [5,15] for approximation, and [24,29,47] for complexity results. However, when it comes to (practical) exact algorithms, the picture is significantly more bleak. After flourishing in the 1990s and early 2000s, algorithmic advances came to a staggering halt with the (joint) PhD theses of Polzin and Vahdati Daneshmand almost 20 years ago [31,46]. They introduced a wealth of new results and algorithms for SPG, and combined them in an exact solver that drastically outperformed all previous results from the literature. Their work is also published in a series of articles [32][33][34][35][36]. However, their solver is not publicly available.
The 11th DIMACS Challenge in 2014, dedicated to Steiner tree problems, brought renewed interest to the field of exact algorithms. In the wake of the challenge, several new exact SPG solvers were introduced in the literature [13,14,17,30]. Overall, the 11th DIMACS Challenge brought notable progress on the solution of notoriously hard SPG instances that had been designed to defy known solution techniques, see [26,41]. Several of these instances could be solved for the first time to optimality. However, on the vast majority of instances from the literature, Polzin and Vahdati Daneshmand [31,46] (whose solver did not compete at the DIMACS Challenge) stayed out of reach: For many benchmark instances, their solver is even two orders of magnitude or more faster, and it can furthermore solve substantially more instances to optimality-including those introduced at the DIMACS Challenge [37]. In 2018, the 3rd PACE Challenge [4] took place, dedicated to fixed-parameter tractable algorithms for SPG. Thus, the PACE Challenge considered mostly instances with a small number of terminals, or with small tree-width. Solvers that successfully participated in the PACE Challenge are for example described in [18,21]. Still, even for these special problem types, the solver by [31,46] remained largely unchallenged, see e.g. [21].
The following article aims to once again advance the state of the art in exact SPG solution.

Contribution
This article is based on a combination of three concepts: Implications, conflicts, and reductions. As a result, various new SPG techniques are conceived. The main contributions are as follows.
-By using a new implication concept, a distance function is conceived that provably dominates the well-known bottleneck Steiner distance. As a result, several reduction techniques that are stronger than results from the literature can be designed. -We show how to derive conflict information between edges from the above methods. Further, we introduce a new reduction operation whose main purpose is to introduce additional conflicts. Such conflicts can for example be used to generate cuts for the integer programming (IP) formulation. -We introduce a more general version of the powerful so-called extended reduction techniques. We furthermore enhance this framework by using both the previously introduced new distance concept, and the conflict information. -Finally, we integrate the components into a branch-and-cut algorithm. Besides preprocessing, domain propagation, and cuts, also primal heuristics can be improved (by using the new implication concept). The practical implementation is realized as an extension of the branch-and-cut solver SCIP-Jack [14].
The resulting exact SPG solver outperforms the current state-of-the-art solver from [31,46] on many well-established benchmark sets from the literature. Furthermore, it can solve several instances for the first time to optimality.

Preliminaries and notation
We write G = (V , E) for an undirected graph, with vertices V and edges E. We set n := |V | and m := |E|. We denote the vertices and edges of any subgraph S ⊆ G by V (S) and E(S), respectively. For a walk W we likewise denote the set of vertices and the set of edges it contains by V (W ) and E(W ). For any U ⊆ V we define the cut δ(U ) := {{u, v} ∈ E | u ∈ U , v ∈ V \U }. We write δ G (U ) to emphasize that the cut is defined with respect to graph G.
Given edge costs c : E → Q ≥0 , the triplet (V , E, c) is referred to as network. By d(v, w) we denote the cost of a shortest path (with respect to c) between vertices v, w ∈ V . For any (distance) functiond : V 2 → Q ≥0 , and any U ⊆ V we define thẽ d-distance network on U as the network withc({v, w}) :=d(v, w) for all v, w ∈ U . Ifd is the standard distance (i.e.d = d), we write D G (U ) instead of D G (U , d). Note that we write usuallyd(v, w) instead of d ({v, w}). For an SPG instance on a graph G = (V , E) with terminal set T ⊆ V and edge costs c we write (G, T , c) or (V , E, T , c).

The bottleneck Steiner distance
Let P be a simple path with at least one edge. The bottleneck length [11] of P is bl(P) := max e∈E (P) c(e).
Let v, w ∈ V . Let P(v, w) be the set of all simple paths between v and w. The bottleneck distance [11] between v and w is defined as b(v, w) := inf{bl(P) | P ∈ P(v, w)}, with the common convention that inf ∅ = ∞. It holds that b(v, w) = ∞ if and only if v and w are unconnected 1 . Note that b(v, w) is equal to the bottleneck length of the path between v and w on any minimum spanning tree (MST) of (G, c), as observed in [8].
Now consider the distance network D := D G (T ∪{v, w}). Let b D be the bottleneck distance in D. Define the bottleneck Steiner distance or special distance [11] between v and w as The arguably best known bottleneck Steiner distance reduction method is based on the following criterion, which allows for edge deletion [11]. Note the analogy between bottleneck distance applied to the MST problem, and bottleneck Steiner distance applied to the SPG: Any edge e = {v, w} that satisfies b(v, w) < c(e) cannot be part of an MST. Otherwise, e could be replaced by an edge of cost at most b(v, w) to obtain a spanning tree of smaller cost. Any edge e = {v, w} that satisfies s(v, w) < c(e) cannot be part of a minimum Steiner tree. Otherwise, e could be replaced by a path in G corresponding to an edge in D = D G (T ∪ {v, w}) with cost at most b D (v, w). In this case, one would obtain a Steiner tree of smaller cost. We also point out that bottleneck Steiner distances can be computed in polynomial time, but in practice (heuristic) approximations are used. See [33] for a state-of-the-art algorithm.

A stronger bottleneck concept
In the following, we describe a generalization of the bottleneck Steiner distance. Initially, for an edge e = {v, w} define the restricted bottleneck distance b(e) [33] as the bottleneck distance between v and w on (V , E\{e}, c).
The basis of the new bottleneck Steiner concept is formed by a node-weight function that we introduce in the following. For any v ∈ V \T and F ⊆ δ(v) define p + (v, F) := max 0, sup{b(e) − c(e) | e ∈ F, e ∩ T = ∅} . (2) We call p + (v, F) the F-implied profit of v. The following observation motivates the subsequent usage of the implied profit. Assume that p + (v, {e}) > 0 for an edge e ∈ δ(v). If a Steiner tree S contains v, but not e, then there is a Steiner tree S with e ∈ E(S ) such that c(E(S )) + p + (v, {e}) ≤ c(E(S)).
Let v, w ∈ V . Consider a finite walk W = (v 1 , e 1 , v 2 , e 2 , . . . , e r −1 , v r ) with v 1 = v and v r = w. We say that W is a (v, w)-walk. For any k, l ∈ N with 1 ≤ k ≤ l ≤ r define the subwalk W (k, l) := (v k , e k , v k+1 , e k+1 , . . . , e l−1 , v l ). W will be called Steiner walk if V (W ) ∩ T ⊆ {v, w} and v, w are contained exactly once in W (the latter condition could be omitted, but has been added for ease of presentation). The set of all Steiner walks from v to w will be denoted by W T (v, w). With a slight abuse of notation we define δ W (u) := δ(u) ∩ E(W ) for any walk W and any u ∈ V . First, for a Steiner walk W ∈ W T (v, w) define Define the implied Steiner length of W as To understand the usage of the implied Steiner length, consider the SPG instance segment shown in Fig. 1. Assume that edge {v 1 , v 4 } is part of Steiner tree S. Removing this edge from S results in two trees S and S with v 1 ∈ V (S ), v 4 ∈ V (S ). Consider the Steiner walk W : 4 ). Note that p + (v 3 , δ(v 3 )\δ W (v 3 )) = 3, and thus l + p (W ) = 4. We claim that S and S can be reconnected to a Steiner treeS that is of smaller weight than S by using only edges from W . First, assume v 3 is contained in either S or S . In this case, we can use the edges {v 1 , v 2 to reconnect S and S . Second, assume that v 3 is neither contained in S nor in S . In this case, also the edge {v 3 , t 1 } cannot be contained in S or S : Because S is a Steiner tree, we have t 1 ∈ V (S ). Indeed, also {t 1 , v 4 } ∈ E(S ) holds. Reconnect S and S by adding all edges of W that are neither in S nor in S . This procedure results in a Steiner treeS. Next, add edge {v 3 , t 1 } and remove edge {t 1 , v 4 } fromS. This exchange reduces the weight ofS by p + (v 3 , δ(v 3 )\δ W (v 3 )). Thus, the final Steiner treeS satisfies c(E(S)) ≤ c(E(S)) − 1.
Terminals are drawn as squares With the above discussion in mind, define the implied Steiner distance between v and w as Note that s p (v, w) ≤ s(v, w) and that the inequality can be strict. Indeed, (v,w) can become arbitrarily large, as Fig. 2 shows: It holds that s(v 0 , v n ) = n, but s p (v 0 , v n ) = 1. To see the latter, consider the Steiner walk W = The above discussion implies that the following result provides a strictly stronger reduction criterion than Theorem 1.
consists of exactly two connected components. Assume that each connected component contains at least one terminal (otherwise the proof is already finished). In the following, we will use a Steiner walk to reconnectS. First, we show the existence of such a reconnecting Steiner walk that has an implied Steiner length (3) smaller than c(e). Second, we add the edges of this walk toS, obtaining a Steiner tree. Third, we follow the same underlying idea as in the discussion for Fig. 1 and apply edgeexchange operations for each vertex of positive implied profit on the Steiner walk. In this way, the weight ofS is reduced.
Consider a (v, w)-path P in D + such that bl D + (P) = b D + (v, w). Let {t, u} be an edge on P such that t and u are in different connected components ofS (where t and u are considered in the original SPG). LetS t andS u be the connected components of S such that t ∈ V (S t ) and u ∈ V (S u ). By the definition of the bottleneck length it holds that Assume that W is given as ReconnectS t andS u by W (a, b), which yields a connected subgraph S 0 with T ⊆ V (S 0 ). Assume that S 0 is a tree (otherwise remove any redundant edges). 2 It holds that Let Note that all e + i are pairwise disjoint (just as the v + i ).
We claim that S i satisfies (9)- (11). Equality (10) follows from the fact that all e + i are disjoint. And (11) follows from the construction of S i . For (9), observe that by definition of the bottleneck distance it holds that c( Thus, Eq. (8) implies that S i satisfies (9). Finally, set S := S z . Because of (11) it holds that T ⊆ V (S ). Furthermore, one obtains: where the last inequality follows from the initial assumptions.
Furthermore, we define the restricted implied bottleneck Steiner distance s p (v, w) between any v, w ∈ V as the implied bottleneck Steiner distance between v and w in the SPG (V , E\ {{v, w}} , c). One obtains the following corollary.
, then at least one minimum Steiner tree does not contain e. Figure 3 shows a segment of an SPG instance for which Theorem 2 allows for the deletion of an edge, but Theorem 1 does not. The implied bottleneck Steiner distance between the endpoints of the dashed edge is 1-corresponding to a walk along the four non-terminal vertices. The edge can thus be deleted. In contrast, the (standard) bottleneck Steiner distance between the endpoints is 1.5 (corresponding to the edge itself).
Unfortunately, already computing the implied Steiner distance is hard, as the following proposition shows.

Proposition 1 Computing the implied Steiner distance is N P-hard.
The proposition can for example be proved by a reduction from the Hamiltonian path problem, similar to a reduction for the prize-collecting Steiner distance concept in [44]. We note that it would also be possible to use the implied Steiner distance concept introduced in this article to generalize the Steiner distance concept used for the prize-collecting Steiner tree problem; see [39] for a definition that dominates the original one from [44]. However, formulating and proving this generalization is quite technical, and the computational benefit seems limited.
Finally, despite this N P-hardness, one can devise heuristics that provide useful upper bounds on s p . We will discuss one such heuristic in the next section.

Approximating the implied bottleneck Steiner distance
This section describes one of the heuristics we use to delete edges by using an approximation of s p . Starting from a vertex v 0 , the heuristic tries to delete several edges of δ(v 0 ) at once. Initially, define a distance arrayd and a predecessor array pr ed as While Q = ∅ let v := arg min u∈Qd [u]. For all {v, w} ∈ δ(v) proceed as follows. First, set p vw : Note that on the left hand side of (18) a possibly smaller value than p vw is subtracted to prevent the algorithm from circling. Furthermore, note that a terminal might be used more than once for a profit calculation p vw on one walk. However, since we subtract only a bounded part of the profit from the distance value in (18), the algorithm still works correctly. Note that one can extend the algorithm to cover the case of equality for edge deletion. In this case, one also needs to check whether (18) is satisfied with equality if w ∈ N (v 0 ). In practice, one should bound the maximum number of visited edges (in the implementation for this article we simply use a fixed bound). Additionally, one can abort the algorithm if min The above algorithm is also useful for finding a simple path between endpoints of an edge that is not longer than the edge itself. Other authors, e.g. [19,33], suggest to run a shortest path algorithm from both endpoints of each edge of the given SPG for this purpose. However, running the above algorithm from each vertex is usually considerably faster in practice.

Bottleneck Steiner reductions beyond edge deletion
This section discusses applications of the implied bottleneck Steiner distance that allow for additional reduction operations: Edge contraction and node replacement. We start with the former. For an edge e and vertices v, w define b e (v, w) as the bottleneck distance between v and w on (V , E\{e}, c). With this definition, we define a generalization of the classic NSV reduction test from [12].
then there is a minimum Steiner tree S with {v, w} ∈ E(S).
Proof sketch Unfortunately, the use of the implied bottleneck Steiner distance makes the proof of the proposition far more difficult than that of the original result from [12].
To avoid an abundance of technicalities, we therefore only provide a proof sketch. For a detailed proof see the technical report [38]. Assume there is an optimal solution S such that {v, w} / ∈ E(S). Remove from E(S) an edge on the (unique) path between t i and t j in S of maximum cost. This operation results in two disjoint trees: S i with t i ∈ S i and S j with t j ∈ S j . By definition of b {v,w} (t i , t j ) it holds that Now the sketchy part starts: Similar to the proof of Theorem 2, condition (19) allows us to connect S i to v such that the resulting treeS i satisfies Equivalently, we can connect S j to w with the result satisfying However, the above is only true, because the two Steiner walks that correspond to s p (v, t i ) and s p (w, t j ) in (21) and (22), respectively, have no vertex in common. If they had a vertex in common, one could build a new Steiner walk W 0 with l + p (W 0 ) ≤ s p (v, t i ) + s p (w, t j ) out of the two above Steiner walks, such that W 0 connects S i and S j . This walk W 0 could then be used to reconnect S i and S j to a Steiner tree of weight smaller than b {v,w} (t i , t j ).
Finally, we defineS as the union ofS i ,S j , and {v, w}. This connected subgraph is not necessarily a tree, but can be made one without increasing c(E(S)) by deleting an edge from each cycle. From (20), (21), and (22) it follows that c(E(S)) ≤ c(E(S)), which concludes the proof.
If criterion (19) is satisfied, one can contract edge {v, w} and make the resulting vertex a terminal. The original criterion from [12] uses the standard distance in (19) instead of the implied bottleneck Steiner distance. We note that using the (standard) bottleneck Steiner distance in (19) does not improve the original test. However, using the implied bottleneck Steiner distance leads to a strictly stronger criterion, as the example in Fig. 4 shows.
The following proposition allows one to identify edges that are candidates for edge contraction. Afterwards, the bottleneck distances can be computed for all these edges in O(m + n log n) amortized time [9]. Proposition 3 Let {v, w} ∈ E and t i , t j ∈ T , t i = t j . If (19)  Proof Assume there is a spanning tree S such that {v, w} / ∈ S. Remove from E(S) an edge on the (unique) path between t i and t j in S of maximum cost. By definition of b {v,w} (t i , t j ) it holds that This operation results in two disjoint trees: S i with t i ∈ S i and S j with t j ∈ S j . If v and w are in different trees, one can add {v, w} to connect S i and S j and obtain a spanning tree of no higher cost than S. Otherwise, assume that Thus, one can add both { p, q} and {v, w} to S i , S j to obtain a connected spanning subgraph S . Because of condition (19) and (23) it holds that Delete any edge other than {v, w} on the cycle in E(S ) that includes {v, w}. In this way one obtains a spanning tree S of no higher cost than S.
This section closes with a reduction criterion based on the standard bottleneck Steiner distance. Besides being a new technique, this result also serves to highlight the complications that arise if one attempts to formulate similar conditions based on the implied bottleneck Steiner distance. Let v ∈ V \T . If for all Δ ⊆ δ(v) with |Δ| ≥ 3 it holds that: then there is at least one minimum Steiner tree S such that |δ S (v)| ≤ 2.
The proposition follows from Corollary 3, which we will introduce in Sect. 4.2. If the conditions (24) are satisfied for a vertex v ∈ V \T , one can pseudo-eliminate [12] or replace [31] vertex v, i.e., delete v and connect any two vertices u, w ∈ N (v) by a new edge {u, w} of weight c({v, u}) + c({v, w}). The SPG depicted in Fig. 5 exemplifies why Proposition 4 cannot be formulated by using the implied Steiner distance. The weight of the minimum spanning tree Y for D G (T , d) is 4, but the weight of a minimum spanning tree with respect to the implied bottleneck Steiner distance is 2. Similarly also the B D m reduction technique from [12] cannot be directly formulated by using the implied bottleneck distance. Still, it is possible to formulate a similar criterion that makes use of the implied bottleneck distance. Unfortunately, both the result and the corresponding proof are more involved than those of their edge elimination counterparts (see Theorem 2). Thus, we omit the details here. The important point is to make sure that the selected Steiner walks do not overlap at vertices with a positive implied profit. However, these techniques have not been implemented yet.

From reductions to conflicts
This section shows an additional advantage of the just introduced node replacement reduction: The creation of conflicts between the newly inserted edges. Furthermore, a new replacement operation is introduced. We say that a set E ⊆ E with |E | ≥ 2 is in conflict if no minimum Steiner tree contains more than one edge of E .

Node replacement
Recall that we have seen three types of reductions so far: Edge deletion, edge contraction, and node replacement. For simplicity, we assume in the following that a reduction is only performed if it retains all optimal solutions. For example, we only delete an edge if we can show that there is no minimum Steiner tree that contains this edge. We say that such a reduction is valid. We start with an SPG instance I = (G, T , c), and consider a series of subsequent, valid reductions (of one of the three above types) that are applied to I . In each reduction step i ≥ 0, the current instance . We set I (0) := I . We define ancestor information for each i = 0, 1, . . . , k by Π (i) : E (i) → P(E) and Consider a reduced instance I (i) . If we contract an edge e ∈ E (i) , we set Π (i+1) Overall, one observes the following.

Observation 1 Let I be an SPG and let I (k) be the SPG obtained from performing a series of k valid reductions on I . For any Steiner tree S (k) for I (k) , the tree S with
is a Steiner tree for I , and it holds that Furthermore, if S (k) is optimal for I (k) , then S is optimal for I . [34] observed that two edges that originate from a common edge by a series of replacements cannot both be contained in a minimum Steiner tree. Using the above notation, we can formulate the condition as follows: If e 1 , e 2 ∈ E (k) satisfy Π (k) (e 1 )∩ Π (k) (e 2 ) = ∅, then there is no minimum Steiner tree that contains both e 1 and e 2 . As we will see in Sect. 4, such conflict information can be used for further reductions.
In the following, we will introduce an edge conflict criterion that is strictly stronger than the one from [34]. Initially, we define additional ancestor information for each i = 0, 1, . . . , k. Namely, sets of replacement ancestors Λ (i) : E (i) → P(N), and Λ If no node replacement is performed, we set λ (i+1) := λ (i) .

Proposition 5
Let I be an SPG and let I (k) be the SPG obtained from performing a series of k valid reductions on I . Further, let e 1 , e 2 ∈ E (k) . If Λ (k) (e 1 ) ∩Λ (k) (e 2 ) = ∅, then no minimum Steiner tree S (k) for I (k) contains both e 1 and e 2 .
Proof Suppose that there is a minimum Steiner tree S (k) with e 1 , e 2 ∈ E (k) (S (k) ). Let x ∈ Λ (k) (e 1 ) ∩ Λ (k) (e 2 ). Let i be the first reduction iteration with λ (i) = x. We may assume that i = 1. Otherwise, we can define additional ancestor information Π and Λ starting from I (i−1) , and perform the reductions from iteration i to iteration k. Let v be the vertex that is replaced in iteration i = 1. Note that x = λ (1) = 1. From Observation 1 we know that the tree S defined by E(S) = e∈E (k) Π (k) (e) ∪ Π (k) F I X is a minimum Steiner tree for I . However, because of λ (1) ∈ Λ (k) (e 1 ) ∩ Λ (k) (e 2 ), we have that Π (k) (e 1 ) ∪ Π (k) (e 2 ) ∩ δ S (v) ≥ 3. This implies however, that replacing v is not valid-a contradiction. Note that any edge e as in Corollary 2 can be deleted.

Edge replacement
This subsection introduces a new replacement operation, whose primary benefit lies in the conflicts it creates. We start with a condition that allows us to perform this operation.
For any Δ ∈ D let

If for all Δ ∈ D with |Δ| ≥ 3 the weight of a minimum spanning tree on D G (U Δ , s) is smaller than c(Δ), then each minimum Steiner tree S satisfies |δ
The proposition can be proven by using Corollary 3, which will be introduced in Sect. 4. If the condition of Proposition 6 is successful, we can perform what we will call a path replacement of e: We delete e and add for each pair p, At first glance, the apparent increase in the number of edges by this operation seems highly disadvantageous. However, due to the increased weight, the new edges can often be deleted by using the criterion from Theorem 2. Furthermore, an edge does not need to be inserted if any two of the three edges it originates from have a common replacement ancestor. Indeed, we only perform a path replacement if at most one of the new edges needs to be inserted. The case that all new edges can be deleted is in principle also covered by the extended reduction technique introduced in the next section (albeit being potentially far more expensive). If exactly one new edge remains, we create new replacement ancestors as follows: Letê = {p, q} be the newly inserted edge. Initially, One can show that Proposition 5 remains valid if path replacement is added to the list of valid reduction operations. Figure 6 illustrates an application of Proposition 6. In this example, all but one replacement edges can be deleted by using a simple alternative path argument. While the number of edges remains unchanged, six new conflicts are created.

From Steiner distances and conflicts to extended reduction techniques
At the end of the last section we have seen a reduction method that inspects a number of trees (of depth 3) that extend an edge considered for replacement. This section continues along this path, based on the reduction concepts introduced so far. Given a tree Y (e.g. a single edge), extended reduction techniques use an enumeration of trees that contain Y to show that there is an optimal Steiner tree that does not contain Y . The trees are built by iteratively enlarging or extending Y . During this process, reduction, conflict, and implication techniques are employed to rule out these extensions of Y . In this way, extended reduction techniques are loosely related to the concepts of probing and conflict (graph) analysis for mixed-integer programming (MIP), see e.g. [1,42].
The idea of extension was first introduced in [48] for the rectilinear Steiner tree problem. Later the idea was adopted by [45] for the SPG. The next advancement came in [10], where backtracking was used, together with a number of new reduction criteria for the enumerated trees. Finally, [34] introduced the up-to-now strongest extended reduction techniques, which improved and complemented the previous results. The authors showed that their sophisticated algorithm could drastically reduce the size of many benchmark SPG instances, and even allowed for the solution of previously intractable instances.
In the following, we introduce new extended reduction algorithms that (provably) dominate those by [34].

The framework
For a tree Y in G, let L(Y ) ⊆ V (Y ) be the set of its leafs. We start with several definitions from [34]. Figure 7 exemplifies this concept. To motivate those definitions, consider a path Q without inner terminals between vertices v and w. For Q to not be peripherally contained in a minimum Steiner tree it is sufficient that s(v, w) is smaller than the weight of Q. However, this condition is not sufficient to show that Q is not contained in a minimum Steiner tree. However, if Q is indeed contained in a minimum Steiner tree, at least one of its inner vertices needs to be of degree greater 2 in this tree. Thus, we can exploit this observation to enumerate extensions of Q from those inner vertices and attempt to rule those extensions out. Such kind of deductions are used in extended reduction techniques. For any P ⊆ V (Y ) with |P| > 1 let Y P be the union of the (unique) paths between any v, w ∈ P in Y . Note that Y P is a tree, and that Y P ⊆ Y holds. P is called pruning set if it contains the linking set between Y P and Y . Additionally, we will use the following new definition: P is called strict pruning set if it is equal to the linking set between Y P and Y . Figure 8 provides an example of pruning and strict pruning sets. One readily verifies the following property of pruning sets.

Observation 2 Let Y be a tree, and let Y ⊆ Y be a tree that is peripherally contained in Y . Further, let P ⊆ V (Y ).
If P is a pruning set for Y , then P is also a pruning set for Y . If P is a strict pruning set for Y , then P is also a strict pruning set for Y .
Additionally, we define a stronger, and new, inclusion concept. Consider a tree Y ⊆ G, and a subtree Y . Let P be a pruning set for Y . We say that Y is Pperipherally contained in Y if P is a pruning set for Y . Now let P be a strict pruning set for Y . We say that Y is strictly P-peripherally contained in Y if P is a strict pruning set for Y . From Observation 2 one obtains the following important property.

Observation 3 Let Y ⊆ G be a tree, let Y ⊆ Y be a subtree, and let P be a pruning set for Y . If Y is peripherally contained in Y , then Y is also P-peripherally contained in Y .
In fact, we will use the contraposition of the observation: If Y is not P-peripherally contained in Y , then Y is not peripherally contained in Y . Note that an equivalent property holds for strict pruning sets.
Given a tree Y and a set E ⊆ E, we write with a slight abuse of notation Y + E for the subgraph with the edge set E(Y ) ∪ E . Algorithm 1 shows a high level description of the extended reduction framework used in this article. The framework is similar to the one introduced in [34], but more general. 3 Note that the algorithm is recursive.
A possible input for Algorithm 1 is an SPG instance together with a single edge. If the algorithm returns true, the edge can be deleted. Besides ExtensionSets, which is described in Algorithm 2, the extended reduction framework contains the following subroutines: The routine returns true if Y is shown to not be P-peripherally contained in any minimum Steiner tree. Otherwise, the routine returns f alse.
The routine returns true if Y is shown to not be strictly P-peripherally contained in any minimum Steiner tree. Otherwise, the routine returns f alse. The usage of P-peripheral inclusion in RuledOut might appear somewhat awkward, but is necessary for ruling-out not only trees (as in line 2 of Algorithm 1), but also all possible extension via a single edge (as in line 4 of Algorithm 2). We explain the extended reduction framework via an example at the end of Sect. 4.2.
In Lines 1-3 of Algorithm 1, we try to peripherally rule-out tree Y . If that is not possible, we try to recursively extend Y in Lines 5-14. Since (given positive edge weights) no minimum Steiner tree has a non-terminal leaf, we can extend from any of the non-terminal leaves of Y . Note that ruling-out all extensions along one single leaf is sufficient to rule-out Y . The correctness of Extended-RuledOut can be proven by induction (under the assumption that the subroutines are correct). We also remark that it is under certain conditions possible to replace the condition not peripherally contained in any minimum Steiner tree by the condition not peripherally contained in at least one minimum Steiner tree. See also the discussion following Theorem 3.

Algorithm 1: Extended-RuledOut
true if Y is shown to not be peripherally contained in any minimum Steiner tree; f alse

Algorithm 2: ExtensionSets
peripherally contained in any minimum Steiner tree. Although the extended reduction framework shown in Algorithm 1 looks simple, an efficient realization is highly intricate. Not least, because the interaction of many different algorithmic components needs to be taken into account. Also, the re-use of intermediate results obtained during the tree extension (such as bottleneck Steiner distances) is non-trivial.
We just note here that we have only implemented extensions in a depth-first-search manner: We extend only from leaves that are farthest away from the initial tree Y . A stronger, but potentially more expensive, alternative is to employ full backtracking, as partially done in [34]. In the following, we concentrate on mathematical descriptions of the subroutines for ruling-out enumerated trees.

Reduction criteria
In this section we introduce several elimination criteria used within RuledOut and RuledOutStrict. In fact, both of these routines consist of several subalgorithms that check different criteria for eliminating the given tree. Note that any criterion that is valid for RuledOut is also valid for RuledOutStrict. We also note that several of the criteria in this section are similar to results from [31,34], but are all stronger. Throughout this section we consider a graph G = (V , E) and an SPG instance I = (G, T , c).
Consider a tree Y ⊆ G, and a pruning set be the graph obtained from G = (V , E) by contracting for each p ∈ P the subtree Y p into p. For any parallel edges, we keep only one of minimum weight. We identify the Finally, let s Y ,P be the bottleneck Steiner distance on (G Y ,P , T Y ,P , c Y ,P ). With these definitions at hand, we are able to formulate a reduction criterion that generalizes a number of results from the literature. See [19,31] for similar, but weaker, conditions. Theorem 3 Let Y ⊆ G be a tree, and let P be a pruning set for Y such that V (Y P )∩T ⊆ L(Y P ). Let I Y ,P be the SPG on the distance network D G Y ,P V Y ,P , s Y ,P with terminal set P. If the weight of a minimum Steiner tree for I Y ,P is smaller than c(E(Y P )), then Y is not P-peripherally contained in any minimum Steiner tree for I .
Proof Let S be a (not necessarily minimum) Steiner tree for I such that Y is Pperipherally contained in S. Let S Y ,P be a minimum Steiner tree for I Y ,P . The underlying idea of the proof is as follows: First, we remove Y P from S. Next, we interconnect all vertices in P. Because of the assumptions of the theorem, this procedure also reconnects S. To obtain a tree that is of smaller weight than S, we use only edges for the reconnection that correspond to edges of S Y ,P .
LetS ⊂ G be the forest defined as follows: LetC be the set of connected components ofS. Further, let f : Note that each C ∈C contains at least one vertex of P, and thus also at least one vertex of S Y ,P . Also, . Further, note that for each of the contracted subtrees Y p there is aC ∈C with Y p ⊆C. In the following, we will iteratively connect all the components inC .
As long as such a path Q exists, proceed as follows. Add Q toS, and remove from E(S Y ,P ) an (arbitrary) edge of the path between f (q) and f (r ) in S Y ,P . Also, updateC and f . Note that the weight of the removed edge (with respect to s Y ,P ) is at most s Y ,P (q, r ).
Once |C | = 1, one notes that the summed up weight of all newly inserted paths (with respect to c) does not exceed the weight of S Y ,P (with respect to s Y ,P ). Because the weight of S Y ,P is smaller than c(E(Y P )), we obtain from the construction ofS that which concludes the proof.
In practice, one does not need to explicitly form G Y ,P . Instead, one can use the (original) bottleneck Steiner distances between the connected components of the graph induced by E(Y )\E(Y P ). Note that one can also extend Theorem 3 to the case of equality if at least one vertex of Y P is not contained in any of the paths corresponding to the s values used for edges of S Y ,P . However, in the context of extended reduction techniques one needs to be careful to not discard all of several equivalent extensions. We omit the quite technical details, but merely note that allowing for equality (and adding suitable checks) can have a significant impact for some instances.
In practice, computing a minimum Steiner tree (or even an approximation) on D G Y ,P V Y ,P , s Y ,P is often too expensive. In such cases, the following corollary provides a strong alternative. Corollary 3 Let Y , P as in Theorem 3. Let (P , P ) be a partition of P. Let F be an MST on D G Y ,P P , s Y ,P , and let z be the weight of F . Let F be an , then Y is not P-peripherally contained in any minimum Steiner tree for I .
Proof First, note that if P = ∅, then the corollary follows directly from Theorem 3, because z is a lower bound on the weight of a minimum Steiner tree in I Y ,P . Thus, we assume P = ∅ in the following.
Suppose there is a minimum Steiner tree S for I such that Y is P-peripherally contained in S. DefineS as in the proof of Theorem 3. Further, proceed as in the proof of Theorem 3 to reconnect all connected components ofS that contain a vertex from P . As a result,S has at most |P | + 1 connected components. Because S is assumed to be optimal, each connected component ofS contains at least one terminal. Thus, we can reconnect the remaining connected components similarly to Theorem 3, by using paths corresponding to edges of F . We need to add at most |P | such paths. Overall, we have increased the weight ofS by at most z which contradicts the optimality of S.
As for Theorem 3, the contractions in Corollary 3 should only be performed implicitly in practice. Furthermore, one requires a careful implementation to avoid a recomputation from scratch of the two minimum spanning trees in Corollary 3 for each enumerated tree in Algorithm 1.
Next, let Y ⊆ G be a tree with pruning set P, and let v, w ∈ V (Y ) and let Q be the path between v, w in Y . We define a pruned tree bottleneck between v and w as a subpath Q(a, b))). The weight c(V (Q(a, b))) of such a pruned tree bottleneck is denoted by b Y ,P (v, w). Using this definition and the implied bottleneck Steiner distance, we obtain the following result.

Proposition 7 Let Y be a tree, let P be a pruning set for Y , and let
, then Y is not P-peripherally contained in any minimum Steiner tree.
The proposition can be proven in a similar way as Theorem 2 (and is indeed a generalization of the latter).
Based on the SPG instance in Fig. 9, we demonstrate the usage of the extended reduction framework and the above reduction criteria in the following. We aim to replace (or pseudo-eliminate) vertex v 3 . To show that this operation is valid, we prove that the tree is not peripherally contained in any minimum Steiner tree. We call Algorithm 1 with Y as defined above. We are neither able to rule out Y in Line 2, nor do we truncate the search in Line 4. In Line 5, we consider vertex v 5 and mark it as promising. The extension sets obtained from Algorithm 2 are: We (recursively) call Algorithm 1 for each of these three extensions in Line 8.
First, we consider the extension via the edge {t 2 , v 5 }. The tree Y := Y + {{t 2 , v 5 }} with pruning set P = {t 1 , t 2 , v 2 } can be shown to not be P-peripherally contained in a minimum Steiner tree by using Proposition 7: It holds s p (t 1 , t 2 ), where the pruned tree bottleneck corresponds to the edges {v 3 , v 5 } and {t 2 , v 5 }.
Next, we consider the extension via the edge {v 4 , v 5 }. We are not able to rule out this extension, and thus extend the tree Y := Y + {{v 4 , v 5 }} from vertex v 4 . The extension Fig. 9 Segment of a Steiner tree instance. Terminals are drawn as squares. By using the extended reduction framework, one can show that vertex v 3 can be replaced In summary, all extensions of the initial tree Y along vertex v 5 are ruled out in the first call of Algorithm 1. Thus, the algorithm returns true, which implies that vertex v 3 can be replaced.
Another criterion can be devised by using the reduced costs of the well-known bidirected cut formulation [50] for SPG. This formulation is based on the observation that any optimal Steiner arborescence for the bidirected equivalent of a given SPG instance with arbitrary root r ∈ T corresponds to an optimal Steiner tree for the original SPG. Let D = (V , A) be the bidirected equivalent of G, and let r ∈ T . Consider a dual solution for the bidirected cut formulation, with reduced costsc, and with objective valueL. Further, for any v, w ∈ V , letd(v, w) be the length for a shortest, directed path from v to w in A with respect to the reduced costs. From the observation that an optimal Steiner arborescence cannot contain any cycles, we obtain the following result with standard linear programming arguments: Proposition 8 Let Y be a tree. Let P = {p 1 , . . . , p k } be a strict pruning set for Y such that there is a k ≤ k with p i ∈ T if and only if i > k . Further, assume that V (Y P ) ∩ T ⊆ L(Y P ), and |P| < |T |. The weight of any Steiner tree that strictly P-peripherally contains Y is at least Given an upper bound on the cost of a minimum Steiner tree, this proposition can be used in the RuleOutStrict routine. In practice, we only use a lower bound on the max subterm in (27). Finally, another important reduction criteria is constituted by edge conflicts-this result follows directly from Proposition 5.

Corollary 4
Let I (k) be an SPG obtained from performing a series of k valid reductions on an SPG I . Let Y ⊆ G (k) be a tree, and let P a pruning set for Y . If there are distinct edges e 1 , e 2 ∈ E (k) (Y ) such that Λ (k) (e 1 )∩Λ (k) (e 2 ) = ∅, then Y is not P-peripherally contained in any minimum Steiner tree.

Exact solution
This section describes how to use the techniques introduced so far for the exact solution of SPG. The new methods have been implemented as an extension of the branch-andcut solver SCIP-Jack [14].

Branch-and-cut
As shown in [33], reduction techniques are the most important ingredient in a state-ofthe-art SPG solver. While [33] uses linear programming and branch-and-bound mostly to trigger further reductions, we employ a proper branch-and-cut approach, based on [14]. On a high level, the solution process of SCIP-Jack can be naturally divided into three phases.
First, the presolving phase. Here, reduction techniques (combined with primal and dual heuristics) are employed to decrease the problem size. As can be seen in Sect. 5.2 and in the detailed results in the appendix, many instances are already drastically reduced in this phase.
Second, the linear programming (LP) based separation phase at the branch-andbound root node. SCIP-Jack employs a specialized separation algorithm, see e.g. [14], to compute lower bounds based on the well-known bidirected cut formulation [50]. Additionally, several specialized methods such as primal heuristics and domain propagation are employed. For domain propagation, we also employ a modified version of the extended reduction techniques that makes use of the reduced costs from the LPrelaxation.
Third and finally, a branch-and-bound search is initiated, with the branching being done on the vertices of the graph. In this phase, again primal heuristics and domain propagation are employed. However, SCIP-Jack aims to avoid the branch-and-bound search, and puts much effort into the root node. Indeed, fewer than five percent of the instances used in this article require branching.
We enhance several vital components of this branch-and-cut framework. The most natural application of reduction methods is within presolving. However, one can also use them within domain propagation, translating the deletion of edges into variable fixings in the integer programming model. However, in our implementation the reduction methods are employed far less aggressively in domain propagation than in presolving (so also the time spent in domain propagation is usually less than 10 percent of the time spent in presolving). The edge conflicts described in this article are used for generating clique cuts, which are well-known for general MIPs [2]. We note, however, that the impact of these cuts on the overall solution time is small; even for instances with many edge conflicts the obtained speed-up is usually only a few percent. Finally, also primal heuristics are improved. First, the stronger reduction methods enhance primal heuristics that involve the solution of auxiliary SPG instances, such as from the combination of several Steiner trees. Second, the implication concept introduced in this article can be used to directly improve a classic SPG heuristic, as shown in the following.

Implications and the shortest path heuristic
The simple 2-approximation for SPG introduced by [43] has been widely used in the literature and is perhaps the best known primal heuristic for SPG. The algorithm starts with a tree S consisting of a single vertex and iteratively connects S by a shortest path to a terminal closest to S. As a simple postprocessing step, one can compute a minimum spanning tree on (V (S), E[S]) and iteratively remove nonterminal leaves. An efficient implementation is given in [3]. This section shows how to use the implication concept introduced in Sect. 2.2 to (empirically) improve the algorithm.
Let If v ∈ T , add the path P from v to S, marked by the predecessor array, to S, add V (P) to Q, and setd[u] := 0 for all u ∈ V (P). Furthermore, update (28). For all {v, w} ∈ δ(v) proceed as follows. If then setd[w] to the left hand side of (29), and add w to Q. Further, set pr ed[w] := v. Note that (29) provides a bias for paths computed by the heuristic to include vertices of implied profit. In this way, the distance associated with a path also reflects the cost needed to connect additional terminals later on. Note that the minimum spanning tree computed during postprocessing will always contain the edge associated with each vertex of positive implied profit contained in S. We use the value min e ∈δ(w)\{e} c(e ) instead of b(e) for e = {v, w}, w ∈ T in (28) for two reasons: First, the value better represents the weight that can be saved when connecting w via v (because the bottleneck edge corresponding to b(e) might already be part of the tree computed by the heuristic so far). Second, this value is much faster to compute (and the primal heuristic is executed often as a subroutine within our implementation).
Computational experiments on the benchmark instances from the next section have shown that the above modifications improve the solution quality of the shortest path heuristic in a surprisingly consistent manner: When run 100 times from different starting points after SPG presolving (as is the default in SCIP-Jack), the solution quality of the heuristic is improved for more than 85 % of the instances. We also note that the shortest path heuristic is used as a subroutine in several more involved heuristics applied by SCIP-Jack, see [14].

Computational results
This section provides computational results for the new solver. In particular, we compare its performance with the updated results of the solver by [31,46] published in [37]. The computational experiments were performed on Intel Xeon CPUs E3-1245 with 3.40 GHz and 32 GB RAM. According to the DIMACS benchmark software [7], this computer is 1.59 times faster than the machine used in [37] 4 . While the authors of the current article do not have access to the machine used in [37], preliminary experiments on different machines have shown that the DIMACS score is a good estimate for the performance of the new solver. Thus, we have scaled the run-times reported in the following accordingly, by multiplying the run-times of SCIP-Jack by 1.59. We use the same LP solver as [37]: CPLEX 12.6 [20]. All results were obtained single-threaded.
For the comparison with the solver by [31,46], we are restricted to the instances used in [37]. Still, the experiments in [37] include a large number of test-sets (both the SteinLib and the 11th DIMACS Challenge collection). Thus, we only use test-sets with at least one instance that takes more than 10 s to be solved by [37] or our solver. There is one notable exception: We do not consider the test-sets I320 and I640 from the SteinLib; for the following reason: [37] use specialized, non-default settings for several test-sets, including I320 and I640, where they use only "(…) fast calculation of bounds (…)" during branch-and-bound. As we aim to give an unbiased picture of the performance of our solver, we only use our default settings for all instance sets. While we can achieve significant speed-ups on all tests-sets when using specialized settings, the impact is by far strongest on the I instances-more than an order of magnitude for the harder instances. We note, however, that we can match the results from [37] on I320 and I640 if we use dual-ascent bounds during branch-and-bound, instead of LP-based ones.
An overview of the test-sets is given in Table 1. The second column gives the number of instances per test-set. The third and fourth columns give the range of nodes and edges per test-set. The fifth column states whether for all instances of the test-set optimal solutions are known.

Impact of implied profit reductions
In the following, the impact of the s p based reduction methods on the preprocessing strength is reported. For the reduced cost based reductions we use the dual-ascent heuristic from [50]. We use seven benchmark sets from the literature; three from the DIMACS Challenge, three from the SteinLib, and one from [22]. Table 2 shows in the first column the name of the test-set, followed by its number of instances. The next columns show the percentual average number of nodes and edges of the instances after the preprocessing without (column three and four), and with (columns five and six) the s p based methods. The last two columns report the percentual relative change between the previous results.
It can be seen that the s p methods allow for a significant additional reduction of the problem size. This behavior is rather remarkable, given the variety of other powerful reduction methods included in SCIP-Jack. Even if the percentage of remaining edges and nodes is already small on average for the base processing (such as for VLSI), there are for each of the seven test-sets at least a few instances that are still of large size. These instances can often be significantly reduced by the s p techniques. While no run times are reported in the table, we note that on each of the seven test-sets the overall run time of the preprocessing (often significantly) decreases when the s p based methods are used. Furthermore, even for other test-sets where the s p methods are less (or not at all) successful, one does not observe an increase in the run time of the preprocessing above 10 percent.

Comparison with the state of the art
Next, we compare the solver by Polzin and Vahdati Daneshmand [31,46] and the new solver SCIP-Jack with respect to the mean time, the maximum time, and the number of solved instances. For the mean time we use the shifted geometric mean with a shift of 10. We note that the use of an arithmetic mean would bias strongly in favor of SCIP-Jack, which is especially faster on harder instances. Table 3 provides the results for a time-limit of 24 h (divided by 1.59 in the case of SCIP-Jack), which is the same time-limit as used in the updated report [37]. The second column shows the number of instances in the test-set. Column three gives the number of instances solved by [37], column four the number of instances solved by SCIP-Jack. Column five shows the mean time taken by [37], column six shows the mean time of SCIP-Jack. The next column gives the relative speedup of SCIP-Jack. The last three columns provide the same information for the maximum run-time.
It can be seen that SCIP-Jack consistently outperforms [37]-both with respect to mean and maximum time. Also, SCIP-Jack solves on each test-set at least as many instances as [37]. The only test-set where [37] prevail is VLSI. On this test-set the results of the extended reductions reported in [31] are also stronger, which might be attributed to the use of full-backtracking, which has not yet been implemented in SCIP-Jack.  On the other test-sets, the difference in the run-time is especially apparent for the maximum run time. This behavior can be explained by the fact that most test-sets contain many instances that can be solved very fast by both solvers-which brings the mean times closer together. Prominent examples are the SP and Copenhag14 test-sets, for which all instances can be solved by SCIP-Jack within roughly 1 h, whereas [37] leave several instances unsolved even after 24 h.
As already mentioned, most test-sets in Table 3 contain a large number of instances that can be solved by both [37] and our solver in well below 1 s. To mitigate the impact of very easy instances on the average times, we group the instances according to their hardness in the following experiment. We use instance groups [10 k , 86,400] for k = −∞, 0, 1, 2, 3. Any group [10 k , 86,400] contains each instance from Table 3 such that [37] or SCIP-Jack solves this instance in not less than 10 k , and at most 86,400 s. If an instance can be solved by only one solver within the time-limit, we consider the run-time of the other solver on this instance as 86,400 s. Such groupings are commonly used in computational mathematical optimization (also with the time lower bounds being powers of 10), see e.g. [28,49]. In addition to the shifted geometric mean, Table 4 also provides the arithmetic mean of the run-time for each group. As before, we give the results for both [37] and SCIP-Jack, and report the respective speed-up of SCIP-Jack.
Unsurprisingly, the ratio of the arithmetic mean stays largely unchanged with increasing hardness of the groups. SCIP-Jack is more than a factor of 5 faster than the solver from [37] on all groups. On the other hand, the performance difference with respect to the shifted geometric mean significantly increases with the hardness of the instances. For instances that take more than a 1000 s to be solved by [37] or SCIP-Jack, the latter is even by a factor of more than 7 faster.

Further results
Finally, we provide results for several large-scale Euclidean Steiner tree problems. For solving such problems, the bottleneck is usually the full Steiner tree concatanation [22]. This concatanation can also be solved as an SPG, however [35]. In Table 5 we give results for Euclidean instances from [22] with 25 thousand (EST-25k), 50 thousand Table 3 Computational comparison of the solver developed for this article (S.-J.) and the solver described in [31,46]   Bold numbers signify a superior performance. Times marked by a were obtained by P.&V. with (specialized) non-default settings Table 4 Computational comparison of the solver developed for this article (S.-J.) and the solver described in [31,46]  Bold numbers signify a superior performance (EST-50k), and 100 thousand (EST-100k) points in the plane. For EST-25k the mean and maximum times are between one and two orders of magnitude faster than those of the well-known geometric Steiner tree solver GeoSteiner 5.1 [22]. Moreover, 7 of the 15 instances from EST-50k are solved for the first time to optimality-in at most 197 s. On the other hand, GeoSteiner cannot solve these instances even after seven days of computation. For EST-100k, GeoSteiner even leaves 12 of the 15 instances unsolved after one week of computation. In contrast, we solve all these instances to optimality in less than 13 minutes. Overall, we solve 19 instances for the first time to optimality. Unfortunately, [37] does not report results for these instances. However, the solver by [30], which won the heuristic SPG category at the 11th DIMACS Challenge, does not reach the upper bounds from GeoSteiner on any of the EST-25k, EST-50k, and EST-100k instances.

Conclusion and outlook
This article has described the combination of implication, conflict, and reduction concepts for the SPG, with the aim of improving the state of the art in exact SPG solution. This combination has spawned several new techniques that (provably) dominate well-known results from the literature, such as the bottleneck Steiner distance. The integration of the new methods into the branch-and-cut solver SCIP-Jack has shown a large impact on exact SPG solution. The new SCIP-Jack could even outperform the long-reigning state-of-the-art solver by [31,46].
Still, there are several promising routes for further improvement. First, one could improve the newly introduced methods. For example, by using full-backtracking in the extended reduction methods, by improving the approximation of the implied bottleneck Steiner distance, or by adapting the latter for replacement techniques. Second, several powerful methods described in [31,46] could be added to the new solver, e.g. a stronger IP formulation realized via price-and-cut, or additional reduction techniques via partitioning.
Unlike the solver by [31,46], the new SCIP-Jack will be made freely available for academic use-as part of the SCIP Optimization Suite 8.

Acknowledgements
The authors would like to thank the referees for their helpful comments. The work for this article has been conducted within the Research Campus MODAL funded by the German Federal Ministry of Education and Research (Fund Number 05M14ZAM), and has also been supported by the DFG Cluster of Excellence MATH+.
Funding Open Access funding enabled and organized by Projekt DEAL.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.

A Detailed computational results
This appendix provides detailed computational results on the problem instances discussed in this article All following tables are structured as follows: First, the name of the respective instance is given. The next three columns give the number of vertices, arcs (after the graph transformation to bidirected SAP), and terminals of the instance. The subsequent segment, labelled "Presolved", provides the size of the preprocessed problem along with the preprocessing time.
The last segment provides first the dual and primal bound, or the optimal solution value if the problem could be solved to proven optimality. Moreover, the number of branch-and-bound nodes (N) and the total run time is given. A time-out is signified by a ">" in front of the termination time. We stress that the reported final execution times include both the preprocessing time and the reading time.
The time limit for the following instances is 54,340 s. This corresponds to 24 h on the machine used by [37] (Tables 6, 7 , 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22). Bold numbers signify a superior performance   Bold numbers signify a superior performance Bold numbers signify a superior performance   Bold numbers signify a superior performance    Bold numbers signify a superior performance  Bold numbers signify a superior performance  Bold numbers signify a superior performance Bold numbers signify a superior performance Bold numbers signify a superior performance