Pith. sign in

REVIEW 3 major objections 5 minor 41 references

Temporal $k$-Core Query, Revisited

T0 review · 3 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read All distinct temporal k-cores in a query interval can be found in a single pass, with time linear in the interval's length times its edge count — removing the previous quadratic interval enumeration.

desk verdict CoreT is a promising single-pass algorithm for temporal k-core queries, but the claimed O(Δ|E|) bound rests on an unproved invariant and a garbled line in the initialization algorithm. read the letter →

arxiv 2508.15238 v1 pith:TVYWHZ3I submitted 2025-08-21 cs.DB

Yinyu Liu , Kaiqiang Yu , Shengxin Liu , Cheng Long , Zhaoquan Gu This is my paper · ORCID
classification cs.DB
keywords temporalgraphsk-corequerytimecohesivesubgraphminingcoredecompositiontime-rangegraphalgorithmssingle-passalgorithm
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper shows that the temporal k-core query — finding every distinct k-core that appears in any sub-interval of a given time range — can be answered in a single pass over time, in O(Δ × |E[Ts,Te]|) total work, where Δ is the query interval's length and |E[Ts,Te]| is the number of temporal edges inside it. The central device is the k-core time: for each vertex and edge, the earliest timestamp at which it enters a k-core. Given these times for a fixed start time, all cores starting at that time are obtained by a monotone threshold sweep, so the quadratic enumeration of overlapping sub-intervals collapses. A peeling initialization computes the core times once, and an incremental update maintains them as the start time advances by one, claiming each element is touched once per timestamp. On large real-world graphs the paper reports speedups of up to four orders of magnitude over the previous state of the art, OTCD, which frequently exceeds a three-hour limit on the same queries.

What carries the argument

The k-core time σ_x(v,G) (Definition 2) — the earliest timestamp t such that v (or edge (u,v)) lies in the k-core of the detemporalized graph over [x,t] — is the paper's central object. Lemma 2 converts core times into an enumeration rule: the temporal k-core T[x,te](G) is exactly the set of vertices and temporal edges whose k-core time is at most te. This identity carries the argument because it turns the problem into computing one vector of entry times per start timestamp rather than decomposing each sub-interval. Two reciprocal update rules (Lemmas 4 and 5) make those vectors maintainable: a vertex's core time equals the k-th smallest core time of its incident edges, and an edge's core ti

What would settle it

A concrete check: construct a small temporal graph with interleaved edge expirations, run CoreT_Update by hand or by exhaustive search over all deletion orders, and look for any vertex or edge whose finalized core time must later be raised — i.e., an element that re-enters the candidate set after being processed. Finding one breaks the per-iteration linear bound. Independently, the correct-but-slow reference is brute force: run the peeling decomposition on every sub-interval of a random small graph (all pairs ts ≤ te) and verify CoreT returns exactly the same distinct cores; any mismatch local

Watch

Extended reading notes

Core claim

CoreT computes all distinct temporal k-cores of a query interval by maintaining, for every vertex and detemporalized edge, a k-core time σ_x(·,G): the smallest end timestamp t such that the element belongs to the k-core of the detemporalized graph G[x,t]. Lemma 2 turns these times into an enumeration rule: a temporal k-core T[x,te] is exactly the subgraph induced by vertices with σ_x ≤ te and edges with σ_x ≤ te whose timestamp is ≤ te, so for each start time the family of cores is a monotone sweep in te. The initialization computes σ_Ts by repeatedly peeling the vertex with the largest k-degree time and recording the running minimum; the update phase moves the start time forward by deleting

Load-bearing premise

The linear time bound stands on an unproved invariant: processing updates in descending order of tentative k-core time ensures each vertex or edge is finalized once per iteration, and the paper omits the formal proof; if any element must be revisited with a larger tentative time, the claimed O(|E[Ts,Te]|) per-iteration cost — and with it the total O(Δ × |E[Ts,Te]|) bound — fails.

Editorial extensions

