Az OWL Web Ontológia Nyelv – Referencia

W3C Ajánlás, 2004. Február 10.

Jelen verzió (angol eredeti):

http://www.w3.org/TR/2004/REC-owl-ref-20040210/

Legutolsó verzió (angol eredeti):

http://www.w3.org/TR/owl-ref/

Előző verzió (angol eredeti):

http://www.w3.org/TR/2003/PR-owl-ref-20031215/

Szerkesztők:

Mike Dean, BBN Technologies
Guus Schreiber, Free University Amsterdam

Szerzők:

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

Absztrakt

Az OWL Web Ontológia Nyelv egy szemantikai jelölőnyelv, mely ontológiák Weben történő publikálására és közös használatára szolgál. Az OWL nyelvet az RDF (Resource Description Framework) szókészletének kiterjesztéseként, a DAML+OIL nyelvből kiindulva fejlesztették ki. Ez a dokumentum az OWL nyelvi konstrukciók teljes halmazának informális leírását tartalmazza, ezért referenciaként szolgálhat azon felhasználók számára, akik ontológiákat kívánnak építeni.

A dokumentum státusa

Ezt a dokumentumot a W3C Tagjai és más érdekelt résztvevők ellenőrizték, és az Igazgató W3C Ajánlásként hitelesítette. Az Ajánlás elkészítésével a W3C célja és szerepe az, hogy ráirányítsa a figyelmet a specifikációra, és elősegítse annak széles körű alkalmazását. Ez megnöveli a Web használhatóságát, és javítja a Weben történő együttműködést.

Ez a dokumentum annak a hat részből álló W3C Ajánlásnak egyik része, mely az OWL Web Ontológia Nyelvet szabványosítja. Ezt az Ajánlást a W3C Szemantikus Web Munkaprogramja keretében a Web Ontológia Munkacsoport dolgozta ki, és 2004. február 10. dátummal publikálta. (Lásd a Munkaprogram-nyilatkozatot és a Munkacsoport Alapszabályát.)

Az OWL konstrukciójának a dokumentumok korábbi verziójában leírt változatát jelentősen átdolgozták, s ez a konstrukció kielégíti a Munkacsoport technikai követelményeit. A Munkacsoport megvizsgálta az összes beérkezett észrevételt, és elvégezte a szükséges javításokat. Az Ajánlástervezet óta a jelen Ajánlás megszületéséig a dokumentumon végrehajtott módosításokat a Változtatási napló részletezi.

A Munkacsoport szívesen fogadja az észrevételeket a public-webont-comments@w3.org (E-mail archívum) címén, az idevágó technológiák általános vitáját pedig a www-rdf-logic@w3.org (E-mail archívum) címén folytatja.

Rendelkezésre áll egy konszignáció az ismert alkalmazásokról.

A W3C listát vezet továbbá azokról a felfedett szabadalmi igényekről is, amelyek ehhez a munkához kapcsolódnak.

Ez a szekció a dokumentumnak a publikáláskor érvényes státusát rögzíti. Más dokumentumok hatálytalaníthatják ezt a dokumentumot. A legújabb W3C publikációk listája, valamint e technikai riport utolsó kiadása megtalálható a W3C technikai riportok indexében, ahttp://www.w3.org/TR/ alatt.

Köszönetnyilvánítás

A jelen dokumentum egyes részei a "DAML+OIL (March 2001) Reference Description" [DAML+OIL] dokumentumból származnak, amelyet a DAML+OIL W3C Note részeként terjesztettek elő. Ennek a dokumentumnak és korábbi változatainak szponzorai különleges köszönetet érdemelnek.

Jeremy Carroll, Jim Hendler, Brian McBride és Peter Patel-Schneider lényegbevágó lektori munkát végeztek az anyagon, és bizonyos szövegrészek szerzőiként is közreműködtek. Jerome Euzenat bocsátotta rendelkezésünkre a Felsorolás adattípussal kapcsolatos egyik példát.

Ez a dokumentum azoknak a széles körű eszmecseréknek és egyeztetéseknek az eredménye, melyeket a Web Ontológia Munkacsoporton mint egészen belül folytattunk. A résztvevők ebben a munkacsoportban: 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 és John Yanosy.

Tartalomjegyzék

• Absztrakt
• A dokumentum státusa
• Köszönetnyilvánítás
• 1. Bevezetés
  • 1.1 A dokumentum célja
  • 1.2 OWL Full / DL / Lite
  • 1.3 Az OWL szintaxisa
  • 1.4 OWL és RDF szemantika
  • 1.5 Megjegyzés a példákhoz
  • 1.6 Adategyesítés és a privát jogok
  • 1.7 E dokumentum függelékei
• 2. Az OWL dokumentum
  • 2.1 Tartalom
  • 2.2 OWL URI szókészlet és névtér
  • 2.3 Az OWL MIME típusa
• 3. Osztályok
  • 3.1 Osztályleírások
    • 3.1.1 Felsorolás
    • 3.1.2 Tulajdonságkorlátozás
      • 3.1.2.1 Értékkorlátozások
        • 3.1.2.1.1 owl:allValuesFrom
        • 3.1.2.1.2 owl:someValuesFrom
        • 3.1.2.1.3 owl:hasValue
      • 3.1.2.2 Kardinalitáskorlátozások
        • 3.1.2.2.1 owl:maxCardinality
        • 3.1.2.2.2 owl:minCardinality
        • 3.1.2.2.3 owl:cardinality
    • 3.1.3 Metszet, unió és komplemens
      • 3.1.3.1 owl:intersectionOf
      • 3.1.3.2 owl:unionOf
      • 3.1.3.3 owl:complementOf
  • 3.2 Osztályaxiómák
    • 3.2.1 rdfs:subClassOf
    • 3.2.2 owl:equivalentClass
    • 3.2.3 Axiómák komplett osztályokhoz owl:equivalentClass használata nélkül
    • 3.2.4 owl:disjointWith
• 4. Tulajdonságok
  • 4.1 RDF Séma alapú tulajdonságkonstrukciók
    • 4.1.1 rdfs:subPropertyOf
    • 4.1.2 rdfs:domain
    • 4.1.3 rdfs:range
  • 4.2 Tulajdonságok közötti relációk
    • 4.2.1 owl:equivalentProperty
    • 4.2.2 owl:inverseOf
  • 4.3 Tulajdonságok kardinalitásának globális korlátozása
    • 4.3.1 owl:FunctionalProperty
    • 4.3.2 owl:InverseFunctionalProperty
  • 4.4 Tulajdonságok logikai jellemzői
    • 4.4.1 owl:TransitiveProperty
    • 4.4.2 owl:SymmetricProperty
• 5. Egyedek
  • 5.1 Osztálytagság és tulajdonságértékek
  • 5.2 Egyedek azonossága, különbözősége
    • 5.2.1 owl:sameAs
    • 5.2.2 owl:differentFrom
    • 5.2.3 owl:AllDifferent
• 6. Adattípusok
  • 6.1 RDF adattípusok
  • 6.2 Felsorolás adattípus az owl:oneOf használatával
  • 6.3 Adattípus-következtetések támogatása
• 7. Annotáció, ontológia-header, importálás és verzió-információ
  • 7.1 Annotációk
  • 7.2 Az ontológia-header
  • 7.3 Ontológiák importálása
  • 7.4 Verzió-információk
    • 7.4.1 owl:versionInfo
    • 7.4.2 owl:priorVersion
    • 7.4.3 owl:backwardCompatibleWith
    • 7.4.4 owl:incompatibleWith
    • 7.4.5 owl:DeprecatedClass és owl:DeprecatedProperty
• 8. OWL Full, OWL DL és OWL Lite
  • 8.1 OWL Full
  • 8.2 OWL DL
  • 8.3 OWL Lite
• A. függelék: A nyelvi elemek indexe
• B. függelék: Az OWL RDF Sémája
• C. függelék: OWL gyorsreferencia
• D. függelék: Változások a DAML+OIL-hoz képest
• E. függelék: "Ökölszabály" az OWL DL ontológiákhoz
• F. függelék: Változtatási napló az Ajánlástervezethez képest
• A külső dokumentumhivatkozások listája

1. Bevezetés

1.1 A dokumentum célja

Ez a dokumentum az OWL modellező nyelvi elemeinek szisztematikus és tömör informatív leírását nyújtja az OWL számára is érvényes RDF/XML adatcsere-szintaxis segítségével.

A jelen dokumentum annak az OWL Web Ontológia Nyelv-leírásnak az egyik komponense, amelyet a W3C Web Ontológia Munkacsoportja (WebOnt) készít. Az OWL Áttekintés dokumentum 1.1 szekciója, "A javasolt olvasási sorrend" bemutatja az egyes rész-dokumentumokat, és azt, hogy ezek miként illeszkednek egymáshoz. Azok az olvasók, akik még nem ismerik az OWL-t, elsőként elolvashatják az [OWL Áttekintés] dokumentumot, majd folytathatják az [OWL Útmutató] dokumentummal, mely olvasmányosabban mutatja be, és példákkal illusztrálja a nyelv használatát.

A jelen dokumentum feltételezi, hogy az olvasó ismeri az RDF alapfogalmait [RDF Fogalmak], és gyakorlati ismeretekkel is rendelkezik az RDF szintaxisa [RDF/XML Szintaxis], valamint az RDF Séma, azaz az [RDF Szókészlet] területén.

Az OWL nyelvi konstrukciók pontos szintaxisának normatív definíciója az OWL Szemantika és absztrakt szintaxis [OWL Sz&ASz] dokumentumban található. Ugyanez a dokumentum tartalmazza – modell-elméleti szemantika formájában – a nyelvi konstrukciók jelentésének precíz definícióját is. Ugyancsak ez a dokumentum tárgyalja az olyan fogalmakat, mint Pl.: az OWL ontológiák konzisztenciája.

Az OWL nyelv alkalmazási eseteit, illetve követelményeit az [OWL Követelmények] dokumentum írja le, az OWL eszközök tesztelési lépéseit pedig az [OWL Tesztsorozat] dokumentum specifikálja. Ebben találhatók tesztsorozatok a következtetési helyesség (entailment correctness) és az ellentmondás-mentesség (konzisztencia) ellenőrzésére is.

1.2 OWL Full / DL / Lite

Ahogy azt már az [OWL Áttekintés] és az [OWL Útmutató] dokumentum is tárgyalta, az OWL nyelvnek két specifikus részhalmaza (alnyelve) van, amelyekről úgy hisszük, hogy előnyösek lehetnek a nyelv implementorai és felhasználói számára. Ezek közül az OWL Lite-ot úgy tervezték meg, hogy egyrészt könnyen implementálható legyen, másrészt a nyelv olyan funkcionális részhalmazát valósítsa meg, mely segíti a felhasználót az elindulásban. Az OWL DL-t – ahol a "DL" a Description Logic, (leíró logika) rövidítése – arra tervezték, hogy támogassa a meglévő leíró logikai üzleti szegmenst, és olyan nyelvi részhalmazt biztosítson, mely a következtető rendszerek szempontjából kedvező kiszámíthatósági tulajdonságokkal rendelkezik. A teljes OWL nyelv (amelyet OWL Full-nak, azaz teljes OWL-nak nevezünk, hogy megkülönböztessük a két részhalmaztól) feloldja az OWL DL néhány kötöttségét, amennyiben olyan opciókat biztosít, amelyek sok adatbáziskezelő és tudásábrázoló rendszer számára előnyösek, de amelyek áthágják a leíró logikai következtető rendszerek határait.

MEGJEGYZÉS: Az RDF dokumentumok általában OWL Full nyelven íródnak, hacsak nem kifejezetten OWL DL-re vagy Lite-ra tervezték őket.

Az OWL Full és az OWL DL az OWL nyelvi konstrukcióinak ugyanazt a halmazát támogatják. A két alnyelv különbsége abban áll, hogy milyen korlátozások mellett használhatják ezeket a nyelvi konstrukciókat, valamint abban, hogy kihasználhatják-e az RDF alapvető tulajdonságait. Az OWL Full például lehetővé teszi az OWL és az RDF Séma vegyes használatát, és ugyanúgy, mint az RDF Séma, nem erőlteti az osztályok, tulajdonságok, egyedek és adatértékek szigorú szétválasztását. Az OWL DL azonban korlátozza a vegyes használatot, és megköveteli, hogy az osztályok, tulajdonságok, egyedek és adatértékek diszjunkt halmazokat alkossanak. Az OWL DL alnyelv létét az indokolja, hogy az eszközfejlesztők már korábban olyan ontológiák támogatására szolgáló nagy teljesítményű következtető rendszereket fejlesztettek ki, amelyek korlátozásai éppen az OWL DL korlátozásait igénylik. Az OWL Full és az OWL DL különbségeinek formális definícióját az OWL Szemantika és absztrakt szintaxis [OWL Sz&ASz] dokumentum 8.2 "OWL DL" szekciója adja meg, mely összefoglalja az OWL Full és az OWL DL közötti különbségeket is.

Az OWL Lite az OWL DL alnyelve, mely az OWL nyelvi konstrukcióinak csupán egy részhalmazát támogatja. Az OWL Lite-ot elsősorban olyan eszközfejlesztőknek szánták, akik támogatni kívánják az OWL-t, de első lépésben a nyelvi konstrukcióknak csak egy viszonylag egyszerű, de alapvető részhalmazát szeretnék megcélozni. Az OWL Lite ugyanazokhoz a szemantikai korlátozásokhoz tartja magát, mint az OWL DL, s ez lehetővé teszi, hogy a következtetőgépek garantálni tudjanak bizonyos kívánatos tulajdonságokat. Az OWL Lite-ban engedélyezett nyelvi konstrukciók összefoglalását a 8.3 szekció tartalmazza. Az OWL Lite által támogatott nyelvi konstrukciók formális leírását az OWL Szemantika és absztrakt szintaxis [OWL Sz&ASz] dokumentumban találja meg az olvasó.

MEGJEGYZÉS: Azok az RDF felhasználók, akik szeretnének átállni az OWL-ra, vegyék figyelembe, hogy az OWL Lite nem pusztán csak egy kiterjesztése az RDF Sémának! Az OWL Lite valójában egy "könnyített" változata az OWL DL-nek, mely korlátozza az RDF szókészlet használatát (pl. osztályok, tulajdonságok stb. diszjunktivitása). Az OWL Full-t viszont éppen az RDF-fel való maximális kompatibilitásra tervezték, és így ez a megfelelő nyelv, amellyel az RDF felhasználók elindulhatnak. Amikor az OWL DL vagy az OWL Lite használatát fontolgatjuk, mérlegelnünk kell, hogy az OWL DL/Light előnyei a következtetés támogatásában többet nyomnak-e a latban, mint az OWL DL/Light hátrányai az OWL és RDF konstrukciók korlátozott használatában.

MEGJEGYZÉS: Az OWL Lite-ot ebben a dokumentumban úgy tárgyaljuk, mint az OWL DL néhány további korlátozását. Ez azt jelenti, hogy az OWL DL konstrukciók az OWL Lite-nak is részei, hacsak kifejezetten másként nem definiáljuk. A 8.3 szekció foglalja össze az OWL Lite-ra vonatkozó többletkorlátozásokat.

1.3 Az OWL szintaxisa

Egy OWL ontológia tulajdonképpen egy RDF gráf [lásd: RDF Fogalmak], mely RDF tripletekből áll. Ugyanúgy, mint bármilyen RDF gráf, az OWL ontológia gráfja is sokféle szintaktikai formában leírható (Lásd az RDF/XML Szintaxis specifikáció új kiadásában [RDF/XML Szintaxis]). A jelen dokumentum (az Útmutatóhoz hasonlóan) az RDF/XML szintaxisnak egy specifikus formáját használja a tripletek ábrázolására. Az OWL ontológia jelentését azonban kizárólag az RDF gráf határozza meg. Így tehát használhatunk bármi más RDF/XML szintaxisformát is, ha ez ugyanazokat az alapvető RDF tripleteket produkálja. Bármilyen szintaxisforma, mely megfelel ennek a kritériumnak, ugyanazt a jelentéstartalmat ábrázolja, mint a jelen dokumentumban használt forma.

Az alábbi példa két alternatív formát mutat be, melynek eredménye ugyanaz az RDF triplet. Tekintsük a következő RDF/XML szintaxist:

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

Az alábbi RDF/XML szintaxis

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

ugyanazt az RDF tripletet kódolja, mint a fenti, és ezért ugyanazt a jelentést hordozza.

1.4 OWL és RDF szemantika

Az OWL az RDF szókészlet (RDF vocabulary) kiterjesztése [RDF Szemantika]. Így tehát minden RDF gráf egy OWL Full ontológiát alkot. Ebből következően az OWL által előállított RDF gráf jelentése ugyanaz, mint az RDF által előállított gráfé. Az OWL Full ontológiák ezért tetszőleges RDF tartalmat foglalhatnak magukban, amelyek kezelése is konzisztens az RDF kezelésével. Az OWL azonban további jelentést tulajdoníthat egyes RDF tripleteknek. Az OWL Szemantika és absztrakt szintaxis dokumentum [OWL Sz&ASz] specifikálja, hogy pontosan mely tripletekhez rendel specifikus jelentést az OWL, és hogy mi ez a jelentés.

MEGJEGYZÉS : Mint már korábban is említettük, az OWL DL és OWL Lite kiterjeszti az RDF szókészletet, de korlátozásokat is bevezet e szókészlet használatára. Ezért az RDF dokumentumok általában OWL Full-ban is érvényes dokumentumok (kivéve, ha kifejezetten OWL DL vagy Lite dokumentumként kódolták őket).

1.5 Megjegyzés a példákhoz

A könnyebb olvashatóság kedvéért e dokumentum példái feltételezik, hogy az olyan XML entitások, mint &rdf; &rdfs; &owl; és &xsd;(XML Séma adattípus) előre definiálva vannak oly módon, ahogy a B. Függelék ismerteti. Ugyanez érvényes az ezeknek megfelelő olyan névterekre is, mint az rdf: rdfs:, owl: és xsd:.

A példákat ebben a dokumentumban csak az OWL nyelvi szerkezetek illusztrálására szántuk. Ezek itt nem alkotnak egy konzisztens ontológiát. Egy komplettebb példát találhat az olvasó az [OWL Útmutató] dokumentumban.

1.6 Adategyesítés és a privát jogok

Az OWL-nak az a képessége, hogy ontológiai információt lehet vele kifejezni olyan egyedekről, amelyek több dokumentumból származnak, szigorúan szabályozott módon támogatja az adatok összekapcsolását. A nyelv beépített szemantikája támogatja az összekapcsolható információk logikai feldolgozását is, s ez nem várt eredményekhez vezethet. Különösen igaz ez az owl:sameAs használatára, amellyel látszólag különböző egyedekről azt állíthatjuk, hogy valójában azonosak. Az owl:InverseFunctionalProperty kifejezés szintén alkalmas arra, hogy segítségével egyedeket kapcsoljunk össze. Ha egy olyan tulajdonságról, mint pl. a "TAJszáma", azt jelentjük ki, hogy Fordított Funkcionális Tulajdonság, akkor a két különböző egyedet (pl. ugyanazon TAJ-szám két különböző néven szereplő birtokosát) azonosnak lehet tekinteni azon az alapon, hogy ezen tulajdonságuk értéke azonos. Amikor az egyedekről ilyen módon meg lehet állapítani, hogy azonosak, akkor a velük kapcsolatos, különböző forrásokból származó információk egyesíthetők. Ez az adategyesítési (aggregation) funkció tehát arra is használható, hogy olyan tényeket is megállapíthassunk, amelyek egyik forrásban sincsenek közvetlenül ábrázolva.

