INTRODUCTION

Extension of process algebra

In this paper we extend process algebra with a new operator that will be helpful to describe process creation. From a methodological point of view the extension of process algebra with new operators is just the right way to incorporate new features. Only in a very rich calculus with many operators one may hope to be able to perform significant algebraic calculations on systems. In many cases a new feature requires new (additional) syntax and more equations, only in very rare circumstances the addition of equations alone suffices to obtain an appropriate model of some new system aspect. The core system ACP, see, describes asynchronous cooperation with synchronous communication.

On top of ACP various features can be added, for instance: asynchronous communication, cooperation in the presence of shared data, broadcasting, interrupts. This note adds process creation to the features that are compatible with process algebra.

For historical remarks and relations with previous literature we refer to.

Process creation

We start on basis of the axiom system ACP which is supposed to be known to the reader. We assume the presence of a finite set of data D and introduce for each d∈D an action cr(d). The action cr(d) stands for: create a process on basis of initial information d. Let cr(D) denote the set {cr(d)|d∈D}.

INTRODUCTION

Many authors have studied the concurrency aspects of sorting, and indeed the n-time bubblesort algorithm (using n processors) is rather thoroughly analyzed already (e.g. see: Hennessy, Kossen and Weijland). However, bubblesort is not the most efficient sorting algorithm in sequential programming, since it is n2-time and for instance heapsort and mergesort are n log n-time sorting algorithms. So, the natural question arises whether it would be possible to design an algorithm using even less than n-time.

In this paper we discuss a concurrent algorithm, capable of sorting n numbers in O(log n) time. This algorithm is based on the idea of square comparison: putting all numbers to be sorted in a square matrix, all comparisons can be made in O(1) time, using n2 processors (one for each cell of the matrix). Then, the algorithm only needs to evaluate the result of this operation.

The algorithm presented here, which is called ranksort, is not the only concurrent time-efficient sorting algorithm. Several sub n-time algorithms have been developed by others (see: Thompson).

One of the basic problems in protocol verification is the following: data are to be transmitted from A to B via some unreliable medium M. A protocol has been proposed for doing so correctly and perhaps efficiently. A rigorous mathematical proof of the correctness claim is desired.

Now protocol verification aims at providing the techniques for giving such a proof. Several formalisms have been advocated, but as yet none has been widely accepted.

The framework we adhere to is process algebra. The first protocol correctness proof by means of process algebra is in Bergstra and Klop, where a simple version of the Alternating Bit Protocol is verified.

We have tried our hands at a more complicated version, called the Concurrent Alternating Bit Protocol (CABP) and found that the number of possible state transitions was prohibitively large. In this article we propose a divide-and-conquer strategy. We group processes into modules, describe and verify their behaviour and finally combine them. For different approaches, see.

In Section 1 we deal with the Concurrent Alternating Bit Protocol (CABP). In Section 2 we present the modular approach. Modules are introduced in Section 3, whereas the verification of the CABP is given in Section 4.

It has been observed that formal verification methods for mathematical proofs, computer programs, communication protocols and the like are usually illustrated by ‘toy’ examples and that such proofs tend to be discouragingly long. In order to demonstrate that it is feasible to verify a ‘real-life’ communication protocol by means of process algebra, we picked one from the literature.

In his Ph.D. thesis, Mullender investigates issues he considered while developing the Amoeba distributed operating system. In Section 3.2.4 of a transaction protocol is described to which we will refer as the Amoeba protocol. In the preceding sections of the design goals are described that this protocol is supposed to satisfy. He does not give a formal verification that his protocol meets this criteria. In fact, it turns out that one of them is not met. Note that this only applies to the simplified version of the protocol that appears in, the actual implementation uses a much more complicated version in which this mistake is not found.

Section 1 of this article gives the minimum background information necessary for understanding the rest of the article.

In Section 2 the design goals are formulated in English and in terms of process algebra.

INTRODUCTION

In this article we will present simple descriptions of so-called systolic systems. Such systems can be looked at as a large integration of identical cells in such a way that the behaviour of the total system strongly resembles the behaviour of the individual cells. In fact the total system behaves like one of its individual cells ‘on a larger scale’.

For example one can think of a machine sorting arrays of numbers with a certain maximum length. Suppose we need a machine handling arrays that are much longer. A typical ‘systolic approach’ to this problem would be to try to interconnect the smaller machines such that the total circuit sorts arrays of a greater length. As a matter of fact this specific example will be worked out in the following sections. In designing VLSI-circuits (short for very large scale integrated circuits) it is very useful, if not necessary, to construct the specific circuit by placing simple components in regular configurations. Otherwise one looses all intuition about the behaviour of the circuit that is eventually constructed.

INTRODUCTION

