---
title: Temporal k-Core Component Search (TCCS)
url: https://www.emergentmind.com/topics/temporal-k-core-component-search-tccs
type: topic
---

# Temporal k-Core Component Search (TCCS)

Temporal k-core component search (TCCS) studies cohesive subgraph retrieval in temporal settings under a $k$-core constraint and explicit time conditions. In one formulation, given a temporal graph, an integer $k$, a query vertex $v$, and a window $[t_s,t_e]$, the task is to return the connected component of the temporal $k$-core that contains $v$ in the snapshot over that window [2508.18151]. Closely related formulations enumerate temporal $k$-core components over all sub-intervals of a query interval and attach each component to its supporting interval [2508.15238], [2301.03770]. A further extension realizes the same connected-$k$-core search primitive in time-dependent road-social attributed networks, where the temporal condition is expressed through departure-time-dependent travel time rather than time-varying social edges [2505.12309].

## 1. Problem formulations and terminology

The literature represented here uses TCCS in several closely related but not identical senses.

| Setting | Input | Output |
|---|---|---|
| Specified-window local query [2508.18151] | $G$, $k$, vertex $v$, window $[t_s,t_e]$ | The connected component of the temporal $k$-core that contains $v$ |
| All-sub-interval enumeration [2508.15238], [2301.03770] | Query interval $[T_s,T_e]$, parameter $k$ | Temporal $k$-core components together with supporting intervals |
| Time-dependent road-social query [2505.12309] | $\langle q,k,s_q,l_q,t\rangle$ over $G=(G_s,G_r)$ | A connected semantic-spatial aware $k$-core containing $q$ |

In the specified-window model, the central object is the component containing a given query vertex. In the all-sub-interval model, the objective is broader: enumerate components induced by every relevant interval inside a query range. This suggests that the term TCCS is used both for local query answering over a specified window and for exhaustive component enumeration over a query interval.

A recurrent source of confusion is the role of connectivity. In the temporal-graph formulations, connectivity is typically **not** required in the definition of the temporal $k$-core itself; it is enforced only when extracting components. Both the specified-window model and the all-sub-interval model make this distinction explicit [2508.18151], [2508.15238]. By contrast, the road-social attributed formulation directly seeks a connected $k$-core community containing the query node [2505.12309].

## 2. Structural and temporal semantics

For the specified-window temporal-graph setting, a temporal graph is an undirected graph $G=(V,E)$ in which each edge $e=(u,v,t)\in E$ carries a timestamp $t\in\{1,2,\ldots,t_{\max}\}$. For a query time window $[t_s,t_e]$, the windowed graph is the static subgraph
$$
G_{[t_s,t_e]}=(V,E_{[t_s,t_e]}),
$$
where $E_{[t_s,t_e]}=\{(u,v,t)\in E:t_s\le t\le t_e\}$. The temporal $k$-core over $[t_s,t_e]$ is the maximal subgraph $T_k([t_s,t_e])\subseteq G_{[t_s,t_e]}$ in which every vertex has at least $k$ neighbors; a temporal $k$-core component is any connected component of that temporal core [2508.18151]. The local TCCS answer is
$$
CC_k(v,[t_s,t_e]),
$$
the connected component containing $v$ within the induced subgraph on the temporal $k$-core vertices.

A second line of work makes the detemporalization step explicit. Given an interval $[a,b]$, it forms the projected temporal graph $\mathcal{G}_{[a,b]}=(V,\mathcal{E}_{[a,b]})$ and the detemporalized static graph
$$
G_{[a,b]}=(V,E_{[a,b]}), \qquad
E_{[a,b]}=\{(u,v)\mid \exists\, t\in[a,b],\, (u,v,t)\in\mathcal{E}\}.
$$
The temporal $k$-core over $[a,b]$ is then the static $k$-core of $G_{[a,b]}$, and a temporal $k$-core component is any connected component in that induced static $k$-core [2508.15238]. This formulation makes clear that repeated interactions between the same pair only affect edge availability in the aggregate graph, not multiplicity-based degree.

