Revisiting a Cutting Plane Method for Perfect Matchings

In 2016, Chandrasekaran, V\'egh, and Vempala published a method to solve the minimum-cost perfect matching problem on an arbitrary graph by solving a strictly polynomial number of linear programs. However, their method requires a strong uniqueness condition, which they imposed by using perturbations of the form $c(i)=c_0(i)+2^{-i}$. On large graphs (roughly $m>100$), these perturbations lead to cost values that exceed the precision of floating-point formats used by typical linear programming solvers for numerical calculations. We demonstrate, by a sequence of counterexamples, that perturbations are required for the algorithm to work, motivating our formulation of a general method that arrives at the same solution to the problem as Chandrasekaran et al. but overcomes the limitations described above by solving multiple linear programs without using perturbations. We then give an explicit algorithm that exploits are method, and show that this new algorithm still runs in strongly polynomial time.


Introduction
Given a graph G = (V, E) with edge cost function c, the minimum-cost (or minimum-weight) perfect matching problem is to find a perfect matching E ′ ⊆ E (a subset such that every vertex v ∈ V is covered by exactly one uv ∈ E ′ ) so that the sum of the costs of E ′ is minimized. As mentioned in [4], the minimum-cost perfect matching problem is a classical problem in combinatorial optimization with numerous and varied applications.
Since Edmonds [8] introduced the blossom algorithm (a polynomial-time combinatorial method of solving the problem), a number of efficient implementations have been developed over the years, with Kolmogorov's Blossom V [12] being a recent notable version.
The problem can also be formulated as a binary integer program: min e∈E c(e)x(e) To use linear programming (LP) techniques to solve the problem, the constraints x(e) ∈ {0, 1} are first relaxed to x(e) ∈ [0, 1] and then to x(e) ≥ 0 since the upper bounds are then implied. The linear program that results turns out to be exact for bipartite graphs in the sense that a basic optimal solution is the incidence vector of a minimum-weight perfect matching. Edmonds [7] provides an LP formulation for non-bipartite graphs that has the same property. It requires the addition of "blossom inequalities": x(e) ≥ 0 ∀ e ∈ E.
Unfortunately, the presence of an exponential number of constraints in this formulation precludes polynomial-time solvability via a generic LP solver. As a result, researchers in the past have experimented with a cutting-plane approach, solving the relaxation first without the blossom inequalities, then iteratively finding and adding violated inequalities until the problem has an integral solution. A polynomial-time (though impractical) algorithm follows using the equivalence of separation and optimization via the ellipsoid method (see Grötschel et al. [10]) and the polynomial-time identification of violated blossom inequalities due to Padberg and Rao [13]. The existence of a practical LP-based cutting plane method for the minimum-weight perfect matching remained uncertain until 2016, when Chandrasekaran et al. [2] gave a cutting-plane algorithm which uses only a polynomial number of linear programs. Their approach involves carefully selecting the blossom inequalities to be included at each iteration and requires that the optimal solution to the linear program be unique. As this uniqueness property does not always hold in general, their method introduces an edge ordering and a perturbation on the edge costs. (The edge costs are assumed to be integers.) In particular, if c 0 (i) is the original cost for the i-th edge, then the perturbed cost is c(i) = c 0 (i) + 2 −i . Such a perturbation turns out to be sufficient for providing the required uniqueness property. Even though the increase in size in representing the perturbed costs is polynomial, when the graph is large (say with hundreds of edges), the precision required to represent the perturbed costs exceeds what is typical of the floating-point formats used by most LP solvers [6]. (For example, 4 + 2 −100 = 5070602400912917605986812821505 1267650600228229401496703205376 requires a mantissa of over 100 bits.) To overcome the potential numerical difficulties caused by perturbation, we present a variant of the algorithm which does not require an explicit perturbation to ensure uniqueness. It works instead by solving a sequence of linear programs for each single linear program that the original algorithm would solve. We present a method whereby, given the solutions to these programs, we can derive the optimal solution to a hypothetical perturbed linear program without any explicit calculations on perturbed costs. After this, the rest of the proof follows just as it did for the original algorithm.
The trade-off is that our algorithm has a worse runtime than that of Chandrasekaran et al. Theirs requires solving O(n log n) linear programs, while ours solves O(mn log n). This is, however, still polynomial.
The rest of this paper is organized as follows. After defining some terms (Section 2) and summarizing the algorithm from [2] (Section 3), we give examples of graphs which show that this algorithm requires some form of perturbation in both the primal and dual problems. In particular, without perturbing the edge costs, we cannot guarantee that the intermediate solutions will always be half-integral (Section 4) or that the algorithm will terminate (Section 5). This occurs even if we force the primal solution to be the same as it would have been with perturbations. This motivates our new method, which uses multiple linear programs to accurately emulate the perturbations. We first explain this in a general case (Section 6) and then apply it to the specific problem of finding perfect matchings (Section 7).

