Generic Search Plans for Matching Advanced Graph Patterns

In the current paper, we present search plans which can guide pattern matching for advanced graph patterns with edge identities, containment constraints, type variables, negative application conditions, attribute conditions, and injectivity constraints. Based on a generic search graph representation, all search plan operations (e.g. checking the existence of an edge, or extending a matching candidate by navigating along an edge) are uniformly represented as special predicates with heuristically assigned costs. Finally, an executable search plan is defined as an appropriate ordering of these predicates. As a main consequence, attribute, injectivity, and negative application conditions can be checked early (but not unnecessarily early) in the pattern matching process to cut off infeasible matching candidates at the right time

Designing the automatic transformation of visual languages

AbstractThe design process of complex systems requires a precise checking of the functional and dependability attributes of the target design. The growing complexity of systems necessitates the use of formal methods, as the exhaustiveness of checks performed by the traditional simulation and testing is insufficient.For this reason, the mathematical models of various formal verification tools are automatically derived from UML-diagrams of the model by mathematical transformations guaranteeing a complete consistency between the target design and the models of verification and validation tools.In the current paper, a general framework for an automated model transformation system is presented. The method starts from a uniform visual description and a formal proof concept of the particular transformations by integrating the powerful computational paradigm of graph transformation, planner algorithms of artificial intelligence, and various concepts of computer engineering

Incremental Graph Pattern Matching: Data Structures and Initial Experiments

Despite the large variety of existing graph transformation tools, the implementation of their pattern matching engine typically follows the same principle. First a matching occurrence of the left-hand side of the graph transformation rule is searched by some graph pattern matching algorithm. Then potential negative application conditions are checked that might eliminate the previous occurrence. However, when a new transformation step is started, all the information on previous matchings is lost, and the complex graph pattern matching phase is restarted from scratch each time. In the paper, we present the foundational data structures and initial experiments for an incremental graph pattern matching engine which keeps track of existing matchings in an incremental way to reduce the execution time of graph pattern matching

Generating Preconditions from Graph Constraints by Higher Order Graph Transformation

Techniques for the verification of structural invariants in graph transformation systems typically rely on the derivation of negative application conditions that are attached to graph transformation rules in order to avoid the runtime occurrence of forbidden structural patterns in the system model. In this paper, we propose a practical approach for this derivation process, which produces the required negative application conditions by applying higher order graph transformation on the rule specifications themselves. Additionally, we integrate filtering criteria into these higher order constructs to avoid already at an early stage the unnecessary construction of invalid and redundant rules with negative application conditions

Conflict Detection for Edits on Extended Feature Models using Symbolic Graph Transformation

Feature models are used to specify variability of user-configurable systems as appearing, e.g., in software product lines. Software product lines are supposed to be long-living and, therefore, have to continuously evolve over time to meet ever-changing requirements. Evolution imposes changes to feature models in terms of edit operations. Ensuring consistency of concurrent edits requires appropriate conflict detection techniques. However, recent approaches fail to handle crucial subtleties of extended feature models, namely constraints mixing feature-tree patterns with first-order logic formulas over non-Boolean feature attributes with potentially infinite value domains. In this paper, we propose a novel conflict detection approach based on symbolic graph transformation to facilitate concurrent edits on extended feature models. We describe extended feature models formally with symbolic graphs and edit operations with symbolic graph transformation rules combining graph patterns with first-order logic formulas. The approach is implemented by combining eMoflon with an SMT solver, and evaluated with respect to applicability.Comment: In Proceedings FMSPLE 2016, arXiv:1603.0857

Improved Conflict Detection for Graph Transformation with Attributes

