Lisez-moi S.V.P. 

La sémantique et la syntaxe abstraite du langage d'ontologie Web OWL

Chapitre 4. L'application aux graphes RDF

Rédacteurs :
Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies
Ian Horrocks, Department of Computer Science, University of Manchester

Veuillez consulter l'errata de ce document, lequel peut contenir des corrections normatives.

Cf. également d'éventuelles traductions.


Table des matières


4. L'application aux graphes RDF (normatif)

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.

4.1. La traduction en graphes RDF

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.

La transformation en triplets
Syntaxe abstraite (et séquences) - STransformation - 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.

4.2. La définition des ontologies OWL DL et OWL Lite dans la forme de graphe RDF

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, …

Définition : Soit O un ensemble d'ontologies, d'axiomes et de faits OWL DL dans la forme de la syntaxe abstraite, il possède un vocabulaire séparé si :

  1. Les ontologies dans O dans 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 ;
  2. Les ontologies dans O dans leur ensemble indiquent le type de chaque identificateur d'individu ;
  3. Les ontologies dans O utilisent, 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, individualvaluedProperty ou 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.