If this is right

  • Temporal k-core queries over long intervals become practical: CoreT finishes in seconds to a few minutes on graphs where OTCD exceeds a three-hour timeout (e.g., the askubuntu, mathoverflow, and wiki-talk datasets).
  • The single-pass structure eliminates the O(Δ²) round structure of OTCD, so query cost scales linearly in both the interval duration and the number of temporal edges inside it.
  • Knowledge of k-core times yields all cores for a given start time by a monotone sweep, so output for each start time is produced incrementally, smallest interval first.
  • Since CoreT is independent of OTCD's Temporal Edge List bookkeeping, it can be implemented on a plain adjacency representation of the detemporalized graph plus per-edge timestamp lists.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The k-core time is a temporal analogue of the static core number; the same 'earliest entry time' bookkeeping can likely be lifted to higher-order structures such as k-trusses, as the paper's conclusion anticipates, or to (k,h)-cores by adapting the support-time and degree-time definitions.
  • The claimed O(|E[Ts,Te]|) per-timestamp update cost hinges entirely on the unproved invariant that descending-order processing prevents re-insertion. A natural stress test is to search, by exhaustive enumeration over small graphs, for an execution where an element must be revisited; the complexity guarantee stands or falls on that search.
  • CoreT's output enumeration is monotone per start time, which suggests the method composes with indexing: the per-start-time k-core-time vectors could be precomputed once and reused across many queries on the same graph, turning each query into a threshold sweep (the paper cites follow-up index work for the OTCD model).
  • For streaming settings, CoreT_Update's incremental revision of entry times as edges expire resembles a sliding-window core-number maintenance scheme; one testable extension is whether the same ordering argument supports arbitrary window slides, not just unit step advances.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. This paper revisits the time-range temporal k-core query problem (Problem 1) and proposes CoreT. The algorithm first computes k-core times σ_Ts for vertices and edges (Section III-B), uses Lemma 2 to list all temporal k-cores with start time Ts, then in each of Δ−1 iterations refines the graph and updates σ by Algorithm 3. The central claim is a total running time of O(Δ × |E[Ts,Te]|), a single pass over the query interval, and experiments on nine real graphs report speedups up to four orders of magnitude over OTCD.

Significance. If the complexity analysis were rigorous, CoreT would be a meaningful advance: it replaces OTCD's repeated Decomp calls with a single incremental propagation of entry times, and the experiments suggest large practical gains. The paper's use of k-core times and Lemma 2 is sound, and the empirical comparison is extensive. However, the main theoretical guarantee rests on an unproved and nontrivial invariant in the update phase; this must be supplied before the paper can be assessed as written.

major comments (3)
  1. [Section III-C, Algorithm 3 (Update ordering)] The claimed O(|E[Ts,Te]|) per-iteration bound for CoreT_Update rests entirely on 'each vertex or edge enters and leaves the candidate set once' (Section III-C). The paper explicitly says 'we omit the formal proof.' The informal argument only analyzes elements after they have already been popped; it does not rule out an element being updated upward while it is still in S, nor a popped element being reinserted by a later edge update. For example, if vertex v is in S with tentative time 50 and another incident edge later raises its tentative time to 70, then either the S entry must support priority updates (not specified) or v will be added again. Without a proof that no element is processed more than once (or an alternative amortized accounting), Lines 7–22 cannot be bounded by O(|E|), and the headline O(Δ|E|) complexity does not follow. This is the main revision needed.
  2. [Section III-B, Algorithm 2, line 11] Algorithm 2, line 11 is garbled: 'dTs(·, G′) ← the k-th smallest one among {Sup(v∗, v,G0) | v ∈ V ′ & (v, v∗) ∈ E0}' has no well-defined left-hand side and uses support times of the removed vertex v*. The intended update rule for the k-degree time of a neighbor v of v* must be stated precisely (presumably the k-th smallest support time among v's incident edges to vertices remaining in V', with +∞ if fewer than k). As written, the reader cannot verify the O(|E0|) initialization time or the correctness proof in Lemma 3.
  3. [Section III-C, correctness of CoreT_Update] The procedure is presented only with an informal rationale; Lemma 4 and 5 give local dependencies but no invariant tying tentative values to σ in Gt. A rigorous proof that Algorithm 3 terminates with σTs+t(·,Gt) is needed, especially because the update ordering may skip recomputations. As it stands, correctness is asserted rather than demonstrated.
