Results 11  20
of
24
State space reduction of rewrite theories using invisible transitions
 P. Proceedings of the 21st German Annual Conference on Artificial Intelligence
, 2006
"... Abstract. State space explosion is the hardest challenge to the effective application of model checking methods. We present a new technique for achieving drastic state space reductions that can be applied to a very wide range of concurrent systems, namely any system specified as a rewrite theory. Gi ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Abstract. State space explosion is the hardest challenge to the effective application of model checking methods. We present a new technique for achieving drastic state space reductions that can be applied to a very wide range of concurrent systems, namely any system specified as a rewrite theory. Given a rewrite theory R = (Σ, E, R) whose equational part (Σ, E) specifies some state predicates P, we identify a subset S ⊆ R of rewrite rules that are Pinvisible, so that rewriting with S does not change the truth value of the predicates P. We then use S to construct a reduced rewrite theory R/S in which all states reachable by Stransitions become identified. We show that if R/S satisfies reasonable executability assumptions, then it is in fact stuttering bisimilar to R and therefore both satisfy the same CT L ∗ −X formulas. We can then use the typically much smaller R/S to verify such formulas. We show through several case studies that the reductions achievable this way can be huge in practice. Furthermore, we also present a generalization of our construction that instead uses a stuttering simulation and can be applied to an even broader class of systems. 1
Abstract Critical Pairs and Confluence of Arbitrary Binary Relations
, 2007
"... In a seminal paper, Huet introduced abstract properties of term rewriting systems, and the confluence analysis of terminating term rewriting systems by critical pairs computation. In this paper, we provide an abstract notion of critical pair for arbitrary binary relations and context operators. We ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
In a seminal paper, Huet introduced abstract properties of term rewriting systems, and the confluence analysis of terminating term rewriting systems by critical pairs computation. In this paper, we provide an abstract notion of critical pair for arbitrary binary relations and context operators. We show how this notion applies to the confluence analysis of various transition systems, ranging from classical term rewriting systems to production rules with constraints and partial control strategies, such as the Constraint Handling Rules language CHR. Interestingly, we show in all these cases that some classical critical pairs can be disregarded. The crux of these analyses is the ability to compute critical pairs between states built with general context operators, on which a bounded, not necessarily wellfounded, ordering is assumed.
Correctness and Verification of Hardware Systems Using Maude
, 2000
"... We consider models of hardware systems, within a welldeveloped set of mathematical tools based on an equational, algebraic model. We implement these tools using Maude, an equational, algebraic language with strong metalanguage tools and an efficient term rewriting implementation. Maude has the same ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
We consider models of hardware systems, within a welldeveloped set of mathematical tools based on an equational, algebraic model. We implement these tools using Maude, an equational, algebraic language with strong metalanguage tools and an efficient term rewriting implementation. Maude has the same mathematical basis as the existing formal tools and it is fast. We consider the process of verification, and apply it to a simple illustrative pipeline. Microprocessors, and related systems, are modelled as iterated maps. Initialisation functions act as an invariant when applying onestep theorems to reduce formal verification to state exploration.
Using Maude to write and execute ODP Information Viewpoint specifications
 Computer Standards & Interfaces
