=Paper= {{Paper |id=Vol-1237/paper4 |storemode=property |title=On Synergies between Model Transformations and Semantic Web Technologies |pdfUrl=https://ceur-ws.org/Vol-1237/paper4.pdf |volume=Vol-1237 |dblpUrl=https://dblp.org/rec/conf/models/BillSWK14 }} ==On Synergies between Model Transformations and Semantic Web Technologies== https://ceur-ws.org/Vol-1237/paper4.pdf

On Synergies between Model Transformations and
Semantic Web Technologies

Robert Bill1 , Simon Steyskal1,2 , Manuel Wimmer1 , and Gerti Kappel1
1
Vienna University of Technology, Austria
[lastname]@big.tuwien.ac.at
2
Siemens AG Österreich, Siemensstrasse 90, 1210 Vienna, Austria

Abstract. The integration of heterogeneous data is a reoccurring problem in
different technical spaces. With the rise of model-driven engineering (MDE),
much effort has been spent in developing dedicated transformation languages and
accompanying engines to transform, compare, and synchronize heterogeneous
models. At the same time, ontologies have been proposed in the Semantic Web
area as the main mean to describe the intension as well as the extension of a
domain. While dedicated languages for querying and reasoning with ontologies
have been intensively studied, specific support for integration concerns leading to
executable transformations is rare compared to MDE.
Based on previous studies which relate metamodels and models to ontologies, we
discuss in this paper synergies between transformation languages of MDE, in par-
ticular Triple Graph Grammars (TGGs), and Semantic Web technologies (SWTs),
namely OWL/SPARQL. First, we show how TGGs are employed to define corre-
spondences between ontologies and how these correspondences are expressed in
SPARQL. Second, we show how reasoning support of SWTs is applied to allow
for underspecified model transformation specifications as well as how the differ-
ent assumptions on existing knowledge effect transformations. We demonstrate
these aspects by a common case study.

Keywords: Model Transformation, Model Integration, Triple Graph Grammars,
OWL, SPARQL

1 Introduction

The integration of heterogeneous data has first emerged in the database area [26]. How-
ever, data integration is a reoccurring problem, not only in the database area, but in
different technical spaces [8, 11]. With the raise of model-driven engineering (MDE),
much effort has been spent in developing dedicated transformation languages and ac-
companying engines to transform, compare, and synchronize heterogeneous models.
At the same time, ontologies have been proposed in Semantic Web to describe the
intension as well as the extension of a domain. While dedicated languages for querying
and reasoning with ontologies have been intensively studied (e.g., classification of indi-
viduals and consistency checking are provided by standard reasoner), specific support
for integration concerns leading to executable transformations is rare.

Proceedings of MPM 2014 31
On Synergies between Model Transformations and Semantic Web Technologies

In order to understand the differences and commonalities between MDE and Se-
mantic Web technologies (SWTs), several studies have investigated about the languages
used in both fields to describe the domain of discourse [28]. Thus, bridges are already
available between these two worlds for transforming metamodels and corresponding
models to ontologies and vice versa. Some studies go also beyond purely structural
information [12], but bridges concerning dynamic information are still mostly unex-
plored. Moreover, for specific domains, such as configuration management [4], both
technologies are applied, but mostly in an isolated manner as we currently explore in a
recent project3 .
Based on previous studies which relate metamodels and models to ontologies [5,10],
we discuss in this paper synergies between transformation languages of MDE, in par-
ticular Triple Graph Grammars (TGGs) [24], and SWTs, namely a combination of
OWL/SPARQL. First, we show how TGGs are employed to define correspondences
between ontologies visualized as metamodels and how these correspondences are op-
erationalized by a compilation of TGGs to OWL/SPARQL. Second, we show how rea-
soning support of SWTs is applicable to allow for underspecified model transformation
specifications, i.e., the concrete types of instances are assigned in a post-processing
step using OWL reasoner. Third, we discuss how switching between the closed world
assumption (CWA) to an open world assumption (OWA) is beneficial for particular
integration scenarios where only partial knowledge of existing models is present. We
demonstrate these aspects by a common case study.
The rest of this paper is structured as follows. In the next section, we introduce the
running example for this paper as well as the technological prerequisites. In Section 3,
we discuss the mapping between TGGs and OWL/SPARQL in a general form, whereas
in Section 4 we demonstrate the compilation of TGGs to OWL/SPARQL by-example
and discuss how features of ontologies may be exploited for model transformations. In
Section 5 we discuss related work before we conclude in Section 6.

2 Preliminaries

2.1 Motivating Example

As an example we will illustrate how heterogeneous views on computer networks can
be joined (cf. Fig. 1). The first view comprises the physical network structure includ-
ing cables of various types and speed as well as computers. The second view contains
the application structure of the network, i.e., various computers are running different
services which might require each other. In that case, a connection to a matching ser-
vice is required. Connections can be modeled by their physical structure, as well as
their logical network structure. By using TGGs we are able to define correspondences
between both structures, which can be used to either (𝑖) express graph transformation
rules to transform individuals from one schema to another or (𝑖𝑖) check whether or
not such alignments hold for given models. Extending those correspondence definitions
with SWTs, allows even more sophisticated reasoning, inferencing, and querying tasks.

3
http://cosimo.big.tuwien.ac.at

Proceedings of MPM 2014 32
On Synergies between Model Transformations and Semantic Web Technologies

Device devices
System connections System
ServiceConnection
name:FString * target maxload:qDouble
* services
1 computers *
networkCables cables
curload:qDouble
1 source requires service Connectable
Computer * *
Cable * 0..1 * name:qString
utilization:FDouble Service

uses
* bandWidth:FDouble source 1 1 target
name:qString
Router connected target *
* services *
slots:FInteger CopperCable Connection
Computer
maxBandWidth:FDouble speed:qDouble
curBandWidth:FDouble GlassFiberCable IntermediateNode isPhysical:qBoolean

(a) (b)

Fig. 1. Representations of networks: (a) physical and (b) logical

2.2 Triple Graph Grammars (TGGs)

TGGs have first been introduced by Andy Schürr [24]. A TGG rule combines elements
from a left model (LM), a right model (RM) and a correspondence model (CM). Each
TGG rule contains a left hand side graph (LG) conforming to LM, a right hand side
graph (RG) conforming to RM and a correspondence graph (CG) conforming to CM
which connects elements from LG and RG. Vertices and edges may not be deleted by
any rule, they can only be preserved or created. In contrast to usual graph transformation
rules, TGG rules are inherently bidirectional. A TGG engine searches for rule applica-
tions creating the required input graphs and creates elements of all other graphs during
that process. For example, in a transformation scenario an input graph for LM would
result in a graph for CM and RM. TGG rules might also have additional constraints,
e.g., negative application conditions or attribute constraints, also restricting the value of
an attribute depending on attribute values of other objects in the TGG rule.
The left-hand side of Fig. 5 shows a simple example of a TGG rule of a computer
network that relates connections of the same speed without declaring them equal. Black
elements denote elements which have been matched already, green elements are ele-
ments which are matched or created then. In this case, the difference between both
models is only a syntactical one.

2.3 Semantic Web Technologies (SWTs)

RDF & OWL. The Resource Description Framework (RDF)4 is a framework to de-
scribe and represent information about resources and is both human-readable and
machine-processable, which enables the possibility to easily exchange information
among different applications using RDF triples.
In RDF everything is a resource, uniquely identified by its URI and all data is repre-
sented as (𝑠𝑢𝑏𝑗𝑒𝑐𝑡, 𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑡𝑒, 𝑜𝑏𝑗𝑒𝑐𝑡) triples, where subjects and predicates are URIs
and objects can either be literals (strings, integers, . . . ) or URIs.
Since RDF itself does not contain sophisticated semantics to express characteristics
of concepts or to define more expressive relationships among them, the Web Ontology
4
http://www.w3.org/TR/rdf-mt/

Proceedings of MPM 2014 33
On Synergies between Model Transformations and Semantic Web Technologies

Language (OWL)5 was developed. Introducing OWL allows the usage of reasoning
systems such as Pellet [27], FaCT++ [29] or HermiT [25] to (𝑖) infer new knowledge
and (𝑖𝑖) detect inconsistencies based on the modeled semantics.

SPARQL. The Protocol And RDF Query Language (SPARQL) is basically the standard
query language for RDF6 . Its syntax (cf. Figs. 2-4) is highly influenced by an RDF
serialization format called Turtle [1] and SQL. In its current version, SPARQL allows
besides basic query operations such as union of queries, filtering, sorting and ordering
of results as well as optional query parts, the use of aggregate functions (SUM, AVG,
MIN, MAX, COUNT,...), the possibility to use subqueries, perform update actions
via SPARQL Update and several other requested features as indicated in [18].7
Another important feature of SPARQL are CONSTRUCT queries, which allow the
construction of new RDF graphs based on a previously matched (against one ore more
input graphs) SPARQL graph pattern (cf. Fig. 3). Their main purpose lies in data inte-
gration scenarios, where data from one ore more data sources have to be normalized to
fit a common schema [19, 23].
CONSTRUCT {
SELECT ?a ?name ?a :hasName true .
ASK WHERE {
WHERE { }
?a a :Device .
?a a :Device . WHERE {
?a :name ?name .
?a :name ?name . ?a a :Device .
}
} ?a :name ?name .
}
Fig. 4. ASK Query
Fig. 2. SELECT Query
Fig. 3. CONSTRUCT Query

3 Aligning TGGs and SWTs

In the following, we map basic TGG rules to SPARQL queries. The TGG rule definition
is based on [2] and extended by labels. Advanced features of graph transformations like
multi–nodes are not supported. Subsequently, we discuss two benefits of using SWTs:
(𝑖) automatic type inference and (𝑖𝑖) reasoning under CWA and OWA.

Definition 1 (E–Graph). A labeled E–Graph 𝐺 = (𝑉𝐺 , 𝑉𝐷 , 𝐸𝐺 , 𝐸NA , 𝐸EA , (src 𝑗 ,
trg 𝑗 )𝑗∈{𝐺,EA,EA} , 𝑙) consists of graph vertices 𝑉𝐺 , data vertices 𝑉𝐷 , graph edges, node
attribute edges and edge attribute edges 𝐸𝐺 , 𝐸NA , 𝐸EA , source and target edge func-
tions src 𝑗 and trg 𝑗 mapping edges to corresponding vertices and a labeling function
𝑙 defining a label for each vertex and edge. As shorthand we use src(𝑒) and trg(𝑒) to
denote source and target edge functions operating on edges of any kind.

Definition 2 (Typegraph). A typegraph TG is an E-Graph specifying the relation be-
tween types. A type morphism 𝑡 maps nodes and edges of a graph to the corresponding
nodes and edges in the type graph.
5
http://www.w3.org/TR/owl2-overview/
6
http://www.w3.org/TR/sparql11-overview/
7
For a comprehensive overview on the semantics of SPARQL queries see [17, 22].

Proceedings of MPM 2014 34
On Synergies between Model Transformations and Semantic Web Technologies

Definition 3 (Triple graph). A triple graph TRG = (LG ←−− CG −−→ RG) consists
𝑠 𝑡 𝑚 𝑚

of three E–Graphs LG, CG and TG and morphisms 𝑚𝑠 and 𝑚𝑡 mapping corresponding
nodes from the correspondence graph to other graphs.

Definition 4 (TGG rule). A parametrized TGG rule TGG = (SG, ZG, ac) consists of
a source triple graph SG, a target triple graph ZG ⊃ SG, and application conditions ac.
For the sake of simplicity, we consider application conditions as boolean formulas using
∧ and ∨, over atomic positive application conditions (PACs) and negative application
conditions (NACs) defined as triple graphs which might share vertices with each other
and SG and TG.

Example 1. The TGG rule r2n = (tr 𝑠 , tr 𝑡 , true) represented in Fig. 5 could be
specified as follows: The type graph of both models is derived from the metamodel.
For example, a subset of the typegraph for network1 could be specified as 𝐺n1 =
({𝑑n1 , 𝑐n1 }, {double}, {sn1 , 𝑡n1 }, {bn1 }, {}, {(𝑠n1 , 𝑐n1 ), (𝑡n1 , 𝑐n1 )}, {(𝑠n1 , 𝑑n1 ),
(𝑡n1 , 𝑑n1 )}), {(𝑏𝑛1 , 𝑐n1 )}, {(𝑏n1 , double)}, {}, {}) combined with a standard double
DSIG algebra.
The source graph of TGG rule tr 𝑠 = (LG 𝑠 ←−𝑠𝑠− CG 𝑠 −−𝑡𝑠 → TG 𝑠 ) with
𝑚 𝑚

LG 𝑠 = ({𝑑1 , 𝑑2 }, ∅, . . . , ∅), CG 𝑠 = ({g2c 1 , g2c 2 }, ∅, . . . , ∅), TG 𝑠 = ({cb1 , cb2 }, ∅,
. . . , {}), 𝑚𝑠𝑠 = ∅, 𝑚𝑡𝑠 = ∅. The target graph tr 𝑡 = (LG 𝑡 ←−𝑠𝑡− CG 𝑡 −−𝑡𝑡 → TG 𝑡 ) with
𝑚 𝑚

LG 𝑡 = LG 𝑠 ∪ ({𝑐1 }, {𝑛}, {𝑠1 , 𝑡1 }, {𝑏1 }, ∅, {(𝑠1 , 𝑐1 ), (𝑡1 , 𝑐1 )}, {(𝑠1 , 𝑑1 ), (𝑡1 , 𝑑2 )},
{(𝑏, 𝑐1 )}, {(𝑏, 𝑛)}, ∅, ∅), CG 𝑡 = CG 𝑠 ∪ ({}, ∅, . . . , ∅), RG 𝑡 = RG 𝑠 ∪ ({𝑐1 }, {𝑛},
{𝑠1 , 𝑡1 }, {𝑏1 }, ∅, {(𝑠1 , 𝑐1 ), (𝑡1 , 𝑐1 )}, {(𝑠1 , cb1 ), (𝑡1 , cb2 )}, {(sp, 𝑐1 )}, {(sp, 𝑛)}, ∅, ∅).
The labeling function assigns the type names from the metamodel in Fig. 1 to elements
of the type graph and lables equal to variable name to elements of other graphs.

Mapping TGG rules to SPARQL queries. Both transformation and correspondence
construction can be expressed using SPARQL queries in the merged ontology using
the labeling function. If a model should be synchronized, at first the maximum cor-
respondence is searched, then for the unmatched elements a transformation might be
conducted. Each vertex and edge in a TGG rule can be used as context, matched or
created element, depending on the use of the TGG rule. In every case, the context nodes
are exactly those occurring in the source model, but not in the target one. In a trans-
formation, elements of source model of the transformation in the target rule, but not in
the source, are used as matched elements while the others are used as created elements.
In a corresponding search scenario, only the elements of the correspondence graph are
created, all others are matched. According to [7], an attribute hasMatch is introduced
to specify which elements have been matched already. For elements, it is initially un-
set and may be set to true. For edges, it has the same domain and range as the edge
to match, but hasMatch_ as prefix to the original name. Thus, it is not necessary to
modify the ontology prior to using the converted TGG rules.
In many cases, TGG rules as defined previously can be transformed to correspond-
ing SPARQL queries. Table 1 shows matching concepts. The general structure of a gen-
erated SPARQL query is CONSTRUCT
WHERE . The first two lines, e.g., indicate that the occur-
rence of a vertex 𝑛 labeled c1 with a type labeled computer in the TGG rule should

Proceedings of MPM 2014 35
On Synergies between Model Transformations and Semantic Web Technologies

P. Type TGG SPARQL
W c,m Vertex 𝑛 ?𝑙(𝑛) a 𝑙(𝑡(𝑛)).
Vertex 𝑛1 , 𝑛2 ,
W c,m 𝑛1 ̸= 𝑛2 , injec- FILTER (?𝑙(𝑛1 ) != ?𝑙(𝑛2 )).
tive matching
C cr Vertex 𝑛 ?𝑙(𝑛) a 𝑙(𝑡(𝑛)).
W c,m Edge 𝑒 ?𝑙(𝑠(𝑒)) dom(𝑒):𝑙(𝑒) ?𝑙(𝑡(𝑛)).
C cr Edge 𝑒 ?𝑙(𝑠(𝑒)) dom(𝑒):𝑙(𝑒) ?𝑙(𝑡(𝑛)).
C m,cr Vertex 𝑛 ?𝑙(𝑛) tgg:hasMatch true.
C m,cr Edge 𝑒 ?𝑙(𝑠(𝑒)) tgg:hasMatch_dom(𝑒)_𝑙(𝑒) ?𝑙(𝑡(𝑒)).
W m Vertex 𝑛 FILTER NOT EXISTS {?𝑙(𝑛) tgg:hasMatch true.}
FILTER NOT EXISTS {?𝑙(𝑠(𝑒))
W m Edge 𝑒
tgg:hasMatch_dom(𝑒)_𝑙(𝑒) ?𝑙(𝑡(𝑒))}
W c Vertex 𝑛 FILTER EXISTS {?𝑙(𝑛) tgg:hasMatch true.}
FILTER EXISTS {?𝑙(𝑠(𝑒)) tgg:hasMatch_dom(𝑒)_𝑙(𝑒)
W c Edge 𝑒
?𝑙(𝑡(𝑒))}
Mapping 𝑒1 ↦→
C m,cr 𝑒2 from 𝑚ss , 𝑚st , ?𝑙(𝑒1 ) owl:sameAs ?𝑙(𝑒2 )
tt or ts
Mapping 𝑒1 ↦→
C m,cr 𝑒2 from 𝑚ss , 𝑚st , ?𝑙(𝑒1 ) owl:sameAs ?𝑙(𝑒2 )
tt or ts
BIND (EXISTS {}) AS ?gn(ac)
BIND (NOT EXISTS {}) AS ?gn(ac)
Full AC ac = FILTER (?gn(ac 1 ) (&&/||) ?gn(ac 2 )) or rather
W -
ac 1 (∧|∨)ac 2 applied recursively until the atomic operations.
Table 1. SPARQL patterns occuring in the WHERE (W) and CONSTRUCT (C) part for context
(c), matching (m) and created (cr) elements

result in c1 a computer., which is placed in the CONSTRUCT part of the SPARQL
query for context nodes and nodes to be matched and in the WHERE part for created
nodes.
The helper function dom returns the graph for an element. It returns o1 for ele-
ments of the left graph, o2 for elements of the right graph and c for elements of the
correspondence graph. The helper function gn assigns a unique name to each atomic
application condition.
Many current TGG implementations allow the use of functions to set values for
attributes. Existing approaches for converting OCL into SPARQL, could be used for
functions requiring matched nodes, context nodes and, for created nodes, (other) created
nodes. The result then can be assigned using BIND. Some constraints on created nodes
might be formulated using SWRL expressions, e.g., the subset of OCL defined in [12].
In this case, the specific match of vertices in a TGG rule has to be stored to be able
to subsequently apply the constraint. Thus, attributes :hasSwrlRule_name_index
might be set true to specify that an element is used as element nr. index in the SWRL
rule name. In such a way, not only conditions in the TGG can be formulated, but also
invariants of each individual model or the merged model. Simple invariants may also be
modeled directly in OWL. In the following, we will show an example to illustrate how
this may help reducing the complexity of TGG rules significantly.

Proceedings of MPM 2014 36
On Synergies between Model Transformations and Semantic Web Technologies

Automatic Type Inference. Considering the two views on an imaginary network,
one might distinguish the creation of Coppercables and Glassfibrecables
based on the speed of a correlating Connection between two previously aligned
Devices and Connectables (e.g. creating a Glassfibrecable if the speed
exceeds a certain threshold or a Coppercable otherwise). Although such distinc-
tions can be modeled with TGGs, at least two TGG rules (in our case; one matching
Coppercable and one matching Glassfibrecable) would be necessary.
A more convenient way to model such a behavior can be achieved by out-sourcing
the type inference to OWL reasoners and only define one TGG rule, which describes the
more general Cable and Connection correspondence as depicted in Figure 5 (with
its corresponding SPARQL CONSTRUCT query). The constraints itself (i.e., defining
the concept Glassfibrecable to be equivalent to an anonymous concept which
is defined as Cable having a speed with a value over 17) can be directly modeled
within the ontology using OWL axioms8 and were generated during the initial model to
ontology transformation .
CONSTRUCT {
?k1 a o1:Cable .
?k1 o1:source ?g1 .
TGG rule example ?k1 o1:target ?g2 .
physical (namespace o1) correspon- ?k1 o1:bandWidth ?n .
g1:Device + source dence ?k1 tgg:hasMatch true .
+ k1:Cable (ns. c)
?c1 tgg:hasMatch true .
bandWidth<==<17 FILTER EXISTS
CopperCable GlassFibreCable {?gc2 tgg:hasMatch true} .
FILTER NOT EXISTS
{?c1 tgg:hasMatch true} .
}

Fig. 5. CONSTRUCT query which generates Cables for given Connections

Reasoning under Open and Closed World Assumption. One of the major benefits
of SWTs for integration scenarios are their well defined semantics and the extensive
reasoner support as already discussed previously. With OWL and OWL reasoners it is
8
cf. [6] for a comprehensive list of OWL axioms

Proceedings of MPM 2014 37
On Synergies between Model Transformations and Semantic Web Technologies

e.g., possible to describe cardinality constraints, perform automatic type inferencing as
discussed above and to check for inconsistency in the given models.
While Semantic Web languages are based on OWA (i.e., if a statement is not ex-
plicitly stated, it does not mean that it does not exist), software engineering languages
are mostly based on CWA (i.e., if a statement is not present, it does not exist) [20].
To deal with this issue, we translate parts9 of the constraints expressed as OWL ax-
ioms into SPARQL queries and query for the presence of individuals which violate
those constraints. E.g., consider the cardinality constraint computers exactly 2
Computer for concept System expressed in OWL Manchester Syntax10 . The an-
swer to the question whether or not a particular System has the right amount of
Computers, would not be directly decidable for the OWA but for the CWA with the
support of SPARQL as depicted in Listing 1.
ASK WHERE {
{ SELECT (count(?b) AS ?number) ?a WHERE {
?a a :System .
?a :computers ?b . } GROUP BY ?a }
FILTER(?number != 2)}
Listing 1. ASK Query which returns true if a System has not exactly 2 Computers

4 Related Work
We discuss three lines of related work: (𝑖) approaches for bridging models and ontolo-
gies, (𝑖𝑖) approaches for transforming transformations to SWTs, and (𝑖𝑖𝑖), approaches
directly using SWTs to encode model transformations.
Bridging models and ontologies. Combining modeling approaches steaming from
MDE with ontologies has been studied in the last decade [5]. There are several ap-
proaches to transform Ecore-based models to OWL and back, e.g., cf. [9, 31]. In ad-
dition, there exist approaches that allow for the definition of ontologies in software
modeling languages such as UML by using dedicated profiles [13]. Moreover, there
are also approaches which combine the benefits of models and ontologies such as done
in [14, 16]. Not only the purely structural part of UML is considered, but some works
also target the translations of constraints between these two technical spaces by using
an intermediate format [3]. We build on these mentioned approaches, but we focus on
correspondence definitions and their execution as transformations.
Transforming transformations to SWTs. Concerning the definition and execution of
model transformations based on SWTs, we are aware of two approaches. First, [15] pro-
pose the usage of an ATL-inspired language for defining mappings between ontologies.
Thus, uni-directional transformations are implementable for ontologies as it is known
from model transformations. Another approach is presented in [30] which translates
parts of ATL transformations to ontologies for checking the consistency of transforma-
tion rules, e.g., overlaps between rules in terms of overlapping matches. In our work,
we follow this line of research, but we consider bi-directional transformations specified
in TGGs. Thus, in our translations to ontologies we have to consider not only source to
9
The decision, which constraints have to be translated, highly depends on the respective inte-
gration scenario.
10
http://www.w3.org/TR/owl2-manchester-syntax/

Proceedings of MPM 2014 38
On Synergies between Model Transformations and Semantic Web Technologies

target transformations, but we have to encode comparison and synchronization trans-
formations as well in SPARQL.
Specifying transformations with SWTs. Finally, there are approaches which shift the
definition of the model transformations to the SWTs. For instance, in [21] it is proposed
to use SWRL to define the correspondences between models to allow for model syn-
chronization. In [10], ontology matching tools are applied to search for correspondences
between metamodels and to derive from these correspondences model transformations.
In the context of this work, we have the assumption that correspondences are defined
based on models using TGGs, but at the same time we explored which benefits from
ontology reasoning may be transferred to model transformation approaches.

5 Conclusion and Further Work
In this paper we have outlined an initial mapping between TGGs and OWL/SPARQL.
Especially, new features of the latest SPARQL version helped in defining a compre-
hensive mapping between these languages. Moreover, we also explored how reasoning
capabilities can be leveraged for underspecified model transformations.
While the initial results of applying our approach seem promising, both from a
mapping point of view and usage of reasoning capabilities for model transformations,
further investigation are planned such as considering a mapping between TGGs and
SWRL. Empirical studies are planned as well in the area of configuration management
together with our industry partner Siemens AG Österreich. In particular, for performing
distributed configuration management [4] where several different models and reasoners
have to be connected, we plan to apply our approach to provide the necessary integra-
tion means.

Acknowledgment: This work has been funded by the Vienna Business Agency (Aus-
tria), in the programme ZIT13 plus, within the project COSIMO (Collaborative Config-
uration Systems Integration and Modeling) under grant number 967327.
References
1. David Beckett and Tim Berners-Lee. Turtle-terse RDF triple language. W3C Team Submis-
sion, 14, 2008.
2. Juan de Lara, Roswitha Bardohl, Hartmut Ehrig, Karsten Ehrig, Ulrike Prange, and Gabriele
Taentzer. Attributed graph transformation with node type inheritance. Theoretical Computer
Science, 376(3):139–163, 2007.
3. Dragan Djuric, Dragan Gasevic, Vladan Devedzic, and Violeta Damjanovic. A UML Profile
for OWL Ontologies. In Proc. of MDAFA, pages 204–219, 2004.
4. Andreas A. Falkner, Alois Haselböck, Gottfried Schenner, and Herwig Schreiner. Modeling
and solving technical product configuration problems. AI EDAM, 25(2):115–129, 2011.
5. Dragan Gasevic, Dragan Djuric, and Vladan Devedzic. Model Driven Engineering and On-
tology Development (2. ed.). Springer, 2009.
6. OWL Working Group. OWL 2 Web Ontology Language. W3C recommendation, 2012.
7. Frank Hermann, Hartmut Ehrig, Fernando Orejas, Krzysztof Czarnecki, Zinovy Diskin,
Yingfei Xiong, Susann Gottmann, and Thomas Engel. Model synchronization based on triple
graph grammars: correctness, completeness and invertibility. SoSyM, pages 1–29, 2013.
8. Zhenjiang Hu, Andy Schürr, Perdita Stevens, and James F. Terwilliger. Dagstuhl seminar on
bidirectional transformations (bx). SIGMOD Record, 40(1):35–39, 2011.

Proceedings of MPM 2014 39
On Synergies between Model Transformations and Semantic Web Technologies

9. Gerti Kappel, Elisabeth Kapsammer, Horst Kargl, Gerhard Kramler, Thomas Reiter, Werner
Retschitzegger, Wieland Schwinger, and Manuel Wimmer. Lifting Metamodels to Ontolo-
gies: A Step to the Semantic Integration of Modeling Languages. In Proc. of MODELS,
pages 528–542, 2006.
10. Gerti Kappel, Horst Kargl, Gerhard Kramler, Andrea Schauerhuber, Martina Seidl, Michael
Strommer, and Manuel Wimmer. Matching metamodels with semantic systems - an experi-
ence report. In Proc. of BTW Workshops, pages 38–52, 2007.
11. Ivan Kurtev, Mehmet Aksit, and Jean Bézivin. Technical Spaces: An Initial Appraisal. In
Proc. of CoopIS, 2002.
12. Sergey Lukichev. Defining a subset of OCL for expressing SWRL rules. In RuleApps, pages
1–3, 2008.
13. Milan Milanovic, Dragan Gasevic, Adrian Giurca, Gerd Wagner, and Vladan Devedzic. To-
wards Sharing Rules Between OWL/SWRL and UML/OCL. ECEASST, 5, 2006.
14. Fernando Silva Parreiras and Steffen Staab. Using ontologies with UML class-based model-
ing: The TwoUse approach. Data Knowl. Eng., 69(11):1194–1207, 2010.
15. Fernando Silva Parreiras, Steffen Staab, Simon Schenk, and Andreas Winter. Model driven
specification of ontology translations. In Proc. of ER, pages 484–497, 2008.
16. Fernando Silva Parreiras, Steffen Staab, and Andreas Winter. On marrying ontological and
metamodeling technical spaces. In Proc. of FSE, pages 439–448, 2007.
17. Jorge Pérez, Marcelo Arenas, and Claudio Gutierrez. Semantics and Complexity of
SPARQL. In Proc. of ISWC, pages 30–43, 2006.
18. Axel Polleres. SPARQL1. 1: New features and friends (OWL2, RIF). In Web Reasoning and
Rule Systems, pages 23–26. Springer, 2010.
19. Axel Polleres, François Scharffe, and Roman Schindlauer. SPARQL++ for mapping between
RDF vocabularies. In Proc. of OTM, pages 878–896, 2007.
20. Tirdad Rahmani, Daniel Oberle, and Marco Dahms. An adjustable transformation from
OWL to Ecore. In Proc. of MODELS, pages 243–257, 2010.
21. Federico Rieckhof, Mirko Seifert, and Uwe Aßmann. Ontology-based model synchronisa-
tion. In Proc. of TWOMDE Workshop, 2010.
22. Simon Schenk. A sparql semantics based on datalog. In Proc. of KI, pages 160–174, 2007.
23. Simon Schenk and Steffen Staab. Networked graphs: a declarative mechanism for SPARQL
rules, SPARQL views and RDF data integration on the web. In Proc. of WWW, pages 585–
594, 2008.
24. Andy Schürr. Specification of Graph Translators with Triple Graph Grammars. In Proc. of
WG Workshop, pages 151–163, 1994.
25. Rob Shearer, Boris Motik, and Ian Horrocks. HermiT: A Highly-Efficient OWL Reasoner.
In Proc. of OWLED Workshop, 2008.
26. Nan C. Shu, Barron C. Housel, Robert W. Taylor, Sakti P. Ghosh, and Vincent Y. Lum. EX-
PRESS: A Data EXtraction, Processing, amd REStructuring System. ACM Trans. Database
Syst., 2(2):134–174, 1977.
27. Evren Sirin, Bijan Parsia, Bernardo Cuenca Grau, Aditya Kalyanpur, and Yarden Katz. Pel-
let: A practical OWL-DL reasoner. J. Web Sem., 5(2):51–53, 2007.
28. Steffen Staab, Tobias Walter, Gerd Gröner, and Fernando Silva Parreiras. Model driven
engineering with ontology technologies. In Proc. of Reasoning Web, pages 62–98, 2010.
29. Dmitry Tsarkov and Ian Horrocks. FaCT++ description logic reasoner: System description.
In Automated reasoning, pages 292–297, 2006.
30. Dennis Wagelaar. Towards using OWL DL as a metamodelling framework for ATL. In Proc.
of MtATL Workshop, pages 79–85, 2010.
31. Tobias Walter, Fernando Silva Parreiras, Gerd Gröner, and Christian Wende. OWLizing:
Transforming Software Models to Ontologies. In Proc. of ODiSE, pages 7:1–7:6, 2010.

Proceedings of MPM 2014 40