Lisez-moi S.V.P. 

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

Chapitre 2. La syntaxe abstraite

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

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

Cf. également d'éventuelles traductions.


Contenu


2. La syntaxe abstraite (normatif)

La syntaxe du langage OWL dans cette section est une abstraction de la syntaxe d'échange OWL, qui facilite donc l'accès au langage et son évaluation. Cette syntaxe particulière a le style d'un cadre, où on présente un ensemble d'informations concernant une classe ou une propriété dans une seule structure syntaxique plus vaste, au lieu de les diviser en plusieurs morceaux atomiques (comme pour la majeure partie de la logique de description), ou de les diviser en un nombre plus grand encore de triplets (comme pour l'écriture de OWL en graphes RDF [RDF Concepts]). La syntaxe employée ici est très informelle, même pour une syntaxe abstraite (en général, les arguments d'une structure sont censés non ordonnés partout où l'ordre n'affecte pas la signification de la structure).

La syntaxe abstraite est définie ici par une version étendue de la forme BNF, très semblable à la notation EBNF utilisée pour le langage XML [XML]. Les terminaux sont entre guillemets, les non-terminaux sont en caractères gras sans guillemet. Les choix multiples sont séparés par des caractères barre verticale (|), ou bien définis dans des productions distinctes. Les composants apparaissant une fois au plus sont entre des crochets ([...]), ceux dont le nombre d'apparitions est arbitraire (y compris zéro) sont entre des accolades ({...}). Les caractères blancs sont ignorés dans les productions.

Dans la syntaxe abstraite, les noms sont des appels d'adresse URI RDF, [RDF Concepts]. Ces noms seront souvent abrégés en noms qualifiés, en utilisant l'un des noms d'espaces de nommage suivants :

Nom d'espace de nommageEspace de nommage
rdfhttp://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfshttp://www.w3.org/2000/01/rdf-schema#
xsdhttp://www.w3.org/2001/XMLSchema#
owlhttp://www.w3.org/2002/07/owl#

La signification de chaque structures de la syntaxe abstraite est décrite de façon informelle au fur et à mesure de leur introduction. Leurs significations formelles sont données dans le chapitre 3 au travers d'une sémantique de modèle théorique.

Quoique toutes les caractéristiques de langages expressifs tel que OWL puissent être importantes pour certains utilisateurs, on comprend aussi que ces langages intimideront d'autres groupes d'utilisateurs essayant de gérer une suite d'outils pour la totalité du langage. Afin de leur fixer un objectif de mise en œuvre plus simple, il a été défini un langage réduit appelé OWL Lite [OWL Overview]. Ce langage réduit est conçu pour offrir des fonctionnalités importantes dans la gestion des applications Web mais absentes du schéma RDF [RDF Schema]. (Toutefois, remarquez que les deux langages OWL DL et OWL Lite n'offrent pas toutes les fonctionnalités du schéma RDF). La syntaxe abstraite exprime à la fois ce langage réduit, appellée ici la syntaxe abstraite OWL Lite), et une forme plus complète du langage OWL, appellée ici la syntaxe abstraite OWL DL.

La syntaxe abstraite est moins générale ici que la syntaxe d'échange du langage OWL. En particulier, elle ne permet pas la construction de structures syntaxiques auto-référentes. Elle est également prévue pour les situations où les classes, les propriétés et les individus forment des ensembles disjoints. Grossièrement, ce sont les limitations nécessaires pour rendre le raisonnement décidable dans OWL, et on devrait donc assimiler la syntaxe abstraite à une syntaxe du langage OWL DL.

REMARQUE : Les langages OWL Lite et OWL DL correspondent étroitement, hormis quelques limitations du traitement des types de données, aux logiques de description connues sous le nom de SHIF(D) et SHION(D). Beaucoup des constructeurs explicites communs associés à SHIF(D) manquent dans la syntaxe abstraite OWL Lite mais la capacité d'expression est intacte.

2.1. Les ontologies

