Building large k-cores from sparse graphs

A popular model to measure network stability is the $k$-core, that is the maximal induced subgraph in which every vertex has degree at least $k$. For example, $k$-cores are commonly used to model the unraveling phenomena in social networks. In this model, users having less than $k$ connections within the network leave it, so the remaining users form exactly the $k$-core. In this paper we study the question whether it is possible to make the network more robust by spending only a limited amount of resources on new connections. A mathematical model for the $k$-core construction problem is the following Edge $k$-Core optimization problem. We are given a graph $G$ and integers $k$, $b$ and $p$. The task is to ensure that the $k$-core of $G$ has at least $p$ vertices by adding at most $b$ edges. The previous studies on Edge $k$-Core demonstrate that the problem is computationally challenging. In particular, it is NP-hard when $k=3$, W[1]-hard being parameterized by $k+b+p$ (Chitnis and Talmon, 2018), and APX-hard (Zhou et al, 2019). Nevertheless, we show that there are efficient algorithms with provable guarantee when the $k$-core has to be constructed from a sparse graph with some additional structural properties. Our results are 1) When the input graph is a forest, Edge $k$-Core is solvable in polynomial time; 2) Edge $k$-Core is fixed-parameter tractable (FPT) being parameterized by the minimum size of a vertex cover in the input graph. On the other hand, with such parameterization, the problem does not admit a polynomial kernel subject to a widely-believed assumption from complexity theory; 3) Edge $k$-Core is FPT parameterized by $\mathrm{tw}+k$. This improves upon the result of Chitnis and Talmon by not requiring $b$ to be small. Each of our algorithms is built upon a new graph-theoretical result interesting in its own.


Introduction
The k-core in an undirected graph G is the maximal induced subgraph of G in which all vertices have degree at least k. This concept has been applied in various areas including social networks [5,10,11], protein function prediction [30], hierarchical structure analysis [3], graph visualization [2], and network clustering and connectivity [1,19].
In online social networks users tend to contribute content only when a certain amount of their friends do the same [6], or in other words, when the formed community is a k-core for some threshold parameter k. Interestingly, losing even a small amount of users or links can bring to the cascade of iterated withdrawals. A classical example of such phenomena is the example of Schelling from [28]: Consider a cycle on n vertices, which is a 2-core with n vertices. Missing just one edge from this graph turns it into in a path and triggers the withdrawals that results in dismounting of the whole network. On the other hand, adding a small number of extra links can create a large k-core and thus prevent users from withdrawal. We consider the following mathematical model for this problem. For a given a network, the assumption is that a user leaves the network when less than k his/her friends remain within it. We would like to prevent unraveling of the network, so that at least p users remain engaged in it. To achieve this, we are given a budget to establish at most b new connections between the users of the network. More precisely, the problem is stated as follows.

Input:
A simple undirected graph G and integers b, k, and p. Task: Decide whether there exists B ⊆ V (G) 2 \ E(G) of size at most b such that the k-core of the graph (V (G), E(G) ∪ B) is of size at least p.

Edge k-Core
The Edge k-Core problem was introduced by Chitnis and Talmon in [9] as a model of preventing unraveling in networks. For instance, in a P2P network, any user benefiting from the network should be linked to at least k other users exchanging resources. In this scenario the Edge k-Core model could be used to find extra connections between users to provide a better service for larger number of users [9,33]. Other potential application of Edge k-Core in real-life networks include friend recommendation in social networks, connection construction in telecom networks, etc. We find the Edge k-Core problem to be interesting from the theoretical perspective too: it has strong links to the well-studied family of problems, where one seeks a modification of a graph satisfying certain conditions on vertex degrees, see [12] for further references. Our interest in the study of the problem is of a theoretical nature.
The k-core in a graph can be found by a simple "shaving" procedure: If a graph contains a vertex of degree less than k, then this vertex cannot be in its k-core and thus can be safely removed. Apparently, solving Edge k-Core is more challenging. In particular, Chitnis and Talmon in [9] proved that Edge k-Core is NP-complete even for k = 3 and when the input graph G is 2-degenerate. 1 Moreover, the problem is W[1]-hard being parameterized by k + b + p. On the other hand, they show that if the treewidth of the graph G is tw, then the problem is solvable in time (k + tw) O(tw+b) · n O(1) and hence is fixed-parameter tractable (FPT) parameterized by k + tw + b. These results of Chitnis and Talmon are the departure point for our study.
Our results. We study the algorithmic complexity of Edge k-Core on three families of sparse graphs: forests, graphs with bounded vertex cover number and graphs of bounded treewidth. Each of our algorithms is based on one of the common algorithmic paradigms: dynamic programming for forests and treewidth, and ILP for vertex cover. The interesting part here is that in each of the cases, the successful application of an algorithmic paradigm crucially depends on a new combinatorial result. We show the following.

