Are k-cores meaningful for temporal graph analysis?

Communities and dense substructures are one of the fundamental concepts in graph analysis, and the k-core is one of the most widely used models for its simplicity and effectiveness. As temporal graphs become more commonly available and larger, the algorithmic community is taking the fundamentals of static graph analysis and defining parallel concepts on temporal graphs. These adaptations, however, seem to follow the goal of being intuitive and concise, but there is yet to be a study showing whether they actually capture useful information in real temporal graphs. This is precisely what we aim to do in this paper: we look at several proposed definitions for the temporal k-core, aiming to assess whether their effectiveness matches that of the static counterpart. First, we unify several existing definitions of temporal k-core with a convenient general notation, and show a simple data structure to compute them efficiently. Then, taking inspiration from static graph analysis, we devise meaningful ways to aggregate and visualize information obtained from temporal k-cores: we show that indeed, temporal k-cores do uncover significant insights on both nodes and the dynamics of the network as a whole, which are not observable with static graph analysis.


INTRODUCTION
Networks are one of the fundamental models in informatics, as they can represent the structure of complex phenomena and their dynamics, and both their size and their availability has rapidly grown in the past two decades.
Graph-theoretical methods have been the main tool to analyse networks for a long time [3], and they become increasingly important as graphs pop up in basically most areas of data mining and optimization (traffic optimization, scheduling, recommendation systems...); one of the key tasks here is identifying communities and densely connected entities.
On the flip side, the complex nature of graphs makes it challenging to extract the vast amount of information they contain: the most strict model of community is the clique, a group of fully interconnected nodes, but finding the largest is NP-Complete [12] and listing all maximal cliques in a graph is #P-Complete [23].Relaxations of the clique have been proposed (e.g., -plex, -clique, -clan [8]), but they are harder rather than easier to mine [6].
In this scenario, a holy grail of graph analysis is the -core [20]: a structure which accurately identifies communities and connectivity in graphs [8,10,13], yet the time to compute all -cores in a network is only linear in its size.The -core model has been remarkably successful for a variety of tasks, such as identifying communities [8], as well as important nodes [22], producing graphical embeddings of large graphs [1,21], and even speeding up graph algorithms via parametrization [7] or pruning [6].
Recent years have seen a dramatic increase in the prominence of temporal graphs, a generalization where edges may freely disappear and reappear at a later time.This generalization is useful for representing linked structures that evolve in time such as network traffic, transactions, or social interactions.
With their popularity, new challenges are being tackled by the algorithmic and data mining communities: how do we adapt decades of graph-based concepts and algorithms to the temporal graph model?So far, significant effort has been devoted to find parallels: direct adaptations of classical graph concepts that feel natural on temporal graphs, such as cliques [11], Eulerian walks [19], plexes [5], and indeed -cores [9,16,24].
While these adaptations are elegant and present interesting properties, the focus has always been on what definition feels more natural, i.e., intuitive and clutterless, and not on what information we can actually get out of them.Focusing on the -core model, this is the direction we take in this paper.Specifically, we consider the following questions: (1) Can proposed adaptations of -cores extract meaningful data from temporal graphs?(2) Can we compute such adaptations efficiently?(3) How can this information be visualized?
We indeed find positive answers.We firstly unify some of the proposed generalizations of temporal -core with a unique general notation, showing they can be computed efficiently: for a temporal graph with  edges and  temporal snapshots, we show how to query -cores from any temporal window in  ( log ) time with simple data structures, rather than the naive  () time approach.
Secondly, we use temporal -cores to analyse several real-world temporal networks, varying the available parameters and considering both instant and aggregated data, drawing inspiration from techniques for static graph analysis, such as [22], to produce suitable visualizations.We show how this can help to highlight key information about the roles of nodes in a temporal network, as well as the dynamics of the network as a whole.
The rest of the paper is organized as follows: Section 2 introduces the notation and models of temporal -core proposed in the literature.Section 3.1 shows how to efficiently compute temporal -cores in our generalized framework.Section 3.2 describes the goals of our analysis and the methods that were employed for it.Finally, Section 4 describes our experimental dataset and shows the results obtained.

