---
title: Treewidth-d Deletion Problem
url: https://www.emergentmind.com/topics/treewidth-d-deletion-problem
type: topic
---

# Treewidth-d Deletion Problem

The Treewidth-d-Deletion problem is a fundamental vertex deletion problem in structural graph theory and parameterized algorithmics. Given an undirected graph $G$ and an integer $d \geq 0$, the goal is to find a vertex set $S \subseteq V(G)$ of minimum size such that the treewidth of the induced subgraph $G - S$ is at most $d$. This problem generalizes classical graph problems such as Vertex Cover (the $d=0$ case) and Feedback Vertex Set ($d=1$), and is core to the study of structural graph decompositions, kernelization, and algorithmic graph minors.

## 1. Formal Problem Statement

Given a graph $G = (V, E)$ and a target treewidth $d \geq 0$, the Treewidth-d-Deletion problem (also known as TW-d-Del or $k$-Treewidth Vertex Deletion) asks for a vertex set $S \subseteq V$ minimizing $|S|$ such that $\operatorname{tw}(G \setminus S) \leq d$, where $\operatorname{tw}(\cdot)$ denotes the treewidth. The parameterized version typically considers $k = |S|$ as the parameter, with $d$ either fixed or part of the input.

Formally,
\[
\min_{S \subseteq V} \; |S| \quad \text{subject to} \quad \operatorname{tw}(G \setminus S) \leq d
\]
Equivalently, via a forbidden minor characterization, Treewidth-d-Deletion is an $\mathcal{F}$-Deletion problem for $\mathcal{F} = \{K_{d+2}\}$, since a graph has treewidth at most $d$ if and only if it excludes the complete graph $K_{d+2}$ as a minor [1907.04442].

A weighted version accepts a node-weighted graph and seeks a set $X$ of minimum total weight such that $\operatorname{tw}(G - X) \leq d$ [2410.06343].

## 2. Approximation and Meta-Algorithmic Frameworks

A central approach to Treewidth-d-Deletion is via an intricate reduction to the $k$-Subset Vertex Separator problem, leveraging structural graph separation results. The $k$-Subset Vertex Separator asks, given a graph $G = (V, E)$, a terminal subset $R \subseteq V$, and integer $k$, for a minimum-size set $X \subseteq V$ such that every connected component of $G \setminus X$ contains at most $k$ terminals. Bicriteria approximation algorithms—returning a solution $X$ of size $O(\log k)\cdot \operatorname{OPT}$ while allowing each component at most $O(k)$ terminals—are used as subroutines [1804.01366].

This reduction, combined with exact FPT algorithms on bounded-treewidth graphs, leads to an $O(\log d)$-approximation for Treewidth-d-Deletion in polynomial time, with additional efficiency on graph classes excluding a fixed minor (admitting EPTAS under bidimensionality theory).

Sketch of the reduction process [1804.01366]:
- Maintain a candidate deletion set $R$.
- Use structure theorems for small separators in bounded-treewidth graphs to relate separators to the $k$-Subset Vertex Separator instance.
- Iteratively refine $R$ using bicriteria separator solutions and exact processing on bounded-treewidth components until a global $O(\log d)\cdot \operatorname{OPT}$-size solution is obtained.

For weighted instances, a combinatorial constant-factor approximation is achieved using random protrusion sampling, modulator-hitting families, and martingale analysis. Every fixed $d$ admits a randomized constant-factor approximation in time $n^{O(d)}$ [2410.06343].

## 3. Kernelization and Compression

Early kernelization results established that, when $\mathcal{F}$ contains a planar graph, the $\mathcal{F}$-Deletion problem admits a polynomial kernel whose size bound is $g(\mathcal{F})\cdot k^{f(\mathcal{F})}$ for computable functions $g,f$ [FOCS 2012]. In the case of Treewidth-d-Deletion, this yields a polynomial kernel with an exponent dependent on $d$, and a lower bound shows this dependence is necessary unless $\text{NP} \subseteq \text{coNP}/\text{poly}$ [2601.08424].

Recent advancements provide uniform *lossy* kernels. For every fixed $d$:
- There exists a 2-approximate kernel of size $O(g(d) \cdot k^5)$, i.e., a polynomial-size reduction to $O(k^5)$ vertices incurring at most a factor-2 in the approximation [2601.08424].
- A $(1+\varepsilon)$-approximate compression protocol is possible, using $O(1)$ calls to oracles for Treewidth-d-Deletion and $\mathcal{F}$-Deletion on graph instances of size polynomial in $k$; the approximation factor can be made arbitrarily close to 1, at the cost of increased compressed size.

