CCS Process Algebra Research Articles

A synchronous program algebra: a basis for reasoning about shared-memory and event-based concurrency

Abstract In this paper we introduce an abstract algebra for reasoning about concurrent programs, that includes an abstract algebra of atomic steps, with sub-algebras of program and environment steps, and an abstract synchronisation operator. We show how the abstract synchronisation operator can be instantiated as a synchronous parallel operator with interpretations in rely-guarantee concurrency for shared-memory systems, and in process algebras CCS and CSP. It is also instantiated as a weak conjunction operator, an operator that is useful for the specification of rely and guarantee conditions in rely/guarantee concurrency. The main differences between the parallel and weak conjunction instantiations of the synchronisation operator are how they combine individual atomic steps. Lemmas common to these different instantiations are proved once using the axiomatisation of the abstract synchronous operator. Using the sub-algebras of program and environment atomic steps, rely and guarantee conditions, as well as Morgan-style specification commands, are defined at a high-level of abstraction in the program algebra. Lifting these concepts from rely/guarantee concurrency to a higher level of abstraction makes them more widely applicable. We demonstrate the practicality of the algebra by showing how a core law from rely-guarantee theory, the parallel introduction law, can be abstracted and verified easily in the algebra. In addition to proving fundamental properties for reasoning about concurrent shared-variable programs, the algebra is instantiated to prove abstract process synchronisation properties familiar from the process algebras CCS and CSP. The algebra has been encoded in Isabelle/HOL to provide a basis for tool support for concurrent program verification based on the rely/guarantee technique. It facilitates simpler, more general, proofs that allow a higher level of automation than what is possible in low-level, model-specific interpretations.

A Modelling Method for Cross-Organizational Business Process Collaboration Based on Petri Net and Process Algebra

In order to resolve the modelling problem of business processes collaboration, especially, the asynchronous communication mechanism problem and the verification problem, combining the respective strengths of Petri Nets and the classical process algebra CCS, a modeling method is proposed in this paper. First of all, modelling the internal view of cross-organization based on Petri Nets, extracting the communication interface and mapping to internal transition to get the public view; Secondly, researching on the asynchronous communication mechanism and modelling the communication process by CCS to get communication behavior view, thus making the verification of collaboration converts to the CCS derivation; Finally, an algorithm is proposed to generate automatically the behaviors possessed by every transition in model view. The modelling method proposed is not only to analyze and verify the structure properties in collaboration, but also to analyze and verify the behavior properties, which brings a huge convenience for further analysis and verification in cross-organizational business process collaboration.

Formalizing BPEL-TC Through Π-Calculus

WS-BPEL is way to define business processes that interact with external entities through web service operations using WSDL. We have proposed BPEL -TC, an extension to existing WS -BPEL which uses temporally customized Web Services (W SDL-TC) as a model for process decomposition and assembly. WSDL-TC handles both backward compatible and incompatible changes and also maintains various versions of the artifacts that results due to changes over time and customizations desired by the users . In this paper, we are using pi-calculus to formalize Business Process Execution Language - Temporal Customization (BPEL-TC) process. π -calculus is a model of computation for concurrent systems along with changing connectivity of interactive systems. Pi -calculus is an extension of the process algebra CCS, with added mobility to CCS while preserving its algebraic properties.

Foundational aspects of multiscale modeling of biological systems with process algebras

We propose a variant of the CCS process algebra with new features aiming at allowing multiscale modeling of biological systems. In the usual semantics of process algebras for modeling biological systems actions are instantaneous. When different scale levels of biological systems are considered in a single model, one should take into account that actions at a level may take much more time than actions at a lower level. Moreover, it might happen that while a component is involved in one long lasting high level action, it is involved also in several faster lower level actions. Hence, we propose a process algebra with operations and with a semantics aimed at dealing with these aspects of multiscale modeling. We give both a reduction semantics and an SOS semantics for our new algebra with a result of operational correspondence between the two. Moreover, we study behavioral equivalences for such an algebra and give some examples.

Aspects of multiscale modelling in a process algebra for biological systems

