Translation between RDF and Topic Maps: Divide and Translate

Christo Dichev

Winston-Salem State University

Darina Dicheva

Winston-Salem State University

Boriana Ditcheva

Winston-Salem State University

Mike Moran

Winston-Salem State University

Copyright © 2008 Christo Dichev, Darina Dicheva, Boriana Ditcheva and Mike Moran. Reproduced with permission.

expand Abstract

Balisage logo

Proceedings

expand How to cite this paper

Translation between RDF and Topic Maps: Divide and Translate

Balisage: The Markup Conference 2008
August 12 - 15, 2008

Introduction

Data availability is no longer a major problem given the sheer volume of information on the web and the advances in information retrieval and indexing technology. The lack of interoperability at the model, metadata, and data levels presents the major barrier to knowledge and data sharing [Stuc02]. Many-to-many data-interchange media, such as the web, pose new requirements for sharing and exchange of data. One of the most challenging among them is the ability to make use of information outside of its structural origin. This requirement implies data interchange not only on a syntactic, but also on a semantic and structural level.

The presented work was motivated by the idea of creating a tool that allows effective reuse and integration of existing Topic Maps (TM) and RDF data. Similarly to previous efforts in this direction [Lach01], [Moore01], [Ogie01], [Cian03], [Gars03], [Pepp06a], we aim at enhancing the interoperability between the two models by providing translation bridging the two frameworks, instead of forcing applications “to speak the same language”. The aim is similar but the proposed approach is different. In previous works, the mapping strategies are guided by the observed equivalence between the Topic Maps subject and RDF resource concepts. Such a strategy implies some sort of subject-centered translation. In contrast, our approach is based on the ontological correspondence between RDF and Topic Maps. Diverse and interesting similarities can be captured based on correspondences between the ways we relate things rather than on the correspondences between things alone. Therefore, our approach implies identifying similarities not only between concepts, but also between how statements about those concepts are asserted. Such similarities make the translation between the two models more predictable. This is a principal point in our translation approach, which proposes to divide the concepts to be translated into overlapping and non-overlapping categories and then to conquer them by translating, with a correspondingly focused and general translation.

This type of work is related to ontology and metadata mapping [Kalf03],[Klein01], [Patel05],[Shvai05]. Metadata mapping, in particular, involves an identification of equivalent or nearly equivalent metadata elements within different metadata schemas. In contrast to metadata mapping, translation between independently developed RDF and Topic Maps data can not be accomplished by mapping between two vocabularies. The mapping mechanism is more complex because it involves mapping between frameworks with extensible vocabularies implying that one-to-one correspondence is not generally possible.

A critical question regarding this type of translation is whether all concepts of the source language can be appropriately translated to some in the target language. Assuming that a complete translation is possible, a derived question is whether all concepts from the source language should be translated to the target language at any price. At first, it seems that complete and accurate translation from the source to the target language (if possible) should be preferable to the translation skipping or transforming the meaning of some concepts. However, the answer, in fact, depends on the purpose of the translation and on the selected criteria. The translation as a process and objective involves two aspects: semantic and pragmatic [Usch03]. They correspond to the following questions: Is a concept from the source language expressible in the target language? Is a concept translated from the source language useful in the target language?

The technical and pragmatic aspects of the translation reflected by the above questions are equally important. They also imply a variable strategy. Instead of a complete and faithful translation in some cases it might be better to chose a translation preserving the meaning of some concepts and modifying (slightly) the meaning of some other in order to match them to predefined concepts in the target language. The translation strategy of the source concepts should not be independent from their role in the target. For example, extending a language to accommodate a foreign concept is a challenging task from a usability perspective. The following observations indicate that the set of concepts satisfying the first question is not necessarily equivalent to the set of concepts satisfying the second one:

  1. Translation of conceptual structures from the source model, even when preserving their meaning (e.g. a TM binary association translated into seven RDF statements), is not very useful if translated structures are not recognizable to the agents using the target model.

  2. Translating a conceptual structure from the source language that does not have a counterpart in the target language (e.g. TM variant names), may result in translated concepts which are meaningless and are disregarded by the agents using the target language.

In trying to enhance the RDF - Topic Maps conversion we focus on identifying the right balance between the following key aspects: (i) semantics-preserving translation; (ii) completeness of the translation; (iii) pragmatics and usability of the translation. In contrast to the previous works on RDF - Topic Maps mapping, preserving the ontological vocabulary is not a required property of our translation approach. Instead, the basic requirements are guided by pragmatic and semantic considerations. As a result, the focus is on a translation respecting the meaning, the utility and the readability of the translated data.

This paper addresses the problem of RDF - Topic Maps interoperability by analyzing the feasibility of this task and identifying some requirements derived from that analysis. Based on the results of the analysis we propose a method for RDF - Topic Maps (RDF2TM) translation. In contrast to metadata mapping, a general RDF2TM mapping goes beyond the simple data interoperability, since it involves exchange of conceptual knowledge within and across the corresponding Topic Maps and RDF models. The paper starts with a conceptual discussion of problems in RDF - Topic Maps interoperability, which motivated the design requirements of our translation. Section 3 discuses the technical details of the proposed approach, while the implementation and examples are presented in section 4. We summarize the related works and tools addressing RDF2TM translation in section 5 and conclude in section 6.

Semantic and Pragmatic Aspects of RDF - Topic Maps Interoperability

Terminology

  • The term translation means changing the representation formalism while preserving the semantics.

  • The term transformation means changing the representation as well as the semantics.

  • Mapping means relating similar concepts or relations from different sources to each other by an equivalence relation. A mapping results in a virtual integration.

  • The term interoperability means ensuring information exchanged between two models that is understandable in the manner intended by the original creator.

  • Semantic interoperability is the ability of systems to share and understand information at the level of formally defined and mutually accepted domain concepts, enabling machine-processable interpretation.

  • The terms model, data model, language, and format are used interchangeably in combination with the terms RDF and Topic Maps (e.g. RDF model, RDF format).

  • When there is no danger of confusion, the phrase RDF - Topic Maps translation/mapping (RDF2TM) will be used to mean RDF to Topic Maps and Topic Maps to RDF translation/mapping.

  • RDF Schema (RDFS) extends RDF with “schema vocabulary”. It provides the framework to describe application-specific classes and properties. The proposed translation uses RDFS for some Topic Maps constructs. We choose the term “RDF” (in the title) based on some traditional associations and because a document that uses terms from the RDFS vocabulary is still an RDF document. In the following the acronym RDF(S) will be used to denote both RDF and RDFS.

RDF and Topic Maps interoperability: a conceptual viewpoint

As with natural languages, translating RDF constructs into corresponding Topic Maps constructs and structures requires interpretation and may involve some loss or distortion of meaning. The interoperability between RDF and Topic Maps languages has been addressed by various authors[Cian03], [Gars03], [Lach01],[Moore01],[Ogie01], [Ogie01], with a focus primarily of the syntactic and semantic level; less attention has been paid to the pragmatic and practical aspects of the translation. In contrast to the previous works on RDF2TM mapping, vocabulary and structure preservation is not the top priority of our translation. Our basic requirements are guided by pragmatic and semantic considerations.

