Detecting almost symmetries of graphs

Abstract

We present a branch-and-bound framework to solve the following problem: Given a graph G and an integer k, find a subgraph of G formed by removing no more than k edges that minimizes the number of vertex orbits. We call the symmetries on such a subgraph “almost symmetries” of G. We implement our branch-and-bound framework in PEBBL to allow for parallel enumeration and demonstrate good scaling up to 16 cores. We show that the presented branching strategy is much better than a random branching strategy on the tested graphs. Finally, we consider the presented strategy as a heuristic for quickly finding almost symmetries of a graph G. The software that was reviewed as part of this submission has been issued the Digital Object Identifier DOI:10.5281/zenodo.840558.

Appendices

Appendix: Detailed computational results

In this appendix we break-out the scaling graph in Fig. 4 into scaling graphs for the individual cases tested. These are presented in Fig. 6. We also present the rest of the results on branching choice robustness, similar to that in Table 4, in Table 7. Also, we provide more test-cases for the branching strategy similar to those given in Fig. 5. These results are in Fig. 7. Finally, in Table 8 we present some computational results on the test suite from Table 2 with a modified branching strategy. In particular, at each node we create three children, two of which are deletion nodes for the two edges highest-ranked by edgeUse and the third fixing both these edges. The hope is this makes the fixing child stronger, making for a more balanced tree while also not loosing much due to the robustness of the branching selection demonstrated in Sect. 4.1. As we can see, this branching strategy is better for the random graphs, miles1500.col, and le450_5b.col, but is worse for the remaining graphs. Overall this strategy apparently does not effectively exploit robustness of edgeUse branching.

Fig. 6

Scaling on various problems

Table 7 edgeUse branching robustness, additional instances

Fig. 7

Random branching (box plot) versus edgeUse branching (black square, number of nodes on right) versus local branching (times, number of nodes on left)

Table 8 Computational results—three children per node

Appendix: Code structure for FindAlmostSymmetry

This appendix provides a brief description for the code structure for FindAlmostSymmetry.

The files NautyGraph.hpp and NautyGraph.cpp provide a C++ wrapper for nauty’s dense graphs with dynamic allocation, allowing for the easy addition and removal of edges. The two main classes are DenseGraph and NautyGraph. DenseGraph is a class for managing graph objects packed in a bit vector format which can be used in nauty. NautyGraph is derived from DenseGraph and provides methods to call nauty’s automorphism routine and accessing the results. For each node A, $E^F_A$ (the graph of fixed edges) and $P_A$ (the graph of permutations) are stored as DenseGraphs. A NautyGraph is used for storing the graph G. NautyGraph.hpp and NautyGraph.cpp also define the class EdgeList, which is used for storing $E^D_A$ for each node A. These three classes all have utilib::PackObject (from PEBBL) as a parent class, allow them to be passed around using MPI by PEBBL (or utilib’s MPI routines).

The files findAlmost.hpp and parFindAlmost.hpp provide the header information for the functions and classes used for the solver, and findAlmost.cpp implements these. The classes defined in findAlmost.hpp provide hooks for PEBBL’s serial interface. Class findAlmost is a derived class of PEBBL’s branching class, and its methods and attributes set up the problem and are common to every search node: the original graph G, the starting budget k, and solver options. Class findAlmostSub is derived from PEBBL’s branchSub class and provides attributes which are specific to a node, and methods which do the node processing. Most of the main while loop in Algorithm 6 is contained in findAlmostSub::boundComputation(), which PEBBL repeatedly calls until either this node is pruned by bound or no more refining can be done for this node, in which case a branching edge is selected using findAlmostSub::findBranchEdge(). Finally, class findAlmostSol is derived from PEBBL’s solution class, and is used for storing, passing, and writing solutions. The remaining functions have names corresponding to those in the paper, e.g., BuildCostMatrix is implemented in buildCostMatrix().

Similarly, the classes in parFindAlmost.hpp provide the hooks for PEBBL’s parallel interface and also has the header information for function using MPI. The function parRefineByMatching() is similar to refineByMatching() but parallelizes the repeated calls to hungarian_solve(). Class parFindAlmost is derived from findAlmost and PEBBL’s parallelBranching class, and has methods that allow instances of it to be passed around using MPI messaging. Similarly, class parFindAlmostSub is derived from findAlmostSub and PEBBL’s parallelBranchSub. In addition to facilitating subproblem passing through MPI, parFindAlmostSub also replaces a few of the methods of findAlmostSub for parallel subproblem management—in particular ensuring parRefineByMatching() is called while the solver is ramping up.