Abstract 1 Introduction 2 Preliminaries 3 Parameterized by Treewidth 4 NP-hardness When Maximum Degree is Bounded 5 Parameterized by Solution Size Plus Degeneracy 6 Brute-force Algorithm and its Optimality References

A Finer View of the Parameterized Landscape of Labeled Graph Contractions

Yashaswini Mathur ORCID Indian Institute of Science Education and Research Bhopal, India Prafullkumar Tale ORCID Indian Institute of Science Education and Research Pune, India
Abstract

We study the Labeled Contractibility problem, where the input consists of two vertex-labeled graphs G and H, and the goal is to determine whether H can be obtained from G via a sequence of edge contractions.

Lafond and Marchand [WADS 2025] initiated the parameterized complexity study of this problem, showing it to be 𝖶[1]-hard when parameterized by the number k of allowed contractions. They also proved that the problem is fixed-parameter tractable when parameterized by the tree-width tw of G, via an application of Courcelle’s theorem resulting in a non-constructive algorithm.

In this work, we present a constructive fixed-parameter algorithm for Labeled Contractibility with running time 2𝒪(tw2)|V(G)|𝒪(1). We also prove that unless the Exponential Time Hypothesis (ETH) fails, it does not admit an algorithm running in time 2o(tw2)|V(G)|𝒪(1). This result adds Labeled Contractibility to a small list of problems that admit such a lower bound and matching algorithm.

We further strengthen existing hardness results by showing that the problem remains 𝖭𝖯-complete even when both input graphs have bounded maximum degree. We also investigate parameterizations by (k+δ(G)) where δ(G) denotes the degeneracy of G, and rule out the existence of subexponential-time algorithms. This answers question raised in Lafond and Marchand [WADS 2025]. We additionally provide an improved 𝖥𝖯𝖳 algorithm with better dependence on (k+δ(G)) than previously known. Finally, we analyze a brute-force algorithm for Labeled Contractibility with running time |V(H)|𝒪(|V(G)|), and show that this running time is optimal under ETH.

Keywords and phrases:
Labeled Contraction, ETH Lower-bound, Treewidth, NP-hard
Funding:
Prafullkumar Tale: INSPIRE Faculty Fellowship by DST, Govt of India.
Copyright and License:
[Uncaptioned image] © Yashaswini Mathur and Prafullkumar Tale; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Fixed parameter tractability
Related Version:
Full Version: https://arxiv.org/abs/2510.06102
Editors:
C. Aiswarya, Ruta Mehta, and Subhajit Roy

1 Introduction

Graph modification problems are a foundational topic in algorithmic graph theory. A general formulation of the -M-Modification problem asks: given a graph G and a fixed set M of allowed modification operations (such as vertex deletion, edge addition/deletion, or edge contraction), can G be transformed into a graph in class using at most k operations from M.

It is well known that the -M-Modification problem is 𝖭𝖯-hard for many natural graph classes when M consists of vertex or edge deletions [54, 42]. Hardness results for edge contraction were first shown by Watanabe et al. [53] and Asano and Hirata [4]. It is noteworthy that while the problem becomes trivially solvable when M includes only vertex or edge deletions and is a singleton, this is not the case for edge contractions. In fact, Brouwer and Veldman [9] established that the problem remains 𝖭𝖯-complete even when is a singleton containing a small graph, such as a cycle or a four-vertex path. This difference highlights the increased algorithmic complexity introduced by edge contractions compared to vertex or edge deletions.

Graph modification problems have played a central role in the development of parameterized complexity and the design of key algorithmic techniques. A representative list of relevant works includes [7, 8, 11, 12, 13, 14, 17, 23, 24, 25, 27, 29]. For a comprehensive overview, the survey by Crespelle et al. [18] provides an in-depth discussion of modification problems involving edge deletion, editing, and completion.

A series of recent papers have studied the parameterized complexity of -Contraction for various graph classes , including paths and trees [35], generalizations and restrictions of trees [1, 2], cactus graphs [40], bipartite graphs [34, 36], planar graphs [33], grids [50], cliques [10], split graphs [3], chordal graphs [44], bicliques [47], and degree-constrained graph classes [5, 32, 51].

Recently, Lafond and Marchand [41] initiated the parameterized study of edge contraction problems in uniquely labeled graphs, where each vertex has a different label. They introduced the following problem:

Labelled Contractibility

Input: Two vertex-labeled graphs G and H with V(H)V(G).

Question: Is H a labeled contraction of G?

See Definition 6 in Section 2 for formal definitions.

They also introduced a generalization, motivated by applications in phylogenetic networks [46], which are rooted acyclic directed graphs with labeled leaves representing evolutionary histories:

Maximum Common Labeled Contraction

Input: Two vertex-labeled graphs G and H, and an integer k.

Question: Do there exist labeled contraction sequences S1 and S2 such that G/S1=H/S2 and |S1|+|S2|k?

This second problem is closely related to the first. As shown in [41], H is a labeled contraction of G if and only if there exists a common contraction of both G and H to a labeled graph H of size at least |V(H)|. This equivalence allows complexity results to be transferred between the two problems. The same work provides additional applications and results.

Lafond and Marchand [41] showed that Labeled Contractibility is 𝖶[1]-hard when parameterized by the natural parameter k=|V(G)V(H)|, the number of allowed edge contractions. This motivates the exploration of structural parameters. They established that the problem admits a fixed-parameter tractable (𝖥𝖯𝖳) algorithm when parameterized by the treewidth tw of the input graph G by invoking a variation of Courcelle’s theorem [26, Theorem 11.73]. However, this approach yields a non-elementary dependence on the parameter.

Our first contribution is a constructive dynamic programming algorithm with a running time that is singly exponential in tw2. We complement this with a matching lower bound under the Exponential Time Hypothesis (ETH):

Theorem 1.

Labeled Contractibility

  • admits an algorithm running in time 2𝒪(tw2)|V(G)|𝒪(1); but

  • does not admit an algorithm running in time 2o(tw2)|V(G)|𝒪(1), unless the ETH fails.

We note that this lower bound also holds when parameterized by the pathwidth, which is a larger parameter. Most known 𝖥𝖯𝖳-algorithms that use dynamic programming on tree decompositions have running times, and matching lower bounds, of the form 2𝒪(tw)n𝒪(1) [19, Chapters 7,13] or 2𝒪(twlogtw)n𝒪(1) [43, 21]. For a relatively rare set of problems exhibits a double-exponential dependence on treewidth, see [30, 52, 16] and references within. To our knowledge, the only problems with single-exponential-but-polynomial dependencies on pathwidth are mentioned in [20, 48, 49]. Similar results parameterized by vertex cover number can be found in [3, 31, 6, 15].

Lafond and Marchand [41] observed that smaller parameters such as degeneracy do not yield tractable results. Specifically, it is known that the Maximum Common Labeled Contraction problem is 𝖭𝖯-hard even when both input graphs have constant maximum degree (and thus constant degeneracy), and that Labeled Contractibility is 𝖭𝖯-hard for graphs of bounded degeneracy [45, Theorem 8]. We strengthen this latter result by proving hardness under an even stricter constraint:

Theorem 2.

Labeled Contractibility is 𝖭𝖯-hard even when both G and H have bounded maximum degree.

These results suggest that tractability is unlikely when parameterizing solely by the solution size k or the degeneracy δ(G). Nevertheless, Lafond and Marchand [41] showed the problem becomes tractable for the combined parameter (k+δ(G)), yielding an algorithm with a running time of (δ(G)+2k)kn𝒪(1). They asked whether a subexponential-time algorithm exists for this parameterization, a question we resolve negatively:

Theorem 3.

Labeled Contractibility does not admit an algorithm running in time 2o(|V(G)|+|E(G)|) even when both G and H have bounded degeneracy, unless the ETH fails.