35:3
Growing from forest. We prove (Theorem 5) that Edge k-Core is solvable in time O(k · |V (G)| 2 ), when the input graph G is a forest. The algorithm is based on a dynamic programming over subtrees. The crucial part of the work is to make this algorithm run in polynomial time. For that we need a new graph-theoretical result, Theorem 4. The theorem states that for any integer k, a forest F on at least k + 1 vertices can be completed into a graph of minimum degree k by adding at most edges. Moreover, this bound is tight, any forest requires such amount of edge additions to grow into a k-core. The proof of Theorem 4 is non-trivial and exploits an interesting connection between the cores in a graph and sufficient conditions on the existence of a large matching in a graph. Here the recent combinatorial theorem of Henning and Yeo [23] on matchings in graphs of bounded degrees becomes handy.
Bounded vertex cover. We prove that the problem is FPT parameterized by the minimum size of a vertex cover in a graph. More precisely, in Theorem 14, we give an algorithm of running time 2 O(vc ·3 vc ) · n O(1) , where vc is the vertex cover number of the input graph. Let us note that every graph is vc-degenerate. We solve the problem by reducing it to an integer linear program (ILP), whose number of variables is bounded by some function of vc. This allows to apply Lenstra's algorithm [25], see also [24,18], to solve Edge k-Core. Nowadays ILP is a commonly used tool for designing parameterized algorithms, see e.g. [13,Chapter 6]. However, just like in the case of forests, the application of an algorithmic paradigm is not direct. In order to encode the problem as ILP with the required number of variables, we need a new combinatorial result (Lemma 13) about degree sequences of a graph. One of the components in the proof of Lemma 13 is the classical Erdős-Gallai theorem [16] about graphic sequences. We complement FPT algorithm by lower bounds on the size of the kernel.
Bounded treewidth. Chitnis and Talmon in [9] have shown that Edge k-Core is FPT parameterized by tw + k + b, where tw is the treewidth of the input graph. Even in the case when the treewidth and k are constants, this does not mean that the problem is solvable in polynomial time. We enhance this result by proving that Edge k-Core is FPT parameterized by tw + k. As the algorithm of Chitnis and Talmon in [9], our algorithm is a dynamic programming on graphs of bounded treewidth, but again, in order to make it work, we need a new combinatorial result (Theorem 20). When the budget b is small (of order k 3 ), the algorithm of Chitnis and Talmon suffices. When the budget b is large, we are able to approach the problem in an interesting new way. Here Theorem 20 provides us with a criteria how a subset of vertices can be turned into a k-core "optimally". This key insight allows us to show that the problem is FPT parameterized by tw + k.
Related work. The usability of k-cores in the study of network unraveling phenomena was popularized by the influential paper of Bhawalkar et al. [4] who suggested the model of forcing a limited number of users of a network to stay in order to maximize the size of the k-core. The same problem was further studied in [7], where new computational results were obtained and some results of [5] were strengthened. Also, Chitnis, Fomin and Golovach studied this problem applied to networks where the underlying graph is directed [8]. Heuristic algorithms for this problem are discussed in [31].

35:4 Building Large k-Cores from Sparse Graphs
Edge k-Core was introduced in [9], where also a number of complexity and algorithmic results about the problem were established. Zhou et al. [33] provide some non-approximability results for Edge k-Core as well as some heuristics. The work [32] is devoted to the "dual" problem of disengaging a limited number of users from a network in order to minimize its k-core size. Another work in this context is the work of Luo, Molter and Suchy [26].
More generally, Edge k-Core fits into a large class of edge modification problems, where one is seeking for an optimum modification to some desired graph property [12]. In particular, a significant part of literature in parameterized complexity is devoted to related problems of graph modification to graphs with some vertex degree properties like being regular, Euler, or to some degree sequence [17,21,20,22,27].