Une ontologie OWL dans la syntaxe abstraite contient une séquence d'annotations, d'axiomes et de faits. Les ontologies OWL peuvent avoir un nom. Les annotations des ontologies OWL peuvent servir à enregistrer l'origine et d'autres renseignements associés à une ontologie, y compris les références d'importations d'autres ontologies. Le contenu principale d'une ontologie OWL tient dans ses axiomes et ses faits, lesquels fournissent des informations concernant les classes, les propriétés et les individus dans l'ontologie.

ontology ::= 'Ontology(' [ ontologyID ] { directive } ')'
directive ::= 'Annotation(' ontologyPropertyID ontologyID ')'
	 | 'Annotation(' annotationPropertyID URIreference ')'
         | 'Annotation(' annotationPropertyID dataLiteral ')'
         | 'Annotation(' annotationPropertyID individual ')'
         | axiom
         | fact

Les noms d'ontologies dans la syntaxe abstraite servent à porter la signification associée à une publication de l'ontologie sur le Web. Les noms d'ontologies dans la syntaxe abstraite servent à porter la signification associée à une publication de l'ontologie sur le Web. Le nom d'une ontologie dans la syntaxe abstraite est donc prévu pour être l'adresse URI où on peut la trouver, quoique cela ne fasse pas partie de la signification formelle du langage OWL. Les annotations imports sont effectivement des instructions pour récupérer un document Web et le traiter comme une ontologie OWL. Toutefois, la plupart des aspects liés au Web, dont les documents manquants, indisponibles ou variables dans le temps, ne sont pas dans le cadre de la spécification OWL : tout cela est traduit par le fait qu'une adresse URI peut se résoudre en une ontologie OWL. À plusieurs reprises dans le document, on recourra donc à des idéalisations de ce sens fonctionnel des importations.

Les ontologies rassemblent des informations à propos de classes, de propriétés et d'individus, tous pouvant avoir un identificateur qui est un appel d'adresse URI. Certains de ces identificateurs ont besoin d'axiomes comme expliqué dans le chapitre 2.3.

datatypeID ::= URIreference
classID ::= URIreference
individualID ::= URIreference
ontologyID ::= URIreference
datavaluedPropertyID ::= URIreference
individualvaluedPropertyID ::= URIreference
annotationPropertyID ::= URIreference
ontologyPropertyID ::= URIreference

Un appel d'adresse URI ne peut pas être en même temps de type datatypeID et de type classID dans une ontologie. Un appel d'adresse URI ne peut pas non plus avoir plus d'un type parmi datavaluedPropertyID, individualvaluedPropertyID, annotationPropertyID ou ontologyPropertyID dans une ontologie. Par contre, un appel d'adresse URI peut être l'identificateur d'une classe ou d'un type de donnée ainsi que d'une propriété ainsi que d'un individu, quoique l'ontologie ne puisse plus alors se traduire en un graphe RDF OWL DL.

Dans le langage OWL, un type de donnée dénote l'ensemble des valeurs de données qui forme l'espace de valeurs du type de donnée. Les classes représentent des ensembles d'individus. Les propriétés relient les individus à d'autres informations, et elles se répartissent en quatre groupes disjoints : les propriétés à valeur de donnée, les propriétés à valeur d'individu, les propriétés d'annotation et les propriétés d'ontologie. Les propriétés à valeur de donnée relient des individus à des valeurs de données. Les propriétés à valeur d'individu relient des individus à d'autres individus. Les propriétés d'annotation servent à placer des annotations sur des individus, des noms de classe, des noms de propriété et des noms d'ontologie. Les propriétés d'ontologie relient des ontologies à d'autres ontologies, notamment pour importer des informations issues d'autres ontologies. Les identificateurs d'individus servent à désigner des ressources, et les littéraux de données à désigner des valeurs de données.