A key structural property is interval monotonicity. If $[t_s,t_e]\subseteq [t_s',t_e']$, then
$$
\mathcal{T}_{[t_s,t_e]}(\mathcal{G})
=
\mathcal{T}_{[t_s,t_e]}\big(\mathcal{T}_{[t_s',t_e']}(\mathcal{G})\big)
\subseteq
\mathcal{T}_{[t_s',t_e']}(\mathcal{G}).
$$
This nested property underpins both decremental interval enumeration and core-time methods [2508.15238]. A plausible implication is that much of TCCS algorithm design reduces to exploiting containment across overlapping intervals while avoiding duplicate component extraction.

## 3. Enumeration-oriented algorithms over all sub-intervals

The earliest scalable line in this group is Temporal Core Decomposition (TCD) and its optimized form OTCD. TCD enumerates subintervals row by row and decrementally induces $\mathcal{T}^k[ts,te]$ from previously induced temporal $k$-cores, reducing intra-core redundant computation. OTCD adds the Tightest Time Interval (TTI), defined as the minimal interval that induces a given temporal $k$-core, and uses TTI-based pruning rules—Pruning-on-the-Right, Pruning-on-the-Underside, and Pruning-on-the-Left—to eliminate inter-core redundant computation. The supporting data structure is the Temporal Edge List (TEL), which organizes temporal edges in a timeline and supports instant updates when new edges arrive. OTCD is reported to outperform the incremental historical k-core query by three orders of magnitude, even though it needs none precomputed index [2301.03770].

CoreT revisits temporal $k$-core query from a core-time perspective. For a fixed start time $x$, it records the earliest timestamp at which each vertex or edge enters a $k$-core. Its update rules are based on the vertex-edge dependency
$$
\sigma_x(v,\mathcal{G})=\text{$k$-th smallest value among }\{\sigma_x(v,u,\mathcal{G})\mid (u,v)\in E\},
$$
and the edge-vertex-support dependency
$$
\sigma_x(u,v,\mathcal{G})=\max\{Sup(u,v,\mathcal{G}),\sigma_x(u,\mathcal{G}),\sigma_x(v,\mathcal{G})\}.
$$
CoreT replaces interval-by-interval enumeration by a single pass over the query interval for each start time, with
$$
\text{Time(CoreT)}=O(\Delta\cdot |E_I|), \qquad
\text{Space(CoreT)}=O(|V|+|\mathcal{E}|).
$$
It achieves up to four orders of magnitude speedup compared to OTCD on large real-world datasets [2508.15238].

A related acceleration based on vertex core times (VCT) and minimal edge core windows (ECS) derives edge core times from
$$
c_{ts}(e;k)=\max\{c_{ts}(u;k),c_{ts}(v;k),t\}.
$$
It then enumerates all distinct temporal $k$-cores in time
$$
O(|VCT|\cdot avg + |R|),
$$
where $|R|$ is the sum over all output $k$-cores of their number of edges. In that framework, connected components are extracted for each emitted temporal $k$-core in total $O(|R|)$ time, so component search inherits a result-size bound [2508.14147]. This suggests a shift from interval complexity to output complexity in recent enumeration-oriented work.

## 4. Historical TCCS indexing and query-time acceleration

For the specified-window local-query problem, the state-of-the-art baseline before 2025 was EF-Index, which models Temporal k-Core Evolution across windows through Tightest Time Interval (TTI), Loosest Time Interval (LTI), lineage graphs, and Minimum Temporal Spanning Forests (MTSFs). Its limitations are high computational cost and storage redundancy, because it enumerates many redundant temporal $k$-cores and stores MTSFs per lineage chain [2508.18151].

