Using Failures and Category Theory to Verify Process Communications between Design and Implementation of Concurrent Systems

Process-oriented design and implementation of concurrent systems has important benefits. However, the inherent complexity of concurrent processes’ communication imposes challenges such as verifying consistency between the process-oriented design and implementation of a concurrent system. To deal with such a challenge, we use Galois connections, Failures and Category Theory to construct a formal framework for designing, implementing, analyzing and verifying consistency of concurrent systems. For the purpose of illustrating the framework, a running concurrent system is designed by Communicating Sequential Processes, implemented by a process-oriented programming language Erasmus.

Communicating Sequential Processes (CSP) has been widely applied to modeling and analyzing concurrent systems. There have been considerable efforts on enhancing CSP by taking data and other system aspects into account. For instance, CSPM combines CSP with a functional programming language whereas CSP# integrates high-level CSP-like process operators with low-level procedure code. Little work has been done to systematically compare these CSP extensions, which may have subtle and substantial differences. In this paper, we compare CSPM and CSP# not only on their syntax, but also operational semantics as well as their supporting tools such as FDR, ProB, and PAT. We conduct extensive experiments to compare the performance of these tools in different settings. Our comparison can be used to guide users to choose the appropriate CSP extension and verification tool based on the system characteristics.

Nowadays, service oriented architecture has been given strong attention as an important approach to integrate heterogeneous systems, in which complex services are created by composing simpler services offered by various systems. The correctness of composition requires techniques to verify if the composite service behaves properly. To this end, in this paper we propose a new method for runtime monitoring of composite services which uses Communicating Sequential Processes (CSP) to specify properties formally. Then, the CSP specification of properties is translated to a Labeled Transition System (LTS). In order to verify the safety of a composite service, we traverse the generated LTS at runtime. Existing methods almost use temporal logic to specify safety properties. There are two advantages in using CSP: 1) similarity of CSP operators and service composition patterns makes CSP straightforward to be used by users. 2) there are some properties which can not be specified by temporal logic, while they can be expressed using CSP.

The specification and implementation of a class of concurrent systems is investigated in this paper using PARLOG as the implementation language, guided by specifications in CCS. This class of systems is restricted to an illustrative subset, including buffers and queues. A comparison is made between the computational models of concurrency that are expressed by each language. Illustrative programs are given which highlight the differences in operational behaviour between programs in the two languages. We investigate the ways in which equivalences in CCS programs may be used to compare PARLOG programs, and the areas of PARLOG programming which are not covered by this comparison. The advantages and disadvantages of CCS compared with PARLOG as a ‘specification-implementation’ language are discussed.

High‐level language primitives for concurrent programming exist in languages such as Ada and Modula‐2. However, each of these languages provides only a single means for specifying multitasking and synchronization, essential in the implementation of concurrent systems. The SR language provides several mechanisms for specifying multi‐tasking and synchronization, so it can be used to explore the performance of various communication techniques.This paper presents performance results for SR's multi‐tasking and synchronization mechanisms and discusses the effects of the generated code, the run‐time support and the hardware on these results. These results are compared with those for similar mechanisms in other languages, leading to some general conclusions about the performance of process communication primitives. These performance results can be used by programmers to make design choices that allow systems programs written in high‐level languages to meet real‐time performance specifications.

The lack of formalism and rigor in existing multi-agents models often leads to ambiguities and different interpretations. Those weaknesses combined with the inherent complexity of multi-agents systems generate many problems in their development process. Using formal notations to specify multi-agents systems’ behavior makes it possible to produce precise description. This also offers a better support to their verification and validation process. The Maude language, based on rewriting logic, presents a rich notation supporting formal specification and implementation of concurrent systems. In this paper, we demonstrate the feasibility and the interest of formalizing the behavior of DIMA model’s agents with the Maude language. The elaborated formal approach captures the inherent aspects of a DIMA model. The generated Maude descriptions have been validated using the platform supporting this language. Moreover, the proposed approach is generic and extensible. It offers, in particular, the advantage of being applicable to all multi-agents systems based on DIMA architecture and presents interesting extension possibilities.

The CSP (communicating sequential processes) method is useful for the development of sequence control mechanisms. From the specifications in CSP, one can investigate the nature and workings of a sequence control mechanism by the process composition calculation or algebra, prove deadlock absence by the algebra, and find the most suitable module structures of the control programs. In this paper, specifications of a silo system with concurrently working components are described in CSP, the movements are investigated by process composition calculations, and the deadlock absence of the system is proved by the calculations. Based on the discussions, specifications of a silo system with two source silos, two measuring hoppers, a mixer, two conveyors and two destination silos are described in CSP, and the system is implemented in the programming language Ada. The author's studies include the relation of CSP specifications to Ada programs. >

