Pith. sign in

REVIEW 4 major objections 5 minor 60 references

Mayura: Exploiting Similarities in Motifs for Temporal Co-Mining

T0 review · 4 major / 5 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 Multiple temporal motif queries can be co-mined exactly by sharing common edge prefixes through an MG-Tree, yielding 2.4x average CPU and 1.7x GPU speedups over per-motif mining.

desk verdict A genuinely useful co-mining idea with a broad evaluation, but the published construction pseudocode has a load-bearing correctness gap that undermines the exactness claim until fixed. read the letter →

arxiv 2507.14813 v1 pith:SJO6CIK2 submitted 2025-07-20 cs.DB cs.DCcs.PF

Sanjay Sri Vallabh Singapuram , Ronald Dreslinski , Nishil Talati This is my paper · ORCID
classification cs.DBcs.DCcs.PF
keywords temporalmotifminingco-miningMG-Treemotif-grouptreeexactenumerationGPUloadbalancingmulti-queryoptimizationgraphs
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 claims that a batch of temporal-motif queries—small, ordered edge patterns that must occur in sequence within a time window δ—can be mined together exactly instead of one at a time. The key move is to organize the motifs into a Motif-Group Tree (MG-Tree), a tree whose internal nodes are common prefixes of the motifs' chronologically ordered edge sequences, so a single search traverses each shared prefix once and branches where motifs diverge. If correct, this removes redundant re-traversals in workloads such as fraud detection and cybersecurity, where several motif queries run at once and exact enumeration rather than approximation is required. Across five real-world datasets the paper reports average speedups of 2.4x on a 40-core CPU and 1.7x on an NVIDIA A40 GPU over state-of-the-art per-motif baselines, with the same match set and peak gains of 8.8x and 7.6x respectively.

What carries the argument

The central object is the Motif-Group Tree (MG-Tree), a tree built from the query motifs in which each node stores three things: a common motif С_N (the ordered edge prefix shared by every descendant), a query reference Q_N (the original motif completed at this node, or empty), and child nodes that extend the prefix. This object carries the argument because matching С_N once gives every descendant its partial match, turning several independent searches into one search that branches only where the motifs' edge sequences diverge. Algorithm 2 constructs the tree by grouping motifs according to their edge at each timestamp, reusing a node when the whole group stays together and creating a new internal node only when the group splits; Algorithm 3 then performs the recursive co-mining traversal.

What would settle it

Take a motif group where one motif is a strict prefix of another, say a two-edge pattern A→B→C and a three-edge pattern A→B→C→D, and mine a tiny graph that certainly contains the two-edge pattern; if the two-edge motif's count is zero while mining it alone finds it, the exactness claim is false, and the construction pseudocode's unassigned parent query reference (lines 24–26 versus line 35) is a plausible source of exactly this failure.

Watch

Extended reading notes

Core claim

The central claim is that a group of δ-temporal motifs can be mined exactly in one coordinated search. The MG-Tree organizes the motifs as a hierarchy of common prefixes over chronologically ordered edges; Algorithm 3 traverses each shared prefix once, reusing its matches as partial matches for every descendant motif, and records a match whenever a node's query reference is set. The paper argues this enumerates the same match set as independent per-motif mining while executing less work, and reports average speedups of 2.4x on a 40-core Intel Xeon CPU and 1.7x on an NVIDIA A40 GPU over the individual-mining baselines, with dynamic instruction counts reduced by 1.6–4.5x.

Load-bearing premise

The whole argument rests on the assumption that the tree-building step attaches every query motif to the tree and marks it on exactly one node, because if a motif is never marked the shared search will silently miss all of that motif's matches.

Editorial extensions

If this is right

  • For a motif group with high overlap, co-mining cuts dynamic instructions by 1.6–4.5x, translating directly into wall-clock speedups on both CPU and GPU backends.
  • Because the match set is identical to independent mining, co-mining can be substituted into exact enumeration workloads without changing downstream results.
  • The MG-Tree exposes hierarchical parallelism: sibling-splitting and multi-offload let GPU warps explore divergent motifs concurrently, with occupancy loss capped at about 1% and instruction overhead at 6%.
  • Dataset structure strongly shapes the gains: on bipartite graphs an unmatched intermediate motif prunes all descendants at once, yielding the largest observed speedups (up to 8.8x CPU and 7.6x GPU).
  • Choosing a smaller time window δ increases the speedup of co-mining over the baseline, because the candidate search space shrinks and load imbalance is less severe.

