## 1 Introduction

In recent years, modelling user engagement in social networks has received substantial interest [26, 3, 7, 24, 13, 25]. A popular assumption is that a user engages in a social network platform if she has at least a certain number of contacts, say , on the platform. Further, she is inclined to abandon the social network if she has less than contacts [26, 3, 7, 21, 13, 6]. In compliance with this assumption, a suitable graph-theoretic model for the “stable” part of a social network is the so-called *-core* of the social network graph, that is, the largest induced subgraph with minimum degree [23].^{1}^{1}1Note that the -core of a graph is uniquely determined.

Now, given a stable social network, that is, a graph with minimum degree , the departure of a user decreases the degree of her neighbors in the graph by one which then might be smaller than for some of them. Following our assumption these users now will abandon the network, too. This causes a cascading effect of users dropping out (collapse) of the network until a new stable state is reached.

From an adversarial perspective a natural question is how to maximally destabilize a competing social network platform by compelling users to abandon the network. This problem was introduced as Collapsed -Core by Zhang et al. [26] and the decision version is formally defined as follows.

Collapsed -Core Input: An undirected graph , and integers , , and . Question: Is there a set with such that the -core of has size at most ?In the mentioned motivation, one would aim to minimize for a given and . Alternatively, we can also interpret this problem as a measure for resilience agains user drop outs of a social network by determining the smallest for a given and .

#### Related Work.

In 2017 Zhang et al. [26] showed that Collapsed -Core is NP-hard for any and gave a greedy algorithm to compute suboptimal solutions for the problem. However, for and any fixed , solving Collapsed -Core is equivalent to finding vertices such that after removing said vertices, the remaining graph is -degenerate^{2}^{2}2A graph is -degenerate if every subgraph of has a vertex with degree at most [10]..
This problem is known as -Degenerate Vertex Deletion and it is defined as follows.

It is easy to see that Collapsed -Core is a generalization of -Degenerate Vertex Deletion. In 2010 Mathieson [22] showed that -Degenerate Vertex Deletion is NP-complete and W[P]-complete when parameterized by the budget for all even if the input graph is already -degenerate and has maximum degree . In the mid-90s Abrahamson et al. [1] already claimed W[P]-completeness for -Degenerate Vertex Deletion with when parameterized by under the name Degree 3 Subgraph Annihilator. For , the problem is equivalent to Feedback Vertex Set and for it is equivalent to Vertex Cover, both of which are known to be NP-complete and fixed-parameter tractable when parameterized by the solution size [14, 9]. The aforementioned results concerning -Degenerate Vertex Deletion in fact imply the hardness results shown by Zhang et al. [26] for Collapsed -Core.

#### Our Contribution.

We complete the parameterized complexity landscape of Collapsed -Core with respect to the parameters , , and . Specifically, we correct errors in the literature [22, 1] concerning the W[P]-completeness of -Degenerate Vertex Deletion when parameterized by for . We go on to clarify the parameterized complexity of Collapsed -Core for by showing W[1]-hardness for parameter and fixed-parameter tractability for the combination of and . Together with previously known results, this reveals a dichotomy in the computational complexity of Collapsed -Core for and .

We present two single exponential linear time FPT algorithms, one for Collapsed -Core with and one for . In both cases the parameter is . In particular, the algorithm for runs in time which means that it solves Feedback Vertex Set in time (here, is the solution size of Feedback Vertex Set). To the best of our knowledge, despite of its simplicity our algorithm improves many previous linear time parameterized algorithm for Feedback Vertex Set [20, 15]. However, recently a linear time computable polynomial kernel for Feedback Vertex Set was shown [16], which together with e.g. [18] yields an even faster linear time parameterized algorithm.

Furthermore, we conduct a thorough parameterized complexity analysis with respect to structural parameters of the input graph. On the positive side, we show that Collapsed -Core is fixed-parameter tractable when parameterized by the treewidth of the input graph and show that it presumably does not admit a polynomial kernel when parameterized by either the vertex cover number or the bandwidth of the input graph. We also show that the problem is fixed-parameter tractable when parameterized by the combination of the cliquewidth of the input graph and or . Further results include W[1]-hardness when parameterized by the clique cover number of the input graph and para-NP-hardness for the domination number of the input graph.

## 2 Hardness Results from the Literature

In this section, we gather and discuss known hardness results for Collapsed -Core. Recall that that Collapsed -Core with is the same problem as -Degenerate Vertex Deletion with . Hence, the hardness of Collapsed -Core was first established by Mathieson [22] who showed that -Degenerate Vertex Deletion is NP-complete and W[P]-complete when parameterized by the budget for all even if the input graph is already -degenerate and has maximum degree . However, in the proof of Mathieson [22] the reduction is incorrect for the case that . Abrahamson et al. [1] claim W[P]-completeness for but their reduction is also flawed. In the following, we provide counterexamples for both cases. Then we show in the following how to adjust the reduction of Mathieson [22] for this case.

