In traditional data manipulation languages, variables can occur in updates. Typically, these updates only cause changes in a single tuple; the variables are used as placeholders for don't-care values in that tuple. For example, in updating an employee's salary, variables can be used for all the irrelevant attributes of the employee record, and only the employee ID and the new salary specified in the update request.

To speed query processing in a relational theory, it may be desirable to restrict the body of the theory to ground formulas, as we did in the preceding chapters. In this case, to perform an update U containing variables, one must first find all the bindings σ of variables to data values such that the selection clause (φ)σ of U might be satisfied by some model of the theory. (In general, we expect all variables in ω to also appear in φ.) Each such set of bindings transforms U into a ground update (U)σ. The task of the update algorithm is then to perform all the ground updates (U)σ simultaneously, as described in Section 5.1. The cost of an update containing variables will be a function of the number of bindings σ for its variables, just as in ordinary relational databases.

If, on the other hand, the body of the relational theory is not restricted to ground formulas, updates with variables are very easy to perform, as shown in Section 5.2.

As usual, we confine our attention to insert requests: insert ω where φ.

Suppose that one wishes to construct, use, and maintain a body of information describing what is known about the state of the world. One would naturally wish to have a means of updating the information as more facts are gathered about the state of the world, and as the world undergoes change. But how can new facts be added to a body of knowledge when the new facts may contradict preexisting information? For example, given the new information that “b or c is true,” how can one get rid of all outdated information about b and c, add the new information, and yet in the process not disturb any other information in the knowledge base? The simplest choice is to place the burden on the users, by requiring them to determine exactly what to add and remove from the knowledge base. But what is really needed is a way to specify the desired change intensionally, by stating a formula that the state of the world is now known to satisfy and letting the knowledge base update algorithms automatically accomplish that change.

In this book we examine application-independent means of updating data and knowledge bases, viewing them abstractly as finite sets of sentences in propositional and first-order logic. We anticipate that an appropriate treatment of updates can be designed for a particular application by coupling the relevant application-independent techniques with additional principles and heuristics that are specific to the application domain.

Incomplete information occurs when, due to insufficient knowledge about the state of the world, there is more than one candidate database to represent the current state of the world. In the database world, one can imagine the user keeping a set of relational databases (even an infinite set, if one imagines vigorously), knowing that one of these databases corresponds to the actual state of the world, but needing more information to know which database is the correct one. If the user wants to apply an ordinary relational update to this set of candidate databases, then the natural definition of the semantics of the update is to apply the update to each candidate database individually.

Though this imaginary scenario paints a clear picture of the semantics of ordinary updates when incomplete information is present, it is unsuitable for direct implementation in most applications, due to the prohibitive expense of storing multiple databases. A more compact representation of the candidate databases is required for the sake of efficiency. Our solution is to represent sets of databases as the models of simple relational theories in first-order logic, using an extension of Reiter's relational theories [Reiter 84]. Our relational theories are sufficiently powerful to represent in one theory any realistic set of relational databases all having the same schema and integrity constraints. Section 3.1 gives a formal description of the language and Section 3.2 of the structure of relational theories.

The semantics presented in Chapter 3 describe the effect of an update on the models of a theory; the semantics give no hints whatsoever on how to translate that effect into changes in the relational theory. An algorithm for performing updates cannot proceed by generating models from the theory and updating them directly; this is because the number of standard models may be exponential in the size of the theory, and it may be very difficult to find even one model, as that is equivalent to testing the satisfiability of the theory.

In the sections of this chapter, we consider algorithmic means of accomplishing successively more complicated updates, beginning with updates under the standard semantics, without nulls and selection clauses, operating under an open-world assumption, in Section 4.1. Section 4.2 extends this approach to updates with nulls, and Section 4.3 shows how to process selection clauses correctly. Section 4.4 shows how to enforce the closed-world assumption.

Section 4.5 shows that these algorithms are correct in the sense that the alternative worlds produced under the algorithms are the same as those produced by updating each alternative world individually.

Section 4.6 discusses the computational complexity of the algorithms. For relational theories and updates without nulls, the algorithms have the same asymptotic cost as for an ordinary complete-information database update, but may increase the size of the relational theory. For updates involving nulls, the increase in size will be severe if many data atoms in the theory unify with those in the update.

