Maude is a high-level language and a high-performance system supporting executable specification and declarative programming in rewriting logic. Since rewriting logic contains equational logic, Maude also supports equational specification and programming in its sublanguage of functional modules and theories. The underlying equational logic chosen for Maude is membership equational logic, that has sorts, subsorts, operator overloading, and partiality definable by membership and equality conditions. Rewriting logic is reflective, in the sense of being able to express its own metalevel at the object level. Reflection is systematically exploited in Maude endowing the language with powerful metaprogramming capabilities, including both user-definable module operations and declarative strategies to guide the deduction process. This paper explains and illustrates with examples the main concepts of Maude's language design, including its underlying logic, functional, system and object-oriented modules, as well as parameterized modules, theories, and views. We also explain how Maude supports reflection, metaprogramming and internal strategies. The paper outlines the principles underlying the Maude system implementation, including its semicompilation techniques. We conclude with some remarks about applications, work on a formal environment for Maude, and a mobile language extension of Maude.

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.

In a similar way as 2-categories can be regarded as a special case of double categories, rewriting logic (in the unconditional case) can be embedded into the more general tile logic, where also side-effects and rewriting synchronization are considered. Since rewriting logic is the semantic basis of several language implementation efforts, it is useful to map tile logic back into rewriting logic in a conservative way, to obtain executable specifications of tile systems. We extend the results of earlier work by two of the authors, focusing on some interesting cases where the mathematical structures representing configurations (i.e., states) and effects (i.e., observable actions) are very similar, in the sense that they have in common some auxiliary structure (e.g., for tupling, projecting, etc.). In particular, we give in full detail the descriptions of two such cases where (net) process-like and usual term structures are employed. Corresponding to these two cases, we introduce two ca...

Rewriting logic expresses an essential equivalence between logic and computation. System states are in bijective correspondence with formulas, and concurrent computations are in bijective correspondence with proofs. Given this equivalence between computation and logic, a rewriting logic axiom of the form t \Gamma! t 0 has two readings. Computationally, it means that a fragment of a system 's state that is an instance of the pattern t can change to the corresponding instance of t 0 concurrently with any other state changes; logically, it just means that we can derive the formula t 0 from the formula t. Rewriting logic is entirely neutral about the structure and properties of the formulas/states t. They are entirely user-definable as an algebraic data type satisfying certain equational axioms. Because of this ecumenical neutrality, rewriting logic has, from a logical viewpoint, good properties as a logical framework, in which many other logics can be naturally represented. And, computationally, it has also good properties as a semantic framework, in which many different system styles and models of concurrent computation and many different languages can be naturally expressed without any distorting encodings. The goal of this paper is to provide a relatively gentle introduction to rewriting logic, and to paint in broad strokes the main research directions that, since its introduction in 1990, have been pursued by a growing number of researchers in Europe, the US, and Japan. Key theoretical developments, as well as the main current applications of rewriting logic as a logical and semantic framework, and the work on formal reasoning to prove properties of specifications are surveyed.

The fact that rewriting logic and Maude are reflective, so that rewriting logic specifications can be manipulated as terms at the metalevel, opens up the possibility of defining an algebra of module composition and transformation operations within the logic. This makes such a module algebra easily modifiable and extensible, enables the implementation of language extensions within Maude, and allows formal reasoning about the module operations themselves. In this paper we discuss in detail the Maude implementation of a specific choice of operations for a module algebra of this type, supporting module operations in the Clear/OBJ tradition as well as the transformation of object-oriented modules into system modules. 1

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

Tile logic extends rewriting logic, taking into account rewriting with side-effects and rewriting synchronization. Since rewriting logic is the semantic basis of several language implementation efforts, it is interesting to map tile logic back into rewriting logic in a conservative way, to obtain executable specifications of tile systems. The resulting implementation requires a meta-layer to control the rewritings, so that only tile proofs are accepted. However, by exploiting the reflective capabilities of the Maude language, such meta-layer can be specified as a kernel of internal strategies. It turns out that the required strategies are very general and can be reformulated in terms of search algorithms for non-confluent systems equipped with a notion of success. We formalize such strategies, giving their detailed description in Maude, and showing their application to modeling uniform tile systems. 1 Introduction The evolution of a process in a concurrent system often depends on the ...

The work presented here aims at bridging the gap between executable specifications and formal verification. In this paper we combine two levels of description without changing the framework. The operational level of Maude/rewriting logic and the property-oriented level of temporal logics are combined. The combination is done by an embedding. We propose a distributed temporal logic as an extension of rewriting logic. Rewriting logic is primarily a logic of change in which the deduction directly corresponds to the computation. In contrast to that, temporal logic is a logic to talk about change in a global way. Especially, more complex system properties such as safety and liveness can be regarded in a temporal logic setting. In our approach we maintain the possibility of executing Maude specifications on the rewrite machine for validation purposes, and add the possibility of formally reasoning about Maude specifications in a temporal logic setting. The work presented focuses on objectorie...

. Tile logic extends rewriting logic by taking into account sideeffects and rewriting synchronization. These aspects are very important when we model process calculi, because they allow us to express the dynamic interaction between processes and "the rest of the world". Since rewriting logic is the semantic basis of several language implementation efforts, an executable specification of tile systems can be obtained by mapping tile logic back into rewriting logic, in a conservative way. However, a correct rewriting implementation of tile logic requires the development of a metalayer to control rewritings, i.e., to discard computations that do not correspond to any deduction in tile logic. We show how such methodology can be applied to term tile systems that cover and extend a wide-class of SOS formats for the specification of process calculi. The well-known case-study of full CCS, where the term tile format is needed to deal with recursion (in the form of the replicator operator), is di...

Maude's language design and implementation make systematic use of the fact that rewriting logic is reflective. This makes the metatheory of rewriting logic accessible to the user in a clear and principled way, and makes possible many advanced metaprogramming applications, including user-definable strategy languages, language extensions by new module composition operations, development of theorem proving tools, and reifications of other languages and logics within rewriting logic. A naive implementation of reflection can be computationally very expensive. We explain the semantic principles and implementation techniques through which efficient ways of performing reflective computations are achieved in Maude through its predefined META-LEVEL module.