Concurrent Semantics Research Articles

Synthesis of Nets with Step Firing Policies

The unconstrained step semantics of Petri nets is impractical for simulating and modelling applications. In the past, this inadequacy has been alleviated by introducing various flavours of maximally concurrent semantics, as well as priority orders. In this paper, we introduce a general way of controlling step semantics of Petri nets through step firing policies that restrict the concurrent behaviour of Petri nets and so improve their execution and modelling features. In a nutshell, a step firing policy disables at each marking a subset of enabled steps which could otherwise be executed. We discuss various examples of step firing policies and then investigate the synthesis problem for Petri nets controlled by such policies. Using generalised regions of step transition systems, we provide an axiomatic characterisation of those transition systems which can be realised as reachability graphs of Petri nets controlled by a given step firing policy. We also provide two different decision and synthesis algorithms for PT-nets and step firing policies based on linear rewards of steps, where the reward for firing a single transition is either fixed or it depends on the current net marking. The simplicity of the algorithms supports our claim that the proposed approach is practical.

AN ORDER DEGREE ALTERNATOR FOR ARBITRARY TOPOLOGIES

An alternator is an arbitrary set of interacting processes that satisfies three conditions. First, if a process executes its critical section, then no neighbor of that process can execute its critical section at the same state. Second, along any infinite sequence of system states, each process will execute its critical section, an infinite number of times. Third, along any maximally concurrent computation, the alternator will stabilize to a sequence of states in which the processes will execute their critical sections in alternation. A principal reason for interest in alternators is their ability to transform systems correct under serial execution semantics to systems that are correct under concurrent execution semantics. An earlier alternator for arbitrary topology required 2q states where q is the dependency graph circumference and after stabilization would wait 2q steps between critical section executions. In a synchronous environment, this alternator requires only 2d+1 states where d is the degree of the graph of process dependencies for the system and after stabilization will require a wait of 2d+1 steps between critical section executions. In an asynchronous environment, the synchronization properties of this alternator must be supplemented with an asynchronous unison algorithm. The asynchronous unison algorithm requires expansion of the required number of states to dt, where t is the longest chordless cycle in the dependency graph; however, the required wait between critical section executions remains O(d).

Relational structures model of concurrency

The paper deals with the foundations of concurrency theory. We show how structurally complex concurrent behaviours can be modelled by relational structures $${(X, \diamondsuit, \sqsubset)}$$, where X is a set (of event occurrences), and $${\diamondsuit}$$ (interpreted as commutativity) and $${\sqsubset}$$ (interpreted as weak causality) are binary relations on X. The paper is a continuation of the approach initiated in Gaifman and Pratt (Proceedings of LICS’87, pp 72–85, 1987), Lamport (J ACM 33:313–326, 1986), Abraham et al. (Semantics for concurrency, workshops in computing. Springer, Heidelberg, pp 311–323, 1990) and Janicki and Koutny (Lect Notes Comput Sci 506:59–74, 1991), substantially developed in Janicki and Koutny (Theoretical Computer Science 112:5–52, 1993) and Janicki and Koutny (Acta Informatica 34:367–388, 1997), and recently generalized in Guo and Janicki (Lect Notes Comput Sci 2422:178–191, 2002) and Janicki (Lect Notes Comput Sci 3407:84–98, 2005). For the first time the full model for the most general case is given.

Angelic semantics of fine-grained concurrency

We introduce a game model for an Algol-like programming language with primitives for parallel composition and synchronization on semaphores. The semantics is based on a simplified version of Hyland–Ong-style games and it emphasizes the intuitive connection between the concurrent nature of games and that of computation. The model is fully abstract for may-equivalence.

Probabilistic π-Calculus and Event Structures

This paper proposes two semantics of a probabilistic variant of the π-calculus: an interleaving semantics in terms of Segala automata and a true concurrent semantics, in terms of probabilistic event structures. The key technical point is a use of types to identify a good class of non-deterministic probabilistic behaviours which can preserve a compositionality of the parallel operator in the event structures and the calculus. We show an operational correspondence between the two semantics. This allows us to prove a “probabilistic confluence” result, which generalises the confluence of the linearly typed π-calculus.

Denotational semantics for thread algebra

This paper gives a denotational semantics for thread algebra (TA), an algebraic framework for the description and analysis of recent programming languages such as C# and Java [J.A. Bergstra, C.A. Middelburg, Thread algebra for strategic interleaving, Formal Aspects of Computing, in press. Preliminary version: Computing Science Report PGR0404: Sectie Software Engineering, University of Amsterdam]. We illustrate the technique taken from the metric topology of de Bakker and Zucker [J.W. Bakker, J.I. Zucker, Processes and the denotational semantics of concurrency. Inform. and Control, 54 (1/2) (1982) 70–120] to turn the domains of TA into complete metric spaces. We show that the complete metric space consisting of projective sequences is an appropriate domain for TA. By using Banach’s fixed point theorem, we prove that the specification of a regular thread determines a unique solution. We also give a structural operational semantics for thread algebra and its relation to our denotational semantics. Finally, we present a particular interleaving strategy for TA that deals with abstraction in a natural way.

Modelling Calculi with Name Mobility using Graphs with Equivalences

In the theory of graph rewriting, the use of coalescing rules, i.e., of rules which besides deleting and generating graph items, can coalesce some parts of the graph, turns out to be quite useful for modelling purposes, but, at the same time, problematic for the development of a satisfactory partial order concurrent semantics for rewrites. Rewriting over graphs with equivalences, i.e., (typed hyper)-graphs equipped with an equivalence over nodes provides a technically convenient replacement of graph rewriting with coalescing rules, for which a truly concurrent semantics can be easily defined. The expressivity of such a formalism is tested in a setting where coalescing rules typically play a basic role: the encoding of calculi with name passing as graph rewriting systems. Specifically, we show how the (monadic fragment) of the solo calculus, one of the dialect of those calculi whose distinctive feature is name fusion, can be encoded as a rewriting system over graph with equivalences.

Unfolding semantics of graph transformation

Several attempts have been made of extending to graph grammars the unfolding semantics originally developed by Winskel for (safe) Petri nets, but only partial results were obtained. In this paper, we fully extend Winskel’s approach to single-pushout grammars providing them with a categorical concurrent semantics expressed as a coreflection between the category of (semi-weighted) graph grammars and the category of prime algebraic domains, which factorises through the category of occurrence grammars and the category of asymmetric event structures. For general, possibly nonsemi-weighted single-pushout grammars, we define an analogous functorial concurrent semantics, which, however, is not characterised as an adjunction. Similar results can be obtained for double-pushout graph grammars, under the assumptions that nodes are never deleted.

Enhanced event structures: Towards a true concurrency semantics for E-LOTOS

E-LOTOS is a standard process-algebraic language for formal specification of real-time concurrent and reactive systems. Its originally defined semantics is based on interleaving of events. In the present paper, we propose an enhanced kind of event structures and show how to employ them to give E-LOTOS processes a branching-time true concurrency semantics. The proposed event structures can model real-time processes with data handling and excel in concise representation of event renaming and synchronization.

Compiling Esterel into Static Discrete-Event Code

Executing concurrent specifications on sequential hardware is important for both simulation of systems that are eventually implemented on concurrent hardware and for those most conveniently described as a set of concurrent processes. As with most forms of simulation, this is easy to do correctly but difficult to do efficiently. Solutions such as preemptive operating systems and discrete-event simulators present significant overhead.In this paper, we present a technique for compiling the concurrent language Esterel into very efficient C code. Our technique minimizes runtime overhead by making most scheduling decisions at compile time and using a very simple linked-list-based event queue at runtime.While these techniques work particularly well for Esterel with its high-level concurrent semantics, the same technique could also be applied to efficiently execute other concurrent specifications.

Event Structure Semantics for Dynamic Graph Grammars

