Timing and causality in process algebra

There has been considerable controversy in concurrency theory between the ‘interleaving’ and ‘true concurrency’ schools. The former school advocates associating a transition system with a process which captures concurrent execution via the interleaving of occurrences; the latter adopts more complex semantic structures to avoid reducing concurrency to interleaving.In this paper we show that the two approaches are not irreconcilable. We define a timed process algebra where occurrences are associated with intervals of time, and give it a transition system semantics. This semantics has many of the advantages of the interleaving approach; the algebra admits an expansion theorem, and bisimulation semantics can be used as usual. Our transition systems, however, incorporate timing information, and this enables us to express concurrency: merely adding timing appropriately generalises transition systems to asynchronous transition systems, showing that time gives a link between true concurrency and interleaving. Moreover, we can provide a complete axiomatisation of bisimulation for our algebra; a result that is often problematic in a timed setting.Another advantage of incorporating timing information into the calculus is that it allows a particularly simple definition of action refinement; this we present. The paper concludes with a comparison of the equivalence we present with those in the literature, and an example system specification in our formalism.

[1]  Glynn Winskel,et al.  A Classiication of Models for Concurrency , 2007 .

[2]  Matthew Hennessy,et al.  Distributed bisimulations , 1989, JACM.

[3]  Wang Yi,et al.  CCS + Time = An Interleaving Model for Real Time Systems , 1991, ICALP.

[4]  Walter Vogler Failures semantics based on interval semiwords is a congruence for refinement , 2005, Distributed Computing.

[5]  Marco Roccetti,et al.  Towards Performance Evaluation in Process Algebras , 1993, AMAST.

[6]  J. Bergstra,et al.  Fixed point semantics in process algebras : (preprint) , 1982 .

[7]  M. Joseph,et al.  Relating Computation and Time , 1989 .

[8]  Matthew Hennessy,et al.  A Temporal Process Algebra , 1990, FORTE.

[9]  Gordon D. Plotkin,et al.  A structural approach to operational semantics , 2004, J. Log. Algebraic Methods Program..

[10]  Jan A. Bergstra,et al.  Real time process algebra , 1991, Formal Aspects of Computing.

[11]  Glynn Winskel,et al.  A Classification of Models for Concurrency , 1993, CONCUR.

[12]  Alley Stoughton,et al.  Substitution Revisited , 1988, Theor. Comput. Sci..

[13]  Kim G. Larsen,et al.  Real-Time Calculi and Expansion Theorems , 1992, NAPAW.

[14]  David Murphy,et al.  Timed Process Algebra, Petri Nets, and Event Refinement , 1991 .

[15]  G. Erard Boudol Atomic Actions (note) , 1989 .

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

[17]  J.J.C. Meijer,et al.  Refinement in branching time semantics , 1989 .

[18]  Joseph Sifakis,et al.  The Algebra of Timed Processes, ATP: Theory and Application , 1994, Inf. Comput..

[19]  Marco Roccetti,et al.  Towards Performance Evaluation in Process Algebras 1 , 1993 .

[20]  Tom Axford Concurrent programming - fundamental techniques for real-time and parallel software design , 1989, Wiley series in parallel computing.

[21]  Maciej Koutny,et al.  Petri Net Semantics of Priority Systems , 1992, Theor. Comput. Sci..

[22]  Matthew Hennessy,et al.  A theory of processes with localities , 1992, Formal Aspects of Computing.

[23]  Marek Antoni Bednarczyk,et al.  Categories of asynchronous systems , 1987 .

[24]  Unique decomposition of processes , 1990, Bull. EATCS.

[25]  Steve A. Schneider,et al.  An Operational Semantics for Timed CSP , 1995, Inf. Comput..

[26]  Luca Aceto,et al.  Relating distributed, temporal and causal observations of simple processes , 1992, Fundam. Informaticae.

[27]  Antoni W. Mazurkiewicz,et al.  Traces, Histories, Graphs: Instances of a Process Monoid , 1984, International Symposium on Mathematical Foundations of Computer Science.

[28]  Matthew Hennessy,et al.  Axiomatising Finite Concurrent Processes , 1988, SIAM J. Comput..

[29]  David Murphy,et al.  On the Ill-Timed but Well-Caused , 1993, CONCUR.

[30]  Friedemann Mattern,et al.  Virtual Time and Global States of Distributed Systems , 2002 .

[31]  Colin J. Fidge A constraint-oriented real-time process calculus , 1992, FORTE.

[32]  Matthew Hennessy,et al.  Observing Localities , 1993, Theor. Comput. Sci..

[33]  R. J. van Glabbeek,et al.  Comparative Concurrency Semantics and Refinement of Actions , 1996 .

[34]  Luca Aceto,et al.  A Complete Axiomatization of Timed Bisimulation for a Class of Timed Regular Behaviours , 1995, Theor. Comput. Sci..

[35]  Walter Vogler,et al.  Modular Construction and Partial Order Semantics of Petri Nets , 1992, Lecture Notes in Computer Science.

[36]  David Murphy,et al.  Real-Timed Concurrent Refineable Behaviours , 1992, FTRTFT.

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

[38]  Rob J. van Glabbeek,et al.  Branching Time and Abstraction in Bisimulation Semantics (Extended Abstract) , 1989, IFIP Congress.

[39]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[40]  Luca Aceto,et al.  A Complete Axiomatization of Timed Bisimulation for a Class of Timed Regular Behaviours (Revised Version) , 1994 .

[41]  Rocco De Nicola,et al.  A Partial Ordering Semantics for CCS , 1990, Theor. Comput. Sci..

[42]  Faron Moller,et al.  Axioms for concurrency , 1989 .

[43]  Jan A. Bergstra,et al.  Global Renaming Operators in Concrete Process Algebra , 1988, Inf. Comput..

[44]  Rob J. van Glabbeek,et al.  A Complete Axiomatization for Branching Bisimulation Congruence of Finite-State Behaviours , 1993, MFCS.

[45]  Leslie Lamport,et al.  Interprocess Communication , 2020, Practical System Programming with C.

[46]  Faron Moller,et al.  A Temporal Calculus of Communicating Systems , 1990, CONCUR.

[47]  Jos C. M. Baeten,et al.  Process Algebra , 2007, Handbook of Dynamic System Modeling.

[48]  Roy H. Campbell,et al.  Atomic Actions in Concurrent Systems , 1986, ICDCS.

[49]  Jan Friso Groote,et al.  An Efficient Algorithm for Branching Bisimulation and Stuttering Equivalence , 1990, ICALP.

[50]  Jim Davies,et al.  A Brief History of Timed CSP , 1995, Theor. Comput. Sci..

[51]  Philippe Darondeau,et al.  Causal Trees , 1989, ICALP.