Dense subgraph mining, that is, finding vertices cohesively connected by internal edges, is an important issue in graph mining. In the literature, many dense subgraph notions have been formalized , e.g., clique, quasi-clique, -core, -truss, -plex and -club. Meanwhile, a large number of dense subgraph mining algorithms have also been proposed.
In many real-world scenarios, a graph often contains various types of edges, which represent various types of relationships between entities. For example, in biological networks, interactions between genes can be detected by different methods ; in social networks, users can interact through different social media . In  and , such a graph with multiple types of edges is modelled as a multi-layer graph, where each layer independently accommodates a certain type of edges.
Finding dense subgraphs on multi-layer graphs has witnessed many real-world applications.
Application 1 (Biological Module Discovery). In biological networks, densely connected vertices (genes or proteins), also known as biological modules, play an important role in detecting protein complexes and co-expression clusters . Due to data noise, there often exist a number of spurious biological interactions (edges), so a group of vertices only cohesively connected by interactions detected by a certain method may not be a convincing biological module. To filter out the effects of spurious interactions and make the detected modules more reliable, biologists detect interactions using multiple methods, i.e., build a multi-layer biological network, where each layer contains interactions detected by a certain method. A set of vertices is regarded as a reliable biological module if they are simultaneously densely connected on multiple layers .
Application 2 (Story Identification in Social Media.) Social media, such as Twitter and Facebook, is updating with numerous new posts every day. A story in a social media is an event capturing popular attention recently 
. Stories can be identified by leveraging some real-world entities involved them, such as people, locations, companies and products. To identify them, scientists often abstract all new posts at each moment as a snapshot graph, where each vertex represents an entity and each edge links two entities if they frequently occur together in these new posts, and maintain a number of snapshot graphs in a time window. After that, each story can be identified by finding a group of strongly associated entities on multiple snapshot graphs. Obviously, this is an instance of finding dense subgraphs on multi-layer graphs.
Different from dense subgraph mining on single-layer graphs, dense subgraphs on multi-layer graphs must be evaluated by the following two orthogonal metrics: 1) Density: The interconnections between the vertices must be sufficiently dense on some individual layers. 2) Support: The vertices must be densely connected on a sufficiently large number of layers.
In the literature, the most representative and widely used notion of dense subgraphs on multi-layer graphs is cross-graph quasi-clique [4, 11, 19]. On a single-layer graph, a vertex set is a -quasi-clique if each vertex in is adjacent to at least vertices in , where . Given a set of graphs with the same vertices (i.e., layers in our terminology) and , a vertex set is a cross-graph quasi-clique if is a -quasi-clique on all of . Although the cross-graph quasi-clique notion considers both density and support, it has several limitations:
1) A single cross-graph quasi-clique only characterizes a microscopic cluster. Finding all cross-graph quasi-cliques is computationally hard and is not scalable to large graphs .
2) The diameter of a cross-graph quasi-clique is often very small. As proved in , the diameter of a cross-graph quasi-clique is at most if . Therefore, the quasi-clique-based methods face the following dilemma: When is large, some large-scale dense subgraphs may be lost; When is small, some sparsely connected subgraphs may be falsely recognized as dense subgraphs. For example, in the -layer graph in Fig. 1, the vertex set naturally induces a dense subgraph on all layers. However, in terms of cross-graph quasi-clique, if , is missing from the result; If , the sparsely connected vertex set is recognized as a cross-graph quasi-clique.
Hence, there naturally arises the first question:
Q1: What is a better notion of dense subgraphs on multi-layer graphs, which can avoid the limitations of cross-graph quasi-cliques?
Additionally, as discovered in , dense subgraphs on multi-layer graphs have significant overlaps. For practical usage, it is better to output a small subset of diversified dense subgraphs with little overlaps. Ref.  proposed an algorithm to find diversified cross-graph quasi-cliques. One of our goal in this paper is to find dense subgraphs on even larger multi-layer graphs. There will be even more dense subgraphs, so the problem of finding diversified dense subgraphs will be more critical. Hence, we face the second question:
Q2: How to design efficient algorithms to find diversified dense subgraphs according to the new notion?
To deal with the first question Q1, we present a new notion called -coherent core (-CC for short) to characterize dense subgraphs on multi-layer graphs. It is extended from the -core notion on single-layer graphs . Specifically, given a multi-layer graph , a subset of layers of and , the -CC with respect to (w.r.t. for short) is the maximal vertex subset such that each vertex in is adjacent to at least vertices in on all layers in . The -CC w.r.t. is unique. The -CC notion is a natural fusion of density and support. It has the following advantages:
1) There is no limit on the diameter of a -CC, and a -CC often consists of a large number of densely connected vertices. Our experiments show that a -CC can cover a large amount of cross-graph quasi-cliques.
2) A -CC can be computed in linear time in the graph size.
3) The -CC notion inherits the hierarchy property of -core: The -CC w.r.t. is a subset of the -CC w.r.t. ; The -CC w.r.t. is a subset of the -CC w.r.t. if .
The -CC notion overcomes the limitations of cross-graph quasi-cliques. Based on this notion, we formalize the diversified coherent core search (DCCS) problem that finds dense subgraphs on multi-layer graphs with little overlaps: Given a multi-layer graph , a minimum degree threshold , a minimum support threshold , and the number of -CCs to be detected, the DCCS problem finds most diversified -CCs recurring on at least layers of . As in [2, 4], we assess the diversity of the discovered -CCs by the number of vertices they cover and try to maximize the diversity of these -CCs. We prove that the DCCS problem is NP-complete.
To deal with the second question Q2, we propose a series of approximation algorithms for the DCCS problem. First, we propose a simple greedy algorithm, which finds -CCs in a greedy manner. The algorithm have an approximation ratio of . However, it must compute all candidate -CCs and therefore is not scalable to large multi-layer graphs.
To prune unpromising candidate -CCs early and improve efficiency, we propose two search algorithms, namely the bottom-up search algorithm and the top-down search algorithm. In both algorithms, the process of generating candidate -CCs and the process of updating diversified -CCs interact with each other. Many -CCs that are unpromising to appear in the final results are pruned in early stage. The bottom-up and top-down algorithms adopt different search strategies. In practice, the bottom-up algorithm is preferable if , and the top-down algorithm is preferable if , where is the number of layers. Both of the algorithms have an approximation ratio of .
We conducted extensive experiments on a variety of datasets to evaluate the proposed algorithms and obtain the following results: 1) The bottom-up and top-down algorithms are – orders of magnitude faster than the greedy algorithm for small and large , respectively. 2) The practical approximation quality of the bottom-up and top-down algorithms is comparable to that of the greedy algorithm. 3) Our DCCS algorithms outperform the quasi-clique-based dense subgraph mining algorithm  on multi-layer graphs in terms of both execution time and result quality.
Ii Problem Definition
Multi-Layer Graphs. A multi-layer graph is a set of graphs , where is the number of layers, and is the graph on layer . Without loss of generality, we assume that contain the same set of vertices because if a vertex is missing from layer , we can add it to as an isolated vertex. Hence, a multi-layer graph can be equivalently represented by , where is the universal vertex set, and is the edge set of .
Let and be the vertex and the edge set of graph , respectively. For a vertex , let be the set of neighbors of in , and let be the degree of in . The subgraph of induced by a vertex subset is , where is the set of edges with both endpoints in .
Given a multi-layer graph , let be the number of layers of , the vertex set of , and the edge set of the graph on layer . The multi-layer subgraph of induced by a vertex subset is , where is the set of edges in with both endpoints in .
d-Coherent Cores. We define the notion of -coherent core (-CC) on a multi-layer graph by extending the -core notion on a single-layer graph . A graph is -dense if for all , where . The -core of graph , denoted by , is the maximal subset such that is -dense. As stated in , is unique, and for .
For ease of notation, let , where . Let be a multi-layer graph and be a non-empty subset of layer numbers. For , the induced subgraph is -dense w.r.t. if is -dense for all . The -coherent core (-CC) of w.r.t. , denoted by , is the maximal subset such that is -dense w.r.t. . Similar to -core, the concept of -CC has the following properties.
Property 1 (Uniqueness)
Given a multi-layer graph and a subset , is unique for .
Property 2 (Hierarchy)
Given a multi-layer graph and a subset , we have for .
Property 3 (Containment)
Given a multi-layer graph and two subsets , if , we have for .
Note: We put all proofs in Appendix A.
Problem Statement. Given a multi-layer graph , a minimum degree threshold and a minimum support threshold , let be the set of -CCs of w.r.t. all subsets such that . When is large, is often very large, and a large number of -CCs in significantly overlap with each other. For practical usage, it is better to output diversified -CCs with little overlaps, where is a number specified by users. Like [2, 4], we assess the diversity of the discovered -CCs by the number of vertices they cover and try to maximize the diversity of these -CCs. Let the cover set of a collection of sets be . We formally define the Diversified Coherent Core Search (DCCS) problem as follows.
Given a multi-layer graph , a minimum degree threshold , a minimum support threshold and the number of -CCs to be discovered, find the subset such that 1) ; and 2) is maximized. The -CCs in are called the top- diversified -CCs of on layers.
The DCCS problem is NP-complete.
Let , and . The top- diversified -CCs for the multi-layer graph in Fig. 1 is , where , and .
Iii Greedy Algorithm
A straightforward solution to the DCCS problem is to generate all candidate -CCs and select of them that cover the maximum number of vertices. However, the search space of all -combinations of -CCs is extremely large, so this method is intractable even for small multi-layer graphs. Alternatively, fast approximation algorithms with guaranteed performance may be more preferable. In this section, we propose a simple greedy algorithm with an approximation ratio of .
Before describing the algorithm, we present the following lemma based on Property 3. The lemma enables us to remove irrelevant vertices early.
Lemma 1 (Intersection Bound)
Given a multi-layer graph and two subsets , we have for .
The Greedy Algorithm. The greedy algorithm GD-DCCS is described in Fig. 2. The input is a multi-layer graph and . GD-DCCS works as follows. Line 1 initializes both the -CC collection and the result set to be . Lines 2–3 compute the -core on each layer by the algorithm in . By definition, we have .
For each with , to find , we first compute the intersection (line 5). By Lemma 1, we have . Thus, we compute on the induced subgraph instead of on by Procedure dCC (line 6) and add to (line 7). Procedure dCC follows the similar procedure of computing the -core on a single-layer graph . Whenever there exists a vertex such that on some layer , is removed from all layers of . Due to space limits, we describe the implementation details of dCC in Appendix B.
Next, lines 8–10 select -CCs from in a greedy manner. In each time, we pick up the -CC that maximizes , add to (line 9) and remove from (line 10). Finally, is output as the result (line 11).
Let , and . Procedure dCC in line 6 runs in time as shown in Appendix B. Line 9 runs in time since computing takes time for each . In addition, . Therefore, the time complexity of GD-DCCS is , and the space complexity is .
The approximation ratio of GD-DCCS is .
Limitations. As verified by the experimental results in Section VI, GD-DCCS is not scalable to very large multi-layer graphs. This is due to the following reasons: 1) GD-DCCS must keep all candidate -CCs in . As increases, grows exponentially. When can not fit in main memory, the algorithm incurs large amounts of I/Os. 2) The exponential growth in significantly increases the running time of selecting diversified -CCs from (lines 8–10 of GD-DCCS). 3) The phase of candidate -CC generation (lines 1–7) and the phase of diversified -CC selection (lines 8–10) are separate. There is no guidance on candidate generation, so many unpromising candidate -CCs are generated in vain.
Iv Bottom-Up Algorithm
This section proposes a bottom-up approach to the DCCS problem. In this approach, the candidate -CC generation and the top- diversified -CC selection phases are interleaved. On one hand, we maintain a set of temporary top- diversified -CCs and use each newly generated -CC to update them. On the other hand, we guide candidate -CC generation by the temporary top- diversified -CCs.
In addition, candidate -CCs are generated in a bottom-up manner. Like the frequent pattern mining algorithm , we organize all -CCs by a search tree and search candidate -CCs on the search tree. The bottom-up -CC generation has the following advantage: If the -CC w.r.t. subset is unlikely to improve the quality of the temporary top- diversified -CCs, the -CCs w.r.t. all such that and need not be generated. As verified by the experimental results in Section VI, the bottom-up approach reduces the search space by 80%–90% in comparison with the greedy algorithm and thus saves large amount of time. Moreover, the bottom-up DCCS algorithm attains an approximation ratio of .
Iv-a Maintenance of Top-k Diversified d-CCs
Let be a set of temporary top- diversified -CCs. In the beginning, . To improve the quality of , we try to update whenever we find a new candidate -CC . In particular, we update with by one of the following rules:
Rule 1: If , is added to .
Rule 2: For , let , that is, is vertex set in exclusively covered by . Let , that is, exclusively covers the least number of vertices among all -CCs in . We replace with if and
On input and , Procedure Update tries to update with using the rules above. The details of Update is described in Appendix C. By using two index structures, Update runs in time.
Iv-B Bottom-Up Candidate Generation
Candidate -CCs with are generated in a bottom-up fashion. As shown in Fig. 6, all -CCs are conceptually organized by a search tree, in which is the parent of if , and the only number satisfies , where is the largest number in (specially, ). Conceptually, the root of the search tree is .
The -CCs in the search tree are generated in a depth-first order. First, we generate the -core on each single layer . By definition, we have . Then, starting from , we generate the descendants of . The depth-first search is realized by recursive Procedure BU-Gen in Fig. 3. In general, given a -CC as input, we first expand by adding a layer number such that . Let . By Lemma 1, we have . Thus, we compute on the induced subgraph by Procedure dCC described in Section III. Next, we process according to the following cases:
Case 1: If , we update with .
Case 2: If and , we recursively call BU-Gen to generate the descendants of .
Case 3: If and , we check if satisfies Eq. (1) to update . If not satisfied, none of the descendants of is qualified to be a candidate, so we prune the entire subtree rooted at ; otherwise, we recursively call BU-Gen to generate the descendants of . The correctness is guaranteed by the following lemma.
Lemma 2 (Search Tree Pruning)
To further improve efficiency, if , we order the layer numbers in decreasing order of and generate according to this order of . For some , if , we can stop searching the subtrees rooted at and for all succeeding in the order. The correctness is ensured by the following lemma.
Lemma 3 (Order-based Pruning)
For a -CC and , if , then cannot satisfy Eq. (1).
Another optimization technique is called layer pruning. For , if and does not satisfy Eq. (1), we need not generate for all such that . The correctness is guaranteed by the following lemma.
Lemma 4 (Layer Pruning)
Fig. 3 describes the pseudocode of Procedure BU-Gen, which naturally follows the steps presented above. Here, we make a few necessary remarks. The input is the set of layer numbers that cannot be used to expand . They are obtained according to Lemma 4 when generating the ascendants of . Thus, the layer numbers possible to be added to are (line 1). In BU-Gen, we use set to record the layer numbers that can actually be added to (lines 9 and 22). In lines 24–26, for each , we make a recursive call to BU-Gen to generate the descendants of . By Lemma 4, the layer numbers that cannot be added to are .
Iv-C Bottom-Up Algorithm
Fig. 7 describes the complete bottom-up DCCS algorithm BU-DCCS. Given a multi-layer graph and three parameters , we can solve the DCCS problem by calling BU-Gen (line 10). To further speed up the algorithm, we propose three preprocessing methods.
Vertex Deletion. Let denote the support number of layers such that , where . If , must not be contained in any -CCs with . Therefore, we can safely remove all these vertices from and recompute the -cores of all layers. This process is repeated until for all remaining vertices in . Lines 1–7 of BU-DCCS describe this preprocessing method.
Sorting Layers. We sort the layers of in descending order of , where . Intuitively, the larger is, the more likely contains a large candidate -CC. Although there is no theoretical guarantee on the effectiveness of this preprocessing method, it is indeed effective in practice. Line 9 of BU-DCCS applies this preprocessing method.
Initialization of . The pruning techniques in BU-Gen are not applicable unless , so a good initial state of can greatly enhance pruning power. We develop a greedy procedure InitTopK to initialize so that . Due to space limits, the details of Procedure InitTopK is described in Appendix D. Line 8 of BU-DCCS initializes by Procedure InitTopK.
The approximation ratio of BU-DCCS is .
V Top-Down Algorithm
The bottom-up algorithm must traverse a search tree from the root down to level . When , the efficiency of the algorithm degrades significantly. As verified by the experiments in Section VI, the performance of the bottom-up algorithm is close to or even worse than the greedy algorithm when . To handle this problem, we propose a top-down approach for the DCCS problem when .
In this section, we assume . In the top-down algorithm, we maintain a temporary top- result set and update it in the same way as in the bottom-up algorithm. However, candidate -CCs are generated in a top-down manner. The reverse in search direction makes the techniques in the bottom-up algorithm no longer suitable. Therefore, we propose a new candidate -CC generation method and a series of new pruning techniques suitable for top-down search. The top-down algorithm attains an approximation ratio of . As verified by the experiments in Section VI, the top-down algorithm is superior to the other algorithms when .
V-A Top-Down Candidate Generation
We first introduce how to generate -CCs in a top-down manner. In the top-down algorithm, all -CCs are conceptually organized as a search tree as illustrated in Fig. 6, where is the parent of if , and the only layer number satisfies . Except the root , all -CCs in the search tree has a unique parent. We generate candidate -CCs by depth-first searching the tree from the root down to level and update the temporary result set during search.
Let be the -CC currently visited in DFS, where . We must generate the children of . By Property 3 of -CCs, we have for all . Thus, to generate , we only have to add some vertices to but need not to delete any vertex from .
To this end, we associate with a vertex set . must contain vertices in all descendants of such that . serves as the scope for searching for the descendants of . We call the potential vertex set w.r.t. . Obviously, we have . Initially, . Section V-B will describe how to shrink to for , so we have if . The relationships between , , and are illustrated in Fig. 6. The arrows in Fig. 6 indicates that is expanded from , and is shrunk from . Keeping this in mind, we focus on top-down candidate generation in this subsection. Sections V-B and V-C will describe how to compute and , respectively.
The top-down candidate -CC generation is implemented by the recursive procedure TD-Gen in Fig. 8. Let be the set of layer numbers possible to be removed from (line 1). For each , let . We have that is a child of . We first obtain and by the methods in Section V-B (line 4) and Section V-C (line 5), respectively. Next, we process based on the following cases:
Case 1 (lines 9–10): If and , we update with by Rule 1 specified in Section IV-A.
Case 2 (lines 11–12): If and , we recursively call TD-Gen to generate the descendants of .
Case 3 (lines 20–21): If and , we update with by Rule 2 specified in Section IV-A.
Case 4 (lines 22–29): If and , we check if satisfies Eq. (1) to update (line 23). If it is not satisfied, none of the descendants of is qualified to be a candidate -CC, so we prune the entire subtree rooted at . Otherwise, we recursively call TD-Gen to generate the descendants of (line 29). The correctness of the pruning method is guaranteed by the following lemma.
Lemma 5 (Search Tree Pruning)
To make top-down candidate -CC generation even faster, we further propose some methods to prune the search tree.
If (Cases 3 and 4), we order the layer numbers in descending order of (line 14). For some , if , we need not to consider all layer numbers in succeeding and can terminate searching the subtrees rooted at immediately (lines 17–18). The correctness of this pruning method is ensured by the following lemma.
Lemma 6 (Order-based Pruning)
For a -CC , its potential vertex set and , if , any descendant of cannot satisfy Eq. (1).
More interestingly, for Case 4, in some optimistic cases, we need not to search the descendants of . Instead, we can randomly select a descendant of