Multilevel Coupled Model Transformations for Precise and Reusable Definition of Model Behaviour

TL;DR

This paper introduces Multilevel Coupled Model Transformations to enhance the precision and reusability of behavioural semantics in Domain-Specific Languages, leveraging multilevel modelling concepts.

Contribution

It proposes a novel multilevel coupled transformation approach with formal definitions and tools, improving the semantics of behavioural DSLs.

Findings

Enhanced precision in behavioural model semantics

Increased reusability of model transformations

Formal framework and practical tools demonstrated

Abstract

The use of Domain-Specific Languages (DSLs) is a promising field for the development of tools tailored to specific problem spaces, effectively diminishing the complexity of hand-made software. With the goal of making models as precise, simple and reusable as possible, we augment DSLs with concepts from multilevel modelling, where the number of abstraction levels are not limited. This is particularly useful for DSL definitions with behaviour, whose concepts inherently belong to different levels of abstraction. Here, models can represent the state of the modelled system and evolve using model transformations. These transformations can benefit from a multilevel setting, becoming a precise and reusable definition of the semantics for behavioural modelling languages. We present in this paper the concept of Multilevel Coupled Model Transformations, together with examples, formal definitions and tools to assess their conceptual soundness and practical value.

Figures

Equations

$$\in$$

$$\begin{gathered} \begin{array}{rl}{ty}^2(\text{e})& =ty(ty(\text{e}))\\ {df}^2(\text{e})& =df(\text{e})+df(ty(\text{e}))\end{array}\begin{array}{rl}{ty}^3(\text{e})& =ty(ty(ty(\text{e})))\\ {df}^3(\text{e})& ={df}^2(\text{e})+df({ty}^2(\text{e}))\end{array}\begin{array}{r}\dots \\ \dots \\ \end{array} \end{gathered}$$

$$G_i\text{ignorespaces}\text{ignorespaces}\text{ignorespaces}\text{ignorespaces}\text{ignorespaces}$$

$$D({\tau }_{j,i}^{MM})=b_j^{-1}(D({\tau }_{f(j),f(i)}^{TG}))$$

$${\sigma }_j^S;{\tau }_{j,i}^{TG}⪯{\sigma }_i^S\text{for all}0\le i\le j\le m$$

$$({\sigma }_j^S{)}^{-1}(D({\tau }_{j,i}^{TG}))⊑S_i:=D({\sigma }_i^S)$$

$$({\sigma }_j^S{)}^{-1}(D({\tau }_{j,i}^{TG}))=S_j\cap S_i=D({\sigma }_j^S)\cap D({\sigma }_i^S)\text{for all}0\le i\le j\le m$$

$$\mathcal{S}$$

$$S_0=S$$

$$S_{f(i)}$$