The principal 2025 indexing alternative is the ECB-forest and its compressed multi-start-time realization, PECB-Index. The method reduces arbitrary-window TCCS to start-anchored TCCS by fixing $t_s$ and allowing arbitrary $t_e\ge t_s$. For fixed $t_s$ and $k$, each temporal edge receives an Edge Core Time (ECT),
$$
(e)_{t_s}^k=\min\{t_e\ge t_s : e\in T_k([t_s,t_e])\},
$$
or $\infty$ if it never enters the temporal $k$-core. A core-time Minimum Spanning Forest (CT-MSF) on these edge weights preserves component connectivity, and the Edge-Centric Binary Forest (ECB-forest) further bounds traversal branching by giving each forest node at most two children.

Across all start times, PECB-Index stores only versioned neighborhood changes of ECB nodes in entries of the form $\langle startTime,leftChild,rightChild,parent\rangle$. Its space is
$$
O(n\cdot \bar{t}),
$$
where $\bar{t}$ is the average number of labels per forest node, and its query time is
$$
O(r\cdot \log \bar{t}),
$$
where $r$ is the number of visited forest nodes. Total construction time is
$$
O(vct\cdot d + |E_{ct}|\cdot h),
$$
with $d$ the average degree and $h$ the forest depth. Empirically, PECB-Index is 10×–1000× smaller than EF-Index on day-aggregated timestamps, achieves microsecond-level query latency comparable to EF-Index, and improves index construction cost up to 100x faster on average while maintaining high query efficiency [2508.18151].

## 5. Extensions beyond plain temporal graphs

A notable attributed generalization realizes TCCS as semantic–spatial aware $k$-core search in a time-dependent road–social attributed network $G=(G_s,G_r)$. The social layer $G_s=(V_s,E_s,A,L)$ carries keywords and mapped locations; the road layer $G_r=(V_r,E_r,W)$ carries piecewise linear travel-time functions $w_{u_r,v_r}(t)$. Given query information $\langle q,k,s_q,l_q,t\rangle$, the target is a connected subgraph $c\subseteq G_s$ containing $q$ such that $\delta_c(v)\ge k$ for all $v\in c$, while semantic cohesiveness and time-dependent spatial cohesiveness are jointly optimized. The objective terms are
$$
K_c=\cos(x_c,x_{s_q})+\frac{1}{|c|}\sum_{v\in c}\max_{x_o\in X_v,\ x_p\in X_{s_q}}\cos(x_o,x_p),
$$
and
$$
T_c=-\frac{1}{|c|}\sum_{v\in c} d_{l_v,l_q,t},
$$
combined after min–max normalization as
$$
MD_c = K_c' + T_c'.
$$
The exact algorithm ESSAC enumerates connected $k$-cores containing $q$ locally, whereas the greedy algorithm GSSAC maintains a single evolving $k$-core around $q$ using the node-expansion score
$$
NE_n=\tilde{y}_1(n)+\tilde{y}_2(n)-\tilde{d}_{l_n,l_q,t}(n).
$$
Semantic preprocessing uses GPT-3.5-Turbo and text-embedding-3-small. GSSAC yields comparable community quality to ESSAC and runs about 30× faster [2505.12309].

A different extension is the edge-based decomposition framework for temporal networks. It defines the edge-based temporal $(k,\Delta)$-core by requiring every temporal edge to have $\Delta$-degree at least $k+1$, and it extracts $\Delta$-connected components through a static transform $S_\Delta(G)$. The paper’s term is “$\Delta$-Connected Community Search (Δ-CCS),” not TCCS, but it provides a structurally analogous route from a temporal decomposition to connected component retrieval [2309.11843].

The TXCQ framework generalizes temporal $k$-core query to user-defined metrics $\mathcal{X}(\cdot)$ that are time-insensitive or time-monotonic. Phase 1 still induces all distinct $k$-cores and locates their “time zones” through TTIs and LTIs; Phase 2 conducts local search inside each zone. For component-level search, the key observation is that the component partition of an identical temporal $k$-core is identical throughout its zone, so only the metric value may vary with the interval [2309.00361].

