In computer science we speak of implementing a logic; this is done in a programming language, such as Lisp, called here the implementation language. We also reason about the logic, as in understanding how to search for proofs; these arguments are expressed in the metalanguage and conducted in the metalogic of the object language being implemented. We also reason about the implementation itself, say to know it is correct; this is done in a programming logic. How do all these logics relate? This paper considers that question and more. We show that by taking the view that the metalogic is primary, these other parts are related in standard ways. The metalogic should be suitably rich so that the object logic can be presented as an abstract data type, and it must be suitably computational (or constructive) so that an instance of that type is an implementation. The data type abstractly encodes all that is relevant for metareasoning, i.e., not only the term constructing functions but also the...

In this paper we describe the use of the rewriting logic based Maude tool to model and analyze mammalian signaling pathways. We discuss the representation of the underlying biological concepts and events and describe the use of the new search and model checking capabilities of Maude 2.0 to analyze the modeled network. We also discuss the use of Maude's reflective capability for meta modeling and analyzing the models themselves. The idea of symbolic biological experiments opens up an exciting new world of challenging applications for formal methods in general and for rewriting logic based formalisms in particular.

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...

2 Dedicated with affection to my beloved parents Cecilia and Miklós 3 4

Abstract not found

This document explains the design and use of a coherence checker tool and of a coherence completion tool. The coherence checker tool checks whether a rewrite logic specification is coherent, and the coherence completion tool tries to complete a rewrite logic specification in order to make it coherent. These tools can be used to prove the coherence property or to coherence complete order-sorted rewrite specifications in Maude [7, 5, 2]. The tools have been written entirely in Maude and are in fact executable specifications in rewriting logic [14] of the formal inference system that they implement. The fact that rewriting logic is reflective [8, 1], and that Maude efficiently supports reflective rewriting logic computations [3, 2] is systematically exploited in the design of the tools.

This document explains the design and use of a termination checker tool and of a Knuth-Bendix completion tool. The termination checker tool checks whether an equational specication terminates, and the Knuth-Bendix completion tool tries to complete an equational speci- cation. These tools can be used to prove the termination or to complete order-sorted equational specications in Maude [7, 6, 4]. The tools have been written entirely in Maude and are in fact executable specications in rewriting logic [17] of the formal inference system that they implement. The fact that rewriting logic is reective [8, 3], and that Maude eciently supports reective rewriting logic computations [5, 4] is systematically exploited in the design of the tools. Contents 1

AbstractMany distributed applications can be understood in terms of components interacting in an open environment such as the Internet. Open environmentsare subject to change in uncontrollable ways, as other applications may arrive, change, or disappear. In order to test the behavior of components in suchenvironments, it is necessary to build a testing environment which reflects this highly unpredictable behavior. To avoid over-specification of environmentcomponents, we use the observable communication history to abstractly reflect the state of communicating components. Rewriting logic has beenused to capture many different systems of concurrency and communication in an executable manner. In this paper, we show how rewriting logic models canbe extended with observable communication histories in a transparent way and suggest using this extension to capture a form of assumption guaranteespecification based testing of components in open environments.

Introduction The increasing importance, criticality, and complexity of communications software makes very desirable the application of formal methods to gain high assurance about its correctness. These needs are even greater in the context of active networks, because the diculties involved in ensuring critical properties such as security and safety for dynamically adaptive software are substantially higher than for more static software approaches. There are in fact many obstacles to the insertion of formal methods in this area, and yet there is a real need to nd adequate ways to increase the quality and reliability of critical communication systems. As a consequence, in spite of the existence of good research contributions in formal approaches to areas such as distributed algorithms and cryptographic protocols, in practice new systems are developed for the most part in a traditional engineering way, using informal techniques, and without much to go by before detailed simulatio

Existing meta-programming languages operate on encodings of programs as data. This paper presents a new meta-programming language, based on an untyped lambda calculus, in which structurally reflective programming is supported directly, without any encoding. The language features call-by-value and call-by-name lambda abstractions, as well as novel reflective features enabling the intensional manipulation of arbitrary program terms. The language is scope safe, in the sense that variables can neither be captured nor escape their scopes. The expressiveness of the language is demonstrated by showing how to implement quotation and evaluation operations, as proposed by Wand. The language’s utility for meta-programming is further demonstrated through additional representative examples. A prototype implementation is described and evaluated.