PRELIMINARIES AND RELATED WORK
Our work focuses on undirected temporal graphs, defined as a pair of vertices and temporal edges   = ( ,   ), where each edge {, ,  } is marked with a timestamp 1 ≤  ≤  and  is called the lifespan of   .When fixing a particular value  for the time  we retrieve the static graph   = ( ,   = {{,  } : {, , } ∈   }) that is called the -th snapshot of   ; thus,  actually denotes the total number of snapshots available for   .For any given snapshot   , we denote the neighborhood of node  as  () = { : {,  } ∈   }, and its degree  () = | ()|.We also use the shorthands  = | | and  = |  |; as nodes never incident to any edge are not of interest, we can discard them and assume  =  () 1 .
A -core in a static graph  = ( , ) is defined as an inclusionmaximal set of vertices  ⊆  in which all the vertices have at least  neighbors in 2 .Since there is only one -core for each  and for each connected component of a graph, -cores can be organized in a chain of inclusions, i.e.,   ⊆ • • • ⊆  1 ⊆  0 =  where   is the -core of the graph.Thanks to this structure, we can compute the core decomposition of a graph, which is the set { 1 ,  2 , . . .  } and sort the vertices according to the core to which they belong.This, in turn, allows us to compute the coreness of each vertex: Definition 1 (Coreness).The coreness (or core number) of a vertex  ∈  of a static graph  = ( , ) is the largest  for which  belongs to the -core of .
We obtain the coreness of each node directly from the -core decomposition of a graph, with well-known linear-time algorithms [17].In static graphs, the coreness captures the community structure of a network [2,8,18], and is a relevant importance score for its nodes [14,24], alongside ℎ-index and degree.The importance of coreness is also shown in [22] as its variation, compared to degree, accurately highlights outlier nodes.
Throughout the paper we will thus rely on coreness; however, since we are dealing with temporal graphs, we have to adapt the concept of -core to the temporal setting.It turns out that different generalizations are possible, depending on how temporal information is aggregated; we give an overview of existing models, and show a convenient unified representation that is able to capture each of them by tweaking its parameters.

Temporal k-core models
In recent years different formalizations of the concept of temporal -core have been proposed, and we briefly recap them below. 3The approach adopted by Galimberti et al. [9] is the one that looks for -cores in what we call the intersection of temporal snapshots, i.e., given a time window, any pair of vertices has to interact in every snapshot covered by the window.This leads us to the formal definition of span cores.
According to this definition, the authors of [9] consider valid only -cores that exist in all the snapshots contained in the given interval Δ, in a logical and fashion, i.e., every edge belonging to a core has to appear in every timestamp inside the window.This is especially useful in social networks analysis, where usually the links between any given pair of people last for long periods without interruptions.Naturally, the opposite or fashion can also be considered, this time requiring only 1 interaction in any given time window Δ.
In particular, Li et al. [16] proposed the following definition: Definition 3 ((, )-persistent core [16]).This definition is useful in call-log networks and email exchanges, or contexts that see sporadic interactions between nodes, as it considers the union of temporal edges within intervals of  snapshots.
A definition capturing the actual notion of union is the following: While this definition allows control over the temporal interval, it does not consider how many times two nodes interact in a time interval, one interaction is always enough.
Finally, another definition is given by Wu et al. [24], which considers a temporal graph as a multigraph (i.e., allows multiple edges between two nodes): Definition 5 ((, ℎ)-core [24]).In a temporal graph   , a (, ℎ)-core is a -core of the static graph The authors of [24] introduce the parameter ℎ, useful for modeling the strength of the connection, however their model does not allow to consider sub-intervals of the timeline or even the sequentiality of temporal information.
We believe that all these models are meaningful and well grounded, with each model considering different aspects of the data and extracting different information.
For this reason, we formalize a definition that encompasses all of these variables while staying reasonably simple, the (, ℎ, Δ)-core: Definition 6 ((, ℎ, Δ)-core).Given a temporal graph   = ( ,   ) two integers , ℎ ∈ N, and a window length Observe how Definition 6 is able to generalize the previously defined models: the intersection model of [9] is a (, Δ, Δ)-core, and while the model of [16] is not captured exactly (due to the interval maximality), we can see how the (, )-core implies the existence of a sequence of (, 1,  )-cores in   , so those communities are captured by Definition 6 as well.Finally, the (, ℎ)-core of [24] is also captured by Definition 6 as a (, ℎ, )-core (where, we recall,  is the lifespan of the temporal graph), and Definition 4 corresponds to the (, 1, Δ)-core.We remark that we do not claim that Definition 6 is superior to the others, but simply that by varying its parameters we can identify the same communities.
Finally recall, as previously motivated, that we will not focus on -cores themselves but rather on the coreness of each vertex.