minor comments (5)
  1. [Section III-A, Time complexity analysis] The formula 'O(∆ × |E[Te−Ts])' should be 'O(∆ × |E[Ts,Te]|)'; the same subscript error appears in Section III-C ('O(|E[Te−Ts]|)').
  2. [Section III-C, Algorithm 3, line 3] Line 3 refers to 'Sup(u,v,G1)' but G1 is never defined. Clarify whether this is the graph after removing the current timestamp's edges or another refinement.
  3. [Section III-A, duplicate-removal remark] The remark states that the O(|Te−Ts|^2) TTI check is 'strictly smaller than |E[Ts,Te]|' under the assumption that each timestamp has at least one edge. Since |E| ≥ Δ, O(Δ^2) can be equal to O(Δ|E|) when the graph is sparse per timestamp; the statement should be weakened to 'does not asymptotically increase O(Δ|E|)'.
  4. [Section III-B, Lemma 3 proof] In the first part of the proof, 'G′[Ts,t]' refers to a graph that changes during peeling; the argument would be clearer if it fixed the snapshot at the iteration where v′ is removed.
  5. [Global] Typo: 'phrases' should be 'phases' in Section III-A. Also, 'CoreT_Updte' in Section III-C should be 'CoreT_Update'.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: CoreT's derivation is self-contained and builds on prior published definitions with attribution; the unproved 'enters S once' invariant is a soundness gap, not a circular step.

full rationale

This paper does not exhibit a circular derivation. The central output—all distinct temporal k-cores over subintervals of [Ts, Te]—is derived from Lemma 2, which characterizes T[x,te](G) in terms of k-core times σx(·, G). That characterization is a direct consequence of the definition of k-core time (Definition 2, from [41]) and the definition of temporal k-core (Definition 1, from [39]); it is a reformulation, not a self-deriving loop. The inclusion property used to justify the iterative update is Lemma 1, quoted from [39], a prior external work with no author overlap with this paper. The k-core time concept is attributed to [41], also external. Neither cited result is a self-citation of the present authors, and neither is invoked as an unexamined uniqueness theorem to force the algorithm. The complexity analysis attempts an independent counting argument: CoreT_Init is O(|E0|) by a bucket-based peeling argument, CoreT_Update is claimed O(|E[Ts,Te]|) per iteration because 'each vertex or edge enters and leaves the candidate set once', and CoreT_List is O(|E[Ts,Te]|) by incremental monotone expansion. These are complexity claims, not fitted parameters renamed as predictions; no quantity is fitted to data and then reported as a discovered result. The experimental speedup is measured against the actual OTCD implementation on public datasets, providing external benchmarking rather than circular validation. The real vulnerabilities are non-circular: (1) Section III-C explicitly states 'To ease the presentation, we omit the formal proof' for the key ordering invariant that guarantees each vertex/edge enters the candidate set S at most once; if that invariant fails, the O(|E[Ts,Te]|) per-iteration bound for Lines 7–22 collapses. This is an unproved assumption in the complexity derivation, but it is not an equivalence-to-input or a self-citation. (2) Algorithm 2's Line 11 is garbled ('dTs(·, G′) ← the k-th smallest one among {Sup(v∗, v,G0) | v ∈ V ′&(v, v∗) ∈ E0}'), making the initialization update rule ambiguous; again a presentation/soundness issue, not circularity. (3) The remark on duplicate removal admits an O(|Te−Ts|^2) TTI-checking cost and asserts it is dominated by |E[Ts,Te]| under an assumption; this is a complexity assumption, not circular. In sum, the paper's claimed derivation chain is self-contained, with no step that reduces by construction to its own inputs. The appropriate finding is no significant circularity, with caveats about unproved invariant

Assumptions & free parameters 0 free parameters · 5 assumptions · 0 invented entities

