Practical Graph Bipartization with Applications in Near-Term Quantum ...

Practical Graph Bipartization with Applications in Near-Term Quantum Computing Timothy D. Goodrich1 , Eric Horton1 , and Blair D. Sullivan1 1

Department of Computer Science, North Carolina State University, Raleigh, North Carolina 27606 {tdgoodri,ewhorton,blair_sullivan}@ncsu.edu

arXiv:1805.01041v1 [cs.DM] 2 May 2018

Abstract We experimentally evaluate the practical state-of-the-art in graph bipartization (Odd Cycle Transversal), motivated by recent advances in near-term quantum computing hardware and the related embedding problems. We assemble a preprocessing suite of fast input reduction routines from the odd cycle transversal and vertex cover literature, allowing the slower branching algorithms to be compared on identically-preprocessed data. In addition to combinatorial branching algorithms, we also study multiple methods for computing graph bipartization with integer linear programming solvers. Evaluating the practical performance of these algorithm, two use cases in quantum annealing are studied with a quadratic unconstrained binary optimization problem corpus. Finally, we provide all code and data in an open source suite, including a Python API for accessing reduction routines and branching algorithms, along with scripts for fully replicating our results. 1998 ACM Subject Classification G.2.2 Graph Theory, G.2.3 Applications Keywords and phrases Graph Bipartization, Odd Cycle Transversal, Near-Term Quantum Computing, Quantum Annealing, Vertex Cover, Integer Linear Programming Digital Object Identifier 10.4230/LIPIcs...

1

Introduction

Odd Cycle Transversal (OCT), the problem of computing a minimum set of vertex removals that will yield a bipartite graph, has been well-studied in the theory community over the last two decades. Techniques such as iterative compression [30, 16] and branch-and-reduce [23, 3] have led to significant improvements in both worst-case and experimental run times. These improvements are most drastically seen on Wernicke’s Minimum Site Removal dataset [35] (referred to here as WH), which has become the canonical OCT benchmark, where run times dropped from over 10 hours [35] to under 3 minutes [16] to under 1 second [3]. Recently, a need for practical graph bipartization algorithms has arisen in quantum computing, where physical constraints limit the topology of all near-term quantum hardware to bipartite structure. However, it is not clear that the existing experimental results for OCT generalize to this setting. Specifically, the datasets arising in quantum computing are not purportedly close-to-bipartite (like those in WH), and bipartization algorithms are typically employed by automated compilers where a heuristic that finds a ‘small enough’ OCT set is acceptable, introducing a run time vs. solution quality trade-off.

1.1

Related Work

Modern theoretical advances on OCT began with the seminal result of Reed, Smith, and Vetta [30] showing that the problem is fixed-parameter tractable (FPT) by introducing © Timothy D. Goodrich and Eric Horton and Blair D. Sullivan; licensed under Creative Commons License CC-BY Leibniz International Proceedings in Informatics Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany

XX:2

Practical Graph Bipartization

a technique called iterative compression. They gave a O(4k km) algorithm for minimum OCT size k; subsequent improved analysis [16, 24] led to a O(3k km) run time and simpler algorithms for the compression routines. The observation that any OCT instance can 0 be naturally transformed into a VC (VC) instance led to an O∗ (2.3146k ) algorithm1 [23] where the parameter k 0 measures the gap between the size of a minimum vertex cover and the solution produced by an LP relaxation of that problem (commonly referred to as Vertex Cover Above LP). Recent work has explored reducing the polynomial run time by increasing the parameterized function to O∗ (4k ) [19, 34, 20]. Other algorithmic results √ for OCT include a O(log n)-approximation algorithm [1], a randomized algorithm based on matroids [22], and a subexponential algorithm on planar graphs [25]. On the practical side, the first implementation was a branch-and-bound algorithm by Wernicke in 2003 [35] used for studying single nucleotide polymorphisms. A greedy depthfirst search heuristic was used to identify upper bounds on OCT, and several sparse-graph reduction routines were applied before branching. A Java implementation of this algorithm solved most WH instances within a 10 hour timeout. In 2009, Hüffner implemented a refined iterative compression algorithm [16] with additional pruning for infeasible assignments and symmetry in the compression routine’s branching algorithm to achieve experimentally faster run times; all of the WH instances could now be solved within three minutes. Hüffner also compared against an ILP formulation using the GNU Linear Programming Kit (GLPK) [11], which had unfavorable run times. More recently, Akiba and Iwata [3] used a VC-solver based on branch-and-reduce to solve OCT using a standard transformation to VC [23]. The authors found that their open source Java implementation could solve all WH data within a second, while competitors based on maximum clique and an ILP formulation run using CPLEX [17] all finished within three seconds.

1.2

Our Contributions

In this work, we evaluate existing OCT implementations in a broader, quantum-computing– inspired experimental envelope (see Section 2.1). We introduce a new benchmark dataset commonly used in quantum annealing [28], and unify a corpus of preprocessing methods from [35, 3]. Next, we collect and implement a heuristic ensemble [35, 12] to compete in the time-limited setting, and engineer an improved version of Hüffner’s iterative compression code. We execute an extensive set of fully replicable experiments to evaluate the effectiveness of preprocessing and compare the performance of heuristic, combinatorial, and ILP-based solvers in both time-limited and exact solution use cases. We start by addressing issues related to datasets. First, the canonical WH dataset is naturally close-to-bipartite (an unrealistic assumption in quantum computing applications) and any modern solver is expected to find an optimal solution within a few seconds on all instances. From the quantum annealing literature [28, 9] we identify the Beasley [5] and GKA [10] datasets as a suitable benchmark (Section 3.2). Second, some previous studies relied on preprocessing [35, 3] while others did not [16]. To even the playing field, we collect existing reduction routines [35, 3] into a suite and apply them to the raw datasets (Section 3.3) before running any OCT algorithm. Since a quantum compiler may prefer speed over solution quality, we collect linear-time heuristics for OCT from the literature and provide them in a heuristic ensemble solver (Section 4.1). We then engineer an updated version of Hüffner’s iterative compression solver

1

O∗ (f (k)) denotes O(f (k)nc ) for some constant c

T. D. Goodrich and E. Horton and B. D. Sullivan

to benefit from starting with a non-optimal solution and a density-based ordering on the remaining vertices (Section 4.2). We find that starting from an initial heuristic solution generally provides a 2× speed-up, and that the density ordering can further help in situations with larger timeouts. Before proceeding to our comprehensive comparison of state-of-the-art solvers, we revisit seemingly contradictory results in prior evaluations of ILP-based solvers. Specifically, previous work by Hüffner [16] found that the ILP formulation of OCT was strictly worse than his iterative compression approach when using the GLPK [11] solver, whereas Akiba and Iwata [3] found that using an OCT → VC → ILP formulation with the CPLEX [17] solver was competitive with modern combinatorial approaches. We examine combinations of these choices along with hardware considerations (Section 5), and find that CPLEX with the OCT → VC → ILP formulation is most efficient, even when varying the number of threads and available system memory. Finally, in Section 6 we benchmark the solvers in two use cases: (1) A heuristic solution is required within 0.01, 0.1, 1, and 10 seconds, and (2) A proven exact solution is required (within a 10 minute timeout). In the time-limited heuristic setting, our Improved Hüffner solver is the best performer for run times less than a second, with ILP pulling ahead for run times over a second. In the exact experiment we find that ILP also dominates, with the Akiba-Iwata VC-solver a constant factor slower. Our work is fully replicable, with documented code open sourced with the BSD 3-Clause license at https://github.com/TheoryInPractice/practical-oct. For the interested reader, implementation considerations are documented in Appendix A, and full experimental results are included in Appendix B.

2 2.1

Background Motivation from Quantum Computing