METHODOLOGY 3.1 Algorithmic methods
In order to compute the coreness of each node in a given temporal graph, we first have to group together the snapshots according to some criteria: this task would cost  () time if done on an on-demaned basis.Therefore we exploit a heap-like tree data structure, where each leaf contains a snapshot, and every internal node contains the intermediate result of the grouping operation (union, intersection, or ℎ-union) of its two children (we allow the existence of unary nodes containing just a copy of their child).The tree is built in a bottom-up fashion: we represent it implicitly with an array, of length linear in , that will be traversed according to the usual heap operations (  , ℎ, ).First we put each single snapshot in the second half of the array, so to fill the last level of the tree; then, starting from the middle of the array we perform the grouping operation on the two children of the node we are currently on.Notice that the number of snapshots may not be a power of two and thus the tree would not be constructed in a proper way; to accomodate this we add some padding to the array in order to have a power of two as the number of leaves: this will possibly create some null leaves that will have to be handled accordingly, but it will greatly simplify the subsequent traversal of the tree.Eventually, the tree  will contain the following elements: to  2 ⌈log 2  ⌉+1 will contain an empty snapshot denoted by ∅.Building this tree and storing it will require  () time and space, and we provide a small graphical example of the resulting data structure in Figure 1.
(a) ∩-tree for (, Δ, Δ)-cores We are now ready to query the tree for obtaining any interval [, ] of the snapshots combined with the • operation of our choice, in  ( log ) time.To do so we use the procedure described in Algorithm 1: we iteratively traverse the tree from  to the root until we find an internal node covering the largest possible [,  ′ ≤ ], then repeat the process for [ ′ + 1, ] until all [, ] is covered; it is easily shown that at most two nodes from each level are selected, so as the tree is balanced the number of selected nodes is ≤ 2 log .
In the end, we simply need to perform the • operation between the  (log ) nodes selected this way, which takes  ( log ) time.Input: An implicit binary tree  , two integers , Having the merged graph we can then use the classical algorithm to compute the coreness of each vertex: we maintain a priority queue with all the vertices, then we repeatedly extract the vertex with the lowest degree and remove it from the graph, updating the degrees of its neighbors accordingly, until the queue is empty [4].The degree of a vertex at time of their removal is its coreness.

