Resource Description Frameworkmerlin.fic.uni.lodz.pl/MSkulimowski/rdfowl.pdfMarcin Skulimowski - RDF...

Marcin Skulimowski - RDF

Marcin Skulimowski Wprowadzenie do Resource Description Framework I. Podstawy RDF RDF jest językiem służącym do reprezentacji informacji na temat zasobów w taki sposób aby informacje te mogły być łatwo przetwarzane przez aplikacje. Zasoby (Resources) Zasobem może być wszystko, każda rzecz, każdy obiekt np. książki, samochody, ludzie, wydawcy etc. Ważne jest aby każdy zasób posiadał identyfiaktor URI (ang. Universal Resource Identifier – Zunifikowany Identyfikator Zasobów). Identyfikatorem URI może być wszystko co jednoznacznie identyfikuje dany zasób np.: numer ISBN, numer telefonu komórkowego. Szczególnym przypadkiem URI jest URL (ang. Universal Resource Locator – Identyfikator Lokalizacji Zasobów) określony dla zasobów internetowych. Identyfikator URI nie musi umożliwiać dostępu do zasobu, ma go tylko jednoznacznie identyfikować. Szczególnym przypadkiem zasobów odgrywających ważną rolę w języku RDF są tzw. właściwości. Właściwości (Properties) Właściwości opisują cechy i właściwości zasobów np.: „zatytułowany”, „napisany przez”, „należący do”, „w kolorze”. Ponieważ właściwości są także zasobami oznacza to, że są identyfikowane przez URI (w praktyce często przez URL). Stwierdzenia o zasobach Ważnym elementem języka naturalnego są zdania. Zdania oznajmujące informują nas o pewnych faktach dotyczących występującego w nich podmiotu. Przykład 1 Rozważmy zdanie

http://xxx.lanl.gov/abs/cs/0610020 ma tytuł „XString: XML as a String”.

W zdaniu tym możemy wyróżnić trzy elementy:

• Rzecz, która jest w tym zdaniu opisywana tzn. artykuł. • Właściwość opisywanej rzeczy wyrażona przez ma tytuł. • Wartość właściwości tytuł czyli „XString: XML as a String”.

Można sobie wyobrazić inne stwierdzenia charakteryzujące powyższy artykuł np.

wersja z dn. 2008-04-17 12:11:18

1


http://xxx.lanl.gov/abs/cs/0610020 ma autora, którym jest W. F. Gilreath’a.

http://xxx.lanl.gov/abs/cs/0610020 jest napisany w języku angielskim.

Podstawowa idea języka RDF sprowadza się do założenia, że zasoby można opisywać przy pomocy stwierdzeń analogicznych do powyższych. Każde stwierdzenie języka RDF zawiera trzy elementy:

• podmiot (ang. subject) – zasób (np. osoba, miejsce, rzecz) o którym mówi stwierdzenie.

• orzeczenie (ang. predicate) – właściwość (np. nazwa, miasto, tytuł, kolor, kształt,

charakterystyka) podmiotu. • obiekt (ang. object) – wartość właściwości opisywanej przez orzeczenie. Obiekt może

być zasobem lub tzw. literałem czyli ciągiem znaków. Dzięki temu, że właściwości są zasobami mogą być szczegółowo „określone” w stwierdzeniach w których będą podmiotami. Pozwala to na precyzyjne określenie zależności między zasobami. Przykład 2 Zdanie

Artykuł http://xxx.lanl.gov/abs/cs/0610020 ma tytuł „XString: XML as a String”. może być reprezentowane w języku RDF przez następujące stwierdzenie:

• podmiot - http://xxx.lanl.gov/abs/cs/0610020 • orzeczenie – http://www.abc.net/elements/tytul • obiekt – „XString: XML as a String”.

Zgodnie z wymogami RDF podmiot i orzeczenie w powyższym stwierdzeniu są jednoznacznie identyfikowane przez identyfikatory URI. Obiekt jest ciągiem znaków. Reprezentacja stwierdzeń Grafy Podstawową reprezentacją stwierdzeń języka RDF są grafy skierowane. Podmiot i obiekt są węzłami grafu. Orzeczenie jest krawędzią skierowaną od węzła reprezentującego podmiot do węzła reprezentującego orzeczenie.

wersja z dn. 2008-04-17 12:11:18

2


Orzeczenie 1 Literał

Orzeczenie 2 Podmiot

Obiekt

Podmioty i obiekty będące zasobami oznaczamy węzłem owalnym. Literały oznaczamy węzłami w kształcie prostokąta. Przykład 3 Stwierdzenie z Przykładu 1 ma następującą reprezentację:

http://xxx.lanl.gov/abs/cs/0610020

”XString: Stri

Przykład 4 Graf reprezentujący dwa stwierdzenia.

http://www.semanti

http://rdf.semantict.net/introRDF/elements#autor

Marcin Skulimowski

Notacja N3 Inną reprezentacją języka RDF jest tzw. notnastępująco:

<PODMIOT> <ORZE W przypadku gdy OBIEKT jest literałem:

wersja z dn. 212:11:

http://www.abc.net/elements/tytul

XML as a ng”

ct.net/RDF/introRDF

http://rdf.semantict.net/introRDF/elements#tytuł

Wprowadzenie do RDF

acja N3. Stwierdzenie w notacji N3 wygląda

CZENIE> <OBIEKT> .

008-04-17 18

3


<PODMIOT> <ORZECZENIE> ”OBIEKT” .

Rozpatrzmy konkretne przykłady. Przykład 5 Stwierdzenia z Przykładu 4 możemy przedstawić następująco: <http://rdf.semantict.net/introRDF> <http://rdf.semantict.net/introRDF/elements#autor> ”Marcin Skulimowski” . <http://rdf.semantict.net/introRDF> <http://rdf.semantict.net/introRDF/elements#tytul> ”Wprowadzenie do RDF” . Aby uniknąć pisania pełnych identyfikatorów URI możemy używać tzw. QNazw. QNazwa składa się z prefiksu określającego przestrzeń nazw po którym następuje dwukropek i lokalna nazwa zasobu. Pełen identyfikator URI otrzymujemy wówczas przez połączenie identyfikatora URI przestrzeni nazw i nazwy lokalnej zasobu. Stosując QNazwy możemy pominąć nawias kwadratowy. Przykład 6 Rozpatrzmy stwierdzenia z Przykładu 5. Przyjmijmy, że prefiks intrdf związany jest z przestrzenią nazw http://rdf.semantict.net/introRDF/elements#, natomiast prefiks semt związany jest z przestrzenią nazw http://rdf.semantict.net/. Wówczas powyższe stwierdzenia możemy zapisać następująco: @prefix intrdf: http://rdf.semantict.net/introRDF/elements# . @prefix semt: http://rdf.semantict.net/ . semt:introRDF intrdf:autor ”Marcin Skulimowski” . semt:introRDF intrdf:tytul ”Wprowadzenie do RDF” . Zauważmy, że przestrzenie nazw definiujemy przy pomocy @prefix. Zauważmy, że w stwierdzeniu 1 obiekt czyli autor jest ciągiem znaków. W ten sposób nie jesteśmy w stanie podać żadnych dodatkowych informacji dotyczących autora np. adres strony WWW, e-mail etc. (podmiotem stwierdzeń może być tylko zasób!). Jeżeli chcielibyśmy to zrobić musielibyśmy autora określić jako zasób.

wersja z dn. 2008-04-17 12:11:18

4


Przykład 7 Określmy identyfikator URL autora:

http://www.semantict.net/ludzie/2344 Graf wygląda wówczas następująco:

http://www.semantict.net/RDF/introRDF


http://rdf.semantict.net/introRDF/elements#wiek

http://www.semantict.net/ludzie/2344

http://rdf.semantict.net/introRDF/elements#imie

Marcin 34

Powyższym graf reprezentuje następujące stwierdzenia:

semt:introRDF intrdf:autor kto:2344 .

kto:2344 intrdf:imie ”Marcin” .

kto:2344 intrdf:wiek ”34” .

gdzie kto oznacza przestrzeń nazw http://www.semantict.net/ludzie/. W notacji N3 stwierdzenia z tym samym podmiotem możemy zapisać skrótowo rozdzielając orzeczenie i obiekty średnikiem. Przykład 8 Stwierdzenia 2 i 3 z przykładu poprzedniego możemy zapisać następująco:

kto:2344 intrdf:imie ”Marcin”; intrdf:wiek ”34” . Stwierdzenia z tym samym podmiotem i orzeczeniem możemy zapisać skrótowo rozdzielając obiekty przecinkiem. Przykład 9 Stwierdzenia

kto:2344 intrdf:autor ”Wprowadzenie do RDF” .

kto:2344 intrdf:autor ”Logika Deskryptywna” .

wersja z dn. 2008-04-17 12:11:18

5


możemy zapisać następująco

kto:2344 intrdf:autor ”Wprowadzeni do RDF”, ”Logika Deskryptywna” . Aktualny dokument RDF oznaczamy przez <>. Przykład 10 @prefix intrdf: http://rdf.semantict.net/introRDF/elements# .

<> intrdf:tytul ”Wprowadzenie do RDF” Puste węzły W przykładzie 7 aby móc dokładniej scharakteryzować autora określiliśmy dla niego identyfikator URI dzięki czemu autor stał się zasobem (i w grafie pojawił się nowy węzeł). Pozwoliło to nam użyć autora jako podmiotu dwóch stwierdzeń (oczywiście stwierdzeń takich może być więcej). Możemy mieć jednak do czynienia z sytuacją kiedy określanie URI dla zasobu nie będzie miało sensu np. wtedy gdy nie planujemy odwoływać się do danego zasobu (w tym przypadku do autora). Może się też zdarzyć, że w chwili tworzenia dokumentu nie będziemy znali identyfikatora URI dla danego zasobu. W takich przypadkach wykorzystujemy tzw. puste węzły czyli węzły bez identyfikatorów URI. Przykład 11 W poniższym grafie autor jest oznaczony pustym węzłem bez identyfikatora URI.



http://rdf.semantict.net/introRDF/elements#wiekhttp://rdf.semantict.net/introRDF/elements#imie

Marcin 34

W notacji N3 puste węzły oznaczamy przez _nazwa. W notacji N3 powyższe stwierdzenia zapisujemy następująco:

semt:introRDF intrdf:autor _:aautor .

_:aautor intrdf:imie ”Marcin” .

_:aautor intrdf:wiek ”34” .

wersja z dn. 2008-04-17 12:11:18

6


W notacji N3 (oraz jak zobaczymy w reprezentacji XML) oznaczenie pustego węzła przez identyfikator ma znaczenie tylko lokalne wewnątrz dokumentu RDF. W przypadku gdy w dokumencie istnieje kilka pustych węzłów ich różne identyfikatory pozwalają je rozróżnić. Jeżeli będziemy odwoływać się do danego węzła z zewnątrz (np. z innego dokumentu RDF) musi on posiadać identyfikator URI. Przykład 11 obrazuje także inne zastosowanie pustych węzłów. Może się zdarzyć, że wartość pewnej właściwości nie jest pojedynczym zasobem albo literałem ale jest bardziej złożona. W powyższym przykładzie taka właściwością jest http://rdf.semantict.net/introRDF/elements#autor. Wartość tej właściwości określiliśmy jako pusty węzeł, który może być podmiotem innych stwierdzeń. Dzięki temu możemy ją opisać bardziej szczegółowo. W notacji N3 puste węzły oznaczmy []. Przykład 12 Stwierdzenie

_:aautor intrdf:imie ”Marcin” . możemy zapisać następująco

[] intrdf:imie ”Marcin” . lub

[intrdf:imie ”Marcin”] .

Stwierdzenia

_:aautor intrdf:imie ”Marcin” .

_:aautor intrdf:wiek ”34” . Możemy zapisać następująco

