Pith. sign in

REVIEW 3 major objections 4 minor 69 references

Triadic First-Order Logic Queries in Temporal Networks

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

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

Pith's one-line read The paper introduces thresholded first-order logic triadic queries for temporal networks and an algorithm, FOLTY, that answers them in time matching the best temporal triangle counters.

desk verdict A genuinely new query class and a fast algorithm, but the in-neighbor segment-tree counting is under-specified and the exactness claim is not yet proven. read the letter →

arxiv 2507.17215 v1 pith:OTOOMS6D submitted 2025-07-23 cs.DB cs.DScs.IRcs.SI

Omkar Bhalerao , Yunjie Pan , C. Seshadhri , Nishil Talati This is my paper · ORCID
classification cs.DBcs.DScs.IRcs.SI
keywords temporalnetworksmotifcountingfirst-orderlogictriangledegeneracyorientationsegmenttreesthresholdedquantifiers
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 introduces thresholded first-order logic (FOL) triadic queries for temporal networks, a query language that mixes existential quantifiers with quantifiers that require satisfaction for at least a τ-fraction of a vertex neighborhood. The central claim is that all four kinds of such queries can be answered exactly by one algorithm, FOLTY, in O(m α log σ_max) time, matching the best known temporal triangle counting bound. If true, this means rich pattern queries like "find all pairs (u,v) such that for most w that share a temporal edge with u, the temporal triangle (u,v,w) occurs within a time window" can be mined at the same cost as ordinary temporal triangle counting. The implementation reported handles graphs with nearly 70 million edges in under an hour on commodity hardware.

What carries the argument

The central mechanism is a degeneracy orientation of the underlying static graph, which guarantees that every vertex has at most α out-neighbours. Out-neighbour contributions are handled by scanning edge lists incident to the lower-ordered endpoint; in-neighbour contributions are handled by a segment tree per static edge that stores timestamp intervals, with a three-phase lazy-update scheme that ensures each distinct in-neighbour is counted exactly once. The segment tree turns a potential O(σ_max) per-query cost into an O(log σ_max) lookup.

What would settle it

Take a small temporal graph in which one in-neighbour w yields two overlapping intervals for the same query timestamp, so a naive segment tree would count w twice. Run FOLTY's in-count computation on that graph and compare against brute-force enumeration of all δ-temporal triangles; any overcount or undercount would refute the exactness claim.

Watch

Extended reading notes

Core claim

FOLTY exactly computes and enumerates solutions to any thresholded FOL triadic query in O(m α log σ_max) time, where m is the number of temporal edges, α the degeneracy of the underlying static graph, and σ_max the maximum number of parallel temporal edges. This matches the running time of the best temporal triangle counters and, up to log factors, the classic O(m α) bound for static triangle listing. The algorithm obtains these solutions without enumerating all temporal triangles, which can number in the billions. It unifies the four quantifier patterns, reducing the ∃∀∃ and ∃∀∀ queries to the ∃∃∀ query.

Load-bearing premise

The correctness of the in-neighbor counting procedure rests on the segment tree lazy-update scheme: the sum of counters along the suitable path equals the number of distinct in-neighbors w in N−(u)∩N(v) that form at least one δ-temporal triangle with e. That claim is only sketched in Section 3.3 and Appendix A.1, and the pseudocode in Algorithm 4 appears to use the out-neighbor loop, leaving the in-neighbor computation underspecified; if this counting is wrong, the exactness guarantee collapses.

Editorial extensions

If this is right

  • Thresholded FOL queries such as 'most neighbours of u form a δ-temporal triangle with edge (u,v)' can now be executed on graphs with tens of millions of edges in minutes.
  • FOLTY removes the need to materialize all temporal triangles when only aggregate or thresholded answers are needed.
  • The reductions among the four quantifier patterns mean a single implementation of the core ∃∃∀ routine covers all query forms.
  • The technique generalizes to other temporal triangle predicates beyond the specific motif used in the paper's examples.
  • Applications in financial transaction monitoring (scatter-gather, bipartite laundering patterns) and citation-network analysis become feasible at scale.

Reading between the lines

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

  • The segment-tree plus degeneracy-orientation combination is not inherently limited to triangles; analogous machinery might answer thresholded FOL queries on 4-vertex patterns, though the time bound may not carry over unchanged.
  • Because the query semantics use thresholds, one could derive approximate answers by sampling neighbours rather than exact counting, trading the O(α log σ_max) per-edge cost for sublinear estimates.
  • A streaming variant of FOLTY might be possible if edge timestamps arrive in order, since the segment trees are built on timestamp-sorted lists.
  • The flattening of solution counts above a threshold (around 0.7) observed in the experiments suggests a robustness property: edges that form triangles with 70% of their neighbourhood often form them with almost all of it; this could be tested as a hypothesis on other datasets.
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 / 4 minor

