Cograph Deletion Problem

• Cograph Deletion is the NP-hard problem of removing at most k edges from a graph to eliminate all induced P4 paths, ensuring a P4-free (cograph) structure.
• The approach leverages modular decomposition and module merges, transforming prime modules into merged units to simplify the graph’s structure.
• Advanced techniques include exact, fixed-parameter, and branch-and-reduce algorithms, offering scalable, parameterized solutions for practical applications.

A cograph is a finite simple graph with no induced path on four vertices ($P_4$-free). The Cograph Deletion Problem asks, given a graph $G = (V,E)$ and integer $k \ge 0$, whether it is possible to delete at most $k$ edges from $G$ such that the resulting graph is a cograph. This classical graph modification problem is central in structural graph theory and finds applications in phylogenetics, the analysis of relational data, and network simplification. The following survey covers the precise statements, solution frameworks based on modular decomposition and module merges, algorithmic advances, fixed-parameter tractability, and recent theoretical breakthroughs.

1. Problem Definition and Basic Properties

The Cograph Deletion Problem is defined formally as follows. Given $G = (V,E)$ (an undirected simple graph) and $k \in \mathbb{N}$, decide if there exists $D \subseteq E$ with $|D| \le k$ such that the graph $G' = (V, E \setminus D)$ contains no induced path $P_4$ (sequence of vertices $v_1,v_2,v_3,v_4$ with edges $v_1v_2,v_2v_3,v_3v_4$ and no others, i.e., chordless path). The optimization variant asks for the smallest $D$ such that $G \setminus D$ is a cograph.

Cographs are the graphs generated from the single-vertex graph under disjoint union and complement operations. Cographs are precisely those graphs whose modular decomposition lacks any prime nodes; equivalently, every internal node of their modular decomposition tree is labeled “parallel” (union/disconnected) or “series” (join/co-disconnected), but never “prime” (Hellmuth et al., 2015, Hellmuth et al., 2017).

The problem is NP-hard under standard reductions. In particular, Cograph Deletion (edge-deletion) is a special case of the general Cograph Editing problem, which is known to be NP-complete, and a direct reduction from Vertex Cover provides its NP-hardness (Hellmuth et al., 2015).

2. Modular Decomposition and Prime Modules

Modular decomposition is a canonical tool in the analysis and solution of cograph modification problems. A set $M \subseteq V$ is a module of $G$ if for all $x, y \in M$ and $v \in V \setminus M$ we have $v$ adjacent to $x$ if and only if $v$ is adjacent to $y$. Trivial modules are singletons and $V$ itself. $G$ is prime if its only strong modules are trivial.

The modular decomposition tree (MDT) of $G$ is a rooted tree whose nodes correspond to strong modules, with leaves representing single vertices. Each internal node is labeled as:

• “parallel” if the induced subgraph $G[M]$ is disconnected,
• “series” if the complement $\overline{G[M]}$ is disconnected,
• “prime” if both $G[M]$ and its complement are connected.

The children of a module $M$ are the maximal strong submodules of $M$. For any fixed graph, MDT$(G)$ can be computed in $O(n + m)$ time (Hellmuth et al., 2015, Hellmuth et al., 2017). The decomposition allows divide-and-conquer for edge modification problems: one solves the problem independently on each prime strong module and their quotient graphs.

The following decomposition lemma is central: if every minimal forbidden induced subgraph is prime, then

$$\operatorname{opt}(G) = \operatorname{opt}(G/\mathcal{M}) + \sum_{M_i \in \mathcal{M}} \operatorname{opt}(G[M_i])$$

where $\mathcal{M}$ is any modular partition (Lafond et al., 5 Jan 2026).

3. Equivalence of $P_4$ Deletion and Module Merges

A fundamental insight is that all induced $P_4$s in $G$ are contained entirely in some prime strong module—a fact implied by the Folkman–Fulkerson property (Hellmuth et al., 2015). Rather than searching for and destroying $P_4$s individually, it is sufficient (and optimal) to “resolve” each prime module by merging certain children into larger modules until no prime structure remains.

