Fast and simple decycling and dismantling of networks

Decycling and dismantling of complex networks are underlying many important applications in network science. Recently these two closely related problems were tackled by several heuristic algorithms, simple and considerably sub-optimal, on the one hand, and involved and accurate message-passing ones that evaluate single-node marginal probabilities, on the other hand. In this paper we propose a simple and extremely fast algorithm, CoreHD, which recursively removes nodes of the highest degree from the 2-core of the network. CoreHD performs much better than all existing simple algorithms. When applied on real-world networks, it achieves equally good solutions as those obtained by the state-of-art iterative message-passing algorithms at greatly reduced computational cost, suggesting that CoreHD should be the algorithm of choice for many practical purposes.


I. INTRODUCTION
In decycling of a network we aim to remove as few nodes as possible such that after the removal the remaining network contains no loop.In network dismantling we aim to find the smallest set of nodes such that after their removal the network is broken into connected components of sub-extensive size.These are two fundamental network-optimization problems with a wide range of applications, related to optimal vaccination and surveillance, information spreading, viral marketing, and identification of influential nodes.Considerable research efforts have been devoted to the network decycling and dismantling problems recently [1][2][3][4][5][6][7][8].
Both the decycling and the dismantling problems belong to the class of NP-hard problems [6,9], meaning that it is rather hopeless to look for algorithms to solve them exactly in polynomial time.However, finding the best possible approximate solutions for as large classes of networks as possible is an open and actively investigated direction.Recent theoretic and algorithmic progress on both these problems [1-3, 5, 6] came from the fact that, on random sparse networks with degree distributions having a finite second moment, methods from physics of spin glasses provide accurate algorithms for both decycling and dismantling.These sparse random networks are locally tree-like and do not contain many short loops.On such networks the decycling is closely linked to dismantling and asymptotically almost the same set of nodes is needed to achieve both [5,6,10].Even on real-world networks that typically contain many small loops, best dismantling is currently achieved by first finding a decycling solution and then re-inserting nodes that close short loops but do not increase too much the size of the largest component [5,6].
Both the algorithms of [6] and [5] achieve performance that is extremely close to the theoretically optimal values computed on random networks.However, both these algorithms are global, they need to iterate certain equa-tions on the whole network in order to select the suitable candidate nodes.Although they are both scalable and can be run on networks with many millions of nodes, they are not completely straightforward to understand and require some experience with spin glass theory.The close-to-optimal performance of these algorithms is theoretically justified only on random networks.Despite their good performance observed empirically on networks with many loops, there might still exist even better and analyzable strategies for real-world networks.
As usual in applied science, in many potential applications we are at first not even sure that optimal dismantling or optimal decycling is the best strategy to answer the question in hand (e.g., the problem of social influence maximization [11][12][13][14]).Therefore it is extremely important to have a really very simple and fast decycling and dismantling strategy that can provide an accurate assessment of whether this approach is at all interesting for a given practical problem.However, existing simple strategies, such as removing adaptively high degree nodes [15,16], are very far from optimal performance and therefore not very useful.Recently the authors of [4] claimed that a heuristics based on the so-called collective influence (CI) measure can be a perfect candidate for this purpose.This algorithm has attracted a lot of enthusiasm in the network science community.However, more systematic investigations performed in [5,6,8] revealed that the CI algorithm is still annoyingly far from being optimal.The CI algorithm is also not particularly competitive in terms of computational time because a large neighborhood of a node needs to be considered in order to evaluate the CI measure.
In the present paper we introduce the CoreHD algorithm that is basically as simple and fast as the adaptive removal of high degree nodes, yet its performance is much closer to optimal than the CI algorithm or its extended versions, and comparably close as the best known message-passing methods [5,6] while several orders of magnitude faster.It hence provides simple and tractable solutions for networks with many billions of nodes.The method is simply based on adaptive removal of highestdegree nodes from the 2-core of the network.Apart of its simplicity and speed the performance of the CoreHD algorithm is basically indistinguishable from the performance of the message-passing algorithms on random graphs with long-tailed degree distributions.On all realworld network instances we tested the result by CoreHD is within few nodes from the best one found by messagepassing and on some instances we found that it is even slightly better.On top of all that, the simple structure of CoreHD might be amenable to rigorous analysis providing guarantees for loopy networks that are not accessible for the message-passing methods.
For all the above reasons we argue that in many applications of decycling and dismantling CoreHD should be the first choice.The simple algorithmic idea generalizes easily to the problem of destroying optimally the k-core of a network -one focuses on the current k-core and adaptively removes highest degree nodes.

