Graph Grammar

We verify a mutual exclusion protocol with dynamic process creation based on token passing. The protocol is specified using objectbased graph grammars. We introduce the protocol and show how the mutual exclusion property and other properties can be verified using the tool Augur, a verification tool for graph transformation systems based on an approximated unfolding technique.

Models which combine the abstract (eg, physiological) function of a plant with its architecture have more and more come into the focus of international research in recent years. In the wake of this development, an entirely new class of models has arisen, generally known as ...

UML is considered as the standard for object-oriented modelling language adopted by the Object Management Group. However, UML has been criticized due to the lack of formal semantics and the ambiguity of its models. In other hands, UML models can be mathematically verified and checked by using its equivalent formal representation. So, in this paper, we propose an approach and a tool based on graph transformation to perform an automatic mapping for verification purposes. This transformation aims to bridge the gap between informal and formal notations and allows a formal verification of concurrent UML models using Maude language. We consider both static (Class Diagram) and dynamic (StateChart and Communication Diagrams) features of concurrent object-oriented system. Then, we use Maude LTL Model Checker to verify the formal model obtained (Automatic Code Generation Maude). The meta-modelling AToM 3 tool is used. A case study is presented to illustrate our approach.

The paper is a further development of the ideas sketched in our previous study on Shape Grammars for space architecture. The composition of new shapes from a set of generic elements is extended to two and three dimensions. A number of specific problems arise with this venture. Originally, generative Grammars were developed as a string rewriting procedure, i.e., they operate in one dimension. We have chosen to develop our extension on the basis of Graph Grammars, invented in the early 1970s to generalize Chomsky string grammars. The main idea is to extend concatenation of strings to a "gluing" of graphs along a common substructure. We have not found a previous usage of Graph Grammars formalism in the development of the Shape Grammars paradigm. Graph Grammars are used in our framework to generate the topology of a spatial skeleton consisting of axes and nodes. Since topology itself is not enough to define a particular shape, certain metrics must be applied. By an appropriate point-group symmetry operation on axes connected with certain nodes, axes directions will be defined. There are fairly strict packing conditions for realistic space modules that need to be met. Once the skeleton is constructed, the procedure may continue by generating "strings of shapes" along of its axes (edges). Parametric rules are used to implement the spatial and physical constraints as regards the membrane theory with thin shells.

An imple­ment­a­tion of a shape gram­mar inter­preter is described. The under­ly­ing graph-theoretic frame­work is briefly dis­cussed to show how altern­at­ive rep­res­ent­a­tions from graph the­ory includ­ing graphs, over­com­plete graphs and hyperedge graphs can sup­port some of the intu­itions handled in shape gram­mars by dir­ect visual com­pu­ta­tions with shapes. The res­ult­ing plu­gin imple­men­ted in Rhino, code-named GRAPE, is briefly described in the end.

The final user interface of an information system could be reverse engineered according to a Model-Driven Engineering perspective to multiple levels of abstraction, either independently of each other or simultaneously depending on the designer's goals: concrete user interface (which is independent of the user interface toolkit), abstract user interface (which is independent of any interaction modality), and "task and concepts" (which is independent of any particular implementation). To support the user interface reverse engineering from the code level to any model level, a set of derivation rules have been implemented in Re-versiXML. To support the user interface reverse engineering from any model to any other level, graph grammars have been implemented in TransformiXML. A graph grammar consists of graph transformation rules, called productions, that accept as input a graph representation of the user interface to be reengineered, apply the transformation, and obtain a result that can be further exploited to re-create a new user interface.

In many physical statistical, biological and other investigations it is desirable to approximate a system of points by objects of lower dimension and/or complexity. For this purpose, Karl Pearson invented principal component analysis in 1901 and found 'lines and planes of closest fit to system of points'. The famous k-means algorithm solves the approximation problem too, but by finite sets instead of lines and planes. This chapter gives a brief practical introduction into the methods of construction of general principal objects, i.e. objects embedded in the 'middle' of the multidimensional data set. As a basis, the unifying framework of mean squared distance approximation of finite datasets is selected. Principal graphs and manifolds are constructed as generalisations of principal components and k-means principal points. For this purpose, the family of expectation/maximisation algorithms with nearest generalisations is presented. Construction of principal graphs with controlled complexity is based on the graph grammar approach.

