Pith. sign in

REVIEW 4 major objections 4 minor 39 references

Accelerating Historical K-Core Search in Temporal Graphs

T0 review · 4 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read A compact edge-centric binary forest reduces historical k-core component queries to a connected-component search, shrinking index cost by up to three orders of magnitude.

desk verdict A genuinely useful index idea undermined by an edge-core-time formula that omits the edge's own timestamp; the fix is a one-line max, but as written the central equivalence claim does not hold. read the letter →

arxiv 2508.18151 v1 pith:5TQ23VD2 submitted 2025-08-25 cs.DB

Zhuo Ma , Dong Wen , Kaiyu Chen , Yixiang Fang , Xuemin Lin , Wenjie Zhang This is my paper · ORCID
classification cs.DB
keywords temporalgraphsk-corehistoricalqueriescomponentsearchedgecoretimebinaryforestincrementalindexconstruction
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

This paper aims to establish that historical k-core component search (TCCS) in temporal graphs can be answered from a compact 'edge-centric binary forest' instead of from a large set of per-window spanning forests. The claim is that for any fixed start time, a forest whose nodes are edges weighted by their core times preserves exactly the connected components of the temporal k-core for every end time, so a query reduces to a breadth-first search of one connected component. If correct, this replaces the EF-Index's quadratic preprocessing and redundant storage with an $O(n)$-per-start-time index built in near-linear incremental work, while keeping queries in microseconds. That would make temporal core queries practical at fine timestamp granularity for contact tracing, fraud detection, and similar windowed analyses.

What carries the argument

The carrying object is the ECB-forest (edge-centric, connectivity-equivalent, binary forest). Given a start time $t_0$, each forest node is an edge of the temporal graph with weight $CT(e)$ (Definition 4.3); the rank of a node is its core time with ties broken by edge ID, and the parent and two children of a node are chosen as the highest-ranked edges below it that connect to each endpoint. This yields a forest with at most two children per node, and Lemma 4.11 states that all nodes in the same temporal core component are connected in the forest. The construction machinery is a set of constant-time rewrite operators, notably the WE (wedge equivalence) operator, that insert a newly appearing edge, break cycles, and identify the expired highest-ranked node as the lowest common ancestor of the two insertion anchors, so each edge insertion costs $O(h)$ for forest depth $h$.

What would settle it

Build a small temporal graph where two vertices $u$ and $v$ are already in the $k$-core at time $t_0$ through other edges, and add a single edge $(u,v,t)$ with $t > t_0$. Compute the core time of that edge by the paper's formula $\max(\mathrm{CT}(u), \mathrm{CT}(v))$; if the result is less than $t$, query the window $[t_0, t-1]$. Algorithm 1 will return $u$ and $v$ in one component via that edge, whereas a direct $k$-core computation on $G[t_0, t-1]$ has no such edge and may keep them separated. Any such discrepancy settles the question.

Watch

Extended reading notes

Core claim

The central discovery is that the temporal k-core component containing a query vertex in an arbitrary window can be recovered from a spanning forest rather than from the full core. For a fixed start time $t_0$, the paper assigns each edge a core time $CT(e)$ — the earliest end time at which the edge belongs to the k-core — and builds a minimum spanning forest (the CT-MSF) with those core times as weights. It then rewires that forest into an edge-centric binary forest (ECB-forest) in which each node is a graph edge, each node has at most two children, and the parent/child relation is dictated by the global ranking by core time. The paper claims that this forest is EC-equivalent to the temporal k-core: for every end time, the connected components of the forest's edges with core time at most $t_e$ coincide with the components of the temporal k-core, so Algorithm 1's breadth-first traversal returns exactly the query component. Across start times, the PECB-Index stores only the parent/children triples that change, yielding an index whose size and construction time beat the EF-Index by up to three orders of magnitude while retaining microsecond query latency.

Load-bearing premise

The paper's index is correct only if an edge's core time for a fixed start time is always the larger of its two endpoints' core times; an edge whose own timestamp is later than both endpoints' core times would be assigned too early an entry time, potentially connecting components before that edge exists.

Editorial extensions

If this is right

  • Any start-anchored query can be answered by a breadth-first traversal of an $O(n)$-node binary forest rather than the full temporal core.
  • Index construction cost is bounded by the forest depth per inserted edge, yielding up to 100x faster builds than the EF-Index baseline on real datasets.
  • Query time stays $O(r \log l)$ for result size $r$, keeping latencies in the microsecond range.
  • The index naturally supports fine-grained original timestamps, where the EF-Index fails to complete on most datasets.
  • Only changed parent/child triples need storage between consecutive start times, giving the PECB-Index its compact space guarantee.

