A case study: Verifying a mutual exclusion protocol with process creation using graph transformation systems (original) (raw)

21 Unfolding Techniques for Verifying Graph Transformation Systems

2004

Graph transformation systems (GTSs) are recognised as an expressive specification formalism, properly generalising Petri nets and especially suited for concurrent, distributed and mobile systems [7]: the (topo) logical distribution of a system can be naturally represented by using a graphical structure and the dynamics of the system, eg, the reconfigurations of its topology, can be modelled by means of graph rewriting rules.

Verifying Object-Based Graph Grammars

Electronic Notes in Theoretical Computer Science, 2004

Object-Based Graph Grammars (OBGG) is a formal language suitable for the specification of distributed systems. On previous work, a translation from OBGG models to PROMELA (the input language of the SPIN model checker) was defined, enabling the verification of OBGG models using SPIN. This paper builds on these results, where we extend the approach for property specification and define an approach to interpret PROMELA traces as OBGG derivations, generating graphical counter-examples for properties that are not true for an OBGG model.

Towards automated verification of layered graph transformation specifications

Iet Software/iee Proceedings - Software, 2009

Graph transformation systems have recently become more and more popular as a general formal modelling language. It is a suitable formalism for modelling different systems like distributed and complex systems. However, modelling must be complemented with proper analysis capabilities to let the user understand how designed models behave and whether stated requirements are fulfilled and model checking has proven to be a viable solution for this purpose. The authors propose an efficient solution for model checking attributed typed and layered graph transformation systems. Layered graph transformation systems are a powerful formalism to formally model different systems like hierarchical systems. In our proposal, AGG layered graph transformation specifications are translated to Bandera intermediate representation (BIR) -the input language of a Bogor model checker -and then Bogor verifies the model against some interesting properties defined by combining LTL (linear temporal logic) and special graph rules. The experimental results are encouraging and show that in most cases our proposal improves existing approaches, in terms of both performance and expressiveness.

Formal Verification of Object-Oriented Graph Grammars Specifications

Electronic Notes in Theoretical Computer Science, 2007

Concurrent object-oriented systems are ubiquitous due to the importance of networks and the current demands for modular, reusable, and easy to develop software. However, checking the correctness of such systems is a hard task, mainly due to concurrency and inheritance aspects. In this paper we present an approach to the verification of concurrent object-oriented systems. We use graph grammars equipped with object oriented features (including inheritance and polymorphism) as the specification formalism, and define a translation from such specifications to Promela, the input language of the SPIN model checker.

Verifying finite-state graph grammars: an unfolding-based approach

2004

We propose a framework where behavioural properties of finite-state systems modelled as graph transformation systems can be expressed and verified. The technique is based on the unfolding semantics and it generalises McMillan's complete prefix approach, originally developed for Petri nets, to graph transformation systems. It allows to check properties of the graphs reachable in the system, expressed in a monadic second order logic.

Towards Unfolding-Based Verification for Graph Transformation Systems

2003

Abstract The unfolding semantics of graph transformation systems can represent a basis for their formal verification. For general, possibly infinite-state, graph transformation systems one can construct finite under-and over-approximations of the (infinite) unfolding, with arbitrary accuracy. Such approximations can be used to check properties of a graph transformation system, like safety and liveness properties, expressed in suitable fragments of the µ-calculus.

Using Graph Transformations and Graph Abstractions for Software Verification

Gg, 2010

In this paper we describe our intended approach for the verification of software written in imperative programming languages. We base our approach on model checking of graph transition systems, where each state is a graph and the transitions are specified by graph transformation rules. We believe that graph transformation is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation allows us to investigate the use of graph abstractions, which can mitigate the combinatorial explosion inherent to model checking. In addition to presenting our planned approach, we reason about its feasibility, and, by providing a brief comparison to other existing methods, we highlight the benefits and drawbacks that are expected.

Abstraction and Abstraction Refinement in the Verification of Graph Transformation Systems

Graph transformation systems (GTSs) form a natural and convenient specification language which is used for modelling concurrent and distributed systems with dynamic topologies. These can be, for example, network and Internet protocols, mobile processes with dynamic behavior and dynamic pointer structures in programming languages. All this, together with the possibility to visualize and explain system behavior using graphical methods, makes GTSs a well-suited formalism for the specification of complex dynamic distributed systems. Under these circumstances the problem of checking whether a certain property of GTSs holds-the verification problem-is considered to be a very important question. Unfortunately the verification of GTSs is in general undecidable because of the Turingcompleteness of GTSs. In the last few years a technique for analysing GTSs based on approximation by Petri graphs has been developed. Petri graphs are Petri nets having additional graph structure. In this work we focus on the verification techniques based on counterexample-guided abstraction refinement (CEGAR approach). It starts with a coarse initial over-approximation of a system and an obtained counterexample. If the counterexample is spurious then one starts a refinement procedure of the approximation, based on the structure of the counterexample. The CEGAR approach has proved to be very successful for the verification of systems based on their over-approximations. This thesis investigates a counterexample-guided abstraction refinement approach for systems modelled with GTSs. Starting with a given spurious counterexample, we describe here how to construct a more exact approximation (by separating merged nodes) for which this counterexamples disappears. This procedure can be performed repeatedly for any number of spurious counterexamples. Furthermore, an incremental coverability approach for Petri nets is developed, which allows one to speed-up the construction of over-approximations of GTSs. A well-known approach is to extend a modelling language with the possibility of describing attributes as values of some data types. The approximation-based verification technique, including a counterexample-guided abstraction refinement, is hence also generalized in this work to attributed GTSs (AGTSs), where the attributes are abstracted in the framework of abstract interpretation. In the practical part, a verification tool Augur 2 is developed, which supports the whole verification process for GTSs and AGTSs. A number of case studies (both attributed and non-attributed GTSs) were successfully solved with Augur 2. Acknowledgement First of all, I would like to thank my doctoral adviser, Barbara König, for being my supervisor, for encouraging and challenging me throughout the academic program. This work would not have been possible without her. I want to express my gratitude to Javier Esparza, whose works on Petri net unfolding have awakened my interests to the related areas of computer science. I thank him also for his support and advices on various aspects of my work. I also would like to thank my colleagues,