Il existe deux classes OWL intégrées qui utilisent toutes deux des appels d'adresses URI dans l'espace de nommage OWL, c'est-à-dire des noms commençant par http://www.w3.org/2002/07/owl#, et pour lesquels on utilise ici le nom d'espace de nommage owl. (Tout au long de ce document, on utilisera des noms qualifiés comme abréviation des appels d'adresses URI). La classe identifiée par owl:Thing est la classe de tous les individus. La classe identifiée par owl:Nothing est la classe vide. Toutes deux font partie du langage OWL Lite.

On peut utiliser les types de données suivants du schéma XML [XML Schema Datatypes] comme étant des types de données intégrés OWL avec un appel d'adresse URI canonique du type de donnée du schéma XML, à savoir http://www.w3.org/2001/XMLSchema#nom, où nom représente le nom local du type de donnée : xsd:string, xsd:boolean, xsd:decimal, xsd:float, xsd:double, xsd:dateTime, xsd:time, xsd:date, xsd:gYearMonth, xsd:gYear, xsd:gMonthDay, xsd:gDay, xsd:gMonth, xsd:hexBinary, xsd:base64Binary, xsd:anyURI, xsd:normalizedString, xsd:token, xsd:language, xsd:NMTOKEN, xsd:Name, xsd:NCName, xsd:integer, xsd:nonPositiveInteger, xsd:negativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:nonNegativeInteger, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte et xsd:positiveInteger. Les autres types de données intégrés du schéma XML sont problématiques pour le langage OWL, comme expliqué dans le chapitre 5.1 de la sémantique RDF [RDF Semantics]. Le type de donnée RDF intégré rdf:XMLLiteral est également un type de donnée OWL intégré. À cause de l'absence d'un moyen standard pour aller d'un appel d'adresse URI à un type de donnée du schéma XML dans XML Schema, il n'y a pas non plus de moyen standard pour utiliser les types de données du schéma XML définis par l'utilisateur dans OWL.

Il existe plusieurs propriétés d'annotation intégrées dans le langage OWL, à savoir owl:versionInfo, rdfs:label, rdfs:comment, rdfs:seeAlso et rdfs:isDefinedBy. Conformément à leurs définitions RDF, on peut seulement utiliser les propriétés rdfs:label et rdfs:comment avec des littéraux de données.

Il existe également plusieurs propriétés d'ontologie intégrées, à savoir owl:imports, owl:priorVersion, owl:backwardCompatibleWith et owl:incompatibleWith. Les annotations d'ontologies utilisant la propriété owl:imports ont pour effet supplémentaire d'importer l'ontologie cible.

Beaucoup de structures OWL utilisent des annotations qui, juste comme instructions d'annotation, servent à enregistrer les informations associées à une certaine partie de la structure.

annotation ::= 'annotation(' annotationPropertyID URIreference ')'
            | 'annotation(' annotationPropertyID dataLiteral ')'
            | 'annotation(' annotationPropertyID individual ')'

2.2. Les faits

La syntaxe abstraite du langage OWL a deux types de faits :

Les faits du premier type énoncent des informations à propos d'un certain individu, sous la forme de classes dont l'individu fait partie plus les propriétés et valeurs de cet individu. L'individu peut recevoir un identificateur de type individualID qui le désignera et pourra servir à l'appeler. Toutefois, un individu n'a pas forcément besoin d'un identificateur individualID ; ces individus sont anonymes (ou blancs dans la terminologie RDF) et ne sont pas directement appelables d'ailleurs. La syntaxe présentée ici réflète quelque peu celle de RDF/XML [RDF Syntax] sans utiliser l'élément rdf:nodeID.

fact ::= individual 
individual ::= 'Individual(' [ individualID ] { annotation } { 'type(' type ')' } { value } ')'
value ::= 'value(' individualvaluedPropertyID individualID ')'
        | 'value(' individualvaluedPropertyID  individual ')'
        | 'value(' datavaluedPropertyID  dataLiteral ')'

Les faits sont les mêmes dans les syntaxes abstraites OWL Lite et OWL DL, sauf ce qui peut être un type. Dans OWL Lite, les types peuvent être des identificateurs de classe ou des restrictions OWL Lite, cf. le chapitre 2.3.1.2.

type ::= classID
       | restriction

Dans la syntaxe abstraite OWL DL, les types peuvent être des descriptions générales, qui contiennent des identificateurs de classe et des restrictions OWL Lite ainsi que d'autres structures.

type ::= description

Les littéraux de données dans la syntaxe abstraite sont soit des littéraux ordinaires, soit des littéraux typés. Un littéral ordinaire se compose d'une chaîne Unicode, dans la forme normale C, et d'une étiquette de langue optionnelle, comme dans les littéraux ordinaires RDF [RDF Concepts]. Un littéral typé se compose d'une représentation lexicale et d'un appel d'adresse URI, comme dans les littéraux typés RDF [RDF Concepts].

dataLiteral ::= typedLiteral | plainLiteral
typedLiteral ::= lexicalForm^^URIreference
plainLiteral ::= lexicalForm | lexicalForm@languageTag
lexicalForm ::= comme dans RDF, une chaîne Unicode dans la forme normale C
languageTag ::= comme dans RDF, une étiquette de langue XML

Les faits du second type servent à affirmer que deux identificateurs représente le même individu, ou au contraire qu'ils sont tous deux différents.

fact ::= 'SameIndividual(' individualID individualID {individualID} ')'
      | 'DifferentIndividuals(' individualID individualID {individualID} ')'

2.3. Les axiomes

Les différences les plus marquées entre les syntaxes abstraites OWL Lite et OWL DL apparaissent dans les axiomes, qui servent à fournir des informations à propos des classes et des propriétés. Comme OWL Lite est le moins riche, on définira d'abord les axiomes OWL Lite dans le chapitre 2.3.1. Ceux du langage OWL DL seront définis dans le chapitre 2.3.2. Les axiomes OWL DL incluent les axiomes OWL Lite dans certains cas particuliers.

Les axiomes servent à associer les identificateurs de classes ou de propriétés aux définitions partielles ou complètes de leurs caractéristiques, et à fournir d'autres informations concernant les classes et les propriétés. On appelait les axiomes des définitions, mais les axiomes ne sont pas tous des définitions au sens courant du terme, et une dénominaton plus neutre a donc été retenue.

La syntaxe employée ici veut quelque peu ressembler à celle employée par certains systèmes d'objets structurés. Dans OWL Lite, chaque axiome de classe contient un ensemble de classes plus générales et un ensemble de restrictions de propriétés locales ayant la forme de structures de restriction. La structure de restriction définit l'image locale de la propriété, le nombre de valeurs permises et/ou un ensemble de valeurs obligatoires. La classe est faite équivalente à l'intersection de ces classes et restrictions plus générales, ou bien faite un sous-ensemble de cette intersection. Dans la syntaxe abstraite OWL DL, un axiome de classe contient un ensemble de descriptions, qui peuvent être celles de classes, de restrictions, d'ensembles d'individus et de combinaisons booléennes plus générales. Les classes peuvent également être définies par énumération, ou être faites équivalentes ou disjointes.

Les propriétés peuvent être équivalentes, ou être des sous-propriétés d'autres propriétés ; on peut les faire fonctionnelles, fonctionnelles symétriques, symétriques ou transitives ; on peut leur attribuer un domaine global ou une image globale. Cependant, la plupart des informations à propos des propriétés s'expriment plus naturellement dans des restrictions, qui permettent de définir l'image et la cardinalité de la propriété localement.

Les appels d'adresse URI utilisés comme identificateurs de classes ou de types de données doivent être différenciés, et il faut donc un axiome, sauf pour les classes et les types de données OWL intégrés et pour rdfs:Literal. Il peut y avoir plusieurs axiomes pour une classe ou un type de donnée. Les propriétés utilisées dans une ontologie dans la syntaxe abstraite doivent être catégorisées comme propriétés à valeur de donnée, ou bien comme propriétés à valeur d'individu, ou bien comme propriétés d'annotation. Les propriétés ont donc au moins besoin d'un axiome pour cela. Si une ontologie en importe une autre, les axiomes dans cette ontologie importée (et dans toutes celles qui seraient importées à leur tour) peuvent être utilisées dans ce but.

2.3.1. Les axiomes OWL Lite

2.3.1.1. Les axiomes de classe OWL Lite

Dans le langage OWL Lite, les axiomes de classe servent à énoncer qu'une classe est exactement équivalente à, pour la modalité complete, ou est une sous-classe de, pour la modalité partial, la conjonction d'un ensemble de superclasses et de restrictions OWL Lite. On peut également énoncer que l'utilisation d'une classe est contre-indiquée.

axiom ::= 'Class(' classID ['Deprecated'] modality { annotation } { super } ')'
modality ::= 'complete' | 'partial'
super ::= classID | restriction

Il est possible de déclarer dans OWL Lite que deux classes ou plus sont équivalentes :

axiom ::= 'EquivalentClasses(' classID classID { classID } ')'

Les axiomes de types de données sont plus simples, et servent seulement à énoncer qu'un identificateur est celui d'un type de donnée et à fournir des annotations pour le type de donnée :

axiom ::= 'Datatype(' datatypeID ['Deprecated']  { annotation } )'
2.3.1.2. Les restrictions OWL Lite