Reading between the lines

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

  • Editorial inference: the ECB-forest's equivalence argument would survive a corrected edge core time that also accounts for the edge's own timestamp, since the forest machinery only uses the resulting weights; the formula in Section 5, not the structure, is the fragile point.
  • Editorial inference: any window-monotone cohesive family whose membership per edge can be summarized by an earliest entry time could plausibly be indexed the same way, so span-cores, persistent cores, or burst-detection variants are natural next targets.
  • Testable extension (editorial): on graphs with many late edges among high-core vertices, running Algorithm 1 against a brute-force k-core computation on random windows should expose any discrepancy, and the errors, if present, would concentrate exactly on the edge-core-time formula.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper studies the temporal k-core component search (TCCS) problem: given a temporal graph, a query vertex, and a time window, return the connected component of the temporal k-core that contains the query vertex. To support arbitrary windows, the paper introduces the ECB-forest, an edge-centric binary forest derived from a core-time-based minimum spanning forest for each anchored start time, and the PECB-Index, which stores only the differences between forests of adjacent start times. The paper claims a query time of O(r log l), an index size of O(n l) per start-time forest (with l the average number of labels per node), and construction cost bounded by the forest depth per inserted edge. Experiments on 15 real-world temporal graphs report large reductions in index size and construction time relative to the EF-Index while maintaining microsecond-level query latency.

Significance. If the proposed structure is correct, the contribution is significant: it offers a much more compact and faster-to-build index for a practically motivated query primitive, and the experimental study is broad. The paper also provides an artifact URL and avoids fitted parameters, grounding its derivation in the external vertex-core-time algorithm of [33] and the MST threshold property. However, the central correctness argument rests on the Section 5 edge-core-time formula, which is inconsistent with Definition 4.3. Until that formula is repaired and the subsequent proofs and experiments are reworked, the claimed guarantees are unsupported.

major comments (4)
  1. [Section 5, 'Computing Edge Core Times'; Definition 4.3] The paper states that the core time of an edge (u,v,t) for start time t0 is the larger of the core times of its terminal vertices. Definition 4.3 defines CT_{t0}(e) as the earliest end time te such that e belongs to the k-core of G[t0,te]. Since e has timestamp t, this requires t <= te, so the correct value is max(CT_{t0}(u), CT_{t0}(v), t). The omitted t is load-bearing. For example, take k=2, two disjoint triangles with all edges at time 1, and a bridge edge (a,b,10) between them. The vertex core times of a and b are 1, so the paper's formula assigns the bridge a core time of 1; the CT-MSF then connects the two triangles for every end time te >= 1, and the query [1,5] returns both triangles as one component, whereas the true 2-core component of a in [1,5] is only its triangle. This contradicts Lemma 4.7 and the EC-equivalence property of Definition 4.2, and it invalidates Algorithm 1 and the experimental claims as stated. The formula must be corrected and the construction, proofs, and experiments redone.
  2. [Section 5, Lemma 5.1] The proof of Lemma 5.1 is not a proof: it asserts that the four insertions and two deletions 'integrate' e and 'preserve reachability' without showing that for every end time te the connected components of the updated ECB-forest coincide with those of the temporal k-core. The argument does not address the edge-timestamp issue from Definition 4.3, and Lemma 5.5 (the WE operator) is stated without proof. Since Lemma 5.1 is the load-bearing invariant for Algorithm 3 and Theorem 5.9, the authors need to provide a rigorous proof, or a counterexample that motivates a different insertion rule.
  3. [Section 4.2, Theorem 4.15] The query complexity is stated as O(r log l) with r the result size, but Algorithm 1 returns vertices while the BFS visits forest nodes that represent edges. An edge component can contain quadratically more edges than vertices, so the stated bound does not follow from the proof given. The theorem should either define r as the number of visited forest nodes and derive the vertex set from it, or state the complexity as O((|V_comp| + |E_comp|) log l).
  4. [Section 6] The experiments measure index size, construction time, and query time, but they never validate that PECB-Index returns the correct k-core component against a brute-force baseline. Because the flaw in Section 5 can produce wrong query results without affecting running time, the current experiments cannot distinguish the proposed index from an incorrect one. A correctness comparison, for example on small graphs with exhaustive enumeration of windows, should be added.
