Specification, Refinement and Verification of Concurrent Systems—An Integration of Object-Z and CSP

This paper presents a method of formally specifying, refining and verifying concurrent systems which uses the object-oriented state-based specification language Object-Z together with the process algebra CSP. Object-Z provides a convenient way of modelling complex data structures needed to define the component processes of such systems, and CSP enables the concise specification of process interactions. The basis of the integration is a semantics of Object-Z classes identical to that of CSP processes. This allows classes specified in Object-Z to be used directly within the CSP part of the specification.In addition to specification, we also discuss refinement and verification in this model. The common semantic basis 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.

[1]  Howard Bowman,et al.  Viewpoint Consistency in Z and LOTOS: A Case Study , 1997, FME.

[2]  Frits W. Vaandrager,et al.  Process algebra semantics of POOL , 1992 .

[3]  John Derrick,et al.  Refinement and verification of concurrent systems specified in Object-Z and CSP , 1997, First IEEE International Conference on Formal Engineering Methods.

[4]  Jonathan P. Bowen,et al.  ZUM '97: The Z Formal Specification Notation , 1997, Lecture Notes in Computer Science.

[5]  C. A. R. Hoare,et al.  Communicating Sequential Processes (Reprint) , 1983, Commun. ACM.

[6]  Cliff B. Jones,et al.  Systematic software development using VDM , 1986, Prentice Hall International Series in Computer Science.

[7]  Jim Woodcock,et al.  On the Refinement and Simulation of Data Types and Processes , 1999, IFM.

[8]  Burkhart Wolff,et al.  A Corrected Failure Divergence Model for CSP in Isabelle/HOL , 1997, FME.

[9]  Roger Duke,et al.  Object-Z: a specification language advocated for the description of standards , 1995 .

[10]  J. Michael Spivey,et al.  The Z notation - a reference manual , 1992, Prentice Hall International Series in Computer Science.

[11]  Graeme Smith,et al.  A Semantic Integration of Object-Z and CSP for the Specification of Concurrent Systems , 1997, FME.

[12]  Graeme Smith,et al.  Combining CSP and Object-Z: Finite or Infinite Trace Semantics? , 1997, FORTE.

[13]  M. Benjamin.  A Message Passing System. An example of combining CSP and Z , 1989, Z User Workshop.

[14]  Jin Song Dong,et al.  Blending Object-Z and Timed CSP: an introduction to TCOZ , 1998, Proceedings of the 20th International Conference on Software Engineering.

[15]  Jin Song Dong,et al.  Sensors and Actuators in TCOZ , 1999, World Congress on Formal Methods.

[16]  Michael Goldsmith,et al.  FDR2 user manual , 2000 .

[17]  S. M. Brien,et al.  W: A Logic for Z , 1991, Z User Workshop.

[18]  Howard Bowman,et al.  Weak Refinement in Z , 1997, ZUM.

[19]  Howard Bowman,et al.  Specifying and Refining Internal Operations in Z , 1998, Formal Aspects of Computing.

[20]  Howard Bowman,et al.  Supporting ODP - Translating LOTOS to Z , 1997 .

[21]  Klaus-Peter Löhr,et al.  Object-Oriented Concurrent Programming , 1992, TOOLS.

[22]  Michael J. Butler.  A CSP approach to action systems , 1992 .

[23]  David A. Carrington,et al.  Specifying Interactive Systems in Object-Z and CSP , 1999, IFM.

[24]  Eerke A. Boiten,et al.  Specifying Component and Context Specification Using Promotion , 1999, IFM.

[25]  Grzegorz Rozenberg,et al.  Foundations of object-oriented languages : REX school/workshop, May 28 - June 1, 1990, Noordwijkerhout, The Netherlands , 1991 .

[26]  Mario Tokoro,et al.  Object-oriented concurrent programming , 1987 .

[27]  David J. Duke,et al.  Towards a Semantics for Object-Z , 1990, VDM Europe.

[28]  Mary Shaw,et al.  Formulations and Formalisms in Software Architecture , 1995, Computer Science Today.

[29]  Clemens Fischer.  CSP-OZ: a combination of object-Z and CSP , 1997 .

[30]  Andrew William Roscoe,et al.  The Theory and Practice of Concurrency , 1997 .

[31]  Jim Woodcock,et al.  Using Z - specification, refinement, and proof , 1996, Prentice Hall international series in computer science.

[32]  A. W. Roscoe.  An Alternative Order for the Failures Model , 1992, J. Log. Comput..

[33]  C. A. R. Hoare,et al.  A Theory of Communicating Sequential Processes , 1984, JACM.

[34]  Carsten Sühl.  RT-Z: An Integration of Z and timed CSP , 1999, IFM.

[35]  A. W. Roscoe,et al.  An Improved Failures Model for Communicating Processes , 1984, Seminar on Concurrency.

[36]  Graeme Smith,et al.  The Object-Z Specification Language , 1999, Advances in Formal Methods.

[37]  Matthias Weber.  Combining Statecharts and Z for the Design of Safety-Critical Control Systems , 1996, FME.

[38]  Maritta Heisel,et al.  Formal Specification of Safety-Critical Software with Z and Real-Time CSP , 1996, SAFECOMP.

[39]  Von der Fakult.  An Integration of Z and Timed CSP for Specifying Real-Time Embedded Systems , 2002 .

[40]  Robert Worden.  The Process of Refinement , 1991 .

[41]  Tommaso Bolognesi,et al.  Tableau methods to describe strong bisimilarity on LOTOS processes involving pure interleaving and enabling , 1994, FORTE.

[42]  A. W. Roscoe,et al.  Unbounded Nondeterminism in CSP , 1989, Mathematical Foundations of Programming Semantics.

[43]  Grzegorz Rozenberg,et al.  Foundations of Object-Oriented Languages , 1991 .

[44]  Jim Woodcock,et al.  Refinement of State-Based Concurrent Systems , 1990, VDM Europe.

[45]  Graeme Smith.  Extending W for Object-Z , 1995, ZUM.

[46]  Joseph A. Goguen,et al.  A Categorial Theory of Objects as Observed Processes , 1990, REX Workshop.

[47]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.