Les restrictions des axiomes de classe OWL Lite servent à placer des contraintes locales sur les propriétés de la classe. Chaque partie allValuesFrom d'une restriction établit une contrainte selon laquelle toutes les valeurs de la propriété appliquée aux individus de la classe doivent appartenir à la classe ou au type de donnée indiqués. Chaque partie someValuesFrom établit une contrainte selon laquelle au moins une valeur de la propriété doit appartenir à la classe ou au type de donnée indiqués. La partie cardinality indique combien la propriété a de valeurs distinctes pour chaque individu de la classe. Dans le langage OWL Lite, seules les valeurs de cardinalité 0 et 1 sont admises.

Cf. le chapitre 2.3.1.3 au sujet de la limitation des parties cardinalité des propriétés dans les restrictions.

restriction ::= 'restriction(' datavaluedPropertyID dataRestrictionComponent ')'
            | 'restriction(' individualvaluedPropertyID individualRestrictionComponent ')'
dataRestrictionComponent ::= 'allValuesFrom(' dataRange ')'
            | 'someValuesFrom(' dataRange ')'
            | cardinality
individualRestrictionComponent ::= 'allValuesFrom(' classID ')'
            | 'someValuesFrom(' classID ')'
            | cardinality 
cardinality ::= 'minCardinality(0)' | 'minCardinality(1)'
            | 'maxCardinality(0)' | 'maxCardinality(1)'
            | 'cardinality(0)'    | 'cardinality(1)'