Communicating Sequential Processes (CSP) is a language used to describe and reason about concurrent systems. It consists of a process algebra combined with a functional language. This combination poses unique problems when attempting to design a type checker. In this paper the differences between a conventional functional language type checker and a type checker for the CSP language are discussed. This type checker was developed to identify polymorphic types, an important first step towards the goal of automating data independence [4]. The result of this work has been incorporated into the Adelaide Refinement Checker [8] (ARC) - a CSP based tool suite for model checking concurrent systems.

Communicating Sequential Processes (CSP) is a process algebra, designed for modeling and analyzing the behavior of concurrent systems. Several security protocols are modeled with CSP and verified using model-checking or theorem proving techniques successfully. Unlike other authentication protocols modeled using CSP, each of the Efficient Multi-chained Stream Signature (EMSS) protocol messages are linked to the previous messages, forming hash chains, which introduces difficulties for modeling and verification. In this paper, we model the EMSS stream authentication protocol using CSP and verify its authentication properties with model checking, by building an infinite state model of the protocol which is reduced into a finite state model.

This paper compares two models of concurrency, Milner's Calculus of Communicating Systems (CCS) and the failures model of Communicating Sequential Processes (CSP) developed by Hoare, Brookes and Roscoe. By adapting Milner's synchronisation trees to serve as notation for both CCS and CSP, we are able to define a representation mapping for CSP processes. We define an equivalence relation on synchronisation trees which corresponds precisely to the notion of failure equivalence. Milner's calculus is founded on a different notion, observation equivalence. We show how these two equivalences are related. Just as Milner's equivalence can be characterised as the smallest relation satisfying a set of axioms, we find a suitable set of axioms for the failures equivalence relation. This again makes explicit the differences between the two systems, as well as revealing that the semantic models underlying CCS and CSP are comparable.

FDR Explorer

Process algebra provides essential tools for studying concurrent systems. An important branch of process algebra is value passing CCS. However, value passing CCS lacks not only action refinement, which is an essential operation in the design of concurrent systems, but also non-interleaving semantics, which is appropriate to specify the partial order and equivalence relations. In this paper, we will define action refinement and non-interleaving semantics by valued stable event structures and valued labeled configuration structures in which special valued actions will be executed. The refinement operation and semantics are useful for the hierarchical design methodology in value passing CCS, e.g. top-down system design.

In order to achieve a ubiquitous ad-hoc environment suitable for any kind and number of compute devices, information concerning device usability must be stored and manipulated. Take, for example the home where a large number of devices - heating, cooking, lighting, entertainment, security all cooperate to provide a suitable environment for a home resident. This paper proposes a representation of home devices as OWL-S (Web service ontology) services, capable of being implemented by means of the formal algebra CSP (communication sequential process). Because of the ontological nature of OWL-S and the possibility of translating CSP equations to lightweight implementations, this proposal allows a rich semantic description of services capable of being hosted by a wide range of devices, including such ones with low computational resources. The paper describes the procedure of developing a service in OWL-S, its translation to CSP and its implementation in occam, an efficient CSP-based language

Information systems are now widely used to automate the manage and execution of judicial business processes. However, the design of a judicial information system is in nature complex, and it is difficult to ensure its correctness and trustworthiness, including the security and integrity of the data about the evidence and the conformance to laws, regulation and rules of practice, in the design and the execution of judicial workflows. In this paper, we focus on how to improve the correctness and trustworthiness of the information system through the development of models of workflows at different levels of abstraction and in different degrees of formality. The final model before the implementation is a formal model which can be formally validated and its implementation is provable correctly. Our proposed method starts with informal use case modeling and gradually transforms to formal Communicating Sequential Process (CSP) modeling. To transform use case models into a model in CSP, the specified use cases are refined into use case sequence diagrams and the relationships between use cases are represented as the case model. Our method combine the advantages of informal models and formal models. It support the modeler to communicate with domain users and experts. With the formal model in CSP, designers are capable of identifying errors during designing of the workflow, and thus able to correct them before the implementation phase. We illustrate the method with the workflow of the civil litigation in China as a case study.

Communicating Sequential Processes (CSP) is a paradigm for communication and synchronization among distributed processes. The alternative construct is a key feature of CSP that allows nondeterministic selection of one among several possible communicants. A generalized version of Hoare's original alternative construct that allows output commands to be included in guards has been proposed. Previous algorithms for this construct assume a message passing architecture and are not appropriate for multiprocessor systems that feature shared memory. This paper describes a distributed algorithm for the generalized alternative construct that exploits the capabilities of a parallel computer with shared memory. A correctness proof of the proposed algorithm is presented to show that the algorithm conforms to somesatefy andliveness criteria. Extensions to allow termination of processes and to ensure fairness in guard selection are also given.