[ intrdf:imie ”Marcin” ] intrdf:wiek ”34” . Stwierdzenie to możemy rozumieć następująco:

Pewna osoba o imieniu Marcin ma 34 lata. Rozpatrzmy przykład z dwoma pustymi węzłami.

wersja z dn. 2008-04-17 12:11:18

7


Przykład 13 Graf z 3 stwierdzeniami, których podmioty są pustymi węzłami:


http://rdf.semantict.net/introRDF/elements#tytul

http://rdf.semantict.net/introRDF/elements#imie

Marcin

Wprowadzenie do RDF

Powyższy graf w notacji N3 możemy zapisać następująco:

[ intrdf:imie ”Marcin” ] rdfint:autor [ intrdf:tytul ”Wprowadzenie do RDF” ] .

Stwierdzenie to możemy rozumieć następująco:

Pewna osoba o imieniu Marcin jest autorem pewnej książki pt. „Wprowadzenie do RDF”. Formuły Notacja N3 pozwala także na wykorzystywanie stwierdzeń w innych stwierdzeniach. Przykład 14 Rozważmy stwierdzenie:

semt:introRDF intrdf:autor ”Marcin Skulimowski” . Stwierdzenie to może być częścią innego stwierdzenia:

{ semt:introRDF intrdf:autor ”Marcin Skulimowski } intrdf:informs „Tomek” . W nawiasie {} możemy umieścić kilka stwierdzeń. Całe wyrażenie w nawiasie {} jest traktowane jako logiczna koniunkcja zawartych w nim stwierdzeń.

wersja z dn. 2008-04-17 12:11:18

8


Literały z określonym typem danych W powyższym przykładzie wartością właściwości intrdf:wiek jest literał ”34”. Oczywiście chodzi nam o liczbę 34, a nie o ciąg znaków ”34”. Co więcej chodzi nam o liczbę 34 w systemie dziesiętnym. W grafie nie ma jednak o tym żadnej informacji. Informację taką można umieścić w grafie wykorzystując tzw. literały z określonym typem danych. Literał taki składa się z ciągu znaków określającego wartość i identyfikatora URI określającego typ danych. Przykład 15 Określmy typ danych dla literału z Przykładu 7 określającego wiek:

kto:2344 intrdf:wiek ”34”^^<http://www/w3.org/2001/XMLSchema#integer> . lub skrótowo używając QNazwy:

kto:2344 intrdf:wiek ”34”^^<xsd:integer> .

gdzie xsd oznacza przestrzeń nazw http://www/w3.org/2001/XMLSchema#. Graf wygląda następująco:

http://rdf.semantict.net/introRDF/elements#wiek

http://www.semantict.net/ludzie/2344

”34”^^ http://www/w3.org/2001/XMLSchema#integer

W języku RDF nie ma zdefiniowanych typów danych (wyjątek stanowi wbudowany typ rdf:XMLLiteral). Typy danych wykorzystywane przez RDF są określone przez podanie odpowiedniego identyfikatora URI. Zwykle są to typy danych wykorzystywane w języku XML. W powyższym przykładzie wykorzystaliśmy typ integer. Oczywiście w języku RDF nie istnieje żaden mechanizm sprawdzenia czy dany literał jest rzeczywiście danego typu. Sprawdzenia takiego mogą ewentualnie dokonywać aplikacje wykorzystujące dokumenty RDF. Przykład 16 Rozważmy następujące stwierdzenie

kto:2344 intrdf:wiek ”auto”^^<xsd:integer> .

Oczywiście ciąg znak ”auto” nie jest typem integer. Jednak z punku widzenia języka RDF stwierdzenie to jest całkowicie poprawne.

wersja z dn. 2008-04-17 12:11:18

9

Literał z informacją w jakim języku jest zapisany

kto:2344 intrdf:imie ”Marcin”@pl . XML Reprezentacja stwierdzeń przy pomocy grafów jest wygodna dla ludzi, ale całkowicie niezrozumiała dla maszyn. Jeżeli język RDF ma być jednym z fundamentów Internetu semantycznego to musi posiadać reprezentację czytelną dla maszyn. Warunek ten spełnia notacja N3. Jednak najbardziej popularną i oficjalną (zatwierdzoną przez konsorcjum W3C) reprezentacją języka RDF jest reprezentacja oparta na języku XML1. W reprezentacji tej dokument RDF zawarty jest między znacznikami:

<rdf:RDF> 

</rdf:RDF> Jako jeden z atrybutów znacznika RDF podajemy zawsze przestrzeń nazw rdf

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" oraz ewentualnie inne wykorzystywane przestrzenie nazw. Każdemu stwierdzeniu odpowiada znacznik:

rdf:Description po którym następuje określenie zasobu (przy pomocy atrybutu elementu rdf:Description) którego stwierdzenie dotyczy. Określenie to może mieć 3 formy:

• atrybut about – gdy określamy istniejący zasób, • atrybut ID – gdy określamy nowy (definiowany) zasób, • bez określenia zasobu – określamy wtedy tzw. zasób anonimowy.

Dowolne stwierdzenie

podmiot, orzeczenie, obiekt . ma następującą reprezentację w języku XML <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <rdf:Description rdf:about="PODMIOT"> <ORZECZENIE>OBIEKT</ORZECZENIE> </rdf:Description> </rdf:RDF>

1 Notacja N3 jest bardziej ogólna od reprezentacji w XML.

wersja z dn. 2008-04-17 12:11:18

10


Przykład 172 Rozważmy graf z przykładu 3. Stwierdzenie wyrażone tym grafem ma następującą reprezentację w języku XML <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:pub="http://www.abc.net/publikacje#"> <rdf:Description rdf:about="http://xxx.lanl.gov/abs/cs/0610020"> <pub:tytul>XString: XML as a String</pub:tytul> </rdf:Description> </rdf:RDF> Gdzie pub jest przestrzenią nazw w której zdefiniowana jest właściwość tytul (o definiowaniu właściwości będzie mowa w części kursu poświęconej RDFS). Przykład 18 Rozważmy stwierdzenia RDF z przykładu 4. Stwierdzenia te mają następującą reprezentację w języku XML <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor>Marcin Skulimowski</intrdf:autor> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:tytul>Wprowadzenie do RDF</intrdf:tytul> </rdf:Description> </rdf:RDF> W powyższych przykładach wartości właściwości opisywanej przez orzeczenie były literałami. Przykład 19 Rozważmy teraz bardziej złożony przykład w którym wartość właściwości opisywanej przez orzeczenie jest zasobem.

2 Wszystkie przykłady z tego rozdziału zostały sprawdzone walidatorem RDF znajdującym się na stronie konsorcjum W3C: http://www.w3.org/RDF/Validator/

wersja z dn. 2008-04-17 12:11:18

11


http:/www.semantict.net/RDF/introRDF

Marcin Skulimowski Wprowadzenie do RDF

http://www.semantict.net/RDF/introRDF/elements#autor http://www.semantict.net/RDF/introRDF/elements#tytul

http://www.semantict.net/RDF/introRDF/elements#czesc

2007 Technologie Semantyczne

http://www.semantict.net/RDF/introRDF/elements#rok http://www.semantict.net/RDF/introRDF/elements#tytul

http://www.semantict.net/tech/

Graf ten reprezentuje następujące stwierdzenia: <http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#autor> ”Marcin Skulimowski” . <http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#tytul> ”Wprowadzenie do RDF” . <http://www.semantict.net/RDF/introRDF> <http://www.semantict.net/RDF/introRDF/elements#czesc> <http://www.semantict.net/tech/> . <http://www.semantict.net/tech/> <http://www.semantict.net/RDF/introRDF/elements#rok> ”2007” . <http://www.semantict.net/tech/> <http://www.semantict.net/RDF/introRDF/elements#tytul> ”Technologie Semantyczne” . Wykorzystując QNazwy stwierdzenia te możemy w notacji N3 zapisać następująco: irdf:introRDF intrdf:autor ”Marcin Skulimowski” . irdf:introRDF intrdf:tytul ”Wprowadzenie do RDF” . irdf:introRDF intrdf:czesc <http://www.semantict.net/tech/> . <http://www.semantict.net/tech/> intrdf:rok ”2007” . <http://www.semantict.net/tech/> intrdf:tytul ”Technologie Semantyczne” .

wersja z dn. 2008-04-17 12:11:18

12


gdzie: irdf - oznacza przestrzeń nazw http://www.semantict.net/RDF/ intrdf - oznacza przestrzeń nazw http://www.semantict.net/RDF/introRDF/elements#. Reprezentacja powyższych stwierdzeń w języku XML jest następująca: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor>Marcin Skulimowski</intrdf:autor> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:tytul>Kurs RDF</intrdf:tytul> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:czesc rdf:resource="http://www.semantict.net/tech/"/> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:rok>2007</intrdf:rok> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:tytul>Technologie Semantyczne</intrdf:tytul> </rdf:Description> </rdf:RDF> W przykładzie tym wartość właściwości czesc jest zasobem. Stąd odwołanie do zasobu przez atrybut rdf:resource. Przykład 20 Zauważmy, że w poprzednim przykładzie obiekt stwierdzenia 3 tzn. <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:czesc rdf:resource="http://www.semantict.net/tech/"/> </rdf:Description> jest podmiotem stwierdzeń 4 i 5 tzn. <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:rok>2007</intrdf:rok> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:tytul>Technologie Semantyczne</intrdf:tytul> </rdf:Description>

wersja z dn. 2008-04-17 12:11:18

13


Orzeczenia związane z tym samym podmiotem można umieścić w jednym elemencie Description. Ponadto element Description może być wartością właściwości. <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor>Marcin Skulimowski</intrdf:autor> <intrdf:tytul>Kurs RDF</intrdf:tytul> <intrdf:czesc> <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:rok>2007</intrdf:rok> <intrdf:tytul>Technologie Semantyczne</intrdf:tytul> </rdf:Description> </intrdf:czesc> </rdf:Description> </rdf:RDF> Oczywiście taki skrótowy zapis nie zmienia grafu. Predykaty (orzeczenia) Jak już wiemy wartością predykatu może być albo zasób albo literał. Zwykle parsery potrafią rozpoznać czy maja do czynienia z zasobem czy z literałem. Istnieje jednak możliwość zapisania wprost że wartość predykatu jest zasobem (literałem). Do tego celu wykorzystywany jest atrybut rdf:parseType. Przykład 21 Rozważmy następujący fragment przykładu 20: <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:czesc> <rdf:Description rdf:about="http://www.semantict.net/tech/"> <intrdf:rok rdf:parseType="Literal"> <h1> 2007 </h1>

</intrdf:rok> <intrdf:tytul>Technologie Semantyczne</intrdf:rok>

</rdf:Description> </intrdf:czesc> </rdf:Description> Dodanie atrybutu rdf:parseType do właściwości intrdf:rok powoduje, że fragment <h1>2007</h1>

wersja z dn. 2008-04-17 12:11:18

14


jest traktowany jak zwykły ciąg znaków i nie jest parsowany. Metoda ta pozwala umieszczać fragmenty kodu xml bezpośrednio w plikach rdf/xml. Po tej modyfikacji graf wygląda następująco:





<h1>2007</h1> Technologie Semantyczne


http://www.semantict.net/tech/

Może się zdarzyć, że będziemy mieli do czynienia z zasobem, dla którego ani URI ani URL nie będziemy znali. W ten sposób nie będziemy mogli określić dla niego ani atrybutu rdf.about ani rdf:ID. Istnieje jednak możliwość zapisania, że mamy do czynienia z zasobem. Robimy to przy pomocy atrybutu rdf:parseType nadając mu wartość "Resource". Przykład 22 Rozważmy następujący fragment przykładu 6: <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:czesc rdf:parseType="Resource"> <intrdf:rok>2007</intrdf:rok> </intrdf:czesc> </rdf:Description>

wersja z dn. 2008-04-17 12:11:18

15






2007 Technologie Semantyczne