We distinguish differences between ontology languages from differences between the ontologies themselves. The latter can further be divided into differences among the things that are described and differences in the way things are described. The problems associated with the semantic interoperability between RDF and Topic Maps are mostly due to the differences in their original assumption of how the world is modeled. These differences are passed to the corresponding modeling frameworks, which directly affects the syntax and the descriptive capability of each. It also affects the mapping between the two models. The fact that RDF and Topic Maps differ in representation, structure, and vocabulary leads to a great multiplicity of matching alternatives. In general, an RDF2TM mapping process can not be defined by one-to-one matching relationships between the source and target concepts. Typically it involves one-to-many, many-to-one, and one-to-none relationships. This type of matching ambiguity may turn into semantic inconsistency that is not resolvable without specific domain information. Such inconsistencies occur because the source model: (i) differs in compositional granularity from the target, (ii) has extensible vocabulary along with the target and (iii) contains concepts that are irrelevant according to the target ontological vocabulary.

These observations are critical in the context of RDF — Topic Maps interoperability. We can illustrate the key points in comparison with conventional programming languages. First consider the translation of the FORTRAN loop statements

      DO 10 I = 1, 100
         STATEMENT1
         …..
         STATEMENTn
     10  CONTINUE 

into the following C++ statement.

    for(int i = 1; i < 101; i++)
       {
	  statement1
           …..
           statementn

       }

It is straightforward, because the loop vocabulary (keywords) is predetermined and it does not depend on the intention of the user. The FORTRAN loop statement DO 10 I = 1, 100 doesn’t allow variations, e.g. PERFORM 10 I = 1, 100. Similarly, C++ does not support extensibility with non standard control structures and for loop is defined in the language. Any change in the C++ loop vocabulary for(int i = 1; i < 101; i++) e.g. into trough(int i = 1; i < 101; i++) will violate the syntax rules. This results into one-to-one matching between the two loop statements with fixed semantics.

Now consider a similar task in our original context: translating the following Topic Maps binary association [1]:


         based-on(lecture7 : adaptation,  Xpointer : source)

with verbalization: Lecture7 is based on the topic Xpointer, where Lecture7 plays a role of adaptation and Xpointer plays a role of source. Can we translate this association into a single RDF property


         ex:lecture7     ext:based-on      ex:Xpointer

with corresponding verbalization Lecture 7 is based on Xpointer? The answer is not obvious at a syntactic level. Firstly, the naming (vocabulary) in the TM association


         based-on(lecture7:adaptation,  Xpointer : source) 

is left to the user’s choice, as opposed to the first example. For instance, it is possible to assert Topic Map association with different name, e.g.


         derived-from(lecture7:adaptation,  Xpointer : source)

but with an equivalent meaning to the first one. More interestingly, Topic Map associations differ in compositional granularity from the RDF properties. Their expression involves concepts such as association type and role types coupled with role-playing topics. The Role player: Role type constructs of the Topic Maps association do not have a matching counterpart in the RDF properties (i.e. one-to-none matching). In such cases there are three alternatives: to disregard all role players in the translation, to translate them into a predefined RDF construct with a similar meaning or to perform a semantic preserving translation into RDF construct intended to serve as an RDF encoding of the TM role types and role players. Even if we decide to skip the Topic Maps role types translation, we still have to decide how to relate role players to the subject and object of the RDF based-on property. This will transform the directionally neutral Topic Maps association into uni-directional RDF properties. A closer look at Topic Maps association specifications reveals that both role players must be topics (they cannot be strings) while the object of the RDF based-on property can be any resource. For example, in one RDF document the object of the ext:based-on property may refer to a web page describing Xpointer (single resource) while in another RDF document the object of the ext:based-on property may refer to the Xpointer concept with a reference to book chapter divided into sections by relevant RDF properties (structure of resources). Thus significant amount of the information carried by the association


         based-on(lecture7 : adaptation,   Xpointer : source)

will be lost if we choose to translate it directly into the RDF statement


         ex:lecture7     ext:based-on      ex:Xpointer

is In fact such a process will be a transformation of a Topic Maps association into an RDF property, since it is changing the representation as well as the semantics.

One point that was left implicit in the above example is that a complete semantic mapping is not always the best alternative. For example, if the Superclass-Subclass association


         Superclass-Subclass(Person: superclass,
Professor: subclass)

is mapped directly to the RDF(S) subClassOf property:


         ex:Professor   rdfs:subClassOf  ex:Person

where the player of type superclass is mapped to the object and the player of type subclass is mapped to the subject of the subClassOf property, then the role types (viz. superclass and subclass) will be lost. If we choose to ignore such a loss, the compensation will be a direct use of the RDF subClassOf property with predefined semantics that captures the intended meaning of the Topic Maps Superclass-Subclass association. Similar arguments also apply to user defined associations/properties such as based-on. However the Topic Maps and RDF extensibility makes finding a user defined property with equivalent semantics a challenging task.

In contrast, a translation of source content, which includes concepts that do not exist in the target model, may result in a redundant set of data, a set that remains unused by the agents using the target representation. Indeed, we can translate a Topic Maps binary association with role types and role players into RDF by mapping it into a composition of RDF properties that preserve the role concept. Thus, it is possible to define a translation that captures the semantics of a TM association. However, the interpretation of the corresponding RDF composition embodying the role concept is conveyed by an external agreement for RDF. More importantly, semantic consistency does not imply intentional consistency. An agent reading the target may be unable to grasp the role concepts as intended in the source. As a result, the original intention assigned to association roles may be lost despite their faithful translation. To make this example more specific, consider a user-defined Topic Maps association, employment, involving two roles, employer and employee. The two roles can be translated into matching RDF constructs participating in the translated employment association. For example, for each role in the employment association we can include a statement whose property corresponds to the role type (viz. employer and employee); its value is a property with predicate member that references the role player, where referencing is done through an additional (e.g. referencedBy ) property. Obviously, this will increase the complexity of the resulted translation while decreasing its readability. More importantly, despite their presence in the resulting RDF encoding, the constructs corresponding to the employer and employee roles may remain unused because they correspond to concepts defined outside of RDF - the existing RDF applications are designed with no assumptions relating to query, search, display, etc., association roles.

It is even more challenging to pragmatically integrate the TM contextual roles (e.g. when a person playing a role of husband in one context is playing a role of father in another context) in an RDF setting, ensuring their practical utilization. When a topic map user applies a scope to a particular statement, he does that with certain intent. The scope concept with meaning provided by the Topic Maps data model is designated to capture this intention. Since there is no corresponding term (and meaning) in the RDF vocabulary, this intention can not be passed to the target. A possible approach for overcoming such problems is to extend the RDF vocabulary with terms for naming given RDF compositions that correspond to particular Topic Maps concepts (e.g. rdf:scope). However, we believe that we should not target a translation that enforces or assumes that RDF users and applications should “speak Topic Maps”.