2.3.1.3. Les axiomes de propriété OWL Lite

Les propriétés sont également définies avec une syntaxe pareille à un objet structuré. Les propriétés à valeur de donnée relient des individus à des valeurs de données, par exemple, à des entiers. Les propriétés à valeur d'individu relient des individus à d'autres individus. Ces deux types de propriétés peuvent avoir des superpropriétés, permettant la contruction d'une hiérarchie de propriétés. Il n'est pas logique qu'une propriété à valeur d'individu soit superpropriété d'une propriété à valeur de donnée, ou vice versa. Les propriétés à valeur de donnée et celles à valeur d'individu peuvent aussi recevoir un domaine ou une image. Le domaine d'une propriété indique quels sont les individus pouvant être sujets des déclarations dont la propriété est le prédicat, tout comme dans RDFS. Dans le langage OWL Lite, les domaines des propriétés sont des classes. Il peut y avoir plusieurs domaines, auquel cas seuls les individus appartenant à tous les domaines sont des sujets potentiels. L'image d'une propriété indique quels sont les individus ou les valeurs de données pouvant être objets des déclarations dont la propriété est le prédicat. De même, il peut y avoir plusieurs images, auquel cas seuls les individus ou les valeurs de données appartenant à toutes les images sont des objets potentiels. Dans le langage OWL Lite, les images des propriétés à valeur d'individu sont des classes, celles des propriétés à valeur de donnée sont des types de données.

Les propriétés à valeur de donnée peuvent être définies (partiellement) fonctionnelles, c'est-à-dire que pour un individu donné il peut y avoir qu'une relation au plus vers une valeur de donnée de cet individu dans la propriété. Les propriétés à valeur d'individu peuvent être définies symétriques à une autre propriété. Elles peuvent également être définies symétriques ainsi que fonctionnelles partielles, fonctionnelles symétriques partielles ou transitives.

