Jan A. Bergstra

Process algebra for synchronous communication

Within the context of an algebraic theory of processes, an equational specification of process cooperation is provided. Four cases are considered: free merge or interleaving, merging with communication, merging with mutual exclusion of tight regions, and synchronous process cooperation. The rewrite system behind the communication algebra is shown to be confluent and terminating (modulo its permutative reductions). Further, some relationships are shown to hold between the four concepts of merging.

Algebra of communicating processes with abstraction

We present an axiom system ACP, for communicating processes with silent actions (‘τ-steps’). The system is an extension of ACP, Algebra of Communicating Processes, with Milners τ-laws and an explicit abstraction operator. By means of a model of finite acyclic process graphs for ACPτ, syntactic properties such as consistency and conservativity over ACP are proved. Furthermore, the Expansion Theorem for ACP is shown to carry over to ACPτ. Finally, termination of rewriting terms according to the ACPτ, axioms is probed using the method of recursive path orderings.

Decidability of bisimulation equivalence for process generating context-free languages

A context-free grammar (CFG) in Greibach Normal Form coincides, in another notation, with a system of guarded recursion equations in Basic Process Algebra. Hence to each CFG a process can be assigned as solution, which has as its set of finite traces the context-free language (CFL) determined by that CFG. While the equality problem for CFLs is unsolvable, the equality problem for the processes determined by CFGs turns out to be solvable. Here equality on processes is given by a model of process graphs modulo bisimulation equivalence. The proof is given by displaying a periodic structure of the process graphs determined by CFGs. As a corollary of the periodicity a short proof of the solvability of the equivalence problem for simple context-free languages is given.

Module algebra

An axiomatic algebraic calculus of modules is given that is based on the operators <italic>combination/union, export, renaming,</italic> and <italic>taking the visible signature</italic>. Four different models of module algebra are discussed and compared.

Conditional rewrite rules: Confluence and termination

Algebraic specifications of abstract data types can often be viewed as systems of rewrite rules. Here we consider rewrite rules with conditions, such as they arise, e.g., from algebraic specifications with positive conditional equations. The conditional term rewriting systems thus obtained which we will study, are based upon the well-known class of left-linear, nonambiguous TRSs. A large part of the theory for such TRSs can be generalized to the conditional case. Our approach is non-hierarchical: the conditions are to be evaluated in the same rewriting system. We prove confluence results and termination results for some well-known reduction strategies.

Program algebra for sequential code

Abstract The jump instruction is considered essential for an adequate theoretical understanding of imperative sequential programming. Using basic instructions and tests as a basis we outline an algebra of programs, denoted PGA, which captures the crux of sequential programming. We single out a behavior extraction operator which assigns to each program a behavior. The meaning of the expressions of PGA is explained in terms of the extracted behavior. Using PGA a small hierarchy of program notations is developed. Projection semantics is proposed as a tool for the description of program semantics.

Axiomatizing probabilistic processes: ACP with generative probabilities

This paper is concerned with finding complete axiomatizations of probabilistic processes. We examine this problem within the context of the process algebra ACP and obtain as our end-result the axiom system prACP I −- , a probabilistic version of ACP which can be used to reason algebraically about the reliability and performance of concurrent systems. Our goal was to introduce probability into ACP in as simple a fashion as possible. Optimally, ACP should be the homomorphic image of the probabilistic version in which the probabilities are forgotten.

The discrete time TOOLBUS—a software coordination architecture

Abstract The notion of “time” plays an important role when coordinating large, heterogeneous, distributed software systems. We present a generic coordination architecture that supports relative and absolute, discrete time. First, we briefly sketch the ToolBus coordination architecture. Next, we give a minor and a major example of its use: a calculator and a distributed auction. Finally, we sketch a framework for describing the operational behavior of the ToolBus , and conclude with a survey of implementation aspects and applications.

Global renaming operators in concrete process algebra

Renaming operators are introduced in concrete process algebra (concrete means that abstraction and silent moves are not considered). Examples of renaming operators are given: encapsulation, pre-abstraction, and localization. We show that renamings enhance the defining power of concrete process algebra by using the example of a queue. We give a definition of the trace set of a process, see when equality of trace sets implies equality of processes, and use trace sets to define the restriction of a process. Finally, we describe processes with actions that have a side effect on a state space and show how to use this for a translation of computer programs into process algebra.

Process algebra with iteration and nesting

We introduce iteration in process algebra by means of (the original, binary version of) Kleenes star operation: x * y is the process that chooses between x and y, and upon termination of x has this choice again. We add this operation to a whole range of process algebra axiom systems, starting from BPA (Basic Process Algebra). In the case of the most complex system under consideration, ACP τ , every regular process can be defined with handshaking (two-party communication) and auxiliary actions. Next we introduce nesting in process algebra: x#y is defined by the equation x#y=x(x#y)x+y