Preliminaries
All graphs considered in this paper are simple undirected graphs. We use standard graph notation and terminology, following the book of Diestel [14]. We write G + F to denote the simple graph obtained by adding the edges from F ⊆ V (G) 2 \ E(G) to a graph G. If not specified otherwise, we use n to denote the number of vertices of the graph G in an input instance of Edge k-Core.
Throughout this paper, we use the following terms. In the following definitions, we assume that k is fixed.

Definition 1 (Deficiency). For a graph G, and its vertex
Note that an addition of an edge between two vertices of G can decrease df(G) by at most two. It also does not make any sense to add edges that do not decrease deficiency if we aim to complete G to a graph of minimum degree k. We distinguish added edges by whether they decrease deficiency by two or one.

Definition 2 (Good/bad edges). For nonadjacent vertices
Thus adding a good edge decreases the total deficiency by 2 and adding a bad one by 1.
Note that whenever there is a vertex set H of size at least p which induces a k-core in G, the k-core of G has also size at least p, since it is the unique maximal induced subgraph of G which is a k-core. We often use this simple observation throughout the paper whenever we show that the k-core is large by presenting a large vertex set which induces a k-core.
Due to the space restrictions, some of the proofs in this paper are omitted. The results with omitted proofs are marked with the ' ' sign. Missing proofs can be found in the full version of this paper.

Growing from forest
In this section we present our polynomial time algorithm for Edge k-Core on forests and the underlying graph-theoretical result.
The algorithm itself is a dynamic programming over subtrees. Normally, an algorithm like this would go from leaves to larger and larger subtrees, storing for every subtree a list of possible configurations a solution could induce on this subtree. In the Edge k-Core problem, naturally we want to store information about edges added inside the subtree and vertices from the subtree which we may later connect to something outside.
Naively, this would take exponential space, as it seems we have to store at least the degrees of the selected vertices in the subtree. However, the following theorem, which is the central technical result of this section, helps greatly.

Theorem 4.
For any integer k, any forest T on at least k + 1 vertices can be completed to a graph of minimum degree k by adding at most

edges, and this cannot be done with less edge additions. Moreover, in the case k ≥ 4, it can be done in a way that the added edges form a connected graph on the vertices they cover.
For our algorithm, Theorem 4 means that whenever we fix the subset of vertices H, we have to add exactly df(T [H])/2 edges in order to induce a k-core on H. Thus it is enough to find a subset of vertices H of size at least p with the smallest possible df(T [H]). This objective turns out to be simple enough for the bottom-top dynamic programming. Namely, for a subtree T v rooted at v, it is enough to store the size of H ∩ T v , the total deficiency of these vertices, whether v is in H and how many neighbors in H ∩ T v it has. Since v separates T v from the rest of the tree, the deficiency of other vertices in H ∩ T v is unchanged no matter how H looks like in the rest of the tree.
The discussion above ultimately leads to a polynomial time algorithm, stated formally in the next theorem. The algorithm follows a fairly standard technique, so the detailed description of the algorithm and the proof of its correctness are omitted from this extended abstract. Instead for the remaining part of this section we focus on the proof of Theorem 4.
Proof of Theorem 4. The theorem says that completion of T to a graph of total deficiency 0 can be done using 1 2 df(T ) edge additions. Note that this bound is tight because a single edge addition decreases the total deficiency by at most two. When df(T ) is even, we have to prove that it is possible to complete T by adding only good edges. When df(T ) is odd, we have to complete T to a graph of total deficiency 1 adding 1 2 df(T ) good edges and then add one bad edge. Fixing deficiency 1 with one bad edge is always possible, since the only deficient vertex u has degree k − 1 and so must have a non-neighbor. In the case k ≥ 4 this can be also done in a way that connects u to the already added good edges. Thus, from now on, it suffices to prove that we can add 1 2 df(T ) good edges, in a connected way for k ≥ 4. For k = 1, vertices with non-zero deficiency are exactly the isolated vertices of T . In this case pairing isolated vertices arbitrarily provides the required 1 2 df(T ) good edges. For k ≥ 2, it is sufficient to prove the theorem statement for the case when T is connected, i.e. T is a tree. If T is a forest consisting of at least two trees, one may reduce the number of trees in T . This can be done by picking two leaf vertices of distinct connected components in T and adding an edge between them. Clearly, such an edge addition is good since any leaf vertex has non-zero deficiency, and it reduces the number of connected components in T .

