Redundancy and subsumption in high-level replacement systems

System verification in the broadest sense deals with those semantic properties that can be decided or deduced by analyzing a syntactical description of the system. Hence, one may consider the notions of redundancy and subsumption in this context as they are known from the area of rule-based systems. A rule is redundant if it can be removed without affecting the semantics of the system; it is subsumed by another rule if each application of the former one can be replaced by an application of the latter one with the same effect. In this paper, redundancy and subsumption are carried over from rule-based systems to high-level replacement systems, which in turn generalize graph and hypergraph grammars. The main results presented in this paper are a characterization of subsumption and a sufficient condition for redundancy, which involves composite productions.Postprint (published version

Net processes correspond to derivation processes in graph grammars

AbstractThe aim of this paper is to compare the running behaviour of Petri nets, given by firing sequences and processes, with derivations and derivation processes in graph grammars. In a first step, Petri nets are simulated by graph grammars so that each firing in a net corresponds exactly to a direct derivation in the simulating graph grammar. In a second step the non-sequential behaviour of nets described by net processes is related to the non-sequential behaviour of graph grammars given by derivation processes. a one-to-one correppondence can be established between the processes on a Petri net and the complete conflict-free processes in the graph grammar simulating the net. This adds a new piece of evidence substantiating the close relationship between net and graph grammar theory

Graph Tuple Transformation

Graph transformation units are rule-based devices to model and compute relations between initial and terminal graphs. In this paper, they are generalized to graph tuple transformation units that allow one to combine different kinds of graphs into tuples and to process the component graphs simultaneously and interrelated with each other. Moreover, one may choose some of the working components as inputs and some as outputs such that a graph tuple transformation unit computes a relation between input and output tuples of potentially different kinds of graphs rather than a binary relation on a single kind of graphs

Correctness of horizontal and vertical composition for implementation concepts based on constructors and abstractor

Sin resume

Correctness of horizontal and vertical composition for implementation concepts based on constructors and abstractor

Sin resume

Stepping from Graph Transformation Units to Model Transformation Units

Graph transformation units are rule-based entities that allow to transform source graphs into target graphs via sets of graph transformation rules according to a control condition. The graphs and rules are taken from an underlying graph transformation approach. Graph transformation units specify model transformations whenever the transformed graphs represent models. This paper is based on the observation that in general models are not always suitably represented as single graphs, but they may be specified as the composition of a variety of different formal structures such as sets, tuples, graphs, etc., which should be transformed by compositions of different types of rules and operations instead of single graph transformation rules. Consequently, in this paper, graph transformation units are generalized to model transformation units that allow to transform such kind of composed models in a rule-based and controlled way. Moreover, two compositions of model transformation units are presented

GRACE as a unifying approach to graph-transformation-based specification1 1This work was partially supported by the ESPRIT Working Group Applications of Graph Transformation (APPLIGRAPH) and the EC TMR Network GETGRATS (General Theory of Graph Transformation Systems).

AbstractIn this paper, we sketch some basic ideas and features of the graph-transformation-based specification language GRACE. The aim of GRACE is to support the modeling of a wide spectrum of graph and graphical processes in a structured and uniform way including visualization and verification

Parameter passing in algebraic specification languages

AbstractIn this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied (matrix(int)) or a nested (bintree(string())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration