Results 1 
8 of
8
Equational abstractions
 of LNCS
, 2003
"... 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 m ..."
Abstract

Cited by 31 (12 self)
 Add to MetaCart
(Show Context)
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.
Abstract Diagnosis of Functional Programs
 LOGIC BASED PROGRAM SYNTHESIS AND TRANSFORMATION – 12TH INTERNATIONAL WORKSHOP, LOPSTR 2002, REVISED SELECTED PAPERS, VOLUME 2664 OF LECTURE NOTES IN COMPUTER SCIENCE
, 2002
"... We present a generic scheme for the declarative debugging of functional programs modeled as term rewriting systems. We associate to our programs a semantics based on a (continuous) immediate consequence operator, T R, which models the (values/normal forms) semantics of R. Then, we develop an effec ..."
Abstract

Cited by 22 (7 self)
 Add to MetaCart
(Show Context)
We present a generic scheme for the declarative debugging of functional programs modeled as term rewriting systems. We associate to our programs a semantics based on a (continuous) immediate consequence operator, T R, which models the (values/normal forms) semantics of R. Then, we develop an effective debugging methodology which is based on abstract interpretation: by approximating the intended specification of the semantics of R we derive a finitely terminating bottomup diagnosis method, which can be used statically. Our debugging framework does not require the user to either provide error symptoms in advance or answer questions concerning program correctness. We have made available a prototypical implementation in Haskell and have tested it on some non trivial examples.
Software Specification and Verification in Rewriting Logic
, 2003
"... One can distinguish two specification levels: a system specification level, in which the computational system of interest is specified; and a property specification level, in which the relevant properties are specified. These lectures present an approach to executable system specification based on e ..."
Abstract

Cited by 13 (4 self)
 Add to MetaCart
One can distinguish two specification levels: a system specification level, in which the computational system of interest is specified; and a property specification level, in which the relevant properties are specified. These lectures present an approach to executable system specification based on equational logic for deterministic systems and on rewriting logic for concurrent systems that is seamlessly integrated with a property specification level using firstorder, inductive, and temporal logics. This integration is directly supported by formal verification tools in the formal environment of the Maude rewriting logic language. We show how this approach and the supporting tools can be applied to the specification and verification of a wide variety of programs, that can be either declarative or imperative, and either deterministic or concurrent.
Maude's Module Algebra
, 2000
"... The reflective capabilities of rewriting logic and their efficient implementation in the Maude language can be exploited to endow a reflective language like Maude with a module algebra in which structured theories can be combined and transformed by means of a rich collection of module operations. We ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
The reflective capabilities of rewriting logic and their efficient implementation in the Maude language can be exploited to endow a reflective language like Maude with a module algebra in which structured theories can be combined and transformed by means of a rich collection of module operations. We have followed this approach and we have used the specification of such a module algebra as its implementation, including a user interface and an execution environment for it. The high level at which the specification of the module algebra has been given makes this approach particularly attractive when compared to conventional implementations, because of its shorter development time and the greater flexibility, maintainability, and extensibility that it affords. We explain the general principles of the reflective design of the module algebra and explain the categorical semantics of parameterized theories, modules and views and their instantiation, and the reflective algebraic specification of the different module and view operations.
Executable Computational Logics: Combining Formal Methods and Programming Language Based System Design
 In Proc. First Int’l Conf. on Formal Methods and Models for Codesign 2003, IEEE CS
"... An executable computational logic can provide the desired bridge between formal system properties and formal methods to verify them on the one hand, and executable models of system designs based on programming languages on the other. However, not all such logics are equally well suited for the task. ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
An executable computational logic can provide the desired bridge between formal system properties and formal methods to verify them on the one hand, and executable models of system designs based on programming languages on the other. However, not all such logics are equally well suited for the task. This paper gives some requirements that seem important for a computational logic to be suitable in practice, and discusses the experience with rewriting logic, its Maude language implementation, and its formal tool environment, concluding that they seem to meet well those requirements. 1. The General Idea The present conference explores a convergence of formal methods and programming language based approaches to system design in both hardware and embedded hardwaresoftware systems. There are many practical benefits to be gained from such a convergence and, furthermore, there are important research issues involved. I wish to put forward a simple general idea that in my view provides a conceptual key to exploring a convergence of this kind. As suggested in the title, the idea is that an executable computational logic can provide the desired bridge between formal system properties and formal methods to verify them on the one hand, and executable models of system designs based on programming languages on the other. The general idea as such is hardly new: it has already been demonstrated very successfully by different researchers using different computational logics. There are
Towards Behavioral Maude: Behavioral Membership Equational Logic Jos'e Meseguer 1
"... Maude's underlying equational logic, membership equational logic, generalizes and increases the expressive power of manysorted and ordersorted equational logics. We develop a hiddensorted extension of membership equational logic, and give conditions under which theories have both an algebrai ..."
Abstract
 Add to MetaCart
(Show Context)
Maude's underlying equational logic, membership equational logic, generalizes and increases the expressive power of manysorted and ordersorted equational logics. We develop a hiddensorted extension of membership equational logic, and give conditions under which theories have both an algebraic and a coalgebraic semantics, including final (co)algebras. We also discuss the language design of BMaude, based on such an extended logic and using categorical notions in and across the different institutions involved. We also explain how Maude's reflective semantics provides a systematic method to extend Maude to BMaude within Maude, including module composition operations, evaluation, and automated proof methods. Key words: Membership and hidden algebra, coalgebra, Maude.
Computational Logical Frameworks and Generic Program Analysis Technologies
"... The technologies developed to solve the verifying compiler grand challenge should be generic, that is, not tied to a particular language but widely applicable to many languages. Such technologies should also be semanticsbased, that is, based on a rigorous formal semantics of the languages. For this ..."
Abstract
 Add to MetaCart
(Show Context)
The technologies developed to solve the verifying compiler grand challenge should be generic, that is, not tied to a particular language but widely applicable to many languages. Such technologies should also be semanticsbased, that is, based on a rigorous formal semantics of the languages. For this, a computational logical framework with efficient executability and a spectrum of metatools can serve as a basis on which to: (1) define the formal semantics of any programming language; and (2) develop generic program analysis techniques and tools that can be instantiated to generate powerful analysis tools for each language of interest. Not all logical frameworks can serve such purposes well. We first list some specific requirements that we think are important to properly address the grand challenge. Then we present our experience with rewriting logic as supported by the Maude system and its formal tool environment. Finally, we discuss some future directions of research. 2 Logical Framework Requirements Based on experience, current trends, and the basic requirements of the grand challenge problem, we believe that any logical framework serving as a computational infrastructure for the various technologies for solving the grand challenge should have at least the following features: 1. good data representation capabilities, 2. support for concurrency and nondeterminism, 3. simplicity of the formalism, 1 4. efficient implementability, and efficient metatools, 5. support for reflection, 6. support for inductive reasoning, preferably with initial model semantics, 7. support for generation of proof objects, acting as correctness certificates. While proponents of a framework may claim that it has all these features, in some cases further analysis can show that it either lacks some of them, or can only “simulate ” certain features in a quite artificial way. A good example is the simulation/elimination of concurrency in inherently deterministic formalisms by implementing or defining thread/process scheduling algorithms. Another example might be the claim that the lambda calculus has good data representation capabilities because one can encode numbers as Church numerals.