No free parameters or invented entities. The paper's contribution is algorithmic. The main unstated baggage is the correctness invariant of the update ordering and the garbled update formula in Algorithm 2, which are the riskiest assumptions.

assumptions (5)
  • domain assumption K-core time definition and its characterization (Lemma 2)
    The algorithm's enumeration step assumes this identity from the historical k-core literature [41]; it is stated without proof in this paper (Lemma 2, Section III-A).
  • domain assumption Inclusion property of temporal k-cores (Lemma 1)
    Adopted from [39]; used to justify the pruning rule and graph refinement.
  • domain assumption Consecutive integer timestamps
    Assumed in Section II-A following prior work [4,11,39].
  • ad hoc to paper Each timestamp in the query interval is associated with at least one edge
    Used in the Remark of Section III-A to claim the TTI deduplication cost O(Δ^2) is dominated by the total complexity; the statement as written says 'strictly smaller than |E[Ts,Te]|', which is not generally true, though it is dominated by the total time when |E| ≥ Δ.
  • ad hoc to paper Update-ordering invariant (each vertex or edge enters the candidate set S at most once in CoreT_Update)
    Central to the O(|E|) per-iteration complexity of Algorithm 3; asserted without formal proof, with the text 'To ease the presentation, we omit the formal proof'.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Temporal $k$-Core Query, Revisited." pith.science (2026). https://pith.science/paper/TVYWHZ3I

@misc{pith2026250815238,
  author       = {Pith},
  title        = {Pith review of: Temporal $k$-Core Query, Revisited},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TVYWHZ3I}},
  note         = {Machine review of arXiv:2508.15238}
}
abstract

Querying cohesive subgraphs in temporal graphs is essential for understanding the dynamic structure of real-world networks, such as evolving communities in social platforms, shifting hyperlink structures on the Web, and transient communication patterns in call networks. Recently, research has focused on the temporal $k$-core query, which aims to identify all $k$-cores across all possible time sub-intervals within a given query interval. The state-of-the-art algorithm OTCD mitigates redundant computations over overlapping sub-intervals by exploiting inclusion relationships among $k$-cores in different time intervals. Nevertheless, OTCD remains limited in scalability due to the combinatorial growth in interval enumeration and repeated processing. In this paper, we revisit the temporal $k$-core query problem and introduce a novel algorithm CoreT, which dynamically records the earliest timestamp at which each vertex or edge enters a $k$-core. This strategy enables substantial pruning of redundant computations. As a result, CoreT requires only a single pass over the query interval and achieves improved time complexity, which is linear in both the number of temporal edges within the query interval and the duration of the interval, making it highly scalable for long-term temporal analysis. Experimental results on large real-world datasets show that CoreT achieves up to four orders of magnitude speedup compared to the existing state-of-the-art OTCD, demonstrating its effectiveness and scalability for temporal $k$-core analysis.

Figures

Figures reproduced from arXiv: 2508.15238 by the authors.