This theorem rules out the possibility of a subexponential-time algorithm parameterized by (k+δ(G)) under the assumption of the ETH. We also provide the following algorithm, which improves upon previous work:

Theorem 4.

Labeled Contractibility can be solved in time (δ(H)+1)k|V(G)|𝒪(1), where k is the solution size and δ(H) is the degeneracy of H.

This algorithm improves upon the (δ(H)+k)kn𝒪(1) algorithm from [41, Section 3.3]. The previous result relied on the bound δ(H)δ(G)+k. We refine this with a tighter upper bound: δ(H)δ(G)|V(G)||V(G)|k. For cases where |V(G)|(1+ϵ)k, this bound yields δ(H)δ(G)cϵ, where ϵ and cϵ are absolute constants. This substantially improves the previous analysis, leading to a more efficient algorithm under these conditions.

Finally, as our last contribution, we analyze a brute-force algorithm for Labeled Contractibility and establish its optimality under the ETH. Notably, our analysis also applies to the more general Maximum Common Labeled Contraction problem.

Theorem 5.

Labeled Contractibility

  • admits an algorithm running in time |V(H)|𝒪(|V(G)|); but

  • does not admit an algorithm running in time |V(H)|o(|V(G)|), unless the ETH fails.

Organization.

We adopt standard notation from graph theory and parameterized complexity, as outlined in Section 2. In Section 3, we present a dynamic programming algorithm based on tree decompositions and establish a matching lower bound. Specifically, we provide a parameter-preserving reduction from the Sub-Cubic Partitioned Vertex Cover problem [3], which proves Theorem 1. Section 4 proves Theorem 2 by a reduction from Positive-Not-All-Equal-SAT, showing 𝖭𝖯-hardness even for graphs of bounded maximum degree. Section 5 is dedicated to a conditional lower bound under the ETH. Using a reduction from 1-in-3-SAT, we prove this result even when both input graphs have bounded degeneracy. We also present an improved 𝖥𝖯𝖳 algorithm for the combined parameter (k+δ(G)). These results together establish Theorems 3 and 4. Section 6 analyzes a brute-force algorithm and establishes its optimality under the ETH. This is achieved via a reduction from the Cross Matching problem [28] and establishes Theorem 5.

For more comprehensive details, including the full proofs and additional technical arguments, we refer the reader to the longer version of this paper.

2 Preliminaries

Throughout this work, we consider uniquely labeled graphs. Following the convention in [41], we refer to vertices directly by their labels rather than using explicit labeling functions. Two labeled graphs G and H are considered equal, denoted G=H, if and only if V(G)=V(H) and E(G)=E(H). This is distinct from the standard notion of graph isomorphism, where a bijection σ:V(G)V(H) exists such that (u,v)E(G) if and only if (σ(u),σ(v))E(H). In our setting, we assume that the labels of H are a subset of those of G.

Definition 6.

Let G be a labeled graph and (u,v)E(G). The labeled contraction of the edge (u,v) is an operation that transforms G by:

  • For every vertex wN(v)N[u], adding the edge (u,w) to G.

  • Removing the vertex v and all incident edges.

The resulting graph is denoted by G/(u,v).

Note that in general, G/(u,v)G/(v,u), as the vertex that is retained after the contraction (and thus the label) is different. The two resulting graphs are, however, isomorphic under the standard unlabeled notion. For simplicity, in the remainder of this paper, we assume all contractions are labeled and refer to them simply as contractions.

A labeled contraction sequence S on a graph G is a sequence of vertex pairs S=((u1,v1),,(uk,vk)) such that for each i{0,,k1}, if Gi is the graph obtained after the first i contractions (with G0:=G), then (ui+1,vi+1)E(Gi) and Gi+1=Gi/(ui+1,vi+1). The graph obtained after the full sequence is denoted by G/S. If S is not a valid contraction sequence on G, then G/S is undefined. We say that a graph H is a labeled contraction of G if there exists a contraction sequence S such that G/S=H. A graph M is a common labeled contraction of graphs G and H if it is a labeled contraction of both. A maximum common labeled contraction of G and H is a common labeled contraction with the largest possible number of vertices.

Consider two graphs H and G such that V(H)V(G).

Definition 7.

A witness structure of G into H is a partition 𝒲={W1,,W|V(H)|} of V(G) into non-empty sets satisfying:

  • For each Wi𝒲, the induced subgraph G[Wi] is connected.

  • Each Wi contains exactly one vertex from V(H), called its representative vertex.

  • For any distinct u,vV(H), the edge (u,v)E(H) if and only if the sets in 𝒲 containing u and v are adjacent in G.

There is a natural bijection between the sets in 𝒲 and the vertices of H via their representatives. It is known that H is a labeled contraction of G if and only if a witness structure of G into H exists (see Observation 2 in [41]). Furthermore, contractions within a single witness set can be performed in any order as long as the representative vertex is preserved (Observation 3 in the same work). For any vertex uV(G), we denote by 𝒲(u)𝒲 the unique set that contains u.

3 Parameterized by Treewidth

In this section, we present the proof of Theorem 1 which we restate.

Theorem 1. [Restated, see original statement.]

Labeled Contractibility

  • admits an algorithm running in time 2𝒪(tw2)|V(G)|𝒪(1); but

  • does not admit an algorithm running in time 2o(tw2)|V(G)|𝒪(1), unless the ETH fails.

In the first subsection, we describe the algorithmic result by presenting a dynamic programming algorithm on tree decomposition. In the second subsection, we establish a matching conditional lower bound.

3.1 Algorithmic Result

In this subsection we will present a dynamic programming (DP) based algorithm for the Labeled Contraction problem when parameterized by treewidth of the input graph. For the sake of completeness, we start with the standard definitions.

Definition 8 ([19]).

A tree decomposition of a graph G is a pair (𝒯,{Xt}tV(𝒯)), where 𝒯 is a rooted tree and each node tV(𝒯) is associated with a set XtV(G), referred to as a bag, satisfying the following conditions:

  • For every vertex vV(G), the set {tV(𝒯)vXt} is nonempty and induces a connected subtree of 𝒯;

  • For every edge {u,v}E(G), there exists a node tV(𝒯) such that {u,v}Xt.

The width of a tree decomposition is maxtV(𝒯)|Xt|1. The treewidth of G, denoted tw(G), is the minimum width over all valid tree decompositions of G.

Definition 9 ([19]).

A nice tree-decomposition of a graph G is a rooted tree-decomposition (𝒯,{Xt}tV(𝒯)) where 𝒯 is rooted at r with Xr=, and each node of 𝒯 belongs to one of the following types:

  • A leaf node t is a leaf of 𝒯 with Xt=.

  • An introduce vertex node t has one child t1 such that Xt=Xt1{x}, for some xXt1.

  • A forget node t has one child t1 such that Xt=Xt1{x}, where xXt1.

  • An introduce edge node t has one child t with Xt=Xt, and is labeled with an edge {u,v}E(G) such that {u,v}Xt. We say that the edge {u,v} is introduced at t;

  • A join node t has two children t1 and t2 such that Xt=Xt1=Xt2.

Without loss of generality, we assume that a nice tree-decomposition of width tw is provided. If not, one can construct an optimum tree decomposition in time 2𝒪(tw2)n𝒪(1)[39].

Recall that we denote GH as the graph with vertex set V(G) and edge set E(G)E(H). The following lemma enables us to work with tree decompositions of GH instead of just G, which is crucial for our formulation.

Lemma 10 ([41], Lemma 13).

If H is a contraction of G, then tw(GH)2tw(G).