Analytic methods
An influential work from Shin, Eliassi-Rad and Faloutsos [22] showed how the coreness of a vertex is strongly correlated to its degree, i.e., if the degree of a vertex is high, then so is its coreness value.Whenever a node deviates from this expectation, we can safely assume that the involved node is an outlier and should be further analysed in order to discover what is going on in the network.This can be useful for many different reasons, like highlighting a follower exchange circle on Twitter, or spotting a copy-pasted bibliography in a network of citations and more.The method proposed by Shin et al. is straightforward: plot the coreness of every node against their degree and see the result; in a normal situation every point in the plot will find its spot near the bisecting line  = , resembling a stepped line chart (see Figure 2 for an example, the authors of [22] call this kind of plots as the Mirror Pattern).Whenever a node deviates from this, we are probably facing an abnormal event and if we have access to the metadata of the network, we can easily understand what is going on and why that specific node does not follow the expected trend of all other nodes.Our main goal is therefore the extension of this method to the context of temporal graphs, and to do so we adopted the following methodology: (1) Group snapshots according to Def. 6 with different ℎ, (2) Compute degree 5 and coreness of each vertex, for each window of fixed size Δ, (3) Plot and analyse the results.While with static graphs it is sufficient to plot the coreness against the degree of every node, with temporal graphs we would have to look at  − Δ + 1 plots and spot any node behaving in an unexpected way, therefore we adopted different kinds of plots, including: (a) Degree for each node, by Δ-window, (b) Coreness for each node, by Δ-window, (c) Coreness-vs-degree for each node, by Δ-window, (d) √︁ coreness • degree (RCD) for each node, in each window of fixed size Δ, (e) Average of √︁ coreness • degree (ARCD) among all windows of size Δ for each node, plotting the values for varying window size 6 .This will be the most valuable tool in our analysis, referred to as the Temporal Resilience Plot.
We show examples of various plots but, due to space constraints, we focus more on the last type as it is able to summarize, in the least space, the behaviour of several parameters along the entire timeline.

EXPERIMENTAL ANALYSIS 4.1 Dataset and Environment
We performed our analysis on 6 temporal graphs of different sizes and types, from the SNAP repository [15]; Table 1 shows the total number of nodes and temporal edges, , and the maximum node degree and coreness among all snapshots.The graphs are provided as edge lists, each edge marked with a timestamp.To create a uniform environment among all graphs, we grouped edges by week, i.e., each   for each graph corresponds to the edges appearing in a consecutive 7-day interval; thus each graph spans 7 •  days.
Our experiments were carried on a dual-processor Intel Xeon Gold 5318Y Icelake @ 2.10GHz machine, with 48 physical cores each and 1TB of shared RAM, running Ubuntu Server 22.04 LTS, Intel C++ compiler icpx, version 2022.2.1.The results were gathered in the csv format later processed with Python 3.11 using common external libraries like Pandas, Numpy and Matplotlib.

Running time
While optimizing our implementation is outside the scope of this paper, Table 2 gives an overview of their efficiency, with the time required to build the data structure described in Section 3.1 for two aggregation functions (∩ and ∪), as well as the average time for computing a (, ℎ, Δ)-core decomposition.We can see how the onetime computing time for the tree is typically a second or less, yet it provides an important speedup to the computation of (, ℎ, Δ)cores, which becomes significant in the analysis where, for each graph, we need to compute hundreds or thousands of different windows.

Experimental Setup
We conducted all our experiments in a sliding window fashion, i.e., we fix a value for Δ and then perform the analysis scanning the lifespan of graphs with windows of size Δ, exploting the data structure described in Section 3.1.Specifically, we consider for Δ the  values Δ = 2 0 , 2 1 , 2 2 , . . ., 2 log 2 ⌊ −1⌋ ,  − 1.We also tested multiple values for the parameter ℎ, in what follows, for space concerns, we show results for ℎ = 1, Δ 2 , Δ as it coincisely shows its range, from the plain union (ℎ = 1) to the intersection of edges (ℎ = Δ), with the middle ground Δ 2 we recreated the mirror pattern [22] plots as a baseline static-graph-based method for comparison, then we analysed all degree and coreness plots to spot any major events and trends, and finally we plotted the RCD and ARCD of the datasets to summarize their behavior over time at different temporal resolutions.We cannot provide many degree/coreness plots of single snapshots due to space concerns as each network can have hundreads of them, therefore in what follows ARCD plots, i.e., the Temporal Resilience Plots defined in Section 3.2, will be our main tool of analysis, as they condense vast amount of information on the temporal evolution of a network at different resolutions simultaneosly, allowing us to coincisely show useful insights.