#### Counterexample for Mathieson’s Reduction [22].

We refer to the original paper by Mathieson [22] for definitions, notation, and description of the gadgets and the reduction itself. Mathieson provides a reduction from Cyclic Monotone Circuit Activation to -Degenerate Vertex Deletion [22, Theorem 4.4] showing that -Degenerate Vertex Deletion is W[P]-complete when parameterized by the budget for all even if the input graph is already -degenerate and has maximum degree . However, for the case of it is easy to see that the OR gadget is already 2-degenerate. We illustrate the flawed OR gadget for in Figure 1.

This means that whenever a Cyclic Monotone Circuit Activation instance is activated by the set of all its binary OR gates, the graph produced by the reduction (for ) is already 2-degenerate, which clearly makes the reduction incorrect. An example of such an instance would be the one given by Mathieson [22]. We reproduce the example in Figure 2.

We describe how to repair the reduction (for ) in the proof of Theorem 1.

#### Counterexample for Abrahamson et al.’s Reduction [1].

We refer to the original paper by Abrahamson et al. [1] for definitions, notation, and description of the gadgets and the reduction itself. The same reduction (using the same notation) can also be found in the book “Fundamentals of Parameterized Complexity” by Downey and Fellows [11]. Abrahamson et al. provide a reduction from Weighted Monotone Circuit Satisfiability to Degree 3 Subgraph Annihilator, which is equivalent to -Degenerate Vertex Deletion with . With this reduction they claim to show that -Degenerate Vertex Deletion with is W[P]-complete when parameterized by the budget [1, Theorem 3.7 (ii)].

The main idea of their reduction is that once a satisfying assignment is found, all variable gadgets corresponding to variables that are set to false are also removed. However, since in a variable gadget for a variable , the vertex has high degree, it is only removed if sufficiently many of the gate gadgets that it is connected to are also removed. However, an AND gadget combined with a fan-out gadget is only removed if both inputs are removed. This follows from fan-out gadget not being removable from below. This allows us to create a counterexample with , which we illustrate in Figure 3. It is easy to check that is the only satisfying assignment that has at most one variable set to true. Furthermore, the AND gates in the red area have two outgoing connections each, hence the corresponding AND gadgets have fan-out gadgets attached to them. Initially, the output of these gates is false for the satisfying assignment so the fan-out gadget attached to them are only removed if the AND gadgets themselves are removed. An AND gadget is removed if both of its inputs are removed. However, note that the variable gadget for is not completely removed after is removed from the graph. In particular, the vertex has still degree after all vertices are removed since the AND gadgets it connects to are not removed. It follows that the graph is not 2-degenerate after removing and hence the reduction is not correct.

We believe that the reduction can be corrected by replacing the high degree vertices by fan-out gadgets that connect to the gate gadgets. However, we omit a proof of this claim.

###### Theorem 1 (Corrected from [22]).

For any -Degenerate Vertex Deletion is NP-hard and W[P]-complete when parameterized by , even if the degeneracy of the input graph is and the maximum degree of the input graph is .

###### Proof.

We refer to the original paper by Mathieson [22] for definitions, notation, and description of the gadgets and the reduction itself. Mathieson provides a reduction from Cyclic Monotone Circuit Activation to -Degenerate Vertex Deletion [22, Theorem 4.4] showing that -Degenerate Vertex Deletion is W[P]-complete when parameterized by the budget for all even if the input graph is already -degenerate and has maximum degree . While Mathieson [22] claimed the result also for , the reduction is incorrect in this case. Similarly, while Abrahamson et al. [1] claimed the same result for under the name Degree 3 Subgraph Annihilator, their reduction also seems to be flawed.

However, there is a way to correct the proof of Mathieson [22]: The only problem is that his OR gadget is 2-degenerate, so the graph sometimes collapses without even deleting a single vertex. Before we introduce the correct gadget, note that the gadget is always used with exactly two inputs (predecessor gates). We can replace the OR gadget for case with the graph illustrated in Figure 4.

To collapse this gadget one can simply delete . The correctness now follows from an analogous argument as given by Mathieson [22]. ∎

The following observation shows that the hardness result by Mathieson [22] (Theorem 1) easily transfers to Collapsed -Core (also in the cases where ).

###### Observation 1.

