CoreT: Efficient Temporal k-Core Query Algorithm

• CoreT is a core-time–based algorithm for temporal k-core queries, efficiently replacing repetitive decompositions with a single pass mechanism.
• It leverages a representation that records the earliest timestamps when vertices and edges enter a k-core, enabling incremental enumeration across sub-intervals.
• Empirical results show that CoreT achieves up to four orders of magnitude speedup over prior methods, making it ideal for analyzing evolving temporal graphs.

Searching arXiv for the CoreT paper and closely related temporal $k$-core query work.

CoreT is a core-time–based algorithm for answering temporal $k$-core queries over temporal graphs. It was introduced in “Temporal $k$-Core Query, Revisited” as a way to replace repeated decompositions over many overlapping sub-intervals with a mechanism that records, for every vertex and edge, the earliest timestamp at which it belongs to a $k$-core. This lets CoreT enumerate all temporal $k$-cores over all sub-intervals of a query interval in one pass, with time complexity linear in both the number of temporal edges within the query interval and the duration of the interval (Liu et al., 21 Aug 2025).

1. Temporal $k$-core queries and the problem CoreT solves

The paper studies an undirected temporal graph

$\mathcal{G} = (V,\mathcal{E}),$

where $\mathcal{E}$ is a multiset of temporal edges and each edge is a triple $(u,v,t)$, meaning an interaction between $u$ and $k$0 at timestamp $k$1. Timestamps are assumed to be consecutive integers in a finite range $k$2. For a time interval $k$3, the projected temporal graph is

$k$4

and its underlying static graph is

$k$5

A static $k$6-core is the maximal induced subgraph in which every vertex has degree at least $k$7. The temporal extension used here defines a temporal $k$8-core over $k$9, denoted $k$0, as a maximal induced subgraph of $k$1 where each vertex has at least $k$2 neighbors. The query problem is: given a temporal graph $k$3, a query interval $k$4, and an integer $k$5, find all distinct temporal $k$6-cores $k$7 such that $k$8 (Liu et al., 21 Aug 2025).

The difficulty is combinatorial. If $k$9, then there are at most $k$0 sub-intervals. A direct approach that computes a decomposition for every interval quickly becomes impractical on long time ranges and large temporal graphs.

2. Relation to earlier methods and the motivation for CoreT

A straightforward baseline enumerates all sub-intervals and runs a static-style decomposition on each one: remove edges outside $k$1, then repeatedly peel vertices with degree less than $k$2. The paper denotes this operation by Decomp$k$3. Its cost is high because the number of sub-intervals is $k$4 and each run processes a large graph.

The immediate predecessor is OTCD, which exploits a nested property: if $k$5, then

$k$6

This reduces redundancy by deriving smaller-interval cores from larger-interval cores instead of from the full graph.

Even so, OTCD remains limited in scalability because it still requires many Decomp calls and maintains a TEL structure through repeated edge and vertex deletions. Its worst-case cost is summarized in the paper as

$k$7

CoreT is designed precisely to avoid this repeated interval-by-interval decomposition. A common misconception is that CoreT changes the semantics of temporal $k$8-cores; it does not. It computes the same temporal $k$9-core model as OTCD, but with a different computational strategy (Liu et al., 21 Aug 2025).

3. Core-time representation

CoreT’s key abstraction is the earliest time at which a vertex or edge enters a $k$0-core. The paper introduces three related notions.

The support time of a detemporalized edge $k$1 is

$k$2

This is the earliest timestamp at which the edge appears.

For a vertex $k$3 and a fixed start timestamp $k$4, the $k$5-degree time is

$k$6

with $k$7 if $k$8 never reaches degree $k$9 in $k$0.

The central concept is the $k$1-core time. For timestamp $k$2, the $k$3-core time of a vertex $k$4, written $k$5, is the minimum timestamp $k$6 such that $k$7 belongs to the $k$8-core of $k$9. For a detemporalized edge $\mathcal{G} = (V,\mathcal{E}),$0, $\mathcal{G} = (V,\mathcal{E}),$1 is the minimum timestamp $\mathcal{G} = (V,\mathcal{E}),$2 such that $\mathcal{G} = (V,\mathcal{E}),$3 belongs to the $\mathcal{G} = (V,\mathcal{E}),$4-core of $\mathcal{G} = (V,\mathcal{E}),$5. If a vertex or edge never belongs to any such $\mathcal{G} = (V,\mathcal{E}),$6-core, its $\mathcal{G} = (V,\mathcal{E}),$7 is $\mathcal{G} = (V,\mathcal{E}),$8 (Liu et al., 21 Aug 2025).

