~~SLIDESHOW~~

====== MIW 2009 OWL_Rules ======

**Zrealizował**: [[mmarsokol@gmail.com|Mariusz Sokołowski]] (4RI)

===== Abstract Syntax =====

Abstrakcyjna składnia języka ontologii OWL zawiera szereg aksjomatów i faktów. Mogą one być różnego rodzaju np. aksjomaty //subClass// i //equivalentClass//. Zaproponowano rozszerzyć je o aksjomaty reguł.
  axiom ::= rule 
Reguła składa się z poprzednika (ciała) i następnika (głowy), który zawiera zbiór atomów (może być pusty).
  rule ::= 'Implies(' { annotation } antecedent consequent ')'
  antecedent ::= 'Antecedent(' { atom } ')'
  consequent ::= 'Consequent(' { atom } ')'
Nieformalnie reguły mogą być odczytywane w ten sposób, że jeżeli poprzednik jest prawdą to także następnik musi być prawdziwy. Pusty poprzednik jest uznawany za prawdę, a pusty następnik jest uznawany za fałsz.


===== Direct Model-Theoretic Semantics =====

Dla danej interpretacji //I// abstrakcyjnego języka OWL, wiązanie //B(I)// jest interpretacją abstrakcyjnego OWL, która rozszerza //I// tak jak funkcja //S// mapuje odpowiednio //i-zmienne// do elementów //R// i //d-zmienne// do elementów  //LV<sub>T</sub>//. 

Abstrakcyjną interpretację OWL przedstawiamy w formie: //I = <R, V, EC, ER, S>//. Atom jest usatysfakcjonowany interpretacją //I// pod warunkami w poniższej tabeli.

^ Atom               ^ Condition on Interpretation ^
| description(x)     | S(x) ∈ EC(description)     |
| property(x,y)      | <S(x),S(y)> ∈ ER(property) |
| sameAs(x,y)        | S(x) = S(y)                 |
| differentFrom(x,y) | S(x) ≠ S(y)                 | 



===== XML Concrete Syntax =====

Istniejący OWL XML można łatwo rozszerzyć, tak aby można było w nim zapisać reguły, dzięki czemu:
  * dowolna klasa OWL może być użyta jako predykat w regułach;
  * aksjomaty reguł i ontologii mogą być dowolnie mieszane;
  * istniejący arkusz stylów XSLT może być łatwo rozszerzona o mapowanie do grafów RDF, które rozszerza wymienną składnię OWL RDF/XML.

\\
===== Element Ontology rozszerzony o aksjomaty Rule i Variable =====


<code xml><Ontology
  name = xsd:anyURI 
>
  Content: (VersionInfo | PriorVersion | BackwardCompatibleWith | 
            IncompatibleWith | Imports | Annotation | 
            Class[axiom] | EnumeratedClass(D,F) | 
            SubClassOf(D,F) | EquivalentClasses | DisjointClasses(D,F) | 
            DatatypeProperty | ObjectProperty | 
            SubPropertyOf | EquivalentProperties | 
            Individual[axiom] | SameIndividual | DifferentIndividuals |
            Rule[axiom] | Variable[axiom])* 
</Ontology></code>

===== Składnia elementów Variable i Rule =====

<code xml><Variable
  name = xsd:anyURI

>
  Content: ( Annotation* ) 
</Variable></code>
<code xml><Rule>
  Content: ( Annotation*, antecedent, consequent )
</Rule></code>


<code xml><antecedent>
  Content: ( atom* )
</antecedent></code>
<code xml><consequent>
  Content: ( atom* )
</consequent></code>

===== Składnia elementów Atomu =====


<code xml><classAtom>
  Content: ( description, iObject )
</classAtom></code>

<code xml><individualPropertyAtom
  property = xsd:anyURI {required} 
>
  Content: ( iObject, iObject )
</individualPropertyAtom></code>

<code xml><datavaluedPropertyAtom
  property = xsd:anyURI {required} 
>
  Content: ( iObject, dObject )
</datavaluedPropertyAtom></code>

<code xml><sameIndividualAtom>
  Content: ( iObject* )
</sameIndividualAtom></code>

<code xml><differentIndividualsAtom>
  Content: ( iObject* )