minor comments (4)
  1. [Algorithm 1] The output comment in Algorithm 1 contains a typo: 'componet' should be 'component'.
  2. [Example 4.5] The sentence 'we record, so we record' is duplicated and should be reduced to a single occurrence.
  3. [Section 4.1] The claim that core times never decrease as t0 grows is intuitive but unproved; a one-sentence argument would make the monotonicity assumption precise.
  4. [Figures 4-6] The y-axis labels in Figures 4-6 do not explicitly state that the reported quantities are in seconds or megabytes; adding clear axis labels would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the ECB-forest derivation is structural, and the only overlapping-author citation is an independent algorithmic building block.

full rationale

The paper's central chain is: define edge core time from membership in the temporal k-core; form a CT-MSF using those core times as weights; argue by the MST threshold property that the forest preserves connected components of every anchored window; convert the MSF into an edge-centric binary forest via insertion and WE operations proved EC-equivalent; and finally compress forests across start times. Each step is argued from definitions and structural lemmas rather than by defining the conclusion into the premise. The PECB-Index query algorithm directly traverses this forest, and the complexity bounds follow from the binary degree bound and per-node binary search. The only overlapping-author citation is [33], used to compute vertex core times; that algorithm targets historical k-core vertex membership, not the ECB-forest/TCCS component result, so it is an independent building block rather than a smuggled conclusion. The asserted edge-core-time formula in Section 5 (max of endpoint core times) is not derived in the paper and may be false when an edge's timestamp postdates both endpoint core times, but a gap or error in a claimed lemma is a correctness risk, not circularity, because the lemma is not an identity that makes the query answer equal to its own input by construction.

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

No fitted parameters appear in the paper. The proposed objects (CT-MSF, ECB-forest, PECB-Index, WE operator) are algorithmic structures rather than postulated natural entities, so no invented-entity burden applies beyond the stated correctness assumptions listed above.

assumptions (5)
  • domain assumption K-core membership is monotone with respect to the end time of a fixed-start window.
    Used implicitly throughout Section 4 to define core times as earliest end times, e.g., Definition 4.3 and Lemma 4.7.
  • domain assumption The algorithm of [33] correctly computes vertex core times for every start time with the stated complexity bound.
    Section 5 uses it as a black box when deriving edge core times from terminal vertex core times.
  • ad hoc to paper The core time of an edge equals the larger core time of its terminal vertices.
    Stated in Section 5 without proof; it is false under Definition 4.3 when an edge's timestamp is later than both endpoint core times, e.g., a late cross edge between two already-existing k-core components.
  • standard math A minimum spanning forest preserves the connected components of every threshold subgraph defined by edge weights.
    Classic MST cut property underlying Lemma 4.7, which gives the CT-MSF its EC-equivalence.
  • ad hoc to paper The insertion and deletion operations in Lemma 5.1 preserve EC-equivalence and edge-connectedness of the ECB-forest.
    The proof in the text is a short reachability paragraph without exhaustive cycle cases; correctness of Algorithm 3 depends on it.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Accelerating Historical K-Core Search in Temporal Graphs." pith.science (2026). https://pith.science/paper/5TQ23VD2

@misc{pith2026250818151,
  author       = {Pith},
  title        = {Pith review of: Accelerating Historical K-Core Search in Temporal Graphs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5TQ23VD2}},
  note         = {Machine review of arXiv:2508.18151}
}
read the original abstract

We study the temporal k-core component search (TCCS), which outputs the k-core containing the query vertex in the snapshot over an arbitrary query time window in a temporal graph. The problem has been shown to be critical for tasks such as contact tracing, fault diagnosis, and financial forensics. The state-of-the-art EF-Index designs a separated forest structure for a set of carefully selected windows, incurring quadratic preprocessing time and large redundant storage. Our method introduces the ECB-forest, a compact edge-centric binary forest that captures k-core of any arbitrary query vertex over time. In this way, a query can be processed by searching a connected component in the forest. We develop an efficient algorithm for index construction. Experiments on real-world temporal graphs show that our method significantly improves the index size and construction cost (up to 100x faster on average) while maintaining the high query efficiency.

Figures

Figures reproduced from arXiv: 2508.18151 by the authors.

