On Structural Parameterizations of the Bounded-Degree Vertex Deletion Problem

We study the parameterized complexity of the Bounded-Degree Vertex Deletion problem (BDD), where the aim is to find a maximum induced subgraph whose maximum degree is below a given degree bound. Our focus lies on parameters that measure the structural properties of the input instance. We first show that the problem is W[1]-hard parameterized by a wide range of fairly restrictive structural parameters such as the feedback vertex set number, pathwidth, treedepth, and even the size of a minimum vertex deletion set into graphs of pathwidth and treedepth at most three. We thereby resolve an open question stated in Betzler, Bredereck, Niedermeier and Uhlmann (2012) concerning the complexity of BDD parameterized by the feedback vertex set number. On the positive side, we obtain fixed-parameter algorithms for the problem with respect to the decompositional parameter treecut width and a novel problem-specific parameter called the core fracture number.


Introduction
This paper studies the Bounded-degree Vertex deletion problem (BDD): given an undirected graph G, a degree bound d, and a limit , determine whether it is possible to delete at most vertices from G in order to obtain a graph of maximum degree at most d.Aside from being a natural generalization of the classical Vertex CoVer problem, BDD has found applications in areas such as computational biology [19] and is the dual problem of the so-called s-Plex Detection problem in social network analysis [3,38,39,44].Finally, related problems on directed as well as undirected graphs which model problems in voting theory and social network analysis have also been studied in the literature [5,7].
It is not surprising that the complexity of BDD and several of its variants has been studied extensively by the theory community in the past years [4,6,9,10,13,34,42,44].Since the problem is NP-complete in general, it is natural to ask under which conditions does the problem become tractable.In this direction, the parameterized complexity paradigm [12,15,41] allows a more refined analysis of the problem's complexity than classical complexity.In the parameterized setting, we associate each instance with a numerical parameter k and are most often interested in the existence of a fixed-parameter algorithm, i.e., an algorithm solving the problem in time f (k) ⋅ |V(G)| O(1) for some computable function f.Parameterized problems admitting such an algorithm belong to the class FPT; on the other hand, parameterized problems that are hard for the complexity class W [1] or W [2] do not admit fixed-parameter algorithms (under standard complexity assumptions).
In general, there exist two notable approaches for selecting parameters: a parameter may either originate from the formulation of the problem itself (often called natural parameters), or rather from the structure of the input graph (so-called structural parameters, most prominently represented by the decomposition-based parameter treewidth ).The parameterized complexity of BDD has already been studied extensively through the lens of natural parameters (especially d and ).In particular, BDD is known to be FPT when parameterized by d + [19, 39, 42], W [2]-hard when parameterized only by [19], and NP-complete when parameterized only by d (as witnessed by the case of d = 0 , i.e., Vertex CoVer).The complexity of BDD is also fairly well understood when considering combinations of natural and structural parameters: it is FPT when parameterized by + d due to Courcelle's Theorem [11] and has been shown to be FPT when parameterized by + [6].Given the above, it is fairly surprising that the problem has remained fairly unexplored when viewed through the lens of structural parameters only, i.e., in the case where we impose no restrictions on the problem formulation itself but only on the structure of the graph.BDD was shown W [1]-hard when parameterized by treewidth [6], complementing the previous O(n +1 ) algorithm of Dessmark et al. [13].The only structural parameter which is known to make the problem fixed-parameter tractable is the feedback edge set number, i.e., the minimum number of edges whose deletion results in a forest [6].
Contribution The goal of this paper is to provide new insight into the complexity of BDD parameterized by the structure of the input graph.Our first main result 1 3 Algorithmica (2021) 83:  shows that BDD is [1]-hard parameterized by the feedback vertex set number, i.e., the minimum number of vertices whose deletion results in a forest.This resolves an open question in [6].Interestingly, our result is significantly stronger since we show that hardness even applies in the case that the remaining parts, after deleting the feedback vertex set, are trees of height three.This rules out fixed-parameter algorithms w.r.t. mst of the remaining "classical" decomposition-based structural parameters such as pathwidth and treedepth [40] as well as w.r.t. the vertex deletion distance [23,40] to bounded pathwidth, treedepth, and treewidth.On the way to our hardness result we show hardness for several multidimensional variants of the classical subset sum problem parameterized by the number of dimensions, which we believe are interesting on their own.
In light of the above, it is natural to ask whether there exist natural decomposition-based parameters for which BDD is fixed-parameter tractable.Our main algorithmic result answers this question affirmatively: we obtain a fixed-parameter algorithm utilizing the recently introduced structural parameter called treecut width.The importance of treecut width is that it plays a similar role with respect to the fundamental graph operation of immersion as the graph parameter treewidth plays with respect to the minor operation [32,37,45].Up to now, only a handful of problems are known to be FPT when parameterized by treecut width but W [1]-hard when parameterized by treewidth [24]; recent work on treecut width also included new algorithmic lower bounds [27] and experimental evaluations [26].We note that unlike previous algorithms exploiting treecut width, ours does not make use of an Integer Linear Programming formulation but instead relies purely on combinatorial arguments.
Our second algorithmic result focuses on structural parameters which are not based on any particular decomposition of the graph, but instead measure the "vertex-deletion distance" to a certain graph property.Such structural parameters have been successfully used in the past for a plethora of other difficult problems [16,17,23,28,29,35].In this context and taking into account the strong lower bounds obtained in Sect.3, we introduce a structural parameter which is specifically tailored to BDD and which we call the core fracture number.Roughly speaking, the core fracture number k is the vertex deletion distance to a graph where each connected component only contains at most k vertices which exceed the degree bound d.We show that computing the core fracture number is FPT which in turn gives rise to a fixed-parameter algorithm for BDD; the latter is achieved by identifying and formalizing a type-aggregation condition, allowing for an encoding of the problem into an Integer Linear Program with a controlled number of integer variables.Since core fracture number generalizes vertex cover, this also resolves the question from [6] if BDD is FPT parameterized by vertex cover.
Finally, we exclude the existence of a polynomial kernel [12,15] for BDD parameterized by the treecut width and core fracture number, and compare the two parameters in Sect. 5.

Basic Notation
We use standard terminology for graph theory, see for instance [14].All graphs except for those used to compute the torso-size in Sect.2.4 are simple; the multigraphs used in Sect.2.4 have loops, and each loop increases the degree of the vertex by 2.
Let G be a graph.We denote by V(G) and E(G) its vertex and edge set, respectively.For a vertex v ∈ V(G) , let N G (v) = {y ∈ V(G) ∶ vy ∈ E(G)} , N G [v] = N G (v) ∪ {v} , and deg G (v) denote its open neighborhood, closed neighbor- hood, and degree, respectively.For a subset X ⊆ V(G) , the (open) neighborhood N G (X) of X is defined as refers to the closed neigh- borhood of X defined as N G (X) ∪ X .We refer to the set N G (V(G) ⧵ X) as G (X) ; this is the set of vertices in X which have a neighbor in V(G) ⧵ X .We omit the lower index G, if G is clear from the context.For a vertex set A, we use G − A to denote the graph obtained from G by deleting all vertices in A. We use [i] to denote the set {0, 1, … , i} ; note that [i] includes 0. For completeness, we provide a formal defini- tion of our problem of interest below.

Input:
A n undirected graph G = (V, E) and integers d ≥ 0 and ≥ 0. Question: Is there a subset V ⊆ V with |V | ≤ whose removal from G yields a graph in which each vertex has degree at most d?