Henceforth, we fix a nice tree decomposition 𝒯 of GH. This choice is crucial because it ensures that for any edge (u,v)E(H), there exists some bag Xt such that u,vXt, a condition that is not guaranteed in a tree decomposition of G alone. For each node t𝒯, we define Gt and Ht to be the subgraphs of G and H, respectively, induced by the union of all bags in the sub-tree of 𝒯 rooted at t.

We now introduce the key definitions for the DP-state at a node t of the tree-decomposition to convey the main ideas of the algorithm. The formal proof follows.

3.1.1 Witness Structures and Functional Representation

Assume that H is a contraction of G, and let 𝒲={W1,,W|V(H)|} denote a witness structure for this contraction. We represent 𝒲 functionally using a pair of auxiliary functions: a parent function and an originator function.

Definition 11 (Parent function).

Given a witness structure 𝒲, a function σ:V(G)V(G) is a parent function with respect to 𝒲 if there exists a collection of rooted trees {Ti}i=1k, where each Ti is a spanning tree of G[Wi] rooted at the unique vertex of WiV(H), such that:

  1. 1.

    For all uWiV(H), σ(u) is the parent of u in Ti; and

  2. 2.

    For the unique vertex uWiV(H), σ(u)=u.

Definition 12 (Originator function).

Given a witness structure 𝒲, a function τ:V(G)V(H) is an originator function with respect to 𝒲 if for every uWi, τ(u) is the unique vertex in WiV(H).

Note that any valid originator function τ defines a partition of V(G) into the witness sets 𝒲. Also, for any vertex uV(G), there exists a bag that contains both u and σ(u), but not necessarily τ(u).

A pair (σ,τ) is said to be consistent if for every uV(G) τ(u)=τ(σ(u)), i.e. u and its parent σ(u) belong to the same witness set. In the remainder of the discussion, we assume all parent-originator pairs to be consistent unless stated otherwise. Although τ can be derived from σ by following parent pointers up to a vertex in V(H), we maintain both functions explicitly for algorithmic clarity.

Definition 13 (Witness impression).

Every witness structure 𝒲 corresponds to pair (σ,τ), called its witness-impression, where σ is a parent function and τ is the corresponding originator function.

Definition 14 (Seed impression).

Let (σ,τ) be an impression of a witness structure. A pair of partial functions (σ,τ), with σ:V(Gt)V(Gt){} and τ:V(Gt)V(Ht){}, is a seed impression of (σ,τ) at t if:

  • For every vertex uV(Gt)Xt, σ(u)=σ(u) and τ(u)=τ(u).

  • For a vertex uXt, if σ(u)V(Gt) then σ(u)=σ(u) otherwise σ(u)=. The function τ is derived from σ by following parent pointers up to either a vertex in V(H) or .

Note that (σ,τ) is not merely the restriction of (σ,τ) to V(Gt), since a vertex u such that σ(u)V(Gt) might satisfy τ(u)V(Gt), but we still assign τ(u)=. Note that in Figure 1, τ(u1)Gt but since σ(u1)Gt we assign τ(u1)=.

We now classify each vertex in the bag Xt into one of three types, according to the seed impression (σ,τ):

Definition 15 (Types of vertices).

Let tV(𝒯) be a node with bag Xt, and let (σ,τ) be a seed impression at t. Then each vertex uXt is assigned one of the following types:

  • Requester: σ(u)V(Gt) and τ(u)V(Ht) (i.e., both are defined); u is ready to request adjacency requirements in H.

  • Dependent: σ(u)V(Gt) but τ(u)=; u has been contracted into its parent and depends on the parent node’s decision regarding the partition.

  • Explorer: σ(u)= (implying τ(u)=); u is still exploring who its parent will be.

We classify the pair of requester vertices into the following three parts.

Definition 16 (Requester pair classification).

Let u,vXt be requester vertices with τ(u)=hu, τ(v)=hv. We say the pair (u,v) is

  • invalid (inv) if (hu,hv)E(H) but τ1(hu),τ1(hv) are adjacent in Gt,

  • unsatisfied (unsat) if (hu,hv)E(H) and τ1(hu),τ1(hv) are not adjacent in Gt, and

  • satisfied (sat), otherwise.

For a vertex uV(G), we define the set des(u)V(G) of descendants of u with respect to a function σ:V(G)V(G) as follows:

des(u)={vV(G)|there exists an integer 0 such that σ()(v)=u},

where σ(0)(v)=v, and for 1, σ()(v)=σ(σ(1)(v)). That is, des(u) consists of all vertices v for which repeated applications of σ eventually reach u, including u itself.

Definition 17 (Pseudo-adjacency).

Let u,v be two vertices in Xt. Then, we say u and v are pseudo-adjacent if sets des(u) and des(v) are adjacent in Gt.

3.1.2 Signatures and Dynamic Programming States

Suppose the graph G admits an H-witness structure 𝒲, and let (σ,τ) be the corresponding witness-impression as specified in Definition 13. Let T be a tree decomposition of the graph GH, and let t be a node of T.

Definition 18 (Partial Solution).

We define a partial solution at node t as a tuple P=(σ,τ,,𝒜), with the following components:

  • (σ,τ) is a seed impression of the witness-impression (σ,τ), restricted to the bag Xt at t, as specified in Definition 14,

  • R×R×{inv,sat,unsat} is a set of labeled pairs, where RXt denotes the set of requester vertices contained in Xt as per Definition 15. Each element (u,v,) represents a label {inv,sat,unsat} assigned to the pair (u,v), as per Definition 16,

  • 𝒜Xt×Xt records unordered pairs of vertices in Xt that are pseudo-adjacent to each other, as per Definition 17.

We now refer to Figure 1 to provide intuition for the above definitions. The figure shows the graph H together with a part of the tree decomposition of GH (we do not explicitly draw G). The rounded outlines indicate the witness structure for the contraction, whenever it exists: each group contains exactly one node of H, representing the collection of vertices that contract to it. Note that σ(u2)=u1, τ(u2)=, and τ(u1)=σ(u1)=. Since the edge (u3,u4) is an edge we processed earlier in the DP, we may store (u7,u5,sat) for Xt. On the other hand, because the edge (u6,u5) has not yet been introduced, the edge (h2,h3) does not appear in the current structure, so we have (u2,u5,unsat). Furthermore, observe that (u8,u5) and (u7,u5) belong to 𝒜, whereas (u9,u5)𝒜. In this way, all relevant sets are defined for the dynamic programming.

(a) Illustration of Gt and Xt.
(b) Graph H.
Figure 1: Depicting definitions relevant to the algorithm.

We now provide a formal definition for the same.

Note that, as it is standard in the case of dynamic programming on tree decomposition, we will not compute all the partial solution at node t but rather just store unique signatures of all the partial solutions at t. The signature S of a partial solution P=(σ,τ,,𝒜) is (σ|Xt,τ|Xt,,𝒜).

States of the Dynamic Programming Algorithms
Definition 19 (Signature).

A state of dynamic programming table will be a tuple S=(σ,τ,,𝒜) such that

  • σ:XtXt{} (which will emulate a parent function),

  • τ:XtV(Ht){} (which will emulate an originator function),

  • R×R×{inv,sat,unsat} is a set of labeled pairs representing a label {inv,sat,unsat} assigned to the pair (u,v), as per Definition 16, and

  • 𝒜 is the collection of pair of vertices in Xt that are pseudo-adjacent with each other.

The condition on functions ensures that at present σ and τ are valid candidate to be a parent function and an originator function.

For a node t in tree decomposition T, we construct a dynamic-programming algorithm that sets the value d[S,t] to True if and only if S is a signature of some partial solution P at node t. Otherwise, we set it to False. Initially, all entries are set to False. For any signature S=(σ,τ,,𝒜), if contains an entry of the type (u,v,inv) then d[S,t] is set to False and it will never be changed.