Pour préserver la décidabilité du raisonnement dans OWL Lite, les propriétés ne peuvent pas toutes recevoir des restrictions de cardinalité, ou être définies fonctionnelles ou fonctionnelles symétriques. Une propriété à valeur d'individu est complexe, si :

  1. elle est définie fonctionnelle ou fonctionnelle symétrique,
  2. une restriction de cardinalité s'y applique,
  3. son symétrique est complexe, ou
  4. sa superpropriété est complexe.

Les propriétés complexes ne peuvent pas être définies transitives.

Les propriétés d'annotation et d'ontologie sont beaucoup plus simples que les propriétés à valeur de donnée et les propriétés à valeur d'individu. Les seules informations sur elles dans leurs axiomes sont des annotations :

axiom ::= 'DatatypeProperty(' datavaluedPropertyID ['Deprecated'] { annotation } 
              { 'super(' datavaluedPropertyID ')' } ['Functional'] 
              { 'domain(' classID' ')' } { 'range(' dataRange ')' } ')'
       | 'ObjectProperty(' individualvaluedPropertyID ['Deprecated'] { annotation } 
              { 'super(' individualvaluedPropertyID ')' }
              [ 'inverseOf(' individualvaluedPropertyID ')' ] [ 'Symmetric' ] 
              [ 'Functional' | 'InverseFunctional' | 'Functional' 'InverseFunctional' | 'Transitive' ]
              { 'domain(' classID ')' } { 'range(' classID ')' } ')'
       | 'AnnotationProperty(' annotationPropertyID { annotation } ')'
       | 'OntologyProperty(' ontologyPropertyID { annotation } ')'
dataRange ::= datatypeID | 'rdfs:Literal'

Les axiomes suivants permettent d'établir que plusieurs propriétés sont équivalentes, ou qu'une propriété est sous-propriété d'une autre :

axiom ::= 'EquivalentProperties(' datavaluedPropertyID datavaluedPropertyID  { datavaluedPropertyID } ')'
        | 'SubPropertyOf(' datavaluedPropertyID  datavaluedPropertyID ')'
        | 'EquivalentProperties(' individualvaluedPropertyID individualvaluedPropertyID  { individualvaluedPropertyID } ')'
        | 'SubPropertyOf(' individualvaluedPropertyID  individualvaluedPropertyID ')'
        

2.3.2. Les axiomes OWL DL

2.3.2.1. Les axiomes de classe OWL DL

La syntaxe abstraite OWL DL présente des versions plus générales des axiomes de classe OWL Lite, qui admettent des restrictions plus générales et des combinaisons booléennes de celles-ci. On appelle collectivement ces structures des descriptions.

axiom ::= 'Class(' classID  ['Deprecated'] modality { annotation } { description } ')'
modality ::= 'complete' | 'partial'

Dans la syntaxe abstraite OWL DL, on peut également faire qu'une classe soit constituée exactement d'un ensemble d'individus, comme suit :

axiom ::= 'EnumeratedClass(' classID ['Deprecated'] { annotation } { individualID } ')'

Enfin, dans la syntaxe abstraite OWL DL, on peut imposer que les éléments d'un ensemble de descriptions soient disjoints deux-à-deux, ou qu'ils aient les mêmes instances, ou qu'une description soit sous-classe d'une autre. Remarquez que les deux derniers axiomes généralisent, sauf les annotations qui manquent, le premier type d'axiome juste avant.

axiom ::= 'DisjointClasses(' description description { description } ')'
        | 'EquivalentClasses(' description { description } ')'
        | 'SubClassOf(' description description ')'

Dans le langage OWL DL, il est possible de n'avoir qu'une seule description dans une structure EquivalentClasses. Cela permet aux ontologies d'inclure des descriptions sans lien, ce qui n'est pas d'une grande utilité sémantique mais permet une création moins optimale d'ontologies.

Les axiomes de type de donnée sont les mêmes que pour OWL Lite.

axiom ::= 'Datatype(' datatypeID ['Deprecated']  { annotation } )'
2.3.2.2. Les descriptions OWL DL