Parameterized Complexity
A parameterized problem P is a subset of * × ℕ for some finite alphabet .Let L ⊆  * be a classical decision problem for a finite alphabet, and let p be a non- negative integer-valued function defined on * .Then L parameterized by denotes the parameterized problem { (x, (x)) | x ∈ L } where x ∈ * .For a problem instance (x, k) ∈ * × ℕ we call x the main part and k the parameter.A parameter- ized problem P is fixed-parameter tractable (FPT in short) if a given instance (x, k) can be solved in time O(f (k) ⋅ p(|x|)) where f is an arbitrary computable function of k and p is a polynomial function; we call algorithms running in this time fixedparameter algorithms.We refer the reader to [15] for more details on parameterized complexity.
Parameterized complexity classes are defined with respect to fpt-reducibility.
, where f and g are computable functions 1 3 Algorithmica (2021) 83:297-336 depending only on k.Owing to the definition, if P fpt-reduces to Q and Q is fixed- parameter tractable then P is fixed-parameter tractable as well.
Central to parameterized complexity is the following hierarchy of complexity classes, defined by the closure of canonical problems under fpt-reductions: All inclusions are believed to be strict.In particu- lar, ≠ [1] under the Exponential Time Hypothesis [30].The class [1] is the analog of in parameterized complexity.A major goal in parameterized complexity is to distinguish between parameterized problems which are in and those which are [1]-hard, i.e., those to which every prob- lem in [1] is fpt-reducible.There are many problems shown to be complete for [1] , or equivalently [1]-complete, including the MultiColored Clique (MCC) problem [15].
Closely related to the search for fixed-parameter algorithms is the search for efficient preprocessing techniques.The goal here is to find an equivalent instance (the so-called kernel) in polynomial time whose size can be bounded by a function of the parameter.A kernelization algorithm transforms in polynomial time a problem instance (x, k) of a parameterized problem L into an instance , and (iii) the size of x ′ can be bounded above by g(k), for functions f and g depending only on k.It is easy to show that a parameterized problem is in FPT if and only if there is kernelization algorithm.A polynomial kernel is a kernel, whose size can be bounded by a polynomial in the parameter.
A polynomial parameter transformation from a parameterized problem P to a parameterized problem Q is a parameterized reduction from P to Q that maps instances (I, k) of P to instances (I � , k � ) of Q with the additional property that 1. (I � , k � ) can be computed in time that is polynomial in |I| + k , and 2. k ′ is bounded by some polynomial p of k.
Proposition 1 [2, Proposition 1] Let P and Q be two parameterized problems such that there is a polynomial parameter transformation from P to Q .Then, if Q has a polynomial kernel also P has a polynomial kernel.
In the following we will introduce another tool called cross-compositions, introduced by [8], for showing lower bounds for the size of kernels.An equivalence relation R on * is called a polynomial equivalence relation if the follow- ing two conditions hold: 1.There is an algorithm that given two strings x, y ∈ * decides whether x and y belong to the same equivalence class in (|x| + |y|) O(1) time.2. For any finite set S ⊆  * the equivalence relation R partitions the elements of S into at most (max s∈S |s|) O(1) classes.
Let L ⊆  * be an (unparameterized) problem and let P ⊆  * × ℕ be a parameter- ized problem.We say that L AND-cross-composes into P if there is a polyno- mial equivalence relation R and an algorithm which, given t instances (x

Integer Linear Programming
Our algorithms use an Integer Linear Programming (ILP) subroutine.ILP is a wellknown framework for formulating problems and a powerful tool for the development of fixed-parameter algorithms for optimization problems.

Definition 1 (p-Variable Integer Linear Programming Optimization
The task is to find a vector x ∈ ℤ p×1 which mini- mizes the objective function c × x and satisfies all q inequalities given by A and b, specifically satisfies A ⋅ x ≥ b .The number of variables p is the parameter (Fig. 1).

Treecut Width
The notion of treecut decompositions was first proposed by Wollan [45], see also [37].A family of subsets X 1 , … , X k of X is a near-partition of X if they are pairwise disjoint and ⋃ k i=1 X i = X , allowing the possibility of X i = �.
Definition 2 A treecut decomposition of G is a pair (T, X) which consists of a rooted tree T and a near-partition A set in the family X is called a bag of the treecut decomposition.
For any node t of T other than the root r, let e(t) = ut be the unique edge incident to t on the path to r.Let T u and T t be the two connected components in T − e(t) which contain u and t, respectively.Note that ( ⋃ q∈T u X q , ⋃ q∈T t X q ) is a near-parti- tion of V(G), and we use (t) to denote the set of edges with one endpoint in each part.We define the adhesion of t ( T (t) or (t) in brief) as | (t)| ; if t is the root, we set T (t) = 0 and (t) = �.The torso of a treecut decomposition (T, X) at a node t, written as H t , is the graph obtained from G as follows.If T consists of a single node t, then the torso of (T, X) The torso H t at t is obtained from G by consolidating each vertex set Z i into a single vertex z i (this is also called shrinking in the literature).Here, the operation of consolidating a vertex set Z into z is to substitute Z by z in G, and for each edge e between Z and v ∈ V(G) ⧵ Z , adding an edge zv in the new graph.We note that this may create par- allel edges.
The operation of suppressing (also called dissolving in the literature) a vertex v of degree at most 2 consists of deleting v, and when the degree is two, adding an edge between the neighbors of v. Given a connected graph G and X ⊆ V(G) , let the 3-center of (G, X) be the unique graph obtained from G by exhaustively suppressing vertices in V(G) ⧵ X of degree at most two.Finally, for a node t of T, we denote by Ht the 3-center of (H t , X t ) , where H t is the torso of (T, X) at t. Let the torso-size (t) denote | Ht |.

Definition 3
The width of a treecut decomposition (T, X) of G is defined as max t∈V(T) { (t), (t)} .The treecut width of G, or (G) in short, is the mini- mum width of (T, X) over all treecut decompositions (T, X) of G.
We conclude this subsection with some notation related to treecut decompositions.Given a tree node t, let T t be the subtree of T rooted at t. Let Y t = ⋃ b∈V(T t ) X b , and let G t denote the induced subgraph G[Y t ] .The depth of a node t in T is the dis- tance of t from the root r.The vertices of t = G (Y t ) are called the border at node t.
A node t ≠ r in a rooted treecut decomposition is thin if (t) ≤ 2 and bold otherwise.For a node t, we let denote the set of thin children of t whose neighborhood is a subset of X t , and we let A t = { a is a child of t | a ∉ B t } be the set of all other children of t.
While it is not known how to compute optimal treecut decompositions efficiently, there exists a fixed-parameter 2-approximation algorithm which fully suffices for our purposes.

Theorem 1 ([32]
) There exists an algorithm that takes as input an n-vertex graph G and integer k, runs in time 2 O(k 2 ) n 2 , and either outputs a treecut decomposition of G of width at most 2k or correctly reports that (G) > k.
A treecut decomposition (T, X) is nice if it satisfies the following condition for every thin node t ∈ V(T) : The intuition behind nice treecut decompositions is that we restrict the neighborhood of thin nodes in a way which facilitates dynamic programming.

Lemma 1 ([24]
) There exists a cubic-time algorithm which transforms any rooted treecut decomposition (T, X) of G into a nice treecut decomposition of the same graph, without increasing its width or number of nodes.
The following property of nice treecut decompositions will be crucial for our algorithm.
Lemma 2 ([24]) Let t be a node in a nice treecut decomposition of width k.Then For completeness and self-containedness, we also provide the proofs of the previous two lemmata in an appendix.We refer to previous work [24,32,37,45] for a more detailed comparison of treecut width to other parameters.Here, we mention only that treecut width lies "between" treewidth and treewidth plus maximum degree.
Proposition 4 [24,37,45] Let (G) denote the treewidth of G and (G) denote the maximum over (G) and the maximum degree of a vertex in G. Then

Hardness Results
In this section we show that BDD is W[1]-hard parameterized by a vertex deletion set to trees of height at most three, i.e., a subset D of the vertices of the graph such that every component in the graph, after removing D, is a tree of height at most three.On the way towards this result, we provide hardness results for several interesting versions of the multidimensional subset sum problem (parameterized by the number of dimensions) which we believe are interesting in their own right.In 1 3 Algorithmica (2021) 83:297-336 particular, we note that the hardness results also hold for the well-known and more general multidimensional knapsack problem [22].Our first auxiliary result shows hardness for the following problem.

Multidimensional Subset Sum (MSS)
Input: An integer k, a set S = {s 1 , . . ., sn} of item-vectors with s i ∈ N k for every i with 1 ≤ i ≤ n and a target vector t ∈ N k .Parameter: k Question: Is there a subset S ⊆ S such that s∈S s = t?
-hard even if all integers in the input are given in unary.
Proof We prove the lemma by a parameterized reduction from MultiColored Clique, which is well-known to be W[1]-complete [43].Given an integer k and a k-partite graph G with partition V 1 , … , V k , the MultiColored Clique problem asks whether G contains a k-clique.In the following we denote by E i,j the set of all edges in G with one endpoint in V i and the other endpoint in V j , for every i and j with 1 ≤ i < j ≤ k .To show the lemma, we will construct an instance I = (k � , S, t) of For our reduction we will employ so called Sidon sequences of natural numbers.A Sidon sequence is a sequence of natural numbers such that the sum of every two distinct numbers in the sequence is unique.For our reduction we will need a Sidon sequence of |V(G)| natural numbers, i.e., containing one number for each vertex of G. Since the numbers in the Sidon sequence will be used as numbers in I , we need to ensure that the largest of these numbers is bounded by a polynomial in |V(G)|.Indeed [18] shows that a Sidon sequence containing n elements and whose largest element is at most 2p 2 , where p is the smallest prime number larger or equal to n, can be constructed in polynomial time.Together with Bertrand's postulate [1], which states that for every natural number n there is a prime number between n and 2n, we obtain that a Sidon sequence containing |V(G)| numbers and whose largest element is at most 8|V(G)| 2 can be found in polynomial time.In the following we will assume that we are given such a Sidon sequence S and we denote by S(i) the i-th element of S for any i with 1 ≤ i ≤ |V(G)| .Moreover, we denote by max(S) and max 2 (S) the largest element of S and the maximum sum of any two numbers in S , respectively.We will furthermore assume that the vertices of G are identified by numbers between 1 and |V(G)| and therefore S(v) is properly defined for every v ∈ V(G).
We are now ready to construct the instance I = (k � , S, t) .We set k � = 2 k 2 + k and t is the vector whose first k 2 entries are all equal to max 2 (S) + 1 and whose remaining k 2 + k entries are all equal to 1.For every i and j with 1 ≤ i < j ≤ k , we will use I(i, j) as a means of enumerating the indices in a sequence of two-element tuples; formally, I(i, j) = ( ∑ l<i l=1 (k − l)) + (j − 1) .Note that the vector t and its indices can then be visualized as follows: We now proceed to the construction of S, which will contain one element for each edge and for each vertex in G.In particular, the set S of item-vectors contains the following elements: -for every i with 1 ≤ i ≤ k and every v ∈ V i , a vector s v such that all entries with index in (informally, this corresponds to all indices where at least one ele- ment of the tuple (l, r) is equal to i), the 2 k 2 + i-th entry is equal to 1, and all other entries are equal to 0. The following illustrates s v for the case that k = 4 and i = 2 : -for every i and j with 1 ≤ i < j ≤ k and every e = {u, v} ∈ E(i, j) , a vector s e such that the entry I(i, j) is equal to (max 2 (S) + 1) − (S(u) + S(v)) , the k 2 + I(i, j)-th entry is equal to 1, and all other entries are equal to 0. The following illustrates the vector s e for the case that k = 4 , i = 2 , and j = 3 : This completes the construction of I .It is clear that I can be constructed in pol- ynomial time and moreover every integer in I is at most max 2 (S) + 1 and hence polynomially bounded in |V(G)|.Intuitively, the construction relies on the fact ) ) ) (3,4) , 0, 0, 0, 1, 0, 0 ⏟⏞⏞⏞⏞⏟⏞⏞⏞⏞⏟ Algorithmica (2021) 83:297-336 that since the sum of each pair of vertices is unique, we can uniquely associate each pair with an edge between these vertices whose value will then be the remainder to the global upper-bound of max 2 (S).