Figure 1
Figure 1. A running illustrative example of key concepts in temporal [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Illustration of OTCD [39] applied to the temporal graph in Figure 1a with k=2 and the query interval [1, 6]: the procedure Decomp decomposes T [1, 6](G) to T [1, 5](G), and then to T[1,4](G). such adaptions are not efficient [39]. We provide further details in Section V on related work. B. State-of-the-art Algorithms Given a time interval [ts, te], we note that the temporal k￾core T[ts,te](G) can be easily obtained … view at source ↗
Figure 3
Figure 3. Temporal 2-cores in intervals starting at time 0. v0 v3 v4 v5 v6 v7 v9 v8 4 4 4 4 5 5 4 1 1 1 6 6 6 v0 6 v3 4 v4 4 v5 1 v6 4 v7 1 v8 1 v9 6 [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (15 more)
Figure 6
Figure 6. Figure 6: 2-core time σ1(·, G1) after removing temporal edges with timestamp 1. σx(u, v, G) ≤ te and t ≤ te}). Formally, we summarize it in the following lemma. Lemma 2. Let G be a temporal graph and 0 ≤ x ≤ te ≤ tmax, we have T[x,te](G) = ({v ∈ V | σx(v, G) ≤ te}, {(u, v, t) ∈ …
Figure 5
Figure 5. Figure 5: 2-core time σ1(·, G1) after removing temporal edges with timestamp 0. timestamp t such that v (resp. (u, v)) belongs to the k-core of the detemporalized graph G[x,t] . 1 We observe that, (Motivation 1) given the k-core times σx(·, G), all temporal k-cores with the same…
Figure 7
Figure 7. Figure 7: Illustration of temporal graph representation. [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: Scatter plot of running times for CoreT and OTCD. 0k 10k 20k 30k 40k 50k number of timestamps 10 0 10 1 10 2 10 3 10 4 10 5 10 6 10 7 time (ms) Ours OTCD (a) CM 0k 25k 50k 75k 100k 125k 150k 175k 200k number of timestamps 10 0 10 1 10 2 10 3 10 4 10 5 10 6 10 7 time (m…
Figure 9
Figure 9. Figure 9: Runtime comparison over increasing time interval. [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: Cumulative distribution of query response times. [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]
Figure 11
Figure 11. Figure 11: Runtime performance of CoreT and OTCD on CollegeMsg (CM) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 100 101 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 100 101 102 time(ms) Ours OTCD (b) α = 0.4 2 3 4 5 6 7 8 9 10 11 12 13…
Figure 12
Figure 12. Figure 12: Runtime performance of CoreT and OTCD on dblp-coauthor (DC) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 100 102 104 106 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 102 103 104 105 106 107 time(ms) Ours OTCD (b) α = 0.4 2 3 …
Figure 13
Figure 13. Figure 13: Runtime performance of CoreT and OTCD on email-Eu-core-temporal (EE) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 104 105 106 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 104 105 106 107 time(ms) Ours OTCD (b) α = 0.4 2 3 4 5…
Figure 14
Figure 14. Figure 14: Runtime performance of CoreT and OTCD on flickr-growth (FG) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 102 103 104 105 106 107 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 102 103 104 105 106 107 time(ms) Ours OTCD (b) α = …
Figure 15
Figure 15. Figure 15: Runtime performance of CoreT and OTCD on sx-askubuntu (AU) [PITH_FULL_IMAGE:figures/full_fig_p011_15.png]
Figure 16
Figure 16. Figure 16: Runtime performance of CoreT and OTCD on sx-mathoverflow (MO) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 102 103 104 105 106 107 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 103 104 105 106 107 time(ms) Ours OTCD (b) α = 0.…
Figure 17
Figure 17. Figure 17: Runtime performance of CoreT and OTCD on sx-superuser (SU) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 103 104 105 106 107 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 104 105 106 107 time(ms) Ours OTCD (b) α = 0.4 2 3 4 5 6…
Figure 18
Figure 18. Figure 18: Runtime performance of CoreT and OTCD on wiki-talk-temporal (WT) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 101 102 103 104 105 106 107 time(ms) Ours OTCD (a) α = 0.2 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 k 102 103 104 105 106 107 time(ms) Ours OTCD…
Figure 19
Figure 19. Figure 19: Runtime performance of CoreT and OTCD on wikipedia-growth (WG) continuity [18] and reliability [31]. In a different direction, Momin et al. [22] introduced the notion of core-invariant nodes, which are nodes whose core numbers remain above a given threshold throughout…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

41 extracted references · 41 canonical work pages

  1. [1]

    Efficient temporal core maintenance of massive graphs,

    W. Bai, Y . Chen, and D. Wu, “Efficient temporal core maintenance of massive graphs,” Information Sciences, vol. 513, pp. 324–340, 2020

    work page 2020

  2. [2]

    Fast algorithms for determining (gener- alized) core groups in social networks,

    V . Batagelj and M. Zaver ˇsnik, “Fast algorithms for determining (gener- alized) core groups in social networks,” Advances in Data Analysis and Classification, vol. 5, no. 2, pp. 129–145, 2011

    work page 2011

  3. [3]

    Financial network communities and methodological insights: A case study for borsa istanbul sustainability index,

    L. M. Batrancea, ¨O. Akg ¨uller, M. A. Balcı, and A. Nichita, “Financial network communities and methodological insights: A case study for borsa istanbul sustainability index,” Humanities and Social Sciences Communications, vol. 11, no. 1, pp. 1–27, 2024

    work page 2024

  4. [4]

    Listing all maximal k-plexes in temporal graphs,

    M. Bentert, A.-S. Himmel, H. Molter, M. Morik, R. Niedermeier, and R. Saitenmacher, “Listing all maximal k-plexes in temporal graphs,” Journal of Experimental Algorithmics (JEA) , vol. 24, pp. 1–27, 2019

    work page 2019

  5. [5]

    Brandes, Network Analysis: Methodological Foundations

    U. Brandes, Network Analysis: Methodological Foundations . Springer Science & Business Media, 2005

    work page 2005

  6. [6]

    Output-sensitive enumeration of maximal cliques in temporal graphs,

    F. Brunelli, A. Conte, R. Grossi, and A. Marino, “Output-sensitive enumeration of maximal cliques in temporal graphs,” Discrete Applied Mathematics, vol. 369, pp. 66–77, 2025

    work page 2025

  7. [7]

    Evaluation of customer behavior with temporal centrality metrics for churn prediction of prepaid contracts,

    L. Calzada-Infante, M. ´Oskarsd´ottir, and B. Baesens, “Evaluation of customer behavior with temporal centrality metrics for churn prediction of prepaid contracts,” Expert Systems with Applications , vol. 160, p. 113553, 2020

    work page 2020

  8. [8]

    Querying structural diversity in streaming graphs,

    K. Chen, D. Wen, W. Zhang, Y . Zhang, X. Wang, and X. Lin, “Querying structural diversity in streaming graphs,” Proceedings of the VLDB Endowment, vol. 17, no. 5, pp. 1034–1046, 2024

    work page 2024

Show all 41 references
  1. [9]

    Relevance of temporal cores for epidemic spread in temporal networks,

    M. Ciaperoni, E. Galimberti, F. Bonchi, C. Cattuto, F. Gullo, and A. Barrat, “Relevance of temporal cores for epidemic spread in temporal networks,” Scientific Reports, vol. 10, no. 1, p. 12529, 2020

    2020

  2. [10]

    Are k-cores meaningful for temporal graph analysis?

    A. Conte and D. Rucci, “Are k-cores meaningful for temporal graph analysis?” in Proceedings of the ACM/SIGAPP Symposium on Applied Computing, 2024, pp. 1453–1460

    2024

  3. [11]

    Mining (maximal) span-cores from temporal networks,

    E. Galimberti, A. Barrat, F. Bonchi, C. Cattuto, and F. Gullo, “Mining (maximal) span-cores from temporal networks,” in Proceedings of the ACM International Conference on Information and Knowledge Manage- ment (CIKM), 2018, pp. 107–116

    2018

  4. [12]

    Enumerating maximal cliques in temporal graphs,

    A.-S. Himmel, H. Molter, R. Niedermeier, and M. Sorge, “Enumerating maximal cliques in temporal graphs,” in Proceedings of the IEEE/ACM International Conference on Advances in Social Networks Analysis and Mining (ASONAM), 2016, pp. 337–344

    2016

  5. [13]

    Modern temporal network theory: A colloquium,

    P. Holme, “Modern temporal network theory: A colloquium,” The European Physical Journal B , vol. 88, pp. 1–30, 2015

    2015

  6. [14]

    Maximum(l, k)-lasting cores in temporal social networks,

    W.-C. Hung and C.-Y . Tseng, “Maximum(l, k)-lasting cores in temporal social networks,” in Proceedings of the International Conference on Database Systems for Advanced Applications (DASFAA), 2021, pp. 336– 352

    2021

  7. [15]

    Efficient snapshot retrieval over histor- ical graph data,

    U. Khurana and A. Deshpande, “Efficient snapshot retrieval over histor- ical graph data,” in Proceedings of the IEEE International Conference on Data Engineering (ICDE) , 2013, pp. 997–1008

    2013

  8. [16]

    k-core: Theories and applications,

    Y .-X. Kong, G.-Y . Shi, R.-J. Wu, and Y .-C. Zhang, “k-core: Theories and applications,” Physics Reports, vol. 832, pp. 1–32, 2019

    2019

  9. [17]

    Persistent community search in temporal networks,

    R.-H. Li, J. Su, L. Qin, J. X. Yu, and Q. Dai, “Persistent community search in temporal networks,” in Proceedings of the IEEE International Conference on Data Engineering (ICDE) , 2018, pp. 797–808

    2018

  10. [18]

    Efficient continual cohesive subgraph search in large temporal graphs,

    Y . Li, J. Liu, H. Zhao, J. Sun, Y . Zhao, and G. Wang, “Efficient continual cohesive subgraph search in large temporal graphs,” World Wide Web, vol. 24, pp. 1483–1509, 2021

    2021

  11. [19]

    The core decomposition of networks: Theory, algorithms and applica- tions,

    F. D. Malliaros, C. Giatsidis, A. N. Papadopoulos, and M. Vazirgiannis, “The core decomposition of networks: Theory, algorithms and applica- tions,” The VLDB Journal , vol. 29, no. 1, pp. 61–92, 2020

    2020

  12. [20]

    Efficient historical butterfly counting in large temporal bipartite networks via graph structure-aware index,

    Q. Mang, J. Chen, H. Zhou, Y . Gao, Y . Zhou, R. Peng, Y . Fang, and C. Ma, “Efficient historical butterfly counting in large temporal bipartite networks via graph structure-aware index,” arXiv preprint arXiv:2406.00344, 2024

    2024 arXiv

  13. [21]

    Masuda and R

    N. Masuda and R. Lambiotte, A Guide to Temporal Networks . World Scientific, 2016

    2016

  14. [22]

    Kwiq: Answer- ing k-core window queries in temporal networks,

    M. Momin, R. Kamal, S. Dixit, S. Ranu, and A. Bagchi, “Kwiq: Answer- ing k-core window queries in temporal networks,” in Proceedings of the International Conference on Extending Database Technology (EDBT) , 2023, pp. 208–220

    2023

  15. [23]

    Newman, Networks: An Introduction

    M. Newman, Networks: An Introduction . OUP Oxford, 2010

    2010

  16. [24]

    An edge- based decomposition framework for temporal networks,

    L. Oettershagen, A. L. Konstantinidis, and G. F. Italiano, “An edge- based decomposition framework for temporal networks,” in Proceedings of the ACM International Conference on Web Search and Data Mining (WSDM), 2025, pp. 735–743

    2025

  17. [25]

    Mining bursting core in large temporal graphs,

    H. Qin, R.-H. Li, Y . Yuan, G. Wang, L. Qin, and Z. Zhang, “Mining bursting core in large temporal graphs,” Proceedings of the VLDB Endowment, vol. 15, no. 13, pp. 3911–3923, 2022

    2022

  18. [26]

    Periodic communities mining in temporal networks: Concepts and algorithms,

    H. Qin, R.-H. Li, Y . Yuan, G. Wang, W. Yang, and L. Qin, “Periodic communities mining in temporal networks: Concepts and algorithms,” IEEE Transactions on Knowledge and Data Engineering , vol. 34, no. 8, pp. 3927–3945, 2020

    2020

  19. [27]

    Network structure and minimum degree,

    S. B. Seidman, “Network structure and minimum degree,” Social Net- works, vol. 5, no. 3, pp. 269–287, 1983

    1983

  20. [28]

    Durable graph pattern queries on historical graphs,

    K. Semertzidis and E. Pitoura, “Durable graph pattern queries on historical graphs,” in Proceedings of the IEEE International Conference on Data Engineering (ICDE) , 2016, pp. 541–552

    2016

  21. [29]

    Timereach: Historical reach- ability queries on evolving graphs,

    K. Semertzidis, E. Pitoura, and K. Lillis, “Timereach: Historical reach- ability queries on evolving graphs,” in Proceedings of the International Conference on Extending Database Technology (EDBT), 2015, pp. 121– 132

    2015

  22. [30]

    Efficient querying k-trusses on temporal graphs,

    Y . Tan, C. Wang, J. Zhou, M. Du, G. Sun, and W. Zheng, “Efficient querying k-trusses on temporal graphs,” Information Processing & Management, p. 104014, 2024

    2024

  23. [31]

    Reliable community search in dynamic networks,

    Y . Tang, J. Li, N. A. H. Haldar, Z. Guan, J. Xu, and C. Liu, “Reliable community search in dynamic networks,” Proceedings of the VLDB Endowment, vol. 15, no. 11, pp. 2826–2838, 2022

    2022

  24. [32]

    Efficient scalable temporal Web graph store,

    K. D. V o, S. Zerr, X. Zhu, and W. Nejdl, “Efficient scalable temporal Web graph store,” in Proceedings of the IEEE International Conference on Big Data (BigData) , 2021, pp. 263–273

    2021

  25. [33]

    Time-dependent graphs: Def- initions, applications, and algorithms,

    Y . Wang, Y . Yuan, Y . Ma, and G. Wang, “Time-dependent graphs: Def- initions, applications, and algorithms,” Data Science and Engineering , vol. 4, no. 4, pp. 352–366, 2019

    2019

  26. [34]

    On more efficiently and versatilely querying historical k-cores,

    Z. Wang, M. Zhong, Y . Zhu, T. Qian, M. Liu, and J. X. Yu, “On more efficiently and versatilely querying historical k-cores,” Proceedings of the VLDB Endowment , vol. 18, pp. 1335–1347, 2025

    2025

  27. [35]

    Efficiently answering span-reachability queries in large temporal graphs,

    D. Wen, Y . Huang, Y . Zhang, L. Qin, W. Zhang, and X. Lin, “Efficiently answering span-reachability queries in large temporal graphs,” in Pro- ceedings of the IEEE International Conference on Data Engineering (ICDE), 2020, pp. 1153–1164

    2020

  28. [36]

    Core decomposition in large temporal graphs,

    H. Wu, J. Cheng, Y . Lu, Y . Ke, Y . Huang, D. Yan, and H. Wu, “Core decomposition in large temporal graphs,” in Proceedings of the IEEE International Conference on Big Data (BigData) , 2015, pp. 649–658

    2015

  29. [37]

    Contemporary recommendation systems on big data and their applications: A survey,

    Z. Xia, A. Sun, J. Xu, Y . Peng, R. Ma, and M. Cheng, “Contemporary recommendation systems on big data and their applications: A survey,” arXiv e-prints, pp. arXiv–2206, 2022

    2022

  30. [38]

    On querying connected components in large temporal graphs,

    H. Xie, Y . Fang, Y . Xia, W. Luo, and C. Ma, “On querying connected components in large temporal graphs,” Proceedings of the ACM on Management of Data (SIGMOD) , vol. 1, no. 2, pp. 1–27, 2023

    2023

  31. [39]

    Scalable time-range k-core query on temporal graphs,

    J. Yang, M. Zhong, Y . Zhu, T. Qian, M. Liu, and J. X. Yu, “Scalable time-range k-core query on temporal graphs,” Proceedings of the VLDB Endowment, vol. 16, no. 5, pp. 1168–1180, 2023

    2023

  32. [40]

    Evolution forest index: Towards optimal temporal k-core com- ponent search via time-topology isomorphic computation,

    ——, “Evolution forest index: Towards optimal temporal k-core com- ponent search via time-topology isomorphic computation,” Proceedings of the VLDB Endowment , vol. 17, no. 11, pp. 2840–2853, 2024

    2024

  33. [41]

    On querying historical k-cores,

    M. Yu, D. Wen, L. Qin, Y . Zhang, W. Zhang, and X. Lin, “On querying historical k-cores,” Proceedings of the VLDB Endowment , vol. 14, no. 11, pp. 2033–2045, 2021

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.