$$D_j:=\{\begin{array}{ll}{D}_j& \text{if j∈f([n])}\\ S_j& \text{if j∈[m]∖f([n])}\end{array}$$

$$s_j:=\{\begin{array}{ll}{s}_j:S_j\hookrightarrow D_j& \text{if j∈f([n])}\\ i{d}_{S_j}:S_j\to D_j=S_j& \text{if j∈[m]∖f([n])}\end{array}$$

Full text

††journal: Journal of Logical and Algebraic Methods in Programming

1 Introduction

Model-driven software engineering (MDSE) is one of the emergent responses from the scientific and industrial communities to tackle the increasing complexity of software systems. MDSE utilises abstractions for modelling different aspects of software systems, and treats models as first-class entities in all phases of software development. There are quite a few studies which support gains in quality, performance, effectiveness, etc. as a result of using MDSE (see, e.g., [1, 2, 3, 4, 5]). However, using modelling to understand a domain, making the right abstractions, and including all the stakeholders in the development process, are without doubt the main gains of MDSE [3, 6, 7].

According to empiric evaluations related to the status and practice of MDSE, the state-of-the-art modelling techniques and tools do a poor job in supporting software development activities [2]. There is basically no consensus on modelling languages or tools — MDSE-developers have reported more than 40 modelling languages and 100 tools as “regularly used” [8]. Moreover, a recent study [9, 10] found that software designers either did not use the Unified Modelling Language (UML) [11] at all or used it only selectively and informally. The main issue here is that most modelling approaches are developed without an appreciation for how people and organisations work [2].

One way to increase the adoption of MDSE in practise is to develop modelling approaches which reflect the way software architects, developers and designers, as well as organisations, domain experts and stakeholders, handle abstraction and problem-solving. We believe that domain-specific (meta)modelling (DSMM) [12, 13, 7, 14] is an approach that could unite software modelling and abstraction, software design and architecture, and organisational studies. This would help in filling the gap between these fields which “could solve all kinds of problems and make modelling even more widely applicable than it currently is” [2].

Domain-specific metamodelling is the art of creating and using languages which are specifically tailored for a particular domain [12, 15]. In this case, the concept of “domain” corresponds to both real-life (problem) domains — such as banking, accounting, robotics, home automation, cyber-physical systems, healthcare, product line systems, education, etc. — and technical (solution) domains — such as SQL, HTML, SysML, Petri Nets, Modelica, etc. — (see Figure 1). The idea of DSMM is already practised in industry and academia and its positive results are documented in the literature [2, 3, 4]. However, mainstream approaches to DSMM and design and implementation of domain-specific languages (DSL), such as the Eclipse Modelling Framework [16], the Unified Modelling Language, MetaCase [17], etc., are based on two-level (meta)modelling approaches. That is, domain concepts are defined in metamodels, and they are instantiated in models which conform to these metamodels. This also includes the usage of “profiles” or “stereotypes”. Provided that in the real-life domains the way of thinking is not limited to a certain number of abstraction levels, approaches which force designers to adapt their way of thinking are deemed to fail. Furthermore, describing software domains only in terms of models and their instances usually leads to unnecessary complexity and synthetic type-instance relations [18]. In this work, we propose an alternative approach based on multilevel modelling (MLM) for DSMM, so that the number of abstraction levels are not limited.

MLM is already a recognised research area with clear advantages in several scenarios [19, 20]. However, it has several challenges that hamper its wide-range adoption, such as lack of a clear consensus on fundamental concepts of the paradigm, which has in turn led to lack of common focus in current multilevel tools [21, 22]. We tackle these challenges by combining the best of the worlds of two-level and multilevel (meta)modelling approaches [23]. In our approach, each metamodel is a graph, and they are organised in a hierarchy representing natural abstraction levels. Then, we define the advanced yet flexible relations between these graphs so that a (meta)model can be used to define concepts which are instantiated (and hence reused) on any lower levels in the hierarchy. This is already a well-known technique in MLM, called deep characterisation, and is usually achieved by means of the so-called potency. In this paper, we also revise the syntax and semantics of potency and use it in an advanced yet flexible manner. We also provide a sound formal foundation for the approach based on graph transformations and category theory.

DSLs have already been used for the definition of both system’s structure and behaviour [24, 25]. Modelling structure has advanced due to mature tools and frameworks, and it is normally defined by a metamodel that determines the language concepts, the relationships between them, and the appropriate well-formedness constraints. However, although understanding the behaviour of these models is required to understand the behaviour of the derived software systems, there is no clear consensus in the MDSE community when it comes to the specification of DSL behaviour. Some approaches propose the use of UML behavioural models to represent system dynamics, such as in [26, 27, 28]; others make use of Abstract State Machines for the same purpose, like in [29, 30]; and several authors define their own language to represent the behaviour of metamodels, such as the Kermeta language [31]. Nevertheless, we argue that in MDSE, where DSLs and model transformations are the key artifacts, model transformations are the natural way to specify behaviour. In particular, model transformation languages that support in-place update are very good candidates for the job [32, 33].

Understanding the behaviour of these models is required to understand the behaviour of the derived software systems. However, there are several challenges regarding DSLs’ behaviour, most of them related to the definition of their semantics. Several approaches have been proposed for the definition and simulation of behavioural models based on model transformations (see, e.g., [34, 35, 36, 37, 38, 39]). Although these approaches provide a very intuitive way to specify behavioural semantics, close to the language of the domain expert [40], all of them rely on two-level modelling, which does not allow associating such behaviour to the right level of abstraction.

Many DSLs’ metamodels and behaviours share significant commonalities, and hence being able to reuse model transformations across these DSLs would mean a significant gain. Nevertheless, existing reusable model transformation approaches focus on traditional two-level modelling hierarchies (see, e.g., [41, 42, 43, 44, 45], or [46, 47] for a survey). This happens despite the fact that modelling behaviour is inherently multilevel since the behavioural modelling language is defined by metamodel while the semantics is described two levels below the metamodel [12, 48, 49]. The cause is that behaviour is reflected in the running instances of the models which in turn conform to their metamodel (see Figure 2). Hence, MLM hierarchies could be used for DSMM, i.e., for the flexible organization of metamodelling languages, models and their running instances [12]. Unfortunately, multilevel model transformations [50, 51, 52] are relatively new and have not yet been proven suitable for both reuse and definition of behavioural models. Writing a multilevel rule which refers to types on a higher level of abstraction will provide for higher degree of reusability and genericness, but the “jump” over the intermediate levels would lead to insufficient precision in the rules, which in turn might lead to too generic rules which would apply in undesired situations.

To achieve reusable multilevel model transformations, we propose the use of Multilevel Coupled Model Transformations (MCMTs) for the definition of behaviour: multilevel to support the inherent multilevelness of domains and achieve reusability by genericness, and coupled to support precision in rule definition and avoid repetition of very similar rules. Hence, by utilising MLM for DSMM we could exploit commonalities among DSLs through abstraction, genericness and definition of behaviour by reusable model transformations.

We will use well-known terminology and constructions from category theory to formalise these multilevel hierarchies and their corresponding MCMTs. By constructing a category for multilevel hierarchies and MCMTs, we are able to build upon the already existing co-span approach from the field of graph transformations [53]. Moreover, it provides a precise semantics and the right intuition on the DSL definitions. This paper’s contributions can be beneficiary for two groups of readers: it could be used by category theory experts as a case-study on applying categorical constructions, in addition, it could be used by model transformation and DSL experts as a tool for the definition of reusable behaviour. The former group of readers may skip Section 5 while the latter group may skip Section 4.

This paper is organised as follows. In Section 2, we present the formal foundations of our modelling framework for building multilevel hierarchies of models, with a running example from the domain of Production Line Systems. In Section 3 the proposed approach of multilevel, coupled model transformations is motivated and presented with the same running example. The formal constructions behind this approach are outlined in Section 4. The tools and algorithms supporting the approach are presented in Section 5. Finally, in Sections 6 and 7 we present some related work, make some concluding remarks, and draw some directions for future work.

2 Multilevel Metamodelling Hierarchies

The building blocks of a modelling framework are models. Our models are represented by means of graphs, organised in a hierarchical manner. In this section, we introduce the kind of graphs used to represent our models, as well as the way to organize them in hierarchies, by means of relations among graphs and the elements — nodes and arrows — that they contain. We use as running example one from the domain of Product Line Systems (PLS), inspired by a common example used in several works for describing DSLs (see, e.g., [54, 38]). Our example hierarchy will progressively be completed in successive diagrams as we introduce the different elements of our proposal. The diagram with the full hierarchy is displayed in Figure 9 (Section 2.6), where we also explain in more detail the concepts defined in the graphs.

2.1 Directed multigraphs

Our multilevel metamodelling approach is based on a flexible typing mechanism. We will consider models abstractly as graphs — specifically, we work with directed multigraphs — represented with a name, usually $G$. These graphs consist of nodes and arrows. A node, in the object-oriented modelling world, represents a class, and an arrow represents a relation between two classes. Hence, an arrow always connects two nodes, and any two nodes can be connected by an arbitrary number of arrows. Arrows with source and target in the same node (loops) are also allowed, and a node can likewise have any number of loops. We will use the word element to refer to both nodes and arrows, and assume that all elements are named and identified by such names. For this reason, the names of any two nodes in the same graph must be different. For the arrows, we allow for equal names as long as the source and target nodes do not match also, in order to be able to differentiate them. Hence, arrows are triples $(s,a,t)$ with $a$ an arrow name and $s$ and $t$ the names of its source and target nodes, respectively. For a given graph $G$, we denote by $G^{N}$ its set of nodes, and by $G^{A}$ its set of arrows. Also, a graph requires two mappings ${\mathit{sc}^{G}:G^{A}\to G^{N}}$ and ${\mathit{tg}^{G}:G^{A}\to G^{N}}$ that assign to each arrow its source and target nodes, respectively. These two morphisms must be total to consider $G$ a valid graph. That is, we can define a graph as a quadruple $G{}={(G^{N},G^{A},\mathit{sc}^{G},\mathit{tg}^{G})}$. Figure 3 shows a graph named hammer_config, which contains two nodes, ghead and c1, represented as yellow squares. The arrow connecting these nodes is labelled with its name, out.

The relations between graphs, like typing and matching, are defined by graph homomorphisms. A homomorphism $\phi$ from graph $G$ to graph $H$ is given by two maps ${\phi^{N}:G^{N}\to H^{N}}$ and ${\phi^{A}:G^{A}\to H^{A}}$ , compatible with the involved source and target maps, respectively.

Since graphs are used as the underlying representation of models, terms graph and model could be used interchangeably in this paper. We will however differentiate by using the former for the definitions in this section, and the latter when discussing examples in the next ones.

2.2 Tree shaped hierarchies, abstraction levels and typing chains

We assume that a graph structure (model) is organized in a tree-shaped hierarchy with a single root graph. Implicit in that assumption is the fact that each graph, except the one at the root, has exactly one parent graph in the hierarchy. Also, we allow for arbitrary finite branching in the tree, so that each graph can have none or arbitrary finite many sibling graphs.

The hierarchy has $l+1$ abstraction levels, where $l$ is the maximal length of paths in the hierarchy tree. Each level in the hierarchy represents a different degree of abstraction. Levels are indexed with increasing integers starting from the uppermost one, with index [math]. Each graph in the hierarchy is placed at some level $i$, where $i$ is the length of the path from the root to the graph. We will use the notation $G_{i}$ to indicate that a graph is placed at level $i$. Level [math] contains, in such a way, just the root $G_{0}$ of the tree.111For implementation reasons, we always use Ecore [55] as root graph at level [math], although we will not fully display it in this section, and will omit it completely in the following ones. For any graph $G_{i}$ we call the unique path $\overline{G_{i}}=[G_{i},G_{i-1},\dots,G_{1},G_{0}]$ from this graph to the root graph of the hierarchy the typing chain of $G_{i}$.

In Figure 4 we show several graphs that constitute a tree-shaped hierarchy, included the one in Figure 3. We can see the graph hammer_config, representing a particular configuration of the elements of some hammer factory, in level $3$, together with another graph stool_config, defining a different configuration for a specific stool-producing plant. These two graphs, although conceptually similar, are independent from each other in the sense that they neither belong to the same branch of the tree nor share their parent graphs — that is, their metamodels. Since we focus in this paper in behavioural modelling languages, the models we define evolve through time, representing the execution of the modelled system. Thus, the purpose of these two models is not just representing a specific plant for producing hammers or stools. They also store, at any particular point in time, the state of the execution of the system. That is, the way machines produce and modify parts in order to manufacture the finished hammers or stools.

2.3 Individual typing

In the hierarchy in Figure 4, the parent graphs of hammer_config and stool_config are located at level $2$, where most of the types for the elements of the previous two graphs are defined. These two parent graphs, hammer_plant and stool_plant, define the types of elements that we can use to create a specific setting of a plant for producing each type of object. Both models share the common parent graph generic_plant, located at level $1$. This language contains basic, abstract concepts for plant configurations, like Machine and Container. Finally, as we previously mentioned, we can see Ecore, the topmost graph and root of the tree, at level [math]. This graph is the parent graph of generic_plant. Note that we use red horizontal lines to indicate the separation between two levels, and blue dashed arrows indicating the sequences of graphs that constitute typing chains and provide the required tree shape. Note also that, since the purpose of this figure is to illustrate the tree shape of the metalevel hierarchies, the contents of both graphs stool_plant and stool_config are not displayed. The diagram with the full hierarchy is displayed in Figure 9.

Any element e in any graph $G_{i}$ has a unique type denoted by $\mathit{ty}(\texttt{e})$. In that case, we can say that e is typed by $\mathit{ty}(\texttt{e})$ or, equivalently, that e is an instance of $\mathit{ty}(\texttt{e})$. Inheritance relations among nodes in the same level are allowed, although they are not used in the examples in this paper. The semantics of this relation are that the information of the parent node (potency and typing) and all its attributes and relations — both incoming and outgoing — are replicated in the child node. That is, if a node x has an inheritance relation to a node y of type Y (i.e. y is a parent node of x), then x must necessarily be typed by Y, and have the same potency, attributes and relations as y. Inheritance relations cannot be established between nodes in different models or be cyclic, neither directly (self-inheritance) or transitively.

To achieve the necessary flexibility, we allow typing to jump over levels. That is, for any e in a graph $G_{i}$, with $i\geq 1$, its individual (or direct) type $\mathit{ty}(\texttt{e})$ is found in a graph $\mathit{TG}(\texttt{e})$, which is one of the graphs $G_{i-1},\dots,G_{1},G_{0}$ in its typing chain. Note that the graphs in which we locate the types of different elements in $G_{i}$ may also be different. By $\mathit{df}(\texttt{e})$ we denote the difference between $i$ and the level where $\mathit{TG}(\texttt{e})$ is located. In most cases, this difference is $1$, meaning that the type of e is located at the level directly above it. In short, we can say that, for any element e in a given graph $G_{i}$, with $i\geq 1$, its type $\mathit{ty}(\texttt{e})$ is an element in the graph $G_{i-\mathit{df}(\texttt{e})}$, where $1\leq\mathit{df}(\texttt{e})\leq i$.

Figure 5 displays our example hierarchy again, including in this case the type of each element. To avoid polluting the diagram with too many arrows, we use alternative representations for them. For every node, its type is identified by name and depicted in a blue ellipse attached to the node. For example, the type of GenHead in hammer_plant is Machine, a relation that could also be represented as an arrow between these two nodes. For the actual arrows that represent relations among nodes in the same level, the type is represented as a second label with the name of the type in italics font. For example, the type of the out arrow in generic_plant is EReference, located in the Ecore graph.

To ensure that every element has a type, we assume that the root graph $G_{0}$ has a self-defining collection of individual typing assignments.222 We use the more relaxed term self-defining instead of reflexive since the former requires all the elements in the graph to be typed by elements in the same graph, whereas the latter requires every element to be strictly typed by itself. That is, instead of requiring that $\mathit{ty}(\texttt{e})=\texttt{e}$ for all $\texttt{e}\in G_{0}$, we just need to ensure that if $\texttt{e}\in G_{0}$ then $\mathit{ty}(\texttt{e})\in G_{0}$.

Possible candidates for the root graph $G_{0}$ are, for instance, Ecore — the one we chose — and the node-and-arrow graph described in [56].

From a more general point of view, we obtain for any e in $G_{i}$ a sequence

[TABLE]

of typing assignments of length $1\leq s_{\texttt{e}}\leq{i}$ with $(i-{\mathit{df}^{s_{\texttt{e}}}(\texttt{e})})=0$. The number $s_{\texttt{e}}$ of steps depends individually on the item e. For convenience, we use the following abbreviations:

[TABLE]

We call any of the elements $\mathit{ty}(\texttt{e})$, $\mathit{ty}^{2}(\texttt{e})$, $\mathit{ty}^{3}(\texttt{e})$, …a transitive type of e.

Let us consider an arbitrary arrow $\texttt{x}\xrightarrow{\texttt{f}}\texttt{y}$, together with its source and target nodes in a graph $G_{i}$. The types of the three elements may be located in three different graphs. The typing of arrows should, however, be compatible with the typing of sources and targets, that is, the source and the target of an arrow $\mathit{ty}(\texttt{f})\in G_{i-\mathit{df}(\texttt{f})}$ must be provided by the types of x and y, respectively:

[TABLE]

More precisely, we require that this non-dangling typing condition is satisfied: There exist $1\leq m_{\texttt{x}}\leq s_{\texttt{x}}$ and $1\leq m_{\texttt{y}}\leq s_{\texttt{y}}$ such that $\mathit{df}^{m_{\texttt{x}}}(\texttt{x})=\mathit{df}^{m_{\texttt{y}}}(\texttt{y})=\mathit{df}(\texttt{f})$, $\mathit{ty}^{m_{\texttt{x}}}(\texttt{x})$ is the source of $\mathit{ty}(\texttt{f})$, and $\mathit{ty}^{m_{\texttt{y}}}(\texttt{y})$ is the target of $\mathit{ty}(\texttt{f})$.

2.4 Typing morphisms and domains of definition

Our notions of flexible multilevel typing can be described for graphs, in a more abstract and compact way, by means of a family of typing morphisms. That is, we can define typing relations between any two graphs in a typing chain as an abstraction of the individual typing that we defined for their elements in Section 2.3. The vocabulary defined for individual typing can be reused here, so that a graph can be an instance of another graph, or be typed by it. These relations among graphs are defined by means of graph homomorphisms. Since the individual typing maps are allowed to jump over levels, two different elements in the same graph may have their types located in different graphs along the typing chain. Hence, the typing morphisms established between graphs become partial graph homomorphisms [57].

Our characterization of individual typing ensures that, for any levels $i$, $j$ such that $0\leq i<j\leq l$, there is a partial typing morphism \tau_{j,i}:G_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i} given by a subgraph $D(\tau_{j,i})\sqsubseteq G_{j}$, called the domain of definition of $\tau_{j,i}$, and a total typing homomorphism $\tau_{j,i}:D(\tau_{j,i})\to G_{i}$. The domain of definition may be empty — and, consequently, $\tau_{j,i}$ is just the inclusion of the empty graph in $G_{i}$ — in case no $\texttt{e}\in G_{j}$ has a transitive type $\mathit{ty}^{m}(\texttt{e})\in G_{i}$ for some $m\geq 1$. Also, in abuse of notation, we use the same name for both morphisms, since they represent the same typing information. Using the same syntax as the examples, Figure 6 depicts these concepts in a generic manner.

Given that a graph is given by its set of nodes and its set of arrows, we can define the domain of definition component-wise. For any $0\leq i<j\leq l$ we can define the set $D(\tau_{j,i}^{N})\subseteq G_{j}^{N}$ of all nodes in $G_{j}$ that are transitively typed by nodes in $G_{i}$. That is, $\texttt{e}\in D(\tau_{j,i}^{N})$ iff there exists $1\leq m\leq s_{\texttt{e}}$ such that $j-i=\mathit{df}^{m}(\texttt{e})$, and thus $\mathit{ty}^{m}(\texttt{e})\in G_{i}^{N}$. We set $\tau_{j,i}^{N}(\texttt{e}):=\mathit{ty}^{m}(\texttt{e})$ for all nodes in $D(\tau_{j,i}^{N})$ and obtain, in such a way, a map $\tau_{j,i}^{N}:D(\tau_{j,i}^{N})\to G_{i}^{N}$. This total map defines a partial map \tau_{j,i}^{N}:G_{j}^{N}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i}^{N} with the domain of definition $D(\tau_{j,i}^{N})$. This component-wise construction is required to ensure the compatibility between the way that domains of definition are calculated and the individual typing.