It remains to show that G has k-clique if and only if I has a solution. Towards showing the forward direction, let
Because C contains exactly one vertex from every V i and exactly one edge from every E i,j , it holds that t Moreover, for every i and j with 1 ≤ i < j ≤ k , the vectors s v i , s v j , and s e i,j are the only vectors in S ′ with a non-zero entry at the as required.
Towards showing the reverse direction, let S ′ be a subset of S such that ∑ s∈S � s = t .Because the last k entries of t are equal to 1 and for every i with 1 ≤ i ≤ k , it holds that the only vectors in S that have a non-zero entry at the i-th last position are the vectors in , we obtain that S ′ contains exactly one vector say e i,j in { s e | e ∈ E i,j } for every i and j with 1 , for every i and j with 1 ≤ i < j ≤ k , it holds that e i,j = {v i , v j } .To see this consider the I(i, j)-th entry of t � = ∑ s∈S � s .The only vectors in S ′ having a non-zero contribution towards t � [I(i, j)] are the vectors s v i , s v j , and s e i,j .Because . Because S is Sidon sequence and thus the sum (S(v i ) + S(v j )) is unique, we obtain that e i,j = {v i , v j } , as required. ◻ Observe that because any solution S ′ of the constructed instance in the previous lemma must be of size exactly k � = 2 k 2 + k , it follows that the above proof also shows W[1]-hardness of the following problem.

Input:
A n integer k, a set S = {s 1 , . . ., sn} of item-vectors with s i ∈ N k for every i with 1 ≤ i ≤ n, a target vector t ∈ N k , and an integer k .Parameter: k + k Question: Is there a subset S ⊆ S with |S | = k such that -hard even if all integers in the input are given in unary.
Using an fpt-reduction from the above problem, we will now show that also the following more relaxed version is W[1]-hard.

Multidimensional Relaxed Subset Sum (MRSS)
Input: A n integer k, a set S = {s 1 , . . ., sn} of item-vectors with Proof We prove the lemma by a parameterized reduction from rMSS, which is W[1]-hard even if all integers in the input are given in unary because of Corollary 1. Namely, given an instance I = (k, S, t, k � ) of rMSS we construct an equivalent instance I = (2k, S, t, k � ) of MrSS in polynomial time such that all integers in I are bounded by a polynomial of the integers in I.
The set S contains one vector s for every vector s ∈ S with for every i with 1 ≤ i ≤ k .This con- cludes the construction of I .Clearly, I can be constructed in polynomial time and the values of all numbers in I are bounded by a polynomial of the maximum num- ber in I .It remains to show that I has a solution if and only if I has a solution.
Towards showing the forward direction, let S ′ ⊆ S be a solution for I , i.e., for every i as above.Moreover, for every i with showing that S is a solution for I.
Towards showing the reverse direction, let S ′ ⊆ S be a solution for I ′ , i.e., } is a solution for I.Because S ′ is a solution for I ′ , we obtain for every i with 1 ≤ i ≤ k that: (1) . First, since we can assume that t[i] > 0 and therefore also Then by using this, we obtain that It follows from ( 1) and ( 2) that and hence S ′ is a solution for I of size k ′ , as required.
◻ We are now ready to show our main hardness result for BDD using a reduction from MrSS.

Theorem 2 BDD is W[1]-hard parameterized by the size of a vertex deletion set into trees of height at most 3.
Proof We prove the theorem by a parameterized reduction from MrSS.Namely, given an instance I = (k, S, t, k � ) of MrSS we construct an equivalent instance . The core idea of the reduction relies on transforming the decision of whether to select a vector into a solution S ′ for I into the decision of whether to resolve a tree gadget in G in one of two possible ways.See Fig. 2, which provides an illustration of the construction.The set D consists of (k � + 1) vertices i for every i with 1 ≤ i ≤ k .Moreover, for every s ∈ S we introduce the gadget G(s) defined as follows.G(s) consists of max(s) , where max(s) is the value of the largest coordinate of s, stars with centers c s 1 , … , c s max(s) .For now we attach one leaf denoted l s i to every such center c s i ; we will later attach additional "unnamed" leaves to ensure that every center has exactly d + 1 leaves, however, d is to be determined later.
Additionally, G(s) has a root vertex, denoted by r s , that has an edge to every center vertex c s i .Finally, we add edges between the leaves l s 1 , … , l s max(s) and the vertices in D such that for every i and j with 1 Clearly this is always possible and can be done in an arbitrary manner.
We set d to be the maximum degree of the part of G constructed so far (note that this maximum is reached by one of the vertices in D).We now add d leaves to each center c s i ensuring that every such center has exactly d + 1 leaves.Moreover, we now ensure that for every i and j with 1 in G by attaching a appropriate number of leaves to d j i .Finally, we set to be ( ∑ s∈S max(s)) + k � .This completes the construction of I ′ .Clearly, I ′ can be constructed in polynomial time.Moreover, |D| ≤ k ⋅ (k � + 1) and each component of G − D is a tree with height at most 3.It remains to show the equivalence between I and I ′ .
Towards showing the forward direction, let S ′ ⊆ S be a solution for For every s ∈ S ⧵ S � , V ′ contains the center vertices c s 1 , … , c s max(s) from G(s) and for every s ∈ S � , V ′ contains the root vertex r s and the leaf vertices Moreover, since for every s ∈ S , the only vertices in G(s), whose degree exceeds d in G, are the centers of the stars, we obtain that the degree of the vertices in G(s) w.r.t.G − V � is at most d.Finally, for every i and j with 1 ≤ i ≤ k and 1 ≤ j ≤ k ′ , the degree of the vertex d as required.Before we continue with the proof for the reverse direction, we will prove a crucial property of the gadget G(s) for any s ∈ S . ◻ ) has a solution, then there is a solution V � ⊆ V(G) such that for every s ∈ S , it holds that either: Proof Let V � ⊆ V(G) be a solution for I and let s ∈ S .It is easy to see that if Finally, since the leaf vertices l s 1 , … , l s max(s) are the only vertices in G(s) with neighbors in D, it holds that the degree of any vertex in D − V �� in G − V �� is at most equal to its degree in G − V � and since V ′ is a solution so is V ′′ .◻ Towards showing the reverse direction of the claim, let V � ⊆ V(G) be a solution for I ′ , i.e., |V ′ | ≤ and every vertex in G − V � has degree at most d.Because of Claim 1, we can assume that V ′ satisfies (G1) or (G2) for every s ∈ S .We claim that the set S ′ ⊆ S containing all s ∈ S such that V ′ satisfies (G2) is a solution for I .Because �V � � ≤ = ∑ s∈S max(s) + k � and V ′ contains at least max(s) vertices from every gadget G(s) for any s ∈ S , we obtain that Since the only neighbors of a vertex d j i (other than leaves, which we can assume are not contained in V ′ ) are the leaf vertices of the gadgets G(s), all these neighbors must lie in the gadgets G(s) for some s ∈ S � .Since the number of neighbors of Because the same argument applies to every i with 1 ≤ i ≤ k , we obtain that ∑ s∈S � s ≥ t and hence S ′ is a solution for I .◻ Clearly trees of height at most three are trivially acyclic.Moreover, it is easy to verify that such trees have pathwidth [33] and treedepth [40] at most three, which implies:

hard parameterized by any of the following parameters:
-the size of a feedback vertex set, -the pathwidth and treedepth of the input graph, -the size of a minimum set of vertices whose deletion results in components of pathwidth/treedepth at most three.

Solving BDD using Treecut Width
The goal of this section is to provide a fixed-parameter algorithm for Bdd parameterized by treecut width.The core of the algorithm is a dynamic programming procedure which runs on a nice treecut decomposition (T, X) of the input graph G.