Translating in the opposite direction, from RDF to Topic Maps, demonstrates slightly different problems [Gars03]. Consider, for example, a general RDF property, relating two resources identified by their URIs. It can be mapped to either a TM binary association or a TM occurrence. The correct mapping of the RDF property to a Topic Maps format depends on the intended meaning of the property (e.g. employment vs. seeAlso). On the other hand, properties such as rdf:type or rdfs:label allow us to map them unambiguously to Topic Maps expressions. The mapping in this particular case is enabled by the existing rdf:type and rdfs:label semantics in the source language. However, non-standard properties, such as rdf:is-described-by, rdf:plays or, rdf:exists, do not carry predefined semantics and thus can not be mapped based on any logical ground. RDF does not make any assumption about their meaning except that they relate two resources - one playing a role of subject and the other a role of object. In this case a semantic mapping to Topic Maps terms would require a significant human involvement. If the property rdf:is-described-by denotes a relationship with an information resource that is pertinent to and enlightens a given subject, then this property should be translated to a TM occurrence, otherwise it should be translated to a TM binary association. Note that a complete and accurate mapping will require additional decisions to be made about the occurrence type and the role types of the association in each of the corresponding decision steps. In a situation like that, human involvement can not be eliminated because a correct property translation will require an understanding of the context of the property, so its intended meaning and the resources it involves can be captured. These distinctive features of the two models and the differences in the compositional granularity result in a mapping ambiguity and the need of an additional vocabulary, such as RTM [Gars03], [Ontop03], for explicitly defining external meaning and intentions.

Design Requirements

Based on the above observations, we focus on a translation that respects the meaning while maximizing the usability of the translation result. To achieve this we exploit the ontological similarities between the models, which also allow natural integration of the translated expressions into the target formalism. As an additional requirement, we chose not to support guided translation [Gars03], [Pepp06b], [Pepp06c]. Thus, we assume that the source model is not annotated with specific information for the purpose of guiding the translation. This kind of annotation presumes familiarity with both models. It is typically done manually and is a costly exercise. A further assumption is that sharing vocabularies across the two models is not required. Our opinion is that the purpose of any translation is to make translated concepts interpretable in terms of the native vocabulary and to allow users not knowing a foreign vocabulary to utilize it. In fact, the primary role of the translation is to make users independent of a foreign vocabulary. The above assumptions served as a starting point for identifying the key requirements of the translation.

Origins of the requirements

The basic idea driving the proposed translation requirements is that RDF and Topic Maps represent two models that overlap to a certain extent in their modeling capabilities. This overlapping is at an ontological level. It refers to similarities in the way things are organized, e.g. similarities in the way things are grouped into classes and the way things are related to each other, to properties or to pertinent information resources in both models. Any strategy for dealing with overlapping concepts implies a decision about what to do with non-overlapping concepts. However, the intuition is that of the total amount of available RDF and Topic Maps data the portion that is represented with non-overlapping conceptual structures is insignificant compared to the potentially sharable information.

The examples discussed in section 2.2 illustrate some translation problems inherent for extensible frameworks such as RDF and Topic Maps. In such data models the vocabulary is not fixed, but is open for defining new terms for particular application domains. A further complication is that when the data models differ in compositional granularity, the recognition of coarser from finer structures in general can not be done at a syntax level.

On the other hand, there are a number of initiatives, such as Dublin Core [Beck02], [DCMI06], FOAF, etc., that provide fixed vocabularies with well defined meanings. Another trend in the Semantic Web is the rise of data that commits to simple ontologies, like SKOS [Miles05], OBO and BIO. There are also a number of predefined properties and classes in RDF, as well as associations in Topic Maps. The predefined constructs provide necessary information for accurate mapping. Since a full automatic translation between RDF and Topic Maps is not feasible in general, one possibility is to provide specialized translations among common ontologies/schemas. Here we can draw an analogy with natural languages, where there is a variety of specialized language translations, such as in the technical, medical, legal, and financial areas. This analogy suggests that a certain accuracy of the translation can be achieved with a specialized translation. Such domain-specific RDF2TM translations could cover a significant portion of the RDF and Topic Maps data on the Web. The remaining (smaller) portion will be the subject of generic translation.

A set of overlapping concepts in RDF and Topic Maps is given in Table 1. Another example is the RDF dialect for the Dublin Core Metadata Initiative (DCMI) and the corresponding dialect under development from the Topic Maps community [Dich06],[Maic06], [Pepp07a]. A useful set of overlapping concepts can be identified between the TM4L Topic Maps dialect [Dich07], [Dich06] and SKOS. Obviously, such overlaps with one-to-one correspondence enable a straightforward semantics-preserving translation and allow round tripping. Since the overlapping concepts allow translation with features matching the requirements, they are made the subject of a special (focused) translation.

Table I

A set of overlapping concepts from the RDF and Topic Maps predefined vocabularies

RDFTopic Maps
resourceTopic
typeClass-Instance association
subClassOfSuperclass-Subclass association
seeAlsoOccurrence
labelName

We extend the set of overlapping concepts to include TM binary associations and RDF properties. To be consistent with the description of overlapping concepts, we restrict the Topic Maps binary associations to associations with all-scopes. As for RDF, we assume that the properties relating the subjects to the relevant information resources (corresponding to Topic Maps occurrences), are identifiable from the general properties. These restrictions may seem too limiting for potential applications. However, our analysis indicates that in most applications, RDF is used as metadata infrastructure. When the RDF properties are used to relate resources analogous to Topic Maps occurrences, they use Dublin Core (e.g. dc:Relation or dc:Source) or, for educational applications, the LOM vocabulary, which makes them identifiable. The part of non identifiable cases, then, is not so significant.

Requirements

The following is a list of requirements guiding the proposed translation between RDF and Topic Maps.

  1. The data translated from the source language must allow merging without syntactic inconsistencies with the data in the target language.

  2. The translation must cover the overlapping concepts of the two models, minimizing the use of concepts beyond the shared ontological boundaries.

  3. The translation must not change the original meaning of the overlapping concepts.

  4. The translation must respect pragmatic requirements, meaning that the translated data is understood as intended by the agents using the target.

  5. The translation must be faithful to the existing RDF(S) core classes and properties, to the TM core types and to the metadata standards that have pre-existing RDF representation.

  6. For non overlapping concepts preference should be given to transformation into similar predefined concepts when possible.

  7. Queries written against one model must be usable with data translated from the other.

  8. The translation between the two models is supposed to be unguided, that is, no annotation for guiding the translation is assumed.

  9. Round-tripping should be possible.

The rationale behind the second and sixth requirements is based on our intent to support the co-existence of RDF and Topic Maps by enabling them to interoperate without the need of a centralized agreement on new vocabulary terms or how to interpret a translation of a particular construct. The adopted strategy aims to make the two models interoperate without introducing concepts with external meaning (if not necessary) to any of the models. This eliminates any need of pre-existing agreement (between the two communities) on the interpretation of the translated data. Such a strategy favors exchange via data translation carrying no external meaning and which is faithful to the basic vocabularies of both models.

As we aim for a translation process providing a reversible translation between the overlapping concepts of the two models, we need to define the formal meaning of reversible translation.

By reversible translation we mean that a translation of an RDF (TM) dataset to a TM (RDF) dataset followed by a reverse translation of the resulting dataset to an RDF (TM) data will yield the original RDF (TM) dataset.

Definition. Let T1 be translation of an RDF dataset ARDF to a Topic Maps dataset ATM. Let T2 be a reverse translation of ATM to a dataset ARDF. The translations T1 and T2 are said to be reversible iff for any dataset translated by T1 (T2) the translation by T2 (T1) of the output from T1 (T2) generates the original dataset. That is, T2(T1(ARDF)) ≡ ARDF and T1(T2(ATM)) ≡ ATM.

Integrating Generic with Focused Translation

The purpose of defining overlapping concepts is to enable an RDF2TM translation that integrates generic with focused translation in a single system. The focused component of the translation is intended to deal with the constructs identified as “overlapping concepts”. This also includes metadata vocabularies expressed in both RDF and Topic Maps in accordance with recognized standards. For such constructs the translation is supposed to yield a semantics-preserving and reversible translation (also referred sometimes as “overlapping translation”). The remaining constructs are subject to generic translation. We claim that such an approach will result in a translation with an increased pragmatic value.

