Concurrent Semantics Research Articles

Branching bisimilarity is an equivalence indeed!

This note presents a detailed proof of a result in the theory of concurrency semantics that is already considered folklore, namely that branching bisimilarity is an equivalence relation. The “simple proof”, which in the literature is always assumed to exist, is shown to be incorrect. The proof in this note is based on the notion of a semi-branching bisimulation taken from (Van Glabbeek and Weijland, 1991). Branching bisimilarity can equivalently be defined in terms of semi-branching bisimulations; the results suggest that such a definition is more intuitive than the original definition of Van Glabbeek and Weijland (1989).

Branching time and abstraction in bisimulation semantics

In comparative concurrency semantics, one usually distinguishes between linear time and branching time semantic equivalences. Milner's notion of observatin equivalence is often mentioned as the standard example of a branching time equivalence. In this paper we investigate whether observation equivalence really does respect the branching structure of processes, and find that in the presence of the unobservable action τ of CCS this is not the case. Therefore, the notion of branching bisimulation equivalence is introduced which strongly preserves the branching structure of processes, in the sense that it preserves computations together with the potentials in all intermediate states that are passed through, even if silent moves are involved. On closed CCS-terms branching bisimulation congruence can be completely axiomatized by the single axion scheme: a.(τ.(y+z)+y)=a.(y+z) (where a ranges over all actions) and the usual loaws for strong congruence. We also establish that for sequential processes observation equivalence is not preserved under refinement of actions, whereas branching bisimulation is. For a large class of processes, it turns out that branching bisimulation and observation equivalence are the same. As far as we know, all protocols that have been verified in the setting of observation equivalence happen to fit in this class, and hence are also valid in the stronger setting of branching bisimulation equivalence.

Principles and practice of constraint programming: The Newport papers

Part 1 Concurrency: a concurrent semantics for concurrent constraint programmes via contextual nets, Ugo Montanari and Francesca Rossi object-oriented concurrent constraint programming in Oz, Martin Henz et al. Part 2 Reactive systems: constraint programming in constraint nets, Ying Zhang and Alan K. Mackworth robot programming and constraints, Dinesh K. Pai constraint logic programming - hybrid control, logic as linear programming, Wolf Kohn et al. Part 3 Languages and environments: 2LP - linear programming and logic programming, Ken McAloon and Carol Tretkoff a constraint-based scientific programming language, Richard Zippel designing constraint logic programming langauges using computational systems, Claude Kirchner et al aggregation in constraint databases, Gabriel M. Kuper synthesis on constraint algorithms, Douglas R. Smith and Stephen J Westfold exploiting constraint dependency information for debugging and explanation, Walid T. Keirouz et al constraining the structure and style of object-oriented programmes, Scott Meyers et al. Part 4 Constraint-solving algorithms: an approach for solving systems of parametric polynomial equations, Deepak Kapur Fourier's elimination - which to choose?, Jean-Louis Imbert verifying logic circuits by benders decomposition, J.N. Hooker and H. Yan an incremental hierarchical constraint solver, Francisco Menezes and Pedro Barahona. Part 5 Artificial intelligence: a disjunctive decomposition control schema for constraint satisfaction, Eugene C. Freuder and Paul D. Hubbe local consistency in parallel constraint-satisfaction networks, Simon Kasif and Arthur L. Delcher terminological reasoning with constraint handling rules, Thom Fruhwirth and Philipp Hanschke. Part 6 Computer graphics: the SkyBlue constraint solver with its applications, Michael Sanella practical issues in graphical constraints, Michael Gleicher constraint management in a declarative design method for 3D scene sketch modelling, Stephane Donikian and Gerard Hegron expressing constraints for data display specification - a visual approach, Isabel F. Cruz.

A Petri nets semantics for data flow networks

This work presents a truly concurrent operational semantics for nondeterministic data flow networks. We introduce a model, the df-process, which is a notion similar to that of non-sequential process for a Petri net: a df-process is defined as a mapping from an occurrence net K to a data flow net N, such that the places and the transitions of K are mapped onto the channels and the nodes of N. A df-process contains, by means of some labelling of the places, information on the value and the order in which data flow through the channels during a computation. Df-processes for a data flow network are characterized in an abstract way by a set of properties and in general a df-process corresponds to a set of computations of the network. We give a way to build the df-process corresponding to a computation incrementally at each event occurrence: a main result of the paper is that the incremental construction yields exactly the same set of df-processes as abstractly defined. We also show that df-processes are compositional. The model is intended to be used by distributed systems designers: it contains enough information to be a guideline for the designer and to be a base to develop dynamic checking tools. We outline how df-processes can be used in the design phase of a system.

On the implementation of concurrent calculi in net calculi: two case studies