We propose a variant of the CCS process algebra with new features aiming at allowing multiscale modelling of biological systems. In the usual semantics of process algebras for modelling biological systems actions are instantaneous. When different scale levels of biological systems are considered in a single model, one should take into account that actions at a level may take much more time than actions at a lower level. Moreover, it might happen that while a component is involved in one long lasting high level action, it is involved also in several faster lower level actions. Hence, we propose a process algebra with operations and with a semantics aimed at dealing with these aspects of multiscale modelling. We study behavioural equivalences for such an algebra and give some examples.

Formal Definition of XCCS Modelling Language

The paper presents a formal definition of XCCS - a graphical extension of CCS process calculus. The aim of this extension is to supply graphical means for creating models and thus to eliminate problems typical for modelling in textual manner inherent to CCS process algebra. XCCS diagrams consist of two layers, a graphical one that represents the structure of a modelled system and algebraic one that describes behaviour of individual agents. The graphical layer takes the form of a directed graph, while the algebraic one is a set of sequences of algebraic equations similar to those in the CCS calculus. The formal definition presented in the paper deals with both parts of such models. At the end of the paper we define the Synchronization Relation and present the Basic Conversion Algorithm that converts XCCS diagrams into CCS scripts.

A ground-complete axiomatisation of finite-state processes in a generic process algebra

The three classical process algebras CCS, CSP and ACP present several differences in their respective technical machinery. This is due, not only to the difference in their operators, but also to the terminology and ‘way of thinking’ of the community that has been (and still is) working with them. In this paper we will first discuss these differences and try to clarify the different usage of terminology and concepts. Then, as a result of this discussion, we define a generic process algebra where each of the basic mechanisms of the three process algebras (including minimal fixpoint based unguarded recursion) is expressed by an operator, and which can be used as an underlying common language. We show an example of the advantages of adopting such a language instead of one of the three more specialised algebras: producing a complete axiomatisation for Milner's observational congruence in the presence of (unguarded) recursion and static operators. More precisely, we provide a syntactical characterisation (allowing as many terms as possible) for the equations involved in recursion operators, which guarantees that transition systems generated by the operational semantics are finite state. Conversely, we show that every process admits a specification in terms of such a restricted form of recursion. We then present an axiomatisation that is ground complete over such a restricted signature. Notably, we also show that the two standard axioms of Milner for weakly unguarded recursion can be expressed using a single axiom only.

Priority and abstraction in process algebra

More than 15 years ago, Cleaveland and Hennessy proposed an extension of the process algebra CCS in which some actions may take priority over others. The theory was equipped with a behavioral congruence based on strong bisimulation. This article gives a full account of the challenges in, and the solutions employed for, defining a semantic theory of observation congruence for this process algebra. A full-abstraction result is presented whose proof relies on a novel approach based on successive approximations for identifying the largest congruence contained in an intuitive but naïve equivalence. Prioritized observation congruence is also characterized equationally for the class of finite processes, while its utility for system verification is demonstrated by an illustrative example.

A Generic Process Algebra

The three classical process algebra CCS, CSP and ACP present several differences in their respective technical machinery. This is due, not only to the difference in their operators, but also to the terminology and “way of thinking” of the community which has been (and still is) working with them. In this paper we will first discuss such differences and try to clarify the different usage of terminology and concepts. Then, as a result of this discussion, we define a generic process algebra where each basic mechanism of the three process algebras is expressed by an operator and which can be used as an underlying common language. We show an example of the advantages of adopting such a language instead of one of the three more specialized algebras: producing a complete axiomatization of finite-state behaviours.

Algebraic–coalgebraic specification in C oC asl

We introduce C oC asl as a light-weight but expressive coalgebraic extension of the algebraic specification language C asl. C oC asl allows the nested combination of algebraic datatypes and coalgebraic process types. Moreover, it provides syntactic sugar for an observer-indexed modal logic that allows e.g. expressing fairness properties. This logic includes a generic definition of modal operators for observers with structured equational result types. We prove existence of final models for specifications in a format that allows the use of equationally specified initial datatypes as observations, as well as modal axioms. The use of C oC asl is illustrated by specifications of the process algebras CSP and CCS.

