Calculus Of Communicating Systems Research Articles

An Equivalence of Communicating Processes in Distributed Environments

The equivalence of communicating processes with respect to their external behaviour is formalized and studied. The processes are represented by mathematical systems related to labelled event structures. The equivalence is similar to the known observational equivalence but it is defined in a manner which reflects how processes behave in distributed environments. It is shown that the introduced equivalence is a congruence with respect to operations as in CCS (Milner’s Calculus of Communicating Systems).

Readies and Failures in the Algebra of Communicating Processes

Readiness and failure semantics are studied in the setting of Algebra of Communicating Processes (ACP). A model of process graphs modulo readiness equivalence, respectively, failure equivalence, is constructed, and an equational axiom system is presented which is complete for this graph model. An explicit representation of the graph model is given, the failure model, whose elements are failure sets. Furthermore, a characterisation of failure equivalence is obtained as the maximal congruence which is consistent with trace semantics. By suitably restricting the communication format in ACP, this result is shown to carry over to subsets of Hoare’s Communicating Sequential Processes (CSP) and Milner’s Calculus of Communicating Systems (CCS). Also, the characterisation implies a full abstraction result for the failure model. In the above we restrict ourselves to finite processes without $\tau $-steps. At the end of the paper a comment is made on the situation for infinite processes with $\tau $-steps: notably we obtain that failure semantics is incompatible with Koomen’s fair abstraction rule, a proof principle based on the notion of bisimulation. This is remarkable because a weaker version of Koomen’s fair abstraction rule is consistent with (finite) failure semantics.

A distributed operational semantics for CCS based on condition/event systems

A new set of inference rules for the guarded version of Milner’s Calculus of Communicating Systems is proposed. They not only describe the actions agents may perform when in a given state, but also say which parts of the agents move when the global state changes. From the transition relation a particular Petri Net, namely a Condition/Event system called ΣCCS, is immediately derived. Our construction gives a semantics which is consistent with the interleaving semantics of CCS and exhibits full parallelism. The proof consists of relating the case graph of ΣCCS with the original and with the multiset (step) transition systems of the calculus.

Type theory and concurrency

This paper describes the use of an automated reasoning tool, the Nuprl system, to formalize Milner's Calculus of Communicating Systems (CCS). The goals of this work are two-fold: the first is to investigate the feasibility of using systems like Nuprl to handle the formal detail arising from reasoning about concurrency, while the second is to develop a framework in which various formalisms for reasoning about concurrency may be presented in an automated fashion. To these ends, an implementation in Nuprl of a formal theory of concurrency is described, an implementation of CCS in this mechanized semantic theory presented, and two means of analyzing CCS terms are investigated.

An interpreter for LOTOS, a specification language for distributed systems

AbstractLOTOS is an executable specification language for distributed systems currently being standardized within ISO as a tool for the formal specification of open systems interconnection protocols and services. It is based on an extended version of Milner's calculus of communicating systems (CCS) and on ACT ONE abstract data type (ADT) formalism. A brief introduction to LOTOS is given, along with a discussion of LOTOS operational semantics, and of the executability of LOTOS specifications. Further, an account of a prototype LOTOS interpreter is given, which includes an interactive system that allows the user to direct the execution of a specification (for example, for testing purposes). The interpreter was implemented in YACC/LEX, C and Prolog. The following topics are discussed: syntax and static semantics analysis; translation from LOTOS external format to internal representation; evaluation of ADT value expressions and extended CCS behaviour expressions. It is shown that the interpreter can be used in a variety of ways: to recognize whether a given sequence of interactions is allowed by the specification; to generate randomly chosen sequences of interactions; in a user‐guided generation mode, etc.

Timer description in CCS (Milner), LOTOS (ISO) and timed LOTOS (Quemada-Fernandez). A case analysis

The Calculus of Communicating Systems (CCS) devised by Milner is an algebraic calculus designed to describe and analyze the behaviour of different systems running in parallel. It has generated a lot of variants, amongst which we find the Language of Temporal Ordering Specification (LOTOS) of ISO, which is more precisely used in the domain of data communication protocol specifications. Recently, Quemada and Fernandez proposed the introduction of time in LOTOS (what we call Timed LOTOS henceforth). We specify in CCS, LOTOS and Timed LOTOS a simple handshake protocol with a one shot sender, a one shot receiver and two unidirectional channels with a capacity of one message and the possibility of loosing this message. For each of these specifications, we calculate the corresponding semantics, which show their properties such as the deadlock freeness and the livelock freeness. By the way, we also compare their relative power with respect to timer description. The conclusion is that none of these models is well suited for the description of timers and time out mechanisms. The reason of this is analyzed.

Extensions to communicating sequential processes to allow protocol performance specification

Formalisms based on Hoare's Communicating Sequential Processes (CSP) and Milner's Calculus of Communicating Systems (CCS) for verifying protocols are currently being used by the International Standard Organisation (ISO). However, these models need to be extended if protocol performance specification and verification is to be done, as neither of these models have timing information (other than sequencing) nor a way of specifying controlled loss of information. This paper presents two extensions to Hoare's CSP that are felt by the author to provide suitable mechanisms for specifying protocol performance. Firstly, the effects of introducing time into CSP are presented, based on the work done by Reed and Roscoe. Secondly, the traces model is modified by associating probabilities with event sequences. Finally, some example specifications are given using these two extensions.

Petri nets, algebras, morphisms, and compositionality

