Algebra Of Communicating Processes Research Articles

Dormancy-aware timed branching bisimilarity with an application to communication protocol analysis

A variant of the standard notion of branching bisimilarity for processes with discrete relative timing is proposed which is coarser than the standard notion. Using a version of ACP (Algebra of Communicating Processes) with abstraction for processes with discrete relative timing, it is shown that the proposed variant allows of both the functional correctness and the performance properties of the PAR (Positive Acknowledgement with Retransmission) protocol to be analyzed. In the version of ACP concerned, the difference between the standard notion of branching bisimilarity and its proposed variant is characterized by a single axiom schema.

Imperative Process Algebra and Models of Parallel Computation

Studies of issues related to computability and computational complexity involve the use of a model of computation. Central in such a model are computational processes. Processes of this kind can be described using an imperative process algebra based on ACP (Algebra of Communicating Processes). In this paper, it is investigated whether the imperative process algebra concerned can play a role in the field of models of computation. It is demonstrated that the process algebra is suitable to describe in a mathematically precise way models of computation corresponding to existing models based on sequential, asynchronous parallel, and synchronous parallel random access machines as well as time and work complexity measures for those models.

Imperative Process Algebra with Abstraction

This paper introduces an imperative process algebra based on ACP (Algebra of Communicating Processes). Like other imperative process algebras, this process algebra deals with processes of the kind that arises from the execution of imperative programs. It distinguishes itself from already existing imperative process algebras among other things by supporting abstraction from actions that are considered not to be visible. The support of abstraction of this kind opens interesting application possibilities of the process algebra. This paper goes briefly into the possibility of information-flow security analysis of the kind that is concerned with the leakage of confidential data. For the presented axiomatization, soundness and semi-completeness results with respect to a notion of branching bisimulation equivalence are established.

Modeling an Edge Computing Arithmetic Framework for IoT Environments.

IoT environments are forecasted to grow exponentially in the coming years thanks to the recent advances in both edge computing and artificial intelligence. In this paper, a model of remote computing scheme is presented, where three layers of computing nodes are put in place in order to optimize the computing and forwarding tasks. In this sense, a generic layout has been designed so as to easily achieve communications among the diverse layers by means of simple arithmetic operations, which may result in saving resources in all nodes involved. Traffic forwarding is undertaken by means of forwarding tables within network devices, which need to be searched upon in order to find the proper destination, and that process may be resource-consuming as the number of entries in such tables grow. However, the arithmetic framework proposed may speed up the traffic forwarding decisions as relaying on integer divisions and modular arithmetic, which may result more straightforward. Furthermore, two diverse approaches have been proposed to formally describe such a design by means of coding with Spin/Promela, or otherwise, by using an algebraic approach with Algebra of Communicating Processes (ACP), resulting in a explosion state for the former and a specified and verified model in the latter.

Using Hoare Logic in a Process Algebra Setting

This paper concerns the relation between process algebra and Hoare logic. We investigate the question whether and how a Hoare logic can be used for reasoning about how data change in the course of a process when reasoning equationally about that process. We introduce an extension of ACP (Algebra of Communicating Processes) with features that are relevant to processes in which data are involved, present a Hoare logic for the processes considered in this process algebra, and discuss the use of this Hoare logic as a complement to pure equational reasoning with the equational axioms of the process algebra.

An Axiomatization for Quantum Processes to Unifying Quantum and Classical Computing

We establish an axiomatization for quantum processes, which is a quantum generalization of process algebra ACP (Algebra of Communicating Processes). We use the framework of a quantum process configuration 〈p, ϱ〉, but we treat it as two relative independent part: the structural part p and the quantum part ϱ, because the establishment of a sound and complete theory is dependent on the structural properties of the structural part p. We let the quantum part ϱ be the outcomes of execution of p to examine and observe the function of the basic theory of quantum mechanics. We establish not only a strong bisimilarity for quantum processes, but also a weak bisimilarity to model the silent step and abstract internal computations in quantum processes. The relationship between quantum bisimilarity and classical bisimilarity is established, which makes an axiomatization of quantum processes possible. An axiomatization for quantum processes called qACP is designed, which involves not only quantum information, but also classical information and unifies quantum computing and classical computing. qACP can be used easily and widely for verification of most quantum communication protocols.

Study on OSPF Algebraic Formal Modelling Using ACP

OSPF is a commonly used link state routing protocol in order to interconnect network devices inside an Autonomous System. This paper focuses on achieving a detailed modelling for OSPF by performing manual algebraic derivations according to Algebra of Communicating Processes (ACP) axioms. The aim of this detailed model is to get a realistic approach of OSPF dynamics by applying the timers involved and by describing the full Link State Advertisement (LSA) exchange process.DOI: http://dx.doi.org/10.5755/j01.eie.24.4.21484

Process Algebra with Strategic Interleaving