35:6
Building Large k-Cores from Sparse Graphs Moreover, for k = 2, vertices with non-zero deficiency are exactly the leaves of T . Since T is a tree with at least three vertices, an edge connecting any two leaves can be added. Thus, as in the case k = 1, pairing the leaves arbitrarily suffices. Now, for every integer k ≥ 3, we prove Theorem 4 by induction on the number of vertices in the tree. The fact that the graph on the added edges must be connected in the case k ≥ 4 will be useful for the induction.
Base case. Let T be a tree on n = k + 1 vertices. The only way to complete T to a graph of minimum degree k is to turn it into a complete graph, i.e. add every possible missing edge between vertices in V (T ). Clearly, each edge addition in such completion is good, thus the completion requires exactly 1 2 df(T ) edge additions. Suppose there are two connected components formed by the added edges. Then T must contain all edges between these components, so it also contains a cycle, since each of the components has at least two vertices. Thus the connectivity condition must be satisfied.
Inductive step. Suppose that Theorem 4 holds for all trees on n vertices, and let T be a tree on n + 1 vertices. We prove that Theorem 4 holds for T . Let v be a leaf of T and let T = T − v be the tree obtained by deleting v from T . By the induction hypothesis, T can be completed to a graph of total deficiency (df(T ) mod 2) using 1 2 df(T ) edge additions. Let A be the graph on the deficient vertices of T formed by the good edges added during the completion.
Our ultimate goal is to transform A in such a way that it accounts for the new vertex v as well. We shall do this by first removing edges from A , and then adding good edges between vertices which are not yet adjacent. In the case k ≥ 4, we must also end up with a connected graph on the added edges.
Briefly explained, our technique of adding and removing edges is as follows. Take an edge st ∈ E(A ), such that 1) s = v, t = v and 2) sv and tv are not yet in the graph. Delete the edge st, and add both edges sv and tv. This operation preserves deficiencies of both s and t, while it decreases the deficiency of v by two. Note that s and t also remain connected through v. We can do the same with a matching instead of a single edge, thus we need a matching of size roughly k/2 to nullify the deficiency of v.
The rest of the proof is structured in two parts. First, we show that there is indeed a sufficiently large matching in A . Second, we give a detailed description of how to reroute the edges of the matching to the new vertex v, and carefully verify the correctness of the procedure.
Finding a matching. We will need the following properties of A .
If k ≥ 4, A is connected.
The correctness of (1) follows from the induction hypothesis. Because each vertex in T has deficiency at most k − 1 and each edge addition is good, we have that Also since there must be at least nk−1 2 edges in the graph after the completion to deficiency (df(T ) mod 2), and only n − 1 of the edges are in T .

35:7
The inequality (4) follows from (2), (3), and the fact that 2 · |E(A )| ≤ ∆(A ) · |V (A )|. For the detailed proof, we direct the reader to the full version of this paper. We now use these properties of A to show that there is a large matching in A . For lower bounds on the size of a maximum matching we rely on the recent work of Henning and Yeo [23].
, if t is odd, or at least n t(t + 1) We shall use Proposition 6 to show that A contains a matching of size roughly k 2 , as stated in the following claim.
Claim 7 ( ). When k is odd and n = k + 1, A has a matching of size at least k−1 2 . Otherwise, A has a matching of size at least k 2 .
The proof is by a careful application of Proposition 6 to (1), (2), (3) and (4), it can be found in the full version of this paper.
Rerouting the edges. Now we shall use the matching provided by Claim 7 to conclude the inductive step. Denote by G the graph obtained after the completion of T to a graph of total deficiency (df(T ) mod 2). That is, V (G ) = V (T ) and E(G ) = E(T ) E(A ). If df(T ) is odd, G has a single vertex with deficiency one, denote it by u. For every other vertex s ∈ V (G ), df G (s) = 0. Our goal is to transform G into a graph G that will correspond to the graph obtained after the completion of T using only good edge additions.
We initialize G with G . Let us remind that v is a leaf of T and T = T − v. We denote the only neighbor of v in T by p. Since G is missing vertex v, we introduce v to G, which is now isolated in G. Now V (G) = V (T ), so it is left to add missing edges to G, while probably removing some of the existing edges. Of course, these added edges should include the edge pv, since E(T ) ⊆ E(G) must hold. Similarly, we should not remove any edges of T from G. Thus, we can remove edges in E(A ) only. We denote by A the graph of added edges in G, analogously to A in G .
As was explained before, our basic technique is to remove the edges of the matching in A , and connect their endpoints to v. However, there are several issues to deal with. First, if p is in V (A ), we have to ensure that one of the edges in E(A ) incident to p gets removed, otherwise one of the edge additions is wasted on p. This edge removal may in turn disconnect A . Second, depending on the parity of df(T ) we may have to deal with the already-deficient vertex u of G , and the parity of k comes into play as well. Thus, in the rest of the proof we go over five different cases and show that in each of them the rerouting is possible. The case analysis is technical, and we dedicate the details to the full version. For the reference, we list the cases here. Clarifying pictures for cases (c), (d) and (e), corresponding to odd k, are presented in Figure 1. Considering each case required to accomplish the inductive step concludes the proof of Theorem 4.