This representation is sufficient to reconstruct all temporal $\mathcal{G} = (V,\mathcal{E}),$9-cores with the same start time. For $\mathcal{E}$0,

$\mathcal{E}$1

This means that once $\mathcal{E}$2 is known, the entire inclusion chain

$\mathcal{E}$3

can be generated incrementally without recomputing decompositions.

4. Algorithmic structure

CoreT has three main procedures: CoreT_Init, CoreT_Update, and CoreT_List.

CoreT_Init computes $\mathcal{E}$4 for $\mathcal{E}$5. It first computes support times for detemporalized edges, then $\mathcal{E}$6-degree times for vertices. It performs a peeling process over a working graph $\mathcal{E}$7, repeatedly removing the vertex with largest current $\mathcal{E}$8-degree time and assigning its core time. Once vertex core times are available, edge core times follow from

$\mathcal{E}$9

The paper proves that this initialization correctly computes $(u,v,t)$0 for every vertex and edge.

CoreT_Update moves the left endpoint from $(u,v,t)$1 to $(u,v,t)$2. It removes temporal edges with timestamp $(u,v,t)$3, updates support times as needed, and propagates the resulting increases in tentative core times through vertex–edge dependencies. Two lemmas drive the update: $(u,v,t)$4 and

$(u,v,t)$5

The update procedure processes elements in descending order of tentative core time so that each vertex and edge is stabilized once per iteration (Liu et al., 21 Aug 2025).

CoreT_List then enumerates temporal $(u,v,t)$6-cores for a fixed start time $(u,v,t)$7. For each $(u,v,t)$8 from $(u,v,t)$9 to $u$0, it outputs the vertex set with $u$1 and the temporal edges whose edge core time is at most $u$2 and whose timestamp is at most $u$3. Because the resulting cores form an inclusion chain, this listing is incremental rather than repetitive.

The implementation uses adjacency lists for the detemporalized graph, sorted timestamp lists for temporal edges, and per-vertex sorted lists of incident edges ordered by tentative core times. This replaces OTCD’s TEL structure with simpler data structures while preserving the information needed for updates.

5. Complexity and scalability

The paper’s main theoretical claim is that CoreT runs in

$u$4

which is linear in both the duration $u$5 and the number of temporal edges within the query interval. Space complexity is $u$6 (Liu et al., 21 Aug 2025).

More specifically, CoreT_Init runs in $u$7, where $u$8 is the edge set of the underlying static graph over $u$9. CoreT_Update is $k$00 per iteration, and CoreT_List is also linear in the size of the current graph because it incrementally traverses the inclusion chain of cores.

This complexity is the reason CoreT is described as suitable for long-term temporal analysis. The algorithm does not eliminate the need to enumerate temporal $k$01-cores over all sub-intervals; rather, it changes the representation so that the enumeration is driven by precomputed core times instead of repeated decompositions. A plausible implication is that CoreT is especially advantageous when $k$02 is large and the number of overlapping intervals makes interval-by-interval recomputation untenable.

6. Empirical performance, interpretation, and scope

The evaluation uses temporal graphs from SNAP and KONECT, including CollegeMsg, sx-superuser, email-Eu-core, sx-mathoverflow, sx-askubuntu, wiki-talk-temporal, dblp-coauthor, flickr-growth, and wikipedia-growth. The experiments vary the core threshold $k$03 from 2 to 20 and the query interval $k$04 with $k$05, with additional fine-grained sweeps and random-query evaluations (Liu et al., 21 Aug 2025).

The central empirical finding is that CoreT achieves up to four orders of magnitude speedup compared to OTCD. On the CollegeMsg dataset with the full interval and $k$06, CoreT runs in 144 ms whereas OTCD requires 1,054,508 ms. On larger datasets such as AU, MO, SU, and WT, OTCD often times out at over 3 hours for many interval settings, while CoreT completes within seconds to a couple of minutes. CDF analyses on short random queries show that OTCD can be comparable on very tiny intervals, and is sometimes slightly faster by less than 1 ms, but CoreT dominates as query time increases.

These results matter because CoreT’s contribution is algorithmic rather than definitional. It does not propose a new cohesiveness notion; it accelerates the standard temporal $k$07-core query model. This makes it suitable for applications that already rely on temporal $k$08-cores, including evolving communities in social networks, shifting hyperlink structures on the Web, and transient communication patterns in call networks.

The paper also outlines natural extensions. It explicitly mentions possible adaptation to temporal $k$09-trusses, as well as directions involving indexing, streaming updates, and parallel or distributed implementations. This suggests that the core-time abstraction is not limited to one query engine, but may serve as a reusable primitive for broader temporal cohesive-subgraph analysis.