Reading between the lines

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

  • The tree construction only shares prefixes under one fixed chronological order of edges; a generalized construction could also share suffixes or reverse-order prefixes and would likely expose co-mining opportunities for motif groups the current similarity metric rates as low-overlap.
  • The reported GPU cutoff (similarity metric at least 0.44, unless the graph is bipartite) is an empirical threshold; a cost model of prefix-sharing savings versus register pressure and divergence could turn it into a portable decision rule.
  • For count-only workloads, the MG-Tree provides an implicit family-level pruning: if an internal prefix has zero matches, the entire subtree of motifs is skipped, an effect the paper observes empirically but does not quantify separately as a pruning guarantee.
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

4 major / 5 minor

Summary. The paper presents Mayura, a system for jointly mining multiple temporal motifs by organizing the query motifs into a Motif-Group Tree (MG-Tree). The central claims are that the MG-Tree captures structural and temporal commonalities across motifs, that the co-mining algorithm (Algorithm 3) mines exactly the same match set as independent per-motif mining while doing less work, and that a CPU/GPU runtime with code generation and load-balancing optimizations achieves average speedups of 2.4x on the CPU and 1.7x on the GPU over single-motif baselines. The evaluation covers five real-world temporal graphs and eight multi-motif queries, and the paper includes detailed architectural analysis of instruction counts, warp divergence, occupancy, and memory footprint.

Significance. If the exactness and performance claims hold, Mayura addresses a real gap: exact temporal motif mining has previously been done one motif at a time, while multi-query workloads in fraud detection and network analysis contain overlapping motifs. The MG-Tree abstraction is a plausible and potentially reusable way to share search paths, and the paper's breadth of evaluation (five datasets, eight queries, CPU and GPU backends, sensitivity to δ, and architectural counters) is a strength. The paper also gives concrete optimization ideas, such as predicate-based structural checks and MG-Tree-specific code generation, which would be of value to the community. However, the exactness claim is load-bearing and currently rests on an unproven partition property of Algorithm 2 whose pseudocode appears internally inconsistent; no released artifact or machine-checked correctness argument is provided. Because the claimed speedups are only meaningful if every query motif's matches are actually counted, the correctness gap must be resolved before the results can be accepted.

major comments (4)
  1. [§4.3, Algorithm 2, lines 24-26 and 35] The construction does not implement the partition property asserted in §A.1. When child_group contains a query motif M with |E(M)| = T together with longer motifs, the variable QN_parent is computed but never assigned to the node created or reused at line 35; line 35 unconditionally sets Q_N ← ∅. Consequently, any counted motif that is a strict prefix of another motif in the same group has its Q_N overwritten or never set, and Algorithm 3 line 6 will never record its matches. This is not an artificial corner case: the depth-focused groups D1 and D2 in Fig. 15 contain M1 as a prefix, and §7 explicitly relies on the "implicit mining of M1 before M4" behavior. Since §A.1 asserts that every motif corresponds to exactly one node with Q_N = M_i but no proof is given, the exactness of the co-mining algorithm is not established by the manuscript. Please correct the pseudocode (e.g., set Q_N ← M when |E(M)| = T), and provide a rigorous argument that the traversal in Algorithm 3 visits every node with nonempty Q_N exactly once.
  2. [§4.3, Algorithm 2, lines 5-7] There is an internal inconsistency at the top of ConstructMGTree. Line 5 obtains root_gid and line 6 initializes Nroot, but line 7 calls CreateTree(1, GetNewUniqeGID(), MG), passing a fresh GID rather than root_gid. The initialized Nroot at gid 0 is therefore never passed to CreateTree and cannot be the root of the returned tree unless additional code not shown attaches it later. Since line 31 reuses p_gid only when the child_group equals motif_group, the effective root of the returned MG-Tree is the node created at gid 1, and a traversal starting from Nroot would see no children. This makes the construction pseudocode impossible to verify as written. Please correct the call to use root_gid, or explicitly describe how the root is finalized.
  3. [§7, Listing 1 and Fig. 19] The heuristic threshold SM = 0.44 for GPU co-mining is selected from the same experiments that are used to report the average GPU speedups. The paper does not describe a holdout validation, a sensitivity analysis around the threshold, or a separate tuning procedure, and the heuristic directly gates whether co-mining is even attempted for low-SM groups such as C1 (SM = 0.36). As a result, the headline 1.7x average GPU speedup conflates the algorithm's intrinsic benefit with the benefit of disabling co-mining on unfavorable inputs. Please report results with and without the heuristic for all queries, or validate the threshold on an independent query/dataset split.
  4. [§A.1 and §9] The exactness claim is stated unconditionally in the abstract and conclusion ("maintaining the exactness required for high-stakes applications"), but the only supporting statement is the definitional assertion in §A.1 that the MG-Tree contains exactly one node with Q_N = M_i for each motif. No correctness proof for the construction or the co-mining recursion is provided, and no artifact or source code is released to allow independent checking. Given the load-bearing nature of this claim and the discrepancies in the pseudocode, a formal correctness argument (or, failing that, a corrected and executable construction with a randomized differential test against per-motif mining on small graphs) is necessary before the exactness claim can be accepted.