35:8 Building Large k-Cores from Sparse Graphs
Since the class of forests is exactly the class of 1-degenerate graphs, it is reasonable to ask whether Edge k-Core is polynomially solvable on other classes of graphs of bounded degeneracy. The answer is negative, and it was shown by Chitnis and Talmon in [9], where they provided a reduction from Clique to Edge k-Core. We note that they used this reduction to prove that Edge k-Core is W[1]-hard when parameterized by the combined parameter b + p, even when k = 3.

Vertex Cover
This section is dedicated to Edge k-Core parameterized by the minimum size of a vertex cover of the input graph G. We show that this problem admits an FPT algorithm and complement this result by ruling out the existence of a polynomial kernel. We start with the high level description of the main ideas behind our algorithm.
High-level description of the algorithm. In order to prove that Edge k-Core is FPT parameterized by the vertex cover number of the input graph, we construct an FPT-time Turing reduction from Edge k-Core to an instance of integer linear program (ILP) whose number of variables is bounded by some function of the vertex cover. While reducing to ILP is a common approach in the design of parameterized algorithms, see [13,Chapter 6], the reduction for Edge k-Core is not straightforward. In order to make the whole approach applicable, we need a new combinatorial result, Lemma 13. The proof of this lemma strongly exploits the refinement of Tripathi and Vijay [29] of the classical theorem of Erdős and Gallai about degree sequences [16]. The reduction target is the following Integer Linear Programming Feasibility (ILP) problem.

Input:
Matrix A ∈ Z m× and vector b ∈ Z m .

Task:
Is there a vector x ∈ Z such that A · x ≤ b?
ILP parameterized by ILP is FPT by the celebrated result of Lenstra [25].
Proposition 9 ([24, 25, 18]). ILP can be solved using O( 2.5 +o( ) · L) arithmetic operations and space polynomial in L. Here L is the number of bits in the input.
Let G be a simple undirected graph on n vertices and b, k, and p be integers. Let vc be the minimum size of a vertex cover in an n-vertex graph G. Our FPT Turing reduction constructs in time 2 O(vc 2 ) · n O(1) at most 2 O(vc 2 ) instances of ILP. Each instance of ILP has = 2 O(vc) variables. Moreover, at least one of the constructed instances of ILP is a yes-instance if and only if one can build a k-core of size p in G by adding at most b edges. Thus by applying Proposition 9 to each of the instances of ILP, we obtain an FPT (parameterized by vc) algorithm for Edge k-Core.
Recall that in Edge k-Core we are looking for a vertex subset H ⊆ V (G) of size at least p such that G [H] can be completed to a graph of minimum degree at least k using at most b edge additions. In what follows, we describe the reduction from Edge k-Core to ILP.
We start with computing a minimum vertex cover C of G. It is well-known that a simple branching algorithm does this job in time 2 |C| · n O(1) , see e.g. [13]. We simplify our task a bit by assuming that C ⊆ H: we just branch into 2 |C| possible options of H ∩ C. For each option we delete vertices C \ H from G. We use the following notion of vertex types. The non-trivial part of the proof is to encode in ILP that G[H] can be completed to a k-core graph using at most b edges. In graph G[H], the vertex set C is a vertex cover and the set I = H \ C is an independent set. Assume that G[H] can be completed into a k-core graph by making use of a set of edges B, |B| ≤ b. The set B can be partitioned into B = B C ∪ B I . Here B C are the edges with at least one endpoint in C, and B I ⊆ I 2 are the remaining edges. Every edge of B I has two endpoints in I. We encode the sets B C and B I in ILP in different ways.