Notation and definitions
The set of m × n matrices with real entries is denoted by R m×n .
For a matrix A ∈ R m×n , A i,j denotes the (i, j)-entry of A; that is, the entry of A at the intersection of the i-th row and the j-th column. A :,j denotes the j-th column of A and A i,: the i-th row. The transpose of A is denoted by A T .
Following common usage in combinatorics, for a finite set E, R E denotes the set of tuples of real numbers indexed by elements of E. For y ∈ R E , y(i) denotes the entry indexed by i ∈ E. For a positive integer n, R n is an abbreviation for R {1,...,n} . Depending on the context, elements of R n are treated as if they were elements of R n×1 .
We assume familiarity with basic terminology related to matchings and linear programming. A refresher of the former can be found at [5,Chapter 5], and of the latter at [14]. We next recall some definitions in Chandrasekaran et al. [2] to facilitate discussion of their minimum-cost perfect matching algorithm.
Let G = (V, E) be an simple undirected graph with integer edge costs given by c ∈ Z E . A family F of subsets of V is said to be laminar if for all U, W ∈ F , U ∩ W = ∅ or U ⊆ W or W ⊆ U . For a set S ⊆ V , δ(S) denotes the set of edges incident to one vertex in S and one vertex not in S. For a vertex u, δ(u) denotes δ({u}). For x ∈ R E and T ⊆ E, x(T ) denotes the sum e∈T x(e).
Let M be a matching of a graph H = (V, E). Let U ⊆ V , and let F be a laminar family of subsets of V . Then M is a (U, F )-perfect-matching if |δ(S) ∩ M | ≤ 1 for every S ∈ F and M covers exactly the vertex set U . A set of vertices S ∈ F is said to be (H, F )-factor-critical for a graph H if, for every u ∈ S, there exists an (S \ {u}, F )-perfect-matching using the edges of H.
For a laminar family F of odd subsets of V , define the following primal-dual pair of linear programming problems: Let Π be a feasible solution to D F (G, c). G Π denotes the graph (V, E Π ) where E Π = {uv ∈ E : S∈V ∪F :uv∈δ(S) Π(S) = c(uv)}. Colloquially, E Π is the set of "tight" edges with respect to Π. We say that Π is an F -critical dual if every S ∈ F is (G Π , F )-factor-critical and Π(T ) > 0 for every non-maximal T ∈ F . If Π is an F -critical dual except that some sets S ∈ F for which Π(S) = 0 may not be (G Π , F )-factor-critical, we say that Π is an F -positivelycritical dual.
Finally, we define a metric on solutions to D F (G, c) It can be easily verified that this has the properties of a metric. For a given fixed Γ , we say that Π is Γ -extremal if it minimizes ∆(Γ, Π). Given Γ and a primal solution x, we may find a Γ -extremal dual optimal solution by solving the following linear program [2, Section 5]: where F x = {S ∈ F : x(δ(S)) = 1}. The solution will give us values for r and Π; we ignore r and take Π to be our Γ -extremal solution.

The Chandrasekaran-Végh-Vempala algorithm
Algorithm 1 for finding a minimum-cost perfect matching on G is due to Chandrasekaran et al. [2]. It assumes, as we will from now on, that the edge costs are integers.