Results and Discussion
We first show the results obtained from a broader degree-vs-coreness analysis conducted according to the same principles of the Mirror Pattern analysis in [22], with parameters Δ =  and ℎ = 1, which basically corresponds to treating the whole temporal graph as a static graph, taking all the temporal edges (ignoring multiedges).Figure 3 shows the plots for 4 graphs in our dataset: from these figures we cannot extract proper information about the communities, nor about the behavior of the nodes during the lifespan of the graphs, except for the AS-733 graph (Figure 3d) where we can see that a small number of nodes stand out for their higher degree and relatively high core number.This static analysis provides us with a first insight into the AS-733 dataset that may highlight important nodes.However, the loss of temporal information does not allow us to understand fluctuations of behaviour, e.g., if communities are cohesive or just the result of aggregating different moments in time, or if the importance of a node is long-or short-lived.
Next, we discuss each graph in our dataset separately.
AS-733.This graph represents connections between autonomous systems from November 8, 1997 to January 2, 2000.We first plotted the degree for each node with a fixed window size of Δ = 2 and ℎ = Δ, i.e., performing the intersection of the edges in the windows (Figure 5a).We firstly observe how the degrees seem to grow in time, consistently with the rapid growth of the Internet around the turn of the century.It is also immediately evident that around window number 60 there is a brief but dramatic degree drop for most nodes, especially the ones of highest degree.From the data provided, this loss of connectivity happened around Christmas of 1998, and while we are not able to pinpoint a specific event that may have caused it, it is a clear example of temporal behaviour that would not emerge from a static view of the graph.On the other hand, this drop does not show as much in the coreness of the nodes in the same graph grouping, as shown in Figure 5b: while it is possible to distinguish the anomaly around window 60, there is no clear gap as several node maintain coreness values comparable to the rest of the timeline.Furthermore, Figure 5b does not seem to highlight any particularly meaningful pattern.
Let us thus consider the Temporal Resilience plots in Figure 4: each line corresponds to a node, and for each window size Δ ( axis) we plot the average RCD among all windows of size Δ.The plots consider different values of ℎ for computing the (, ℎ, Δ)-cores.
We can clearly identify three vertices standing out for their ARCD always above all of the other nodes: these nodes must act like a backbone to the autonomous system network and are resilient to the changes that happen, like the Christmas event, even if their degree dropped significantly.This is made even clearer by looking at the sequence of plots given by the values ℎ = 1, Δ 2 , 3Δ 4 , Δ, where we can see that the three topmost lines "survive" the increasing constraint given by the different ℎ values, while the others start approaching zero as soon as ℎ = Δ/2.This also visualizes the intuition and expectation that the connectivity of the nodes in any temporal graph decreases as we increase ℎ, i.e., when we require more and more interactions between any pair of nodes for a given window size.This also highlights something remarkable: while the high degrees in Figure 5a    could already suggest important nodes, the temporal resilience of Figure 4d (where ℎ = Δ means intersection is performed) highlights the fact that these node form consistently unbroken communities, as their coreness remains significant even when intersecting all windows, i.e., when Δ =  (right-most points in the lines).
With this temporal resilience plot we can also classify the nodes according to their falling point in the plot.Specifically, we assign classes based on the time their ARCD value drops to zero, as we enlarge the window size.We colored the ARCD plot according to the above classes obtaining Figure 6, from which we can see how the classes are well separated from each other, validating our hypotesis that some nodes are resilient to the process of enlarging the window size while keeping the value of ℎ high.It is worth noting that the classes become more distinguishable as the window size increases, whereas for small values of Δ it may happen that less-resilient nodes (i.e.their falling point comes earlier in the x-axis) have ARCD values higher than more-resilient ones, which we may expect due to smaller values being more susceptible to fluctuations.We can then conclude that in the AS-733 we can identify backbone nodes, that play a fundamental role in the network and are extremely robust in their mutual connections.Even more remarkably, Figure 6 shows that some of the most resilient nodes (colored green) can only be recognized over very wide windows: when considering small windows, their ARCD is surpassed by nodes of lower classes (orange and purple).This shows that important insight is missed if we don't analyse the dataset at different temporal resolutions.
Finally, observe the coreness/degree plot for the same dataset in Figure 3d: while we may identify important nodes, all of the other dynamics highlighted are not evident from it, which underlines the value of the analysis shown.The temporal resilience plot in Figure 7 shows how most of the nodes are not able to form lasting communities, even if we require them to interact just half of the time (ℎ = Δ/2).We do observe positive values of ARCD for Δ = 1, meaning connections and communities are created, but as soon as we enlarge Δ they quickly drop to 0 or almost 0 (the drop would of course be even steeper with higher values of ℎ).This behaviour is opposite to that of AS-733, and shows us that communities are not at all resilient but ephemeral.Remarkably, this is consistent with the functioning dynamics of the StackExchange system: questions are short-lived and recommended randomly, and there are no "friendship" or "follow" features, so we can expect random users to group briefly on a question and then not interact again.We can indeed see how the resilience plot captures this dynamic, and discriminates between this network and AS-733 better than the static plots of Figure 3.
To further highlight the volatility of these communities we can look at the Temporal Resilience plot for ℎ = 1 (i.e., union), in Figure 8.Here the ARCD values grow uniformly, so both the coreness and the degree increase as we include more snapshots into the windows, meaning people continuously interact with new random ones (differently, e.g., from the same plot for AS-733 in Figure 4a, where more stable interactions with the same nodes cause a slower growth).Bitcoin Networks.Bitcoin-alpha and bitcoin-otc are "who-trustswhom" network among Bitcoin users.We can observe here a volatile behaviour similar to StackExchange networks: looking at the ARCD distribution in Figure 9 we already see low maximum absolute values, that reach 0 very quickly as the window size increases.The ephemerality of communities is further underlined by the plot staying essentially the same even if we lower ℎ to Δ/2 (omitted for space).However, setting ℎ = 1 (union), shown in Figure 10, tells us something interesting: here we can observe two classes of nodes for both bitcoin networks, reminiscent of AS-733; few nodes starkly above all others, akin to "hubs" in terms of connectivity, then most nodes in the middle on a continuous scale of higher to lower connectivity.This analysis highlights a dynamic of the bitcoin trust networks that sees few very influential entities, while most people have several interactions over time but typically with new people, hence the absence of persistent communities.
Email-EU-core.This network shows email exchanges between members of a large European research institution.
The temporal resilience plot, shown for ℎ = Δ/2 in Figure 11, again uncovers interesting information: several nodes maintain high ARCD for the whole plot, thus forming a persistent community, but the others are not all immediately broken; it appears the network contains a mix of short-lasting, long-lasting and mediumlasting communities, as for each falling point in the graph we see a reasonably well-sized class of nodes.Although some nodes may simply correspond to employees on a short-term contract, this possibly suggests a dynamic structure of the research institute with frequent creation of projects of different size and duration.Again we observe how this trend could not be seen without careful consideration of temporal information (e.g., from Figure 3), and we remark the importance of the choice of ℎ (although we cannot include other values here for space).
Finally, we remark again how the falling points in the temporal resilience plot can provide a crisp clustering into classes of higher and lower connectivity nodes, marked by color in Figure 11 similarly to what we did for AS-733 (see Figure 6).RedditHyperlinks.Nodes in this graph are "sub-reddits" and edges are links to one posted on another, collected from January 2014 to April 2017.Looking at the Temporal Resilience plot for ℎ = Δ (Figure 12), the graph resembles the Bitcoin and StackExchange networks for ℎ = Δ, with quickly dwindling ARCD values.On the other hand, for ℎ = Δ/2 we can see similarities with the Email-EUcore graph instead.
We observe that there are medium-and long-lasting communities here, with interactions that are consistent in time; however, the communities are not so tightly knit, i.e., they are not observed if we require frequent interactions, e.g., in every window, which intuitively makes sense when considering that small sub-reddits may not receive comments and links everyday.Therefore, we can conclude that this graph is somewhat similar in structure to Stack-Exchange networks, but more densely interconnected, and with "weak but persistent" communities.