We remark that the technical challenge in designing the dynamic programming algorithm was to find an appropriate, concise expression for the partial solution, which was discussed above. At any node t of the tree decomposition, the number of distinct signatures that can be stored is bounded by 2𝒪(tw2), where tw denotes the width of the decomposition. This bound arises from the fact that the signature must encode information pertaining to all pairs of vertices in the bag Xt. The specific process to update the dynamic programming table is a standard exhaustive enumeration over compatible signatures at the child node(s) and applying the corresponding update rule. For full details on the update rules and their proof of correctness, we refer the reader to the longer version of this paper. The time required to process each node is polynomial in the number of signatures. Consequently, the overall running time of the algorithm is bounded by 2𝒪(tw2)|V(G)|𝒪(1). This concludes the proof of the algorithmic result mentioned in Theorem 1.

3.2 Conditional Lower Bound

In this section, we demonstrate that unless (ETH) fails, Labeled Contraction does not admit an algorithm running in time 2o(tw2)|V(G)|𝒪(1), where tw is the treewidth of the input graph G. To obtain the lower bound, we reduce from a special case of Vertex Cover on sub-cubic graphs, defined in [3] as follows:

Sub-Cubic Partitioned Vertex Cover (Sub-Cubic PVC)

Input: A sub-cubic graph G; an integer t; for i[t], an integer ki0; a partition 𝒫={C1,,Ct} of V(G) such that t𝒪(|V(G)|) and for all i[t], Ci is an independent set and |Ci|𝒪(|V(G)|). Furthermore, for i,j[t], ij, |E(G[CiCj])E(G)|=1.

Question: Does G have a vertex cover X such that for all i[t], |XCi|ki?

Proposition 20 (Theorem 3.9 in [3]).

Sub-Cubic PVC does not admit an algorithm running in time 2o(n), unless the ETH fails.

We now prove the lower bound in Theorem 1.

Let (G,𝒫={C1,C2,,Ct},k1,,kt) be an instance of the Sub-Cubic PVC problem, where n=|V(G)|. We construct an instance (G,H) of the Labeled Contraction problem as follows.

Construction of 𝑮.

We begin by setting V(G)V(G), i.e., all vertices of G are copied into G (without copying any edges). For each partition Ci𝒫, we introduce a set Si consisting of (|Ci|ki+1) new vertices in G, where each vertex sSi corresponds uniquely to a subset CiCi of size exactly ki+1. For each such vertex sSi, we add edges between s and every vertex in the subset Ci. Additionally, for every Ci𝒫, we introduce three auxiliary vertices {xi,yi,zi} in G. Each of these vertices is connected to every vertex in Ci. Moreover, we add edges (zi,xi) and (zi,yi). Each vertex sSi is connected to the corresponding vertex xi.

We now encode the edges in G. Consider a pair i,j[t] and an edge (u,v)E(G) with uCi and vCj. By the problem definition, such an edge exists. We add edges (u,xj) and (v,xi) to G.

Finally, the set {y1,y2,,yt} is made into a clique by adding all possible edges between them, and for every i,j[t], we add the edge (xi,yj) in G.

Construction of 𝑯.

We start constructing H from G by deleting all vertices in G in it. Formally, V(H)=(i=1tSi)(i=1t{xi,yi,zi}), that is, it includes all newly introduced vertices from the sets Si and the auxiliary vertices xi,yi,zi for each i[t], but does not include any vertex from the original graph G. The edge set of H is defined as follows. First, a clique is formed on the vertex set {y1,y2,,yt}{x1,x2,,xt}, adding all edges between these vertices. Additionally, for every i[t], we include the edges (xi,zi) and (yi,zi). Finally, for every i[t] and each vertex sSi, we add the edge (s,yi).

This concludes the construction. We refer the reader to Figure 2 for an illustration of the reduction. We now prove the correctness of the reduction.

(a) Graph G.
(b) Graph H.
Figure 2: Illustration of the graphs G and H in the reduction for the lower bound of Theorem 1.

() Suppose we are given a solution to the Sub-Cubic PVC instance, that is, a vertex cover XV(G) such that for every i[t], it holds that |XCi|ki. We now describe a contraction sequence on G that yields H. For each partition Ci𝒫, we proceed as follows: For every vertex aXCi, we contract the edge (a,xi). For every vertex bCiX, we contract the edge (b,yi).

Observe that since X is a vertex cover of G, for each pair ij[t], there exists exactly one edge in G between Ci and Cj, say (u,v)E(G), with uCi and vCj. The contractions described above will result in u being contracted to xi or yi, and v to xj or yj. Since uX or vX, at least one of the endpoints is contracted to an x-vertex, ensuring that each pair (xi,xj) becomes adjacent in the resulting graph, thereby forming a clique on the set {x1,x2,,xt}.

Furthermore, for each i[t], since |XCi|ki, it follows that no subset of Ci of size ki+1 is entirely mapped to xi. Therefore, for every vertex sSi, which corresponds to a subset of Ci of size ki+1, at least one vertex in that subset is contracted to yi. Consequently, the edge (s,yi) appears in the resulting graph, as required by H. The edges (xi,yi) and (yi,zi) are preserved directly from the original construction. Thus, the contraction process yields graph H, completing the forward direction of the reduction.
() Suppose we are given a solution to the Labeled Contraction instance, i.e., a sequence of edge contractions that transforms G into H. We construct a corresponding solution XV(G) to the original Sub-Cubic PVC instance as follows.

Recall that the vertex set of H is precisely V(G)V(G), which implies that every contracted edge in the solution involves a vertex from V(G), more precisely vertices in Ci for each i[t]. Furthermore, observe that for each i[t], the vertices zi and those in Si do not share edges with each other or with vertices in V(G) outside of Ci neither in G nor in H. In particular, the absence of edges of the form (zi,s) for any sSi, and the absence of edges (zi,xj) or (zi,yj) for ij, implies that vertices in Ci can only be either contracted to xi or yi.

Now, for each vertex sSi, we note that s is adjacent to yi in H. In the construction of G, the vertex s was made adjacent to a subset CiCi of size ki+1. In order for s to remain adjacent to yi in H, it is necessary that at least one vertex in Ci is contracted to yi. Thus, no subset of Ci of size ki+1 can be entirely contracted to xi. This ensures that at most ki vertices from Ci are contracted to xi. Based on this observation, we define the vertex set XV(G) by including, for each i[t], all vertices in Ci that are contracted to xi. From the argument above, we have |XCi|ki for all i[t].

It remains to show that X is a vertex cover of G. Observe that in the construction of G, for each pair i,j[t], ij, such that E(G[CiCj])E(G)={(u,v)} with uCi, vCj, we added edges (u,xj) and (v,xi) to G. Since xi and xj are adjacent in H, and since no edge directly connects xi and xj in G, at least one of the vertices u or v must be contracted to xi or xj, respectively. This implies that either uX or vX, and hence X intersects every edge in E(G). Therefore, X is a valid vertex cover of G. This completes the proof of correctness for the reduction.

To upper bound the treewidth of the graph G, define the set W={xi,yi,zii[t]}. Observe that the graph GW consists of t vertex-disjoint subgraphs, each corresponding to a complete bipartite graph between Ci and Si. For each i[t], the set Ci is of size 𝒪(n). This implies that the treewidth of each G[CiSi] is 𝒪(n). Therefore, treewidth of G is at most tw(G)|W|+maxi[t]tw(G[CiSi])=𝒪(n).