minor comments (5)
  1. [§2.2, Algorithm 1, line 18] RollBackEdge(edge_G.u, edge_G.u) should presumably be RollBackEdge(edge_G.u, edge_G.v); the function signature at line 19 takes two endpoint arguments, and the body at line 23 refers to an undefined variable named edge.
  2. [Appendix A.3, Listing 3] The generated-code example checks M3.matches({e1, e2, e3, e4}) in the loop for e3, but e4 is not defined at that point; this appears to be a typo and should be e3 or a comment explaining the intended pseudo-variable.
  3. [§7, Figure 20] The sentence beginning "SThe efficacy of code-generation" contains a typo and should read "The efficacy...".
  4. [§7, Memory Footprint paragraph] The text mentions "16MB for D2, 20MB for D3," but the query set contains D1 and D2, not D3; this should be corrected to a real query name or clarified.
  5. [Abstract vs. Conclusion] The abstract reports an average CPU speedup of 2.4x while the conclusion reports 2.5x; please make these consistent.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the MG-Tree co-mining claim is a constructive algorithmic claim, and the reported speedups are empirical comparisons rather than derivations from fitted inputs.

full rationale

The central claim is that MG-Tree-guided co-mining enumerates the same match set as per-motif mining while sharing prefix work. This is a constructive algorithmic claim: Algorithm 3 is Algorithm 1 with the single motif replaced by a tree of prefix motifs, and exactness would follow from the partition invariant stated in Appendix A.1 (each query motif appears as exactly one Q_N and every node is reachable from the root). No equation in the paper defines the speedup in terms of the baseline's own output, and no reported speedup is computed from a parameter fitted to that same speedup. The only self-citation is the use of Everest [57] as the GPU baseline; since Everest is an independently published system with its own measured runtimes, comparing against it is not circular, though the overlapping authorship is a fairness consideration rather than a derivation loop. The SM = 0.44 threshold in Listing 1 is fit from the evaluation, but it is presented as a post-hoc heuristic rather than as a prediction used to generate the reported speedups, so it does not make the results circular. Separately, I note two non-circular correctness concerns that are outside this pass but are flagged explicitly: Algorithm 2 computes QN_parent but never assigns it to the node created at line 35, and no formal proof of the Appendix A.1 partition invariant is provided; these would affect exactness of the implementation, not the circularity of the derivation. Overall, no load-bearing step in the paper reduces to its own input, so the circularity score is 0.

Assumptions & free parameters 3 free parameters · 4 assumptions · 1 invented entities

The central speedup result depends on the exactness of the MG-Tree search-space partition and on the baselines being representative of the state of the art. The paper states these as assumptions rather than proving them, and it tunes one heuristic threshold on the evaluation data.

free parameters (3)
  • SM threshold for GPU co-mining heuristic = 0.44
    Listing 1 disables GPU co-mining when the similarity metric is below 0.44; this threshold was determined from the evaluation results in §7.
  • INTRA_INTRVL = unspecified
    Intra-warp load balancing interval referenced in §4.5 and §A.2; not given a concrete value, so results cannot be reproduced exactly.
  • INTER_INTRVL = unspecified
    Inter-warp load balancing interval in §4.5; stated as larger than INTRA_INTRVL but no value is given.
