Circle Graph Recognition Algorithm

• Circle Graph Recognition Algorithm is a method to decide if a graph can be represented by intersecting chords in a circle.
• It leverages data structures like PC-trees, CSC, and GLTs to perform incremental updates and achieve linear-time recognition.
• The algorithm utilizes LexBFS ordering and split decomposition to maintain consecutivity in chord diagrams, ensuring optimal performance.

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$ (Paul et al., 29 Dec 2025).

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 (Gioan et al., 2011, Paul et al., 29 Dec 2025). Prime circle graphs feature a unique chord representation up to reversal (Paul et al., 29 Dec 2025).

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 (Chaplick et al., 2013). 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 (Gioan et al., 2011, Gioan et al., 2011).

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 (Paul et al., 29 Dec 2025).

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 (Gioan et al., 2011).

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 (Gioan et al., 2011, Paul et al., 29 Dec 2025).

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 (Gioan et al., 2011, Paul et al., 29 Dec 2025).

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 (Paul et al., 29 Dec 2025).

4. Stepwise Description of the Recognition Algorithm

The linear-time recognition algorithm (Paul et al., 29 Dec 2025) 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 (Paul et al., 29 Dec 2025).

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$) (Gioan et al., 2011, Gioan et al., 2011). The transition to PC-trees eliminates this factor, exploiting local pointer-based updates and the consecutivity property of LBFS insertions (Paul et al., 29 Dec 2025).

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 (Jauregui et al., 2021). 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 (Chaplick et al., 2013).

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 (Gioan et al., 2011, Paul et al., 29 Dec 2025).

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 (Gioan et al., 2011). The transition from union-find to PC-tree approaches further simplifies the implementation details and reduces theoretical and practical overhead (Paul et al., 29 Dec 2025).

---

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 (Paul et al., 29 Dec 2025, Gioan et al., 2011, Gioan et al., 2011, Chaplick et al., 2013, Jauregui et al., 2021).