Figure 1
Figure 1. A temporal graph and its projected graph [4,5] . The -cores [26] of a graph are the maximal induced connected subgraphs in which every vertex has degree at least within the subgraph. Thanks to its simplicity and effectiveness at capturing cohesion, the -core has attracted significant research attention due to its wide range of applications, including community detec￾tion, network visualization, and system structure … view at source ↗
Figure 2
Figure 2. The CT-MSF and the corresponding ECB-Forest of [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. An illustration of the process of adding the edge [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Index space for datasets with timestamps by days. [PITH_FULL_IMAGE:figures/full_fig_p010_4.png]
Figure 5
Figure 5. Figure 5: Construction time for datasets with timestamps by [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: Average query time on datasets with timestamps by d [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]
Figure 7
Figure 7. Figure 7: Index space for datasets with timestamp grouped by [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]
Figure 8
Figure 8. Figure 8: Construction time for datasets with timestamp gro [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 9
Figure 9. Figure 9: Average query time on datasets with timestamps gro [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]
Figure 10
Figure 10. Figure 10: Index space for the original datasets. F [PITH_FULL_IMAGE:figures/full_fig_p012_10.png]
Figure 11
Figure 11. Figure 11: Construction time for the original dataset. [PITH_FULL_IMAGE:figures/full_fig_p012_11.png]
Figure 12
Figure 12. Figure 12: Average query time on the original datasets. [PITH_FULL_IMAGE:figures/full_fig_p012_12.png]

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

39 extracted references · 25 canonical work pages

  1. [33]

    Michael Yu, Dong Wen, Lu Qin, Ying Zhang, Wenjie Zhang, a nd Xuemin Lin

    work page

  2. [1]

    Hidayet Aksu, Mustafa Canim, Yuan-Chi Chang, Ibrahim Ko rpeoglu, and Özgür Ulusoy. 2014. Distributed /u1D458 -Core View Materialization and Maintenance for Large Dynamic Graphs. IEEE Transactions on Knowledge and Data Engineering 26, 10 (2014), 2439–2452

    work page 2014

  3. [2]

    Kemafor Anyanwu and Amit P. Sheth. 2003. /u1D70C-Queries: Enabling Querying for Semantic Associations on the Semantic Web. In Proceedings of the Twelfth International World Wide Web Conference, WWW 2003, Budapest, Hungary, May 20-24, 2003, Gusztáv Hencsey, Bebo White, Yih-Farn Robin Chen, László Kovács, and Steve Lawrence (Eds.). ACM, 690–699

    work page 2003

  4. [3]

    Wen Bai, Yadi Chen, and Di Wu. 2020. Efficient Temporal Core Mainte- nance of Massive Graphs. Information Sciences 513 (March 2020), 324–340. https://doi.org/10.1016/J.INS.2019.11.003

    work page doi:10.1016/j.ins.2019.11.003 2020

  5. [4]

    Vladimir Batagelj and Matjaz Zaversnik. 2003. An o (m) al gorithm for cores decomposition of networks. arXiv preprint cs/0310049 (2003)

    arXiv 2003

  6. [5]

    Tamer Ozsu

    James Cheng, Yiping Ke, Shumo Chu, and M. Tamer Ozsu. 2011 . Efficient Core Decomposition in Massive Networks. Proceedings - International Conference on Data Engineering (2011), 51–62. https://doi.org/10.1109/ICDE.2011.5767 911

    work page arXiv 2011

  7. [6]

    Lingyang Chu, Yanyan Zhang, Yu Yang, Lanjun Wang, and Jia n Pei

    work page

  8. [7]

    Wanyun Cui, Yanghua Xiao, Haixun Wang, and Wei Wang. 2014 . Lo- cal Search of Communities in Large Graphs. Proceedings of the ACM SIGMOD International Conference on Management of Data (2014), 991–1002. https://doi.org/10.1145/2588555.2612179

    work page arXiv 2014

Show all 39 references
  1. [8]

    Laxman Dhulipala, Guy Blelloch, and Julian Shun. 2017. J ulienne: A framework for parallel graph algorithms using work-efficient bucketin g. In Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Archi tectures. 293– 304

    2017

  2. [9]

    Edoardo Galimberti, Alain Barrat, Francesco Bonchi, Ci ro Cattuto, and Francesco Gullo. 2018. Mining (Maximal) Span-Cores from Temporal Networks. International Conference on Information and Knowledge Man agement, Proceed- ings (Oct. 2018), 107–116. https://doi.org/10.1145/3269...

    2018 doi

  3. [10]

    Petter Holme and Jari Saramäki. 2012. Temporal Network s. Physics reports 519, 3 (2012), 97–125

    2012

  4. [11]

    Svante Janson and Malwina J. Luczak. 2005. A Simple Solu tion to the K- Core Problem. Random Structures and Algorithms 30, 1-2 (Aug. 2005), 50–62. https://doi.org/10.1002/rsa.20147

    2005 doi

  5. [12]

    Wissam Khaouid, Marina Barsky, Venkatesh Srinivasan, and Alex Thomo. 2015. K-core decomposition of large networks on a single PC. Proceedings of the VLDB Endowment 9, 1 (2015), 13–23

    2015

  6. [13]

    Gregory Levitin, Liudong Xing, and Shengji Yu. 2014. Op timal Connecting Ele- ments Allocation in Linear Consecutively-Connected Systems with Phased Mis- sion and Common Cause Failures. Reliability Engineering & System Safety 130 (2014), 85–94

    2014

  7. [14]

    Rong Hua Li, Jiao Su, Lu Qin, Jeffrey Xu Yu, and Qiangqiang Dai. 2018. Per- sistent Community Search in Temporal Networks. Proceedings - IEEE 34th International Conference on Data Engineering, ICDE 2018 (Oct. 2018), 797–808. https://doi.org/10.1109/ICDE.2018.00077

    2018

  8. [15]

    Rong Hua Li, Jeffrey Xu Yu, and Rui Mao. 2014. Efficient Core Maintenance in Large Dynamic Graphs. IEEE Transactions on Knowledge and Data Engineering 26, 10 (Oct. 2014), 2453–2465. https://doi.org/10.1109/T KDE.2013.158

    2014 doi

  9. [16]

    Yuan Li, Jinsheng Liu, Huiqun Zhao, Jing Sun, Yuhai Zhao , and Guoren Wang

  10. [17]

    Longlong Lin, Pingpeng Yuan, Rong-Hua Li, Chunxue Zhu, Hongchao Qin, Hai Jin, and Tao Jia. 2024. QTCS: Efficient Query-Centered Tem poral Community Search. Proc. VLDB Endow. 17, 6 (Feb. 2024), 1187–1199. https://doi.org/10.14778/3648160.3648163

    2024

  11. [18]

    Shuai Ma, Renjun Hu, Luoshu Wang, Xuelian Lin, and Jinpe ng Huai. 2020. An Efficient Approach to Finding Dense Temporal Subgraphs. IEEE Trans- actions on Knowledge and Data Engineering 32, 04 (April 2020), 645–658. https://doi.org/10.1109/TKDE.2019.2891604

    2020

  12. [19]

    Zijun Mao, Hong Yao, Qi Zou, Weiting Zhang, Ying Dong, et al. 2021. Digital Contact Tracing Based on a Graph Database Algorithm for Emergency Manage- ment during the COVID-19 Epidemic: Case Study. JMIR mHealth and uHealth 9, 1 (2021), e26836

    2021

  13. [20]

    Mahdihusain Momin, Raj Kamal, Shantwana Dixit, Sayan R anu, and Amitabha Bagchi. 2023. KWIQ: Answering k-Core Window Queries in Temp oral Net- works. https://doi.org/10.48786/EDBT.2023.17

    2023 doi

  14. [21]

    Alberto Montresor, Francesco De Pellegrini, and Danie le Miorandi. 2011. Dis- tributed k-core decomposition. In Proceedings of the 30th annual ACM SIGACT- SIGOPS symposium on principles of distributed computing . 207–208

    2011

  15. [22]

    Katerina Pechlivanidou, Dimitrios Katsaros, and Lean dros Tassiulas. 2014. MapReduce-based distributed k-shell decomposition for on line social networks. In 2014 IEEE World Congress on Services . IEEE, 30–37

    2014

  16. [23]

    Hongchao Qin, Rong Hua Li, Guoren Wang, Lu Qin, Yurong Ch eng, and Ye Yuan. 2019. Mining Periodic Cliques in Temporal Networks. Proceedings - In- ternational Conference on Data Engineering 2019-April (April 2019), 1130–1141. https://doi.org/10.1109/ICDE.2019.00104

    2019

  17. [24]

    Hongchao Qin, Rong Hua Li, Ye Yuan, Guoren Wang, Weihua Y ang, and Lu Qin. 2022. Periodic Communities Mining in Temporal Network s: Concepts and Algorithms. IEEE Transactions on Knowledge and Data Engineering 34, 8 (Aug. 2022), 3927–3945. https://doi.org/10.1109/TKDE.2020.3 028025

    2022 doi

  18. [25]

    Çatalyürek

    Ahmet Erdem Sariyüce, Bu ˇgra Gedik, Gabriela Jacques-Silva, Kun Lung Wu, and ümit V. Çatalyürek. 2013. Streaming Algorithms for K-Co re Decom- position. Proceedings of the VLDB Endowment 6, 6 (April 2013), 433–444. https://doi.org/10.14778/2536336.2536344

    2013

  19. [26]

    Stephen B. Seidman. 1983. Network Structure and Minimu m Degree. Social Net- works 5, 3 (Sept. 1983), 269–287. https://doi.org/10.1016/0378 -8733(83)90028-X

    1983 doi

  20. [27]

    Lei Tang, Huan Liu, Jianping Zhang, and Zohreh Nazeri. 2 008. Community Evolution in Dynamic Multi-Mode Networks. In Proceedings of the 14th ACM SIGKDD International Conference on Knowledge Discovery an d Data Mining, Las Vegas, Nevada, USA, August 24-27, 2008 , Ying Li, Bing ...

    2008

  21. [28]

    Dong Wen, Lu Qin, Ying Zhang, Xuemin Lin, and Jeffrey Xu Yu . 2015. I/O Efficient Core Graph Decomposition at Web Scale. 2016 IEEE 32nd Inter- national Conference on Data Engineering, ICDE 2016 (Nov. 2015), 133–144. https://doi.org/10.1109/ICDE.2016.7498235

    2015

  22. [29]

    Huanhuan Wu, James Cheng, Yi Lu, Yiping Ke, Yuzhen Huang , Da Yan, and Hejun Wu. 2015. Core Decomposition in Large Temporal Graphs . 2015 IEEE International Conference on Big Data (Big Data) (Oct. 2015), 649–658. https://doi.org/10.1109/BIGDATA.2015.7363809

    2015

  23. [30]

    Haoxuan Xie, Yixiang Fang, Yuyang Xia, Wensheng Luo, an d Chenhao Ma. 2023. On Querying Connected Components in Large Temporal Graphs. Proc. ACM Manag. Data 1, 2 (2023), 170:1–170:27

    2023

  24. [31]

    Junyong Yang, Ming Zhong, Yuanyuan Zhu, Tieyun Qian, Me ngchi Liu, and Jeffrey Xu Yu. 2023. Scalable Time-Range k-Core Query on T emporal Graphs. Proceedings of the VLDB Endowment 16, 5 (Jan. 2023), 1168–1180. https://doi.org/10.14778/3579075.3579089

    2023

  25. [32]

    Junyong Yang, Ming Zhong, Yuanyuan Zhu, Tieyun Qian, Me ngchi Liu, and Jeffrey Xu Yu. 2024. Evolution Forest Index: Towards Optimal Temporal k-Core Component Search via Time-Topology Isomorphic Computatio n. Proc. VLDB Endow. 17, 11 (July 2024), 2840–2853. https://doi.org/10.14...

    2024

  26. [34]

    Haohua Zhang, Hai Zhao, Wei Cai, Jie Liu, and Wanlei Zhou . 2010. Us- ing the K-Core Decomposition to Analyze the Static Structur e of Large-Scale Software Systems. Journal of Supercomputing 53, 2 (Aug. 2010), 352–369. https://doi.org/10.1007/S11227-009-0299-0

    2010 doi

  27. [35]

    Yikai Zhang, Jeffrey Xu Yu, Ying Zhang, and Lu Qin. 2016. A Fast Order-Based Approach for Core Maintenance. Proceedings - International Conference on Data Engineering 0 (June 2016), 337–348. https://doi.org/10.1109/ICDE.20 17.93 14

    2016 doi

  28. [37]

    On Querying Historical K-Cores. Proc. VLDB Endow. 14, 11 (2021), 2033– 2045

    2021

  29. [1509]

    https://doi.org/10.1007/S11280-021-00917-Z/MET RICS

    doi

  30. [2019]

    Proceedings of the VLDB Endowment 12, 13 (Sept

    Online Density Bursting Subgraph Detection from Temp oral Graphs. Proceedings of the VLDB Endowment 12, 13 (Sept. 2019), 2353–2365. https://doi.org/10.14778/3358701.3358704

    2019

  31. [2021]

    World Wide Web-internet and Web Information Systems 24, 5 (Sept

    Efficient Continual Cohesive Subgraph Search in Large T emporal Graphs. World Wide Web-internet and Web Information Systems 24, 5 (Sept. 2021), 1483–

    2021

Pith tools

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