Graph models for reachability analysis of concurrent programs

Reachability analysis is an attractive technique for analysis of concurrent programs because it is simple and relatively straightforward to automate, and can be used in conjunction with model-checking procedures to check for application-specific as well as general properties. Several techniques have been proposed differing mainly on the model used; some of these propose the use of flowgraph based models, some others of Petri nets.This paper addresses the question: What essential difference does it make, if any, what sort of finite-state model we extract from program texts for purposes of reachability analysis? How do they differ in expressive power, decision power, or accuracy? Since each is intended to model synchronization structure while abstracting away other features, one would expect them to be roughly equivalent.We confirm that there is no essential semantic difference between the most well known models proposed in the literature by providing algorithms for translation among these models. This implies that the choice of model rests on other factors, including convenience and efficiency.Since combinatorial explosion is the primary impediment to application of reachability analysis, a particular concern in choosing a model is facilitating divide-and-conquer analysis of large programs. Recently, much interest in finite-state verification systems has centered on algebraic theories of concurrency. Yeh and Young have exploited algebraic structure to decompose reachability analysis based on a flowgraph model. The semantic equivalence of graph and Petri net based models suggests that one ought to be able to apply a similar strategy for decomposing Petri nets. We show this is indeed possible through application of category theory

Characterizing Behavioural Congruences for Petri Nets

We exploit a notion of interface for Petri nets in order to design a set of net combinators. For such a calculus of nets, we focus on the behavioural congruences arising from four simple notions of behaviour, viz., traces, maximal traces, step, and maximal step traces, and from the corresponding four notions of bisimulation, viz., weak and weak step bisimulation and their maximal versions. We characterize such congruences via universal contexts and via games, providing in such a way an understanding of their discerning powers

On Modelling and Analysis of Dynamic Reconfiguration of Dependable Real-Time Systems

This paper motivates the need for a formalism for the modelling and analysis of dynamic reconfiguration of dependable real-time systems. We present requirements that the formalism must meet, and use these to evaluate well established formalisms and two process algebras that we have been developing, namely, Webpi and CCSdp. A simple case study is developed to illustrate the modelling power of these two formalisms. The paper shows how Webpi and CCSdp represent a significant step forward in modelling adaptive and dependable real-time systems.Comment: Presented and published at DEPEND 201

Mining structured Petri nets for the visualization of process behavior

Visualization is essential for understanding the models obtained by process mining. Clear and efficient visual representations make the embedded information more accessible and analyzable. This work presents a novel approach for generating process models with structural properties that induce visually friendly layouts. Rather than generating a single model that captures all behaviors, a set of Petri net models is delivered, each one covering a subset of traces of the log. The models are mined by extracting slices of labelled transition systems with specific properties from the complete state space produced by the process logs. In most cases, few Petri nets are sufficient to cover a significant part of the behavior produced by the log.Peer ReviewedPostprint (author's final draft

Dependencies and Simultaneity in Membrane Systems

Membrane system computations proceed in a synchronous fashion: at each step all the applicable rules are actually applied. Hence each step depends on the previous one. This coarse view can be refined by looking at the dependencies among rule occurrences, by recording, for an object, which was the a rule that produced it and subsequently (in a later step), which was the a rule that consumed it. In this paper we propose a way to look also at the other main ingredient in membrane system computations, namely the simultaneity in the rule applications. This is achieved using zero-safe nets that allows to synchronize transitions, i.e., rule occurrences. Zero-safe nets can be unfolded into occurrence nets in a classical way, and to this unfolding an event structure can be associated. The capability of capturing simultaneity of zero-safe nets is transferred on the level of event structure by adding a way to express which events occur simultaneously