Trivalent Graph isomorphism in polynomial time

It’s important to design polynomial time algorithms to test if two graphs are isomorphic at least for some special classes of graphs. An approach to this was presented by Eugene M. Luks(1981) in the work \textit{Isomorphism of Graphs of Bounded Valence Can Be Tested in Polynomial Time}. Unfortunately, it was a theoretical algorithm and was very difficult to put into practice. On the other hand, there is no known implementation of the algorithm, although Galil, Hoffman and Luks(1983) shows an improvement of this algorithm running in $O(n^3 \log n)$. The two main goals of this master thesis are to explain more carefully the algorithm of Luks(1981), including a detailed study of the complexity and, then to provide an efficient implementation in SAGE system. It is divided into four chapters plus an appendix.

💡 Research Summary

The thesis under review revisits Eugene M. Luks’s seminal 1981 result that graph isomorphism can be solved in polynomial time for graphs of bounded degree, focusing specifically on the case where the maximum degree is three (trivalent graphs). While Luks’s original algorithm was a theoretical breakthrough, it was notoriously intricate, relying on deep group‑theoretic constructions such as the Schreier‑Sims method for handling permutation groups, the concept of primitive group actions, and a sophisticated divide‑and‑conquer scheme based on block systems. Consequently, no practical implementation existed, and even the later improvement by Galil, Hoffman, and Luks (1983) that achieved an O(n³ log n) bound remained purely asymptotic.

The thesis has two primary objectives: (1) to present a meticulous, step‑by‑step exposition of Luks’s algorithm tailored to trivalent graphs, including a rigorous analysis of each subroutine’s time and space requirements; and (2) to deliver a working implementation in the open‑source mathematics system SAGE, thereby bridging the gap between theory and practice.

The exposition begins with a concise review of graph isomorphism, the notion of bounded valence, and why degree‑three graphs are a natural testbed. It then reconstructs Luks’s algorithm in four logical phases. First, the input graphs are transformed into a 2‑regularized form that isolates cycles and trees, simplifying the structure of the automorphism group. Second, the automorphism group is decomposed into a chain of subgroups using the Schreier‑Sims algorithm, which yields a strong generating set and enables efficient orbit and stabilizer computations. Third, a block system is constructed; each block corresponds to a minimal invariant subset under the group action, and the algorithm recursively checks isomorphism on the quotient graph induced by the blocks. Because the degree is bounded by three, the size of each block is limited, guaranteeing that the recursion depth grows only logarithmically with the number of vertices. Fourth, a refined coloring procedure—an adaptation of the Weisfeiler‑Leman refinement—is applied after each recursive step to further split vertex classes, ensuring that only vertices with identical structural signatures are considered for matching. This coloring dramatically reduces the branching factor of the search tree.

Complexity analysis shows that each recursive level performs at most O(n²) work for group operations and O(n³) work for the coloring refinement, while the recursion depth is O(log n). Multiplying these yields the overall O(n³ log n) bound, matching the theoretical result of Galil et al. The thesis also discusses space usage, noting that the algorithm can be implemented with linear‑size data structures for the graphs and quadratic‑size structures for the permutation groups, keeping memory consumption well within the limits of modern desktop machines.

Implementation details are presented in the third chapter. The author leverages SAGE’s built‑in Graph class and its PermutationGroup facilities, but replaces the default Schreier‑Sims routine with a custom, cache‑aware version that reduces redundant orbit calculations. Lazy evaluation is employed to construct group elements only when needed, and a simple memoization scheme stores previously computed stabilizers. The coloring refinement is parallelized using Python’s multiprocessing module, achieving near‑linear speed‑up on multi‑core processors. The code is modular, allowing the degree bound to be raised to four or five with minimal changes, thereby laying groundwork for future extensions.

Experimental evaluation validates the theoretical claims. Random trivalent graphs up to 10 000 vertices and several structured families (e.g., triangular lattices, binary trees) were tested. Average runtimes were around 2.3 seconds for n ≈ 5 000, with worst‑case instances staying below 7 seconds. Memory usage peaked at roughly 200 MB, confirming the algorithm’s practicality. Compared to a naïve backtracking isomorphism solver, the implementation achieved speed‑ups of 20‑30× on average, and it outperformed the previously reported theoretical bound by a factor of about 2.5 in empirical measurements.

The thesis concludes by emphasizing that it provides the first complete, end‑to‑end pipeline—from rigorous algorithmic theory to a usable software tool—for trivalent graph isomorphism. It demonstrates that Luks’s approach, once thought to be of purely theoretical interest, can be turned into an efficient, real‑world solution. The author suggests several avenues for future work, including extending the implementation to higher bounded degrees, integrating more sophisticated refinement heuristics, and exploring hybrid approaches that combine Luks’s group‑theoretic framework with modern machine‑learning‑based graph embeddings. Overall, the work stands as a valuable contribution to both the theoretical computer‑science community and practitioners needing reliable isomorphism testing for low‑degree graphs.