Lisez-moi S.V.P. 
W3C

La référence du langage d'ontologie Web OWL

Recommandation du W3C du 10 février 2004

Cette version :
http://www.w3.org/TR/2004/REC-owl-ref-20040210/
Dernière version :
http://www.w3.org/TR/owl-ref/
Version précédente :
http://www.w3.org/TR/2003/PR-owl-ref-20031215/
Rédacteurs :
Mike Dean, BBN Technologies
Guus Schreiber, Free University Amsterdam
Auteurs :
Sean Bechhofer, University of Manchester
Frank van Harmelen, Free University Amsterdam
Jim Hendler, University of Maryland
Ian Horrocks, University of Manchester
Deborah L. McGuinness, Stanford University
Peter F. Patel-Schneider, Bell Labs Research, Lucent Technologies
Lynn Andrea Stein, Franklin W. Olin College of Engineering

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

Cf. également d'éventuelles traductions.

Résumé

Le langage d'ontologie Web OWL est un langage de balisage sémantique pour publier et partager des ontologies sur le Web. Le langage OWL est développé comme une extension de vocabulaire de RDF et dérivé du langage d'ontologie Web DAML+OIL. Ce document présente une description informelle structurée de l'ensemble complet des structures du langage OWL et il est destiné à servir de référence aux utilisateurs souhaitant construire des ontologies OWL.

Statut de ce document

Ce document revu par les membres du W3C et des tiers intéressés a été approuvé par le Directeur comme recommandation du W3C. Le rôle du W3C en produisant la recommandation consiste à attirer l'attention sur la spécification et à en promouvoir un large déploiement. Cela contribue à améliorer la fonctionnalité et l'interopérabilité du Web.

Le document représente l'une des six parties composant la recommandation du W3C pour le langage d'ontologie Web OWL. Il a été développé par le groupe de travail Ontologie Web, rattaché à l'activité Web sémantique du W3C (cf. le rapport d'activité, et la charte du groupe) et publié le 10 février 2004.

Le concept de OWL exprimé dans les versions précédentes de ces documents a été largement revu et il satisfait aux impératifs techniques fixés par le groupe de travail. Celui-ci a pris en compte toutes les remarques reçues et effectué les changements nécessaires. Les modifications apportées au document depuis la version au stade recommandation proposée sont consignées dans le journal des changements.

Les remarques sont les bienvenues sur la liste de diffusion public-webont-comments@w3.org (cf. archives), les débats généraux sur les technologies apparentées se tenant sur www-rdf-logic@w3.org (cf. archives).

Une liste des mises en œuvre est disponible.

Le W3C tient une liste des éventuelles divulgations de brevets concernant ce travail.

Cette section décrit le statut de ce document au jour de sa publication. D'autres documents peuvent venir le remplacer. On trouvera une liste des publications actuelles du W3C et la dernière révision de ce rapport technique dans l'index des rapports techniques du W3C à http://www.w3.org/TR/.

Remerciements

Certaines parties de ce document s'inspirent de la description de référence de DAML+OIL (mars 2001) [DAML+OIL] accompagnant la note du W3C DAML+OIL. Nous sommes reconnaissants envers les partenaires de ce document et des précédents.

Jeremy Carroll, Jim Hendler, Brian McBride et Peter Patel-Schneider ont contribués significativement à l'écriture et à la révision de ce document. Jeff Heflin s'est chargé du chapitre traitant de la contre-indication et Jérôme Euzenat de l'exemple de type de donnée énuméré.

Ce document est le résultat de débats approfondis au sein du groupe de travail Ontologie Web dans son ensemble. Les participants à ce groupe de travail comprenaient : Yasser alSafadi, Jean-François Baget, James Barnette, Sean Bechhofer, Jonathan Borden, Frederik Brysse, Stephen Buswell, Jeremy Carroll, Dan Connolly, Peter Crowther, Jonathan Dale, Jos De Roo, David De Roure, Mike Dean, Larry Eshelman, Jérôme Euzenat, Tim Finin, Nicholas Gibbins, Sandro Hawke, Patrick Hayes, Jeff Heflin, Ziv Hellman, James Hendler, Bernard Horan, Masahiro Hori, Ian Horrocks, Jane Hunter, Francesco Iannuzzelli, Rüdiger Klein, Natasha Kravtsova, Ora Lassila, Massimo Marchiori, Deborah McGuinness, Enrico Motta, Leo Obrst, Mehrdad Omidvari, Martin Pike, Marwan Sabbouh, Guus Schreiber, Noboru Shimizu, Michael Sintek, Michael K. Smith, John Stanton, Lynn Andrea Stein, Herman ter Horst, David Trastour, Frank van Harmelen, Bernard Vatant, Raphael Volz, Evan Wallace, Christopher Welty, Charles White et John Yanosy.

Table des matières

1. Introduction

1.1 L'objectif de ce document

Ce document fournit une description systématique, compacte et informative de toutes les primitives de modélisation du langage OWL, en utilisant la syntaxe d'échange RDF/XML de OWL. Nous souhaitons que ce document serve de guide de référence aux utilisateurs du langage OWL.

Ce document représente l'un des composants de la description du langage d'ontologie Web OWL, en cours de développement par le groupe de travail Ontologie Web du W3C. Le chapitre La cartographie du document dans le document constituant la vue d'ensemble du langage OWL décrit ses différentes parties et comment elles s'organisent. Les lecteurs qui découvrent OWL consulteront peut-être d'abord la vue d'ensemble [OWL Overview] puis le guide de OWL [OWL Guide] pour une description plus narrative et des exemples d'utilisation du langage.

Ce document suppose une certaine familiarité du lecteur avec les concepts de base de RDF [RDF Concepts] ainsi qu'une connaissance pratique de la syntaxe RDF/XML [RDF/XML Syntax] et du schéma RDF [RDF Vocabulary].

On trouvera une référence normative de la syntaxe exacte des structures du langage dans le document de la sémantique et de la syntaxe abstraite de OWL [OWL S&AS]. Ce dernier contient aussi une définition précise de la signification des structures du langage sous la forme d'une sémantique de modèle théorique. Des notions, telle que la cohérence des ontologies OWL, y sont abordées.

Les cas et conditions d'utilisation du langage OWL sont décrits dans le document des besoins du langage [OWL Requirements]. Les jeux d'essais des outils OWL (par exemple, les tests d'inférence et de cohérence) sont définis dans le document de tests [OWL Test Cases].

1.2 OWL Full/DL/Lite

Comme indiqué dans le document de vue d'ensemble de OWL [OWL Overview] ainsi que dans le guide de OWL [OWL Guide], le langage OWL se décline en deux sous-ensembles spécifiques dont nous espérons qu'ils seront utiles aux développeurs et utilisateurs du langage. Le langage OWL Lite a été conçu pour une mise en œuvre aisée offrant aux utilisateurs un sous-ensemble fonctionnel qui leur permettra de démarrer avec OWL. Le langage OWL DL (pour les initiales de Description Logic, logique de description en français) a été conçu pour tenir compte du secteur existant de la logique de description et offrir un sous-ensemble du langage avec des propriétés de calcul souhaitables pour les système de raisonnement. Le langage OWL complet (appelé OWL Full pour le distinguer des sous-ensembles) assouplit certaines contraintes exercées sur OWL DL, de façon à permettre des fonctionnalités qui seront peut-être utiles à plusieurs bases de données et systèmes de représentation des connaissances, mais enfreindront les contraintes des moteurs de raisonnement de logique de description.

REMARQUE : Les documents RDF seront généralement dans le langage OWL Full, sauf construction spécifique en OWL DL ou OWL Lite.

Les langages OWL Full et OWL DL gèrent le même ensemble de structures de langage OWL. Ils se différencient par les restrictions d'utilisation sur certaines fonctionnalités et par l'emploi de fonctionnalités RDF. Le langage OWL Full permet de mélanger arbitrairement OWL et le schéma RDF, et comme pour le schéma RDF, il n'impose pas une séparation stricte des classes, des propriétés, des individus et des valeurs de données. Le langage OWL DL définit des conditions au mélange avec RDF et impose une disjonction des classes, des propriétés, des individus et des valeurs de données. La justification principale du sous-langage OWL DL est que les développeurs d'outils ont créé des systèmes de raisonnement puissants reconnaissant des ontologies dont les contraintes sont celles imposées pour OWL DL. Le lecteur trouvera les définitions formelles des différences entre OWL Full et OWL DL dans le document de la sémantique et de la syntaxe abstraite [OWL S&AS]. Le chapitre 8.2 OWL DL résume les différences entre OWL Full et OWL DL.

Le langage OWL Lite est un sous-langage de OWL DL ne gérant qu'un sous-ensemble des structures de langage OWL. Il s'adresse plus particulièrement aux développeurs d'outils souhaitant mettre en œuvre le langage OWL en commençant toutefois par un ensemble de base relativement simple des fonctionnalités du langage. Le langage OWL Lite est soumis aux mêmes restrictions que OWL DL, en offrant aux moteurs de raisonnement la garantie de certaines propriétés souhaitables. On trouvera un résumé des structures de langage admises dans OWL Lite dans le chapitre 8.3. Le lecteur est invité à consulter le document de la sémantique et de la syntaxe abstraite [OWL S&AS] pour une description plus formelle du sous-ensemble des structures de langage reconnues par OWL Lite.

REMARQUE : Les utilisateurs de RDF faisant une mise à jour vers OWL devraient savoir que le langage OWL Lite n'est pas simplement une extension du schéma RDF. C'est aussi une version allégée de OWL DL qui place des contraintes sur l'utilisation du vocabulaire RDF (par exemple, la disjonction des classes, des propriétés, etc.). Le langage OWL Full est conçu pour une compatibilité maximale avec RDF, et les utilisateurs de RDF commenceront donc naturellement avec ce langage. Au moment d'opter entre OWL DL ou OWL Lite, on devrait évaluer dans quelle mesure les avantages de OWL DL/Lite (par exemple, la gestion du raisonnement) l'emportent sur les restrictions de OWL DL/Lite à l'utilisation des structures OWL et RDF.

REMARQUE : Le langage OWL Lite est défini dans ce document comme ajoutant des restrictions supplémentaires à OWL DL. Cela signifie que les structures OWL DL font également partie de OWL Lite, sauf déclaration explicite contraire. Le chapitre 8.3 résume ces restrictions OWL Lite supplémentaires.

1.3 La syntaxe OWL

Une ontologie OWL est un graphe RDF [RDF Concepts], qui est à son tour un ensemble de triplets RDF. Comme n'importe quel graphe RDF, le graphe d'une ontologie OWL peut s'écrire avec des formes syntaxiques différentes (comme décrit dans la spécification révisée de la syntaxe RDF/XML [RDF/XML Syntax]). Le présent document (tout comme le document du guide OWL) utilise certaines formes syntaxiques particulières de RDF/XML pour représenter des triplets. Toutefois, la signification d'une ontologie OWL est uniquement déterminée par le graphe RDF. L'utilisation d'autres formes syntaxiques RDF/XML est donc admise tant que cela produit le même ensemble sous-jacent de triplets RDF. Ces autres formes syntaxiques prendraient alors la même signification que celles utilisées dans ce document.

Comme exemple simple d'une autre forme syntaxique produisant les mêmes triplets RDF, prenons la syntaxe RDF/XML suivante :

<owl:Class rdf:ID="Continent"/> 

Soit la syntaxe RDF/XML :

<rdf:Description rdf:about="#Continent">
  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
</rdf:Description> 

Elle représente le même ensemble de triplets et va donc avoir la même signification.

1.4 Le langage OWL et la sémantique RDF

Le langage OWL est une extension de vocabulaire de RDF [RDF Semantics]. Par conséquent, tout graphe RDF forme une ontologie OWL Full. En outre, la signification donnée à un graphe RDF par OWL inclut celle donnée au graphe par RDF. Les ontologies OWL Full peuvent donc inclure un contenu RDF arbitraire, qui est traité régulièrement selon celui de RDF. Le langage OWL assigne une signification supplémentaire à certains triplets RDF. Le document de la sémantique et de la syntaxe abstraite [OWL S&AS] définit exactement quels triplets reçoivent une signification particulière et ce que cela représente.

REMARQUE : Comme indiqué précédemment, les langages OWL DL et OWL Lite étendent le vocabulaire RDF mais aussi en restreignent l'utilisation. C'est la raison pour laquelle les documents RDF seront généralement en OWL Full, à moins de les construire spécifiquement en OWL DL ou OWL Lite.

1.5 Remarque à propos des exemples

Pour des questions de lisibilité, les exemples de ce document supposent que les entités XML &rdf;, &rdfs;, &owl; et &xsd; (pour les types de données du schéma XML) sont définies de la même façon que dans l'annexe B. Il en est de même pour les espaces de nommage associés rdf:, rdfs:, owl: et xsd:.

Les exemples de ce document sont prévus pour illustrer l'utilisation de structures de langage OWL. Leur composition ne forme pas une ontologie régulière. Le lecteur qui souhaite un exemple complet se reportera au document guide de OWL [OWL Guide].

1.6 L'agrégation des données et la vie privée

La capacité du langage OWL d'exprimer des informations ontologiques à propos des instances apparaissant dans plusieurs documents permet de lier et de consolider des données provenant de sources diverses. À partir de ces données, la sémantique sous-jacente autorise des inférences pouvant fournir des résultats inattendus. En particulier, la possibilité d'exprimer des équivalences avec l'élément owl:sameAs peut servir à déclarer des individus apparemment différents comme étant en réalité les mêmes. L'élément Owl:InverseFunctionalProperty peut aussi servir à relier des individus. Par exemple, si une propriété telle que NuméroDeSécuritéSociale est du type owl:InverseFunctionalProperty, on pourrait alors conclure que deux individus séparés sont identiques, puisqu'ils auront la même valeur pour cette propriété. Si on détermine par ces moyens que des individus sont les mêmes, on peut rapprocher des informations les concernant issues de sources différentes. Cette agrégation peut servir à établir des faits non représentables directement par une seule source.

La capacité du Web sémantique à relier des informations provenant de plusieurs sources est une caractéristique souhaitable et puissante, qui peut être mise à profit dans beaucoup d'applications. Néanmoins, la capacité à réunir des données issues de plusieurs sources combinée au pouvoir de déduction de OWL peut entraîner des abus. Les utilisateurs de OWL devraient avoir conscience des implications potentielles pour la vie privée. Le groupe de travail n'a pas été jugé compétent pour préciser des mesures de sécurité. Quelques organisations abordent ces problèmes avec des solutions de sécurité et des approches différentes. Cf. par exemple SAML et P3P.

1.7 Les annexes de ce document

Ce document comprend un ensemble d'annexes avec des informations supplémentaires.

Les liens associés aux définitions des structures de langage mènent au document de la sémantique et de la syntaxe abstraite de OWL [OWL S&AS]. L'annexe A contient un ensemble systématique de liens depuis chaque structure de langage vers les chapitres correspondants dans le document guide et le document de la sémantique et de la syntaxe abstraite.

L'annexe B contient un schéma RDF des structures de langage OWL. Ce schéma fournit des renseignements sur le vocabulaire OWL et il peut servir de point de référence pour les concepteurs d'ontologies et les développeurs d'outils. Les restrictions sur les classes et les propriétés OWL indiquées par le schéma sont informatives et incomplètes. En outre, ce schéma ne fait aucune distinction entre OWL Full, OWL DL et OWL Lite. Par convention, les noms de classe commencent par une lettre majuscule. Ainsi, owl:Ontology est une classe et owl:imports est une propriété.

REMARQUE : Le fichier du schéma RDF du langage OWL n'est pas censé être importé explicitement (c'est-à-dire avec la propriété owl:imports) dans une ontologie. Le schéma a seulement un statut informatif et il sert à fournir les classes et les propriétés à utiliser dans la syntaxe RDF/XML. Les personnes qui importeraient quand même ce schéma auront prévu d'obtenir une ontologie OWL Full.

L'annexe C présente un tableau d'ensemble du vocabulaire OWL selon les classes et les propriétés (ces dernières avec leur domaine et leur image) intégrées de OWL.

Pour les lecteurs familiers de DAML+OIL, l'annexe D liste les changements intervenus entre DAML+OIL et OWL.

Finalement, l'annexe E offre un ensemble de conseils pratiques pour définir les ontologies OWL DL dans RDF.

2. Le document OWL