We can follow an analogous procedure for the set $G^{A}$ to obtain a partial map \tau_{j,i}^{A}:G_{j}^{A}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i}^{A} with domain of definition $D(\tau_{j,i}^{A})$.

The non-dangling typing condition is now equivalent to the requirement that the pair $(D(\tau_{j,i}^{N}),D(\tau_{j,i}^{A}))$, constitutes a subgraph $D(\tau_{j,i})$ of $G_{j}$. That is, for any arrow $\texttt{e}\in D(\tau_{j,i}^{A})$ we have $\mathit{sc}^{G_{j}}(\texttt{e}),\mathit{tg}^{G_{j}}(\texttt{e})\in D(\tau_{j,i}^{N})$. Consequently, the pair of morphisms $(\tau_{j,i}^{N},\tau_{j,i}^{A})$ provides a total graph homomorphism ${\tau_{j,i}:D(\tau_{j,i})\to G_{i}}$ and thus a partial typing morphism \tau_{j,i}:G_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i}.

All the typing morphisms \tau_{j,0}:G_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{0} are total, since every element has a type. The uniqueness of typing is reflected on the abstraction level of type morphisms by the uniqueness condition: For all $0\leq i<j<k\leq l$, we have that $\tau_{k,j};\tau_{j,i}\preceq\tau_{k,i}$, i.e., $D(\tau_{k,j};\tau_{j,i})\sqsubseteq D(\tau_{k,i})$ and, moreover, $\tau_{k,j};\tau_{j,i}$ and $\tau_{k,i}$ coincide on $D(\tau_{k,j};\tau_{j,i})$. Note, that the domain of definition of the composition $D(\tau_{k,j};\tau_{j,i})$ is obtained by a pullback (inverse image) (see Definition 1 in Section 4.1). Informally, the uniqueness condition means whenever an element in $G_{k}$ is transitively typed by an element in $G_{j}$ such that this element in $G_{j}$ is, in turn, transitively typed by an element in $G_{i}$ then the element in $G_{k}$ is also transitively typed by an element in $G_{i}$ and both ways provide the same type in $G_{i}$.

The other way around, we can reconstruct individual typings from a family of partial typing morphisms between graphs that satisfy the totality and uniqueness conditions. For any item e in a graph $G_{k}$ there exists a maximal (least abstract) level $0\leq i_{\texttt{e}}<k$ such that e is in $D(\tau_{k,i_{\texttt{e}}})$ but not in $D(\tau_{k,j})$ for all ${i_{\texttt{e}}}<j<k$, since $\tau_{j,0}$ is total and $k$ a finite number. Hence, the individual type of e is given by $\mathit{ty}(\texttt{e}):=\tau_{k,i_{\texttt{e}}}(\texttt{e})$ and $\mathit{df}(\texttt{e}):=k-i_{\texttt{e}}$.

Figure 7 depicts the typing morphisms between all the graphs in the hierarchy. Note that the morphism from generic_plant to Ecore is total, since all the types used in the former can only be defined in the latter, and all elements must have a type.

2.5 Potency

In this subsection, we introduce our modification and formalisation of the concept of potency of an element originally defined in [58]. Potencies are used on elements as a means of restricting the length of the jumps of their typing morphisms across several levels. The reason for this is that the formalisation presented so far is aimed at classifying graphs in tree-shaped hierarchies as a means to get a clear structure of the concepts defined, but the hierarchy is built based on the individual typing relations, which do not have any restrictions regarding levels. Due to this fact, levels become less useful in practice if the individual typing relations are unbounded, hence the necessity of potencies to restrict the jumps of typing across levels. This concept is therefore designed to allow designers to properly constrain how nodes and arrows are instantiated in a more detailed way, but it is not required to ensure the correct typing of nodes or the typing compatibility of arrows.

We represent the potency of an element with an interval, using the notation min-max. These values may appear after the declaration of an element using @ as a separator. More precisely, for any element x in $G_{i}$ we require $min\leq\mathit{df}(\texttt{x})\leq max$ where $\mathit{ty}(\texttt{x})$@min-max is the declared potency of the type $\mathit{ty}(\texttt{x})$ in $G_{i-\mathit{df}(\texttt{x})}$. This condition can be reformulated using partial typing morphisms. For any element y in $G_{j}$ with a potency declaration y@min-max we require that $\tau_{j,i}^{-1}(\texttt{y})$ is empty for all $j$ with $j-i<\texttt{min}$ or $j-i>\texttt{max}$. In the cases where $\texttt{min}=\texttt{max}$, the notation can be simplified to show just one number. Such is the case with the default value of potency: $\texttt{@1-1}\equiv\texttt{@1}$.

For the typing relations used in our example to be correct, we require the arrow out in generic_plant to have increased potency. That way, it becomes possible to use it as type for the other out arrow, located two levels below, in the hammer_config graph. Besides, and to ease the interpretation of a diagram, the type of an element which is specified in a level different from the one immediately above uses the @ notation to indicate it. For nodes, the annotation is located in the blue ellipse. For arrows, the ty(e)@$\mathit{df}(\texttt{e})$ annotation is displayed in the declaration of the type (in italics). Figure 8 shows a new version of the example hierarchy which includes potencies.

Unlike other approaches, our realization makes the declared potency of an element independent of the potency of its type. For example, the default value of the potency of the arrow out in hammer_config could be changed to some other one without being affected by the potency @1-2 of its type arrow (out in generic_plant).

2.6 PLS multilevel hierarchy

The full version of the PLS hierarchy is shown in Figure 9. This figure has been generated from the real implementation of the PLS multilevel hierarchy created with the tool MultEcore (see Section 5). For this reason, there is an addition to the syntax used so far: The multiplicity of arrows is now displayed in those cases where it is different from its default value 0..n.

The hierarchy displays a top model, called generic_plant (Figure 9a), where we define abstract concepts related to product lines that manufacture physical objects. Machine defines any device that can create, modify or combine objects, which are represented by the concept Part. In the first case, we indicate the relation from a generator-like machine to the part it generates with the creates relation. In order for parts to be transported between machines or to be stored, they can be inside Containers, and this relation is expressed by the contains relation. All machines may have containers to take parts from or to leave manufactured ones in. These two relations are identified with the in and out relations, respectively.

The second level of the hierarchy contains two models, that define concepts related to specific types of plants. In Figure 9b we can find hammer_plant, where the final product Hammer is created by combining one Handle and one Head. Both hasHandle and hasHead relations express this fact, and their 1..1 multiplicity states that a Hammer must be created out of exactly one Head and one Handle. The type of these two relations is EReference (from Ecore), since there is no relation defined for parts in generic_plant, because the concept of assembling parts is too specific to be located in generic_plant. Note that thanks to the use of potency, we can define hasHandle and hasHead without forcing Part to have a relation with itself in generic_plant in order to use it as their type: It is not desirable that a specific detail in a lower level (hammer_plant) affects the specification of an upper one (generic_plant). In the hammer_plant model we also define three types of machines. First, GenHandle and GenHead, that create the corresponding parts, indicated by the two creates arrows. And secondly, Assembler, that generates hammers by assembling the corresponding parts. Finally, the model contains two specific instances of Container, namely Conveyor and Tray. The cout arrow between them indicates that a Conveyor must always be connected to a Tray. As explained before, this relation can be defined without requiring a loop arrow in Container, thanks to the use of potency, satisfying the separation in levels of abstraction.

The other model in the second level, depicted in Figure 9c, contains another specification of a manufacturing plant, in this case for stools. In this model, the relations between Stool, Leg and Seat resembles those of Hammer, Handle and Head. The multiplicity of the arrow between the first two indicates that a Stool must have exactly three Legs. Two different types of machine, GenLeg and GenSeat, manufacture Legs and Seats, respectively. The remaining one, Gluer, takes three Legs and a Seat and creates a Stool out of them. Finally, the only container defined for this kind of plant is Box.

The two models at the bottom of the hierarchy, in Figures 9d and 9e, represent specific configurations of a hammer PLS (hammer_config) and a stool PLS (stool_config). They contain specific instances of the concepts defined in the level above, organized to specify correct product lines, in which parts get transferred from generator machines to machines that combine them to obtain the final manufactured products. Note that, again, the use of potencies enables the creation of instances of the out relation defined two levels above between Machine and Container, without requiring a type defined in the intermediate level of hammer_plant and stool_plant.

3 Multilevel Coupled Model Transformations for the Definition of Behaviour

To enable the integration of MLM in MDSE projects, model-to-model transformations are key. In the literature, we find notions such as multilevel to two-level model transformations [51], deep transformations — defined at a specific level but with references to upper levels — [12], or coupled transformations — that operate on a model and its metalevels simultaneously [59, 12, 49]. In this section, we propose a generic way of specifying multilevel transformations, operating on models that belong to a multilevel hierarchy. We focus on in-place transformations, and specifically use them to define the behaviour of DSLs.

Indeed, the formal, flexible MLM approach introduced so far also opens a door for the reusability of model’s behaviour. Since most behavioural models have some commonalities both in concepts and their semantics, reusing these model transformations across behavioural models would mean a significant gain. By utilising MLM in a metamodelling process for the definition of modelling languages, we can exploit commonalities among these languages through abstraction, genericness and reusability of behaviour. We will build on our running example from the PLS domain to explain our approach to reusable model transformations, namely, multilevel coupled model transformations (MCMTs). We will also compare MCMTs to other well-known approaches so that the advantages become clearer.

3.1 Why using MCMTs?

Recall the PLS hierarchy above, and assume we want to define the behaviour of the machines that generate parts. Instances of Machine are related by the creates relation with instances of Part. Using model transformations, we have now three options to define the rule for the action of creating a part, namely, traditional two-level model transformation rules, multilevel rules, and our multilevel coupled model transformations. For the display of the example rules in the following, we use a declarative way of specifying transformation rules, and we do this using the same graphical syntax for nodes, arrows, types and potencies that we used in Section 2.

3.1.1 Traditional two-level model transformation rules

Using two-level transformation rules for the creation of parts on instances of hammer_plant (Figure 9b), we would need to specify two rules, one for each generator. That is, one for GenHandle (Figure 11) and one for GenHead (Figure 11). If we wanted to do the same for the stool plant (Figure 9c), we would need two more rules.

Following the declarative specification of transformation rules, the rules consist of FROM and TO blocks. The FROM block contains the pattern that the rule must match in order to be executed. If a match is found, then the matched subgraph is modified in the way defined in the TO block, which may comprise the creation, deletion or modification of nodes and arrows.