Key takeaways
Our experimental analysis showed that using current definitions of temporal -cores, supported by node degree, is a valid method to uncover trends and dynamics of temporal graphs.Moreover, this kind of analysis is able to provide a preliminary classification of the nodes for further inspection.Another key aspect is that we are actually able to highlight some aspects of the communities' strenght, resilience and character, as our method was able to visualize some behaviors expected from the domain knowledge of each dataset, such as ephemerality of community structure in Q&A sites or reliability of backbone routers in AS networks.
For these reasons we believe that temporal -cores are able to highlight information that would not otherwise be captured.

CONCLUSIONS
In this paper, we showed how to extend classical graph community analysis techniques on degree and coreness to the temporal graphs, including a data structure to be used for querying intervals of the graphs, employing several proposed definitions of temporal -core combined with node degree.
To visualize information effectively we adopted temporal resilience plots, showing condensed information on node connectivity for different temporal resolutions at once.We discussed in depth the results obtained by our experimentations, highlighting key insights regarding the dynamics of the networks such as existence, strength and volatility (or persistence) of communities, as well as resilience of node connectivity.We observed how these insights cannot be obtained by static graph analysis, motivating the effectiveness of temporal -cores.
We believe this work answers the question "are -cores meaningful for temporal graph analysis?"positively, and opens the way for a deeper analysis of temporal graphs.

