Bevezetés
Az elõzõ fejezetben láthattuk, hogyan használható az RDF nyelv erõforrásokhoz metainformációk kapcsolására. Létezik egy RDF séma nyelv, mely RDF erõforrások egy halmaz. Ez egy könnyûsúlyú ontológianyelv, mely egyszerûbb feladatokra használható, de erre most nem térünk ki részletesen. Ezzel szemben az OWL egy nehézsúlyú ontológianyelv, melyet a W3C arra az esetre ajánl, ha az RDF séma által nyújtott képességek nem elegendõek.
Az OWL résznyelvei
Az OWL három résznyelvet definiál, melynek eltérõ a kifejezõereje és a reprezentált tudáson való következtetés hatékonysága, ezek az OWL Full, OWL DL és az OWL Lite. Az OWL Full minden nyelvi elemet tartalmaz, ezzel szemben az OWL DL kevesebbet, a Lite pedig még kevesebbet. Mindezt azért teszik, hogy hatékonyabban lehessen következtetni az egyes résznyelveken. A nyelvi elemek ismertetésénél mindig megadásra kerül majd, hogy melyik az a résznyelv, ami már tartalmazza az adott elemet.
1. OWL Lite
Ebbõl a résznyelvbõl bizonyos konstrukciók teljesen hiányoznak. Olyan felhasználók támogatására készült, akik elsősorban osztályozási hierarchiákat és egyszerű korlátozásokat alkalmaznak. Így például támogatja a kardinalitáskorlátozást, de a kardinalitás értékeként csak a 0 és 1 értéket engedi meg. Az OWL Lite eszköztámogatása így egyszerűbb lehet, mint a nagyobb kifejező erejű rokonaié. Alapötlete, hogy az RDF sémánál egy kicsivel nagyobb legyen a kifejezõereje, de még kellõen egyszerû legyen, hogy az alkalmazásfejlesztõk könnyen használhassák egyfajta ugródeszkaként a komolyabb ontológianyelvek irányába. A SHIF(D) nyelv a legszûkebb leíró logikai nyelv melyben leírhatók az OWL Lite dokumentumok.
2. OWL DL
Az OWL DL neve a Description Logics (leíró logika) kifejezésre utal, mely az OWL formális megalapozásának logikai kérdéseit tárgyaló kutatási terület neve. azokat a felhasználókat támogatja, akik a maximális kifejezőképességet igénylik, mégpedig úgy, hogy a teljes kiszámíthatóság és az eldönthetőség is megmarad (vagyis, hogy minden konklúzió garantáltan kiszámítható, és minden számítás véges időn belül be is fejeződik). Tartalmazza az összes OWL nyelvi konstrukciót, csak bizonyos típus-szétválasztási korlátozásokkal használhatók. Megköveteli, hogy az osztályokat, adattípusokat, egyedtulajdonságokat, adattípus tulajdonságokat, annotációs és ontológia tulajdonságokat, egyedeket, értékeket és a beépített osztályokat és tulajdonságokat azonosító URI-k páronként különbözzenek. Ennek megfelelõen egy erõforrás például nem lehet egyszerre osztály és egyed is. Az OWL DL dokumentumokat az SHOIN(D) leíró logikai nyelvre lehet transzformálni.
3. OWL Full
Az OWL Full alnyelvet olyan felhasználóknak szánták, akik a maximális kifejező erőt és az RDF szintaktikai szabadságát igénylik, de ennek fejében lemondanak a kiszámíthatósági garanciákról. Például az OWL Full-ban egy osztály egyidejűleg kezelhető egyedek gyűjteményeként és más osztályok egyedeként is. Lehetővé teszi egy ontológiának, hogy kiterjessze az előre definiált (RDF vagy OWL) szókészlet jelentéstartományát, viszont nem feleltethetõ meg egyetlen leíró logikai nyelvnek sem. Az OWL Full nyelvû dokumentumon való következtetéshez elsõrendû következtetési képességek kellenek, de ekkor is számos trükkre van szükség a dokumentum elsõrendû logikai állításokká való konvertálásához.
E három alnyelv mindegyike az egyszerűbb elődjének a kiterjesztése abban a tekintetben, hogy mit lehet vele legálisan kifejezni, és abban a tekintetben is, hogy a velük ábrázolt ontológiából mit lehet érvényesen kikövetkeztetni. E nyelvekre vonatkozóan az alábbi kijelentések érvényesek
- Minden legális OWL Lite ontológia egyben legális OWL DL ontológia is.
- Minden legális OWL DL ontológia egyben legális OWL Full ontológia is.
- Minden érvényes OWL Lite konklúzió egyben érvényes OWL DL konklúzió is.
- Minden érvényes OWL DL konklúzió egyben érvényes OWL Full konklúzió is.
Az ontológiák struktúrája
Az OWL fejlesztése a Szemantikus Web munkaprogram része, és arra irányul, hogy a Web adatforrásait alkalmasabbá tegyék az automatikus feldolgozásra azáltal, hogy egzakt információkat adnak meg azokról az adatforrásokról, amelyek leírják vagy előállítják a Web tartalmát. Tekintve, hogy a Szemantikus Web a jellegéből adódóan elosztott rendszer, az OWL-nak lehetővé kell tennie, hogy az információkat elosztott forrásokból is lehessen gyűjteni.
1. Névterek
Mielőtt egy kifejezéshalmazt elkezdünk használni, pontosan meg kell jelölnünk, hogy melyik konkrét szókészletből való. Az ontológiák szabványos bevezető eleme egy sor XML névtér deklarációt tartalmaz az rdf:RDF nyitótag-gel bevezetve. Ezek az ontológia további szövegét könnyebben olvashatóvá, az azonosítók interpretálását pedig egyértelművé teszik. Egy tipikus OWL ontológia az alábbihoz hasonló névtérdeklarációval kezdődik:
<rdf:RDF xmlns ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xmlns:vin ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xml:base ="http://www.w3.org/TR/2004/REC-owl-guide-20040210/wine#" xmlns:food="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food#" xmlns:owl ="http://www.w3.org/2002/07/owl#" xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xsd ="http://www.w3.org/2001/XMLSchema#">
2. Ontológia-headerek
Ha a névtereket már definiáltuk, akkor az owl:Ontology tag alatt általában teszünk néhány állítást magáról az ontológiáról. Ez a tag olyan lényeges szervezési feladatot lát el, mint az ontológia kommentálása, verziókontroll és más ontológiák beépítése.
<owl:Ontology rdf:about=""> <rdfs:comment>Egy ontológia példa</rdfs:comment> <owl:priorVersion rdf:resource="http://www.w3.org/TR/2003/PR-owl-guide-20031215/wine"/> <owl:imports rdf:resource="http://www.w3.org/TR/2004/REC-owl-guide-20040210/food"/> <rdfs:label>Wine Ontology</rdfs:label> ... </owl:Ontology>Az owl:imports egy olyan jellegű mechanizmust jelent, mint a C nyelvnél az "#include" direktíva. Az owl:imports egyetlen argumentumot használ, amelyet az rdf:resource attribútum azonosít.
3. Adategyesítés és 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 segíti az adatok összekapcsolását. A nyelv beépített szemantikája támogatja az ilyen információk logikai feldolgozását is, s ez nem várt eredményekhez vezethet. Különösen igaz ez, pl. owl:sameAs kifejezésre, amellyel látszólag különböző egyedekről azt állíthatjuk, hogy valójában azonosak. A Szemantikus Web-nek az a képessége, hogy több forrásból lehet 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, kombinálva az OWL következtető képességeivel, magában hordja a visszaélés lehetőségét is.
Alapvető elemek
Egy OWL ontológia legtöbb eleme az osztályokkal, tulajdonságokkal, az osztályok egyedeivel és a köztük lévő viszonyokkal kapcsolatos. Ez a fejezet bemutatja azokat a nyelvi komponenseket, amelyek fontosak az ilyen elemek bevezetéséhez.
1. Egyszerű nevesített osztályok
Egy tématerület legáltalánosabb fogalmait olyan osztályoknak kell megfeleltetnünk, amelyek majd a különböző taxonómia fák gyökerei lesznek (taxonómia: tudományos rendszerre épülő osztályozás, meghatározva a hierarchiai szinteket, a fogalmak szabályozott formában szerepelnek benne a jobb visszakereshetőség érdekében). Az OWL világában minden egyed az owl:Thing (Valami) osztály tagja. Így a felhasználó által definiált minden osztály implicite szintén az owl:Thing osztály alosztálya. Egy tématerület gyökérosztályait egyszerű nevesített osztályok definiálásával hozzuk létre. Az OWL definiál egy üres osztályt is, amelynek a neve owl:Nothing (Semmi). Például:
<owl:Class rdf:ID="Winery"/> <owl:Class rdf:ID="Region"/> <owl:Class rdf:ID="ConsumableThing"/>Jegyezzük meg, hogy itt egyelőre csak azt mondtuk, hogy létezik három osztály, amelynek ezeket a neveket adtuk, és ezt az 'rdf:ID=' szintaxissal jelöltük. A létezésükön kívül, formálisan, szinte semmit sem tudunk ezekről az osztályokról, annak ellenére sem, hogy ismerős angol kifejezéseket használtunk a megnevezésükre. Alapvető taxonómiaépítő-elem az osztályok számára az rdfs:subClassOf. Ez egy specifikusabb osztályt definiál, amelyet egy általánosabb osztály alá sorol. Ha X az Y alosztálya, akkor X minden egyede Y-nak is egyede. Az rdfs:subClassOf reláció tranzitív: ha X az Y alosztálya, és Y a Z alosztálya, akkor X szintén alosztálya Z-nek.
<owl:Class rdf:ID="PotableLiquid"> <rdfs:subClassOf rdf:resource="#ConsumableThing" /> ... </owl:Class>Itt definiáltuk a PotableLiquid (IhatóFolyadék) osztályt mint a ConsumableThing (FogyaszthatóDolog) alosztályát. A Web alapú ontológiák világában ezt a két osztályt egy-egy külön ontológiában lehetne definiálni, amelyek előállítanák az alapvető építőkockákat az étel és ital ontológiák széles választékához, ahogy meg is tettük. Ezek az osztályok a "food" ontológiában vannak definiálva, amelyet importáltunk a "wine" ontológiába. A "food" és a "wine" ontológiák kölcsönösen függenek egymástól, éppen azért, hogy megfeleljenek a célnak: az ételek és borok párosításának. Ezen a ponton most már készíthetünk egy egyszerű (de nem komplett) definíciót a Wine osztály számára.
<owl:Class rdf:ID="Wine"> <rdfs:subClassOf rdf:resource="&food;PotableLiquid"/> <rdfs:label xml:lang="en">wine</rdfs:label> <rdfs:label xml:lang="fr">vin</rdfs:label> ... </owl:Class>A "wine" definíciónk még messze nem teljes. Még semmit sem tudunk meg belőle a borról azon kívül, hogy ez Valami, és hogy IhatóFolydék, de már van elegendő információnk ahhoz, hogy megnevezhessük az egyedeit, és ezekről információkat szerezhessünk.
2. Egyedek
Az osztályok mellett az is szükséges, hogy leírhassuk ezek tagjait. Általában úgy gondolunk az egyedekre, mint a dolgok univerzumának egyedeire. Egy egyed minimális bevezetése az által történik, hogy egy osztály tagjaként deklaráljuk. Azért, hogy legyen készenlétben még néhány további osztályunk a következő szekciókban bemutatandó tulajdonságok számára, alább definiáljuk a Grape (Szőlő) taxonómia egyik ágát egy alosztálya (WineGrape = Borszőlő), és annak egy egyede (a Cabernet Sauvignon borszőlőfajta) által. A szőlőfajták a "food" ontológiában vannak definiálva:
<owl:Class rdf:ID="Grape"> ... </owl:Class>És így a Wine antológiában a következőket definiálhatjuk:
<owl:Class rdf:ID="WineGrape"> <rdfs:subClassOf rdf:resource="&food;Grape" /> </owl:Class>
<WineGrape rdf:ID="CabernetSauvignonGrape" />Amint arról szó lesz a következő szekcióban, a CabernetSauvignonGrape egy egyed, mert egy konkrét borszőlőfajtát azonosít.
3. A használat megtervezése
Felmerül néhány fontos kérdés az OWL-ban az osztály és az egyed megkülönböztetésével kapcsolatban. Egy osztály nem más, mint egy név, valamint olyan tulajdonságok kollekciója, mely egyedek halmazát írja le. Az egyedek ennek a halmaznak az elemei. Így az osztályoknak meg kell felelniük a dolgok természetes halmazainak a szóban forgó tématerületen, az egyedeknek pedig meg kell felelniük azoknak a konkrét entitásoknak, amelyek ezekbe az osztályokba becsoportosíthatók. Az ontológiák építésében ez a megkülönböztetés gyakran kétféle okból is homályos lehet:
- Az ábrázolás szintjei: Bizonyos környezetekben valamit, ami nyilvánvalóan osztály, egyben egy másik osztály egyedének is lehet tekinteni. Például a bor ontológiában van egy olyan fogalmunk, hogy "grape" (szőlő), mely arra szolgál, hogy megjelölje az összes szőlőfajták halmazát. A CabernetSauvingonGrape, például egyik egyede ennek az osztálynak, minthogy ez megnevez egy konkrét szőlőfajtát a Cabernet Sauvignon-t. Azonban maga a CabernetSauvignonGrape is tekinthető osztálynak, például a konkrét Cabernet Sauvignon szőlők osztályának.
- Alosztály vagy egyed? Nagyon könnyű összekeverni az "egyede" relációt az "alosztálya" relációval. Például mindegynek tűnhet, hogy a CabernetSauvignonGrape-et a Grape egyedének vagy az alosztályának nyilvánítjuk-e. Pedig ez nem tetszőleges döntés. A Grape osztály az összes szőlőfajták halmaza, és ezért annak bármelyik alosztálya a szőlőfajták egy-egy részhalmazát jelöli. Ezért tehát a CabernetSauvignonGrape a Grape egyede, és nem alosztálya. (Ugyanis, a szőlőfajtáknak nem egy részhalmazát írja le, hanem egy konkrét szőlőfajtát.)
4. Tulajdonságok definiálása
A Tulajdonságok (Properties) lehetővé teszik számunkra, hogy közös jellemzőket adjunk meg egy osztály összes tagjáról, és hogy egyedi tényeket állítsunk ezek meghatározott egyedeiről. A tulajdonság bináris reláció, azaz két dolog logikai kapcsolatát leíró fogalom. A tulajdonságok két típusát különböztetetjük meg:
- Adattípus-tulajdonságok (datatype properties), azaz egyedek és adatok (RDF literálok vagy XML Séma adattípusok) közötti relációk.
- Objektumtulajdonságok (object properties), azaz osztályok egyedei közötti relációk.
<owl:ObjectProperty rdf:ID="madeFromGrape"> <rdfs:domain rdf:resource="#Wine"/> <rdfs:range rdf:resource="#WineGrape"/> </owl:ObjectProperty>A madeFromGrape (~SzőlőbőlKészült) tulajdonság érvényességi köre (domain) a Wine osztály, az értéktartománya (range) pedig a WineGrape osztály. Vagyis, ez a tulajdonság a Wine osztály egyedeit kapcsolja a WineGrape osztály egyedeihez. Jegyezzük meg, hogy a domain és a range információk az OWL-ban nem azonosak a programozási nyelvekben használt type információval. A típusokat egyebek között a konzisztencia ellenőrzésére használják a programnyelvek. Az OWL-ban egy range egy típus kikövetkeztetésére használható. A tulajdonságok, ugyanúgy mint az osztályok, hierarchiába rendezhetők:
<owl:Class rdf:ID="WineDescriptor" />
<owl:Class rdf:ID="WineColor"> <rdfs:subClassOf rdf:resource="#WineDescriptor" /> ... </owl:Class>
<owl:ObjectProperty rdf:ID="hasWineDescriptor"> <rdfs:domain rdf:resource="#Wine" /> <rdfs:range rdf:resource="#WineDescriptor" /> </owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="hasColor"> <rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" /> <rdfs:range rdf:resource="#WineColor" /> ... </owl:ObjectProperty>A WineDescriptor (BorJellemző) tulajdonságok a borokat a színükkel, az összetevőikkel, és az ízük komponenseivel (édesség, testesség, aroma) kapcsolják össze. A hasColor (színe) tulajdonság a hasWineDescriptor (BorJellemzője) tulajdonság altulajdonsága, amelynek az értéktartományát tovább korlátozzuk a WineColor (BorSzín) osztályra. Az rdfs:subPropertyOf reláció ebben az esetben azt jelenti, hogy bármi, aminek van egy hasColor tulajdonsága X értékkel, annak van egy hasWineDescriptor tulajdonsága is X értékkel.
5. Tulajdonságok és adattípusok
A tulajdonságokat megkülönböztetjük azon az alapon, hogy egyedeket kapcsolnak-e egyedekhez (objektumtulajdonságok), vagy egyedeket adattípusokhoz (adattípus-tulajdonságok). Az OWL használja a legtöbb beépített XML Séma adattípust. Az alábbi adattípusok ajánlottak az OWL-ban való használatra:
| xsd:string | xsd:normalizedString | xsd:boolean | |
| xsd:decimal | xsd:float | xsd:double | |
| xsd:integer | xsd:nonNegativeInteger | xsd:positiveInteger | |
| xsd:nonPositiveInteger | xsd:negativeInteger | ||
| xsd:long | xsd:int | xsd:short | xsd:byte |
| xsd:unsignedLong | xsd:unsignedInt | xsd:unsignedShort | xsd:unsignedByte |
| xsd:hexBinary | xsd:base64Binary | ||
| xsd:dateTime | xsd:time | xsd:date | xsd:gYearMonth |
| xsd:gYear | xsd:gMonthDay | xsd:gDay | xsd:gMonth |
| xsd:anyURI | xsd:token | xsd:language | |
| xsd:NMTOKEN | xsd:Name | xsd:NCName |
6. Tulajdonságjellemzők
A következő néhány szakasz azokat a mechanizmusokat írja le, amelyekkel tovább pontosíthatjuk a tulajdonságokat. Lehetőségünk van például tulajdonságjellemzőket (property characteristics) specifikálni, amelyek hatékony mechanizmusokat adnak a kezünkbe a tulajdonságokkal kapcsolatos magasabb rendű következtetések levonására.
- Tranzitív tulajdonság (Ha egy P tulajdonságot tranzitívnak specifikálunk, akkor minden x, y és z-re igaz, hogy ha P(x,y) és P(y,z) akkor P(x,z)). Ilyen például az 'őse' reláció.
- Szimmetrikus tulajdonság (Ha egy P tulajdonságot szimmetrikusnak címkézünk, akkor minden x-re és y-ra igaz, hogy ha P(x,y) akkor P(y,x) és megfordítva, vagyis a két kifejezés kölcsönösen implikálja egymást). Kézenfekvõ példa a 'testvére' reláció.
- Funkcionális tulajdonság (Ha egy P tulajdonságot funkcionálisnak címkézünk, akkor minden x, y, és z-re igaz, hogy ha P(x,y) és P(x,z) akkor y = z) Ez a tulajdonság megadja, hogy egy adott alanyhoz csak egy tárgy kapcsolható. Ilyen például az 'apja' reláció, ahol jogos elvárás, hogy egy embernek csak egy apja legyen.
- Fordított tulajdonság (Ha egy P1 tulajdonságot úgy címkézünk, hogy owl:inverseOf P2, akkor minden x-re és y-ra igaz, hogy ha P1(x,y) akkor P2(y,x) és megfordítva, vagyis a két kifejezés kölcsönösen implikálja egymást) például, hogy mindenki a saját gyermekének a szülõje.
- Fordított funkcionális tulajdonság (Ha egy P tulajdonságot InverseFunctional-ként címkézünk akkor minden x, y és z-re igaz, hogy ha P(y,x) és P(z,x) akkor y=z). Itt egy adott tárgyat csak egy alanyhoz lehet hozzákapcsolni. Erre egy példa, hogy egy konkrét háznak csak egy tulajdonosa lehet egyszerre.
7. Tulajdonságkorlátozások
A tulajdonságjellemzők mellett lehetőségünk van még tovább korlátozni egy tulajdonság értéktartományát bizonyos környezetekben és különböző módokon. Ezt a tulajdonságkorlátozásokkal valósítjuk meg. Ezeknek az alábbiakban leírt különböző formáit csak egy owl:Restriction kontextusban (azaz egy ilyen tag-pár által közrefogott definíciószakaszon belül) használhatjuk. Az owl:onProperty elem jelöli a korlátozandó tulajdonságot.
- Tulajdonság értékeinek korlátozása
Az owl:allValuesFrom korlátozás azt köti ki, hogy egy olyan osztály minden egyede számára, amelyiknek vannak a specifikált tulajdonsággal rendelkező egyedei, a tulajdonság lehetséges értékeit az owl:allValuesFrom záradékkal megjelölt osztály összes tagja alkotja. Az alábbi példában az osztályba olyan egyedek tartoznak melyeknek minden gyermekük szép:
<owl:Restriction> <owl:onProperty rdf:resource="#gyermeke"/> <owl:allValuesFrom rdf:resource="#Szép"/> </owl:Restriction>
Hasonló a helyzet az owl:someValuesFrom korlátozással. Az alábbi példa megad egy osztályt, melybe olyan egyedek tartoznak, akik ismernek legalább egy olyan illetõt, akinek minden gyermeke okos:<owl:Restriction> <owl:onProperty rdf:resource="#ismerõse"/> <owl:someValuesFrom> <owl:Restriction> <owl:onProperty rdf:resource="#gyermeke"/> <owl:allValuesFrom rdf:resource="#Okos"/> </owl:Restriction> </owl:someValuesFrom> </owl:Restriction>
A két korlátozás közötti logikai különbség nem más, mint az elsőrendű logika univerzális és egzisztenciális kvantora közötti különbség. - Tulajdonság kardinalitásának korlátozása Már láttunk példákat a kardinalitás korlátozására. Eddig azonban ezek csak a kardinalitás minimális értékére vonatkoztak (owl:minCardinality). Ennél még szigorúbb az owl:Cardinality, mely lehetővé teszi, hogy pontosan megadjuk egy adott reláció előfordulásainak a számát egy adott osztály esetén. A 0 és 1 értékre korlátozott kardinalitás már az OWL Lite-ban is használható. Ezzel a felhasználó azt mondhatja, hogy annak értéke 'legalább egy', 'legfeljebb egy', vagy 'pontosan egy'. Az OWL DL megengedi a 0 és 1 értékeken kívül, a többi pozitív egész szám megadását is. Az owl:maxCardinality korlátozással a felső határát, az owl:minCardinality-val pedig az alsó határát specifikáljuk. A kettő kombinálásával egy numerikus intervallumon belül határozhatjuk meg, hogy egy adott osztály bármelyik egyede hányszor kapcsolható az így korlátozott relációval más egyedekhez.
- Tulajdonság értékének megadása [OWL DL]
A hasValue tulajdonságkorlátozás lehetővé teszi, hogy osztályokat definiáljunk egy meghatározott tulajdonságérték megléte alapján. Ebből következően
egy egyed ennek az osztálynak a tagja lesz, ha a tulajdonság értékeinek legalább egyike egyenlő a hasValue kifejezésben megadott értékkel.
<owl:Class rdf:ID="Burgundy"> ... <rdfs:subClassOf> <owl:Restriction> <owl:onProperty rdf:resource="#hasSugar" /> <owl:hasValue rdf:resource="#Dry" /> </owl:Restriction> </rdfs:subClassOf> </owl:Class>Itt azt deklaráltuk, hogy minden Burgundi bor száraz. Azaz, kell hogy legyen legalább egy olyan "cukrossága" tulajdonsága, amelynek értéke: "Száraz". Ugyanúgy, mint az allValuesFrom és a someValuesFrom, ez is egy helyi korlátozás (local restriction), mivel a hasSugar tulajdonságot csak a Burgundy osztályon belül korlátozza.
Ontológiák egyesítése
Ahhoz, hogy ontológiáink elérjék a maximális hatásukat, az kell, hogy széles körben használják őket. Ehhez pedig elengedhetetlen, hogy a fejlesztésükhöz szükséges erőfeszítéseket minimalizáljuk. Ezért az ontológiáknak újrafelhasználhatóknak kell lenniük. Fontos észrevennünk, hogy az ontológiák fejlesztésében a legtöbb erőfeszítést arra kell fordítanunk, hogy olyan módokon kapcsoljunk össze osztályokat és tulajdonságokat, hogy ezek sokféle információ kinyerésére adjanak lehetőséget. Azt szeretnénk, ha az osztályokról és tagjaikról tett egyszerű állításainkból messzemenő és hasznos következtetéseket lehetne levonni. Az ontológiák fejlesztésében azonban éppen ez a legnagyobb kihívás. Ezért, ha sikerül találnunk egy olyan meglévő ontológiát, amelyik sok finomításon átesett már át, és széles körben használják, akkor érdemes azt adoptálnunk.
1. Egyenértékűség osztályok, tulajdonságok között (equivalentClass, equivalentProperty)
Ahhoz, hogy egy sor meglévő ontológiát komponensként egy újabb ontológiába beépíthessünk, gyakran meg kell jelölnünk, hogy az egyik ontológiában egy adott osztály vagy tulajdonság egyenértékű egy másik ontológia valamelyik osztályával vagy tulajdonságával. Ezt a lehetőséget azonban körültekintően kell használni. Ha ugyanis a kombinált ontológiák ellentmondásosak (pl. azt mondjuk, hogy minden A egyenértékű minden B-vel, miközben ez nem igaz), akkor az osztálynak esetleg nem lesz olyan kiterjedése, amelyik kielégítené az új kombinációt. Az étel ontológiában az étkezési fogások leírásánál szeretnénk a Bor ontológia egyes elemeihez kapcsolódni. Ennek egyik módja, hogy definiálunk egy osztályt az Étel ontológiában (&food;Wine) és azt egyenértékűnek deklaráljuk a bor ontológiában már meglévő Bor osztállyal (&vin;Wine).
<owl:Class rdf:ID="Wine"> <owl:equivalentClass rdf:resource="&vin;Wine"/> </owl:Class>Az owl:equivalentClass tulajdonságot használjuk annak jelölésére, hogy a két osztálynak pontosan ugyanazok az egyedei. Megjegyzendő, hogy az OWL DL-ben az osztályok csak egyedek halmazait jelölik, de maguk nem lehetnek egyedek. Az OWL Full-ban viszont használhatjuk az owl:sameAs kifejezést két osztály között annak jelölésére, hogy ezek minden vonatkozásban azonosak. A tulajdonságok hasonló módon történő összekapcsolására az owl:equivalentProperty konstruktort használjuk.
2. Egyedek azonossága (sameAs)
Ez a mechanizmus az osztály-ekvivalenciánál leírtakhoz hasonló, de itt két egyedet deklarálunk azonosnak. Egy példa erre:
<Wine rdf:ID="MikesFavoriteWine"> <owl:sameAs rdf:resource="#StGenevieveTexasWhite" /> </Wine>Ennek a példának nincs különösebb haszna. Amit ebből megtudunk, az csak annyi, hogy Mike kedvel egy olcsó helyi borfajtát. Sokkal tipikusabb használata a sameAs kifejezésnek az, amikor két ontológia egyesítése során, két egyedet, amelyet két különböző dokumentumban más-más néven definiáltak, azonosnak jelentünk ki. Ez ráirányítja a figyelmet egy nagyon fontos dologra: az OWL nem feltételez egyedi neveket. Így tehát pusztán az, hogy a nevek különböznek, még nem jelenti azt, hogy ezek különböző egyedekre is hivatkoznak. Jegyezzük meg, hogy a sameAs használata két osztály egyenlővé tételére nem ugyanaz, mintha az owl:equivalentClass segítségével tettük volna ugyanezt, mert az előbbi forma egyedként interpretál egy osztályt, és ez elegendő ahhoz, hogy ontológiánkat OWL Full kategóriájúvá minősítse át. Az OWL Full-ban a sameAs használható bárminek az egyenlővé nyilvánítására: egy osztálynak és egy egyednek, egy tulajdonságnak és egy osztálynak stb., ugyanis az OWL Full mindkét argumentumot eleve egyednek tekinti.
3. Egyedek különbözősége (differentFrom, AllDifferent)
Ez a mechanizmus a sameAs hatásának a fordítottját állítja elő.
<WineSugar rdf:ID="Dry" /> <WineSugar rdf:ID="Sweet"> <owl:differentFrom rdf:resource="#Dry"/> </WineSugar> <WineSugar rdf:ID="OffDry"> <owl:differentFrom rdf:resource="#Dry"/> <owl:differentFrom rdf:resource="#Sweet"/> </WineSugar>Ez egyik módja annak, hogy kijelentsük pl. a bor cukrosságát jelző Sweet, Dry és offDry egyedekről (Édes, Száraz, Félédes), hogy mindegyikük különbözik a többitől. Vannak olyan esetek, amikor garantálnunk kell különböző entitások kölcsönös különbözőségét. Létezik egy alkalmasabb mechanizmus is, amellyel kölcsönösen különböző egyedek halmazát lehet definiálni. A következő példa azt jelenti ki, hogy a Red, White és Rose egyedek minden párkombinációban különböznek egymástól.
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType="Collection">
<vin:WineColor rdf:about="#Red" />
<vin:WineColor rdf:about="#White" />
<vin:WineColor rdf:about="#Rose" />
</owl:distinctMembers>
</owl:AllDifferent>
Megjegyzés: az owl:distinctMembers felsorolás elem csak az owl:AllDifferent-tel kombinálva használható.
Összetett osztályok
Az OWL további konstruktorokat is biztosít, amelyekkel osztályokat képezhetünk. Ezek a konstruktorok ún. osztálykifejezések előállítására használhatók. Az OWL támogatja az alapvető halmazműveleteket, nevezetesen az uniót, a metszetet és a komplementer halmaz képzését. Ezeket owl:unionOf, owl:intersectionOf és owl:complementOf néven vezeti be a nyelv. Emellett felsorolás osztályokat is deklarálhatunk. Az osztálykiterjedéseket explicit módon a oneOf konstruktorral adhatjuk meg. Az osztályok kiterjedéseit diszjunkt halmazoknak is minősíthetjük. Megjegyezzük, hogy az osztálykifejezések egymásba ágyazhatóak anélkül, hogy a közbülső osztályoknak nevet kellene adnunk. Ez a halmazműveletekkel együtt lehetővé teszi összetett osztályok képzését névtelen osztályokból vagy érték-korlátozott osztályokból.
1. Halmazműveletek (intersectionOf, unionOf, complementOf)
Egy OWL osztály kiterjedése olyan halmaz, mely az osztály egyedeiből áll. Az OWL lehetővé teszi, hogy az alapvető halmazoperátorok segítségével manipulálhassuk az osztályok kiterjedéseit.
- Metszet:
Azok az osztályok, amelyeket halmazműveletekkel konstruálunk, sokkal inkább hasonlítanak valódi osztálydefiníciókra, mint azok, amelyeket eddig láttunk. Az osztály tagjait teljesen specifikálják a halmazműveletek. Az alábbi konstrukció azt mondja ki, hogy a FehérBor (WhiteWine) pontosan a Bor osztálynak és a fehér színű dolgok halmazának a metszete. Ez azt jelenti, hogy ha valami bor és fehér, akkor az a FehérBor osztály egyede. Egy ilyen definíció nélkül felismerhetnénk, hogy a FehérBor az bor és fehér, de megfordítva már nem. Ez egy nagyon fontos eszköz az egyedek kategorizálására.
<owl:Class rdf:ID="WhiteWine"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Wine" /> <owl:Restriction> <owl:onProperty rdf:resource="#hasColor" /> <owl:hasValue rdf:resource="#White" /> </owl:Restriction> </owl:intersectionOf> </owl:Class>Az OWL Lite korlátozza a metszetképzés használatát. Az osztályleírások listájában csak megnevezett osztályok és tulajdonságkorlátozással megadott osztályok szerepelhetnek. - Unió:
Az alábbi példa demonstrálja a unionOf konstrukció használatát. Ezt pontosan ugyanúgy használjuk, mint az intersectionOf konstrukciót:
<owl:Class rdf:ID="Fruit"> <owl:unionOf rdf:parseType="Collection"> <owl:Class rdf:about="#SweetFruit" /> <owl:Class rdf:about="#NonSweetFruit" /> </owl:unionOf> </owl:Class>A Gyümölcs (Fruit) osztály tartalmazza mind az édes, mind a nem édes gyümölcsöket (SweetFruit, NonSweetFruit). Az OWL Lite nyelvben nem használható az unióképzés. - Komplementer:
A complementOf konstrukció kiválasztja mindazon egyedeket az ábrázolt tématerületről, amelyek nem tartoznak egy bizonyos osztályhoz. Általában ez az egyedek igen nagy halmazát jelenti
<owl:Class rdf:ID="ConsumableThing" /> <owl:Class rdf:ID="NonConsumableThing"> <owl:complementOf rdf:resource="#ConsumableThing" /> </owl:Class>A NemFogyaszthatóDolog (NonConsumableThing) osztály tagjai mindazon egyedek, amelyek nem tartoznak a FogyaszthatóDolog (ConsumableThing) osztály kiterjedéséhez. A NonConsumableThing halmaz pontosan az owl:Thing és a ConsumableThing halmazok különbsége. Az OWL Lite nyelvben nem használható a komplementerképzés.
2. Felsorolás osztályok (oneOf)
Az OWL eszközei lehetővé teszik, hogy osztályokat specifikáljunk a tagjaik közvetlen felsorolásával. Ezt a oneOf construkció valósítja meg. Ez az egyetlen olyan definíció, mely véglegesen specifikálja az osztály kiterjedését, vagyis további egyedek utólag már nem deklarálhatók az osztály tagjaiként. Az alábbi példa a BorSzín (WineColor) osztályt definiálja, amelynek elemei a fehér, a rosé és a vörös (White, Rose és a Red) egyedek.
<owl:Class rdf:ID="WineColor">
<rdfs:subClassOf rdf:resource="#WineDescriptor"/>
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#White"/>
<owl:Thing rdf:about="#Rose"/>
<owl:Thing rdf:about="#Red"/>
</owl:oneOf>
</owl:Class>
Az első, amit itt meg kell értenünk az az, hogy semmilyen más egyed nem lehet érvényes BorSzín, mivel az osztályt az egyedek felsorolásával végleg definiáltuk.
A oneOf konstrukció minden elemének egy érvényesen deklarált egyednek kell lennie. Egy egyednek mindig egy osztályhoz kell tartoznia. A fenti példában minden egyedre névvel hivatkoztunk, ehhez pedig a legegyszerűbb klisét, az owl:Thing-et használtuk. Egy másik lehetőségként a halmaz elemeire is hivatkozhattunk volna a specifikus típusukkal (ami történetesen a WineColor). Ez a konstrukció nem használható az OWL Lite nyelv esetében. Az OWL DL nyelv esetében használható, amennyiben a kollekció minden eleme egy alaphalmazból kerül ki.
3. Diszjunkt osztályok (disjointWith)
Az osztályok egy adott halmazának a diszjunkt voltát az owl:disjointWith konstruktorral fejezhetjük ki. Ez garantálja, hogy egy egyed, amelyik egy osztálynak a tagja, nem lehet egyidejűleg egy másik adott osztálynak is a tagja.
<owl:Class rdf:ID="Pasta"> <rdfs:subClassOf rdf:resource="#EdibleThing"/> <owl:disjointWith rdf:resource="#Meat"/> <owl:disjointWith rdf:resource="#Fowl"/> <owl:disjointWith rdf:resource="#Seafood"/> <owl:disjointWith rdf:resource="#Dessert"/> <owl:disjointWith rdf:resource="#Fruit"/> </owl:Class>A fenti Tészta (Pasta) példánk több diszjunkt osztályt definiál. Jegyezzük meg azonban, hogy itt csak azt állítjuk, hogy a Pasta idegen (diszjunkt) az összes itt felsorolt osztálytól. Nem állítjuk azonban azt, hogy pl. a Meat és a Fruit is idegen egymástól. Ha azt akarjuk kimondani osztályok egy csoportjáról, hogy kölcsönösen idegenek (azaz, hogy nincsenek közös egyedeik), akkor egy külön owl:disjointWith állítást kell tennünk minden lehetséges osztály párral kapcsolatban, amelyik ehhez a csoporthoz tartozik. Az OWL Lite nem támogatja ezt a tulajdonságot.
Ontológiák verziókezelése
Az ontológiák olyanok, mint a szoftver. Ezeket is folyamatosan karban kell tartani, és így állandóan változnak az idők során. A korábban tárgyalt owl:Ontology elemen belül lehetőségünk van az éppen definiált ontológiát az előző verziójához linkelni. Az owl:priorVersion tulajdonság szolgál ennek a linknek a megadására, és ez biztosítja, hogy visszafelé követni tudjuk egy ontológiaverzió történetét.
<owl:Ontology rdf:about=""> ... <owl:priorVersion rdf:resource="http://elozoverzio.com"/> ... </owl:Ontology>A megjelölt ontológia annak az ontológiának az előző verziója, amelyiket éppen definiáljuk. Az ontológiák verziói nem feltétlenül kompatibilisek egymással. Például egy ontológia előző verziójában lehetnek olyan állítások, amelyek ellentmondanak a jelenlegi verziónak. Egy owl:Ontology elemen belül az owl:backwardCompatibleWith és az owl:incompatibleWith tageket használjuk annak megadására, hogy kompatibilis-e a jelenlegi ontológia az előző verzióival, vagy sem. Ha nincs explicite deklarálva a visszamenőleges kompatibilitás, akkor nem szabad a kompatibilitást feltételezni. Van még egy owl:versionInfo nevű tag, amellyel a verziókezelő rendszerek számára adhatunk meg további verzió-információkat. Szemben az előző három taggel, az owl:versionInfo objektuma egy literál. Ez a tag nemcsak ontológiák, hanem osztályok és tulajdonságok verzió-adatainak megadására is használható. Sok alkalmazásban az ontológia szintű verziókövetés nem elegendő. A karbantartóknak szükségük lehet kisebb egységek (osztályok, tulajdonságok és egyedek) szintjén is nyilvántartani a verzió-információkat – és lehet, hogy még ez sem elég. Az OWL-ban az osztálykifejezések inkrementális jellege azzal a következménnyel jár, hogy egyik ontológia újabb korlátozásokat vezethet be egy (nevesített) osztályhoz, és ezek az új korlátozások is verzió-információkat igényelnek. Az OWL Full rendelkezik olyan kifejező erővel, hogy bármilyen állítást tehetünk egy osztállyal kapcsolatban, beleértve azt is, hogy egyede egy másik osztálynak, vagy hogy egy osztály (tehát nemcsak az egyedei) tulajdonságokkal, a tulajdonságai pedig értékkel rendelkeznek. Ezt a lehetőséget felhasználhatjuk osztályok és tulajdonságok ontológiájának a felépítésére is, amellyel követni lehet a verziókat. Az OWL névtér tartalmaz két előre definiált osztályt ElavultOsztály, illetve ElavultTulajdonság (owl:DeprecatedClass és owl:DeprecatedClass) néven. Ezekkel azt lehet jelezni, hogy a következő verzióban az osztály vagy a tulajdonság valószínűleg inkompatibilis módon fog változni.