Concurrent calculi, such as CCS, are defined in terms of labelled transition system; similarly, here we introduce the notion of net (or distributed) calculus, which is defined through a place/transition Petri net. As a first case study, a simple calculus of nets, called SCONE, is proposed. Relationships between SCONE and the subset of CCS without restriction and relabelling, called RCCS, are studied by showing that RCCS can be implemented in SCONE through a suitable mapping from the transition system for RCCS to net for SCONE. In particular, the complex CCS operation of global choice is implemented in terms of the SCONE finer grained operation of local choice, making explicit the fact that certain CCS transition are implemented as SCONE computations to be executed atomically. The result is a finite net implementation for RCCS agents. By making the quotient of the RCCS transition system w.r.t. the implementation mapping, we induce a truly concurrent semantics for RCCS. The second case study is then concerned with an extension dealing with restriction and relabelling. The resulting net calculus, called SCONE +, is exploited as an implementation language for full CCS. The truly concurrent semantics induced by the implementation mapping is proved to coincide with the so-called “permutation-of-transitions” sematics.

The design and implementation of a distributed transaction system based on atomic data types

The complexity of potential interactions among concurrent activities and the multitude of failure modes that can occur in distributed systems make it hard to reason about distributed programs. Transactions provide the programmer with a mechanism that simplifies the development of concurrent and distributed programs. In this paper we present the design and implementation of a distributed transaction system that uses atomic data types to provide synchronization and recovery. Generally speaking, implementing user-defined atomic data types is a difficult task. However, unlike existing systems, our system requires programmers to do very little extra work to make an object atomic. Programmers implement atomic data types as if for a sequential and reliable environment and specify the concurrent semantics of object operations separately in a small, but expressive declarative language. Appropriate synchronization and recovery code for atomic data types is generated automatically by the system according to this information.

Concurrent Computing: from Petri Nets to Graph Grammars

Petri nets are widely accepted as a specification formalism for concurrent and distributed systems. One of the reasons of their success is the fact that they are equipped with a rich theory, including well-understood concurrent semantics; they also provide an interesting benchmark for tools and techniques for the description of concurrent systems.Graph grammars can be regarded as a proper generalization of Petri nets, where the current state of a system is described by a graph instead as by a collection of tokens. In this tutorial paper I will review some basic definitions and constructions concerning the concurrent semantics of nets, and I will show to what extent corresponding notions have been developed for graph grammars. Most of such results come out from a joint research by the Berlin and Pisa COMPUGRAPH groups.

Concurrent Semantics for the π-calculus

In this paper we give both operational and abstract concurrent semantics for the π-calculus (a process algebra with the ability of handling channels as messages [23]) and discuss their consistency. For the operational semantics [15,6];, for the abstract semantics we introduce interleaving, partial ordering and mixed ordering observations, define the corresponding bisimulation relations and discuss them.

Infinite Concurrent Systems — I. The Relationship between Metric and Order Convergence

Abstract In recent years, Mazurkiewicz trace theory has become increasingly popular as a model of semantics for non-interleaving concurrency, and the theory is here further extended to allow descriptions of infinite behaviours based on alphabets of arbitrary cardinality. We describe an unconventional but nonetheless natural, ordering on trace space, and show that under this ordering, every nonempty set of traces has a greatest lower bound. Consequently, the ordering is consistently complete, i.e. if a set of traces has an upper bound, it has a least such bound. This parallels the result that traces over finite alphabets form a domain. Kwiatkowska has demonstrated an ultrametric, definable on (standard) trace spaces, under which they become compact, and hence complete, topological spaces. For finite alphabets, thus ultrametric essentially agrees with that of Comyn and Dauchet, but for infinite alphabets they differ in behaviour. We investigate the structure of trace space under various topologies, demonstrate the relationship between order convergence and the various metric convergence regimes, and thereby explain apparent behaviourial anomalies.

The connection between an event structure semantics and an operational semantics forTCSP

The relation between an operational interleaving semantics for TSCP based on a transition system and a compositional true concurrency semantics based on event structures is studied. In particular we extend the consistency result of U. Goltz and R. Loogen [Ann. Soc. Math. Pol., Ser. IV, Fundam. Inf. 14, 39-73 (1991; Zbl 0717.68028)] for TCSP processes without recursion to the general case. Thus, we obtain for every TCSP process P that its operational meaning O(P) and the interleaving behaviour O(M[[P]]) which is derived from the event structure M[[P]] associated with P are bisimilar. (aus: Zentralblatt MATH)

DISTRIBUTIVE EVALUATIONS OF λ-CALCULUS

In this paper we address the problem of encoding evaluation strategies for the λ-calculus into prime event structures. In order for this to be possible the derivation spaces yielded by the evaluation mechanism must be prime algebraic cpo's. This requirement is not met by permutation equivalence (the standard concurrent semantics with which λ-calculus is equipped) since the derivation spaces it yields are upper semi-lattices. We solve this problem by taking the coarsest congruence contained in permutation equivalence such that permutations of disjoint reductions are equated and the downward closure of every derivation is a distributive lattice. This equivalence, called distributive permutation equivalence, is characterized directly by restricting permutations of redexes to those sets U which are distributive, i.e. for every u ∈ U, the development of every V ⊆ (U\{u}) does not duplicate or delete u. A simple consequence of our results is that the derivation spaces of the call-by-value λ-calculus are distributive lattices. Finally, we show that a sequential evaluation mechanism can not, in general, be effectively transformed into a maximally distributive one.

