MIW 2009 SWRLtrans

Zrealizował: Michał Lesiak (4RI)

Work on the translation of XTT2 to SWRL using XSLT.

miw08_xtt_rif xttml2rif

Prezentacja

Prezentacja wyników projektowych.

Spotkania

Notatki ze spotkań projektowych.

Projekt

Implementacja translacji w prologu.

Sprawozdanie

Założenia

W projekcie zostanie stworzony wzorzec XSLT, który zamieni składnię XTTML na składnię SWRL XML, przy czym XML dla SWRL jest kombinacją OWL Web Ontology Language XML z RuleML XML

Możliwa jest również zamiana XTTML na RDF dla SWRL, przy czym można tego dokonać korzystając ze wzorca owlxml2rdf.xsl, który należałoby rozbudować.

Wprowadzenie do SWRL

Introduction

Semantic Web Rule Language (SWRL) jest propozycją języka, który bazuje na kombinacji OWL DL i OWL Lite, czyli podjęzyków OWL Web Ontology Language z pojedynczymi/binarnymi datalogami języka RuleML. Propozycja rozszerza zbiór aksjomatów OWL tak, by zawierał reguły podobne do reguł Horna. Reguły te mogą więc być łączone z bazą wiedzy OWL.

Reguły są przedstawiane w formie implikacji: poprzednik („body”) i następnik („head”), z których każdy może składać się z zera lub więcej atomów. Implikacja w przypadku pustego poprzednika jest traktowana jako zawsze prawdziwa, a w przypadku pustego następnika jest traktowana jako zawsze fałszywa. Wiele atomów jest traktowanych jako koniunkcja. Reguła z koniunkcją atomów w następniku jest równoważna koniunkcjom reguł, w których następnikami są pojedyncze atomy.

Składnia XML

XML Concrete Syntax

Składnia XML dla SWRL jest kombinacją OWL Web Ontology Language XML z RuleML XML.

Definiuje przestrzenie nazw swrlx i swrlb, importuje przestrzeń nazw ruleml i owl.

Używane przestrzenie nazw:

Skrót	Przestrzeń nazw
swrlx	http://www.w3.org/2003/11/swrlx
swrlb	http://www.w3.org/2003/11/swrlb
ruleml	http://www.w3.org/2003/11/ruleml
owl	http://www.w3.org/2003/05/owl-xml
xsd	http://www.w3.org/2001/XMLSchema

Zalety SWRL

klasy OWL (np. opisy) mogą być używane jako predykaty w regułach,

reguły i aksjomaty ontologii mogą być dowolnie mieszane,