genid: ARP103321

Zauważmy, że mimo tego, że wartość predykatu czesc nie posiada identyfikatora URI to jednak jest oznaczona owalem tak jak zasób. Jest to tzw. pusty węzeł. Węzły takie omówimy w następnym rozdziale. Atrybutem rdf:parseType można też oznaczyć właściwość będącą zasobem nawet jeżeli właściwość ta nie posiada wartości. Przykład 23 Rozważmy następujący przykład: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:czesc rdf:parseType="Resource"/> </rdf:Description> </rdf:RDF> Zauważmy, że właściwość czesc nie posiada wartości. Graf w tym przypadku wygląda następująco:

wersja z dn. 2008-04-17 12:11:18

16




genid: ARP103321

Puste węzły W poprzednim punkcie mieliśmy do czynienia z sytuacją gdzie URI zasobu nie był określony. Węzeł związany z takim zasobem nazywamy węzłem pustym (ang. blank node). Pojawienie się pustego węzła może oznaczać, że identyfikator URI dla danego zasobu nie istnieje lub jest w danej chwili nieznany. Zasób oznaczony pustym węzłem jest określony przez swoje własności, a nie przez identyfikator. Pusty węzeł ma zwykle przypisany przez walidator identyfikator. Dzięki temu, w ramach tego samego dokumentu RDF, puste węzły mogą być między sobą rozróżnione. Przykład 24 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor> <rdf:Description> <intrdf:imie>Marcin</intrdf:imie>

<intrdf:nazwisko>Skulimowski</intrdf:nazwisko> </rdf:Description> </intrdf:autor> </rdf:Description> </rdf:RDF> Graf powyższego dokumentu RDF/XML wygląda następująco


Marcin

http://www.semantict.net/RDF/introRDF/elements#autor

genid:ARP1033

http://www.semantict.net/RDF/introRDF/elements#imie http://www.semantict.net/RDF/introRDF/elements#nazwisko

Skulimowski

wersja z dn. 2008-04-17 12:11:18

17


Walidator wygenerował identyfikator dla pustego węzła będącego wartością właściwości autor. Identyfikator te nie ma żadnego znaczenia poza tym, że pozwala rozróżnić puste węzły w ramach tego samego dokumentu RDF. Istnieje możliwość nadania pustemu węzłowi ściśle określonego identyfikatora. W tym celu wykorzystujemy atrybut rdf:nodeID. Przykład 25 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor> <rdf:Description rdf:nodeID="autordane"> <intrdf:imie>Marcin</intrdf:imie>

<intrdf:nazwisko>Skulimowski</intrdf:nazwisko> </rdf:Description> </intrdf:autor> </rdf:Description> </rdf:RDF> Graf powyższego dokumentu RDF/XML wygląda następująco:


Marcin

http://www.semantict.net/RDF/introRDF/elements#autor

autordane

http://www.semantict.net/RDF/introRDF/elements#imie http://www.semantict.net/RDF/introRDF/elements#nazwisko

Skulimowski

Uwaga: atrybut rdf:nodeID jest elementem składni RDF/XML i nie jest elementem abstrakcyjnego modelu RDF.

wersja z dn. 2008-04-17 12:11:18

18


Referencje URI Względne URI i bazowy URI Zgodnie z ideą języka RDF wszystkie podmioty i orzeczenia powinny być opisywane identyfikatorami URI. Nie zawsze musi to jednak być cały identyfikator. Możemy operować względnym URI. Cały identyfikator URI jest wówczas uzyskany przez połączenie bazowego URI i względnego URI. Załóżmy, że dokument http://www.semantict.net/RDF/introRDF/ zawiera następujący element

<rdf:Description rdf:about="cos"> Bazowym URI jest URI dokumentu zawierającego powyższy element. Pełen identyfikator URI otrzymujemy przez połączenie URI bazowego i URI względnego tzn.

http://www.semantict.net/RDF/introRDF/cos Identyfikator URI otrzymujemy w powyższy sposób zawsze wtedy kiedy dla danego zasobu nie jest podany pełen identyfikator. Możliwe jest też określenie bazowego URI bez względu na dokument zawierający dany element. Wykorzystujemy w tym celu atrybut xml:base. Przykład 26 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="introRDF"> <intrdf:autor> <rdf:Description> <intrdf:imie>Marcin</intrdf:imie>

<intrdf:nazwisko>Skulimowski</intrdf:nazwisko> </rdf:Description> </intrdf:autor> </rdf:Description> </rdf:RDF> Podobnie jak poprzednio pełen identyfikator URI powstaje przez konkatencję (sklejenie) nazwy z atrybutu about (względny URI) oraz atrybutu xml:base (bazowy URI). W efekcie otrzymujemy:

http://www.semantict.net/RDF/introRDF Jeżeli w powyższym przykładzie nie określimy atrybutu xml:base wówczas pełen URI jest otrzymany przez konkatencję adresu pliku zwierającego dokument RDF/XML oraz atrybutu about.

wersja z dn. 2008-04-17 12:11:18

19


Atrybut rdf:ID Atrybut rdf:ID jest bardzo podobny do atrybutu rdf:about. Podobieństwo polega na tym, że oba atrybuty służą do określenia identyfikatora URI. Jednak o ile atrybut rdf:about określa URI istniejącego zasobu o tyle atrybutu rdf:ID jest używany do określenia nowego zasobu. Do zasobu takiego możemy się odwoływać przez wartość atrybutu ID prefiksem #. Przykład 27 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="introRDF"> <intrdf:autor> <rdf:Description> <intrdf:imie>Marcin</intrdf:imie>

<intrdf:nazwisko>Skulimowski</intrdf:nazwisko> </rdf:Description>

</intrdf:autor> <intrdf:seria> <rdf:Description rdf:ID="semtech"> <intrdf:rok>2007</intrdf:rok> <intrdf:tytul>Technologie Semantyczne</intrdf:rok> </rdf:Description> </intrdf:seria> </rdf:Description> </rdf:RDF> Pełen URI dla w powyższym przykładzie uzyskujemy przez połączenie URI bazowego i wartości atrybutu rdf:ID przedzielonych znakiem # tzn.

http://www.semantict.net/RDF/#semtech

Predykat rdf:value Rozważmy następujący przykład: <intrdf:modyfikacja>23</intrdf:modyfikacja> Przyjmijmy, że liczba 23 związana jest z ostatnią datą modyfikacji tzn. tyle dni temu zasób był modyfikowany. Nie wiemy jednak czy chodzi o godziny, dni, czy może miesiące. Taką dodatkową informację możemy zapisać następująco: <intrdf:modyfikacja>23 dni</intrdf:modyfikacja>

wersja z dn. 2008-04-17 12:11:18

20


W tym przypadku wydobycie informacji o liczbie dni wymaga jednak rozbicia zawartości znacznika na dwa elementy: liczba i słowo ‘dni’. Informację taką możemy jednak zapisać inaczej: <intrdf:modyfikacja>23</intrdf:modyfikacja> <intrdf:jednostka>dzien</intrdf:jednostka> W tym przypadku jednak wartość 23 nie jest ściśle związana z jednostką poza tym, że modyfikacja i jednostka są właściwościami tego samego zasobu. Powyższych problemów możemy uniknąć jeżeli zastosujemy predykat rdf:value, który określa właśnie wartość. Rozważmy przykład: Przykład 28 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:modyfikacja> <rdf:value>23</rdf:value> <intrdf:jednostka>dzien</intrdf:jednostka> </intrdf:modyfikacja> </rdf:Description> </rdf:RDF> W przykładzie tym liczba 23 jest wartością właściwości value związanej z zasobem autordane.


dzień

http://www.semantict.net/RDF/introRDF/elements#modyfikacja

genid:ARP1033

http://www.semantict.net/RDF/introRDF/elements#jednostka http://www.w3.org/1999/02/22-rdf-syntax-ns#value

23

Predykat rdf:type Zasoby, którymi zajmowaliśmy się do tej pory nie miały ściśle określonego typu. Były po prostu zasobami. Możemy jednak określić typ zasobu przy pomocy predykatu rdf:type.

wersja z dn. 2008-04-17 12:11:18

21


Przykład 29 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements/"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/"> <intrdf:autor>Marcin Skulimowski</intrdf:autor> <intrdf:type rdf:resource="http://www.semantict.net/RDF/introRDF/elements#kurs"/> </rdf:Description> </rdf:RDF> Predykat rdf:type związał dany zasób z klasą kurs określoną w RDFS. RDF/XML skróty Istnieje kilka sposobów uproszczenia dokumentu RDF.

• Różne predykaty określające ten sam zasób mogą znajdować się w jednym elemencie Description (patrz Przykład 20).

• Niepowtarzające się właściwości (orzeczenia) można zapisać jako atrybuty zasobu (w języku XML atrybuty tego samego elementu muszą mieć różne nazwy).

Przykład 30

<?xml version="1.0"?> <rdf:RDF

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"> <rdf:Description rdf:about="http://www.semantict.net/RDF/introRDF/" intrdf:autor="Marcin Skulimowski" intrdf:tytulKurs="RDF"/>

</rdf:RDF> • W elemencie Description z określonym typem zasobu zamiast rdf:Description

możemy pisać typ zasobu.

Przykład 31

<?xml version="1.0"?> <rdf:RDF

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <intrdf:Kurs rdf:about="introRDF"> <intrdf:autor> <rdf:Description>

wersja z dn. 2008-04-17 12:11:18

22


<intrdf:imie>Marcin</intrdf:imie> <intrdf:nazwisko>Skulimowski</intrdf:nazwisko> </rdf:Description>

</intrdf:autor> </intrdf:Kurs> </rdf:RDF>

• Zasoby, które nie mają orzeczeń nie muszą być zdefiniowane w bloku Description.

W dotychczasowych przykładach zasoby były zawsze określone przy pomocy znacznika rdf:Description. Blok rdf:Description może być pominięty. Jest to możliwe w dwóch przypadkach.

1. Dany obiekt będący zasobem nie jest podmiotem żadnego orzeczenia.

Przykład 32 <?xml version="1.0"?> <rdf:RDF

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#"

xml:base="http://www.semantict.net/RDF/">

<rdf:Description rdf:about="introRDF"> <intrdf:czesc rdf:resource="tech"/> </rdf:Description> </rdf:RDF>

Nowy zasób został wprowadzony przy pomocy atrybutu rdf:resource.

2. Zasób jest podmiotem stwierdzenia (stwierdzeń), ale dokładnie opisany jest w dalszej części dokumentu (i tam są podane związane z nim właściwości i ich wartości).

Przykład 33

<?xml version="1.0"?>

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="introRDF.html"> <intrdf:czesc rdf:resource="tech"/> </rdf:Description> <rdf:Description rdf:about="tech"> <intrdf:autor>Marcin Skulimowski</intrdf:autor> <intrdf:rok>2007</intrdf:rok> </rdf:Description> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

23


Powyższy zapis można uprościć wykorzystując omówiony wcześniej skrót tzn. orzeczenia podmiotu będącego zasobem możemy umieścić jako atrybuty znacznika rdf:Description.

<?xml version="1.0"?>

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/">

<rdf:Description rdf:about="tech" intrdf:autor="Marcin Skulimowski" intrdf:rok="2007"/>

</rdf:RDF>

Omówione powyżej skróty upraszczają reprezentację stwierdzeń RDF w języku XML, ale oczywiście nie zmieniają grafu będącego właściwą reprezentacją języka RDF.

wersja z dn. 2008-04-17 12:11:18

24


