Rule-Based Graph Programs Matching the Time Complexity of Imperative Algorithms
Ziad Ismaili Alaoui, Detlef Plump
TL;DR
The paper tackles the challenge that rule-based graph programs in GP 2 typically underperform compared with imperative implementations due to graph-matching costs, especially on unbounded-degree or disconnected graphs. It introduces two compiler-driven data-structure enhancements that enable linear-time matching for core tasks and presents three case studies—recognising connected graphs, recognising acyclic graphs, and implementing Bellman–Ford shortest paths—with formal correctness and time-complexity proofs and empirical validation. The connectedness and acyclicity results achieve linear time on arbitrary input graphs, while the Bellman–Ford implementation attains the imperial-time $O(nm)$ bound, all demonstrated within GP 2’s rule-based paradigm. Together, these contributions close a long-standing gap between rule-based graph programming and imperative performance and point toward broader applicability through a library of advanced data structures.
Abstract
We report on recent advances in rule-based graph programming, which allow us to match the time complexity of some fundamental imperative graph algorithms. In general, achieving the time complexity of graph algorithms implemented in conventional languages using a rule-based graph-transformation language is challenging due to the cost of graph matching. Previous work demonstrated that with rooted rules, certain algorithms can be implemented in the graph programming language GP 2 such that their runtime matches the time complexity of imperative implementations. However, this required input graphs to have a bounded node degree and (for some algorithms) to be connected. In this paper, we overcome these limitations by enhancing the graph data structure generated by the GP 2 compiler and exploiting the new structure in programs. We present three case studies: the first program checks whether input graphs are connected, the second program checks whether input graphs are acyclic, and the third program solves the single-source shortest-paths problem for graphs with integer edge-weights. The first two programs run in linear time on (possibly disconnected) input graphs with arbitrary node degrees. The third program runs in time $O(nm)$ on arbitrary input graphs, matching the time complexity of imperative implementations of the Bellman-Ford algorithm. For each program, we formally prove its correctness and time complexity, and provide runtime experiments on various graph classes.