Veuillez consulter l'errata de ce document, lequel peut contenir des corrections normatives.
Cf. également d'éventuelles traductions.
Copyright © 2004 W3C® (MIT, ERCIM, Keio), tous droits réservés. Les règles de responsabilité, de marque commerciale, d'utilisation des document et d'octroi de licences logicielles du W3C s'appliquent.
Ce chapitre du document fournit une application de la syntaxe abstraite de OWL DL et OWL Lite, introduite dans le chapitre 2, à la syntaxe d'échange du langage OWL, à savoir RDF/XML [RDF Syntax]. Cette application (dans ce sens et inversement) fournit les relations normatives entre la syntaxe abstraite et la syntaxe d'échange. On montre dans le chapitre 5 et l'annexe A.1 que cette application préserve la signification des ontologies OWL DL. Le chapitre 4.2 définit les dialectes OWL DL et OWL Lite du langage OWL comme étant les graphes RDF résultant des applications d'ontologies dans la syntaxe abstraite.
La syntaxe d'échange du langage OWL est RDF/XML [RDF Syntax], comme défini dans la description de référence du langage OWL [OWL Reference]. De plus, la signification d'une ontologie OWL dans RDF/XML est seulement déterminée à partir du graphe RDF [RDF Concepts] issu de l'analyse RDF du document RDF/XML. On peut donc traduire une ontologie OWL depuis le format de la syntaxe abstraite vers la syntaxe d'échange, en transformant chaque directive en un ensemble de triplets. Puisque toutes les structures OWL Lite représentent des cas particuliers de structures de la syntaxe abstraite complète, on ne fournit que les transformations des versions OWL DL.
La sémantique OWL DL est définie par rapport à la syntaxe abstraite et d'une syntaxe concrete constituant un sous-ensemble des graphes RDF. En conséquence, il est nécessaire de relier des ontologies spécifiques dans la syntaxe abstraite à des documents RDF/XML spécifiques et leurs graphes correspondants. Ce chapitre définit une relation à origines et destinations multiples entre les ontologies dans la syntaxe abstraite et les graphes RDF. Cela est fait avec un ensemble de règles d'application non déterministes. Pour appliquer la sémantique à un graphe RDF particulier, il faut donc trouver une ontologie dans la syntaxe abstraite correspondant à ce graphe conformément aux règles d'application puis lui appliquer la sémantique. L'application est conçue de façon à ce que tous les graphes RDF correspondant à une ontologie abstraite particulière aient la même signification, comme toutes les ontologies abstraites correspondant à un graphe RDF particulier. En outre, puisque ce processus ne peut pas s'appliquer aux graphes RDF sans forme correspondante dans la syntaxe abstraite, les règles d'application définissent implicitement un ensemble de graphes caractérisant la syntaxe OWL DL dans RDF/XML.
La syntaxe des triplets utilisée ici est celle de la sémantique RDF [RDF Semantics]. Cette variante autorise les noms qualifiés. Comme précisé dans la sémantique RDF, pour la transformer dans la syntaxe standard, il suffit de développer les noms qualifiés en appels d'adresses URI à la façon normale de RDF, par concaténation du nom d'espace de nommage et du nom local, en utilisant les espaces de nommage OWL standards.
Le tableau de transformation donne les règles permettant de transformer la syntaxe abstraite en syntaxe d'échange OWL.
Dans quelques cas, notamment pour la structure DifferentIndividuals
, les règles de transformation sont différentes.
Auxquels cas, on pourra choisir l'une ou l'autre règle, aboutissant à une traduction non déterministe. Dans d'autres cas,
notamment pour les axiomes de classe et de propriété, des triplets seront générés ou non. Ces triplets seront marqués d'une
étiquette [opt]
. Dans quelques cas encore, un ou deux triplets devront être générés. Cela sera indiqué en séparant les triplets
par OR
. Ces non-déterminismes permettent de générer plus de graphes RDF.
La colonne de gauche du tableau donne un morceau de syntaxe abstraite S
,
la colonne centrale en donne la transformation en triplets T(S)
et la colonne de droite donne l'identificateur
du nœud principal de la transformation M(T(S))
, pour les structures syntaxiques apparaissant comme morceaux de directives.
Les composants à répéter sont transcrits avec des ellipses, comme par exemple, description1 … descriptionn
,
cette forme permettant de définir aisément la transformation de toutes les valeurs de n
dans la syntaxe.
Les parties optionnelles de la syntaxe abstraite (entre des crochets) correspondent à des parties optionnelles de la transformation
(indiquées aussi par des crochets). De même, pour toutes les structures des
types de données OWL intégrés, des
classes OWL intégrées, des
propriétés d'annotation OWL intégrées et des
propriétés d'ontologie OWL intégrées,
le premier triplet rdf:type dans leur transformation ou dans leur axiome est optionnel.
Certaines transformations dans le tableau concernent des directives. D'autres concernent des parties de directives. La dernière transformation concerne les séquences, qui ne font pas partie de la syntaxe abstraite en soi. Cette dernière transformation sert à rendre certaines autres transformations plus compactes et plus faciles à lire.
Pour beaucoup de directives, ces règles de tranformation invoquent la transformation de certains composants de la directive par d'autres règles de transformation. Si la transformation d'un composant est utilisée comme sujet, prédicat ou objet d'un triplet, même pour un triplet optionnel, alors la transformation du composant fait partie de la production (mais seulement une seule fois par production) et le nœud principal de cette transformation devrait être utilisé dans le triplet.
On doit interpréter ici les identificateurs de nœuds blancs
comme appliqués localement à chaque transformation, c'est-à-dire qu'il faudrait se servir d'identificateurs différents
pour chaque invocation d'une règle de transformation. Les ontologies anonymes reçoivent un nœud blanc comme nœud principal,
tandis que les ontologies nommées utilisent leur nom comme nœud principal ; quel que soit le cas, on désignera
ce nœud par O
ci-dessous.
| Syntaxe abstraite (et séquences) - S | Transformation - T(S) | Nœud principal - M(T(S)) |
|---|---|---|
| Ontology(O directive1 … directiven) | O rdf:type owl:Ontology . T(directive1) … T(directiven) |
|
| Ontology(directive1 … directiven) | O rdf:type owl:Ontology . T(directive1) … T(directiven) |
|
| Annotation(ontologyPropertyID URIreference) | ontologyPropertyID rdf:type owl:OntologyProperty . O ontologyPropertyID URIreference . URIreference rdf:type owl:Ontology . |
|
| Annotation(annotationPropertyID URIreference) | annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] O annotationPropertyID URIreference . |
|
| Annotation(annotationPropertyID dataLiteral) | annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] O annotationPropertyID T(dataLiteral) . |
|
| Annotation(annotationPropertyID individual) | annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] O annotationPropertyID T(individual) . |
|
| rdfs:Literal | rdfs:Literal | |
| datatypeID | datatypeID rdf:type rdfs:Datatype . | datatypeID |
| classID | classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] |
classID |
| individualID | individualID | |
| datavaluedPropertyID | datavaluedPropertyID rdf:type owl:DatatypeProperty . datavaluedPropertyID rdf:type rdf:Property . [opt] |
datavalued- PropertyID |
| individualvaluedPropertyID | individualvaluedPropertyID rdf:type owl:ObjectProperty .
[opt] si un triplet dans la traduction de l'ontologie fait valoir que le type de la propriété individualvaluedPropertyID
est owl:InverseFunctionalProperty, owl:TransitiveProperty
ou owl:SymmetricProperty] . individualvaluedPropertyID rdf:type rdf:Property . [opt] |
individualvalued- PropertyID |
| dataLiteral | dataLiteral | dataLiteral |
| Individual(iID annotation1 … annotationm type(type1)… type(typen) value(pID1 v1) … value(pIDk vk)) |
iID T(annotation1) … iID T(annotationm) iID rdf:type T(type1) . … iID rdf:type T(typen) . iID T(pID1) T(v1) . … iID T(pIDk) T(vk) . |
iID |
| Individual(annotation1 … annotationm type(type1)…type(typen) value(pID1 v1) … value(pIDk vk)) (Avec au moins un type.) |
_:x T(annotation1) … _:x T(annotationm) _:x rdf:type T(type1) . … _:x rdf:type T(typen) . _:x T(pID1) T(v1) . … _:x T(pIDk) T(vk) . |
_:x |
| Individual(annotation1 … annotationm value(pID1 v1) … value(pIDk vk)) |
_:x T(annotation1) … _:x T(annotationm) _:x rdf:type owl:Thing . _:x T(pID1) T(v1) . … _:x T(pIDk) T(vk) . |
_:x |
| SameIndividual(iID1 … iIDn) | iIDi owl:sameAs iIDi+1 . 1≤i<n iIDi owl:sameAs iIDj . [opt] 1≤i≠j≤n |
|
| DifferentIndividuals(iID1 … iIDn) | iIDi owl:differentFrom iIDj .
OR iIDj owl:differentFrom iIDi . 1≤i<j≤n iIDj owl:differentFrom iIDi . [opt] 1≤i≠j≤n |
|
| DifferentIndividuals(iID1 … iIDn) | _:x rdf:type owl:AllDifferent . _:x owl:distinctMembers T(SEQ iID1 … iIDn) . |
|
|
Class(classID [Deprecated] partial annotation1 … annotationm description1 … descriptionn) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) classID rdfs:subClassOf T(description1) . … classID rdfs:subClassOf T(descriptionn) . |
|
| Class(classID [Deprecated] complete annotation1 … annotationm description1 … descriptionn) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) classID owl:intersectionOf T(SEQ description1…descriptionn) . |
|
| Class(classID [Deprecated] complete annotation1 … annotationm description) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) classID owl:equivalentClass T(description) . |
|
| Class(classID [Deprecated] complete annotation1 … annotationm unionOf(description1 … descriptionn)) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) classID owl:unionOf T(SEQ description1…descriptionn) . |
|
| Class(classID [Deprecated] complete annotation1 … annotationm complementOf(description)) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) classID owl:complementOf T(description) . |
|
| EnumeratedClass(classID [Deprecated] annotation1 … annotationm iID1 … iIDn) |
classID rdf:type owl:Class . classID rdf:type rdfs:Class . [opt] [classID rdf:type owl:DeprecatedClass .] classID T(annotation1) … classID T(annotationm) . classID owl:oneOf T(SEQ iID1…iIDn) . |
|
| DisjointClasses(description1 … descriptionn) | T(descriptioni) owl:disjointWith T(descriptionj) . OR T(descriptionj) owl:disjointWith T(descriptioni) . 1≤i<j≤n T(descriptioni) owl:disjointWith T(descriptionj) . [opt] 1≤i≠j≤n |
|
| EquivalentClasses(description1 … descriptionn) | T(descriptioni) owl:equivalentClass T(descriptionj) . pour tout <i,j> dans G, où G est un ensemble de couples sur {1,...,n}x{1,...,n} lequel, si on l'interprète comme un graphe non orienté, forme un graphe connexe de {1,...,n} |
|
| SubClassOf(description1 description2) | T(description1) rdfs:subClassOf T(description2) . | |
| Datatype(datatypeID [Deprecated] annotation1 … annotationm ) |
datatypeID rdf:type rdfs:Datatype . datatypeID rdf:type rdfs:Class . [opt] [datatypeID rdf:type owl:DeprecatedClass .] datatypeID T(annotation1) … datatypeID T(annotationm) |
|
| unionOf(description1 … descriptionn) | _:x rdf:type owl:Class . _:x rdf:type rdfs:Class . [opt] _:x owl:unionOf T(SEQ description1…descriptionn) . |
_:x |
| intersectionOf(description1 … descriptionn) | _:x rdf:type owl:Class . _:x rdf:type rdfs:Class . [opt] _:x owl:intersectionOf T(SEQ description1…descriptionn) . |
_:x |
| complementOf(description) | _:x rdf:type owl:Class . _:x rdf:type rdfs:Class . [opt] _:x owl:complementOf T(description) . |
_:x |
| oneOf(iID1 … iIDn) | _:x rdf:type owl:Class . _:x rdf:type rdfs:Class . [opt] _:x owl:oneOf T(SEQ iID1…iIDn) . |
_:x |
| oneOf(v1 … vn) | _:x rdf:type owl:DataRange . _:x rdf:type rdfs:Class . [opt] _:x owl:oneOf T(SEQ v1 … vn) . |
_:x |
|
restriction(ID component1 … componentn) (Avec au moins deux composants) |
_:x rdf:type owl:Class . _:x rdf:type rdfs:Class . [opt] _:x owl:intersectionOf T(SEQ(restriction(ID component1) … restriction(ID componentn))) . |
_:x |
| restriction(ID allValuesFrom(range)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:allValuesFrom T(range) . |
_:x |
| restriction(ID someValuesFrom(required)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:someValuesFrom T(required) . |
_:x |
| restriction(ID value(value)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:hasValue T(value) . |
_:x |
| restriction(ID minCardinality(min)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:minCardinality "min"^^xsd:nonNegativeInteger . |
_:x |
| restriction(ID maxCardinality(max)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:maxCardinality "max"^^xsd:nonNegativeInteger . |
_:x |
| restriction(ID cardinality(card)) | _:x rdf:type owl:Restriction . _:x rdf:type owl:Class . [opt] _:x rdf:type rdfs:Class . [opt] _:x owl:onProperty T(ID) . _:x owl:cardinality "card"^^xsd:nonNegativeInteger . |
_:x |
|
DatatypeProperty(ID [Deprecated] annotation1 … annotationm super(super1)… super(supern) domain(domain1)… domain(domaink) range(range1)… range(rangeh) [Functional]) |
ID rdf:type owl:DatatypeProperty . ID rdf:type rdf:Property . [opt] [ID rdf:type owl:DeprecatedProperty .] ID T(annotation1) … ID T(annotationm) ID rdfs:subPropertyOf T(super1) . … ID rdfs:subPropertyOf T(supern) . ID rdfs:domain T(domain1) . … ID rdfs:domain T(domaink) . ID rdfs:range T(range1) . … ID rdfs:range T(rangeh) . [ID rdf:type owl:FunctionalProperty . ] |
|
|
ObjectProperty(ID [Deprecated] annotation1 … annotationm super(super1)… super(supern) domain(domain1)… domain(domaink) range(range1)… range(rangeh) [inverseOf(inverse)] [Functional | InverseFunctional | Transitive]) [Symmetric] |
ID rdf:type owl:ObjectProperty . [optionnel si l'un des trois triplets est inclus] ID rdf:type rdf:Property . [opt] [ID rdf:type owl:DeprecatedProperty .] ID T(annotation1) … ID T(annotationm) ID rdfs:subPropertyOf T(super1) . … ID rdfs:subPropertyOf T(supern) . ID rdfs:domain T(domain1) . … ID rdfs:domain T(domaink) . ID rdfs:range T(range1) . … ID rdfs:range T(rangeh) . [ID owl:inverseOf T(inverse) .] [ID rdf:type owl:FunctionalProperty . ] [ID rdf:type owl:InverseFunctionalProperty . ] [ID rdf:type owl:TransitiveProperty . ] [ID rdf:type owl:SymmetricProperty . ] |
|
| AnnotationProperty(ID annotation1 … annotationm) |
ID rdf:type owl:AnnotationProperty . ID rdf:type rdf:Property . [opt] ID T(annotation1) … ID T(annotationm) |
|
| OntologyProperty(ID annotation1 … annotationm) |
ID rdf:type owl:OntologyProperty . ID rdf:type rdf:Property . [opt] ID T(annotation1) … ID T(annotationm) |
|
| EquivalentProperties(dvpID1 … dvpIDn) | T(dvpIDi) owl:equivalentProperty T(dvpIDi+1) . 1≤i<n | |
| SubPropertyOf(dvpID1 dvpID2) | T(dvpID1) rdfs:subPropertyOf T(dvpID2) . | |
| EquivalentProperties(ivpID1 … ivpIDn) | T(ivpIDi) owl:equivalentProperty T(ivpIDi+1) . 1≤i<n | |
| SubPropertyOf(ivpID1 ivpID2) | T(ivpID1) rdfs:subPropertyOf T(ivpID2) . | |
| annotation(annotationPropertyID URIreference) | annotationPropertyID URIreference . annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] |
|
| annotation(annotationPropertyID dataLiteral) | annotationPropertyID T(dataLiteral) . annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] |
|
| annotation(annotationPropertyID individual) | annotationPropertyID T(individual) . annotationPropertyID rdf:type owl:AnnotationProperty . annotationPropertyID rdf:type rdf:Property . [opt] |
|
| SEQ | rdf:nil | |
| SEQ item1…itemn |
_:l1 rdf:type rdf:List . [opt] _:l1 rdf:first T(item1) . _:l1 rdf:rest _:l2 . … _:ln rdf:type rdf:List . [opt] _:ln rdf:first T(itemn) . _:ln rdf:rest rdf:nil . |
_:l1 |
Cette transformation n'est pas injective, car plusieurs ontologies OWL abstraites n'utilisant pas le vocabulaire réservé
précédent peuvent s'appliquer à des graphes RDF égaux. Toutefois, les seuls cas où cela peut se produire sont avec des
structures de même signification, comme plusieurs axiomes DisjointClasses
produisant le même effet qu'un seul plus vaste.
Au besoin, il serait possible de définir une transformation symétrique canonique.
Lorsqu'on a affaire à des ontologies OWL Lite et OWL DL dans la forme de graphe RDF, on doit faire attention de ne pas employer certains termes de vocabulaire comme noms de classes, de propriétés ou d'individus OWL. Si on ne le fait pas, les définitions intégrées ou l'utilisation de ce vocabulaire (dans les définitions RDF ou OWL) augmenteront peut-être les informations dans l'ontologie OWL. Seule une partie du vocabulaire RDF tombe dans cette catégorie, car quelques structures de ce vocabulaire comme rdf:subject ont peu ou pas de signification dans les définitions RDF, et leur utilisation ne présente pas de problème tant qu'elle ne contredit pas le signification donnée dans les définitions RDF.
Définition :
Le vocabulaire interdit depuis RDF
comprend les structures suivantes : rdf:type, rdf:Property,
rdf:nil, rdf:List, rdf:first,
rdf:rest, rdfs:domain, rdfs:range,
rdfs:Resource, rdfs:Datatype, rdfs:Class,
rdfs:subClassOf, rdfs:subPropertyOf, rdfs:member,
rdfs:Container et rdfs:ContainerMembershipProperty.
Le vocabulaire interdit depuis OWL
comprend les structures suivantes :
owl:AllDifferent, owl:allValuesFrom, owl:AnnotationProperty,
owl:cardinality, owl:Class, owl:complementOf,
owl:DataRange, owl:DatatypeProperty, owl:DeprecatedClass,
owl:DeprecatedProperty, owl:differentFrom, owl:disjointWith,
owl:distinctMembers, owl:equivalentClass, owl:equivalentProperty,
owl:FunctionalProperty, owl:hasValue, owl:intersectionOf,
owl:InverseFunctionalProperty, owl:inverseOf, owl:maxCardinality,
owl:minCardinality, owl:ObjectProperty, owl:oneOf,
owl:onProperty, owl:Ontology, owl:OntologyProperty,
owl:Restriction, owl:sameAs, owl:someValuesFrom,
owl:SymmetricProperty, owl:TransitiveProperty et owl:unionOf.
L'union du vocabulaire interdit depuis RDF et du
vocabulaire interdit depuis OWL constitue le
vocabulaire interdit.
Définition : Le vocabulaire réservé aux classes comprend les structures rdf:Statement, rdf:Seq, rdf:Bag et rdf:Alt. Le vocabulaire réservé aux types de données comprend les structures des types de données OWL intégrés. Le vocabulaire réservé aux propriétés comprend rdf:subject, rdf:predicate, rdf:object et toutes les propriétés de membre de conteneur, à savoir rdf:_1, rdf:_2, …
Odans leur ensemble n'utilisent pas un appel d'adresse URI plus d'une fois comme identificateur de classe, identificateur de type de donnée, identidificateur d'individu, indentificateur de propriété à valeur d'individu, identificateur de propriété à valeur de donnée, identificateur de propriété d'annotation, identificateur de propriété d'ontologie ou identificateur d'ontologie ;
Odans leur ensemble indiquent le type de chaque identificateur d'individu ;
Outilisent, sauf pour les valeurs d'annotation, seulement le vocabulaire réservé aux classes pour identifier les classes, le vocabulaire réservé aux types de données pour identifier les types de données, la structure rdfs:Literal dans les gammes de données, le vocabulaire réservé aux propriétés pour identifier les structures
datavaluedProperty,
individualvaluedPropertyou
annotationProperty, les classes intégrées pour identifier les classes, les types de données intégrés pour identifier les types de données, les propriétés d'annotation intégrées pour identifier les structures
annotationProperty, les propriétés d'ontologie intégrées pour identifier les structures
ontologyProperty, et n'utilisent aucun terme du vocabulaire interdit.
Définition : Un graphe RDF est une ontologie OWL DL dans la forme de graphe RDF s'il est égal (cf. ci-dessous pour une définition moins stricte) au résultat de la transformation en triplets précédente d'un ensemble d'ontologies, d'axiomes et de faits OWL DL dans la forme de la syntaxe abstraite avec un vocabulaire séparé. Pour déterminer si un graphe RDF est bien une ontologie OWL DL dans la forme de graphe RDF, les restrictions de cardinalité peuvent utiliser explicitement des constructions telle que "1"^^xsd:integer tant que la valeur de donnée ainsi codée est un entier non négatif.
Définition :
Un graphe RDF est une ontologie OWL Lite dans la forme de graphe RDF
s'il est tel que précédemment, sauf que le contenu de l'ensemble O
se compose d'ontologies,
d'axiomes ou de faits OWL Lite dans la forme de la syntaxe abstraite.