Let be a positive integer. There is a reduction which transforms instances of Collapsed -Core with into equivalent instances of Collapsed -Core.

###### Proof.

We distinguish two cases, depending on the relation of to .

If , then we let . Obviously, if is a solution for , then it is also a solution for . On the other hand, if is a solution for , then has a -core with at most vertices. However, any vertex of a graph with at most has degree at most and, thus, the -core is empty. Therefore is a solution for .

If , then we obtain as a disjoint union of and a clique on vertices. Again obviously, if is a solution for , then it is also a solution for , since the -core of is exactly .

Now let be a solution for . Note that if one vertex of is part of the -core of , then all vertices of are. If indeed is a part of the -core of , then the -core contains at most other vertices. If is the set of vertices in the -core of , then is a solution for .

Now if is not a part of the -core of , then we know that vertices are sufficient to collapse a clique of size . Since the -core of , which is the same as the -core of is of size at most , there is a set of vertices at most such that the -core of is empty. Hence is a solution for . ∎

With that, we arrive at the following corollary.

###### Corollary 1.

Collapsed -Core is NP-hard and W[P]-hard when parameterized by for all and , even if the degeneracy of the input graph is and the maximum degree of the input graph is .

Note that -Degenerate Vertex Deletion is known to be NP-hard for all .^{3}^{3}3Theorem 1 states NP-hardness of -Degenerate Vertex Deletion for . Recall that for -Degenerate Vertex Deletion is equivalent to Feedback Vertex Set and for it is equivalent to Vertex Cover, both of which are known to be NP-hard [14]. Hence, we also know that Collapsed -Core is NP-hard for and all . However, the parameterized complexity with respect to is open in this case. We settle this in the next section.

## 3 Algorithms for and

In this section we investigate the parameterized complexity of Collapsed -Core for the case that . Since Corollary 1 only applies for we first show in the following that the problem is W[1]-hard with respect to the combination of and for all . Furthermore, we present two algorithms; one that solves Collapsed -Core with and one for the case. Both algorithm run in single exponential linear FPT-time with respect to the parameter combination .

We first give a parameterized reduction from Clique to Collapsed -Core. Note that since this hardness result holds for the combination of and the dual parameter of , it is incomparable to Corollary 1 for .

###### Proposition 1.

Collapsed -Core is W[1]-hard when parameterized by the combination of and for all , even if the input graph is bipartite and -degenerate.

###### Proof.

We reduce from W[1]-hard problem Clique [9], where given a graph and an integer , the task is to decide whether contains a clique of size at least . Let be an instance of Clique and be a given constant. We build an instance of Collapsed -Core as follows. We can assume that , as otherwise we can output a trivial no-instance. We further assume that each vertex of has degree at least . Vertex of degree less than is not part of a clique of size at least , while for all vertices of degree or we can check in time whether there is a clique of size at least containing any of them.

We let , where are the vertices of , , and . We also let , where , and . We actually only introduce the sets and if .

Finally we set and , where is the number of vertices of graph .

We claim that is a yes-instance of Collapsed -Core if and only if is a yes-instance of Clique.

If is a clique of size at least in , then we claim that deleting from results in a -core of size at most . Let be an edge between two vertices of in . Then for any vertex has only vertices as neighbors in . Hence, it has degree in this graph and it is not part of the -core of the graph. Since this holds for each , vertices do not have any neighbors in the -core of and, hence, they are also not in the -core of the graph. This makes vertices per each edge of the clique which are not deleted and not in the -core, showing that the size of the -core is at most .

Now let be a set of vertices of of size at most such that has -core of size at most . For let . Let . Note that if , , and , then whole is in the -core of as each vertex in has at least neighbors in . This means that each vertex in is in the -core of . Indeed, for an arbitrary vertex in the degree of in is at least and, thus, there is at least one edge incident to which is not in . Hence is in the -core of by the above argument.

For possibly no vertex of is in the -core of , effectively shrinking it by vertices. However, this does not influence the other vertices in , , or , since is in the -core, as we already observed. If and , then also the whole is not in the -core as observed in the first implication. Thus, if and , then there are at most vertices of which are neither in nor in the -core of . As is a solution, this number has to be at least , while . It follows that and is a clique of size in .

Note that graph is bipartite and for it is also -degenerate, as all vertices in have degree , after removing them the vertices of have degree , and, finally, forms an independent set in . ∎

Now we proceed with the algorithm for Collapsed -Core with . While there is a simple algorithm with running time^{4}^{4}4An informal description of the algorithm: We use an initially empty set that should contain vertices of the remaining 1-core. We branch over edges where both endpoints are not in and either remove one of the endpoints or put both endpoint into . Then we branch over all edges that have exactly one endpoint in and either remove the other endpoint or put the other endpoint into as well. for this case, we prefer to present an algorithm with the slightly worse running time as stated, since we then generalize this algorithm to the case with some modifications.

