Vertical Implementation

We investigate criteria to relate specifications and implementations belonging to conceptually different levels of abstraction. For this purpose, we introduce the generic concept of a vertical implementation relation, which is a family of binary relations indexed by a refinement function that maps abstract actions onto concrete processes and thus determines the basic connection between the abstraction levels. If the refinement function is the identity, the vertical implementation relation collapses to a standard (horizontal) implementation relation. As desiderata for vertical implementation relations we formulate a number of congruence-like proof rules (notably a structural rule for recursion) that offer a powerful, compositional proof technique for vertical implementation. As a candidate vertical implementation relation we propose vertical bisimulation. Vertical bisimulation is compatible with the standard interleaving semantics of process algebra; in fact, the corresponding horizontal relation is rooted weak bisimulation. We prove that vertical bisimulation satisfies the proof rules for vertical implementation, thus establishing the consistency of the rules. Moreover, we define a corresponding notion of abstraction that strengthens the intuition behind vertical bisimulation and also provides a decision algorithm for finite-state systems. Finally, we give a number of small examples to demonstrate the advantages of vertical implementation in general and vertical bisimulation in particular.

[1]  Matthew Hennessy,et al.  Symbolic Bisimulations , 1995, Theor. Comput. Sci..

[2]  Arend Rensink,et al.  Action Refinement as an Implementation Relations , 1997, TAPSOFT.

[3]  Ursula Goltz,et al.  Equivalences and Refinement , 1990, Semantics of Systems of Concurrent Processes.

[4]  Walter Vogler,et al.  Bisimulation and Action Refinement , 1991, Theor. Comput. Sci..

[5]  Ursula Goltz,et al.  Refinement of actions and equivalence notions for concurrent systems , 2001, Acta Informatica.

[6]  Michaela Huhn,et al.  Action Refinement and Property Inheritance in Systems of Sequential Agents , 1996, CONCUR.

[7]  Arend Rensink Models and Methods for Action Refinement , 1993 .

[8]  Grzegorz Rozenberg,et al.  Stepwise Refinement of Distributed Systems Models, Formalisms, Correctness , 1989, Lecture Notes in Computer Science.

[9]  Grzegorz Rozenberg,et al.  Linear Time, Branching Time and Partial Order in Logics and Models for Concurrency , 1988, Lecture Notes in Computer Science.

[10]  Walter Vogler,et al.  The Limit of Split_n-Language Equivalence , 1995, ICALP.

[11]  Jörg Desel Structures in Concurrency Theory , 1995, Workshops in Computing.

[12]  Luca Aceto,et al.  Towards Action-Refinement in Process Algebras , 1993, Inf. Comput..

[13]  Rob J. van Glabbeek The Refinement Theorem for ST-bisimulation Semantics , 1990, Programming Concepts and Methods.

[14]  Arend Rensink An Event-Based SOS for a Language with Refinement , 1995, STRICT.

[15]  Ursula Goltz,et al.  Interleaving semantics and action refinement with atomic choice , 1992, Advances in Petri Nets: The DEMON Project.

[16]  Rob J. van Glabbeek,et al.  Petri Net Models for Algebraic Theories of Concurrency , 1987, PARLE.

[17]  Michel Bidoit,et al.  TAPSOFT '97: Theory and Practice of Software Development , 1997, Lecture Notes in Computer Science.

[18]  Irène Guessarian Semantics of Systems of Concurrent Processes , 1990, Lecture Notes in Computer Science.

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

[20]  Kim S. Larsen,et al.  Fully abstract models for a process language with refinement , 1988, REX Workshop.

[21]  Irène Guessarian,et al.  Semantics of systems of concurrent processes : LITP Spring School on Theoretical Computer Science, La Roche Posay, France, April 23-27, 1990, proceedings , 1990 .

[22]  Heike Wehrheim Parametric Action Refinement , 1994, PROCOMET.

[23]  Arend Rensink,et al.  Methodological Aspects of Action Refinement , 1994, PROCOMET.