We are interested in the verification of distributed systems by means of algebraic manipulations. In process algebra, verifications often consist of a proof that the behaviour of an implementation IMPL equals the behaviour of a specification SPEC, after abstraction from internal activity: τI(IMPL) = SPEC.

The simplest strategy to prove such a statement is to derive first the transition system (process graph) for the process IMPL with the expansion theorem, apply an abstraction operator to this transition system, and then simplify the resulting system to the system for SPEC using the laws of (for instance) bisimulation semantics. This ‘global’ strategy however, is often not very practical due to combinatorial state explosion: the number of states of IMPL can be of the same order as the product of the number of states of its components. Another serious problem with this strategy is that it provides almost no ‘insight’ in the structure of the system being verified.

This article serves as an introduction to the basis of the theory, that will be used in the rest of this book. To be more precise, we will discuss the axiomatic theory ACPT (Algebra of Communicating Processes with abstraction), with additional features added, which is suitable for both specification and verification of communicating processes. As such, it can be used as background material for the other articles in the book, where all basic axioms are gathered. But we address ourselves not exclusively to readers with previous exposure to algebraic approaches to concurrency (or, as we will call it, process algebra). Also newcomers to this type of theory could find enough here, to get started. For a more thorough treatment of the theory, we refer to, which will be revised, translated and published in this CWI Monograph series. There, most proofs can also be found; we refer also to the original papers where the theory was developed. This article is an abbreviated version of reference.

Our presentation will concentrate on process algebra as it has been developed since 1982 at the Centre for Mathematics and Computer Science, Amsterdam (see), since 1985 in cooperation with the University of Amsterdam and the University of Utrecht. This means that we make no attempt to give a survey of related approaches though there will be references to some of the main ones.

This paper is not intended to give a survey of the whole area of activities in process algebra.

We acknowledge the help of Jos Baeten in the preparation of this paper.

In this book, we give applications of the theory of process algebra, known by the acronym ACP (Algebra of Communicating Processes), as it has been developed since 1982 at the Centre for Mathematics and Computer Science, Amsterdam (see), since 1985 in cooperation with the University of Amsterdam and the University of Utrecht. An important stimulus for this book was given by the ESPRIT contract no. 432, An Integrated Formal Approach to Industrial Software Development (Meteor). The theory itself is treated in, which will be revised, translated and published in this series. The theory is briefly reviewed in the first article in this book, An introduction to process algebra, by J.A. Bergstra and J.W. Klop.

This book gives applications of the theory of process algebra. By the term process algebra we mean the study of concurrent or communicating processes in an algebraic framework. We endeavour to treat communicating processes in an axiomatic way, just as for instance the study of mathematical objects as groups or fields starts with an axiomatization of the intended objects. The axiomatic method which will concern us, is algebraic in the sense that we consider structures which are models of some set of (mostly) equational axioms; these structures are equipped with several operators. Thus we use the term ‘algebra’ in the sense of model theory.

Introduction

In this chapter we present and discuss examples of the syntactic and translation rules of the QE-III fragment whose definition was given in Chapter 6. As we pointed out in that presentation, the PTQ fragment stands essentially intact as the core of QE-III. There are, however, certain changes to this core. One major change is our use of the logic ILs as the intermediate translation language; this logic is a modification to Montague's IL, and makes explicit the hidden abstraction over indices that is a part of the evaluation process in Montague's PTQ analysis. In defining ILs we have already shown that we evaluate any expression α with respect to a state s by forming the expression: [λiα](s).

Moreover, in presenting the pragmatics of QE-III, we showed how the pragmatic interpretation of any sentential expression was essentially given by the denotation of the expression formed by λ-abstracting over all of the free individual variables and also evaluating with respect to now.

In addition to this change in the underlying logic and method of evaluation, the following additional modifications have been made to the rules of the PTQ fragment:

1. Rule S4 has been modified to perform the single function of combining a Term with an IV to form a sort of proto-sentence. It no longer performs the verb inflection for third person singular present tense. The entire treatment of tense and time adverbials is now performed more systematically by rules S101 through S106. (The tensing functions of S17 have therefore been totally eliminated.)

2. […]

Introduction

In the previous chapters of this book we have presented the historical relational database model HRDM as a means of formally incorporating a temporal semantics into the relational database model. We now turn our attention to the problem of providing a semantics for querying an hrdb using natural language, specifically English. Our method will be to define the semantics of queries expressed in English in terms of the semantics of the HRDM model already presented by defining a small query fragment as a Montague Grammar (as in [Mon73], henceforth PTQ.) The correlation between the database semantics we have already defined and this query language will be made explicit by providing the semantics of the query fragment via an indirect translation into the intensional logic ILs. The translations will provide for a completely extensional treatment of verbs, (i.e., there will be no verbs like “seek” which can be nonextensional in object position in the PTQ treatment). This treatment is dictated by the application of the Montague Semantics approach to a database environment, in which existence is tantamount to existence in the database. Through these translations, then, the model for ILs that we defined as induced by the database will also serve as the model for a formal definition of the semantics of the English queries. In addition to providing a semantic interpretation, which in model-theoretic terms is called its denotation, we also provide for each expression a pragmatic interpretation in a manner to be explained.

