# Enumerating Isolated Cliques in Temporal Networks

- 1 Citations
- 1.9k Downloads

## Abstract

Isolation is a concept from the world of clique enumeration that is mostly used to model communities that do not have much contact to the outside world. Herein, a clique is considered *isolated* if it has few edges connecting it to the rest Motivated by recent work on enumerating cliques in temporal networks, we bring the isolation concept to this setting. We discover that the addition of the time dimension leads to six distinct natural isolation concepts. Our main contribution is the development of fixed-parameter enumeration algorithms for five of these six clique types employing the parameter “degree of isolation”. On the empirical side, we implement and test these algorithms on (temporal) social network data, obtaining encouraging preliminary results.

## Keywords

Community detection Dense subgraphs Social network analysis Time-evolving data Fixed-parameter tractability## 1 Introduction

Clique detection and enumeration is a fundamental primitive of complex network analysis. In particular, there are numerous approaches (both from a more theory-based and from a more heuristic side) for listing all maximal cliques (that is, fully-connected subgraphs) in a graph.“Isolation is the one sure way to human happiness.” – Glenn Gould

^{1}It is well-known that finding a maximum-cardinality clique is computationally hard (NP-hard, hard in the approximation sense and hard when parameterized by the clique cardinality). Hence, heuristic approaches usually govern computational approaches to clique finding and enumeration. There have been numerous efforts to provide both theoretical guarantees and practically useful algorithms [4, 9, 10, 11]. In particular, to simplify (in a computational sense) the task on the one hand and to enumerate more meaningful maximal cliques (for specific application contexts) on the other hand, Ito and Iwama [10] introduced and investigated the enumeration of maximal cliques that are “isolated”. Roughly speaking, isolation means that the connection of the maximal clique to the rest of the graph is limited, that is, there are few edges with one endpoint in the clique and one endpoint outside the clique; indeed, the degree of isolation can be controlled by choosing specific values of a corresponding isolation parameter. For instance, think of social networks where one wants to spot more or less segregated sub-communities with little interaction to the world outside but intensive interaction inside the community. We mention in passing that, recently, there have been (only) theoretical studies on the concept of “secludedness” [2, 3] which is somewhat similar to the older isolation concept: whereas for isolation one requests “few outgoing edges”, for secludedness one asks for “few outneighbors”; while finding isolated cliques becomes tractable [10], finding secluded ones remains computationally hard [2].

Ito and Iwama [10] showed that in static networks isolated cliques often can be enumerated efficiently; the only exponential factor in the running time depends on the “isolation parameter”, and so fairly isolated cliques can be enumerated quite quickly. In follow-up work, the isolation concept then was significantly extended and more thorough experimental studies (also with financial networks) have been performed [9, 11]. However, analyzing complex networks more and more means studying time-evolving networks. Hence, computational problems known from static networks also need to be solved on temporal networks (mathematically, these are graphs with fixed vertex set but a time-dependent edge set) [8, 12, 13, 14]. Thus, not surprisingly, the enumeration of maximal cliques has recently been brought to the temporal setting [1, 7, 15, 16]. While becoming algorithmically more challenging than in the static network case, nevertheless the empirical results that have been achieved are encouraging. In this work, we now fill a gap by proposing to bring also the isolation concept to the temporal clique enumeration context, otherwise using the same modeling of temporal cliques as in previous work.

We focus on two basic isolation concepts described by Komusiewicz et al. [11] for the static setting. More specifically, we consider “maximal isolation” (every vertex has small outdegree) and “average isolation” (vertices have small outdegree on average). We face a much richer modeling than in the static case since isolation can happen in two “dimensions”: vertices and time; for both we can consider maximum and average isolation. With this distinction, we end up with eight natural ways to model isolation, where two “pairs” of isolation models turn out to be equivalent, finally leaving six different temporal isolation concepts for further study.