Dynamic graph grammars (DGGs) are a reflexive extension of Graph Grammars that have been introduced to represent mobile reflexive systems and calculi at a convenient level of abstraction. Persistent graph grammars (PGGs) are a class of graph grammars that admits a fully satisfactory concurrent semantics thanks to the fact that all so-called asymmetric conflicts (between items that are read by some productions and consumed by other) are avoided. In this paper we introduce a slight variant of DGGs, called persistent dynamic graph grammars (PDGGs), that can be encoded in PGGs preserving concurrency. Finally, PDGGs are exploited to define a concurrent semantics for the Join calculus enriched with persistent messaging (if preferred, the latter can be naively seen as dynamic nets with read arcs).

Compositional semantics for open Petri nets based on deterministic processes

In order to model the behaviour of open concurrent systems by means of Petri nets, we introduce open Petri nets, a generalisation of the ordinary model where some places, designated as open, represent an interface between the system and the environment. Besides generalising the token game to reflect this extension, we define a truly concurrent semantics for open nets by extending the Goltz–Reisig process semantics of Petri nets. We introduce a composition operation over open nets, characterised as a pushout in the corresponding category, suitable for modelling both interaction through open places and synchronisation of transitions. The deterministic process semantics is shown to be compositional with respect to such a composition operation. If a net $Z_3$ results as the composition of two nets $Z_1$ and $Z_2$, having a common subnet $Z_0$, then any two deterministic processes of $Z_1$ and $Z_2$ that ‘agree’ on the common part, can be ‘amalgamated’ to produce a deterministic process of $Z_3$. Conversely, any deterministic process of $Z_3$ can be decomposed into processes of the component nets. The amalgamation and decomposition operations are shown to be inverse to each other, leading to a bijective correspondence between the deterministic processes of $Z_3$ and the pair of deterministic processes of $Z_1$ and $Z_2$ that agree on the common subnet $Z_0$. Technically, our result is similar to the amalgamation theorem for data-types in the framework of algebraic specification. A possible application field of the proposed constructions and results is the modelling of interorganisational workflows, recently studied in the literature. This is illustrated by a running example.

Event-based operational semantics and a consistency result for real-time concurrent processes with action refinement

In this paper an event-based operational interleaving semantics is proposed for real-time processes, for which action refinement and a denotational true concurrency semantics are developed and defined in terms of timed event structures. The authors characterize the timed event traces that are generated by the operational semantics in a denotational way, and show that this operational semantics is consistent with the denotational semantics in the sense that they generate the same set of timed event traces, thereby eliminating the gap between the true concurrency and interleaving semantics.

A discrete-time UML semantics for concurrency and communication in safety-critical applications

We define a subset krtUML of UML which is rich enough to express such modelling entities of UML, used in real-time applications, as active objects, dynamic object creation and destruction, dynamically changing communication topologies, combinations of synchronous and asynchronous communication, and shared memory usage through object attributes. We define a formal interleaving semantics for this kernel language by associating with each model M ∈ krtUML a symbolic transition system STS ( M ) . We briefly outline how to compile models of industrial systems making use of generalisation hierarchies, weak and strong aggregation, and hierarchical state-machines into krtUML. The main aim of the paper is to provide an executable semantics for krtUML suitable for the formal verification of temporal model properties with existing model-checking tools.

Domain and event structure semantics for Petri nets with read and inhibitor arcs

We propose a functorial concurrent semantics for Petri nets extended with read and inhibitor arcs, that we call inhibitor nets. Along the lines of the seminal work by Winskel on safe (ordinary) nets, the truly concurrent semantics is given at a categorical level via a chain of coreflections leading from the category SW- IN of semi-weighted inhibitor nets to the category Dom of finitary prime algebraic domains (equivalent to the category PES of prime event structures). As an intermediate semantic model, we introduce inhibitor event structures, an event-based model able to faithfully capture the dependencies among events which arise in the presence of read and inhibitor arcs. Inhibitor event structures generalise several event structure models in the literature, like prime, asymmetric and bundle event structures.

Domain and event structure semantics for Petri nets with read and inhibitor arcs*1

We propose a functorial concurrent semantics for Petri nets extended with read and inhibitor arcs, that we call inhibitor nets . Along the lines of the seminal work by Winskel on safe (ordinary) nets, the truly concurrent semantics is given at a categorical level via a chain of coreflections leading from the category SW - IN of semi-weighted inhibitor nets to the category Dom of finitary prime algebraic domains (equivalent to the category PES of prime event structures). As an intermediate semantic model, we introduce inhibitor event structures , an event-based model able to faithfully capture the dependencies among events which arise in the presence of read and inhibitor arcs. Inhibitor event structures generalise several event structure models in the literature, like prime, asymmetric and bundle event structures.