Now suppose, for the sake of contradiction, that there exists an algorithm 𝒜 that solves Labeled Contraction in time 2o(tw(G)2)|V(G)|𝒪(1). We use 𝒜 as a subroutine to construct an algorithm for solving Sub-Cubic PVC. On input an instance (G,𝒫={C1,C2,,Ct},k1,,kt) of Sub-Cubic PVC with n=|V(G)|, algorithm performs the following steps: It constructs the corresponding instance (G,H) of Labeled Contraction as described in the reduction. This step takes time 2𝒪(n). Then, it invoke algorithm 𝒜 on the instance (G,H) and return the result produced by 𝒜.

The correctness of algorithm follows directly from the correctness of the reduction. Since tw(G)=𝒪(n), the total running time of is 2o(n), which contradicts the ETH, by Proposition 20. This establishes the claimed conditional lower bound stated in Theorem 1.

4 NP-hardness When Maximum Degree is Bounded

In this section, we establish the 𝖭𝖯-hardness of the Labeled Contractibility problem, even when both the input graphs G and H have constant maximum degree. Specifically, we present a polynomial-time reduction from a variation of Positive-Not-All-3-SAT problem to the Labeled Contractibility problem, thereby proving Theorem 2. We begin by formally defining the source problem, which is proved to be 𝖭𝖯-complete in [22].

Positive-Not-All-(3,4)-SAT

Input: A 3-CNF Boolean formula ψ in which every literal in each clause is positive and every variable appears in at most 4 clauses.

Question: Does there exist a truth assignment to the variables such that every clause is satisfied and, in each clause, not all three literals are assigned True?

Let {x1,x2,,xn} denote the set of variables, and let {C1,C2,,Cm} denote the set of clauses in the formula ψ. Without loss of generality, assume that the number of clauses m satisfies 2m+2=2q for some integer q; let p=2q (note that p is even).

We now describe the construction of two vertex-labeled graphs G and H corresponding to the given formula.

Construction of 𝑯.

Graph H is a simple path on p vertices {v1,v2,,vp}.

Construction of 𝑮.

We begin by constructing a complete binary tree of depth q rooted at vertex v1, and later add some edges among its vertices. Note that the number of leaves of this binary tree is 2q=2m+2. All but two leaves of this tree are labeled as {C1,a1,C2,a2,,Cm,am}, alternating between clause vertices Cj and auxiliary vertices aj. We label it such that Ci and ai shares a parent. Consider the remaining two leaves which share a parent. Add an edge between these two leaves, label one of them as vp/2 and other leave with any other label (as it will be irrelevant to the construction). We additionally add edges (ai,ai+1) for all i[m1]. Now, consider the internal vertices of the constructed binary tree rooted at v1. Finally, along the shorted path between v1 and vp/2, label the vertices as v2,v3,,vp/21 respectively. For every j[p/21], let Uj be the collection of vertices that are at exactly j distance from v1. Alternately, these are all 2j many vertices in jth-level of the complete binary tree. We add a path connecting these vertices. The internal structure of the tree, including its dummy vertices and edges, is constructed as illustrated in Figure 3.

A mirrored copy of this tree is constructed symmetrically, rooted at vertex vp, with the corresponding leaf labels {C1,a1,C2,a2,,Cm,am}, such that each primed vertex is associated with its unprimed counterpart. Additionally, we add the labels vp/2+1,,vp along the shortest path from vp/2 to vp. Furthermore, we add an edge (Cj,Cj) for each j[m], and an edge (vp/2,vp/2+1), thereby connecting the two binary trees via the central edge of the path. Finally, we add the edges (a1,vp/2) and (a1,vp/2+1).

Variable Gadgets.

For each variable xi with i[n], introduce a new vertex ui. For each clause Cj in which xi appears, connect ui to the vertices {Cj,aj,Cj,aj}.

This concludes the description of the reduction. Note that in the final graph G, each vertex has degree at most 16.

For proof of the correctness, we refer the reader to the full version of this paper.

Figure 3: Example of the construction of G with m=3. We only show one xi for convenience that appears in C3.

5 Parameterized by Solution Size Plus Degeneracy

We prove Theorem 3 and Theorem 4 in the following two subsections.

5.1 Conditional Lower Bound

We remark that most of the previous reduction about Labeled Contraction are from the variation of 3-SAT problem called Not-All-Equal-3-SAT. In this variation, the input is a 3-CNF formula and the objective is to find an assignment that sets at least one but not all literals in every clause to set to True. We consider the following, different version of 3-SAT as starting point of our reduction and present a simple proof from 3-SAT to get desired conditional lower bound.

1-in-3-SAT

Input: A Boolean formula ψ in 3-CNF

Question: Does there exist a satisfying assignment such that exactly one literal is set to true in each clause?

Consider the following polynomial-time reduction from 3-SAT to 1-in-3-SAT where each clause Ci=(x¬yz) in the original formula is replaced by three clauses:

C1i=(¬xaibi),C2i=(ybici),C3i=(¬zcidi),

where ai,bi,ci,di are fresh variables unique to the clause Ci. This reduction introduces a linear blow-up in the number of variables and clauses. Combining this reduction with the (ETH) [37] and the Sparsification Lemma [38], we obtain the following:

Proposition 21.

Unless the ETH fails, 1-in-3-SAT cannot be solved in time 2o(n+m), where n and m are the number of variables and clauses in the input formula, respectively.

We now reduce 1-in-3-SAT to Labeled Contraction, ensuring that the number of vertices in G and H is linearly bounded by the number of variables and clauses in and instance of 1-in-3-SAT.

We now proceed with the proof of Theorem 3.

Proof.

Let ψ be an instance of 1-in-3-SAT with variable set {x1,x2,,xn} and clause set {C1,C2,,Cm}. We construct a corresponding instance (G,H) of Labeled Contraction such that ψ is satisfiable if and only if H is a labeled contraction of G.

We simultaneously define the graphs G and H as follows (See Figure 4 for an illustration.):

  • Global vertices: Add two special vertices gT and gF to both G and H, connected by the edge (gT,gF). These represent the “true” and “false” assignments, respectively, for literals.

  • Variable gadget: For each variable xi, i[n]:

    • Add a vertex ui to both G and H, representing variable xi.

    • Add two vertices vi and vi to G, corresponding to literals xi and ¬xi, respectively.

    • In G, connect ui to both vi and vi. Also connect both vi and vi to gT and gF.

    • In H, add edges (ui,gT), (ui,gF), and retain (gT,gF).

  • Clause gadget: For each clause Cj=(j1j2j3), let 𝗅𝗂𝗍𝗏() denote vi if =xi, and vi if =¬xi.

    • Add four vertices wj0,wj1,wj2,wj3 to both G and H.

    • In H, connect wj0 to gT and gF.

    • In G, connect wj0 to 𝗅𝗂𝗍𝗏(j1), 𝗅𝗂𝗍𝗏(j2), and 𝗅𝗂𝗍𝗏(j3).

    • For each k{1,2,3}, add edge (wjk,gT) to both G and H, and edge (wjk,gF) only to H.

    • Finally, form a 6-cycle in G by connecting the three wjk’s with the three 𝗅𝗂𝗍𝗏(jk)’s in an alternating cycle such that no two wjk’s nor any two 𝗅𝗂𝗍𝗏(jk)’s are adjacent.

This completes the reduction. It is easy to see that it takes polynomial time, and both graphs G and H have degeneracy at most 3.

(a) Variable gadget in G.
(b) Variable gadget in H.
(c) Clause gadget in G.
(d) Clause gadget in H.
Figure 4: Illustration of the reduction. (Top) Variable gadgets in G and H for a variable (vi). (Bottom) Clause gadgets in G and H for some clause of the form (vivjvk).

We now show the equivalence between satisfiability of ψ and labeled contractibility of G into H.
() Suppose there exists a satisfying assignment α:{x1,,xn}{True,False} such that exactly one literal is true in each clause. Define the contraction sequence S as follows:

  • For each xi, if α(xi)=True, then add edges (vi,gT), (vi,gF) to S; and if α(xi)=False, then add edges (vi,gF), (vi,gT) to S.