A significant portion of the information in the Semantic Web comes in three forms: metadata, taxonomies, and lightweight ontologies. (Some authors argue that most of the Semantic Web is metadata [Usch03].) This means that Superclass-Subclass, Class-Instance, and Dublin Core metadata form a vocabulary with a key role in the Semantic Web. If we enable a lossless and faithful-to-the-original-intention translation even only for the data expressed by this “core vocabulary”, that will already be a contribution to the RDF-TM interoperability.

Focused (overlapping) translation

Since the separation between overlapping and non-overlapping concepts is based on syntactic distinctions, the differentiation of their translation does not significantly increase the level of complexity. The following strategy for translating RDF properties into Topic Maps associations can be used as an illustration of this approach.

The RDF type property is converted to Class-Instance association, where the subjects of the property aremapped to the instance members of the association and the objects of the type property are mapped to the corresponding typing topics. The RDF(S) subClassOf property is converted to Superclass-Subclass association, where the subjects of the property are mapped to the subclass association members and the objects of the subClassOf property are mapped to the superclass association members. RDFS label properties are converted to Topic names (baseName). The predefined RDF(S) properties seeAlso are converted to Topic Maps occurrences, where the subject of the property is converted to a topic and the object of the property to the topic occurrence. More specifically, the object of the seeAlso property is converted to an external occurrence of type Information Resource. The remaining RDF properties (describing user defined structures) are subject to generic translation. They are converted into a Topic Maps binary association with two role types: subject and object, mirroring the subject and the object of the corresponding RDF property. The type of the association corresponds to the predicate of the property.

Going in the reverse direction is similar. All TM Class-Instance associations are converted to an RDF type property, where the topic instances are mapped to the subjects and the typing topics of the associations are mapped to the objects of the type property. Superclass-Subclass associations are converted to a subClassOf property, where the players of type superclass are mapped to the objects and the players of type subclass are mapped to the subjects of the subClassOf property.

The remaining binary associations are also subject to focused translation. The association assoc(player1:Role1, player2:Role2) is translated to RDF(S) by creating a property assoc with domain Role1 (Role2) and range Role2 (Role1). Note that the choice of which association role types to map to the domain and which one to the range of the property is arbitrary. The lack of predetermined mapping reflects the fact that, the TM role types play a neutral role in the associations and any decision of how to map them to the domain and range will have equal effect on the translation. For example, one possible translation of the association employment(Christo:employee, WSSU:employer) into an RDF property may result in an RDF property employment with domain employee and range employer. This translation generates the property employment that applies to instances of the class employee and the values of the employment property are instances of the class employer. The other alternative will generate an RDF property employment with domain employer and range employee, which means that the property employment now applies to instances of the class employment and the values of the property are instances of the class employee. Since the Topic Maps associations are directionally neutral, there is no danger of reversing the directionality of the origin. Instead, we are fixing it. As Topic Maps do not assume any directionality, the names of the associations are typically articulated by a direction-neutral terms (e.g. employment). Thus, the selection of the directionality does not affect the readability of the translation result.

Topic Maps external occurrences are converted to a seeAlso property with an object of the occurrence URI. Internal occurrences are also converted to a seeAlso property with an object of the internal resource (string). Finally topic names are converted to an RDFS label property.

Translating between RDF and Topic Maps metadata formats

As stated earlier, the goal of this work is to foster the interchange of resources between RDF and Topic Maps. However, resource semantics is a broad term, which includes ontologies, metadata and instance-data. From the perspective of a librarian, cataloger or publisher, the Semantic Web is a metadata initiative. Therefore, successful interoperation requires an efficient strategy of how the standard categories of metadata relate to each other across RDF and Topic Maps formats. The current web includes ontologies and metadata developed by different communities, such as Dublin Core metadata, FOAF etc. FOAF data currently makes the bulk of the Semantic Web information. Another trend is the rise of data that commits to simple ontologies like SKOS. The proposed approach combining translation of overlapping concepts with generic translation also incorporates methods specializing in specific metadata formats and dialect vocabularies. The inclusion of metadata into “overlapping concepts” is a reflection of the existence of both RDF and Topic Maps standards for encoding the included metadata. The standardization is an important component that integrates them in both languages and makes them overlapping concepts. For example DCMI currently has a Recommendation for expressing Dublin Core in RDF/XML [Beck02], [Nils08] and a new work item was recently approved by ISO for a Type 3 Technical Report on Expressing Dublin Core Metadata Using Topic Maps [Pepp07a], [Pepp07b]. Assuming a two-format representation, the translation turns into a simple mapping between two standard encodings of the same metadata concepts.

Table 2 shows the proposed translation between RDF and Topic Maps representation of Dublin Core Metadata. Based on the recommended encoding of the Simple Dublin Core Metadata Element Set [DCMI06] and following Pepper [Pepp07a], elements contributor, coverage, creator, type, format, language, publisher, relation, source and subject are translated into an association of the corresponding type (see Table 2). The resource to which metadata is being assigned is represented as an association role of type resource, while the other role of the association is of type value. The elements date, description, identifier and rights are represented as occurrences, while the element title is represented as a topic name.

The reverse direction is obvious. Topic Map associations of type contributor, coverage, creator format, language, publisher, relation, source, subject, and type are translated to dc:contributor, dc:coverage, dc:creator, dc:format, dc:language, dc:publisher, dc:relation, dc:source, dc:subject, and dc:type, where the players of type resource are translated to the subject and the player of type value to the object of the corresponding property. The occurrences of type date, description, identifier and rights are translated to properties dc:date, dc:description, dc:identifier and dc:rights. Finally, the topic name is translated to dc:title.

Table II

Translation between Dublin Core Metadata Element Set and Topic Maps

DC Term NameTM Representation
contributorassociation contributor(object: resource, subject: value)
coverageassociation coverage(object: resource, subject: value)
creatorassociation creator(object: resource, subject: value)
dateoccurrence of type date
descriptionoccurrence of type description
formatassociation format(object: resource, subject: value)
identifieroccurrence of type identifier
languageassociation language(object: resource, subject: value)
publisherassociation publisher(object: resource, subject: value)
relationassociation relation(object: resource, subject: value)
rightsoccurrence of type rights
sourceassociation source(object: resource, subject: value)
subjectassociation subject(object: resource, subject: value)
titlename of type title

As for RDF dialects, such as FOAF and SKOS, there are no corresponding recommendations from the Topic Maps ISO side. As an illustration of a translation between SKOS and Topic Maps, we present sketchy translations between associations from the TM4L Dialect of Topic Maps and SKOS properties. The association Related(player1:Relation, player2:Relation) is translated to RDFS by creating a symmetric property rdfs:related by defining a symmetric property rdfs:related which entails the inverse relation of subject and object.

Generic Translation

