Eduardo Zambon

Modelling and analysis using GROOVE

In this paper we present case studies that describe how the graph transformation tool groove has been used to model problems from a wide variety of domains. These case studies highlight the wide applicability of groove in particular, and of graph transformation in general. They also give concrete templates for using groove in practice. Furthermore, we use the case studies to analyse the main strong and weak points of groove.

Pattern-based graph abstraction

We present a new abstraction technique for the exploration of graph transformation systems with infinite state spaces. This technique is based on patterns, simple graphs describing structures of interest that should be preserved by the abstraction. Patterns are collected into pattern graphs, layered graphs that capture the hierarchical composition of smaller patterns into larger ones. Pattern graphs are then abstracted to a finite universe of pattern shapes by collapsing equivalent patterns. This paper shows how the application of production rules can be lifted to pattern shapes, resulting in an over-approximation of the original system behaviour and thus enabling verification on the abstract level.

Solving the N-Queens Problem with GROOVE - Towards a Compendium of Best Practices

We present a detailed solution to the N-queens puzzle using GROOVE, a graph transformation tool especially designed for state space exploration and analysis. While GROOVE has been freely available for more than a decade and has attracted a reasonable number of users, it is safe to say that only a few of these users fully exploit the tool features. To improve this situation, using the N-queens puzzle as a case study, in this paper we provide an in-depth discussion about problem solving with GROOVE, at the same time highlighting some of the tool’s more advanced features. This leads to a list of best-practice guidelines, which we believe to be useful to new and expert users alike.

Using graph transformations and graph abstractions for software verification

In this abstract we present an overview of our intended approach for the verification of software written in imperative programming languages. This approach is based on model checking of graph transition systems (GTS), where each program state is modeled as a graph and the exploration engine is specified by graph transformation rules. We believe that graph transformation [13] is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation provides a clean setting to investigate the use of graph abstractions, which can mitigate the space state explosion problem that is inherent to model checking techniques.

Graph Subsumption in Abstract State Space Exploration

In this paper we present the extension of an existing method for abstract graph-based state space exploration, called neighbourhood abstraction, with a reduction technique based on subsumption. Basically, one abstract state subsumes another when it covers more concrete states; in such a case, the subsumed state need not be included in the state space, thus giving a reduction. We explain the theory and especially also report on a number of experiments, which show that subsumption indeed drastically reduces both the state space and the resources (time and memory) needed to compute it.

Knowledge-Based graph exploration analysis

In a context where graph transformation is used to explore a space of possible solutions to a given problem, it is almost always necessary to inspect candidate solutions for relevant properties. This means that there is a need for a flexible mechanism to query not only graphs but also their evolution. In this paper we show how to use Prolog queries to analyse graph exploration. Queries can operate both on the level of individual graphs and on the level of the transformation steps, enabling a very powerful and flexible analysis method. This has been implemented in the graph-based verification tool groove. As an application of this approach, we show how it gives rise to a competitive analysis technique in the domain of feature modelling.

Graphs as Models - Preface

This volume contains the proceedings of the (first) Graphs as Models (GaM) 2015 workshop, held on 10-11 April 2015 in London, U.K., as a satellite workshop of ETAPS 2015, the European Joint Conferences on Theory and Practice of Software. This new workshop combines the strengths of two pre-existing workshop series: GT-VMT (Graph Transformation and Visual Modelling Techniques) and GRAPHITE (Graph Inspection and Traversal Engineering). Graphs are used as models in all areas of computer science: examples are state space graphs, control flow graphs, syntax graphs, UML-type models of all kinds, network layouts, social networks, dependency graphs, and so forth. Used to model a particular phenomenon or process, graphs are then typically analysed to find out properties of the modelled subject, or transformed to construct other types of models. The workshop aimed at attracting and stimulating research on the techniques for graph analysis, inspection and transformation, on a general level rather than in any specific domain. In total, we received 15 submissions covering several different areas. Of these 15 submissions, nine were eventually accepted and appear in this volume.This volume contains the proceedings of the (first) Graphs as Models 2015 workshop, held on 10-11 April 2015 in London, U.K., as a satellite workshop of ETAPS 2015, the European Joint Conferences on Theory and Practice of Software.

Recipes for Coffee: Compositional Construction of JAVA Control Flow Graphs in GROOVE

The graph transformation tool GROOVE supports so-called recipes, which allow the elaboration of composite rules by gluing simple rules via a control language. This paper shows how recipes can be used to provide a complete formalization (construction) of the control flow semantics of JAVA 6. This construction covers not only basic language elements such as branches and loops, but also abrupt termination commands, such as exceptions. By handling the whole JAVA 6 language, it is shown that the method scales and can be used in real-life settings. Our implementation has two major strengths. First, all rule sequencing is handled by recipes, avoiding the need to include extraneous elements in the graphs for this purpose. Second, the approach provides rules modularization: related rules are grouped in recipes, which in turn can be used again to form larger, more elaborated recipes. This gives rise to an elegant, hierarchical rule structure built in a straightforward, compositional way.

Formal definition of a general ontology pattern language using a graph grammar

In recent years, there has been a growing interest in the use of ontologica! theories in the philosophical sense (Foundational Ontologies) to analyze and (re)design conceptual modeling languages. This paper is about an ontologically well-founded conceptual modeling language in this tradition, termed OntoUML. This language embeds a number of ontological patterns that reflect the micro-theories comprising a particular foundational ontology named UFO. We here (re)define OntoUML as a formal graph grammar and demonstrate how the models of this language can be constructed by the combined application of ontological patterns following a number of graph transformation rules. As a result, we obtain a version of this language fully defined as a formal Ontology Pattern Grammar. In other words, this paper presents a formal definition of OntoUML that is both explicit in terms of the ontological patterns that it incorporates and is completely independent of the UML meta-model.

Saying Hello World with GROOVE - A Solution to the TTC 2011 Instructive Case

This report presents a solution to the Hello World case study using GROOVE. We provide and explain the grammar that we used to solve the case study. Every requested question of the case study was solved by a single rule application.