This ensures the correct neighborhood for ui in H, as it will have edges to both gT and gF.

Now consider any clause Cj. Since exactly one literal is true under α, exactly one 𝗅𝗂𝗍𝗏(jk) is contracted into gT, and the remaining two are contracted into gF. The contraction of the wjk-triangle via the 6-cycle then ensures:

  • The edge (wj0,gT) is introduced by the literal assigned true;

  • The edge (wj0,gF) is introduced by the literals assigned false;

  • All three edges (gF,wj1),(gF,wj2),(gF,wj3) are created.

Hence, the resulting graph after the contraction is precisely H.
() Conversely, suppose H is a labeled contraction of G. We argue that this implies a satisfying assignment for ψ.

The only way to create both edges (ui,gT) and (ui,gF) in H is by contracting vi and vi into gT and gF, respectively, or vice versa. This naturally defines a valid assignment:

α(xi)={Trueif vi is contracted to gT,Falseif vi is contracted to gT.

Next, observe that to produce all three edges (gF,wj1),(gF,wj2),(gF,wj3), at least two of the literals in clause Cj must contract to gF, while one contracts to gT. Thus, in each clause, exactly one literal must be set to true under α. Therefore, α satisfies ψ as a 1-in-3-SAT assignment.

Each vertex in the variable and clause gadgets has degree at most 3 in G and at most 2 in H, so the degeneracy of both graphs is bounded by a constant. The size of G is linear in n+m, and the construction can be completed in polynomial time. Hence, if Labeled Contraction can be solved in time 2o(|V(G)|+|E(G)|), then 1-in-3-SAT can be solved in time 2o(n+m), which contradicts ETH according to Proposition 21. This completes the proof of Theorem 3.

5.2 Algorithmic Result

We first present proof of Theorem 4 establishing an alternate 𝖥𝖯𝖳 algorithm and later mention its consequences. Recall that the theorem states that the Labeled Contraction problem admits an algorithm with running time (δ(H)+1)k|V(G)|𝒪(1), where k=|V(G)V(H)|.

Let (G,H) be an instance of the Labeled Contraction problem. With sanity check, we can assume that V(H)V(G).

The goal is to decide whether there exists a valid witness structure 𝒲={WhV(G)hV(H)} such that contracting each Wh into the vertex h yields the graph H.

Let k=|V(G)V(H)| denote the number of vertices in G that are not in H, and hence must be contracted. Each such vertex xV(G)V(H) must be assigned to exactly one vertex hV(H), corresponding to the witness set Wh into which x will be contracted.

Define a mapping ϕ:V(G)V(H) as follows: (i) For each vV(H), set ϕ(v)=v; (ii) For each xV(G)V(H), ϕ(x) denotes the vertex in V(H) to which x is assigned (i.e., the representative vertex of the witness set containing x). A mapping ϕ defines a candidate witness structure, and we wish to determine whether it corresponds to a valid contraction of G into H.

To bound the number of candidate functions ϕ, we exploit structural properties of the graph H. Let δ(H) denote the degeneracy of H. By definition, H admits an ordering v1,v2,,vn such that each vertex has at most δ(H) neighbors among its predecessors. This implies that H is (δ(H)+1)-colorable, and such a coloring can be computed in polynomial time.

Fix a proper coloring c:V(H)[δ(H)+1]. For each vertex xV(G)V(H), let NH(x):={vV(H){x,v}E(G)}. If two vertices y1,y2NH(x) belong to the same color class (i.e., c(y1)=c(y2)) and {y1,y2}E(H), then assigning x to either y1 or y2 would result in the edge {y1,y2} being introduced during the contraction process – contradicting the assumption that H is the target graph. Therefore, for each xV(G)V(H), there are at most δ(H)+1 valid choices for ϕ(x). These choices corresponds at most one vertex in each color class. Thus, the total number of candidate assignments ϕ is bounded by (δ(H)+1)k. For each such assignment, we can verify in polynomial time whether the induced contraction yields H, by simulating the contraction and checking edge and label consistency. This yields an algorithm with running time (δ(H)+1)k|V(G)|𝒪(1). This completes the proof for Theorem 4

6 Brute-force Algorithm and its Optimality

We now prove Theorem 5. We establish a conditional lower bound showing that the brute-force algorithm described in the full version is essentially optimal, unless the Exponential Time Hypothesis (ETH) fails. For the full details of the brute-force algorithm and its exact running time analysis, we refer the reader to the longer version of this paper. We present the conditional lower bound proof here.

Our lower bound is derived via a polynomial-time reduction from the following problem, introduced by Fomin et al. [28], which has served as a hardness source for several contraction-based graph problems.

Cross Matching

Input: A graph G together with a partition (A,B) of V(G) such that |A|=|B|.

Question: Does there exist a perfect matching ME(G) such that each edge in M connects one vertex from A and one from B, and the graph G/M is a clique?

Proposition 22 (Lemma 4.1 in [28]).

Unless the ETH fails, Cross Matching cannot be solved in time no(n), where n=|A|=|B|.

We now present a polynomial-time reduction from Cross Matching to Labeled Contractibility, preserving the ETH-based lower bound under size-preserving transformation.

(a) Graph G.
(b) Graph H.
Figure 5: Illustration of the graphs G and H in the reduction. The required adjacency across {x1,x2} and A forces a candidate solution to form a matching across A and B.
Lemma 23.

Unless the ETH fails, the Labelled Contractibility problem does not admit an algorithm running in time |V(H)|o(|V(G)|).

Proof.

Let (G,A,B) be an instance of Cross Matching with |A|=|B|=n. We construct an equivalent instance (G,H) of Labeled Contractibility as follows.

The graph G is obtained from G by introducing two new vertices x1 and x2, and adding edges between each of these new vertices and all vertices in B. Formally, V(G)=V(G){x1,x2}, and E(G)=E(G){(x1,b),(x2,b)bB}. The target graph H is defined on vertex set V(H)=A{x1,x2}, with the following edge set: (i) all pairs {a1,a2}A are adjacent (i.e., A induces a clique); and (ii) both x1 and x2 are adjacent to every vertex in A. We remark that vertices x1 and x2 are not adjacent. Equivalently, H is a complete graph on A{x1,x2} minus the edge (x1,x2). See Figure 5 for an illustration.

We prove that (G,A,B) is a Yes-instance of Cross Matching if and only if (G,H) is a Yes-instance of Labeled Contractibility.

() Suppose (G,A,B) is a Yes-instance of Cross Matching. Then there exists a perfect matching M between A and B such that the contracted graph G/M is a clique.

We construct a labeled contraction sequence S on G by contracting each edge (a,b)M, with aA and bB, in arbitrary order. Since M is a matching, all contracted edges are vertex-disjoint. After performing all contractions in S, each vertex bB is removed, and the vertex set of G/S becomes A{x1,x2}.

In G/S, the subgraph induced by A is a clique, since G/M is a clique and the contractions only merged b into a. Furthermore, since x1 and x2 were connected to every bB, and each b was contracted into some aA, the contraction introduces edges from both x1 and x2 to every aA. However, since x1 and x2 are not adjacent to each other in the original graph G, and no contraction involved either of them, the edge (x1,x2) is not introduced. Thus, the resulting graph G/S is H.

() Suppose (G,H) is a Yes-instance of Labelled Contractibility, i.e., there exists a sequence S of labeled contractions such that G/S=H.

By construction, V(G)=AB{x1,x2} and V(H)=A{x1,x2}. Therefore, all vertices in B must be removed during the contraction sequence. In the labeled contraction model, a vertex is removed only when it is the second vertex in a contracted pair. Hence, each bB must appear as the second vertex in some contraction (u,b)S.

We now argue that each bB must be contracted into a distinct vertex aA. Suppose, for contradiction, that some aA does not serve as the representative of any contracted pair. Consider the edge (a,x1) in H. Since a and x1 were not adjacent in G, this edge must have been created through a contraction involving a common neighbor bB. The only way to generate such an edge is to contract b into x1, i.e., perform (x1,b)S. However, b is also adjacent to x2 in G, and contracting b into x1 would create an edge (x1,x2), a contradiction, since (x1,x2)E(H). Therefore, for each aA, there must be a distinct bB such that (a,b)S. Since |A|=|B|=n, this yields a perfect matching M={(a,b)S} between A and B.

Finally, we argue that G/M is a clique. Since G/S=H, and the subgraph induced by A in H is a clique, the same must hold in G/M (as contractions outside AB do not affect this subgraph). Thus, (G,A,B) is a Yes-instance of Cross Matching.

The construction of (G,H) from (G,A,B) takes polynomial time. The sizes satisfy |V(G)|=2n+2 and |V(H)|=n+2, both in 𝒪(n). Therefore, if Labeled Contractibility admitted an algorithm running in time |V(H)|o(|V(G)|), then Cross Matching could be solved in time no(n), contradicting the ETH according to Proposition 22. This concludes the proof of the lemma.

References

  • [1] Akanksha Agarwal, Saket Saurabh, and Prafullkumar Tale. On the parameterized complexity of contraction to generalization of trees. Theory of Computing Systems, 63(3):587–614, 2019. doi:10.1007/s00224-018-9892-z.
  • [2] Akanksha Agrawal, Lawqueen Kanesh, Saket Saurabh, and Prafullkumar Tale. Paths to trees and cacti. Theoretical Computer Science, 860:98–116, 2021. doi:10.1016/j.tcs.2021.01.033.
  • [3] Akanksha Agrawal, Daniel Lokshtanov, Saket Saurabh, and Meirav Zehavi. Split contraction: The untold story. ACM Transactions on Computation Theory, 11(3):1–22, 2019. doi:10.1145/3319909.
  • [4] Takao Asano and Tomio Hirata. Edge-contraction problems. J. Comput. Syst. Sci., 26(2):197–208, 1983. doi:10.1016/0022-0000(83)90012-0.
  • [5] Rémy Belmonte, Petr A. Golovach, Pim Hof, and Daniël Paulusma. Parameterized complexity of three edge contraction problems with degree constraints. Acta Informatica, 51(7):473–497, 2014. doi:10.1007/S00236-014-0204-Z.
  • [6] Benjamin Bergougnoux, Tuukka Korhonen, and Jesper Nederlof. Tight lower bounds for problems parameterized by rank-width. arXiv preprint, 2210(02117), 2022. doi:10.48550/arXiv.2210.02117.
  • [7] Ivan Bliznets, Fedor V. Fomin, Marcin Pilipczuk, and Michal Pilipczuk. A subexponential parameterized algorithm for proper interval completion. SIAM J. Discret. Math., 29(4):1961–1987, 2015. doi:10.1137/140988565.
  • [8] Ivan Bliznets, Fedor V. Fomin, Marcin Pilipczuk, and Michal Pilipczuk. Subexponential parameterized algorithm for interval completion. ACM Trans. Algorithms, 14(3):35:1–35:62, 2018. doi:10.1145/3186896.
  • [9] Andries E. Brouwer and Henk Jan Veldman. Contractibility and np-completeness. J. Graph Theory, 11(1):71–79, 1987. doi:10.1002/jgt.3190110111.
  • [10] Leizhen Cai and Chengwei Guo. Contracting few edges to remove forbidden induced subgraphs. In Proc. of the 8th International Symposium on Parameterized and Exact Computation (IPEC), volume 8246 of LNCS, pages 97–109, 2013. doi:10.1007/978-3-319-03898-8_10.
  • [11] Yixin Cao. Linear recognition of almost interval graphs. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, pages 1096–1115. SIAM, 2016. doi:10.1137/1.9781611974331.ch77.
  • [12] Yixin Cao. Unit interval editing is fixed-parameter tractable. Inf. Comput., 253:109–126, 2017. doi:10.1016/j.ic.2017.01.008.
  • [13] Yixin Cao and Dániel Marx. Interval deletion is fixed-parameter tractable. ACM Trans. Algorithms, 11(3):21:1–21:35, 2015. doi:10.1145/2629595.
  • [14] Yixin Cao and Dániel Marx. Chordal editing is fixed-parameter tractable. Algorithmica, 75(1):118–137, 2016. doi:10.1007/s00453-015-0014-x.
  • [15] Dibyayan Chakraborty, Oscar Defrain, Florent Foucaud, Mathieu Mari, and Prafullkumar Tale. Parameterized complexity of isometric path partition: treewidth and diameter. arXiv preprint, 2508(05448), 2025. doi:10.48550/arXiv.2508.05448.
  • [16] Dipayan Chakraborty, Florent Foucaud, Diptapriyo Majumdar, and Prafullkumar Tale. Tight (double) exponential bounds for identification problems: Locating-dominating set and test cover. 35th International Symposium on Algorithms and Computation (ISAAC 2024), 322:19:1–19:18, 2024. doi:10.4230/LIPIcs.ISAAC.2024.19.
  • [17] Christophe Crespelle, Pål Grønås Drange, Fedor V. Fomin, and Petr A. Golovach. A survey of parameterized algorithms and the complexity of edge modification. CoRR, abs/2001.06867, 2020. arXiv:2001.06867.
  • [18] Christophe Crespelle, Pål Grønås Drange, Fedor V. Fomin, and Petr A. Golovach. A survey of parameterized algorithms and the complexity of edge modification, 2020. arXiv:2001.06867.
  • [19] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [20] Marek Cygan, Dániel Marx, Marcin Pilipczuk, and Michal Pilipczuk. Hitting forbidden subgraphs in graphs of bounded treewidth. Inf. Comput., 256:62–82, 2017. doi:10.1016/J.IC.2017.04.009.
  • [21] Marek Cygan, Jesper Nederlof, Marcin Pilipczuk, Michal Pilipczuk, Johan M. M. van Rooij, and Jakub Onufry Wojtaszczyk. Solving connectivity problems parameterized by treewidth in single exponential time. ACM Trans. Algorithms, 18(2):17:1–17:31, 2022. doi:10.1145/3506707.
  • [22] Andreas Darmann and Janosch Döcker. On a simple hard variant of not-all-equal 3-sat. Theor. Comput. Sci., 815:147–152, 2020. doi:10.1016/J.TCS.2020.02.010.
  • [23] Pål Grønås Drange, Markus Fanebust Dregi, Daniel Lokshtanov, and Blair D. Sullivan. On the threshold of intractability. J. Comput. Syst. Sci., 124:1–25, 2022. doi:10.1016/j.jcss.2021.09.003.
  • [24] Pål Grønås Drange, Fedor V. Fomin, Michal Pilipczuk, and Yngve Villanger. Exploring subexponential parameterized complexity of completion problems. In 31st International Symposium on Theoretical Aspects of Computer Science (STACS), volume 25 of LIPIcs, pages 288–299, 2014. doi:10.4230/LIPIcs.STACS.2014.288.
  • [25] Pål Grønås Drange and Michal Pilipczuk. A polynomial kernel for trivially perfect editing. Algorithmica, 80(12):3481–3524, 2018. doi:10.1007/s00453-017-0401-6.
  • [26] Jörg Flum and Martin Grohe. Parameterized Complexity Theory. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2006. doi:10.1007/3-540-29953-X.
  • [27] Fedor V. Fomin, Stefan Kratsch, Marcin Pilipczuk, Michal Pilipczuk, and Yngve Villanger. Tight bounds for parameterized complexity of cluster editing with a small number of clusters. J. Comput. Syst. Sci., 80(7):1430–1447, 2014. doi:10.1016/j.jcss.2014.04.015.
  • [28] Fedor V. Fomin, Daniel Lokshtanov, Ivan Mihajlin, Saket Saurabh, and Meirav Zehavi. Computation of hadwiger number and related contraction problems: Tight lower bounds. ACM Trans. Comput. Theory, 13(2):10:1–10:25, 2021. doi:10.1145/3448639.
  • [29] Fedor V. Fomin and Yngve Villanger. Subexponential parameterized algorithm for minimum fill-in. SIAM J. Comput., 42(6):2197–2216, 2013. doi:10.1137/11085390X.
  • [30] Florent Foucaud, Esther Galby, Liana Khazaliya, Shaohua Li, Fionn Mc Inerney, Roohani Sharma, and Prafullkumar Tale. Problems in NP can admit double-exponential lower bounds when parameterized by treewidth or vertex cover. In 51st International Colloquium on Automata, Languages, and Programming, ICALP, volume 297 of LIPIcs, pages 66:1–66:19, 2024. doi:10.4230/LIPICS.ICALP.2024.66.
  • [31] Florent Foucaud, Esther Galby, Liana Khazaliya, Shaohua Li, Fionn Mc Inerney, Roohani Sharma, and Prafullkumar Tale. Metric dimension and geodetic set parameterized by vertex cover. In 42nd International Symposium on Theoretical Aspects of Computer Science, STACS, volume 327 of LIPIcs, pages 33:1–33:20, 2025. doi:10.4230/LIPICS.STACS.2025.33.
  • [32] Petr A. Golovach, Marcin Kaminski, Daniël Paulusma, and Dimitrios M Thilikos. Increasing the minimum degree of a graph by contractions. Theoretical Computer Science, 481:74–84, 2013. doi:10.1016/j.tcs.2013.02.030.
  • [33] Petr A. Golovach, Pim van’t Hof, and Daniël Paulusma. Obtaining planarity by contracting few edges. Theoretical Computer Science, 476:38–46, 2013. doi:10.1016/j.tcs.2012.12.041.
  • [34] Sylvain Guillemot and Dániel Marx. A faster FPT algorithm for Bipartite Contraction. Information Processing Letters, 113(22):906–912, 2013. doi:10.1016/j.ipl.2013.09.004.
  • [35] Pinar Heggernes, Pim van ’t Hof, Benjamin Lévêque, Daniel Lokshtanov, and Christophe Paul. Contracting graphs to paths and trees. Algorithmica, 68(1):109–132, 2014. doi:10.1007/s00453-012-9670-2.
  • [36] Pinar Heggernes, Pim van ’t Hof, Daniel Lokshtanov, and Christophe Paul. Obtaining a bipartite graph by contracting few edges. SIAM Journal on Discrete Mathematics, 27(4):2143–2156, 2013. doi:10.1137/130907392.
  • [37] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k-sat. J. Comput. Syst. Sci., 62(2):367–375, 2001. doi:10.1006/JCSS.2000.1727.
  • [38] Russell Impagliazzo, Ramamohan Paturi, and Francis Zane. Which problems have strongly exponential complexity? J. Comput. Syst. Sci., 63(4):512–530, 2001. doi:10.1006/JCSS.2001.1774.
  • [39] Tuukka Korhonen and Daniel Lokshtanov. An improved parameterized algorithm for treewidth. SIAM Journal on Computing, 0(0):STOC23–155–STOC23–214, 2023. doi:10.1137/23M1595059.
  • [40] R. Krithika, Pranabendu Misra, and Prafullkumar Tale. A single exponential-time FPT algorithm for cactus contraction. Theor. Comput. Sci., 954:113803, 2023. doi:10.1016/J.TCS.2023.113803.
  • [41] Manuel Lafond and Bertrand Marchand. The parameterized landscape of labeled graph contractions. In (To appear) in Algorithms and Data Structures Symposium WADS 2025, volume abs/2502.16096, 2025. doi:10.48550/arXiv.2502.16096.
  • [42] John M. Lewis and Mihalis Yannakakis. The node-deletion problem for hereditary properties is np-complete. J. Comput. Syst. Sci., 20(2):219–230, 1980. doi:10.1016/0022-0000(80)90060-4.
  • [43] Daniel Lokshtanov, Dániel Marx, and Saket Saurabh. Slightly superexponential parameterized problems. SIAM J. Comput., 47(3):675–702, 2018. doi:10.1137/16M1104834.
  • [44] Daniel Lokshtanov, Neeldhara Misra, and Saket Saurabh. On the hardness of eliminating small induced subgraphs by contracting edges. In Proc. of the 8th International Symposium on Parameterized and Exact Computation (IPEC), volume 8246 of LNCS, pages 243–254, 2013. doi:10.1007/978-3-319-03898-8_21.
  • [45] Bertrand Marchand, Nadia Tahiri, Olivier Tremblay Savard, and Manuel Lafond. Finding maximum common contractions between phylogenetic networks. In Solon P. Pissis and Wing-Kin Sung, editors, 24th International Workshop on Algorithms in Bioinformatics, WABI, volume 312 of LIPIcs, pages 16:1–16:24, 2024. doi:10.4230/LIPICS.WABI.2024.16.
  • [46] Bertrand Marchand, Nadia Tahiri, Olivier Tremblay-Savard, and Manuel Lafond. Finding Maximum Common Contractions Between Phylogenetic Networks. In WABI, pages 16:1–16:24, 2024. doi:10.4230/LIPIcs.WABI.2024.16.
  • [47] Barnaby Martin and Daniël Paulusma. The computational complexity of disconnected cut and 2K2-partition. Journal of Combinatorial Theory, Series B, 111:17–37, 2015. doi:10.1016/j.jctb.2014.09.002.
  • [48] Michal Pilipczuk. Problems parameterized by treewidth tractable in single exponential time: A logical approach. In Mathematical Foundations of Computer Science 2011 - 36th International Symposium, MFCS, volume 6907 of Lecture Notes in Computer Science, pages 520–531. Springer, 2011. doi:10.1007/978-3-642-22993-0_47.
  • [49] Ignasi Sau and Uéverton dos Santos Souza. Hitting forbidden induced subgraphs on bounded treewidth graphs. Inf. Comput., 281:104812, 2021. doi:10.1016/J.IC.2021.104812.
  • [50] Saket Saurabh and Prafullkumar Tale. On the parameterized complexity of maximum degree contraction problem. arXiv preprint arXiv:2009.11793, 2020.
  • [51] Saket Saurabh and Prafullkumar Tale. On the parameterized complexity of maximum degree contraction problem. In Proc. of the 15th International Symposium on Parameterized and Exact Computation (IPEC), volume 180 of LIPIcs, pages 26:1–26:16, 2020. doi:10.4230/LIPIcs.IPEC.2020.26.
  • [52] Prafullkumar Tale. Double exponential lower bound for telephone broadcast, 2024. doi:10.48550/arXiv.2403.03501.
  • [53] Toshimasa Watanabe, Tadashi Ae, and Akira Nakamura. On the removal of forbidden graphs by edge-deletion or by edge-contraction. Discret. Appl. Math., 3(2):151–153, 1981. doi:10.1016/0166-218X(81)90039-1.
  • [54] Mihalis Yannakakis. Node- and Edge-Deletion NP-Complete Problems. In Proc. of the 10th Annual ACM Symposium on Theory of Computing (STOC), pages 253–264, 1978. doi:10.1145/800133.804355.