Overview
First we define the data table the algorithm is going to dynamically compute for individual nodes of the treecut decomposition.For each node t ∈ V(T) , the table is going to contain two components, which we will call the universal cost u t and the specific cost s t .Informally, the universal cost captures the minimum number of vertices which need to be deleted from Y t to satisfy the degree bound in G t .The specific cost captures how many more vertices (than the universal cost) we need to delete in order to satisfy the degree bound in G t when we also place restrictions on how G t will interact with the rest of the graph.We formalize these notions below.Let us fix an instance (G, d, ) of Bdd and a treecut decomposition (T, X) of G of width at most k and rooted at r.A configuration of a graph H with a designated vertex-subset Z is a mapping Z ↦ [k] ∪ {del} , i.e., each vertex in Z receives a value up to the treecut width or "del".Intuitively, configurations are going to be used to place additional restrictions on the deletion sets we are interested in.We let (H, Z, ) denote the minimum size of a vertex set W ⊆ V(H) such that: Figure 3 depicts an illustration of (H, Z, ) .Informally, bdd captures the size of a minimum deletion set which intersects the designated subset precisely in the vertices specified by , and for the remainder of the designated subset it overshoots the degree bound by a buffer specified by .If (H, Z, ) is not defined (which may happen, e.g., if d < |Z| ), we formally set (H, Z, ) = ∞ .For each node t ∈ V(T) , we can now define: We proceed with a few observations.Naturally, the value of u t can be much larger than k (as an example, consider a collection of disjoint stars), and this is not an issue for our algorithm.Furthermore, for every it holds that 0 ≤ s � t ( ) , since u t ≤ (G t , t , ) ; notice that u t attains the value of the smallest deletion set for G t , while (G t , t , ) attains the value of a smallest deletion set for G t which satisfies certain additional restrictions.
Crucially, the value of s � t ( ) can be much larger than k, and this represents a sig- nificant obstacle for our algorithm.The role of the specific cost in the dynamic programming procedure is to capture how a node may interact with the solution and how such interactions affect the size of a deletion set.The algorithm relies heavily on having only a bounded number of possible interactions in order to achieve its run-time bounds.Luckily, we will prove that any value of s � t ( ) exceeding k must lead to a dead end and can be disregarded.Note that Lemma 5 also showcases how s ′ t relates to a solution in G, and the introduced notion of t S defined in the statement of the lemma is also useful later on.
Lemma 5 Let S be a minimum-size bounded degree deletion set in G. Let t S be defined over t as follows: Proof For brevity, let q = |N(Y t )| .The fact that q ≤ k follows immediately from the bound on the adhesion of t, hence we only need to prove that s � t ( t S ) ≤ q .So, assume for a contradiction that s � t ( t S ) > q .Let P be a witness for the value of u t , i.e., let P be a minimum-cardinality vertex subset of G t such that the maximum degree in G t − P is at most d.Observe that |P ∪ N(Y t )| = u t + q .Now consider the set S � = (S ⧵ Y t ) ∪ P ∪ N(Y t ) .First of all, note that |S ′ | < |S| , since we obtained S ′ from S by removing more than u t + q vertices (recall that, by our assumption, s � t ( t S ) > q ) and then adding back at most u t + q vertices.Second, we claim that S ′ is also a bounded degree deletion set in G. Indeed, consider for a contradiction that G − S � contains a vertex v of degree higher than d.Such a v cannot lie in Y t since P was a solution in G t and N(Y t ) separates G t from the rest of G. On the other hand, v cannot lie outside of Y t due to the fact that S itself was a solution in G[V(G) − Y t ] .So the claim holds, and S ′ contradicts the optimality of S. ◻ Thanks to Lemma 5, we can safely focus our attention on those configurations where s � t ( ) ≤ |N(Y t )| .In particular, let s t ( ) be defined as follows.
Observe that, unlike s ′ t , the number of distinct possibilities of what a specific cost s t may look like is bounded by a function of k.The high-level strategy for the algo- rithm is now the following: 1. Compute (u t , s t ) when t is a leaf, 2. Compute (u t , s t ) when t is not a leaf, but the universal and specific costs are known for all of its children, and 3. Use the values (u r , s r ) at the root node r ∈ T.
As we will see below, points 1. and 3. are straightforward.
Observation 3 (u t , s t ) can be computed in time at most 2 O(k⋅log k) if t is a leaf.
Proof Recall that |X t | ≤ k .To compute u t it suffices to exhaustively loop through all vertex subsets L ⊆ X t and check whether G t − L has degree at most d.Then u t is equal to the minimum size of such a subset.To compute s t , we proceed simi- larly: for each configuration such that each v ∈ t is mapped to del or to an integer i ≤ |N(v) ⧵ Y t | , we exhaustively loop through all L ⊆ X t ⧵  t in order to determine the value of (G t , t , ) , and we then use that value and u t to determine s t ( ) .◻ Observation 4 (G, d, ) is a YES-instance of Bdd if and only if u r ≤ .
Given the above, the last remaining obstacle is handling point 2, i.e., the dynamic propagation of information from leaves to the root.This is also the by far most challenging part of the algorithm, and we will deal with it in the next subsection.

The Dynamic Step
Recalling that u t is an integer and s t a mapping from configurations to integers, we summarize the subproblem that corresponds to handling point 2:

BDD Join
Instance: A BDD instance (G, d, ), a treecut decomposition (T, X ) of G with width at most k, a node t ∈ V (T ) and the tuples (up, sp) for each child p of t.
Our strategy for dealing with Bdd Join is to apply a 2-step approach.Figure 4 shows an illustration of the upcoming branching sets for a node t.Recall that A t and B t denote the set of all children of t which are bold and thin, respectively.First, we exhaustively loop over all options of how a deletion set candidate intersects with X t and the borders of nodes in A t , resulting in a set of "templates" which provide us with additional information about a potential solution.Here the bound on |A t | provided in Lemma 2 will be crucial.Second, we use branching and network flows to find an optimal way of extending such a template to a solution which deals with B t .In this step, we overcome the fact that there may be an unbounded number of children p in B t by "aggregating" them into types based on their s p component.Fig. 4 The three branching sets for a node t ∈ V(T) , first branch on t (green), then on the boundaries of the bold nodes A t together with the "interior" of t (orange) and finally on the equivalence classes of B t (gray) 1 3 Algorithmica (2021) 83:297-336 Lemma 5 along with our definition of specific costs then guarantees that the number of aggregated types will depend only on k.Informally, if two nodes p 1 , p 2 in B t have the same specific cost, then their behavior ("contribution") to any solution is fully interchangeable.In particular, even if p 1 , p 2 have different universal costs, both of these costs will need to be "paid" by every solution regardless of how the solution handles the borders of these nodes.We proceed by formalizing the algorithm for Bdd Join.
In other words, Q contains vertices in X t as well as the endpoints (in Y t ) of any edge which contributes to the adhesion of p ∈ A t , but not vertices in t .The idea underlying the choice of Q is that we want it to act as our branching set extending our initial choice of (which already provides us with full information on t ).See Fig. 5 for an illustration of Q.Since |A t | ≤ 2k + 1 by Lemma 2 and the adhesion of each node in A t is upper- bounded by k, we see that |Q| ≤ k + (2k + 1) ⋅ k = 2k 2 + 2k .In the first phase of the algorithm, we will exhaustively loop through all possible intersections of a deletion set with Q.For the following, let us consider one such intersection R ⊆ Q .◻ At this point, a fixed choice of R and together with the records for nodes in A t give us sufficient information to determine the size of the intersection between (1) any minimum deletion set corresponding to our choice of and R, and (2) Y p for any p ∈ A t .Our next order of business is to formally establish this claim.For the rest of the proof, we will use the term global solution as shorthand for "a minimum-cardinality vertex subset of G such that the maximum degree in the graph after its deletion is at most d".Furthermore, let , where ′ is the configuration of p which corresponds to our choices of R and .Formally, ′ is defined for each p and each w ∈ p as follows: -if w ∈ R or (w) = del then we set � (w) = del , and otherwise -if w ∈ t then we set

and otherwise
Intuitively, C t refers to the part of Y t that we can deal with thanks to having fixed R and , and (R, ) denotes the size of a global solution in C t as we prove below.

Claim 2 Let S be a global solution such that
Proof (Claim) Assume for a that |S ∩ C t | < (R, ) .This implies that there must exist a child p ∈ A t such that |S ∩ Y p | < u p + s p ( � ) , where ′ is defined as above.However, note that S ∩ Y p satisfies all the conditions stipulated by (G p , Y p , � ) , which are: In particular, this implies that , we arrive at a contradiction.On the other hand, assume that |S ∩ C t | > (R, ) .Then there must exist a child p ∈ A t such that |S ∩ Y p | > u p + s p ( � ) .By the definition of s p , we know that there exists a vertex set W ⊆ Y p of size u p + s p ( � ) which satisfies all the conditions imposed on W by (G p , Y p , � ) .Let us now consider the vertex set S ′ obtained by replacing its part in Y p with W; formally, let S � = (S ⧵ Y p ) ∪ W .By our assump- tion that |S ∩ Y p | > u p + s p ( � ) , it follows that |S ′ | < |S| .Moreover, we claim that S ′ is also a bounded degree deletion set in G. Indeed, each vertex v ∉ (Y p ∪ S) has the same neighborhood in S as in S ′ (Condition (A)).On the other hand, each vertex v ∈ (Y p ⧵ S � ) has degree at most d by the properties of W; in particular, if v has no neighbors outside of Y p then it suffices to realize that W is a solution in G p (Condi- tion (C)), and if v has neighbors outside of Y p then these are accounted for by the more restrictive degree bounds placed on vertices in p (Condition (B)).
Since S ′ is a bounded degree deletion set in G that is smaller than S, we have reached a contradiction with our assumption that S is a global solution. ◻ Since (R, ) can be readily computed for each choice of R and using the information we have for children in A t , it remains to determine how to best extend a particular choice of R and into a deletion set for B t ; in particular, we need to determine �S ∩ ⋃ b∈B t Y b � for a global solution S that corresponds to R and .Note that, unlike A t , the cardinality of B t is not bounded by a function of k, but instead we have strong restrictions on the neighborhood of each G b .

3
Algorithmica (2021) 83:297-336 Dealing with Thin Nodes Our first goal will be to show that any global solution only "expends" a total of at most k from all the specific costs of all nodes in B t .), it follows that |S ′ | < |S| .We claim that S ′ is a the initial choice of S (specifically, its optimality).