Semantics preserving translation is just one of the criteria guiding our translation strategy. As we mentioned earlier, the translation is intended to facilitate interoperability. The interoperability is measured by the ability of the two models to share common concepts. Concepts that have no match in the other model are among the ones that make the translation task difficult. For such concepts it is possible to provide translation generating semantically equivalent results such that even a user familiar with RDF and Topic Maps will hardly recognize and understand. Therefore, for non overlapping concepts we combine our criteria with pragmatic interoperability. Pragmatic interoperability is used to measure the utilization of the translation result for achieving the agent’s goals. It is in line with the intentional consistency as a measure of the occurrences when the intended meaning of the translation is in agreement with its actual interpretation from agents operating on the source. The proposed generic translation is intended to generate syntactically correct encoding in terms of the target model with minimal intentional inconsistency with respect to the original. All Topic Maps and RDF concepts that do not have corresponding counterparts in the other model (i.e. with no matching target concepts) are subject to generic translation. Strictly speaking, the term “generic translation” refers to a combination of translations and transformations. The semantics of particular source concept may change its meaning when translated into the target model in order to make use of existing concepts with similar meaning instead of introducing new ones. Syntactically correct RDF (Topic Maps) output generated by the proposed approach does not always imply a compete translation. It is possible that part of the input changes both the representation and semantics during the translation.

The Topic Maps N-ary associations are dealt with generic translation. The concept of an n-ary relationship can be represented in multiple ways in RDF. We propose a translation where an association n-assoc(player1:Role1, player2:Role2, .., playern:Rolen) is translated to RDF by creating blank nodes as shown in Figure 1.

N-ary-relation

jpg image ../../../vol1/graphics/Dichev01/Dichev01-001.jpg

Figure 1. N-ary Relationship

The other Topic Map concept that is a subject to a generic translation is scope. We translate scope by defining an RDF class Scope. The intention is for all scopes to be defined as a subclass of the class Scope. Thus each scoped item (e.g. name or occurrence) becomes a member of a particular “scope” subclass in addition to its preexisting class memberships. Such scope-based classifications allow additional grouping of the corresponding items based on their scopes.

The variant names are translated into a new RDFS property altLabel defined as a sub-property of the property rdfs:label. The use of the term altLabel was motivated by its inclusion in the SKOS vocabulary.

The non-overlapping concepts from the RDF side include containers and collections. The three types of containers: bag, sequence and alternative are intended for a different type of resource grouping. We transform RDF containers into compositions of the predefined Topic Maps InstanceOf and Whole-Part binary associations. For each container, a topic of type Bag, Seq or Alt is generated. This topic container is also a role payer of type whole. The contained items, called members, are translated as role players of type part and linked by the Whole-Part association to the container topic.

For example, the statement “Group1 consists of the students Elva, James and Paul” with the following RDF representation.


   <rdf:Bag>
      <rdf:li rdf:resource="#Elva"/>
      <rdf:li rdf:resource="#James"/>t;
      <rdf:li rdf:resource="#Paul"/>
   </rdf:Bag>

is translated into the following sequence of Topic Maps assertions


    InstanceOf(Group1:instance, Bag:class)
    Whole-Part(Group1: whole, Elva: part)
    Whole-Part(Group1: whole, James: part)
    Whole-Part(Group1: whole, Paul: part)

The remaining type of containers rdf:Seq or rdf:Alt are translated in a similar fashion. The difference is that the container topic is now of type Seq or Alt instead of Bag. Thus each container is composed from multiple Whole-Part associations applied to the container topic of type Bag/Seq/Alt.

The translation of the RDF built-in structure List is similar with some abuse of the Whole-Part association. To avoid defining new non-standard associations we (inaccurately) treat list members as part of a particular container of type List. Thus RDF list members are represented as parts of a topic of type List .

Implementation and Examples