Towards a Rule-Level Verification Framework for Property-Preserving Graph Transformations

We report in this paper a method for proving that a graph transformation is property-preserving. Our approach uses a relational representation for graph grammar and a logical representation for graph properties with first-order logic formulas. The presented work consists in identifying the general conditions for a graph grammar to preserve graph properties, in particular structural properties. We aim to implement all the relevant notions of graph grammar in the Isabelle/HOL proof assistant in order to allow a (semi) automatic verification of graph transformation with a reasonable complexity. Given an input graph and a set of graph transformation rules, we can use mathematical induction strategies to verify statically if the transformation preserves a particular property of the initial graph. The main highlight of our approach is that such a verification is done without calculating the resulting graph and thus without using a transformation engine.

Modeling and Verification of Reliable Messaging by Graph Transformation Systems

Electronic Notes in Theoretical Computer Science, 2007

Due to the increasing need of highly dependable services in Service-Oriented Architectures (SOA), service-level agreements include more and more frequently such non-functional aspects as security, safety, availability, reliability, etc. Whenever a service can no longer be provided with the required QoS, the service requester needs to switch dynamically to a new service having adequate service parameters after exchanging a sequence of messages. In the current paper, we first extend the core SOA metamodel with parameters required for reliable messaging in services. Then we model reconfigurations for reliable message delivery by graph transformation rules. Finally, we carry out a formal verification of the proposed rule set by combining analysis tools for graph transformation and labeled transition systems.

Unfolding Graph Transformation Systems: Theory and Applications to Verification

Lecture Notes in Computer Science, 2008

The unfolding of a system represents in a single branching structure all its possible computations: it is the cornerstone both of semantical constructions and of efficient partial order verification techniques. In this paper we survey the contributions we elaborated in the last decade with Ugo Montanari and other colleagues, concerning the unfolding of graph transformation systems, and its use in the definition of a Winskel style functorial semantics and in the development of methodologies for the verification of finite and infinite state systems.

Verifying a behavioural logic for graph transformation systems

2004

Abstract We propose a framework for the verification of behavioural properties of systems modelled as graph transformation systems. The properties can be expressed in a temporal logic which is basically a µ-calculus where the state predicates are formulae of a monadic second order logic, describing graph properties. The verification technique relies on an algorithm for the construction of finite over-approximations of the unfolding of a graph transformation system.

Towards model checking graph grammars

Workshop on Automated Verification of Critical …

We sketch a setup in which transition systems are generated from graph grammars and subsequently checked for properties expressed in a temporal logic on graphs. We envisage this as part of an approach where graph grammars are used to express the behavioural semantics of object-oriented programs, thus enabling automatic verification of those programs.

An efficient solution for model checking graph transformation systems

2008

This paper presents an efficient solution for modeling checking graph transformation systems. The approach transforms AGG specifications into Bogor models and supports both attributed typed graphs and layered transformations. Resulting models are amenable to check interesting properties expressed as combinations of LTL (Linear Temporal Logic) and graph transformation rules.

Using graph transformation systems to specify and verify data abstractions

2008

Abstract This paper proposes an approach for the specification of the behavior of software components that implement data abstractions. By generalizing the approach of behavior models using graph transformation, we provide a concise specification for data abstractions that describes the relationship between the internal state, represented in a canonical form, and the observers of the component. Graph transformation also supports the generation of behavior models that are amenable to verification.

Formal Verification of Graph Grammars using Mathematical Induction

Electronic Notes in Theoretical Computer Science, 2009

Graph grammars are a formal description technique suitable for the specification of distributed and reactive systems. Model-checking of graph grammars is currently supported by various approaches. However, in many situations the use of this technique can be very time and space consuming, hindering the verification of properties of many systems. This work proposes a relational and logical approach to graph grammars that allows formal verification of systems using mathematical induction. We use relational structures to define graph grammars and first-order logic to model graph transformations. This approach allows proving properties of systems with infinite state-spaces.

Model checking graph grammars

Proc. Workshop on Automated Verification of Critical …, 2003

Explicit state model checking for graph grammars

Concurrency, Graphs and Models, 2008

In this paper we present the philosophy behind the GROOVE project, in which graph transformation is used as a modelling formalism on top of which a model checking approach to software verification is being built. We describe the basic formalism, the current state of the project, and (current and future) challenges.

Summary 2: Graph grammar verification through abstraction

2005

Until now there have been few contributions concerning the verification of graph grammars, specifically of infinite-state graph grammars. This paper compares two existing approaches, based on abstractions of graph transformation systems. While in the unfolding approach graph grammars are approximated by Petri nets, in the partitioning approach graphs are abstracted according to their local structure. We describe differences and similarities of the two approaches and explain the underlying ideas.

Graph grammar verification through abstraction

Dagstuhl Seminar Proceedings, 2004