**OWL - Web Ontology Language** jest językiem ze składnią opartą na XML, a semantyką opartą na tzw. logice deskrypcyjnej (ang. description logics). Stanowi on rozszerzenie [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rdf|RDF (ang. Resource Description Framework)]]. Służy do reprezentacji i przetwarzania danych w sieci WWW. OWL umożliwia opisywanie danych w postaci ontologii i budowanie w ten sposób tzw. Semantycznego Internetu. OWL  posiada trzy podjęzyki o wzrastającej ekspresyjności: OWL Lite, OWL DL, and OWL Full. Zapis w języku OWL składa się z definicji ontologicznych metadanych (container), definicji 
relacji binarnych, pojęć, przykładów pojęć oraz aksjomatów definiujących omówione dodatkowe 
właściwości pojęć i relacji.

[[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:owl:syntax|Krótka charakterystyka języka OWL]]

Ponieważ OWL posiada pewne ograniczenia - nie można uchwycić złożonych relacji pomiędzy zdefiniowanymi właściwościami (chociażby ogólnie znany przykład "uncle") - powstała idea rozszerzenia OWL'a o pewne formy regułowe przy jednoczesnym zachowaniu maksymalnej kompatybilności z istniejącą składnią i semantyką OWL. 

Obecnie istnieje propozycja języka **[[http://www.daml.org/2003/11/swrl/|SWRL - Semantic Web Rule Language]]** (początkowo nazwany ORL - OWL Rules Language) opartego na połączeniu podjęzyków OWL DL i OWL Lite języka OWL z fragmentami języka [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:ruleML|RuleML (Rule Markup Language)]]. Propozycja ta rozszerza zbiór aksjomatów zapisanych w języku OWL tak, aby obejmował reguły mające postać klauzul. Pozwala to łączyć takie reguły z bazą wiedzy zapisaną w języku OWL. Proponowane reguły mają postać implikacji pomiędzy poprzednikiem (ciałem) i następnikiem (nagłówkiem). Poprzednik i następnik mogą być zbudowane z koniunkcji atomów, pojedynczego atomu albo być puste. (Wiadomo, że regułę zawierającą koniunkcję w następniku można przekształcić w zestaw reguł zawierających tylko jeden atom w następniku). Reguła ma następujące znaczenie: jeśli warunki podane w poprzedniku zachodzą, to warunki podane w następniku także muszą zachodzić. Pusty poprzednik jest traktowany jako trywialnie prawdziwy, a pusty następnik jako trywialnie fałszywy. Atomy w regułach mogą być postaci C(x), P(x,y), sameAs(x,y) lub differentFrom(x,y), gdzie C jest deskrypcją pojęcia języka OWL, P jest własnocią, a x,y są albo zmiennymi, albo indywiduami, albo wartościami danych.

W tzw. Human Readable Syntax czyli składni bardziej czytelnej człowiekowi reguły przyjmują formę:

<code xml>
antecedent -> consequent   czyli   poprzednik -> następnik
</code>

gdzie zarówno antecedent jak i consequent składają się ze zbioru atomów a1 ^ a2 ^ ... ^ an. Zmienne są zaznaczane przy użyciu standardowej konwencji prefixowania ich znakiem zapytania (np.?x). Korzystając z tej składni reguła  stwierdzająca że połączenie własności 'parent' i 'brother' da nam własność 'uncle' może być zapisana następująco:

<code xml>
parent(?a,?b) ^ brother (?b,?c) -> uncle(?a,?c)
</code>

czyli jeśli Mary jest rodzicem Johna i Bill jest bratem Mary, to ta reguła wymaga by Bill był wujkiem Johna. 

Indywidua są zaznaczane za pomocą ich nazw w OWL. Przykładem indywiduum może być 'Fred' lub 'Mary'. Przykład reguły w SWRL określającej własność hasBrother, korzystającej z indywiduum :  

<code xml>
Person(Mary) ^ hasSibling(Mary, Fred) ^ Male(Fred) -> hasBrother(Mary, Fred)
</code>

Podstawowe typy takie jak integer, long, float czy double są określane za pomocą XML Schema datatypes. Wartości typu Boolean czyli prawda i fałsz są przedstawiane za pomocą vartości "true" i "false". Przykłady literałów:
<code xml>
34    
4.45    
-34    
True   
false      
"a literal"   
</code>
Wszystkie typy danych muszą być poprzedzone prefixem przestrzeni nazw 'xsd:', np:
<code xml>
xsd:unsignedInt    
xsd:string    
</code>
Nie wszystkie typy danych XML Schema są obecnie obsługiwane. Do tych wpieranych zaliczamy  xsd:int, xsd:short, xsd:long, xsd:boolean, xsd:float, xsd:double, xsd:string, xsd:time, xsd:anyURI, xsd:base64Binary, xsd:xsd:byte, xsd:duration, xsd:dateTime, oraz xsd:date.

Literały mogą być sprecyzowane typem danych przez poprzedzenie ich parą "^^" oraz nazwą typu danej, np: 
<code xml>
34^^xsd:unsignedInt 
"a literal"^^xsd:string
</code>

Jedną z najważniejszych cech SWRL jest możliwość korzystania z  zdefiniowanych przez użytkownika predykatów. Predykaty te mogą pobierać jeden lub więcej argumentów i ocenić prawdę jeśli argumenty te odpowiadają predykatowi. Na przykład predykat 'równości' może być zdefiniowany tak by przyjmować dwa argumenty i zwracać true jeśli te argumenty są takie same. Duża liczba typowych predykatów wykonujących operacje matematyczne oraz operacje na stringach zawarte są w SWRL Built-in Submission.

Przykład reguły SWRL korzystającej z wbudowanego predykatu by stwierdzić że osoba z wiekiem większym niż 17 jest osobą dorosłą:
<code xml>
Person(?p) ^ hasAge(?p, ?age) ^ swrlb:greaterThan(?age, 17) -> Adult(?p) 
</code>

Dla zachowania konwencji predykaty zawarte w SWRL poprzedzane są prefixem swrlb.
<code xml>
Person(?p) ^ hasNumber(?p, ?number) ^ swrlb:startsWith(?number, "+") -> hasInternationalNumber(?p, true) 
</code>

W SWRL negacja nie jest możliwa, czyli poniższa reguła jest błędem:
<code xml>
Person(?p) ^ ¬ hasCar(?p, ?c) -> CarlessPerson(?p)
</code>

Więcej informacji oraz odpowiedzi na najczęściej zadawane pytania odnośnie SWRL: http://protege.cim3.net/cgi-bin/wiki.pl?SWRLLanguageFAQ

Teraz kilka słów o SWRL zapisywanym w XML Presentation Syntax.

  * **owlr** - prefix przestrzeni nazw dla nowo przedstawianej składni (**swrlx** w innych opracowaniach)
  * **owlx** - prefix przestrzeni nazw http://www.w3.org/2003/05/owl-xml 

Deklaracje zmiennych są zdaniami wskazującymi by dany URI był używany jako zmienna. Na przykład:

<code xml>
<owlr:Variable owlr:name="x1"/>
</code>

Aksjomaty reguł posiadają poprzedników (owlr:antecedent) oraz następników (owlr:consequent), które są listami atomów tworzonych z klas, predykatów, równości i nierówności. Na przykład:

<code xml>
<owlr:classAtom>
    <owlx:Class owlx:name="Person"/>
    <owlr:Variable owlr:name="x1"/>
</owlr:classAtom>
</code>

jest atomem klasy używającym nazwy Person, natomiast:

<code xml>
<owlr:classAtom>
    <owlx:IntersectionOf>
        <owlx:Class owlx:name="Person"/>
        <owlx:ObjectRestriction owlx:"hasParent"/>
              <owlx:someValuesFrom owlx:class="Physician"/>
        <owlx:ObjectRestriction/>
    <owlx:IntersectionOf>
    <owlr:Variable owlr:name="x2"/>
</owlr:classAtom>
</code>

jest atomem klasy używającym opis reprezentujący osobę('Person') mającą przynajmniej jednego rodzica, który jest lekarzem('Physician')

Property atom zawiera atrybut name oraz dwa elementy które mogą być zmiennymi, indywiduami, albo wartościami danych. Na przykład:

<code xml>
<owlr:datavaluedPropertyAtom owlr:property="grade">
    <owlr:Variable owlr:name="x1">
    <owlx:DataValue rdf:datatype="&xsd:integer">4</owlx:DataValue>
</owlr:datavaluedPropertyAtom>
</code>

Na koniec jeszcze przykład atomu wskazującego równość (nierówność) pomiędzy zbiorami indywiduów i nazwami zmiennych.

<code xml>
<owlr:sameIndividualAtom>
    <owlr:Variable owlr:name="x1"/>
    <owlr:Variable owlr:name="x2"/>
    <owlx:Individual owlx:name="Clinton"/>
    <owlx:Individual owlx:name="Bill_Clinton"/>
</owlr:sameIndividualAtom>
</code>

Teraz spróbujmy zapisać nasz przykład (tj. jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą SWRL:

<code xml>
monday(?day) -> temp(20)  
</code>

w składni XML:

<code xml>
<owlx:Rule>
    <owlr:antecedent>
        <owlr:individualPropertyAtom owlr:property="monday">
            <owlr:Variable owlr:name="day"/>
        </owlr:individualPropertyAtom>
    </owlr:antecedent>
    <owlr:consequent>
        <owlr:datavaluedPropertyAtom owlr:property="temp">
            <owlx:DataValue rdf:datatype="&xsd:integer">20</owlx:DataValue>
        </owlr:datavaluedPropertyAtom>
    </owlr:consequent>
</owlx:Rule>
</code>

W materiałach z których korzystałem nie spotkałem się z identyfikowaniem zapisywanych reguł. Nie wyklucza to jednak takiej możliwości. Moja propozycja to nadawanie regułom ID analogicznie jak jest to w przypadku ERDF.

(INNE IMPLEMENTACJE SWRL MOGĄ KORZYSTAĆ ZE SKŁADNI ALTERNATYWNEJ)




====== Materiały ======

** OWL RULES: A Proposal and Prototype Implementation** http://www.cs.man.ac.uk/~horrocks/Publications/download/2005/HPBT05.pdf

** SWRL: A Semantic Web Rule Language Combining OWL and RuleML** http://www.daml.org/2003/11/swrl/

** Translator R2ML do SWRL(składnia alternatywna)** http://oxygen.informatik.tu-cottbus.de/translator/R2MLtoSWRL/index.jsp 

** OWL Overview w języku polskim** http://www.rax.pl/tlumaczenia/OWL-Web-Ontology-Language-Overview/index.htm

** OWL Overview w języku angielskim** http://www.w3.org/TR/2004/REC-owl-features-20040210/

[[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules|Powrót]]