</differentIndividualsAtom></code>

\\
===== Przykład reguły w OWL XML =====
 
<code xml>
<owlx:Rule> 
  <owlx:antecedent> 
    <owlx:individualPropertyAtom  owlx:property="hasParent"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x2" />
    </owlx:individualPropertyAtom> 
    <owlx:individualPropertyAtom  owlx:property="hasBrother"> 
      <owlx:Variable owlx:name="x2" />
      <owlx:Variable owlx:name="x3" />
    </owlx:individualPropertyAtom> 
  </owlx:antecedent> 
  <owlx:consequent> 
    <owlx:individualPropertyAtom  owlx:property="hasUncle"> 
      <owlx:Variable owlx:name="x1" />
      <owlx:Variable owlx:name="x3" />
    </owlx:individualPropertyAtom> 
  </owlx:consequent> 
</owlx:Rule>
</code>

 

===== Mapping to RDF Graphs =====

Reguły zawierają zmienne, więc bardzo trudne jest traktowanie ich jako semantyczne rozszerzenie RDF. Aczkolwiek możliwe jest dostarczenie składni RDF dla reguł. Jest tak, ponieważ semantyka wynikowego grafu RDF nie jest rozszerzeniem RDF Semantics. Mapowanie do RDF/XML jest prościej tworzone jako rozszerzenie transformacji XSLT dla składni OWL XML. 

===== Przykład rozszerzenia składni OWL RDF/XML o reguły =====

<code xml>
<owlr:Variable rdf:ID="_x1"/>
<owlr:Variable rdf:ID="_x2"/>
<owlr:Variable rdf:ID="_x3"/>
<owlr:Rule> 
  <owlr:antecedent rdf:parseType="Collection">
    <owlr:individualPropertyAtom> 
      <owlr:propertyPredicate rdf:resource="&eg;hasParent"/> 
      <owlr:argument1 rdf:about="#_x1" />
      <owlr:argument2 rdf:about="#_x2" />
    </owlr:individualPropertyAtom>
    <owlr:individualPropertyAtom> 
      <owlr:propertyPredicate rdf:resource="&eg;hasSibling"/> 
      <owlr:argument1 rdf:about="#_x2" />
      <owlr:argument2 rdf:about="#_x3" />
    </owlr:individualPropertyAtom>
    <owlr:individualPropertyAtom> 
      <owlr:propertyPredicate rdf:resource="&eg;hasSex"/> 
      <owlr:argument1 rdf:about="#_x3" />
      <owlr:argument2 rdf:about="#male" />
    </owlr:individualPropertyAtom>
  </owlr:antecedent>
  <owlr:consequent rdf:parseType="Collection"> 
    <owlr:individualPropertyAtom> 
      <owlr:propertyPredicate rdf:resource="&eg;hasUncle"/> 
      <owlr:argument1 rdf:about="#_x1" />
      <owlr:argument2 rdf:about="#_x3" />
    </owlr:individualPropertyAtom>
  </owlr:consequent> 
</owlr:Rule>
</code> 





===== Inductive Logic Programming =====


Jedną z koncepcji zbudowania reguł ontologii jest ILP, które powstało z połączenia Logic Programming i Concept Learning. Z LP wzięło framework Knowledge Representation, a z CL odziedziczyło mechanizm wnioskowania dla indukcji, z którego najbardziej znaczące jest uogólnianie. W Cencept Learning uogólnianie jest postrzegane jako przeszukiwanie częściowo uporządkowanej przestrzeni indukcyjnych hipotez. Zgodnie z tą wizją indukcyjna hipoteza jest teoretycznie klauzulą, które wymaga strukturyzacji, przeszukiwania i ograniczania przestrzeni klauzul. 

Przestrzeń hipotez może być przeszukiwana przez znaczenie uściślonych operatorów, które są funkcjami obliczającymi zbiór specjalizacji klauzuli. Specjalizacja jest odpowiednia dla kierunku przeszukiwania w tym podejściu. Kierunek przeszukiwań jest w tym przypadku z góry do dołu, ale operatory mogą być także zdefiniowane jako obliczające uogólnienia z klauzul i wtedy mamy przeszukiwanie z dołu do góry.