Modeling molecules as undirected graphs and chemical reactions as graph rewriting operations is a natural and convenient approach to modeling chemistry. Graph grammar rules are most naturally employed to model elementary reactions like merging, splitting, and isomerisation of molecules. In this paper a generic approach for composing graph grammar rules to define a chemically useful rule compositions. We iteratively apply these rule compositions to elementary transformations in order to automatically infer complex transformation patterns.

Shape Types Pascal Pradet and Daniel Le Métayer Irisa/Inria Campus de Beaulieu, 35042 Rennes, France [fradet,leaetayer]Oirisa.fr Abstract Type systems currently available for imperative languages are too weak to detect a significant class of programming errors. For example, ...

This paper presents the combined use of meta-modelling and graph grammars for the generation of visual modelling tools for simulation formalisms. In meta-modelling, formalisms are described at a meta-level. This information is used by a meta-model processor to generate modelling tools for the described formalisms. We combine meta-modelling with graph grammars to extend the model manipulation capabilities of the generated modelling tools: edit, simulate, transform into another formalism, optimize and generate code. We store all (meta-)models as graphs, and thus, express model manipulations as graph grammars. We present the design and implementation of these concepts in AToM3 (A_To_ol for M_ulti-formalism, M_eta-M_odelling). AToM3 supports modelling of complex systems using different formalisms, all meta-modelled in their own right. Models in different formalisms may be transformed into a single common formalism for further processing. These transformations are specified by graph grammars. Mosterman and Vangheluwe [18] introduced the term multi-paradigm modelling to denote the combination of multiple formalisms, multiple abstraction levels, and meta-modelling. As an example of multi-paradigm modelling we present a meta-model for the Object-Oriented Continuous Simulation Language OOCSMP, in which we combine ideas from UML class diagrams (to express the OOCSMP model structure), Causal Block Diagrams (CBDs), and Statecharts (to specify the methods of the OOCSMP classes). A graph grammar is able to generate OOCSMP code, and then a compiler for this language (C-OOL) generates Java applets for the simulation execution.

Visualizing and simulating the behavior of formal models in an adequate and flexible way becomes increasingly important in the design of complex systems. With GenGED, a tool is available which automatically generates a visual environment to process (create, edit, check, simulate) visual models in a specified formalism (a visual language). Both the specification of the formalism and the model manipulation are based on graph grammars. In this paper we present the means to transform a formal model into different application domain oriented views (scenario views). We show how the behavior of the model is transferred to the views and animated there (i.e. simulated in the layout of the application domain). Possible extensions towards animation modules (animated scenario views defined by GenGED that are accessible from other tools) are discussed.

Models and model transformations are the core concepts of OMG's MDA T M approach. Within this approach, most models are derived from the MOF and have a graph-based nature. In contrast, most of the current model transformations are specified textually. To enable a graphical specification of model transformation rules, this paper proposes to use triple graph grammars as declarative specification formalism. These triple graph grammars can be specified within the FUJABA tool and we argue that these rules can be more easily specified and they become more understandable and maintainable. To show the practicability of our approach, we present how to generate Tefkat rules from triple graph grammar rules, which helps to integrate triple graph grammars with a state of a art model transformation tool and shows the expressiveness of the concept.

A computational approach for the automated graph representation and diagrammatic notation of all underlying symmetry structures of threedimensional shapes with a center of symmetry is briefly presented and some applications with shape grammars to illustrate these ideas are discussed in the end.

The impact of the web as source of information and services is growing continuously and consequently the importance of appropriate design of algorithms for the web has increased. Such algorithms depend both on the web structure and how it evolves over time. The webgraph is formed by the link structure of webpages. It is well known that this graph is

Graph-like data structures and rule-based systems play an important role within many branches of computer science. Nevertheless, their symbiosis in the form of graph rewriting systems or graph grammars are not yet popular among software engineers. This is a consequence of the fact that graph grammar tools were not available until recently and of the lack of knowledge about how to use graph grammars for software development purposes. "Graph grammar engineering'' is a first attempt to establish a new graph and rule centered methodology for the development of information system components. Having its roots in the late 80's it gradually evolved from a "paper and pencil'' specification formalism to a tool-assisted specification and rapid prototyping approach.