Dans la syntaxe abstraite OWL DL, les descriptions incluent des identificateurs et des restrictions de classes. Elles peuvent aussi être des combinaisons booléennes d'autres restrictions, et des ensembles d'individus.

description ::= classID
            | restriction
            | 'unionOf(' { description } ')'
            | 'intersectionOf(' { description } ')'
            | 'complementOf(' description ')'
            | 'oneOf(' { individualID } ')'
2.3.2.3. Les restrictions OWL DL

Les restrictions dans la syntaxe abstraite OWL DL généralisent les restrictions OWL Lite en autorisant des descriptions là où OWL Lite admettait des classes et en autorisant des ensembles de valeurs de données ainsi que des types de données. La combinaison de types de données et d'ensembles de valeurs de données est appelée une gamme de données. Dans la syntaxe abstraite OWL DL, on peut également donner des valeurs aux propriétés dans les classes. En outre, les valeurs de cardinalité ne se limitent pas seulement à 0 et à 1.

restriction ::= 'restriction(' datavaluedPropertyID dataRestrictionComponent { dataRestrictionComponent } ')'
            | 'restriction(' individualvaluedPropertyID individualRestrictionComponent { individualRestrictionComponent } ')'
dataRestrictionComponent ::= 'allValuesFrom(' dataRange ')'
            | 'someValuesFrom(' dataRange ')'
            | 'value(' dataLiteral ')'
            | cardinality
individualRestrictionComponent ::= 'allValuesFrom(' description ')'
            | 'someValuesFrom(' description ')'
            | 'value(' individualID ')'
            | cardinality 
cardinality ::= 'minCardinality(' non-negative-integer ')'
            | 'maxCardinality(' non-negative-integer ')'
            | 'cardinality(' non-negative-integer ')'

Une gamme de données, utilisée comme image d'une propriété à valeur de donnée et ailleurs dans la syntaxe abstraite OWL DL, représente soit un type de donnée, soit un ensemble de valeurs de données.

dataRange ::= datatypeID | 'rdfs:Literal'
            | 'oneOf(' { dataLiteral } ')'

Les limitations OWL Lite quant aux restrictions de propriétés admettant des composants de cardinalité sont également présentes dans OWL DL.

2.3.2.4. Les axiomes de propriété OWL DL

Les axiomes de propriété dans la syntaxe abstraite OWL DL généralisent les axiomes de propriété OWL Lite en admettant des descriptions au lieu de classes, et des gammes de données au lieu de types de données dans les domaines et les images.

axiom ::= 'DatatypeProperty(' datavaluedPropertyID ['Deprecated'] { annotation } 
                { 'super(' datavaluedPropertyID ')'} ['Functional']
                { 'domain(' description ')' } { 'range(' dataRange ')' } ')'
        | 'ObjectProperty(' individualvaluedPropertyID ['Deprecated'] { annotation } 
                { 'super(' individualvaluedPropertyID ')' }
                [ 'inverseOf(' individualvaluedPropertyID ')' ] [ 'Symmetric' ] 
                [ 'Functional' | 'InverseFunctional' | 'Functional' 'InverseFunctional' | 'Transitive' ]
                { 'domain(' description ')' } { 'range(' description ')' } ')'
        | 'AnnotationProperty(' annotationPropertyID { annotation } ')'
        | 'OntologyProperty(' ontologyPropertyID { annotation } ')'

Les limitations OWL Lite quant aux propriétés pouvant être définies fonctionnelles ou fonctionnelles symétriques sont également présentes dans OWL DL.

Comme dans le langage OWL Lite, les axiomes suivants permettent d'établir que plusieurs propriétés sont équivalentes ou qu'une propriété est sous-propriété d'une autre :

axiom ::= 'EquivalentProperties(' datavaluedPropertyID datavaluedPropertyID  { datavaluedPropertyID } ')'
        | 'SubPropertyOf(' datavaluedPropertyID  datavaluedPropertyID ')'
        | 'EquivalentProperties(' individualvaluedPropertyID individualvaluedPropertyID
                                  { individualvaluedPropertyID } ')'
        | 'SubPropertyOf(' individualvaluedPropertyID  individualvaluedPropertyID ')'