It is shown how a category of Petri nets can be viewed as a subcategory of two sorted algebras over multisets. This casts Petri nets in a familiar framework and provides a useful idea of morphism on nets different from the conventional definition—the morphisms here respect the behaviour of nets. The categorical constructions which result provide a useful way to synthesise nets and reason about nets in terms of their components; for example, various forms of parallel composition of Petri nets arise naturally from the product in the category. This abstract setting makes plain a useful functor from the category of Petri nets to a category of spaces of invariants and provides insight into the generalisations of the basic definition of Petri nets—for instance, the coloured and higher level nets of Kurt Jensen arise through a simple modification of the sorts of the algebras underlying nets. Further, it provides a smooth formal relation with other models of concurrency such as Milner's calculus of communicating systems (CCS) and Hoare's communicating sequential processes (CSP), though this is only indicated in this paper.

Structure of a LOTOS interpreter

LOTOS is an executable specification language for protocols and services currently being standardized within ISO. It is based on an extended version of Milner's Calculus of Communicating Systems (CCS) and ACT ONE Abstract Data Type formalism. After a brief introduction to LOTOS, we give here an account of a prototype LOTOS interpreter, which includes an interactive system that allows the user to direct the execution of a specification. The interpreter was implemented in YACC/LEX, C, and Prolog. The discussion includes the following topics: syntax and static semantics analysis; translation from LOTOS external format to internal representation; evaluation of Abstract Data Type value expressions and CCS * clauses.

Conformity analysis for communication protocols

In this paper we propose a methodology for conformity analysis of communication protocols. By conformity analysis it is meant to demonstrate that a protocol does indeed provide the service for which it is intended. We specify both a protocol and its service by a CSP (Communicating Sequential Processes) based language. To perform the conformity analysis we develop a transformation system to extract from a CSP process the communication sequences that may arise during its execution, and to express these sequences in terms of behavior expressions in CCS (Calculus of Communicating Systems). By performing algebraic manipulations and the equivalence proof on these expressions, we can show that the external behavior of a protocol conforms to its intended service. A version of the Alternating Bit Protocol is used to demonstrate the feasibility of the methodology.

A Calculus of Communicating Systems with Label Passing

Milner's Calculus of Communicating Systems (CCS) is extended with a mechanism for label passing - as an attempt to remedy some of the shortcomings of CCS w.r.t. dynamic change of agent interconnections. In the extended calculus, restriction is viewed formally as a binder, and the calculus allows dynamic change of scope (of label) in connection with communication. It is proved that algebraic properties of strong (and observational) equivalence for CCS are preserved by the extension. Examples illustrating the expressive power of the calculus and its methods for reasoning are given.

Algebraic specification and verification of communication protocols

Assume a communication network, consisting of switching nodes which make connections (like telephone exchanges) and terminal nodes which use these connections (like subscribers, computer terminals, etc.). The terminal nodes are at the periphery of the network, whereas switching nodes are internal to the network. In this paper it is shown how Milner's calculus of communicating systems (CCS) can be applied to specify and verify the communication behaviour of switching nodes. Starting from a specification of the communication behaviour of terminal nodes, a specification for the protocol between terminal nodes and the network of switching nodes is systematically derived. In a similar way the communication behaviour of switching nodes inside the network is derived. Verification is based on a formal abstraction mechanism which shows the equivalence of a specification and the corresponding design. The expansion theorem of CCS, together with certain laws from CCS, provide such a mechanism. With these, it is proved that the behaviour of a network of switching nodes is observation equivalent to a single switching node, which proves the consistency of the specification of the communication behaviour of the network as a whole and the combined behaviour of its constituents, the switching nodes.

IDEOSY

IDEOSY is an experiment in the use of a formal semantics as the basis for a programming system and in use of an ideographic language as the primary means of user-computer communication. The important characteristics of our system are that it uses an ideographic syntax, has a syntax-directed editor, supports the definition of various equivalence properties and the proofs of such equivalence, and has an interpreter. It currently runs on Apollo workstations and on VAXes running Berkeley UNIX@ using any of a variety of high-resolution color displays. Our formalism is based on Milner's Calculus of Communicating Systems ( CCS ) [1]. We have found CCS to be a convenient formalism for describing programs and have even used it for describing the UNIX operating system [2]. Its algebraic properties are very useful for building descriptions out of components and for proving the equivalence of descriptions. Since CCS is an operational semantics, we may directly interpret descriptions written in CCS.

IDEOSY

IDEOSY is an experiment in the use of a formal semantics as the basis for a programming system and in use of an ideographic language as the primary means of user-computer communication. The important characteristics of our system are that it uses an ideographic syntax, has a syntax-directed editor, supports the definition of various equivalence properties and the proofs of such equivalence, and has an interpreter. It currently runs on Apollo workstations and on VAXes running Berkeley UNIX@ using any of a variety of high-resolution color displays. Our formalism is based on Milner's Calculus of Communicating Systems ( CCS ) [1]. We have found CCS to be a convenient formalism for describing programs and have even used it for describing the UNIX operating system [2]. Its algebraic properties are very useful for building descriptions out of components and for proving the equivalence of descriptions. Since CCS is an operational semantics, we may directly interpret descriptions written in CCS.

Software Reliability Issues In CCS And CSP

Two of the main problems in attaining reliable software in today's computer systems are, firstly, being able to accurately capture system, program and user requirements in the form of a specification, and secondly, finding a close enough link between that specification and the implemented code to allow easy maintenance, error diagnosis and cross-checking. Robin Milner's ideas, embodied in his 'Calculus of Communicating Systems (CCS)' and Tony Hoare's 'Communicating Sequential Processes (CSP)' provide a rich means of modelling the behaviour of sequential and concurrent programs and systems in such a way that these two problems can be attacked headon.