Motivation for practical graph bipartization implementations stems from advances in nearterm quantum computing. While long-term quantum computing focuses on using quantum computers to unequivocally beat classical computing, the theoretical hardware requirements are quite far from modern production models. For example, running Shor’s Algorithm to factor integers in 2048-bit RSA keys is estimated to require three million qubits in a circuit-based model when error correction is taken into account [2]. In contrast, near-term quantum computing concentrates on using quantum computers obtainable now to achieve speedups in specific applications. Figure 1 depicts several such hardware models as graphs, where qubits and their couplers are represented as nodes and edges, respectively. Notably, physical constraints force modern hardware to have bipartite topology. Graph bipartization occurs during the compilation step, when a problem graph must be embedded into the hardware graph. The definition of “embedding” depends on the model of quantum computing, but at a high level it captures the notion of mapping logical qubits needed by the program to physical qubits present in the hardware. In analog quantum computing (“quantum annealing”), a typical pipeline is for an optimization problem to be formulated as a Quadratic Unconstrained Binary Optimization Problem (QUBO), which then must be found as an graph minor of the hardware [7]. Researchers have had success running natively bipartite QUBOs (e.g. deep learning models) on D-Wave Systems annealers [31, 21, 6, 29]. Generalizing these tools to non-bipartite QUBOs is currently of interest to enable additional applications (e.g. Karp’s 21 NP-hard problems [27]). The area of automatic embedding tools is under active development (refer

XX:3

XX:4


Google Bristlecone (72-qubit)

IBM (50-qubit)

D-Wave 2000Q (2048-qubit) Rigetti (20-qubit)

···

··· .. .

.. .

Figure 1 All modern topologies are natively bipartite (visually denoted by a blue-white twocoloring). Google’s announced Bristlecone hardware is expected to be the first hardware to achieve quantum supremacy over classical computers. Rigetti Computing [8] and IBM [18] both manufacture circuit-based quantum computers with 20- and 50-qubits, respectively. D-Wave Systems manufactures quantum annealers using ‘Chimera(L, M , N )’ graphs: An M × N grid of complete bipartite KL,L cells; the upper-left corner of this fabric is shown here.

to, e.g., [12, 14, 33]). In circuit-based quantum computing, the embedding problem is a more complex placement, routing and scheduling problem [32]. Unlike on quantum annealers, adjacent qubits on a circuit-based hardware can be swapped, allowing non-complete hardware topology to execute gates on all combinations of edges through a series of exchanges. However, these swaps should be minimized to decrease run time, highlighting the need for optimal initial placements. Fast graph bipartization routines would enable a better initial placement analysis, so that odd cycles in the problem circuit are most easily emulated on the bipartite hardware. While the theory behind circuit-based models is older, production-level analog computers are more prevalent, so we will restrict our scope to quantum annealing. We will concentrate on two use cases of current relevance. First, a feasible bipartization of a graph is useful for certain embedding algorithms, regardless of minimality [12, 14]. An automated compiler might require this bipartization in as little as 0.01 seconds, whereas a computer-assisted researcher working in an interactive environment may wait closer to 10 seconds. In a second use case, OCT can be used to identify when a particular program cannot embed into hardware, as is shown for D-Wave System’s Chimera hardware in [12]. This scenario requires that the solver return a proven-minimum OCT solution, but longer run times are permissible since a hardware owner can compute forbidden configurations once per hardware model. We examine both of these use cases in more detail in Section 6.

2.2

Definitions and Notation

We denote a graph G = (V, E). For a set of vertices S, G \ S denotes the graph resulting from deleting S from G. We now formally define OCT (and the related problem VC).


XX:5

Odd Cycle Transversal (OCT) Input: Problem: Objective:

An input graph G = (V, E). Find S ⊆ V such that G \ S is bipartite. Minimize |S|.

Vertex Cover (VC) Input: Problem: Objective:

An input graph G = (V, E). Find S ⊆ V such that G \ S is edgeless. Minimize |S|.

As noted in [23], an instance of OCT can be solved as an instance of VC by creating an auxiliary graph G0 = (V1 ∪ V2 , E1 ∪ E2 ∪ E 0 ), where Vi = {vi | v ∈ V } and Ei = {(ui , vi ) | (u, v) ∈ E} (for i = 1, 2), and E 0 = {(v1 , v2 ) | v ∈ V }. A solution S to the VC instance can be mapped to a solution S 0 for the OCT instance with S 0 = {v | v1 ∈ S and v2 ∈ S}. Additionally, each problem can be reformulated as an Integer Linear Programming instance to be solved with an industrial-grade solver (e.g., CPLEX [17]): Odd Cycle Transversal (ILP-Formulation) [16] Input: G = (V, E). X Minimize cv v∈V

s.t.

sv + su + cv + cu ≥ 1

∀(u, v) ∈ E

sv + su − cv − cw ≤ 1

∀(u, v) ∈ E

sv ∈ {0, 1}

∀v ∈ V

cv ∈ {0, 1}

∀v ∈ V

Vertex Cover (ILP-Formulation) [3] Input: G = (V, E). X Minimize xv v∈V

s.t.

xu + xv ≥ 1

∀(u, v) ∈ E

xv ∈ {0, 1}

∀v ∈ V

The OCT solution can be recovered from the first formulation with S = {v | cv = 1}, and a VC solution from the second with S = {v | xv = 1}. See [16] and [3] for more details on how these ILP formulations are derived.

3

Experimental Setup

In this section we detail the experimental setup, including the hardware and software environment, the data used, and steps taken to preprocess the data.

XX:6


3.1

Hardware and Software Environment

All experiments were run on a Dell T20 workstation with an Intel Xeon E3-1225 v3 CPU, 16GB ECC DDR3 system memory in a dual-channel configuration, and an Intel S3500 solid state drive as storage. This workstation ran Debian 4.9.82-1 with Linux kernel 4.9.0-6, CPLEX 12.8, and GLPK 4.61. C/C++ code was compiled with gcc/g++ 6.3.0, Java code was compiled and run with OpenJDK 1.8.0_162, and Python code was run with Python 3.5.3 (the newest version supported by CPLEX 12.8). All code is available at https://github.com/TheoryInPractice/practical-oct. For information on reproducing the full results presented here, see REPLICABILITY.md. All algorithms are available as standalone solvers, and we provide scripts for downloading the original data source and nondeterministically parsing it into the graphs used in this work. Python scripts are provided to execute the experiments reported here and produce all associated results tables. Implementation details are provided in Appendix A.

3.2

Data

As mentioned in Section 1.1, the primary dataset studied in OCT literature originates from Wernicke and is distributed with Hüffner’s code; we refer to this data as the Wernicke-Hüffner (WH) dataset. This dataset is composed of 45 Afro-American graphs (denoted aa-10, . . . , aa-54) and 29 Japanese graphs (denoted j-10, . . . , j-28). Although files aa-12, j-12, and j-27 are provided in Hüffner’s code, they are empty and not included here. While Wernicke’s implementation required over 10 hours to solve some of these datasets, Akiba and Iwata’s latest results show that any state-of-the-art solver can solve all these instances within three seconds, therefore we borrow a more difficult benchmark dataset from quantum computing. A recent survey [9] collected six datasets from the QUBO literature (see Section 2.1); of these, only the Beasley [5] and GKA [10] data have instances whose sizes are amenable to embedding in near-term quantum annealing hardware. Specifically, we consider the 50-vertex instances (denoted b-50-1, . . . , b-50-10) and the 100-vertex instances (denoted b-100-1, . . . , b-100-10) of the Beasley dataset and the first 35 instances of the GKA dataset (denoted gka-1, . . . , gka-35), which have varying numbers of vertices and densities. All datasets are parsed as undirected, simple graphs with no vertex or edge weights. Vertices or edges with weight zero are excluded, and self-loops are removed. Additionally, graphs are relabeled with vertices {0, . . . , n − 1} and are written to files for each solver’s required format. (We refer the interested reader to Appendix A.1 for implementation details).

3.3

Reduction Routines and Preprocessed Data

Previous experiments have differed in the use of preprocessing methods: Wernicke uses them for moderately faster run times, Hüffner’s algorithm does not use any, and Akiba-Iwata’s VC-solver fundamentally depends on iteratively reducing the graph after branching. To remove the effect of non-uniform application initial reductions from our experiments, we preprocess the input corpus by applying both Wernicke’s and Akiba-Iwata’s reductions iteratively until none apply. We provide an implementation of Wernicke’s reductions in Python using NetworkX [13] and modify Akiba-Iwata’s implementation to compute one round of reductions; details are deferred to Appendix A.2. While some reduction routines are nondeterministic, we use sorting to ensure that our implementation provides deterministic results for a given dataset graph file, therefore our exact results are reproducible from the original graph files.


Original Graph

Reductions

XX:7

Reduced Graph

Dataset |V | |E| OP T |Vr | |Er | |Vo | |Vb | |V 0 ∪ Vb | |E 0 | OP T 0 aa-10 69 181 6 10 0 0 30 59 181 6 aa-11 103 298 11 10 0 0 62 93 298 11 aa-16 14 0 0 14 0 0 0 0 0 0 aa-21 31 0 9 22 0 9 0 0 0 0 aa-41 300 1585 40 39 0 0 172 261 1585 40 aa-42 237 1100 30 11 0 0 137 226 1100 30 j-10 57 97 3 20 0 0 13 37 97 3 j-11 51 198 5 14 0 0 8 37 198 5 j-15 45 0 1 44 0 1 0 0 0 0 j-16 14 0 0 14 0 0 0 0 0 0 gka-1 50 90 11 4 0 2 9 44 90 9 gka-2 60 149 17 1 0 1 1 58 149 16 gka-16 90 0 86 4 0 86 0 0 0 0 gka-17 100 0 96 4 0 96 0 0 0 0 gka-18 125 16 120 0 0 118 1 7 16 2 gka-25 100 495 42 0 0 0 1 100 495 42 b-50-1 50 108 11 0 0 0 5 50 108 11 b-50-2 50 118 11 3 0 0 4 47 118 11 b-100-1 100 464 41 0 0 0 0 100 464 41 b-100-2 100 482 42 0 0 0 0 100 482 42 Table 1 A representative sample of preprocessed datasets. Each instance initially has |V | vertices and |E| edges, and a min OCT size of OP T . Preprocessing partitions V = Vr ] Vo ] Vb ] V 0 , where Vr are removed, Vo (Vb ) must (must not) be in the OCT set for some fixed, optimal OCT, and V 0 are remaining unlabeled vertices. Likewise, edges are partitioned into E = Er ] E 0 , where Er are removed edges and E 0 are remaining edges. The reduced graph has |V 0 ∪ Vb | vertices, |E 0 | edges, and a min OCT size of OP T 0 .