A Szemantikus Web-nek az a képessége, hogy több forrásból tudunk vele információkat egyesíteni, egy szükséges és rendkívül gyümölcsöző tulajdonság, mely sok alkalmazásnál jól kihasználható. Azonban az a lehetőség, hogy különböző forrásokból adatokat lehet integrálni, az OWL következtető képességeivel kombinálva magában hordja a visszaélés lehetőségét is. Az OWL felhasználóinak ébereknek kell tehát lenniük, ha meg akarják őrizni a privát szférájuk integritását. A részletes biztonsági megoldásokat a Munkacsoport nem tekintette feladatának. Több olyan szervezet foglalkozik azonban ezekkel a kérdésekkel, amelyek a biztonsági- és preferencia-megoldások különböző változatait kínálják (lásd, pl. SAML és P3P).

1.7 E dokumentum függelékei

Dokumentumunk végén található egy sor függelék, mely további információkat tartalmaz az anyag megértéséhez.

A dokumentumban azok a linkek, amelyeket a nyelvi konstrukciók definícióinál megadtunk, közvetlenül elérhetővé teszik a megfelelő szemantikai leírást az OWL Szemantika és absztrakt szintaxis dokumentumban [OWL Sz&ASz]. Az A. függelék a nyelvi konstrukciók neveinek, illetve hiperlinkjeinek olyan táblázata, mely kereszthivatkozást teremt az Útmutató, a Referencia és a Szemantika dokumentum azon szekciói között, amelyek ugyanazt a nyelvi konstrukciót tárgyalják.

A B. függelék az OWL nyelvi konstrukciók RDF sémáját tartalmazza. Ez a séma információkat szolgáltat az OWL szókészletéről, és hasznos referenciapont lehet az ontológiaépítők és eszközfejlesztők számára. Azok a korlátozások, amelyeket az OWL osztályokkal és tulajdonságokkal kapcsolatban a séma közöl, csak informatív jellegűek, és nem teljesek. Továbbá, ez a séma nem tesz különbséget az OWL Full, az OWL DL és az OWL Lite között sem. A hagyományoknak megfelelően, az osztályok neveit nagy kezdőbetűvel, a tulajdonságokét pedig kis kezdőbetűvel írjuk. Így tehát az owl:Ontology egy osztály, míg az owl:imports egy tulajdonság.

MEGJEGYZÉS: Az OWL ontológiákban nem szükséges explicit módon importálni (az owl:imports segítségével) az RDF Séma fájlt. A séma itt informatív jellegű, és csak arra szolgál, hogy rendelkezésre bocsássa azokat az osztályokat és tulajdonságokat, amelyeket az RDF/XML szintaxis használ. Azok, akik mégis importálják ezt a sémát, számítsanak arra, hogy az ontológiájuk OWL Full ontológia lesz.

A C. függelék egy táblázatos áttekintés az OWL szókészletéről, mely a nyelvi elemeket két részre (beépített OWL osztályokra, illetve tulajdonságokra) bontja. A tulajdonságoknál az érvényességi kört és az értéktartományt is feltünteti.

Azon olvasók számára, akik ismerik a DAML+OIL nyelvet, a D. függelék felsorolja a DAML+OIL és az OWL közötti eltérések nagy részét.

És végül az E. függelék egy gyakorlati vezérfonalat ad az OWL DL-szintű ontológiák RDF-ben történő specifikálásához.

2. Az OWL dokumentum

2.1 Tartalom

Egy OWL dokumentum (tipikusan) egy opcionális ontológia-header-ből, plusz tetszőleges számú osztályaxiomából, tulajdonságaxiomából és egyeddel kapcsolatos tényállításból áll. Megjegyzendő, hogy az "axióma" egy formális kifejezés, amelyet a Szemantika (Sz&ASz) dokumentum használ. Az axiómákat kissé informálisabban "definícióknak" nevezzük az Útmutató és az Áttekintés dokumentumban.

MEGJEGYZÉS: Az OWL semmilyen módon nem korlátozza a komponensek sorrendjét az ontológián belül. Persze, mindig használunk valamilyen sorrendet (például az ontológia elejére tesszük a headert), de ennek nincs hatása a jelentésére. Az ontológiát feldolgozó eszközök sem tételezhetnek fel semmilyen kötött sorrendet.

Mint a legtöbb RDF dokumentumnál, az OWL-nál is minden elem az rdf:RDF elem alá van rendelve. Ez a befogadó elem tartalmazza általában az XML névterét és bázisdeklarációit is. Egy ontológiadokumentum is gyakran kezdődik egy sor entitásdeklarációval. Az ilyen típusú információra tipikus példát mutat be a Bor és az Étel ontológia, amelyet az [OWL Útmutató] tárgyal.

2.2 OWL URI szókészlet és névtér

Az OWL beépített szókészletét az OWL névtér

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

definiálja, mely konvencionálisan az owl névhez van kapcsolva. Ajánlatos, hogy az ontológiák ebből a (tágabb) névtérből kizárólag a beépített szókészletet használják. Az OWL eszközök fejlesztői tehát akkor járnak el helyesen, ha a programjukból figyelmeztető jelzést adnak, amikor a felhasználó más neveket is használ, de ezt követően a programnak normálisan tovább kell folytatnia a feldolgozást.

2.3 Az OWL MIME típusa

A Web Ontológia Munkacsoport nem igényelt külön MIME típust az OWL dokumentumok számára. Ehelyett az RDF Core Munkacsoport által igényelt MIME típus használatát ajánlja (nevezetesen az application/rdf+xml [lásd: RDF Fogalmak], vagy alternatívaként az application/xml MIME típust).

Fájlnév-kiterjesztésként az .rdf vagy az .owl kiterjesztést ajánlja a Munkacsoport.

3. Osztályok

Az osztályok olyan absztrakciós mechanizmusok, amelyek segítségével csoportosíthatjuk az azonos tulajdonságú erőforrásokat. Ugyanúgy, mint az RDF-nél, az OWL-nál is egy osztályhoz egyedek halmazát asszociáljuk, s ezt az osztály kiterjedésének nevezzük. Az osztály kiterjedését alkotó egyedeket (angolul: individuals) más szavakkal az osztály példányainak, eseteinek, vagy előfordulásainak is hívjuk (angolul: "instances"). Az osztály jelentése intenzionális (azaz absztrakt fogalmat takar), amely kapcsolatos ugyan, de nem azonos az osztály kiterjedésével (ami extenzionális, tehát konkrét jelentésű). Így tehát két osztálynak lehet ugyanaz a kiterjedése, mégis különböző osztályokat alkothatnak.

Amikor ebben a dokumentumban azt mondjuk, hogy "egyedek osztálya", ezt úgy értjük, hogy "egy osztály, amelynek az osztálykiterjedése egyedekből áll..."

MEGJEGYZÉS: Az OWL Lite-ban és az OWL DL-ben egy egyed nem lehet egyidejűleg osztály is: az egyedek és osztályok itt diszjunkt fogalmi kört alkotnak (miként a tulajdonságok és az adatértékek is). Ezzel szemben az OWL Full az RDF Sémáéhoz hasonló szabadságot biztosít: egy osztály felléphet egy másik (meta)osztály egyedeként is.

Az OWL osztályokat "osztályleírások" segítségével definiáljuk, amelyek "osztályaxiómákká" kombinálhatók. Az alábbiakban először az osztályleírásokat ismertetjük, majd pedig osztályaxiómákká alakításukat tárgyaljuk.

3.1 Osztályleírások

Ebben a dokumentumban (és az OWL Szemantika és absztrakt szintaxis dokumentumban is) osztályleírások alatt az osztályaxiómák alapvető építőköveit értjük. (Az osztályaxiómákat, kevésbé formálisan, osztálydefinícióknak hívjuk az Áttekintés és az Útmutató dokumentumban). Egy osztályleírás az osztályt a nevének, vagy a kiterjedésének a megadásával írja le. Az előbbi esetben nevesített, az utóbbi esetben névtelen osztályról beszélünk.

Az OWL hatféle osztályleírást különböztet meg:

1. Osztályazonosító (egy URI hivatkozás)
2. Felsorolás (azon egyedeknek a teljes felsorolása, amelyek az osztályt alkotják)
3. Tulajdonságkorlátozás
4. Metszet (két vagy több osztály kiterjedésének a halmazmetszete)
5. Unió (két vagy több osztályleírás halmazuniója)
6. Komplemens (egy osztályleírással megadott osztály egyedeinek komplementer halmaza)

Az első típus különleges abban az értelemben, hogy az osztályt pusztán az osztály nevével írja le (amit szintaktikailag egy URI hivatkozás ábrázol). A többi öt osztályleírás típus névtelen osztályt ír le, mégpedig oly módon, hogy korlátozásokat fogalmaz meg az osztály kiterjedésére (azaz a lehetséges egyedeire) vonatkozóan.

Az 2. típus olyan osztályt ír le, amelyik pontosan és kizárólag a felsorolt egyedekből áll. A 3. típus olyan osztályt határoz meg, amelynek az egyedei kielégítenek egy bizonyos tulajdonságkorlátozást. A 4., az 5. és a 6. típus olyan osztályt specifikál, mely más osztályleírások Boole-algebrai kombinációjának felel meg. (A metszet, az unió és a komplemens rendre az ÉS, VAGY, illetve a NEM operátornak felel meg.) Az utolsó négy osztályleírás egymásba skatulyázható, és így elvileg tetszőlegesen bonyolult osztályleírást alkothatnak. A gyakorlatban azonban az egymásba skatulyázható szintek számát általában korlátozzák.

Az 1. típusú osztályleírást szintaktikailag az owl:Class (az rdfs:Class: alosztálya) egy nevesített egyedének megadásával ábrázoljuk:

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

Ez a mondat az "ex:Human rdf:type owl:Class ." tripletet generálja, ahol ex: a Human fogalmat tartalmazó tématerület ontológiájának a névtere.

MEGJEGYZÉS: Az OWL Lite-ban és az OWL DL-ben az owl:Class (vagy a később ismertetendő owl:Restriction) elem keretében adjuk meg az összes osztályleírást.

MEGJEGYZÉS: Az owl:Class az rdfs:Class alosztályaként van definiálva. Annak az oka, hogy egy külön "OWL Class" konstrukciót használunk, az OWL DL és az OWL Lite korlátaiban keresendő. E korlátok miatt nem minden RDFS osztály legális OWL DL osztály is. Az OWL Full-ban ezek a korlátozások nem érvényesek, ezért ott az owl:Class és az rdfs:Class egyenértékű.

A másik öt osztályleírási forma RDF tripletek (gráf-elemek) halmazából áll, ahol egy üres csomópont az éppen definiált osztályt ábrázolja. Ennek az üres csomópontnak van egy rdf:type tulajdonsága, amelynek értéke az owl:Class.

MEGJEGYZÉS: Ha egy RDF azonosítóval látjuk el a felsorolás, a metszet, az unió vagy a komplemens típusú osztályleírást, akkor ezt már nem osztályleírásnak, hanem egy komplett osztályt definiáló osztályaxiómának tekintjük. A részleteket lásd a 3.2.3 szekcióban.

MEGJEGYZÉS: Ebben a dokumentumban a könnyebb olvashatóság kedvéért "osztályleírás"-t írunk, amikor azt akarjuk mondani, hogy "az osztály, amelyet az osztályleírással definiálunk". Szigorúan véve ez két különböző dolog a 2-6 típusú osztályleírások esetében: az osztályt a megfelelő üres csomópont ábrázolja; az osztály leírását pedig azok a tripletek ábrázolják, amelyeknek ez az üres csomópont az alanyuk.

Két OWL osztályazonosítót előre definiál a nyelv; nevezetesen az owl:Thing és az owl:Nothing azonosítót. Az owl:Thing osztálykiterjedése az összes egyedek halmaza, míg az owl:Nothing osztály kiterjedése az üres halmaz. Ebből az következik, hogy minden osztály az owl:Thing alosztálya, valamint az, hogy az owl:Nothing minden más osztálynak alosztálya. (Az alosztályreláció jelentését lásd az rdfs:subClassOf szekcióban.)

3.1.1 Felsorolás

A "Felsorolás" típusú osztályleírást az owl:oneOf tulajdonság segítségével adjuk meg. Ennek a beépített OWL tulajdonságnak az értékei azon egyedek listája, amelyek az osztályt alkotják. Ez lehetővé teszi, hogy egy osztályt definiálhassunk az egyedeinek a teljes felsorolásával. Az owl:oneOf segítségével leírt osztály kiterjedése pontosan a felsorolt egyedeket tartalmazza; sem többet, sem kevesebbet. Az egyedek listáját tipikusan az rdf:parseType="Collection" RDF konstrukcióval ábrázoljuk, mely kényelmes rövidítési lehetőségeket biztosít a listaelemek leírásához. Például, az alábbi RDF/XML szintaxis a kontinensek osztályát definiálja:

<owl:Class>
  <owl:oneOf rdf:parseType="Collection">
    <owl:Thing rdf:about="#Eurasia"/>
    <owl:Thing rdf:about="#Africa"/>
    <owl:Thing rdf:about="#NorthAmerica"/>
    <owl:Thing rdf:about="#SouthAmerica"/>
    <owl:Thing rdf:about="#Australia"/>
    <owl:Thing rdf:about="#Antarctica"/>
  </owl:oneOf>
</owl:Class>

Az <owl:Thing rdf:about="..."/> RDF/XML szintaxis valamilyen egyedre utal (emlékezzünk, hogy minden egyed automatikusan az owl:Thing osztály egyede).

Az adattípusokkal foglalkozó szekcióban látni fogjuk az owl:oneOf egy más célú használatát is, nevezetesen, amikor adatértékeket sorolunk fel a segítségével.

MEGJEGYZÉS: a "Felsorolás" elem az OWL Lite-ban nem használható.

3.1.2 Tulajdonságkorlátozás

A tulajdonságkorlátozás az osztályleírás speciális formája, mely egy névtelen osztályt ír le, nevezetesen: mindazon egyedek osztályát, amelyek megfelelnek az adott korlátozásnak. Az OWL a tulajdonságkorlátozások két típusát különbözteti meg: az értékkorlátozást és a kardinalitáskorlátozást.

Az értékkorlátozás valamely tulajdonság értéktartományát határozza meg az éppen leírt osztályra érvényes hatállyal. Például ennek segítségével hivatkozhatnánk azokra az egyedekre, amelyeknél a "szomszédosMegyéje" tulajdonság értéke valamilyen DunántúliMegye, majd pedig használhatnánk ezt a hivatkozást egy osztályaxiómán belül (akár még magán a DunántúliMegye osztályaxiómáján belül is). Figyeljük meg azonban, hogy ez az értékkorlátozás különbözik pl. az rdfs:range-től, mely mindenütt hatályos, ahol az általa korlátozott tulajdonságot használjuk.

A kardinalitáskorlátozás segítségével azt határozhatjuk meg az adott osztályleírás kontextusán belül (azaz lokális érvénnyel), hogy egy tulajdonság hány különböző értéket vehet fel. Például: megadhatnánk azt, hogy a Futballcsapat nevű osztály játékosa tulajdonságának 11 értéke lehet (pl. a 11 játékos neve). Egy kosárlabdacsapat esetén ugyanez a tulajdonság csak 5 értéket vehetne fel.

Az OWL támogat egy korlátozott számú olyan konstrukciót is, nevezetesen az owl:FunctionalProperty és az owl:InverseFunctionalProperty konstrukciót, amelyek globális érvénnyel korlátozzák a tulajdonságok kardinalitását (lásd a tulajdonságokról szóló szekcióban).

A tulajdonságkorlátozások általános formája a következőképpen néz ki:

<owl:Restriction>
  <owl:onProperty rdf:resource="(valamilyen tulajdonság)" />
  (egy érték- vagy egy kardinalitáskorlátozás, lásd alább)
</owl:Restriction>

Az owl:Restriction (Korlátozás) osztályt az owl:Class alosztályaként definiálták. Egy Restriction osztálynak van egy, és csak egy olyan tripletje, mely a korlátozást egy tulajdonsághoz kapcsolja az owl:onProperty tulajdonság segítségével. És van egy, és csak egy olyan tripletje, mely az értékkorlátot vagy a kardinalitáskorlátot reprezentálja az adott tulajdonságra vonatkoztatva (pl. azt, hogy a tulajdonság kardinalitása pontosan 1).

Tulajdonságkorlátozásokat alkalmazhatunk adattípus-tulajdonságokra (amelyek értéke literál típusú) valamint objektumtulajdonságokra (amelyek értéke egyed típusú). E megkülönböztetéssel kapcsolatban lásd a tulajdonságokról szóló szekciót.

3.1.2.1 Értékkorlátozások

3.1.2.1.1 owl:allValuesFrom

Az owl:allValuesFrom értékkorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy osztályleíráshoz vagy egy adatérték-tartományhoz kapcsol. Az owl:allValuesFrom (~mindenÉrtéke) állítmányt tartalmazó korlátozást azon egyedek osztályának leírására használjuk, amelyek számára az éppen korlátozott tulajdonság minden értéke: vagy az osztályleírás kiterjedésének a tagja, vagy pedig olyan adatérték, mely egy (literálisan megadott) értéktartományon belül helyezkedik el. Másként kifejezve: ez az értékkorlátozás olyan X egyedek osztályát definiálja, amelyekre érvényes, hogy, ha az (X,Y) alany-tárgy páros az éppen korlátozott P tulajdonság (állítmány) egyik előfordulása, akkor Y vagy az osztályleírás egyik egyede, vagy egy adatérték-tartomány egyik adatértéke.

Egy egyszerű példa:

<owl:Restriction>
  <owl:onProperty rdf:resource="#hasParent" />
  <owl:allValuesFrom rdf:resource="#Human"  />
</owl:Restriction>

Ez a példa azon egyedek névtelen osztályát írja le, amelyek esetében a hasParent(szülője) tulajdonság csak a Human (Ember) osztály egyede lehet. Jegyezzük meg, hogy ez az osztályleírás nem azt mondja ki, hogy ez a tulajdonság mindig ebből az osztályból kaphat csak értéket, hanem azt, hogy ez a megkötés csak a névtelen korlátozásosztály kiterjedésére vonatkoztatva érvényes.

MEGJEGYZÉS: Az OWL Lite-ban az owl:allValuesFrom állítmány tárgyaként megadott osztályleírás-típus csak egy osztálynév lehet.

Az owl:allValuesFrom korlátozás jelentése lényegében azonos az ítéletkalkulus univerzális kvantorának jelentésével ("minden elemre igaz"), minthogy a leírt osztály minden egyedére igaz, hogy P tulajdonság minden értékének ki kell elégítenie a megkötést. Vegyük észre azt is, hogy az owl:allValuesFrom és az univerzális kvantor abban is megfelelnek egymásnak, hogy a P tulajdonság értékeire bevezetett owl:allValuesFrom korlátozást egy olyan egyed is triviális módon kielégíti, amelyiknek egyáltalán nincs értéke P-re. Hogy lássuk, miért van ez így, vegyük észre, hogy az owl:allValuesFrom korlátozás azt köti ki, hogy P minden értéke T típusú legyen. Ha tehát nem létezik ilyen érték, akkor a korlátozás eleve megvalósul.