Definition 10 (Vertex types). Let G be a graph and C be its vertex cover. For
It is convenient to assume that B C contains no edges with both endpoints in C. We reach this condition by branching into 2 ( |C| 2 ) = 2 O(vc 2 ) possible options of which edges between vertices in C are added to G. For each such guess we also update the value b and the conditions on degrees of vertices in C.
The next step in the reduction to ILP is to encode the graph G[H] + B C . Since we do not have edges with both endpoints in C anymore, B C consists only of edges between C and I. We proceed with the description of how we encode the edge set B I . For that we need to ensure that for each vertex of I its degree in G[H] + (B C ∪ B I ) is at least k. Since adding edges between vertices in I could significantly increase the vertex cover of G[H], we cannot do the encoding in the same way as for the edges in B C . However, I remains to be an independent set in G[H] + B C . Therefore, B I can be any set of edges subject to the condition that in G[I] + B I the degree of every vertex v ∈ I is at least df G[H]+B C (v). Thus, to ensure that B I is an appropriate set all we need to consider are the deficiencies of vertices in I.
The deficiencies of vertices in I are integers within the range [max{0, k − |C|}, k]. Since G[I] is an empty graph, it is not necessary to know the deficiency of each particular vertex in I. Knowing the number of vertices in I of each particular deficiency is sufficient for our purposes. For i ∈ [max{0, k − |C|}, k], let s i denote the number of vertices in I with deficiency i. These variables can be encoded with ILP equations using the variables y S,S .
We arrive to the most interesting and non-trivial part of the reduction. While the inequalities we have built so far are necessary for encoding the information about the set B I , they are not sufficient. The reason is that not every sequence of integers corresponds to a sequence of vertex degrees in a graph. There is a classical theorem of Erdős and Gallai providing a characterization of graphic sequences. However, if we use this theorem to encode graphic sequences in ILP, the resulting integer program could have unbounded (by a function of vc) number of variables. To overcome this obstacle, we need Lemma 13, a new combinatorial result about graphic sequences.
We want to encode the property that there exists a set of edges B I of size at most b − |B C | such that the edges of B I form a graph with at least s k vertices of degree at least k, at least s k−1 other vertices of degree at least k − 1, and so on down to s max{0,k−|C|} . One technical obstacle here is that we ask for s i vertices of degree at least i, not of degree exactly i. In what follows, for clarity, we explain only how to encode the existence of an edge set forming a graph with t i vertices of degree exactly i for each i ∈ [max{0, k − |C|}, k]. For the "at least" case we need to do more work, but the main idea remains the same. Note that the case we explain here (requiring t i vertices of degree exactly i) is achieved automatically if all edges in B I are good edges (that is, consecutive addition of edges from B I decreases deficiencies of exactly two vertices by one) and the cardinality of this set is found easily as 1 2 i t i . Let us remind the following classical graph-theoretical notion. In terms of this notion, our task is to check that a sequence consisting of integers from [max{0, k − |C|}, k], where the integer i appears exactly t i times, is a graphic sequence. The problem of determining that a given sequence is graphic was approached by Erdős and Gallai in their famous work [16].

Proposition 12 (Erdős-Gallai Theorem, [16]). A sequence of non-negative integers
However, the statement of Proposition 12 does not allow us to encode corresponding inequalities in ILP with the number of variables bounded by |C|. We need a refined version of this proposition, Lemma 13. This combinatorial result on graphic sequences of integers in a short range is crucial in constructing ILP inequalities with bounded number of variables. The proof of the lemma is based on the modification of the Erdős-Gallai theorem due to Tripathi and Vijay [29].
Then d 1 , d 2 , . . . , d n is graphic if and only if k i=k−a i·t i is even and for each D ∈ [k −a, k] at least one of the following holds: We are now ready to state the main result of this section. Its formal proof is given in the full version of the paper and accumulates ideas discussed above in this section. The proof also contains the full description of the constructed linear program. To complement our FPT algorithm, we show that Edge k-Core does not admit a polynomial kernel when parameterized by the combined parameter vc + k + b + p. It was shown in [15] that the Bounded Rank Disjoint Sets problem does not admit a polynomial kernel, and our proof is by reduction from this problem. Theorem 18 ( ). Unless NP ⊆ coNP/poly, Edge k-Core does not admit a polynomial kernel when parameterized by the combined parameter vc + k + b + p.