We denote reductions as a partition of the original vertex set V = Vr ] Vo ] Vb ] V 0 . The vertices that may be removed without changing OP T are denoted Vr . For some fixed optimal solution S, vertices Vo must be in S and vertices Vb cannot be in S. Finally, the remaining vertices are labeled V 0 . Analogously, the edges are partitioned into E = Er ] E 0 . The removed vertices/edges and fixed OCT vertices may be removed from the graph safely, therefore the preprocessed graph has vertices Vb ∪ V 0 and edges E 0 . Table 1 summarizes preprocessing results on several representative instances; full results are in Appendix B (Table 7). There are several noteworthy observations. First, a number of instances can be solved entirely with preprocessing; we leave the resulting empty graphs in our dataset for consistency with prior experiments, but remark that they provide no meaningful insights into solver performance. Second, the effects of preprocessing are highly variable across types of data. In the WH datasets, which are expected to be bipartite with errors based on domain knowledge, preprocessing typically removes a significant number of vertices, and is able to establish that many more can be fixed as bipartite. In contrast, the reduction routines identify vertices in the GKA datasets which can be fixed as OCT and removed from the graph, significantly reducing the complexity of solving (since OCT is FPT with respect to solution size), but almost no other preprocessing techniques apply. Finally, Beasley datasets saw little to no effect from preprocessing.

4

Heuristics and Iterative Compression

In this section we overview heuristics for upper-bounding OCT, and engineer improvements to Hüffner’s algorithm using a heuristic solution and subgraph density information to determine the order in which the iterative compression algorithm considers vertices.

XX:8


OCT Size Dataset p Mean S.D. Min 25% 50% 75% Max Timeout: 1 (s) aa-42

gka-2

0 1 2 0 1 2

51.8 31.0 31.9 16.8 16.0 16.0

13.4 1.2 0.3 0.9 0.0 0.0

33 30 31 16 16 16

42 30 32 16 16 16

49 31 32 17 16 16

59 32 32 17 16 16

85 35 32 19 16 16

14.4 1.2 0.7 1.6 0.5 0.5

48 40 40 23 23 23

55 40 41 24 23 23

64 41 41 25 23 23

75 42 41 26 24 24

110 44 43 29 24 24

Timeout: 10 (s) aa-41

gka-3

0 1 2 0 1 2

67.0 41.4 41.2 25.2 23.3 23.4

Table 2 Heuristic solution sizes for select datasets at the three levels of preprocessing (p ∈ {0, 1, 2}) for Improved Hüffner. The timeout level on each dataset was taken to be the maximum time in {0.01, 0.1, 1, 10} less than the time Hüffner at p = 0 took to find an exact solution. Mean, standard deviation, and quintiles are computed over 50 samples per timeout, dataset, and preprocessing level.

4.1

Heuristic Algorithms

Heuristics for OCT typically compute a maximal bipartite induced subgraph, then label all remaining vertices as an odd cycle transversal. One strategy for finding a large bipartite subgraph is greedily 2-coloring the vertices using a depth-first search, adding incompatible vertices to an OCT set as needed [35]; this heuristic has a natural breadth-first search variant. Both of these methods are nondeterministic with the choice of the initial vertex and in the order which neighbors are added to the search queue. Another approach is to find an independent set for the first partite set, then repeat for a second partite set, for example as in Luby’s Algorithm [26]. Recent work showed that by using the minimum-degree heuristic for independent set, this strategy gives a d-approximation in d-degenerate graphs [12]. Both of these methods are nondeterministic; the former is stochastic by design, and the latter breaks ties between minimum degree vertices. We provide implementations of these four heuristics (DFS, BFS, Luby, and MinDeg), along with an ensemble solver that runs them round-robin for a specified timeout; see Appendix A.3 for implementation considerations.

4.2

Improving Hüffner’s Iterative Compression Algorithm

The state-of-the-art implementation for solving OCT directly is by Hüffner, and is based on iterative compression, a standard technique from parameterized complexity [30], where a solution of size k + 1 on a subgraph is compressed to a solution of size k for the same subgraph in time O∗ (f (k)). Although prior work has shown that iterative compression is slower than VC-based algorithms both in theory [23] and in practice [3], we observe that it may have an advantage in some quantum use cases. Specifically, since this approach maintains a lower bound on OCT and computes increasingly better upper bounds, it can be applied to improve non-optimal solutions in time-limited settings. We use an engineered version of Hüffner’s implementation in our experiments; in this section, we describe these modifications and their impacts on solution quality under varying timeouts. Hüffner’s OCT implementation iterates over an ordering of V , starting with both subgraph


and OCT set equal to the initial k +1 vertices, then repeatedly compressing and incorporating the next unused vertex in the ordering. The algorithm’s performance can vary significantly depending on the ordering used. We first show that a heuristic solution can be used to reduce the number of compressions executed. Hüffner (correctly) noted that starting with a heuristic solution on the full graph and compressing down would lead to an exponentially-slower algorithm. Instead of taking this approach, we instead use the bipartite subgraph G \ S 0 identified in a heuristic solution S 0 to define the initial subgraph. By placing these |G \ S 0 | bipartite vertices at the start of the vertex ordering, the initial compression routine will execute with the next k + 1 vertices as an OCT set on a subgraph of the first |G \ S 0 | + k + 1 vertices, effectively reducing the number of compression routine executions by |G \ S 0 |. Second, exploiting Hüffner’s branching speedups on dense graphs, we order the remaining vertices in S 0 based on their degree into the subgraph. Hüffner’s pruning of the search space of k-sized solutions operates by eliminating (in)feasible solutions based on the presence of edges (e.g., two adjacent vertices cannot be assigned the same partite set), therefore the compression routine performs best when the graph is as dense as possible. We can maximize this density by adding vertices based on their degree into the current iteration’s subgraph. At a minimum, this heuristic improvement will eliminate the addition of vertices with no edges into the current graph, a clear worst-case. Finally, we note that Hüffner’s branching rules for reducing the search space of size k solutions using the connectivity of the OCT set can be improved with data from preprocessing. Specifically, vertices in Vb will fix bipartite components and reduce the search space. However, given the lack of these preprocessing reductions in QUBO data (Section 3.3), we leave this extension as future work.

4.3

Improvement Evaluation

We implement our heuristic improvements in a version of Hüffner’s code improved for simplicity and compiler compatibility. Details are deferred to Appendix A.4. In this Improved Hüffner (IC+ p ) algorithm we require two new parameter inputs: a preprocessing optimization level p ∈ {0, 1, 2}, and a preprocessing timeout. The preprocessing optimization levels are none (0), bipartite-heuristic only (1), and bipartite-heuristic with density sorting (2). We found that setting the preprocessing timeout to 30% of the total timeout for a maximum of one second provided optimal performance. To evaluate these preprocessing options, we selected a subset of the data (c.f., Table 3) with a mixture of easy and difficult problems. We then ran all three levels using 50 random seeds on each instance for each of four timeouts {0.01, 0.1, 1, 10}, and report mean, standard deviation, and quintiles of the OCT sizes found. A representative sample of results is in Table 2, with full results in Appendix B (Table 9). We find that p = 1 always dominates p = 0, especially in max and standard deviation, suggesting that certain orderings (avoided with p = 1) are significantly disadvantageous for iterative compression. Second, we find that p = 2 tends to help on larger timeouts, where the run time cost of computing this ordering disappears. Both observations can be seen in Table 2, where aa-41 and aa-42 benefit slightly from p = 2, but gka-2 and gka-3 do not.

5

Integer Linear Programming Solvers

As noted in the introduction, previous work [16, 3] has conflicting reports on the effectiveness of Integer Linear Programming (ILP) solvers. In this section we identify the best

XX:9


Preprocessed Graph

Solver

Dataset

|V |

|E|

OP T

Time (s)

CPLEXVC 4

gka-1 aa-43 aa-45 gka-2 aa-29 aa-42 aa-32 gka-3 aa-41 gka-26 gka-24 gka-25 gka-29 gka-27 gka-28

44 58 75 58 265 226 126 70 261 100 90 100 100 100 100

90 303 381 149 1048 1100 733 223 1585 494 400 495 2000 1016 1425

9 18 20 16 21 30 30 23 40 43 37 42 77 62 70

0.1 0.1 0.1 0.1 0.1 0.3 0.4 0.8 0.7 16.8 17.8 24.4 36.3 107.4 142.0

1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0×

CPLEXVC 1

GLPKVC 1

1.0× 1.0× 1.0× 4.0× 4.0× 4.0× 3.0× 5.6× 2.3× 3.3× 5.5× 8.2× 11.7× 4.1× 2.7×

3.0× 163.0× 389.0× 206.0× 2375.0× -

Table 3 Relative run times for solving exactly with the OCT → VC → ILP formulation and 16GB of memory. Multithreaded CPLEX is used as the baseline time. Times are not reported for configurations that required more than 10 minutes.