A query-centered precursor is Significant Engagement Community Search (SECS), which seeks a temporal subgraph $\mathcal{H}$ such that the de-temporal graph of $\mathcal{H}$ is a connected $k$-core containing the query vertex $u$, and
$$
Eng_u(\mathcal{H})=\frac{d_{u,\mathcal{H}}}{\sum_{v\in \mathcal{H}} d_{v,\mathcal{H}}}
$$
is maximized. Its algorithms TDGP, BULS, BULS+, and BULS* anticipate later local-search variants of TCCS by combining connected-$k$-core feasibility with temporal objective optimization [2206.06350].

## 6. Empirical findings, applications, and open issues

Within the specified-window indexing setting, TCCS is described as critical for contact tracing, fault diagnosis, and financial forensics. PECB-Index was evaluated on 15 real-world temporal graphs from SNAP, KONECT, and Network Repository, including FB-Forum, CollegeMsg, Email, Mooc, AskUbuntu, Enron, WikiTalk, ProsperLoans, YouTube, and DBLP. On day-aggregated timestamps it is 10×–1000× smaller than EF-Index, and on fine-grained original timestamps EF-Index often fails to complete while PECB-Index builds successfully [2508.18151].

Within the all-sub-interval enumeration setting, CoreT was evaluated on SNAP and KONECT temporal graphs including CollegeMsg, email-Eu-core, StackExchange networks, wiki-talk, dblp-coauthor, flickr-growth, and wikipedia-growth. Example results include CollegeMsg with $\alpha=1.0$ and $k=2$, where CoreT ran in 144 ms versus 1,054,508 ms for OTCD. On medium and large graphs, OTCD often times out at $\alpha\ge 0.6$–$1.0$, while CoreT completes within seconds to minutes [2508.15238]. Earlier OTCD experiments reported that PoU and PoL prune large areas of the interval schedule, with total pruned subintervals often exceeding 80–95% [2301.03770].

Within the road-social attributed setting, experiments used five social networks—Foursquare_rec, Foursquare, Weeplace, Gowalla, and Flickr—combined with the California and North_America road networks, with 200 query nodes sampled for each composite dataset. Against spatial baselines SLDRG and LSADEN, GSSAC achieves higher `coe`, `GPT_score`, and `t_coe` on most datasets; against the keyword baseline ACQ, it yields comparable structural cohesiveness and higher semantic and time-dependent spatial cohesiveness. Ablation results show that removing initial construction, candidate selection, or greedy expansion degrades `coe` and `t_coe`, and replacing LLM-based processing or embeddings with direct matching reduces `GPT_score` substantially [2505.12309].

Several limitations recur. Many formulations assume undirected graphs, and extensions to directed or weighted settings require adapted core notions such as $(k,h)$-core or weighted core [2508.18151]. CoreT assumes integer timestamps and an undirected temporal graph, and its memory remains $O(|V|+|\mathcal{E}|)$ because it stores per-edge timestamp lists [2508.15238]. The road-social formulation evaluates temporal-spatial cohesiveness at a single departure time $t$ rather than over a longer window $W$, and dynamic updates and multi-query expansions are not addressed [2505.12309]. In TXCQ, time-nonmonotonic user-defined metrics remain an open problem [2309.00361].

Taken together, these results indicate a clear methodological split. One branch focuses on exact or output-sensitive enumeration of temporal $k$-cores and then extracts components; another focuses on indexed local retrieval for arbitrary windows; and a third incorporates additional semantic, spatial, or user-defined objectives. What remains common is the same structural kernel: a connected component derived from a $k$-core under explicit temporal semantics.

Source: https://www.emergentmind.com/topics/temporal-k-core-component-search-tccs