An implementation of the Palladian grammar using a graph grammar and a graph to shape mapping is presented. The application is embedded in a parametric CAD environment and allows the exploration of Palladian villas by hand or by using a random generator.

The software is available from the authors.

DIEGO module systems o er means for DIstributed programming with Encapsulated Graph Objects. Their operational semantics de nition follows the lines of distributed graph transformation, thereby permitting the speci cation of distributed systems with concurrently interacting objects. Adapting previously made proposals for a graph grammar module concept and for graph models with information hiding to this setting, the new approach supports structuring of large speci cations into small reusable modules with well-de ned interfaces between them. Use relations between export interfaces and import interfaces are our means to construct system architectures and to allow reuse of modules in di erent environments.

GENGED is a generic graphical editor supporting the graphical definition of visual languages. Given an alphabet and rules of a specific visual language GENGED generates a syntax-directed graphical editor for this language. GENGED as well as each visual language defined using GENGED is based on algebraic graph grammars. A sentence is given by a graphical structure consisting of a logical (abstract syntax) and a visual level (concrete syntax). Both levels are connected by layout operations. Visual language rules are defined by graph grammar rules. The underlying logical structure, however, is hidden from the user, but it is essential for a formal presentation and manipulation of graphical structures on both levels. The manipulations are performed by a graph transformation machine working on the logical level, whereas a graphical constraint solver manages the layout the user works with.

An implementation of a shape grammar interpreter is described. The underlying graph-theoretic framework is briefly discussed to show how alternative representations from graph theory including graphs, overcomplete graphs and hyperedge graphs can support some of the intuitions handled in shape grammars by direct visual computations with shapes. The resulting plugin implemented in Rhino, code-named GRAPE, is briefly described in the end.

Precedence graph grammars are of major interest in all those applications of graph grammars, where highly efficient parsers are needed. Up to now there are no other graph parsers with the same performance. Due to the fact, that even regular graph grammars with very restricted embedding relations have a NP-complete membership problem, different kinds than Chomsky-like restrictions have to be imposed on graph grammars. We start with contextfree graph grammars and introduce precedence relations. By demanding conflictfreeness, unique invertibility and some further, more technical constraints, precedence graph grammars are introduced with an O(n 2 ) -membership problem, where n ist the number of nodes of the input graph.Precedence graph grammars are unambiguous, which is especially important for semantic evaluation of the derivation trees. In this paper we show, that in spite of all constraints the proposed graph grammar class has interesting generative power, concerning applications in such areas as e.g. dynamic data structures, program graphs, data and control flow graphs and syntactic pattern recognition. For the last topic an error correcting facility incorporated into the precedence graph parser is of special interest. In general inexact graph matching is NP-complete. In this paper we present a method, that increases the time complexity of our parser only by a factor of n. At last, our method is demonstrated with an example from syntactic pattern recognition.

GRAPPA, an implementation of the Palladian grammar, is introduced. Graphs are used for the underlying representation, graph grammars take over the computation. Once a set of graph grammar rules equivalent to the original set of shape rules is defined, derivations, in the form of attributed graphs, are generated. These graphs contain all necessary information to output floor plans of Palladian villas using an appropriate mapping.

UML provides standard abstractions to simplify the documentation, understanding, and maintenance of object oriented complex software systems. UML sequence diagrams are used to describe the behaviors of systems. However, UML is a semi-formal language that lacks tools for analysis and validation of user requirements. In other hand, Petri Nets models are tools for the validation and performance analysis of distributed systems. In this paper we present an approach for transforming UML sequence diagrams to labeled generalized stochastic Petri nets. By this transformation we aim to bridge the gap between the semiformal notation (UML) and the formal notations (Petri nets) for analysis and validation purposes. UML is used for modeling and Petri nets are used for analysis. The approach is based on the combined use of Meta-Modeling and graph grammars. Since the input and the output models are graphs, we use Java based graph transformation to perform this process automatically. The approach is illustrated through an example from e-entrepreneurship domain.

Object-Based Graph Grammars (OBGG) is a formal specification language suitable for modeling concurrent object-based systems. On previous work we have mainly discussed the language along with case studies and analysis techniques (model checking and simulation) for systems described in OBGG. In this paper we present the set of tools we have developed and/or integrated to build an environment for the development of concurrent object-based systems. With this environment, we support the specification and analysis of concurrent object-based systems specified using OBGG.

