Towards Automated Refinement: Patterns in Event B
Linas Laibinis2009
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their insufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by increasing automation of development steps. We introduce a notion of refinement patterns -generic representations of typical correctness-preserving model transformations. Our definition of a refinement pattern contains a description of syntactic model transformations, as well as the pattern applicability conditions and proof obligations for verification of correctness preservation. This establishes a basis for building a tool supporting formal system development via pattern reuse and instantiation. We present a prototype of such a tool and some examples of refinement patterns for automated development in the Event B formalism.
Related papers
Formal Refinement Automation
2008
Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their insufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by increasing automation of development steps. We introduce a notion of refinement patterns -generic representations of typical correctness-preserving model transformations. Our definition of a refinement pattern contains a description of syntactic model transformations, as well as the pattern applicability conditions and proof obligations for verification of correctness preservation. This establishes a basis for building a tool supporting formal system development via pattern reuse and instantiation. We present a prototype of such a tool and some examples of refinement patterns for automated development in the Event B formalism.
Patterns for Refinement Automation
Lecture Notes in Computer Science, 2010
Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their in-sufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by increasing automation of development steps. We introduce a notion of refinement patterns -generic representations of typical correctnesspreserving model transformations. Our definition of a refinement pattern contains a description of syntactic model transformations, as well as the pattern applicability conditions and proof obligations for verification of correctness preservation. This establishes a basis for building a tool supporting formal system development via pattern reuse and instantiation. We present a prototype of such a tool and some examples of refinement patterns for automated development in the Event B formalism.
A Formal Approach to Model Refactoring and Model Refinement
Software and Systems …, 2007
Model-driven engineering is an emerging software engineering approach that relies on model transformation. Typical kinds of model transformations are model refinement and model refactoring. Whenever such a transformation is applied to a consistent model, we would like to know whether the consistency is preserved by the transformation. Therefore, in this article, we formally define and explore the relation between behaviour inheritance consistency of a refined model with respect to the original model, and behaviour preservation of a refactored model with respect to the original model. As it turns out, there is a strong similarity between these notions of behaviour consistency and behaviour preservation. To illustrate this claim, we formalised the behaviour specified by UML 2.0 sequence and protocol state machine diagrams. We show how the reasoning capabilities of description logics, a decidable fragment of first-order logic, can be used in a natural way to detect behaviour inconsistencies. These reasoning capabilities can be used in exactly the same way to detect behaviour preservation violations during model Communicated by refactoring. A prototype plug-in in a UML CASE tool has been developed to validate our claims.
Guided formal development: patterns for modelling and refinement
2008
Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their insufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by providing them with guidelines comprising a collection of reusable modelling and refinement patterns. A modelling pattern encapsulates a tactic for achieving a certain goal in the development process. Furthermore, we generalise our experience in developing systems by refinement via defining generic refinement patterns. Our approach is exemplified by the Event-B-based development of agent systems. The use of modelling and refinement patterns helps us to achieve a higher degree of automation in formal modelling which would potentially ease the use of formal models.
REFINER: Towards Formal Verification of Model Transformations
Lecture Notes in Computer Science, 2014
We present the Refiner tool, which offers techniques to define behavioural transformations applicable on formal models of concurrent systems, reason about semantics preservation and the preservation of safety and liveness properties of such transformations, and apply them on models. Behavioural transformations allow to change the potential behaviour of systems. This is useful for model-driven development approaches, where systems are designed and created by first developing an abstract model, and iteratively refining this model until it is concrete enough to automatically generate source code from it. Properties that hold on the initial model and should remain valid throughout the development in later models can be maintained, by which the effort of verifying those properties over and over again is avoided. The tool integrates with the existing model checking toolsets mCRL2 and Cadp, resulting in a complete model checking approach for model-driven system development.
A Reification Calculus for Model-Oriented Software Specification
Formal Aspects of Computing, 1990
This paper presents a transformational approach to the derivation of implementations from model-oriented specifications of abstract data types. The purpose of this research is to reduce the number of formal proofs required in model refinement, which hinder software development. It is shown to be applicable to the transformation of models written in META-IV (the specification language of VDM) towards their refinement into, for example, Pascal or relational DBMSs. The approach includes the automatic synthesis of retrieve functions between models, and data-type invariants. The underlying algebraic semantics is the so-calledfinal semantics “à la Wand”: a specification “is” amodel (heterogeneous algebra) which is the final object (up to isomorphism) in the category of all its implementations. The transformational calculus approached in this paper follows from exploring the properties of finite, recursively defined sets. This work extends the well-known strategy of program transformation to model transformation, adding to previous work on a transformational style for operation-decomposition in META-IV. The model-calculus is also useful for improving model-oriented specifications.
A rigorous approach for proving model refactorings
Proceedings of the 20th IEEE/ACM international Conference on Automated software engineering - ASE '05, 2005
Both model and program refactorings are usually proposed in an ad hoc way because it is difficult to prove that they are sound with respect to a formal semantics. In this paper, we propose guidelines on how to rigorously prove model refactorings for Alloy, a formal object-oriented modeling language. We use the Prototype Verification System (PVS) to specify and prove the soundness of the transformations. Proposing refactorings in this way can facilitate not only design, but also improve the quality of refactoring tools.
Formal behavior modeling and effective automatic refinement
Information Sciences, 2010
Modeling and refining behaviors of software systems are two crucial issues in the methodology of Model-Driven Development (MDD). Traditional methods include Unified Modeling Language (UML) based methods and formal methods. Recently integrated methods by taking full advantages of these two methods have received increasing attention. Unfortunately, there are still no effective formal modeling and automatic refinement methods for behaviors. Besides, difficulties exist in generating some structures, e.g., explicit loop structures, via existing approaches.
Trans-DV: A Framework for Developing and Formally Verifying Model Transformation Specifications
2011
Abstract The Trans-DV framework proposes a set of languages for specifying model transformations with attached verification properties. The languages are based on a corpus of transformation patterns, which support automatically generating a formal specification using templates that are amenable to simulation and analysis.
INTEGRATION OF AUTOMATIC THEOREM PROVERS IN EVENT-B PATTERNS
Event-B is a formal method for the system level modeling and analysis of dependable applications. It is supported by an open and extendable Eclipse-based tool set called Rodin. In this paper we proposed using Automatic theorem provers known as SMT-solvers with event-B pattern. The benefits of that are to reduce the proving effort, to reuse a model and to increase the degree of automation. The proposed approach has been applied successfully on two different case studies.
Related papers
Supporting Reuse of Event-B Developments through Generic Instantiation
Lecture Notes in Computer Science, 2009
It is believed that reusability in formal development should reduce the time and cost of formal modelling within a production environment. Along with the ability to reuse formal models, it is desirable to avoid unnecessary re-proof when reusing models. Event-B is a formal method that allows modelling and refinement of systems. Event-B supports generic developments through the context construct. Nevertheless Event-B lacks the ability to instantiate and reuse generic developments in other formal developments. We propose a way of instantiating generic models and extending the instantiation to a chain of refinements. We define sufficient proof obligations to ensure that the proofs associated to a generic development remain valid in an instantiated development thus avoiding re-proofs.
A Logical Framework for Integrating Software Models via Refinement
2016
We propose the development of an institution-based framework within which software models can be combined not only at different levels of abstraction but across multiple formalisms. Event-B is an industrial-strength formalism that supports refinement, we envisage that the construction of an institution for Event-B, EVT, will not only increase the modularity of Event-B specifications but also provide a foundation for the interoperability of Event-B with other formalisms.
Automatic Refinement for Event-B through Annotated Patterns
2017 25th Euromicro International Conference on Parallel, Distributed and Network-based Processing (PDP), 2017
In this paper, we investigate how patterns could be used in order to generate Event-B refinements automatically through DSL(s) for temporal, timed or distribution patterns. Our ulimate goal is to generate code for a concurrent, or distributed framework, e.g., BIP.
Event-B Patterns and Their Tool Support
2009
Event-B has given developers the opportunity to construct models of complex systems that are correct by construction. However, there is no systematic approach, especially in terms of reuse, which could help with the construction of these models. We introduce the notion of design patterns within the framework of Event-B to shorten this gap.
A formal approach to modeling and model transformations in software engineering
A software model is an abstract representation of a software system which can be used to describe, at a higher abstraction level, different aspects of the software system. Since the beginning of computer science, raising the abstraction level of software systems has been a continuous goal for many computer scientists. This has lead to the usage of models and modeling languages in software development processes. Currently in addition to documentation purposes, models are increasingly used to automatically generate and integrate parts of the systems that they describe. As a consequence, there is a need for formal modeling languages and formal transformation denition techniques which can be employed to automatically translate between (and integrate) models. Therefore, a major focus of our research is on the formalization of modeling and model transformation in the generic formalism, Diagrammatic Predicate Logic (DPL). This paper provides an overview of the stateof-the-art of our ongoing research on analysis of modeling and model transformations based on the DPL framework.
Transforming Event B Models into Verified C# Implementations
EPiC Series in Computing
The refinement-based approach to developing software is based on thecorrect-by-construction paradigm were software systems are constructed via the step-by-step refinement of an initial high-level specification into a final concrete specification. Proof obligations, generated during this process are discharged to ensure the consistency between refinement levels and hence the system's overall correctness.Here, we are concerned with the refinement of specifications using the Event B modelling language and its associated toolset, the Rodin platform. In particular, we focus on the final steps of the process where the final concrete specification is transformed into an executable algorithm. The transformations involved are (a) the transformation from an Event B specification into a concrete recursive algorithm and (b) the transformation from the recursive algorithm into its equivalent iterative version. We prove both transformations correct and verify the correctness of the final code...
On the Use of Formal Techniques to Support Model Evolution
Model-driven engineering (MDE) is an emerging software engineering discipline that relies on model transformation. Model transformations can be very diverse, and encompass, among others, the following techniques: code generation, reverse engineering, model refinement and model refactoring. Due to the inherently volatile nature of all kinds of software artefacts, and models in particular, all existing and future MDE approaches should explicitly take into account the inevitable process of model evolution. In this paper, we explain why formal support for model evolution is needed. We motivate this by using the formalism of description logics to support the activity of model inconsistency management, and by using the formalism of graph transformation to support the activity of model refactoring.
Formal verification of model transformations: An automated framework
2010 International Joint Conference on Computational Cybernetics and Technical Informatics, 2010
When designing safety critical applications in UML, the system models are frequently projected into various mathematical domains (such as Petri nets, transition systems, process algebras, etc.) to carry out a formal analysis of the system under design by automatic model transformations. Automation surely increases the quality of such transformations as errors manually implanted into transformation programs during implementation are eliminated; however, conceptual flaws in transformation design still remain undetected. In this paper, we present a model-level, modeling language independent and highly automated technique to formally verify by model checking that a model transformation from an arbitrary well-formed model instance of the source modeling language into its target equivalent preserves (language specific) dynamic consistency properties. We demonstrate the feasibility of our approach on a complex mathematical model transformation from UML statecharts to Petri nets.
A Formalism for Automated Verification of Model Transformations
Abstract: Verification of models and model processing programs are fundamental issues and are inevitable in model-based software development in order to apply them in realworld solutions. Verification concerns the analysis of non-functional and functional properties as well. Model transformation developers are interested in offline methods for the verification process.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.