Claim 3 Let S be a global solution. Then �S
To see that S ′ is indeed a global solution, consider an arbitrary vertex v ∈ V(G) − S � .If v lies in some Y b , then v cannot have degree greater than d by our choice of P b .Otherwise, v is separated from every Y b by X t ⊆ S ′ and hence N(v) ⧵ S � ⊆ N(v) ⧵ S .So S ′ is indeed a global solution and the claim holds.◻ As an immediate consequence of Claim 3, every optimal solution S has the property that there are at most k nodes b ∈ B t such that |S ∩ Y b | > u b .However, since the cardinality of B t is not bounded by a function of k, exhaustively loop- ing through all possible k-tuples of nodes in B t to "guess" where S exceeds u b would be too expensive.Instead, we will identify a bounded number of equivalence classes of nodes in B t , and show that nodes in B t are interchangeable as far as determining where S exceeds the universal cost.
Let us define the following relation ≡ on B t .Two nodes p, q ∈ B t satisfy p ≡ q if there exists a bijective function ∶ p → q (called the renaming function) such that 1. ∀v ∈ p ∶ N(v) ∩ X t = N( (v)) ∩ X t , and 2. ∀ ∈ p → {del, 0, 1, 2} ∶ s p ( ) = s q ( ( )) , where ( ) is the mapping obtained from by renaming vertices in p according to .
Since is bijective, ≡ is clearly an equivalence relation.Let ⟨≡⟩ denote the set of equivalence classes of ≡ .We claim that �⟨≡⟩� ≤ O(k 2 ) : indeed, since the bor- ders in B t have size at most 2, there are O(k 2 ) different possibilities of select- ing neighbors of border vertices in X t , and thanks to Lemma 5 there are at most |{del, 0, 1, 2}| 2 = 16 many different options for the specific costs.Furthermore, we can determine whether p ≡ q in constant time: indeed, there are only constantly many renaming functions to consider, and checking each renaming function only requires constant time.In turn, this means that we can arrange all elements of B t into equivalence classes in time at most O(|B t | 2 ).
As explained earlier, the goal of ≡ is to partition B t into boundedly-many equivalence classes which group nodes that are fully interchangeable as far as their interactions with any global solution are concerned.We will formalize this in the next claim.It will be useful to recall the definition of p S from Lemma 5.