In graph transformation, a conflict describes a situation where two alternative transformations cannot be arbitrarily serialized. When enriching graphs with attributes, existing conflict detection techniques typically report a conflict whenever at least one of two transformations manipulates a shared attribute. In this paper, we propose an improved, less conservative condition for static conflict detection of graph transformation with attributes by explicitly taking the semantics of the attribute operations into account. The proposed technique is based on symbolic graphs, which extend the traditional notion of graphs by logic formulas used for attribute handling. The approach is proven complete, i.e., any potential conflict is guaranteed to be detected.Comment: In Proceedings GaM 2015, arXiv:1504.0244

Complex Attribute Manipulation in TGGs with Constraint-Based Programming Techniques

Model transformation plays a central role in Model-Driven Engineering (MDE) and providing bidirectional transformation languages is a current challenge with important applications.  Triple Graph Grammars (TGGs) are a formally founded,  bidirectional model transformation language shown by numerous case studies to be quite promising and successful.  Although TGGs provide adequate support for structural aspects via object  patterns in TGG rules, support for handling complex relationships between different attributes is still missing in current implementations.  For certain applications, such as bidirectional model-to-text transformations, being able to manipulate attributes via string manipulation or arithmetic operations in TGG rules is vital.  Our contribution in this paper is to formalize a TGG extension that provides a means for complex attribute manipulation in TGG rules.  Our extension is compatible with the existing TGG formalization, and retains the "single specification'' philosophy of TGGs

A Systematic Approach to Constructing Incremental Topology Control Algorithms Using Graph Transformation

Communication networks form the backbone of our society. Topology control algorithms optimize the topology of such communication networks. Due to the importance of communication networks, a topology control algorithm should guarantee certain required consistency properties (e.g., connectivity of the topology), while achieving desired optimization properties (e.g., a bounded number of neighbors). Real-world topologies are dynamic (e.g., because nodes join, leave, or move within the network), which requires topology control algorithms to operate in an incremental way, i.e., based on the recently introduced modifications of a topology. Visual programming and specification languages are a proven means for specifying the structure as well as consistency and optimization properties of topologies. In this paper, we present a novel methodology, based on a visual graph transformation and graph constraint language, for developing incremental topology control algorithms that are guaranteed to fulfill a set of specified consistency and optimization constraints. More specifically, we model the possible modifications of a topology control algorithm and the environment using graph transformation rules, and we describe consistency and optimization properties using graph constraints. On this basis, we apply and extend a well-known constructive approach to derive refined graph transformation rules that preserve these graph constraints. We apply our methodology to re-engineer an established topology control algorithm, kTC, and evaluate it in a network simulation study to show the practical applicability of our approachComment: This document corresponds to the accepted manuscript of the referenced journal articl

A Systematic Approach to Constructing Families of Incremental Topology Control Algorithms Using Graph Transformation

In the communication systems domain, constructing and maintaining network topologies via topology control (TC) algorithms is an important cross-cutting research area. Network topologies are usually modeled using attributed graphs whose nodes and edges represent the network nodes and their interconnecting links. A key requirement of TC algorithms is to fulfill certain consistency and optimization properties to ensure a high quality of service. Still, few attempts have been made to constructively integrate these properties into the development process of TC algorithms. Furthermore, even though many TC algorithms share substantial parts (such as structural patterns or tie-breaking strategies), few works constructively leverage these commonalities and differences of TC algorithms systematically. In previous work, we addressed the constructive integration of consistency properties into the development process. We outlined a constructive, model-driven methodology for designing individual TC algorithms. Valid and high-quality topologies are characterized using declarative graph constraints; TC algorithms are specified using programmed graph transformation. We applied a well-known static analysis technique to refine a given TC algorithm in a way that the resulting algorithm preserves the specified graph constraints. In this paper, we extend our constructive methodology by generalizing it to support the specification of families of TC algorithms. To show the feasibility of our approach, we reneging six existing TC algorithms and develop e-kTC, a novel energy-efficient variant of the TC algorithm kTC. Finally, we evaluate a subset of the specified TC algorithms using a new tool integration of the graph transformation tool eMoflon and the Simonstrator network simulation framework.Comment: Corresponds to the accepted manuscrip