3.1.2.1.2 owl:someValuesFrom

Az owl:someValuesFrom értékkorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy osztályleíráshoz vagy egy adatérték-tartományhoz kapcsol. Az owl:someValuesFrom (~néhányÉrtéke) megkötést tartalmazó korlátozás azon egyedek osztályát írja le, amelyek számára az éppen korlátozott tulajdonságnak legalább egy értéke az osztályleírás egyede, vagy egy adatérték-tartomány valamelyik értéke. Másként fogalmazva: ez az értékkorlátozás olyan X egyedek osztályát definiálja, amelyek számára létezik egy olyan Y (az osztályleírás egyik egyede, vagy egy értéktartomány egyik értéke) amelynél az (X,Y) pár a P tulajdonság egyik előfordulása. Ez a megkötés nem zárja ki azonban, hogy P-nek lehetnek más olyan (pl. X,Y') előfordulásai, amelyeknél Y' nem tartozik az adott osztályleíráshoz vagy adatérték-tartományhoz.

Az alábbi példa olyan egyedek osztályát definiálja, amelyeknek legalább egyik "szülője" (hasParent) "Orvos" (Physician):

<owl:Restriction>
  <owl:onProperty rdf:resource="#hasParent" />
  <owl:someValuesFrom rdf:resource="#Physician" />
</owl:Restriction>

Az owl:someValuesFrom korlátozás lényegében azonos az ítéletkalkulus egzisztenciális kvantorával, mivel azt köti ki az éppen definiált osztály minden egyedének P tulajdonságára, hogy "létezzék legalább egy" olyan értéke, mely kielégíti a korlátozást.

MEGJEGYZÉS: Az OWL Lite-ban az owl:someValuesFrom állítmány tárgyaként megadott osztályleírás-típus csak egy osztálynév lehet.

3.1.2.1.3 owl:hasValue

Az owl:hasValue értékkorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy olyan V értékhez kapcsol, amelyik vagy egy egyed, vagy egy adatérték. Az owl:hasValue értékkorlátozás tehát azon egyedek osztályát írja le, amelyek számára az éppen korlátozott tulajdonságnak van legalább egy olyan értéke, amelyik szemantikailag egyenlő V-vel (de emellett lehetnek más értékei is).

MEGJEGYZÉS: Az, hogy "szemantikailag egyenlő", adattípusok esetében azt jelenti, hogy a két adat lexikai ábrázolásának gépi nyelvre történő lefordítása ugyanazt az értéket adja. Egyedek esetében pedig azt jelenti, hogy vagy azonos az URI hivatkozásuk, vagy különböző ugyan, de ezeket előzőleg azonosnak deklaráltuk (lásd: owl:sameAs).

MEGJEGYZÉS: az owl:hasValue értékkorlátozás nem használható az OWL Lite-ban.

Az alábbi példa azon egyének osztályát írja le, akiknél a "szülője" tulajdonság értéke: Clinton.

<owl:Restriction>
  <owl:onProperty rdf:resource="#hasParent" />
  <owl:hasValue rdf:resource="#Clinton" />
</owl:Restriction>

3.1.2.2 Kardinalitáskorlátozások

Az OWL-ban az RDF-hez hasonlóan feltételezzük, hogy egy osztály bármelyik egyedének tetszőleges számú (zéró, egy vagy több) értéke lehet egy adott tulajdonságára. Annak érdekében, hogy egy adott osztály egyedei számára egy tulajdonságot feltétlenül szükségesnek deklarálhassunk (azaz megkövetelhessük, hogy az legalább egy értékkel rendelkezzék), vagy hogy egy tulajdonságot kitilthassunk (azaz kiköthessük, hogy a tulajdonság legfeljebb zéró számú értékkel rendelkezhet), vagy hogy előírhassuk, hogy egy tulajdonság pontosan hány értéket vehet fel, kardinalitáskorlátozást alkalmazunk. Az OWL-ban három konstrukció áll rendelkezésre a tulajdonságok kardinalitásának helyi, azaz osztályra érvényes korlátozására.

Megjegyzés: Az OWL Lite tartalmazza a kardinalitás korlátozásának mind a három típusát, de a kardinalitás értéke itt csak 0 vagy 1 lehet.

3.1.2.2.1 owl:maxCardinality

Az owl:maxCardinality típusú kardinalitáskorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy olyan adatértékhez kapcsol, mely az XML Séma nonNegativeInteger értékterébe tartozik. Egy owl:maxCardinality megkötést tartalmazó korlátozás azon egyedek osztályát írja le, amelyeknek az éppen korlátozandó tulajdonsága legfeljebb N számú, szemantikailag különböző értéket (egyedet vagy adatértéket) kaphat, ahol N a kardinalitáskorlát értéke. Szintaktikailag a kardinalitáskorlátozást egy RDF tulajdonságelemmel, és a hozzá tartozó rdf:datatype attribútummal ábrázoljuk.

Az alábbi példa olyan egyedek osztályát írja le, amelyeknek legfeljebb két szülőjük lehet:

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

Az RDF adattípusainak használatát részletesebben a 6. szekció tárgyalja.

3.1.2.2.2 owl:minCardinality

Az owl:minCardinality típusú kardinalitáskorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy olyan adatértékhez kapcsol, mely az XML Séma nonNegativeInteger értékterébe tartozik. Egy owl:minCardinality megkötést tartalmazó korlátozás azon egyedek osztályát írja le, amelyeknek az éppen korlátozandó tulajdonsága legalább N számú, szemantikailag különböző értéket (egyedet vagy adatértéket) kell kapnia, ahol N a kardinalitáskorlát értéke. Szintaktikailag a kardinalitáskorlátozást egy RDF tulajdonságelemmel, és a hozzá tartozó rdf:datatype attribútummal ábrázoljuk.

Az alábbi példa olyan egyedek osztályát írja le, amelyeknek legalább két szülőjük van:

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

Jegyezzük meg, hogy ha az owl:minCardinality értéke nagyobb vagy egyenlő eggyel, az egyben azt is jelenti, hogy az adott osztály egyedeinél ez a tulajdonság feltétlenül értéket kell hogy kapjon.

3.1.2.2.3 owl:cardinality

Az owl:Cardinality típusú kardinalitáskorlátozás egy beépített OWL tulajdonság, mely egy korlátozásosztályt egy olyan adatértékhez kapcsol, mely az XML Séma nonNegativeInteger értékterébe tartozik. Egy owl:Cardinality megkötést tartalmazó korlátozás azon egyedek osztályát írja le, amelyeknek az éppen korlátozandó tulajdonsága pontosan N számú, szemantikailag különböző értéket (egyedet vagy adatértéket) kell kapnia, ahol N a kardinalitáskorlát értéke. Szintaktikailag a kardinalitáskorlátozást egy RDF tulajdonságelemmel, és a hozzá tartozó rdf:datatype attribútummal ábrázoljuk.

Ez a konstrukció tulajdonképpen redundáns, hiszen bármikor helyettesíthető egy owl:minCardinality és egy owl:maxCardinality korlátozásból álló párral úgy, hogy mindkettőnek azonos értéket adunk. Ezt a korlátozástípust csak a kényelem és a tömörebb írásmód érdekében vették fel a nyelvbe.

Az alábbi példa olyan egyedek osztályát írja le, amelyeknek pontosan két szülőjük lehet:

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

3.1.3 Metszet, unió és komplemens

Az ebben a szekcióban tárgyalt három osztályleírás-típus azokat a fejlettebb osztálykonstruktorokat reprezentálja, amelyeket a leíró logikában használnak. Ezeket úgy is tekinthetjük, mint osztályokra alkalmazott ÉS, VAGY és NEM műveleteket. Ez a három művelet a halmazoperátorok szokásos neveit viseli: metszet, unió és komplemens. Ezek a nyelvi konstrukciók abban hasonlítanak egymásra, hogy egymásba ágyazott osztályleírásokat tartalmaznak: vagy egyet (mint a komplemens esetén), vagy pedig többet (mint az unió és a metszet esetén).

3.1.3.1 owl:intersectionOf

Az owl:intersectionOf egy beépített OWL tulajdonság, mely egy osztályt kapcsol egy osztályleírás-listához. Az owl:intersectionOf konstrukció egy olyan osztályt ír le, amelynek a kiterjedése pontosan azokból az egyedekből áll, amelyek a listában szereplő minden osztályleírás kiterjedésben benne vannak.

Példa:

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

Ebben a példában az owl:intersectionOf tulajdonság értéke két osztályleírás: nevezetesen két felsorálás típusú osztályleírás, amelyek mindegyike két-két egyedet tartalmaz. Az eredményül kapott metszet pedig egy olyan osztály, mely egyetlen egyedet tartalmaz, nevezetesen a Tosca-t, minthogy ez az egyetlen olyan egyed, amelyik közös a két felsorolásban.

MEGJEGYZÉS: Ez feltételezi, hogy a három egyed mind különböző. Az OWL-ban azonban ez nem magától értetődően van így. Ugyanis, különböző URI hivatkozások mutathatnak ugyanarra az egyedre, lévén, hogy az OWL nem feltételez egyedi neveket. Az 5. szekcióban olyan nyelvi konstrukciókat találhat az olvasó, amelyekkel egyedek egyenlőségét és különbözőségét deklarálhatjuk.

MEGJEGYZÉS: Ebben a példában történetesen most csak felsorolásokat használtunk, hogy átláthatóvá tegyük ennek a nyelvi konstrukciónak a jelentését. Életszerűbb példákat találhat azonban az olvasó az [OWL Útmutató] dokumentumban.

MEGJEGYZÉS: Az OWL Lite-nak vannak bizonyos korlátai az owl:intersectionOf használatában. A 3.2.3 szekcióban később még szólunk erről.

Az owl:intersectionOf a konjunkció (logikai ÉS) műveletnek felel meg.

3.1.3.2 owl:unionOf

Az owl:unionOf egy beépített OWL tulajdonság, mely egy osztályt kapcsol egy osztályleírás-listához. Az owl:unionOf konstrukció egy olyan osztályt ír le, amelynek a kiterjedése pontosan azokból az egyedekből áll, amelyek a listában szereplő osztályleírások kiterjedéseinek legalább egyikében szerepelnek.

Példa:

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

Ez az osztályleírás egy olyan osztályt ír le, amelynek a kiterjedése három egyedet tartalmaz, nevezetesen a Tosca, Salome, és Turandot egyedet (feltételezve, hogy ezek mind különbözőek).

MEGJEGYZÉS: az owl:unionOf nem használható az OWL Lite-ban.

Az owl:unionOf a diszjunkció (logikai VAGY) műveletnek felel meg.

3.1.3.3 owl:complementOf

Az owl:complementOf beépített OWL tulajdonság egy osztályt és egy osztályleírást kapcsol össze. Az owl:complementOf konstrukció egy olyan osztályt ír le, amelynek a kiterjedése pontosan azokból az egyedekből áll, amelyek nem tartoznak annak az osztályleírásnak a kiterjedéséhez, amelyet a kijelentés tárgyaként adunk meg. Az owl:complementOf a negáció (logikai NEM) műveletnek felel meg, hiszen azon egyedeket adja eredményül, amelyek NEM tartoznak a tárgyban megnevezett osztályhoz.

Jó példa lehet a komplementer osztályra a "not meat" (nem hús) osztály, amelynek leírását az alábbi kódrészlet mutatja be:

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

Ennek az osztályleírásnak a kiterjedése mindazon egyedeket tartalmazza, amelyek nem tartoznak a Meat (Hús) osztályhoz.

MEGJEGYZÉS: az owl:complementOf nem használható az OWL Lite-ban.

3.2 Osztályaxiomák

Az osztályleírások alkotják azokat az építőköveket, amelyekből osztályaxiómák segítségével osztályokat definálhatunk. Az osztályaxiómák legegyszerűbb formája az első típusú osztályleírás, mely csupán az osztály létét és azonosító nevét deklarálja az owl:Class konstruktor segítségével.

Az alábbi példa egy osztályaxiómát ábrázol, amelyben egy OWL osztályt a "Human" névvel azonosítunk [itt, az eredeti angol szövegben nem kompatibilis a példa és a magyarázata, ezért a magyarázatot értelemszerűen módosítottuk – a ford.]:

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

Ez egy teljesen szabályos OWL mondat, de nem sokat árul el nekünk a Human osztályról. Az osztályaxiómák általában további komponenseket is tartalmaznak, amelyek megadják egy osztály szükséges és/vagy elégséges jellemzőit. Az OWL három olyan nyelvi konstrukciót tartalmaz, amelyekkel az osztályleírások osztályaxiómákká kombinálhatók:

• Az rdfs:subClassOf segítségével azt jelenthetjük ki, hogy egy osztályleírás kiterjedése egy másik osztályleírás kiterjedésének a részhalmaza.
• Az owl:equivalentClass útján azt mondhatjuk ki, hogy egy osztályleírás kiterjedése azonos egy másik osztályleírás kiterjedésével.
• Az owl:disjointWith használatával azt deklarálhatjuk, hogy egy osztályleírás kiterjedésében nincs egyetlen olyan egyed sem, mely egy másik megadott osztályleírás kiterjedésében is szerepel (azaz nincsenek közös egyedeik).

Szintaktikailag ezek a nyelvi konstrukciók olyan tulajdonságok, amelyeknek az érvényességi köre és az értéktartománya is osztályleírás. (Az alábbi alszekciókban részletesen tárgyaljuk ezeket a tulajdonságokat).

Az OWL megenged olyan osztályaxiómákat is, amelyekben a felsorolás típusú és a halmazoperátoros típusú osztályleírásoknak nevet adunk. Az ilyen osztályaxiómák szemantikailag egyenértékűek azokkal az osztályaxiómákkal, amelyekben az owl:equivalentClass állítmányt használjuk. Erre később még visszatérünk a 3.2.3 Axiómák komplett osztályokhoz owl:equivalentClass használata nélkül című szekcióban).

3.2.1 rdfs:subClassOf

AZ AXIÓMA SÉMÁJA: osztályleírás rdfs:subClassOf osztályleírás

Az rdfs:subClassOf konstrukciót az RDF Séma [RDF Szókészlet] részeként definiálták, de a jelentése az OWL-ban is pontosan ugyanaz: ha a C1 osztályleírást a C2 osztályleírás alosztályának definiáltuk, akkor akkor a C1 osztálykiterjedését alkotó egyedek halmaza a C2 osztálykiterjedését alkotó egyedek halmazának a részhalmaza kell hogy legyen. Egy osztály, értelemszerűen, egyben önmagának a részhalmaza is (minthogy egy teljes halmaz is lehet részhalmaz).

Példa:

<owl:Class rdf:ID="Opera">
  <rdfs:subClassOf rdf:resource="#MusicalWork" />
</owl:Class>

Ez az osztályaxióma egy "alosztály" viszonyt deklarált két olyan OWL osztály között, amelyek a nevükkel vannak leírva. Ez a két osztály az Opera és a MusicalWork (Opera, illetve Zenemű). Az alosztályreláció biztosítja a szükséges feltételt ahhoz, hogy egy osztályhoz tartozást deklaráljon. A példából látható: ahhoz, hogy valami Opera legyen, Zeneműnek kell lennie.

Megjegyzés: Az OWL Lite-ban az rdfs:subClassOf kijelentés alanyának osztályazonosítónak kell lennie, a tárgya pedig osztályazonosító vagy tulajdonságkorlátozás lehet.

Egyetlen osztály számára tetszőleges számú subClassOf axiómát adhatunk meg. Az Opera osztályra például megadhatjuk az alábbi axiómát:

<owl:Class rdf:about="#Opera">
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#hasLibrettist" />
      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
</owl:Class>

Ez az osztályaxióma egy tulajdonságkorlátozást tartalmaz. Lévén, hogy az owl:Restriction egy beépített OWL osztály (az owl:Class alosztálya), a fenti példában azt jelentjük ki, hogy az Opera egy olyan névtelen OWL osztálynak az alosztálya, amelynek kiterjedése azon egyedek halmaza, amelyek hasLibrettist tulajdonsága legalább egy értékkel rendelkezik. Ez tömören azt akarja kifejezni, hogy az opera olyan valami, aminek legalább egy szövegkönyvírója van.

Az osztályaxiómák bonyolultabbakká válhatnak, ha az osztályleírások egymásba ágyazódnak. Például: az olyan típusú tulajdonságkorlátozások, amelyek owl:allValuesFrom vagy owl:someValuesFrom állítmányt tartalmaznak, bármilyen osztályleírásra mutathatnak. Figyeljük meg az alábbi példát:

<owl:Class rdf:ID="TraditionalItalianOpera">
  <rdfs:subClassOf rdf:resource="#Opera"/>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#hasOperaType"/>
      <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>

Ez a példa egyebek közt bemutatja az owl:oneOf konstrukció használatát. A példabeli osztályaxióma a hagyományos olasz operát az operák olyan alosztályaként definiálja, amelyek "operaTípusa" vagy KomolyOpera vagy Vígopera. (Ha nem alkalmazunk külön kardinalitáskorlátozást, akkor az "operaTípusa" tulajdonság mindkét értéket megkaphatja). További példák találhatók az [OWL Útmutató] dokumentumban.

Az alosztály-axiómák csak részbeni definíciókat szolgáltatnak, ugyanis ezek csak a szükséges, de nem az elégséges feltételt biztosítják ahhoz, hogy valamely egyed osztálytagságát egyértelműen megállapíthassuk. A következő alszekcióban látni fogjuk, hogy a szükséges és elégséges feltétel definiálásához az OWL rendelkezik egy owl:equivalentClass konstrukcióval. Ugródeszkaként az ilyen axiómákhoz, tekintsük a következő példát:

<owl:Class rdf:ID="Operetta">
  <rdfs:subClassOf rdf:resource="#MusicalWork"/>
  <rdfs:subClassOf>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#hasLibrettist" />
      <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
    </owl:Restriction>
  </rdfs:subClassOf>
  <rdfs:subClassOf>
    <owl:Class>
      <owl:complementOf rdf:resource="#Opera"/>
    </owl:Class>
  </rdfs:subClassOf> 
</owl:Class>

Ez az osztályaxióma úgy definiálja az Operettet, hogy az egy Zenemű, amelynek legalább egy szövegkönyvírója van, de nem Opera. Az "alosztály" reláció használata nyitva hagyja azt a lehetőséget, hogy vannak más zeneművek is, amelyeknek van egy szövegkönyvírójuk, és nem operák. Ha azt akarnánk mondani, hogy az operettek pontosan és kizárólag azok a zeneművek, amelyeknek van szövegkönyvírójuk, de nem operák, akkor szükségünk lenne az owl:equivalentClass konstrukcióra is.

3.2.2 owl:equivalentClass

AZ AXIÓMA SÉMÁJA: osztályleírás owl:equivalentClass osztályleírás

Egy osztályaxióma több owl:equivalentClass állítást is tartalmazhat. Az owl:equivalentClass egy beépített tulajdonság, mely egy osztályleírást egy másik osztályleíráshoz kapcsol. Az ilyen osztályaxióma jelentése az, hogy a benne szereplő két osztályleírásnak ugyanaz a kiterjedése (vagyis, hogy pontosan ugyanazokat az egyedeket tartalmazza).

