Abstract not found

This paper intends to give a semantical perspective on the recent work by Herlihy, Shavit and Rajsbaum on computability and complexity results for t-resilient and wait-free protocols for distributed systems. It is an extended abstract a of a talk given at the Imperial College Workshop, Oxford, Christ Church on the 2nd of April 1996. 1 Introduction In this article we address some computability and complexity problems which have most often arisen in the area of protocols for distributed systems and concurrent databases. The essence of these problems is to decide whether we can compute a certain kind of function in a distributed - yet robust - manner. Let us take our first example from the concurrent database theory. Imagine that we have a database that can be shared by n concurrent transactions T 1 ; \Delta \Delta \Delta ; Tn asynchronously. We suppose that the network linking the transactions to the shared database is not reliable in the sense that any wire can be cut unexpectedly, ...

We consider a class of Kripke Structures in which the atomic propositions are events. This enables us to represent worlds as sets of events and the transition and satisfaction relations of Kripke structures as the subset and membership relations on sets. We use this class, called event Kripke structures, to model concurrency. The obvious semantics for these structures is a true concurrency semantics. We show how several aspects of concurrency can be easily defined, and in addition get distinctions between causality and enabling, and choice and nondeterminism. We define a duality for event Kripke structures, and show how this duality enables us to convert between imperative and declarative views of programs, by treating states and events on the same footing. We provide pictorial representations of both these views, each encoding all the information to convert to the other. We define a process algebra of event Kripke structures, showing how to combine them in the usual ways---parallel co...

Abstract In this paper I compare the expressive power of several models of concurrency based on their ability to represent causal dependence. To this end, I translate these models, in behaviour preserving ways, into the model of higher dimensional automata, which is the most expressive model under investigation. In particular, I propose four different translations of Petri nets, corresponding to the four different computational interpretations of nets found in the literature. I also extend various equivalence relations for concurrent systems to higher dimensional automata. These include the history preserving bisimulation, which is the coarsest equivalence that fully respects branching time, causality and their interplay, as well as the ST-bisimulation, a branching time respecting equivalence that takes causality into account to the extent that it is expressible by actions overlapping in time. Through their embeddings in higher dimensional automata, it is now well-defined whether members of different models of concurrency are equivalent.

this paper . . . . . . . . . . . . . . . . . . . . . . . . . 4

This paper discusses results that say what cannot be computed in certain environments or when insucient resources are available. A comprehensive survey would require an entire book. As in Nancy Lynch's excellent 1989 paper, \A Hundred Impossibility Proofs for Distributed Computing" [86], we shall restrict ourselves to some of the results we like best or think are most important. Our aim is to give you the avour of the results and some of the techniques that have been used. We shall also mention some interesting open problems and provide an extensive list of references. The focus will be on results from the past decade.

. In this paper we define a process algebra abstracting relevant features of the Linda paradigm to parallel computation and show how to give it a semantics based on higher-dimensional automata which is more expressive than interleaving transition systems. In particular, it is a truly concurrent operational semantics, compositional in nature. Furthermore this semantics leads us to new kinds of abstract interpretations useful for the static analysis of concurrency. One of these addresses the correctness of implementations of Linda programs on real computers (which have a finite number of processors). 1 Introduction Parallel languages are difficult to design and implement. On the one hand, the task of actually using at the same time several processors should be taken care of in a transparent manner for the user. On the other hand, the multiplicity of architectures and paradigms for parallel machines and languages makes it difficult to find a unified way of speaking about semanti...

We review the conceptual development of (true) concurrency and branching time starting from Petri nets and proceeding via Mazurkiewicz traces, pomsets, bisimulation, and event structures up to higher dimensional automata (HDAs), whose acyclic case may be identified with triadic event structures and triadic Chu spaces. Acyclic HDAs may be understood as the extension of Boolean logic with a third truth value expressing transition. We prove the necessity of such a third value under mild assumptions about the nature of observable events, and show that the expansion of any complete Boolean basis L to L with a third literal �a expressing a = forms an expressively complete basis for the representation of acyclic HDAs. The main contribution is a new event state × of cancellation, sibling to, serving to distinguish a(b + c) from ab + ac while simplifying the extensional definitions of termination �A and sequence AB. We show that every HDAX (acyclic HDA with ×) is representable in the expansion of L to L × with a fourth literal �a expressing a = ×.

Homotopy in concurrent processes In theories of job scheduling and of distributed computing, there have been many attempts to introduce tools originating from algebraic and combinatorial topology, such as homotopy groups. Informally, the fundamental (or first homotopy) group gives an account of the nature of "holes" in a topological space. In the realm of processes, such holes may correspond to forbidden configurations; e.g. where more than one process is within the same critical region. However, many topological properties, technically necessary for the construction of the fundamental group, have no counterparts, or only artificial ones, in concurrent processes. The paths corresponding to process executions are not cyclic, because time only flows forwards, and they cannot be as naturally composed as looping paths in topological spaces. The fundamental "group" lacks therefore its group operations. This paper puts forward a simple remedy for the shortcomings: if you cannot find a usefu...

This thesis is concerned with formal semantics and models for concurrent computational systems, that is, systems consisting of a number of parallel computing sequential systems, interacting with each other and the environment. A formal semantics gives meaning to computational systems by describing their behaviour in a mathematical model. For concurrent systems the interesting aspect of their computation is often how they interact with the environment during a computation and not in which state they terminate, indeed they may not be intended to terminate at all. For this reason they are often referred to as reactive systems, to distinguish them from traditional calculational systems, as e.g. a program calculating your income tax, for which the interesting behaviour is the answer it gives when (or if) it terminates, in other words the (possibly partial) function it computes between input and output. Church's thesis tells us that regardless of whether we choose the lambda calculus, Turing machines, or almost any modern programming language such as C or Java to describe calculational systems, we are able to describe exactly the same class of functions. However, there is no agreement on observable behaviour for concurrent reactive systems, and consequently there is no correspondent to Church's thesis. A result of this fact is that an overwhelming number of di#erent and often competing notions of observable behaviours, primitive operations, languages and mathematical models for describing their semantics, have been proposed in the litterature on concurrency.