Many questions asked of graph data are questions about small structures. A biologist wants to know which wiring patterns recur in a regulatory network more often than chance would predict (Milo et al., 2002). A chemist wants the substructures shared by a set of active compounds. An analyst of a payment network wants every instance of a suspicious cycle. Each task requires finding the occurrences, usually called embeddings or matches, of one or more pattern graphs inside a data graph, and the tasks differ mainly in whether the patterns are given in advance or must be discovered.

These problems are grouped under the name graph pattern mining. They are expensive for a reason that no implementation can remove: deciding whether one graph contains another as a subgraph is NP-complete (Garey and Johnson, 1979), and the number of matches of even a small pattern can exceed the size of the data graph by many orders of magnitude. Progress has therefore come from pruning the search, avoiding repeated work and using hardware well, not from better worst-case bounds.

This review traces that progress in two parts, algorithms and systems, and then sets out the scalability limits that remain. Its purpose is to help a reader judge what current tools can be expected to do and where a new workload is likely to fail.

The article is a narrative review of the published literature on exact and approximate mining of subgraph patterns in static graphs. It concentrates on work that introduced an idea later adopted widely, and it relies on earlier surveys for breadth: Jiang et al. (2013) cover frequent subgraph mining algorithms in detail, and Ribeiro et al. (2021) cover subgraph counting. No systematic search was performed and no performance figures are reproduced, since results reported on different hardware, graphs and patterns cannot be set side by side with any confidence. Graph neural approaches to pattern counting and the mining of temporal graphs fall outside the scope.

Two settings must be kept apart. In the transactional setting the input is a collection of many small graphs, such as molecules, and a pattern is frequent if it occurs in at least a given number of them. Support counts graphs, not embeddings, so one occurrence per graph is enough. In the single-graph setting the input is one large graph and support must be defined over embeddings. Counting embeddings directly breaks the property on which all frequent pattern mining depends, namely that a pattern can be no more frequent than its subpatterns. Bringmann and Nijssen (2008) proposed the minimum image based support, which takes for each pattern vertex the number of distinct data vertices it maps to and then the minimum over pattern vertices. The measure is anti-monotone and cheap to compute, and it is now the usual choice.

A second distinction concerns what is asked for. Frequent subgraph mining discovers patterns. Subgraph matching lists the embeddings of a given pattern. Motif or graphlet counting returns the number of occurrences of every pattern up to a small size, and clique listing is the special case of complete patterns. A further choice is whether matches are induced, so that the data graph has no extra edges among the matched vertices, or merely edge-preserving. Systems differ in which of these they support natively, and a benchmark for one says little about another.

The algorithms on which present systems rest were developed over roughly four decades. Figure 1 marks the contributions that the remainder of this section and the next describe.

General graph processing frameworks were not built for this workload. Pregel popularised the vertex-centric model, in which each vertex exchanges messages with its neighbours in synchronised rounds (Malewicz et al., 2010). The model suits computations whose state is proportional to the graph, such as PageRank. Pattern mining produces intermediate state proportional to the number of partial embeddings, and encoding those as messages overwhelms both memory and network. Dedicated systems followed, and Table 1 groups them into three generations.

Arabesque introduced the embedding as the unit of computation. The system enumerates all embeddings of size k, passes each to a user-defined filter and process function, and extends the survivors to size k + 1, distributing the work across machines and compressing the stored embeddings (Teixeira et al., 2015). The interface is simple and general, but the system explores every connected subgraph up to the target size whether or not it can match the pattern of interest, and it must test each embedding for canonicality to avoid counting it more than once. Fractal kept the model and replaced stored embeddings with depth-first recomputation from compact state, which trades processor time for memory (Dias et al., 2019). RStream took the opposite route on a single machine, expressing extension as a relational join over edge streams on disk (Wang et al., 2018).

The second shift was to let the pattern guide the search. AutoMine compiles each pattern into nested loops over set intersections and differences of adjacency lists, which is the worst-case optimal join strategy made concrete, and schedules the loops to share work between patterns (Mawhirter and Wu, 2019). Peregrine analyses the pattern at run time to obtain a matching order and a set of ordering constraints on the matched vertices; these constraints break the pattern's symmetries so that each match is produced once and no canonicality test is needed (Jamshidi et al., 2020). GraphPi searches over combinations of matching order and symmetry-breaking restrictions with a cost model and uses inclusion-exclusion to count without enumerating the innermost loops (Shi et al., 2020). Pangolin showed that the extend and filter steps can be run in bulk on graphics processors when embedding lists fit in device memory (Chen et al., 2020).

Pattern-aware systems made small patterns on large graphs routine. They did not change the shape of the problem, and five limits persist in the literature.

Three directions seem the most promising responses to these limits. The first is approximation with usable guarantees: estimators whose error can be bounded for the rare patterns that applications care about, and systems that expose the trade between accuracy and cost to the user. The second is incremental mining. Most production graphs change continuously, and recomputing pattern counts after each batch of edge updates wastes the previous result; restricting the search to matches that involve a changed edge is conceptually simple but complicates symmetry breaking and support maintenance. The third is tighter integration with query processing. Since pattern matching is a join, optimisers that combine worst-case optimal and conventional join operators, and that reason about labels and predicates through statistics, could bring to mining the cost-based planning it currently lacks.

Graph pattern mining has advanced through a steady accumulation of pruning ideas: canonical codes that visit each pattern once, support measures that permit early termination, matching orders derived from the pattern, and symmetry breaking that eliminates duplicate matches before they are generated. Systems built on these ideas handle small patterns over very large graphs on a single well-provisioned machine. The limits that remain are structural. They concern output size, skew, symmetry in larger patterns, distribution and the comparability of results, and they are more likely to yield to approximation, incremental computation and better planning than to further tuning of exact enumeration.

To be declared by the author(s) before publication.

To be declared by the author(s) before publication.