Az equivalentClass típusú axióma legegyszerűbb formája az, amikor két nevesített osztály között deklarál (a kiterjedésükre vonatkozóan) egyenértékűséget. Egy példa erre:

<owl:Class rdf:about="#AzEgyesültÁllamokElnöke">
  <equivalentClass rdf:resource="#AFehérHázLegfontosabbLakója"/>
</owl:Class>

MEGJEGYZÉS: Az owl:equivalentClass kifejezés nem jelenti két osztály egyenlőségét. Két osztály egyenlősége ugyanis azt jelenti, hogy azonos az intenzionális jelentésük (ugyanazt a fogalmat jelölik). A fenti példában az "Egyesült Államok elnöke" fogalom összefügg ugyan azzal a fogalommal, hogy a "Fehér Ház legfontosabb lakója", de nem egyenlő vele. Egy állam elnökének a fogalma, és az a fogalom, hogy valaki egy bizonyos épület legfontosabb lakója, nem lehet azonos. (Itt csupán az a két egyed azonos, aki a fenti példában szereplő két, egyfős osztálynak a közös tagja: az elnök személye). A tényleges osztályazonosságot csak az owl:sameAs konstrukcióval tudjuk deklarálni. Minthogy azonban ez azt igényli, hogy osztályokat egyedként is kezelhessünk, az ilyen egyenlőséget csak az OWL Full-ban tudjuk kifejezni.

Az owl:equivalentClass segítségével felépített axióma alkalmas felsorolásosztályok definiálására is oly módon, hogy egy 1. típusú osztályleírást (osztályazonosítót) egy 2. típusú osztályleíráshoz (felsoroláshoz) kapcsol. Egy példa erre:

<owl:Class rdf:ID="DaPonteOperaOfMozart">
  <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>

Ez az axióma olyan operák osztályát definiálja DaPonteOperaOfMozart néven, amelyek szövegírója Da Ponte, zeneszerzője pedig Mozart (ez a zenetudomány egyik érdekes témája). Az equivalentClass konstrukcióval meg tudjuk adni a fenti osztályhoz való tartozás szükséges és elegendő feltételeit, amit ebben az esetben a három tényleges egyed egyszerű felsorolása reprezentál.

MEGJEGYZÉS: Az OWL DL semmilyen módon nem korlátozza azoknak az osztályleírásoknak a típusát, amelyek egy owl:equivalentClass kijelentés alanyai, illetve tárgyai lehetnek. Az OWL Lite-ban azonban az alanynak osztálynévnek kell lennie, a tárgy pedig lehet akár osztálynév, akár tulajdonságkorlátozás.

MEGJEGYZÉS: Habár egy equivalentClass alanyaként tulajdonképpen különböző típusú osztályleírások is megadhatók, a gyakorlatban ez általában egy osztályazonosító szokott lenni. Ez a jelen szekció példáira is is jellemző.

Egy osztály definiálásában alkalmazhatunk több equivalentClass típusú osztályaxiómát is. Ilyenkor azonban vigyázni kell! Mindegyik axiómának ugyanazt a végeredményt (ugyanazt a kiterjedést) kell produkálnia. Például, a Mozart Da Ponte operáit leíró alternatív equivalentClass axióma az alábbi is lehetne:

<owl:Class rdf:about="#DaPonteOperaOfMozart">
  <owl:equivalentClass>
    <owl:Class>
      <owl:intersectionOf rdf:parseType="Collection">
        <owl:Restriction>
          <owl:onProperty rdf:resource="#hasComposer"/>
          <owl:hasValue rdf:resource="#Wolfgang_Amadeus_Mozart"/>
        </owl:Restriction>
        <owl:Restriction>
          <owl:onProperty rdf:resource="#hasLibrettist"/>
          <owl:hasValue rdf:resource="#Lorenzo_Da_Ponte"/>
        </owl:Restriction>
      </owl:intersectionOf>
    </owl:Class>
  </owl:equivalentClass>
</owl:Class>

Ez az axióma azt állapítja meg, hogy a DaPonteOperaOfMozart osztály kiterjedése pontosan azokból az operákból áll, amelyek komponistája Mozart, és a szövegírója Lorenzo Da Ponte (intersection = metszet = ÉS). Ez az axióma tehát egy olyan osztályt definiál, amelynek ugyanazok az egyedei, mint az előző példában szereplő osztályé.

MEGJEGYZÉS: Ha az "A subClassOf B" típusú axiómát egy "A equivalentClass B" típusú axiómává kívánnánk "feljavítani" (ami azt mondaná ki, hogy A kiterjedése nem akármilyen részhalmaz, hanem B kiterjedésével azonos halmaz), akkor kiegészíthetnénk egy második axiómával (ezúttal "B subClassOf A" formában), mely együtt, a két osztályt értelemszerűen egyenértékűvé tenné (vagyis ugyanazt jelentené, mint "A equivalentClass B"). A nyelv explicite lehetővé teszi ilyen kölcsönös alosztályrelációk alkalmazását. Minthogy az OWL elosztott környezetben is használható, ez egy nagyon hasznos opció lehet.

3.2.3 Axiómák komplett osztályokhoz owl:equivalentClass használata nélkül

AZ AXIÓMA SÉMÁJA: Egy 2. típusú nevesített osztályleírás (owl:oneOf állítmánnyal), vagy pedig egy 4-6. típusú nevesített osztályleírás (owl:intersectionOf, owl:unionOf vagy owl:complementOf állítmánnyal).

Az OWL lehetővé teszi, hogy a felhasználó egy osztályaxiómát definiáljon úgy, hogy osztálynevet rendel egy felsorolás típusú vagy egy halmazművelet típusú osztályleíráshoz. Az ilyen osztályaxióma szükséges és elegendő feltételt biztosít az osztályhoz tartozás megállapítására. Egy korábbról kissé már ismert példa erre:

<owl:Class rdf:ID="DaPonteOperaOfMozart">
  <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>

Ezt az osztályaxiómát úgy kell értelmeznünk, hogy a DaPonteOperaOfMozart osztály kiterjedését pontosan és véglegesen definiálja a megadott felsorolás.

Ez az osztályaxióma szemantikailag egyenértékű az előző szekció első opera példájával, amelyik még egy owl:equivalentClass állítmányt is tartalmazott. Ilyen axiómát az owl:intersectionOf, az owl:unionOf és az owl:complementOfállítmánnyal is előállíthatunk. Egy példa az unió alkalmazásával:

<owl:Class rdf:ID="LivingBeing">
  <owl:unionOf rdf:parseType="Collection">
    <owl:Class rdf:about="#Plant"/>
    <owl:Class rdf:about="#Animal"/>
  </owl:unionOf>
</owl:Class>

Ez az osztályaxióma azt jelenti ki, hogy az Élőlény (LivingBeing) osztály kiterjedése megegyezik a Növény és az Állat (Plant és Animal) osztály kiterjedésének uniójával.

MEGJEGYZÉS: Az OWL Lite csak ilyen típusú osztályaxiómákat ismer, amelyeket az owl:intersectionOf tulajdonsággal konstruálunk. Itt az intersectionOf listájának értékei csak osztályazonosítók és/vagy tulajdonságkorlátozások lehetnek. Így tehát komplett osztályt definiáló axiómák (mint a felsorolás, a komplemens és az unió) az OWL Lite-ban nem alkalmazhatók.

3.2.4 owl:disjointWith

AZ AXIÓMA SÉMÁJA: class description owl:disjointWith class description

Egy osztályaxióma (több) owl:disjointWith (diszjunkt/idegen osztály) állítást tartalmazhat. Az owl:disjointWith egy beépített tulajdonság, amelynek érvényességi köre és értéktartománya egy-egy osztályleírás. Minden egyes owl:disjointWith állítmány azt jelenti ki, hogy az állításban szereplő két osztályleírás kiterjedésében nincsenek közös egyedek. Ugyanúgy, mint egy "alosztály" viszony deklarálása (rdfs:subClassOf), a "diszjunkt" viszony deklarálása (owl:disjointWith) is csak parciális definíciót eredményez. Ez is csak a szükséges, de nem az elégséges feltételt szolgáltatja az osztályhoz tartozás megállapításához.

Egy népszerű példa diszjunkt osztályokra:

<owl:Class rdf:about="#Man">
  <owl:disjointWith rdf:resource="#Woman"/>
</owl:Class>

Hogy ez az állítás ténylegesen igaz-e, annak eldöntése a biológusokra tartozik. A következő példa alosztály-hierarchiákon mutatja be a diszjunktivitás egyszerű alkalmazását:

<owl:Class rdf:about="#MusicDrama">
  <owl:equivalentClass>
    <owl:Class>
      <owl:unionOf rdf:parseType="Collection">
        <owl:Class rdf:about="#Opera"/>
        <owl:Class rdf:about="#Operetta"/>
        <owl:Class rdf:about="#Musical"/>
      </owl:unionOf>
    </owl:Class>
  </owl:equivalentClass>
</owl:Class>

<owl:Class rdf:about="#Opera">
  <rdfs:subClassOf rdf:resource="#MusicDrama"/>
</owl:Class>

<owl:Class rdf:about="#Operetta">
  <rdfs:subClassOf rdf:resource="#MusicDrama"/>
  <owl:disjointWith rdf:resource="#Opera"/>
</owl:Class>

<owl:Class rdf:about="#Musical">
  <rdfs:subClassOf rdf:resource="#MusicDrama"/>
  <owl:disjointWith rdf:resource="#Opera"/>
  <owl:disjointWith rdf:resource="#Operetta"/>
</owl:Class>

Itt az owl:disjointWith állítást a owl:unionOf állítással együtt használtuk annak érdekében, hogy definiálhassuk egy főosztály kölcsönösen diszjunkt és komplett alosztályait. Természetes nyelven fogalmazva, itt azt mondtuk ki: miden Zenedráma vagy Opera, vagy Operett, vagy Musical (az osztályok szétválasztása teljes), és hogy azok az egyedek, amelyek az egyik alosztályhoz (pl. Opera) tartoznak, nem tartozhatnak más alosztályhoz is (mint pl. Musical), vagyis, ezek diszjunkt, nem átfedő alosztályok. Ez egy általánosan ismert modellezési fogalom, amelyet sok adatmodellező nyelvben alkalmaznak.

MEGJEGYZÉS: Az OWL Lite nem engedélyezi az owl:disjointWith használatát.

4. Tulajdonságok

Az OWL a tulajdonságok két kategóriáját különbözteti meg, amelyeket az ontológiafejlesztő használhat:

• Objektumtulajdonságok, amelyek egyedeket kapcsolnak egyedekhez.
• Adattípus-tulajdonságok, amelyek egyedeket kapcsolnak adatértékekhez.

MEGJEGYZÉS: Az OWL használ olyan fogalmakat is, mint annotációtulajdonság (owl:AnnotationProperty) és ontológiatulajdonság (owl:OntologyProperty). Ezeket az OWL DL igényli, szemantikai okokból. Lásd a 7. szekcióban, valamint az OWL Szemantika és absztrakt szintaxis [OWL Sz&ASz] dokumentumban.

Egy objektumtulajdonságot az owl:ObjectProperty nevű beépített OWL osztály tagjaként, egy adattípus-tulajdonságot pedig az owl:DatatypeProperty tagjaként definiálhatunk. Mind az owl:ObjectProperty, mind az owl:DatatypeProperty az rdf:Property nevű RDF osztály tagja (lásd a B. függelékben).

MEGJEGYZÉS: Az OWL Full-ban az objektumtulajdonságok és az adattípus-tulajdonságok nem alkotnak diszjunkt halmazokat. Mivel itt az adatértékek egyedként kezelhetők, az adattípus-tulajdonság lényegében az objektumtulajdonság alosztályaként funkcionál. Az OWL Full-ban az owl:ObjectProperty gyakorlatilag egyenértékű az rdf:Property-vel; ez főleg az owl:InverseFunctionalProperty használata esetén jár következményekkel. Lásd az OWL Full jellemzését a 8.1 szekcióban.

Egy tulajdonságaxióma egy tulajdonság jellemzőit definiálja. A tulajdonságaxióma a legegyszerűbb formájában csupán a tulajdonság létét definiálja. Például:

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

Ez a példa egy tulajdonságot definiál azzal a kikötéssel, hogy annak értékei csak osztályok egyedei lehetnek.

A tulajdonságaxiómák azonban többnyire egyéb jellemzőket is megadnak a tulajdonságok leírásánál. Az OWL az alábbi konstruktorokat nyújtja a tulajdonságaxiómák definiálásához:

• RDF Séma konstrukció: rdfs:subPropertyOf, rdfs:domain és rdfs:range
• Más tulajdonságokhoz való viszony: owl:equivalentProperty és owl:inverseOf
• Globális kardinalitáskorlátozás: owl:FunctionalProperty és owl:InverseFunctionalProperty
• Logikai tulajdonságjellemzők: owl:SymmetricProperty és owl:TransitiveProperty

Az alábbi alszekciókban részletesen tárgyaljuk a különféle tulajdonságaxiómákat.

MEGJEGYZÉS: Ebben a szekcióban az "osztálykiterjedés" fogalmához hasonlóan használjuk a "tulajdonságkiterjedés" fogalmát. A tulajdonság kiterjedése a tulajdonság azon eseteinek (előfordulásainak) a halmaza, amelyek a tulajdonsághoz kapcsolódnak. Egy tulajdonság esetei nem egyedülálló elemek, hanem a tulajdonsághoz (mint állítmányhoz) tartozó alany-tárgy párok. (A relációs adatbázisok fogalomkörében a tulajdonság eseteit egy bináris reláció – azaz tulajdonság – tuple-jainak neveznénk.)

4.1 RDF Séma alapú tulajdonságkonstrukciók

Az ebben a szekcióban szereplő konstrukciókat az RDF Séma [RDF Szókészlet] részletesen tárgyalja. Ez a szekció ezért inkább csak a konstrukciók szinopszisát és OWL-specifikus aspektusait ismerteti.

4.1.1 rdfs:subPropertyOf

Egy rdfs:subPropertyOf axióma azt definiálja, hogy egy tulajdonság egy másiknak altulajdonsága. Formálisan ez azt jelenti, hogy ha P1 altulajdonsága P2-nek, akkor P1 kiterjedése (alany-állítmány párjainak halmaza) P2 hasonló párokból álló kiterjedésének a részhalmaza.

Példa:

<owl:ObjectProperty rdf:ID="hasMother">
  <rdfs:subPropertyOf rdf:resource="#hasParent"/>
</owl:ObjectProperty>

Ez azt állapítja meg, hogy a "anyja" (hasMother) tulajdonság kiterjedésében előforduló elemek (párok) egyben a "szülője" (hasParent) tulajdonság kiterjedésének elemei is.

Az altulajdonság-axiómák mind adattípus-tulajdonságokhoz, mind objektumtulajdonságokhoz alkalmazhatók.

MEGJEGYZÉS: Az OWL DL-ben egy altulajdonság-axiómának az alanya és tárgya csak azonos típusú tulajdonság (vagy adattípus-tulajdonság, vagy objektumtulajdonság) lehet.

4.1.2 rdfs:domain

Egy tulajdonság számára egy vagy több rdfs:domain ("érvényességi köre") axiómát definiálhatunk. Szintaktikailag az rdfs:domain egy beépített tulajdonság, mely egy tulajdonságot, az rdf:Property osztály valamelyik esetét, egy osztályleíráshoz kapcsolja. Egy rdfs:domain axióma azt jelenti ki, hogy az ilyen tulajdonságaxiómák alanyainak a megadott osztályleírás kiterjedéséhez kell tartozniuk.

Több rdfs:domain axióma is megadható ugyanarra a tulajdonságra, amelyeket úgy kell értelmezni, hogy konjunkciót alkotnak: vagyis, a tulajdonság érvényességi körét azokra az egyedekre korlátozzák, amelyek az egyes rdfs:domain osztályaxiómák metszetéhez tartoznak. Ha azt akarnánk kifejezni, hogy egy tulajdonság érvényességi köre több osztályra terjed ki, akkor egy owl:unionOf típusú osztályleírást kellene használnunk. Például: ha azt akarnánk kifejezni, hogy a "bankszámlája" (hasBankAccount) tulajdonság egyaránt érvényes a "Vállalat" (Corporation) osztályban és a "Személy" (Person) osztályban, akkor ilyen kijelentéseket kellene tennünk:

<owl:ObjectProperty rdf:ID="hasBankAccount">
  <rdfs:domain>
    <owl:Class>    
      <owl:unionOf rdf:parseType="Collection">
        <owl:Class rdf:about="#Person"/>
        <owl:Class rdf:about="#Corporation"/>
      </owl:unionOf>
    </owl:Class>    
  </rdfs:domain>
</owl:ObjectProperty>

MEGJEGYZÉS: Az OWL Lite-ban az rdfs:domain tulajdonság értéke csak osztályazonosító lehet.

4.1.3 rdfs:range

Egy tulajdonság számára egy vagy több rdfs:range ("értéktartománya") axiómát definiálhatunk. Szintaktikailag az rdfs:range egy beépített tulajdonság, mely egy tulajdonságot, az rdf:Property osztály valamelyik esetét, egy osztályleíráshoz vagy egy adatérték-tartományhoz kapcsolja. Egy rdfs:range axióma azt jelenti ki, hogy az adott tulajdonság lehetséges értékeinek a megadott osztályleírás kiterjedéséhez, vagy a megadott adatérték-tartományhoz kell tartozniuk.

Ha több rdfs:range típusú korlátozást adunk meg ugyanarra a tulajdonságra, akkor ezzel azt jelentjük ki, hogy a tulajdonság értéktartománya a megadott értéktartományok metszete (osztályleírások kiterjedésének a metszete, vagy adatérték-tartományok metszete) legyen. Az rdfs:domain-hez hasonlóan több alternatív értéktartományt specifikálhatunk egy owl:unionOf típusú osztályleírás keretében is (lásd a példát az előző szekcióban).

Figyeljük meg, hogy – szemben az összes értékkorlátozással, amelyet az osztályleírásokról szóló szekcióban tárgyaltunk – az rdfs:range korlátozások globálisak. Az olyan értékkorlátozásokat, mint az owl:allValuesFrom, csak az osztályleírásokban használjuk, és csak akkor hatályosak az adott tulajdonságra, amikor a leírt osztály egyedeivel kapcsolatban használjuk őket. Az rdfs:range viszont mindig érvényes az adott tulajdonságra, függetlenül attól, hogy melyik osztály egyedeire alkalmazzuk. Ezért az rdfs:range használata óvatosságot igényel.

MEGJEGYZÉS: Az OWL Lite-ban az rdfs:range tárgyaként kizárólag osztályneveket használhatunk.

4.2 Tulajdonságok közötti relációk

4.2.1 owl:equivalentProperty

Az owl:equivalentProperty ("egyenértékű tulajdonság") konstrukció segítségével azt fejezhetjük ki, hogy két tulajdonságnak ugyanaz a tulajdonságkiterjedése. Szintaktikailag az owl:equivalentProperty egy beépített OWL tulajdonság, amelynek az érvényességi köre és értéktartománya egyaránt az rdf:Property osztály.

MEGJEGYZÉS: A tulajdonságok egyenértékűsége nem azonos a tulajdonságok egyenlőségével. Az egyenértékű tulajdonságoknak ugyanaz az "értékük" (ugyanaz a kiterjedésük), de az intenzionális jelentésük különböző lehet (különböző fogalmakat jelölhetnek). A tulajdonságok egyenlőségét az owl:sameAs konstrukcióval deklarálhatjuk. De mivel ez megköveteli, hogy tulajdonságokat egyedként is kezelhessünk, az ilyen axiómák csak az OWL Full-ban használhatók.