configuration for solving OCT with ILP with the following options: choosing a solver from CPLEX [17] and GLPK [11], choosing a formulation from OCT → ILP and OCT → VC → ILP, having one thread or multithreaded (4 physical cores), and having limited system memory (4MB) or plentiful memory (16GB). This memory limit is significant because [16] notes that Hüffner’s implementation only requires 4MB of memory and there may be a use case that requires minimal memory usage. We find that CPLEX and OCT → VC → ILP result in the fastest solutions, that multithreading can result in superlinear speedup, and that increased system memory can provide up to a 2× speedup depending on the instance.

5.1

Experimental Evaluation

To evaluate ILP-based approaches, we use the same subset of data selected in Section 4.3 and solve with all possible combinations of solver, threads, and OCT formulation described above (denoted SolverFormulation ). (Note that GLPK is single-threaded). T hreads CPLEX Solution Times (16 GB) 400 Time (s)

300

CPLEXOCT 1 CPLEXOCT 4

200

CPLEXVC 1 CPLEXVC 4

100

gka-28

gka-27

gka-29

gka-25

gka-24

gka-26

gka-3

aa-41

aa-32

aa-42

gka-2

aa-29

aa-45

gka-1

0 aa-43

XX:10

Dataset

Figure 2 Run times for CPLEX configurations with 16GB of system memory. Times are not reported for configurations that required more than 10 minutes.


XX:11

Comparing solvers, CPLEX dominated GLPK when using the same formulation, regardless of number of threads or system memory levels. Table 3 depicts the relative run times when fixing the formulation to OCT → VC → ILP and system memory to 16GB. Interestingly, CPLEXVC often performed over four times faster than its single-threaded variant. 4 Comparing problem formulations, OCT → VC → ILP also dominated OCT → ILP (Figure 2). This result may not be surprising given [23], but it suggests that there may also be alternative, faster formulations of OCT as an ILP that may lead to even better results. In extended results (Appendix B, Figure 3 and Table 6) we find that limiting the solvers to 4MB of system memory does not change the relative performance landscape, and only doubles the run time of the slowest dataset gka-28. However, our results together with the run times from Section 6 suggest that using ILP would still be preferable when time is not extremely limited.

6

Experimental Results

In this section, we evaluate all solvers in our two quantum-computing–inspired use cases.

Use Case: Heuristic Solutions For the first use case, a quantum compiler may need a bipartization of an input program (e.g., a QUBO or circuit) in order to prune a search space of embeddings, but has a very small time budget for this step. We thus computed heuristic solutions for OCT on each preprocessed instance with timeouts of 0.01, 0.1, 1.0, and 10 seconds using three solvers: the heuristic ensemble from Section 4.1 (HE); Improved Hüffner from Section 4.2 with optimization level p = 2 (IC+ 2 ); and the best ILP configuration from Section 5 using CPLEX with an OCT → VC → ILP formulation, 4 threads, and 16GB of memory (ILP). At the timeout, we recorded the current best solution known to the solver and the time taken to find it. We report approximation factors in Table 4, with full results in Appendix B (Tables 11 and 12). Notably, a user could achieve worst-case approximation factors of 1.29 and 1.18 for timeouts 0.01(s) and 0.1(s) (respectively) by solving with IC+ 2 , and approximation factors of 1.10 and 1.02 for timeouts 1(s) and 10(s) by solving with ILP. Timeout:

0.01(s)

0.1(s)

1(s)

10(s)

Dataset

HE

IC+ ILP 1

HE

IC+ ILP 1

HE

IC+ ILP 2

HE

IC+ ILP 2

aa j b-50 b-100 gka

1.38 1.11 1.11 1.10 1.21

1.29 1.23 1.09 1.10 1.18

1.27 1.11 1.09 1.07 1.18

1.17 1.11 1.07 1.07 1.18

1.19 1.00 1.08 1.05 1.11

1.12 1.00 1.00 1.05 1.14

1.19 1.00 1.00 1.05 1.11

1.06 1.00 1.00 1.05 1.14

8.05 1.60 1.56 1.17 1.34

2.19 1.00 1.21 1.17 1.18

1.00 1.00 1.00 1.10 1.07

1.00 1.00 1.00 1.02 1.02

Table 4 Observed approximation factors for heuristic solutions over datasets aa, j, b-50, b-100, and gka. For each dataset, we report the worst-case approximation ratio over its instances. Approximation ratios are with respect to OP T , computed and cross-validated with ILP and A-I.

Use Case: Exact Solutions In the second use case, a researcher may want to compute the limits of particular configurations supported on a fixed hardware graph. By recognizing if the OCT size of a problem graph is too large for the hardware, we can reject a configuration without trying to embed. We thus computed exact solutions with a 10 minute timeout on preprocessed instances using the three solvers that could guarantee optimality: the Akiba-Iwata (A-I) VC-solver [3], IC+ 2 , and ILP.

XX:12


The majority of the results roughly mirror those of [3]: A-I and ILP solve optimally within three seconds, and IC+ 2 run times rapidly increase with the OCT size. However, Table 5 lists the datasets that are more computationally difficult, and here we find that ILP bests A-I in the majority of instances. Full data is available in Appendix B (Table 10). Graph

Solver

Dataset

OP T

b-100-1 b-100-2 b-100-3 b-100-4 b-100-5 b-100-6 b-100-7 b-100-8 b-100-9 b-100-10 gka-3 gka-8

41 42 42 41 42 43 42 43 44 44 23 28

A-I

IC+ 2

Graph ILP

97.8 - 21.3 185.5 - 52.7 242.3 - 20.9 199.8 - 33.1 208.6 - 41.7 143.6 - 99.6 182.0 - 40.4 356.7 - 39.3 321.4 - 72.9 188.6 - 118.3 1.4 58.0 0.9 7.2 4.8

Solver

Dataset OP T gka-21 gka-22 gka-23 gka-24 gka-25 gka-26 gka-27 gka-28 gka-29 gka-30 gka-31 gka-32

40 43 46 37 42 43 62 70 77 82 85 88

A-I

IC+ 2

ILP

1.7 22.2 0.3 5.4 1.0 42.6 - 16.9 74.3 - 17.3 122.9 - 28.6 160.5 - 18.4 535.3 - 192.6 284.9 - 366.0 64.3 - 42.5 32.7 - 53.2 11.7 107.6 17.4 5.3 17.9 19.2

Table 5 Run times on select instances for solvers A-I, IC+ 2 , and ILP. Times are not reported for configurations that required more than 10 minutes.

7

Conclusion

We experimentally evaluate state-of-the-art approaches to computing Odd Cycle Transversal on both the canonical WH dataset and on a new benchmark dataset from quantum annealing. On this expanded corpus, we find that there is no single implementation that dominates in all scenarios. Under extreme time constraints, low-overhead heuristics followed by iterative compression performs best. However, even with a 10 second time limit, heuristics quickly become ineffective when compared with modern ILP solvers (which come with the additional benefit of scaling with additional CPU and memory resources). If open source code is required, however, the Akiba-Iwata VC-solver becomes competitive. Our results identify several important directions for future work: Development of lightweight solvers with efficient implementations. While suites such as CPLEX dominate the exact solver comparisons, there are opportunities to improve in the very short run time scenarios where low overhead is paramount. Efficient implementations of reduction routines, heuristics, and incremental improvement algorithms are needed here. Increasing scalability of existing algorithms. Akiba-Iwata and Hüffner both leverage combinatorial structure for lightweight, competitive algorithms. However, both current implementations are written for serial processors and use relatively little system memory. CPU-based parallelism would benefit the branch-and-reduce strategy, while GPU-based Single-Instruction-Multiple-Data parallelism fits well with Hüffner’s compression routine. Exploring formulations of OCT as ILP. We found that formulating OCT as VC led to a more efficient ILP formulation. Additional structures (such as those from biased graphs [34]) may lead to even faster ILP formulations.

Acknowledgments This work supported in part by the Gordon & Betty Moore Foundations Data-Driven Discovery Initiative through Grant GBMF4560 to Blair D. Sullivan, and a fellowship by the National Defense Science & Engineering Graduate Program to Timothy D. Goodrich.


References 1

2

3 4 5 6

7 8 9

10 11 12

13

14

15 16 17 18 19