Figure 1 :
Figure 1: Examples of the tree data structure on a toy   (bottom row).Each tree node contains the intersection (a) or union (b) of the edges of children graphs.Highlighted nodes in (a) are the ones used to perform the intersection  1 ∩  2 ∩  3 .-cores in the resulting graph correspond to the (, [1, 3])-span cores of [9].Highlighted nodes in (b) are the ones used to perform the union  2 ∪ 3 ∪ 4 .The two resulting graphs are shown in the top left and top right corners.

Algorithm 1 :
Computing the topmost nodes of the tree  covering the leaves indicated by interval [, ].

1 Figure 2 :
Figure 2: Coreness-vs-degree plots (Mirror Pattern in[22]) in two of our datasets for a fixed time interval and fixed ℎ.

Figure 4 :
Figure 4: Temporal Resilience plots for the AS-733 dataset for different values of ℎ.

Figure 6 :
Figure 6: Coloring of the nodes of AS-733, according to their falling points in the Temporal Resilience plot.

Figure 11 :
Figure 11: Coloring of the nodes on the Email-EU dataset according to their connectivity class given by the falling point in the corresponding Temporal Resilience plot (ℎ = Δ/2).
Let   = ( ,   ) be a temporal graph, ,  ∈ N, and [  ,   ] with   −   ≥  be an interval.A (, )-persistent core in the interval [  ,   ] is a set of nodes that is a -core of the static graph  ′ = ( ,  [,+ ],1 ) for all  ∈ [  ,   −  ], and the same does not hold for any interval strictly containing [  ,   ].

Table 1 :
Summary of our dataset.

Table 2 :
Running times (milliseconds) for computing our data structures, and average times for (, ℎ, Δ)-core decompositions with and without our data structures.