A *linear* kernel is achievable on graph classes excluding a fixed topological minor, for fixed $d$, thus generalizing to sparse graph classes with even disconnected forbidden minors [2601.08424]. This relies on global protrusion decompositions and extended replacement techniques.

## 4. Fixed-Parameter and Exact Algorithms

For general graphs, the Treewidth-d-Deletion problem is connected to $\mathcal{F}$-M-Deletion with $\mathcal{F} = \{K_{d+2}\}$: $G$ has treewidth $\leq d$ if and only if it excludes $K_{d+2}$ as a minor [1907.04442]. The major algorithmic advances follow the structure below:
- Dynamic programming over tree decompositions using the theory of boundaried graphs and equivalence classes for gluing operations (using representatives $\mathcal{R}_h^{(t)}$).
- The Flat Wall Theorem and bidimensionality to obtain small constant-treewidth “modulators” and identify large-wall obstacles.
- The irrelevant vertex technique inside large grid-like subgraphs, enabling reduction to minimal representatives.
- Protrusion replacement: converting protrusions to smaller equivalents, preserving the solution structure.

An optimal algorithm for this family of problems runs in time $2^{O(\mathrm{tw}\cdot \log \mathrm{tw})} n^{O(1)}$, where $\mathrm{tw}$ is the width of the tree decomposition of $G$. The lower bound under ETH rules out a $2^{o(\mathrm{tw} \log \mathrm{tw})} n^{O(1)}$ algorithm even for small $d$ [1907.04442].

## 5. Special Cases, Generalizations, and Hardness

Several special cases arise as $d$ varies:
- For $d=0$ (Vertex Cover), NP-hardness of approximation within $2-\varepsilon$ holds [Dinur–Safra], even for exact or parameterized kernels.
- For $d=1$ (Feedback Vertex Set), the problem remains W[1]-hard under various generalizations.

The generalized framework extends directly to problems such as Pathwidth-, Treedepth-, and minor/transversal versions under hereditary graph classes with bounded treewidth, often with similar algorithmic and kernelization results [1804.01366].

Hardness results include:
- For hereditary classes, the maximization version (max $|V - S|$ s.t. tw$(G-S)\le d$) is $n^{1-\delta}$-hard for some $\delta > 0$.
- No $O(1)$-approximation independent of $d$ is known unless a constant-factor $k$-Subset Vertex Separator algorithm is found.

## 6. Structural and Technical Ingredients

Key algorithmic and structural tools include:
- Near-protrusion and true protrusion decompositions to partition the graph into bounded connectivity/complexity parts.
- The large-simplicial-neighborhood rule for effective reduction, yielding lossy kernels [2601.08424].
- Augmented graphs to facilitate distinction between simplicial and non-simplicial components.
- Exhaustive families of partial solutions for protrusion handling, relying on the theory of monadic second-order logic on bounded-treewidth graphs (Courcelle's theorem).
- Martingale analysis in weighted deletion for bounding expected cost against the optimum [2410.06343].

## 7. Summary Table of Key Algorithmic Results

| Result Type                      | Bound/Guarantee                                                                 | Reference       |
|-----------------------------------|--------------------------------------------------------------------------------|-----------------|
| $O(\log d)$-approximation         | Polynomial time for arbitrary graphs                                            | [1804.01366]    |
| Constant-factor apx (weighted)    | Randomized, polynomial in $n^{O(d)}$                                           | [2410.06343]    |
| 2-approximate kernel (uniform)    | $O(g(d)\cdot k^5)$ vertices, polynomial time                                   | [2601.08424]    |
| $(1+\varepsilon)$-lossy protocol  | Compression with $O(1)$ small-oracle calls, $(1+\varepsilon)$-approximation    | [2601.08424]    |
| Linear-size exact kernelization   | O$(k)$ vertices on topological-minor-free classes, fixed $d$                   | [2601.08424]    |
| Exact, bounded-treewidth graphs   | $2^{O(\mathrm{tw}\cdot\log\mathrm{tw})}n^{O(1)}$                              | [1907.04442]    |

All polynomial kernelizations for the general Treewidth-d-Deletion problem are necessarily non-uniform in $d$ unless $\text{NP} \subseteq \text{coNP}/\text{poly}$ [2601.08424], indicating a strong lower bound on compressibility.

## References

- [1804.01366] "Losing Treewidth by Separating Subsets"
- [2410.06343] "Losing Treewidth In The Presence Of Weights"
- [1907.04442] "Hitting minors on bounded treewidth graphs. IV. An optimal algorithm"
- [2601.08424] "Protrusion Decompositions Revisited: Uniform Lossy Kernels for Reducing Treewidth and Linear Kernels for Hitting Disconnected Minors"

Source: https://www.emergentmind.com/topics/treewidth-d-deletion-problem