√ Amit Agarwal, Moses Charikar, Konstantin Makarychev, and Yury Makarychev. O( log n approximation algorithms for min UnCut, min 2CNF deletion, and directed cut problems. In Proceedings of the thirty-seventh annual ACM symposium on Theory of computing, pages 573–581. ACM, 2005. Muhammad Ahsan, Rodney Van Meter, and Jungsang Kim. Designing a million-qubit quantum computer using a resource performance simulator. ACM Journal on Emerging Technologies in Computing Systems (JETC), 12(4):39, 2016. Takuya Akiba and Yoichi Iwata. Branch-and-reduce exponential/fpt algorithms in practice: A case study of vertex cover. Theoretical Computer Science, 609:211–225, 2016. John E. Beasley. OR-Library. URL: http://people.brunel.ac.uk/~mastjjb/jeb/info. html. John E. Beasley. Heuristic algorithms for the unconstrained binary quadratic programming problem. London, England, 1998. Edward Boyda, Saikat Basu, Sangram Ganguly, Andrew Michaelis, Supratik Mukhopadhyay, and Ramakrishna R Nemani. Deploying a quantum annealing processor to detect tree cover in aerial imagery of California. PloS one, 12(2):e0172505, 2017. Vicky Choi. Minor-embedding in adiabatic quantum computation: II. Minor-universal graph design. Quantum Information Processing, 10(3):343–353, 2011. Rigetti Computing. The Rigetti QPU, 2018. URL: http://pyquil.readthedocs.io/en/ latest/qpu.html. Iain Dunning, Swati Gupta, and John Silberholz. What works best when? a framework for systematic heuristic evaluation. 2015. URL: http://www.optimization-online.org/ DB_FILE/2015/05/4895.pdf. Fred Glover, Gary A. Kochenberger, and Bahram Alidaee. Adaptive memory tabu search for binary quadratic programs. Management Science, 44(3):336–345, 1998. GNU. Linear Programming Kit (GLPK), Version 4.61. URL: http://www.gnu.org/ software/glpk/glpk.html. Timothy D. Goodrich, Blair D. Sullivan, and Travis S. Humble. Optimizing adiabatic quantum program compilation using a graph-theoretic framework. Quantum Information Processing, 17(5):118, Apr 2018. Aric A. Hagberg, Daniel A. Schult, and Pieter J. Swart. Exploring network structure, dynamics, and function using NetworkX. In Gaël Varoquaux, Travis Vaught, and Jarrod Millman, editors, Proceedings of the 7th Python in Science Conference, pages 11 – 15, Pasadena, CA USA, 2008. Kathleen E. Hamilton and Travis S. Humble. Identifying the minor set cover of dense connected bipartite graphs via random matching edge sets. Quantum Information Processing, 16(4):94, 2017. Falk Hüffner. occ graph bipartization solver. URL: http://theinf1.informatik. uni-jena.de/occ/. Falk Hüffner. Algorithm engineering for optimal graph bipartization. Journal of Graph Algorithms and Applications, 13(2):77–98, 2009. IBM. CPLEX Optimization Studio 12.8. URL: https://www.ibm.com/analytics/ data-science/prescriptive-analytics/cplex-optimizer. IBM. IBM announces advances to IBM Quantum Systems & Ecosystem, 2018. URL: http://www-03.ibm.com/press/us/en/pressrelease/53374.wss. Yoichi Iwata, Keigo Oka, and Yuichi Yoshida. Linear-time fpt algorithms via network flow. In Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms, pages 1749–1761. Society for Industrial and Applied Mathematics, 2014.

XX:13

XX:14


20 21 22

23

24

25

26 27 28

29

30 31

32

33

34

35

Yoichi Iwata, Yutaro Yamaguchi, and Yuichi Yoshida. 0/1/all CSPs, half-integral A-path packing, and linear-time fpt algorithms. arXiv preprint arXiv:1704.02700, 2017. Bart Kosko. Bidirectional associative memories. IEEE Transactions on Systems, man, and Cybernetics, 18(1):49–60, 1988. Stefan Kratsch and Magnus Wahlström. Compression via matroids: a randomized polynomial kernel for odd cycle transversal. ACM Transactions on Algorithms (TALG), 10(4):20, 2014. Daniel Lokshtanov, NS Narayanaswamy, Venkatesh Raman, MS Ramanujan, and Saket Saurabh. Faster parameterized algorithms using linear programming. ACM Transactions on Algorithms (TALG), 11(2):15, 2014. Daniel Lokshtanov, Saket Saurabh, and Somnath Sikdar. Simpler parameterized algorithm for oct. In International Workshop on Combinatorial Algorithms, pages 380–384. Springer, 2009. Daniel Lokshtanov, Saket Saurabh, and Magnus Wahlström. Subexponential parameterized odd cycle transversal on planar graphs. In LIPIcs-Leibniz International Proceedings in Informatics, volume 18. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2012. Michael Luby. A simple parallel algorithm for the maximal independent set problem. SIAM journal on computing, 15(4):1036–1053, 1986. Andrew Lucas. Ising formulations of many NP problems. Frontiers in Physics, 2:5, 2014. Hartmut Neven, Geordie Rose, and William G. Macready. Image recognition with an adiabatic quantum computer I. mapping to quadratic unconstrained binary optimization. arXiv preprint arXiv:0804.4457, 2008. Thomas E Potok, Catherine D Schuman, Steven R Young, Robert M Patton, Federico Spedalieri, Jeremy Liu, Ke-Thia Yao, Garrett Rose, and Gangotree Chakma. A study of complex deep learning networks on high performance, neuromorphic, and quantum computers. In Machine Learning in HPC Environments (MLHPC), Workshop on, pages 47–55. IEEE, 2016. Bruce Reed, Kaleigh Smith, and Adrian Vetta. Finding odd cycle transversals. Operations Research Letters, 32(4):299–301, 2004. Jonathan Schrock, Alex J. McCaskey, Kathleen E. Hamilton, Travis S. Humble, and Neena Imam. Recall performance for content-addressable memory using adiabatic quantum optimization. Entropy, 19(9):500, 2017. Davide Venturelli, Minh Do, Eleanor Rieffel, and Jeremy Frank. Compiling quantum circuits to realistic hardware architectures using temporal planners. Quantum Science and Technology, 2017. Davide Venturelli, Salvatore Mandra, Sergey Knysh, Bryan O’Gorman, Rupak Biswas, and Vadim Smelyanskiy. Quantum optimization of fully connected spin glasses. Physical Review X, 5(3):031040, 2015. Magnus Wahlström. LP-branching algorithms based on biased graphs. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1559–1570. Society for Industrial and Applied Mathematics, 2017. Sebastian Wernicke. On the algorithmic tractability of single nucleotide polymorphism (SNP) analysis and related problems. Diplomarbeit, WilhelmSchickard-Institut für Informatik, Universität Tübingen„ 2003.


A A.1

Implementation Details Data Implementation

Original data comes from two sources. Wernicke-Hüffner data is provided in the Hüffner code download [15], and Beasley and GKA data comes from Beasley’s repository [4]. When parsing the graphs with Python we read them into NetworkX graph and remove edges with zero weights (used to denote non-edges in some problems) and self-loops. We then relabel the vertices to {0, . . . , n − 1}. To remove possible non-determinism in how vertices are relabeled, we specify that convert node labels in sorted order, guaranteeing that each graph is always converted in the same way. See the DATA.md document in our repository for information on how to use our scripts for automating this download and parsing process.

A.2

Preprocessing Routines

Reduction routines for preprocessing come from two papers: Wernicke [35] and Akiba and Iwata [3]. While Wernicke originally implemented his in Java, the code does not appear to have been open sourced. We implement his reduction routines in Python3 with NetworkX. Some care must be taken that these reductions operate nondeterministically so the results can be reproduced. Specifically, reduction rules 4 and 6 require vertex cuts, which are computed by NetworkX are returned in arbitrary order; we convert the cuts to tuples and sort them by vertex name (recall vertices are named from {0, . . . , n − 1}). Additionally, reduction rules 7, 8, and 9 find and remove particular configurations in the graph based on degree 2 and 3 vertices; we sort these sets of vertices and the related neighborhoods. For Akiba and Iwata’s reduction routines, we modify their GitHub code2 so that no branching is done after the first iteration of reduction routines, and the preprocessed graph is output instead. To preprocess a graph, we apply Wernicke reductions first, then Akiba-Iwata reductions, and repeat until the graph does not change. This was done primarily because some of Akiba-Iwata’s reductions will not apply after the Wernicke reductions, simplifying the conversion from VC to OCT. In order to make our experiments replicable, we verified that these reductions are nondeterminstic by performing multiple rounds of preprocessing on different machines and checking that the resulting graphs were isomorphic, if small enough to be feasible, and had matching degree, triangle, and number of cliques sequences using the NetworkX could_be_isomorphic method otherwise. To verify that these reductions are safe, we saved and verified a certificate from each run of a solver that returned a feasible solution. See the PREPROCESSING.md document in our repository for information on how to run our scripts for preprocessing.

A.3

Heuristics

We implemented the heuristic ensemble in Modern C++14. Given a graph file and a timeout, the ensemble will run greedy independent set (MinDeg), Luby’s Algorithm (Luby), DFS 2-coloring (DFS), and BFS 2-coloring (BFS) in a round-robin fashion until the time limit

2

https://github.com/wata-orz/vertex_cover

XX:15

XX:16


is reached, returning the single best solution found by any heuristic. See [12] for more on MinDeg, [26] for more on Luby, and [35] for more on DFS. See the HEURISTIC.md document in our repository for information on how to run the heuristic ensemble solver.

A.4

Hüffner Improvements

We implemented our improvements to Hüffner’s implementation [16, 15] in Modern C++14, and rewrote the original solver to compile in C11. By default, the enum2col solver is run, with the preprocessing level p specified by the user: The default algorithm (p = 0), the default algorithm with a heuristic bipartite subgraph starting the ordering (p = 1), and the default algorithm with a heuristic bipartite subgraph starting the ordering and the remaining vertices sorted such that the most number of edges appear in the subgraph the earliest (p = 2). See the IC.md document in our repository for information on how to download, install, and run this improved iterative compression solver.


B

XX:17

Extended Results CPLEX Solution Times (4 MB)

Time (s)

400 300

CPLEXOCT 1

200

CPLEXOCT 4

100

CPLEXVC 4

CPLEXVC 1

gka-28

gka-27

gka-29

gka-25

gka-24

gka-26

aa-41

gka-3

aa-32

aa-42

gka-2

aa-29

aa-45

gka-1

aa-43

0

Dataset Figure 3 Run times for CPLEX configurations with 4MB of system memory. Times are not reported for configurations that required more than 10 minutes.

Preprocessed Graph

Solver

Dataset

|V |

|E|

OP T

Time (s)

CPLEXVC 4

gka-1 aa-43 aa-45 gka-2 aa-29 aa-42 aa-32 gka-3 aa-41 gka-26 gka-24 gka-25 gka-29 gka-27 gka-28

44 58 75 58 265 226 126 70 261 100 90 100 100 100 100

90 303 381 149 1048 1100 733 223 1585 494 400 495 2000 1016 1425

9 18 20 16 21 30 30 23 40 43 37 42 77 62 70

0.1 0.1 0.1 0.1 0.1 0.3 0.4 0.7 0.7 26.1 20.7 35.3 44.1 139.0 317.1

1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0× 1.0×

CPLEXVC 1

GLPKVC 1

1.0× 1.0× 1.0× 4.0× 4.0× 4.0× 3.0× 6.4× 2.3× 2.1× 4.9× 8.5× 10.5× 3.2× 1.4×

3.0× -

Table 6 Relative run times for solving exactly with the OCT → VC → ILP formulation and 4MB of memory. Multithreaded CPLEX is used as the baseline time. Times are not reported for configurations that required more than 10 minutes.

XX:18


Original Graph Dataset aa-10 aa-11 aa-13 aa-14 aa-15 aa-16 aa-17 aa-18 aa-19 aa-20 aa-21 aa-22 aa-23 aa-24 aa-25 aa-26 aa-27 aa-28 aa-29 aa-30 aa-31 aa-32 aa-33 aa-34 aa-35 aa-36 aa-37 aa-38 aa-39 aa-40 aa-41 aa-42 aa-43 aa-44 aa-45 aa-46 aa-47 aa-48 aa-49 aa-50 aa-51 aa-52 aa-53 aa-54 j-10 j-11 j-13 j-14 j-15 j-16 j-17 j-18 j-19 j-20 j-21 j-22 j-23 j-24 j-25 j-26 j-28

|V | 69 103 131 127 67 14 153 90 192 225 31 167 143 261 15 95 120 167 277 39 30 151 194 134 82 112 74 171 145 140 300 237 64 60 83 163 65 90 27 113 79 68 89 90 57 51 78 72 45 14 81 73 101 241 33 76 76 150 14 66 96

Results

Reduced Graph

|E| OP T |Vr | |Er | |Vo | |Vb | |V 0 ∪ Vb | 181 6 10 0 0 30 59 298 11 10 0 0 62 93 375 12 10 0 0 79 121 512 19 16 0 0 66 111 146 7 15 0 1 21 51 0 0 14 0 0 0 0 628 25 7 0 0 91 146 373 14 11 0 0 33 79 636 19 11 0 0 120 181 760 19 7 0 0 161 218 0 9 22 0 9 0 0 636 16 5 0 0 115 162 492 18 21 0 0 69 122 1099 21 12 0 0 169 249 0 1 14 0 1 0 0 255 13 21 0 1 33 73 322 11 12 0 0 61 108 841 27 13 0 0 89 154 1048 21 12 0 0 197 265 61 4 9 0 0 12 30 0 2 28 0 2 0 0 733 30 25 0 0 61 126 481 4 12 0 0 143 182 440 13 12 0 0 85 122 264 10 6 0 0 38 76 309 7 9 0 0 68 103 120 5 24 0 1 22 49 852 26 10 0 0 94 161 689 23 4 0 0 82 141 604 22 20 0 0 60 120 1585 40 39 0 0 172 261 1100 30 11 0 0 137 226 303 18 6 0 0 18 58 157 10 7 0 0 23 53 381 20 8 0 0 32 75 514 13 17 0 0 89 146 195 14 17 0 1 13 47 330 17 14 0 0 35 76 0 5 22 0 5 0 0 463 18 5 0 0 48 108 268 11 8 0 0 27 71 183 14 20 0 2 14 46 224 12 9 0 0 37 80 222 12 13 0 0 31 77 97 3 20 0 0 13 37 198 5 14 0 0 8 37 153 6 22 0 2 28 54 55 4 52 0 1 3 19 0 1 44 0 1 0 0 0 0 14 0 0 0 0 304 10 20 0 0 20 61 284 9 15 0 0 11 58 116 3 63 0 0 20 38 0 1 240 0 1 0 0 16 9 18 0 7 1 8 384 9 9 0 0 23 67 345 19 25 0 0 1 51 265 4 83 0 1 20 66 0 0 14 0 0 0 0 126 6 29 0 0 10 37 552 13 22 0 0 17 74

|E 0 | OP T 0 181 6 298 11 375 12 512 19 146 6 0 0 628 25 373 14 636 19 760 19 0 0 636 16 492 18 1099 21 0 0 255 12 322 11 841 27 1048 21 61 4 0 0 733 30 481 4 440 13 264 10 309 7 120 4 852 26 689 23 604 22 1585 40 1100 30 303 18 157 10 381 20 514 13 195 13 330 17 0 0 463 18 268 11 183 12 224 12 222 12 97 3 198 5 153 4 55 3 0 0 0 0 304 10 284 9 116 3 0 0 16 2 384 9 345 19 265 3 0 0 126 6 552 13

Table 7 Results of preprocessing the WH datasets. Each instance initially has |V | vertices and |E| edges, and a min OCT size of OP T . Preprocessing partitions V = Vr ] Vo ] Vb ] V 0 , where Vr are removed, Vo (Vb ) must (must not) be in the OCT set for some fixed, optimal OCT, and V 0 are remaining unlabeled vertices. Likewise, edges are partitioned into E = Er ] E 0 , where Er are removed edges and E 0 are remaining edges. The reduced graph has |V 0 ∪ Vb | vertices, |E 0 | edges, and a min OCT size of OP T 0 .


