BON-CASE: An Extensible CASE Tool for Formal Specification and Reasoning (original) (raw)

VeriAgent: an Approach to Integrating UML and Formal Verification Tools

Electronic Notes in Theoretical Computer Science, 2004

The mathematical notations of Formal Verification Tools (FVTs) do not prevent us from wrongly defining the behavior of systems, any more than UML-based CASE tools do. Both technologies have their advantages: respectively, precise and well defined semantics or high-level graphical notation. Unfortunately, these technologies are not fully integrated and usable in a single tool. With software rapidly growing in size and complexity, graphical specifications in languages like UML need to be formally verified, before the implementation phase, in order to guarantee the development of more reliable systems. While the enterprise of integrating CASE and FVTs has had reasonable success with the translation of simple diagrams to model checkers' notations, integration at the level of returning verification results to users was lacking. In this work we present a protocol interface for joining both technologies as a reliable solution to bridging this gap.

VeriAgent: an Approach to Integrating UML and Formal Verification Tools*1

Electronic Notes in Theoretical Computer Science, 2004

The mathematical notations of Formal Verification Tools (FVTs) do not prevent us from wrongly defining the behavior of systems, any more than UML-based CASE tools do. Both technologies have their advantages: respectively, precise and well defined semantics or high-level graphical notation. Unfortunately, these technologies are not fully integrated and usable in a single tool. With software rapidly growing in size and complexity, graphical specifications in languages like UML need to be formally verified, before the implementation phase, in order to guarantee the development of more reliable systems. While the enterprise of integrating CASE and FVTs has had reasonable success with the translation of simple diagrams to model checkers' notations, integration at the level of returning verification results to users was lacking. In this work we present a protocol interface for joining both technologies as a reliable solution to bridging this gap.

Developing BON as an Industrial-Strength Formal Method

Lecture Notes in Computer Science, 1999

The emerging Unified Modelling Language has been touted as merging the best features of existing modelling languages, and has been adopted by leading companies and vendors as a universal software modelling language. Some researchers are also looking to UML as a basis for formal methods development. A less known approach is BON (the Business Object Notation), which is based on the principles of seamlessness, reversibility and design by contract, making it an ideal basis for industrial-strength formal methods development of objectoriented software. In this paper, we argue that BON is much more suited for the application of formal methods than UML. We describe the properties that an industrial-strength formal method must have, show how algorithm refinement can be done in BON (as an example of using BON for formal development), and contrast BON with other approaches, including UML, Z, B and VDM.

Bogor: an extensible and highly-modular software model checking framework

2003

Model checking is emerging as a popular technology for reasoning about behavior properties of a wide variety of software artifacts including: requirements models, architectural descriptions, designs, implementations, and process models. The complexity of model checking is well-known, yet costeffective analyses have been achieved by exploiting, for example, naturally occurring abstractions and semantic properties of a target software artifact. Adapting a model checking tool to exploit this kind of domain knowledge often requires in-depth knowledge of the tool's implementation.

Integration of Formal Proof into Unified Assurance Cases with Isabelle/SACM

Formal Aspects of Computing, 2021

Assurance cases are often required to certify critical systems. The use of formal methods in assurance can improve automation, increase confidence, and overcome errant reasoning. However, assurance cases can never be fully formalised, as the use of formal methods is contingent on models that are validated by informal processes. Consequently, assurance techniques should support both formal and informal artifacts, with explicated inferential links between them. In this paper, we contribute a formal machine-checked interactive language, called Isabelle/SACM, supporting the computer-assisted construction of assurance cases compliant with the OMG Structured Assurance Case Meta-Model. The use of Isabelle/SACM guarantees well-formedness, consistency, and traceability of assurance cases, and allows a tight integration of formal and informal evidence of various provenance. In particular, Isabelle brings a diverse range of automated verification techniques that can provide evidence. To valida...

JoSEL: A Job Specification and Execution Language for Model Checking

2008

Abstract. Model checking tools and techniques are being applied for verification of concurrent systems by users having different skills and background. This ranges from formal methods experts with detailed knowledge of the inner workings of the tools over students learning about model checking techniques to engineers that are mostly interested in applying the technology as a black-box. This paper proposes JoSEL, a visual language for specification of executable model checking jobs.

Towards automating proofs for model-based software engineering

Abstract. Model-based approaches are commonly used to engineering software for safety-critical applications. Several artifacts, such as abstract specifications, formal refinements, and assertions at the implementation level require computational support for formal reasoning activities. Delivering formal verification tools that address such reasoning activities in an automated, trustable and flexible fashion remains a scientific challenge.

A Case Study in Combining Formal Verification and Model-Driven Engineering

2012

Formal methods are increasingly used in software engineering. They offer a formal frame that guarentees the correctness of developments. However, they use complex notations that might be difficult to understand for unaccustomed users. It thus becomes interesting to formally specify the core components of a language, implement a provably correct development, and manipulate its components in a graphical/ textual editor. This paper constitutes a first step towards using Model Driven Engineering (MDE) technology in an interactive proof development. It presents a transformation process from functional data structures, commonly used in proof assistants, to Ecore Models. The transformation is based on an MDE methodology. The resulting meta-models are used to generate graphical or textual editors. We will take an example to illustrate our approach: a simple domain specific language. This guiding example is a Java-like language enriched with assertions.

A formal framework for model verification in System Engineering: UPSL

HAL (Le Centre pour la Communication Scientifique Directe), 2010

the aim of this paper is to present and to illustrate a formal model verification framework called UPSL (Unified Property Specification Language) applied here in System Engineering verification activities context. The concepts and principles, the associated languages and supporting platform specification are presented. This framework is based on formalization of requirement under the form of properties and the use of proof mechanisms of properties taking into account the multi models, multi disciplinary, multi domains, multi paradigms, and last the collaborative characteristic of a system engineering project.