###### Proposition 2.

Collapsed -Core with can be solved in time. Assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , for any function .

*Algorithm:* We present a recursive algorithm (see Algorithm 1 for pseudocode) that maintains two sets and .
The recursive function is supposed to return a solution to the instance, whenever there is a solution containing all of and there is no solution containing and anything of . If some of the conditions is not met, then the function should return “No solution”.
In other words, is the set of deleted vertices and is the set of vertices the algorithm has decided not to delete in the previous steps but may be collapsed in the future.
Hence, the solution to the instance, or the information that there is none, is obtained by calling the recursive function with both sets and empty.

The algorithm first checks that is of size at most and is of size at most . If any of these is not true, then it rejects the current branch. Then it computes the -core of the graph . If the -core is of size at most , then it returns as a solution. If is larger, but all its vertices are in , then we have no way to shrink the core and we again reject. Finally, the algorithm picks an arbitrary vertex of largest degree in which is not in and recurses on both possibilities—either is in the solution, modeled by adding it to , or it is in no solution containing , modeled by adding it to . We start by showing that Algorithm 1 has the claimed running time.

###### Lemma 1.

Algorithm 1 runs in time.

###### Proof.

Assume the running time of Algorithm 1 is , where . Let and be the number of edges and number of vertices in respectively. Since when or Algorithm 1 directly return “No solution” in line 1, we have for . Lines 1, 1, 1 and 1 can be done in time. In line 1 the -core can be found in time by first removing vertices in and edges incident with them to get , and then removing isolated vertices in . Thus except for line 1 and 1, all steps can be done in time, and we have that

∎

Next we show the claimed conditional lower bound on the running time for any algorithm for Collapsed -Core with .

###### Lemma 2.

Assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , for any function .

###### Proof.

Since Collapsed -Core with and is equivalent to Vertex Cover, and assuming the Exponential Time Hypothesis, there is no time algorithm for Vertex Cover [19], we have that assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , where can be an arbitrary function. ∎

Before showing the correctness of Algorithm 1, we first show in the following lemma why in line 1 set should be bounded by .

###### Lemma 3.

If is of size more than , then there is no solution containing whole and no vertex from .

###### Proof.

Suppose for contradiction that there is a set of size at least and a solution such that , and . Let be the vertices of the set in the order as they were added to the set by successive recursive calls. Moreover, if is empty, then let . Otherwise, let , i.e., in both cases . Let be the -core of and let . Since is a solution, we know that . Our aim is to show that the number of edges lost by vertices of is larger than the number of edges incident to the vertices of , which would be a contradiction.

To this end, we construct an injective function that maps the vertices in to vertices of . First let be the vertex in with the largest . We let be . Now let be the vertex from with the largest such that was not set yet and be the vertex from with the least such that . We set . Since the set contains at least vertices, while contains at most , this way we find a mapping for every vertex in . Moreover, there remains at least one vertex in not being in the image of , let us denote it .

For let be the -core of the graph . For let be the degree of the vertex in . By the way we selected we know that for every . Moreover, for every . Note also that since is a -core, we have for all .

If for every vertex we have , then for every vertex in . Let us count the number of edges of the form such that and . Since each edge incident on a vertex of must have the other endpoint in , this number is at least . On the other hand, since edges towards are always counted in , this number is at most . We have that

On the other hand, since for every vertex in we have that

which is a contradiction.

Otherwise, let be the largest such that and . We consider the graph . Now for every with we have , thus . Let us count the number of edges of the form in such that and . Since each edge of incident on a vertex of must have the other endpoint in , this number is at least . On the other hand, since edges towards are always counted in , this number is at most . We have that

On the other hand, since for every vertex in we have that

which is again a contradiction. ∎

Now we have all necessary pieces to prove Proposition 2.

###### Proof for Proposition 2.

To show the correctness of the Algorithm 1, we first show that whenever the algorithm outputs a solution, then this solution is indeed correct. Then we show that whenever there exists a solution, the algorithm also finds a solution.

We show this part by induction on the recursion tree. If Algorithm 1 returns as a solution in line 1, then it is of size at most since line 1 does not apply and the -core of is of size at most . This constitutes the base case of the induction.

If the solution is obtained from recursive calls on lines 1-1, then we know that it is correct by induction hypothesis.

