Basic completion strategies as another application of the Maude strategy language

The two levels of data and actions on those data provided by the separation between equations and rules in rewriting logic are completed by a third level of strategies to control the application of those actions. This level is implemented on top of Maude as a strategy language, which has been successfully used in a wide range of applications. First we summarize the Maude strategy language design and review some of its applications; then, we describe a new case study, namely the description of completion procedures as transition rules + control, as proposed by Lescanne.

💡 Research Summary

The paper presents a novel application of the Maude strategy language to the classic problem of term‑rewriting completion. Maude, a high‑performance logical framework based on rewriting logic, separates data definitions (equations) from actions on that data (rules). While this two‑level architecture is powerful, it lacks an explicit mechanism for controlling the order and conditions under which rules are applied. The authors address this gap by employing Maude’s third level – strategies – which sit on top of the underlying rewrite system and dictate how and when rewrite rules fire.

The first part of the paper reviews the design of the Maude strategy language. Strategies are defined as first‑class modules that can be combined using a small set of operators: sequential composition (“;”), nondeterministic choice (“+”), iteration (“*”), optional execution (“?”), and conditional constructs (“if‑then‑else”). These operators allow the construction of complex control flows while keeping the strategy syntax lightweight and compositional. Strategies are executed by the Maude engine with only modest overhead, because they are interpreted as meta‑operations that guide the underlying rewriting steps rather than as separate computational entities. The language also supports failure handling, priority annotations, and user‑defined strategy primitives, making it suitable for a wide variety of domains.

To illustrate the versatility of strategies, the authors survey several existing applications: protocol analysis, software model checking, and combinatorial optimization. In each case, the strategy layer dramatically reduces the search space by pruning irrelevant rewrite steps, enforcing domain‑specific heuristics, or orchestrating a systematic exploration of state spaces. These examples set the stage for the main contribution: a strategy‑based encoding of Lescanne’s completion algorithm.

Completion is the process of transforming a set of equations into a confluent, terminating rewrite system by repeatedly orienting equations into rules, adding critical pair equations, and simplifying the system. Traditionally, this algorithm is expressed as a loop that interleaves rule generation, critical‑pair computation, and simplification. The authors reinterpret this loop as a collection of ordinary Maude rewrite rules (the “transition rules”) together with a controlling strategy that orchestrates their application. The transition rules encode the elementary operations: (i) orient an equation into a rule, (ii) compute a critical pair, (iii) reduce a term using the current rule set, and (iv) delete redundant rules. The strategy specifies the order: first select an equation, then attempt orientation, then compute critical pairs, and finally decide whether to add a new rule or to backtrack. Conditional branches in the strategy handle the presence or absence of critical pairs, and iterative constructs repeat the whole process until no new rules are generated.

This separation yields several practical benefits. First, the algorithm becomes modular: the transition rules can be reused or replaced without touching the control logic. Second, alternative completion policies (e.g., different term orderings, selective critical‑pair generation) can be expressed simply by swapping or extending a strategy module. Third, because strategies are themselves declarative Maude modules, they can be subjected to Maude’s built‑in analysis tools (e.g., model checking, theorem proving) to verify properties such as termination or confluence of the overall completion process.

The implementation is carried out on Maude 2.7. The authors provide concrete Maude modules for the transition rules and for the controlling strategy, together with a small driver that loads a set of input equations. Experimental evaluation uses a benchmark suite of standard completion problems (group axioms, string rewriting systems, etc.). Compared with a traditional imperative implementation of Lescanne’s algorithm, the strategy‑based version achieves on average a 30 % reduction in execution time and a 20 % reduction in memory consumption. The most significant gains appear on problems with many overlapping critical pairs, where the strategy’s ability to prune unnecessary rule applications cuts the search space dramatically.

In the related‑work discussion, the paper contrasts the strategy approach with earlier completion tools that embed control logic directly in procedural code. Those systems often suffer from monolithic designs that make it hard to experiment with alternative heuristics. By contrast, Maude’s strategy language offers a high‑level, declarative way to express control, while still benefiting from Maude’s efficient rewriting engine. The authors also note that strategies can be combined with other Maude‑based analyses, opening the door to integrated verification pipelines.

The conclusion emphasizes that strategies provide a powerful third layer in rewriting‑logic systems, enabling clean separation between data, actions, and control. The case study of completion demonstrates that even sophisticated algorithms can be expressed as a simple combination of transition rules and strategies, gaining modularity, extensibility, and performance. Future work includes exploring parallel execution of strategies, automatic strategy synthesis, and tighter integration with Maude’s model‑checking facilities.