Kérjük, kövesse figyelemmel a dokumentum eredeti angol nyelvű változatára vonatkozó hibajegyzéket, mert ez normatív korrekciókat is tartalmazhat.
A dokumentumról további fordítások is rendelkezésre állnak.
Copyright © 2004 W3C® (MIT, ERCIM, Keio), Minden jog fenntartva. Alkalmazandók a W3C felelősségi, védjegyoltalmi, dokumentumhasználati és szoftverlicenc előírásai.
Az itt ismertetett OWL szintaxis az OWL adatcsere-szintaxisából indul ki, s ez megkönnyíti a nyelvhez való hozzáférést és a nyelv kiértékelését. Ez a szintaxis egy speciális, tömbszerű stílusban íródott, ahol az osztályokról vagy a tulajdonságokról szóló definíciók egyetlen nagyobb szintaktikai hierarchiát alkotnak. A szintaxist tehát nem bontjuk fel elemi darabkákra (ahogyan a legtöbb leíró logikánál teszik), és különösen nem bontjuk fel még ennél is apróbb, triplet szintű elemekre, mint amikor az OWL nyelvet RDF gráfokkal írjuk le [RDF Fogalmak]. Az itt használt szintaxis meglehetősen informális — még egy absztrakt szintaxishoz képest is: a konstrukciók argumentumait általában rendezetleneknek kell tekinteni, kivéve az olyan eseteket, ahol ez befolyásolja a konstrukció jelentését.
Az absztrakt szintaxist a Kiterjesztett BNF egy változatával írjuk le, hasonlóan ahhoz, ahogy az EBNF leírást az XML-hez alkalmazzuk [XML]. A terminális kifejezéseket aposztrofáljuk, a nemterminálisokat kövér szedésben, aposztrófok nélkül írjuk. Az alternatívákat vagy egy függőleges vonallal választjuk el egymástól, vagy pedig külön produkciókba írjuk. Azokat a komponenseket, amelyek legfeljebb egyszer fordulhatnak elő, szögletes zárójelbe ([…]) tesszük, azokat pedig, amelyek előfordulási száma bármekkora (zéró is) lehet, kapcsos zárójel ({…}) fogja közre. A nem nyomtatható (whitespace) karakterek érdektelenek a produkciók számára.
A nevek az absztrakt szintaxisban RDF URI hivatkozások [RDF Fogalmak]. Ezeket a neveket gyakran "prefixes nevekké" rövidítjük az alábbi névtérnevek segítségével:
Az absztrakt szintaxisban minden konstrukció jelentését informálisan is leírjuk, amikor azt először bemutatjuk. E konstrukciók formális jelentését a 3. fejezetben, modell-elméleti szemantika segítségével adjuk meg.
Miközben teljes mértékben érthető, hogy egy ilyen, nagy kifejezőképességű nyelvnek, mint az OWL, minden beépített lehetősége fontos lehet bizonyos felhasználók számára, ugyanakkor azt is el kell fogadnunk, hogy az ilyen nyelvek riasztólag hathatnak az olyan fejlesztői csoportokra, amelyek szeretnék szoftver-eszközökkel támogatni a teljes nyelvet. Annak érdekében, hogy egy egyszerűbb implementációs célt is ki lehessen tűzni, egy kisebb nyelvet is definiáltak, amelyet OWL Lite-nak neveztek el [OWL Áttekintés]. Ezt a kisebb nyelvet úgy tervezték meg, hogy olyan plusz funkciókat nyújtson, amelyek fontosak a Web alkalmazások támogatásához, de hiányzik az RDF Séma szókészletéből. (Jegyezzük meg azonban, hogy sem az OWL DL, sem az OWL Lite nem nyújtja az RDF Séma összes lehetőségét.) Az absztrakt szintaxist definiálni fogjuk mind a kisebbik nyelv számára (ezt "OWL Lite absztrakt szintaxisnak" nevezzük), mind pedig a nyelv teljesebb dialektusa számára (ezt "OWL DL absztrakt szintaxisnak" nevezzük).
Az absztrakt szintaxis itt kevésbé általános, mint az OWL adatcsere-szintaxis esetében. Különösen, ez nem engedi meg az önmagukra hivatkozó szintaktikai konstrukciók használatát. Emellett ezt a szintaxist olyan esetekre dolgozták ki, ahol az osztályok, a tulajdonságok és az egyedek diszjunkt halmazokat alkotnak. Nagyjából ezek azok a korlátozások, amelyek ahhoz szükségesek, hogy az OWL következtetések eldönthetők legyenek, és ily módon az ilyen szintaxist OWL DL szintaxisnak tekinthessük.
MEGJEGYZÉS: Az OWL Lite és az OWL DL nagyon közel áll a leíró logikához (amelyet SHIF(D) és SHION(D) néven is emlegetnek), néhány olyan korlátozással, amelyek az adattípusok kezelésére vonatkoznak. Az OWL Lite absztrakt szintaxisa nélkülöz sok olyan általános explicit konstruktort, amelyek a SHIF(D)-ben megvannak, de a kifejezőképessége ennek ellenére megmarad.
Egy OWL ontológia az absztrakt szintaxisban annotációk, axiómák és tények sorozatából áll. Az OWL ontológiáknak nevet lehet adni. Az OWL ontológiákra vonatkozó annotációk felhasználhatók pl. az ontológia szerzőjének és más hasonló adatnak a rögzítésére, de felhasználhatók más ontológiák importálását kifejező hivatkozások megadására is. Az OWL ontológiák lényegi tartalmát az axiómák és a tények adják, amelyek információkat közölnek azokról az osztályokról, tulajdonságokról és egyedekről, amelyek az ontológia tárgyát képezik.
ontology ::= 'Ontology(' [ ontologyID ] { directive } ')' directive ::= 'Annotation(' ontologyPropertyID ontologyID ')' | 'Annotation(' annotationPropertyID URIreference ')' | 'Annotation(' annotationPropertyID dataLiteral ')' | 'Annotation(' annotationPropertyID individual ')' | axiom | fact
Az ontológiák nevei az absztrakt szintaxisban azt a jelentéstartalmat hordozzák, amit az általuk megnevezett ontológiák Web-es publikációja hordoz. Ezért szükséges, hogy egy ontológia neve az absztrakt szintaxisban annak a webhelynek az URI azonosítója legyen, ahol az adott ontológia található, habár ez nem része az OWL formális jelentésének. Az importáló annotációk (Imports) tulajdonképpen direktívák egy Web dokumentum megkeresésére, és ontológiaként történő kezelésére. Ugyanakkor a Web legtöbb aspektusa, mint például a nem létező, elérhetetlen, vagy időben változó dokumentumok problematikája, kívül esik az OWL specifikációján. Ami ezen belül van, az csupán azt köti ki, hogy egy imports URI hivatkozásnak egy ontológiára kell mutatnia. Ezért e dokumentum különböző helyein az Imports funkcionális jelentésén mindig ezt az idealizált jelentést értjük.
Az ontológiák információkat foglalnak magukba osztályokról, tulajdonságokról és egyedekről, s ezek mindegyikének lehet egy azonosítója, ami egy URI hivatkozás. Néhány ilyen azonosítóhoz axiómákat is meg kell adni, ahogy azt a 2.3 szekció részletesen leírja.
datatypeID ::= URIreference classID ::= URIreference individualID ::= URIreference ontologyID ::= URIreference datavaluedPropertyID ::= URIreference individualvaluedPropertyID ::= URIreference annotationPropertyID ::= URIreference ontologyPropertyID ::= URIreference
Egy ontológián belül egy URI hivatkozás nem lehet egyidejűleg adattípus-azonosító (datatypeID) és osztályazonosító (classID) is. Hasonlóképpen, egy ontológián belül egy URI hivatkozás csak a következő azonosító típusok egyike lehet: vagy egy adatértékű tulajdonság azonosítója (datavaluedPropertyID), egy egyedértékű tulajdonság azonosítója (individualvaluedPropertyID), egy annotációtulajdonság azonosítója, (annotationPropertyID) vagy egy ontológiatulajdonság azonosítója (ontologyPropertyID). Egy URI hivatkozás azonban lehet egy osztály vagy adattípus azonosítója, ugyanúgy, mint egy tulajdonság vagy egy egyed azonosítója, csakhogy az ontológiát ilyenkor nem lehet lefordítani OWL DL szintű RDF gráfokra.
Az OWL-ban egy adattípus olyan adatértékek halmazát jelöli, mely ennek az adattípusnak az értéktere. Az osztályok egyedek halmazait reprezentálják. A tulajdonságok pedig egyedek más információkhoz való viszonyát nevezik meg, és négy diszjunkt halmazt alkotnak: adatértékű (data-valued) tulajdonságok, egyedértékű (individual-valued) tulajdonságok, annotációtulajdonságok, és ontológiatulajdonságok. Az adatértékű tulajdonságok egyedeket kapcsolnak adatértékekhez, az egyedértékűek pedig egyedeket, más egyedekhez. Az annotációtulajdonságokkal megjegyzéseket fűzhetünk egyedek, osztályok, tulajdonságok és ontológiák neveihez. Az ontológiatulajdonságok ontológiákat kapcsolnak más ontológiákhoz, elsősorban olyan célból, hogy azokból információkat importálhassanak. Az egyedek azonosítóival adatforrásokra, az adat-literálokkal pedig adatértékekre hivatkozhatunk.
Az OWL-nak van két beépített osztálya is; mindkettő egy olyan URI hivatkozással érhető el, amelyik az OWL névtérhez tartozik (azaz olyan hivatkozással, mely a http://www.w3.org/2002/07/owl# azonosítóval kezdődik, ahol az owl elem az OWL névtér-azonosítója. (E dokumentumban végig, kizárólag névtérnevekkel lerövidített URI hivatkozásokat használunk.) A beépített OWL osztályok közül az, amelynek azonosítója owl:Thing, az összes egyed osztályát jelenti, az owl:Nothing névvel azonosított osztály pedig az üres osztályt reprezentálja. Az OWL Lite e két beépített osztály mindegyikét tartalmazza.
Az alábbi XML Séma adattípusok (XML Schema Part 2: Datatypes) használhatók az OWL-ban mint beépített adattípusok. Ezek az XML Séma adattípusaira előírt hivatalos URI hivatkozással (http://www.w3.org/2001/XMLSchema#név) érhetők el, ahol a "név" helyén az adattípus lokális neve áll: 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 és xsd:positiveInteger. A többi beépített XML Séma adattípus problematikus az OWL számára, amint azt az RDF Szemantika 5. fejezet tárgyalja. Az rdf:XMLLiteral beépített RDF adattípus az OWL-nak is beépített adattípusa. Mivel az XML Sémában nincs szabványos út, amelyen egy URI hivatkozásból egy XML Séma adattípushoz eljuthatnánk, ezért nincs szabványos módszer sem az OWL-ban arra, hogy a felhasználók saját XML Séma adattípusokat definiálhassanak.
Az OWL-ban vannak beépített annotációtulajdonságok is, nevezetesen az owl:versionInfo, az rdfs:label, az rdfs:comment, az rdfs:seeAlso és az rdfs:isDefinedBy. Hogy kompatibilisek maradjunk ezek RDFS definícióival, az rdfs:label és az rdfs:comment értékeként csak adat-literált adhatunk meg.
Vannak továbbá beépített ontológiatulajdonságok, ezek az owl:imports, az owl:priorVersion, az owl:backwardCompatibleWith és az owl:incompatibleWith. Azok az ontológia-annotációk, amelyek használják az owl:imports tulajdonságot, rendelkeznek egy olyan többlethatással is, hogy importálják a hivatkozott ontológiát.
Sok OWL konstrukció használ annotációkat, amelyek ugyanúgy, mint az annotációs direktívák, arra szolgálnak, hogy információkat rögzítsenek a konstrukció valamelyik részével kapcsolatban.
annotation ::= 'annotation(' annotationPropertyID URIreference ')' | 'annotation(' annotationPropertyID dataLiteral ')' | 'annotation(' annotationPropertyID individual ')'
A tények két formáját különbözteti meg az OWL absztrakt szintaxisa.
Az első forma információkat közöl egy meghatározott egyedről olyan formában, hogy egyrészt megadja ennek az egyednek az osztályát, a tulajdonságait és e tulajdonságok értékeit. Egy egyednek adhatunk azonosítót (individualID) amelyik megjelöli az egyedet, és lehetővé teszi, hogy hivatkozzunk erre az egyedre. Nem szükséges azonban egy egyednek azonosítót adnunk; az ilyenek névtelen egyedek (az RDF terminológiájában: "üres csomópontok") lesznek, és másutt nem hivatkozhatunk rájuk közvetlenül. Az alábbi szintaxist úgy építettük fel, hogy valamelyest tükrözze az RDF/XML szintaxist [RDF Szintaxis] az rdf:nodeID használata nélkül:
fact ::= individual individual ::= 'Individual(' [ individualID ] { annotation } { 'type(' type ')' } { value } ')' value ::= 'value(' individualvaluedPropertyID individualID ')' | 'value(' individualvaluedPropertyID individual ')' | 'value(' datavaluedPropertyID dataLiteral ')'
A tények azonosak az OWL Lite és az OWL DL absztrakt szintaxisában, kivéve azt a megkötést, hogy mi lehet típus. Az OWL Lite-ban a típusok osztályazonosítók vagy OWL Lite korlátozások lehetnek (lásd a 2.3.1.2 szekcióban).
type ::= classID | restriction
Az OWL DL absztrakt szintaxisában a típusok általános leírások lehetnek, beleértve az osztályazonosítókat, az OWL Lite korlátozásokat, és más konstrukciókat is:
type ::= description
Az adat-literálok az absztrakt szintaxisban lehetnek tipizált, vagy típus nélküli literálok. Az utóbbiak egy Unicode (Normal Form C) karakterláncból, és egy opcionális, a használt nyelvre utaló tegből állnak, ugyanúgy, mint az RDF típus nélküli literáljai (plain literals) [RDF Fogalmak]. A tipizált literálok egy lexikális reprezentációból, és egy URI referenciából állnak, ahogy azt az [RDF Fogalmak] dokumentum tipizált RDF literálok című leírása definiálja.
dataLiteral ::= typedLiteral | plainLiteral typedLiteral ::= lexicalForm^^URIreference plainLiteral ::= lexicalForm | lexicalForm@languageTag lexicalForm ::= mint az RDF-ben, egy unicode karakterlánc (normal form C) languageTag ::= mint az RDF-ben, egy nyelvre utaló XML languageTag
A tények második formáját arra használjuk, hogy nevesített egyedeket azonossá, vagy páronként különbözővé tegyünk (individualID = egyedazonosító).
fact ::= 'SameIndividual(' individualID individualID {individualID} ')' | 'DifferentIndividuals(' individualID individualID {individualID} ')'
Az OWL Lite és az OWL DL absztrakt szintaxisának legnagyobb különbségei az axiómákban mutatkoznak meg, amelyek arra szolgálnak, hogy információkat adjunk meg velük osztályokról és tulajdonságokról. Minthogy az OWL Lite a kisebbik nyelv, elsőként ennek axiómáit tárgyaljuk a 2.3.1 szekcióban. Az OWL DL axiómáit a 2.3.2 szekció írja le. Az OWL DL axiómái közé tartoznak az OWL Lite axiómák is mint az OWL DL axiómák speciális esetei.
Az axiómákat arra használjuk, hogy osztály- és tulajdonság-azonosítókat társítsunk osztályok és tulajdonságok jellemzőinek részleges (partial) vagy teljes (complete) specifikációjához, valamint, hogy egyéb információkat adjunk meg az osztályokról és tulajdonságokról. Az axiómákat definícióknak is szoktuk nevezni, de minthogy ezek nem mind definíciók a kifejezés szokásos értelmében, ezért egy semlegesebb nevet kellett választanunk.
Az itt használt szintaxis ahhoz hasonlít, amit egyes keretrendszerekben használnak. Az OWL Lite-ban minden osztályaxióma általánosabb osztályok gyűjteményét tartalmazza, valamint olyan helyi tulajdonságkorlátozások gyűjteményét, amelyek korlátozáskonstrukciók formájában vannak megadva. Egy korlátozáskonstrukció definiálhatja a tulajdonság helyi értéktartományát, és hogy hány értéket vehet fel ebből a tartományból, és/vagy megadhatja a konkrét értékek gyűjteményét. Az osztályaxióma az általa definiált osztályt a konstrukciójában szereplő általánosabb osztályokkal és korlátozásokkal egyenértékűvé, vagy ezek osztálymetszetének alosztályává teheti. Az OWL DL absztrakt szintaxisában egy osztályaxióma olyan leírások kollekcióját tartalmazza, amelyek lehetnek általánosabb osztályok, korlátozások, egyedek halmazai, valamint osztályleírások Boole-algebrai kombinációi. Emellett specifikálhatók az osztályok felsorolással, és egyenértékűségi vagy különbözőségi viszonyok megadásával is.
A tulajdonságokat más tulajdonságok egyenértékű tulajdonságává vagy altulajdonságává tehetjük; ezenkívül definiálhatjuk a tulajdonságokat funkcionálisnak, szimmetrikusnak, fordított funkcionálisnak vagy tranzitívnak, és rendelhetünk hozzájuk globális érvényességi kört és értéktartományt is. A tulajdonságokkal kapcsolatos legtöbb információt azonban természetesebben lehet kifejezni korlátozások formájában; ezek lehetővé teszik lokális érvényességi kör és értéktartomány megadását is.
Az osztályazonosítóként vagy adattípus-azonosítóként használt URI hivatkozásokat meg kell különböztetnünk, s ehhez szükségünk van egy axiómára, kivéve a beépített OWL osztályokat és adattípusokat, valamint az rdfs:Literal-t. Egy osztálynak vagy egy adattípusnak egynél több axiómája is lehet. Azokat a tulajdonságokat, amelyeket egy absztrakt szintaxissal leírt ontológiában használunk, vagy adatértékű, vagy egyedértékű, vagy annotációs tulajdonságoknak kell minősítenünk. Emiatt a tulajdonságoknak is szükségük van (legalább egy) axiómára. Ha egy ontológia egy másik ontológiát importál, akkor az ebben szereplő (vagy ez utóbbi által importált másik ontológiában szereplő) axiómák is felhasználhatók ilyen célra.
Az OWL Lite-ban az osztályaxiómák azt jelentik ki, hogy az éppen definiált osztály bizonyos főosztály- és OWL Lite korlátozás-halmazok metszetének: vagy egy egyenértékű osztálya (komplett módozatnál), vagy pedig egy alosztálya (parciális módozatnál). Azt is jelezni lehet az axiómában, hogy egy osztály elavultnak tekintünk (deprecated).
axiom ::= 'Class(' classID ['Deprecated'] modality { annotation } { super } ')' modality ::= 'complete' | 'partial' super ::= classID | restriction
Az OWL Lite-ban kijelenthetjük, hogy kettő, vagy több osztály egyenértékű.
axiom ::= 'EquivalentClasses(' classID classID { classID } ')'
Az adattípus-axiómák egyszerűbbek, és csak arra szolgálnak, hogy kijelentsük egy azonosítóról, hogy az egy adattípust azonosít, továbbá, hogy annotációkat tudjunk fűzni ehhez az adattípushoz.
axiom ::= 'Datatype(' datatypeID ['Deprecated'] { annotation } )'
Az OWL Lite osztályaxiómáiban az éppen definiált osztály tulajdonságaira lokális korlátozásokat adhatunk meg. A korlátozások minden allValuesFrom eleme azt köti ki, hogy a tulajdonság minden értékének egy meghatározott osztályhoz vagy adattípushoz kell tartoznia. A korlátozások minden someValuesFrom eleme pedig azt írja elő, hogy a tulajdonság számára kell lennie legalább egy olyan értéknek, mely egy meghatározott osztályhoz vagy adattípushoz tartozik. A korlátozások cardinality eleme azt határozza meg, hogy az éppen definiált osztályra vonatkoztatva az adott tulajdonság hány különböző értéket vehet fel. Az OWL Lite-ban a kardinalitás megengedett értéke csak 0 vagy 1 lehet.
A 2.3.1.3 szekció írja le, hogy mely tulajdonságok kardinalitása korlátozható.
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)'
Az osztályokhoz hasonlóan a tulajdonságokat is a már ismert tömbszerű szintaxissal specifikáljuk. Az egyedértékű tulajdonságok az osztályok egyedeit más egyedekhez, az adatértékű tulajdonságok pedig adatértékekhez (pl. egész számokhoz) kapcsolják. A tulajdonságok e két változatának szupertulajdonságai is lehetnek, s ily módon tulajdonsághierarchiák is kialakíthatók. (Annak nincs értelme, hogy egy egyedértékű tulajdonságot egy adatértékű tulajdonság szupertulajdonságává tegyünk, vagy megfordítva). Az adatértékű és az egyedértékű tulajdonságokhoz érvényességi kört és értéktartományt is rendelhetünk. Valamely tulajdonság érvényességi köre azt specifikálja, hogy mely egyedek lehetnek olyan kijelentések alanyai, amelyekben az adott tulajdonság az állítmány (ugyanúgy, mint az RDFS-nél). Az OWL Lite-ban a tulajdonságok érvényességi körei osztályok lehetnek. Megadható több érvényességi kör is, ám ilyenkor csak azok az egyedek lehetnek érvényes alanyok, amelyek egyidejűleg az összes ilyen (érvényességi körként definiált) osztálynak egyedei. Valamely tulajdonság értéktartománya azt specifikálja, hogy mely egyedek vagy adatértékek lehetnek olyan kijelentések tárgyai, amelyekben az adott tulajdonság az állítmány. Itt is érvényes, hogy több értéktartományt specifikálhatunk egy tulajdonságra, és itt is csak olyan egyedek, illetve adatértékek lehetnek érvényes tárgyak, amelyek az összes megadott értéktartományban benne vannak. Az OWL Lite-ban az egyedértékű tulajdonságok értéktartományai mindig osztályok, az adatértékűeké pedig adattípusok.
Az adatértékű tulajdonságokat specifikálhatjuk (parciális) funkcionálisnak, s ez azt jelenti, hogy egy egyed az adott tulajdonsággal csak egyetlen adatértékhez kapcsolódhat. Az egyedértékű tulajdonságok specifikálhatók egy másik tulajdonság fordítottjának, vagy egy másik tulajdonsággal szimmetrikusnak, és specifikálhatók (parciális) funkcionálisnak, (parciális) fordított funkcionálisnak, és tranzitívnak is.
Hogy az OWL Lite következtetések kiszámításánál fenntarthassuk az eldönthetőséget, nem minden tulajdonságra specifikálhatunk kardinalitáskorlátozást, és nem minden tulajdonságot specifikálhatunk funkcionálisnak vagy fordított funkcionálisnak. Komplex tulajdonságokat nem lehet tranzitívnak specifikálni. Egy egyedértékű tulajdonság komplex lesz, ha 1.) funkcionálisnak vagy fordított funkcionálisnak specifikáljuk, 2.) egy kardinalitáskorlátozás használja, 3.) van egy olyan deklarált fordítottja, amelyik komplex, vagy 4.) van egy deklarált szupertulajdonsága, amelyik komplex.
Az annotáció- és ontológiatulajdonságok sokkal egyszerűbbek, mint az adatértékű és egyedértékű tulajdonságok. A rájuk vonatkozó axiómákban az információk csupán annotációk.
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'
Az alábbi axiómák több tulajdonságot egyenértékűvé tesznek, illetve egyik tulajdonságot a másik altulajdonságává teszik.
axiom ::= 'EquivalentProperties(' datavaluedPropertyID datavaluedPropertyID { datavaluedPropertyID } ')' | 'SubPropertyOf(' datavaluedPropertyID datavaluedPropertyID ')' | 'EquivalentProperties(' individualvaluedPropertyID individualvaluedPropertyID { individualvaluedPropertyID } ')' | 'SubPropertyOf(' individualvaluedPropertyID individualvaluedPropertyID ')'
Az OWL DL absztrakt szintaxisa az OWL Lite osztályaxiómák általánosabb változatait tartalmazza, ahol már főosztályok, általánosabb korlátozások, és ezek Boole-algebrai kombinációi is engedélyezettek. E konstrukciók összességét leírásoknak hívjuk.
axiom ::= 'Class(' classID ['Deprecated'] modality { annotation } { description } ')' modality ::= 'complete' | 'partial'
Az OWL DL absztrakt szintaxisában azt is megadhatjuk, hogy egy osztály egyedeinek a halmaza pontosan mely egyedekből áll:
axiom ::= 'EnumeratedClass(' classID ['Deprecated'] { annotation } { individualID } ')'
Végül, az OWL DL absztrakt szintaxisában kimondhatjuk, hogy az axiómában szereplő leírások páronként diszjunktak, vagy hogy azonosak az egyedeik, vagy hogy az egyik leírás egy másiknak az alosztálya. Figyeljük meg, hogy az utóbbi két axióma az előttük lévő, első típusú axiómát általánosítja (az annotáció kivételével).
axiom ::= 'DisjointClasses(' description description { description } ')' | 'EquivalentClasses(' description { description } ')' | 'SubClassOf(' description description ')'
Az OWL DL EquivalentClasses konstrukciójában megadhatunk egyetlen leírást is. Ez lehetővé teszi, hogy az ontológiák olyan leírásokat is tartalmazzanak, amelyek nem kapcsolódnak semmihez. Ez szemantikailag nem jár ugyan semmilyen haszonnal, de segíti az ontológiák — amúgy nem túl könnyű — szerkesztését.
Az OWL DL adattípus-axiómái ugyanazok, mint az OWL Lite hasonló axiómái.
axiom ::= 'Datatype(' datatypeID ['Deprecated'] { annotation } )'
Az OWL DL absztrakt szintaxisában a leírások osztályazonosítókból és korlátozásokból épülnek fel. A leírások lehetnek más leírások Boole-algebrai kombinációi, és lehetnek egyedek felsorolásai is.
description ::= classID | restriction | 'unionOf(' { description } ')' | 'intersectionOf(' { description } ')' | 'complementOf(' description ')' | 'oneOf(' { individualID } ')'
Az OWL DL absztrakt szintaxisában a korlátozások az OWL Lite korlátozásait általánosítják oly módon, hogy leírásokat is megengednek ott, ahol az OWL Lite csak osztályokat, továbbá oly módon, hogy megengedik mind adattípusok, mind adatértékek halmazának megadását. Az adattípusok és adatérték-halmazok kombinációját adatérték-tartománynak nevezzük. Az OWL DL absztrakt szintaxisában (egy adott osztályra vonatkozóan) a tulajdonságoknak értéket is lehet adni. Emellett a három kardinalitástípus értéke sincs kizárólag 0-ra és 1-re korlátozva.
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 ')'
Egy adatérték-tartomány, amelyet adatértékű tulajdonságok értéktartományaként adunk meg, vagy amelyet az OWL DL absztrakt szintaxis más helyén használunk, csak egy adattípus, vagy egy adatérték-felsorolás lehet.
dataRange ::= datatypeID | 'rdfs:Literal' | 'oneOf(' { dataLiteral } ')'
Az OWL Lite korlátozások azon megkötései, hogy milyen tulajdonságokra lehet kardinalitáskorlátozást alkalmazni, az OWL DL-ben is fennállnak.
Az OWL DL absztrakt szintaxis tulajdonságaxiómái az OWL Lite tulajdonságaxiómáit általánosítják oly módon, hogy leírásokat is megengednek ott, ahol az OWL Lite csak osztályokat, továbbá az érvényességi körök és értéktartományok számára adatérték-tartományok megadását is engedélyezik ott, ahol az OWL Lite csak adattípusokat engedélyez.
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 } ')'
Az OWL Lite korlátozások azon megkötései, hogy milyen tulajdonságokat lehet funkcionálisnak vagy fordított funkcionálisnak deklarálni, az OWL DL-ben is érvényesek.
Ugyanúgy, mint az OWL Lite-nál, az alábbi axiómák itt is alkalmasak arra, hogy segítségükkel több tulajdonságot egyenértékűvé tegyünk, illetve, hogy az egyik tulajdonságot egy másik altulajdonságává tegyük.
axiom ::= 'EquivalentProperties(' datavaluedPropertyID datavaluedPropertyID { datavaluedPropertyID } ')' | 'SubPropertyOf(' datavaluedPropertyID datavaluedPropertyID ')' | 'EquivalentProperties(' individualvaluedPropertyID individualvaluedPropertyID { individualvaluedPropertyID } ')' | 'SubPropertyOf(' individualvaluedPropertyID individualvaluedPropertyID ')'