Treewidth
In this section, we give an FPT-algorithm for Edge k-Core parameterized by tw + k. This improves upon the following result of Chitnis and Talmon, and we also use their algorithm as a subroutine.
We start with the central combinatorial result of this section which allows the algorithmic improvement. Namely, we show that whenever the total deficiency of a graph G exceeds a polynomial in k, G can be completed to a graph of minimum degree k using the minimum possible number of edges. Also, the required edge additions can be identified in polynomial time.
We believe that this result is interesting on its own, since it considerably simplifies the problem whenever the budget is sufficiently high compared to k. If we are trying to identify the best vertex set H which induces a k-core, we have to only care about the total deficiency of G[H], and not of any particular structure on it.
Theorem 20. For any integer k ≥ 2, any graph G with df(G) ≥ 3k 3 can be completed to a graph of minimum degree k using 1 2 df(G) edge additions with a polynomial-time algorithm.
Proof. It is enough to prove that we can satisfy all deficiencies by adding only good edges, except if df(G) is odd, exactly one edge addition is bad.
We constructively obtain a graph G of form G + B, initially B = ∅. The construction is a polynomial time algorithm.
First, we exhaustively apply the following rule, which always does one good edge addition. If there are two distinct vertices u, v ∈ V (G ) such that df G (u) > 0, df G (v) > 0, and uv / ∈ E(G ), then add the edge uv to B. Assume that the rule is no longer applicable. Let us denote C = {v ∈ V (G)| df G (v) > 0}, by the conditions of the rule, C induces a clique in G . Then, |C| ≤ k, since otherwise vertices in C could not have positive deficiency. Now we exhaustively apply the new rule. Fix two vertices u, v ∈ C, such that either u and v are distinct, or u = v and df G (u) ≥ 2. Then find two distinct vertices u , v ∈ V (G ) \ C such that u v ∈ B and uu , vv / ∈ E(G ). Since u v is in B, u and v have degree exactly k, as previously we have only added good edges and u , v / ∈ C. Delete u v from B, now u and v have positive deficiencies. Add edges uu and vv to B, by the choice of u and v these edges are not in E(G ), and also both these additions are good.
We claim that when the new rule is no longer applicable, the size of C is at most one, and df(G ) is also at most one. Suppose it is not true, in this case there is always a proper choice of u, v ∈ C. Then there are no u , v ∈ V (G) \ C satisfying the conditions above. Then each edge u v ∈ B is of one of the following kinds: 1. u , v ∈ C, since |C| ≤ k, there are at most k 2 such edges; 2. one of u , v is in C and the other is not in C, there are at most k(k − 1) edges of this kind, since |C| ≤ k and degrees in C are less than k; 3. u , v / ∈ C, and either uu ∈ E(G ) or vv ∈ E(G ); there are at most k(k − 1) vertices adjacent to C, and each of them has at most k incident edges from B, so there are at most k 2 (k − 1) such edges. Then the size of B is at most k 2 +k(k −1)+k 2 (k −1) < 2k 3 . However, df(G) = 2|B|+df(G ), and df(G ) ≤ |C| · k ≤ k 2 . So df(G) < 3k 3 contradicting the statement.
Therefore, by the constructed sequence of good additions we reached the situation when |C| and df(G ) are both at most one. If C is empty, we are done. If C consists of one vertex u, then its deficiency is one. Since df(G) = 2|B| + df(G ), df(G) is odd, and we have one more edge addition. Then we add to B an edge from u to any other vertex v such that uv / ∈ E(G ); this is always possible since deg G (u) < k, and V (G) > k because df(G) ≥ 3k 3 .
The intuition to our FPT algorithm is as follows. When we can obtain a sufficiently large k-core by adding a number of edges b < 3k 3 , the algorithm from Proposition 19 suffices. Otherwise b ≥ 3k 3 and by Theorem 20 we can focus on finding a vertex subset in G of size at least p minimizing the total deficiency of the induced subgraph. We show how to do that with a dynamic programming over a tree decomposition.