The merge operation is defined as follows: let $M_1, \ldots, M_p$ be disjoint modules in $G$ (children of a prime module $M$). In $G'$, $M_1, \ldots, M_p$ are merged into $M := \bigcup_{i=1}^p M_i$ if (i) each $M_i$ and $M$ are modules of $G'$ but $M$ is not a module of $G$ (Hellmuth et al., 2015, Hellmuth et al., 2017). This corresponds to editing all edges between $M$ and $V\setminus M$ required to synchronize their adjacencies and collapse $M_1,\ldots,M_p$ into a larger module.

The equivalence theorem states that every optimal cograph deletion set can be realized as a sequence of pairwise module merges across prime modules, and every minimal sequence of such merges corresponds to a unique minimal edge-deletion solution (Hellmuth et al., 2015, Hellmuth et al., 2017). This equivalence underpins algorithmic strategies—solving globally difficult graph editing by orchestrating a local sequence of module merges.

4. Exact and Parameterized Algorithms

The module-merge perspective leads directly to an exact branching algorithm:

• Compute the modular decomposition of $G$.
• Recurse on each prime module $M$ with children $M_1,\ldots, M_\ell$.
• For each unordered pair $(i,j)$, compute the minimum edge set $D_{ij}$ whose deletion merges $M_i$ and $M_j$ (forcing twin structure).
• Branch on deleting $D_{ij}$, and recurse with an updated budget $k-|D_{ij}|$.
• Repeat until all prime modules are eliminated.

This branching scheme explores all pairwise merges, guaranteed by key lemmas to capture all minimal solutions [(Hellmuth et al., 2015), Lemma 5] [(Hellmuth et al., 2017), Theorem 4.4]. The running time is $O((\ell^2)^k \cdot \text{poly}(n))$ where $\ell$ is the maximum number of children in any prime module. Since the process is recursive on disjoint modules and at most $k$ branches occur, the algorithm is fixed-parameter tractable (FPT) in $k$. By reparameterizing by modular-width, one achieves $O(n^2 (k!)^2 2^k)$ for the editing problem; the same holds for deletion-only (Hellmuth et al., 2017).

In practice, the following heuristics are fast and almost always yield high-quality solutions:

• $O(n^3)$ time: greedily merge the smallest-cost pair of modules at every step, updating adjacency tables.
• $O(n^2)$ time: randomly select pairs to merge, maintain the quotient graph only, and realize edits after all merges (Hellmuth et al., 2017).

The correctness of these algorithms relies on the preservation of strong modules under edge deletions and the fact that all new strong modules in $G'$ correspond to unions of children of a prime module of $G$ (Hellmuth et al., 2015, Hellmuth et al., 2017).

5. Branch-and-Reduce and Bounded Search Tree Methods

Independent of modular decomposition, several FPT branching algorithms exploit forbidden subgraph relaxations, particularly $P_4$-sparse graphs. A $P_4$-sparse graph is one where every five-vertex induced subgraph contains at most one $P_4$. The seven forbidden subgraphs on five vertices (e.g., $C_5$, $P_5$, kite, pan, fork, co-4-pan, $\overline{P_5}$) provide short constant-size patterns to branch upon.

The basic procedure (Nastos et al., 2010, Tsur, 2019):

• Recursively search for a forbidden pattern.
• For each minimal edge-deletion set covering all $P_4$s in the pattern, branch, decrease budget, and repeat.
• Once the graph is $P_4$-sparse, use the linear-time “spider” decomposition for a direct cograph completion.

The worst-case search tree for edge-deletion, governed by the 4-pan forbidden subgraph, leads to recurrence $T(k)\le T(k-1)+4T(k-2)$, yielding $O(2.562^k)$ (Nastos et al., 2010). More refined approaches (including larger forbidden patterns and automated branching rule generation) reduce this exponent to $O(2.303^k)$ (Tsur, 2019). The bottleneck is the fraction of $P_4$s destroyed in each branch, optimized via analysis of inclusion-minimal deletion sets.