Indukcja z ILP, uogólnia poszczególne instancje w obecnej podstawie wiedzy, znajdując poprawne hipotezy. Ich prawdziwość zależy od poniższego otoczenia. Obecnie istnieje kilka formalizmów indukcji w logice opartej na klauzulach.

===== Inductive Logic Programming cd. =====

Zostały zaproponowane dwa frameworki ILP, które stosują hybrydowy język DL-HCL dla reprezentacji zarówno hipotez jak i wiedzy.
  * CARIN-ALN - framework skupia się na wyróżniku indukcji i stosuje opcje ILP uczenia z interpretacji. Docelową koncepcją jest jednoskładnikowy predykat Datalogu. Ponadto hipotezy są reprezentowane jako reguły Carin-ALN z literałem Datalogu w następniku.

  * AL-log - hipotezy są reprezentowane jako ograniczone klauzule Datalogu, które są powiązane, połączone i zgodne z Object Identity. Literał w następniku hipotezy reprezentuje koncepcje zarówno discriminant induction jak i characteristic induction. Obszar relacji dla opcji ILP uczenia z interpretacji został zdefiniowany o podstawy odpowiedzi kwerend w AL-log.


Nowe frameworki ILP mogą być zaprojektowane dla bardziej ekspresyjnego hybrydowego języka DL-HCL. Siła ekspresji może być zwiększona bardziej ekspresywnym DL (niż ALC i ALN) lub bardziej ekspresywnym fragmentem HCL (niż Datalog) lub luźniejszą integracją pomiędzy częściami DL i HCL. Bezpieczeństwo i rozstrzygalność tych formalizmów są dwoma pożądanymi właściwościami, które szczególnie docenia się w ILP i aplikacjach sieci semantycznych.




===== Hybrid MKNF =====
 
Logic Programing jest często brane pod uwagę jako sposób na pokonanie kilku wad OWL, takich jak niezdolność do tworzenia ograniczeń czy wykonywania kwerend "closed-world". Jakkolwiek semantyka OWL jest typu "open-world" i wydaje się być niekompatybilna z semantyką "closed-world" LP. Dlatego zaproponowano alternatywny język ontologii bazujący całkowicie na LP. Jest nim hybrydowy MKNF, który integruje OWL z LP.

Zalety integracji języka OWL z Logic Programming:
  * wyższa relacyjna ekspresyjność języka
  * wieloskładnikowe predykaty
  * wnioskowanie "closed-world"
  * więzi integralności
  * modelowanie wyjątków

===== Rozszerzenie DL o First-Order Rules =====


Głównym założeniem jest dodanie aksjomatów postaci H ← B1, . . . ,Bn gdzie H (następnik reguły) i Bi (poprzednik) mogą być postaci C(s) lub R(s, t), przy czym C to koncepcja, R rola, a s i t są termami (np. zmienne czy tzw. 'individuals'). Reguły te są interpretowane przez standardową semantykę pierwszego rzędu jako \\ 
∀x : H ∨ ¬B1 ∨ . . . ∨ ¬Bn, gdzie x jest zbiorem dowolnych zmiennych z wszystkich H i Bi.

===== Rozszerzenie DL o niemonotoniczne właściwości =====


Rozszerzenie to opiera się na auto-epistemicznej logice, która pozwala wnioskować o przekonaniach. Wprowadzono auto-epistemiczny operator K, który może być stosowany do koncepcji i ról z intuicyjnym znaczeniem - "jest wiadomo, że zajdzie".
Auto-epistemiczne wnioskowanie może być połączone z DL na dwa sposoby:
  * jako operatory w kwerendach - Epistemic Query Language - kwerendy EQL są formułami zbudowanymi na atomach postaci Kq, gdzie q jest kwerendą w pierwszorzędnym DL.
  * jako operatory w bazie wiedzy - MKNF (Minimal Knowledge and Negation-as-Failure) - umożliwia domyślną negację i modelowanie wyjątków. Przyjęto auto-epistemiczny operator A ('not' z first-order MKNF) o nieformalnym znaczeniu - "może być fałszem".

===== Hybrid MKNF KBs =====