Summary. The paper introduces thresholded first-order logic (FOL) triadic queries for temporal networks, in which a query consists of a prefix of existential and thresholded universal quantifiers followed by a temporal triangle predicate. The authors define four query types (∃∃∃, ∃∃∀, ∃∀∃, ∃∀∀) and propose FOLTY, an algorithm that computes per-temporal-edge in-count and out-count arrays using degeneracy orientation and segment-tree interval data structures, and then derives solutions to the three non-trivial query types from these counts. The claimed running time is O(m α log σmax), matching the best known temporal triangle counting bound. The paper reports an implementation and experiments on SNAP datasets with up to 63.5 million edges.

Significance. If the central correctness claim holds, this is a substantial contribution: it is the first algorithm for thresholded FOL triadic motif queries and it achieves a runtime matching the best temporal triangle counters, without enumerating all temporal triangles. The paper's strengths include the clean proofs for the out-neighbor case (Theorems 3.1-3.3), the use of Chiba-Nishizeki degeneracy orientation, a unified treatment of four query types, and an empirical evaluation with publicly available code. The parameters (thresholds τ and time window δ) are user-supplied, not fitted, and the theoretical analysis is not circular. However, the exactness of the in-neighbor counting procedure, which is load-bearing for all three thresholded query types, is not established as written because the segment-tree insertion scheme is underspecified for multiple interval lists, and the pseudocode for that subroutine is inconsistent with the prose. The contribution is therefore promising but requires a corrected proof and pseudocode before the main claims can be accepted.

major comments (3)
  1. [Section 3.3 / Appendix A.1] The lazy segment-tree scheme is specified for a single list of intervals, but the in-neighbor computation inserts many lists I_{w,u,v} (one per in-neighbor w) into the same tree T_{u,v}. The text does not state whether Phases 1 and 2 are executed per list or jointly over all lists. If they are executed jointly, the scheme is incorrect: consider lists L_w = {[6,13],[8,10]} and L_z = {[8,14]}, with canonical nodes [7,10] and [9,10] respectively. Phase 2 recolors [9,10] to white because [7,10] is grey, even though the counter at [7,10] belongs to w, not z. In Phase 3, the Vertex check at [7,10] sees Vertex != z and descends, only to find [9,10] white, so no counter is added for z; a query at t=9 returns 1 instead of 2. If Phases 1-2 are intended per list, the scheme may be correct, but this is not stated and Algorithm 4 has no per-list phase loop. Consequently, Theorem A.1 does not establish the invariant that the path sum equals the number of distinct in-neighbor lists containing an interval that covers the query timestamp, and the central O(m α log σmax) exactness claim for in-count is not proven.
  2. [Algorithm 4, lines 5-9] The pseudocode is inconsistent with the prose in Section 3.2. The prose states that for the case L1 <- E_{w,v}, the algorithm sets L2 <- E_{w,u} and L3 <- E_{v,u}, and for the mirrored case L1 <- E_{w,u} it sets L2 <- E_{w,v} and L3 <- E_{u,v}. Algorithm 4, line 5 instead sets L2 <- E_{v,u}, L3 <- E_{w,u}, L'2 <- E_{w,u}, and L'3 <- E_{v,u}, which swaps the roles of the two endpoints. This makes it impossible to verify the correctness of the interval construction I_{u,v,w} and I_{u,w,v} against Theorem 3.4, and it also obscures how the segment tree receives the lists for different in-neighbors. The pseudocode must be corrected and aligned with the proof.
  3. [Abstract and Section 1.3] The paper claims that FOLTY can exactly compute and enumerate solutions to 'any thresholded FOL triadic query', but the algorithm and proofs are developed only for the specific temporal triangle in Figure 2a with the temporal constraint t1 ≤ t2 ≤ t3 ≤ t1 + δ. Section 1.2 says the techniques 'can be generalized', but no generalization is proved or described. Since different temporal triangles can have different edge orderings and window constraints, the interval construction and the correctness arguments in Sections 3.2-3.3 do not automatically transfer. The scope of the contribution should be stated precisely (e.g., for the family of triangles reducible to this ordering), or a general reduction should be provided.
