Rule-Based Graph Programs Matching the Time Complexity of Imperative Algorithms

2025-01-15

AI Summary

This paper addresses the long-standing efficiency bottleneck in rule-based graph programming: achieving time complexity comparable to classical imperative algorithms—without assumptions on node degrees or graph connectivity. We propose a compiler-enhanced graph data structure for the GP 2 language, integrating rooted rewriting rules, static analysis, and formal asymptotic complexity proofs. Our approach is the first to achieve, within a purely rule-based framework: (i) linear-time O(n + m) algorithms for connectivity and acyclicity testing; (ii) an O(nm) single-source shortest paths algorithm matching Bellman–Ford’s complexity; and (iii) full formal verification of both functional correctness and asymptotic time complexity for all algorithms. Experimental evaluation across diverse graph families confirms consistency between theoretical bounds and empirical performance.

Technology Category

• Knowledge Representation and Reasoning: Computational Complexity of Reasoning
• Machine Learning: Graph-based Machine Learning
• Data Mining & Knowledge Management: Graph Mining, Social Network Analysis & Community

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Semantics and Knowledge: Scalable techniques for the creation, curation, publication, maintenance, and consumption of large, Web-based, structured, reusable, knowledge graphs and ontologies
• Web Mining and Content Analysis: Robustness and generalizability of Web mining methods

Abstract

We report on a recent breakthrough in rule-based graph programming, which allows us to match the time complexity of some fundamental imperative graph algorithms. In general, achieving the complexity of graph algorithms in conventional languages using graph transformation rules 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.

Problem

• Rule-based Graph Programs
• Complex Connectivity
• Efficiency

Innovation

• Graph Processing
• Rule-based Programming
• Belman-Ford Algorithm