Zaawansowane konstrukcje języka RDF Kontenery Kontenery są wykorzystywane w sytuacjach kiedy mamy do czynienia ze stwierdzeniami dotyczącymi wielu różnych zasobów traktowanych jako całość. W języku RDF istnieją trzy rodzaje kontenerów. rdf.Bag Kontener ten zawiera nieuporządkowaną listę zasobów (lub literałów) w której poszczególne elementy mogą się powtarzać. Przykład 34 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:ksiazki> <rdf:Bag> <rdf:li rdf:resource="semanticweb.pdf"/> <rdf:li rdf:resource="rdf.pdf"/> <rdf:li rdf:resource="owl.pdf"/> </rdf:Bag> </intrdf:ksiazki> </rdf:Description> </rdf:RDF> Graf

http://www.semantict.net/RDF/spis.htmlhttp://www.semantict.net/RDF/introRDF/elements#ksiazki

genid:A69811

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

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


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

3

2

1

Gdzie: 1 - http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag 2 - http://www.semantict.net/RDF/semanticweb.pdf 3 - http://www.semantict.net/RDF/rdf.pdf 4 - http://www.semantict.net/RDF/owl.pdf

wersja z dn. 2008-04-17 12:11:18

25


Jeżeli kontener zawiera literały zamiast zasobów wówczas każdy element jest określony następująco <rdf:li>Internet Semantyczny</rdf:li> Zamiast elementów rdf:li możemy użyć elementów postaci rdf:_n gdzie n jest liczbą. Przykład 35 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:ksiazki> <rdf:Bag> <rdf:_1 rdf:resource="semanticweb.pdf"/> <rdf:_2 rdf:resource="rdf.pdf"/> <rdf:_3 rdf:resource="owl.pdf"/> </rdf:Bag> </intrdf:ksiazki> </rdf:Description> </rdf:RDF> Elementy rdf:_n i rdf:li można użyć jednocześnie przy czym liczba n nie ma wpływu na numerację w grafie związaną z rdf:li. Przykład 36 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:ksiazki> <rdf:Bag> <rdf:li rdf:resource="semanticweb.pdf"/> <rdf:_5 rdf:resource="rdf.pdf"/> <rdf:li rdf:resource="owl.pdf"/> </rdf:Bag> </intrdf:ksiazki> </rdf:Description> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

26


Graf

http://www.semantict.net/RDF/spis.html

http://www.semantict.net/RDF/introRDF/elements#ksiazki

genid:A69811





Gdzie: 1 - http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag 2 - http://www.semantict.net/RDF/semanticweb.pdf 3 - http://www.semantict.net/RDF/rdf.pdf 4 - http://www.semantict.net/RDF/owl.pdf rdf:Seq Kontener ten zawiera uporządkowaną listę zasobów (lub literałów) w której poszcelementy mogą się powtarzać. A zatem w tym przypadku kolejność odgrywa rolokreślana za pomocą elementu rdf:_n widocznym na grafie. Wartość tego azwiązana jest z kolejnością elementów listy. Przykład 37 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:ksiazki> <rdf:Seq> <rdf:li rdf:resource="semanticweb.pdf"/> <rdf:li rdf:resource="rdf.pdf"/> <rdf:li rdf:resource="owl.pdf"/> </rdf:Seq> </intrdf:ksiazki> </rdf:Description> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

1

2

3

4

zególne e i jest trybutu

27


W dokumencie RDF/XML możemy użyć elementy rdf:_n. Przykład 38 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:ksiazki> <rdf:Seq> <rdf:_1 rdf:resource="semanticweb.pdf"/> <rdf:_2 rdf:resource="rdf.pdf"/> <rdf:_3 rdf:resource="owl.pdf"/> </rdf:Seq> </intrdf:ksiazki> </rdf:Description> </rdf:RDF> rdf:Alt Kontener ten zawiera alternatywy dla pewnej wartości. Musi on zawierać przynajmniej jeden element będący wartością domyślną (pierwszy element listy). Przykład 39 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="kurs.html"> <intrdf:prowadzi> <rdf:Alt> <rdf:_1 rdf:resource="11234"/> <rdf:_2 rdf:resource="34567"/> </rdf:Alt> </intrdf:prowadzi> </rdf:Description> </rdf:RDF> W powyższym przykładzie wykład prowadzi osoba o identyfikatorze 11234 lub osoba o identyfikatorze 34567. Kolekcje W przeciwieństwie do kontenerów kolekcja zawiera skończoną liczbę elementów z zaznaczonym elementem ostatnim. W dokumentach RDF/XML kolekcja jest zdefiniowana przez atrybut rdf:parseType="Collection".

wersja z dn. 2008-04-17 12:11:18

28


Przykład 40 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="spis.html"> <intrdf:menu rdf:parseType="Collection"> <rdf:Description rdf:about="semanticweb.pdf"/> <rdf:Description rdf:about="rdf.pdf"/> <rdf:Description rdf:about="owl.pdf"/> </intrdf:menu> </rdf:Description> </rdf:RDF> Graf

przy czym

rdf:fi

rdf:re

http://www.semantict.net/RDF/spis.html

genid:

genid:

genid:

użyliśmy następ

rst zamiast h

st zamiast htt

http://www.semantict.net/RDF/introRDF/elements#menu

A69811 rdf:first

A69812 rdf:first

A69813 rdf:first

ujących skrótów:

ttp://www.w3.org/1

p://www.w3.org/199

wersja z dn. 200812:11:18

http://www.semantict.net/RDF/semanticweb.pdf

rdf:rest

999

9/0

-04-

http://www.semantict.net/RDF/rdf.pdf

rdf:rest

http://www.semantict.net/RDF/owl.pdf

rdf:rest

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

/02/22-rdf-syntax-ns#first

2/22-rdf-syntax-ns#rest

17 29


Reifikacja Dotychczas rozważaliśmy stwierdzenia składające się z 3 elementów:

podmiot, orzeczenie, obiekt Przykładem takiego stwierdzenia pochodzącym z języka potocznego jest zdanie

Witrynę http://www.abc.pl stworzył Łukasz W języku potocznym zdarzają się jednak stwierdzenia bardziej złożone np.:

Marek powiedział, że witrynę http://www.abc.pl stworzył Łukasz

Jest to stwierdzenie dotyczące innego stwierdzenia czyli tzw. metastwierdzenie. Poznane dotychczas konstrukcje języka RDF nie pozwalają nam formułować stwierdzeń dotyczących tego stwierdzenia ponieważ stwierdzenie nie jest zasobem i nie może być podmiotem innego stwierdzenia. Umożliwia to tzw. reifikacja. Stwierdzenie

Witrynę http://www.strona.pl stworzył Łukasz będące częścią powyższego zdania ma bardzo prostą reprezentację w języku RDF\XML. <rdf:Description rdf:about="http://www.strona.pl/"> <intrdf:autor>Łukasz</intrdf:autor> </<rdf:Description> Rozważmy następujący przykład: Przykład 41 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="opinia.html"> <rdf:subject rdf:resource="http://www.strona.pl/"/> <rdf:predicate rdf:resource="http://www.semantict.net/RDF/introRDF/elements#autor"/> <rdf:object>Lukasz</rdf:object> <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax- ns#Statement"/> <intrdf:informs>Tomek</intrdf:informs> </rdf:Description> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

30


Graf

http://www.semantict.net/RDF/opinia.html

http://www.strona.pl/

http://www.semantict.net/RDF/introRDF/elements#autor http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate

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

Łukasz

Tomek http://www.semantict.net/RDF/introRDF/elements/informs


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

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

Informacje o reifikowanym stwierdzeniu i reifikacje można rozdzielić. Jest to szczególnie przydatne gdy stwierdzenie poddane reifikacji jest podmiotem kilku stwierdzeń. Przykład 42 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="#w"> <rdf:subject rdf:resource="http://www.strona.pl/"/> <rdf:predicate rdf:resource="http://www.semantict.net/RDF/introRDF/elements#autor"/> <rdf:object>Łukasz</rdf:object> <rdf:type rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax- ns#Statement"/> </rdf:Description> <rdf:Description rdf:about="http://www.semantict.net/persons/01"> <intrdf:informsAbout rdf:resource="#w" /> </rdf:Description> </rdf:RDF> Reifikacji możemy też dokonać bez używania właściwości subject, predicate i object. Do właściwości występującej w stwierdzeniu dodajemy wówczas atrybut rdf:ID.

wersja z dn. 2008-04-17 12:11:18

31


Przykład 43 <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/"> <rdf:Description rdf:about="http://www.strona.pl/"> <intrdf:autor rdf:ID="w">Łukasz</intrdf:autor> </rdf:Description> <rdf:Description rdf:about="#w"> <intrdf:informs rdf:resource="http://www.semantict.net/persons/01" /> </rdf:Description> </rdf:RDF> RDF i HTML Język HTML służy do tworzenia stron internetowych. Oprócz informacji i sposobu ich prezentacji można w dokumentach HTML umieścić pewne metadane. Standardowo robi się to przy pomocy znaczników <meta>. Można jednak zrobić coś więcej, można dołączyć do dokumentu HTML dokument RDF ze stwierdzeniami dotyczącymi zasobów. Zgodnie z zaleceniem W3C można tego dokonać umieszczając w dokumencie HTML link do odpowiedniego dokumentu RDF. Przykład 44 <head> <title>Moja strona</title> <link rel="meta" type="application/rdf+xml" href="meta.rdf"> </head> Znacznik <link> nie musi znajdować się w nagłówku dokumentu HTML. Możemy umieścić go w części <body>.

wersja z dn. 2008-04-17 12:11:18

32


II. Schematy RDF (RDFS) Język RDFS pozwala nam definiować słownictwo wykorzystywane w dokumentach RDF. Podstawowymi elementami takiego słownictwa są klasy (ang. class) zasobów i ich właściwości (ang. property) charakterystyczne dla rozważanej dziedziny. Klasy i właściwości Stwierdzenia języka RDF dotyczą konkretnych przykładów obiektów należących do różnych klas. Przykład 44 Rozważmy następujący przykład: <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:pub="http://www.abc.net/publikacje/"> <rdf:Description rdf:about="http://xxx.lanl.gov/abs/quant-ph/0609211"> <pub:tytul>How to Introduce Time Operator</pub:tytul> <rdf:type rdf:resource="http://www.abc.net/publikacje/artykul"/> </rdf:Description> </rdf:RDF> Zasób http://xxx.lanl.gov/abs/quant-ph/0609211 jest określony jako przykład klasy http://www.abc.net/publikacje/artykul. Klasy zasobów charakteryzowane są przez właściwości. Rozważmy następujące stwierdzenie: Artykuł „How to Introduce Time Operator” został napisany przez „Wprowadzenie do XML” . Oczywiście stwierdzenie takie nie ma sensu. Obiekt „How to Introduce Time Operator” jest przykładem klasy artykuł. „Wprowadzenie do XML” jest przykładem klasy książka. Oczywiście artykuły nie są pisane przez ksiązki. Musimy zatem zagwarantować, aby wartość właściwości napisany/napisana przez była przykładem klasy autor. Oznacza to, że musimy określić zasięg (ang. range) tej właściwości. Podobnie musimy określić jej dziedzinę (ang. domain). W przypadku powyższego zdania dziedzinę stanowi klasa publikacja. Przestrzeń nazw dla schematów RDF:

xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" Język RDFS posiada „wbudowane” pewne klasy i właściwości przy pomocy których możemy definiować własne klasy i właściwości. Podstawowe klasy RDF i RDFS rdfs:Class – klasa wszystkich klas.

wersja z dn. 2008-04-17 12:11:18

33