4.2.2 owl:inverseOf

A tulajdonságoknak irányuk van, mely az érvényességi körtől az értéktartomány felé mutat. A gyakorlatban azonban hasznos lehet, ha mindkét irányban definiálhatunk tulajdonságokat: pl. Úrvezető "gépkocsija", illetve Gépkocsi "tulajdonosa". Az owl:inverseOf konstrukciót használjuk az ilyen fordított vagy inverz tulajdonság definiálására (informálisan írva: "gépkocsija" inverseOf "tulajdonosa").

Szintaktikailag az owl:inverseOf egy beépített OWL tulajdonság, amelynek az érvényességi köre és értéktartománya egyaránt az owl:ObjectProperty osztály. Egy "P1 owl:inverseOf P2" formátumú axióma azt deklarálja, hogy a P1 tulajdonság kiterjedésének minden (x,y) párja számára létezik egy (y,x) pár a P2 tulajdonság kiterjedésében, és megfordítva. Az owl:inverseOf tehát egy szimmetrikus tulajdonság. Az alábbi példa azt deklarálja, hogy a "gyermeke" (hasChild) tulajdonság a "szülője" (hasParent) tulajdonság fordítottja:

<owl:ObjectProperty rdf:ID="hasChild">
  <owl:inverseOf rdf:resource="#hasParent"/>
</owl:ObjectProperty>

4.3 Tulajdonságok kardinalitásának globális korlátozása

4.3.1 owl:FunctionalProperty

A funkcionális tulajdonság olyan speciális tulajdonság, amelynek csak egyetlen (azaz: egyedülálló) y értéke lehet minden x egyed számára. Vagyis, nem létezhet két olyan különböző y1 és y2 érték úgy, hogy mind az (x,y1), mind az (x,y2) pár ennek a tulajdonságnak az esete lenne. Mind az objektumtulajdonságokat, mind az adattípus-tulajdonságokat deklarálhatjuk funkcionálisnak. Erre a célra az OWL definiál egy owl:FunctionalProperty nevű beépített osztályt, mely az rdf:Property RDF osztály speciális alosztálya.

Az alábbi axióma kijelenti, hogy a "férje" (husband) tulajdonság funkcionális, vagyis, hogy egy Asszonynak (Woman) legfeljebb egy férje lehet (ez egyben jó példa az ontológiáknak a különböző kultúráktól való függőségére is):

<owl:ObjectProperty rdf:ID="husband">
  <rdf:type    rdf:resource="&owl;FunctionalProperty" />
  <rdfs:domain rdf:resource="#Woman" />
  <rdfs:range  rdf:resource="#Man" />
</owl:ObjectProperty>

Mint általában, itt is variálható a szintaxis. A fenti definíció szemantikailag ekvivalens az alábbival:

<owl:ObjectProperty rdf:ID="husband">
  <rdfs:domain rdf:resource="#Woman" />
  <rdfs:range  rdf:resource="#Man" />
</owl:ObjectProperty>

<owl:FunctionalProperty rdf:about="#husband" />

4.3.2 owl:InverseFunctionalProperty

Ha egy tulajdonságot fordított funkcionálisnak deklarálunk, akkor a tulajdonsággal megfogalmazott állítás tárgya egyértelműen meghatározza az alanyt (valamilyen egyedet). Formálisabban fogalmazva: ha kijelentjük, hogy P egy fordított funkcionális tulajdonság (Inverse Functional Property), akkor ez azt garantálja, hogy egy y érték csupán egyetlen x egyed P tulajdonságának az értéke lehet, vagyis, nem létezhet két olyan különböző, x1 és x2 egyed oly módon, hogy mind az (x1,y), mind (x2,y) páros a P tulajdonság esete lenne.

Egy fordított funkcionális tulajdonságaxiómát szintaktikailag úgy adunk meg, hogy az adott tulajdonságot az owl:InverseFunctionalProperty beépített OWL osztály egyedének deklaráljuk. Ez az osztály egyébként az owl:ObjectProperty OWL osztály alosztálya.

MEGJEGYZÉS: Mivel az OWL Full-ban az adattípus-tulajdonságok az objektumtulajdonságok alosztályát képezik, ezért itt a fordított funkcionális jellemzőt adattípus-tulajdonságokra is alkalmazhatjuk. Az OWL DL-ben azonban az objektumtulajdonságok és az adattípus-tulajdonságok diszjunkt halmazokat alkotnak, s így az adattípus-tulajdonságok nem deklarálhatók fordított funkcionálisnak. (lásd a 8.1. szekcióban és a 8.2. szekcióban is).

Egy tipikus példa fordított funkcionális tulajdonságra:

<owl:InverseFunctionalProperty rdf:ID="isBiologicalMotherOf">
  <rdfs:domain rdf:resource="#Woman"/>
  <rdfs:range rdf:resource="#Human"/>
</owl:InverseFunctionalProperty>

Ez a példa azt mondja, hogy az "isBiologicalMotherOf" ("biológiaiAnyja~nak") kijelentés minden egyes tárgya (valamelyik Human/Ember) számára egyértelműen azonosítható egy alany (valamelyik Woman/Asszony). Ezért az ilyen tulajdonságok emlékeztetnek az adatbázisok "kulcsaira", amelyek egyértelműen azonosítanak egy egyedet.

Az "egyenes" és a fordított funkcionális tulajdonság közötti egyik különbség az, hogy az utóbbi definíciójához nem szükséges még egy további objektumtulajdonság-axióma vagy adattípustulajdonság-axióma: a fordított funkcionális tulajdonság ugyanis eleve csak objektumtulajdonság lehet.

Vegyük észre, hogy az owl:FunctionalProperty, valamint az owl:InverseFunctionalProperty globális kardinalitáskorlátozást valósít meg. Azaz mindegy, hogy éppen melyik osztály egyedeit jellemezzük vele, a korlátozás mindig érvényben marad. Ez tehát különbözik azoktól a kardinalitáskorlátozásoktól, amelyeket a Tulajdonságkorlátozások c. szekcióban ismertettünk. Ezek ugyanis mind osztályleírások, s ezért csak helyileg, az éppen leírt osztályra érvényesek.

4.4 Tulajdonságok logikai jellemzői

4.4.1 owl:TransitiveProperty

Amikor egy P tulajdonságot tranzitívnak deklarálunk, ez annyit jelent, hogy ha egy (x,y) pár és egy (y,z) pár is P-nek egy-egy előfordulása, akkor ebből az következik, hogy az (x,z) pár szintén egy előfordulása P-nek.

Szintaktikailag egy tulajdonságot oly módon definiálunk tranzitívnak, hogy az owl:TransitiveProperty nevű beépített OWL osztály egyedévé tesszük. (Ezt a beépített OWL osztályt az owl:ObjectProperty alosztályaként definiálja az OWL nyelv.)

A tranzitív tulajdonságok tipikus példái azok a tulajdonságok, amelyek egy bizonyos rész-egész relációt ábrázolnak. Például: mondhatnánk, hogy a subRegionOf (alrégiója~nak) tulajdonság régiók közötti relációként tranzitív:

<owl:TransitiveProperty rdf:ID="subRegionOf">
  <rdfs:domain rdf:resource="#Region"/>
  <rdfs:range  rdf:resource="#Region"/>
</owl:TransitiveProperty>

Ebből egy OWL következtetőgépnek le kell tudnia vezetni, hogy ha pl. Chianti, Toscana és Itália egy-egy régió (Region), és Chianti alrégiója (subregionOf) Toscanának, akkor Chianti alrégiója Itáliának is.

Jegyezzük meg, hogy mivel az owl:TransitiveProperty osztály az owl:ObjectProperty osztály alosztálya, az alábbi példa egyenértékű a fentivel:

<owl:ObjectProperty rdf:ID="subRegionOf">
  <rdf:type rdf:resource="&owl;TransitiveProperty"/>
  <rdfs:domain rdf:resource="#Region"/>
  <rdfs:range  rdf:resource="#Region"/>
</owl:ObjectProperty>

MEGJEGYZÉS: Az OWL DL nem engedi meg, hogy egy tranzitív tulajdonságra (vagy egy ilyennek a fordítottjára, szupertulajdonságára, vagy a fordítottja szupertulajdonságára) akár lokális, akár globális kardinalitáskorlátozást deklaráljunk.

4.4.2 owl:SymmetricProperty

A szimmetrikus tulajdonság egy olyan tulajdonság, amelyre érvényes a következő megállapítás: ha egy (x,y) pár a P tulajdonság egyik előfordulása, akkor az (y,x) pár szintén egy előfordulása P-nek. Szintaktikailag egy tulajdonságot úgy deklarálunk szimmetrikusnak, hogy azt az owl:SymmetricProperty nevű beépített OWL osztály alosztályává tesszük. (Ezt a beépített OWL osztályt az owl:ObjectProperty alosztályaként definiálja az OWL nyelv.)

A szimmetrikus tulajdonságra népszerű példa a friendOf (barátja) reláció:

<owl:SymmetricProperty rdf:ID="friendOf">
  <rdfs:domain rdf:resource="#Human"/>
  <rdfs:range  rdf:resource="#Human"/>
</owl:SymmetricProperty>

A szimmetrikus tulajdonságok érvényességi köre és értéktartománya azonos.

5. Egyedek

Egyedeket un. tényaxiómákkal definiálhatunk (ezeket néha egyszerűen csak "tényeknek" nevezzük). A tények két csoportjáról beszélhetünk:

1. Tények az osztálytagságról, és tények az egyedek tulajdonságainak értékeiről.
2. Tények az egyedek azonosságáról (vagy különbözőségéről).

5.1 Osztálytagság és tulajdonságértékek

A legtöbb tény tipikusan olyan kijelentés, mely egyedek osztálytagságáról (osztályhoz tartozásáról), vagy a tulajdonságaik értékéről szól. Példaképpen tekintsük az alábbi kijelentések csokrát, amelyben az Opera osztály egyik egyedéről teszünk tényállításokat.

<Opera rdf:ID="Tosca">
  <hasComposer rdf:resource="#Giacomo_Puccini"/>
  <hasLibrettist rdf:resource="#Victorien_Sardou"/>
  <hasLibrettist rdf:resource="#Giuseppe_Giacosa"/>
  <hasLibrettist rdf:resource="#Luigi_Illica"/>
  <premiereDate rdf:datatype="&xsd;date">1900-01-14</premiereDate>
  <premierePlace rdf:resource="#Roma"/>
  <numberOfActs rdf:datatype="&xsd;positiveInteger">3</numberOfActs> 
</Opera>

Ez a példa ilyen tényeket tartalmaz a Toscáról, az Opera osztály egyik egyedéről, mint hogy a Tosca szerzője Giacomo Puccini, hogy az operának három szövegkönyvírója van (Sardou, Giacosa és Illica) és így tovább. Itt a "bemutatóDátuma" (premiereDate) tulajdonság az operát egy tipizált literálhoz, az XML Séma "date" adattípusához kapcsolja. (Az [XML Séma Adattípusok] dokumentum tartalmazza a releváns információt ennek az adattípusnak a szintaxisáról és szemantikájáról).

A tényaxiómák nem szükségszerűen szólnak nevesített egyedekről: névtelen egyedekre is vonatkozhatnak. Példaképpen nézzük meg az alábbi RDF/XML kódrészletet. A példa néhány tényt közöl a Mérés (Measurement) osztály egy névtelen egyedéről (egy mérésiadat-rekordról), ahol a méréshez, mint kvantitatív megfigyeléshez, ilyen tények listája tartozik: a megfigyelt alany (observedSubject), a megfigyelt jelenség (observedPhenomenon), a mértékegység (quantityUnit), a megfigyelt érték (QuantityValue), és a megfigyelés időpontja (TimeStamp).

<Measurement>
  <observedSubject rdf:resource="#JaneDoe"/>
  <observedPhenomenon rdf:resource="#Weight"/>
  <observedValue>
    <Quantity>
      <quantityValue rdf:datatype="&xsd;float">59.5</quantityValue>
      <quantityUnit rdf:resource="#Kilogram"/>
    </Quantity>
  </observedValue>
  <timeStamp rdf:datatype="&xsd;dateTime">2003-01-24T09:00:08+01:00</timeStamp>
</Measurement>

Ez a tényaxióma két névtelen egyedet tartalmaz: valamilyen Measurement-et és valamilyen Quantity-t. Természetes nyelven a példa ezt mondja: "a Jane Doe nevű alany esetében a testsúly (Weight) nevű jelenség mért értéke egy olyan mennyiség, amelynek mértékegysége a Kilogramm, az értéke pedig 59.5. A mérés ideje 2003. január 14-én reggel, 8 perccel 9 óra után, az UTC+1 órás zónaidőben (Amszterdam, Berlin, Párizs téli időszámítása szerint)". Mint az előbbi példában a date adattípus, az itteni float és dateTime adattípusok is XML Séma adattípusok. (Az [XML Séma Adattípusok] dokumentum tartalmazza a szükséges információt ezeknek az adattípusoknak a szintaxisáról és szemantikájáról).

5.2 Egyedek azonossága

Sok nyelv él az "egyedi nevek feltételezésének" módszerével, mely azt jelenti, hogy a nyelv elvárja: a különböző nevek különböző dolgokra hivatkozzanak a világban. A Weben azonban ilyen feltételezés nem lehetséges, hiszen pl. ugyanarra a személyre különböző URI-k segítségével hivatkozhatunk. Emiatt az OWL nem is használ ilyen feltételezést. Hacsak explicite nem jelentjük ki (OWL nyelven), hogy két URI hivatkozás ugyanarra, vagy hogy két különböző egyedre mutat, akkor az OWL-t támogató eszközöknek defaultként azt kell feltételezniük, hagy bármelyik eset előfordulhat.

Az OWL három olyan nyelvi konstrukciót tartalmaz, amellyel tényeket jelenthetünk ki az egyedek azonosságával kapcsolatban:

• Az owl:sameAs azt jelenti ki, hogy két URI hivatkozás ugyanarra az egyedre mutat.
• Az owl:differentFrom segítségével azt állítjuk, hogy két URI hivatkozás különböző egyedekre mutat.
• Az owl:AllDifferent pedig egy olyan fogalmat takar, amellyel egyedek egy megadott listájáról kijelenthetjük, hogy abban minden egyed különbözik a többitől.

5.2.1 owl:sameAs

Az owl:sameAs beépített OWL tulajdonság egy egyedet egy másik egyedhez kapcsol. Egy owl:sameAs kijelentés azt deklarálja, hogy két URI hivatkozás ténylegesen ugyanarra az egyedre mutat (az egyedeknek ugyanaz az "identitásuk").

Olyan egyedek esetében, mint pl. "emberek", ezt a fogalmat viszonylag könnyű megérteni. Például, állíthatnánk azt, hogy a következő két URI ténylegesen ugyanarra a személyre hivatkozik:

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

Az owl:sameAs állítmányt gyakran használjuk, amikor két ontológia közötti leképezéseket definiálunk. Nem realisztikus ugyanis elvárni, hogy mindenki ugyanazzal a névvel hivatkozzék egy bizonyos egyedre. (Ez egy grandiózus tervet igényelne, ami ellenkezik a Web szellemével).

Az OWL Full-ban, ahol osztályokat más (meta)osztályok egyedeként is kezelhetünk, az owl:sameAs konstrukciót használhatjuk osztályok egyenlőségének a deklarálására is, kimondva ily módon azt, hogy a két fogalom intenzionális jelentése azonos. Egy példa:

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

Elképzelhetjük ezt az axiómát, pl. egy hipotetikus "Európai sportok ontológiája" elemeként. A két osztályt itt egyednek tekintjük (az owl:Class egyedének). Ez lehetővé teszi nekünk, hogy kijelentsük: a FootballTeam osztály az Európai sportok ontológiájában ugyanazt a fogalmat jelöli meg, mint a SoccerTeam az Amerikai sportok ontológiájában. Vegyük észre azonban a jelentés eltérését az alábbi kijelentésben:

<footballTeam owl:equivalentClass us:soccerTeam />

Ez ugyanis azt mondja, hogy a két osztály osztálykiterjedése azonos, de a két osztály nem szükségszerűen jelenti ugyanazt a fogalmat.

MEGJEGYZÉS: Az URI hivatkozások összehasonlításának részleteivel kapcsolatban lásd az [RDF Fogalmak]. dokumentum megfelelő szekcióját.

5.2.2 owl:differentFrom

Az owl:differentFrom beépített OWL tulajdonság egy egyedet egy másik egyedhez kapcsol. Egy owl:differentFrom kijelentés azt deklarálja, hogy két URI hivatkozás különböző egyedekre mutat.

Példa:

<Opera rdf:ID="Don_Giovanni"/>

<Opera rdf:ID="Nozze_di_Figaro">
  <owl:differentFrom rdf:resource="#Don_Giovanni"/>
</Opera>

<Opera rdf:ID="Cosi_fan_tutte">
  <owl:differentFrom rdf:resource="#Don_Giovanni"/>
  <owl:differentFrom rdf:resource="#Nozze_di_Figaro"/>
</Opera>

5.2.3 owl:AllDifferent

Az olyan ontológiák, amelyek egyedi neveket feltételeznek, valószínűleg nagy számban alkalmaznak owl:differentFrom állításokat, hiszen az egyedek minden lehetséges párkombinációjáról külön-külön ki kell mondaniuk, hogy különbözőek. Ilyen esetekre az OWL-nak van egy speciális idiómája, amelyet az owl:AllDifferent konstrukció realizál. Az owl:AllDifferent egy speciális, beépített OWL osztály, amelyhez definiáltak egy owl:distinctMembers tulajdonságot is. Ez a tulajdonság az owl:AllDifferent osztály egyik egyedét más egyedek egy megadott listájához kapcsolja. Az ilyen konstrukció szándékolt jelentése az, hogy a listában szereplő minden egyed különbözik a lista többi egyedétől.

Például:

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

Ez a példa azt állapítja meg, hogy ez a hat URI hivatkozás hat különböző operára mutat.

MEGJEGYZÉS: az owl:distinctMembers egy speciális szintaktikai konstrukció, egy olyan állítmány, amelyet kényelmi okokból vettek fel a nyelvbe, és amelynek alanya mindig egy owl:AllDifferent egyed.

6. Adattípusok

Ebben a dokumentumban több helyen találkozhattunk azzal a fogalommal, hogy adatérték-tartomány, amikor adatértékek egy bizonyos halmazát kellett specifikálnunk. Az OWL az adatértéktartomány-specifikációk három típusát tartalmazza:

• Az RDF adattípus specifikációt.
• Az RDFS literálok osztályát (rdfs:Literal)
• A felsorolás adattípust az owl:oneOf konstrukció felhasználásával.

Az adattípusok minimális eszköztámogatását a 6.3. szekció tárgyalja.

6.1 RDF adattípusok

Az OWL az RDF adattipizálási sémáját alkalmazza, mely tartalmaz egy mechanizmust az XML Séma adattípusaira történő hivatkozáshoz [XML Séma adattípusok]. Ezek részletesebb leírását megtalálja az olvasó az RDF dokumentumokban, pl. az [RDF Fogalmak] dokumentumában. Az olvasó tájékoztatására itt most csak az RDF adattípusok szinopszisát adjuk meg.