minor comments (4)
  1. [Abstract] The sentence 'can answer triadic FOL queries on graphs with nearly 70M edges is less than hour' is ungrammatical and inconsistent with the experimental tables: the largest reported graph (sx-stackoverflow) has 63.5M edges and takes about 956 seconds.
  2. [Section 5.1] In the paragraph 'Number of solutions for a fixed threshold, varying delta', the text first states that the number of solutions decreases as δ increases, then says that the increase in the number of solutions with increasing δ is explained. The correct monotonicity is non-decreasing in δ, so the first sentence should be corrected.
  3. [Section 3.1] The section begins by saying 'We defer the proofs of the theorems in this section to the supplementary material', but the proofs of Theorems 3.1 and 3.2 appear in the main text immediately after the statements.
  4. [Algorithms 4 and 6] The subroutine names are inconsistent: the text defines FindExceedingEntryLS and FindExceedingEntryBS, but Algorithm 4 calls FirstExceedingEntryLS and Algorithm 6 calls FirstExceedingEntry. The names should be unified.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: FOLTY's derivation is self-contained; the identified in-neighbor counting gap is an underspecification/correctness issue, not a circular reduction.

full rationale

FOLTY contains no fitted parameters: thresholds tau and delta are user-supplied, and the algorithm's outputs are exact counts rather than predictions calibrated to data. The out-neighbor cases are proven directly (Theorems 3.1 and 3.2) from the definitions of FindExceedingEntry and FindBoundingEntry, and the in-neighbor reduction is proven in Theorem 3.4 as an interval-containment equivalence. The segment-tree construction in Section 3.3 and Appendix A.1 is a data-structure implementation of that equivalence; the lazy three-phase coloring is designed to prevent double-counting intervals from the same in-neighbor list. The proof of Theorem A.1 only establishes the runtime and leaves the distinct-list invariant largely asserted (the text says 'the hope is that this sum is equal to the number of lists'), and Algorithm 4's variable naming is inconsistent with the prose. That is a genuine correctness gap, not circularity: the invariant is not assumed as an input; it is an unproven property of the proposed procedure. The paper's citation to Pashanasangi-Seshadhri [39] for the 'best known temporal triangle counter' is a benchmark comparison; the O(m alpha log sigma_max) bound is derived from Chiba-Nishizeki's lemma and the degeneracy bound within this paper, not imported from [39]. No derivation step reduces to its own input by construction, no fitted constant is renamed as a prediction, and no uniqueness claim is carried by self-citation. The principal weakness is an omitted correctness proof, which belongs under correctness risk rather than circularity.

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

The algorithm has no fitted parameters; δ, τ1, and τ2 are user query inputs. The theoretical bound relies on standard degeneracy ordering and the Chiba-Nishizeki lemma, plus a domain assumption about sorted temporal edge lists. The main ad hoc assumption is the correctness of the segment tree lazy-update scheme for in-neighbor counting, which is not fully proven in the available text.

assumptions (5)
  • standard math The underlying static graph G_S has degeneracy α, and a degeneracy ordering π can be computed in O(|E|) time, with the Chiba-Nishizeki sum-of-degrees lemma Σ d_e = O(mα).
    Invoked in Section 2 to construct G→π and to prove the O(mα log σ_max) bound; relies on [8] and [32].
  • domain assumption Temporal edges are presented as lists sorted by timestamp with O(1) access, and the temporal motif definitions from [38,39] apply.
    Assumed in the Preliminaries and used by all subroutines (FindExceedingEntry, FindBoundingEntry, segment tree construction).
  • domain assumption All triadic FOL queries begin with an existential quantifier; queries beginning with a universal quantifier can be transformed using negation and De Morgan's laws.
    Stated in Section 1.2 to restrict the query types to four (∃∃∃, ∃∃∀, ∃∀∃, ∃∀∀).
  • ad hoc to paper The predicate φ is the specific temporal triangle in Figure 2a, and the techniques generalize to other temporal triangles.
    Section 1.3 asserts generalization without proof; the algorithm is only described for one triangle ordering.
  • ad hoc to paper The segment tree lazy-update procedure correctly counts distinct in-neighbors without double-counting intervals from the same vertex.
    Section 3.3 and Appendix A.1 describe a three-phase coloring scheme, but the correctness proof is only sketched and some details are deferred to an unavailable supplementary.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Triadic First-Order Logic Queries in Temporal Networks." pith.science (2026). https://pith.science/paper/OTOOMS6D

@misc{pith2026250717215,
  author       = {Pith},
  title        = {Pith review of: Triadic First-Order Logic Queries in Temporal Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OTOOMS6D}},
  note         = {Machine review of arXiv:2507.17215}
}
abstract