En OWL, les informations sont rassemblées en ontologies, qui peuvent être stockées comme documents sur le Web. Un aspect du langage OWL, l'importation d'ontologies, repose sur cette possibilité de stocker les ontologies OWL sur le Web.

2.1 Le contenu

Un document OWL se compose d'une en-tête d'ontologie optionnelle (généralement une au plus) et d'un nombre quelconque d'axiomes de classe, d'axiomes de propriété et de faits concernant les individus. Veuillez noter que le terme axiome est le terme formel employé dans le document de la sémantique et de la syntaxe abstraite. Moins formellement, on appelle ces axiomes des définitions dans le document guide et le document de vue d'ensemble.

REMARQUE : Le langage OWL n'impose aucun ordre des composants OWL. Les rédacteurs d'ontologies humains suivront probablement des conventions pour le rangement, par exemple, en plaçant l'en-tête de l'ontologie au début, mais cela n'a aucune conséquence sur le signifié. Les outils ne devraient pas présupposer un ordre particulier.

Comme pour la plupart des documents RDF, le code OWL devrait se placer en sous-élément de rdf:RDF. Cet élément englobant est généralement le lieu des déclarations XML d'espaces de nommage et de la base. Un document d'ontologie OWL commence souvent aussi par plusieurs déclarations d'entités. Comme exemple typique de ces informations, cf. les exemples d'ontologies de vins et d'aliments dans le document guide [OWL Guide].

2.2 Les adresses URI du vocabulaire et de l'espace de nommage OWL

Le vocabulaire intégré de OWL provient en totalité de l'espace de nommage OWL :

http://www.w3.org/2002/07/owl#

Par convention, on lui associe le nom d'espace de nommage owl. Il est recommandé de ne pas emprunter les noms issus de cet espace de nommage dans les ontologies, sauf pour le vocabulaire intégré. Les outils OWL sont libres d'émettre un avertissement si d'autres noms de cet espace de nommage ont été employés, sinon le traitement devrait continuer normalement.

2.3 Le type MIME

Le groupe de travail Ontologie Web n'a pas requis de type MIME distinct pour les documents OWL. Nous recommandons plutôt d'utiliser le type MIME demandé par le groupe de travail RDF Core, à savoir application/rdf+xml [RDF Concepts], ou sinon le type MIME de XML, à savoir application/xml.

Et comme suffixe de nom de fichier, nous recommandons soit .rdf, soit .owl.

3. Les classes

Les classes fournissent un mécanisme d'abstraction permettant de regrouper des ressources avec des caractéristiques similaires. Comme pour les classes RDF, chaque classe OWL est associée à un ensemble d'individus qu'on appelle extension de classe. Les individus dans l'extension de classe sont appelés des instances de la classe. Une classe a une signification intensionnelle (le concept sous-jacent) liée mais non égale à son extension de classe. Ainsi, deux classes peuvent avoir la même extension de classe et pourtant être des classes différentes.

Dans ce document, lorsque nous utiliserons une formulation telle que la classe des individus etc., il faudrait comprendre la classe avec une extension de classe contenant les individus etc..

REMARQUE : En OWL Lite et OWL DL, un individu ne sera jamais en même temps une classe : les classes et les individus forment des domaines disjoints (tout comme les propriétés et les valeurs de données). OWL Full permet la souplesse du schéma RDF : une classe peut se comporter comme une instance d'une autre classe (une métaclasse).

Les classes OWL sont définies par des descriptions de classe, qui peuvent se combiner en axiomes de classe. Nous présenterons d'abord les descriptions de classe puis nous nous tournerons vers les axiomes de classe.

3.1 Les descriptions de classe

Une description de classe est le terme employé dans ce document (et dans celui de la sémantique et de la syntaxe abstraite) pour désigner les blocs de construction élémentaires des axiomes de classe (que l'on appelle de manière informelle des définitions de classe dans le document guide et le document de vue d'ensemble). Une description de classe définit une classe OWL en nommant la classe, ou bien en définissant l'extension de classe d'une classe anonyme.

Le langage OWL distingue six types de description de classe :

  1. l'identificateur de classe (un appel d'adresse URI) ;
  2. l'énumération exhaustive des individus formant collectivement les instances de la classe ;
  3. la restriction de propriété ;
  4. l'intersection de deux descriptions de classe ou plus ;
  5. l'union de deux descriptions de classe ou plus ;
  6. le complémentaire d'une description de classe.

Le premier type est un type spécial dans la mesure où il décrit une classe au moyen d'un nom de classe (il prend la forme syntaxique d'un appel d'adresse URI). Les cinq autres types de description de classe décrivent une classe anonyme en exerçant des contraintes sur l'extension de classe.

Les descriptions de classe des types 2 à 6 décrivent respectivement une classe contenant exactement les individus énumérés (type 2), une classe de tous les individus satisfaisant à une restriction de propriété particulière (type 3), ou des classes satisfaisant à des combinaisons booléennes de descriptions de classe (type 4, 5 et 6). On peut assimiler l'intersection, l'union et la complémentarité aux opérateurs logiques ET, OU et NON respectivement. Les quatre derniers types conduisent à des descriptions de classe imbriquées qui peuvent donc théoriquement produire des descriptions de classe de complexité arbitraire. En pratique, le niveau d'imbrication est habituellement limité.

Une description de classe de type 1 se présente syntaxiquement comme une instance nommée de la classe owl:Class, laquelle est une sous-classe de rdfs:Class :

<owl:Class rdf:ID="Humain"/>

Ce qui fait valoir le triplet "ex:Humain rdf:type owl:Class", où ex: est l'espace de nommage de l'ontologie en question.

REMARQUE : En OWL Lite et OWL DL, on doit utiliser owl:Class (ou owl:Restriction, cf. ci-dessous) pour toutes les descriptions de classe.

REMARQUE : La classe owl:Class est définie comme sous-classe de rdfs:Class. La justification d'une structure de classe OWL séparée trouve son origine dans les restrictions de OWL DL (et donc aussi de OWL Lite), qui impliquent que les classes RDFS ne sont pas toutes des classes OWL DL légales. Ces restrictions n'existent pas dans le langage OWL Full, et les classes owl:Class et rdfs:Class y sont donc équivalentes.

Les cinq autres formes de description de classe consistent en un ensemble de triplets RDF dans lesquels la classe décrite est représentée par nœud blanc. Ce nœud blanc possède une propriété rdf:type dont la valeur est owl:Class.

REMARQUE : Si on fournit un identificateur RDF à une description de classe ayant un type énumération, intersection, union ou complémentarité, alors elle ne sera pas considérée comme une description de classe, mais comme un axiome de classe de type spécial d'une classe complète. Cf. le chapitre 3.2.3 pour des précisions.

REMARQUE : Pour des questions de lisibilité, on emploie parfois dans ce document le raccourci description de classe pour désigner la classe décrite par la description de classe. À strictement parler, c'est différent en ce qui concerne les descriptions de classe des types 2 à 6 : la classe est représentée par le nœud blanc correspondant, et la description de classe par les triplets dont ce nœud blanc est le sujet.

Il y a deux identificateurs de classe OWL prédéfinis, à savoir les classes owl:Thing et owl:Nothing. L'extension de classe de owl:Thing est l'ensemble de tous les individus. L'extension de classe de owl:Nothing est l'ensemble vide. Par conséquent, chaque classe OWL est une sous-classe de owl:Thing, et inversement owl:Nothing est une sous-classe de chaque classe (cf. la signification de la relation sous-classe dans le chapitre consacré à rdfs:subClassOf).

3.1.1 L'énumération

Une description de classe du type énumération se définit au moyen de la propriété owl:oneOf. La valeur de cette propriété OWL intégrée doit être la liste des individus instances de la classe. Cela permet de décrire une classe par énumération exhaustive de ses instances. L'extension de classe d'une classe décrite par owl:oneOf contient exactement les individus énumérés, ni plus ni moins. La liste des individus est typiquement représentée par la structure RDF rdf:parseType='Collection', qui fournit un raccourci pratique pour énoncer l'ensemble des éléments de la liste. Par exemple, la syntaxe RDF/XML suivante définit la classe de tous les continents :

<owl:Class>
  <owl:oneOf rdf:parseType="Collection">
    <owl:Thing rdf:about="#Eurasie"/>
    <owl:Thing rdf:about="#Afrique"/>
    <owl:Thing rdf:about="#AmeriqueDuNord"/>
    <owl:Thing rdf:about="#AmeriqueDuSud"/>
    <owl:Thing rdf:about="#Australie"/>
    <owl:Thing rdf:about="#Antarctique"/>
  </owl:oneOf>
</owl:Class>

La syntaxe RDF/XML <owl:Thing rdf:about="..."/> désigne un individu (par définition, tous les individus sont des instances de la classe owl:Thing).

Dans le chapitre consacré aux types de données, nous verrons une autre utilisation de la structure owl:oneOf, à savoir la définition d'une énumération de valeurs de données.

REMARQUE : L'énumération ne fait pas partie du langage OWL Lite.

3.1.2 Les restrictions de propriété

Une restriction de propriété est un type particulier de description de classe. Elle décrit une classe anonyme, c'est-à-dire la classe de tous les individus satisfaisant à la restriction. Le langage OWL distingue deux types de restrictions de propriété : celles contraignant sa valeur et celles contraignant sa cardinalité.

Une contrainte de valeur exerce une limitation sur l'image de la propriété lorsqu'elle s'applique à cette description de classe particulière. Par exemple, nous pourrions nous référer aux individus dont la valeur de la propriété adjacentTo serait une certaine région (Region) pour l'utiliser ensuite dans un axiome de classe, peut-être même dans un axiome de classe de Region. Remarquez que ce n'est pas la même chose qu'avec rdfs:range qui s'applique à toutes les situations où la propriété est utilisée.

Une contrainte de cardinalité exerce une limitation sur le nombre des valeurs prises par une propriété dans le contexte de cette description de classe particulière. Par exemple, on pourrait indiquer que la propriété aPourJoueur appliquée à une équipe de football admet onze valeurs. Appliquée à une équipe de basketball, la même propriété n'aurait que cinq valeurs.

Le langage OWL reconnaît également un ensemble réduit de structures pour définir la cardinalité des propriétés globales, à savoir les propriétés owl:FunctionalProperty et owl:InverseFunctionalProperty (cf. le chapitre sur ces propriétés).

Les restrictions de propriété ont la forme générale suivante :

<owl:Restriction>
  <owl:onProperty rdf:resource="(une propriété)" />
  (une valeur exactement ou bien une contrainte de cardinalité, cf. ci-dessous.)
</owl:Restriction>

La classe owl:Restriction se définit comme une sous-classe de owl:Class. Une classe de restriction devrait comporter exactement un seul triplet reliant la restriction à une propriété particulière au moyen de la propriété owl:onProperty. La classe de restriction devraient n'avoir également qu'un seul triplet exactement représentant la contrainte de valeur ou de cardinalité sur la propriété en question, par exemple, indiquant que la cardinalité de la propriété vaut exactement 1.

Les restrictions de propriété s'appliquent aux propriétés de types de données (les propriétés dont la valeur est une donnée littérale) et aux propriétés d'objets (les propriétés dont la valeur est un individu). Pour des précisions sur cette distinction, cf. le chapitre à propos des propriétés.

3.1.2.1 Les contraintes de valeur
3.1.2.1.1 owl:allValuesFrom

La contrainte de valeur owl:someValuesFrom est une propriété, OWL intégrée qui relie une classe de restriction à une description de classe, ou bien à une gamme de données. On utilise une restriction avec une contrainte owl:allValuesFrom pour décrire la classe de tous les individus pour lesquels toutes les valeurs de la propriété concernée sont soit des membres de l'extension de classe de la description de classe, soit des valeurs de données dans la gamme de données indiquée. En d'autre termes, elle définit une classe d'individus x tel que, si le couple (x,y) est une instance de P (la propriété concernée), alors y devrait être une instance de la description de classe ou bien une valeur de la gamme de données.

Un exemple simple :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:allValuesFrom rdf:resource="#Humain"  />
</owl:Restriction>

Cet exemple décrit la classe OWL anonyme de tous les individus pour lesquels la propriété aPourParent a seulement des valeurs de la classe Humain. Remarquez que cette description de classe ne déclare pas que la propriété a toujours des valeurs de cette classe, mais juste qu'elle est vérifiée pour les individus appartenant à l'extension de classe de la classe de restriction anonyme.

REMARQUE : En OWL Lite, le seul type de description de classe admis comme argument de la contrainte owl:allValuesFrom est un nom de classe.

La contrainte owl:allValuesFrom s'apparente au quantificateur universel pour tous de la logique des prédicats ; pour chaque instance de la classe décrite, chaque valeur de la propriété P doit remplir la condition. Notez également que la correspondance de owl:allValuesFrom au quantificateur universel signifie qu'une contrainte owl:allValuesFrom sur une propriété P sera automatiquement satisfaite pour un individu qui n'a aucune valeur pour P. Pour s'en convaincre, observez que la contrainte owl:allValuesFrom demande à ce que toutes les valeurs de P soient de type T, et si ces valeurs n'existent pas, la contrainte est tout simplement vérifiée.

3.1.2.1.2 owl:someValuesFrom

La contrainte de valeur owl:someValuesFrom est une propriété OWL intégrée qui relie une classe de restriction à une description de classe ou bien à une gamme de données. Une restriction contenant une contrainte owl:someValuesFrom décrit la classe de tous les individus pour lesquels au moins une valeur de la propriété concernée est une instance de la description de classe ou une valeur de donnée dans la gamme de données. En d'autres termes, elle définit une classe d'individus x pour lesquels il existe au moins un y (soit une instance de la description de classe, soit une valeur de la gamme de données) tel que le couple (x,y) soit une instance de la propriété P. Cela n'exclut pas le fait qu'il puisse y avoir d'autres instances (x,y') de P pour lesquelles y' n'appartient pas à la description de classe ou à la gamme de données.

L'exemple suivant définit la classe des individus dont au moins un parent est un médecin :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:someValuesFrom rdf:resource="#Médecin" />
</owl:Restriction>

La contrainte owl:someValuesFrom s'apparente au quantificateur existentiel de la logique des prédicats ; pour chaque instance de la classe définie, il existe au moins une valeur de la propriété P remplissant la condition.

REMARQUE : En OWL Lite, le seul type de description de classe admis comme argument de la contrainte owl:someValuesFrom est un nom de classe.

3.1.2.1.3 owl:hasValue