Our main contributions are as follows: First, as indicated above, we identify six mathematically formalized concepts of isolation for temporal networks. Second, building on and extending the algorithmic framework of Komusiewicz et al. [11] for static networks, for small isolation values we provide efficient algorithms for five of our six isolated clique enumeration models and prove worst-case performance bounds for them.^{2} In this context, a main algorithmic contribution is the development of tailored subroutines (that are only partially shared between different isolation concepts). Finally, on the empirical side we contribute an encouraging first experimental analysis of our algorithms based on social network data. Our preliminary experiments indicate differences (mostly in terms of running time) but also (sometimes surprising) accordances between the concepts.

## 2 Preliminaries

In this section, we provide some basic notation and terminology, recall the isolation concepts for static graphs, and transfer them to temporal graphs.

*Static Graphs.* Graphs in this paper are assumed to be undirected and simple. To clearly distinguish them from temporal graphs, they are sometimes referred to as *static* graphs. Let \(G=(V,E)\) be a static graph. We denote the vertex set of *G* with *V*(*G*) and the edge set of *G* with *E*(*G*). For \(v \in V(G)\) we use \(\deg _G(v)\) for the number of edges ending at *v*. For \(v \in A \subseteq V\), Open image in new window denotes the number of edges with one endpoint *v* and the other one outside of *A*. We further use Open image in new window and \(\delta _G(A) := \min _{v \in A} \deg _G(v)\). In all these notations, we omit the index *G* if there is no ambiguity.

*Temporal Graphs and Temporal Cliques.* A *temporal graph* is a tuple Open image in new window of a vertex set *V* and \(\tau \) edge sets \(E_i \subseteq \left( {\begin{array}{c}V\\ 2\end{array}}\right) \). The graphs \(G_i := \left( V, E_i \right) \) are called the *layers* of Open image in new window. The *time edge set* Open image in new window (or Open image in new window if Open image in new window is clear from the context) is the disjoint union \(\bigsqcup _{t=1}^\tau E_i\) of the edge sets of the layers of Open image in new window. For any \(1 \le a \le b \le \tau \) we define the (static) graphs \(\bigcup _{t=a}^b G_t := \left( V, \bigcup _{t=a}^b E_t\right) \) and \(\bigcap _{t=a}^b G_t := \left( V, \bigcap _{t=a}^b E_t\right) \).

Following the definition of Viard et al. [15], a \(\varDelta \)*-clique* (for some Open image in new window) of Open image in new window is a tuple (*C*, [*a*, *b*]) with \(C \subseteq V\) and \(1 \le a \le b \le \tau \) such that *C* is a clique in \(\bigcup _{i=t}^{t+\varDelta }G_i\) for all \(t \in [a, b - \varDelta ]\).