While this might do the job for one language, problems arise regarding reusability. The rules would be too specific and tied to the types GenHandle, GenHead, Handle and Head, and the creation of further parts in this or other languages would require additional specific rules. As a consequence, a significant number of very similar rules are required, leading to the proliferation problem: each machine would need a rule and each hierarchy would need its set of almost identical rules.

The basic structure of these rules is outlined in Figure 12. In its most general terms, a graph transformation rule is defined as a left $L$ and a right $R$ pattern. These patterns are graphs which are mapped to each other via graph morphisms $l,r$ from or into a third graph $I$, such that $L,R,I$ constitute either a span or a co-span, respectively [33, 53, 60]. In this paper we use the co-span version, which facilitates the manipulation of model elements without the two phases of delete-then-add. This same construction will be reused for the next two alternatives.

In order to apply a rule to a source graph $S$, first a match of the left pattern must be found in $S$, i.e., a graph homomorphism $m:L\rightarrow S$. Then, using a pushout construction, followed by a pullback complement construction, will create a target graph $T$. Details of application conditions and theoretical results on graph transformations can be found in [33]. We omit in our sample rules the details introduced by graph $I$.

In typed transformation rules, the calculation of matches needs to fulfil a typing condition: In the construction in Figure 12, all the triangles must be commutative. In other words, since both the rules and the models are typed by the same type graph, the rules are defined at the type graph level and are applied to typed graphs.

3.1.2 Multilevel Rules

Multilevel rules, also known as deep rules (see, e.g., [12]), enable us to specify a common behaviour at upper levels of abstraction. The creation of parts in our PLS example may be specified using multilevel rules by a single rule, operating on the more abstract types Machine and Part as displayed in Figure 13. Thus, this rule can be applied to GenHandle and GenHead in the hammer plant (Figure 9b) as well as to GenLeg and GenSeat generators in the stool plant (Figure 9c).

While multilevel model transformations solve some problems, it introduces a new issue related to case distinction. That is, the approach works fine in cases where the model on which the rules are applied — usually a running instance — contains the structure that is required by the rule, and, when all types required by the rule exist in the same metalevel. If not, the rules will only be able to express behaviour in a generic way, but they will not be precise enough. In other words, the rules become too generic and imprecise: all machines will create parts (even machines which should not be creating parts), all parts can be created directly (even those which should be derived from others), and any machine can create any part. For example, GenHead may create Hammer, and GenHandle may create a Head.

The general structure of multilevel transformation rules is shown in Figure 14. This could be considered as a method to relax the strictness of two-level model transformations through multilevel model transformations (see, e.g., [51, 50]). To achieve flexibility, the rules could be defined over a type graph somewhere at a higher level in the hierarchy and applied to running instances at the bottom of the hierarchy (see Figure 14). Types will be resolved by composing typing graph homomorphisms from the model on which the rule is applied and upwards to the level where of the type graph.

3.1.3 Multilevel Coupled Model Transformation Rules

We propose Multilevel Coupled Model Transformation (MCMT) rules, as a means to overcome the issues of the two aforementioned approaches. Using MCMTs, the rule CreatePart can be specified as shown in Figure 15. We introduce a new component into the rules, namely the META block. This new part of the rule allows us to locate types in any level of the hierarchy that can then be used in the FROM and TO blocks. Moreover, the real expressive power from this new block comes from the fact that we can define a whole pattern that these types must satisfy in order for the rule to be applied. This feature allows us to create case distinctions in the rules easily, allowing for a finer tuning of the rules that prevents the aforementioned side effects. This version of CreatePart can be applied on any PLS typed by Generic Plant, since the variable P1 could match any of the parts — Head, Handle, Seat or Leg — and the variable M1 could match any of the creator machines — GenHead, GenHandle, GenSeat or GenLeg. However, the important difference is that this rule can only match the generators of parts, since we require M1 in the META block to have a creates relation to the P1.

We find a match of this rule when we find an element which, when coupled together with its type, fits an instance of M1 that has a relation of type creates to an instance of P1. For example, GenHandle in Figure 9b, fits M1, since GenHandle has a creates relation to Handle. Hence, m1 can be matched to ghandle when applying the rule, in order to create a new part (p1), which would be an instance of Handle.

The usage of this new block allows for a finer tuning that other techniques, like inheritance. For example, the possibility of referring to the creates relation between Machine and Part when more abstraction is required, while still being able to instantiate it only in some cases (like GenHead and Head) is a level of granularity cannot be achieved by turning all instances of Machine and Part into subclasses. This would render impossible to retain the abstraction “machines can create parts” while specifying that “generators of heads generate heads” and that “assemblers do not create any part”. Therefore, this alternative would create undesirable side effects.

The META section may include several metamodel levels. The general structure of an MCMT is displayed in Figure 16. The figure can be visualized as two flat trees, each of them defined by typing chains and connected to each other by matching morphisms.

The tree on the left contains the pattern that the user defines in the rule. It consists of the left and right parts of the rule (FROM and TO, respectively), represented as L and R in the diagram, and the interface I that contains the union of both L and R, hence the inclusion morphisms333In all our examples in this paper, the interface I contains the left and right graphs since the morphisms l and r are monomorphisms, but this might not be the general case.. These three graphs are typed by elements in the same typing chain, which is represented as a sequence of metamodels MMx that ends with the root of the hierarchy tree MM0 (Ecore in our case). The multilevel typing arrows from $L,I,R$ to the typing chain $[\textit{MM}_{n},\textit{MM}_{n-1},\dots,\textit{MM}_{1},\textit{MM}_{0}]$ (see Section 4.1) should be compatible with typing (see Section 4.2). That is, both triangles at the bottom must be commutative.

The tree on the right side represents the actual path in the type chain on which the rule is applied. Before applying the rule, we only have the graph S and its multilevel type to the typing chain $[\textit{TG}_{m},\textit{TG}_{m-1},\dots,\textit{TG}_{1},\textit{TG}_{0}]$. In order for the rule to be applied, it is required to find matches of all metamodel graphs MMx into the actual typing chain graphs TGy. These matches do not require to be parallel in the sense that the difference of levels between the two sources of any two matching morphisms is not required to be equal to the difference of levels between the targets of those two morphisms. This is due to the flexibility in the specification of the number of levels that separate two metamodel graphs in the pattern. In terms of our example, if we add more intermediate levels to the PLS hierarchy, and consequently the depth becomes bigger, the defined rules would still be applicable. Moreover, when the rules are defined with a flexible depth, they would fit or match different branches of the hierarchy regardless their depth. That is, the graph representing the pattern could be matched in several different ways to the same hierarchy, hence providing the flexibility that we require.

The match b0 is trivial in the implementation since both MM0 and TG0 are Ecore. If all the metamodel graphs can be matched into the type graphs, such that every resulting square commutes, we proceed to find a match (a graph homomorphism $m$) of the pattern graph L into the instance S. This match must be type compatible, i.e., the types of elements in $L$ which are matched to elements in $S$ must be matched by one of the bindings $b_{x}$ (see Section 4.2). If this match m is successful, i.e., a type compatible graph homomorphism from $L$ to $S$ is found, we construct the intermediate instance D by pushout, and then proceed to generate the target instance T by pullback complement. The necessary formal constructions are introduced in Section 4.

To summarise, while existing approaches which employ reusable model transformations for the definition of behavioural models focus on traditional two-level modelling hierarchies and their affiliated two-level model transformations (see [46, 47] for a survey), multilevel model transformations [50, 51] are relatively new and are not yet proven suitable for reuse and definition of model’s behaviour. Our approach to multilevel model transformation build on top of these original approaches to combine reusability with flexibility in the number of modelling levels. In other words, in the time of defining the rules, the height/depth of the modelling hierarchy (on which we intend to apply the rules) is not important since no matter how deep the hierarchy gets, the rules will still work. It is also important to notice that, so far, we have not identified a scenario in which MCMTs have more expressive power than two-level MTs. That is, one MCMT conveys the same information as an arbitrarily large set of two-level MTs with commonalities, but in a much more concise, reusable and maintainable way, as remarked in Section 7.

3.2 MCMTs for PLS

Using the PLS example, we have already explained the advantages of using MCMTs with respect to reusability and shortly presented a comparison to two-level and multilevel model transformation rules. Here we will show a few MCMTs which together define the behaviour of any plant which directly or indirectly conforms to generic_plant.

The first rule in the PLS example is CreatePart, already shown in Figure 15, which is used to create parts by the corresponding generator machines. Note that, as mentioned above, this rule is not restricted to instances of hammer_plant and it could also be applied to any instance — direct or indirect — of generic_plant.

Another rule used in this example is SendPartOut, shown in Figure 17, used for moving a created part from its generator into the output container of this machine. This rule displays a richer META block than CreatePart, in which we need to identify elements from two different models, separated with a red line, as in the examples in Section 2. Such information was not displayed explicitly in CreatePart since it could be automatically inferred and for the sake of simplicity. At the top level, we mirror part of generic_plant, defining elements like out and contains, that are used directly as types in the FROM and TO blocks, via potency. These elements are defined as constants, meaning that the name of the pattern element must match an element with the same name in the typing chain. The use of constants allows us to be more restrictive when matching, and significantly reduces the amount of matches that we obtain (see Section 5.3).

Once the component parts have reached the right containers, it is possible to combine them to create final products — hammers or stools in our hierarchy. The Assemble rule does exactly that: it assembles two parts into a different part (see Figure 18). It requires the resulting part p3 to be a part that can consist of, or be built from, parts p1 and p2. One particularity of this rule is that the META block defines several instances of the same type, but different from each other. In such a way, we ensure that, for example, P1 is different from P2, but both are instances of Part.

The semantics of matching makes this rule applicable for a variable number of parts which are assembled into one part. To apply this rule we use the cardinality information of relations h1 and h2, as long as the upper bound is different from *. The cardinalities of h1 and h2 in the corresponding model will indicate the number of instances of P1 and P2 that should appear in the FROM block. This information is then used to replicate the instances p1 and p2 accordingly, together with all their related references (co1 and co2, in this case). That is, this rule fits both the Gluer and the Assembler functionalities of the two sample plants (for hammers and stools). For example, this process gives us the semantics that, in order to build an instance of Stool, we require three instances of Leg and one instance of Seat. In case that the cardinalities allow for several values, i.e., the minimum and maximum values are different, one copy of the rule will be generated for each possible value.

Finally, the last rule is used to specify the transfer of the assembled part from the assembler’s output conveyor into a tray. This behaviour is achieved by applying the rule TransferPart displayed in Figure 19.

4 The Category of Graph Chains and Graph Chain Morphisms

We use model transformations to define the behaviour of our MLM hierarchies. Since every branch in our MLM hierarchies is represented by a graph chain, the application of our model transformation rules will rely on pushout and pullback complement constructions in the category $\mathsf{Chain}$. By constructing this category for multilevel hierarchies and MCMTs, we are able build upon the already existing co-span approach to graph transformations [53]. We introduce appropriate definitions for the category $\mathsf{Chain}$in this section.

This formalisation is required since the semantics of model transformations needs to be adapted to our multilevel setting, keeping flexibility of rules in mind. The formalism can be later used as a reference for the expected behaviour of MCMTs, regardless of the mechanism used to implement them (e.g. the proliferation process presented in section 5.2). Detailed descriptions and proofs of the constructions are left out as a technical report [61].

4.1 Multilevel typing

