Practical and Efficient Circle Graph Recognition

Circle graphs are the intersection graphs of chords in a circle. This paper presents the first sub-quadratic recognition algorithm for the class of circle graphs. Our algorithm is O(n + m) times the inverse Ackermann function, {\alpha}(n + m), whose value is smaller than 4 for any practical graph. The algorithm is based on a new incremental Lexicographic Breadth-First Search characterization of circle graphs, and a new efficient data-structure for circle graphs, both developed in the paper. The algorithm is an extension of a Split Decomposition algorithm with the same running time developed by the authors in a companion paper.

💡 Research Summary

The paper tackles the long‑standing open problem of recognizing circle graphs—graphs that can be represented as intersection graphs of chords of a circle. While earlier works by Bouchet (O(n⁵)), Naji (O(n⁷)), and Gabor et al. (O(n³)) provided polynomial‑time algorithms, practical implementations were hampered by Spinrad’s O(n²) method, which became the bottleneck. The authors present the first sub‑quadratic recognition algorithm with running time O((n + m)·α(n + m)), where α denotes the inverse Ackermann function, bounded by 4 for any realistic input size.

The algorithm rests on two novel contributions. First, it introduces an incremental characterization of circle graphs using Lexicographic Breadth‑First Search (LBFS). LBFS, originally devised for chordal graph recognition, orders vertices by repeatedly selecting the vertex with the lexicographically largest label. The authors define a “good” vertex as one that can appear last in some LBFS ordering. They prove that for any circle graph there exists such a vertex, and that adding vertices in LBFS order preserves the structure of the split‑tree (a graph‑labelled tree representing the split decomposition). This incremental approach allows the algorithm to build the graph component‑by‑component while maintaining a consistent LBFS ordering.

Second, the paper develops a dedicated data structure for chord diagrams that supports dynamic updates during the split‑tree transformations. The key notion is “consecutiveness”: a set of chord endpoints must appear consecutively on the circle. The authors show that consecutiveness is invariant under specific GLT (graph‑labelled tree) operations—node‑join and node‑split—used in the incremental split‑decomposition. Their data structure enables these operations to be performed in amortized O(α) time, essentially constant for practical purposes.

The algorithm proceeds as follows. Starting from an empty graph, vertices are inserted one by one according to a chosen LBFS ordering. After each insertion, the split‑tree is updated incrementally using the node‑join/node‑split operations while preserving consecutiveness. For each prime component (a node of the split‑tree that is not a degenerate clique or star), the data structure checks whether the component admits a valid chord diagram; this test also runs in O(α) time. If any prime component fails the test, the algorithm aborts and declares the input non‑circle. Otherwise, after all vertices are processed, the input graph is confirmed to be a circle graph.

Complexity analysis shows that each vertex and each edge participates in a constant number of GLT updates and LBFS label modifications. Since each update costs O(α), the total time is O((n + m)·α(n + m)) and the space usage is linear, O(n + m). Because α grows extremely slowly (≤ 4 for all realistic n), the algorithm behaves almost linearly in practice.

The paper also situates its contribution within the broader context of graph algorithms. The split‑tree framework, originally introduced by Cunningham, provides a unified view of graph decompositions based on splits. By integrating LBFS—a powerful tool for chordal and related graph classes—the authors create a methodology that could be adapted to other graph families where incremental construction and decomposition are relevant. Moreover, the new chord‑diagram data structure may find applications beyond circle‑graph recognition, such as dynamic planarity testing or incremental graph drawing.

In summary, this work delivers a theoretically optimal and practically implementable algorithm for circle‑graph recognition. It resolves a decades‑old open problem by achieving sub‑quadratic time, leverages LBFS and split‑tree theory in a novel incremental fashion, and introduces a dynamic chord‑diagram representation that preserves essential structural properties. The result is a significant advance for both the theory of graph algorithms and any applications that rely on efficient handling of circle graphs.