Claim 4
Let S be a global solution and let p, q be two nodes of B t such that p ≡ q and ( p S ) ≠ q S .Then there exists a global solution S ′ satisfying: Proof (of Claim) Let W p be a minimum-cardinality bounded degree deletion set for G p satisfying the conditions imposed by (G p , p , p S � ) , and similarly for W q on G q and q S other words, W p is a solution on G p which has the "same properties" as S ∩ Y q (since ( p S � ) = q S ), and similarly W q is a solution on G q which has the "same proper- ties" as S ∩ Y p (since The set S ′ satisfies the itemized properties by construction, and so it remains to argue that S ′ is a global solution.Since p ≡ q , it follows that Now we only need to argue that S ′ is indeed a bounded degree dele- tion set of G.It will be useful to recall that and so has degree at most d in S ′ .Now consider a vertex v ∈ N(Y q ) ; such a vertex will also have the same degree in G − S as in G − S � ; since the configurations of q and p were swapped, any change of the number of edges between v and Y q is precisely compensated by the opposite change of the number of edges between v and Y p .Next, let us consider (w.l.o.g. based on symmetry between p and q) a vertex v ∈ Y p ⧵ p : here, v must have degree at most d in G − S � because W p was a bounded degree deletion set in G p .
Finally, we consider (w.l.o.g.) v ∈ p ⧵ S � .The existence of such v means that, due to the construction of our configuration q S ′ , the vertex (v) ∈ q is not in S. Since S is a solution, (v) has degree at most d in G − S , and in particular has degree at most d − q S ( (v)) in G q − S and has We have shown that S ′ has the same cardinality as S and is also a bounded degree deletion set, meaning that S ′ is a global solution satisfying the desired properties.◻ As a consequence of Claim 3 and 4 , when looking for a global solution consistent with our choice of and R, we may exhaustively branch over: 1. how many nodes in B t have a specific cost greater than 0 ( k + 1 many options), 1 3 Algorithmica (2021) 83:297-336 2. which equivalence classes of ≡ are these nodes located in (at most k O(k) many options after considering point 4.2), 3. which configuration do these nodes have in a global solution (also at most k O(k)  many options after considering point 4.2).
Let us consider the procedure for one specific branch as above, denoted ; formally, is a tuple of the form (i, . Let B t be obtained from B t after removing i arbitrary choices of nodes from the equivalence classes specified in .Having fixed , R and , we can already determine the value of (G t , t , ) for any bounded degree deletion set consistent with and R. In particular, if such a deletion set exists then it must have size val( , R, ) = (R, ) + , where s [≡] j is the specific cost of an arbitrary node in [≡] j .
All that remains now is to determine whether there in fact exists a bounded degree deletion set in G t (a t-solution) consistent with , R and .To be precise, a t-solution S is a bounded degree deletion set in G t such that: , and S ∩ Y b satisfies the conditions of j .
Clearly, if val( , R, ) = ∞ , then the answer is no.On the other hand, if val( , R, ) ≠ ∞ , then we only need to make sure that the degree bounds are met for nodes in X = X t ⧵ (R ∪ del ) .Furthermore, for each vertex x ∈ X , we can straightfor- wardly determine the maximum number of neighbors it can accommodate from nodes in B t : this is done by subtracting from d the "buffer" required by , the num- ber of its neighbors in X, the number of its neighbors in ⋃ a∈A t Y a ⧵ R , and the num- ber of its neighbors in ⋃ b∈B t ⧵B t Y b based on the configurations in .Let us denote the maximum number of neighbors x can still accommodate from B t by c(x), i.e., c(x Before solving this final problem and moving onward to arguing the correctness of our algorithm, we will need a few final considerations.First of all, it may happen that our choice of R and means that the sought-after t-solution will leave some nodes in X t undeleted, and these nodes may prevent the use of a configura- tion achieving u b for some node b ∈ B t .To give a concrete example, consider an undeleted vertex x ∈ X t and a node b ∈ B t with b = {b 1 } and x ∈ N(b 1 ) ; it could happen that s b (b 1 ↦ 0) is the only specific cost that is equal to 0, but the presence of x means that s b (b 1 ↦ 1) would need to be used instead.Naturally, it can be checked in time |B t | whether each node in B t can still achieve a specific cost of 0; if not, then we discard our choice of and proceed to the next branch.
Next, for any node b ∈ B t such that b = {b 1 } , a t-solution could in principle either contain b 1 or not.If s b (b 1 ↦ del) ≠ 0 then the sought after t-solution must (based on our choice of ) not intersect b 1 ; this means that any such node b will reduce the value c(N(b 1 ) ∩ X t ) by 1.On the other hand, if s b (b 1 ↦ del) = 0 , then we may assume w.l.o.g. that the t-solution contains b 1 (as this comes at no addi- tional "cost"); such nodes b will not reduce the value of c(x) for any x.
Let us now consider a node b ∈ B t such that b = {b 1 , b 2 } .By the same consid- erations as above (and always while respecting the condition that the specific cost must remain 0): -if we can add both b 1 and b 2 into the t-solution, we can safely do so, and we do not change the values of c(x); -otherwise, if it is only possible to have a t-solution that intersects b 1 but not b 2 , then we will reduce the value of c(N(b 2 )) by 1; -otherwise, if it is only possible to have a t-solution that intersects b 2 but not b 1 , then we will reduce the value of c(N(b 1 )) by 1; -otherwise, if it is only possible to have a t-solution that intersects neither b 1 nor b 2 , then we need to reduce the values of c(x) accordingly (resulting in a total decrease of 2).
The last remaining case is that we can choose between a t-solution that intersects b 2 but not b 1 and a t-solution that intersects b 1 but not b 2 ; in one case, we will reduce the value of c(N 1 ) by 1, and in the other case we will reduce the value of c(N 2 ) by 1.Let be the subset of nodes in B t which have this property.Our final is to determine whether it is possible to delete one of the two border vertices in the nodes of while maintaining non-negative values of c(x).We will encode this task into a network flow instance , which we construct below.
We begin by adding a universal source and a universal sink.Next, we add one vertex for each w ∈ , and one vertex for each x ∈ X .We add an arc from each x ∈ X to the sink with the remaining capacity c(x) (after all the updates of c(x) carried out above).We add an arc from the universal source to each w ∈ of capacity 1.Finally, we add arcs from each w to its two neighbors in X, each arc of capacity 1.

Claim 5 admits a network flow of size | | if and only if there exists a t-solution consistent with , R and .
Proof (of Claim) Consider a t-solution S consistent with , R and .Let us consider the intersection between S and a node b ∈ B t .For all nodes b which do not force us to make a choice between deleting one of its border vertices or the other, either S behaves "optimally" as per our considerations above, or we can locally replace S ∩ Y b by a different t-solution for G b which intersects more vertices from the bor- der than S.After performing all such local replacements, we are left with a new t-solution S ′ .
Let us now consider a node b ∈ , and recall that | b | = 2 .Since S is consistent with , it can only intersect at most one vertex from b ; let us set z ∈ b ⧵ S .Now, let us route the flow in from b to N(z) ∩ X , and observe that this cannot exceed the Algorithmica (2021) 83:297-336 capacity bound on the edges from X to the sink because the number of neighbors of each x ∈ X to ⋃ b∈ Y b ⧵ S is upper-bounded by c(x).On the other hand, consider a flow in of size | | .From the definition of t-solu- tions consistent with , R and , it follows that we merely need to determine how S interacts with B t , i.e., its intersection with each b for b ∈ B t .For all nodes in B t ⧵ , we determine the intersection based on our considerations above.For , we use the flow in of size | | : for each b ∈ the flow must go to some x ∈ X , and so we select an arbitrary z ∈ N(x) ∩ Y b and set S ∩ b = b ⧵ {z} .This guarantees that the degree bound is never exceeded by any x ∈ X , while the existence of a bounded degree deletion set in G b of size u b that intersects b in b ⧵ {z} guaranteed by the fact that b ∈ .◻ Let us now summarize the whole algorithm.We begin by branching over all configurations of G t with the goal of computing (G t , t , ) for each choice of .Next, we construct the branching set Q and apply a second round of branching by exhaustively selecting R ⊆ Q .We then construct the equivalence classes [≡] , and apply our third (and final) round of branching by selecting .In the resulting branch, we have full information about how we want our solution to intersect all borders except for those in B t .For the remaining nodes in B t , we either determine this intersection greedily, or apply network flows.If we did not reach a conflict up to this point (e.g., by constructing an instance with a negative capacity of some edge, or by having val( , R, ) = ∞ ), then we are guaranteed the existence of a solution consistent with , R and and can set (G t , t , ) = val( , R, ) ; other- wise, we set val( , R, ) = ∞.
We conclude the proof by arguing the running time of the above algorithm.The number of choices of is upper-bounded by O(k k ) .Since |Q| ≤ O(k 2 ) , the number of choices of R is upper-bounded by 2 O(k 2 ) .For our third branching, the number of choices of can be upper-bounded by k ⋅ k 2k = k O(k) .The network flow instance can be constructed in time O(|B t |) and can be solved by the Ford-Fulker- son algorithm in time O(|B t | 2 ) .Hence we can upper-bound the total running time of the algorithm by where k and n are the treecut width and number of vertices of the input graph, respectively.
Proof We begin by applying Theorem 1 followed by Lemma 1 to obtain a nice treecut decomposition (T, X) of width at most 2k.We then use a dynamic program- ming algorithm to compute the values u t and s t at every node t ∈ V(T) .For leaves, this is carried out by Observation 3, while for non-leaves we invoke Lemma 6.
Finally, once we compute u r for the root r, we can determine the answer to a Bdd instance using Observation 4. ◻ Theorem 6 BDD parameterized by treecut width has no polynomial kernel unless ⊆ ∕poly.
Proof We will show that the well-known NP -complete Vertex CoVer problem, i.e., given a graph G and an integer k, decide whether G has a vertex cover of size at most k, AND-cross-composes into Bdd parameterized by treecut width.This then shows the theorem due to Proposition 2. Note that, by employing the polynomial equivalence relation that maps two instances (G, k) and (G � , k � ) of Vertex CoVer to the same equivalence class if |V(G)| = |V(G � )| and k = k � , we can assume that the t instances come with the same number of vertices and the same value for k.
Hence, assume that we are given t instances (G 1 , k), … , (G t , k) of Vertex CoVer, where n = |V(G i )| .Note that simply taking a disjoint union of the t instances and then asking for a vertex cover of size kt is not sufficient, since some of the instances might have a vertex cover using less than k vertices and could therefore compensate for instances whose vertex cover is larger than k.
Hence, before taking the disjoint union, we need to adapt the instances in such a way that the original instance a cover of size at most k if and only if the modified instance has a deletion set of size exactly k.
Given the instance (G i , k) of Vertex CoVer, we construct an instance (G � i , n − k, k) of Bdd as follows: -we add k + 1 apex vertices a 1 , … , a k+1 to G i and make them adjacent to every vertex in G i , -we add n − 2k − 1 leaves to every vertex in G i .
The following claim now shows that the constructed instance has the desired properties.

◻ Claim 6 (G i , k) has a vertex cover of size at most k if and only if (G �
i , n − k, k) has no deletion set of size at most k − 1 and (G � i , n − k, k) has a deletion set D of size exactly k such that G ′ i ⧵ D has maximum degree n − k.
Proof (of Claim) Towards showing the forward direction let C be a vertex cover of size at most k for G i and let A be an arbitrary set of exactly k − |C| vertices in G i ⧵ C .We claim that D = C ∪ A is the required deletion set for G ′ i , for which it suffices to show that every vertex in G ′ i ⧵ D has degree at most n − k .This clearly holds for the apex vertices a 1 , … , a k+1 , since each of these vertices has degree exactly n in G ′ i of which exactly k are in D.Moreover, since C is a vertex cover for G i , every other vertex in G ′ i is only adjacent to the n − 2k − 1 leaves and the k + 1 apex vertices and hence has degree at most n − k , as required.
Towards showing the reverse direction, let D be a deletion set of size exactly k for G ′ i .Because |D| ≤ k , there is at least one apex vertex, say a i , that is not in D. Moreo- ver, since the degree of a i in G ′ i is exactly k more than the required degree (of n − k ) and a i is only adjacent to the (original) vertices in G i , it follows that D ⊆ V(G i ) .We now claim that D is a vertex cover for G i .This is because every vertex in G i has at least n − k neighbors in G ′ i ⧵ D , i.e., the k + 1 apex vertices plus the n − 2k − 1 leaf vertices.◻ 1 3 Algorithmica (2021) 83:297-336 We now obtain the required instance (G, d, l) of Bdd by taking the disjoint union of the graphs G i and setting d = n − k and l = tk .Clearly, (G, d, l) can be constructed in time polynomial in ∑ t i=1 �x i � and moreover it satisfies Property 1 of an AND-cross-composition, because of Claim 6.Finally, the instance also satisfies Property 2, because the treecut width of G is equal to the maximum treecut width of any of the t instances, which in turn is at most n = max t i=1 |V(G i )| .◻

Core Fracture Number
In this section we introduce the new structural parameter core fracture number and provide a fixed-parameter algorithm for BDD parameterized by this parameter.An important prerequisite for the introduction of this parameter is the following simple preprocessing procedure that can be applied to any BDD instance.Given an instance I = (G, d, ) of BDD, the core of I , denoted by (I) = ( (G), d, ) , is the BDD instance obtained from I after removing all whose degree at most d from G.
Observation 7 Let I = (G, d, ) be a BDD instance.Then I and (I) are equivalent instances of BDD in the sense that any solution for I is also a solution for (I) and vice versa.Moreover, (I) can be computed in linear time w.r.t. the number of edges of G.
In the following we will assume that we have already applied the above preprocessing procedure to any BDD instance and hence the graph of the instance does not contain any edges between vertices whose degree is already below the given degree bound.-all instances in C d 1 have core fracture number at most 1 and for every n > 1 there is a graph in C d 1 with treecut width n, -all graphs in C d 2 have treecut width at most 1 and and for every n > 1 there is an instance in C d 2 with core fracture number n, Proof For the class C d 1 we make use of the class H 2 that was used in previous work on treecut width [24,Proposition 3].In particular, H 2 is the class of graphs S n obtained from a star with n leaves l 1 , … , l n by replacing each edge with n subdivided edges; Fig. 6 illustrates the graph S 3 .Following the arguments used in previous work [24,Proposition 3], we can verify that (S n ) ≥ n : suppose for a contradiction that (S n ) ≤ n − 1 .Then any two leaves z i and z j , i ≠ j , must be contained in the same bag in any tree-cut decomposition of width at most n − 1 as they are connected by n edge-disjoint paths.This means there exists a bag t containing all z i 's in any such tree-cut decomposition, which however implies that (t) ≥ n.Towards defining the class C d 1 of BDD instances, we need to ensure that graphs do not change after the core operation is applied.We do so by introducing the graphs S d n , which are obtained from S n after attaching d − 1 novel leaf vertices to l i .Then C Because the treecut width of any tree is at most one (simple take the tree itself as the treecut decomposition), we have that (I) ≤ 1 for every Towards showing that the core fracture number of the instances in C d 2 is unbounded, assume for a contradiction that this is not the case, i.e., there is k ∈ ℕ such that (I) ≤ k for every Then any vertex set D ⊆ V(G) witnessing (I) must contain at least one vertex from every subpath of P (k+1) 2 of length k + 1 .Since P (k+1) 2 contains k + 1 such subpaths, which are pairwise disjoint, this is not possible if |D| ≤ k .Hence (I) > k , a contradiction to our ini- tial assumption.◻ For completeness, we note that the treedepth (and hence also treewidth) of the core is always upper-bounded by a function of the core fracture number.Indeed, observe that deleting k vertices from a graph with core fracture number k leads to a graph where every connected component has at most k vertices; from this and the definition of treedepth [40], it is easy to show that the graph has treedepth at most 2k + 1 .On the other hand, the core fracture number is upper bounded by the vertex cover number (i.e., the size of a minimum vertex cover).Hence our tractability results for core fracture number also imply analogous results for the vertex cover number.
We are now ready to present our fixed-parameter algorithm for BDD parameterized by the core fracture number.The algorithm consists of two steps: (1) it computes a deletion set D of size at most k, witnessing that (I) ≤ k and (2) it solves I with the help of the deletion set D. Namely, our algorithm will consists of fixed-parameter algorithms for the following two parameterized problems.Proof Let I = (G, d, , k) be any instance of CFND and let M be the set of all ver- tices in G that have degree larger than d.We will show the lemma by providing a depth-bounded search tree algorithm, which is based on the following observations.O1 If G is not connected then a solution for I can be obtained as the disjoint union of every component of G. starts at any vertex in M and stops as soon as k + 1 vertices of M have been visited.Then |C| ≤ 2(k + 1) − 1 because at most every second vertex that is visited by the depth-first search can be a vertex in V(G) ⧵ M ; this is because G − M is an independent set (recall that we assume (G) = G and hence G contains no edges between vertices of degree at most d).The algorithm then branches on the vertices in C, i.e., for every v ∈ C the algorithm recursively computes a solution for the instance (G − {v}, d, , k − 1) .It then returns the solution of minimum size returned by any of those recursive calls, or no-if none of those calls returns a solution.This completes the description of the algorithm.The correctness of the algorithm follows immediately from the above observations.Moreover the running time of the algorithm is easily seen to be dominated by the maximum time required for the case that at each step of the algorithm G is connected.
In this case the running time can be obtained as the product of the number of branching steps times the time spent on each of those.Because at each recursive call the parameter k is decreased by at least one and the number of branching choices is at most 2(k + 1) − 1 , we obtain that there are at most (2(k + 1) − 1) k = (2k + 1) k branching steps.Furthermore, the time at each branching step is dominated by the time required to check whether G is connected, which is linear in the number of edges of G. Putting everything together, we obtain O((2k + 1) k |E(G)|) as the total time required by the algorithm, which completes the proof of the lemma.◻ We note that the depth-first search algorithm in the above proof can be easily transformed into a polynomial time approximation algorithm for CFND that exhibits an approximation ratio of 2k + 1 .In particular, instead of branching on the vertices of a connected subgraph C of G with at most 2k + 1 vertices, this algorithm would simply add all the vertices of C into the current solution.This way we obtain: o is an integer with 0 ≤ o < 2k , and Informally, for every subset D ′ of vertices that we decide to delete from D, the signature tells us how many vertices in C we need to delete and how their deletion affects the degrees of the remaining vertices in D − D � .Because we only need to consider solutions containing less than 2k vertices from C (Lemma 7), the number of ways in which different solutions effect the degrees of vertices in D is bounded (in terms of k), which allows us to compute the signatures.

Lemma 8 The signature S(C) can be computed in time O(|V(C)|
Proof Let I = (G, d, , D) be the given instance of CFNE, let C be any component of G − D , and let M be the set of all vertices in C that have degree more than d in G.Note that |M| ≤ k and because G = (G) also C − M is an independent set.The main idea behind the algorithm to compute S(C) is that even though there can be many vertices in V(C) ⧵ M the vertices can only behave in a limited number of ways towards the vertices of high degree, i.e., the vertices in D ∪ M .Namely, let D ′ be an arbitrary subset of D. Then we say that two vertices v, v � ∈ V(C) ⧵ M have the same type if both have the same neighborhood in M ∪ (D ⧵ D � ) .Let NT be the set of types of vertices in V(C) ⧵ M and for a type t ∈ NT we denote by #(t) the number of verti- ces in C having type t.Because |D ∪ M| ≤ 2k , it holds that |NT| ≤ 2 2k .For a vertex v ∈ D ⧵ D � let NT(v) be the set of all types having v as a neighbor.Observe that if two vertices u and v have the same type then the effect of removing u is the same as the effect of removing v, i.e., the resulting graphs will be isomorphic.Hence for the computation of S(C) it is not necessary to distinguish between vertices of the same type.Namely, there is a pair (o, ) satisfying (S1) and (S2) if and only if there is a subset M ′ ⊆ M together with a mapping ∶ NT → {0, … , 2k − 1} such that: (S0') (t) ≤ #(t) for every t ∈ NT and �M Hence for a given D ′ we can compute by enumerating all pairs (M � , ) and for each pair testing whether it satisfies (S0')-(S2').If it does then we add the pair The total running time of the algorithm is obtained as follows.To compute NT and #(t) for every t ∈ NT it is sufficient to make one pass through the vertices in V(C) ⧵ M ; since one also needs to store the values the total running time of this step is at most O(|V(C)| + |E(C)| + 2 2k ) .Moreover, the time needed to enumerate all pairs (M � , ) and verify that the pair satisfies Conditions (S0')-(S2'), is domi- nated by the number of these pairs, i.e., O(2 k (2k) 2 2k ) .The same holds for calculating the pair (o, ) from (M � , ) in the case that all conditions were met.Hence the total running time of the algorithm is  (C, (o, )) components C ∈ C .Condition (C2) ensures that there are enough compo- nents in C and moreover that this way we use every component exactly once.Finally, we add D ′ to V ′ .Because of Condition (C1), we have that |V ′ | ≤ .Moreover, because of Condition (C3), we obtain that every vertex in D ⧵ D ′ has degree at most d in G − V � .The same holds for every vertex in any component C of G − D , because of Property (S1).Hence V ′ is a solution for I of size at most .◻ With the help of the above lemma, we can express the existence of a solution in terms of the solution of an integer linear program with a bounded number of variables, which in turn can be solved in fpt-time w.r.t. the number of variables (Proposition 3).It is known that Set Cover does not admit a polynomial kernel under standard complexity assumptions, notably, unless ⊆ ∕poly [12].Given an instance I = (U, F, k) of Set Cover, we construct an instance I � = (G, d, , D) of CFNE as follows.G has one vertex v u for every u ∈ U as well as one vertex w F for every F ∈ F .Moreover, G has an edge between a vertex v u and a vertex w F if and only if u ∈ F .We set D = { v u | u ∈ U } .Let be the maximum degree of any vertex in G. Then we attach to every vertex in D new leaf vertices such that the degree of every vertex in D becomes + 1 .This completes the construction of G. Towards showing the forward direction let F ′ ⊆ F be a solution for I .Then it is straightforward to verify that { w F | F ∈ F � } is a solution for I ′ .
Towards establishing the reverse direction let V � ⊆ V(G) be a solution for I ′ .We first show that w.l.o.g.we can assume that V � ⊆ { w F | F ∈ F } .Suppose not then V ′ either contains a in D or a leaf attached to a vertex in D. V ′ contains a leaf, then we can replace the leaf with the vertex in D that it is attached to.Hence it only remains to deal with the case that V ′ contains a vertex in D. In this case we can replace the vertex say v u in D with any vertex w F such that u ∈ F and F ∈ F .Note that such a vertex w F exists since otherwise I is a no-instance.This works because all vertices in { w F | F ∈ F } already have degree at most d in G and moreover v has degree at most d + 1 in G. Thus let be a solution for Then it is straightforward to verify that { F | w F ∈ V � } is a solution for I .◻

Concluding Notes
Our results close a wide gap in the understanding of the complexity landscape of BDD parameterized by structural parameters.In particular, they not only resolve an open question from previous work in the area [6], but push the lower bounds cantly further, specifically to deletion distance to trees of bounded depth.Moreover, we identified structural parameterizations which are better suited for the problem at hand and used these to obtain two novel fixed-parameter algorithms for BDD.
In particular, it is interesting that treecut width is the only known decompositional parameter that allows for an fixed-parameter algorithm.Moreover, the core fracture number is a natural and quite significant generalization of the vertex cover number.For future work it would be interesting to empirically evaluate how large the considered parameters are on practical instances, and whether the ideas used in our exact algorithms can be used to improve heuristic approaches commonly used to solve the problem.suppressing z a ′ , contradicting our assumption about the sequence of suppressions.The same argument applies to a ′′ .It follows that a � , a �� ∈ A �� t ∪ {top} .Furthermore, as a suppressing of a vertex removes it from the considered graph, either a ′ or a ′′ belongs to A ′′ t .Since we pick b ′ as the first b ∈ A �� t such that the degree z b strictly decreases, it cannot be a � ∈ A �� t .Hence, we have a � = top and a �� ∈ A �� t .By a similar argument, we know that a �� = b � .
Notice that the suppressing of z a ′ , namely z top , decreases the degree of z b ′ by one.That is, the degree of z b ′ in H (i+1)     remains at least two.Now that the suppressing of z b ′ in H (j) t strictly decreases the degree of z b ′′ , the degree of z b ′ in H (j) equals to one.This implies that there is a suppressing of a vertex, say z a * , which further decreases the degree of z b ′ between the sequence of H (i+1) t and H (j) t .However, then a * ∈ A �� t , which contradicts our choice of b ′′ and H

Fig. 1 A 3
Fig.1A graph G and a width-3 treecut decomposition of G, including the torso-size (left value) and adhesion (right value) of each node

in polynomial time with k � = 2 k 2 +
k and all integers in I are bounded by a polynomial in |V(G)| such that G has a k-clique if and only if I has a solution.

Fig. 2
Fig. 2 Example of the gadget in Theorem 2

Fig. 3 3
Fig. 3 Illustration of the set (H, Z, ) .The dotted edges are not considered for the degree of a node v

Fig. 5
Fig. 5 Illustration of the set Q.The orange parts are exactly the sets Q consists of (Color figure online) For each b ∈ B t , let P b be a solution realizing u b , i.e., let P b be a vertex subset of G b such that |P b | = u b and G b − P b has maximum degree at most d.Now consider the set obtained from S by replacing its intersection with B t with the union of all the sets P b and by adding

Theorem 8
The core fracture number of a BDD instance I = (G, d, ) , denoted by (I) , is the minimum integer k such that there is a deletion set D ⊆ V(G) with |D| ≤ k and the number of vertices in any component C of G ⧵ D of degree larger than d in G is at most k.In other words, each connected component of G − D may contain only at most k vertices of degree greater than d.We start by showing that this parameter is orthogonal to treecut width.For every d ∈ ℕ , there are classes C d 1 and C d 2 of BDD instances I = (G, d, ) with (I) = I such that:

CoreTheorem 9
Fracture Number Detection (CFND) Input: A n instance I = (G, d, ) of BDD and an integer k.Parameter: k Question: Decide whether cfn(I) ≤ k and if so output a deletion set D ⊆ V (G) witnessing this.Core Fracture Number Evaluation (CFNE) Input: A n instance I = (G, d, ) of BDD and a deletion set D witnessing cfn(G) ≤ |D|.Parameter: |D| Question: Decide whether has a solution and if so output a solution for I. CFND can be solved in time O((2k + 1) k |E(G)|) and is hence fixed- parameter tractable.
is connected and |C ∩ M| > k , then any solution for I has to contain at least one vertex from C.These observations lead directly to the following recursive algorithm that given the instance I either determines that the instance is a no-instance or outputs a solution D ⊆ V(G) of minimum size for I .The algorithm first checks whether G is connected.If G is not connected the algorithm calls itself recursively on the instance (C, d, , k) for each component C of G.If one of the recursive calls returns no or if the size of the union of the solutions returned for each component exceeds k, the algorithm returns that I is a no-instance.Otherwise the algorithm returns the union of the solutions returned for each component of G.If G is connected and |V(G) ∩ M| ≤ k , the algorithm returns the empty set as a solution.Otherwise, i.e., if G is connected but |V(G) ∩ M| > k the algorithm first computes a set C of at most 2(k + 1) − 1 vertices of G such that G[C] is con- nected and |C ∩ M| > k This can for instance be achieved by a depth-first search

Theorem 10 Lemma 7 3
CFND can be approximated in polynomial time within a factor of 2k + 1.Let I = (G, d, , D) be an instance of CFNE and assume w.l.o.g. that (G) = G and k = |D| .We start by showing that we do not need to consider solutionsV � ⊆ V(G) for I that contain more than 2k − 1 vertices from any component C of G − D. If I has a solution, then it has a solution V ′ such that |V � ∩ V(C)| < 2k for every component C of G − D.1 Algorithmica (2021) 83:297-336Proof Let V ′ be a solution for I and C be a component of G − D with |V � ∩ V(C)| ≥ 2k ; if no such component exists, then we are done.Let M be the set of all vertices in C, whose degree is larger thand in G. Then (V � ⧵ V(C)) ∪ M ∪ D is also a solution for I and moreover |(V � ⧵ V(C)) ∪ M ∪ D| ≤ |V � | − + k + k ≤ |V � | .By iterating the same process for every component C with |V ∩ V(C)| ≥ 2k , one obtains the desired solution for I .◻ Let C be a component of G − D and let M ⊆ V(C) be the set of all vertices with degree larger than d in G. Then the signature of C, denoted by S(C) , contains all pairs (D � , ) such that: -D ′ ⊆ D, -is the set of all pairs (o, ) such that:

Lemma 9
and let C and C ′ be two distinct components of G − D .We say that C and C ′ are equivalent w.r.t.D ′ if (D � , ) ∈ S(C) ∩ S(C � ) for some .Let P(D � ) be the partition of all components of G − D into equivalence classes and for an equiva- lence class C ∈ P(D � ) let (C) denote the set such that (D � , ) ∈ S(C) for every C ∈ C .Note that |P(D � )| ≤ 2 2k(2k) k .An instance I = (G, d, , D) has a solution if and only if there is a subset D ′ of D and a mapping that assigns to every C ∈ P(D � ) and every (o, ) ∈ (C) a natural number satisfying the following conditions:

3
, )) = �C� for every C ∈ P(D � ) , i.e., all components are con- sidered, (C3) ∑ C∈P(D � )∧(o, )∈ (C) (v) ⋅ (C, (o, ) ≥ �N G−D � (v)� − d for every v ∈ D ⧵ D � , i.e., the degree conditions for the vertices in D ⧵ D ′ are satisfied.Informally, for C ∈ P(D � ) and every (o, ) ∈ (C) , gives the number of compo- nents in C that use the configuration (o, ).Proof Towards showing the forward direction let V ′ be a solution for I .We start by setting D � = D ∩ V � .Consider a component C of G − D and let be the set such that (D � , ) ∈ S(C) .Because of Lemma 7, we can assume that |V � ∩ V(C)| < 2k . 1 Algorithmica (2021) 83:297-336 Hence contains a pair (|V � ∩ V(C)|, ) , which we denote by A(C), such that for every v ∈ D ⧵ D � , it holds that v has exactly (v) neighbors in V � ∩ V(C) .For every C ∈ P(D � ) and (o, ) ∈ (C) , we now set (C, (o, )) to be the number of compo- nents C in C with A(C) = (o, ) and claim that satisfies the conditions (C1)- (C3).Because ( ∑ C∈P(D � )∧(o, )∈ (C) o ⋅ (C, (o, ))) + �D � � = �V � � and |V | ≤ , we obtain that satisfies (C1).Condition (C2) follows immediately from the definition of .Finally, (C3) follows because for every v ∈ D ⧵ D � it holds that ∑ C∈P(D � )∧(o, )∈ (C) (v) ⋅ (C, (o, )) is equal to the number of neighbors of v in V ′ ⧵ D and the fact that v can have at most d neighbors in G − V � .Towards showing the reverse direction let D ′ ⊆ D and be a mapping satisfy- ing (C1)-(C3).For a component C ∈ C and (o, ) ∈ , where C ∈ P(D � ) and (D � , ) ∈ S(C) , we denote by V(C, (o, )) a subset of V(C) of size o satisfying the conditions (S1) and (S2) in the definition of a signature.a solution V ′ for I is obtained as follows.For any C ∈ P(D � ) we take the union of V(C, (o, )) for exactly

Theorem 11
CFNE is fixed-parameter tractable.Proof Let I = (G, d, , D) be the given instance of CFNE.The algorithm first com- putes the signature S(C) for every component C of G − D according toLemma 8.It then uses the characterization given in Lemma 9 to decide whether I has a solu- tion.Namely, for every D ′ ⊆ D the algorithm constructs an ILP instance I ′ whose optimum is at most − |D � | if and only if the BDD instance I has a solution V ′ with V � ∩ D = D � .In accordance with Lemma 9 the ILP instance I ′ has one variable, denote by x C,(o, ) , for every C ∈ P(D � ) and (o, ) ∈ (C) and consists of the following constraints:Observe that there is a one-to-one correspondence between assignments for the variables in I ′ and the assignment defined in Lemma 9.Moreover, the constraints of I ′ ensure Condition (C2) and (C3) and Condition (C1) can be satisfied if and onlyminimize ∑ C∈P(D � ),(o, )∈Γ(C) o ⋅ x C,(o, ) subject to ∑ (o, )∈Γ(C) x C,(o, ) = �C� ∀C ∈ P(D � ) ∑ C∈P(D � )∧(o, )∈Γ(C) (v) ⋅ x C,(o, ) ≥ �N G−D � (v)� − d ∀v ∈ D⧵D � if the optimum value of I ′ is at most − |D � | .This completes the description of the algorithm and the running time of the algorithm is obtained as follows.Apart from constructing the ILP instance, the main task of the algorithm are to compute the signature for every component C of G − D and to compute P(D � ) for every D ′ ⊆ D .The first task can be achieved in time O(|E(G)| + |V(G)|2 k (2k) 2 2k ) due to Lemma 8.The second task can be achieved by going over all of the at most |V(G)| 2 pairs of components G − D and checking for each such pair whether the are the same.Hence the total time required for the second step is at most O(2 k |V(G)| 2 k(2k) k ) .Finally, constructing and solving the ILP instance I ′ for every D ′ ⊆ D is dominated by the time required to solve I ′ , which because of Proposition 3 takes time at most O(p 2.5p+o(p) ⋅ L) , where p is the number of variables and L is the size of I ′ in bits.Now the number of variables p of I ′ is at most |P(D � )| max , where max = max C∈P(D � ) | (C)| .Moreover, the size of I ′ in bits is dominated by the size of the last row in I ′ , which is at most O((log(k)|P(D � )| max ) + log(|V(G)|)k) .Since |P(D � )| ≤ 2 k(2k) k and max ≤ k(2k) k , we obtain that p ∈ O(2 k(2k) k k(2k) k ) and L ∈ O((log(k)2 k(2k) k k(2k) k ) + log(|V(G)|)k) ,which shows that constructing and solving I ′ is fixed-parameter tractable parameter- ized by k.Taking everything together, we obtainO(2 k (|V(G)| 2 k(2k) k + p 2.5p+o(p) L) , where p ∈ O(2 k(2k) k k(2k) k ) and L ∈ O((log(k)2 k(2k) k k(2k) k ) + log(|V(G)|)k) ,as the total running time of the algorithm.◻ As our final result, we show a kernel lower bound for CFNE.Theorem 12 CFNE has no polynomial kernel unless ⊆ ∕poly.Proof We give a polynomial parameter transformation from the well-known Set CoVer parameterized by the size of the universe.The result then follows from Proposition 1. Set Cover Input: Auniverse U , a family F of subsets of U , k ∈ N. Parameter: |U |.Task: Find a subfamily F ⊆ F such that |F | = k and F covers U , i.e., F ∈F F = U .

3
Finally, we set d = and = k .Because G − D is an independent 1 Algorithmica (2021) 83:297-336 set, it shows that (G) ≤ |U| = |D| .It remains to show that I has a solution if and only if so does I ′ .
where |B t | is upper-bounded by the number of children of t.Proof For technical reasons, we will show how to compute the value (G t , t , ) for each configuration ; clearly, this is sufficient to determine (u t , s t ) , as u t is the minimum of (G t , t , ) over all choices of .For our presentation, let us now consider an arbitrary fixed choice of .Dealing with Bold Nodes Let Towards the definition of the class C d 2 , let P d n be the path on n vertices after attaching d novel leaf vertices to every vertex in the path.Then C d 2 is the class of all BDD instance (P d n , d, ) for any n, ∈ ℕ .Note that (I) = I for every I ∈ C d 2 .