Original Graph Dataset b-50-1 b-50-2 b-50-3 b-50-4 b-50-5 b-50-6 b-50-7 b-50-8 b-50-9 b-50-10 b-100-1 b-100-2 b-100-3 b-100-4 b-100-5 b-100-6 b-100-7 b-100-8 b-100-9 b-100-10 gka-1 gka-2 gka-3 gka-4 gka-10 gka-11 gka-12 gka-13 gka-14 gka-15 gka-16 gka-17 gka-18 gka-19 gka-20 gka-21 gka-22 gka-23 gka-24 gka-25 gka-26 gka-27 gka-28 gka-29 gka-30 gka-31 gka-32 gka-33 gka-34 gka-35

|V | 50 50 50 50 50 50 50 50 50 50 100 100 100 100 100 100 100 100 100 100 50 60 70 80 30 40 50 60 70 80 90 100 125 40 50 60 70 80 90 100 100 100 100 100 100 100 100 100 100 100

Results

XX:19

Reduced Graph 0

|E| OP T |Vr | |Er | |Vo | |Vb | |V ∪ Vb | |E 0 | OP T 0 108 11 0 0 0 5 50 108 11 118 11 3 0 0 4 47 118 11 132 14 0 0 0 3 50 132 14 108 11 4 0 0 8 46 108 11 131 13 0 0 0 3 50 131 13 97 9 7 0 0 5 43 97 9 116 10 1 0 1 4 48 116 9 137 14 0 0 0 4 50 137 14 118 12 4 0 0 2 46 118 12 106 11 2 0 0 6 48 106 11 464 41 0 0 0 0 100 464 41 482 42 0 0 0 0 100 482 42 490 42 0 0 0 1 100 490 42 475 41 0 0 0 0 100 475 41 459 42 0 0 0 0 100 459 42 510 43 0 0 0 0 100 510 43 469 42 0 0 0 0 100 469 42 492 43 0 0 0 0 100 492 43 502 44 0 0 0 1 100 502 44 485 44 0 0 0 0 100 485 44 90 11 4 0 2 9 44 90 9 149 17 1 0 1 1 58 149 16 223 23 0 0 0 4 70 223 23 304 28 0 0 0 0 80 304 28 60 26 0 0 18 0 12 60 8 84 36 0 0 26 0 14 84 10 264 46 0 0 26 0 24 264 20 180 56 0 0 40 0 20 180 16 312 66 0 0 44 0 26 312 22 0 76 4 0 76 0 0 0 0 0 86 4 0 86 0 0 0 0 0 96 4 0 96 0 0 0 0 16 120 0 0 118 1 7 16 2 588 32 0 0 1 0 39 588 31 763 39 0 0 0 0 50 763 39 701 40 0 0 0 0 60 701 40 720 43 0 0 0 0 70 720 43 641 46 0 0 0 0 80 641 46 400 37 0 0 0 0 90 400 37 495 42 0 0 0 1 100 495 42 494 43 0 0 0 0 100 494 43 1016 62 0 0 0 0 100 1016 62 1425 70 0 0 0 0 100 1425 70 2000 77 0 0 0 0 100 2000 77 2414 82 0 0 0 0 100 2414 82 2948 85 0 0 0 0 100 2948 85 3434 88 0 0 0 0 100 3434 88 3907 90 0 0 0 0 100 3907 90 4346 92 0 0 0 0 100 4346 92 0 96 4 0 96 0 0 0 0