istniejący arkusz XSLT (http://www.w3.org/TR/owl-xmlsyntax/owlxml2rdf.xsl) może posłużyć jako podstawa do stworzenia mapowania na grafy RDF,

istniejące narzędzia do RuleML mogą być przystosowane do SWRL

Wady SWRL http://vistology.com/papers/SWRLp.PDF

konieczność transformacji na predykaty binarne (SWRL jest zgodne z OWL, który zabrania używania predykatów złożonych („higher-order”). Zwiększa nieczytelność, wydłuża XML,

rozróżnianie predykatów reprezentujących: classAtom, individualPropertyAtom, datavaluedPropertyAtom. Wydłuża XML,

mieszanie ruleml, swrlx, swrlb i owlx. W każdym elemencie trzeba określić przestrzeń nazw. Wydłuża XML,

nie można korzystać z predykatów definiowanych zewnętrznie jak ma to miejsce w RIF http://www.w3.org/2005/rules/wg/draft/rif-dtb/#Appendix:_Schemas_for_Externally_Defined_Terms.

SWRL nie obsługuje ani negacji, ani alternatywy SWRL FAQ.

W związku z czym został zaproponowany bardziej czytelny XML: SWRL presentation: SWRLp

Elementy składni

Ontology

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

Główny element „Ontology” w stosunku do składni prezentacji OWL XML został rozszerzony o aksjomaty „imp” („implication” - reguła implikacyjna) oraz „var” („variable” - deklaracja zmiennej)

ruleml: var

<ruleml:var>xsd:string</ruleml:var>

Definiuje istnienie zmiennej. Zapożyczono z przestrzeni nazw RuleML.

ruleml: imp

<ruleml:imp>
Content: ( _rlab?, owlx:Annotation*, _body, _head )
</ruleml:imp>

ruleml:_rlab

<ruleml:imp>
Content: ( _rlab?, owlx:Annotation*, _body, _head )
</ruleml:imp>

ruleml:_body

<ruleml:_body>
Content: ( swrlx:atom* )
</ruleml:_body>

ruleml:_head

<ruleml:_head>
Content: ( swrlx:atom* )
</ruleml:_head>

Atomy

Mogą być pojedynczymi predykatami (klasami), binarnymi predykatami (właściwościami), równościami lub nierównościami.

swrlx:classAtom

swrlx:datarangeAtom

swrlx:individualPropertyAtom

swrlx:datavaluedPropertyAtom

swrlx:sameIndividualAtom

swrlx:differentIndividualsAtom

swrlx:builtinAtom

Translacja XTT na SWRL

W SWRL występuje ciąg aksjomatów (axioms) i faktów, gdzie aksjomaty to reguły i klasy obiektów. SWRL przewiduje tylko proste obliczenia matematyczne (builtIn), ale poprawność syntaktyczna nie jest sprawdzana. Np. operacja „builtIn(op:numeric-add ?x 5)” (czyli: x + 5 zamiast np. 6 = x + 5) jest poprawna i zwraca wartość fałszu. SWRL bazuje na opisie i właściwościach klas obiektów. To zdecydowanie odmienne podejście niż w przypadku XTT powoduje problemy w translacji między tymi językami.

Problemy w translacji

1. Możliwość stosowania tylko predykatów binarnych w SWRL (w XTT brak ograniczenia),
2. Brak możliwości zagnieżdżania obliczeń matematycznych w SWRL,
3. Brak możliwości korzystania z predykatów zdefiniowanych zewnętrznie,
4. SWRL nie obsługuje negacji ani alternatywy.

Rodzaje podejść

Translacja identycznościowa

Translacja, której wynikiem byłby XML SWRL taki, że interpreter SWRL dokonywałby działań (operacji) analogicznych do interpretera XTT. Napisanie takich reguł translacji XTT -> SWRL przy pomocy XSLT jest bardzo trudne, o ile nie niemożliwe (XSLT jest nieodpowiednim do tego narzędziem, należałoby napisać własny translator).

W tym podejściu rozwiązania problemów przedstawiałyby się nastepująco:
ad 1. Rozwiązaniem jest stworzenie sztucznej relacji, która wiąże ze soba kolejne argumenty. Przykład zastosowania sztucznej relacji 'reifiedRelation'
ad 2. Rozwiązaniem jest stworzenie serii zmiennych pomocniczych, które przechowywałyby wyniki obliczeń kolejno w sobie zagnieżdżonych operacji.
ad 3. Brak istniejącego rozwiązania.
ad 4. Rozwiązaniem problemu alternatywy jest stworzenie tylu reguł, ile jest alternatyw. Każda reguła w poprzedniku posiadałaby inną alternatywę, w następniku znajdowałaby się natomiast ta sama dla wszystkich operacja (Zbiór operacji).

Przykład translacji identycznościowej: Przykład translacji identycznościowej XTT -> SWRL

Translacja obiektowa

Translacja, której wynikiem byłby XML SWRL taki, że interpreter SWRL stwierdziłby poprawność XML, ale nie byłby w stanie wykonać działań (operacji) analogicznie do tego jak zrobiłby to interpreter XTT. Translacja powodowałaby przedstawienie obliczeń i operacji w postaci klas i obiektów.

Najbardziej właściwa dla SWRLa wydaje się propozycja przedstawiania zmiennych/operacji/funkcji jako klas, posiadających odpowiednie własności: wartość (własność: „value”), operacja (własność zależna od operacji).
Przykładem operacji jest np. sumowanie, właściwość obiektu „add” byłaby obiektem, która posiadałaby własność liczby (DataPropertyValue) lub przechowywałaby konieczne do wykonania obliczenia w postaci obiektu (ObjectPropertyValue) - kolejne zagnieżdżenie z kolejnymi własnościami „value” lub operacjami.
W takim przypadku również reguła byłaby obiektem, ponieważ interpreter SWRL i tak nie byłby w stanie sprawdzić założeń reguły (poprzednika, tezy), gdyż poprzednikiem byłaby po prostu klasa - czyli obiekt.

Przykład translacji obiektowej: Przykład translacji obiektowej XTT -> SWRL

Przykład Prolog -> SWRL

Przykład pokazuje rozwiązanie problemu translacji predykatów o arności większej niż 2.

SWRL example
Kod w Prologu:

inSupplyOfAt(Consumer,Resource,Time)
:- reserve(Consumer,Resource,Time,Reserve)
consumption(Consumer,Resource,Consumption)
greaterThanOrEqual(Reserve,Consumption).

Składnia SWRL:

<ruleml:imp>
<ruleml:_head>
<swrlx:classAtom>
<owlx:Class owlx:name="InSupplyOfAt"/>
<ruleml:var>?reifiedRelation</ruleml:var>
</swrlx:classAtom>
<swrlx:individualPropertyAtom swrlx:property="consumer">
<ruleml:var>?reifiedRelation</ruleml:var>
<ruleml:var>?consumer</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:individualPropertyAtom swrlx:property="resource">
<ruleml:var>?reifiedRelation</ruleml:var>
<ruleml:var>?resource</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:datavaluedPropertyAtom swrlx:property="dateTime">
<ruleml:var>?reifiedRelation</ruleml:var>
<ruleml:var>?time</ruleml:var>
</swrlx:datavaluedPropertyAtom>
</ruleml:_head>
<ruleml:_body>
<swrlx:individualPropertyAtom swrlx:property="reserve">
<ruleml:var>?consumer</ruleml:var>
<ruleml:var>?reserve</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:individualPropertyAtom swrlx:property="resource">
<ruleml:var>?reserve</ruleml:var>
<ruleml:var>?resource</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:datavaluedPropertyAtom swrlx:property="dateTime">
<ruleml:var>?reserve</ruleml:var>
<ruleml:var>?time</ruleml:var>
</swrlx:datavaluedPropertyAtom>
<swrlx:individualPropertyAtom swrlx:property="quantity">
<ruleml:var>?reserve</ruleml:var>
<ruleml:var>?quantity</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:datavaluedPropertyAtom swrlx:property="amount">
<ruleml:var>?quantity</ruleml:var>
<ruleml:var>?amount</ruleml:var>
</swrlx:datavaluedPropertyAtom>
<swrlx:individualPropertyAtom swrlx:property="consumption">
<ruleml:var>?consumer</ruleml:var>
<ruleml:var>?consumption</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:individualPropertyAtom swrlx:property="consumptionType">
<ruleml:var>?consumption</ruleml:var>
<ruleml:var>?resource</ruleml:var>
</swrlx:individualPropertyAtom>
<swrlx:datavaluedPropertyAtom swrlx:property="consumptionRate">
<ruleml:var>?consumption</ruleml:var>
<ruleml:var>?rate</ruleml:var>
</swrlx:datavaluedPropertyAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;greaterThanOrEqual">
<ruleml:var>?amount</ruleml:var>
<ruleml:var>?rate</ruleml:var>
<ruleml:var/>
</swrlx:builtinAtom>
</ruleml:_body>
</ruleml:imp>

Więcej przykładów SWRL (na podstawie OWL)

Przykład translacji identycznościowej XTT -> SWRL

XTT: xttml

W skrócie:
xtt_1:
rule_1: if att_0 in <1,5>u{8} then att_1 = att_0 + 1 and att_1 = 5 + sin(att_0)

Propozycja translacji identycznościowej SWRL: (sprawdzona poprawność składniowa przez http://www.w3.org/2001/03/webdata/xsv)

<?xml version='1.0' ?>
<!DOCTYPE swrlx:Ontology [
<!ENTITY swrlb 'http://www.w3.org/2003/11/swrlb'>
<!ENTITY xsd 'http://www.w3.org/2001/XMLSchema'>
<!ENTITY map 'http://www.daml.org/2001/06/map/map-ont#'>
]>
<swrlx:Ontology
xmlns:owlx="http://www.w3.org/2003/05/owl-xml"
xmlns:swrlx="http://www.w3.org/2003/11/swrlx"
xmlns:ruleml="http://www.w3.org/2003/11/ruleml"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2003/11/swrlx http://www.ruleml.org/swrl/xsd/swrlx.xsd"
>
<owlx:Annotation>
<owlx:Documentation> XTT to SWRL Translator</owlx:Documentation>
</owlx:Annotation>
<owlx:VersionInfo>v 1.0 2009/03/15 Michal Lesiak mikelik@o2.pl</owlx:VersionInfo>
<owlx:ObjectProperty owlx:name="table"/>
<owlx:ObjectProperty owlx:name="link"/>
<ruleml:var>att_0</ruleml:var>
<ruleml:var>att_1</ruleml:var>
<ruleml:var>temp1</ruleml:var>
<ruleml:imp>
<ruleml:_rlab ruleml:href="rul_1a"/>
<owlx:Annotation>
<owlx:Documentation>
Ta reguła dotyczy: if att_0 nalezy do zbioru (1,5)
</owlx:Documentation>
</owlx:Annotation>
<ruleml:_body>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#greaterThanOrEqual">
<ruleml:var>att_0</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">1</owlx:DataValue>
</swrlx:builtinAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#lessThanOrEqual">
<ruleml:var>att_0</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">5</owlx:DataValue>
</swrlx:builtinAtom>
</ruleml:_body>
<ruleml:_head>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#add">
<ruleml:var>att_1</ruleml:var>
<ruleml:var>att_0</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">1</owlx:DataValue>
</swrlx:builtinAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#sin">
<ruleml:var>temp1</ruleml:var>
<ruleml:var>att_0</ruleml:var>
</swrlx:builtinAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#add">
<ruleml:var>att_1</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">5</owlx:DataValue>
<ruleml:var>temp1</ruleml:var>
</swrlx:builtinAtom>
</ruleml:_head>
</ruleml:imp>
<owlx:Individual owlx:name="rul_1a">
<owlx:ObjectPropertyValue owlx:property="table">
<owlx:Individual owlx:name="#xtt_1" />
</owlx:ObjectPropertyValue>
<owlx:ObjectPropertyValue owlx:property="link">
<owlx:Individual owlx:name="#xtt_1" />
</owlx:ObjectPropertyValue>
<!-- owlx:type owlx:name="typu_np._link" - jakis typ obiektu czyli klasa" /> -->
<!-- może być tez wartość typu string
<owlx:DataPropertyValue owlx:property="link">
<owlx:DataValue owlx:datatype="&xsd;string">xtt_1</owlx:DataValue>
</owlx:DataPropertyValue> -->
</owlx:Individual>
<ruleml:imp>
<ruleml:_rlab ruleml:href="rul_1b"/>
<owlx:Annotation>
<owlx:Documentation>
Ta reguła dotyczy: if att_0 jest rowne 8
</owlx:Documentation>
</owlx:Annotation>
<ruleml:_body>
<swrlx:datarangeAtom>
<owlx:OneOf>
<owlx:DataValue owlx:datatype="&xsd;int">8</owlx:DataValue>
</owlx:OneOf>
<ruleml:var>att_0</ruleml:var>
</swrlx:datarangeAtom>
</ruleml:_body>
<ruleml:_head>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#add">
<ruleml:var>att_1</ruleml:var>
<ruleml:var>att_0</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">1</owlx:DataValue>
</swrlx:builtinAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#sin">
<ruleml:var>temp1</ruleml:var>
<ruleml:var>att_0</ruleml:var>
</swrlx:builtinAtom>
<swrlx:builtinAtom swrlx:builtin="&swrlb;#add">
<ruleml:var>att_1</ruleml:var>
<owlx:DataValue owlx:datatype="&xsd;#int">5</owlx:DataValue>
<ruleml:var>temp1</ruleml:var>
</swrlx:builtinAtom>
</ruleml:_head>
</ruleml:imp>
<owlx:Individual owlx:name="rul_1b">
<owlx:ObjectPropertyValue owlx:property="table">
<owlx:Individual owlx:name="#xtt_1" />
</owlx:ObjectPropertyValue>
<owlx:ObjectPropertyValue owlx:property="link">
<owlx:Individual owlx:name="#xtt_1" />
</owlx:ObjectPropertyValue>
</owlx:Individual>
</swrlx:Ontology>

Przykład translacji obiektowej XTT -> SWRL

XTT: xttml

W skrócie:
xtt_1:
rule_1: if att_0 in <1,5>u{8} then att_1 = att_0 + 1 and att_1 = 5 + sin(att_0)

Poniżej translacja tylko fragmentu XTT, gdyż reszta jest analogiczna:

XTT:

<logop name="in">
<attref ref="att_0"/>
<domain>
<range from="1" to="5"/>
<value>8</value>
</domain>
</logop>

SWRL:

<owlx:Individual>
<owlx:ObjectPropertyValue owlx:property="logop">
<owlx:Individual>
<owlx:ObjectPropertyValue owlx:property="attribute">
<owlx:Individual>
<owlx:DataPropertyValue owlx:property="name">
<owlx:DataValue owlx:datatype="&xsd;string">in</owlx:DataValue>
</owlx:DataPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
<owlx:ObjectPropertyValue owlx:property="attref">
<owlx:Individual>
<owlx:ObjectPropertyValue owlx:property="attribute">
<owlx:Individual>
<owlx:DataPropertyValue owlx:property="ref">
<owlx:DataValue owlx:datatype="&xsd;string">in</owlx:DataValue>
</owlx:DataPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
<owlx:ObjectPropertyValue owlx:property="domain">
<owlx:Individual>
<owlx:ObjectPropertyValue owlx:property="range">
<owlx:Individual>
<owlx:ObjectPropertyValue owlx:property="attribute">
<owlx:Individual>
<owlx:DataPropertyValue owlx:property="from">
<owlx:DataValue owlx:datatype="&xsd;string">1</owlx:DataValue>
</owlx:DataPropertyValue>
<owlx:DataPropertyValue owlx:property="to">
<owlx:DataValue owlx:datatype="&xsd;string">5</owlx:DataValue>
</owlx:DataPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
<owlx:DataPropertyValue owlx:property="value">
<owlx:DataValue owlx:datatype="&xsd;string">8</owlx:DataValue>
</owlx:DataPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
</owlx:Individual>
</owlx:ObjectPropertyValue>
</owlx:Individual>

Materiały

SWRL

http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=node/15

http://st.inf.tu-dresden.de/OCLApps2006/topic/acceptedPapers/04_Gasevic_OnInterchanging.pdf

zależności RIF <-> SWRL

http://protege.cim3.net/cgi-bin/wiki.pl?SWRLLanguageFAQ

SWRL Presentation Proposal

SWRL na podstawie OWL - podstawy, przykłady

Oxygen - darmowy edytor XML

Sprawdzanie poprawności XML