MCMTs are defined as graphs $L,I,R$ which are located at the bottom of a typing chain representing the metamodels in the rule hierarchy. Moreover, the instance graph $S$ on which we apply the MCMTs is also located at the bottom of the typing chain. We call the relation between these graphs and their typing chains multilevel typing. In fact, the relation between each graph $G_{i}$ in a typing chain $\overline{G}$ and the rest of the chain $[G_{i-1}...G_{0}]$ above the graph is a multilevel typing. Further, applying an MCMT will produce the intermediate graph $D$ and the target graph $T$ which have to have a multilevel typing relation to the target typing chain. To be able to use the well-established constructions of pushout and pullback complement in the lowest level graphs $L$, $I$, $R$, $S$, $D$, and $T$, and indeed get the multilevel typing of the constructed graphs, we will define some restrictions on typing chains. First of all, we will generalise the concept of typing chain and formally define the concept “graph chain”. Then, we will define graph chain morphisms and multilevel typing of a graph over a graph chain.

Definition 1** (Graph chain)**

A graph chain $\mathcal{G}:=(\overline{G},{n},{\tau^{G}})$ is given by a natural number $n$, a sequence $\overline{G}=[G_{n}{},G_{n-1},\dots,G_{1}{},G_{0}{}]$ of graphs of length $n+1$ together with a family \tau^{G}=(\tau^{G}_{j,i}:G_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i}\mid 0\leq i<j\leq n) of partial graph homomorphisms where

each partial graph homomorphism \tau^{G}_{j,i}:G_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}G_{i} is given by a subgraph $D(\tau^{G}_{j,i})\sqsubseteq G_{j}$, called the domain of definition of $\tau^{G}_{j,i}$, and a total graph homomorphism $\tau^{G}_{j,i}:D(\tau^{G}_{j,i})\xrightarrow{}G_{i}$,

• 2.

all the morphisms $\tau^{G}_{j,0}:G_{j}\to G_{n}$ with $1\leq j\leq n$ to the top level graph are total, i.e., $D(\tau^{G}_{j,0})=G_{j}$, and

• 3.

for all $0\leq i<j<k\leq n$ the uniqueness condition $\tau^{G}_{k,j};\tau^{G}_{j,i}\preceq\tau^{G}_{k,i}$ is satisfied, i.e., $D(\tau^{G}_{k,j};\tau^{G}_{j,i})\sqsubseteq D(\tau^{G}_{k,i})$ and, moreover, $\tau^{G}_{k,j};\tau^{G}_{j,i}$ and $\tau^{G}_{k,i}$ coincide on $D(\tau^{G}_{k,j};\tau^{G}_{j,i})$. The composition $\tau^{G}_{k,j};\tau^{G}_{j,i}$ is defined by pullback (inverse image) of total graph homomorphisms as follows:

\textstyle{D(\tau^{G}_{k,j};\tau^{G}_{j,i})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\tau^{G}_{k,i}}$$\textstyle{D(\tau^{G}_{k,j})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\tau^{G}_{k,j}}$$\textstyle{PB}$$\textstyle{D(\tau^{G}_{j,i})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\tau^{G}_{j,i}}$$\textstyle{G_{k}}$$\textstyle{G_{j}}$$\textstyle{G_{i}}

That is, $D(\tau^{G}_{k,j};\tau^{G}_{j,i})=(\tau^{G}_{k,j})^{-1}(D(\tau^{G}_{j,i}))$ thus we have $D(\tau^{G}_{k,j};\tau^{G}_{j,i})=D(\tau^{G}_{k,j})$ if $\tau^{G}_{j,i}$ is total, i.e., $G_{j}=D(\tau^{G}_{j,i})$.

Applying an MCMT rule would now require finding a match of the rule, which has three characteristics: (i) a match homomorphism from $L$ to $S$, (ii) a match of the graph chain $\cal{MM}$ into the graph chain $\cal{TG}$, and, (iii) both these matches need to be compatible with respect to multilevel typing. To formalise the intended flexibility of matching MCMT rules, and in order to define matches between graph chains, we define graph chain morphisms.

Definition 2** (Graph chain morphism)**

A morphism $(\phi,f):\mathcal{G}\to\mathcal{H}$ between two graph chains $\mathcal{G}=(\overline{G},{n},{\tau^{G}})$ and $\mathcal{H}=(\overline{H},{m},{\tau^{H}})$ with $n\leq m$ is given by

a function $f:[n]\to[m]$, where $[n]$ $\in\{0,1,2,\ldots,n\}$, such that $f(0)=0$ and $i<j$ implies $f(i)<f(j)$ for all $i,j\in[n]$, and

• 2.

a family of total graph homomorphisms $\phi=(\phi_{i}:G_{i}\to H_{f(i)}\mid i\in[n])$ such that $\tau^{G}_{j,i};\phi_{i}=\phi_{j};\tau^{H}_{f(j),f(i)}$ for all $0\leq i<j\leq n$, i.e., due to the definition of composition of partial morphisms (cf. Definition 1), we assume for any $0\leq i<j\leq n$ the following commutative diagram of total graph homomorphisms