Motif counting is a fundamental problem in network analysis, and there is a rich literature of theoretical and applied algorithms for this problem. Given a large input network $G$, a motif $H$ is a small "pattern" graph indicative of special local structure. Motif/pattern mining involves finding all matches of this pattern in the input $G$. The simplest, yet challenging, case of motif counting is when $H$ has three vertices, often called a "triadic" query. Recent work has focused on "temporal graph mining", where the network $G$ has edges with timestamps (and directions) and $H$ has time constraints. Inspired by concepts in logic and database theory, we introduce the study of "thresholded First Order Logic (FOL) Motif Analysis" for massive temporal networks. A typical triadic motif query asks for the existence of three vertices that form a desired temporal pattern. An "FOL" motif query is obtained by having both existential and thresholded universal quantifiers. This allows for query semantics that can mine richer information from networks. A typical triadic query would be "find all triples of vertices $u,v,w$ such that they form a triangle within one hour". A thresholded FOL query can express "find all pairs $u,v$ such that for half of $w$ where $(u,w)$ formed an edge, $(v,w)$ also formed an edge within an hour". We design the first algorithm, FOLTY, for mining thresholded FOL triadic queries. The theoretical running time of FOLTY matches the best known running time for temporal triangle counting in sparse graphs. We give an efficient implementation of FOLTY using specialized temporal data structures. FOLTY has excellent empirical behavior, and can answer triadic FOL queries on graphs with nearly 70M edges is less than hour on commodity hardware. Our work has the potential to start a new research direction in the classic well-studied problem of motif analysis.

Figures

Figures reproduced from arXiv: 2507.17215 by the authors.

