--- title: Circle Graph Recognition Algorithm url: https://www.emergentmind.com/topics/circle-graph-recognition-algorithm type: topic --- # Circle Graph Recognition Algorithm A circle graph is the intersection graph of chords in a circle, or formally, a graph $G=(V,E)$ is a circle graph if there exists a set of chords $\{c_v\}_{v\in V}$ on a circle such that $uv\in E$ if and only if $c_u$ and $c_v$ cross. Recognition of circle graphs, that is, deciding whether an input graph admits such a representation, is a central problem in algorithmic graph theory due to connections with split decomposition, unique chord diagram representations of prime circle graphs, and efficient algorithms using advanced combinatorial structures. ## 1. Mathematical Foundation of Circle Graphs A chord diagram $D$ on a set $X$ consists of a circular word in which each $x\in X$ appears exactly twice, with the property that $x$ and $y$ cross in $D$ iff one occurrence of $y$ lies between the two occurrences of $x$ and the other between the opposite arc. The associated circle graph $G(D)$ has vertices $X$ and edges $xy$ whenever $x$ and $y$ cross in $D$ [2512.23492]. Each circle graph admits a decomposition via split decomposition: a split is a bipartition $(A,B)$ of $V$ together with frontier sets so that adjacencies occur only between specified pairs $(A',B')$. A unique split-tree representation, using graph-labelled trees (GLTs), encodes all splits and isolating prime (no nontrivial split) and degenerate (clique or star) subgraphs [1104.3283, 2512.23492]. Prime circle graphs feature a unique chord representation up to reversal [2512.23492]. ## 2. Evolution of Recognition Algorithms Early recognition algorithms were based on recursive structural characterizations, culminating in $O(n^3)$ time via split decomposition plus SAT-based merging of partial representations at prime nodes [1309.2399]. The subquadratic $O((n+m)\alpha(n+m))$ approach of Gioan, Paul, Tedder, and Corneil introduced incremental split decomposition using Lexicographic Breadth-First Search (LBFS) ordering to insert vertices, maintaining the chord property locally via unique chord diagrams at prime nodes [1104.3284, 1104.3283]. The recent breakthrough achieves $O(n+m)$ time by leveraging the PC-tree data structure to maintain split decomposition without union-find overhead. All split-tree and chord diagram updates, including consecutivity checks and merges, become linear or constant amortized per operation [2512.23492]. ## 3. Key Principles and Data Structures **Incremental LBFS and Split Trees:** The algorithm builds the graph in an LBFS order. The "good-vertex" property asserts that the last vertex in any LBFS can be placed so that its neighborhood is a consecutive set in the chord diagram for the current graph. This enables incremental, locality-preserving updates [1104.3284]. **Graph-Labelled Trees (GLTs) and Split-Trees:** The split decomposition is encoded as a tree where internal nodes are graphs (prime or degenerate). Each tree node corresponds to a subgraph of the input with its own local labeling, and the connectivity between leaves encodes adjacencies in the original graph [1104.3283, 2512.23492]. **Consistent Symmetric Cycle (CSC):** CSCs encode chord diagrams for prime blocks in a form amenable to constant-time updates. Endpoints are matched and linked by successor and mate pointers, ensuring operations like testing consecutivity, performing circle-joins, and inserting chords are efficient and preserve diagram invariants [1104.3284, 2512.23492]. **PC-Tree:** PC-trees, generalizing PQ-trees, represent the split-tree structure and marker lists for maintaining clique and star nodes. Prime nodes store just the CSC for their unique chord diagrams. This supports cut-free, efficient subtree identification and repair without global restructuring [2512.23492]. ## 4. Stepwise Description of the Recognition Algorithm The linear-time recognition algorithm [2512.23492] proceeds as follows: 1. **LexBFS Ordering:** Compute a LexBFS ordering $v_1,\dots,v_n$ of the vertices. 2. **Incremental Construction:** Starting with the empty graph, insert each vertex $x$ in order, maintaining the PC-tree (split-tree and chord diagrams). For each insertion: - Identify the minimal subtree $T(N(x))$ containing the neighborhood. - Mark segment extremities as perfect, empty, or mixed relative to $N(x)$. - Depending on the local configuration (clique-node, star-node, hybrid, fully mixed), update the split-tree and, if operating within a prime node, ensure that the touched marker set is consecutive in its CSC (i.e., $MP(u)$ consecutive). - For prime node updates, perform constant-time checks and pointer reassignments in the CSC to insert the new chord or merge blocks. 3. **Termination:** If an insertion fails (e.g., non-consecutivity or circle-join fails), the input is not a circle graph. Otherwise, after $n$ insertions, $G$ is a circle graph. The data structures involved guarantee that all operations are amortized constant or linear in the degree per vertex, leading to an overall $O(n+m)$ runtime [2512.23492]. ## 5. Structural and Complexity Results | Year | Approach | Running Time | Data Structure | |---------|------------------------------|---------------------|---------------------| | Pre-2011| Recursive/SAT (split-based) | $O(n^3)$ | Split-tree + 2-SAT | | 2011 | LBFS + incremental split | $O((n+m)\alpha(n+m))$ | GLT + CSC | | 2025 | LBFS + PC-tree | $O(n+m)$ | PC-tree + CSC | The subquadratic bound $O((n+m)\alpha(n+m))$ relies on union-find in split-tree maintenance, where $\alpha$ is the inverse Ackermann function (practically $\leq 4$) [1104.3283, 1104.3284]. The transition to PC-trees eliminates this factor, exploiting local pointer-based updates and the consecutivity property of LBFS insertions [2512.23492]. ## 6. Extensions and Distributed Protocols The structural characterizations used in sequential algorithms also admit distributed and interactive proof systems for recognizing circle graphs. For example, a three-round Arthur–Merlin protocol with $O(\log n)$ per-node certificates is described for distributed settings, using algebraic conditions on interval models unwrapped from the chord diagram and local neighbor checks of interval containment [2112.03206]. This protocol achieves optimality up to constant factors in certificate size. The partial representation extension problem generalizes recognition: given partial pre-drawn chords, can the representation be extended? An $O(n^3)$ algorithm solves the extension problem using similar split-decomposition and 2-SAT merging at prime nodes, reducing to recognition when there are no pre-specified chords [1309.2399]. ## 7. Correctness, Soundness, and Practical Considerations Soundness is ensured because at every insertion, prime node updates only occur when a valid chord diagram with the required consecutivity exists, by the unique representation theorem for prime circle graphs. Completeness follows from the canonical structure of split-trees—if the input is a circle graph, all requisite consecutivity and merge conditions are satisfiable throughout the insertion process [1104.3284, 2512.23492]. In practice, pointer-based data structures used for CSC and PC-tree representation incur only bounded, local memory movement. Empirical observations on graphs with several hundred thousand vertices indicate linear behavior in $n+m$ for practical instances [1104.3284]. The transition from union-find to PC-tree approaches further simplifies the implementation details and reduces theoretical and practical overhead [2512.23492]. --- Thus, circle graph recognition has evolved from expensive structural or SAT-based global searches to practical, optimal algorithms leveraging split decomposition, advanced labeling trees, and local consecutivity properties, now achieving true linear-time recognition for arbitrary graphs [2512.23492, 1104.3284, 1104.3283, 1309.2399, 2112.03206]. Source: https://www.emergentmind.com/topics/circle-graph-recognition-algorithm