II. THE COREHD ALGORITHM
We now describe CoreHD as an extremely fast algorithm for decycling and dismantling of huge complex networks with close-to-optimal outcomes.Let us begin with some motivating discussions.
Perhaps the simplest algorithms one can propose for decycling and dismantling is adaptive removal of highestdegree nodes.We call this method HD, it is indeed extremely fast, but empirically does not perform very well.One reason why HD does not work well is that some nodes of large degree, such as node i in Fig. 1, do not belong to any loop, and hence do not have to be removed for decycling.Due to the property that trees can always be dismantled by a vanishing fraction of nodes [10], nodes such as i of Fig. 1 are also not useful for dismantling.Note that the CI method of [4] shares this problem, see the appendix.The above observation motivates a very natural idea that dismantling and decycling algorithms should always focus only on the 2-core of the network.The 2-core is a sub-network that is obtained after adaptive removal of all leaves (nodes with only a single attached edge).The sim-plest and fastest strategy is then to remove the highestdegree nodes from the remaining 2-core.To our surprise this simple idea provides much better performance than other comparably simple approaches existing in the literature.We call the resulting algorithm CoreHD, it is detailed in Algorithm 1.

Algorithm 1: CoreHD
Input: A network.Output: A forest of small trees.
1. Find the 2-core of the network, and obtain the degree of every node within this 2-core (edges to outside nodes not considered).
2. Identify the node i with the largest degree in the 2-core.If there are more nodes with the same largest degree, randomly choose one of them.
3. Remove node i, update the 2-core and the degrees of all its nodes.If the 2-core is empty, then do tree-breaking and stop; otherwise go to step 2.
For the decycling problem, CoreHD simply removes highest-degrees nodes from the 2-core in an adaptive way (updating node degree as the 2-core shrinks), until the remaining network becomes a forest.For dismantling, after decycling, CoreHD also breaks the trees into small components, see Appendix that follows tree-breaking strategy from [5,6].In case the original network has many small loops, a refined dismantling set is obtained after a reinsertion of nodes that do not increase (much) the size of the largest component, again as proposed recently in [5,6].For details on implementation of the reinsertion algorithm we refer to the Appendix.