The tool providing the translation between RDF and Topic Maps has been designed as a plug-in to the Topic Maps editing environment, TM4L (http://compsci.wssu.edu/iis/nsdl/ download.html). TM4L [Dich06] development was driven by two competing considerations: to provide a general purpose Topic Map editor and to create an e-learning environment providing authoring and browsing support for creating ontology-based learning content and for structuring digital repositories. To be consistent with the intended support and functionality, TM4L has extended the basic Topic Map vocabulary with predefined associations that are of specific importance to organizing digital collections. The vocabulary supported by TM4L can be viewed as a light Topic Map dialect. The translation tool being a plug-in to TM4L interprets the TM4L (extended) vocabulary as a basic Topic Maps vocabulary. That explains why the associations of type Whole-Part and Related are dealt with focused translation. The first version of the plug-in was released for public use and testing in October 2007. The next version is planed for August 2008.

The following are examples intended to demonstrate the work of the translation plug-in. The examples are presented based on RDF/XML format (for RDF) and XTM (for Topic Maps). The reason to use the verbose XTM format is because (i) the Topic Map input/output from TM4L is in XTM format; (ii) there is no official standard for a compact Topic Maps syntax.

The first one demonstrates translations of RDF to Topic Maps. The RDF statement asserting that the resource with rdf:label property value Spinach Lasagna is an instance of the resource with rdf:label property value Lasagna is translated into an equivalent Topic Maps set of assertions: namely, the topic with basename Spinach Lasagna is an instance of the topic with basename Lasagna.


        <rdf:Description rdf:ID="Spinach-Lasagna-Id">
          <rdf:type rdf:resource="#Lasagna-Id"/>
          <rdfs:label>Spinach Lasagna</rdfs:label>
        </rdf:Description>

        <rdf:Description rdf:ID="Lasagna-Id">
          <rdfs:label>Lasagna</rdfs:label>
        </rdf:Description>

	<topic id="Spinach-Lasagna-Id">
   	  <baseName>
     	    <baseNameString>Spinach Lasagna</baseNameString>
   	  </baseName>
   	  <instanceOf>
     	    <topicRef xlink:href="#Lasagna-Id"/>
   	  </instanceOf>
	</topic>
	<topic id="Lasagna-Id">
   	  <baseName>
     	    <baseNameString>Lasagna</baseNameString>
   	  </baseName>
	</topic>

In the following examples we use obvious short expressions, e.g. “resource Lasagna” instead of “resource with rdf:label property value Lasagna” and “topic Lasagna” instead of “topic with base name Lasagna” in order to simplify the readability of the description.

The next example illustrates translation of the Topic Maps Superclass-Subclass association into rdf:subClassOf property. The Topic Maps expressions asserting that the topic Lasagna plays a role of subclass and Pasta Dishes plays a role of superclass in the association of type Superclass-Subclass is translated into a set of RDF statements asserting that the resources Lasagna and Pasta Dishes are instances of rdfs:Class and Lasagna is subClassOf Pasta Dishes.


        <topic id="x1oajte2sn-1e5c">
           <baseName>
              <baseNameString>Pasta Dishes</baseNameString>
           </baseName>
        </topic>
        <topic id="x1oajte2sn-1e5e">
           <baseName>
              <baseNameString>Lasagna</baseNameString>
           </baseName>
        </topic>
        <topic id="x1oajte2sn-1e3c">
           <baseName>
              <baseNameString>Superclass-Subclass</baseNameString>
           </baseName>
           <baseName>
               <scope>
                  <topicRef xlink:href="#x1oajte2sn-1e3e" />
                </scope>
                <baseNameString>is superclass of</baseNameString>
           </baseName>
           <baseName>
               <scope>
                  <topicRef xlink:href="#x1oajte2sn-1e41" />
               </scope>
           <baseNameString>is subclass of</baseNameString>
           </baseName>
        </topic>
        <topic id="x1oajte2sn-1e3e">
            <baseName>
               <baseNameString>Superclass</baseNameString>
            </baseName>
        </topic>
        <topic id="x1oajte2sn-1e41">
            <baseName>
               <baseNameString>Subclass</baseNameString>
            </baseName>
        </topic>
        <association>
           <instanceOf>
              <topicRef xlink:href="#x1oajte2sn-1e3c" />
           </instanceOf>
           <member>
               <roleSpec>
                   <topicRef xlink:href="#x1oajte2sn-1e3e" />
               </roleSpec>
               <topicRef xlink:href="#x1oajte2sn-1e5c" />
           </member>
           <member>
               <roleSpec>
                   <topicRef xlink:href="#x1oajte2sn-1e41" />
                </roleSpec>
                <topicRef xlink:href="#x1oajte2sn-1e5e" />
           </member>
        </association>

        <rdf:Description rdf:ID="Pasta Dishes-Id">
        <rdfs:label> Pasta Dishes </rdfs:label>
           <rdf:type
             rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
        </rdf:Description>

        <rdf:Description rdf:ID=" Lasagna-Id">
          <rdfs:label> Lasagna </rdfs:label>
          <rdf:type
            rdf:resource="http://www.w3.org/2000/01/rdf-schema#Class"/>
          <rdfs:subClassOf
            rdf:resource="http://compsci.wssu.edu/iis/tm4l/#PastaDishes"/>
        </rdf:Description>

The next example illustrates a generic translation using the user-defined binary association Recommended. The Topic Maps statements asserting that Turkey Dish playing a role of Dish and Thanksgiving playing a role of Event in the Recommended association are translated into a set of RDF statements asserting that Recommended is a property with rdfs:domain Dish and rdfs:range Event. Turkey Dish is an instance of Dish and is Recommended for Thanksgiving, which is an instance of Event. To simplify the illustration, the topic definition Dish, Turkey Dish, Event and Thanksgiving have been omitted from the xtm verbose encoding in the following example.


        <topic id="x1oajte2sn-280d">
            <baseName>
               <baseNameString>Recommended</baseNameString>
            </baseName>
           <baseName>
        <scope>
                <topicRef xlink:href="#x1oajte2sn-280f" />
             </scope>
                    <baseNameString>Dish</baseNameString>
             </baseName>
             <baseName>
                <scope>
                        <topicRef xlink:href="#x1oajte2sn-2812" />
             </scope>
                 <baseNameString>Event</baseNameString>
             </baseName>
         </topic>
         <association>
             <instanceOf>
                <topicRef xlink:href="#x1oajte2sn-280d" />
             </instanceOf>
             <member>
                <roleSpec>
                    <topicRef xlink:href="#x1oajte2sn-280f" />
                 </roleSpec>
                 <topicRef xlink:href="#x1oajte2sn-2809" />
              </member>
              <member>
                 <roleSpec>
                     <topicRef xlink:href="#x1oajte2sn-2812" />
                 </roleSpec>
                 <topicRef xlink:href="#x1oajte2sn-280b" />
               </member>
            </association>

        <rdf:Property rdf:ID="Recommended">
          <rdfs:domain rdf:resource="#"Dish"/>
          <rdfs:range rdf:resource="#Event"/>
        </rdf:Property>

        <rdf:Description
          rdf:about="http://compsci.wssu.edu/iis/tm4l/#TurkeyDish">
           <rdfs:label> Turkey Dish </rdfs:label>
           <rdf:type
             rdf:resource="http://www.w3.org/2000/01/rdf-schema#Dish"/>
           <ex:Recommended
             rdf:about="http://compsci.wssu.edu/iis/tm4l/#Thanksgiving">
        </rdf:Description>

        <rdf:Description
          rdf:about="http://compsci.wssu.edu/iis/tm4l/#Thanksgiving">
           <rdfs:label> Thanksgiving </rdfs:label>
           <rdf:type
             rdf:resource="http://www.w3.org/2000/01/rdf-schema#Event"/>
        </rdf:Description>

The final example illustrates translation of Dublin Core meta-data represented in RDF/XML format into Topic Maps. The RDF statements asserting that Dave Beckett is a creator of Dublin Core Metadata Initiative - Home Page with creation date of 2001-01-16 is translated into Topic Maps statements asserting that the topic Dublin Core Metadata Initiative - Home Page topic with occurrence 2001-01-16 of type Date plays a role of Resource, while the topic Dave Beckett plays a role of Value in the Creator association.


        <rdf:Description rdf:about="http://dublincore.org/">
           <dc:title>Dublin Core Metadata Initiative - Home Page</dc:title>
           <dc:creator>Dave Beckett</dc:creator>
           <dc:date>2001-01-16</dc:date>
        </rdf:Description>

        <topic id="x1osden5er-38">
            <subjectIdentity>
                 <subjectIndicatorRef xlink:href="http://dublincore.org/" />
            </subjectIdentity>
            <baseName>
                  <baseNameString>Dublin Core Metadata Initiative - Home
                    Page</baseNameString>
            </baseName>
            <occurrence>
                 <instanceOf>
                     <topicRef xlink:href="#x1osden5er-3b" />
                 </instanceOf>
                 <resourceData>2001-01-16</resourceData>
             </occurrence>
        </topic>
        <topic id="x1osden5er-46">
           <baseName>
               <baseNameString>Dave Beckett</baseNameString>
           </baseName>
        </topic>
        <topic id="x1osden5er-3e">
          <baseName>
              <baseNameString> Creator </baseNameString>
          </baseName>
          <baseName>
              <scope>
                   <topicRef xlink:href="#x1osden5er-40" />
              </scope>
              <baseNameString>Resource</baseNameString>
           </baseName>
           <baseName>
             <scope>
                 <topicRef xlink:href="#x1osden5er-43" />
             </scope>
             <baseNameString>Value</baseNameString>
          </baseName>
        </topic>
        <association>
           <instanceOf>
               <topicRef xlink:href="#x1osden5er-3e" />
           </instanceOf>
            <member>
                <roleSpec>
                     <topicRef xlink:href="#x1osden5er-40" />
                 </roleSpec>
                 <topicRef xlink:href="#x1osden5er-38" />
            </member>
            <member>
                 <roleSpec>
                     <topicRef xlink:href="#x1osden5er-43" />
                 </roleSpec>
                 <topicRef xlink:href="#x1osden5er-46" />
            </member>
        </association>
        <topic id="x1osden5er-3b">
          <baseName>
              <baseNameString>Date</baseNameString>
          </baseName>
        </topic>

Related Work

The Web and Semantic Web visions are to share and reuse as much information as possible. A significant amount of work is being done to match different vocabularies. In this area there have been considerable studies of approaches for ontology mapping where the concept of sharing and reusability has been interlinked to merging, alignment, articulation and fusion of ontologies [Kalf03], [Klein01, [Shvai05]. In parallel, a number of different languages for ontology modeling have been proposed [Cran01], [Hunt03], [UML], [XTM], [RDF], [OWL]. The problem of interoperation of heterogeneous data, based on different data models and modeling languages like RDF, Topic Maps, UML, etc. implies model-based methods aiming at model-level interoperability. As a result, a number of informal model-to-model mappings have been defined, including several proposals for mapping between Topic Maps and RDF [Bowe02], [Cran01], [Creg05], [DCMI06], [Dich07], [Dich06]. Despite the emerging interest in the problem and the availability of some mapping tools, the reports on integration and reuse of data across the two models are scarce.

Moore [Moore01] was perhaps the first to propose a general strategy towards integration between Topic Maps and RDF. Lacher and Decker [Lach01] presented a model for mapping between the two standards by exploiting the “Topicmaps.net’s Processing Model for XTM 1.0” [Newc01]. Technically, the conversion from Topic Maps to RDF is achieved by mapping the Topic Map graph model to an RDF graph. Another work in the area of TM2RDF mapping has been presented by Ogievetski. His starting point is also [Newc01] but he uses XSLT-based technology to translate any topic map document expressed in XTM into RDF abbreviated syntax. The relation between Topic Maps and RDF are discussed in detail by Garshol [Gars03], [Gars05]. The proposal in [Cran01] is the most mature work in the field, which describes how to convert information back and forth between the two technologies, how to convert schema information, and how to do queries across both information representations. Some strategies and algorithms to achieve these goals are also presented along with a discussion of the problems of conversion between Topic Maps and RDF. A practical result of this work is the extension of the Ontopia’s Topic Map browser Omnigator (http://www.ontopia.net) with functionality allowing export/import between Topic Maps and RDF data.

An interesting work on integration between the Topic Maps and RDF technologies has been done as part of the META project, resulting in a set of tools for converting, editing and navigating metadata expressed in either language [Cian03]. In this work the authors present their approach to the bidirectional conversion of RDF and Topic Maps and show how the use of schemas and standard predicates in RDF can lead to a flexible integration of the two languages. This integration is in the heart of the effort aimed at incorporating separate modules into a single editing and navigation tool that can be used for metadata collections expressed in both languages.

An analysis of the relationship between Topic Maps and RDF and a complete review and comparison of the RDF/Topic Maps interoperability proposals can be found in [Pepp06a]. Despite the efforts and the proposed Guidelines for RDF/Topic Maps Interoperability [Pepp06b], however, there is no fully worked out and widely agreed upon solution to achieving data interoperability between RDF and Topic Maps yet.

Among the relevant works there are also the efforts for translating between Topic Maps and ontology models such as OWL and UML [Colo06], [Creg05].

While our work might seem close to the previous proposals on the surface, there are principal differences stemming from the different perception of the commonalities in both models. For example, the key correspondences between RDF and Topic Maps according to Garshol and Pepper [Gars03], [Pepp06b] are “subject (TM) — resource (RDF)” and “topic (TM) — node (RDF)”, which is reflected in their mapping strategy. In contrast, our approach builds on ontological correspondence. Commonalities are better explicated in correspondences between how the things are related than in correspondences between the things alone. Thus, the “overlapping approach” reflects our understanding of the role of a shared ontological ground for meaning preserving translation. This sets the starting point in our translation strategy on overlapping concepts with reliance on existing and established vocabularies (e.g. RDF/RDFS, Dublin Core, and SKOS). The key factors of this strategy include minimizing the need of (i) a centralized agreement on new vocabulary terms emerging from the translation and (ii) an agreement of how to guide the translation process.

In contrast to previous work, considering the completeness of translation as a key requirement, our starting point here was the question: Which Topic Maps constructs can be represented naturally in RDF (i.e. as RDF graphs) without RDF vocabulary extension? We also asked the reverse question: Which are the RDF constructs naturally expressible in Topic Maps? Since, generally, full automatic translation between RDF and Topic Maps is not possible, one possibility is to focus on semantic-preserving translation of the ontologies/schemas with common conceptual space. Translation satisfying such requirements can be achieved by identifying the overlapping conceptual domains of both models. Another difference is that our approach does not assume any annotation for guiding the translation. As a result, pre-translating human involvement is eliminated.

Among the most challenging tasks in the area of Topic Maps/RDF interoperability is the problem of translating the Topic Maps concept of scope. Except for Garshol [Gars03] no other works handle scope in satisfactory manner. The list of challenging problems also includes mapping variant names and RDF types such as containers and collections. None of the existing tools which provide translation between RDF and Topic Maps are able to handle containers and collections. The only approach for dealing with variant names is that of Ciancarini et al [Cian03], [Pepp06c]. They suggest translating variant names as compound concepts, which is quite unintuitive. Our strategy with non-overlapping concepts is similar to the way terms are traditionally translated from one language to another with a more limited vocabulary, namely, with a maximal reuse of the source vocabulary that is able to convey the intended meaning of the original.

Conclusion

Taking the information from one representation scheme (such as Topic Maps) and extracting some or all of it for use in another scheme (such as RDF) is a difficult task [Bowe02]. In fact, few working tools exist to perform such transformations. One reason such conversions are difficult is that representation schemes differ in the basic structural constructs, granularity and schema constraints they provide for organizing information. As a consequence, straightforward, one-to-one mappings between schemes rarely exist.

In this context, the presented work is a contribution to the efforts aimed at improving the interoperability between Topic Maps and RDF. It has been carried on as a part of the TM4L project. The driving insight was to allow TM4L users to use RDF data and also enable RDF applications to use Topic Maps data produced with TM4L. During the implementation stage, the initial objective was broadened to create a general tool for RDF - Topic Maps translation. In the proposed approach, the balance between translation and transformation is in agreement with the target model. The type of translation applied to a particular construct depends on the level of overlapping between the corresponding concepts in the two models. The idea is to provide a translation, from which the reader in the target is able to grasp the intended meaning of the original author. This implies a translation with acceptable loss of information when complete translation is impractical.

The proposed Topic Maps/RDF translation approach is implemented as a plug-in for TM4L. Although the illustrative examples mostly cover Topic Maps to RDF mapping, the actual implementation enables round tripping translation for a significant class of RDF/Topic Maps concepts. The idea is to enable Topic Maps users not only to merge existing Topic Maps data with RDF data but also to exploit some inference capability and then translate the results back into Topic Maps.

References

[Beck02] Beckett D., Miller E., Brickley D. Expressing Simple Dublin Core in RDF/XML, 2002, Retrieved July 17, 2008, from : http://dublincore.org/documents/dcmes-xml/

[Bowe02] Bowers, S., Delcambre, L. “On modeling Conformance for flexible Transformation over data models”. In Proc. of the Workshop on Knowledge Transformation for the Semantic Web at the 15th European Conference on Artificial Intelligence (KTSW-2002), Lyon, 2002.

[Cian03] Ciancarini P., Gentilucci R., Pirruccio M., Presutti V., and Vitali F. Metadata on the web: On the integration of RDF and Topic Maps. In Proc. Conf. on Extreme Markup Languages, Montreal, Canada, 2003.

[Colo06] Colomb, R., Raymond K., Hart L., Emery P., Welty C,. Xie G. T, and Kendall E.. The Object Management Group Ontology De¯nition Metamodel. In F. Ruiz, C. Calero, and M. Piattini, editors, Ontologies for Software Engineering and Technology. Springer, 2006. doi:10.1007/3-540-34518-3_8.

[Cran01] Cranefield S., Networked Knowledge Representation and Exchange using UML and RDF, Journal of Digital Information, Volume 1(8) Article No. 44, 2001-02-15

[Creg05] Cregan A., (2005) Building Topic Maps in OWL-DL. In: Conference of IDEAllianc Extreme Markup Languages 2005: Proceedings, Montréal. Retrieved July 17, 2008, from: http://www.idealliance.org/papers/extreme/proceedings//html/2005/Cregan01/EML2005Cregan01.html

[DCMI06] DCMI Usage Team (2006). DCMI Metadata Terms. Retrieved July 17, 2008, from: http://www.dublincore.org/documents/dcmi-terms/

[Dich07] Dicheva D. & Dichev C. Authors Support In The TM4L Environment, International Journal "Information Technologies and Knowledge" Vol.1 / 2007, 215-219.

[Dich06] Dicheva, D. & Dichev, C.: TM4L: Creating and Browsing Educational Topic Maps, British Journal of Educational Technology - BJET, 37(3) (2006) 391-404

[Gars03] Garshol, L. M.: Living with Topic Maps and RDF: Topic Maps, RDF, DAML, OIL, OWL, TMCL. XML Europe Conference 2003, London, England, 2003.

[Gars05] Garshol, L.M.: Q: A model for topic maps: Unifying RDF and topic maps. Extreme Markup Languages, Montreal, Canada 2005.

[Hunt03] Hunting (eds.) 2003. XML Topic Maps: Creating and Using Topic Maps for the Web. Boston: Addison-Wesley.

[Kalf03] Kalfoglou, Y., Schorlemmer, M., Ontology Mapping: the State of the Art, The Knowledge Engineering Review, 18(1), 2003, pp. 1-31. doi:10.1017/S0269888903000651.

[Klein01] Klein M. Combining and relating ontologies: an analysis of problems and solutions. In IJCAI-2001 Workshop on Ontologies and Information Sharing, IJCAI'01, Seattle, USA, Aug. 4--5, 2001

[Lach01] Lacher, Martin, and Stefan Decker, On the integration of Topic Map data and RDF data, In Extreme Markup Languages 2001, Montreal, Canada, 2001

[Miles05] Miles, A. & Brickley, D. (2005). SKOS Core Guide. Retrieved July 17, 2008, from: http://www.w3.org/TR/2005/WD-swbp-skos-core-guide-20051102/

[Maic06] Maicher, L.: Dublin Core Metadata Terms as Topic Map. Retrieved July 17, 2008, from: http://www.informatik.uni-leipzig.de/~maicher/topicmaps/DCMT.ltm

[Moore01] Moore, G., RDF and TopicMaps: An Exercise in Convergence, In XML Europe 2001, Berlin, Retrieved July 17, 2008, from: http://www.topicmaps.com/topicmapsrdf.pdf.

[Newc01] Newcomb, Steven R., and Michel Biezunski, Topicmaps.net’s Processing Model for XTM 1.0, version 1.0.2, 25 July 2001, Retrieved July 17, 2008, from: http://www.topicmaps.net/pmtm4.htm.

[Nils08] Nilsson M., Baker T. Notes on DCMI specifications for Dublin Core metadata in RDF, 2008, Retrieved July 17, 2008, from: http://dublincore.org/documents/2008/01/14/dc-rdf-notes/

[Ogie01] Ogievetsky, Nikita, XML Topic Maps through RDF glasses, In Extreme Markup Languages 2001, Montreal, Canada, Retrieved July 17, 2008, from: http://www.cogx.com/rdfglasses.html.

[ODM08] Ontology Definition Metamodel, IBM Sandpiper Software, Inc, Retrieved July 17, 2008, from: http://www.omg.org/docs/ad/05-08-01.pdf

[Ontop03] Ontopia: The RTM RDF to Topic Maps Mapping: Definition and Introduction. [Ontopia TR]. Version 0.2., 2003, Retrieved July 17, 2008, from: Ontopia http://www.ontopia.net/topicmaps/materials/rdf2tm.html.

[Patel05] Patel, M., Koch T., Doerr M., Tsinaraki C. Semantic Interoperability in Digital Library Systems, WP5: Knowledge Extraction and Semantic Interoperability DELOS2 Network of Excellence in Digital Libraries, 2005, Retrieved July 17, 2008, from: http://delos-wp5.ukoln.ac.uk/project-outcomes/SI-in-DLs/SI-in-DLs.pdf

[Pepp07a] Pepper, S. Expressing Dublin Core in Topic Maps. Proc. TMRA 2007, Leipzig, 2007. Also available at: http://www.ontopedia.net/pepper/papers/DCinTopicMaps.pdf

[Pepp07b] Pepper, S., Naito M, Durusau, P. N0884 - Draft Dublin Core - Topic Maps , Information Technology - Document Description and Processing Languages ISO/IEC JTC 1/SC 34, 2007. Retrieved July, 17, 2008, from: http://www.jtc1sc34.org/repository/0884.htm

[Pepp00] Pepper, S. The TAO of Topic Maps, 2000. Retrieved July 17, 2008, from: at http://www.ontopia.net/topicmaps/materials/tao.pdf.

[Pepp06a] Pepper, S., Vitali, F., Garshol, L.M., Gessa, N. , Presutti, V. (eds.). A Survey of RDF/Topic Maps Interoperability Proposals. W3C Working Group, 2006 Note. Retrieved July 17, 2008, from: http://www.w3.org/TR/rdftm-survey/

[Pepp06b] Pepper, S., Presutti, V., Garshol, L.M., Vitali, F.: Guidelines for RDF/Topic Maps Interoperability. W3C Editor's Draft 30 June 2006, Retrieved July 17, 2008, from: http://www.w3.org/2001/sw/ BestPractices/RDFTM/guidelines-20060630.html

[Pepp06c] Pepper, S., Presutti V., Garshol L.M.and Vitali.F. “Reusing data across Topic Maps and RDF.” In Proceedings of Extreme Markup Languages 2006.

[Shvai05] Shvaiko P., Euzenat J.: A Survey of Schema-based Matching Approaches. Journal on Data Semantics (JoDS), IV, LNCS 3730, pp. 146-171, 2005.

[Souz04] de Souza, K.X.S., Davis, J.: Using an aligned ontology to process user queries, Lecture notes in computer science, 44-53, Springer-Verlag 2004.

[Stuc02] Stuckenschmidt H., Ontology-Based Information Sharing in Weakly Structured Environments, PhD thesis, AI Department, Vrije Universiteit Amsterdam, 2002, Retrieved July 17, 2008, from: http://citeseer.ist.psu.edu/article/stuckenschmidt02ontologybased.html

[UML] Unified Modeling Language Resource Page of the Object Management Group, Retrieved July 17, 2008, from: http://www.uml.org/

[Usch03] Uschold M., "Where Are the Semantics in the Semantic Web?" AI Magazine, vol. 24, no. 3, 2003, pp. 25–36.

[Volz04] Volz R., Goble C., Studer R. Will the Semantic Web Scale ?, Proposal for a Debate Panel at WWW 2004, Retrieved July 17, 2008, from: http://km.aifb.uni-karlsruhe.de/conferences/debate/proposal.pdf

[XTM] Topic Maps - XML Syntax, Information Technology - Document Description and Processing Languages, ISO/IEC JTC1/SC34, 2006 Retrieved July 17, 2008, from: http://www.isotopicmaps.org/sam/sam-xtm/

[RDF] World Wide Web Consortium, RDF/XML Syntax Specification (Revised), W3C Working Recommendation, 10 February 2004, Retrieved July 17, 2008, from:http://www.w3.org/TR/rdf-syntax-grammar.

[OWL] World Wide Web Consortium, OWL Web Ontology Language, Recommendation, 10 February 2004, Retrieved July 17, 2008, from: http://www.w3.org/TR/owl-features.



[1] For single TM assertions we use notation based on LTM (http://www.ontopia.net/download/ltm.html