Przykład 45 Klasę artykul możemy zdefiniować następująco: <rdfs:Class rdf:ID="Publikacja">  </rdfs:Class> rdfs:Resource – klasa wszystkich zasobów. rdfs:Literal – klasa wszystkich literałów (ciągów znaków). rdfs:XMLLiteral – klasa wszystkich literałów zawierających składnię XML'a. Klasa ta jest podklasą klasy rdfs:Literal. rdf:Property – klasa wszystkich zasobów określających właściwości. Przykład 46 Właściwość tytul możemy zdefiniować następująco: <rdf:Property rdf:ID="tytul">  </rdf:Property> rdfs:Datatype – klasa typów danych. Każdy przykład tej klasy jest podklasą klasy rdfs:Literal. rdf:Statement – klasa wszystkich reifikowanych stwierdzeń. rdf:Bag – nieuporządkowana kolekcja. rdf:Seq – uporządkowana kolekcja. rdf:Alt – kolekcja alternatyw. rdfs:Container – klasa kontenerów. rdf:ConstraintResource - klasa wszystkich więzów. Klasa rdfs:Class jest podklasą klasy rdfs:Resource tzn. każda klasa jest zasobem. Klasa rdfs:Resource jest przykładem klasy rdfs:Class ponieważ rdfs:Resource jest klasą wszystkich zasobów, a zatem jest klasą czyli przykładem rdfs:Class.

wersja z dn. 2008-04-17 12:11:18

34


rdfs:ConstraintResource rdf:Property

rdfs:Resource W definicjac Podstawowe rdf:type przykładem rdfs:subCdana klasa Klasa może Przykład 47 Klasa artyku <rdfs:Clas <rdfs:su</rdfs:Cla Przykład 48 Klasa artykuksiążkowej j <rdfs:Clas <rdfs:su <rdfs:su</rdfs:Cla rdfs:subPktórej zawier

rdfs:Class

rdfs:ConstraintProperty

RDFS – hierarchia podstawowych klas

h klas i właściwości możemy wykorzystywać następujące właściwości:

właściwości RDF i RDFS

- właściwość, która określa klasę do której należy dany zasób. Zasób jest tej klasy (patrz Przykład 1).

lassOf - właściwość, która określa klasę (superklasę) w której zawiera się (będąca jej podklasą). Wszystkie przykłady klasy są przykładami superklasy. być podklasą wielu klas.

l jest podklasą klasy publikacje.

s rdf:about="Artykul"> bClassOf rdf:resource="#Publikacja"/> ss>

lInternetKsiazka artykułów które zostały opublikowane Internecie oraz w postaci est podklasą klasy artykulInternet i klasy artykulKsiazka.

s rdf:ID="ArtykulInternetKsiazka"> bClassOF rdf:resource="#ArtykulInternet"/> bClassOF rdf:resource="#ArtykulKsiazka"/> ss>

ropertyOf - właściwość, która określa właściwość (superwłaściowość) w a się dana właściwość (będąca jej podwłaściwością).

wersja z dn. 2008-04-17 12:11:18

35


Przykład 49 <rdf:Property rdf:ID="tytulKsiazki"> <rdfs:subPropertyOf rdf:resource="#tytul"/> </rdf:Property> Właściwości rdfs:subClassOf i rdfs:subPropertyOf są przechodnie. rdfs:domain - określa dziedzinę (ang. domain) właściwości P tzn. klasę zasobów, które mogą się pojawić jako zasób z właściwością P. Jeżeli dziedzina nie jest określona może nią być dowolna klasa. rdfs:range - określa zakres (ang. range) właściwości P tzn. klasę zasobów, które mogą się pojawić jako wartość właściwości P. Przykład 50 Wartość właściwość tytul powinna być literałem. <rdf:Property rdf:ID="tytul"> <rdfs:domain rdf:resource="#publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> Przykład 51 Wartość właściwość ISSN powinna być liczbą całkowitą. <rdf:Property rdf:ID="ISSN"> <rdfs:domain rdf:ID="publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/> </rdf:Property> rdf:ConstraintProperty - klasa wszystkich właściwości definiujących więzy. Klasa ta jest podklasą klasy rdf:ConstraintResource i rdf:Property. Klasa ta posiada dwa przykłady: rdfs:domain i rdfs:range. rdfs:label – określenie zasobu dla ludzi Przykład 52 <rdf:Property rdf:ID="ISSN"> <rdfs:label>numer ISSN</rdfs:label> <rdfs:domain rdf:recource="#publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/> </rdf:Property>

wersja z dn. 2008-04-17 12:11:18

36


rdfs:seeAlso – własność określająca inny zasób zawierający informacje na temat opisywanego zasobu. Przykład 53 <rdf:Description rdf:about="http://www.w3.org/2000/01/rdf-schema#"> <rdfs:seeAlso rdf:resource="http://www.w3.org/2000/01/rdf-schema-more#"/> </rdf:Description> rdfs:isDefinedBy - określa przestrzeń nazw zasobu. rdfs:comment – umożliwia dodanie komentarza Przykład 54 <rdfs:Class rdf:ID="ArtykulInternetKsiazka"> <rdfs:subClassOF rdf:resource="#ArtykulInternet"/> <rdfs:subClassOF rdf:resource="#ArtykulKsiazka"/> <rdfs:comment> klasa artykułów opublikowanych jednocześnie w Internecie i w formie książkowej </rdfs:comment> </rdfs:Class> rdfs:member – element kontenera rdf:first - pierwszy element listy (głowa) rdf:rest – pozostała część listy (ogon) rdf:value – określa wartość właściwości rdf:subject – podmiot stwierdzenia rdf:predicate – orzeczenie stwierdzenia rdf:object – obiekt stwierdzenia

wersja z dn. 2008-04-17 12:11:18

37


rdfs:Resource

rdf:Literal

rdfs:ConstraintProperty

rdf:Property

rdfs

RDFS – zależności m

rdfs:Class

rdfs:range

:ConstraintResource

iędzy przykładami pod

wersja z dn. 2008-04-12:11:18

rdfs:domain

stawowych klas i właściwości

17 38


Przykładowy Schemat RDF Poniżej schemat RDF związany z publikacjami. <?xml version="1.0"?> <rdf:RDF

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">

<rdfs:Class rdf:ID="Publikacja"/> <rdf:Property rdf:ID="tytul"> <rdfs:domain rdf:resource="#Publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdfs:Class rdf:ID="Artykul"> <rdfs:subClassOf rdf:resource="#Publikacja"/> </rdfs:Class> <rdfs:Class rdf:ID="Ksiazka"> <rdfs:subClassOf rdf:resource="#Publikacja"/> </rdfs:Class> <rdf:Property rdf:ID="tytulArtykulu"> <rdfs:subPropertyOf rdf:resource="#tytul"/> <rdfs:domain rdf:resource="#Artykul"/> </rdf:Property> <rdf:Property rdf:ID="tytulKsiazki"> <rdfs:subPropertyOf rdf:resource="#tytul"/> <rdfs:domain rdf:resource="#Ksiazka"/> </rdf:Property> <rdf:Property rdf:ID="issn"> <rdfs:domain rdf:resource="#Publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/> </rdf:Property> <rdf:Property rdf:ID="autor"> <rdfs:domain rdf:resource="#Publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2000/01/rdf-schema#Literal"/> </rdf:Property> <rdf:Property rdf:ID="liczbaStron"> <rdfs:domain rdf:resource="#Publikacja"/> <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#integer"/> </rdf:Property> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

39


Schematy RDF i notacja N3 Schematy RDF można zapisywać w notacji N3. W notacji N3 właściwość rdf:type ma skrótową postać a. Przykłady z poprzedniego rozdziału zapisane w notacji N3: Przykład 45*

:Publikacja a rdfs:Class . Przykład 46*

:tytul a rdf:Property .

Przykład 47*

:Artykul a rdfs:Class . :Artykul rdfs.subClassOf :Publikacja .

Skrótowo:

:Artykul a rdfs:Class; rdfs:subClassOf :Publikacja .

Przykład 48* :ArtykulInternetKsiazka rdfs:subClassOf :ArtykulInternet, :ArtykulKsiazka . Przykład 49*

:tytulKsiazki rdfs:subPropertyOf :tytul .

Przykład 50*

:tytul rdfs:domain :publikacja; rdfs:range <http://www.w3.org/2000/01/rdf-schema#Literal> .

Przykład 51*

:issn rdfs:domain :publikacja; rdfs:range <http://www.w3.org/2001/XMLSchema#integer> . Przykład 52*

:issn rdfs:label "numer ISSN"; rdfs:domain :publikacja; rdfs:range <http://www.w3.org/2001/XMLSchema#integer> .

wersja z dn. 2008-04-17 12:11:18

40


Ograniczenia RDFS Język RDFS pozwala nam definiować proste ontologie. Posiada jedna pewne ograniczenia:

• rdfs:range określa zakres właściwości dla wszystkich klas. Ta sama właściwość może mieć różne zakresy dla różnych klas. Przykład: zywiSie.

• Brak możliwości zapisania, że dwie klasy są rozłączne.

Przykład: klasa Kobieta i klasa Mezczyzna.

• Brak możliwości definiowania klas z użyciem operacji sumy, iloczynu.

Przykład: klasa Osoba jako rozłączna suma klas Kobieta i Mezczyzna.

• Brak ograniczeń na liczbę wartości które może posiadać dana właściwość.

Przykład: właściwość mama.

• Brak bardziej szczegółowego określenia właściwości: właściwość przechodnia, właściwość odwrotna etc.

Przykład: wyzszyOd,

zjada, jestZjadanyPrzez Istnieje zatem potrzeba rozszerzenia RDFS. „Rozszerzeniem” takim jest język OWL (ang. Ontology Web Language).

wersja z dn. 2008-04-17 12:11:18

41


IV. SPARQL SPARQL (ang. SPARQL Protocol And RDF Query Language) jest językiem zapytań dla dokumentów RDF. SPARQL pozwala wyciągać z nich dane zawężone według kryteriów określonych poprzez predykaty RDF. Jest opisany przez kilka specyfikacji W3C. W obecnej chwili wszystkie specyfikacje są w statusie szkicu. Ostania wersja robocza – 26 marzec 2007. Zmienne w zapytaniach języka SPARQL oznaczamy przez

?nazwa_zmiennej Przykład 53 Dane: <http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> "SPARQL Tutorial" . Zapytanie: SELECT ?title WHERE { <http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> ?title . } Wynik: "SPARQL Tutorial" Przykład 54 Dane: @prefix foaf: <http://xmlns.com/foaf/0.1/> . _:a foaf:name "Johnny Lee Outlaw" . _:a foaf:mbox <mailto:[email protected]> . _:b foaf:name "Peter Goodguy" . _:b foaf:mbox <mailto:[email protected]> . _:c foaf:mbox <mailto:[email protected]> . Zapytanie: PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name ?mbox WHERE { ?x foaf:name ?name . ?x foaf:mbox ?mbox } Wynik: "Johnny Lee Outlaw" <mailto:[email protected]>

wersja z dn. 2008-04-17 12:11:18

42


"Peter Goodguy" mailto:[email protected] Przykład 55 Dane: @prefix dt: <http://example.org/datatype#> . @prefix ns: <http://example.org/ns#> . @prefix : <http://example.org/ns#> . @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . :x ns:p "cat"@en . :y ns:p "42"^^xsd:integer . :z ns:p "abc"^^dt:specialDatatype . Zapytanie: SELECT ?v WHERE { ?v ?p "cat"@en } Wynik: <http://example.org/ns#x> Przykład 56 Dane: @prefix foaf: <http://xmlns.com/foaf/0.1/> . _:a foaf:name "Alice" . _:b foaf:name "Bob" . Zapytanie: PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?x ?name WHERE { ?x foaf:name ?name } Wynik: _:c "Alice" _:d "Bob" Przykład 57 Dane: @prefix foaf: <http://xmlns.com/foaf/0.1/> . _:a foaf:name "Alice" . _:b foaf:name "Bob" . Zapytanie: PREFIX foaf: <http://xmlns.com/foaf/0.1/>

wersja z dn. 2008-04-17 12:11:18

43