\textstyle{G_{i}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\phi_{i}}$$\textstyle{H_{f(i)}}$$\textstyle{D(\tau^{G}_{j,i})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\phi_{j|i}}$$\scriptstyle{PB}$$\textstyle{D(\tau^{H}_{f(j),f(i)})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\textstyle{G_{j}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\tau^{G}_{j,i}}$$\scriptstyle{\circ}$$\scriptstyle{\phi_{j}}$$\textstyle{H_{f(j)}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\tau^{H}_{f(j),f(i)}}$$\scriptstyle{\circ}

A match of the rule graph chain $\mathcal{MM}:=(\overline{MM},{n},{\tau^{MM}})$ to the target graph chain $\mathcal{TG}:=(\overline{TG},{m},{\tau^{TG}})$ is now defined as a graph chain morphism $(b,f):\mathcal{MM}\to\mathcal{TG}$.

Note that since the composition of partial morphisms is based on a pullback construction, the condition $\tau_{j,i}^{MM};b_{i}=b_{j};\tau_{f(j),f(i)}^{TG}$, for all $0\leq i<j\leq n$, means that we are not only requiring that typing is preserved, but that typing is also reflected, since $b_{j}$ and $b_{i}$ are total morphisms. That is, we have:

[TABLE]

Remark 1

Identity graph chain morphisms and composition of graph chain morphisms are straightforward to define and to be shown to satisfy the category axioms, and thus we obtain the category $\mathsf{Chain}$ of graph chains and graph chain morphisms.

As mentioned, all the graphs $L,I,R,S,D,T$ in Figure 16 are multilevel-typed over either the graph chain $\cal{MM}$ or $\cal{TG}$. To explain the multilevel typing relation we consider one of these graphs, $S$, and one of the graph chains, $\cal{TG}$, however, the discussion can be generalised to any of the other graphs and graph chains.

The multilevel typing of $S$ over $\cal{TG}$ is given by a family of partial typing morphisms \sigma^{S}={(\sigma_{i}^{S}:S{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}TG_{i}\mid 0\leq i\leq m)} where $\sigma_{0}^{S}:S\to TG_{0}$ is total (see Figure 20). This multilevel typing must be compatible with the “internal” typing morphisms $\tau^{TG}$. Analogous to the uniqueness condition for graph chains we require that

[TABLE]

The family $\sigma^{S}$ of partial typing morphisms defines implicitly a sequence $\bar{S}=[S_{m},S_{m-1},\dots,S_{1},S_{0}]$ of subgraphs of $S$ with $S_{0}:=S$ and $S_{i}=D(\sigma^{S}_{i})$, for all $0\leq i\leq m$ (see Figure 20). Due to the composition of partial morphisms, the condition (2) is equivalent to the condition

[TABLE]

That is, if we assign to an item $e$ in $S$ a type $\sigma_{j}^{S}(e)$ in $\mathit{TG}_{j}$ and this item, in turn, has a transitive type $\tau_{j,i}^{TG}(e)$ in $\mathit{TG}_{i}$ then $\sigma_{i}^{S}$ has to assign this transitive type to $e$. It is adequate to require a stronger condition that if both $\sigma_{j}^{S}$ and $\sigma_{i}^{S}$ assign a type to $e$ then $\sigma_{i}^{S}(e)$ has to be a transitive type of $\sigma_{j}^{S}(e)$. Note that $(\sigma_{j}^{S})^{-1}(D(\tau_{j,i}^{TG}))\sqsubseteq S_{j}=D(\sigma_{j}^{S})$ by definition of pre-images. In such a way, we require that

[TABLE]

That is, we require the following diagram to commute for all $0\leq i\leq j\leq m$

\textstyle{S_{i}=D(\sigma^{S}_{i})\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sigma^{S}_{i}}$$\textstyle{TG_{i}}$$\textstyle{S_{j}\cap S_{i}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{PB}$$\textstyle{D(\tau^{TG}_{j,i})\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\tau^{TG}_{j,i}}$$\textstyle{S_{j}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sigma^{S}_{j}}$$\textstyle{TG_{j}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\tau^{TG}_{j,i}}$$\scriptstyle{\circ}

By using the stronger yet adequate condition (4) we can now:

Transform any graph $S$ into an abstract multilevel typing structure independent of any other typing chain, by simply choosing a sequence of arbitrary subgraphs of $S$ (see Corollary 1).

• 2.

Express an actual multilevel typing over a given graph chain by means of chain morphisms.

Corollary 1** (Refactoring)**

For any graph $S$ we can extend any sequence $\overline{S}=[S_{m},S_{m-1},\dots,S_{1},S_{0}]$ of subgraphs of $S$, with $S_{0}=S$, to a graph chain $\cal{S}$ $=(\overline{S},m,\tau^{S})$ where for all $0\leq i\leq j\leq m$, \tau_{j,i}^{S}:S_{j}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}S_{i} (also called a partial inclusion morphism) is given by $D(\tau_{j,i}^{S}):=S_{j}\cap S_{i}$ and the span ${S_{j}\hookleftarrow D(\tau_{j,i}^{S}):=S_{j}\cap S_{i}\hookrightarrow S_{i}}$ of inclusions. We call the graph chain ${\cal{S}=(\overline{S},m,\tau^{S})}$ also an inclusion chain.

To summarise, for any of the pairs $(L,\sigma^{L})$, $(I,\sigma^{I})$, $(R,\sigma^{R})$ and $(S,\sigma^{S})$, of a graph and a multilevel typing, we require that condition (4) is satisfied, which ensures that we get by Corollary 1 four corresponding inclusion chains \cal{L}$$=(\overline{L},n,\tau^{L}), \cal{I}$$=(\overline{I},n,\tau^{I}), \cal{R}$$=(\overline{R},n,\tau^{R}) and \cal{S}$$=(\overline{S},m,\tau^{S}), respectively, together with chain morphisms $(\sigma^{L},id_{[n]}):$ $\cal{L}$ $\to$ $\cal{MM}$, $(\sigma^{I},id_{[n]}):$ $\cal{I}$ $\to$ $\cal{MM}$, $(\sigma^{R},id_{[n]}):$ $\cal{R}$ $\to$ $\cal{MM}$, and $(\sigma^{S},id_{[m]}):$ $\cal{S}$ $\to$ $\cal{TG}$. Note that the $\sigma$’s in the chain morphisms are the total components of the partial typing morphisms in the original pairs.

4.2 Compatibility with respect to typing

In the same lines of typed graph morphisms where type compatibility must be ensured (see, e.g., [33]) we have to make sure that graph chain morphisms, when needed, also respect typing. For our MCMT rules, this means that $l:L\to I$ and $m:L\to S$ are compatible with respect to typing. First we will discuss the typing compatibility of $l$, then we use an analogous explanation for $m$.

In case of $l:L\to I$, we do have actually a morphism $l:(L,\sigma^{L})\to(I,\sigma^{I})$ where we require that, for all $0<i\leq n$, the diagram (a) is commutative.

$MM_{i}$L**I=$$(a)$$\sigma^{L}_{i}$$\sigma^{I}_{i}$$l

\mathcal{MM}$$\mathcal{L}=D(\sigma^{L})$$\mathcal{I}=D(\sigma^{I})$$=$$(b)$$(\sigma^{L},id_{[n]})$$(\sigma^{I},id_{[n]})$$(l,id_{[n]})

As explained in [61], it is now straight forward to show that the family $l=(l_{i}:L_{i}\to I_{i}\mid i\in[n])$ of inclusion homomorphisms establishes a chain morphism $(l,id_{[n]}):\cal{L}$ $\to\cal{I}$ (cf. Section 4.3.1). The compatibility of typing for $l$ can be described by a commutative triangle (b) of chain morphisms.

Analogous to $l$, the type compatibility of $m:L\to S$ means that we require that, for all $0<i\leq n$, the diagram (c) below is commutative

MM_{i}$$TG_{i}L**S=$$(c)$$b_{i}$$m$$\sigma^{L}_{i}$$\sigma^{L}_{f(i)}

\mathcal{MM}$$\mathcal{TG}$$\mathcal{L}$$\mathcal{S}$$=$$(d)$$(b,f)$$(m,f)$$(\sigma^{L},id_{[n]})$$(\sigma^{S},id_{[m]})

Again, as explained in [61], it is now straight forward to show that the $m_{i}$ establish a chain morphism $(m,f):\cal{L}$ $\to\cal{S}$, hence the compatibility of typing for $m$ can be described by a commutative square (d) of chain morphisms.

4.3 Pushouts in the category $\mathsf{Chain}$

As indicated in the previous section we use model transformations to define the behaviour of our MLM hierarchies. Since every branch in our MLM hierarchies is represented by a graph chain, the application of our model transformation rules will rely on pushout and pullback complement constructions in the category $\mathsf{Chain}$. Due to similarities between these constructions, the main focus of this section will be on the construction of the pushout of the following span

[TABLE]

of chain morphisms between inclusion chains in the category $\mathsf{Chain}$, where our assumption should ensure that the pushout becomes an inclusion chain as well. Moreover, the pushout in $\mathsf{Chain}$ should be fully determined by the construction of the pushout $D$ of the span

[TABLE]

in the category $\mathsf{Graph}$ of graphs and total graph homomorphisms. Especially, the multilevel typing of $D$, i.e., the level-wise pushouts of all the spans

[TABLE]

should be just parts of the pushout construction for the base $i=0$.

The result of the level-wise pushouts should be an inclusion chain of length $n+1$. The rule provides, however, only information about the typing at the levels $f([n])\subseteq[m]$. For the levels in $[m]\setminus f([n])$ we have to borrow the typing from the corresponding untouched levels in $\mathcal{S}$. In terms of graph chain morphisms, this means that we factorize $(m,f)$ into two graph chain morphisms and that we construct the resulting inclusion chain in two pushout steps (see Figure 21) where $\mathcal{S}_{\downarrow f}=(\overline{S}_{\downarrow f},n,\tau^{S}_{\downarrow f})$ with $\overline{S}_{\downarrow f}=[S_{f(n)},S_{f(n-1)},\ldots,S_{f(1)},S_{0}]$ and \tau^{S}_{\downarrow f}=(\tau^{S}_{f(j),f(i)}:S_{f(j)}{\mbox{\hskip 6.99997pt\circ\longrightarrow\hskip 1.00006pt}}S_{f(i)}\mid 0\leq i<j\leq n).

The graph chain morphism $(\overline{id},f):\mathcal{S}_{\downarrow f}\to\mathcal{S}$ is a level-wise identity and just embeds a chain of length $n$ into a chain of length $m$, i.e., $\overline{id}=(id_{f(i)}:S_{f(i)}\to S_{f(i)}\mid i\in[n])$. $\mathcal{D}_{\downarrow f}$ and $(\overline{id},f):\mathcal{D}_{\downarrow f}\to\mathcal{D}$ are defined analogously.

In the first step (1) we construct the pushout of inclusion chains of equal depth and in pushout step (2) we just exchange some levels in $\mathcal{S}$ by the corresponding extended levels provided by $\mathcal{D}_{\downarrow f}$.

4.3.1 Pushouts for chains with equal depth

We describe now the construction of the pushout (1) of chains of graphs of equal length (see Figure 21). The rest of this section depends on the special pushout construction in category $\mathsf{Graph}$for a span with one inclusion graph homomorphism and a necessary result about the structure of special mediating morphisms. A recapitulation of this construction is presented in [61].

We construct the corresponding pushout of graph homomorphisms (in category $\mathsf{Graph}$) for each level $i\in[n]$ as follows.

L_{i}$$I_{i}$$S_{f(i)}$$D_{f(i)}:=S_{f(i)}+I_{i}\setminus L_{i}POl_{i}$$s_{f(i)}$$m_{i}$$d_{i}:=m_{i}+id_{I_{i}\setminus L_{i}}

We consider any level $1\leq i\leq n$ together with the base level [math]. Since $I_{i}\sqsubseteq I_{0}$, we have that $I_{i}\setminus L_{i}\sqsubseteq I_{0}\setminus L_{0}$ and thus we get a span of pullbacks.

S=S_{0}$$D:=D_{0}$$I=I_{0}$$S_{f(i)}$$D_{f(i)}$$I_{i}$$s:=s_{0}$$d:=d_{0}$$\tau^{S}_{i,0}$$\tau^{D}_{i,0}:=\tau^{S}_{i,0}+\tau^{I}_{i,0}\setminus\tau^{L}_{i,0}$$\tau^{I}_{i,0}:=\tau^{L}_{i,0}+\tau^{I}_{i,0}\setminus\tau^{L}_{i,0}$$s_{f(i)}$$d_{i}

The sequence $[D_{f(n)},D_{f(n-1)},\dots,D_{f(1)},D_{0}]$ defines, according to Corollary 1, an inclusion chain that we denote by $\mathcal{D}_{\downarrow f}$. To show that the family of inclusion graph homomorphisms $(s_{f(i)}:S_{f(i)}\hookrightarrow D_{f(i)}\mid i\in[n])$ defines a graph chain morphism $(s_{\downarrow f},id_{[n]}):\mathcal{S}_{\downarrow f}\hookrightarrow\mathcal{D}_{\downarrow f}$ we have to show, according to Definition 2, that we have for any $0\leq i<j\leq n$ a commutative diagram with a pullback as follows.

\textstyle{S_{f(i)}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{f_{f(i)}}$$\textstyle{D_{f(i)}}$$\textstyle{S_{f(j)}\cap S_{f(i)}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{PB}$$\textstyle{D_{f(j)}\cap D_{f(i)}\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sqsubseteq}$$\scriptstyle{\sqsubseteq}$$\textstyle{S_{f(j)}\ignorespaces\ignorespaces\ignorespaces\ignorespaces}$$\scriptstyle{\sigma^{S}_{j}}$$\textstyle{D_{f(j)}}

Analogously, it can be shown that the family $(d_{i}:I_{i}\hookrightarrow D_{f(i)}\mid i\in[n])$ establishes a chain morphism $(d,id_{[n]}):\mathcal{I}\hookrightarrow\mathcal{D}_{\downarrow f}$. Since the resulting commutative square (1) of chain morphisms (see Figure 21) is obtained by level-wise pushout constructions, it is straight forward to show that (1) becomes indeed a pushout in $\mathsf{Chain}$.

4.3.2 Pushout by extension

In this subsection we will define the pushout construction (2) in Figure 21. To obtain an inclusion chain $\mathcal{D}$ of length $m+1$ we fill the gaps in the sequence $[D_{f(n)},D_{f(n-1)},\dots,D_{f(1)},D_{0}]$ of subgraphs of $D=D_{0}$, constructed in Section 4.3.1, by corresponding subgraphs of $S$ from the sequence $[S_{m},S_{m-1},\dots,S_{1},S_{0}]$. For any $j\in[m]\setminus f([n])$ we denote by $f^{-}(j)$ the unique index in $[n]$ such that $f(f^{-}(j))=j$. We define the sequence $\bar{D}$ of subgraphs of $D=D_{0}$ as follows.

[TABLE]

and denote by $\mathcal{D}=(\overline{D},{m},{\tau^{D}})$ the corresponding inclusion chain according to Corollary 1. The family $\bar{id}=(id_{D_{f(i)}}:D_{f(i)}\to D_{f(i)}\mid i\in[n])$ of graph homomorphisms defines trivially a chain morphism $(\bar{id},f):\mathcal{D}_{\downarrow f}\to\mathcal{D}$.

It remains to show that the family $s=(s_{j}:S_{j}\to D_{j}\mid j\in[m])$ of graph homomorphisms defined by

[TABLE]

establishes a chain morphism $(s,id_{[m]}):\mathcal{S}\to\mathcal{D}$.

The resulting square (2) in Figure 21 is commutative by construction and it is straightforward to show that it becomes a pushout in $\mathsf{Chain}$as well. Composing the two pushouts (1) and (2) we obtain a pushout in $\mathsf{Chain}$that provides us, finally, with a chain morphism from $\mathcal{D}$ to $\mathcal{TG}$ that materialises the required multilevel typing of the constructed graph $D$. The left triangle commutes due to compatible typing of the rule. The roof square commutes since the match $(m,f)$ is type compatible. This gives us $(m,f);(\sigma^{S},id_{[m]})=(l,id_{[n]});(\sigma^{I},id_{[n]});(b,f)$, thus the pushout universal property of the back of the square gives us a unique chain morphism $(\sigma^{D},id_{[m]}):\mathcal{D}\to\mathcal{TG}$ such that the two desired typing compatibilities $(s,id_{[m]});(\sigma^{D},id_{[m]})=(\sigma^{S},id_{[m]})$ and $(d,f);(\sigma^{D},id_{[m]})=(\sigma^{I},id_{[n]});(b,f)$ are satisfied.

5 Tooling

We present in this section our current results towards the full support for multilevel modelling and MCMTs. Specifically, we introduce in Section 5.1 our textual language for the specification of MCMTs — equivalent to the graphical representation used in previous sections — and its editor. We present a proliferation algorithm that generates two-level MTs out of given set of MCMTs, which can then be used on conventional model transformation engines. This way, we exploit the advantages of MCMTs over two-level MTs — as presented in Section 3.1 — but avoid the necessity of creating a brand new transformation engine for MCMTs. A full-fledged implementation of a MLM transformation engine is left as future work. These tools are available as Eclipse plugins from the MultEcore website444MultEcore website: http://ict.hvl.no/multecore..

5.1 Textual DSL for MCMTs

The abstract syntax of our DSL for MCMTs is defined as an Ecore metamodel, partially depicted in Figure 22. This metamodel has been used to create an editor using Xtext [62] which provides syntax highlighting, error detection, code completion and outline visualization.

This DSL provides the specification of modules containing a collection of multilevel coupled transformation rules defined independently from a hierarchy, but that will be matched against one during the proliferation process (see Section 5.2). Therefore, the MCMTs are applied to a single hierarchy in each execution.

In order to briefly present this DSL, we use the textual representation of the MCMT rule CreatePart, already introduced in Section 3.1. This textual version is shown in Figure 23, from a screenshot of our Eclipse-based editor. As stated in Section 3.1, Rule elements are structured into three organizational components, namely META, FROM and TO, named in lowercase in the textual syntax. These blocks contain graph pattern declarations, plus expressions that relate the elements to each other. The meta block must contain a valid pattern, but the from and to blocks may be empty. In the meta block, a pattern is specified by means of MetaElementDec, used to declare both nodes and edges, which can in turn be constant or not. Also, this block may contain assignment expressions, used in this example to specify the structural relationships between the declared nodes by means of the declared edges. In the example, P1, M1 are declared as node variables, while creates is declared as a variable edge. Specifying any of these as a constant would just require to add the character $ as a suffix to their type. Note that the type names of the meta block elements are suffixed by the keyword mm followed by the level (index) at which these types is actually declared, starting from 0 and increasing downwards. Note that this editor assumes Ecore at level 0, which does not have to be explicitly given.

In the from and to blocks we can define patterns according to the MetaElementDec previously declared in the meta part. In the example, the from block of the rule defines a pattern consisting of just one variable m1, while its to block comprises three variable declarations and an assignment expression between them. This pattern mirrors precisely the one depicted in Figure 15.

5.2 Proliferation process

As mentioned before, an MCMT can generically, but precisely, comprise a number of two-level specific rules which are applicable to just one given source model. For matching an MCMT in a modelling hierarchy and executing it, we can consider two different approaches.

A first approximation requires the implementation of a custom execution engine that tackles MCMTs and multilevel modelling stacks. This kind of approach would offer a more seamless execution of MCMTs in an integrated enviroment, also facilitating possible extensions and eliminating the necessity of back and forth translation of hierarchies and MCMTs to existing transformation engines. However, the cost of implementing such a custom engine from scratch, including the re-implementation of basic functionalities which already exist in transformation engines, would be too high. Moreover, it might lock the transformation engine to a single MLM-tool.

As an alternative, it is possible to perform a pre-processing step that can automatically generate the operationally equivalent two-level rules which, while correct, are in general too numerous and cumbersome to specify by hand. This approach can be combined with other well-established, well-understood and optimised transformation engines like Henshin [63], Groove [37, 64], ETL [65] or ATL [66]. In other words, this process of automatic proliferation results in a more flexible implementation, in which we do not even strictly depend on a particular transformation engine. Besides, the process of adapting both the target hierarchy and the MCMTs to a two-level setting can be done automatically, and indeed needs to be performed only once before running the whole scenario.

Specifically, our automatic proliferation procedure consists in the generation of two-level model transformations for every possible match of the variables defined in an MCMT. The goal of this process is to replace the variability in the types of the elements in the FROM and TO blocks — which cannot be interpreted by mainstream model transformation engines — by specific types, so that we can generate automatically an executable set of rules for any two-level engine.

Once specified, an MCMT is run by specifying in which model it will be applied, as in any model transformation engine. The specification of the input model, which is part of a multilevel hierarchy, uniquely identifies its branch in the hierarchy tree. That is, we can ignore at execution time the same-level sibling models of the input one as well as the sibling models of any metamodel of the input model in the levels above. Furthermore, in the exceptional case that the input model is not in the bottommost level of the hierarchy, all models in the levels below it can be ignored for the execution. As a consequence of these simplifications, the relevant part of the hierarchy will always be a stack of models, without any branches. Hence, we will hereafter use the term stack instead of hierarchy.

The way to replace the variable types of the MCMT by specific ones, is by looking at the META part of the MCMT rule and finding all possible matches of its variables into the types defined in the modelling stack. Looking back to Figure 16, this process will establish all the possible maps bx, and generate one two-level rule for each valid combination that involves one map per level in the META part, which is represented as the sequence of graphs MMx. Once proliferated, it is necessary to perform a second matching process m between the FROM graph L and the input model S, in order to actually apply the — now proliferated — rule. Such operation will be performed by the selected two-level engine, so both L and S are excluded from the proliferation algorithm.

The core of our MCMT proliferation mechanism is a matching algorithm between the meta part of an MCMT rule and the stack of metamodels of the input model. We describe our matching algorithm in the following sections.

5.3 Matching algorithm

The algorithm that generates the list of all possible values of the variables that yield valid two-level MTs is shown in Algorithm 1. It consists of a recursive function with four input parameters and an input/output parameter.

The first two input parameters, $\mathit{MM}$ and $\mathit{TG}$, represent all the metalevels of an MCMT depicted in Figure 16 as MMx and TGy. Hence, they represent the META part of an MCMT (the typing chain $\mathit{MM}$) and the levels above the one were the MCMT will be applied ($\mathit{TG}$). That is, $\mathit{MM}$ represents the pattern that the algorithm tries to match and $\mathit{TG}$ represent the stack against which the algorithm tries to match $\mathit{MM}$. Both inputs are accessed level by level, in all valid combinations, as the algorithm progresses. This way, it establishes all possible maps between pairs of levels that conform a full match — and hence result in a proliferated rule.

The next two parameters, $\mathit{mmLevel}$ and $\mathit{tgLevel}$, are the indexes used to indicate the current levels that are being accessed in $\mathit{MM}$ and $\mathit{TG}$, respectively. In the first call, both have value zero, which will increase as the algorithm progresses. Since we number the levels of both the $\mathit{MM}$ and $\mathit{TG}$ increasing downwards, the matches will be generated in a top-down manner. This decision is not arbitrary: the match between two levels depends, among other things, of the types of their elements; since those types may be other elements in levels above, these need to be matched first, so that we can check that the types of any two elements are compatible — that is, the type in the pattern has been previously mapped to the type in the stack.

The last parameter, $\mathit{matches}$, contains the list of all valid matches found by the algorithm. It is initially empty, and it is required to work as an input/output variable (by reference) so that the algorithm can modify it in each recursive call and, afterwards, propagate the result of such calls to provide the final list. For the same reason described in the previous paragraph, the information of the maps established so far for any match needs to be passed to $\mathit{graphMatch}$ so that it can be taken into account to produce only those maps that are consistent with the maps of the types.

The algorithm depends on an auxiliary function $\mathit{graphMatch}$ (line 7) that calculates the possible matches between two models. This auxiliary algorithm is described in Section 5.4.

The function returns a boolean value that indicates whether the algorithm has found valid matches or not. In the latter case, the rule would not be applicable and, consequently, would not be proliferated. This value is also used by the algorithm to filter all potential matches that are discarded, in case they could not be completed.

The algorithm works as follows. First, the base case of the recursion is triggered if the $\mathit{mmLevel}$ has reached the size of the pattern of the rule ($\mathit{MM}$). This would indicate that the algorithm has found a sequence of partial matches all the way down to the last level of $\mathit{MM}$, which constitute a full match. If that is not the case, the first time that a pair of levels is explored as part of one sequence of matches, the flag $\mathit{found}$ is set to false.

The core of the algorithm is a while loop that attempts to match the current $\mathit{mmLevel}$ with all the remaining $\mathit{tgLevel}$s. The first value is the one which was passed to the function in the call, which will increase by $1$ in each iteration. On each iteration, the list of maps that are possible to establish for $\mathit{mmLevel}$ and $\mathit{tgLevel}$ are calculated with the call to $\mathit{graphMatch}$. This function takes the two levels of $\mathit{MM}$ and $\mathit{TG}$ indicated by the indexes, and gives back a list of maps from all the elements in the pattern into elements of the multilevel stack. This results are stored in the $\mathit{maps}$ variable, and then iterated in the for loop that performs the recursive calls in order to complete the match.

Inside the for loop, the current match $\mathit{m}$ is stored in $\mathit{matches}$, and the recursive call is made afterwards. However, a case distinction is required. In those cases where both the size of the $\mathit{matches}$ variable and $\mathit{mmLevel}$ are not zero, these values indicate that the algorithm has already found some maps for the current match. In that case, such information is stored in the last position of the list ($\mathit{matches[size-1]}$), and $\mathit{m}$ is simply added to that position (line 12). Furthermore, in case more than one match can be generated from the current sequence of maps and other values of $\mathit{m}$, that current information is temporarily stored in $\mathit{currentMatch}$ and duplicated in the last position of $\mathit{matches}$ after the recursive call (lines 11 and 14). In the cases where the $\mathit{size}$ of $\mathit{matches}$ is zero (empty list) or $\mathit{mmLevel}$ is zero, there is no partial information to be preserved before storing $\mathit{m}$ and making the recursive call, so $\mathit{m}$ is simply added to the tail of the list, since it is the first map of the sequence. In both cases, the recursive call is performed in the same way, and its return value is used to indicate if the match was completed after the current map or not. The result, stored in $\mathit{found}$, will be then propagated to the calling function in the same way (line 25).

After all iterations of a loop are completed, and due to the duplication described above when $\mathit{mmLevel}$ and $\mathit{size}$ are not zero, the last partial result that was not completed is taken away from the list of matches.

Note that $\mathit{mmLevel}$ and $\mathit{tgLevel}$ are increased in such a way that it always holds that $\mathit{mmLevel}\leq\mathit{tgLevel}$. Moreover, every time that $\mathit{mmLevel}$ is increased, the same happens to $\mathit{tgLevel}$. This ensures that the sequence of graph matches are consistent with their depiction in Figure 16, where two bx cannot have the same source or target, or “cross” each other.

To sum up, the algorithm is first called with the $\mathit{MM}$ specified in the META part of the MCMT, the $\mathit{TG}$ that represent the multilevel stack on top of the model to be transformed, both $\mathit{mmLevel}$ and $\mathit{tgLevel}$ initialized at zero and $\mathit{matches}$ initialized empty. It will recursively explore all valid combination of maps that cover all the levels in the pattern, and return those in $\mathit{matches}$, plus a boolean value set to false if no full matches were found.

Figure 24 displays an example of the application of Algorithm 1 to the MCMT CreatePart that we previously presented in Figure 15. Following the top-down mechanism we already described, the two MMx representing the META part of the rule are matched against the multilevel stack in top of the model where the rule is applied. The rule CreatePart is applied in this example to the model hammer_config in Figure 9d. Hence, the stack of models TGy consists of generic_plant and hammer_plant — Figure 9(a) and (b), respectively. For simplicity reasons, the potencies of all elements, as well as the multiplicities of relations, are excluded from the diagram, since they are not specified and hence make no difference in the execution of the algorithm.

5.4 Graph matching

The match between a graph defined in the META part of an MCMT and a subgraph of one of the models in the multilevel stack is done by means of graph homomorphisms, plus some restrictions. The algorithm for graph matching is a modification of the Ullman algorithm [67], as proposed in [68]. Basically, we take into account some modelling aspects in order to adapt the process from pure graphs to modelling.

Recall that nodes within a graph are uniquely identified by their name, which act as unique identifiers. As for arrows, names can be reused as long as the source or target nodes — at least one — are different. Moreover, both nodes and arrows are fundamentally defined by their types. Hence, in order to match any element, it is required that the one in the pattern and its counterpart in the hierarchy have matching types. This restriction does not conflict with the possibility of having variable types — see, e.g., rules Assemble (Figure 18) and TransferPart (Figure 19).

As shown in Section 5.2, the proliferation algorithm works in a top-down manner, so that before matching any element, its type has already been matched, and it is possible to use that information for the current match.

For arrows, where multiplicity is part of their definition, the lower and upper bounds can also be used for matching purposes, taking into account that a more restrictive multiplicity in the pattern will match a less restrictive one in the hierarchy. For example, a pattern arrow with multiplicity 1..2 will match a hierarchy arrow with multiplicity 0..3 if the rest of the matching conditions are met.

In addition, the notion of potency can also be used in the match if required, although it is ignored if not specified. In a similar manner to arrow multiplicity, the less restrictive ones in the hierarchy — broader intervals — can be matched by more restrictive patterns — narrower intervals.

Lastly, the distinction between variables and constants, already presented in Section 3.2, also influences the graph matching algorithm. In this case, the name of the element is taken into account for the matching. For nodes, the algorithm must find a corresponding node with all the restrictions aforementioned, plus an equal name, in order to get a successful match. For arrows, the type is still required, since the name does not necessarily identifies a single arrow. To properly identify one specific arrow, we need to identify its source and target nodes as constants too.

Figure 25 displays a fragment of Figure 24, in which, after matching MM1 to TG1, the proliferation algorithm proceeds to find matches between MM2 to TG2. As depicted, the pattern (blue) can match two different subgraphs (green), resulting in two different proliferated rules. This can be achieved since the proliferation process has already matched, before a recursive call, the elements Machine, Part and creates in MM1 to their homonyms in TG1.

6 Related Work

We discuss in this section works related to our proposal in the fields of multilevel modelling and on the use of model transformations to define the behaviour of languages and systems.

6.1 Multi-level metamodelling

Multi-level metamodelling was initially proposed by Atkinson and Kühne [69, 70]. And since then, several researchers have pointed out the benefits of using multi-level modelling languages (see, e.g., [12, 13, 7, 14]). Indeed, different authors have proposed different formalizations of multilevel modelling languages and different aspects related to multilevel structures (see, e.g., [71, 57]).

Proposals such as MetaDepth [71], Melanee  [20], AtomPM [72] or Modelverse [73] propose conceptual frameworks and tools for multilevel modelling. These approaches are based on the concept of clabject  [69], which provides two facets for every modelling element, so that they can be seen as classes or as objects. Clabjects stem from the traditional object-oriented programming, so their realization into a metamodelling framework requires a linguistic metamodel that all the levels must share. That is, the clabject element is contained in a linguistic metamodel, together with other elements such as field and constraint.

MetaDepth [71] is a deep modelling tool built on the notion of orthogonal classification and deep instantiation. MetaDepth supports several interesting features such as model transformation reuse [12] and generic metamodelling [48]. Melanee has been developed with a stronger focus on editing capabilities  [20], as well as possible applications into the domains of executable models  [52]. AtomPM  [72] is a modelling framework highly focused on the development of cloud and web tools. Modelverse  [73] offers multilevel modelling functionalities by implementing the concept of clabject and building a linguistic metamodel that includes a synthetic typing relation. In [74], the same idea is applied the implementation of multilevel modelling.

All these previous approaches implement their multilevel modelling solutions by using a linguistic metamodel including the clabject element, and flattening the ontological hierarchy as an instance of this linguistic metamodel. That is, the whole ontological stack becomes an instance of the clabject-based modelling language. Moreover, they require the creation of supporting tools, such as editors, constraint definition mechanisms and import/export capabilities to more widespread tools like EMF, from scratch. With our approach, multilevel modelling is realised in a different way, which improves its flexibility and removes the need for custom-made environments and tools. Our approach that does not require the definition of a specific linguistic metamodel, nor a flattening of the ontological levels.

6.2 Reusability

We have illustrated in previous sections how the use of multilevel modelling hierarchies may improve reusability. There are several alternative proposals to improve reusability of models and model transformations. In [45], two perspectives on model transformation reuse are presented: programming language- and MDSE-based. For each perspective, the authors discuss two approaches: subtyping and mapping, and lifting and aggregating. In [75] a variability-based graph transformation approach is introduced to tackle the performance problems that are introduced by systems in which a substantial number of the rules are similar to each other. In [76] an approach to reusable model transformations is presented, which is based on sub-typing an effective part of the existing source metamodel. That is, the metamodel of the models to be transformed is made a subtype of a pruned metamodel. In this way, the models can be transformed by the same transformation rules which were written for the source metamodel.

To achieve genericness, in [42, 43] the rules are typed over a generic metamodel which is called concept. Then, any metamodel to which there exist an embedding from the concept-metamodel (called binding) can be used by composition for the type-check during matching. Thus, any model in a hierarchy can be typed by the concept metamodel and get the transformation rules for free. However, it is not always straight forward to define the embedding morphism from the concept metamodel to the metamodel. This might be because the metamodel has several structures which have the same behaviour leading to several bindings. This is solved by introducing syntax for the definition of cardinality in which the concept metamodel can be written in a generic way, however, in the realisation of the concept, this is just syntactic sugar for the definition of multiple concept metamodels. Moreover, finding reasonable embeddings due to structure mismatches (or heterogeneity) might be a challenge. Adapters and concept inheritance could be seen as solution of this problem, as seen [42].

The notion of concept from [43] is extended in [44] to parametric models, where the parameters have both structure and behaviour. In this case we not only have a mechanism for the reutilisation of transformations, but mechanisms for the reutilisation and composition of models with behaviour. The challenges in finding embeddings is however more difficult, since rules in parameter models must also be mapped to the corresponding target models.

6.3 Multi-level model management and transformation

Although some management operations on hierarchies have been satisfactorily formalized (see, e.g., [57, 12]), the definition of transformations on multi-level hierarchies is not yet so well handled. Current proposals use traditional two-level transformations to deal with multi-level-hierarchy transformations. Multi-modelling languages like the ones proposed in [77] to define domain specific process modelling notations, in [78] to express variability over DSLs and to extend them with interfaces for model reuse, or in [79] to declare component types with ports, use multi-level languages to express variability and reuse of multi-level languages, but it is done by emulating three meta-levels within two.

The only proposals supporting some form of deep transformations are, to some extend, Melanee [80, 51], MetaDepth [71] and DeepJava [81]. They follow very different approaches, but none of them provides a formalization of multi-level transformations as we do. Here, we focus on their possibilities for multi-level hierarchy transformations.

MetaDepth [71] is a deep modelling tool built on the notion of orthogonal classification and deep instantiation. It is a textual tool, and provides facilities to write executable code against it. De Lara et al. in [12] present their extension of the Epsilon [82] family of languages to support multilevel scenarios: They define model manipulation operations, code generators working at several metalevels, and model-to-model transformations [12]. However, all these transformations are defined at a particular level of the hierarchy, perhaps with references to indirect types. For transformations affecting multiple levels, they propose what they call “co-transformations”, transformations that transform a model and its metamodel at the same time. Their are called co-transformations because they are defined as transformations that operate on respective levels, but are applied simultaneously. Similar approaches are discussed in [59] in the context of co-evolution, where models and their corresponding metamodels are transformed simultaneously. They also provide support for refinement of transformations, when transformations require some adaptation for their application, and linguistic extensions.

Melanee [80] is a graphical multi-level modelling tool based on EMF and GMF. Atkinson et al. present in [51] their ideas for extending the transformation language ATL to work on multi-level models. Although they discuss the two-level to multilevel and multilevel to two-level transformation cases, the paper focuses on the multilevel to two-level case. Moreover, in this setting, the transformation is applied at the bottommost level of the source model. Although discussed in the paper, Melanee does not support in-place transformations.

DeepJava [81] extends Java with the ability to perform multiple instantiations. DeepJava programs are compiled into Java.

6.4 In-place transformation rules for the definition and analysis of behaviour

Two-level modelling tools such as Groove [83], AGG [36], ATOM3 [35, 40] and e-Motions [38] use in-place model transformation to deal with the behaviour of DSLs. The Groove and AGG tools do not support the definition of a specific graphical notation associated to the DSL at hand: rule patterns are defined with graphs. AToM3 and e-Motions allow the user to specify a graphical concrete syntax for the DSLs. From these tools, only e-Motions support the interoperation of the models defined using it with other tools. As MulEcore, tools like the e-Motions graphical framework, Tiger EMF [84] or MOMENT2 [85] were developed for the Eclipse platform, and enable their integration with other modelling tools already defined for Eclipse, such as EMF, GMF, ATL, TCS, etc., because they all share the same representation/notation of models and metamodels. This allows users to benefit from all of these tools to achieve a complete MDSE process. Tools like Groove, AGG and ATOM3 are developed as stand-alone tools, i.e., their connection with other modelling tools requires a high effort, because they do not share a common model notation.

Systems like e-Motions and Groove focus on the definition of timed systems, and on the verification of the systems specified, providing facilities for model-checking or statistical model-checking inside their environments [64, 86]. See [83, 64] for a discussion on Groove, or [87] for the use of different formal verification techniques on systems specified using in-place model transformations.

7 Conclusions and future work

This paper presents an approach for multilevel modelling based on graphs and Category Theory constructions, such as pushouts and pullbacks in the corresponding category. The approach tackles both multilevel metamodelling — the definition of hierarchies — and multilevel model transformation — the definition of transformation rules — with focus on specifying and reusing behaviour in the same domain and among similar ones. The main focus of the work presented here are in-place, multilevel model transformations, for which we coin the concept of Multilevel Coupled Model Transformations, MCMTs. This framework is presented conceptually (in Section 3), theoretically (in Section 4) and in practice (in Section 5).

We have argued how MCMTs can achieve greater expressive power than traditional, two-level MTs, which allows to reuse behaviour for different elements in the same model and, more importantly, for different models with shared commonalities. This reusability reduces the amount of transformation rules that need to be defined, as detailed in Section 3.1. In this regard, the 4 rules presented in Section 3.2 (CreatePart, SendPartOut, Assemble and Transferpart) generate, after the proliferation process for the typing chain of hammer_config, 21 two-level rules, which would have needed to be manually specified otherwise. This number of rules would further increase if we consider defining behaviour for the typing chain of stool_plant (the right branch of the PLS hierarchy), while our 4 original MCMTs would still suffice to represent the same information.

We have presented a formalization of MLM hierarchies, on which we have introduced our MCMTs. Since every branch in our MLM hierarchies is represented by a graph chain, the application of our model transformation rules are formalized by appropriate pushout and pullback complement constructions in the category $\mathsf{Chain}$of graph chains and graph chain morphisms. Specifically, our constructions for graph chains build on the well-established constructions of pushout and pullback complement in the lowest level graphs of the hierarchy in the category $\mathsf{Graph}$, and indeed get the multilevel typing of the constructed graphs.

When it comes to the usage of potency, we have also redefined its semantics, compared to other approaches like [57]. The range-like potency specification allows us to constrain a type more specifically than the single-valued one, with the extra advantage that a single notation covers both notations defined in those approaches (jump-like and continuous). Additionally, our version of potency allows to specify values like @2-3, which are not possible to replicate with single-valued ones.

About the next steps in our work, we plan to increase the tool support to both hierarchies and MCMTs specification, as well as test their feasibility in new scenarios. In addition, we plan to use, or adapt, strategy languages like [88, 89] in order to coordinate the execution of MCMTs, allowing for even richer semantics for the execution of behavioural DSLs [61].