Baza wiedzy //K// w hybrid MKNF składa się z bazy wiedzy //O// w rozstrzygalnym DL i ze zbioru //P// reguł MKNF w następującej postaci:\\
KH<sub>1</sub> ∨ . . . ∨KH<sub>n</sub> ← KB<sub>1</sub><sup>+</sup>, . . . ,KB<sub>m</sub><sup>+</sup>, notB<sub>1</sub><sup>−</sup>, . . . , notB<sub>k</sub><sup>−</sup>

Tak samo jak w SWRL, H<sub>i</sub>, B<sub>i</sub><sup>+</sup>, B<sub>i</sub><sup>-</sup> są atomami pierwszego rzędu postaci P(t1, . . . , tn). Dla P = ≈ lub predykatu występującego w //O// atom jest atomem DL, w innym przypadku nie. Przyjęto, że operator π zamienia dowolną bazę wiedzy //O// w DL na formułę π(//O//) w logice pierwszego rzędu zawierającej równość. Semantyka tego formalizmu została zdefiniowana przez dołączenie //K// w następującym wzorze MKNF, gdzie x jest zbiorem dowolnych zmiennych reguł r:


π(//K//) = //K//π(//O//) ∧ (iloczyn logiczny dla r∈P ∀x : r)

Semantyka bazy wiedzy hybrydowego MKNF ukazuje dwie ważne własności. Z jednej strony jest w pełni kompatybilna z OWL - wszystkie zapytanie standardowego DL są traktowane w zwykły sposób. Z drugiej strony MKNF jest także w pełni kompatybilny z Logic Programming. Reguły MKNF mogą być również użyte w celu integracji OWL z językami LP zorientowanymi obiektowo takimi jak F-Logic czy WSML. 


===== F-Logic rules =====


Reguły F-Logic są regułami Logic Programming na atomach F-Logic. 

Alfabet języka F-Logic składa się ze zbioru F symboli funkcji, pełniących rolę konstruktorów obiektów. 'Id-term'y są złożone z konstruktorów i zmiennych i są interpretowane jako elementy świata.  
Niech o, c, d, d<sub>1</sub>, ... , d<sub>n</sub>, p, v, v<sub>1</sub>, v<sub>n</sub> będą id-term lub literałami. Zauważmy, że URL jako podklasa klasy string może wskazywać obiekty.

===== Składnia F-Logic =====

Na przykład:
  “foo:bla#john”:“foo:meta#Person”[“foo:meta#name”!“John”; 
  “foo:meta#livesIn”!!(“geo://de/Berlin”:“geo:meta#City”)].
jest poprawnym fragmentem języka F-Logic.

Atom 'is-a' jest wyrażeniem postaci o : c (obiekt o jest składnikiem klasy c), lub c :: d (klasa c jest podklasą klasy d). 

Reguła F-Logic jest logiczną regułą h ← b na atomach F-Logic, np. asercje 'is-a' i obiektowe atomy. F-Logic program jest zbiorem reguł. Semantyka reguł F-Logic jest zdefiniowana przez struktury Herbrand'a, gdzie świat składa się z podstawowych id-term'ów. H-struktura jest zbiorem podstawowych atomów F-Logic, opisujących obiektowy świat, więc musi spełniać kilka domykających aksjomatów związanych z ogólnymi, zorientowanymi obiektowo właściwościami.

===== Aksjomaty F-Logic =====


Zbiór H (może być nieskończony) podstawowych atomów jest H-strukturą jeśli dla dowolnych u, u<sub>0</sub>, . . . , u<sub>n</sub> i u<sub>m</sub> ze zbioru H zachodzą następujące warunki:

  * u :: u ∈ H (zwrotność podklas),
  * jeśli u<sub>1</sub> :: u<sub>2</sub> ∈ H i u<sub>2</sub> :: u<sub>3</sub> ∈ H to u<sub>1</sub> :: u<sub>3</sub> ∈ H (przenośność podklas), analogicznie, jeśli u<sub>1</sub> : u<sub>2</sub> ∈ H i u<sub>2</sub> :: u<sub>3</sub> ∈ H to u<sub>1</sub> : u<sub>3</sub> ∈ H,
  * jeśli u<sub>1</sub> :: u<sub>2</sub> ∈ H i u<sub>2</sub> :: u<sub>1</sub> ∈ H to u<sub>1</sub> = u<sub>2</sub> ∈ H (niecykliczność podklas),
  * jeśli dla podstawowych id-term'ów u i u′ (u ≠ u′) takich, że u<sub>0</sub>[u<sub>m</sub>→u] ∈ H i u<sub>0</sub>[u<sub>m</sub>→u′] ∈ H, to u = u′ (niepowtarzalność skalarnych właściwości).

Dla zbioru M podstawowych atomów, α(M) oznacza domknięcie zbioru M.

Dobre programy F-Logic są analizowane z dołu-do-góry przez operator zawierania α, typu T<sub>p</sub>, dostarczając minimalne semantyki modelowe.



===== What reasoning support for Ontology and Rules? =====

Jako, że jest to niemożliwe, żeby mieć równocześnie rozstrzygalność, kompletność i ekspresyjność, wymagane właściwości aplikacji muszą być dokładnie określone, ze względu na możliwości i ograniczenia metody wnioskowania, w celu wybrania jak najlepszego języka. Użyteczne jest wyjaśnienie, które właściwości są przewidywane pod ograniczeniami DLP, kiedy silnik reguł produkcyjnych np. Jess i mechanizm wnioskujący języka DL np. Racer są używane oddzielnie. Jeżeli DLP nie jest wystarczający i jest potrzebna ekspresyjność OWL DL, to dobrym rozwiązaniem jest rozszerzenie OWL DL bezpiecznymi regułami Datalog (¬∨), językiem SWRL lub FOL, zależnie od przewidywanej ekspresywności i obliczeniowych własności.




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

  * [[http://www.cs.man.ac.uk/~horrocks/DAML/Rules/|A Proposal for an OWL Rules Language]]
  * [[http://www.comlab.ox.ac.uk/people/ian.horrocks/Publications/download/2004/HoPa04a.pdf|I. Horrocks, P. F. Patel-Schneider: A Proposal for an OWL Rules Language]]

  * [[http://www.w3.org/Submission/SWRL/|SWRL: A Semantic Web Rule Language - Combining OWL and RuleML]]
  * [[http://www.comlab.ox.ac.uk/people/ian.horrocks/Publications/download/2004/TRBH04a.pdf|D. Tsarkov, A. Riazanov, S. Bechhofer, I. Horrocks: Using Vampire to Reason with OWL]]
  * [[http://www.comlab.ox.ac.uk/people/ian.horrocks/Publications/download/2005/HPBT05.pdf|I. Horrocks, P. F. Patel-Schneider, S. Bechhofer, D. Tsarkov: OWL Rules - A Proposal and Prototype Implementation]]
  * [[http://www.comlab.ox.ac.uk/people/ian.horrocks/Publications/download/2006/PSSTH06.pdf|J. Z. Pan, G. Stoilos, G. Stamou, V. Tzouvaras, I. Horrocks: f-SWRL: A Fuzzy Extension of SWRL]]
  * [[http://www.comlab.ox.ac.uk/people/ian.horrocks/Publications/download/2006/MHRS06.pdf|B. Motik, I. Horrocks, R. Rosati, U. Sattler: Can OWL and Logic Programming Live Together Happily Ever After?]]


  * [[http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-287/paper_8.pdf|H. Kattenstroth, W. May, F. Schenk: Combining OWL with F-Logic Rules and Defaults]]


  * [[http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-188/sub21.pdf|Ch. Golbreich, O. Dameron, O. Bierlaire, B. Gibaud: What reasoning support for Ontology and Rules?]]
  * [[http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-188/sub22.pdf|A. Cregan, M. Mochol, D. Vrandecic, S. Bechhofer: Pushing the limits of OWL, Rules and Protege]]
  * [[http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-314/42.pdf|F. A. Lisi, F. Esposito: Building Rules on top of Ontologies? Inductive Logic Programming can help!]]
  * [[http://protege.cim3.net/cgi-bin/wiki.pl?SWRLLanguageFAQ|SWRL Language FAQ]]


  * [[hekate:dl_intro|Description Logics and OWL in the Semantic Web]]