SELECT ?x ?name WHERE { ?x foaf:name ?name FILTER regex(?name, "bo", "i" )} Wynik: _:c "Bob" Przykład 58 Dane: @prefix foaf: <http://xmlns.com/foaf/0.1/> . _:a foaf:name "Alice" . _:b foaf:name "Bob" . _:a foaf:age 23 . _:b foaf:age 32 . Zapytanie: PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?z WHERE { ?x foaf:age ?y FILTER (?y<30) ?x foaf:name ?z } Wynik: "Alice" Przykład 59 Dane: @prefix dc: <http://purl.org/dc/elements/1.1/> . @prefix : <http://example.org/book/> . @prefix ns: <http://example.org/ns#> . :book1 dc:title "SPARQL Tutorial" . :book1 ns:price 42 . :book2 dc:title "The Semantic Web" . :book2 ns:price 23 . Zapytanie: PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX ns: <http://example.org/ns#> SELECT ?title ?price WHERE { ?x dc:title ?title . OPTIONAL { ?x ns:price ?price . FILTER (?price < 30) } } Wynik: "SPARQL Tutorial" "The Semantic Web" 23

wersja z dn. 2008-04-17 12:11:18

44


Zastosowania 1) Dublin Core http://dublincore.org/ http://www.ukoln.ac.uk/metadata/dcdot/ 2) Adobe PDF 3) FOAF http://www.foaf-project.org/ 3) RDFpic http://jigsaw.w3.org/rdfpic/ Aplikacje 4) IsaViz http://www.w3.org/2001/11/IsaViz/ 5) RDF API for PHP http://sites.wiwiss.fu-berlin.de/suhl/bizer/rdfapi/

wersja z dn. 2008-04-17 12:11:18

45


Dublin Core jest ogólnym standardem metadanych służącym do opisu zasobów. Wersja 1.1 standardu Dublin Core Metadata Element Set określa następujące elementy metadanych, które mogą być obecne w opisie: Title (tytuł) Creator (twórca) Subject and Keywords (temat i słowa kluczowe) Description (opis) Publisher (wydawca) Contributor (współtwórca) Date (data) Resource Type (typ zasobu) Format (format) Resource Identifier (identyfikator zasobu) Source (źródło) Language (język) Relation (odniesienie) Coverage (zakres) Rights Management (zarządzanie prawami) Przykład <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/"> <rdf:Description rdf:about="http://www.semantict.net"> <dc:title>Wprowadzenie do RDF</dc:title> <dc:creator>Marcin Skulimowski</dc:creator> <dc:date>07.05.07</dc:date> <dc:type>Text</dc:type> <dc:format>text/html</dc:format> <dc:format>1873 bytes</dc:format> <dc:language>pl</dc:language> <dc:relation>www.semantic-web.org</dc:relation> </rdf:Description> </rdf:RDF>

wersja z dn. 2008-04-17 12:11:18

46


Marcin Skulimowski Wprowadzenie do Ontology Web Language Ontologie Ontologia jest pojęciem zaczerpniętym z filozofii, gdzie miedzy innymi oznacza analizę pojęć i idei w celu ustalenia co istnieje oraz jakie są związki pomiędzy istniejącymi elementami. W informatyce pojęcia tego używa się w bardzo podobnym kontekście. Ontologia to formalna specyfikacja konceptualizacji pewnego obszaru wiedzy czy opisu elementów rzeczywistości. Przy projektowaniu ontologii wykorzystywane są metody kategoryzacji i hierarchizacji. Pewnym pojęciom abstrakcyjnym i grupom obiektów posiadającym wspólne cechy przyporządkowywane są nazwy, tworzone są wiec klasy obiektów (kategoryzacja). Tak utworzone klasy są następnie umieszczane w strukturze hierarchicznej. Przy tworzeniu ontologii można użyć różnych języków modelowania. Najczęściej wykorzystywany jest RDF/RDFS lub bardziej wyrafinowane języki wykorzystujące tą technologię np. OWL. Wymagania stawiane językom służącym do tworzenia ontologii Dobrze określona składnia. Formalna semantyka – semantyka opisująca precyzyjnie wiedzę. Precyzyjnie tzn. bez subiektywnych intuicji oraz bez możliwość różnych interpretacji przez różne aplikacje. Skuteczne wnioskowanie Formalna semantyka pozwala wnioskować na temat wiedzy. W przypadku ontologii możemy wnioskować o:

• Przynależności do klasy. Jeżeli x jest przykładem klasy C i C jest podklasą D wówczas wnioskujemy, że x jest przykładem D.

• Równoważności klas.

Jeżeli klasa A jest równoważna klasie B i klasa B jest równoważna klasie C wówczas klasa A jest równoważna klasie C.

• Niesprzeczności. Przypuśćmy, że zadeklarowaliśmy, że x jest przykładem klasy A i klasa A jest podklasą B∩C, A jest podklasą D, klasy B i D są rozłączne. Otrzymujemy sprzeczność.

• Klasyfikacji. Jeżeli zdeklarujemy, że pewne warunki są wystarczające dla przynależności do klasy A, wówczas jeżeli obiekt x spełnia te warunki, wówczas wnioskujemy, że x jest przykładem klasy A.

Wnioskowania takie są przeprowadzane automatycznie i pozwalają:

wersja z dn. 2008-04-17 12:11:18

47


• Sprawdzić niesprzeczność ontologii. • Automatycznie klasyfikować przykłady klasy. • Uzyskać zależności między klasami, które nie są wprost zapisane w ontologii.

Ontology Web Language Nagłówek Dokumenty OWL (nazywamy ontologiami OWL) są dokumentami RDF/XML. Korzeniem takiego dokumentu jest element RDF którego atrybutami są deklaracje przestrzeni nazw. Przykład 1 <rdf:RDF xmlns="http://www.semantict.net/RDF/introRDF/elements#" xml:base="http://www.semantict.net/RDF/introRDF/elements#" xmlns:intrdf="http://www.semantict.net/RDF/introRDF/elements#" 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#"> Następnym elementem jest opcjonalny element owl:Ontology, który zawiera pewne informacje dotyczące ontologii. Element ten zawiera atrybut rdf:about, którego wartość określa nazwę lub referencję do ontologii. Wartość "" oznacza, ze opisujemy ontologię znajdującą się w bieżącym dokumencie. Reprezentant klasy owl:Ontology (czyli ontologia) posiada następujące właściwości:

• owl:versionInfo – informacje o wersji ontologii.

• owl:priorVersion – poprzednia wersji ontologii (właściwość nie tylko owl:Ontology).

• owl:backwardCompatibleWith – określa ontologię, która jest „kompatybilna” z

daną ontologią. Wszystkie konstrukcje występujące w obu ontologiach (klasy, właściwości etc.) mają to samo znaczenie.

• owl:incompatibleWith - określa ontologię, która jest nie kompatybilna z daną

ontologią. Niekompatybilność może na przykład oznaczać, że zmieniło się określenie jednej z klas.

• owl:imports – określa identyfikator URI ontologii, które są przyjmowane jako

część aktualnej ontologii.

Jeżeli ontologia A importuje ontologię B oznacza to, że w ontologii A są wszystkie klasy i właściwości określone przez B.

wersja z dn. 2008-04-17 12:11:18

48


• owl:imports jest właściwością przechodnią. Jeżeli ontologia A importuje ontologię

B i ontologia B importuje ontologię C wówczas ontologia A importuje ontologię C. Przykład 2 <owl:Ontology rdf:about=""> <rdfs:label>Ontologia Uniwersytetu</rdfs:label> <owl:versionInfo>Pierwsza wersja ontologii zwiazanej z uniwersytetem</owl:versionInfo> <owl:priorVersion rdf:resource="http://www.semantict.net/OWL/07/uni-old/"/> <owl:backwardCompatibleWith rdf:resource="http://www.semantict.net/OWL/06/uni-old/"/> <owl:incompatibleWith rdf:resource="http://www.semantict.net/OWL/05/uni-old/"/> <owl:imports rdf:resource="http://www.domain.com/uni"/> Klasy W języku OWL istnieją dwie wbudowane klasy:

owl:Thing – klasa zwierająca wszystkie klasy.

owl:Nothing – klasa pusta zawierająca się w każdej klasie. Własne klasy definiujemy przy pomocy elementu owl:Class. Klasa owl:Class jest podklasą klasy rdfs:Class. Przykład 3 <owl:Class rdf:ID=”Profesor”> <rdfs:subClassOf rdf:resource=”#kadraAkademicka”/> <owl:Class> W języku OWL możemy powiedzieć, że dwie klasy są rozłączne. Używamy w tym celu właściwości owl:disjointWith. Przykład 4 <owl:Class rdf:about=”#Profesor”> <rdfs:disjointWith rdf:resource=”#Adiunkt”/> <rdfs:disjointWith rdf:resource=”#Asystent”/> </owl:Class> Możemy też powiedzieć, że jedna klasa jest równoważna z inną klasą. Służy do tego właściwość owl:equvalentClass.

wersja z dn. 2008-04-17 12:11:18

49


Przykład 5 <owl:Class rdf:about=”#Adiunkt”> <rdfs:equivalentClass rdf:resource=”#Doktor”/> </owl:Class> Właściwości W języku OWL istnieją dwa rodzaje właściwości:

• właściwości obiektowe (owl:ObjectProperty) – łączą obiekty z obiektami. Przykład 6 <owl:ObjectProperty rdf:ID=”jestProwadzonyPrzez”> <rdfs:domain rdf:resource=”#Wyklad”/> <rdfs:range rdf:resource=”#Profesor”/> </owl:Class>

• właściwości typów danych (owl:DatatypeProperty) – łączą obiekty ze standardowymi typami danych (np. z XMLSchema)

Przykład 7 <owl:DatatypeProperty rdf:about=”#rokStudiow”> <rdfs:domain rdf:resource=”#Student”/> <rdfs:range rdf:resource=”http://www.w3.org/2001/XMLSchema#integer”/> </owl:Class> Właściwość owl:inverseOf służy do określenia właściwość będącej odwrotnością innej właściwości. Przykład 8 <owl:ObjectProperty rdf:about=”#prowadziWyklad”> <rdfs:domain rdf:resource=”#Profesor”/> <rdfs:range rdf:resource=”#Wyklad”/> <owl:inverseOf rdf:resource=”#jestProwadzonyPrzez”/> </owl:Class> Podobnie jak w przypadku klas możemy powiedzieć, że dwie właściwości są równoważne. Służy do tego właściwość owl:equivalentProperty. Przykład 9 <owl:ObjectProperty rdf:ID=”#wyklada”> <owl:equivalentProperty rdf:resource=”#prowadziWyklad”/>

wersja z dn. 2008-04-17 12:11:18

50


</owl:ObjectProperty> Ograniczenia właściwości Załóżmy, że chcemy powiedzieć, że wszyscy reprezentanci klasy C spełniają pewne warunki (oprócz wieli innych). Możemy to zrobić twierdząc, że klasa C jest podklasą klasy C’ której wszyscy reprezentanci spełniają te warunki. Klasa C’ nie ma identyfikatora (jest anonimowa) i jest określona przez podanie warunków jakie spełniają jej elementy. Warunki te są związane z ograniczeniami nałożonymi na właściwości. Ograniczenie właściwości określamy następująco: <owl:Restriction> <owl:onProperty rdf:resorce=”nazwa_wlasciwosci”/> sposób_ograniczenia </owl:Restriction> Właściwości możemy ograniczać na kilka sposobów. Ograniczenia wartości owl:allValuesFrom – określa dopuszczalne wartości właściwości. Przykład 10 <owl:Class rdf:about=”wykladNaPierwszymRoku”> <owl:subClassOf> <owl:Restriction> <owl:onProperty rdf:resorce=”#jestProwadzonyPrzez”/> <owl:allValuesFrom rdf:resorce=”#Profesor”/> </owl:Restriction> </owl:subClassOf> </owl:Class> Klasa wykladNaPierwszymRoku obejmuje wykłady, które są prowadzone przez przedstawicieli klasy Profesor. UWAGA: nie oznacza to, że każdy przedstawiciel klasy wykladNaPierwszymRoku musi mieć określonego prowadzącego profesora. Jeżeli jednak ma właściwość jestProwadzonyPrzez to jej wartość musi być typu Profesor.

