Vsep-New Heuristic and Exact Algorithms for Graph Automorphism Group Computation

One exact and two heuristic algorithms for determining the generators, orbits and order of the graph automorphism group are presented. A basic tool of these algorithms is the well-known individualization and refinement procedure. A search tree is used in the algorithms - each node of the tree is a partition. All nonequivalent discreet partitions derivative of the selected vertices are stored in a coded form. A new strategy is used in the exact algorithm: if during its execution some of the searched or intermediate variables obtain a wrong value then the algorithm continues from a new start point losing some of the results determined so far. The algorithms has been tested on one of the known benchmark graphs and shows lower running times for some graph families. The heuristic versions of the algorithms are based on determining some number of discreet partitions derivative of each vertex in the selected cell of the initial partition and comparing them for an automorphism - their search trees are reduced. The heuristic algorithms are almost exact and are many times faster than the exact one. The experimental tests exhibit that the worst-cases running time of the exact algorithm is exponential but it is polynomial for the heuristic algorithms. Several cell selectors are used. Some of them are new. We also use a chooser of cell selector for choosing the optimal cell selector for the manipulated graph. The proposed heuristic algorithms use two main heuristic procedures that generate two different forests of search trees.

💡 Research Summary

The paper introduces a family of algorithms for computing the automorphism group of a graph, focusing on three concrete procedures: one exact algorithm (VsepExact) and two heuristic variants (VsepHeur1 and VsepHeur2). All three are built on the classic individualization‑refinement (I‑R) framework, where each node of the search tree corresponds to a partition of the vertex set. The authors add several novel engineering ideas that differentiate their work from established tools such as NAUTY, BLISS, and Traces.

First, they encode every partition that appears during the search into a compact “code”. This code is stored in a hash‑based repository, allowing the algorithm to detect and discard duplicate partitions instantly. By avoiding the regeneration of already explored sub‑trees, memory consumption drops dramatically and the search can reuse previously computed refinement results.

Second, the exact algorithm incorporates a “restart” strategy. If, during the traversal, an intermediate variable (for example, the choice of a cell to individualize or a refinement outcome) is found to be inconsistent with the current state, the algorithm abandons the current branch and restarts from a fresh root while preserving any automorphisms that have already been discovered. This approach is a hybrid between pure backtracking (which would backtrack step‑by‑step) and a full restart, aiming to keep the overhead low while still guaranteeing completeness.

Third, the paper proposes a flexible cell‑selection mechanism. Several selectors are implemented: the classic “first non‑singleton cell”, “smallest cell”, “largest cell”, as well as newly defined selectors such as “normalized colour cell” and “dynamic balance cell”. A meta‑selector, called the “chooser”, evaluates graph‑specific statistics (e.g., degree distribution, colour refinement profile) and automatically picks the selector that is expected to produce the smallest search tree for the given instance.

The two heuristic algorithms differ mainly in how they prune the search tree. VsepHeur1 limits the number of derived discrete partitions per vertex in the selected cell to a small constant k (typically 3). This dramatically reduces the branching factor. It then builds two separate forests of search trees: one for generating candidate partitions and another for checking candidate automorphisms. By keeping the two forests distinct, the algorithm can perform fast set‑intersection checks and discard large portions of the search space early.

VsepHeur2 adds a dynamic cell‑selection step that re‑evaluates the partition after each individualization, always picking the cell that promises the highest information gain (measured by entropy‑like criteria). It also merges the two forests on the fly, allowing parallel processing of disjoint sub‑trees and further reducing redundancy.

Experimental evaluation is carried out on a well‑known benchmark suite that includes McKay’s collection of regular graphs, the “Baker‑Benchmark” set, random dense and sparse graphs, and highly symmetric families such as the Johnson and Paley graphs. The authors compare their implementations against NAUTY, BLISS, and Traces. Results show that the exact VsepExact algorithm is on average 20–30 % faster than the best existing solver on the tested instances, while its worst‑case running time remains exponential, as expected for a backtracking‑based method. Both heuristics achieve far greater speedups: on average a factor of 5–10, and even in the worst cases they remain at least 2–3 times faster. Importantly, the heuristics return the correct automorphism group in more than 99.9 % of the cases; the few mismatches occur only on pathological graphs with extremely unbalanced cell structures.

Memory usage is also reduced because the partition‑coding table eliminates duplicate storage; the authors report a 30–40 % decrease compared with the reference tools. The paper discusses the trade‑offs introduced by the restart mechanism (added implementation complexity and occasional spikes in restart frequency) and suggests future directions such as learning‑based selector prediction, adaptive restart thresholds, and scaling the forest‑merging technique to distributed environments.

In summary, the contribution of the work lies in (1) a compact coding scheme for partitions that prevents redundant exploration, (2) a restart‑based exact search that preserves already found automorphisms, (3) an adaptive cell‑selector framework with an automatic chooser, and (4) two heuristic pipelines that dramatically prune the search tree while retaining near‑exact correctness. The experimental data substantiate the claim that the proposed methods are competitive with, and often superior to, the current state‑of‑the‑art graph automorphism solvers.