Table 8 Results of preprocessing the Beasley and GKA datasets. Each instance initially has |V | vertices and |E| edges, and a min OCT size of OP T . Preprocessing partitions V = Vr ] Vo ] Vb ] V 0 , where Vr are removed, Vo (Vb ) must (must not) be in the OCT set for some fixed, optimal OCT, and V 0 are remaining unlabeled vertices. Likewise, edges are partitioned into E = Er ] E 0 , where Er are removed edges and E 0 are remaining edges. The reduced graph has |V 0 ∪ Vb | vertices, |E 0 | edges, and a min OCT size of OP T 0 .

XX:20


OCT Size Dataset p Mean S.D. Min 25% 50% 75% Max Timeout: 0.01 (s) aa-43

aa-45

gka-1

0 1 2 0 1 2 0 1 2

21.4 18.9 19.5 29.6 21.8 22.7 9.0 9.0 9.0

3.0 0.7 0.6 4.2 0.9 0.7 0.0 0.0 0.0

18 18 18 22 20 21 9 9 9

19 18 19 27 21 22 9 9 9

21 19 20 30 22 23 9 9 9

23 19 20 32 22 23 9 9 9

29 20 20 41 24 24 9 9 9

16.2 1.3 1.7

21 21 21

23 21 23

32 22 24

39 23 25

97 26 28

13.4 1.2 0.3 0.9 0.0 0.0

33 30 31 16 16 16

42 30 32 16 16 16

49 31 32 17 16 16

59 32 32 17 16 16

85 35 32 19 16 16

2.4 0.9 0.4 14.4 1.2 0.7 1.6 0.3 0.3 2.6 0.0 0.0 2.3 0.4 0.4 1.7 0.1 0.0 1.2 0.2 0.2 0.8 0.0 0.0 1.6 0.5 0.5

30 30 30 48 40 40 44 37 37 49 44 44 52 43 43 68 62 63 75 71 72 81 77 77 23 23 23

30 30 31 55 40 41 46 38 38 55 44 44 55 44 44 71 63 63 77 72 72 82 77 77 24 23 23

30 31 31 64 41 41 47 38 38 56 44 44 57 44 44 72 63 63 78 72 72 82 77 77 25 23 23

32 31 31 75 42 41 48 38 38 58 44 44 58 44 44 74 63 63 79 72 72 83 77 77 26 24 24

38 33 31 110 44 43 50 38 38 62 44 44 62 44 44 75 63 63 80 73 73 84 77 77 29 24 24

Timeout: 0.1 (s) aa-29

0 1 2

35.9 22.2 23.9


gka-2

0 1 2 0 1 2

51.8 31.0 31.9 16.8 16.0 16.0


aa-41

gka-24

gka-25

gka-26

gka-27

gka-28

gka-29

gka-3

0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2

31.6 30.8 30.8 67.0 41.4 41.2 47.1 37.9 37.9 56.2 44.0 44.0 57.0 43.8 43.8 72.3 63.0 63.0 78.0 72.0 72.0 82.4 77.0 77.0 25.2 23.3 23.4

Table 9 Heuristic solution sizes for select datasets at the three levels of preprocessing (p ∈ {0, 1, 2}) for Improved Hüffner. The timeout level on each dataset was taken to be the maximum time in {0.01, 0.1, 1, 10} less than the time Hüffner at p = 0 took to find an exact solution. Mean, standard deviation, and quintiles are computed over 50 samples per timeout, dataset, and preprocessing level.


XX:21

Graph

Solver

Dataset OP T

IC+ 2

ILP

Dataset

OP T

0.2 1.0 0.1 1.0 0.1 1.0 0.2 4.7 0.1 1.0 0.1 1.0 0.4 6.4 0.1 1.0 0.2 2.7 0.3 1.1 0.1 1.0 0.2 1.0 0.2 1.0 0.3 1.4 0.1 1.0 0.1 1.0 0.2 1.0 0.2 1.1 0.3 1.1 0.1 1.0 0.1 1.0 0.6 10.2 0.1 1.0 0.2 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.3 1.5 0.3 2.7 0.3 1.5 0.8 48.0 0.4 2.1 0.1 1.0 0.1 1.0 0.2 1.1 0.2 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.2 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.2 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.0 0.1 1.1 0.1 1.0

0.0 0.1 0.1 0.1 0.0 0.0 0.1 0.0 0.2 0.1 0.0 0.1 0.1 0.1 0.0 0.0 0.1 0.1 0.1 0.0 0.0 0.5 0.0 0.1 0.0 0.0 0.0 0.1 0.1 0.1 0.4 0.3 0.1 0.0 0.1 0.1 0.0 0.1 0.0 0.1 0.0 0.1 0.1 0.1 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.1 0.0

j-25 j-26 j-28 b-50-1 b-50-2 b-50-3 b-50-4 b-50-5 b-50-6 b-50-7 b-50-8 b-50-9 b-50-10 b-100-1 b-100-2 b-100-3 b-100-4 b-100-5 b-100-6 b-100-7 b-100-8 b-100-9 b-100-10 gka-1 gka-2 gka-3 gka-4 gka-5 gka-6 gka-7 gka-8 gka-9 gka-10 gka-11 gka-12 gka-13 gka-14 gka-15 gka-16 gka-17 gka-18 gka-19 gka-20 gka-21 gka-22 gka-23 gka-24 gka-25 gka-26 gka-27 gka-28 gka-29 gka-30 gka-31 gka-32 gka-33 gka-34 gka-35

0 6 13 11 11 14 11 13 9 9 14 12 11 41 42 42 41 42 43 42 43 44 44 9 16 23 28 22 16 18 28 2 8 10 20 16 22 0 0 0 2 31 39 40 43 46 37 42 43 62 70 77 82 85 88 90 92 0

aa-10 aa-11 aa-13 aa-14 aa-15 aa-16 aa-17 aa-18 aa-19 aa-20 aa-21 aa-22 aa-23 aa-24 aa-25 aa-26 aa-27 aa-28 aa-29 aa-30 aa-31 aa-32 aa-33 aa-34 aa-35 aa-36 aa-37 aa-38 aa-39 aa-40 aa-41 aa-42 aa-43 aa-44 aa-45 aa-46 aa-47 aa-48 aa-49 aa-50 aa-51 aa-52 aa-53 aa-54 j-10 j-11 j-13 j-14 j-15 j-16 j-17 j-18 j-19 j-20 j-21 j-22 j-23 j-24

6 11 12 19 6 0 25 14 19 19 0 16 18 21 0 12 11 27 21 4 0 30 4 13 10 7 4 26 23 22 40 30 18 10 20 13 13 17 0 18 11 12 12 12 3 5 4 3 0 0 10 9 3 0 2 9 19 3

A-I

Graph

Solver A-I

IC+ 2

ILP

0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.1 0.1 1.0 0.0 0.2 1.2 0.0 0.1 1.0 0.0 0.2 1.1 0.1 0.1 1.0 0.0 0.1 1.0 0.0 0.2 1.4 0.1 0.2 1.1 0.1 0.1 1.0 0.1 97.8 - 21.3 185.5 - 52.7 242.3 - 20.9 199.8 - 33.1 208.6 - 41.7 143.6 - 99.6 182.0 - 40.4 356.7 - 39.3 321.4 - 72.9 188.6 - 118.3 0.1 1.0 0.1 0.4 2.2 0.1 1.4 58.0 0.9 4.4 2.3 0.7 3.4 0.1 0.1 1.0 0.1 0.1 1.0 0.0 7.2 4.8 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.1 1.0 0.0 0.2 1.0 0.1 0.6 1.2 0.1 1.7 22.2 0.3 5.4 1.0 42.6 - 16.9 74.3 - 17.3 122.9 - 28.6 160.5 - 18.4 535.3 - 192.6 284.9 - 366.0 64.3 - 42.5 32.7 - 53.2 11.7 107.6 17.4 5.3 17.9 19.2 4.0 3.1 2.2 2.5 1.2 1.4 0.1 1.0 0.0

Table 10 Run times for solvers Akiba-Iwata (A-I), improved Hüffner (IC1+ for preprocessing with heuristics, and IC2+ for preprocessing with heuristics and density sort), and CPLEXVC (ILP). Times 4 are not reported for configurations that required more than 10 minutes.

XX:22


Timeout:

0.01(s)

0.1(s)

1(s)

IC+ 1

IC+ 1

ILP

HE

IC+ 2

ILP

