• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
TMCL and OWL
 

TMCL and OWL

on

  • 1,706 views

A number of proposals have been made for Topic Maps/OWL interoperability, but this is really looking for interoperability on the wrong level. This paper instead looks at interoperability between OWL ...

A number of proposals have been made for Topic Maps/OWL interoperability, but this is really looking for interoperability on the wrong level. This paper instead looks at interoperability between OWL and TMCL, and shows how it is possible to convert OWL ontologies into TMCL schemas and vice versa, once a mapping for the vocabulary is available.

Statistics

Views

Total Views
1,706
Views on SlideShare
1,701
Embed Views
5

Actions

Likes
2
Downloads
24
Comments
0

3 Embeds 5

http://www.topicmapslab.de 3
http://www.slideshare.net 1
http://www.slashdocs.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    TMCL and OWL TMCL and OWL Presentation Transcript

    • TMCL and OWL Lars Marius Garshol <larsga@bouvet.no> 2008-10-17 TMRA 2008
    • RDF/TM interoperability today
      • Instance data can be converted back and forth
        • effectively allows RDF vocabularies to be used in TMs, and vice versa
      • Schemas, however, cannot be converted
        • must be converted manually
        • to do this, detailed knowledge of RDFS, OWL, and TMCL is needed
        • awkward and error-prone
      • Schemas are needed for
        • documentation,
        • schema-driven editors,
        • validation,
        • reasoning,
        • etc
      ?
    • Comparing TMCL with RDFS&OWL
      • Similarities
        • describe correct use of vocabularies
        • vocabularies, not separate languages
      • Differences
        • obviously based on different technologies (TM vs RDF)
        • TMCL intended for individual projects, RDFS/OWL for open semantic web
        • TMCL has validation semantics, while RDFS/OWL have reasoning semantics
    • Validation Rule: Every dc:creator must be a person dc:creator person tm:type-instance dc:creator sheep tm:type-instance
    • Reasoning Rule: Every dc:creator must be a person dc:creator person rdf:type dc:creator sheep rdf:type rdf:type owl:disjointWith
    • RDFS and OWL
      • Divided into four layers extending each other
      • Basic RDFS features:
        • rdfs:Class - declares a class
        • rdfs:Property - declares a property
        • rdfs:domain - restricts type of subject
        • rdfs:range - restricts type of object
      • Example:
        • person rdf:type rdfs:Class .
        • resource rdf:type rdfs:Class .
        • dc:creator rdf:type rdfs:Property .
        • dc:creator rdfs:domain resource .
        • dc:creator rdfs:range person .
      OWL Full OWL DL RDFS OWL Lite
    • TMCL
      • Two parts:
        • declarative constraints
        • TMQL-based constraints
      • In addition:
        • CTM templates for ease of authoring
      • Basic features much as in RDFS
        • tmcl:topictype
        • tmcl:nametype
        • tmcl:occurrencetype
        • tmcl:associationtype
        • tmcl:roletype
      • c isa tmcl:roleplayer-constraint;
      • tmcl:card-min: 0 ;
      • tmcl:card-max: 1 .
      • tmcl:applies-to(tmcl:constraint-role : c, tmcl:assoctype-role : dc:creator )
      • tmcl:applies-to(tmcl:constraint-role : c, tmcl:roletype-role : dcc:resource )
      • tmcl:applies-to(tmcl:constraint-role : c, tmcl:topictype-role : resource )
    • Conversion principles
      • Follow instance data conversion
        • that is, source data valid against source schema should produce valid data against translated schema
        • means schema conversion is based on RTM/TMR mappings
      • Translate intent
        • on the level of: “every dc:creator must be a person”
        • ignore the reasoning/validation issue
      • Aim for introspectable schemas
        • be reasoning-friendly in RDF where possible (e.g. avoid OWL Full)
        • prefer TMCL Core over TMCL Query
    • What the conversion does
      • We can convert quite a lot of RDFS/OWL to TMCL
        • if we restrict ourselves to TMCL Core then we can convert much less
      • Reverse conversion is similar
        • however, some features of TMCL are hard to reproduce in RDFS/OWL
      OWL Full OWL DL RDFS OWL Lite TMCL Query TMCL Core
    • RDF-to-TM basics
      • Any rdf:Class becomes a tmcl:topictype
        • same for owl:Class, obviously
      • Any rdf:Property becomes a statement type
        • the question is: which?
        • the RTM mapping answers this for us
      • Any rdf:domain statement becomes a constraint
        • which type of constraint depends on the RTM mapping
      • Any rdf:range statement becomes a constraint
        • for name types: an error
        • for occurrence types: a datatype constraint
        • for association types: as for domain
    • Name type mapping
      • x rdf:domain y
      • x rtm:maps-to rtm:basename
      • x isa tmcl:nametype .
      • ?c isa tmcl:topicname-constraint .
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:topictype-role : y )
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:nametype-role : x )
      What kind of constraint to map to?
    • Occurrence type mapping
      • x rdfs:domain y
      • x rtm:maps-to rtm:occurrence
      • x isa tmcl:occurrencetype .
      • ?c isa tmcl:topicoccurrence-constraint .
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:topictype-role : y )
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:occurrencetype-role : x )
    • Occurrence type (2)
      • x rdfs:range z
      • x rtm:maps-to rtm:occurrence
      • ?c isa tmcl:occurrencedatatype-constraint
      • tmcl:datatype: z .
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:occurrencetype-role : x )
    • Association type mapping
      • x rdfs:domain y
      • x rtm:maps-to rtm:association
      • x rtm:subject-role s
      • x isa tmcl:associationtype .
      • s isa tmcl:roletype .
      • ?c isa tmcl:associationrole-constraint
      • tmcl:card-min: 1
      • tmcl:card-max: 1 .
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:assoctype-role : x )
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:roletype-role : s )
      • ?c2 isa tmcl:roleplayer-constraint .
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : x )
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : s )
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : y )
    • Association type mapping (2)
      • x rdfs:range z
      • x rtm:maps-to rtm:association
      • x rtm:object-role o
      • x isa tmcl:associationtype .
      • o isa tmcl:roletype .
      • ?c isa tmcl:associationrole-constraint
      • tmcl:card-min: 1
      • tmcl:card-max: 1 .
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:assoctype-role : x )
      • tmcl:applies-to(tmcl:constraint-role : ?c, tmcl:roletype-role : o )
      • ?c2 isa tmcl:roleplayer-constraint .
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : x )
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : o )
      • tmcl:applies-to(tmcl:constraint-role : ?c2, tmcl:assoctype-role : z )
    • RTM mapping
      • rdfs:subClassOf  TMDM superclass-subclass associations
      • rdfs:subPropertyOf  TMDM superclass-subclass associations
      • rdfs:label  base name with the default type
      • rdfs:comment  occurrence of type rdfs:comment
      • rdfs:seeAlso  occurrence of type rdfs:seeAlso
      • rdfs:isDefinedBy  assoc. of type tmcl:definedBySchema
    • OWL to TMCL
      • Much harder, but some things are easy
        • owl:disjointWith -> tmcl:exclusive-instance
        • owl:complementOf -> tmcl:exclusive-instance
        • owl:equivalentClass -> subclass loop
        • owl:equivalentProperty -> subclass loop
        • cardinalities -> cardinalities
        • owl:InverseFunctionalProperty -> unique occurrence constraint
        • documentary properties -> use RTM mapping
      • Some OWL, strangely, becomes input to the mapping
        • owl:SymmetricProperty
        • owl:ObjectProperty
        • ...
    • Converts to TMCL Query
      • owl:intersectionOf
      • owl:unionOf
      • owl:allValuesFrom
      • owl:someValuesFrom
      • owl:hasValue
    • Documentary information
      • All convertible using RTM
        • whether it gets picked up on the other side is not clear
      • owl:DeprecatedClass
      • owl:DeprecatedProperty
      • owl:versionInfo
      • owl:priorVersion
      • owl:backwardCompatibleWith
      • owl:incompatibleWith
      • owl:Schema
      • owl:differentFrom & owl:AllDifferent
      • owl:oneOf
    • Non-convertible
      • owl:TransitiveProperty
        • no constraints, only used for reasoning
        • no way to reproduce this in TMCL
        • convert as is, to let software pick it up if supported
      • owl:imports
        • really abstract syntax, shouldn’t be converted
      • owl:OntologyProperty
        • no equivalent in Topic Maps
      • owl:AnnotationProperty
        • ditto
    • TMCL to RDFS/OWL
      • Works much the same way, but obviously in reverse
        • based on the TMR mapping
        • no attempt made to convert TMQL constraints
      • Converts to
        • OWL Lite, if certain features are not used
        • OWL DL, if exclusive-instance or abstract classes are used
        • OWL Full, if the tmcl:*type classes are not disjoint (and a few other cases)
      • Non-convertible elements
        • regular expressions
        • subject identifier/locator constraints
        • scope constraints
    • Basic workings
      • tmcl:topictype -> owl:Class
      • tmcl:nametype -> owl:DatatypeProperty
      • tmcl:occurrencetype -> owl:DatatypeProperty
      • tmcl:associationtype -> owl:ObjectProperty
      • constraints -> rdfs:range & rdfs:domain
      • Abstract classes -> complicated OWL expression
    • Conclusion
      • Conversion between TMCL and RDFS/OWL is possible!
        • core of both standards convertible and roundtrippable
        • some limitations, however
        • much of OWL not convertible in introspectible fashion
      • Further work
        • finish TMCL
        • implement RDFS/OWL import in Ontopoly
        • implement RDFS/OWL export in Ontopoly