Az adatértékek az rdfs:Literal RDF Séma osztály egyedei. A literálok lehetnek egyszerűek (adattípus nélküliek), vagy tipizáltak. Az adattípusok az rdfs:Datatype osztály egyedei. Az RDF/XML-ben egy literál típusát egy rdf:datatype attribútummal specifikáljuk, amelynek az értéke ajánlatos, hogy az alábbiak valamelyike legyen:

• Egy kanonikus URI hivatkozás egy XML Séma adattípusra, a következő formában:

         http://www.w3.org/2001/XMLSchema#NAME
      

  ahol "NAME" egy egyszerű, beépített XML Séma adattípus neve, ahogy azt az [XML Séma Adattípusok] 3. szekciója definiálja, az alább specifikált kikötésekkel.
• Az rdf:XMLLiteral adattípus URI hivatkozása. Ezt az adattípust használjuk, ha XML tartalmat akarunk beépíteni egy RDF/OWL dokumentumba. Ennek az adattípusnak az URI hivatkozása:

      http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral
    

  Erről az adattípusról további részletek találhatók az [RDF Fogalmak] dokumentumában.

Az [RDF Szemantika] dokumentum 5. fejezete az alábbi beépített XML Séma adattípusok használatát ajánlja:

• Az xsd:string elemi adattípust, plusz az xsd:string-ből származtatott következő adattípusokat: xsd:normalizedString, xsd:token, xsd:language, xsd:NMTOKEN, xsd:Name és xsd:NCName.
• Az xsd:boolean elemi adattípust.
• Az elemi numerikus adattípusokat, mint xsd:decimal, xsd:float és xsd:double, valamint az xsd:decimal adattípusból derivált összes adattípust (xsd:integer, xsd:positiveInteger. xsd:nonPositiveInteger, xsd:negativeInteger, xsd:nonNegativeInteger, xsd:long, xsd:int, xsd:short, xsd:byte, xsd:unsignedLong, xsd:unsignedInt, xsd:unsignedShort, xsd:unsignedByte).
• Az idővel kapcsolatos elemi adattípusokat: xsd:dateTime, xsd:time, xsd:date, xsd:gYearMonth, xsd:gYear, xsd:gMonthDay, xsd:gDay és xsd:gMonth.
• Az egyéb elemi adattípusokat: xsd:hexBinary, xsd:base64Binary és xsd:anyURI.

MEGJEGYZÉS: nem illegális ugyan, de nem is ajánlatos, hogy az alkalmazások saját adattípusokat definiáljanak az rdfs:Datatype egyedeként. Az ilyen adattípusokat "ismeretlennek" minősíti a nyelv, és hasonló módon kezeli őket, mint a "nem támogatott" adattípusokat (Lásd a részleteket a 6.3. szekcióban arról, hogy az OWL szoftvereszközeinek hogyan kell kezelniük ezeket az eseteket.)

Amikor adattípusokat használunk, ne felejtsük el, hogy az RDF/XML elvárja, hogy egy adattípus-tulajdonság értékének használatánál az adatértékre mindig megadjuk az adattípust, még akkor is, ha már definiáltuk ennek az adattípus-tulajdonságnak az értéktartományát. Példa lehet erre a timeStamp tulajdonság, amelyet korábban már használtunk a Mérés (Measurement) példánál. (Figyeljük meg, hogy egyszer a tulajdonság értéktartományaként (rdf:range) deklaráljuk a "dateTime" adattípust, majd az értékadásnál adattípusként (rdf:datatype) újból megadjuk):

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

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

6.2 Felsorolás adattípus az owl:oneOf használatával

Az RDF adattípusok mellett az OWL tartalmaz egy további konstrukciót is adatérték-tartományok definiálására, nevezetesen a "felsorolás" adattípust. Ezt az adattípus formátumot az owl:oneOf konstrukcióval deklaráljuk, amelyet egyébként felsorolásosztályok leírására is használunk. Felsorolás-adattípus esetén az owl:oneOf alanya egy owl:DataRange osztályú üres gráfcsomópont, a tárgya pedig literálok listája. Sajnos, itt nem használhatjuk az rdf:parseType="Collection" idiómát a literálok listájának megadására, mivel az RDF elvárja, hogy egy kollekció RDF csomóponti elemek listája legyen. Ezért az adatértékek listáját az elemi listakonstrukciók (az rdf:first, az rdf:rest és az rdf:nil) segítségével specifikáljuk.

MEGJEGYZÉS: Felsorolás adattípusokat az OWL Lite-ban nem használhatunk.

Az alábbi példa a tennisGameScore (teniszjátszma-eredmény) tulajdonság adatérték-tartományát egész számok listájával {0, 15, 30, 40} specifikálja:

<owl:DatatypeProperty rdf:ID="tennisGameScore">
  <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 Adattípus-következtetések támogatása

Az OWL-t támogató szoftvereszközök különbözőek lehetnek attól függően, hogy miként támogatják az adattípus-következtetés fogalmát. A szoftvereszközöknek ezt az opciót legalább az xsd:string és az xsd:integer XML Séma adattípusok vonatkozásában támogatniuk kell. Az OWL Full eszközöknek ezen felül támogatniuk kell az rdf:XMLLiteral adattípust is. A nem támogatott adattípusok esetén a lexikailag azonos literálokat egyenlőknek kell tekinteni, míg a lexikailag különböző literálokról azt kell feltételezni, hogy vagy egyenlők, vagy nem. Az "ismeretlen" adattípusokat ugyanúgy kell kezelni, mint a "nem támogatott" adattípusokat.

7. Annotáció, ontológia-header, importálás és verzió-információ

7.1 Annotációk

Az OWL Full semmilyen formában nem korlátozza az annotációkat (fontos megjegyzéseket) egy ontológiában. Az OWL DL lehetővé teszi az annotációkat osztályokkal, tulajdonságokkal, egyedekkel, és ontológia-headerekkel kapcsolatban, de csak az alábbi feltételekkel:

• Az objektumtulajdonságok, adattípus-tulajdonságok, annotációtulajdonságok és ontológiatulajdonságok kölcsönösen diszjunkt halmazokat kell hogy alkossanak. Így tehát, az OWL DL-ben, pl. a dc:creator nem lehet egyidejűleg adattípus-tulajdonság és annotációtulajdonság is.
• Az annotációtulajdonságoknak kell hogy legyen egy explicit tipizáló tripletje az alábbi formátumban:

      AnnotationPropertyID rdf:type owl:AnnotationProperty .
    

• Az annotációtulajdonságokat nem szabad tulajdonságaxiómákban használni. Az OWL DL-ben így az annotációtulajdonságok számára nem definiálhatunk altulajdonságokat, érvényességi kört és értéktartományt.
• Az annotációtulajdonság tárgya adat-literál, URI hivatkozás vagy egyed kell hogy legyen.

Az OWL-ban öt annotációtulajdonság van előre definiálva, nevezetesen:

• owl:versionInfo (verzió-információ)
• rdfs:label (címke)
• rdfs:comment (kommentár)
• rdfs:seeAlso ("Lásd ~t is")
• rdfs:isDefinedBy ("definiálta:")

Íme egy példa egy annotációtulajdonság legális használatára OWL DL-ben:

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

<owl:Class rdf:about="#MusicalWork">
  <rdfs:label>Musical work</rdfs:label>
  <dc:creator>N.N.</dc:creator>
</owl:Class>

A példa feltételezi, hogy a &dc; illetve a dc: prefix a Dublin Core URI-ra, illetve névtérre mutat. Így a Dublin Core tulajdonságok annotációtulajdonságként történő használata OWL DL-ben egy explicit tipizáló tripletet igényel. Ez biztosítja, hogy az OWL DL következtetőgépek szemantikailag korrekt módon használják az annotációkat (a részleteket lásd az OWL Szemantika és absztrakt szintaxis [OWL Sz&ASz] dokumentumban).

Ha már egyszer a dc:creator-t annotációtulajdonságként deklaráltuk, az OWL DL már nem engedi ezt tulajdonságaxiómákban korlátozni – pl. az értéktartománya tekintetében – lásd alább:

<-- Ez például illegális OWL DL esetén -->

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

Jegyezzük meg azonban, hogy annotációtulajdonság-deklarációkban az adatértékek literál típusát azért szabad specifikálnunk:

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

7.2 Az ontológia-header

Egy dokumentum, mely egy ontológiát ír le, általában tartalmaz információt magával az ontológiával kapcsolatban is. Az ontológia egy adatforrás, s így az leírható olyan tulajdonságokkal, amelyeket az OWL névteréből, vagy más névterekből veszünk. Páldául:

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

Az ilyen információblokkot ontológia-headernek nevezzük, és általában az RDF/XML dokumentumok elejére tesszük. Az alábbi sor:

  <owl:Ontology rdf:about="">

kijelenti, hogy ez a blokk a jelenlegi ontológiát írja le. Pontosabban: azt mondja, hogy a jelenlegi dokumentum bázis URI-ja az owl:Ontology osztály egyik egyedét azonosítja. Ajánlatos, hogy a bázis URI-t a dokumentum legelején található <rdf:RDF> elem xml:base attribútuma segítségével explicit módon definiáljuk.

Egy ontológia-header pl. így nézne ki:

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

A következő szekciók leírják azokat a különböző deklarációkat, amelyeket tipikusan a headeren belül használunk.

MEGJEGYZÉS: Az owl:imports ontológia importáló konstrukciót és az owl:priorVersion, owl:backwardCompatibleWith, owl:incompatibleWith ontológia-verziókezelő konstrukciókat az OWL szókészlete definiálja az owl:OntologyProperty osztály egyedeiként. Az owl:OntologyProperty osztály egyedeinek érvényességi köre és értéktartománya egyaránt az owl:Ontology osztály kell hogy legyen. Szabad más ontológiatulajdonságokat is definiálni az owl:OntologyProperty egyedei mellé. Az OWL DL-ben az ontológiatulajdonságokra ugyanazok a megkötések érvényesek, mint a 7.1 szekcióban ismertetett annotációtulajdonságokra.

7.3 Ontológiák importálása

Az owl:imports kijelentés egy másik ontológiára hivatkozik, mely olyan definíciókat tartalmaz, amelyek jelentéstartalma az importáló ontológia jelentéstartalmának részét képezi. Minden ilyen hivatkozás egy URI-ból áll, mely azt specifikálja, hogy honnan importáljuk az ontológiát. Szintaktikailag az owl:imports egy tulajdonság, amelynek az érvényességi köre és az értéktartománya egyaránt az owl:Ontology osztály.

Az owl:imports állítások tranzitívak, azaz, ha az A ontológia importálja B-t, és B importálja C-t, akkor A importálja B-t és C-t is.

Az, hogy egy OWL szoftvereszköznek be kell-e töltenie az importált ontológiát a befogadó ontológiába, vagy sem, az mindig az eszköz rendeltetésétől függ. Ha az eszköz egy teljes következtető rendszer (mely teljes konzisztencia-ellenőrzést is tartalmaz), akkor be kell töltenie az importált ontológiákat. Egyéb eszközök, mint például az egyszerű szerkesztő programok és a nem teljes következtető rendszerek dönthetnek úgy is, hogy az importált ontológiákból csak néhányat töltenek be, vagy akár egyetlenegyet sem.

Habár az owl:imports deklarációk és a névtérdeklarációk redundánsnak tűnhetnek, ezek valójában különböző célokra szolgálnak. A névtérdeklarációk egyszerűen csak rövidítéseket kreálnak, amelyekkel adatforrás-azonosítókra lehet hivatkozni. Ezek implicite nem építik be az ontológiába annak a dokumentumnak a jelentéstartalmát, amelyet a hivatkozott adaforrás-azonosító (URI) megcímez. Az owl:imports viszont nem produkál olyan rövidítéseket, amelyekkel az importált dokumentum azonosítóira lehetne hivatkozni. Ezért bevett szokás, hogy mindig megadjuk az importált ontológiáknak megfelelő névtérdeklarációkat is.

MEGJEGYZÉS: az owl:imports az owl:OntologyProperty egyede.

7.4 Verzió-információk

7.4.1 owl:versionInfo

Az owl:versionInfo állítmányhoz tartozó tárgy általában egy karakterlánc, mely információkat tartalmaz a jelenlegi ontológia-verzióról (ezek lehetnek például RCS/CVS kulcsszavak). Egy ilyen állítás semmit nem tesz hozzá az ontológia jelentéstartalmához azon felül, amit az RDF(S) model theory (az RDF Séma formális, modell-elméleti szemantikája) definiál.

Az owl:versionInfo tulajdonságot tipikusan arra használjuk, hogy ontológiákról közöljünk vele verzió-információkat, de alkalmazhatjuk bármilyen más OWL konstrukciók esetében is. Például egy OWL osztályhoz is csatolhatnánk egy owl:versionInfo deklarációt.

MEGJEGYZÉS: Az owl:versionInfo az owl:AnnotationProperty osztály egyede.

7.4.2 owl:priorVersion

Az owl:priorVersion kijelentés egy olyan URI hivatkozást tartalmaz, mely egy másik ontológiára mutat. Ez azt mondja ki a hivatkozott ontológiáról, hogy az a jelen ontológia előző verziója. Ennek a kijelentésnek a modell-elméleti szemantikában nincs egyéb jelentése, mint amit az RDF(S) model theory hozzárendel. A szoftver azonban jól használhatja ezt az információt az ontológiák verziók szerinti szervezéséhez.

Az owl:priorVersion egy beépített OWL tulajdonság, amelynek érvényességi köre és értéktartománya egyaránt az owl:Ontology osztály.

MEGJEGYZÉS: az owl:priorVersion az owl:OntologyProperty osztály egyede.

7.4.3 owl:backwardCompatibleWith

Az owl:backwardCompatibleWith kijelentés egy olyan URI hivatkozást tartalmaz, mely egy másik ontológiára mutat. Ez azt állítja a hivatkozott ontológiáról, hogy a jelen ontológia előző verziója, és hogy a jelen ontológia verzió visszamenőlegesen kompatibilis ezzel az elődjével. A visszamenőleges kompatibilitás főleg azt jelzi, hogy az előző verzióban használt összes azonosítónak ugyanaz az interpretációja az új verzióban is. Egy ilyen kijelentés tehát fontos jelzés lehet azok számára, akik az előző verziót használták, hiszen ebből láthatják, hogy biztonságosan átállhatnak az új verzióra, elég csak megváltoztatniuk a névtérdeklarációkat, valamint az owl:imports deklarációt oly módon, hogy ezek az új verzió URL-jét használják.

Ha az owl:backwardCompatibleWith nincs deklarálva két verzió számára, akkor a kompatibilitást nem szabad feltételeznünk.

Az owl:backwardCompatibleWith kijelentésnek a modell-elméleti szemantikában nincs egyéb jelentése, mint amit az RDF(S) model theory hozzárendel.

Az owl:backwardCompatibleWith egy beépített OWL tulajdonság, amelynek érvényességi köre és értéktartománya egyaránt az owl:Ontology osztály.

MEGJEGYZÉS: az owl:backwardCompatibleWith az owl:OntologyProperty osztály egyede.

7.4.4 owl:incompatibleWith

Az owl:incompatibleWith kijelentés egy másik ontológiára hivatkozik, és azt mondja róla, hogy az a jelen ontológia előző verziója, és hogy a jelen verzió visszamenőlegesen nem kompatibilis az elődjével. Ez elsősorban azoknak az ontológiaszerzőknek lehet fontos információ, akik biztosak akarnak lenni abban, hogy nem állhatnak át az új ontológia verzió használatára annak ellenőrzése nélkül, hogy szükséges-e változtatniuk a saját ontológiájukon, vagy sem.

Az owl:incompatibleWith kijelentésnek a modell-elméleti szemantikában nincs egyéb jelentése, mint amit az RDF(S) model theory hozzárendel.

Az owl:incompatibleWith egy beépített OWL tulajdonság, amelynek érvényességi köre és értéktartománya egyaránt az owl:Ontology osztály.

MEGJEGYZÉS: az owl:incompatibleWith az owl:OntologyProperty osztály egyede.

7.4.5 owl:DeprecatedClass and owl:DeprecatedProperty

Az elavultatás (deprecation) egy általánosan használt fogalom a verziókezelő szoftverek területén annak jelzésére, hogy egy bizonyos, elavult nyelvi elemet csak a visszamenőleges kompatibilitás miatt tartunk meg, és hogy ez az elem feltehetően kimarad a nyelv későbbi verzióiból (lásd pl. a Java programozási nyelvnél). Ezzel a két nyelvi konstrukcióval egy azonosítóról azt állíthatjuk, hogy owl:DeprecatedClass típusú, vagy owl:DeprecatedProperty típusú, ahol az owl:DeprecatedClass az rdfs:Class alosztálya, az owl:DeprecatedProperty pedig az rdf:Property alosztálya. Azzal, hogy elavultnak nyilvánítunk egy kifejezést, azt akarjuk jelezni, hogy az ontológiafejlesztők ne használják az újabb dokumentumaikban, ha ezek a dokumentumok függenek a jelen ontológiától (és annak későbbi verzióitól). Ez az opció lehetővé teszi, hogy az ontológiák fenntarthassák a visszamenőleges kompatibilitást, de azért fokozatosan lecserélhessék az elavult szókészletet (így az elavultatásnak csak a visszamenőleges kompatibilitás fenntartásával együtt van értelme). Ennek eredményeként könnyebb a régi adatokat és alkalmazásokat átállítani az újabb ontológia verzióra. Az elavultságot deklaráló kijelentéseknek a modell-elméleti szemantikában nincs több jelentésük, mint amit az RDF(S) model theory hozzájuk rendel. Az ontológiafejlesztő rendszerek azonban felhasználhatják ezeket arra, hogy felhívják a felhasználók figyelmét a szükséges ellenőrzésekre.

Egy elavultatási példa:

<owl:Ontology rdf:about="">
  <rdfs:comment>Jármű Ontologia, v. 1.1</rdfs:comment>
  <owl:backwardCompatibleWith
          rdf:resource="http://www.example.org/Jármű-1.0"/>   
  <owl:priorVersion rdf:resource="http://www.example.org/jármű-1.0"/>
</owl:Ontology>

<owl:DeprecatedClass rdf:ID="Autó">
  <rdfs:comment>Modernebb a Személygépkocsi kifejezés</rdfs:comment>
  <owl:equivalentClass rdf:resource="#Személygépkocsi"/>
  <!-- Megjegyzés: az equivalentClass csak annyit jelent, hogy 
       ugyanaz a kiterjedése, tehát NEM következik belőle, hogy
       a Személygépkocsi szintén elavult kifejezés volna -->        
</owl:DeprecatedClass>

<owl:Class rdf:ID="Személygépkocsi" />

<owl:DeprecatedProperty rdf:ID="sofőrje">
  <rdfs:comment>inverse property drives is now preferred</rdfs:comment>
  <owl:inverseOf rdf:resource="#~gépkocsitVezet" />
</owl:DeprecatedProperty>

<owl:ObjectProperty rdf:ID="~gépkocsitVezet" />