Wernicke-Hüffner Afro-American Graphs aa-10 6 7 6 8 6 6 aa-11 11 12 11 15 12 11 aa-13 12 15 12 22 15 12 aa-14 19 21 19 35 19 19 aa-15 6 8 6 12 6 6 aa-16 0 0 0 0 0 0 aa-17 25 28 28 41 28 27 aa-18 14 18 14 21 17 14 aa-19 19 22 22 38 21 21 aa-20 19 23 24 129 22 20 aa-21 0 0 0 0 0 0 aa-22 16 17 17 37 17 16 aa-23 18 21 21 35 21 18 aa-24 21 25 27 150 25 24 aa-25 0 0 0 0 0 0 aa-26 12 13 12 14 12 12 aa-27 11 14 11 13 14 11 aa-28 27 33 32 106 31 29 aa-29 21 26 26 169 22 24 aa-30 4 4 4 4 4 4 aa-31 0 0 0 0 0 0 aa-32 30 39 35 47 32 35 aa-33 4 4 4 31 4 4 aa-34 13 16 13 27 13 13 aa-35 10 10 10 10 10 10 aa-36 7 7 7 18 7 7 aa-37 4 5 4 7 4 4 aa-38 26 33 31 102 31 27 aa-39 23 28 27 40 26 26 aa-40 22 25 28 33 22 23 aa-41 40 50 46 172 48 45 aa-42 30 36 35 160 36 33 aa-43 18 19 19 20 19 19 aa-44 10 10 10 15 10 10 aa-45 20 22 22 20 21 22 aa-46 13 18 13 37 16 13 aa-47 13 14 13 15 14 13 aa-48 17 19 18 21 17 17 aa-49 0 0 0 0 0 0 aa-50 18 21 19 27 21 18 aa-51 11 13 11 16 11 11 aa-52 12 13 12 15 12 12 aa-53 12 15 12 18 14 12 aa-54 12 14 12 21 14 12

6 13 12 27 6 0 34 14 20 25 0 16 19 46 0 12 11 32 23 4 0 37 4 13 10 7 4 35 26 28 60 43 18 12 20 13 13 17 0 19 11 12 13 14

6 11 14 19 6 0 26 14 21 22 0 17 19 24 0 12 13 30 22 4 0 32 4 13 10 7 4 31 24 22 46 34 19 10 21 14 13 17 0 20 11 12 14 13

6 11 12 19 6 0 27 14 19 20 0 16 18 21 0 12 11 27 21 4 0 33 4 13 10 7 4 26 25 22 45 32 19 10 20 13 13 17 0 18 11 12 12 12

6 11 12 19 6 0 25 14 19 19 0 16 18 21 0 12 11 27 21 4 0 30 4 13 10 7 4 26 23 22 40 30 18 10 20 13 13 17 0 18 11 12 12 12

6 11 13 19 6 0 26 14 21 22 0 17 19 24 0 12 12 30 22 4 0 32 4 13 10 7 4 31 24 22 46 34 19 10 21 14 13 17 0 19 11 12 13 12

6 11 12 19 6 0 25 14 19 20 0 16 18 21 0 12 11 28 21 4 0 31 4 13 10 7 4 26 23 22 41 30 19 10 20 13 13 17 0 18 11 12 12 12

6 11 12 19 6 0 25 14 19 19 0 16 18 21 0 12 11 27 21 4 0 30 4 13 10 7 4 26 23 22 40 30 18 10 20 13 13 17 0 18 11 12 12 12

Wernicke-Hüffner Japanese Graphs j-10 3 3 3 3 3 5 5 j-11 5 5 5 j-13 4 4 4 4 4 j-14 3 3 3 3 3 j-15 0 0 0 0 0 j-16 0 0 0 0 0 j-17 10 10 10 16 10 j-18 9 10 10 12 10 j-19 3 3 3 3 3 j-20 0 0 0 0 0 j-21 2 2 2 2 2 j-22 9 9 9 9 9 j-23 19 19 19 19 19 j-24 3 3 3 3 3 j-25 0 0 0 0 0 j-26 6 6 6 7 6 j-28 13 13 16 16 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

3 5 4 3 0 0 10 9 3 0 2 9 19 3 0 6 13

Dataset OP T

HE

ILP

HE

3 5 4 3 0 0 10 10 3 0 2 9 19 3 0 6 13

10(s) HE IC+ ILP 2

Table 11 Heuristic solution sizes after 0.01, 0.1, 1, and 10 seconds for the Heuristic Ensemble (HE), Improved Hüffner (IC1+ for preprocessing with heuristics, and IC2+ for preprocessing with heuristics and density sort), and CPLEXVC (ILP) when run on Wernicke-Hüffner datasets. Highlighting 4 indicates instances where the solver found an exact solution before the provided time limit.


Timeout:

XX:23

0.01(s)

0.1(s)

1(s)

IC+ 1

ILP

HE

IC+ 1

ILP

HE

IC+ 2

ILP

Beasley 50-Vertex Graphs b-50-1 11 12 11 b-50-2 11 12 11 b-50-3 14 15 15 b-50-4 11 12 12 b-50-5 13 13 13 b-50-6 9 9 9 b-50-7 9 10 9 b-50-8 14 15 15 b-50-9 12 13 12 b-50-10 11 12 11

15 13 16 14 16 14 12 20 16 13

11 12 14 11 13 9 9 15 13 12

11 11 14 11 13 9 9 15 12 11

12 11 14 11 15 9 9 17 12 11

11 11 14 11 13 9 9 15 13 11

11 11 14 11 13 9 9 14 12 11

11 11 14 11 13 9 9 14 12 11

11 11 14 11 13 9 9 14 12 11

11 11 14 11 13 9 9 14 12 11

11 11 14 11 13 9 9 14 12 11

Beasley 100-Vertex b-100-1 41 b-100-2 42 b-100-3 42 b-100-4 41 b-100-5 42 b-100-6 43 b-100-7 42 b-100-8 43 b-100-9 44 b-100-10 44

Graphs 43 44 44 44 46 45 43 45 45 44 45 46 45 45 47 46 46 47 46 48

46 47 49 45 47 48 47 48 49 50

43 43 45 42 44 45 44 45 45 45

44 44 45 42 44 45 44 45 45 46

46 47 49 45 47 48 47 48 49 50

43 43 44 42 43 45 44 45 45 45

43 43 44 42 43 45 44 45 45 45

43 43 46 42 45 45 43 47 46 46

43 43 44 42 42 45 44 45 45 45

43 43 44 42 43 45 44 45 45 45

42 42 42 42 43 44 42 43 44 45

9 16 24 31 22 16 18 33 2 8 10 20 16 22 0 0 0 2 31 39 42 46 48 38 46 44 64 73 77 84 87 89 91 93 0

12 19 24 33 23 16 18 33 2 8 10 20 16 22 0 0 0 2 32 40 41 49 52 44 47 50 75 94 95 96 95 97 98 98 0

9 16 24 31 22 16 18 33 2 8 10 20 16 22 0 0 0 2 31 39 41 44 48 38 44 44 64 72 77 83 86 89 91 93 0

9 16 24 30 22 16 18 33 2 8 10 20 16 22 0 0 0 2 31 39 42 46 48 38 44 44 63 72 77 83 87 89 90 92 0

9 17 24 33 23 16 18 33 2 8 10 20 16 22 0 0 0 2 31 39 41 46 51 43 47 50 65 74 80 85 88 90 98 98 0

9 16 24 30 22 16 18 31 2 8 10 20 16 22 0 0 0 2 31 39 41 44 47 38 44 44 63 72 77 83 86 89 90 93 0

9 16 23 30 22 16 18 32 2 8 10 20 16 22 0 0 0 2 31 39 41 46 47 38 44 44 63 72 77 83 86 89 90 92 0

9 16 23 28 22 16 18 28 2 8 10 20 16 22 0 0 0 2 31 39 40 43 47 39 45 43 63 71 79 83 87 89 90 92 0

9 16 23 30 22 16 18 31 2 8 10 20 16 22 0 0 0 2 31 39 40 43 46 37 44 44 63 72 77 83 86 88 90 92 0

9 16 23 30 22 16 18 32 2 8 10 20 16 22 0 0 0 2 31 39 41 45 46 38 44 44 63 72 77 83 86 88 90 92 0

9 16 23 28 22 16 18 28 2 8 10 20 16 22 0 0 0 2 31 39 40 43 46 37 43 43 63 71 78 82 85 88 90 92 0

Dataset OP T

GKA Graphs gka-1 9 gka-2 16 gka-3 23 gka-4 28 gka-5 22 gka-6 16 gka-7 18 gka-8 28 gka-9 2 gka-10 8 gka-11 10 gka-12 20 gka-13 16 gka-14 22 gka-15 0 gka-16 0 gka-17 0 gka-18 2 gka-19 31 gka-20 39 gka-21 40 gka-22 43 gka-23 46 gka-24 37 gka-25 42 gka-26 43 gka-27 62 gka-28 70 gka-29 77 gka-30 82 gka-31 85 gka-32 88 gka-33 90 gka-34 92 gka-35 0

HE

9 16 24 31 22 16 18 34 2 8 10 20 16 22 0 0 0 2 31 39 41 46 48 39 45 44 65 73 77 83 86 89 91 93 0

10(s) HE IC+ ILP 2

Table 12 Heuristic solution sizes after 0.01, 0.1, 1, and 10 seconds for the Heuristic Ensemble (HE), Improved Hüffner (IC1+ for preprocessing with heuristics, and IC2+ for preprocessing with heuristics and density sort), and CPLEXVC 4 (ILP) when run on GKA and Beasley datasets. Highlighting indicates instances where the solver found an exact solution before the provided time limit.