La contrainte de valeur owl:hasValue est une propriété OWL intégrée qui relie une classe de restriction à une valeur V, laquelle peut être soit un individu, soit une valeur de donnée. Une restriction contenant une contrainte owl:hasValue décrit la classe de tous les individus pour lesquels la propriété concernée a au moins une valeur sémantiquement égale à la valeur V (elle peut aussi avoir d'autres valeurs).

REMARQUE : Pour les types de données, le terme sémantiquement égal signifie que la représentation lexicale des littéraux correspond à la même valeur. Pour les individus, cela signifie soit qu'ils ont la même adresse URI, soit qu'ils sont définis comme étant le même individu (cf. la relation owl:sameAs).

REMARQUE : La contrainte de valeur owl:hasValue ne fait pas partie du langage OWL Lite.

L'exemple suivant décrit la classe des individus qui ont pour parent l'individu nommé Clinton :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:hasValue rdf:resource="#Clinton" />
</owl:Restriction>
3.1.2.2 Les contraintes de cardinalité

Dans le langage OWL comme dans RDF, toute instance d'une classe peut avoir un nombre arbitraire de valeurs (zéro à plusieurs) pour une propriété particulière. Pour imposer une propriété (au moins une), ou lui autoriser un nombre spécifique de valeurs, ou en interdire l'utilisation, on peut utiliser des contraintes de cardinalité. Le langage OWL offre trois structures pour restreindre localement la cardinalité des propriétés dans le contexte d'une classe.

REMARQUE : Le langage OWL Lite inclut l'utilisation des trois types de contrainte de cardinalité mais seulement pour les valeurs "0" ou "1".

3.1.2.2.1 owl:maxCardinality

La contrainte de cardinalité owl:maxCardinality est une propriété OWL intégrée qui relie une classe de restriction à une valeur de donnée appartenant à l'espace de valeurs du type de donnée nonNegativeInteger du schéma XML. Une restriction avec une contrainte owl:maxCardinality décrit la classe de tous les individus ayant au plus N valeurs sémantiquement distinctes (des individus ou des valeurs de données) pour la propriété concernée, où N est la valeur de la contrainte de cardinalité. Pour la syntaxe, la contrainte de cardinalité est représentée par un élément de propriété RDF avec l'attribut rdf:datatype correspondant.

L'exemple suivant décrit la classe des individus ayant au plus deux parents :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:maxCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:maxCardinality>
</owl:Restriction>

Le typage des données RDF est abordé plus en détails au chapitre 6.

3.1.2.2.2 owl:minCardinality

La contrainte de cardinalité owl:minCardinality est une propriété OWL intégrée qui relie une classe de restriction à une valeur de donnée appartenant à l'espace de valeurs du type de donnée nonNegativeInteger du schéma XML. Une restriction avec une contrainte owl:minCardinality décrit la classe de tous les individus ayant au moins N valeurs sémantiquement distinctes (des individus ou des valeurs de données) pour la propriété concernée, où N est la valeur de la contrainte de cardinalité. Pour la syntaxe, la contrainte de cardinalité est représentée par un élément de propriété RDF avec l'attribut rdf:datatype correspondant.

L'exemple suivant décrit la classe des individus ayant au moins deux parents :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:minCardinality>
</owl:Restriction>

Remarquez qu'une valeur d'un ou plus pour owl:minCardinality signifie que toutes les instances de la classe doivent avoir une valeur pour la propriété en question.

3.1.2.2.3 owl:cardinality

La contrainte de cardinalité owl:cardinality est une propriété OWL intégrée qui relie une classe de restriction à une valeur de donnée appartenant à l'espace de valeurs du type de donnée nonNegativeInteger du schéma XML. Une restriction avec une contrainte owl:cardinality décrit la classe de tous les individus ayant exactement N valeurs sémantiquement distinctes (des individus ou des valeurs de données) pour la propriété concernée, où N est la valeur de la contrainte de cardinalité. Pour la syntaxe, la contrainte de cardinalité est représentée par un élément de propriété RDF avec l'attribut rdf:datatype correspondant.

Cette structure est en fait redondante puisqu'on peut toujours la remplacer par un couple correspondant de contraintes owl:minCardinality et owl:maxCardinality ayant la même valeur.

L'exemple suivant décrit la classe des individus ayant exactement deux parents :

<owl:Restriction>
  <owl:onProperty rdf:resource="#aPourParent" />
  <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">2</owl:cardinality>
</owl:Restriction>

3.1.3 L'intersection, l'union et la complémentarité

Les trois types de description de classe de ce chapitre représentent les constructeurs de classes les plus évolués de la logique de description. On peut les assimiler aux opérateurs ET, OU et NON sur les classes. Ces trois opérateurs portent les noms standards des opérateurs d'ensembles : l'intersection, l'union et le complémentaire. Ces structures de langage partagent également comme caractéristique de contenir des descriptions de classes imbriquées, que ce soit une seule (complémentarité) ou plusieurs (union, intersection).

3.1.3.1 owl:intersectionOf

La propriété owl:intersectionOf relie une classe à une liste de descriptions de classe. Une déclaration owl:intersectionOf décrit la classe dont l'extension de classe contient précisément les individus membres de l'extension de classe de toutes les descriptions de classe dans la liste.

Un exemple :

<owl:Class>
  <owl:intersectionOf rdf:parseType="Collection">
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Tosca" />
        <owl:Thing rdf:about="#Salome" />
      </owl:oneOf>
    </owl:Class>
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Turandot" />
        <owl:Thing rdf:about="#Tosca" />
      </owl:oneOf>
    </owl:Class>
  </owl:intersectionOf>
</owl:Class>

Dans cet exemple, la valeur de la propriété owl:intersectionOf est une liste composée de deux descriptions de classe, à savoir deux énumérations décrivant toutes deux une classe de deux individus. L'intersection résultante est une classe d'un seul individu, à savoir Tosca, car c'est le seul individu commun aux deux énumérations.

REMARQUE : Cela suppose que les trois individus soient tous différents. En fait, par définition, ce n'est pas vrai dans OWL. Différents appels d'adresses URI peuvent se rapporter aux mêmes individus, parce que le langage OWL ne présuppose pas de noms uniques. On peut trouver dans le chapitre 5 des structures de langage OWL qui permettent d'établir des contraintes d'égalité et de différence sur des individus.

REMARQUE : Dans cet exemple, on emploie des énumérations afin d'éclairer la signification de cette structure de langage. Cf. le guide OWL [OWL Guide] pour des exemples plus typiques.

REMARQUE : Le langage OWL Lite limite l'utilisation de la propriété owl:intersectionOf. Cf. une explication dans le chapitre 3.2.3.

On peut assimiler la propriété owl:intersectionOf à une conjonction logique.

3.1.3.2 owl:unionOf

La propriété owl:unionOf relie une classe à une liste de descriptions de classe. Une déclaration owl:unionOf décrit une classe anonyme dont l'extension de classe contient les individus apparaissant dans au moins une des extensions de classe des descriptions de classe de la liste.

Voici un exemple :

<owl:Class>
  <owl:unionOf rdf:parseType="Collection">
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Tosca" />
        <owl:Thing rdf:about="#Salome" />
      </owl:oneOf>
    </owl:Class>
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <owl:Thing rdf:about="#Turandot" />
        <owl:Thing rdf:about="#Tosca" />
      </owl:oneOf>
    </owl:Class>
  </owl:unionOf>
</owl:Class>

Cette description de classe définit une classe dont l'extension de classe contient trois individus, à savoir Tosca, Salome et Turandot (en supposant qu'ils soient tous différents).

REMARQUE : La propriété owl:unionOf ne fait pas partie du langage OWL Lite.

On peut assimiler la propriété owl:unionOf à une disjonction logique.

3.1.3.3 owl:complementOf

Une propriété owl:complementOf relie une classe à une seule description de classe exactement. Une déclarationowl:complementOf décrit la classe dont l'extension de classe contient exactement les individus n'appartenant pas à l'extension de classe de la description de classe faisant l'objet de la déclaration. On peut assimiler la propriété owl:complementOf à une négation logique : l'extension de classe se compose des individus qui NE SONT PAS membres de l'extension de classe de la classe complémentaire.

Comme exemple d'utilisation de la complémentarité, l'expression non viande pourrait se traduire par :

<owl:Class>
  <owl:complementOf>
    <owl:Class rdf:about="#Viande"/>
  </owl:complementOf>
</owl:Class>

L'extension de cette description de classe contient tous les individus n'appartenant pas à la classe Viande.

REMARQUE : La propriété owl:complementOf ne fait pas partie du langage OWL Lite.

3.2 Les axiomes de classe

Les descriptions de classe constituent les blocs d'assemblage pour définir les classes au travers d'axiomes de classe. L'axiome de classe le plus élémentaire prend la forme d'une description de classe de type 1 : il déclare juste l'existence de la classe au moyen de l'élément owl:Class et d'un identificateur de classe.

Par exemple, l'axiome de classe suivant déclare l'adresse URI #Humain être le nom d'une classe OWL :

<owl:Class rdf:ID="Humain"/>

Cette syntaxe OWL est correcte mais elle ne nous apprend pas grand chose de la classe Humain. Les axiomes de classe contiennent en général d'autres composants pour définir les caractéristiques nécessaires et/ou suffisantes d'une classe. Le langage OWL offre trois structures de langage pour combiner les descriptions de classe en axiomes de classe :

D'un point de vue syntaxique, ces trois structures de langage sont des propriétés dont le domaine et l'image sont des descriptions de classe. Nous aborderons ces propriétés en détails dans les sous-sections suivantes.

En outre, le langage OWL autorise des axiomes de classe dans lesquels une description de classe du type énumération ou opérateur d'ensembles reçoit un nom. Ces axiomes de classe sont sémantiquement équivalents aux axiomes de classe avec une déclaration owl:equivalentClass, nous les aborderons ainsi juste après cette sous-section (cf. le chapitre 3.2.3 Les axiomes de classes complètes sans utiliser owl:equivalentClass).

3.2.1 rdfs:subClassOf

SCHÉMA AXIOMATIQUE : description de classe rdfs:subClassOf description de classe

La structure rdfs:subClassOf est définie par le schéma RDF [RDF Vocabulary]. Sa signification dans OWL est exactement la même : si la description de classe C1 est définie comme sous-classe de la description de classe C2, alors l'ensemble des individus de la classe d'extension de C1 devrait être un sous-ensemble de l'ensemble des individus de la classe d'extension de C2. Par définition, une classe est sous-classe d'elle-même (tout comme le sous-ensemble peut être l'ensemble entier).

Voici un exemple :

<owl:Class rdf:ID="Opéra">
  <rdfs:subClassOf rdf:resource="#GenreMusical" />
</owl:Class>

Cet axiome de classe déclare une relation de sous-classe entre les deux classes OWL décrites au travers de leurs noms (Opéra et GenreMusical). Les relations de sous-classe fournissent les conditions nécessaires de l'appartenance à une classe. Dans le cas présent, pour que l'individu soit un opéra, il doit forcément être un genre musical aussi.

REMARQUE : En OWL Lite, le sujet d'une déclaration rdfs:subClassOf doit être un identificateur de classe, et l'objet doit être un identificateur de classe ou bien une restriction de propriété.

Une classe peut avoir un nombre quelconque d'axiomes subClassOf. Par exemple, on pourrait ajouter l'axiome suivant à propos de la classe Opéra :

<owl:Class rdf:about="#Opéra">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#aPourParolier" />
      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

Cet axiome de classe contient une restriction de propriété. L'exemple affirme que Opéra est la sous-classe d'une classe anonyme OWL (se rappeler que owl:Restriction est une sous-classe de owl:Class), dont l'extension de classe est l'ensemble de tous les individus pour lesquels la propriété aPourParolier a au moins une valeur. Les opéras devraient donc avoir au moins un parolier.

Les axiomes de classe peuvent devenir plus complexes lorsque les descriptions de classe s'imbriquent. Par exemple, les restrictions de propriété avec une déclaration owl:allValuesFrom ou owl:someValuesFrom peuvent désigner n'importe quelle description de classe. Considérons l'exemple suivant :

<owl:Class rdf:ID="OpéraItalienTraditionnel">
  <rdfs:subClassOf rdf:resource="#Opéra"/>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#aPourGenre"/>
      <owl:someValuesFrom>
        <owl:Class>
          <owl:oneOf rdf:parseType="Collection">
            <owl:Thing rdf:about="#OperaSeria"/>
            <owl:Thing rdf:about="#OperaBuffa"/>
          </owl:oneOf>
        </owl:Class>
      </owl:someValuesFrom>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

Cet exemple montre l'utilisation de la structure owl:oneOf. L'axiome de classe définit l'opéra italien traditionnel comme étant une sous-classe des opéras, et ayant pour genre opera seria, ou bien opera buffa (sans contrainte de cardinalité, il pourrait en fait avoir les deux valeurs).

On trouvera d'autres exemples dans le document guide [OWL Guide]. Les axiomes de sous-classes fournissent des définitions partielles : ils représentent des conditions nécessaires mais non suffisantes pour établir l'appartenance d'un individu à une classe. Dans la sous-section suivante, nous verrons que le langage OWL fournit la structure owl:equivalentClass pour définir des conditions nécessaires et suffisantes. En introduction à ces axiomes, considérons l'exemple suivant :

<owl:Class rdf:ID="Opérette">
  <rdfs:subClassOf rdf:resource="#GenreMusical"/>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#aPourParolier" />
      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <owl:Class>
      <owl:complementOf rdf:resource="#Opéra"/>
    </owl:Class>
  </rdfs:subClassOf> 
</owl:Class>

Cet axiome de classe déclare que l'opérette est un genre musical, ayant au moins un parolier et n'étant pas un opéra. L'utilisation d'une relation de sous-classe autorise l'éventualité d'un autre genre musical, avec parolier et sans être un opéra. S'il on avait voulu exprimer le fait que l'opérette est exactement le genre musical avec parolier et sans être un opéra, il aurait fallu utiliser la structure owl:equivalentClass.

3.2.2 owl:equivalentClass

SCHÉMA AXIOMATIQUE : description de classe owl:equivalentClass description de classe

Un axiome de classe peut contenir plusieurs déclarations owl:equivalentClass. La propriété OWL intégrée owl:equivalentClass relie une description de classe à une autre description de classe. Un tel axiome de classe signifie que les deux descriptions de classe impliquées ont la même extension de classe (c'est-à-dire que leurs deux extensions de classe contiennent exactement le même ensemble d'individus).

Dans sa forme minimale, un axiome equivalentClass affirme l'équivalence (en ce qui concerne leurs extensions de classe) de deux classes nommées. Voici un exemple :

<owl:Class rdf:about="#PrésidentDesÉtatsUnis">
  <equivalentClass rdf:resource="#RésidentPrincipalDeLaMaisonBlanche"/>
</owl:Class>

REMARQUE : L'utilisation de owl:equivalentClass n'implique pas l'égalité des classes. Cela voudrait dire que les classes ont la même signification intensionnelle (représentent le même concept). Dans l'exemple précédent, le concept de Président des États-Unis s'apparente, sans être égal, au concept de résident principal d'un certain bâtiment blanc. On ne peut exprimer une égalité de classe réelle qu'au travers de la structure owl:sameAs. Et comme cela impose de traiter les classes comme des individus, on ne peut exprimer une égalité de classe que dans le langage OWL Full.

On peut aussi utiliser des axiomes avec owl:equivalentClass pour définir une classe énumérée, en reliant une description de classe de type 1 (un identificateur de classe) à une description de classe de type 2 (une énumération). Voici un exemple ::

<owl:Class rdf:ID="OpérasDaPonteDeMozart">
  <owl:equivalentClass>
    <owl:Class>
      <owl:oneOf rdf:parseType="Collection">
        <Opera rdf:about="#Nozze_di_Figaro"/>
        <Opera rdf:about="#Don_Giovanni"/>
        <Opera rdf:about="#Cosi_fan_tutte"/>
      </owl:oneOf>
    </owl:Class>
  </owl:equivalentClass>
</owl:Class>

Cette axiome de classe définit la classe des opéras représentant collectivement les opéras Da Ponte de Mozart (un sujet connu en musicologie). Avec la structure equivalentClass, on peut déclarer les conditions nécessaires et suffisantes d'appartenance à la classe, qui est constituée ici d'une énumération de trois individus, ni plus ni moins.

REMARQUE : Le langage OWL DL n'exerce aucune contrainte sur les types des descriptions de classe sujet et objet d'une déclaration owl:equivalentClass. En OWL Lite, le sujet doit être un nom de classe et l'objet doit être un nom de classe ou bien une restriction de propriété.

REMARQUE : Bien qu'on puisse théoriquement utiliser différents types de descriptions de classe en sujet d'une déclaration equivalentClass, il s'agira en pratique d'un identificateur de classe. C'est le cas des exemples de ce chapitre.

Il est possible d'avoir plusieurs axiomes equivalentClass à propos de la même classe. Toutefois, il faut faire attention. Les deux axiomes doivent conduire au même résultat, c'est-à-dire à la même extension de classe exactement. Par exemple, on pourrait avoir cet autre axiome equivalentClass suivant pour les Opéras Da Ponte de Mozart :

<owl:Class rdf:about="#OpérasDaPonteDeMozart">
  <owl:equivalentClass>
    <owl:Class>
      <owl:intersectionOf rdf:parseType="Collection">
        <owl:Restriction>
          <owl:onProperty rdf:resource="#aPourCompositeur"/>
          <owl:hasValue rdf:resource="#Wolfgang_Amadeus_Mozart"/>
        </owl:Restriction>
        <owl:Restriction>
          <owl:onProperty rdf:resource="#aPourParolier"/>
          <owl:hasValue rdf:resource="#Lorenzo_Da_Ponte"/>
        </owl:Restriction>
      </owl:intersectionOf>
    </owl:Class>
  </owl:equivalentClass>
</owl:Class>

L'extension de classe des opéras Da Ponte de Mozart est déclarée correspondre exactement aux opéras composés par Mozart et à ceux dont les paroles ont été écrites par Da Ponte (note : intersection = ET). Cet axiome définit effectivement une classe ayant les mêmes instances exactement que dans l'axiome précédent.

