The Maude LTL model checker supports on-the-y explicit-state model checking of concurrent systems expressed as rewrite theories with performance comparable to that of current tools of that kind, such as SPIN. This greatly expands the range of applications amenable to model checking analysis. Besides traditional areas well supported by current tools, such as hardware and communication protocols, many new applications in areas such as rewriting logic models of cell biology, or nextgeneration reective distributed systems can be easily speci ed and model checked with our tool.

This paper explains the design and use of two equational proving tools, namely an inductive theorem prover -- to prove theorems about equational specifications with an initial algebra semantics -- and a Church-Rosser checker---to check whether such specifications satisfy the Church-Rosser property. These tools can be used to prove properties of order-sorted equational specifications in Cafe [11] and of membership equational logic specifications in Maude [7, 6]. The tools have been written entirely in Maude and are in fact executable specifications in rewriting logic of the formal inference systems that they implement.

Eden is a concurrent declarative language that aims at both the programming of reactive systems and parallel algorithms on distributed memory systems. In this paper, we explain the computation and coordination model of Eden. We show how lazy evaluation in the computation language is fruitfully combined with the coordination language that is specifically designed for multicomputers and that aims at maximum parallelism. The two-level structure of the programming language is reflected in its operational semantics, which is sketched shortly.

First-order languages based on rewrite rules share many features with functional languages. But one difference is that matching and rewriting can be made much more expressive and powerful by incorporating some built-in equational theories. To provide reasonable programming environments, compilation techniques for such languages based on rewriting have to be designed. This is the topic addressed in this paper. The proposed techniques are independent from the rewriting language and may be useful to build a compiler for any system using rewriting modulo associative and commutative (AC) theories. An algorithm for many-to-one AC matching is presented, that works efficiently for a restricted class of patterns. Other patterns are transformed to fit into this class. A refined data structure, namely compact bipartite graph, allows encoding all matching problems relative to a set of rewrite rules. A few optimisations concerning the construction of the substitution and of the reduced term are described. We also address the problem of non-determinism related to AC rewriting and show how to handle it through the concept of strategies. We explain how an analysis of the determinism can be performed at compile time and we illustrate the benefits of this analysis for the performance of the compiled evaluation process. Then we briefly introduce the ELAN system and its compiler, in order to give some experimental results and comparisons with other languages or rewrite engines.

Abstract. Abstraction reduces the problem of whether an infinite state system satisfies version. The most common abstractions are quotients of the original system. We present a simple method of defining quotient abstractions by means of equations collapsing the set of states. Our method yields the minimal quotient system together with a set of proof obligations that guarantee its executability and can be discharged with tools such as those in the Maude formal environment.

This paper describes in detail how to bridge the gap between theory and practice in a new implementation of the CCS operational semantics in Maude, where transitions become rewrites and inference rules become conditional rewrite rules with rewrites in the conditions, as made possible by the new features in Maude 2.0. We implement both the usual transition semantics and the weak transition semantics where internal actions are not observed, and on top of them we also implement the HennessyMilner modal logic for describing processes. We compare this implementation with a previous one where transitions become judgements and inference rules become rewrites, and also comment on extensions to the LOTOS language.

The ρ-calculus permits to express in a uniform and simple way firstorder rewriting, λ-calculus and non-deterministic computations as well as their combination. In this paper, we present the main components of the ρ-calculus and we give a full first-order presentation of this rewriting calculus using an explicit substitution setting, called ρσ, that generalizes the λσ-calculus. The basic properties of the non-explicit and explicit substitution versions are presented. We then detail how to use the ρ-calculus to give an operational semantics to the rewrite rules of the ELAN language. 1

This paper presents the design, the implementation and experiments of the integration of syntactic, conditional possibly associative-commutative term rewriting into proof assistants based on constructive type theory. Our approach is called external since it consists in performing term rewriting in a speci c and ecient environment and to check the computations later in a proof assistant.

A metalogical framework is a logic with an associated methodology that is used to represent other logics and to reason about their metalogical properties. We propose that logical frameworks can be good metalogical frameworks when their logics support reective reasoning and their theories always have initial models. We present a concrete realization of this idea in rewriting logic. Theories in rewriting logic always have initial models and this logic supports reective reasoning. This implies that inductive reasoning is valid when proving properties about the initial models of theories in rewriting logic, and that we can use reection to reason at the metalevel about these properties. In fact, we can uniformly reect induction principles for proving metatheorems about rewriting logic theories and their parameterized extensions. We show that this reective methodology provides an eective framework for dierent, non-trivial, kinds of formal metatheoretic reasoning; one can...

In this paper we formalise CSP solving as an inference process. Based on the notion of Computational Systems we associate actions with rewriting rules and control with strategies that establish the order of application of the inferences. The main contribution of this work is to lead the way to the design of a formalism allowing to better understand constraint solving and to apply in the domain of CSP the knowledge already developed in Automated Deduction. Keywords: Constraint Satisfaction Problems, Computational Systems, Rewriting Logic. 1 Introduction In the last twenty years many work has been done on solving Constraint Satisfaction Problems, CSP. The solvers used by constraint solving systems can be seen as encapsulated in black boxes. In this work we formalise CSP solving as an inference process. We are interested in description of constraint solving using rule-based algorithms because of the explicit distinction made in this approach between deduction rules and control. We associ...