We present a new, high-level approach for the specification of model-to-model transformations based on declarative patterns. These are (atomic or composite) constraints on triple graphs declaring the allowed or forbidden relationships between source and target models. In this way, a transformation is defined by specifying a set of triple graph constraints that should be satisfied by the result of the transformation. The description of the transformation is then compiled into lower-level operational mechanisms to perform forward or backward transformations, as well as to establish mappings between two existent models. In this paper we study one of such mechanisms based on the generation of operational triple graph grammar rules. Moreover, we exploit deduction techniques at the specification level in order to generate more specialized constraints (preserving the specification semantics) reflecting pattern dependencies, from which additional rules can be derived.

Model-to-model (M2M) transformation consists in transforming models from a source to a target language. Many transformation languages exist, but few of them combine a declarative and relational style with a formal underpinning able to show properties of the transformation. Pattern-based transformation is an algebraic, bidirectional, and relational approach to M2M transformation. Specifications are made of patterns stating the allowed or forbidden relations between source and target models, and then compiled into low level operational mechanisms to perform source-to-target or target-to-source transformations. In this paper, we study the compilation into operational triple graph grammar rules and show: (i) correctness of the compilation of a specification without negative patterns; (ii) termination of the rules, and (iii) completeness, as each generated model from the specification can be built by the rules.

Object-Based Graph Grammar (OBGG) is a formal visual language suited to the specification of asynchronous distributed systems based on message passing. Model-checking of OBGG models is currently supported and a series of case studies have been developed. However, in many situations one has to evaluate non-functional aspects like availability and performance of the system under consideration. In such cases, a stochastic analysis of the system is desired. This paper is a first contribution to the stochastic analysis of OBGG models. OBGG models with occurrence rates associated to rules are translated to Stochastic Automata Networks (SAN). SAN is a Markov Chain equivalent formalism having as advantage its modularity in terms of representation and a compact mathematical solution, allowing the analysis of models with larger state space.

Humans daily infer causal structure from patterns of correlation and learn about categories and hidden properties of objects based on experience and knowledge. A Bayesian approach seems to best model human reasoning over structures, relations and links, and it is possible to provide a detailed computational account of how a number of basic structural forms can be inferred from various types of data (feature sets, similarity matrices, relations). In the literature some algorithms have been proposed that generate candidate model structures from graph grammars, compute the probability of the data given each candidate model, and identify the model with maximum posterior probability given the data. The structural representation, being generated by algorithms comparable to human thinking (according to the cognitive sciences community) should be also easily understandable and usable by analysts for further investigation.

This paper presents the combined use of meta-modelling and graph grammars for the generation of visual modelling tools for simulation formalisms. In meta-modelling, formalisms are described at a meta-level. This information is used by a meta-model processor to generate modelling tools for the described formalisms. We combine meta-modelling with graph grammars to extend the model manipulation capabilities of the generated modelling tools, as we store (meta-)models as graphs, and thus, express model manipulations as graph grammars.

The mapping problem has been defined as any method aimed at mapping models capturing various aspects of an interactive system throughout their development life cycle to support model-based design of user interfaces. This field has followed a long tradition of establishing models and maintaining mappings between them so as to create and maintain accurate specifications of a user interface. In this paper, potential mappings between models are defined so as to create a uniform and integrated framework of adding, removing, and modifying mappings throughout the development life cycle of interactive systems. The mappings can be established from any source model to any target model, one or many, in the same formalism, or from any model element to any other. Those models include task, domain, presentation, dialog, and context of use. The context of use is itself decomposed into user, platform, and environment. To support the manipulation of mappings between models, two examples of supporting software are detailed. TRANSFORMIXML consists of a Java application that triggers transformations of models expressed by graph grammars. IDEALXML consists of a Java application allowing the designer to edit any model at any time, and element of any model and to establish a set of mappings. Both software are based on UsiXML, a User Interface Description Language

In this paper, we introduce contextual hypergraph grammars, which generalize the total contextual string grammars. We study the position of the class of languages generated by contextual hypergraph grammars in comparison with graph languages generated by hyperedge replacement grammars and double-pushout hypergraph grammars. Moreover, several examples show the potential of the new class of grammars.