REMARQUE : Si on avait voulu reclasser un axiome de la forme A subClassOf B en A equivalentClassOf B (pour signifier que l'extension de classe de A n'est pas juste un quelconque sous-ensemble mais en fait le même ensemble que l'extension de classe de B), on aurait pu ajouter un deuxième axiome subClassOf de la forme B subClassOf A, qui rend les deux classes d'extension équivalentes par définition (et dont la signification est donc la même que A equivalentClassOf B). Les cycles subClassOf de ce type sont explicitement permis. Comme le langage OWL est utilisable en environnement réparti, c'est une caractéristique qui peut se révéler utile.

3.2.3 Les axiomes de classes complètes sans utiliser owl:equivalentClass

SCHÉMA AXIOMATIQUE : description de classe nommée de type 2 (pour owl:oneOf) ou de type 4-6 (pour owl:intersectionOf, owl:unionOf ou owl:complementOf

Le langage OWL permet aux utilisateurs de définir des axiomes de classe en nommant les descriptions de classe de type énumération ou opérateur d'ensembles. Un tel axiome de classe définit les conditions nécessaires et suffisante pour établir l'appartenance à une classe. Voici un exemple :

<owl:Class rdf:ID="OpérasDaPonteDeMozart">
  <owl:oneOf rdf:parseType="Collection">
    <owl:Thing rdf:about="#Nozze_di_Figaro"/>
    <owl:Thing rdf:about="#Don_Giovanni"/>
    <owl:Thing rdf:about="#Cosi_fan_tutte"/>
  </owl:oneOf>
</owl:Class>

L'interprétation de cet axiome de classe devrait être la suivante : l'énumération définit l'extension de classe de la classe OpérasDaPonteDeMozart.

Cet axiome de classe équivaut sémantiquement au premier exemple d'opéra dans le chapitre précédent, lequel contenait en plus une déclaration owl:equivalentClass. Les axiomes de ce type peuvent aussi se construire avec des propriétés owl:intersectionOf, owl:unionOf et owl:complementOf. Voici un exemple d'union :

<owl:Class rdf:ID="ÊtreVivant">
  <owl:unionOf rdf:parseType="Collection">
    <owl:Class rdf:about="#Plante"/>
    <owl:Class rdf:about="#Animal"/>
  </owl:unionOf>
</owl:Class>

Cet axiome de classe affirme que l'extension de classe de la classe ÊtreVivant correspond exactement à l'union des extensions de classe des classes Plante et Animal.

REMARQUE : Le langage OWL Lite inclut seulement les axiomes de ce type construits avec la propriété owl:intersectionOf. Les valeurs de liste de la propriété intersectionOf doivent être des identificateurs de classe et/ou des restrictions de propriété. Les axiomes de classe complète utilisant l'énumération, la complémentarité et l'union ne sont donc pas admis dans OWL Lite.

3.2.4 owl:disjointWith

SCHÉMA AXIOMATIQUE : description de classe owl:disjointWith description de classe

Un axiome de classe peut également contenir plusieurs déclarations owl:disjointWith. Le domaine et l'image de la propriété OWL intégrée owl:disjointWith sont des descriptions de classes. Chaque déclaration owl:disjointWith fait valoir que les deux descriptions de classe concernées n'ont aucun individu commun. Comme pour les axiomes avec rdfs:subClassOf, déclarer deux classes disjointes est une définition partielle : elle impose une condition nécessaire mais non suffisante sur la classe.

Voici un exemple de disjonction de classe à la mode :

<owl:Class rdf:about="#Homme">
  <owl:disjointWith rdf:resource="#Femme"/>
</owl:Class>

Que cette définition soit réellement vérifiée est du ressort des biologistes. L'exemple suivant montre une utilisation courante de disjonction de classe dans des hiérarchies de sous-classes :

<owl:Class rdf:about="#SpectacleMusical">
  <owl:equivalentClass>
    <owl:Class>
      <owl:unionOf rdf:parseType="Collection">
        <owl:Class rdf:about="#Opéra"/>
        <owl:Class rdf:about="#Opérette"/>
        <owl:Class rdf:about="#ComédieMusicale"/>
      </owl:unionOf>
    </owl:Class>
  </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="#Opéra">
  <rdfs:subClassOf rdf:resource="#SpectacleMusical"/>
</owl:Class>

<owl:Class rdf:about="#Opérette">
  <rdfs:subClassOf rdf:resource="#SpectacleMusical"/>
  <owl:disjointWith rdf:resource="#Opéra"/>
</owl:Class>

<owl:Class rdf:about="#ComédieMusicale">
  <rdfs:subClassOf rdf:resource="#SpectacleMusical"/>
  <owl:disjointWith rdf:resource="#Opéra"/>
  <owl:disjointWith rdf:resource="#Opérette"/>
</owl:Class>

Dans cet exemple, on utilise des déclarations owl:disjointWith avec une déclaration owl:unionOf afin de définir un ensemble de sous-classes complètes mutuellement disjointes par rapport à une superclasse. En français : chaque spectacle musical est ou bien un opéra ou bien une opérette ou bien une comédie musicale (le cloisonnement des sous-classes est complet), et les individus appartenant à une sous-classe, par exemple à Opéra, ne peuvent pas appartenir à une autre, par exemple à ComédieMusicale (des sous-classes disjointes ou non chevauchantes). Beaucoup de notations de modélisation de données emploient couramment ce concept de modélisation.

REMARQUE : Le langage OWL Lite n'admet pas l'utilisation de la propriété owl:disjointWith.

4. Les propriétés

Le langage OWL distingue deux catégories de propriétés définissables par un concepteur d'ontologies :

REMARQUE : Le langage OWL inclut également les notions de propriété d'annotation (owl:AnnotationProperty) et de propriété d'ontologie (owl:OntologyProperty). Ces propriétés sont nécessaires au langage OWL DL pour des raisons sémantiques. Cf. le chapitre 7 et le document de la sémantique et de la syntaxe abstraite OWL [OWL S&AS].

Une propriété d'objet est définie comme une instance de la classe OWL intégrée owl:ObjectProperty. Une propriété de type de donnée est définie comme une instance de la classe OWL intégrée owl:DatatypeProperty. Toutes deux sont des sous-classes de la classe RDF rdf:Property (cf. l'annexe B).

REMARQUE : Dans le langage OWL Full, les propriétés d'objets et de types de données ne sont pas disjointes. Puisqu'on peut traiter les valeurs de données comme des individus, les propriétés de types de données sont effectivement des sous-classes de propriétés d'objets. Dans OWL Full, la classe owl:ObjectProperty équivaut à la classe rdf:Property. En pratique, cela entraîne principalement des conséquences sur l'utilisation de la propriété owl:InverseFunctionalProperty. Cf. également la caractérisation du langage OWL Full dans le chapitre 8.1.

Un axiome de propriété définit les caractéristiques d'une propriété. Dans sa forme minimale, un axiome de propriété définit simplement l'existence d'une propriété. Par exemple :

<owl:ObjectProperty rdf:ID="aPourParent"/>

Cet axiome définit une propriété avec une restriction selon laquelle ses valeurs devraient être des individus.

Souvent, les axiomes de propriété définissent d'autres caractéristiques de propriétés. Le langage OWL reconnaît les structures suivantes dans les axiomes de propriété :

Dans les sous-sections suivantes, on traitera les divers types d'axiome de propriété plus en détails.

REMARQUE : Dans ce chapitre, on emploie le terme extension de propriété de façon similaire au terme extension de classe. L'extension d'une propriété est l'ensemble d'instances associé à la propriété. Les instances de propriétés ne sont pas des éléments seuls mais des couples de déclarations de propriété sujet-objet. Dans le jargon des bases de données relationnelles, on appellerait les instances d'une propriété les tuples d'une relation binaire (la propriété).

4.1 Les structures du schéma RDF

Les structures trouvées dans ce chapitre sont discutées en détails dans le document du schéma RDF [RDF Vocabulary]. Les descriptions dans ce chapitre fournissent un synopsis de ces structures, des aspects spécifiques de OWL et des exemples.

4.1.1 rdfs:subPropertyOf

Un axiome rdfs:subPropertyOf définit la propriété comme sous-propriété d'une autre. Formellement, cela signifie que si P1 est une sous-propriété de P2, alors l'extension de propriété de P1 (un ensemble de couples) devrait être un sous-ensemble de l'extension de propriété de P2 (un ensemble de couples aussi).

Voici un exemple :

<owl:ObjectProperty rdf:ID="aPourMère">
  <rdfs:subPropertyOf rdf:resource="#aPourParent"/>
</owl:ObjectProperty>

Cet axiome affirme que toutes les instances (couples) contenues dans l'extension de propriété de la propriété aPourMère sont aussi membres de l'extension de propriété de la propriété aPourParent.

Les axiomes de sous-propriété peuvent s'appliquer aux propriétés de types de données comme aux propriétés d'objets.

REMARQUE : Dans le langage OWL DL, le sujet et l'objet d'une déclaration de sous-propriété doivent tous deux être soit des propriétés de types de données, soit des propriétés d'objets.

4.1.2 rdfs:domain

On peut définir plusieurs axiomes rdfs:domain pour une propriété. Pour la syntaxe, la propriété OWL intégrée rdfs:domain relie une propriété (une certaine instance de la classe rdf:Property) à une description de classe. Un axiome rdfs:domain fait valoir que les sujets de telles déclarations de propriété doivent appartenir à l'extension de classe de la classe de description indiquée.

Les axiomes rdfs:domain multiples sont permis et on devrait les interpréter comme une conjonction : il s'agit d'une restriction du domaine de la propriété aux individus appartenant à l'intersection des descriptions de classe. Si on veut signifier que plusieurs classes agissent comme un seul domaine, on devrait utiliser une description de classe de la forme owl:unionOf. Par exemple, si nous voulons indiquer que le domaine de la propriété aUnCompteBancaire est soit Particulier, soit Entreprise, il faudrait déclarer quelque chose comme ceci :

<owl:ObjectProperty rdf:ID="aUnCompteBancaire">
  <rdfs:domain>
    <owl:Class>    
      <owl:unionOf rdf:parseType="Collection">
        <owl:Class rdf:about="#Particulier"/>
        <owl:Class rdf:about="#Entreprise"/>
      </owl:unionOf>
    </owl:Class>    
  </rdfs:domain>
</owl:ObjectProperty>

REMARQUE : Dans le langage OWL Lite, la valeur de l'axiome rdfs:domain doit être un identificateur de classe.

4.1.3 rdfs:range

On peut définir plusieurs axiomes rdfs:range pour une propriété. Pour la syntaxe, la propriété OWL intégrée rdfs:range relie une propriété (une certaine instance de la classe rdf:Property) à une description de classe, ou bien à une gamme de données. Un axiome rdfs:range fait valoir que les valeurs de cette propriété doivent appartenir à l'extension de classe de la description de classe, ou aux valeurs de données dans la gamme de données définie.

On interprète les restrictions d'image multiples comme déclarant l'image de la propriété être l'intersection de toutes les images (c'est-à-dire, l'intersection des extensions de classe des descriptions de classe, ou bien l'intersection des gammes de données). Comme pour rdfs:domain, on peut définir plusieurs images en utilisant une description de classe de type owl:unionOf (cf. la sous-section précédente).

Remarquez que les restrictions rdfs:range sont globales, contrairement aux contraintes de valeur présentées dans le chapitre des descriptions de classe. On utilise les contraintes de valeur, telle owl:allValuesFrom, dans une description de classe, et elles agissent sur la propriété seulement si celle-ci s'applique à cette classe. Par contraste, les restrictions rdfs:range sont associées à la propriété indépendamment de la classe sur laquelle elle s'applique. Il faut donc utiliser les restrictions rdfs:range avec circonspection.

REMARQUE : Dans le langage OWL Lite, le seul type de description de classe admis comme objet d'une restriction rdfs:range est un nom de classe.

4.2 Les relations aux autres propriétés

4.2.1 owl:equivalentProperty

La structure owl:equivalentProperty sert à déclarer que deux propriétés ont la même extension de propriété. Pour la syntaxe, le domaine et l'image de la propriété OWL intégrée owl:equivalentProperty sont de la classe rdf:Property.