It is difficult to imagine a successful semantic theory that does not include time as an integral component. Yet all of today's major data models – models which purport to provide a general theory on how to represent information for convenient and rapid storage and retrieval on digital computers – completely ignore this essential aspect of semantics. In this work we examine the connection between two areas of semantics, namely the semantics of databases and the semantics of natural language, and link them together via a common view of the semantics of time. In the first part we argue that an essential ingredient for the success of efforts to incorporate more real world semantics into database models is a coherent theory of the semantics of time. We describe such a database theory, and then proceed to present a formally defined English database query language whose semantic theory makes explicit reference to the notion of denotation with respect to a moment of time.

The idea that time might be an important consideration in providing an enriched database semantics is not new to this work, but it is nonetheless a relatively recent concern of database research. [Bub77], [Ser80], [Klo81], [And81], [AM82], [CW83], [Sno84], [GV85], [CC87], [GY88], and [CC88a] are among the many works that have lately investigated ways in which time might be added to a database model.

Overview of the Approach

In a series of papers culminating in [Mon 73], henceforth PTQ, Richard Montague embarked upon a program of providing a formal syntax coupled with a model-theoretic semantics for increasingly sophisticated fragments of English. The semantics for the PTQ fragment is given indirectly, as follows. The set of sentences of the fragment is defined inductively from a set of Basic Expressions (words). Direct translations into an Intensional Logic (IL) are provided for each of the Basic Terms. Each of the formation rules in the inductive definition is coupled with a translation rule which specifies the translation into IL of the output of the rule as a function of the translations of the input(s) to the rule. Thus the interpretation of any English sentence in the fragment is given by means of the model-theoretic interpretation given by the semantics of the logic to its corresponding representation in IL.

Subsequent to the presentation of the PTQ fragment, a number of researchers (e.g. [Tho72], [Ben74], [Par75], [Tho76], [Kar77], [Ben79], [Dow79], [Hir83], and [Hin88]) have explored various extensions to the PTQ fragment. These extensions have been motivated by the desire to provide a formal syntax and semantics to a larger set of English syntactic constructs; occasionally they have necessitated changes or extensions to the underlying logic IL. [DWP81] provides an excellent introduction to the area known as Montague Semantics, while [vB88] surveys the entire field of intensional logic.

Introduction

In this Chapter we give a formal specification of a simple English Query Fragment, QE-III, for the historical department store database example discussed in earlier chapters. This fragment incorporates all of the features that we discussed in the previous chapter. Towards the end of the chapter we present a Fragment Schema for a QE-III type query language that could be adapted to other domains by defining the relevant vocabulary in the categories of the fragment. The schema and the guidelines for defining such a fragment are intended both to help a database administrator in the process of designing a language for a new domain, and also to show some of the general principles relating aspects of the HRDM model to the query language semantics.

We present the language definition in three parts. First we describe the syntactic component, which consists of defining the categories of the language and the basic expressions of these categories, followed by the rules of formation. Together these constitute an inductive definition of the set of meaningful expressions of QE-III. The semantics of the language is presented next, following Montague's general procedure in PTQ. This consists of giving, for each syntactic rule, a corresponding rule of translation into the logic ILs, for which a direct semantic interpretation has already been specified (in Chapter 2.) Finally, we provide a pragmatics for the language when used in the assumed context of a question-answering system.

Motivation for Historical Databases

The relational database model proposed by Codd [Cod70] views a database as a collection of “time-varying relations of assorted degrees” [Cha78]. However the model itself incorporates neither the concept of time nor any theory of temporal semantics. Our research suggests that the concept of time can be of interest in real-world databases, and presents a technique for incorporating a semantics of time into a database model. The relational model is used as the formal database framework within which the work is cast, but it is not an essential ingredient in the work discussed. Indeed in [CC88a] we address the issue of modelling the temporal dimension of data within the context of an object-oriented database model.

A great deal of attention has been given lately to the role that formal logic can play in providing a formal mathematical theory to unify the theory and semantics of database concepts and operations ([GM78] is an excellent reference for these issues.) We believe that this is a healthy trend that can only serve to clarify and make precise otherwise vague ideas and theories. Moreover, a great deal of the meta-theory of formal logic can be applied directly toward the understanding and the proof of many notions in database theory. In this work we propose the concept of a historical database as a tool for modelling the changing states of information about some part of the real world.