One easily observes that (*C*, [*a*, *b*]) is a \(\varDelta \)-clique in Open image in new window if and only if \((C, [a, b-\varDelta ])\) is a 0-clique in Open image in new window where \(E'_i := \bigcup _{t=i}^{i+\varDelta } E_t\). Due to this, in our theoretical results we will only concern ourselves with \(\varDelta = 0\) and simply refer to 0-cliques as *temporal cliques*.

*Temporal Isolation.* We first introduce the isolation concepts for static graphs and then describe how we transfer them to the temporal setting. In a (static) graph *G*, a clique \(C \subseteq V(G)\) is called *avg-**c**-isolated* if Open image in new window where Open image in new window is some positive number [10]. Further, it is called *max-c-isolated* if Open image in new window. Clearly max-*c*-isolation implies avg-*c*-isolation.

Moving to temporal graphs, we aim at defining an isolation concept for temporal cliques. Recall that a temporal clique consist of a vertex set and a time interval. We apply the isolation requirement both on a vertex and on a time level, meaning that for each dimension we can either require the average outdegree (as for static avg-*c*-isolation) or the maximum outdegree (as for static max-*c*-isolation) to be small. To make this more clear, we next provide some examples. For instance, we can require that, on average over all layers, the maximum outdegree in a layer is small. Or we can require that the average outdegree must be small in every single layer. Note that the ordering of the requirements for the time dimension and the vertex dimension also matters. Requiring the average outdegree to be small in every layer is different from requiring that, on average over all vertices, the maximum degree over all time steps must be small. Having two isolation requirements (avg and max) for two dimensions with two possible orderings, we arrive at eight canonical temporal isolation types. However it turns out that if we use the same requirement for both dimensions, they behave commutatively, so it boils down to six *different* temporal isolation types. In the following, we give a formal definition for each of the six temporal isolation types. To make the names less confusing, we use “usually” to refer to the avg isolation requirement in the time dimension and “alltime” to refer to the max isolation requirement in the time dimension.

### Definition 1

**(Temporal Isolation).**

*Let*Open image in new window.

*A temporal clique*(

*C*, [

*a*,

*b*])

*in a temporal graph*Open image in new window

*is called*

We define the set of *isolation types* as
Open image in new window
.

For all isolation types Open image in new window, an *I*-*c*-isolated temporal clique (*C*, [*a*, *b*]) is called *time-maximal* if there is no other *I*-*c*-isolated clique \((C', [a', b'])\) with \(C' \supseteq C\) and \([a', b'] \supset [a, b]\). If there is no *I*-*c*-isolated temporal clique \((C', [a', b'])\) with \(C' \supset C\) and \([a', b'] \supseteq [a, b]\), then we call (*C*, [*a*, *b*]) *vertex-maximal*. We call (*C*, [*a*, *b*]) *maximal* if it is time-maximal and vertex-maximal.

Subsequently we give some intuition about the different isolation concepts. Note that for sufficiently small *c* they all converge to disallowing *any* outgoing edges. We start with the most restrictive and perhaps also most straightforward isolation type, that is, **alltime-max-isolation**. Here all vertices are required to have little or no outside contact at all times—think of a quarantined group. Slightly less restrictive is the notion of **avg-alltime-isolation**. Here it would be possible to have some distinguished “bridge” vertices inside the clique with relatively much outside contact, as long as most vertices never have many outgoing edges. If we reorder the terms, then we obtain **all-timeavg-isolation**. In contrast to the previous case, now the set of “bridge” vertices may be different at any point in time. A typical situation where this could occur is that there is a low bandwidth connection between the clique and the rest of the graph, only allowing a limited number of communications to occur at any given moment. The next isolation concept, **usually-max-isolation**, can be seen as allowing short bursts of activity, in which some or even all vertices have many outgoing edges, as long as the entire clique is isolated most of the time. Again, if we reorder the terms, then we get a less restrictive concept (**max-usually-isolation**). Here, the bursts of activity may happen at different times for different vertices. Finally, **usually-avg-isolation** is the least restrictive of these notions, only limiting the total number of outside contacts over all vertices and layers that are part of the temporal clique.

We can make the following observation about the relations between different types of isolation. It is easily checked using the definitions above.

### Observation 2

*C*in \(\bigcap _{t=a}^b G_t\), and any \(c > 0\):

Note that Observation 2 does not hold for *maximal* isolated temporal cliques: A maximal alltime-max-c-isolated clique is not necessarily a maximal usually-avg-c-isolated clique. In the full version, we prove several results that help to confine the search space of our algorithms. Here, we only mention the following two lemmata, which we will use in Sect. 3 to prove the correctness of our algorithm for the enumeration of avg-alltime-isolated cliques.

### Lemma 3

Let *G* be a static graph and let *C* be a clique in *G*. Then, any avg-*c*-isolated subset \(C' \subseteq C\) has size Open image in new window.

### Lemma 4

Let *C* be a clique and let \(C' \subseteq C\) be a maximal avg-*c*-isolated subset. Let \(\tilde{C} \subseteq C\) be the \(\delta (C) - c + 2\) vertices of minimal degrees. Then \(\tilde{C} \subseteq C'\).

## 3 Enumerating Maximal Isolated Temporal Cliques

We develop efficient algorithms to enumerate maximal isolated temporal cliques for five out of the six introduced temporal isolation concepts (all except usually-max).^{3} In this section, we focus on one case (avg-alltime) to present some of the key ideas. Our algorithms have *fixed-parameter tractable* (FPT) running times for the isolation parameter *c*, that is, for fixed *c*, the running time is a polynomial whose degree does not depend on *c*. The following theorem summarizes our main result. Its proof is partially given at the end of this section. The remainder, including the proof of the running times listed in Table 1, can be found in to the full version.

### Theorem 5

Let a temporal graph Open image in new window with \(\tau \) layers, an isolation type
Open image in new window
, and an isolation parameter Open image in new window be given. Then all maximal *I*-*c*-isolated temporal cliques in Open image in new window can be enumerated in FPT-time for the isolation parameter *c*. The specific running times depend on *I* and are given in Table 1.

Running time of our maximal isolated temporal clique enumeration algorithms for the different temporal isolation types.

alltime-avg | alltime-max | avg-alltime | max-usually | usually-avg |
---|---|---|---|---|

*I*-

*c*-isolated temporal clique (

*C*, [

*a*,

*b*]) is contained in some vertex-maximal

*c*-isolated clique \(C'\) of \(G_\cap := \bigcap _{t=a}^b G_t\) (by Observation 2). Algorithm 1 constitutes the top level algorithm. Here, we iterate over all possible time windows [

*a*,

*b*] and apply the so-called trimming procedure developed by Ito and Iwama [10] to \(G_\cap \) to obtain, for each so-called

*pivot vertex*

*v*, a set \(C_v \subseteq N[v]\) containing all avg-

*c*-isolated cliques of \(G_\cap \) that contain

*v*. Subsequently, we enumerate all maximal cliques within \(C_v\) and test each of them for maximal

*I*-

*c*-isolated subsets. For this step, we employ our theoretical results to quickly skip over irrelevant subsets. The details depend on the choice of

*I*, as does the strategy for the last step, that is, removing non-maximal elements from the result set. Remember that we have to pay attention to both, time- and vertex-maximality. For the latter we can, in most cases, utilize an idea by Komusiewicz et al. [11].

*Enumerating Isolated Subsets.* We now discuss the Open image in new window subroutine of Algorithm 1 (Line 11). While the details depend on the isolation type, there are two main flavors. For alltime-max-isolation and max-usually-isolation, it is possible to determine a single vertex that must be removed in order to obtain an isolated subset. By repeatedly doing so, one either reaches an isolated subset or the size threshold set by Lemma 3. In particular, each maximal clique contains at most one maximal isolated subset.

*Checking for Maximality.* We now informally discuss the Open image in new window subroutine of Algorithm 1 (Line 18). For a fully detailed description we refer to the full version. Note that, while each temporal clique (*C*, [*a*, *b*]) returned by Open image in new window is vertex-maximal within its respective set \(C_v\), it may be not vertex-maximal with regard to the entire graph. Moreover, we need to check for maximality with regard to cliques with a larger time window. The naïve approach of pairwise comparing all elements of the result set is feasible but inefficient. Instead, for alltime-max-isolation, alltime-avg-isolation, and avg-alltime-isolation it is sufficient to only check whether the time window can be extended in either direction, and whether a larger clique exists within the same time window (i.e., checking vertex-maximality). Except for the case of alltime-avg-isolation, the latter can again be implemented more efficiently than by using pairwise comparisons. We modify the maximality test developed by Komusiewicz et al. [11] which searches for cliques within the common neighborhood of *C* and then checks whether these can be used to build a larger isolated clique.

*Correctness.* We now show the correctness of our algorithm. We first prove that the Open image in new window function (Function 1) behaves as intended.

### Lemma 6

Let Open image in new window be a temporal graph, Open image in new window, and
Open image in new window
. Let *C* be a clique in \(G_\cap := \bigcap _{i=a}^b G_i\) and \(\delta = \delta _{G_\cap }(C)\). Then
Open image in new window
returns all maximal sets \(\tilde{C} \subseteq C \) such that \((\tilde{C}, [a, b])\) is *I*-*c*-isolated.

### Proof (for the case I = avg-alltime)

For the sake of brevity, we will simply write that some set \(X \subseteq C\) is, say, Open image in new window-isolated to denote that (*X*, [*a*, *b*]) is Open image in new window-isolated. Let Open image in new window and let Open image in new window be any maximal Open image in new window subset. Note that any subset of *C* is Open image in new window if and only if the same set was avg-*c*-isolated in a static graph where each vertex’ degree was set to \(\max _{i\in [a, b]} \deg _{G_i}(v)\). By applying Lemma 4 to this auxiliary graph, we see that \(\tilde{C}\) must contain \(C \setminus B\). Thus, we observe that the algorithm will eventually check \(\tilde{C}\). \(\square \)

The algorithms for the other isolation types and the corresponding proofs of correctness are part of the full version. Thus, we now have all the necessary pieces to prove the correctness of Algorithm 1.

### Proof

*(of Theorem* 5*).* The running time of Algorithm 1 is proven in the full version, as is the correctness of the Open image in new window subroutine. Thus it remains to show that the result set contains (at least) all maximal *I*-*c*-isolated temporal cliques. To this end, let (*C*, [*a*, *b*]) be any maximal *I*-*c*-isolated clique. Then, *C* is an avg-*c*-isolated clique in \(G_\cap = \bigcap _{a \le i \le b} G_i\) by Observation 2. Ito and Iwama [10] showed that we then have \(C \subseteq C_v\) where \(v \in C\) is of minimum degree. Further Open image in new window by Lemma 3. Thus, \(C \subseteq C'\) for some Open image in new window is added to the result set by Lemma 6. \(\square \)

## 4 Experimental Evaluation

In this section, we empirically evaluate the running times of our enumeration algorithms for maximal isolated \(\varDelta \)-cliques (Algorithm 1) on several real-world temporal graphs. In particular, we investigate the effect of different isolation concepts as well as different values for isolation parameter *c* and \(\varDelta \) (now allowing \(\varDelta > 0\), see the definition of \(\varDelta \)-cliques in Sect. 2) on the running time and on the number of cliques that are enumerated. We also draw some comparisons concerning running times to a state-of-the-art algorithm to enumerate maximal (non-isolated) \(\varDelta \)-cliques by Bentert et al. [1].

*Setup and Statistics.* We implemented our algorithms^{4} in Python 3.6.8 and carried out experiments on an Intel Xeon E5-1620 computer clocked at 3.6 GHz and with 64 GB RAM running Debian GNU/Linux 6.0. The given times refer to single-threaded computation. Bentert et al. [1] implemented their algorithm in Python 2.7.12.

For the sake of comparability we tested our implementation on four freely available data sets; however, due to space restrictions, we only present a subset of the results here. The remainder can be found in the full version.

The “highschool-2011” data set was also used by Bentert et al. [1].

*c*, where Open image in new window := 0.001 effectively requires complete isolation and 125 Open image in new window imposes little or no restriction. We chose our \(\varDelta \)-values in the same fashion as Bentert et al. [1]. In order to limit the influence of time scales in the data and to make running times comparable between instances, the chosen \(\varDelta \)-values of 0, \(5^3\), and \(5^5\) were scaled by Open image in new window, where

*L*is the temporal graph’s lifetime in seconds [7, Section 5.1].

*Experimental Results.*In Figs. 1 and 2 the number of maximal isolated \(\varDelta \)-cliques and the running time are plotted for each of the five isolation types and a range of isolation values

*c*. Missing values indicate that the respective instance exceeded the time limit of 1 h. In general, the different isolation types produce surprisingly similar outputs. This suggests that the degrees of the vertices forming an isolated \(\varDelta \)-clique are typically rather similar and remain constant over the lifetime of the clique. Unsurprisingly, raising the value of

*c*increases the number of maximal cliques as the isolation restriction is weakened. However, this effect ceases roughly at \(c =5\). Increasing

*c*further does not produce additional cliques, suggesting that the vertices in \(\varDelta \)-cliques we found in the data sets mostly have out-degree at most five. Furthermore, we can generally observe that the number of maximal cliques decreases with increasing values of \(\varDelta \), which might seem unexpected at first glance, but is a consequence from finding many small cliques (with few vertices as well as short time intervals) for small \(\varDelta \)-values that “merge together” for larger \(\varDelta \)-values. This behavior is consistent across all data sets we investigated.

Regarding running time, our algorithm is generally slower than the non-isolated clique enumeration algorithm by Bentert et al. [1], even for small values of *c*. For comparison, the algorithm by Bentert et al. [1] solved the “highschool-2011” instance for the same values for \(\varDelta \) that we considered in less than 10 seconds per instance, while we needed up to 20 min for \(\varDelta \)-values 0 and \(5^3\) and more than one hour for \(5^5\). We believe that the two main reasons for our algorithm to be slower are the following. On the one hand, the maximality check we perform is much more complicated than the one of the algorithm of Bentert et al. [1], which is an issue that also occurs in the static case [9, 11]. On the other hand, we have to explicitly interate through more or less all possible intervals in which we could find an isolated \(\varDelta \)-clique, which seems unavoidable in our setting. A particular consequence of this is that our algorithm is not *output-sensitive*, that is, the running time can be much larger than the number of maximal isolated \(\varDelta \)-cliques in the input graph. In the case of (non-isolated) \(\varDelta \)-clique enumeration, there are ways to circumvent these issues and in particular, the algorithm of Bentert et al. [1] is output-sensitive. Both algorithms have a similar running time behavior with respect to \(\varDelta \), that is, the running time increases with \(\varDelta \), once \(\varDelta \) reaches moderately large values. Since higher values of \(\varDelta \) create a more dense graph after the preprocessing step, this behavior is expected. The algorithm of Bentert et al. [1] is slow for very small values of \(\varDelta \) that are close to zero (compared to itself for larger values of \(\varDelta \)). We do not observe this phenomenon in most of our algorithms. In the variants for max-usually and usually-avg, however, we experience a similar issue for small values of *c*, especially visible in the “tij_pres_LH10” data set (Fig. 2), where the running time is surprisingly high for \(\varDelta =0\) and \(c=\varepsilon \). A possible explanation is that the “usually-variants” use a different maximality check than the “alltime-variants”. Interestingly, no universal trend can be observed for the running time taken per resulting clique with respect to *c*, which stands in contrast to our theoretical running time analysis.

## 5 Conclusion

We have brought the concept of isolation from the static to the temporal setting, introducing six different types of temporal isolation. For five out of those we developed algorithms and showed that enumerating maximal temporally isolated cliques is fixed-parameter tractable with respect to the isolation parameter. This leaves one case (usually-max-isolation) open for future research on computational complexity classification. As a rule of thumb, if there are no specific requests from the use case, we recommend to choose the alltime-max concept as a default, since overall it allowed for the fastest running times without huge differences in terms of enumerated maximal cliques.

From an algorithm engineering perspective there is still room for improvement. So far the practical running times make it hard to analyze larger data sets as done for example by Bentert et al. [1] in the “non-isolated” setting.

Finally, as in the static case, it would be natural to apply the isolation concepts to further community models such as for example temporal *k*-plexes [1, 11].

## Footnotes

- 1.
*Network*and*Graph*are used interchangeably. - 2.
In terms of the language of parameterized algorithmics, we show that these cases are fixed-parameter tractable when parameterized by isolation value.

- 3.
One may wonder why usually-max-isolation was dropped here. The answer is that, even though the same approach as for the other isolation concepts also works for usually-max-isolation, we found no way to limit the work that would be required in the Open image in new window subroutine significantly below \(\varOmega (2^n)\).

- 4.
The code of our implementation is freely available at https://www.akt.tu-berlin.de/menue/software/.

## Notes

### Acknowledgments

We want to thank our student assistant Fabian Jacobs for his work on the implementation of our algorithms and anonymous reviewers for helpful feedback.

## References

- 1.Bentert, M., Himmel, A.S., Molter, H., Morik, M., Niedermeier, R., Saitenmacher, R.: Listing all maximal \(k\)-plexes in temporal graphs. ACM J. Exp. Algorithm.
**24**(1), 1.13:1–1.13:27 (2019)MathSciNetGoogle Scholar - 2.van Bevern, R., Fluschnik, T., Mertzios, G.B., Molter, H., Sorge, M., Suchý, O.: The parameterized complexity of finding secluded solutions to some classical optimization problems on graphs. Discret. Optim.
**30**, 20–50 (2018)MathSciNetCrossRefGoogle Scholar - 3.Chechik, S., Johnson, M.P., Parter, M., Peleg, D.: Secluded connectivity problems. Algorithmica
**79**(3), 708–741 (2017)MathSciNetCrossRefGoogle Scholar - 4.Eppstein, D., Strash, D.: Listing all maximal cliques in large sparse real-world graphs. ACM J. Exp. Algorithm.
**18**, 1–3 (2013)zbMATHGoogle Scholar - 5.Fournet, J., Barrat, A.: Contact patterns among high school students. PLoS ONE
**9**(9), 1–17 (2014)CrossRefGoogle Scholar - 6.Génois, M., Barrat, A.: Can co-location be used as a proxy for face-to-face contacts? EPJ Data Sci.
**7**(1), 11 (2018)CrossRefGoogle Scholar - 7.Himmel, A.S., Molter, H., Niedermeier, R., Sorge, M.: Adapting the Bron-Kerbosch algorithm for enumerating maximal cliques in temporal graphs. Soc. Netw. Anal. Min.
**7**(1), 35:1–35:16 (2017)CrossRefGoogle Scholar - 8.Holme, P., Saramäki, J.: Temporal networks. Phys. Rep.
**519**(3), 97–125 (2012)CrossRefGoogle Scholar - 9.Hüffner, F., Komusiewicz, C., Moser, H., Niedermeier, R.: Isolation concepts for clique enumeration: comparison and computational experiments. Theor. Comput. Sci.
**410**(52), 5384–5397 (2009)MathSciNetCrossRefGoogle Scholar - 10.Ito, H., Iwama, K.: Enumeration of isolated cliques and pseudo-cliques. ACM Trans. Algorithms
**5**(4), 40:1–40:21 (2009)MathSciNetCrossRefGoogle Scholar - 11.Komusiewicz, C., Hüffner, F., Moser, H., Niedermeier, R.: Isolation concepts for efficiently enumerating dense subgraphs. Theor. Comput. Sci.
**410**(38–40), 3640–3654 (2009)MathSciNetCrossRefGoogle Scholar - 12.Latapy, M., Viard, T., Magnien, C.: Stream graphs and link streams for the modeling of interactions over time. Soc. Netw. Anal. Min.
**8**(1), 61 (2018)CrossRefGoogle Scholar - 13.Michail, O.: An introduction to temporal graphs: an algorithmic perspective. Internet Math.
**12**(4), 239–280 (2016)MathSciNetCrossRefGoogle Scholar - 14.Rossetti, G., Cazabet, R.: Community discovery in dynamic networks: a survey. ACM Comput. Surv.
**51**(2), 35 (2018)CrossRefGoogle Scholar - 15.Viard, T., Latapy, M., Magnien, C.: Computing maximal cliques in link streams. Theor. Comput. Sci.
**609**, 245–252 (2016)MathSciNetCrossRefGoogle Scholar - 16.Viard, T., Magnien, C., Latapy, M.: Enumerating maximal cliques in link streams with durations. Inf. Process. Lett.
**133**, 44–48 (2018)MathSciNetCrossRefGoogle Scholar