REMARQUE : L'équivalence de propriété n'est pas la même chose que l'égalité de propriété. Les propriétés équivalentes ont les mêmes valeurs (c'est-à-dire, la même extension de propriété), mais elles peuvent avoir des significations intensionnelles différentes (c'est-à-dire représenter des concepts différents). L'égalité de propriété devrait s'exprimer avec la structure owl:sameAs. Puisque cela impose de traiter les propriétés comme des individus, ces axiomes ne sont permis que dans le langage OWL Full.

4.2.2 owl:inverseOf

Les propriétés ont une direction d'application, d'un domaine à une image. En pratique, il est souvent commode de définir des relations dans les deux sens : les personnes possèdent des voitures, les voitures sont possédées par des personnes. On peut utiliser la structure owl:inverseOf pour définir une telle relation symétrique entre des propriétés.

Pour la syntaxe, le domaine et l'image de la propriété OWL intégrée owl:inverseOf sont de la classe owl:ObjectProperty. Un axiome de la forme P1 owl:inverseOf P2 fait valoir que pour chaque couple (x,y) dans l'extension de propriété de la propriété P1, il existe un couple (y,x) dans l'extension de propriété de P2, et vice versa. La propriété owl:inverseOf est donc symétrique.

Voici un exemple :

<owl:ObjectProperty rdf:ID="aPourEnfant">
  <owl:inverseOf rdf:resource="#aPourParent"/>
</owl:ObjectProperty>

4.3 Les contraintes de cardinalité globales sur les propriétés

4.3.1 owl:FunctionalProperty

Une propriété fonctionnelle est une propriété qui ne peut avoir qu'une seule (unique) valeur y pour chaque instance x, c'est-à-dire qu'il ne peut pas y avoir de valeurs distinctes y1 et y2 telles que les couples (x,y1) et (x,y2) soient tous deux des instances de cette propriété. On peut déclarer comme fonctionnelles aussi bien les propriétés d'objets que les propriétés de types de données . Pour cela, le langage OWL définit la classe intégrée owl:FunctionalProperty comme sous-classe spéciale de la classe RDF rdf:Property.

L'axiome suivant affirme que la propriété aPourÉpoux est fonctionnelle, c'est-à-dire qu'une femme ne peut avoir qu'un époux au plus (ce qui est un bon exemple de la dépendance culturelle des ontologies) :

<owl:ObjectProperty rdf:ID="aPourÉpoux">
  <rdf:type    rdf:resource="&owl;FunctionalProperty" />
  <rdfs:domain rdf:resource="#Femme" />
  <rdfs:range  rdf:resource="#Homme" />
</owl:ObjectProperty>

Comme toujours, il existe des variations syntaxiques. L'exemple précédent est sémantiquement équivalent à celui-ci :

<owl:ObjectProperty rdf:ID="aPourÉpoux">
  <rdfs:domain rdf:resource="#Femme" />
  <rdfs:range  rdf:resource="#Homme" />
</owl:ObjectProperty>

<owl:FunctionalProperty rdf:about="#aPourÉpoux" />

4.3.2 owl:InverseFunctionalProperty

Si on déclare une propriété être fonctionnelle symétrique, alors l'objet d'une déclaration de propriété détermine son sujet de façon unique (un certain individu). Plus formellement, si on déclare la propriété P être du type owl:InverseFunctionalProperty, alors cela fait valoir qu'une valeur y ne peut être la valeur de P que pour une seule instance x, c'est-à-dire qu'il ne peut pas y avoir deux instances distinctes x1 et x2 telles que les couples (x1,y) et (x2,y) soient tous deux des instances de P.

Pour la syntaxe, on définit un axiome de propriété fonctionnelle symétrique en déclarant la propriété être une instance de la classe OWL intégrée owl:InverseFunctionalProperty qui est une sous-classe de la classe OWL owl:ObjectProperty.

REMARQUE : Puisque dans le langage OWL Full les propriétés de types de données forment une sous-classe des propriétés d'objets, il est possible de les définir comme propriétés fonctionnelles symétriques. Dans le langage OWL DL, les propriétés d'objets et les propriétés de types de données forment des ensembles disjoints, et on ne peut donc pas définir de propriété fonctionnelle symétrique des propriétés de types de données. Cf. également le chapitre 8.1 et le chapitre 8.2.

Voici un exemple typique de propriété fonctionnelle symétrique :

<owl:InverseFunctionalProperty rdf:ID="estLaMèreBiologiqueDe">
  <rdfs:domain rdf:resource="#Femme"/>
  <rdfs:range rdf:resource="#Humain"/>
</owl:InverseFunctionalProperty>

Cet exemple indique que pour chaque objet d'une déclaration estLaMèreBiologiqueDe (un certain humain), on devrait pouvoir identifier un sujet unique (une certaine femme). Les propriétés fonctionnelles symétriques ressemblent à la notion de clé dans les bases de données.

Une différence par rapport aux propriétés fonctionnelles, c'est qu'il n'est pas nécessaire d'ajouter un axiome de propriété d'objet ou de type de donnée aux propriétés fonctionnelles symétriques : par définition, ce sont des propriétés d'objets.

Remarquez que les propriétés owl:FunctionalProperty et owl:InverseFunctionalProperty établissent des contraintes de cardinalité globales. C'est-à-dire, quelle que soit la classe sur laquelle la propriété s'applique, que la contrainte de cardinalité doit être vérifiée. C'est une différence par rapport aux contraintes de cardinalités contenues dans les restrictions de propriété. Ces dernières sont des descriptions de classe, et elles agissent sur les propriétés seulement si celles-ci s'appliquent à cette classe.

4.4 Les caractéristiques logiques des propriétés

4.4.1 owl:TransitiveProperty

Lorsque l'on définit une propriété P comme étant transitive, cela signifie que si le couple (x,y) est une instance de P et le couple (y,z) aussi, alors on peut inférer que le couple (x,z) est également une instance de P.

Pour la syntaxe, une propriété est définie comme étant transitive en faisant d'elle une instance de la classe OWL intégrée owl:TransitiveProperty qui est définie comme sous-classe de owl:ObjectProperty.

Les propriétés représentant des relations d'inclusion sont habituellement transitives. Par exemple, on pourrait indiquer que la propriété sousRégionDe entre des régions est transitive :

<owl:TransitiveProperty rdf:ID="sousRégionDe">
  <rdfs:domain rdf:resource="#Région"/>
  <rdfs:range  rdf:resource="#Région"/>
</owl:TransitiveProperty>

D'après cette déclaration, un moteur de raisonnement OWL devrait pouvoir déduire que si ChiantiClassico, Toscane et Italie sont des régions, et si ChiantiClassico est une sous-région de Toscane et Toscane une sous-région de Italie, alors ChiantiClassico est également une sous-région de Italie.

Remarquez, puisque owl:TransitiveProperty est une sous-classe de owl:ObjectProperty, que la variante syntaxique-ci équivaut à l'exemple précédent :

<owl:ObjectProperty rdf:ID="sousRégionDe">
  <rdf:type rdf:resource="&owl;TransitiveProperty"/>
  <rdfs:domain rdf:resource="#Région"/>
  <rdfs:range  rdf:resource="#Région"/>
</owl:ObjectProperty>

REMARQUE : Le langage OWL DL impose, en ce qui concerne une propriété transitive, de ne pas déclarer de contrainte de cardinalité locale ou globale sur la propriété même ou ses superpropriétés, ni sur la propriété symétrique ou ses superpropriétés.

4.4.2 owl:SymmetricProperty

Une propriété symétrique est telle que si le couple (x,y) est une instance de la propriété P, alors le couple (y,x) est aussi une instance de P. Pour la syntaxe, une propriété est définie comme symétrique en faisant de celle-ci une instance de la classe OWL intégrée owl:SymmetricProperty qui est une sous-classe de owl:ObjectProperty.

Un exemple à la mode de propriété symétrique est la relation estAmiDe :

<owl:SymmetricProperty rdf:ID="estAmiDe">
  <rdfs:domain rdf:resource="#Humain"/>
  <rdfs:range  rdf:resource="#Humain"/>
</owl:SymmetricProperty>

Le domaine et l'image d'une propriété symétrique se confondent.

5. Les individus

Les individus se définissent avec des axiomes d'individu (appelés aussi des faits). Nous discuterons de deux types de faits :

  1. Les faits concernant l'appartenance de classe et les valeurs de propriétés des individus ;
  2. Les faits concernant l'identité des individus.

5.1 L'appartenance de classe et les valeurs de propriétés

Beaucoup de faits sont généralement des déclarations indiquant l'appartenance de classe des individus et les valeurs de leurs propriétés. Comme exemple, prenons l'ensemble de déclarations suivant à propos d'une instance de la classe Opéra :

<Opéra rdf:ID="Tosca">
  <aPourCompositeur rdf:resource="#Giacomo_Puccini"/>
  <aPourParolier rdf:resource="#Victorien_Sardou"/>
  <aPourParolier rdf:resource="#Giuseppe_Giacosa"/>
  <aPourParolier rdf:resource="#Luigi_Illica"/>
  <dateDeLaPremière rdf:datatype="&xsd;date">1900-01-14</dateDeLaPremière>
  <lieuPremière rdf:resource="#Roma"/>
  <nombreActes rdf:datatype="&xsd;positiveInteger">3</nombreActes> 
</Opéra>

Cet exemple comprend un certain nombre de faits concernant l'individu Tosca qui est une instance de la classe Opéra. L'opéra Tosca a été composé par Giacomo Puccini. L'opéra a eu trois paroliers. La propriété dateDeLaPremière relie un opéra à un littéral de type date du schéma XML. Le document du schéma XML traitant des types de données [XML Schema Datatypes] contient les informations nécessaires à propos de la syntaxe et la sémantique de ce type de donnée.

Les axiomes d'individu ne concernent pas forcément des individus nommés : ils peuvent également désigner des individus anonymes. Comme exemple, prenons l'extrait de code RDF/XML suivant. On définit quelques faits à propos d'une instance anonyme de la classe Mesure, une observation quantitative listant des faits tels que le sujet à observer, le phénomène observé, la valeur observée et la date d'observation :

<Mesure>
  <sujetObservé rdf:resource="#MarieMartin"/>
  <phénomèneObservé rdf:resource="#Poids"/>
  <valeurObservée>
    <Quantité>
      <valeurDeQuantité rdf:datatype="&xsd;float">59.5</valeurDeQuantité>
      <unitéDeQuantité rdf:resource="#Kilogramme"/>
    </Quantité>
  </valeurObservée>
  <dateObservation rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</dateObservation>
</Mesure>

Cet axiome d'individu contient deux individus anonymes, à savoir Mesure et Quantité. En français : pour le sujet Marie Martin la valeur mesurée du phénomène Poids est une certaine quantité, dont la valeur est 59.5 dans l'unité kilogramme ; la mesure a eu lieu en date du 24 janvier 2003 à neuf heure et huit secondes du matin, dans le fuseau horaire UTC+1 (heure d'hiver à Amsterdam, Berlin, Paris). Comme précédemment, les types float et dateTime sont des types de données du schéma XML, dont on trouvera la syntaxe et la sémantique dans la documentation appropriée du schéma XML [XML Schema Datatypes].

5.2 L'identité de l'individu

Beaucoup de langages admettent un postulat de soit-disant noms uniques : des noms différents désignent des choses différentes dans la réalité. Sur le Web, ce postulat est impossible. Par exemple, la même personne pourrait être désignée de plusieurs façons différentes (c'est-à-dire avec des appels d'adresse URI différents). Le langage OWL ne retient pas cette hypothèse pour cette raison. Sauf déclaration explicite selon laquelle deux adresses URI se rapportent au même individu ou sinon à des individus différents, les outils OWL devrait en principe supposer les deux éventualités.

Le langage OWL offre trois structures pour déclarer les faits concernant l'identité des individus :

5.2.1 owl:sameAs

La propriété OWL intégrée owl:sameAs relie un individu à un autre individu. Une telle déclaration owl:sameAs indique que deux appels d'adresses URI se rapportent en réalité à la même chose : les individus ont la même identité.

Pour des individus tels que ceux de la classe des personnes, cette notion est relativement facile à comprendre. Par exemple, on pourrait déclarer que les deux appels d'adresses URI suivants désignent en fait une même personne :

<rdf:Description rdf:about="#William_Jefferson_Clinton">
  <owl:sameAs rdf:resource="#BillClinton"/>
</rdf:Description>

Les déclarations owl:sameAs sont souvent utilisées pour définir des correspondances entre les ontologies. Il n'est pas réaliste de supposer que tout le monde utilisera le même nom pour désigner des individus. Cela nécessiterait un projet d'ensemble ce qui est contraire à l'esprit du Web.

Dans le langage OWL Full où les classes peuvent être traitées comme des instances de classes (métaclasses), nous pouvons utiliser la structure owl:sameAs pour définir une égalité de classe, indiquant ainsi que deux concepts ont la même signification intensionnelle. Voici un exemple :

<owl:Class rdf:ID="ÉquipeDeFootball">
  <owl:sameAs rdf:resource="http://sports.org/US#SoccerTeam"/>
</owl:Class>

On pourrait imaginer que cet axiome fasse partie d'une ontologie européenne de sports. Les deux classes sont traitées ici comme des individus, en tant qu'instances de la classe owl:Class. Cela nous permet de déclarer que la classe ÉquipeDeFootball d'une certaine ontologie européenne de sports présente un concept similaire à celui de la classe SoccerTeam d'une certaine ontologie américaine de sports. Remarquez la différence avec la déclaration suivante :

<ÉquipeDeFootball owl:equivalentClass us:SoccerTeam />

Cet axiome indique que les deux classes ont la même extension de classe mais ne relèvent pas (forcément) de concepts semblables.

REMARQUE : Pour des précisions sur la comparaison des appels d'adresses URI, cf. le chapitre sur les appels d'adresses URI RDF dans le document des concepts RDF [RDF Concepts].

5.2.2 owl:differentFrom

La propriété OWL intégrée owl:differentFrom relie un individu à un autre individu. Une déclaration owl:differentFrom indique que deux appels d'adresses URI se rapportent à des individus différents.

Voici un exemple :

<Opéra rdf:ID="Don_Giovanni"/>

<Opéra rdf:ID="Nozze_di_Figaro">
  <owl:differentFrom rdf:resource="#Don_Giovanni"/>
</Opéra>

<Opéra rdf:ID="Cosi_fan_tutte">
  <owl:differentFrom rdf:resource="#Don_Giovanni"/>
  <owl:differentFrom rdf:resource="#Nozze_di_Figaro"/>
</Opéra>
Cet exemple déclare l'existence de trois opéras différents.

5.2.3 owl:AllDifferent

Pour les ontologies où tient le postulat de noms uniques, utiliser la propriété owl:differentFrom conduira probablement à un grand nombre de déclarations, car tous les individus doivent être déclarés disjoints deux-à-deux. Pour de telles situations, le langage OWL offre un idiome spécial sous la forme de la structure owl:AllDifferent. Cette structure owl:AllDifferent est une classe OWL intégrée spéciale, dont la propriété owl:distinctMembers est définie, qui relie une instance de owl:AllDifferent à une liste d'individus. La signification résultant de cette déclaration, c'est que tous les individus de la liste sont différents les uns des autres.

Voici un exemple :

<owl:AllDifferent>
  <owl:distinctMembers rdf:parseType="Collection">
    <Opera rdf:about="#Don_Giovanni"/>
    <Opera rdf:about="#Nozze_di_Figaro"/>
    <Opera rdf:about="#Cosi_fan_tutte"/>
    <Opera rdf:about="#Tosca"/>
    <Opera rdf:about="#Turandot"/>
    <Opera rdf:about="#Salome"/>
  </owl:distinctMembers>
</owl:AllDifferent>

Cet exemple déclare que les six appels d'adresses URI pointent tous vers des opéras différents.

REMARQUE : La propriété owl:distinctMembers est une structure syntaxique spéciale, ajoutée par commodité, qui devrait toujours s'utiliser avec un individu owl:AllDifferent comme sujet.

6. Les types de données

À plusieurs reprises dans ce document, nous avons entraperçu la notion de gamme de données pour définir un ensemble de valeurs de données. Le langage OWL offre trois types de définitions de valeurs de données :

Le niveau de prise en charge minimale des types de données par un outil est expliqué dans le chapitre 6.3.

6.1 Les types de données RDF

Le langage OWL utilise le système de typage de données RDF, qui fournit un mécanisme permettant une référence aux types de données du schéma XML [XML Schema Datatypes]. Le lecteur est invité à consulter la documentation RDF, par exemple [RDF Concepts], pour une description détaillée. Pour la commodité du lecteur, nous présentons ici un synopsis de l'utilisation des types de données RDF.

Les valeurs de données sont des instances de la classe rdfs:Literal du schéma RDF. Les littéraux peuvent se présenter soit sous une forme brute (pas de type de donnée), soit sous une forme typée. Les types de données sont des instances de la classe rdfs:Datatype. Dans RDF/XML, le type d'un littéral est indiqué par un attribut rdf:datatype pour lequel on recommande l'une des valeurs suivantes :

Le document de la sémantique RDF [RDF Semantics, chapitre 5] recommande d'utiliser les types de données intégrés simples du schéma XML suivants :

REMARQUE : Quoique non recommandé, il n'est pas interdit aux applications de définir leurs propres types de données à partir d'une instance de la classe rdfs:Datatype. Ces types de données sont non reconnus mais ils sont traités de façon similaire aux types de données non pris en charge (cf. le chapitre 6.3 pour des précisions sur la façon dont les outils OWL devraient les traiter).

Lorsqu'on utilise des types de données, veuillez remarquer que, même si une propriété est définie avoir une image d'un certain type, le langage RDF/XML impose de toujours définir le type de donnée à chaque utilisation de la propriété. Un exemple pourrait être celui de la déclaration de propriété que nous avons utilisé précédemment pour la classe Mesure :

<owl:DatatypeProperty rdf:about="#dateObservation">
  <rdfs:domain rdf:resource="#Mesure"/>
  <rdf:range rdf:resource="&xsd;dateTime"/>
</owl:DatatypeProperty>

<Mesure>
  <dateObservation rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</dateObservation>  
</Mesure>

6.2 Le type de donnée énuméré

Outre les types de données RDF, le langage OWL fournit une autre structure pour définir une gamme de valeurs de données, à savoir un type de donnée énuméré. Ce format de type de donnée utilise la structure owl:oneOf, qui sert aussi à décrire une classe énumérée. Pour un type de donnée énuméré, le sujet de la propriété owl:oneOf est un nœud blanc de la classe owl:DataRange et son objet une liste de littéraux. Malheureusement, on ne peut pas utiliser l'idiome rdf:parseType='Collection' pour définir la liste des littéraux, car RDF impose à la collection d'être une liste d'éléments de nœuds RDF. Nous devons donc définir la liste des valeurs de données avec les structures de liste de base rdf:first, rdf:rest et rdf:nil.

REMARQUE : Les types de données énumérés ne font pas partie du langage OWL Lite.

L'exemple suivant définit l'image de la propriété marqueDuTennis comme étant la liste des valeurs entières {0, 15, 30, 40} :

<owl:DatatypeProperty rdf:ID="marqueDuTennis">
  <rdfs:range>
    <owl:DataRange>
      <owl:oneOf>
        <rdf:List>
           <rdf:first rdf:datatype="&xsd;integer">0</rdf:first>
           <rdf:rest>
             <rdf:List>
               <rdf:first rdf:datatype="&xsd;integer">15</rdf:first>
               <rdf:rest>
                 <rdf:List>
                   <rdf:first rdf:datatype="&xsd;integer">30</rdf:first>
                   <rdf:rest>
                     <rdf:List>
                       <rdf:first rdf:datatype="&xsd;integer">40</rdf:first>
                       <rdf:rest rdf:resource="&rdf;nil" />
                     </rdf:List>
                   </rdf:rest>
                 </rdf:List>
              </rdf:rest>
            </rdf:List>
          </rdf:rest>
        </rdf:List>
      </owl:oneOf>
    </owl:DataRange>
  </rdfs:range>
</owl:DatatypeProperty>

6.3 La gestion du raisonnement des types de données

Les outils peuvent varier en matière de gestion du raisonnement des types de données. Au minimum, les outils doivent prendre en charge le raisonnement des types de données xsd:string et xsd:integer du schéma XML. Les outils OWL Full doivent également prendre en charge le type rdf:XMLLiteral. En ce qui concerne les types de données non pris en charge, les littéraux lexicalement identiques devraient être considérés égaux, tandis que ceux lexicalement différents ne sauraient être décidés égaux ou inégaux. Les types de données non reconnus devraient recevoir le même traitement que pour les types de données non pris en charge.

7. Les annotations, l'en-tête d'ontologie, les importations et les informations de version

7.1 Les annotations

Le langate OWL Full ne place aucune contrainte pour les annotations d'une ontologie. Il admet des annotations sur les classes, les propriétés, les individus et les en-têtes d'ontologies, mais seulement aux conditions suivantes :

Le langage OWL prédéfinit cinq propriétés d'annotations, à savoir :

Voici un exemple d'utilisation de propriété d'annotation légale dans OWL DL :

<owl:AnnotationProperty rdf:about="&dc;creator"/>

<owl:Class rdf:about="#GenreMusical">
  <rdfs:label>Genre musical</rdfs:label>
  <dc:creator>N.N.</dc:creator>
</owl:Class>

L'exemple suppose que &dc; et dc: pointent respectivement vers l'adresse URI et l'espace de nommage Dublin Core. Utiliser une propriété Dublin Core comme propriété d'annotation dans le langage OWL DL impose donc un triplet de typage. Cela garantit la manipulation sémantique correcte des annotations par les moteurs de raisonnement OWL DL (cf. le document de la sémantique et de la syntaxe abstraite de OWL [OWL S&AS] pour des précisions).

Une fois défini dc:creator comme propriété d'annotation, le langage OWL DL INTERDIT les axiomes de propriétés comme la contrainte d'image suivante :

<-- Ceci est illégal dans OWL DL -->

<owl:AnnotationProperty rdf:about="&dc;creator">
  <rdfs:range rdf:resource="&xsd;string"/>
</owl:AnnotationProperty>

Remarquez que l'on peut toujours indiquer le type de valeur d'un littéral dans la déclaration d'une propriété d'annotation :

<Opéra rdf:about="#Tosca">
  <dc:creator rdf:datatype="&xsd;string">Giacomo Puccini</dc:creator>
</Opéra>

7.2 L'en-tête de l'ontologie

Un document décrivant une ontologie contient généralement des informations à propos de l'ontologie elle-même. Une ontologie étant une ressource, on peut donc la décrire avec des propriétés issues de l'espace de nommage OWL et d'autres espaces de nommage, par exemple :

<owl:Ontology rdf:about="">
  <owl:versionInfo> ... </owl:versionInfo>
  <rdfs:comment>...</rdfs:comment>
  <owl:imports rdf:resource="..."/>
</owl:Ontology>

C'est ce qu'on appelle couramment l'en-tête de l'ontologie, qui se trouve en générale vers le début du document RDF/XML.

  <owl:Ontology rdf:about="">

Cette ligne déclare que ce bloc décrit l'ontologie en question. Plus précisément, elle déclare que l'adresse URI de base courante identifie une instance de la classe owl:Ontology. On recommande de définir l'adresse URI de base par un attribut xml:base dans l'élément <rdf:RDF> au tout début du document.

Un exemple d'en-tête d'ontologie ressemblerait à ceci :

<owl:Ontology rdf:about="">
  <owl:versionInfo>v 1.17 2003/02/26 12:56:51 mdean</owl:versionInfo>
  <rdfs:comment>Un exemple d'ontologie</rdfs:comment>
  <owl:imports rdf:resource="http://www.example.org/foo"/>
</owl:Ontology>

Les chapitres suivants décrivent les divers types de déclarations utilisés habituellement dans l'en-tête.

REMARQUE : La structure d'importation d'ontologies owl:imports, et les structures de versionnage d'ontologies owl:priorVersion, owl:backwardCompatibleWith et owl:incompatibleWith sont définies dans le vocabulaire OWL comme étant des instances de la classe OWL intégrée owl:OntologyProperty. Le domaine et l'image des instances de owl:OntologyProperty doivent être de la classe owl:Ontology. On peut définir d'autres instances de la classe owl:OntologyProperty. Dans le langage OWL DL, les contraintes des propriétés d'ontologies sont les mêmes que celles des propriétés d'annotations (cf. le chapitre 7.1).

7.3 L'importation d'une ontologie

Une déclaration owl:imports appelle une autre ontologie OWL contenant des définitions dont la signification fait partie de l'ontologie appelante. Chaque appel consiste en une adresse URI indiquant où est l'ontologie à importer. Pour la syntaxe, le domaine et l'image de la propriété owl:imports sont de la classe owl:Ontology.

Les déclarations owl:imports sont transitives, c'est-à-dire que si l'ontologie A importe l'ontologie B, et si B importe C, alors A importe les deux ontologies B et C.

L'importation d'une ontologie par elle-même est une action nulle, donc si l'ontologie A importe l'ontologie B et si B importe A, alors elles sont considérées équivalentes.

Remarquez que le chargement ou non d'une ontologie importée par un outil OWL dépendra de la destination de l'outil. Si l'outil est un moteur de raisonnement complet (comprenant des vérificateurs de cohérence complets), il doit alors charger toutes les ontologies importées. D'autres outils, comme les éditeurs simples et les moteurs de raisonnement incomplets, peuvent opter de ne charger que certaines ontologies importées voire aucune.

Quoique les déclarations owl:imports et d'espaces de nommage puissent sembler redondantes, elles servent en réalité des objectifs différents. Les déclarations d'espaces de nommage établissent simplement un raccourci pour appeler des identificateurs. Elles ne contiennent pas implicitement la signification des documents désignés par l'adresse URI. Inversement, les déclarations owl:imports n'offrent aucune notation raccourcie pour appeler les identificateurs depuis le document importé. C'est pourquoi il est courant d'avoir la déclaration de l'espace de nommage correspondant d'une ontologie importée.

REMARQUE : La propriété owl:imports est une instance de la classe owl:OntologyProperty.

7.4 Les informations de version

7.4.1 owl:versionInfo

L'objet d'une déclaration owl:versionInfo est généralement une chaîne fournissant des renseignements à propos de la version de l'ontologie, par exemple, des mots-clés RCS/CVS. Cette déclaration ne contribue pas à la signification logique de l'ontologie hormis celle fournie par le modèle théorique RDF(S).

Bien que cette propriété servent habituellement à faire des déclarations à propos des ontologies, elle peut s'appliquer à n'importe quelle structure OWL. Par exemple, on pourrait associer une déclaration owl:versionInfo à une classe OWL.

REMARQUE : La propriété owl:versionInfo est une instance de la classe owl:AnnotationProperty.

7.4.2 owl:priorVersion

Une déclaration owl:priorVersion contient une référence à une autre ontologie. Elle identifie l'ontologie indiquée comme une version précédente de l'ontologie courante. Cette déclaration n'a pas de signification dans la sémantique théorique du modèle hormis celle fournie par le modèle théorique RDF(S). Par contre, elle peut être exploitée par un programme pour organiser les ontologies par version.

Le domaine et l'image de la propriété OWL intégrée owl:priorVersion sont de la classe owl:Ontology.

REMARQUE : La propriété owl:priorVersion est une instance de la classe owl:OntologyProperty.

7.4.3 owl:backwardCompatibleWith

Une déclaration owl:backwardCompatibleWith contient une référence à une autre ontologie. Elle identifie l'ontologie indiquée comme une version précédente de l'ontologie courante, en indiquant en outre que cette dernière est rétrocompatible. Notamment, elle indique que tous les identificateurs de la version précédente gardent la même interprétation dans la nouvelle version. C'est donc une indication fournie aux auteurs afin d'engager leurs documents en toute sécurité vers la nouvelle version (en mettant simplement à jour les déclarations d'espaces de nommage et les déclarations owl:imports pour les pointer vers l'adresse URL de la nouvelle version). Si deux versions ne sont pas reliées par la propriété owl:backwardCompatibleWith, alors elles ne sont pas compatibles.

La propriété owl:backwardCompatibleWith n'a pas de signification dans la sémantique théorique du modèle hormis celle fournie par le modèle théorique RDF(S).

Le domaine et l'image de la propriété OWL intégrée owl:backwardCompatibleWith sont de la classe owl:Ontology.

REMARQUE : La propriété owl:backwardCompatibleWith est une instance de la classe owl:OntologyProperty.

7.4.4 owl:incompatibleWith

Une déclaration owl:incompatibleWith contient une référence à une autre ontologie. Elle identifie l'ontologie courante comme une version ultérieure mais non compatible de celle indiquée. Pour l'essentiel, cette déclaration s'adresse aux auteurs d'ontologies voulant signaler explicitement que les documents ne peuvent pas être mis à jour vers la nouvelle version sans vérifier si des changements sont nécessaires.

La propriété owl:incompatibleWith n'a pas de signification dans la sémantique théorique du modèle hormis celle fournie par le modèle théorique RDF(S).

Le domaine et l'image de la propriété OWL intégrée owl:incompatibleWith sont de la classe owl:Ontology.

REMARQUE : La propriété owl:backwardCompatibleWith est une instance de la classe owl:OntologyProperty.

7.4.5 owl:DeprecatedClass et owl:DeprecatedProperty

La contre-indication est un mécanisme couramment employé dans le versionnage logiciel (cf. par exemple, le langage de programmation Java) pour indiquer qu'une caractéristique particulière, quoique conservée pour des raisons de rétrocompatibilité, est susceptible de disparaître dans le futur. Auquel cas, on dira qu'un identificateur donné est du type owl:DeprecatedClass ou owl:DeprecatedProperty, où owl:DeprecatedClass est une sous-classe de rdfs:Class, et owl:DeprecatedProperty une sous-classe de rdf:Property. La contre-indication d'un terme signifie qu'il ne devrait plus être employé dans les nouveaux documents engagés dans une ontologie. Cela permet à l'ontologie de rester compatible pendant le remplacement progressif de l'ancien vocabulaire (utiliser la contre-indication n'est donc logique qu'en combinaison avec la rétro-compatibilité). En conséquence, les données et les applications anciennes migreront plus facilement tout en augmentant le degré d'adoption de la nouvelle version. Cela n'a pas de signification dans la sémantique théorique du modèle hormis celle fournie par le modèle théorique RDF(S). Toutefois, les outils de création peuvent s'en servir pour avertir les utilisateurs lors de la vérification d'un balisage OWL.

Voici un exemple de contre-indication :

<owl:Ontology rdf:about="">
  <rdfs:comment>Ontologie de véhicules, v. 1.1</rdfs:comment>
  <owl:backwardCompatibleWith
          rdf:resource="http://www.example.org/vehicules-1.0"/>   
  <owl:priorVersion rdf:resource="http://www.example.org/vehicules-1.0"/>
</owl:Ontology>

<owl:DeprecatedClass rdf:ID="Voiture">
  <rdfs:comment>On préfère « automobile » dorénavant</rdfs:comment>
  <owl:equivalentClass rdf:resource="#Automobile"/>
  <!-- Remarquez que la déclaration equivalentClass dit simplement que les classes ont
       la même extension de classe ; on NE DOIT PAS en conclure qu'Automobile est aussi
       de type DeprecatedClass  -->        
</owl:DeprecatedClass>

<owl:Class rdf:ID="Automobile" />

<owl:DeprecatedProperty rdf:ID="aPourConducteur">
  <rdfs:comment>On préfère la propriété symétrique « conduit » dorénavant</rdfs:comment>
  <owl:inverseOf rdf:resource="#conduit" />
</owl:DeprecatedProperty>

<owl:ObjectProperty rdf:ID="conduit
" />

8. OWL Full, OWL DL et OWL Lite

En introduction, nous avons présenté brièvement les trois sous-langages de OWL. Dans ce chapitre, on informe des différences entre les trois espèces du langage OWL. Un compte formel de ces différences est donné dans le document de la sémantique et de la syntaxe abstraite [OWL S&AS].

8.1 OWL Full

En réalité, le langage OWL Full n'est pas un sous-langage. OWL Full contient l'intégralité des structures du langage OWL et il permet d'utiliser librement les structures RDF. Dans OWL Full, la ressource owl:Class équivaut à rdfs:Class. Contrairement à OWL DL et OWL Lite, où owl:Class est une sous-classe propre de rdfs:Class (c'est-à-dire que les classes RDF ne sont pas toutes des classes OWL DL ou OWL Lite). Le langage OWL Full permet également aux classes d'apparaître comme des individus. Par exemple, dans OWL Full, il est parfaitement légal d'avoir un identificateur Fokker-100 qui se comporte à la fois comme nom de classe (dénotant l'ensemble des avions Fokker-100 volant dans le monde) et comme nom d'individu (par exemple, en tant qu'instance de la classe TypeAvion).

Dans OWL Full, toutes les valeurs de données font aussi partie du domaine de l'individu. Dans OWL Full, l'univers des individus se compose de toutes les ressources (owl:Thing équivaut à rdfs:Resource). Cela signifie que les propriétés d'objets et les propriétés de types de données ne sont pas disjointes. Dans OWL Full, la classe owl:ObjectProperty équivaut à la classe rdf:Property. En conséquence, les propriétés de types de données constituent une sous-classe des propriétés d'objets. (Remarque : Le fait que les classes owl:ObjectProperty et owl:DatatypeProperty soient toutes deux des sous-classes de rdf:Property n'est pas une contradiction).

Le langage OWL Full servira typiquement aux personnes voulant combiner la capacité d'expression du langage OWL à la flexibilité et aux caractéristiques de métamodélisation de RDF. Toutefois, l'utilisation des fonctionnalités de OWL Full signifie aussi l'abandon des garanties (cf. ci-dessous) que OWL DL et OWL Lite sont susceptibles d'apporter aux systèmes de raisonnement.

REMARQUE : Les documents RDF seront généralement en OWL Full, sauf à les construire spécifiquement en OWL DL ou OWL Lite.

REMARQUE : En résumé, dans OWL Full, la classe owl:Thing équivaut à la classe rdfs:Resource, la classe owl:Class équivaut à rdfs:Class, et la classe owl:ObjectProperty à rdf:Property.

8.2 OWL DL

Le langage OWL DL est un sous-langage de OWL qui placer certaines contraintes sur l'utilisation des structures du langage OWL. En bref, ces contraintes sont les suivantes :

Ces contraintes du langage OWL DL semblent constituer un ensemble arbitraire, mais ce n'est pas le cas en réalité. Elles sont fondées sur les travaux réalisés dans le domaine des moteurs de raisonnement dans la logique de description, lesquels imposent ces restrictions afin de permettre une gestion du raisonnement aux concepteurs ou aux utilisateurs d'ontologies. En particulier, les restrictions OWL DL permettent de réaliser le sous-ensemble maximal du langage OWL Full, pour lequel la recherche actuelle peut assurer qu'il existe une procédure de raisonnement décidable pour un moteur de raisonnement OWL.

REMARQUE : L'annexe E donne des conseils pratiques afin de définir des ontologies OWL DL dans RDF.

8.3 OWL Lite

Le langage OWL Lite respecte toutes les restrictions que le langage OWL DL place sur l'utilisation des structures de langage OWL. En outre, OWL Lite interdit l'utilisation de :

Le langage OWL Lite impose aussi que :

L'idée derrière les limitations d'expressivité du langage OWL Lite est de produire un sous-ensemble pratique minimal des caractéristiques du langage, relativement simple à mettre en œuvre par les développeurs d'outils. Les structures de langage OWL Lite fournissent l'essentiel de la construction d'une hiérarchie de sous-classes : des sous-classes et des restrictions de propriétés. En outre, OWL Lite permet de rendre les propriétés optionnelle ou obligatoires. Les limitations du langage OWL Lite le placent à un niveau de complexité inférieur à celui du langage OWL DL. Cela peut avoir un impact positif sur l'efficacité des moteurs de raisonnement complets OWL Lite.

Les mises en œuvre qui prennent seulement en charge le vocabulaire OWL Lite, mais sinon relâchent les restrictions de OWL DL, ne peuvent pas prétendre à certains calculs en ce qui concerne la cohérence et la complexité. Toutefois, elles peuvent se révéler utiles en apportant, à l'interopérabilité des systèmes OWL, des modèles RDFS, des bases de données, des outils de balisage ou d'autres outils sans raisonnement. Le groupe de travail Ontologie Web n'a pas donné de nom à ce sous-ensemble potentiellement utile.

Annexe A. Index de tous les éléments du langage

REMARQUE : Cette annexe contient seulement les structures spécifiques du langage OWL. Pour les structures RDF/RDFS, cf. la documentation RDF concernée, notamment le document du schéma RDF [RDF Vocabulary].

[Référence OWL]
(ce document)
[Sémantique OWL]
(normatif)
[Guide OWL]
(exemples)
owl:AllDifferent owl:AllDifferent owl:AllDifferent
owl:allValuesFrom owl:allValuesFrom owl:allValuesFrom
owl:AnnotationProperty owl:AnnotationProperty
owl:backwardCompatibleWith owl:backwardCompatibleWith owl:backwardCompatibleWith
owl:cardinality owl:cardinality owl:cardinality
owl:Class owl:Class owl:Class
owl:complementOf owl:complementOf owl:complementOf
owl:DataRange owl:DataRange
owl:DatatypeProperty owl:DatatypeProperty owl:DatatypeProperty
owl:DeprecatedClass owl:DeprecatedClass owl:DeprecatedClass
owl:DeprecatedProperty owl:DeprecatedProperty owl:DeprecatedProperty
owl:differentFrom owl:differentFrom owl:differentFrom
owl:disjointWith owl:disjointWith owl:disjointWith
owl:distinctMembers owl:distinctMembers owl:distinctMembers
owl:equivalentClass owl:equivalentClass owl:equivalentClass
owl:equivalentProperty owl:equivalentProperty owl:equivalentProperty
owl:FunctionalProperty owl:FunctionalProperty owl:FunctionalProperty
owl:hasValue owl:hasValue owl:hasValue
owl:imports owl:imports owl:imports
owl:incompatibleWith owl:incompatibleWith owl:incompatibleWith
owl:intersectionOf owl:intersectionOf owl:intersectionOf
owl:InverseFunctionalProperty owl:InverseFunctionalProperty owl:InverseFunctionalProperty
owl:inverseOf owl:inverseOf owl:inverseOf
owl:maxCardinality owl:maxCardinality owl:maxCardinality
owl:minCardinality owl:minCardinality owl:minCardinality
owl:Nothing owl:Nothing owl:Nothing
owl:ObjectProperty owl:ObjectProperty owl:ObjectProperty
owl:oneOf owl:oneOf owl:oneOf
owl:onProperty owl:onProperty owl:onProperty
owl:Ontology owl:Ontology owl:Ontology
owl:OntologyProperty owl:OntologyProperty
owl:priorVersion owl:priorVersion owl:priorVersion
owl:Restriction owl:Restriction owl:Restriction
owl:sameAs owl:sameAs owl:sameAs
owl:someValuesFrom owl:someValuesFrom owl:someValuesFrom
owl:SymmetricProperty owl:SymmetricProperty owl:SymmetricProperty
owl:Thing owl:Thing owl:Thing
owl:TransitiveProperty owl:TransitiveProperty owl:TransitiveProperty
owl:unionOf owl:unionOf owl:unionOf
owl:versionInfo owl:versionInfo owl:versionInfo

Annexe B. Le schéma RDF du langage OWL

Cf. le chapitre 1.7 pour une description de l'objectif de cette annexe. On peut trouver la version RDF/XML de cette annexe à http://www.w3.org/2002/07/owl.

<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [
     <!ENTITY rdf  "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
     <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
     <!ENTITY xsd  "http://www.w3.org/2001/XMLSchema#" >
     <!ENTITY owl  "http://www.w3.org/2002/07/owl#" >
   ]>

<rdf:RDF
  xmlns     ="&owl;"
  xmlns:owl ="&owl;"
  xml:base  ="http://www.w3.org/2002/07/owl"
  xmlns:rdf ="&rdf;"
  xmlns:rdfs="&rdfs;"
>

<Ontology rdf:about="">
  <imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-semantics-20040210/" />
  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-test-20040210/" />
  <rdfs:isDefinedBy rdf:resource="http://www.w3.org/TR/2004/REC-owl-features-20040210/" />
  <rdfs:comment>Ce fichier définit, dans le format du schéma RDF,
    les classes et propriétés intégrées qui forment collectivement
    la base de la syntaxe RDF/XML de OWL Full, OWL DL et OWL Lite.
    Ce fichier n'a pas destiné à être importé explicitement dans une ontologie.
    Les personnes qui le feraient quand même obtiendront une ontologie OWL Full. 
  </rdfs:comment>
  <versionInfo>10 février 2004</versionInfo>
</Ontology>

<rdfs:Class rdf:ID="Class">
  <rdfs:label>Class</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdfs;Class"/>
</rdfs:Class>

<Class rdf:ID="Thing">
  <rdfs:label>Thing</rdfs:label>
  <unionOf rdf:parseType="Collection">
    <Class rdf:about="#Nothing"/>
    <Class>
      <complementOf rdf:resource="#Nothing"/>
    </Class>
  </unionOf>
</Class>

<Class rdf:ID="Nothing">
  <rdfs:label>Nothing</rdfs:label>
  <complementOf rdf:resource="#Thing"/>
</Class>

<rdf:Property rdf:ID="equivalentClass">
  <rdfs:label>equivalentClass</rdfs:label>
  <rdfs:subPropertyOf rdf:resource="&rdfs;subClassOf"/>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</rdf:Property>

<rdf:Property rdf:ID="disjointWith">
  <rdfs:label>disjointWith</rdfs:label>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</rdf:Property>

<rdf:Property rdf:ID="equivalentProperty">
  <rdfs:label>equivalentProperty</rdfs:label>
  <rdfs:subPropertyOf rdf:resource="&rdfs;subPropertyOf"/>
</rdf:Property>

<rdf:Property rdf:ID="sameAs"> 
  <rdfs:label>sameAs</rdfs:label>
  <rdfs:domain rdf:resource="#Thing"/>
  <rdfs:range rdf:resource="#Thing"/>
</rdf:Property>

<rdf:Property rdf:ID="differentFrom">
  <rdfs:label>differentFrom</rdfs:label>
  <rdfs:domain rdf:resource="#Thing"/>
  <rdfs:range rdf:resource="#Thing"/>
</rdf:Property>

<rdfs:Class rdf:ID="AllDifferent">
  <rdfs:label>AllDifferent</rdfs:label>
</rdfs:Class>

<rdf:Property rdf:ID="distinctMembers">
  <rdfs:label>distinctMembers</rdfs:label>
  <rdfs:domain rdf:resource="#AllDifferent"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</rdf:Property>
  
<rdf:Property rdf:ID="unionOf">
  <rdfs:label>unionOf</rdfs:label>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</rdf:Property>

<rdf:Property rdf:ID="intersectionOf">
  <rdfs:label>intersectionOf</rdfs:label>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</rdf:Property>

<rdf:Property rdf:ID="complementOf">
  <rdfs:label>complementOf</rdfs:label>
  <rdfs:domain rdf:resource="#Class"/>
  <rdfs:range rdf:resource="#Class"/>
</rdf:Property>

<rdf:Property rdf:ID="oneOf">
  <rdfs:label>oneOf</rdfs:label>
  <rdfs:domain rdf:resource="&rdfs;Class"/>
  <rdfs:range rdf:resource="&rdf;List"/>
</rdf:Property>

<rdfs:Class rdf:ID="Restriction">
  <rdfs:label>Restriction</rdfs:label>
  <rdfs:subClassOf rdf:resource="#Class"/>
</rdfs:Class>

<rdf:Property rdf:ID="onProperty">
  <rdfs:label>onProperty</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&rdf;Property"/>
</rdf:Property>

<rdf:Property rdf:ID="allValuesFrom">
  <rdfs:label>allValuesFrom</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&rdfs;Class"/>
</rdf:Property>

<rdf:Property rdf:ID="hasValue">
  <rdfs:label>hasValue</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
</rdf:Property>

<rdf:Property rdf:ID="someValuesFrom">
  <rdfs:label>someValuesFrom</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&rdfs;Class"/>
</rdf:Property>

<rdf:Property rdf:ID="minCardinality">
  <rdfs:label>minCardinality</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</rdf:Property>

<rdf:Property rdf:ID="maxCardinality">
  <rdfs:label>maxCardinality</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</rdf:Property>

<rdf:Property rdf:ID="cardinality">
  <rdfs:label>cardinality</rdfs:label>
  <rdfs:domain rdf:resource="#Restriction"/>
  <rdfs:range rdf:resource="&xsd;nonNegativeInteger"/>
</rdf:Property>

<rdfs:Class rdf:ID="ObjectProperty">
  <rdfs:label>ObjectProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="DatatypeProperty">
  <rdfs:label>DatatypeProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdf:Property rdf:ID="inverseOf">
  <rdfs:label>inverseOf</rdfs:label>
  <rdfs:domain rdf:resource="#ObjectProperty"/>
  <rdfs:range rdf:resource="#ObjectProperty"/>
</rdf:Property>

<rdfs:Class rdf:ID="TransitiveProperty">
  <rdfs:label>TransitiveProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>

<rdfs:Class rdf:ID="SymmetricProperty">
  <rdfs:label>SymmetricProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="#ObjectProperty"/>
</rdfs:Class>

<rdfs:Class rdf:ID="FunctionalProperty">
  <rdfs:label>FunctionalProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="InverseFunctionalProperty">
  <rdfs:label>InverseFunctionalProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="&owl;ObjectProperty"/>
</rdfs:Class>

<rdfs:Class rdf:ID="AnnotationProperty">
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<AnnotationProperty rdf:about="&rdfs;label"/>
<AnnotationProperty rdf:about="&rdfs;comment"/>
<AnnotationProperty rdf:about="&rdfs;seeAlso"/>
<AnnotationProperty rdf:about="&rdfs;isDefinedBy"/>

<rdfs:Class rdf:ID="Ontology">
  <rdfs:label>Ontology</rdfs:label>
</rdfs:Class>

<rdfs:Class rdf:ID="OntologyProperty">
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdf:Property rdf:ID="imports">
  <rdfs:label>imports</rdfs:label>
  <rdf:type rdf:resource="#OntologyProperty"/>
  <rdfs:domain rdf:resource="#Ontology"/>
  <rdfs:range rdf:resource="#Ontology"/>
</rdf:Property>

<rdf:Property rdf:ID="versionInfo">
  <rdfs:label>versionInfo</rdfs:label>
  <rdf:type rdf:resource="#AnnotationProperty"/>
</rdf:Property>

<rdf:Property rdf:ID="priorVersion">
  <rdfs:label>priorVersion</rdfs:label>
  <rdf:type rdf:resource="#OntologyProperty"/>
  <rdfs:domain rdf:resource="#Ontology"/>
  <rdfs:range rdf:resource="#Ontology"/>
</rdf:Property>

<rdf:Property rdf:ID="backwardCompatibleWith">
  <rdfs:label>backwardCompatibleWitesh</rdfs:label>
  <rdf:type rdf:resource="#OntologyProperty"/>
  <rdfs:domain rdf:resource="#Ontology"/>
  <rdfs:range rdf:resource="#Ontology"/>
</rdf:Property>

<rdf:Property rdf:ID="incompatibleWith">
  <rdfs:label>incompatibleWith</rdfs:label>
  <rdf:type rdf:resource="#OntologyProperty"/>
  <rdfs:domain rdf:resource="#Ontology"/>
  <rdfs:range rdf:resource="#Ontology"/>
</rdf:Property>

<rdfs:Class rdf:ID="DeprecatedClass">
  <rdfs:label>DeprecatedClass</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdfs;Class"/>
</rdfs:Class>

<rdfs:Class rdf:ID="DeprecatedProperty">
  <rdfs:label>DeprecatedProperty</rdfs:label>
  <rdfs:subClassOf rdf:resource="&rdf;Property"/>
</rdfs:Class>

<rdfs:Class rdf:ID="DataRange">
  <rdfs:label>DataRange</rdfs:label>
</rdfs:Class>

</rdf:RDF>

Annexe C. Un aide-mémoire du langage OWL

Les classes du vocabulaire OWL :

rdfs:Class
owl:AllDifferent
owl:AnnotationProperty
owl:Class
owl:DataRange
owl:DatatypeProperty
owl:DeprecatedClass
owl:DeprecatedProperty
owl:FunctionalProperty
owl:InverseFunctionalProperty
owl:Nothing
owl:ObjectProperty
owl:Ontology
owl:OntologyProperty
owl:Restriction
owl:SymmetricProperty
owl:Thing
owl:TransitiveProperty

Les propriétés du vocabulaire OWL :

rdf:Property rdfs:domain rdfs:range
owl:allValuesFrom owl:Restriction rdfs:Class
owl:backwardCompatibleWith owl:Ontology owl:Ontology
owl:cardinality owl:Restriction xsd:nonNegativeInteger
owl:complementOf owl:Class owl:Class
owl:differentFrom owl:Thing owl:Thing
owl:disjointWith owl:Class owl:Class
owl:distinctMembers owl:AllDifferent rdf:List
owl:equivalentClass owl:Class owl:Class
owl:equivalentProperty rdf:Property rdf:Property
owl:hasValue owl:Restriction
owl:imports owl:Ontology owl:Ontology
owl:incompatibleWith owl:Ontology owl:Ontology
owl:intersectionOf owl:Class rdf:List
owl:inverseOf owl:ObjectProperty owl:ObjectProperty
owl:maxCardinality owl:Restriction xsd:nonNegativeInteger
owl:minCardinality owl:Restriction xsd:nonNegativeInteger
owl:oneOf owl:Class rdf:List
owl:onProperty owl:Restriction rdf:Property
owl:priorVersion owl:Ontology owl:Ontology
owl:sameAs owl:Thing owl:Thing
owl:someValuesFrom owl:Restriction rdfs:Class
owl:unionOf owl:Class rdf:List
owl:versionInfo

Annexe D. Les changements depuis DAML+OIL

Cette annexe résume les changements intervenus de DAML+OIL [DAML+OIL] vers OWL.

  1. Les sémantiques ont beaucoup changé. Entre les trois sous-langages, c'est la sémantique de OWL DL qui se rapproche le plus de celle de DAML+OIL ;
  2. L'espace de nommage est devenu http://www.w3.org/2002/07/owl ;
  3. Les diverses mises à jour du groupe de travail RDF Core pour RDF et le schéma RDF ont été intégrées, à savoir :
  4. Les restrictions qualifiées ont été supprimées du langage, cela se traduisant par la suppression des propriétés suivantes :
  5. Des propriétés et des classes diverses ont été renommées comme l'indique le tableau suivant :
    DAML+OILOWL
    daml:differentIndividualFromowl:differentFrom
    daml:equivalentToowl:sameAs
    daml:sameClassAsowl:equivalentClass
    daml:samePropertyAsowl:equivalentProperty
    daml:hasClassowl:someValuesFrom
    daml:toClassowl:allValuesFrom
    daml:UnambiguousPropertyowl:InverseFunctionalProperty
    daml:UniquePropertyowl:FunctionalProperty
  6. La classe owl:SymmetricProperty a été ajoutée ;
  7. Les classes owl:AnnotationProperty, owl:OntologyProperty et owl:DataRange ont également été ajoutées ;
  8. Une propriété de type owl:DatatypeProperty peut être de type owl:InverseFunctionalProperty dans OWL Full ;
  9. Les synonymes des classes et propriétés de RDF et du schéma RDF ont été supprimés du langage, cela se traduisant par la suppression de :
  10. La propriété daml:disjointUnionOf a été supprimée du langage, puisqu'on peut la reproduire avec une relation owl:unionOf, ou avec des relations rdfs:subClassOf et owl:disjointWith ;
  11. La propriété daml:equivalentTo a été renommée en owl:sameAs, et elle n'est plus une superpropriété de owl:equivalentClass et owl:equivalentProperty ;
  12. Les propriétés et classes suivantes ont été ajoutées pour le versionnage :
  13. Les propriétés owl:AllDifferent et owl:distinctMembers ont été ajoutées afin de répondre au postulat des noms uniques.

Annexe E. Règles générales pour les ontologies OWL DL

Le document de la sémantique et de la syntaxe abstraite de OWL [OWL S&AS] fournit une caractérisation des ontologies OWL selon une syntaxe abstraite, en même temps qu'une correspondance avec des triplets RDF.

Les règles informelles suivantes caractérisent les conditions pour qu'un graphe RDF soit aussi une ontologie OWL DL. Ces règles ne remplacent pas la caractérisation décrite dans le document de la sémantique et de la syntaxe mais fournissent plutôt des indications générales : l'idée est que, à suivre ces conseils, la probabilité sera forte de produire des ontologies OWL DL. Elles ne cherchent pas non plus à tourner la représentation en triplets en quelque chose se rapprochant de la syntaxe abstraite.

Ne touchez pas au vocabulaire

On ne devrait pas redéfinir les propriétés et les classes intégrées. En général, cela signifie que les éléments des espaces de nommage OWL, RDF ou RDFS ne devraient pas apparaître comme sujets de triplets.

Donnez un typage explicite

Toute chose devrait avoir un type1. Si on utilise un appel d'adresse URI x là où on attend une classe, alors le graphe devrait contenir un triplet déclarant que :

x rdf:type owl:Class

De même, si on utilise une propriété p là où on attend une propriété d'objet, alors il devrait y avoir un triplet2 tel que :

p rdf:type owl:ObjectProperty

Si on utilise une propriété q là où on attend une propriété de type de donnée, alors il devrait y avoir un triplet tel que :

q rdf:type owl:DatatypeProperty

Si on utilise une propriété o là où on attend une propriété d'ontologie, alors il devrait y avoir l'une des propriétés d'ontologie intégrées (owl:imports, owl:priorVersion, owl:backwardCompatibleWith ou owl:incompatibleWith), ou bien un triplet tel que :

o rdf:type owl:OntologyProperty

Si on utilise une propriété a là où on attend une propriété d'annotation, alors il devrait y avoir l'une des propriétés d'annotation (owl:versionInfo, rdfs:label, rdfs:comment, rdfs:seeAlso ou rdfs:isDefinedBy), ou bien un triplet tel que :

a rdf:type owl:AnnotationProperty

Tout individu qui apparaît dans l'ontologie devrait définir au moins un type, c'est-à-dire que pour tout individu i, il devrait y avoir un triplet tel que :

i rdf:type c

c représente une instance de la classe owl:Class ou owl:Restriction.

Gardez les noms séparés

Les appels d'adresse URI de classes, de propriétés (les propriétés d'objets, de types de données, d'ontologies et d'annotations) et d'individus devraient être disjoints. Nous ne pouvons donc pas avoir de déclarations telle que :

x rdf:type owl:Class
x rdf:type owl:ObjectProperty

Cela veut dire en particulier qu'on ne peut pas utiliser les classes comme instances, c'est-à-dire :

x rdf:type owl:Class
y rdf:type owl:Class
x rdf:type y

Cette syntaxe n'est pas valide dans OWL DL. En règle générale, s'il existe un nœud x dans le graphe avec un triplet tel que :

x rdf:type owl:Class

Alors x ne devrait pas apparaître comme sujet d'un autre triplet avec un prédicat rdf:type3.

Les restrictions

Si un nœud se présente sous la forme x rdf:type owl:Restriction, alors il s'agira d'un des cas suivants :

Les axiomes de classe

Quel que soit le triplet dont le prédicat est rdfs:subClassOf, owl:equivalentClass ou owl:disjointWith, le sujet et l'objet de ce triplet devraient tous deux être de la classe owl:Class, ou bien owl:Restriction, c'est-à-dire que, si on a :

x rdfs:subClassOf y

Alors le graphe doit contenir un triplet :

x rdf:type owl:Class

Ou bien :

x rdf:type owl:Restriction.

Et l'un des triplets suivants :

y rdf:type owl:Class

Ou bien :

y rdf:type owl:Restriction.

Les axiomes de propriété

Quel que soit le triplet dont le prédicat est rdfs:subPropertyOf ou owl:equivalentProperty, le sujet et l'objet de ce triplet devraient tous deux avoir le même type, owl:ObjectProperty ou owl:DatatypeProperty, c'est-à-dire que, si on a :

p owl:equivalentProperty q

Alors le graphe doit contenir soit :

p rdf:type owl:ObjectProperty
q rdf:type owl:ObjectProperty.

Soit :

p rdf:type owl:DatatypeProperty
q rdf:type owl:DatatypeProperty.

Le sujet des triplets avec un prédicat rdfs:domain devraient être une instance de la classe owl:ObjectProperty ou owl:DatatypeProperty et leur objet une instance de la classe owl:Class ou owl:Restriction.

Le sujet des triplets avec un prédicat rdfs:range devraient être une instance de la classe owl:ObjectProperty, ou bien de la classe owl:DatatypeProperty. Dans le premier cas, l'objet du triplet devrait alors être une instance de la classe owl:Class ou owl:Restriction, et dans le second cas, être ou bien un type de donnée du schéma XML, ou bien un élément de type rdfs:Literal, ou bien un élément owl:oneOf définissant une gamme de données de type owl:DataRange.

Le sujet et l'objet d'un triplet owl:inverseOf doivent être du type owl:ObjectProperty.

Les axiomes d'individu

Quel que soit le triplet dont le prédicat est owl:sameAs ou owl:differentFrom, le sujet et l'objet de ce triplet doivent être des individus.

Remarquez que relier deux classes via owl:sameAs représente tout autre chose que les relier via owl:equivalentClass. La première proposition fait en fait valoir que les deux objets sont les mêmes, ce qui constitu en réalité un exemple de classe comme instance et fait sortir l'ontologie du cadre de OWL DL. La dernière fait valoir que leurs extensions de classe (l'ensemble des membres) sont équivalentes.

De même, relier des classes via owl:differentFrom n'est pas la même chose que les relier via owl:disjointWith (ce qui constitue encore un exemple de structure OWL Full). Deux classes peuvent être des objets différents et pourtant partager la même extension.

Si un nœud se présente sous la forme x rdf:type owl:AllDifferent, alors il s'agira de l'un des cas suivants :

Les expressions de classe booléennes

Les opérateurs booléens (ET, OU, NON) sont représentés dans le langage OWL par des relations owl:intersectionOf, owl:unionOf et owl:complementOf.

Le sujet d'un triplet owl:complementOf doit être une instance de la classe owl:Class, et l'objet être une instance de la classe owl:Class, ou bien de la classe owl:Restriction.

Le sujet d'un triplet owl:unionOf, ou d'un triplet owl:intersectionOf, doit être une instance de la classe owl:Class, et l'objet être une liste rdf:List (bien formée) dont tous les éléments sont des instances de la classe owl:Class, ou bien de la classe owl:Restriction. On pourrait les représenter explicitement par des éléments rdf:List développés, ou bien par l'attribut rdf:parseType='Collection' si on utilise RDF/XML.

<owl:Class>
 <owl:intersectionOf rdf:parseType="Collection">
  <owl:Class rdf:about="x"/>
  <owl:Class rdf:about="y"/>
 </owl:intersectionOf>
</owl:Class>

Si l'instance owl:Class est un nœud blanc (c'est-à-dire que la classe est anonyme), alors elle peut être le sujet d'au plus un seul triplet avec un prédicat owl:intersectionOf, ou owl:unionOf, ou owl:complementOf. Si la classe est nommée, un nombre quelconque de ces triplets est permis.

Les énumérations

Le sujet d'un triplet avec un prédicat owl:oneOf doit être une instance de la classe owl:Class, ou bien de la classe owl:DataRange. Dans le premier cas, l'objet doit être une liste rdf:List (bien formée) dont tous les éléments sont des individus. Dans le second cas, l'objet doit être une liste rdf:List (bien formée) dont tous les éléments sont des littéraux de données. De même, comme avec les opérateurs booléens, on peut utiliser rdf:parseType="Collection".

Les propriétés d'ontologie et d'annotation

Le sujet et l'objet d'un triplet avec un prédicat d'ontologie devraient être une ontologie, par exemple, un nœud x dont la forme du triplet est :

x rdf:type owl:Ontology

Le sujet d'un triplet avec un prédicat d'annotation devrait être une classe nommée (c'est-à-dire ne pas être un nœud blanc), une propriété, un individu ou une ontologie. L'objet d'un triplet avec un prédicat d'annotation devrait être un individu, un littéral de donnée, ou un appel d'adresse URI arbitraire.

Hormis les prédicats dans les vocabulaires OWL, RDF et RDFS, les propriétés d'annotation sont les seuls prédicats apparaissant dans les triplets dont le sujet est une classe ou une propriété.

Les propriétés d'annotation et d'ontologie devraient être elles-mêmes typées, et elles ne devraient pas apparaître comme sujet ou objet d'un triplet, sauf comme sujet de triplet avec un prédicat rdf:type ou comme sujet de propriété d'annotation.

Évitez la mise en commun d'une structure

En général, la description sémantique et syntaxique de OWL ne permet pas la mise en commun des structures dans la représentation RDF. Dans les faits, cela signifie qu'un nœud anonyme dans le graphe RDF représentant une description particulière ne devrait apparaître qu'une seule fois (comme objet d'un triplet). Ainsi, les déclarations suivantes :

x1 rdf:type owl:Class
x1 rdfs:subClassOf _:y
x2 rdf:type owl:Class
x2 rdfs:subClassOf _:y
_:y rdf:type owl:Class
_:y owl:complementOf z

On devrait les éviter. Cela est permis dans certains cas difficiles. Toutefois, les graphes devraient en général utiliser des nœuds blancs distincts à chaque fois qu'une description de classe sert en plusieurs endroits.

Évitez les nœuds blancs orphelins

En général, un nœud blanc apparaissant dans le graphe représente un individu anonyme, ou bien il devrait correspondre à un seul exactement des suivants :

De façon générale, les nœuds blancs orphelins, c'est-à-dire ceux n'étant pas l'objet d'un triplet, ne sont pas permis (sauf dans le cas avec owl:AllDifferent décrit précédemment).

Les faits élémentaires

Les ontologies peuvent contenir des assertions de faits élémentaires (par exemple, des triplets qui font valoir les propriétés des individus). Les propriétés de ces assertions doivent être de type owl:ObjectProperty ou owl:DatatypeProperty. Le sujet du triplet doit être un individu (qui devrait être typé). L'objet peut consister en une référence d'individu (si la propriété est de type owl:ObjectProperty), ou bien en un littéral de donnée (si la propriété est de type owl:DatatypeProperty).

OWL Lite

Les documents OWL Lite devraient suivre les mêmes règles que celles des documents OWL DL, avec quelques restrictions supplémentaires concernant principalement le vocabulaire permis. Un document OWL Lite ne devrait pas utiliser le vocabulaire suivant :

Si l'objet est un nœud blanc, alors il ne devrait pas être le sujet ou l'objet d'un triplet avec un prédicat owl:equivalentClass.

L'objet d'un triplet avec un prédicat owl:minCardinality, owl:maxCardinality ou owl:cardinality devrait être un littéral de donnée représentant un entier de valeur 0 ou 1.

La situation est un peu plus complexe en ce qui concerne le prédicat owl:intersectionOf dans OWL Lite. Le prédicat ne devrait pas être utilisé pour former des expressions arbitraires mais il est nécessaire pour représenter les définitions de classes complètes. Les restrictions précédentes indiquent que le sujet d'un triplet avec un prédicat owl:intersectionOf devrait être une instance de la classe owl:Class. Dans OWL Lite, cette classe doit en outre être nommée, c'est-à-dire que le sujet ne devrait pas être un nœud blanc.

Divers

Il faut faire attention avec la classe owl:Thing. Par exemple, le fragment OWL-RDF suivant :

<owl:Class rdf:about="#A">
  <rdfs:subClassOf>
    <owl:Thing/>
  </rdfs:subClassOf>
</owl:Class>

Ce n'est pas la description d'une classe A sous-classe de owl:Thing mais en réalité celle d'une classe A sous-classe d'une certaine instance anonyme de owl:Thing. C'est donc utiliser une classe comme instance, hors du cadre de OWL DL. Pour obtenir l'effet désiré de sous-classe de owl:Thing, on fait comme ceci :

<owl:Class rdf:about="#A">
  <rdfs:subClassOf>
    <owl:Class rdf:about="http://www.w3.org/2002/07/owl#Thing"/>
  </rdfs:subClassOf>
</owl:Class>

Faites attention de ne pas confondre owl:Class et rdfs:Class. Le triplet suivant n'est pas dans OWL DL car c n'a pas reçu de type approprié :

c rdf:type rdfs:Class

Renvois

[1] Bien sûr, la nécessité de tout typer ne s'applique pas aux objets des espaces de nommage OWL, RDF ou RDFS.

[2] À strictement parler, ce n'est pas nécessaire si la propriété est définie avoir un type owl:TransitiveProperty, owl:SymmetricProperty ou owl:InverseFunctionalProperty.

[3] Une exception ici, on peut avoir :

x rdf:type rdfs:Class
x rdf:type owl:Class
p rdf:type rdf:Property
p rdf:type owl:ObjectProperty

Ou :

q rdf:type rdf:Property
q rdf:type owl:DatatypeProperty

En outre, pour les restrictions, on peut avoir :

x rdf:type owl:Restriction
x rdf:type rdfs:Class
x rdf:type owl:Class

Annexe F. Le journal des changements depuis la version de recommandation proposée

  1. Supprimé le renvoi [4] superflu dans l'annexe E ;
  2. Ajouté l'élément rdfs:label à AnnotationProperty et OntologyProperty, dans l'annexe B (le schéma RDF du langage OWL), à la suite d'une remarque de Jacco van Ossenbruggen ;
  3. Réparé un appel de section cassé et corrigé le style des appels de section ;
  4. Normalisé la section des références ;
  5. Révision du texte de la description des conditions requises pour l'élément rdf:RDF à la suite d'une remarque de Minsu Jang ;
  6. Plusieurs changements de texte en réponse aux commentaires de Lacy ;
  7. Ajouté une explication au chapitre 7.1, à propos des contraintes OWL DL sur l'utilisation des propriétés d'annotation, à la suite de plusieurs commentaires publics (par exemple, cf. les remarques de Benjamin Nowack). Ajouté également une phrase au chapitre 7.2 pour dire que les mêmes contraintes s'appliquaient aux propriétés d'ontologie ;
  8. Plusieurs petites corrections de texte suite à une relecture finale par le rédacteur.

Références

[OWL Overview]
Vue d'ensemble du langage d'ontologie Web OWL, Deborah L. McGuinness et Frank van Harmelen, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-owl-features-20040210/. Dernière version disponible à http://www.w3.org/TR/owl-features/.
[OWL Guide]
Guide du langage d'ontologie Web OWL, Michael K. Smith, Chris Welty et Deborah L. McGuinness, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-owl-guide-20040210/. Dernière version disponible à http://www.w3.org/TR/owl-guide/.
[OWL Semantics and Abstract Syntax]
La sémantique et la syntaxe abstraite du langage d'ontologie Web OWL, Peter F. Patel-Schneider, Patrick Hayes et Ian Horrocks, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-owl-semantics-20040210/. Dernière version disponible à http://www.w3.org/TR/owl-semantics/.
[OWL Test]
Les jeux d'essais du langage d'ontologie Web OWL, Jeremy J. Carroll et Jos De Roo, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-owl-test-20040210/. Dernière version disponible à http://www.w3.org/TR/owl-test/.
[OWL Requirements]
Les cas et conditions d'utilisation du langage d'ontologie Web OWL, Jeff Heflin, rédacteur, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-webont-req-20040210/. Dernière version disponible à http://www.w3.org/TR/webont-req/.
[RDF Concepts]
Le cadre de description de ressources (RDF) : concepts et syntaxe abstraite, Graham Klyne et Jeremy J. Carroll, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/. Dernière version disponible à http://www.w3.org/TR/rdf-concepts/.
[RDF Syntax]
Spécification de la syntaxe RDF/XML (révisée), Dave Beckett, rédacteur, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/. Dernière version disponible à http://www.w3.org/TR/rdf-syntax-grammar/.
[RDF Semantics]
La sémantique RDF, Pat Hayes, rédacteur, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/. Dernière version disponible à http://www.w3.org/TR/rdf-mt/.
[RDF Vocabulary]
Le langage de description du vocabulaire RDF 1.0 : schéma RDF, Dan Brickley et R. V. Guha, rédacteurs, recommandation du W3C, 10 février 2004, http://www.w3.org/TR/2004/REC-rdf-schema-20040210/. Dernière version disponible à http://www.w3.org/TR/rdf-schema/.
[DAML+OIL]
Description de référence du langage DAML+OIL (mars 2001), Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider et Lynn Andrea Stein, note du W3C, 18 décembre 2001. Dernière version disponible à http://www.w3.org/TR/daml+oil-reference.
[XML-SCHEMA2]
Le schéma XML partie 2 : Les types de données, recommandation du W3C, 2 mai 2001.