Logical Specification and Analysis of Fault Tolerant Systems Through Partial Model Checking

This paper presents a framework for a logical characterization of fault tolerance and its formal analysis based on partial model checking techniques. The framework requires a fault tolerant system to be modeled using a formal calculus, here the CCS process algebra. To this aim we propose a uniform modeling scheme in which to specify a formal model of the system, its failing behaviour and possibly its fault-recovering procedures. Once a formal model is provided into our scheme, fault tolerance - with respect to a given property - can be formalized as an equational μ-calculus formula. This formula expresses, in a logic formalism, all the fault scenarios satisfying that fault tolerance property. Such a characterization understands the analysis of fault tolerance as a form of analysis of open systems and, thank to partial model checking strategies, it can be made independent from any particular fault assumption. Moreover this logical characterization makes possible the fault-tolerance verification problem be expressed as a general μ-calculus validation problem, for solving which many theorem proof techniques and tools are available. We present several analysis methods showing the flexibility of our approach.

Applying Generalized Non Deducibility on Compositions (GNDC) Approach in Dependability

This paper presents a framework where dependable systems can be uniformly modeled and dependable properties analyzed within the Generalized Non Deducibility on Compositions (GNDC), a scheme that has been profitably used in definition and analysis of security properties. Precisely, our framework requires a systems to be modelled using a formal calculus, here the CCS process algebra, where both the failing behaviour of the system and the related fault-recovering procedures are also explicitly described. An environment able to inject any fault in the system is then defined as a separated component. The parallel composition between the system and the environment represents our scenario of analysis, where some fault tolerance property (e.g., fail stop, safe and silent) are studied as instances of GNDC properties. By using different instances of GNDC we are able to argue about the availability of effective methodologies of analysis, and on the possibility of applying compositional techniques.

Bisimulation on speed: worst-case efficiency

This paper introduces a novel (bi)simulation-based faster-than preorder which relates asynchronous processes, where the relative speeds of system components are indeterminate, with respect to their worst-case timing behavior. The study is conducted for a conservative extension of the process algebra CCS, called TACS, which permits the specification of upper time bounds on action occurrences. TACS complements work in plain process algebras which compares asynchronous processes with respect to their functional reactive behavior only, and in timed process algebras which focus on analyzing synchronous processes. The most unusual contribution is in showing that the proposed faster-than preorder coincides with several other preorders, two of which consider the absolute times at which actions occur in system runs. The paper also develops the semantic theory of TACS by studying congruence properties, equational laws, and abstractions from internal actions. Two examples, one dealing with mail delivery and one relating two implementations of a simple storage system, testify to the practical utility of the new theory.

Object-oriented modelling and specification using SHE

Industry is facing a crisis in the design of complex hardware/software systems. Due to the increasing complexity, the gap between the generation of a product idea and the realisation of a working system is expanding rapidly. To manage complexity and to shorten design cycles, industry is forced to look at system-level languages towards specification and design. The (formal) system-level modelling language called POOSL is very expressive and is able to model dynamic hard real-time behaviour and to (visually) capture static (architecture and topology) structure in an object-oriented fashion. The language integrates a process part, based on the process algebra CCS, with a data part, based on the concepts of traditional object-oriented programming languages and it is equipped with a formal semantics. Currently, a number of automated software tools (model editing, simulator and compiler tools) are available in an environment called SHESim. These tools allow visual entry of structure and topology of the system, whereas dynamic behaviour of individual processes is expressed in an expressive imperative language. The formal semantics of POOSL provides a solid basis for the application of verification and performance analysis techniques and establishing a rigorous connection to existing analysis tools.

On the bisimulation proof method

