Refinement and verification of concurrent systems specified in Object-Z and CSP

The formal development of large or complex systems can often be facilitated by the use of more than one formal specification language. Such a combination of languages is particularly suited to the specification of concurrent or distributed systems, where both the modelling of processes and state is necessary. This paper presents an approach to refinement and verification of specifications written using a combination of Object-Z and CSP. A common semantic basis for the two languages enables a unified method of refinement to be used, based upon CSP refinement. To enable state-based techniques to be used for the Object-Z components of a specification we develop state-based refinement relations which are sound and complete with respect to CSP refinement. In addition, a verification method for static and dynamic properties is presented. The method allows us to verify properties of the CSP system specification in terms of its component Object-Z classes by using the laws of the CSP operators together with the logic for Object-Z

Integrating BON and Object-Z.

A significant limitation with object-oriented formal specification languages, such as Object-Z, is that they lack development and management processes, which can be used to guide the production of reliable, robust object-oriented systems. An integration of an object-oriented methodology, BON, and Object-Z is presented in order to add an industrially validated development process to Object-Z. An extensible CASE tool for BON is also described that supports the integration with an Object-Z code generation engine

Model checking object-Z using ASM

A major problem with creating tools for Object-Z is that its high-level abstractions are difficult to deal with directly. Integrating Object-Z with a more concrete notation is a sound strategy. With this in mind, in this paper we introduce an approach to model-checking Object-Z specifications based on first integrating Object-Z with the Abstract State Machine (ASM) notation to get the notation OZ-ASM. We show that this notation can be readily translated into the specification language ASM-SL, a language that can be automatically translated into the language of the temporal logic model checker SMV

Hardness and inapproximability results for minimum verification set and minimum path decision tree problems

Minimization of decision trees is a well studied problem. In this work, we introduce two new problems related to minimization of decision trees. The problems are called minimum verification set (MinVS) and minimum path decision tree (MinPathDT) problems. Decision tree problems ask the question "What is the unknown given object?". MinVS problem on the other hand asks the question "Is the unknown object z?", for a given object z. Hence it is not an identification, but rather a verification problem. MinPathDT problem aims to construct a decision tree where only the cost of the root-to-leaf path corresponding to a given object is minimized, whereas decision tree problems in general try to minimize the overall cost of decision trees considering all the objects. Therefore, MinVS and MinPathDT are seemingly easier problems. However, in this work we prove that MinVS and MinPathDT problems are both NP-complete and cannot be approximated within a factor in o(lg n) unless P = NP

Towards an Interactive Learning Environment for Object-Z

We have been engaged in research towards designing a software system called LOZ for learning the object oriented formal specification notation Object-Z. Initially, we conducted a survey to analyse the effectiveness of traditional methodologies for learning Z notation. In LOZ, the semi-formal model UML is used in the intermediate phase between informal textual description and formal Object-Z description. We also employ a refinement unit that produces code from the specification. Based on the cognitive apprenticeship approach, we employ a four-phase instructional model in our system. Persuading the learners to be partially responsible for their own model and allowing them to decide their own levels of control over the learning process are key features of our system

A software modelling exercise using FCA

This paper describes an exercise in object-oriented modelling where Formal Concept Analysis is applied to a formal specification case study using Object-Z. In particular, the informal description from the case study is treated as a set of use-cases from which candidate classes and objects are derived. The resulting class structure is contrasted with the existing Object-Z design and the two approaches are discussed

Mapping UML models incorporating OCL constraints into object-Z

Focusing on object-oriented designs, this paper proposes a mapping for translating systems modelled in the Unified Modelling Language (UML) incorporating Object Constraint Language (OCL) constraints into formal software specifications in Object-Z. Joint treatment of semi-formal model constructs and constraints within a single translation framework and conversion tool is novel, and leads to the generation of much richer formal specifications than is otherwise possible. This paper complements previous analyses by paying particular attention to the generation of complete Object-Z structures. Integration of proposals to extend the OCL to include action constraints also boosts the expressivity of the translated specifications. The main features of a tool support are described

Specifying the Behavior of UML Collaborations Using Object-Z

UML is a standard modelling language that is able to specify a wide range of object-oriented concepts. Among them, we have collaborations, that serve to realise use cases, a powerful abstraction concept. The behaviour part of a collaboration is rendered using collaboration diagrams. However, the lack of formalisation compromises the precision of the specification. By using formal description techniques, such as Object-Z, we can reason about the requirements and identify ambiguities and inconsistencies earlier in the development process. In general, we can say that formalisation helps obtaining a more reliable system. Our aim is to formalise collaborations Object-Z class schemas. This is accomplished by proposing an integrated formal process