Next, we show by induction on the recursion tree that if there is a solution then Algorithm 1 returns a solution. In particular, we show that if there is a recursive call of Algorithm 1 with sets and such that there is a solution containing all of and there is no solution containing the whole and any vertex from , then the algorithm either directly outputs a solution or it invokes a recursive call with sets and such that there is a solution containing all of and there is no solution containing the whole and any vertex from . Let and be two input sets of a recursive call of Algorithm 1 and let be a solution such that and . First we show that none of lines 1 and 1 applies. Line 1 will not apply since we have and by Lemma 3 we also know that we have . If the -core of is of size more than , which is the case when line 1 applies and line 1 does not apply, then no set with can make the -core of of size at most , which is a contradiction to being a solution with . If follows that the current recursive call of Algorithm 1 does not output “No Solution”.

If , then line 1 applies and the algorithm outputs . Otherwise, we know that any vertex is either in and hence , or we have that . In particular, if the recursive call on line 1 does not return a solution, then, by induction hypothesis, there is no solution containing , i.e., there is no solution containing and anything of and the call on line 1 must return a solution by induction hypothesis. It follows that the algorithm invokes a recursive call with the desired properties in line 1 or in line 1.

In the remainder of the section, we show how to adapt this algorithm for Collapsed -Core with .

###### Theorem 2.

Collapsed -Core with can be solved in time. Assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , for any function .

The above theorem in particular yields an algorithm for Feedback Vertex Set. For the proof we need the following lemma, which shows that, except for some specific connected components, we can limit the solution to contain vertices of degree at least three.

###### Lemma 4.

For any instance of Collapsed -Core with , where is a -core and does not contain a cycle as a connected component, if there is a solution for , then there is also a solution for which contains only vertices with degree larger than 2.

###### Proof.

Let be any vertex with degree 2 in . Let be a vertex of degree at least 3 in such that there is a path between and with all internal vertices of degree exactly 2 in . Since no component of is a cycle, such a vertex must exist. Let and . We have the -core of is the same as the -core of and the -core of is a subset of the -core of . So the -core of is a subset of the -core of , and hence no larger than . Therefore is also a solution for . Following the same way, we can replace all degree 2 vertices in with vertices which have degree larger than 2, and get a new solution for . ∎

*Algorithm:*
Our algorithm for is similar to Algorithm 1 with two main differences (see Algorithm 2 for pseudocode).
First is replaced by .
Second when selecting the maximum degree vertex from , we need to make sure that this vertex has degree greater than 2.
Otherwise, either we can directly select vertices from to break cycles in and get a -core of size at most , or the algorithm rejects this branch.

We start by showing that Algorithm 2 has the claimed running time.

###### Lemma 5.

Algorithm 2 runs in time.

###### Proof.

We first show by induction on the size of starting with the largest size achieved that a call with and results in at most calls to the function in total. Indeed, the size of never exceeds and the size of never exceeds since the sizes grow by one and if they achieve the bound, then line 2 applies. Hence, if any of the lines 2–2 applies, then we have only one call and and implies , making the basic cases. If the call makes recursive calls, then in one of them is one larger than in the current one, and if the second one is made, then is one larger in it. Hence the number of calls is at most , finishing the induction.

Since we call the algorithm with sets and empty, it follows that the total number of calls is at most . Using, e.g., the lemma of Fomin et al. [12, Lemma 10] (or Stirling’s approximation) one can show that . Hence, . So we have that the number of recursive calls is at most .

Now we analyze the time complexity of a single call. In line 2, the -core can be found in time by recursively removing vertices with degree less than 2 in [2]. In line 2, sorting these circles according to their sizes can be done in time using counting sort. Thus except for Line 2 and 2, all steps can be done in . Since there are at most edges or we are facing a no-instance, we have that the time complexity of the algorithm is , which is as claimed. ∎

Next we show the claimed conditional lower bound on the running time for any algorithm for Collapsed -Core with .

###### Lemma 6.

Assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , for any function .

###### Proof.

Since Collapsed -Core with and is equivalent to Feedback Vertex Set, and assuming the Exponential Time Hypothesis, there is no time algorithm for Feedback Vertex Set [19], we have that assuming the Exponential Time Hypothesis, there is no time algorithm for Collapsed -Core with , where is an arbitrary function. ∎

Before showing the correctness of Algorithm 2, we prove the following lemmata which will be helpful in the correctness proof. The next lemma helps to show that line 2 is correct.

###### Lemma 7.

###### Proof.

Suppose for contradiction that is a solution containing . Note that in this case is a solution for . Let be the graph formed by the union of connected components of containing vertices of degree at least 3 and be the graph formed by the union of connected components of which are cycles and contain vertices of , that is,

Comments

There are no comments yet.