Ebben a példában Jármű ontológia 1.1 verzióját visszamenőlegesen kompatibilisnak deklaráltuk az 1.0 verziójával. Ugyanakkor elavultnak minősítettük a régi verzióban szereplő Automobil osztályt, amelyet az új verzióban (azonos osztálykiterjedéssel) már a Személygépkocsi osztály helyettesít. Ugyancsak elavulttá minősíti a példa a "sofőrje" tulajdonságot, és helyette a "~gépkocsitVezet" tulajdonság fordítottját vezeti be, ami ugyan az XML kódban nem szerepel, de valami ilyesmi lehet, mint "gépkocsiVezetője". [A magyar fordításban a tilde (~) karakter előreutalás a tulajdonsághoz tartozó tárgyra. (Pl. egy ilyen triplet: "János ~gépkocsitVezet BMW" így olvasandó: János BMW gépkocsit vezet. A fordított tulajdonsággal a triplet: "BMW gépkocsiVezetője János") – a ford.]

8. OWL Full, OWL DL és OWL Lite

A bevezetésben röviden már tárgyaltuk az OWL három alnyelvét. Ez a fejezet informatív módon specifikálja a nyelv ezen három "alfajának" különbségeit. A különbségek formális kimutatását az OWL Szemantika és absztrakt szintaxis dokumentum [OWL Sz&ASz] tartalmazza.

8.1 OWL Full

Az OWL Full valójában nem egy alnyelv. Az OWL Full tartalmazza az összes OWL nyelvi konstrukciót, továbbá lehetővé teszi az RDF konstrukciók szabad és korlátlan használatát. Az OWL Full-ban az owl:Class nevű erőforrás enyenértékű az rdfs:Class erőforrással. Ez nem így van az OWL DL és OWL Lite alnyelvben, ahol az owl:Class az rdfs:Class-nak egy megfelelő alosztálya (ami azt jelenti, hogy az OWL DL és OWL Lite esetében nem minden RDF osztály egyben OWL osztály is). Az OWL Full lehetővé teszi továbbá, hogy osztályokat egyedként is kezelhessünk. Például: az OWL Full-ban teljesen legális, hogy van egy "Fokker-100" azonosítónk, mely egyszer úgy működik, mint egy osztálynév (ilyenkor pl. a világban repülő konkrét Fokker-100 gépek halmazát jelenti), máskor meg úgy, mint egy egyednek a neve (ilyenkor pl. a RepülőgépTípusok osztályának egyik egyedét azonosítja).

Az OWL Full-ban az összes adatértéket egyszersmind egyednek is tekintjük. Az OWL Full-ban az egyedek univerzuma az összes erőforrásból (resource) áll. (Az owl:Thing egyenértékű az rdfs:Resource-szal). Ez azt jelenti, hogy az objektumtulajdonságok és az adattípus-tulajdonságok itt nem alkotnak diszjunkt halmazokat. Az OWL Full-ban az owl:ObjectProperty egyenértékű az rdf:Property-vel. Ennek következménye az, hogy az adattípus-tulajdonságok ténylegesen az objektumtulajdonságok alosztályát képezik. Ennek nem mond ellent az a tény sem, hogy az owl:ObjectProperty és az owl:DatatypeProperty az rdf:Property alosztályai.

Az OWL Full tipikusan azok számára hasznos, akik kombinálni szeretnék az OWL Full kifejezőképességét az RDF flexibilitásával és metamodellező képességeivel. Az OWL Full lehetőségeinek a kihasználása azonban azt is jelenti, hogy bizonyos mértékig elveszítjük azokat a garanciákat (lásd alább) amelyeket az OWL DL és az OWL Lite tud nyújtani a következtető rendszerek számára.

MEGJEGYZÉS: Az RDF dokumentumok általában OWL Full szintű dokumentumoknak tekinthetők, hacsak nem specifikusan OWL DL-nek vagy OWL Lite-nak tervezték őket.

MEGJEGYZÉS: Így az OWL Full-ban az owl:Thing egyenértékű az rdfs:Resource-szal, az owl:Class az rdfs:Class-szal, az owl:ObjectProperty pedig az rdf:Property-vel.

8.2 OWL DL

Az OWL DL az OWL alnyelve, mely bizonyos korlátokat vezet be az OWL nyelvi konstrukcióinak hsználatára. Ezek a korlátok röviden a következők:

• Az OWL DL páronként diszjunkt halmazoknak tekinti az osztályokat, az adattípusokat, az adattípus-tulajdonságokat, az objektumtulajdonságokat, az annotációtulajdonságokat, az ontológiatulajdonságokat (importáló és verziókezelő elemeket), az egyedeket, az adatértékeket és a beépített szókészletet. Ez azt jelenti például, hogy egy osztály nem lehet egyidejűleg egyed is.
• Az, hogy az OWL DL-ben az objektumtulajdonságok és az adattípus-tulajdonságok halmaza diszjunkt, azzal a következménnyel jár, hogy az alábbi négy tulajdonságjellemző:
  • az inverse of,
  • az inverse functional,
  • a symmetric, és
  • a transitive
  sohasem specifikálható adattípus-tulajdonságokra.
• Az OWL DL kiköti, hogy sem lokális, sem globális kardinalitáskorlátozás nem alkalmazhataó tranzitív tulajdonságokra, ilyenek fordítottjára vagy bármelyik szupertulajdonságára.
• Annotációk csak bizonyos körülmények között használhatók (lásd a 7.1 szekcióban).
• Az RDF(S) szókészlet nagyobbik része nem használható az OWL DL-ben. (A részleteket lásd az OWL Szemantika és absztrakt szintaxis dokumentumban [OWL Sz&ASz]).
• Az axiómáknak szintaktikailag pontosaknak kell lenniük (pl. nem lehetnek bennük felesleges vagy hiányzó szintagmák), továbbá fa-struktúrába kell szerveződniük.

  Az utóbbi kikötés azt is jelenti, hogy minden osztály és tulajdonság, amelyre hivatkozunk, kifejezetten csak OWL osztály, illetve tulajdonság lehet. Például: ha az ontológia az alábbi komponenst tartalmazza:

    <owl:Class rdf:ID="C1">
      <rdfs:subClassOf rdf:resource="#C2" />
    </owl:Class> 

  akkor az ontológiának (vagy egy általa importált másik ontológiának) tartalmaznia kell egy owl:Class tripletet a C2 számára.

• Az egyedek egyenlőségéről és különbözőségéről szóló axiómák (tények) csak nevesített (azaz névvel rendelkező) egyedekkel kapcsolatban definiálhatók.

Ezek az OWL DL korlátok véletlenszerűeknek tűnhetnek, de mégsem azok. A felsorolt korlátozások a leíró logikai következtető rendszerek területén végzett fejlesztéseken alapulnak, amelyek azért igénylik ezeket a korlátozásokat, hogy megfelelő következtetési támogatással láthassák el az ontológia építőket és felhasználókat. Konkrétabban: az OWL DL korlátozások lehetővé teszik, hogy az OWL Full lehető legnagyobb részhalmazát kihasználhassuk, de úgy, hogy azért ennek logikai feldolgozására (a kutatások mai állása szerint) egy eldönthető következtető eljárást lehessen kidolgozni.

MEGJEGYZÉS: Az E. függelék gyakorlati iránymutatást ad arra nézve, hogy miként lehet OWL DL ontológiákat készíteni RDF-ben.

8.3 OWL Lite

Az OWL Lite is tartja magát azokhoz a megkötésekhez, amelyeket az OWL DL fogalmaz meg az OWL nyelvi konstrukciók használatával lkapcsolatban. Ezen túlmenően, az OWL Lite tiltja az alábbi konstrukciók használatát is:

• owl:oneOf
• owl:unionOf
• owl:complementOf
• owl:hasValue
• owl:disjointWith
• owl:DataRange

Az OWL Lite elvárja továbbá, hogy:

• az owl:equivalentClass tripletek alanya osztálynév, a tárgya pedig osztálynév vagy korlátozás legyen;
• az rdfs:subClassOf tripletek alanya szintén osztálynév, a tárgya pedig osztálynév vagy korlátozás legyen;
• az owl:intersectionOf konstrukciót csak egynél több elemet tartalmazó listákra alkalmazzuk, ahol a lista-elemek osztálynevek vagy korlátozások;

  MEGJEGYZÉS: Ez egy iskolapélda arra, hogy hogyan használjuk OWL Lite-ban az owl:intersectionOf konstrukciót:

          <owl:Class rdf:ID="Woman">
            <owl:intersectionOf rdf:parseType="Collection">
              <owl:Class rdf:about="#Female"/>
              <owl:Class rdf:about="#Human"/>
            </owl:intersectionOf>
          </owl:Class/>
        

• az owl:allValuesFrom és az owl:someValuesFrom tripletek tárgya osztálynév vagy adattípusnév legyen;
• az rdf:type triplet tárgya osztálynév vagy korlátozás legyen;
• az rdfs:domain triplet tárgya osztálynév legyen; valamint, hogy
• az rdfs:range triplet tárgya osztálynév vagy adattípusnév legyen.

Az OWL Lite limitált kifejezőképessége mögött az a gondolat húzódik meg, hogy legyen egy olyan minimális, de hasznos részhalmaza az OWL nyelvnek, amelyet az eszközfejlesztők még viszonylag egyszerűen támogatni képesek. Az OWL Lite nyelvi konstrukciói tartalmazzák az alapvető elemeket alosztályhierarchiák építéséhez is (alosztálydefiníciók és tulajdonságkorlátozások formájában). Emellett az OWL Lite lehetővé teszi, hogy a tulajdonságokat opcionálissá vagy kötelezővé tegyük. Az OWL Lite-ot a korlátai az OWL DL-nél alacsonyabb komplexitási osztályba sorolják. Ez pozitív hatással lehet az OWL Lite következtetőgépek hatékonyságára is.

Azok az OWL implementációk, amelyek csak az OWL Lite szókészletét támogatják, de egyébként lazítanak az OWL DL kötöttségein, nem tarthatnak igényt a teljes számíthatóságra a konzisztencia biztosítása és a komplexitás kezelhetősége tekintetében. Mindenesetre, az ilyen implementációk hasznosak lehetnek abban, hogy lehetővé teszik az OWL rendszerek együttműködését az RDFS modellekkel, adatbázisokkal, jelölő eszközökkel és más, nem következtető célú eszközökkel. A Web Ontológia Munkacsoport nem adott nevet az ilyen implementációk potenciálisan hasznos részhalmazának.

A. függelék: A nyelvi elemek indexe

MEGJEGYZÉS: Ez a függelék csak az OWL-specifikus konstrukciókat tartalmazza. Az RDF/RDFS konstrukciók tekintetében lásd az RDF dokumentációt, különösen az RDF Séma dokumentumot [RDF Szókészlet].

B. Függelék: Az OWL RDF Sémája

Az olvasó az 1.7 szekcióban találja meg annak leírását, hogy milyen célokat szolgál ez a függelék. A függelék RDF/XML változata megtalálható a W3C weblapján: 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>This file specifies in RDF Schema format the
    built-in classes and properties that together form the basis of
    the RDF/XML syntax of OWL Full, OWL DL and OWL Lite.
    We do not expect people to import this file
    explicitly into their ontology. People that do import this file
    should expect their ontology to be an OWL Full ontology. 
  </rdfs:comment>
  <versionInfo>10 February 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>

C. függelék: OWL gyorsreferencia

Osztályok az OWL szókészletében:

Tulajdonságok az OWL szókészletében (a táblázat tartalmazza a tulajdonságok érvényességi körét (domain) és értéktartományát (range) is):

D. függelék: Változások a DAML+OIL-hoz képest

Ez a függelék összefoglalja azokat a változtatásokat, amelyek a [DAML+OIL]-ról az OWL-ra történő átalakulás során keletkeztek.

1. A szemantika jelentősen megváltozott. A három alnyelvet illetően a DAML+OIL szemantikája az OWL DL szemantikájához áll legközelebb.
2. A névtér http://www.w3.org/2002/07/owl-ra változott.
3. Az RDF Core Working Group által az RDF és RDF Séma területén bevezetett különféle korszerűsítések átvételre kerültek; például:
   • ciklikus alosztályokat nem enged meg az OWL nyelv
   • több rdfs:domain vagy rdfs:range tulajdonság megadását úgy kezeli az OWL mint metszetet
   • RDF szemantika [RDF Szemantika] használata
   • adattípusok
     • Az RDF és az OWL a http://www.w3.org/2001/XMLSchema XML Séma névteret használja a http://www.w3.org/2000/10/XMLSchema helyett
     • Az OWL nem támogatja adattípusok használatát típus értelemben. Például:

       <size>
         <xsd:integer rdf:value="10"/>
       </size>

       Ehelyett az OWL-ban ezt használjuk:

       <size
       rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">10</size>

   • a daml:List konstrukció, amelyet zárt kollekciók ábrázolására használt a DAML+OIL, nagymértékben átkerült az RDF-be
     • az rdf:parseType="daml:collection" konstrukciót felváltja az rdf:parseType="Collection" konstrukció
     • a daml:List, daml:first, daml:rest, és daml:nil helyébe az rdf:List, rdf:first, rdf:rest és rdf:nil lép.
     • a daml:item konstrukciót nem támogatja az OWL. Mivel tipikusan ezt használták tipizált listák ábrázolására, az alábbiakban bemutatunk egy példát arról, hogy miként kreálhatunk egy ilyen listát daml:item használata nélkül:

               <rdfs:Class rdf:ID="OperaList">
                 <rdfs:subClassOf rdf:resource="&rdf;List"/>
                 <rdfs:subClassOf>
                   <owl:Restriction>
                     <owl:onProperty rdf:resource="&rdf;first"/>
                     <owl:allValuesFrom rdf:resource="#Opera"/>
                   </owl:Restriction>
                 </rdfs:subClassOf>
                 <rdfs:subClassOf>
                   <owl:Restriction>
                     <owl:onProperty rdf:resource="&rdf;rest"/>
                     <owl:allValuesFrom rdf:resource="#OperaList"/>
                   </owl:Restriction>
                 </rdfs:subClassOf>
               </rdfs:Class>
               

       Ebben a példában egy listát definiáltunk, amelynek az elemei operák. Ezt két korlátozás segítségével valósítottuk meg: az egyik az rdf:first értékre vonatkozik (mely a lista-elem típusát ábrázolja), a másik pedig az rdf:rest értékre (mely a definiált lista nevét adja meg).
4. A minősített korlátozásokat eltávolították a nyelvből, aminek eredményeként kimaradtak az alábbi tulajdonságok:
   • daml:cardinalityQ
   • daml:hasClassQ
   • daml:maxCardinalityQ
   • daml:minCardinalityQ
5. Több tulajdonság és osztály új nevet kapott, ahogy a táblázat mutatja:

   DAML+OIL	OWL
   daml:differentIndividualFrom	owl:differentFrom
   daml:equivalentTo	owl:sameAs
   daml:sameClassAs	owl:equivalentClass
   daml:samePropertyAs	owl:equivalentProperty
   daml:hasClass	owl:someValuesFrom
   daml:toClass	owl:allValuesFrom
   daml:UnambiguousProperty	owl:InverseFunctionalProperty
   daml:UniqueProperty	owl:FunctionalProperty

6. Az owl:SymmetricProperty belekerült a nyelvbe.
7. Ugyancsak felvették a nyelvbe az owl:AnnotationProperty, az owl:OntologyProperty és az owl:DataRange konstrukciókat.
8. Az OWL Full-ban egy owl:DatatypeProperty lehet owl:InverseFunctionalProperty is.
9. Az RDF és az RDF Séma osztályokra, illetve tulajdonságokra vonatkozó szinonimákat eltávolították a nyelvből. Így kimaradtak az alábbi kifejezések:
   • daml:comment
   • daml:domain
   • daml:label
   • daml:isDefinedBy
   • daml:Literal
   • daml:Property
   • daml:range
   • daml:seeAlso
   • daml:subClassOf
   • daml:subPropertyOf
   • daml:type
   • daml:value
10. A daml:disjointUnionOf konstrukciót törölték a nyelvből, hiszen ez megvalósítható az owl:unionOf vagy rdfs:subClassOf és az owl:disjointWith kombinációjával.
11. A daml:equivalentTo kifejezés az owl:sameAs nevet kapta, és egyben megszűnt az owl:equivalentClass és az owl:equivalentProperty szupertulajdonsága lenni.
12. A verziókezelés támogatására az alábbi tulajdonságokat és osztályokat vették fel a nyelvbe:
    • owl:backwardCompatibleWith
    • owl:DeprecatedClass
    • owl:DeprecatedProperty
    • owl:incompatibleWith
    • owl:priorVersion
13. Az "egyedi nevek feltételezésének" támogatására beépítették a nyelvbe az owl:AllDifferent és az owl:distinctMembers kifejezéseket.

E. függelék: "Ökölszabály" az OWL DL ontológiákhoz

Az OWL Szemantika és absztrakt szintaxis dokumentum [OWL Sz&ASz] adja meg az OWL ontológiák pontos leírását absztrakt szintaxis, illetve RDF tripletekre történő leképezés formájában.

Az alábbi szabályok azon feltételek informális leírását adják, amelyek teljesülése esetén egy RDF gráf DL szintű ontológiának minősíthető. Ezzel nem szándékunk helyettesíteni azt a formális leírást, amelyet az Sz&ASz dokumentum ad, hanem csak általános fogódzót kívánunk adni. Nem célunk ezzel azt sem elmondani, hogy miként lehet a tripletes ábrázolást az absztrakt szintaxishoz közelebb álló alakra hozni. Pusztán csak azt kívánjuk mindezzel sugallni, hogy ha az olvasó betartja az itt megadott szabályokat, akkor nagy valószínűséggel OWL DL szintű ontológiákat fog produkálni.

Ne keveredjünk bele a beépített szókészletekbe

A beépített tulajdonságokat és osztályokat ne akarjuk újradefiniálni. Ez általában teljesül, ha az OWL, az RDF és az RDFS névtérben szereplő dolgokat nem szerepeltetjük tripletek alanyaként.

Adjunk explicit típusdeklarációt

Mindennek kell, hogy legyen egy típusa¹. Ha bármilyen x URI hivatkozást használunk ott, ahol egy osztálynak kell szerepelnie, a gráfnak kell tartalmaznia egy ilyen tripletet:

x rdf:type owl:Class

Hasonlóképpen, ha egy p tulajdonságot használunk ott, ahol a nyelv egy objektumtulajdonságot vár el, akkor lennie kell egy ilyen tripletnek is:²

p rdf:type owl:ObjectProperty

Vagy, ha egy q tulajdonságot használunk ott, ahol egy adattípus-tulajdonságot vár a nyelv, akkor szerepelnie kell egy ilyen tripletnek is:

q rdf:type owl:DatatypeProperty

Ha egy o tulajdonságot használunk ott, ahol egy ontológiatulajdonságnak kell szerepelnie, akkor o-nak egy ilyen beépített tulajdonságnak kell lennie, mint owl:imports, owl:priorVersion, owl:backwardCompatibleWith, vagy owl:incompatibleWith), vagy pedig meg kell adni egy ilyen tripletet:

o rdf:type owl:OntologyProperty

Ha egy olyan a tulajdonságot használunk ott, ahol egy annotációtulajdonságot vár a nyelv, akkor a-nak egy beépített annotációtulajdonságnak (owl:versionInfo, rdfs:label, rdfs:comment, vagy rdfs:seeAlso vagy rdfs:isDefinedBy) kell lennie, vagy pedig definiálnunk egy ilyen tripletet az a tulajdonságra:

a rdf:type owl:AnnotationProperty

Minden egyed számára, amelyik megjelenik az ontológiában legalább egy típust specifikálni kell, azaz, egy i egyed számára meg kell adni egy ilyen tripletet:

i rdf:type c

ahol c egy owl:Class vagy egy owl:Restriction.

Válasszuk szét a neveket

Az osztályoknak, az objektum-, adattípus-, ontológia- és annotációtulajdonságoknak, valamint az egyedek URI hivatkozásainak diszjunkt halmazokat kell alkotniuk. Az alábbi módon tehát nem adhatunk meg típusokat:

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

És különösen: nem használhatunk osztályokat egyed szerepben, ahogyan pl. az alábbi példa teszi:

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

Ez ugyanis nem legális az OWL DL-ben. Az általános szabály itt az, hogy ha van a gráfban egy x csomópont egy ilyen tripletben:

x rdf:type owl:Class

akkor x nem jelenhet meg alanyként egy másik olyan tripletben, amelynek állítmánya rdf:type.³

Korlátozások

Ha egy x csomópont típusa korlátozás (x rdf:type owl:Restriction), akkor az x csomóponttal kapcsolatban az alábbi helyzetnek kell fennállnia:

• Ez egy üres csomópont (azaz: névtelen).
• Ez nem alanya egyetlen másik olyan tripletnek sem, amelynek állítmánya az rdf:type³.
• Ez pontosan egy olyan tripletnek az alanya, amelynek az állítmánya owl:onProperty, mégpedig úgy, hogy a tripletnek a tárgya vagy owl:ObjectProperty vagy owl:DatatypeProperty típusú.
• Ez pontosan egy dolognak az alanya az alábbiak közül:
  • Egy olyan tripletnek, amelynek állítmánya owl:someValuesFrom. Ebben az esetben, az owl:onProperty triplet tárgyaként szereplő tulajdonságnak ezzel adekvátnak kell lennie. Ez azt jelenti, hogy ha a triplet tárgya egy adattípus, akkor a tulajdonságnak owl:DatatypeProperty típusúnak kell lennie; ha pedig a tárgy egy osztályleírás, akkor a tulajdonságnak owl:ObjectProperty típusúnak kell lennie. Ez a tipizáló információ sohasem maradhat el (a fentebb említett megkötés miatt).
  • Egy olyan tripletnek, amelynek állítmánya owl:allValuesFrom. Itt ugyanazok a megkötések érvényesek, mint az owl:someValuesFrom esetében.
  • Egy olyan tripletnek, amelynek állítmánya owl:hasValue. Ha az owl:onProperty tripletben megadott tulajdonság típusa owl:ObjectProperty, akkor ennek a tripletnek a tárgya egy egyed kell hogy legyen. Ha pedig az owl:onProperty tripletben megadott tulajdonság típusa owl:DatatypeProperty, akkor a tripletünk tárgyának egy literálnak kell lennie.
  • Egy olyan tripletnek, amelynek állítmánya owl:minCardinality. E triplet tárgyának egy adat-literálnak kell lennie, mely egy nemnegatív egész számot ábrázol.
  • Egy olyan tripletnek, amelynek állítmánya owl:maxCardinality. A megkötés itt is ugyanaz, mint az owl:minCardinality esetében.
  • Egy olyan tripletnek, amelynek állítmánya owl:cardinality. A megkötés itt is ugyanaz, mint az owl:minCardinality esetében.
• Minden egyéb x alanyú tripletnek az állítmánya csak owl:equivalentClass vagy owl:disjointWith lehet.

Osztályaxiómák

Minden olyan tripletnek, amelynek állítmánya rdfs:subClassOf, owl:equivalentClass, vagy owl:disjointWith, az alanya és tárgya egyaránt egy owl:Class vagy egy owl:Restriction kell hogy legyen. Pl., ha van egy

x rdfs:subClassOf y

tripletünk, akkor a gráfnak a következőket is tartalmaznia kell: egy

x rdf:type owl:Class

vagy egy

x rdf:type owl:Restriction

tripletet; valamint egy

y rdf:type owl:Class

vagy egy

y rdf:type owl:Restriction

tripletet.

Tulajdonságaxiómák

Minden olyan tripletnek, amelynek az állítmánya rdfs:subPropertyOf vagy owl:equivalentProperty, az alanya és a tárgya ugyanolyan típusú, mégpedig az owl:ObjectProperty vagy az owl:DatatypeProperty valamelyike kell hogy legyen; azaz, ha van egy ilyen tripletünk:

p owl:equivalentProperty q

akkor a gráfnak tartalmaznia kell vagy egy:

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

triplet párt, vagy pedig egy

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

triplet párt.

Azoknak a tripleteknek, amelyeknek az állítmánya rdfs:domain, alanyként egy owl:ObjectProperty, vagy egy owl:DatatypeProperty típusú tulajdonságot, tárgyként pedig egy owl:Class vagy owl:Restriction típust kell tartalmazniuk.

Azoknak a tripleteknek, amelyeknek az állítmánya rdfs:range, alanyként vagy egy owl:ObjectProperty, vagy egy owl:DatatypeProperty típusú tulajdonságot kell tartalmazniuk. Az előbbi esetben a triplet tárgya egy owl:Class vagy egy owl:Restriction típus lehet, az utóbbi esetben pedig egy XML Séma adattípus, egy rdfs:Literal, vagy egy owl:oneOf elem, mely egy owl:DataRange típusú adattartományt definiál.

Egy owl:inverseOf tripletnek mind az alanya, mind pedig a tárgya owl:ObjectProperty típusú kell hogy legyen.

Tényaxiómák (egyedekre vonatkozó állítások)

Minden owl:sameAs vagy owl:differentFrom állítmányt tartalmazó triplet alanyának egyednek kell lennie.

Jegyezzük meg, hogy két osztálynak egy owl:sameAs tulajdonsággal történő összekapcsolása nagymértékben különbözik attól az esettől, amikor az owl:equivalentClass tulajdonsággal kapcsoljuk össze őket. Az előbbi azt mondja, hogy a két objektum ténylegesen ugyanaz (ami példa arra az esetre, amikor az osztályokat egyedeknek tekintjük, s ez az ontológiánkat ki is szorítja az OWL DL-ből). Az utóbbi pedig azt jelenti ki, hogy csupán a két osztály kiterjedése (az egyedeik halmaza) az, ami egyenlő.

Hasonlóképpen, az osztályok owl:differentFrom relációval történő összekapcsolása nem ugyanaz, mintha az owl:disjointWith relációval kapcsoltuk volna össze őket (ami szintén egy példa az OWL Full szintű konstrukcióra). Két osztály lehet két különböző objektum, de a kiterjedésük mégis közös lehet.

Ha egy x csomópont típusa owl:AllDifferent, akkor OWL DL esetén a következő helyzetnek kell fennállnia:

• Ez egy üres csomópont (azaz: névtelen).
• Ez egy olyan triplet alanya, amelynek állítmánya owl:distinctMembers, a tárgya pedig egy szintaktikailag pontos (well-formed) rdf:List, amelynek listaelemei mind egyedek.
• Ez nem alanya (vagy tárgya) semmilyen más tripletnek.

Boole-algebrai osztálykifejezések

A Boole-algebrai operátorokat (ÉS, VAGY, NEM) az OWL-ban, rendre, az owl:intersectionOf, az owl:unionOf és az owl:complementOf konstrukciók helyettesítik.

Egy owl:complementOf triplet alanya egy owl:Class, a tárgya pedig egy másik owl:Class vagy egy owl:Restriction kell hogy legyen.

Egy owl:unionOf vagy egy owl:intersectionOf triplet alanya egy owl:Class, a tárgya pedig egy (szintaktikailag pontos) rdf:List kell hogy legyen; ez utóbbi listaelemeinek pedig vagy owl:Class vagy owl:Restriction típusúaknak kell lenniük, ahol a lista elemeit vagy explicit módon, a kiterjesztett rdf:List segítségével, vagy pedig, ha RDF-XML-t használunk, akkor az rdf:parseType="Collection" attribútum segítségével ábrázoljuk.

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

Ha egy owl:Class egy üres csomópont (vagyis, az osztály névtelen), akkor az csak egyetlen olyan triplet alanya lehet, amelynek állítmánya owl:intersectionOf, owl:unionOf vagy owl:complementOf. Ha az osztály nevesített, akkor tetszőleges számú ilyen triplet engedélyezett a számára.

Felsorolások

Minden olyan tripletnek az alanya, amelynek az állítmánya owl:oneOf, az vagy egy owl:Class, vagy egy owl:DataRange típusú objektum kell hogy legyen. Az előbbi esetben a triplet tárgyának egy olyan (szintaktikailag pontos) rdf:List felsorolásnak kell lennie, amelynek minden eleme egy egyed. Az utóbbi esetben pedig egy olyan (szintaktikailag ugyancsak pontos) rdf:List felsorolásnak, amelynek minden eleme egy adat-literál. Itt is, mint a Boole-algebrai operátoroknál, az rdf:List helyett az rdf:parseType="Collection" is használható.

Ontológia- és annotációtulajdonságok

Minden olyan triplet esetén, amelyben az állítmány egy ontológiatulajdonság, az alanynak és a tárgynak egyaránt ontológiának kell lennie (vagyis, egy olyan x csomópontnak, amelyre létezik egy ilyen triplet):

x rdf:type owl:Ontology

Minden olyan triplet esetén, ahol az állítmány egy annotációtulajdonság, az alanynak egy nevesített, azaz nem üres csomóponttal reprezentált osztálynak, egy tulajdonságnak, egy egyednek, vagy egy ontológiának kell lennie. Az ilyen, annotációs állítmánnyal rendelkező triplet tárgya pedig csak egy egyed, egy adat-literál, vagy egy tetszőleges URI hivatkozás lehet.

Olyan állítmányok kivételével, amelyek az OWL, az RDF vagy az RDFS szókészletből valók, csak az annotációs állítmányoknak kell olyan tripletekben megjelenniük, amelyek alanya egy osztály vagy egy tulajdonság.

Maguknak az annotáció- és ontológiatulajdonságoknak is tipizáltnak kell lenniük, és nem jelenhetnek meg tripletek alanyaként vagy tárgyaként másként, mint olyan triplet alanyaként, amelynek az állítmánya rdf:type vagy egy annotációtulajdonság.

Kerüljük a struktúrák többszörös kihasználását

Az OWL Sz&ASz leírása ugyanis ezt általában nem engedi meg az RDF ábrázolásban. Ez gyakorlatilag azt jelenti, hogy az RDF gráf egy névtelen csomópontja, mely osztályleírást ábrázol, csak egyszer fordulhat elő (egy triplet tárgyaként). Így tehát az alábbi használat kerülendő:

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

Vannak azonban olyan trükkös helyzetek, amikor az ilyesmi megengedett. Általában azonban a gráfnak különálló üres csomópontokat kell használnia, amikor ugyanannak osztályleírásnak több helyen kell szerepelnie.

Kerüljük az árva üres csomópontokat

A gráfban megjelenő üres csomópontok általában vagy névtelen egyedeket ábrázolnak, vagy az alábbiak közül valamelyiket (de csak egyiket):

• Egy rdfs:subClassOf, egy owl:equivalentClass, egy owl:disjointWith, egy owl:someValuesFrom, egy owl:allValuesFrom vagy egy rdf:type triplet tárgyát.
• Egy rdf:type triplet alanyát, owl:AllDifferent állítmánnyal.
• Egy rdf:List egyik elemét.

Az árva üres csomópontok, vagyis az olyan üres csomópontok, amelyek nem tárgyai valamilyen tripletnek, általában nem engedélyezettek (a fentebb leírt owl:AllDifferent kivételével).

Alapvető tényállítások

Az ontológiák kijelentéseket tartalmazhatnak alapvető tényekről (pl. olyan tripletek formájában, amelyek egyedek tulalajdonságait definiálják). Az ilyen tényállításokban használt tulajdonságoknak owl:ObjectProperty vagy owl:DatatypeProperty osztályúaknak kell lenniük. A tényállítások alanya egy egyed kell hogy legyen, mely csakis tipizált lehet. A tényállítások tárgya pedig vagy egy egyedre való hivatkozás, (ha a tulajdonság owl:ObjectProperty osztályú) vagy egy adat-literál (ha a tulajdonság owl:DatatypeProperty osztályú).

OWL Lite

Az OWL Lite dokumentumoknak ugyanazokat a szabályokat kell követniük, mint az OWL DL dokumentumoknak, de néhány további korlátozással, főleg az engedélyezett szókészlet vonatkozásában. Az OWL Lite dokumentumok nem használhatják az alábbi szókészletet:

• owl:unionOf
• owl:complementOf
• owl:oneOf
• owl:hasValue
• owl:disjointWith

Az owl:equivalentClass típusú tripletek alanyai vagy tárgyai nem lehetnek üres csomópontok.

Az owl:minCardinality, az owl:maxCardinality és az owl:cardinality állítmányú tripletek tárgya csak egy olyan adat-literál lehet, amelynek értéke 0 vagy 1 (nemnegatív egész szám).

Az OWL Lite-nál az owl:intersectionOf használatával kapcsolatos helyzet egy kicsit bonyolultabb, mint az OWL DL-nél. Ez az állítmány itt nem használható tetszőleges kifejezések alkotására, de nélkülözhetetlen ahhoz, hogy komplett osztálydefiníciókat tudjunk ábrázolni. A fenti (OWL DL típusú) megkötések azt mondják ki, hogy minden olyan triplet alanya, amelynek állítmánya owl:intersectionOf, egy owl:Class kell hogy legyen. Az OWL Lite-nál ehhez még az a megkötés is társul, hogy ez az OWL osztály egy névvel kell hogy rendelkezzék, tehát nem lehet egy üres csomópont.

Egyebek

Óvatosnak kell lennünk az owl:Thing használatával. Például, ez az OWL-RDF kódrészlet:

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

nem azt mondja az A osztályról, hogy az owl:Thing alosztálya (amit gondolnánk), hanem ténylegesen azt, hogy A az owl:Thing osztály valamilyen névtelen egyedének az alosztálya. Itt tehát egy osztályt egyedként kezeltünk, ami nem legális az OWL DL-ben. A kívánt hatást, vagyis hogy A-t az owl:Thing alosztályaként deklaráljuk, az alábbi kódrészlettel érhetjük el:

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

Vigyázzunk, nehogy összetévesszük az owl:Class és az rdfs:Class osztályt. Az alábbi pl. nem DL kód, mivel c számára nem deklaráltunk megfelelő típust.

c rdf:type rdfs:Class

Lábjegyzetek az E. függelékhez

[1] Természetesen, az a követelmény, hogy mindent tipizálni szükséges, nem vonatkozik az OWL, az RDF és az RDFS névterekben szereplő dolgokra.

[2] Szigorúan véve: ha a tulajdonságot úgy definiáltuk, hogy az egy owl:TransitiveProperty, egy owl:SymmetricProperty vagy egy owl:InverseFunctionalProperty, akkor ez nem szükséges.

[3] Ezek azok a kivételek, amelyek előfordulhatnak:

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

p rdf:type rdf:Property
p rdf:type owl:ObjectProperty

vagy pedig az alábbiak:

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

sőt (korlátozással kapcsolatban) ez is megengedett:

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

F. függelék: Változtatási napló az Ajánlástervezethez képest

1. Hibás lábjegyzet [4] eltávolítása az E. függelék végéről.
2. Egy rdfs:label elem hozzáadása az AnnotationProperty és OntologyProperty tulajdonságtípusokhoz a B. függelékben (lásd az OWL RDF Sémáját), Jacco van Ossenbruggen megjegyzése alapján.
3. Egy megszakadt szekcióhivatkozás kijavítása, valamint ugyanitt, a szabványos szekcióhivatkozási karakterstílus helyreállítása.
4. A külső dokumentumhivatkozások listájának szabványossá tétele.
5. Az rdf:RDF elem követelményleírásának szerkesztői módosítása Minsu Jang

   megjegyzése nyomán.

6. Több szerkesztői módosítás Lacy lektori véleménye alapján.
7. A 7.1 szekciónál egy, az annotációtulajdonságok használatával kapcsolatos magyarázó szöveg beszúrása az OWL DL korlátairól, nyilvános megjegyzések alapján (lásd például Benjamin Nowack hozzászólását). A 7.2 szekció ugyancsak bővült egy mondattal, jelezvén, hogy ugyanazok a korlátozások érvényesek az ontológiatulajdonságokra is.
8. Több kisebb szerkesztői javítás végrehajtása a szöveg utolsó átolvasása után.

A külső dokumentumhivatkozások listája

[OWL Áttekintés]

Az OWL Web Ontológia Nyelv – Áttekintés, W3C Ajánlás, 2004. Február 10. Szerkesztők: Deborah L. McGuinness és Frank van Harmelen. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/owl-features/

[OWL Útmutató]

Az OWL Web Ontológia Nyelv – Útmutató, W3C Ajánlás, 2004. Február 10. Szerkesztők: Michael K. Smith, Chris Welty, és Deborah L. McGuinness. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/owl-guide/

[OWL Sz&ASz]

Az OWL Web Ontológia Nyelv – Szemantika és absztrakt szintaxis, W3C Ajánlás, 2004. Február 10. Szerkesztők: Peter F. Patel-Schneider, Patrick Hayes, és Ian Horrocks. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/owl-semantics/ .

[OWL Tesztsorozat]

Az OWL Web Ontológia Nyelv – Tesztsorozat, W3C Ajánlás, 2004. Február 10. Szerkesztők: Jeremy J. Carroll és Jos De Roo. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/owl-test/

[OWL Követelmények]

Az OWL Web Ontológia Nyelv – Alkalmazási esetek és követelmények, W3C Ajánlás, 2004. Február 10. Szerkesztő: Jeff Heflin. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/webont-req/

[RDF Fogalmak]

Az RDF Erőforrás Leíró Keretrendszer alapfogalmai és absztrakt szintaxisa, W3C Ajánlás, 2004. Február 10. Szerkesztők: Graham Klyne és Jeremy J. Carroll. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/rdf-concepts/ .

[RDF Szintaxis]

Az RDF/XML Szintaxis Specifikációja (Átdolgozott kiadás), W3C Ajánlás, 2004. Február 10. Szerkesztő: Dave Beckett. A mindenkori legutolsó (eredeti angol) változat: //www.w3.org/TR/rdf-syntax-grammar/ .

[RDF Szemantika]

Az RDF Szemantikája, W3C Ajánlás, 2004. Február 10. Szerkesztő: Pat Hayes. A mindenkori legutolsó (eredeti angol) változat: http://www.w3.org/TR/rdf-mt/ .

[RDF Szókészlet]

Az RDF Szókészlet Leíró Nyelv 1.0: RDF Séma, W3C Ajánlás, 2004. Február 10. Szerkesztők: Dan Brickley és R. V. Guha. A mindenkori legutolsó (eredeti angol) változat: //www.w3.org/TR/rdf-schema/ .

[DAML+OIL]

DAML+OIL (March 2001) Reference Description. Dan Connolly, Frank van Harmelen, Ian Horrocks, Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea Stein. W3C Note 18 December 2001. Latest version is available at http://www.w3.org/TR/daml+oil-reference.

[XML-SCHEMA2]

XML Schema Part 2: Datatypes - W3C Recommendation, World Wide Web Consortium, 2 May 2001.