III. RESULTS
In this section we evaluate the CoreHD algorithm for both random and real-world networks, by comparing the minimum fraction of nodes we need to remove in order to break the network into a forest or components with size smaller than 0.01n.We compare to the Belief Propagation guided Decimation (BPD) [5] and Collective Influence method (CI) [4] (CI 4 results are obtained using the original code of Ref. [4]).
First, we notice that on some simple examples, e.g.regular random graphs with degree 3, the CoreHD algorithm reaches the exact optimal decycling fraction ρ = 0.25.This matches the performance of a greedy method of [17] that for this particular case is provably optimal.
In Fig. 2 we compare the performance of the above algorithms on an Erdős-Rényi random network with N = 50000 nodes and average degree c = 3.5.In the upper panel we plot the fraction of nodes in the largest connected component (LCC, denoted q) as a function of the fraction of removed nodes, denoted ρ.We see that compared to HD and CI the CoreHD algorithm works 0.17 the best by a large margin, breaking the network into small component with size smaller than 0.01N after removing fraction of only 0.1846 of nodes.While CI and HD need to remove fraction 0.2014, and 0.2225 of nodes respectively.This is compared to the close-to-optimal performance of the iterative message passing BPD that needs to remove fraction 0.1780 of nodes, and to the theoretical prediction for the asymptotically optimal value 0.1753 [1-3, 6, 7].
We also see from the figure that the fraction of nodes in the LCC obtained by CoreHD encounters a first order transition when ρ dec = 0.1831, this is because at this point (just at the beginning of the discontinuity) the remaining network becomes a forest.The greedy treebreaking procedure then quickly breaks the forest into small components.While the other algorithms do not have this phenomenon, the size of the LCC goes to zero continuously.In the lower panel of Fig. 2 we plot the fraction q of nodes in the 2-core as a function of ρ.We can see that for CoreHD, q reaches zero at ρ = 0.1831 indicating that the remaining network contains no loop, thus is a forest.While for other algorithms the 2-core remains extensive until the network is dismantled.On a larger ER random network with N = 10 6 , c = 3.5, the difference between the sizes of decycling and the dismantling sets the CoreHD algorithm finds is not distinguishable within the precision of 4 valid digits and is 0.1830 for both.Note that this result is (slightly) better than yet another approach suggested recently in the literature [8] that achieves 0.1838 with an algorithm still considerably more involved than CoreHD.
Besides performing much better than CI, the CoreHD is also much faster: the 2-core of the network can be computed efficiently using a leaf-removal process with O(N ) operations.After deleting a node, one only needs to update the 2-core, which requires on average O(1) operations in sparse networks, and is clearly much faster than updating the CI score.Actually, in sparse networks when the size of the 2-core is much smaller than the size of the network, CoreHD is even faster than the HD algorithm which removes one by one nodes from the whole network.
The computational times for the CoreHG, CI and BPD algorithms as the system size grows are shown in Fig. 3 for ER network with mean degree c = 3.The BPD algorithm performs slightly better than the CoreHD algorithm but it is much slower.For example, for an ER network with c = 3 and N = 2 × 10 8 , the solution obtained by CoreHD has relative dismantling/decycling set size ρ ≈ 0.1407 (computing time is 64 minutes), which is only slightly larger than the value of ρ ≈ 0.1357 ob- Fraction ρ of removed nodes for (A) Erdős-Rényi (ER) random networks of mean degree c, (B) Regular Random (RR) networks of degree K, and (C) Scale Free (SF) networks of average degree c and decay exponent γ = 3.0 generated as in [18].Each data point obtained by CoreHD is the over 96 instances of size N = 10 5 .The results of CI4 and the results of BPD are from [5].In BPD and CI4, at each iteration a fraction f of nodes are removed (with f = 0.01 for BPD and f = 0.001 for CI4, decreasing f does not improve the performance visibly), while in CoreHD nodes are removed one by one.tained by BPD (computing time is 23.5 hours [5]).We note that in these experiments, in each step of removal, BPD and CI 4 remove 0.1% of nodes (e.g., 10000 nodes for N = 10 7 ), while CoreHD removes only 1 node per step.Even this way the computational time of CoreHD is shorter than the time used for reading the network from the data file (edge-list format, using a c++ procedure).Fig. 4 presents results for Erdős-Rényi random graphs, regular random graphs, and scale-free random networks of varying average degree.In all cases CoreHD works better than CI and worse than BPD, with the best performance obtained for scale-free networks.The good performance of CoreHD for the scale-free networks is of particular interest because almost all real-world networks have a heavy-tailed degree-distribution.
A set of experiments on real-world networks is presented in Tab.I. We list the fraction of nodes we need to remove in order to remove all cycles, and in order to break the network into small components with size smaller than 0.01N .For dismantling, in addition to Al-gorithm 1 we do a refinement by inserting back some deleted nodes that do not increase the largest component size beyond the 0.01N .We can see that CoreHD works excellently for real-world network instances, giving decycling and dismantling sets very close to the state-ofart BPD and much smaller than CI.It is also surprising to see that in some networks e.g.RoadEU, IntNet1 and RoadTX, CoreHD even outperforms BPD slightly.Tab.I clearly demonstrates the time superiority of CoreHD for real-world networks as compared with both CI and BPD.