In process algebras such as ACP (Algebra of Communicating Processes), parallel processes are considered to be interleaved in an arbitrary way. In the case of multi-threading as found in contemporary programming languages, parallel processes are actually interleaved according to some interleaving strategy. An interleaving strategy is what is called a process-scheduling policy in the field of operating systems. In many systems, for instance hardware/software systems, we have to do with both parallel processes that may best be considered to be interleaved in an arbitrary way and parallel processes that may best be considered to be interleaved according to some interleaving strategy. Therefore, we extend ACP in this paper with the latter form of interleaving. The established properties of the extension concerned include an elimination property, a conservative extension property, and a unique expansion property.

Quantum Process Algebra with Priorities

One of the most fascinating characteristics is the modularity of ACP (Algebra of Communicating Processes), that is, ACP can be extended easily. qACP also inherents the modularity characteristics of ACP. By introducing new operators or new constants, qACP can have more properties. In this paper, we extend the quantum process algebra qACP with priorities support in an elegant way. And we obtain the soundness and completeness of the extension.

Formal Specification of Spanning Tree Protocol Using ACP

Spanning-Tree Protocol (STP) has nowadays been implemented by most manufacturers in order to avoid loops in bridged networks. IEEE 802.1D STP is the original standard and it is run as a distributed algorithm by every bridge. In this paper we propose a formal specification of that STP by using a Process Algebra named Algebra of Communicating Processes (ACP), following a manual approach. Furthermore, STP protocol verification has been performed, both in a formal and in an informal way.DOI: http://dx.doi.org/10.5755/j01.eie.23.2.18005

Towards an Algebraic Semantics of Software Evolution Process Models

随着大量的软件演化过程模型被软件演化过程元模型建模产生,如何验证过程模型的正确性,是摆在人们面前的一个重要任务.针对软件演化过程元模型,引入进程代数ACP(algebra of communicating processes)对其扩展,提出软件演化过程元模型代数,使用进程项指定软件演化过程模型的代数语义,在进程代数的统一框架下,基于等式推理验证软件演化过程模型的行为,使行为验证方式从模型推导变为代数推导.这种方法充分结合了Petri 网和ACP 的长处,可以有效地支持软件演化过程的形式验证.;As a number of software evolution process models increased, as modeled by EPMM (software evolution process meta model), verifying the correctness of these models becomes the important. This paper extends EPMM with ACP (algebra of communicating processes) and proposes EPMM-A (software evolution meta modelalgebra). In order to discuss behavior verification in the unified framework of EPMM-A, a process term is used to define an algebraic semantics of a software evolution process model. Based on equational reasoning of EPMM-A, behavior verification of a software evolution process model emphasizes algebraic reasoning as opposed to modelbased reasoning. This method combines the advantages of both Petri nets and ACP, which can effectively support software evolution process formal verification.

PSF - A Retrospective

Modern day computer architectures offer ever-increasing support for parallel processing, still it turns out to be quite difficult for programmers and therefore programs to tap into these parallel resources. To benefit from real general-purpose parallel computing we claim that it is likely that a paradigm shift is needed in the way we think about programming. This change of thought in turn will need to be reflected in future programming languages as well. We think that the field of process algebra provides thorough insight in how to reason about the construction of software for concurrent systems and will be one of the enabling technologies supporting this transition. The wish to connect process algebra, a mathematical theory, to the world of computer-readable and executable specifications led to the development of PSF (Process Specification Formalism). PSF is an implementation of the process algebra ACP (Algebra of Communicating Processes) integrating ASF (Algebraic Specification Formalism) to specify algebraic data types. One of the first publications on PSF appeared in Fundamenta Informaticae in 1990. Here we stated as the first sentence of the abstract: Traditional methods for programming sequential machines are inadequate for specifying parallel systems. Unfortunately, though some advancements have been made since 1990, we can still uphold this statement 20 years later. This current report documents the developments that lead to the construction of PSF and the 1990 publication and moreover it also documents how PSF and its tools have evolved since 1990 taking the conclusion and the outlook for future work from the original article as a reference point. Using the knowledge gained both in constructing tools for PSF and in using PSF to specify concurrent systems, we will judge, discuss and criticise the design decisions taken and show paths for future developments.

A Process Specification Formalism1

Traditional methods for programming sequential machines are inadequate for specifying parallel systems. Because debugging of parallel programs is hard, due to e.g. non-deterministic execution, verification of program correctness becomes an even more important issue. The Algebra of Communicating Processes (ACP) is a formal theory which emphasizes verification and can be applied to a large domain of problems ranging from electronic circuits to CAM architectures. The manual verification of specifications of small size has already been achieved, but this cannot easily be extended to the verification of larger industrially relevant systems. To deal with this problem we need computer tools to help with the specification, simulation, verification and implementation. The first requirement for building such a set of tools is a specification language. In this paper we introduce PSFd (Process Specification Formalism – draft) which can be used to formally express processes in ACP. In order to meet the modern requirements of software engineering, like reusability of software, PSFd supports the modular construction of specifications and parameterization of modules. To be able to deal with the notion of data, ASF (Algebraic Specification Formalism) is embedded in our formalism. As semantics for PSFd a combination of initial algebra semantics and operational semantics for concurrent processes is used. A comparison with programming languages and other formal description techniques for the specification of concurrent systems is included.

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.