Superposition: composition vs refinement of non-deterministic, action-based systems

Abstract. The traditional notion of superposition has been used for supporting two distinct aspects of parallel program design: composition and refinement. This is because, when trace-based semantics of concurrency are considered, which is typical of most formal methods, these two relationships are modelled as inclusion between sets of behaviours. However, when forms of non-deterministic behaviour have to be considered, which is the case for component and service-based development, these two aspects do not coincide. In this paper, we show how the two roles of superposition can be separated and supported at the language and semantic levels. For this purpose, we use a categorical formalisation of program design in the language CommUnity that we are also using for addressing architectural concerns, another area in which the distinction between composition and refinement is particularly important.

A simple process algebra based on atomic actions with resources

This paper initiates the study of a process algebra based on atomic actions that are assigned resources, and that supports true concurrency. By true concurrency we mean that the parallel composition of concurrent processes does not rely on an interleaving of concurrent actions for its definition. Our process algebra includes a number of interesting operators that can be defined using resources of atomic actions to control their behaviour: of particular note is a (weak) sequential composition operator that exploits the truly concurrent nature of the semantics; this operator extends significantly the operation of prefixing by atomic actions that is supported in most truly concurrent semantics. Our language also includes a parallel composition operator that allows local events to execute asynchronously, while requiring synchronising events to execute simultaneously. In addition, the language supports a restriction operator and includes (unguarded) recursion.We present both a denotational semantics and a companion operational semantics for our language. The denotational semantics supports true concurrency, so that parallel composition is defined without non-determinism or interleaving. This semantics also is novel for its treatment of recursion. The meaning of a recursive process is defined using a least fixed point on a subdomain that is determined by the body of the recursion, and that varies from one process to another. Nonetheless, the recursion operators in the language have continuous interpretations in the denotational model. In fact, our denotational model is based on a domain-theoretic generalisation of Mazurkiewicz traces in which the concatenation operator, as well as the other operators from our language, can be given continuous interpretations.The operational model is presented in a natural SOS style. We prove a congruence theorem relating the two semantics, which implies the operational model itself is compositional. The congruence theorem also implies the denotational model is adequate with respect to the operational semantics, and we characterise the relatively mild conditions under which the denotational semantics is fully abstract with respect to the operational semantics.

Concurrency and Refinement in the Unified Modeling Language

Abstract This paper defines a formal semantics for a subset of the Unified Modeling Language (UML). It shows how suitable combinations of class, object, state, and sequence diagrams can be associated with patterns of interaction, expressed in the event notation of Communicating Sequential Processes (CSP). The diagram semantics is then extended to give a meaning to complete models – suitable combinations of diagrams – and thus a concurrency semantics for object models written in UML. This model semantics is in turn used to define a theory of refinement, based upon existing notions of data and process refinement.

MODELING AND ANALYZING MULTI-AGENT BEHAVIORS USING PREDICATE/TRANSITION NETS

How agents accomplish a goal task in a multi-agent system is usually specified by multi-agent plans built from basic actions (e.g. operators) of which the agents are capable. The plan specification provides the agents with a shared mental model for how they are supposed to collaborate with each other to achieve the common goal. Making sure that the plans are reliable and fit for the purpose for which they are designed is a critical problem with this approach. To address this problem, this paper presents a formal approach to modeling and analyzing multi-agent behaviors using Predicate/Transition (PrT) nets, a high- level formalism of Petri nets. We model a multi-agent problem by representing agent capabilities as transitions in PrT nets. To analyze a multi-agent PrT model, we adapt the planning graphs as a compact structure for reachability analysis, which is coherent to the concurrent semantics. We also demonstrate that one can analyze whether parallel actions specified in multi-agent plans can be executed in parallel and whether the plans can achieve the goal by analyzing the dependency relations among the transitions in the PrT model.