As we mentioned in the first chapter, general questions concerning whole numbers, rather than merely mechanical computations, can be extremely difficult to answer. Indeed this higher (as opposed to basic) arithmetic is one of the most difficult and fascinating branches of mathematics, and has been extensively studied by many of the greatest mathematicians. These mathematicians often spent an enormous amount of time and energy checking their conjectures with specific numbers and sifting through mountains of experimental data. (Mathematics is an experimental science after all. It differs from other experimental sciences, however, because often the amount of experimental evidence prior to the proof of a result might be very slim, and after the proof experimental evidence is strictly irrelevant, although psychologically reassuring.) Anyway, the computational feats of mathematicians of old are often extremely impressive, bearing in mind that they only had paper and pencil (or papyrus and stylus or whatever) to hand. What an advantage we have! Indeed what might Gauss have achieved with his own micro? Let us start our investigations. The emphasis throughout this chapter will be on the building blocks of arithmetic: the prime numbers.

Prime numbers

Recall that a natural number x is prime if it is only divisible by 1 and itself (in other words cannot be written as a product of natural numbers a and b unless a or b is 1). It is fairly clear that any number can be factored as a product of prime numbers and the resulting factorization is unique up to the order of the factors.

INTRODUCTION

This book provides a systematic introduction to process algebra, suitable for teaching purposes. By the term process algebra we mean the study of concurrent communicating processes in an algebraic framework, following the approach of J.A. Bergstra and J.W. Klop (see section 8.1). In the present book we treat concurrency theory (the theory of concurrent 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. This axiomatic method is algebraic in the sense that we consider structures (also called “process algebras”) as models of some set of (mostly) equational axioms. These structures are equipped with several operators, and so we use the term algebra in the sense of model theory. R. Milner, with his Calculus of Communicating Systems (CCS), is generally considered to be the initiator of the field of process algebra. CCS forms the basis for most of the axiom systems presented below.

There is ample motivation for such an axiomatic-algebraic approach to concurrency theory. The main reason is that there is not one definitive notion of process. There is a staggering amount of properties which one may or may not attribute to processes, there are dozens of views (semantics) which one may have on processes, and there are infinitely many models of processes. So an attempt to organize this field of process theories leads very naturally and almost unavoidably to an axiomatic methodology. A curious consequence is that one has to answer the question “What is a process?” with the seemingly circular answer “A process is something that obeys a certain set of axioms … for processes”.

BISIMULATION AND TRACE SEMANTICS

So far, we only considered models having the property of containing a submodel which is isomorphic to the initial algebra of the current theory (for instance see 2.7.35). In other words we may say that if two finite processes in a model are equal, this equality must be derivable from the theory.

Models that with respect to finite processes correspond to the graph model or the term model are said to be models in bisimulation semantics. Because for every one of our theories, its initial model is a model in bisimulation semantics, our axiom systems are said to be a complete axiomatization of bisimulation semantics. In this chapter we will consider other semantics than bisimulation semantics, and we will present complete axiomatizations of these alternative semantics as well.

Because all operators except for + and · can be eliminated from closed terms, we will mainly restrict ourselves to the theory BPA, with special constant 8. The addition of the special constant τ leads to many interesting observations, and a vastly increased complexity. We do not include it here, in order to focus on a few key issues.

We will discuss semantics that identify more processes than bisimulation semantics does. The advantage of this is clear: calculations become easier, and more simplifications can be made. On the other hand, some differences between processes are disregarded, and as a consequence, in some cases some operators cannot be defined any more.

We start with the repetition of an earlier result.

PRIORITIES AND INTERRUPTS

In this chapter will develop some additional features to the theory in the former chapters, in order to enlarge the area of its application. Let us start by introducing a mechanism to describe priorities in the system ACP of chapter 4 (see 4.2.1). In ACP with priorities some actions have priority over others in a sum. This mechanism can be used to model interrupts in a distributed system.

REMARK

We will not combine the system ACP with priorities with τ and the abstraction operator of chapter 5. This can be done in several ways, see 6.1.23.

PARTIAL ORDERING

Assume we have a partial ordering on the set of atomic actions A. This means that we have a relation < satisfying, for all a,b,c∈ A:

1. at most one< / i. of a < b, b < a, a = b is the case;

2. a<b and b<c imply a<c.

a<b now means that b has priority over a. Special constants like δ, are not included in the ordering, and thus never have priority over other actions (this is forced by axiom A6).

AIM

We want to define an operator ε implementing these priorities, i.e: if a<b, a<c, and b and c are not related, we want to have:

1. ε(a + b) = b; ε(a + c) = c;

2. ε(b + c) = b + c.

ACTION RELATIONS

It is relatively straightforward to give a definition by action relations of the priority operator. We present such a definition in table 68 below.

This book was written in the years 1989 and 1990 at the Centre for Mathematics and Computer Science in Amsterdam. Much of the material comes from a Dutch book (reference Baeten [1986]), that was used in university courses at the University of Amsterdam and the University of Utrecht.

For the first time, this book brings together a lot of work in the area of algebraic process theory, as this has been developed since 1982 by a group of people in Amsterdam and Utrecht under the guidance of Jan Bergstra. Most of the research that found its way into this book was funded by European programmes, notably METEOR (ESPRIT I), SPECS (RACE), CONCUR (ESPRIT II BRA).

Many people contributed in one way or another to this book. We want to mention (in alphabetical order) Gert-Jan Akkerman, Jan Bergstra, Wiet Bouma, Jeroen Bruijning, Nicolien Drost, Rob van Glabbeek, Jan Friso Groote, Jan Willem Klop, Karst Koymans, Evangelos Kranakis, Sjouke Mauw, Kees Middelburg, Hans Mulder, Eric Nieuwland, Ernst-Rudiger Olderog, Alban Ponse, Scott Smolka, Frits Vaandrager, Gert Veltink, Jos Vrancken, Han Zuidweg. Thanks are due to the head of the Department of Software Technology of the Centre for Mathematics and Computer Science, Jaco de Bakker, who created an excellent working atmosphere.

The first author wants to dedicate this book to his wife Jeanne, who was very important in its writing, but cannot see its completion.

THE BASIC SYSTEM

In this chapter we will introduce some basic concepts of process algebra. We will do this in a modular way: first we will consider the theory BPA (Basic Process Algebra) as the kernel of all other theories that are given later. In the following sections we will show how to add some features such as deadlock, termination, projection and recursion to this theory in order to make it more powerful in its theoretical and practical applications. Each additional feature yields a conservative extension of the theories, so that we may consider the additional equations as a modular extension. Whether or not such a module should be added to the theory depends on what we want to use the theory for.

Starting in section 2.5, we consider various models for the algebraic theories that we found up to that point. Finding these models is important for more than one reason. First of all, it guarantees that the theories are consistent in the sense that the equations do not force undesirable identities to hold. Also, the models can help the intuition, they can help to visualize processes. Our models will in all cases be complete for the given theory, so the equality of two terms is true in the model exactly when it is derivable from the theory.

SYNTAX

We begin immediately with the equational specification BPA = (∑BPA, EBPA).

INTERLEAVING

In order to be able to describe processes that occur in parallel, concurrently, we introduce the merge operator ||.

The process χ || y is the process that executes processes χ and y in parallel. If we assume

that the observation of an atomic action has no duration, and that two actions cannot happenn simultaneously, then it appears that in χ || y the atomic actions of χ are merged or interleaved with those of y: every time we either see the next action of χ, or the next action of y. Thus, in a || b (a,b ∈ A) we either see a first, followed by b, or we see b first, followed by a. We obtain the following identity:

a||b = ab + ba.

This approach to the merge operator is called arbitrary interleaving or shuffle in the literature. Notice that we do not assert that the first action has terminated when the second one starts. This can depend on the implementation of a process (on a sequential or a parallel machine). We can however, if we want to, explicitly state that two actions can overlap in time: if g and h are two events having some duration, we can introduce atomic actions begin(g), end(g), begin(h) and end(h), and then we can describe process g || h by

This process has begin(g)·begin(h)·end(g)·end(h) as one of its possible execution sequences.

Note that in this theory, we cannot mention time explicitly, contrary to theories like temporal logic.

In 3.1.2 we will expand the system BPA from chapter 2 with this merge operator. In order to specify the merge in finitely many equations, we need an auxiliary operator.