Algorithm 1: C-P-Matching Algorithm
Input: A graph G = (V, E) with edge costs c ∈ Z E . Output: A binary vector x representing a minimum-cost perfect matching on G. 1 Let c be the cost function on the edges after perturbation (i.e., after ordering the edges arbitrarily and increasing the cost of each edge i by Find an optimal solution x to P F (G, c). 5 Find a Γ -extremal dual optimal solution Π to D F (G, c) (possibly by solving D * F (G, c)).
Let C denote the set of odd cycles in supp(x). For each C ∈ C , definê C as the union of V (C) and the maximal sets of H ′ intersecting it.
The authors of the algorithm showed that F is always a laminar family and that the algorithm terminates after O(n log n) iterations, assuming that P F (G, c) has a unique optimal solution in every iteration of the algorithm. This is ensured through the use of perturbations in the first step. The authors further demonstrate that a Γ -extremal dual solution, with an F -critical Γ , is an F -positively-critical dual optimal to D F (G, c), so the result of step 5 is Fpositively-critical. When combined with the uniquness assumption, this leads to x being half-integral in each iteration.
The choice of using powers of 1 2 for the perturbations is to keep the increases in input size polynomial. However, to guarantee uniqueness, powers of a sufficiently small ǫ > 0 can be used instead.
There exists a δ > 0 such that the perturbations used in Algorithm 1 may be replaced with powers of ǫ for any δ > ǫ > 0.
Proof. Consider the proof given for the efficacy of the 2 −i perturbation in [2,Section 7]. This uses only one property of the perturbation: We prove this for a class of arbitrary ǫ > 0, after which the desired result follows. Assume This shows that, for any given a and b, there exists a δ such that if a(i)δ i = b(k)δ k , then a = b for all δ > ǫ > 0. In fact, we need only consider the cases where a and b are basic feasible solutions to P F (G, c), because if there exists an optimal solution that is not a basic feasible solution then there exist two distinct basic feasible solutions that are optimal. Therefore, if optimal basic feasible solutions are unique, so are optimal solutions in general.
Fix F . Then, because P F (G, c) is bounded and finite-dimensional, it has a finite number of basic feasible solutions s 1 , . . . , s k . Every pair (s p , s q ) gives us a δ by setting a = s p , b = s q and running through the logic above. Take the smallest of these δs to complete the proof.
For reasons that will become clear later (see Section 6), it will be more convenient to use powers of a sufficiently small ǫ > 0 as perturbations instead of powers of 1 2 . In any case, increasing the bit-length required to represent the edge costs can lead to practical computation challenges since most LP solvers employ fixed-length floating-point formats. (Notable exceptions exist, such as QSopt-Exact [1] and the SoPlex rational solver [9], but they are significantly slower than non-exact solvers.) We feel strongly that the key to a successful implementation of Algorithm 1 is to not work with any explicit numerical perturbation.
An obvious way of modifying the algorithm is simply to not perturb the edge costs and run the rest of the procedure as stated, but this violates the uniqueness assumption, and as easily demonstrated in [2, Section 1], can lead to non-half-integrality and cycling.
Instead, we may emulate perturbations by ordering the edges (as in step 1 of Algorithm 1) and then finding a lexicographically-minimal optimal solution to P F (G, c), where c is now an unperturbed cost function. This may be accomplished using Algorithm 2, which shows the process in a more general case.
x ∈ R n . Output: The lexicographically-minimal solution x to P . 1 Solve P and let its opimal value be γ.
By [14, p. 138], the lexicographically-minimal optimal solution to P F (G, c) is the same as the optimal solution to the perturbed P F (G, c). Unfortunately, this on its own ensures neither half-integrality nor convergence: for an arbitrarily small nonzero value there exist graphs such that the lexicographically-minimal optimal solution to P F (G, c) contains smaller values, and there exist graphs on which this modification of the algorithm enters an infinite loop. Before giving a slightly more complex modification of the algorithm that uses a multi-stage approach to mimic solving with perturbation without actually working with perturbations, we first give some examples of graphs that demonstrate the problems just mentioned.

Non-half-integral solution
The following example, which we call the "dancing robot," shows that, if the edge costs are not perturbed at all, having an F -critical dual is not sufficient to guarantee that all lexicographically-minimal optimal primal solutions are halfintegral. Chandrasekaran et al. [2] provide an example early in their paper of a graph on which their algorithm as written does not maintain half-integrality, but this does not entirely suffice for our purposes, as the lexicographically-minimal primal solution on this graph, for any edge ordering, is integral.
The graph shown in Figures 1-4, with all edges having cost 1, eventually gives non-half-integral values when run through the original algorithm without any perturbation while enforcing a lexicographically-minimal optimal primal. During each iteration, an optimal dual solution is given by Π, the vector having value 1 2 on the entries indexed by the vertices and 0 on entries indexed by the sets in F . Note that all edges in the graph are tight with respect to Π. We can see that, although the primal solutions in the first and second iterations are half-integral (shown in Figures 2 and 3), the solution in the third iteration no longer is. The 1 3 -and 2 3 -edges are shown in Figure 4. Meanwhile, the dual solution Π is a positively-critical optimal dual for the current F in every iteration, as well as a critical dual for the next F . For instance, the Π from the second iteration, feasible to the dual problems from both the second and third iterations, is trivially an F -positively-critical optimal dual for the second iteration, since none of the sets S ∈ F have positive dual value. For the third iteration, since there exists an (S \ {u}, F )-perfect-matching for any node u ∈ S ∈ F , and since F only has maximal sets, that same Π is an F -critical dual.   Even worse, the algorithm will eventually enter into an infinite loop on this example. The details are tedious, so we will not go into them -the example in the next section also loops but does not lose half-integrality.
On their own, then, a lexicographically-minimal primal and an F -critical dual can guarantee neither half-integrality nor termination. It is worth mentioning that we could expand the graph to get one with more non-half-integral edges by making the 2-6 edge (the "arm" of the dancing robot) overlap with another dancing robot's 6-2 edge. This combination would have twice as many non-half-integral edges, spread across twice as many non-half-integral paths, as the original dancing robot. By combining multiple dancing robots in such a manner, we can get as many non-half-integral paths as we want, which indicates that we cannot avoid these non-half-integral edges via a simple combinatorial linearor constant-time algorithm.
We can even alter the dancing robot in order to give us arbitrarily small but nonzero values in a lexicographically-minimal optimal solution. Say we want a primal solution x such that, for some uv, x(uv) = 1 2n+1 for some n ∈ Z ≥0 . We add 2(n − 1) new edges between 0 and the 0-1 edge, alternately without and with adjoining 4-cycles. The next example shows how this works for n = 2.   Simply by following the algorithm through, we see that we will eventually end up with a cut ({4, 12, 0, 16, 17, 1, 5, 15, 13} in Figure 7) with 2n + 1 edges coming out of it. Furthermore, by the conditions of the matching (x(δ(u)) = 1) and the fact that these edges form a path in the matching, each edge coming out of this cut must have the same value, which we will call ζ. Since x(δ(S)) ≥ 1, the minimum cost is when (2n + 1)ζ = 1 or ζ = 1 2n+1 .

Cycling example
Even when seeking a lexicographically-minimal optimal solution to P F (G, c) with half-integrality maintained throughout, cycling can still occur in the absence of perturbation. The graph in Figures 9 and 10 (which is easily seen to have a perfect matching), with each edge having cost 1, exhibits such behavoir. At all times, an optimal F -positively critical dual is given by a vector with the vertices having value 1 2 and the odd sets in F having value 0. Since Algorithm 1 only retains cuts which have nonzero values in the dual (step 6), no cuts are preserved between iterations. Thus, the blossom inequalities which were violated in the previous iteration are once again allowed to be violated in the next iteration, leading to cycling.  This precludes us from ensuring termination of an approach using a lexicographically-minimal primal with an unperturbed dual. More significantly, it also means we could not even implement a heuristic version which, in the event of cycling, would restart the algorithm with randomized edge orderings. Were half-integrality to occur in tandem with cycling, as it does in Section 4, we could simply verify half-integrality at each iteration, and, in rare cases of non-half-integrality, begin the entire algorithm again with a different edge ordering, giving us a good average-case runtime. 5 However, this graph shows that when a possibility of cycling exists, it is likely undetectable by any means other than direct comparison between iterations. This forces us to adopt an algorithm which simulates perturbations in the dual.

Solving LP problems with perturbed costs
Chandrasekaran et al. [2] chose a specific perturbation of the costs, namely, adding 2 −i on each edge i. In general, perturbation in linear programming (usually for the purpose of eliminating degeneracy, as in [3]) is of the form ǫ i where ǫ is sufficiently small. In theoretical analysis, ǫ is simply left unspecified. In the same spirit, we show in this section how we could obtain optimal solutions to both the primal and dual problems with perturbed costs, working with the fact that ǫ is sufficiently small yet not given exactly, without the need of an optimal basis. The method we describe is therefore able to avoid working directly with cost values that exceed the representation capacity of fixed-length floating-point formats typically used by LP solvers. Our method is applicable to any situation in which the objective function of a generic LP problem is perturbed in order to enforce uniqueness of the optimal solution. In the next section, we specialize it to Algorithm 1.
Let A ∈ R m×n , b ∈ R m , and c 0 , . . . , c k ∈ R n for some nonnegative integer k. Let N ⊆ {1, . . . , n}. Let F = {1, . . . , n} \ N . Define c ǫ as k p=0 c p ǫ p where ǫ ≥ 0. Consider the linear programming problem: Its dual is 5 We discovered the dancing robot after searching through over two thousand randomly-generated graphs, all of which were rapidly and correctly solved by the use of a lexicographically-minimal primal and unperturbed dual. Furthermore, if a random edge ordering is applied to the dancing robot for example, it is very likely that a perfect matching will be found without issue.
and y p to an optimal solution to its dual.
The correctness of Algorithm 3 follows from Lemma 2 below. Before we give the proof, we illustrate the algorithm with an example. For each p, let M p denote the LP problem in step 4 of the algorithm. Consider P (ǫ) with The dual problem is Note that x 0 = 1 1 0 T and y 0 = 1 1 T are optimal solutions to P (0) and D(0), respectively, which are in turn equivalent to M 0 and its dual.
Since y 0 (1), y 0 (2) > 0 and all the constraints in D(0) are satisfied with equality at y 0 , M 1 is An optimal solution to M 1 is T . An optimal dual solution is y 1 = 4 −2 T . The second constraint in the dual is not active at y 1 . Hence, M 2 is An optimal solution to M 2 is 1 2 0 1 2 T . An optimal dual solution is y 2 = −2 3 2 T .
Lemma 2. Let M p denote the LP problem solved in step 4 of Algorithm 3.
Proof. For each j = 1, . . . , p, M j is obtained from M j−1 by adding constraints to enforce complementary slackness with y j−1 . Removing x(j) can be viewed as adding the constraint x(j) = 0. It follows that x p is feasible to M j and satisfies complementary slackness with y j for all j ∈ {0, . . . , p − 1}.
To prove the second part, we start by noting that x ′ is feasible to P (ǫ). Let E p , J p , and J p be the sets E, J, and J referred to in M p . The dual of M p is Clearly, y ′T A :,j = c ǫ (j) for all j ∈ F . Next, we show that y ′T A :,j ≤ c ǫ (j) for all j ∈ N .
Suppose that j ∈ J k . Since J p ⊆ J p−1 for p = 1, . . . , k, we have y T p A :,j ≤ c p (j). Thus, Now, suppose that j ∈ J k . Then, there exists r < n such that y T r A :,j < c r (j).
We now make two observations that will be useful in the next section. First, we can see from the proof of Lemma 2 that the dual of M p can be obtained directly from the dual of M p−1 and an associated optimal solution y p−1 by removing constraints (including the nonnegativity bound constraints) that are not active at y p−1 . It follows that one can work exclusively with the duals of M 0 , . . . , M k if one is only interested in obtaining an optimal solution to D(ǫ). Moreover, in practice, y ′ hardly needs to be worked out for a particular value of ǫ and can be represented by the list y 0 , . . . , y k . Then, to determine if y ′ (i) = 0 for some i, simply check if there exists a p such that y p (i) = 0, since, for sufficiently small ǫ, y ′ (i) = 0 if and only if y p (i) = 0 for all p.

Modified Chandrasekaran-Végh-Vempala algorithm
We now modify Algorithm 1 to circumvent the need to utilize an explicit perturbation of the edge costs. First, we arbitrarily order the edges and increase the cost of each edge i by ǫ i for some sufficiently small ǫ > 0 that will remain unspecified. By Lemma 1, we may assume that with such a perturbation, Algorithm 1 will still return a minimum-cost perfect matching. In Algorithm 1, step 4 and step 5 involve solving P F (G, c) and D * F (G, c) respectively with perturbed data. We emulate perturbations in the first of these by finding a lexicographicallyminimal optimal solution. The other is handled through the method developed in the previous section applied to the following LP, which is easily seen to be equivalent to D * F (G, c): With explicit perturbation of the edge costs, Γ and c will be polynomials in ǫ. Intuitively, we define Γ i and c i to be the coefficients of ǫ i in Γ and c; we will define these rigorously in a moment. The reason for writing D * F (G, c) as above is to make it plain that it can be viewed as the dual problem D(ǫ) of some P (ǫ) with cost values given by polynomials in ǫ. However, in an actual algorithm as seen below, we can work directly with D * F (G, c) as originally written. With these changes and the following definitions, we obtain Algorithm 4.
Given an ordering σ : E → {1, . . . , |E|} on the edges of G, define the following cost function: With this, we define the following linear program: Intuitively, c i and Γ i correspond to the coefficients of ǫ i in c and Γ if we were to perturb the edge costs on the graph by ǫ i and run Algorithm 1.

Algorithm 4: Unperturbed C-P-Matching Algorithm
Input: A graph G = (V, E) with edge costs c ∈ Z E and an ordering σ : E → {1, . . . , |E|}. Output: A binary vector x representing a minimum-cost perfect matching on G.
Let x be the lexicographically-minimal optimal solution to P F (G, c) with respect to σ.
Let C be the set of odd cycles in supp(x). For each C ∈ C , let V (C) be the union of C with all sets in H ′ intersecting it.

16
Steps 8 through 11 exist to remove the slack constraints from the next iterations of D i F (G, c, σ, Γ, L, M, N, Q), as in Algorithm 3. A reference implementation, written in Python 3, is available at [11].
Lemma 3. In every iteration of the Unperturbed C-P-Matching Algorithm (4), x is equal to its counterpart in the C-P-Matching Algorithm (1) with perturbations c(i) = ǫ i .
Proof. As mentioned in Section 3, by [14], the lexicographically-minimal unperturbed primal solution is equal to the unique perturbed optimal primal solution for a given F , so we need only show that F is always equal to its counterpart.
Consider Γ as a single vector of polynomials in ǫ, with the coefficients of the ǫ i terms given by Γ i . Then, by Lemma 2, y = i ǫ i D i is an optimal solution to the linear program in step 6, and y(S) > 0 if and only if max(D i ) > 0. But the linear program in question is exactly that which the C-P-Matching algorithm uses to obtain a Γ -extremal dual optimal solution. Therefore H ′ , which is defined solely based on whether y(S) > 0 or not, is equal to its counterpart in the C-P-Matching algorithm. Since H ′′ is defined exactly the same way as its counterpart, the two are equal, so F is equal to its counterpart as well.
Since, by Lemma 1, neither the correctness nor the complexity of Algorithm 1 are affected by changing from the perturbation c(i) = 2 −i to the perturbation c(i) = ǫ i , we can rephrase this to give Theorem 1. The Unperturbed C-P-Matching Algorithm gives a minimum-cost perfect matching.
The lemma also has the following Corollary 1. The Unperturbed C-P-Matching algorithm requires solving O(mn log n) linear programming problems in the worst case.
Proof. According to [2, Theorem 1], the C-P-Matching Algorithm takes at most O(n log n) iterations. The Unperturbed C-P-Matching Algorithm has the same number of iterations, but each iteration utilizes 2(m + 1) linear programming problems, which is O(m). Therefore, the Unperturbed C-P-Matching Algorithm requires solving O(m) × O(n log n) = O(mn log n) linear programming problems in total.

Final remarks
We have developed a general method for solving perturbed linear programs in polynomial time without performing explicitly perturbed calculations, and demonstrated that it applies to the minimum-cost perfect matching problem. The use of perturbations to guarantee uniqueness is common in linear programming, and it remains to be seen whether or not our method could be applied to other algorithms or used to solve other problems. We do not yet know if our new algorithm, when properly implemented and optimized, can be made competitive with combinatorial methods such as Edmonds's blossom algorithm. According to [12], the best known asymptotic runtime for such an implementation is O(n(m + log n)). Our algorithm, which solves O(mn log n) linear programs, each of which requires the use of a theoretically polynomial-time solver, is significantly slower in the worst case.
We encountered a number of interesting phenomena regarding the subroutine for finding the lexicographically-minimal primal optimal solution. Although, as written, it requires solving a fixed number of linear programs (|E| + 1), we noticed in empirical testing that it often gave this solution far more quickly than that, with the last few linear programs all giving the same answer. We did not investigate this any further, but hypothesize that shortcuts exist to decrease the runtime by a factor of 1 4 or more.