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