assumptions (4)
  • domain assumption The temporal graph has unique timestamps and edges are processed in chronological order.
    Stated in §2.1; all pruning in Algorithm 1 depends on this.
  • domain assumption The isomorphism-based match definition from [30, 34, 57] is adopted, ignoring alternative match notions.
    §2.1 explicitly restricts scope to strict isomorphism; results may not transfer to homomorphism-based mining.
  • ad hoc to paper The MG-Tree construction yields a disjoint, complete partition of the search space, so co-mining is exact.
    Assumed in §4.4 for Algorithm 3; no proof is given, and Algorithm 2 appears to leave prefix motifs unattached.
  • domain assumption The baseline implementations (Mackey et al. [30] and Everest [57]) are correct and representative of the state of the art.
    Evaluation in §6 compares only against these; Everest is authored by co-authors, which may bias the comparison.
invented entities (1)
  • Motif-Group Tree (MG-Tree)
    purpose: Hierarchical tree over temporal motifs that groups motifs by common edge prefixes to enable shared search paths and eliminate redundant computation in co-mining.
    Introduced in §4.3; its correctness and performance benefits are only supported by the paper's own experiments, with no formal proof or released implementation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Mayura: Exploiting Similarities in Motifs for Temporal Co-Mining." pith.science (2026). https://pith.science/paper/SJO6CIK2

@misc{pith2026250714813,
  author       = {Pith},
  title        = {Pith review of: Mayura: Exploiting Similarities in Motifs for Temporal Co-Mining},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SJO6CIK2}},
  note         = {Machine review of arXiv:2507.14813}
}
read the original abstract

Temporal graphs serve as a critical foundation for modeling evolving interactions in domains ranging from financial networks to social media. Mining temporal motifs is essential for applications such as fraud detection, cybersecurity, and dynamic network analysis. However, conventional motif mining approaches treat each query independently, incurring significant redundant computations when similar substructures exist across multiple motifs. In this paper, we propose Mayura, a novel framework that unifies the mining of multiple temporal motifs by exploiting their inherent structural and temporal commonalities. Central to our approach is the Motif-Group Tree (MG-Tree), a hierarchical data structure that organizes related motifs and enables the reuse of common search paths, thereby reducing redundant computation. We propose a co-mining algorithm that leverages the MG-Tree and develop a flexible runtime capable of exploiting both CPU and GPU architectures for scalable performance. Empirical evaluations on diverse real-world datasets demonstrate that Mayura achieves substantial improvements over the state-of-the-art techniques that mine each motif individually, with an average speed-up of 2.4x on the CPU and 1.7x on the GPU, while maintaining the exactness required for high-stakes applications.

Figures

Figures reproduced from arXiv: 2507.14813 by the authors.