The most popular method for establishing bisimilarities among processes is to exhibit bisimulation relations. By definition, [Rscr ] is a bisimulation relation if [Rscr ] progresses to [Rscr ] itself, i.e., pairs of processes in [Rscr ] can match each other's actions and their derivatives are again in [Rscr ].We study generalisations of the method aimed at reducing the size of the relations to be exhibited and hence relieving the proof work needed to establish bisimilarity results. We allow a relation [Rscr ] to progress to a different relation [Fscr ] ([Rscr ]), where [Fscr ] is a function on relations. Functions that can be safely used in this way (i.e., such that if [Rscr ] progresses to [Fscr ] ([Rscr ]), then [Rscr ] only includes pairs of bisimilar processes) are sound. We give a simple condition that ensures soundness. We show that the class of sound functions contains non-trivial functions and we study the closure properties of the class with respect to various important function constructors, like composition, union and iteration. These properties allow us to construct sophisticated sound functions – and hence sophisticated proof techniques for bisimilarity – from simpler ones.The usefulness of our proof techniques is supported by various non-trivial examples drawn from the process algebras CCS and π-calculus. They include the proof of the unique solution of equations and the proof of a few properties of the replication operator. Among these, there is a novel result that justifies the adoption of a simple form of prefix-guarded replication as the only form of replication in the π-calculus.

The Evolution of Concurrent Programs

Process algebra are formal languages used for the rigorous specification and analysis of concurrent systems. By using a process algebra as the target language of a genetic programming system, the derivation of concurrent programs satisfying given problem specifications is possible. A genetic programming system based on Koza‘s model has been implemented. The target language used is Milner‘s CCS process algebra, and is chosen for its conciseness and simplicity. The genetic programming environment needs a few adaptations to the computational characteristics of concurrent programs. In particular, means for efficiently controlling the exponentially large computation spaces that are common with process algebra must be addressed. Experimental runs of the system successfully evolved a number of non–iterative CCS systems, hence proving the potential of evolutionary approaches to concurrent system development.

Information Control Nets as Processes: Qualitative Analysis

In this paper, we address the formal venfication in workflow systems More precisely, we consider the automatic verification of one of the most prominent workflow models, namely the Information Control Nets (ICNs) model We present a powerful method for the qualitative analy sis of ICNs The analysis proposed rests on an observed analogy between ICNs and usual process algebra Actually, ICNs are translated into CCS process algebra agents The properties to be verified are expressed in a temporal logic, the propositional modal ν-calculus The verification is done thanks to model-checking algorithms

設計生産コミュニケーションモデルの記述表現及び応用に関する研究 (第3報)

In previous report, an integrated model about concurrent process that is examined within design and manufacturing activity are proposed. Subject of this report is a development of a computer aided application system that controls cooperative activities. A methodology about formal represented activity is inspected. Based on a process algebra CCS, a fundamental function of process management system is proposed. As an example, a concurrent process simulator is developed utilizing an object oriented language.

Deadlock-free completely connected networks: towards a π-calculus approach

A very general communication protocol is presented, which enables communication, without danger of deadlock, in a class of networks of asynchronous processes that communicate synchronously, subject to certain fairness constraints on the individual node processes. Deadlock freedom is first proved using the process algebra CCS, but the proof uses the dynamic scoping of channels which is more naturally described by the Π-calculus.

A calculus of mobile processes, I

We present the π-calculus, a calculus of communicating systems in which one can naturally express processes which have changing structure. Not only may the component agents of a system be arbitrarily linked, but a communication between neighbours may carry information which changes that linkage. The calculus is an extension of the process algebra CCS, following work by Engberg and Nielsen, who added mobility to CCS while preserving its algebraic properties. The π-calculus gains simplicity by removing all distinction between variables and constants; communication links are identified by names, and computation is represented purely as the communication of names across links. After an illustrated description of how the π-calculus generalises conventional process algebras in treating mobility, several examples exploiting mobility are given in some detail. The important examples are the encoding into the π-calculus of higher-order functions (the λ-calculus and combinatory algebra), the transmission of processes as values, and the representation of data structures as processes. The paper continues by presenting the algebraic theory of strong bisimilarity and strong equivalence, including a new notion of equivalence indexed by distinctions—i.e., assumptions of inequality among names. These theories are based upon a semantics in terms of a labeled transition system and a notion of strong bisimulation, both of which are expounded in detail in a companion paper. We also report briefly on work-in-progress based upon the corresponding notion of weak bisimulation, in which internal actions cannot be observed.