, 2005
"... The aim of the open distributed processing (ODP) information viewpoint is to describe the semantics of the information and of the information processing in a system, from a global point of view, without having to worry about other considerations, such as how the information will be finally distribut ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
The aim of the open distributed processing (ODP) information viewpoint is to describe the semantics of the information and of the information processing in a system, from a global point of view, without having to worry about other considerations, such as how the information will be finally distributed or implemented or the technology used to achieve such implementation. Although several notations have been proposed to model this ODP viewpoint, they are not expressive enough to faithfully represent all the information concepts, or they tend to suffer from a lack of (formal) support, or both. In this paper, we explore the use of Maude as a formal notation for writing ODP information specifications. Maude is an executable rewriting logic language especially well suited for the specification of objectoriented open and distributed systems. We show how Maude offers a simple, natural, and accurate way of modeling the ODP information viewpoint concepts, allows the execution of the specifications produced, and offers good tool support for reasoning about them.
Learning to Verify Systems
, 2006
"... Making high quality and reliable software systems remains a difficult problem. One approach to address this problem is automated verification which attempts to demonstrate algorithmically that a software system meets its specification. However, verification of software systems is not easy: such sys ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Making high quality and reliable software systems remains a difficult problem. One approach to address this problem is automated verification which attempts to demonstrate algorithmically that a software system meets its specification. However, verification of software systems is not easy: such systems are often modeled using abstractions of infinite structures such as unbounded integers, infinite memory for allocation, unbounded space for call stack, unrestricted queue sizes and so on. It can be shown that for most classes of such systems, the verification problem is actually undecidable (there exists no algorithm which will always give the correct answer for arbitrary inputs). In spite of this negative theoretical result, techniques have been developed which are successful on some practical examples although they are not guaranteed to always work. This dissertation is in a similar spirit and develops a new paradigm for automated verification of large or infinite state systems. We observe that even if the state space of a system is infinite, for practical examples, the set of reachable states (or other fixpoints needed for verification) is often expressible in a simple representation. Based on this observation, we propose an entirely new approach to verification: the idea is to use techniques from computational learning theory to identify the reachable states (or other fixpoints) and then verify the property of interest. To use learning techniques, we solve key problems of
Algebraic Simulations ⋆
"... Abstract. Rewriting logic is a flexible and general logic to specify concurrent systems. To prove properties about concurrent systems in temporal logic, it is very useful to use simulations that relate the transitions and atomic predicates of a system to those of a potentially much simpler one; then ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract. Rewriting logic is a flexible and general logic to specify concurrent systems. To prove properties about concurrent systems in temporal logic, it is very useful to use simulations that relate the transitions and atomic predicates of a system to those of a potentially much simpler one; then, if the simpler system satisfies a property ϕ in a suitable temporal logic we are guaranteed that the more complex system does too. In this paper, the suitability of rewriting logic as a formal framework not only to specify concurrent systems but also to specify simulations is explored in depth. For this, increasingly more general notions of simulation (allowing stuttering) are first defined for Kripke structures, and suitable temporal logics allowing properties to be reflected back by such simulations are characterized. The paper then proves various representability results à la Bergstra and Tucker, showing that recursive Kripke structures and recursive simulation maps (resp. r.e. simulation relations) can always be specified in a finitary way in rewriting logic. Using simulations typically requires both model checking and theorem proving, since their correctness requires discharging proof obligations. In this regard, rewriting logic, by containing equational logic as a sublogic and having equationallybased inductive theorem proving at its disposal, is shown to be particularly wellsuited for verifying the correctness of simulations.
The Maude formal tool environment
 Algebra and Coalgebra in Computer Science (CALCO’07), volume 4624 of Lecture Notes in Computer Science
, 2007
"... Abstract. This paper describes the main features of several tools concerned with the analysis of either Maude specifications, or of extensions of such specifications: the ITP, MTT, CRC, ChC, and SCC tools, and RealTime Maude for realtime systems. These tools, together with Maude itself and its sea ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. This paper describes the main features of several tools concerned with the analysis of either Maude specifications, or of extensions of such specifications: the ITP, MTT, CRC, ChC, and SCC tools, and RealTime Maude for realtime systems. These tools, together with Maude itself and its searching and modelchecking capabilities constitute Maude’s formal environment. 1
Formalizing ODP Enterprise Specifications in Maude
 in Maude. Computer Standards & Interfaces
, 2003
"... Maude is an executable rewriting logic language specially well suited for the specification of objectoriented open and distributed systems. In this paper we explore the possibility of using Maude as a formal notation for writing and reasoning about RMODP enterprise specifications. Maude o#ers a si ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Maude is an executable rewriting logic language specially well suited for the specification of objectoriented open and distributed systems. In this paper we explore the possibility of using Maude as a formal notation for writing and reasoning about RMODP enterprise specifications. Maude o#ers a simple, natural and accurate way of modeling the enterprise viewpoint concepts, which provides interesting benefits over previous modeling approaches, allows overcoming some of their limitations, and o#ers good tool support.
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
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
Zilles. Formally defining and verifying master/slave speculative parallelization
 In Proceedings of the International Symposium of Formal Methods Europe (FM’05
, 2005
"... ..."