wersja z dn. 2008-04-17 12:11:18

51


owl:someValuesFrom – przynajmniej jedna wartość właściwości musi być danego typu. Przykład 11 <owl:Class rdf:about=”#Profesor”> <owl:subClassOf> <owl:Restriction> < <owl:someValuesFrom rdf:resorce=”#wykladMonograficzny”/>

owl:onProperty rdf:resorce=”#prowadziWyklad”/>

</owl:Restriction> </owl:subClassOf> </owl:Class> Oznacza to, że każdy reprezentant klasy Profesor musi prowadzić przynajmniej jeden wykład monograficzny (reprezentant klasy wykladMonograficzny). owl:hasValue – określa dokładną wartość właściwości. Przykład 12 <owl:Class rdf:about=”#wykladMatematyka”> <owl:subClassOf> <owl:Restriction> < w <owl:hasValue rdf:resorce=”#787678”/>

owl:onProperty rdf:resorce=”#jestPro adzonyPrzez”/>

</owl:Restriction> </owl:subClassOf> </owl:Class> Oznacza to, że wykład z matematyki jest prowadzony przez osobą o identyfikatorze 787678. Ograniczenia kardynalne Ograniczenia takie pozwalają nam określić ile wartości może posiadać dana właściwość. owl:minCardinality – minimalna liczba wartości. owl:maxCardinality – minimalna liczba wartości. owl:Cardinality – dokładna liczba wartości.

wersja z dn. 2008-04-17 12:11:18

52


Przykład 13 <owl:Class rdf:about=”#WykladOpcjonalny”> <owl:subClassOf> <owl:Restriction> <owl:onProperty rdf:resorce=”#uczestniczy”/> <owl:minCardinality rdf:datatype=”http://www.w3.org/2001/XMLSchema#nonNegativeInteger”/> 10 </owl:minCardinality> </owl:Restriction> </owl:subClassOf> </owl:Class> Specjalne właściwości

• owl:TransitiveProperty – właściwość przechodnia.

Przykład: jestWyzszyOd, jestNastepca.

• owl:SymmetricProperty – właściwość symetryczna.

Przykład: jestTegoSamegoWzrostu, jestBratem.

• owl:FunctionalProperty – właściwość która może posiadać co najwyżej jedna wartość.

Przykład: wiek, wzrost, numerISSN.

• owl:inverseFunctionalProperty – właściwość która dla dwóch różnych obiektów nie może posiadać tej samej wartości.

Przykład: numerPesel, numerTelefonu.

Przykład 14 <owl:ObjectProperty rdf:ID=”studiujeNaTymSamymRokuCo”> <rdf:type rdf:resource=”&owl;TransitiveProperty”/> <rdf:type rdf:resource=”&owl;SymmetricProperty”/> <rdfs:domain rdf:resource=”#Student”/> <rdfs:range rdf:resource=”#Student”/> </owl:ObjectProperty>

wersja z dn. 2008-04-17 12:11:18

53


Operacje Boolowskie W języku OWL możliwe definiowanie klas przy pomocy operacji Boolowskich. owl:unionOf – określamy klasę będącą sumą innych klas. Przykład 15 <owl:Class rdf:ID=”skladOsobowyUniwersytetu”> <owl:unionOf rdf:parseType=”Collection”> <owl:Class rdf:about=”#kadraAkademicka”/> <owl:Class rdf:about=”#Student”/> </owl:unionOf> </owl:Class> owl:interSectionOf – określamy klasę będącą sumą innych klas. Przykład 16 <owl:Class rdf:ID=”AdunkciWydzialuMatematyki”> <owl:interSectionOf rdf:parseType=”Collection”> <owl:Class rdf:about=”#OsobyZeStopniemDoktora”/> <owl:Class rdf:about=”#PracownicyWydzialuMatematyki”/> </owl:unionOf> </owl:Class> owl:complementOf – określamy klasę będącą dopełnieniem innej klasy. Przykład 16 <owl:Class rdf:ID=”pracownicyAdministracji”> <owl:subClassOf> <owl:Class> <owl:complementOf rdf:resource=”pracownicyNaukowi”/> </owl:Class> </owl:subClassOf> </owl:Class>

wersja z dn. 2008-04-17 12:11:18

54


Wyliczanie Za pomocą elementu owl:oneOf możemy określić klasę wypisując jej wszystkie elementy. Przykład 17 <owl:Class rdf:ID=”DniTygodnia”> <owl:oneOf rdf:parseType=”Collection”> <owl:Thing rdf:about=”#Poniedzialek”/> <owl:Thing rdf:about=”#Wtorek”/> <owl:Thing rdf:about=”#Sroda”/> <owl:Thing rdf:about=”#Czwartek”/> <owl:Thing rdf:about=”#Piatek”/> <owl:Thing rdf:about=”#Sobota”/> <owl:Thing rdf:about=”#Niedziela”/> </owl:oneOf> </owl:Class> Przykłady klas Klasy zdefiniowane w ontologii możemy wykorzystywać w dokumentach RDF. Przykład 18 <rdf:Description rdf:ID=”949352”> <rdf:type rdf:resource=”#kadraAkademicka”/> <rdf:Description> Równoważnie Przykład 19 <kadraAkademicka rdf:ID=”949352”/> Oczywiście do określenia klasy możemy dodać orzeczenia. Przykład 20 <kadraAkademicka rdf:ID=”949352”> <uni:prowadziWyklad>Matematyka Dyskretna</uni:prowadziWyklad> </kadraAkademicka> W języku OWL dwa obiekty (przykłady) klasy mające różne identyfikatory lub nazwy nie muszą być różnymi obiektami.

wersja z dn. 2008-04-17 12:11:18

55


Przykład 21 <owl:ObjectProperty rdf:ID=”jestProwadzonyPrzez”> <rdfs:domain rdf:resource=”#Wyklad”/> <rdfs:range rdf:resource=”#Profesor”/> <rdf:type rdf:resource=”&owl;FunctionalProperty”/> </owl:Class> <Wyklad rdf:ID=”w234”> <jestProwadzonyPrzez rdf:resource=”#789098”> <jestProwadzonyPrzez rdf:resource=”#675899”> </Wyklad> Powyższy fragment ontologii nie prowadzi aplikacji wnioskującej do sprzeczności ponieważ nie jest powiedziane, że profesor o ID 789098 nie jest profesorem o ID 675899. Informacje o tym, że dwa przykłady klasy są różne musimy zapisać wprost. Przykład 22 <Profesor ID=”789098”> <owl:differentFrom rdf:resource=”#675899”/> </Profesor> Przykład 23 <owl:AllDifferent> <owl:distinctMembers rdf:parseType=”Collection”> <lecturer rdf:about=”#789098”/> <lecturer rdf:about=”#455512”/> <lecturer rdf:about=”#123333”/> <lecturer rdf:about=”#456789”/> </owl:distinctMembers> </owl:AllDifferent>

wersja z dn. 2008-04-17 12:11:18

56


Dialekty OWL OWL Full – wszystkie konstrukcje języka mogą być stosowane. OWL DL – spełnia następujące warunki:

• podział słownictwa – każdy zasób może być jedynie: klasą, typem danych, właściwością, przykładem klasy lub częścią wbudowanego słownictwa. Oznacza to, że np. klasa nie może być jednocześnie przykładem klasy. Podobnie właściwość nie może posiadać pewnych wartości będących typami danych i pewnych będących przykładami klas.

• Typy zasobów muszą być pisane wprost. Przykład 24 <owl:Class rdf:ID=”C1”>

<rdfs:SubClassOf rdf:about=”#C2”/> </owl:Class> Możemy wywnioskować, że zasób C2 jest klasą. W OWL DL musi to być jednak zapisane wprost: <owl:Class rdf:ID=”C2”/> • Zbiory właściwości obiektowych i właściwości typów danych są rozłączne.

• Właściwości przechodnie nie mogą być ograniczane kardynalnie.

• Anonimowe klasy są dozwolone jedynie jako dziedzina i zakres

owl:equivalentClass oraz owl:disjointWith, i jako zakres rdfs:subClassOf.

OWL Lite – spełnia warunki OWL DL oraz warunki:

• Zakazane jest użycie konstruktorów: owl:oneOf, owl:disjointWith, owl:unionOf, owl:complementOf i owl:hasValue.

• W ograniczeniach kardynalnych właściwości można stosować tylko liczby 0 i 1.

• Właściwość owl:equivalentClass nie być użyta dla anonimowych klas.

wersja z dn. 2008-04-17 12:11:18

57


wersja z dn. 2008-04-17 12:11:18

58


Reguły wnioskowania w notacji N3.

Aby móc wnioskować w oparciu o RDF i OWL musimy dysponować regułami np.

{ :termostat :temp :wysoka} log:implies { :podgrzewanie :moc ”0” } .

W formułach mogą występować zmienne, które mogą przyjmować wartości różnych obiektów. Możliwe są dwa rodzaje zmiennych. Zmienne uniwersalne Zmienną uniwersalną deklarujemy następująco:

@forAll :x Przykład 1 Rozważmy regułę: @forAll :x. { :termostat :temp :x } log:implies { :chlodzenie :moc :x } . Reguła ta mówi, że jeżeli temperatura jest x wówczas moc chłodzenia wynosi x. Zmienne egzystencjalne Zmienną egzystencjalną deklarujemy następująco:

@forSome :x

wersja z dn. 2008-04-17 12:11:18

59


Przykład 2 Rozważmy regułę: @forSome :a. :Tomek :dom :a . :a :telefon ”4566778” . Reguła ta mówi, że istnieje coś takiego jak dom Tomka i ma numer telefonu 4566778. Zauważmy, że możemy to zapisać inaczej: :Tomek :dom [ :telefon ”4566778” ] . Puste węzły są zmiennymi egzystencjalnymi. Przykład 3 Stwierdzenia:

[ intrdf:imie ”Marcin” ] intrdf:wiek ”34” . Możemy zapisać równoważnie: @forSome :a. :a intrdf:imie ”Marcin” . :a intrdf:wiek ”34” . Podobnie stwierdzenia:

[ intrdf:imie ”Marcin” ] intrdf:autor [ intrdf:tytul ”Wprowadzenie do RDF” ] . możemy zapisać: @forSome :a. @forSome :b. :a intrdf:imie ”Marcin” . :a intrdf:autor :b . :b intrdf:tytul ”Wprowadzenie do RDF” . Zmienne z ? i _ W niektórych sytuacjach nie musimy wprowadzać zmiennych uniwersalnych i egzystencjalnych. Zamiast zmiennej uniwersalnej możemy użyć ?x. Przykład 4 Regułę: @forAll :x, :y. { :x :rodzic :y } log:implies { :y :dziecko :x } .

wersja z dn. 2008-04-17 12:11:18

60


Możemy zapisać następująco: { ?x :rodzic ?y } log:implies { ?y :dziecko ?x } . Zamiast zmiennej uniwersalnej możemy użyć _:x. Przykład 5 Stwierdzenia: @forSome :x, :y. :x :kocha :y . :y :niekocha :x . Możemy zapisać następująco: _:x :kocha _:y . _:y :niekocha _:x . Możemy też korzystać z [] pomijając zmienne egzystencjalne w ogóle. Konstrukcje i reguły w RDF i RDFS W opisywanych regułach będziemy korzystali z następujących przestrzeni nazw. @prefix log: <http://www.w3.org/2000/10/swap/log#>. @prefix math: <http://www.w3.org/2000/10/swap/math#>. @prefix list: <http://www.w3.org/2000/10/swap/list#>. @prefix owl: <http://www.w3.org/2002/07/owl#>. @prefix xsd: <http://www.w3.org/2001/XMLSchema#>. @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>. @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. @prefix : <http://eulersharp.sourceforge.net/2003/03swap/rpo-rules#>. Definicje RDF i OWL Definicje wszystkich konstrukcji używanych w językach RDF, RDFS i OWL możemy zapisać w notacji N3. owl:ObjectProperty rdfs:subClassOf rdf:Property. owl:OntologyProperty rdfs:subClassOf rdf:Property. owl:Restriction rdfs:subClassOf owl:Class. rdfs:subClassOf a rdf:Property;