COMBINING CCS AND PETRI NETS VIA STRUCTURAL AXIOMS

Many approaches have been developed with the aim of capturing the advantages of both process algebras and Petri nets in terms of modularity and structure on one side and faithful description of concurrency on the other. A natural way of merging these different models is to express the semantics of process algebras in terms of Petri nets. In this work we present a modular construction of operational models for CCS via different groups of structural axioms. To express them, we use Equational Type Logic (ETL), a formalism based on conditional axioms on typed algebras. Typed algebras can be used with profit to present transition systems where both states and transitions have algebraic structure, as opposed to the usual SOS approach where only states have structure. We build an algebra in which different types give different views of the language. In fact, different subalgebras live together in the same structure and are related by axioms. They represent: i) the transition system of CCS; ii) an unfolded version of it; iii) a net for CCS and its marking graph; and iv) a folded version of the latter with the same states as i). The model is completely compositional, since CCS operations are defined on all state representations. We also present axioms which directly establish the relation between interleaving and truly concurrent semantics for CCS. Finally, some related work is discussed and the relation of our models with two previous proposals is shown in detail.

Relation-based semantics for concurrency

Despite several decades of research, capturing the semantics of concurrent programs in a crisp and tractable fashion remains a formidable challenge. In this paper, we present a relation-based model for defining the semantics of concurrent programs. Although it is still in its enfancy, this model shows some advantageous features, which make it worthy of further investigation.

A true concurrency semantics for parallel programs

The paper shows, how the true concurrency model for concurrent systems, so-called directed, acyclic, arc-labelled graphs, and propositional Concurrent Temporal Logic, that have been developed for the specification and verification of elementary net systems, can be adapted to give a true concurrency semantics to shared variables programs, and to write first-order specifications of the programs, so that also concurrency can be specified.

A true concurrency model of CCS semantics

Degano et al. (1989) introduced AC/E systems (augmented C/E systems) to give a true concurrency semantics to CCS. But the true concurrency was not complete. There was no true concurrency for recursive agents (like < x>. e 1| e 2) and nondeterminant agents (like e 1| e 2+ e 3| e 4). Also the concept of bisimulation has not been transplanted to AC/E systems. This paper defines a complete true concurrency model of CCS by exploiting the potential concurrency of any CCS agent to its full strength. It introduces a kind of multilayered Petri nets, called NP/R nets, to define the processes on AC/E systems. We also introduced the notion of bisimulation of groups of NP/R nets and proved that this bisimulation relation can determine the CCS bisimulation uniquely.

Weakest precondition semantics for time and concurrency

A weakest precondition semantics for a real-time concurrent language is defined. An example in verification is presented, and the use of predicate transformers as the basis of a refinement calculus is also discussed.

Petri net semantics of priority systems

The specification of priorities provides a convenient way of resolving conflicts in the design of concurrent computing systems. Priorities have been widely used by operating systems to enforce the preferred order of the execution of jobs waiting for processing; while programming languages often provide primitives, such as prioritised choice operator, for expressing the intended preference of the execution of one enabled section of the program over another enabled section of the program. In this paper we consider priority systems ( Σ, ϱ), where Σ is a bounded Petri net, and ϱ is a priority relation on the transitions of the net. Our main goal is to give a formal semantics of ( Σ, ϱ) by constructing a Petri net Σ ϱ which would retain as much of the concurrency semantics of Σ as possible and at the same time not violate the priority constraints imposed by ϱ. In the construction provided by this paper, Σ ϱ is derived from Σ by adding additional places and arcs, and by splitting the transitions of the original net Σ if necessary. The way in which these new places are added generalises the standard complementation technique introduced for P/T-nets. For safe nets Σ he construction can be simplified and Σ ϱ built without splitting of any transitions. We then outline how the translation from ( Σ, ϱ) to Σ ϱ might be used to give a formal semantics of the prioritised choice operator.

Concurrent bisimulations in Petri nets

After various attempts, an equivalence relation is defined for labelled Petri nets, on the base of the concurrency semantics of net theory. This relation, called Fully Concurrent bisimulation and abbreviated FC-bisimulation, preserves the level of concurrency of visible operations and, under some conditions, allows to enforce injective labelling on them. Refinements of a visible operation are also defined and we show that, under some conditions, they preserve FC-bisimulation.

Fundamental study: Contractions in comparing concurrency semantics

We define for a number of concurrent imperative languages both operational and denotational semantic models as fixed points of contractions on complete metric spaces. Next, we develop a general method for comparing different semantic models by relating their defining contractions and exploiting the fact that contractions have a unique fixed point.

A metric for traces

We have derived an ultrametric suitable for the domain of traces, which constitutes a natural generalization of the standard metric used in the complete metric space of strings. The results presented here have applications in the denotational semantics for concurrency. As opposed to the domain-theoretic approach, the metric-space approach guarantees unique solutions to reflexive domain equations