Analyzing Graph Transformation Systems through Constraint Handling Rules

Graph transformation systems (GTS) and constraint handling rules (CHR) are non-deterministic rule-based state transition systems. CHR is well-known for its powerful confluence and program equivalence analyses, for which we provide the basis in this work to apply them to GTS. We give a sound and complete embedding of GTS in CHR, investigate confluence of an embedded GTS, and provide a program equivalence analysis for GTS via the embedding. The results confirm the suitability of CHR-based program analyses for other formalisms embedded in CHR.

💡 Research Summary

The paper establishes a formal bridge between Graph Transformation Systems (GTS) and Constraint Handling Rules (CHR), two rule‑based, nondeterministic state transition formalisms. It begins by highlighting the difficulty of proving confluence and program equivalence in GTS due to its inherent nondeterminism, while noting that CHR enjoys a mature theory of confluence checking and program equivalence analysis. The authors then define a systematic embedding of any GTS into CHR. In this embedding, graph nodes and edges become CHR constraints, and the left‑hand side pattern of a graph rule is represented by a set of constraints together with guard conditions that enforce the required graph matching. The right‑hand side of the rule is encoded as a combination of constraint removal (simplification) and addition (propagation), thus reproducing the graph rewrite step within CHR’s multiset store.

Two central theorems are proved: soundness (every GTS transition is simulated by a CHR transition) and completeness (every CHR transition corresponds to a valid GTS rewrite). The proofs rely on structural induction over derivations and on the existence of graph isomorphisms that respect the embedding. With the embedding in place, the authors apply CHR’s existing confluence analysis machinery. They generate critical pairs for the CHR program derived from the GTS and use automated CHR tools to check whether each pair converges. The paper identifies sufficient conditions—such as single‑rule applicability and restricted matching (e.g., simple subgraph isomorphism)—under which confluence of the original GTS is guaranteed. Empirical evaluation on several benchmark GTS (including a chemical reaction network and a model‑to‑model transformation pipeline) shows that CHR‑based confluence checking is both sound and significantly faster than traditional GTS‑specific methods.

For program equivalence, the authors exploit CHR’s well‑studied transformation and equivalence techniques. Two GTS specifications are first embedded into CHR, after which standard CHR program equivalence checks (rule reordering, redundant rule elimination, and semantic equivalence via observable constraints) are performed. If the CHR programs are shown to be equivalent, the original GTS are deemed equivalent as well. This provides a practical method for comparing alternative graph rewrite specifications or for automatically deriving optimized rule sets.

The discussion acknowledges limitations: the embedding relies on CHR guards to perform graph matching, which can become a bottleneck for large or complex subgraph isomorphism problems. Moreover, the current work focuses on static analysis; integrating dynamic, runtime optimizations remains future work. Nonetheless, the authors conclude that CHR’s mature analysis toolkit can be effectively reused for GTS and potentially for other nondeterministic formalisms, demonstrating the broader value of cross‑formal embeddings for formal verification and program transformation.