21 Unfolding Techniques for Verifying Graph Transformation Systems (original) (raw)

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,

A logic for analyzing abstractions of graph transformation systems

2003

A technique for approximating the behaviour of graph transformation systems (GTSs) by means of Petri net-like structures has been recently defined in the literature. In this paper we introduce a monadic second-order logic over graphs expressive enough to characterise typical graph properties, and we show how its formulae can be effectively verified.

Towards a Petri net Model for Graph Transformation Systems

2019

Graph transformation systems (GTS) have been successfully proposed as a general, theoretically sound model for concurrency. Petri nets (PN), on the other side, are a central and intuitive formalism for concurrent or distributed systems, well supported by a number of analysis techniques/tools. Some PN classes have been shown to be instances of GTS. In this paper, we change perspective presenting an operational semantics of GTS in terms of Symmetric Nets, a well-known class of Coloured Petri nets featuring a structured syntax that outlines model symmetries. Some practical exploitations of the proposed operational semantics are discussed. In particular, a recently developed structural calculus for SN is used to validate graph rewriting rules in a symbolic way.

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.

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.

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.

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.

Model checking graph transformations: A comparison of two approaches

Graph Transformations, 2004

Model checking is increasingly popular for hardware and, more recently, software verification. In this paper we describe two different approaches to extend the benefits of model checking to systems whose behavior is specified by graph transformation systems. One approach is to encode the graphs into the fixed state vectors and the transformation rules into guarded commands that modify these state vectors appropriately to enjoy all the benefits of the years of experience incorporated in existing model checking tools. The other approach is to simulate the graph production rules directly and build the state space directly from the resultant graphs and derivations. This avoids the preprocessing phase, and makes additional abstraction techniques available to handle symmetries and dynamic allocation. In this paper we compare these approaches on the basis of three case studies elaborated in both of them, and we evaluate the results. Our conclusion is that the first approach outperforms the second if the dynamic and/or symmetric nature of the problem under analysis is limited, while the second shows its superiority for inherently dynamic and symmetric problems.

Automatic Graph Transformation In System Verification

2000

The use of formal verification methods is essential in the design process of dependable computer controlled systems. A complex environment should support the semiformal specification as well as the formal verification of the desired system. The efficiency of applying these formal methods will be highly increased if the underlying mathematical background is hidden from the designer. In such an integrated system effective techniques are needed to transform the system model to different sort of mathematical models supporting the assessment of system characteristics. The current paper introduces our research results towards a general-purpose model transformation engine. This approach results in yielding a provenly correct and complete transformation code by combining the powerful techniques of graph transformation, planner algorithms and deductive databases. Keywords: formal verification, graph transformation, visual languages, planner algorithms, deductive databases. 1

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.