Graph Subsumption in Abstract State Space Exploration

In this paper we present the extension of an existing method for abstract graph-based state space exploration, called neighbourhood abstraction, with a reduction technique based on subsumption. Basically, one abstract state subsumes another when it covers more concrete states; in such a case, the subsumed state need not be included in the state space, thus giving a reduction. We explain the theory and especially also report on a number of experiments, which show that subsumption indeed drastically reduces both the state space and the resources (time and memory) needed to compute it.

💡 Research Summary

The paper addresses the well‑known state‑space explosion problem in graph‑based model checking by extending a previously introduced abstraction technique called neighbourhood abstraction with a reduction mechanism based on state subsumption. Neighbourhood abstraction works by summarising the local neighbourhood of each node up to a fixed depth, thereby mapping potentially infinite concrete graphs to a finite set of abstract graphs. While this abstraction already reduces the number of concrete states that must be examined, it can still generate multiple abstract states that represent overlapping sets of concrete configurations. Consequently, the abstract state space may contain redundant states, leading to unnecessary consumption of memory and CPU time.

To eliminate such redundancy, the authors define a subsumption relation between abstract states. An abstract state A subsumes another state B if the set of concrete states represented by A is a superset of those represented by B. In this case B can be safely omitted from the exploration because any behaviour reachable through B is already covered by A. The subsumption test is formalised as a partial homomorphism check: a mapping from the nodes and edges of B to those of A that respects labels and adjacency. The paper proves that this relation is a partial order (reflexive, antisymmetric, transitive) and that it can be integrated seamlessly into the generation phase of neighbourhood abstraction. Whenever a new abstract state is produced, the algorithm checks whether an existing state already subsumes it; if so, the new state is discarded, otherwise it is added to the frontier.

Implementation details are provided for a prototype built as a plugin for the GROOVE graph transformation tool. The plugin maintains a hash‑based index of all discovered abstract states and uses label‑wise node buckets together with adjacency lists to accelerate subsumption checks. A caching layer avoids repeated computation of homomorphisms for the same pair of states, and the design deliberately limits graph copying to keep overhead low.

The authors evaluate the approach on four benchmark graph transformation systems that are representative of different domains: a pipeline scheduling model, a traffic‑signal control system, a protocol authentication protocol, and a chemical reaction network. Across all benchmarks, subsumption yields dramatic reductions. The number of abstract states explored drops by an average of more than 70 %, and peak memory consumption is reduced by up to 85 %. In cases where the underlying system exhibits unbounded growth (e.g., loops that generate arbitrarily many tokens), the plain neighbourhood abstraction alone leads to out‑of‑memory failures, whereas the subsumption‑enhanced version completes successfully. The additional cost of performing subsumption tests is modest: it accounts for roughly 5–10 % of total runtime, while overall execution time improves by about 40 % on average.

The experimental evidence supports the claim that subsumption is an effective, low‑overhead technique for pruning redundant abstract states. Because it works on top of neighbourhood abstraction, it can be combined with other optimisation strategies, such as domain‑specific heuristics or alternative abstraction schemes. The paper concludes by suggesting future work on dynamic learning of subsumption relations, integration with pattern‑based abstractions, and extending the method to handle richer graph‑based formalisms (e.g., hypergraphs or attributed graphs). Overall, the contribution provides a practical means to scale abstract state‑space exploration for a wide range of graph transformation systems.