Figure 1
Figure 1. Example of mining a 3-cycle motif within a tempo [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Search-Tree to mine a 3-cycle in Data Graph G in [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Common search-path between 3-cycle, 4-cycle and [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (16 more)
Figure 4
Figure 4. Figure 4: Example User Query. Data Graph Query Graphs MG-Tree Construction User Query Data Loader Backend Choice Code Generation CPU Task Manager GPU Task Manager Results Runtime Backend-Dependent Data Loading MG-Specific Code Generation 1 2 OpenMP CUDA 3 4 5 6 7 [PITH_FULL_IMA…
Figure 5
Figure 5. Figure 5: Overview of Mayura’s workflow. Data-Loading and Compile-Time Phases consists of mecha￾nisms for 1) Data Preprocessing 2 , 2) Motif-Group Tree (MG-Tree) Construction 3 , and 3) Backend-Specific Code Generation and Compilation 4 . The temporal data graph specified by the…
Figure 6
Figure 6. Figure 6: Visualizing MG-Tree Construction. I1 1 2 [M3,M4,M5] Intr. Node I1. (not counted) M3 1 2 3 M3 Leaf Node (Counted) M4 2 4 3 1 M4 Leaf Node (Counted) 1 M5 2 3 4 M5 Leaf Node (Counted) 1 I2 2 3 [M4,M5] Intr. Node I2. (not counted) [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 8
Figure 8. Figure 8: Search-Tree to mine motifs M3,M4 and M5 reflects the hierarchical structure of their MG-Tree ( [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]
Figure 9
Figure 9. Figure 9: Visualizing Thread Context and Load-Balancing on [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 10
Figure 10. Figure 10: Intra-Warp Load-Balancing distributing candi [PITH_FULL_IMAGE:figures/full_fig_p008_10.png]
Figure 11
Figure 11. Figure 11: Inter-Warp Load-Balancing distributing candidates [PITH_FULL_IMAGE:figures/full_fig_p008_11.png]
Figure 12
Figure 12. Figure 12: Optimization to reduce warp-divergence and streamline control-flow. [PITH_FULL_IMAGE:figures/full_fig_p009_12.png]
Figure 14
Figure 14. Figure 14: Optimization for Inter-Warp Load-balancing. [PITH_FULL_IMAGE:figures/full_fig_p010_14.png]
Figure 15
Figure 15. Figure 15: MG-Trees of Motif Groups, with respective (SM). [PITH_FULL_IMAGE:figures/full_fig_p011_15.png]
Figure 16
Figure 16. Figure 16: CPU Timings (seconds) [PITH_FULL_IMAGE:figures/full_fig_p011_16.png]
Figure 19
Figure 19. Figure 19: Breakdown of performance improvements of differ [PITH_FULL_IMAGE:figures/full_fig_p011_19.png]
Figure 20
Figure 20. Figure 20: Architectural Metrics for mining D2, F3 and C3 on wtt, relative to the baseline. eqx dataset exhibits exceptionally high speedups on both CPU and GPU platforms, due to the fact that bipartite graph cannot allow motifs that connect vertices in the same disjoint partiti…
Figure 21
Figure 21. Figure 21: Effect of scaling 𝛿 on Speedup and Runtime. the state-of-the-art in static graph mining, they do not address the unique challenges posed by temporal constraints in motif mining. Temporal Motif Mining introduces additional complexity by incorporating temporal ordering …
Figure 23
Figure 23. Figure 23: Effect of scaling 𝛿 on Speedup and Runtime on the Stack Overflow (sxo) dataset. 17 [PITH_FULL_IMAGE:figures/full_fig_p017_23.png]
Figure 24
Figure 24. Figure 24: Effect of scaling 𝛿 on Speedup and Runtime on the trr dataset. 18 [PITH_FULL_IMAGE:figures/full_fig_p018_24.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

60 extracted references · 42 canonical work pages

  1. [1]

    CUDA Handbook

    2025. CUDA Handbook. https://docs.nvidia.com/cuda/cuda-c-best-practices- guide/contents.html

    work page 2025

  2. [2]

    Sameer Agarwal, Barzan Mozafari, Aurojit Panda, Henry Milner, Samuel Madden, and Ion Stoica. 2013. BlinkDB: queries with bounded errors and bounded response times on very large data. In Proceedings of the 8th ACM European conference on computer systems. 29–42

    work page 2013

  3. [3]

    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. Advances in Neural Information Processing Systems 36 (2023), 29851–29874

    work page 2023

  4. [4]

    Subi Arumugam, Alin Dobra, Christopher M Jermaine, Niketan Pansare, and Luis Perez. 2010. The DataPath system: a data-centric analytic processing engine for large data warehouses. In Proceedings of the 2010 ACM SIGMOD International Conference on Management of data . 519–530

    work page 2010

  5. [5]

    Shilpa Balan and Janhavi Rege. 2017. Mining for social Media: Usage patterns of small businesses. Business Systems Research Journal 8, 1 (March 2017), 43–50. https://doi.org/10.1515/bsrj-2017-0004

    work page doi:10.1515/bsrj-2017-0004 2017

  6. [6]

    Jovan Blanuša, Maximo Cravero Baraja, Andreea Anghel, Luc Von Niederhäusern, Erik Altman, Haris Pozidis, and Kubilay Atasu. 2024. Graph Feature Preprocessor: Real-time Subgraph-based Feature Extraction for Financial Crime Detection. In Proceedings of the 5th ACM International Conference on AI in Finance . 222–230

    work page 2024

  7. [7]

    Peter Boncz, Torsten Grust, Maurice Van Keulen, Stefan Manegold, Jan Rittinger, and Jens Teubner. 2006. MonetDB/XQuery: a fast XQuery processor powered by a relational engine. In Proceedings of the 2006 ACM SIGMOD international conference on Management of data . 479–490

    work page 2006

  8. [8]

    Jianhong Cai, Hao Gu, and Xiaorong Zhu. 2023. Mobility-Aware Offloading Scheme for 6G’s Real-Time Tasks with Temporal Graphs and Graph Match- ing. 2023 International Conference on Networks, Communications and Intelligent Computing (NCIC) (2023), 189–194. https://api.semanticscholar.org/CorpusID: 269806405

    work page 2023

Show all 60 references
  1. [9]

    George Candea, Neoklis Polyzotis, and Radek Vingralek. 2009. A scalable, pre- dictable join operator for highly concurrent data warehouses. In Proceedings of the 35th International Conference on Very Large Data Bases (VLDB)

    2009

  2. [10]

    Ming-Syan Chen, Jiawei Han, and P.S. Yu. 1996. Data mining: an overview from a database perspective. IEEE Transactions on Knowledge and Data Engineering 8, 6 (1996), 866–883. https://doi.org/10.1109/69.553155

    1996 doi

  3. [11]

    Xuhao Chen and Arvind. 2022. Efficient and Scalable Graph Pattern Mining on GPUs. In 16th USENIX Symposium on Operating Systems Design and Im- plementation (OSDI 22) . USENIX Association, Carlsbad, CA, 857–877. https: //www.usenix.org/conference/osdi22/presentation/chen

    2022

  4. [12]

    Lawrence Fisher. 2024. Leveraging Graph Databases for Fraud De- tection in Financial Systems. Communications of ACM (Oct. 2024). https://cacm.acm.org/blogcacm/leveraging-graph-databases-for-fraud- detection-in-financial-systems/

    2024

  5. [13]

    Z. Gao, C. Cheng, Y. Yu, L. Cao, C. Huang, and J. Dong. 2022. Scalable Motif Counting for Large-scale Temporal Graphs. In 2022 IEEE 38th International Con- ference on Data Engineering (ICDE) . IEEE Computer Society, Los Alamitos, CA, USA, 2656–2668. https://doi.org/10.1109/ICD...

    2022

  6. [14]

    Joshua Glasser and Brian Lindauer. 2013. Bridging the gap: A pragmatic approach to generating insider threat data. In 2013 IEEE Security and Privacy Workshops . IEEE, 98–104

    2013

  7. [15]

    László Hajdu and Miklós Krész. 2020. Temporal network analytics for fraud de- tection in the banking sector. In ADBIS, TPDL and EDA 2020 Common Workshops and Doctoral Consortium. Springer, 145–157

    2020

  8. [16]

    Brandon Haynes, Rana Alotaibi, Anna Pavlenko, Jyoti Leeka, Alekh Jindal, and Yuanyuan Tian. 2023. GEqO: ML-Accelerated Semantic Equivalence Detection. Proceedings of the ACM on Management of Data 1, 4 (2023), 1–25

    2023

  9. [17]

    Weihua Hu, Matthias Fey, Hongyu Ren, Maho Nakata, Yuxiao Dong, and Jure Leskovec. 2021. Ogb-lsc: A large-scale challenge for machine learning on graphs. arXiv preprint arXiv:2103.09430 (2021)

    2021 arXiv

  10. [18]

    Kasra Jamshidi, Rakesh Mahadasa, and Keval Vora. 2020. Peregrine: A Pattern- Aware Graph Mining System. , Article 13 (2020), 16 pages. https://doi.org/10. 1145/3342195.3387548

    2020

  11. [19]

    Kasra Jamshidi and Keval Vora. 2021. A Deeper Dive into Pattern-Aware Sub- graph Exploration with PEREGRINE. SIGOPS Oper. Syst. Rev. 55, 1 (June 2021), 1–10. https://doi.org/10.1145/3469379.3469381

    2021

  12. [20]

    Kasra Jamshidi, Harry Xu, and Keval Vora. 2023. Accelerating graph mining systems with subgraph morphing. In Proceedings of the Eighteenth European Conference on Computer Systems . 162–181

    2023

  13. [21]

    Changjiu Jin, Sourav S Bhowmick, Byron Choi, and Shuigeng Zhou. 2012. Prague: towards blending practical visual subgraph query formulation and query pro- cessing. In 2012 IEEE 28th International Conference on Data Engineering . IEEE, 222–233

    2012

  14. [22]

    Alekh Jindal, Konstantinos Karanasos, Sriram Rao, and Hiren Patel. 2018. Select- ing subexpressions to materialize at datacenter scale. Proceedings of the VLDB Endowment 11, 7 (2018), 800–812

    2018

  15. [23]

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

  16. [24]

    Chrysanthi Kosyfaki, Nikos Mamoulis, Evaggelia Pitoura, and Panayiotis Tsaparas. 2018. Flow Motifs in Interaction Networks. In International Conference on Extending Database Technology

    2018

  17. [25]

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

    2014

  18. [26]

    Paul Liu, Austin Benson, and Moses Charikar. 2018. A sampling framework for counting temporal motifs. arXiv preprint arXiv:1810.00980 (2018)

    2018 arXiv

  19. [27]

    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

  20. [28]

    Lin Ma, Dana Van Aken, Ahmed Hefny, Gustavo Mezerhane, Andrew Pavlo, and Geoffrey J Gordon. 2018. Query-based workload forecasting for self-driving database management systems. InProceedings of the 2018 International Conference on Management of Data . 631–645

    2018

  21. [29]

    Ziyi Ma, Jianye Yang, Xu Zhou, Guoqing Xiao, Jianhua Wang, Liang Yang, Kenli Li, and Xuemin Lin. 2024. Efficient Multi-Query Oriented Continuous Subgraph Matching. In 2024 IEEE 40th International Conference on Data Engineering (ICDE) . IEEE, 3230–3243

    2024

  22. [30]

    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

  23. [31]

    Mawhirter, S

    D. Mawhirter, S. Reinehr, C. Holmes, T. Liu, , and B. Wu. 2019. Graphzero: Breaking symmetry for efficient graph mining. InarXiv preprint arXiv:1911.12877

    2019 arXiv

  24. [32]

    Daniel Mawhirter and Bo Wu. 2019. AutoMine: Harmonizing High-Level Ab- straction and High Performance for Graph Mining. (2019), 509–523. https: //doi.org/10.1145/3341301.3359633

    2019

  25. [33]

    Yunjie Pan, Omkar Bhalerao, C Seshadhri, and Nishil Talati. 2024. Accurate and Fast Estimation of Temporal Motifs using Path Sampling. arXiv preprint arXiv:2409.08975 (2024)

    2024

  26. [34]

    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

  27. [35]

    Xuguang Ren and Junhu Wang. 2016. Multi-query optimization for subgraph isomorphism search. Proceedings of the VLDB Endowment 10, 3 (2016), 121–132

    2016

  28. [36]

    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

  29. [37]

    Ilie Sarpe and Fabio Vandin. 2021. OdeN: Simultaneous Approximation of Multi- ple Motif Counts in Large Temporal Networks. In Proceedings of the 30th ACM International Conference on Information & Knowledge Management (Virtual Event, Queensland, Australia) (CIKM ’21). Associati...

    2021

  30. [38]

    Ilie Sarpe and Fabio Vandin. 2021. PRESTO: Simple and Scalable Sampling Tech- niques for the Rigorous Approximation of Temporal Motif Counts. InProceedings of the 2021 SIAM International Conference on Data Mining (SDM) . SIAM, 145–153. 14

    2021

  31. [39]

    Timos Sellis and Subrata Ghosh. 1990. On the multiple-query optimization problem. IEEE Transactions on Knowledge & Data Engineering 2, 02 (1990), 262– 266

    1990

  32. [40]

    Timos K Sellis. 1988. Multiple-query optimization.ACM Transactions on Database Systems (TODS) 13, 1 (1988), 23–52

    1988

  33. [41]

    Huijuan Shao, Manish Marwah, and Naren Ramakrishnan. 2013. A temporal motif mining approach to unsupervised energy disaggregation: Applications to residential and commercial buildings. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 27. 1327–1333

    2013

  34. [42]

    T. Shi, M. Zhai, Y. Xu, and J. Zhai. 2020. GraphPi: High Performance Graph Pattern Matching through Effective Redundancy Elimination . Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis

    2020

  35. [43]

    On the swipe

    Floyd Smith. 2023. Case study: Fraud detection “On the swipe” for a major US bank. https://www.singlestore.com/blog/case-study-fraud-detection-on-the- swipe/

    2023

  36. [44]

    Corey Sommers. 2024. Advanced Fraud Detection in Financial Services | ArangoDB. https://arangodb.com/2024/03/advanced-fraud-detection-in- financial-services-with-arangodb-and-aql/

    2024

  37. [45]

    Shixuan Sun, Xibo Sun, Yulin Che, Qiong Luo, and Bingsheng He. 2020. Rapid- Match: a holistic approach to subgraph query processing. Proc. VLDB Endow. 14, 2 (Oct. 2020), 176–188. https://doi.org/10.14778/3425879.3425888

    2020

  38. [46]

    Xibo Sun and Qiong Luo. 2023. Efficient gpu-accelerated subgraph matching. Proceedings of the ACM on Management of Data 1, 2 (2023), 1–26

    2023

  39. [47]

    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

  40. [48]

    Carlos H. C. Teixeira, Alexandre J. Fonseca, Marco Serafini, Georgos Siganos, Mohammed J. Zaki, and Ashraf Aboulnaga. 2015. Arabesque: A System for Distributed Graph Mining. (2015), 425–440. https://doi.org/10.1145/2815400. 2815410

    2015 doi

  41. [49]

    TigerGraph. 2022. Anti-Money Laundering with Graph DB | TigerGraph. https: //www.tigergraph.com/solutions/anti-money-laundering-aml/

    2022

  42. [50]

    Yicheng Tu, Mehrad Eslami, Zichen Xu, and Hadi Charkhgard. 2022. Multi- Query Optimization Revisited: A Full-Query Algebraic Method. In 2022 IEEE International Conference on Big Data (Big Data) . IEEE, 252–261

    2022

  43. [51]

    Alexander van Renen, Dominik Horn, Pascal Pfeil, Kapil Vaidya, Wenjian Dong, Murali Narayanaswamy, Zhengchun Liu, Gaurav Saxena, Andreas Kipf, and Tim Kraska. 2024. Why TPC is not enough: An analysis of the Amazon Redshift fleet. Proceedings of the VLDB Endowment 17, 11 (2024)...

    2024

  44. [52]

    Chaohui Wang, Miao Xie, Sourav S Bhowmick, Byron Choi, Xiaokui Xiao, and Shuigeng Zhou. 2020. FERRARI: an efficient framework for visual exploratory subgraph search in graph databases. The VLDB Journal 29 (2020), 973–998

    2020

  45. [53]

    Guoping Wang and Chee-Yong Chan. 2013. Multi-query optimization in mapre- duce framework. Proceedings of the VLDB Endowment 7, 3 (2013), 145–156

    2013

  46. [54]

    Jiaqi Wang, Tianyi Li, Anni Wang, Xiaoze Liu, Lu Chen, Jie Chen, Jianye Liu, Junyang Wu, Feifei Li, and Yunjun Gao. 2023. Real-time workload pattern analysis for large-scale cloud databases. arXiv preprint arXiv:2307.02626 (2023)

    2023 arXiv

  47. [55]

    Jingjing Wang, Yanhao Wang, Wenjun Jiang, Yuchen Li, and Kian-Lee Tan

  48. [56]

    Yihua Wei and Peng Jiang. 2022. STMatch: Accelerating Graph Pattern Matching on GPU with Stack-Based Loop Optimizations. In Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis (Dallas, Texas) (SC ’22). IEEE Press, Article...

    2022

  49. [57]

    Yichao Yuan, Haojie Ye, Sanketh Vedula, Wynn Kaza, and Nishil Talati. 2023. Everest: GPU-Accelerated System for Mining Temporal Motifs. Proc. VLDB Endow. 17, 2 (Oct. 2023), 162–174. https://doi.org/10.14778/3626292.3626299

    2023

  50. [58]

    Cécile Zachlod, Olga Samuel, Andrea Ochsner, and Sarah Werthmüller. 2022. Analytics of social media data – State of characteristics and application. Journal of Business Research 144 (2022), 1064–1076. https://doi.org/10.1016/j.jbusres. 2022.02.016 15 A DESIGN A.1 Definition of...

    2022 doi

  51. [2020]

    In Proceedings of the 29th ACM international conference on information & knowledge management

    Efficient sampling algorithms for approximate temporal motif counting. In Proceedings of the 29th ACM international conference on information & knowledge management. 1505–1514

  52. [2021]

    https://doi.org/10.5281/zenodo.4543269 Data used in our upcoming paper: Kondor D, Bulatovic N, Stéger J, Csabai I, Vattay G (2021)

    Ethereum Transaction Network. https://doi.org/10.5281/zenodo.4543269 Data used in our upcoming paper: Kondor D, Bulatovic N, Stéger J, Csabai I, Vattay G (2021). The rich still get richer: Empirical comparison of preferen- tial attachment via linking statistics in Bitcoin and ...

    2021 arXiv

Pith tools

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