[24]  Arend Rensink,et al.  Weak Sequential Composition in Process Algebras , 1994, CONCUR.

[25]  Philippe Darondeau,et al.  On Guarded Recursion , 1991, Theor. Comput. Sci..

[26]  Simon L. Peyton Jones,et al.  Imperative functional programming , 1993, POPL '93.

[27]  Robin Milner,et al.  Barbed Bisimulation , 1992, ICALP.

[28]  Arend Rensink,et al.  Comparing Syntactic and Semantic Sction Refinement , 1996, Inf. Comput..

[29]  Arend Rensink,et al.  Action Refinement , 1999, Handbook of Process Algebra.

[30]  Walter Vogler,et al.  The Limit of Splitn-Language Equivalence , 1996, Inf. Comput..

[31]  Julian Bradfield CONCUR '96: Concurrency Theory , 1996 .

[32]  Arend Rensink,et al.  Bisimilarity of open terms , 1999, EXPRESS.

[33]  Robin Milner,et al.  On Observing Nondeterminism and Concurrency , 1980, ICALP.

[34]  Rocco De Nicola,et al.  Testing Equivalences for Processes , 1984, Theor. Comput. Sci..

[35]  Rocco De Nicola,et al.  Testing Equivalence for Processes , 1983, ICALP.

[36]  Cosimo Laneve,et al.  Split and ST Bisimulation Semantics , 1995, Inf. Comput..

[37]  Luca Aceto,et al.  Adding Action Refinement to a Finite Process Algebra , 1994, Inf. Comput..

[38]  Roberto Gorrieri,et al.  A hierarchy of system descriptions via atomic linear refinement , 1992, Fundam. Informaticae.

[39]  Walter Vogler Failures Semantics Based on Interval Semiwords is a Congruence for Refinement , 1990, STACS.

[40]  Mario Bravetti,et al.  Deciding and Axiomatizing ST Bisimulation for a Process Algebra with Recursion and Action Refinement , 1999, EXPRESS.

[41]  R. V. Glabbeek The Linear Time - Branching Time Spectrum II: The Semantics of Sequential Systems with Silent Moves , 1993 .

[42]  David Sands From SOS rules to proof principles: an operational metatheory for functional languages , 1997, POPL '97.

[43]  Mario Bravetti,et al.  Deciding and axiomatizing weak ST bisimulation for a process algebra with recursion and action refinement , 2002, TOCL.

[44]  Rob J. van Glabbeek,et al.  Branching time and abstraction in bisimulation semantics , 1996, JACM.

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

[46]  Jcm Jos Baeten,et al.  Abstraction and empty process in process algebra , 1987 .

[47]  Grzegorz Rozenberg,et al.  Semantics: Foundations and Applications , 1992, Lecture Notes in Computer Science.

[48]  Grzegorz Rozenberg Advances in Petri Nets 1992 , 1992, Lecture Notes in Computer Science.

[49]  Bengt Jonsson,et al.  Refining Interfaces of Communicating Systems , 1991, TAPSOFT, Vol.2.

[50]  Roberto Gorrieri,et al.  A Categorial View of Process Refinement , 1992, REX Workshop.

[51]  Douglas J. Howe Proving Congruence of Bisimulation in Functional Programming Languages , 1996, Inf. Comput..

[52]  Roberto Gorrieri,et al.  A Causal Operational Semantics of Action Refinement , 1995, Inf. Comput..

[53]  Bengt Jonsson,et al.  CONCUR ’94: Concurrency Theory , 1994, Lecture Notes in Computer Science.

[54]  Rob J. van Glabbeek,et al.  The Linear Time - Branching Time Spectrum II , 1993, CONCUR.

[55]  Ursula Goltz,et al.  Refinement of Actions in Causality Based Models , 1990, REX Workshop.

[56]  Mannes Poel,et al.  Action Systems and Action Refinement in the Development of Parallel Systems - An Algebraic Approach , 1991, CONCUR.