Notably, every branching rule is exhaustive and safe, ensuring that all solutions are enumerated, and once in $P_4$-sparse class, decomposition allows for optimal resolution in $O(n+m)$ time (Nastos et al., 2010).

6. Recent Advances: $O^*((2+\varepsilon)^k)$ Algorithm

Lafond and Sarrazin (2026) introduced a new direction by leveraging structural theorems for large prime graphs in concert with modular decomposition (Lafond et al., 5 Jan 2026). Their strategy employs the result (Chudnovsky–Kim–Oum–Seymour, 2015) that every sufficiently large prime graph contains as an induced subgraph one of seven “unavoidable” structures (and their complements): 1-subdivision of $K_{1,c}$, line graph of $K_{2,c}$, thin spiders, half-graphs, and specific chain graphs, each guaranteeing $\Omega(c)$ induced $P_4$s.

This insight enables branching rules where, on encountering a large prime quotient, the process:

• Identifies one of the unavoidable subgraphs with $\Theta(c)$ $P_4$s.
• Branches by deleting a small “pivot” edge (cost $1$ or a few) or, if not, pays a large linear penalty forced by the overlap structure (cost $\Theta(c)$).
• As $c\to\infty$, the branching vector yields an exponent arbitrarily close to $2$.

The overall algorithm applies modular decomposition, recursing on prime modules and quotient graphs, and, crucially, controls the branching number via linear-cost pivots: $T(k) \leq 2T(k-1) + T(k-(c-1)),$ with the largest root tending to $2+\varepsilon$ for sufficiently large $c$. Thus, the subexponential bottleneck of the $2.303^k$-type algorithms is circumvented for the first time (Lafond et al., 5 Jan 2026). The correctness is underpinned by decomposition lemmas (all minimal forbidden induced subgraphs are prime) and the universality of the structural theorem for prime graphs.

This approach generalizes to any hereditary $H$-free editing problem where all minimal forbidden graphs are prime, including cluster editing, chordal editing, and trivial-perfect editing, provided this structural criterion holds.

7. Summary Table: Algorithmic Landscape for Cograph Deletion

Algorithmic Approach	Exponential Factor	Core Technique	Reference
Forbidden $P_4$ branching (naive)	$O(3^k)$	$P_4$-search	(Tsur, 2019)
$P_4$-sparse subgraph branching	$O(2.562^k)$	Forbidden 5-vertex	(Nastos et al., 2010)
Automated pattern branching	$O(2.303^k)$	Enumerate all minimal	(Tsur, 2019)
Modular decomposition + pairwise merges	FPT in $k$	Module merges	(Hellmuth et al., 2015, Hellmuth et al., 2017)
Modular-width parameterization	$O(n^2 (k!)^2 2^k)$	Brute-force over modules	(Hellmuth et al., 2017)
Large-prime subgraph structural branching	$O^*((2+\varepsilon)^k)$	Exploit prime substructures	(Lafond et al., 5 Jan 2026)

Each advance channeled structural insight—first by local forbidden subgraphs, then local-to-global module merges, and most recently by recognizing and exploiting global prime-induced subgraphs—to improve the exponent of the FPT runtime. The methodologies not only precisely solve Cograph Deletion but have implications for a broad class of hereditary graph modification problems.

---

References

• (Hellmuth et al., 2015) Techniques for the Cograph Editing Problem: Module Merge is equivalent to Editing P4s
• (Hellmuth et al., 2017) Cograph Editing: Merging Modules is equivalent to Editing P4's
• (Nastos et al., 2010) Bounded Search Tree Algorithms for Parameterized Cograph Deletion: Efficient Branching Rules by Exploiting Structures of Special Graph Classes
• (Tsur, 2019) Faster algorithms for cograph edge modification problems
• (Lafond et al., 5 Jan 2026) A $O^*((2 + ε)^k)$ Time Algorithm for Cograph Deletion Using Unavoidable Subgraphs in Large Prime Graphs