Figure 1
Figure 1. Different Money-Laundering and Gambling Pat [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Consider the query ∃𝑢 ∃𝑣 ∀𝑤 ∈ 𝑁 (𝑢), the edges (𝑢, 𝑣), (𝑢,𝑤), and (𝑣,𝑤) occur within 20 timesteps. In the left figure, the edge (𝑢, 𝑣) is a solution. In the right figure, it is not a so￾lution. Triangle (𝑢, 𝑣, 𝑥) violations the timestamp constraint, while triangle (𝑢, 𝑣,𝑤) violates the directions. 𝑤. In each of these triangles, the edge (𝑢, 𝑣) appears first, followed by the edge (𝑣,𝑤) and finally the edge (𝑤, 𝑢). Fu… view at source ↗
Figure 3
Figure 3. We apply FOLTY to the Venmo transaction Net [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Insertion into Segment Trees, different phases [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Number of solutions to different queries for a fixed [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Number of solutions to different queries for a vary [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]
Figure 7
Figure 7. Figure 7: Number of solutions to different queries for a vary [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Insertion into Segment Trees Typically, given a collection of intervals 𝐿, its segment tree is built using the distinct endpoints of the intervals in 𝐿 [9]. However, in our case, the number of such endpoints can be very large. Instead we build 𝑇𝑢,𝑣 (and 𝑇𝑣,𝑢) using the…
Figure 9
Figure 9. Figure 9: Insertion into Segment Trees, different phases [PITH_FULL_IMAGE:figures/full_fig_p017_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

69 extracted references · 57 canonical work pages

  1. [1]

    Serge Abiteboul, Richard Hull, and Victor Vianu. 1995. Foundations of Databases. Addison-Wesley. http://webdam.inria.fr/Alice/

    1995

  2. [2]

    Nesreen K Ahmed, Nick Duffield, Jennifer Neville, and Ramana Kompella. 2014. Graph sample and hold: A framework for big-graph analytics. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining. 1446–1455

    work page 2014

  3. [3]

    Nesreen K Ahmed, Nick Duffield, and Ryan A Rossi. 2021. Online sampling of temporal networks. ACM Transactions on Knowledge Discovery from Data (TKDD) 15, 4 (2021), 1–27

    work page 2021

  4. [4]

    Erik Altman, Jovan Blanuša, Luc von Niederhäusern, Béni Egressy, Andreea Anghel, and Kubilay Atasu. 2023. Realistic synthetic financial transactions for anti-money laundering models. In Proc. of Neural Information Processing Systems (NeurIPS). 29851–29874

    work page 2023

  5. [5]

    Marcelo Arenas and Gonzalo I. Diaz. 2016. The Exact Complexity of the First- Order Logic Definability Problem. ACM Trans. Database Syst. 41, 2 (2016), 13:1– 13:14. https://doi.org/10.1145/2886095

    work page doi:10.1145/2886095 2016

  6. [6]

    Xin-Wei Cai, Xiangyu Ke, Kai Wang, Lu Chen, Tianming Zhang, Qing Liu, and Yunjun Gao. 2023. Efficient Temporal Butterfly Counting and Enumeration on Temporal Bipartite Graphs. CoRR abs/2306.00893 (2023). doi:10.48550/ARXIV. 2306.00893

    arXiv doi:10.48550/arxiv.2306.00893 2023

  7. [7]

    Chandra and David Harel

    Ashok K. Chandra and David Harel. 1980. Computable Queries for Relational Data Bases. J. Comput. Syst. Sci. 21, 2 (1980), 156–178. https://doi.org/10.1016/0022- 0000(80)90032-X

    doi:10.1016/0022- 1980

  8. [8]

    Norishige Chiba and Takao Nishizeki. 1985. Arboricity and Subgraph Listing Algorithms. SIAM J. Comput. 14, 1 (1985), 210–223. doi:10.1137/0214017

    doi:10.1137/0214017 1985

Show all 69 references
  1. [9]

    van Kreveld, and Mark H

    Mark de Berg, Otfried Cheong, Marc J. van Kreveld, and Mark H. Overmars

  2. [10]

    Mehrdad Farajtabar, Manuel Gomez-Rodriguez, Yichen Wang, Shuang Li, Hongyuan Zha, and Le Song. 2018. COEVOLVE: A Joint Point Process Model for Information Diffusion and Network Co-evolution. In Companion of the The Web Conference 2018 on The Web Conference 2018, WWW 2018, Lyon...

    2018

  3. [11]

    Turull Torres

    Flavio Antonio Ferrarotti, Alejandra Lorena Paoletti, and José M. Turull Torres

  4. [12]

    Zhongqiang Gao, Chuanqi Cheng, Yanwei Yu, Lei Cao, Chao Huang, and Junyu Dong. 2022. Scalable motif counting for large-scale temporal graphs. In 2022 IEEE 38th International Conference on Data Engineering (ICDE) . IEEE, 2656–2668

    2022

  5. [13]

    Noé Gaumont, Clémence Magnien, and Matthieu Latapy. 2016. Finding remark- ably dense sequences of contacts in link streams. Soc. Netw. Anal. Min. 6, 1 (2016), 87:1–87:14

    2016

  6. [14]

    Martin Grohe. 2011. From polynomial time queries to graph structure theory. Commun. ACM 54, 6 (2011), 104–112. doi:10.1145/1953122.1953150

    2011

  7. [15]

    Martin Grohe, Stephan Kreutzer, and Sebastian Siebertz. 2014. Deciding first- order properties of nowhere dense graphs. InSymposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31 - June 03, 2014 , David B. Shmoys (Ed.). ACM, 89–98

    2014

  8. [16]

    László Hajdu and Miklós Krész. 2020. Temporal network analytics for fraud detection in the banking sector. InInternational Conference on Theory and Practice of Digital Libraries. Springer, 145–157

    2020

  9. [17]

    Mohammad Al Hasan and Vachik S. Dave. 2018. Triangle counting in large networks: a review. WIREs Data Mining Knowl. Discov. 8, 2 (2018)

    2018

  10. [18]

    Jack Hessel, Chenhao Tan, and Lillian Lee. 2016. Science, askscience, and bad- science: On the coexistence of highly related communities. In Proceedings of the international AAAI conference on web and social media , Vol. 10. 171–180

    2016

  11. [19]

    Pfeiffer III, Timothy La Fond, Sebastián Moreno, and Jennifer Neville

    Joseph J. Pfeiffer III, Timothy La Fond, Sebastián Moreno, and Jennifer Neville

  12. [20]

    Anand Padmanabha Iyer, Zaoxing Liu, Xin Jin, Shivaram Venkataraman, Vladimir Braverman, and Ion Stoica. 2018. ASAP: Fast, approximate graph pattern mining at scale. In 13th USENIX Symposium on Operating Systems Design and Implemen- tation (OSDI 18). 745–761

    2018

  13. [21]

    Madhav Jha, C Seshadhri, and Ali Pinar. 2015. Path sampling: A fast and prov- able method for estimating 4-vertex subgraph counts. In Proceedings of the 24th international conference on world wide web . 495–505

    2015

  14. [22]

    Wojciech Kazana and Luc Segoufin. 2018. First-order queries on classes of struc- tures with bounded expansion. CoRR abs/1802.04613 (2018). arXiv:1802.04613 http://arxiv.org/abs/1802.04613

    2018 arXiv

  15. [23]

    Arijit Khan, Nan Li, Xifeng Yan, Ziyu Guan, Supriyo Chakraborty, and Shu Tao

  16. [24]

    Dániel Kondor, Nikola Bulatovic, József Stéger, István Csabai, and Gábor Vattay

  17. [25]

    Lauri Kovanen, Márton Karsai, Kimmo Kaski, János Kertész, and Jari Saramäki

  18. [26]

    Lauri Kovanen, Kimmo Kaski, János Kertész, and Jari Saramäki. 2013. Tempo- ral motifs reveal homophily, gender-specific patterns, and group talk in call sequences. Proceedings of the National Academy of Sciences 110, 45 (2013), 18070– 18075

    2013

  19. [27]

    Rohit Kumar and Toon Calders. 2018. 2scent: An efficient algorithm to enumerate all simple temporal cycles. Proceedings of the VLDB Endowment 11, 11 (2018), 1441–1453

    2018

  20. [28]

    Jure Leskovec and Andrej Krevl. 2014. SNAP Datasets: Stanford Large Network Dataset Collection. http://snap.stanford.edu/data

    2014

  21. [29]

    Penghang Liu, Rupam Acharyya, Robert E Tillman, Shunya Kimura, Naoki Ma- suda, and Ahmet Erdem Sarıyüce. 2023. Temporal Motifs for Financial Networks: A Study on Mercari, JPMC, and Venmo Platforms.arXiv preprint arXiv:2301.07791 (2023)

    2023 arXiv

  22. [30]

    Paul Liu, Austin R Benson, and Moses Charikar. 2019. Sampling methods for counting temporal motifs. In Proceedings of the twelfth ACM international confer- ence on web search and data mining . 294–302

    2019

  23. [31]

    Journal of Statistical Me- chanics: Theory and Experiment 2011, 11 (2011), P11005

    Temporal motifs in time-dependent networks. Journal of Statistical Me- chanics: Theory and Experiment 2011, 11 (2011), P11005

    2011

  24. [32]

    Matula and Leland L

    David W. Matula and Leland L. Beck. 1983. Smallest-Last Ordering and clustering and Graph Coloring Algorithms. J. ACM 30, 3 (1983), 417–427. https://doi.org/ 10.1145/2402.322385

    1983

  25. [33]

    Telang, and Munindar P

    Felipe Meneguzzi, Pankaj R. Telang, and Munindar P. Singh. 2013. A First- Order Formalization of Commitments and Goals for Planning. In Proceedings of the Twenty-Seventh AAAI Conference on Artificial Intelligence, July 14-18, 2013, Bellevue, Washington, USA, Marie desJardins a...

    2013 doi

  26. [34]

    Italiano, and Wook-Shin Han

    Seunghwan Min, Jihoon Jang, Kunsoo Park, Dora Giammarresi, Giuseppe F. Italiano, and Wook-Shin Han. 2024. Time-Constrained Continuous Subgraph Matching Using Temporal Information for Filtering and Backtracking. In 40th IEEE International Conference on Data Engineering, ICDE 20...

    2024

  27. [35]

    Leora Morgenstern. 1986. A First Order Theory of Planning, Knowledge, and Action. In Proceedings of the 1st Conference on Theoretical Aspects of Reasoning about Knowledge, Monterey, CA, USA, March 1986, Joseph Y. Halpern (Ed.). Morgan Kaufmann, 99–114

    1986

  28. [36]

    Gergely Palla, Imre Derényi, Illés Farkas, and Tamás Vicsek. 2005. Uncovering the overlapping community structure of complex networks in nature and society. Nature 435 (07 2005), 814–818

    2005

  29. [37]

    Patrick Mackey, Katherine Porterfield, Erin Fitzhenry, Sutanay Choudhury, and George Chin. 2018. A chronological edge-driven approach to temporal subgraph isomorphism. In 2018 IEEE international conference on big data (big data) . IEEE, 3972–3979

    2018

  30. [38]

    Ashwin Paranjape, Austin R Benson, and Jure Leskovec. 2017. Motifs in temporal networks. In Proceedings of the tenth ACM international conference on web search and data mining. 601–610

    2017

  31. [39]

    Noujan Pashanasangi and C Seshadhri. 2021. Faster and generalized temporal tri- angle counting, via degeneracy ordering. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining . 1319–1328

    2021

  32. [40]

    Aduri Pavan, Kanat Tangwongsan, Srikanta Tirthapura, and Kun-Lung Wu. 2013. Counting and sampling triangles from a graph stream. Proceedings of the VLDB Endowment 6, 14 (2013), 1870–1881

    2013

  33. [41]

    Ali Pinar, Comandur Seshadhri, and Vaidyanathan Vishal. 2017. Escape: Effi- ciently counting all 5-vertex subgraphs. In Proceedings of the 26th international conference on world wide web . 1431–1440

    2017

  34. [42]

    Stuart Russell and Peter Norvig. 2020. Artificial Intelligence: A Modern Approach (4th Edition). Pearson. http://aima.cs.berkeley.edu/

    2020

  35. [43]

    Seshadhri, and Nishil Talati

    Yunjie Pan, Omkar Bhalerao, C. Seshadhri, and Nishil Talati. 2024. Accurate and Fast Estimation of Temporal Motifs using Path Sampling. arXiv:2409.08975 [cs.SI] https://arxiv.org/abs/2409.08975

    2024

  36. [44]

    Ilie Sarpe and Fabio Vandin. 2021. Presto: Simple and scalable sampling techniques for the rigorous approximation of temporal motif counts. In Proceedings of the 2021 SIAM International Conference on Data Mining (SDM) . SIAM, 145–153

    2021

  37. [45]

    Seshadhri

    C. Seshadhri. 2023. Some Vignettes on Subgraph Counting using Graph Orien- tations. Invited tutorial slides, International Conference on Database Theory (ICDT). https://users.soe.ucsc.edu/~sesh/publication.html

    2023

  38. [46]

    Seshadhri, Tamara G

    C. Seshadhri, Tamara G. Kolda, and Ali Pinar. 2012. Community structure and scale-free collections of Erdös-Rényi graphs. Physical Review E 85, 5 (May 2012), 056109. doi:10.1103/PhysRevE.85.056109

    2012 doi

  39. [47]

    C Seshadhri, Ali Pinar, and Tamara G Kolda. 2014. Wedge sampling for computing clustering coefficients and triangle counts on large graphs. Statistical Analysis and Data Mining: The ASA Data Science Journal 7, 4 (2014), 294–307

    2014

  40. [48]

    C Seshadhri and Srikanta Tirthapura. 2019. Scalable subgraph counting: The methods behind the madness: WWW 2019 tutorial. In Proceedings of the Web Conference (WWW), Vol. 2. 75

    2019

  41. [49]

    Ilie Sarpe and Fabio Vandin. 2021. OdeN: simultaneous approximation of mul- tiple motif counts in large temporal networks. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management . 1568–1577

    2021

  42. [50]

    Xiaoli Sun, Yusong Tan, Qingbo Wu, Baozi Chen, and Changxiang Shen. 2019. Tm-miner: Tfs-based algorithm for mining temporal motifs in large temporal network. IEEE Access 7 (2019), 49778–49789

    2019

  43. [51]

    Nishil Talati, Haojie Ye, Sanketh Vedula, Kuan-Yu Chen, Yuhan Chen, Daniel Liu, Yichao Yuan, David Blaauw, Alex Bronstein, Trevor Mudge, et al. 2022. Mint: An Accelerator For Mining Temporal Motifs. In 2022 55th IEEE/ACM International Symposium on Microarchitecture (MICRO) . I...

    2022

  44. [52]

    Nishil Talati, Haojie Ye, Yichen Yang, Leul Belayneh, Kuan-Yu Chen, David Blaauw, Trevor Mudge, and Ronald Dreslinski. 2022. Ndminer: accelerating graph pattern mining using near data processing. In Proceedings of the 49th Annual International Symposium on Computer Architectur...

    2022

  45. [53]

    Jie Tang, Jing Zhang, Limin Yao, Juanzi Li, Li Zhang, and Zhong Su. 2008. Arnet- Miner: extraction and mining of academic social networks. In Proceedings of the 14th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Las Vegas, Nevada, USA, August 24-2...

    2008

  46. [54]

    Charalampos E Tsourakakis, U Kang, Gary L Miller, and Christos Faloutsos. 2009. Doulion: counting triangles in massive graphs with a coin. In Proceedings of the 15th ACM SIGKDD international conference on Knowledge discovery and data mining. 837–846

    2009

  47. [55]

    Seshadhri and Srikanta Tirthapura

    C. Seshadhri and Srikanta Tirthapura. 2019. Scalable Subgraph Counting: The Methods Behind The Madness: WWW 2019 Tutorial

    2019

  48. [56]

    Ata Turk and Duru Turkoglu. 2019. Revisiting wedge sampling for triangle counting. In The World Wide Web Conference. 1875–1885

    2019

  49. [57]

    Davide Vega and Matteo Magnani. 2018. Foundations of Temporal Text Networks. Appl. Netw. Sci. 3, 1 (2018), 25:1–25:26. doi:10.1007/S41109-018-0082-3

    2018 doi

  50. [58]

    Giorgio Venturin, Ilie Sarpe, and Fabio Vandin. 2025. Efficient Approximate Temporal Triangle Counting in Streaming with Predictions.CoRR abs/2506.13173 (2025). https://doi.org/10.48550/arXiv.2506.13173

    2025 doi arXiv

  51. [59]

    Jingjing Wang, Yanhao Wang, Wenjun Jiang, Yuchen Li, and Kian-Lee Tan. 2020. Efficient sampling algorithms for approximate temporal motif counting. In Pro- ceedings of the 29th ACM international conference on information & knowledge management. 1505–1514

    2020

  52. [60]

    Pinghui Wang, Junzhou Zhao, Xiangliang Zhang, Zhenguo Li, Jiefeng Cheng, John CS Lui, Don Towsley, Jing Tao, and Xiaohong Guan. 2017. MOSS-5: A fast method of approximating counts of 5-node graphlets in large graphs. IEEE Transactions on Knowledge and Data Engineering 30, 1 (2...

    2017

  53. [61]

    Kun Tu, Jian Li, Don Towsley, Dave Braines, and Liam D. Turner. 2018. Network Classification in Temporal Networks Using Motifs. CoRR abs/1807.03733 (2018). arXiv:1807.03733 http://arxiv.org/abs/1807.03733 Conference acronym ’XX, June 03–05, 2018, Woodstock, NY Omkar Bhalerao, ...

    2018 arXiv

  54. [67]

    inserts an interval 𝐼

    Yichao Yuan, Haojie Ye, Sanketh Vedula Wynn Kaza, and Nishil Talati. 2023. Everest: GPU-Accelerated System For Mining Temporal Motifs. arXiv preprint arXiv:2310.02800 (2023). A Appendix A.1 Segment-Trees to deal with in-neighbours A.1.1 Primer on Segment Trees: Before we proce...

    2023 arXiv

  55. [68]

    As a consequence, the algorithm over-counts the contribution of𝑤

    This creates a problem, since the suitable path for 𝑒 =(𝑢,𝑣, 9) will return 2 as the value for in-count[𝑒]. As a consequence, the algorithm over-counts the contribution of𝑤. More concretely, the algorithm fails if an interval𝐼, which be- longs to the canonical subset of a node...

    2018

  56. [69]

    (2) If the algorithm visits a white node𝑥 with Counter(𝑥) > 0, then check for Vertex(𝑥)

    Given an interval𝐼∈𝐼𝑧,𝑢,𝑣, (1) If the algorithm encounters a grey node, then simply return and move on to the next interval of𝐼𝑧,𝑢,𝑣. (2) If the algorithm visits a white node𝑥 with Counter(𝑥) > 0, then check for Vertex(𝑥). If Vertex(𝑥) ≠𝑧, then continue with the insertion proc...

    2018

  57. [2008]

    Springer

    Computational geometry: algorithms and applications, 3rd Edition . Springer. https://www.worldcat.org/oclc/227584184

  58. [2009]

    In Advances in Conceptual Modeling - Challenging Perspectives, ER 2009 Workshops CoMoL, ETheCoM, FP-UML, MOST-ONISW, QoIS, RIGiM, SeCoGIS, Gramado, Brazil, November 9-12, 2009

    First-Order Types and Redundant Relations in Relational Databases. In Advances in Conceptual Modeling - Challenging Perspectives, ER 2009 Workshops CoMoL, ETheCoM, FP-UML, MOST-ONISW, QoIS, RIGiM, SeCoGIS, Gramado, Brazil, November 9-12, 2009. Proceedings (Lecture Notes in Com...

    2009 doi

  59. [2011]

    In Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2011, Athens, Greece, June 12-16, 2011 , Timos K

    Neighborhood based fast graph search in large networks. In Proceedings of the ACM SIGMOD International Conference on Management of Data, SIGMOD 2011, Athens, Greece, June 12-16, 2011 , Timos K. Sellis, Renée J. Miller, Anastasios Kementsietsidis, and Yannis Velegrakis (Eds.). ...

    2011

  60. [2012]

    Fast Generation of Large Scale Social Networks While Incorporating Transitive Closures. In 2012 International Conference on Privacy, Security, Risk and Trust, PASSAT 2012, and 2012 International Confernece on Social Computing, SocialCom 2012, Amsterdam, Netherlands, September ...

    2012

  61. [2021]

    Frontiers in Blockchain 4 (2021), 668510

    The rich still get richer: Empirical comparison of preferential attachment via linking statistics in bitcoin and ethereum. Frontiers in Blockchain 4 (2021), 668510

    2021

Pith tools

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