rdfs:domain rdfs:Class; rdfs:range rdfs:Class; a owl:TransitiveProperty.

wersja z dn. 2008-04-17 12:11:18

61


rdfs:subPropertyOf a rdf:Property; rdfs:domain rdf:Property; rdfs:range rdf:Property; a owl:TransitiveProperty.

rdf:first a rdf:Property;

rdfs:domain rdf:List. rdf:rest a rdf:Property;

rdfs:domain rdf:List; rdfs:range rdf:List.

owl:equivalentClass a rdf:Property;

rdfs:domain rdfs:Class; rdfs:range rdfs:Class; rdfs:subPropertyOf rdfs:subClassOf; a owl:SymmetricProperty.

owl:equivalentProperty a rdf:Property;

rdfs:domain rdf:Property; rdfs:range rdf:Property; rdfs:subPropertyOf rdfs:subPropertyOf; a owl:SymmetricProperty.

owl:sameAs a rdf:Property;

a owl:SymmetricProperty, owl:TransitiveProperty.

owl:inverseOf a rdf:Property; rdfs:domain owl:ObjectProperty; rdfs:range owl:ObjectProperty; a owl:SymmetricProperty.

owl:differentFrom a rdf:Property;

a owl:SymmetricProperty. owl:distinctMembers a rdf:Property;

rdfs:domain owl:AllDifferent; rdfs:range rdf:List.

owl:oneOf a rdf:Property;

rdfs:domain rdfs:Class; rdfs:range rdf:List.

owl:intersectionOf a rdf:Property;

rdfs:domain rdfs:Class; rdfs:range rdf:List.

owl:unionOf a rdf:Property;

rdfs:domain rdfs:Class;

wersja z dn. 2008-04-17 12:11:18

62


rdfs:range rdf:List. owl:complementOf a rdf:Property;

rdfs:domain rdfs:Class; rdfs:range rdfs:Class.

owl:allValuesFrom rdfs:domain owl:Restriction; rdfs:range rdfs:Class. owl:hasValue rdfs:domain owl:Restriction; rdfs:range rdfs:Resource. owl:maxCardinality rdfs:domain owl:Restriction; rdfs:range xsd:nonNegativeInteger. owl:minCardinality rdfs:domain owl:Restriction; rdfs:range xsd:nonNegativeInteger. Wnioskowanie Aplikacje analizujące w oparciu o dokumenty RDF i OWL wykorzystują m.in. następujące reguły wnioskowania3:

• {?S ?P ?O} => {?P a rdf:Property}.

Przykład 6

Ze stwierdzenia:

semt:introRDF intrdf:autor kto:2344 .

wynika, że zasób intrdf:autor jest właściwością czyli:

intrdf:autor a rdf:Property .

• {?P rdfs:domain ?C. ?S ?P ?O} => {?S a ?C}.

Przykład 7

Ze stwierdzeń: :tytul rdfs:domain :Publikacja .

:2344 :tytul ”XPath and SPARQL” .

3 http://www.agfa.com/w3c/euler/owl-rules.n3 http://www.agfa.com/w3c/euler/rpo-rules.n3

wersja z dn. 2008-04-17 12:11:18

63


wynika, że zasób :2344 jest reprezentantem kasy :Publikacja czyli:

:2344 a :Publikacja .

• {?P rdfs:range ?C. ?S ?P ?O} => {?O a ?C}.

• {?A rdfs:subClassOf ?B. ?S a ?A} => {?S a ?B}.

Przykład 8

Ze stwierdzeń: :Artykul rdfs.subClassOf :Publikacja .

:2344 a :Artykul .

wynika, że zasób :2344 jest reprezentantem klasy :Publikacja czyli:

:2344 a :Publikacja .

• {?P rdfs:subPropertyOf ?R. ?S ?P ?O} => {?S ?R ?O}.

Przykład 9

Ze stwierdzeń: :tytulKsiazki rdfs:subPropertyOf :tytul .

:2344 :tytulKsiazki ”XPath and SPARQL” .

wynika, że zasób :2344 ma tytul ”XPath and SPARQL” czyli:

:2344 :tytul ”XPath and SPARQL” .

• {?X owl:sameAs ?Y. ?P a rdf:Property. ?X ?P ?O} => {?Y ?P ?O}.

Przykład 10

Ze stwierdzeń: :2344 owl:sameAs :4567 .

:tytulKsiazki a rdf:Property .


wynika, że zasób :4567 ma tytul ”XPath and SPARQL” czyli:


• {?X owl:sameAs ?Y. ?S ?X ?O} => {?S ?Y ?O}.

wersja z dn. 2008-04-17 12:11:18

64


• {?X owl:sameAs ?Y. ?P a rdf:Property. ?S ?P ?X} => {?S ?P ?Y}. • {?P owl:inverseOf ?Q. ?S ?P ?O} => {?O ?Q ?S}. • {?P a owl:SymmetricProperty. ?S ?P ?O} => {?O ?P ?S}.

Przykład 11

Ze stwierdzeń:

:wspolpracownik a owl:SymmetricProperty .

:8878 :wspolpracownik :9876 .

Wynika, że

:9876 :wspolpracownik :8878 .

• {?P a owl:TransitiveProperty. ?S ?P ?X. ?X ?P ?O} => {?S ?P ?O}.

Przykład 12

Ze stwierdzeń: :jestStarszyOd a owl:TransitiveProperty .

:8878 :jestStarszyOd :9876 .

:9876 :jestStarszyOd :1000 .

Wynika, że

:8878 :jestStarszy :1000 .

• {?P a owl:FunctionalProperty. ?S ?P ?X. ?S ?P ?Y} => {?X owl:sameAs ?Y}.

Przykład 13

Ze stwierdzeń: :mama a owl:FunctionalProperty .

:1000 :mama :3453 . :1000 :mama :1234 .

Wynika, że

:3453 :sameAs :1234 .

• {?P a owl:InverseFunctionalProperty. ?X ?P ?O. ?Y ?P ?O} => {?X owl:sameAs ?Y}.

Przykład 14

Ze stwierdzeń:

wersja z dn. 2008-04-17 12:11:18

65


:issn a owl:InverseFunctionalProperty .

:4567 :issn ”23435677” . :3433 :issn ”23435677” .

Wynika, że

:4567 :owlSameAs :3433 .

• {?A owl:distinctMembers ?D. ?D rdf:rest ?R} => {?A owl:distinctMembers ?R}.

• {?A owl:distinctMembers ?D. ?L :subListOf ?D. ?L rdf:first ?X; rdf:rest ?R. ?Y list:in ?R} => {?X owl:differentFrom ?Y}.

• {?C owl:oneOf ?L. ?X list:in ?L} => {?X a ?C}. • {?C owl:intersectionOf ?L. ?X :inAllOf ?L} => {?X a ?C}.

Przykład 15

Ze stwierdzeń: :2345 owl:intersectionOf { :a, :b } .

:3456 :inAllOf { :a, :b } .

Wynika, że

:3456 a :2345 .

• {?A rdfs:subClassOf ?B. ?B rdfs:subClassOf ?A} => {?A owl:equivalentClass ?B}. • {?A owl:onProperty ?P, ?Q; owl:hasValue ?V. ?P @has rdfs:domain ?A; a

owl:FunctionalProperty. ?Q rdfs:domain ?D; a owl:FunctionalProperty} => {?P rdfs:subPropertyOf ?Q}.

Reguły prowadzące do sprzeczności:

• {?B owl:onProperty ?P1; owl:someValuesFrom ?X. ?X @has owl:intersectionOf ?L. ?L :item

?I1. ?I1 owl:onProperty ?P2; owl:someValuesFrom owl:Thing. ?L :item ?I2. ?I2 owl:onProperty ?P3; owl:someValuesFrom owl:Thing. ?L :item ?I3. ?I3 owl:onProperty ?P2; owl:allValuesFrom ?C. ?L :item ?I4. ?I4 owl:onProperty ?P3; owl:allValuesFrom ?U. ?U2 owl:onProperty ?P2; owl:someValuesFrom owl:Thing. ?U @has owl:equivalentClass ?U2. ?L :item ?I5. ?I5 owl:onProperty ?P3; owl:allValuesFrom ?V. ?V2 owl:onProperty ?P3; owl:someValuesFrom owl:Thing. ?V @has owl:equivalentClass ?V2. ?L :item ?I6. ?I6 owl:onProperty ?P3; owl:allValuesFrom ?W. ?W2 owl:onProperty ?P2; owl:allValuesFrom ?C. ?W @has owl:equivalentClass ?W2. ?C @has owl:equivalentClass ?C1. ?C1 owl:onProperty ?P8; owl:allValuesFrom ?C2. ?P8 owl:inverseOf ?P2. ?D2 owl:onProperty ?P7; owl:allValuesFrom ?C3. ?P7 owl:inverseOf ?P3. ?C2 @has owl:equivalentClass ?D2. ?D3 owl:onProperty ?P9; owl:allValuesFrom ?C4. ?P9 owl:inverseOf ?P1. ?C3 @has owl:equivalentClass ?D3. ?C4 owl:complementOf ?A. ?P3 a owl:TransitiveProperty. ?D rdfs:subClassOf ?A, ?B}

=> {?D owl:equivalentClass owl:Nothing}.

wersja z dn. 2008-04-17 12:11:18

66


• {?C1 @has owl:equivalentClass ?A. ?A owl:onProperty ?P1; owl:someValuesFrom ?C6. ?P1

@has rdfs:domain ?C1; @has rdfs:range ?C6; @has rdf:type owl:FunctionalProperty. ?C1 @has owl:equivalentClass ?B. ?B owl:onProperty ?P3; owl:someValuesFrom ?C5. ?P3 @has rdfs:domain ?C1; @has rdfs:range ?C5; @has rdf:type owl:FunctionalProperty. ?C5 @has owl:equivalentClass ?C. ?C owl:onProperty ?P2; owl:someValuesFrom ?C6. ?P2 @has rdfs:domain ?C5; @has rdfs:range ?C6; @has rdf:type owl:FunctionalProperty. ?C5 @has owl:equivalentClass ?D. ?D owl:onProperty ?P7; owl:cardinality ?X1. ?P7 owl:inverseOf ?P3. ?C6 @has owl:equivalentClass ?F. ?F owl:onProperty ?P8; owl:cardinality ?X2. ?P8 owl:inverseOf ?P2. ?C6 @has owl:equivalentClass ?H. ?H owl:onProperty ?P9; owl:cardinality ?X3. ?P9 owl:inverseOf ?P1. ?H @has owl:equivalentClass ?I. ?I owl:onProperty ?P4; owl:someValuesFrom ?C3. ?P4 @has rdfs:domain ?C6; @has rdfs:range ?C3; @has rdf:type owl:FunctionalProperty. ?C3 @has owl:equivalentClass ?G. ?G owl:onProperty ?P6; owl:maxCardinality ?X4. ?P6 owl:inverseOf ?P4. (?X1 ?X2) math:product ?X. ?X math:notEqualTo ?X3} => {?C3 owl:equivalentClass owl:Nothing}.

wersja z dn. 2008-04-17 12:11:18

67

Resource Description Frameworkmerlin.fic.uni.lodz.pl/MSkulimowski/rdfowl.pdfMarcin Skulimowski - RDF...

Documents

Transcript of Resource Description Frameworkmerlin.fic.uni.lodz.pl/MSkulimowski/rdfowl.pdfMarcin Skulimowski - RDF...