IV. CONCLUSION AND DISCUSSIONS
We have presented that iteratively removing nodes having the highest degree from the 2-core of a network gives an ultra-fast while very efficient algorithm for decycling and dismantling of networks.Our algorithm is so fast that its running time is shorter than the time of reading the network file.
It is still surprising to us that such a simple algorithm could work much better than more sophisticated algorithms: We have tried running CI (see Appendix), adjacency matrix centrality on the 2-core of the network, and HD on 3-core of the network, they are all slower but perform no better than CoreHD.Our experiments also show that CoreHD outperforms centrality measures using left and right eigenvector of the non-backtracking matrix [27], an idea that originally inspired us to propose the CoreHD algorithm.More detailed understanding of why this is the best performing strategy is let for future work.
On the real-world networks which typically have many short loops and motifs, decycling is quite different from dismantling.A natural idea to generalize our CoreHD would be consider a factor graph treating short loops and motifs as factors, then do CoreHD on the 2-core of the factor graph.
Finally, CoreHD can be generalized naturally to removal of the k-core, again running the adaptive DH heuristics on the k-core or the current graph.Comparison of this strategy to existing algorithms [2,28] is in progress.
TABLE II.Comparing the dismantling performance of CoreHD and CoreCI on ER, RR, and SF random networks.Each data point is the mean and standard deviation of ρ (the fraction of deleted nodes) over 96 dismantling solutions obtained by CoreHD or CoreCI on 96 independent network instances of size N = 10 5 and mean degree c (ER and SF) or degree K (RR).The ball radius of CoreCI is fixed to = 4.The SF network instances are generated by the static method [18].(6)

FIG. 1 .
FIG. 1. Illustration of a network with dangling trees.Each circle denotes a node in the network, each line connecting circles denotes an edge, and the cloud represents the other part (nodes and edges) of the network.

FIG. 2 .
FIG.2.Fraction of nodes in the largest connected component (LCC) (upper) and in the 2-core (lower) as a function of fraction of nodes removed, for HD, CI4, CoreHD and BPD on an Erdős-Rényi random graph with number of nodes N = 5×10 4 , and average degree c = 3.5.In all four methods nodes are removed one by one.

FIG. 3 .
FIG. 3.Performance of the CoreHD algorithm (magenta squares) and its comparison with the BPD algorithm (blue circles) and the CI algorithm ( = 4, grey diamonds) on ER networks of average degree c = 3 and size N .(A) The relationship between the total running time τ and N .The simulation results are obtained on a relatively old desktop computer (Intel-6300, 1.86 GHz, 2 GB memory).(B) The relationship between the fraction ρ of removed nodes and N .The dotted horizontal line denotes the theoretically predicted minimum value.
FIG.4.Fraction ρ of removed nodes for (A) Erdős-Rényi (ER) random networks of mean degree c, (B) Regular Random (RR) networks of degree K, and (C) Scale Free (SF) networks of average degree c and decay exponent γ = 3.0 generated as in[18].Each data point obtained by CoreHD is the over 96 instances of size N = 10 5 .The results of CI4 and the results of BPD are from[5].In BPD and CI4, at each iteration a fraction f of nodes are removed (with f = 0.01 for BPD and f = 0.001 for CI4, decreasing f does not improve the performance visibly), while in CoreHD nodes are removed one by one.

TABLE I .
[5]parative results of the CoreHD method with CI and the BPD algorithm on a set of real-world network instances.N and M are the number of nodes and links of each network, respectively.The number of nodes deleted by CI, CoreHD, and BPD are listed in the 4th, 5th, and 6th column.The CI and BPD results are from[5].The time (seconds) for dismantling is the running time of algorithms, i.e. with time for reading network from the data file excluded.