Opis

Projekt zakończony

Michał, Rogula, michal.rogula@wp.pl

  1. Porównać i omówić metody reprezentowania atrybutów w językach:
  • RDF
  • OWL
  • RIF
  • R2ML
  • RuleML

oraz metody reprezentowania reguł w:

  • RIF
  • R2ML
  • RuleML

Projekt

Jeżeli dzień=poniedziałek wtedy temp=20st

mamy 2 atrybuty:

  • dzień, przyjmuje wart symboliczne ze zb: pon-niedz
  • temp, jest liczbą, np. float, z zakresu, np. 0-20st

Rozważania na temat zapisu powyższej reguły za pomocą:

Spotkania

Sprawozdanie

1. RIF(Rule Interchange Format)

RIF jest stworzonym przez W3C (Word Wide Web Consorcium) formatem reguł pozwalających na ich wymianę dla różnych języków reguł w sieciach semantycznych (RDF, OWL). Format RIF jest ciągle w fazie rozwoju, jedyne dostępne dokumenty są to szkice specyfikacji poszczególnych modułów (Working Draft). Do rozwijanych dokumentów należą m.in. RIF Framework for Logic Dialects oraz RIF Basic Logic Dialect

Atrybuty w RIF + RDF oraz OWL Kompatybilność

Dokładny opis specyfikacji RIF można znaleźć w projekcie XTT_RIF. Dla mnie istotna, z punktu widzenia projektu, jest wiedza jak zapisywać typowe dla reguł elementy tj:

  • wartosc logiczna: np: B
<Var> B </Var>
  • stałe argumenty: np: 300
<arg><Const type="rds:long"> 300 </Const></arg>
  • suma: n+1
<Uniterm>
<op><Const type="rif:iri"> op:numeric-add </Const></op>
<arg><Const type=""> 1 </Const></arg>
<arg><Var> n </Var></arg>
</Uniterm>
  • różnica: n-1
<Uniterm>
<op><Const type="rif:iri"> op:numeric-subtract </Const></op>
<arg><Const type=""> 1 </Const></arg>
<arg><Var> n </Var></arg>
</Uniterm>
  • równość: (wyr_1) = (wartosc)
<Equal>
<arg> wyr_1 </arg>
<arg> wartosc </arg>
</Equal>
  • nierówność: n > 0
<Uniterm>
<op><Const type="rif:iri"> op:numeric-greater-than </Const></op>
<arg><Var> n </Var></arg>
<arg><Const type="xsd:decimal"> 0 </Const></arg>
</Uniterm>
  • nierówność: n ⇐ 1
<Uniterm>
<op><Const type="rif:iri"> op:numeric-less-or-equal-than </Const></op>
<arg><Var> n </Var></arg>
<arg><Const type="xsd:decimal"> 0 </Const></arg>
</Uniterm>
  • suma logiczna : (wyr_1) and (wyr_2)
<And>
<formula>
(wyr_1)
</formula> 
<formula>
(wyr_2)
</formula>
</And>
  • warunek if : (conclusion) if (conditions)
<Implies>
<if>
(conditions)
</if>
<then>
(conclusion)
</then>
</Implies>

Teraz, na podstawie powyższej wiedzy, możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą RIF:

<?xml version="1.0" encoding="UTF-8"?>
 
<Ruleset>
<rule>
  <declare><Var> day </Var></declare> 
  <formula>
   <Implies>
    <if>
      <formula>
        <Equal>
         <arg><Var> day </Var></arg>
         <arg><Const type="xsd:string">Monday</Const></arg>
        </Equal>
      </formula> 
    </if>
    <then>
      <Uniterm>
       <op><Const type="rif:local">temp</Const></op>
       <arg><Const type="rds:positiveInteger">20</Const></arg>
      </Uniterm>
    </then>
   </Implies>
  </formula>
 </rule>
</Ruleset>

W analogiczny sposób możemy zapisać większość reguł. Przykładem może być tu całość HeKatE Case Thermostat którego reguły przedstawione w RIF wyglądają nastepująco: therm in RIF.

2. R2ML – Reverse Rule Markup Language

R2ML powstał z inicjatywy REWERSE Working Group I1, w celu ułatwienia wymiany reguł między różnymi systemami oraz narzędziami, wzbogacenia ontologii o reguły oraz możliwości łączenia systemów regułowych z narzedziami R2ML do wizualizacji, weryfikacji, walidacji oraz werbalizacji. R2ML wspiera Integrity Rules, Derivation Rules, Production Rules oraz Reaction Rules. R2ML integruje Object Constraint Language (OCL), Semantic Web Rule Language (SWRL) oraz Rule Markup Language (RuleML).

Nie musimy być zaznajomieni ze wszystkimi elementami języka R2ML w celu wykorzystania jej wydajnością. Aby można było użyć R2ML’a do przedstawiania reguł potrzebna jest wiedza jak zapisywać typowe dla nich elementy. Poniżej przedstawiam kilka takich elementów zapisanych w R2ML ver.0.4:

  • wartość logiczna: np: B
<r2ml:GenericVariable r2ml:name="B"/>
  • stałe argumenty: np: 300
<r2ml:TypedLiteral r2ml:lexicalValue="300" r2ml:datatype="xs:integer"/>
  • suma: n+1
<r2ml:DatatypeFunctionTerm r2ml:datatypeFunction="op:numeric-add">
   <r2ml:dataArguments>
   <r2ml:GenericVariable r2ml:name="n"/>
      <r2ml:TypedLiteral r2ml:lexicalValue="1" r2ml:datatype="xs:integer"/>
   </r2ml:dataArguments>
</r2ml:DatatypeFunctionTerm>
  • różnica: n-1
<r2ml:DatatypeFunctionTerm r2ml:datatypeFunction="op:numeric-subtract">
  <r2ml:dataArguments>
   <r2ml:GenericVariable r2ml:name="n"/>
       <r2ml:TypedLiteral r2ml:lexicalValue="1" r2ml:datatype="xs:integer"/>
  </r2ml:dataArguments>
</r2ml:DatatypeFunctionTerm>
  • równość: (wyr_1) = (wartosc)
<r2ml:EqualityAtomr2ml:isNegated="false">
   <r2ml:ObjectVariabler2ml:name="wyr_1"/>
   <r2ml:ObjectVariabler2ml:name="wartosc"/>
</r2ml:EqualityAtom>
  • nierówność: n > 0
<r2ml:DatatypePredicateAtomr2ml:datatypePredicateID="swrlb:greaterThan">
  <r2ml:dataArguments>
  <r2ml:GenericVariable r2ml:name="n"/>
    <r2ml:TypedLiteral r2ml:lexicalValue="1" r2ml:datatype="xs:integer"/>
  </r2ml:dataArguments>
</r2ml:DatatypePredicateAtom>
  • nierówność: n ⇐ 1
<r2ml:DatatypePredicateAtomr2ml:datatypePredicateID="swrlb: lessThanOrEqual ">
  <r2ml:dataArguments>
  <r2ml:GenericVariable r2ml:name="n"/>
     <r2ml:TypedLiteral r2ml:lexicalValue="1" r2ml:datatype="xs:integer"/>
  </r2ml:dataArguments>
</r2ml:DatatypePredicateAtom>
  • suma logiczna : (wyr_1) and (wyr_2)
<r2ml:GenericAtom r2ml:isNegated="false" r2ml:predicateID="wyr_1">
  <r2ml:arguments>
  </r2ml:arguments>
  </r2ml:GenericAtom>
  <r2ml:GenericAtom r2ml:isNegated="false" r2ml:predicateID="wyr_2">
  <r2ml:arguments>
  </r2ml:arguments>
</r2ml:GenericAtom>
  • warunek if : (conclusion) if (conditions)
<r2ml:DerivationRule>
<r2ml:conditions>
     (conditions)
</r2ml:conditions>
<r2ml:conclusion>
     (conclusion)  
</r2ml:conclusion>
</r2ml:DerivationRule>
  • funkcje: fun_name(B)
<r2ml:GenericFunctionTermr2ml:genericFunctionID=" fun_name ">
  <r2ml:arguments>
  <r2ml:GenericVariabler2ml:name="B"/>
  </r2ml:arguments>
</r2ml:FunctionTerm>

Teraz możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą R2ML. Przedstawmy go w postaci:

	temp = 20    if    day = monday

wówczas zapis w R2ML wyglada następująco:

<?xml version="1.0" encoding="UTF-8" ?>
<r2ml:RuleBase xmlns:r2ml="http://www.rewerse.net/I1/2006/R2ML"
          xmlns:r2mlv="http://www.rewerse.net/I1/2006/R2ML/R2MLV"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:xs="http://www.w3.org/2001/XMLSchema" 
          xmlns:userv="http://www.businessrulesforum.com/2005/userv#" 
          xmlns:swrlb="http://www.w3.org/2003/11/swrlb"
          xsi:schemaLocation="http://oxygen.informatik.tu-cottbus.de/R2ML/0.5/R2ML.xsd">
 
<r2ml:DerivationRuleSet>
<r2ml:DerivationRule r2ml:ruleID="Rule" xmlns:swrlb="http://www.w3.org/2003/11/swrlb" xmlns:srv="http://www.services.org/EU-Rent/">
   <r2ml:Documentation>
    <r2ml:RuleText r2ml:textFormat="plain"  r2ml:ruleDiagram="examples:DR_scheduledService.gif">
      If day is a monday then temp is equal to 20 degrees.
    </r2ml:RuleText>
   </r2ml:Documentation>
   <r2ml:conditions>
     <r2ml:ObjectClassificationAtom r2ml:classID="monday">
      <r2ml:ObjectVariable r2ml:name="day"/>
     </r2ml:ObjectClassificationAtom>
   </r2ml:conditions>
   <r2ml:conclusion>
    <r2ml:DatatypePredicateAtom r2ml:datatypePredicateID="swrlb:equal">
     <r2ml:dataArguments>
      <r2ml:ObjectVariable r2ml:name="temp"/>
      <r2ml:TypedLiteral r2ml:lexicalValue="20" r2ml:datatypeID="xs:positiveInteger"/>
     </r2ml:dataArguments>
    </r2ml:DatatypePredicateAtom>
   </r2ml:conclusion>
  </r2ml:DerivationRule>
</r2ml:DerivationRuleSet>
</r2ml:RuleBase>

Inne przykłady przedstawienia reguł za pomocą R2ML można znaleźć na stronie: Rule Examples. Ciekawym przykładem może być również całość hekate_case_thermostat zapisana w R2ML: Therm in R2ML

3. RuleML - Rule Markup Language

RuleML jest językiem powstałym w ramach inicjatywy Semantic Web, służącym do zapisywania reguł logicznych na bazie składni języka XML. W istocie, język RuleML rozszerza język OWL o dynamiczne aspekty modelowania wiedzy. RuleML obejmuje m.in.

  • Mathematical Markup Language (MathML)
  • DARPA Agent Markup Language (DAML)
  • Predictive Model Markup Language (PMML)
  • Gramatyke atrybutów w XML (AG-znaczników):
  • Transformacje XSL (XSLT)

Podobnie jak to było w przypadku R2ML, nie musimy być zaznajomieni ze wszystkimi elementami języka RuleML w celu jego wykorzystania. Aby można było użyć RuleML do przedstawiania reguł potrzebna jest wiedza jak zapisywać typowe dla nich elementy.

Przykłady takich elementów (RuleML ver. 0.91):

  • wartosc logiczna: B
<Var> B </Var>
  • stałe argumenty: 20
<Data xsi:type = "xs:integer"> 20 </Data>
  • suma: n+1
<Expr>
<Fun in="yes"> add </Fun>
    <Var> n </Var>
    <Ind> 1 </Ind>
</Expr>
  • różnica: n-1
<Expr>
<Fun in="yes"> subtract </Fun>
   <Var> n </Var>
   <Ind> 1 </Ind>
</Expr>
  • równość: (wyr_1) = (wartosc)
<Equal oriented="yes">
  <lhs>
     (wyr_1)
  </lhs>
  <rhs>
     (wartosc)
  </rhs>
</Equal>

Atrybut ‘oriented’ przyjmuje wartość ‘yes’ (directed equation) lub ‘no’ (undirected equation, default) (<lhs> (left hand side) i <rhs> (right hand side) moga być pominiete, pomagaja w okresleniu orientacji)

  • nierówność: n > 0
<Rel> greaterThan </Rel>
    <Var>n</Var>
    <Ind>0</Ind>
  • nierówność: n ⇐ 1
<Rel> lessThanorEqual </Rel>
    <Var>n</Var>
    <Ind>0</Ind>
  • suma logiczna : (wyr_1) and (wyr_2)
<And>
  <Atom>
       (wyr_1)
  </Atom>
  <Atom>
       (wyr_2)
  </Atom>
</And>
  • warunek if : (conclusion) if (conditions)
<Implies>
  <head>
    (conclusion)
  </head>
  <body>
    (conditions)
  </body>	
</Implies>
  • funkcje: fun_name(B)
<Fun in="…" val="…"> fun_name </Fun>
   <Var> B </Var>

Atrybut ‘in’ przyjmuje wartości “yes”(uninterpreted functions – nie uzywaja definicji funkcji) lub “no”(interpreted functions – uzywaja definicji funkcji), in=”semi” to wartość domyślna (neutralna). Atrybut ‘val’ określa czy funkcja jest determistyczna czy nie determistyczna; dopuszczalne wartości „1”- dokładnie jeden , „0…” – zero lub wiecej, „2”, „0…3” itp.

Teraz możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą RuleML. Przedstawmy go w postaci:

	temp = 20    if    day = monday

wówczas w RuleML zapis bedzie wyglądał następująco:

<?xml version="1.0" encoding="UTF-8"?>
 
<RuleML  xmlns=http://www.ruleml.org/0.91/xsd
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.ruleml.org/0.91/xsd http://www.ruleml.org/0.91/xsd/hornlogeq.xsd">
<Implies>
    <head>
      <Equal oriented="yes">
      <lhs>
          <Var> day </Var>
      </lhs>
      <rhs>
          <Data xsi:type="xs:dateTime">monday</Data>
      </rhs>
      </Equal>  
    </head>
    <body>
      <Atom>
          <Rel> temp </Rel>
          <Data xsi:type = "xs:float"> 20 </Data>
      </Atom>
    </body>	
</Implies>
</RuleML>

4. RDF (Resource Description Framework)

RDF jest podstawowym językiem używanym do zapisu informacji w Sieci Semantycznej i przeznaczonym do przetwarzania maszynowego. W dosłownym tłumaczeniu jest środowiskiem do opisu zasobów (jako zasób rozumiemy: dowolny obiekt znajdujący się w sieci, pojęcia abstrakcyjne, relacje i obiekty fizyczne). Do opisu zasobów używa się tzw. stwierdzeń (ang. statements), które składają się z podmiotu, orzeczenia oraz obiektu. W RDF podmiot stanowi opisywany zasób, predykat określa jaka jego własność jest opisywana, zaś obiekt stanowi wartość tej własności. Podstawowym mechanizmem wykorzystywanym przez RDF do identyfikacji podmiotu, predykatu i obiektu jest URI. RDF stanowi model lub bazę danych, która jest reprezentowana w formie grafu. RDF/XML jest językiem XML-a, który może być użyty do reprezentacji danych RDF.

Kilka dodatkowych słów o RDF + atrybuty w RDF + przykład

Ważną cechą języka RDF jest to iż nie obsługuje on negacji oraz reguł. Można to zaliczyć od jego wad gdyż systemy reprezentowania wiedzy potrzebują dwóch rodzajów negacji, mianowicie słabej negacji ~ (ang. weak negation) wyrażającej nieprawdę, silnej negacji (ang. strong negation) wyrażającej jednoznacznie nieprawdziwe informacje lub błędność, oraz oczywiście możliwości zapisu reguł. Aby temu zaradzić rozpoczęto prace nad nowym językiem Extended RDF oznaczonym jako ERDF (obecnie jest to tylko prototypowa implementacja w wersji 0.1). Język ten jest rozszerzeniem RDF'a o wyżej wspomniane negacje oraz reguły. Na ten czas skupię sie tylko na kwestiach związanych z rozszerzeniami RDF'a umożliwiającymi zapisywanie reguł gdyż to jest tematem projektu. W poniższym opisie oraz przykładach będę się posługiwał składnia XML:

Składnia reguł ERDF (ang.abstract syntax of ERDF Rules) zdefiniowana jest za pomocą poniższego diagramu (Rys.1). Reguły ERDF przybierają formę D ← A1,…,An, gdzie D jest opisem ERDF (ang.ERDF description) z możliwością negacji natomiast A1,…,An są atomami ERDF.

:pl:miw:miw08_hml_rules:erdf.gif

Rys.1 ERDF-Rule Meta-Model

Termy ERDF są referencjami URI, identyfikatorami, zmiennymi lub literałami. Są one wyrażane na dwa sposoby, zależnie od ich występowania jako subject expression (z atrybutem erdf:about) lub jako value expression (rdf:resource, rdf:nodeID lub erdf:variable).

:pl:miw:miw08_hml_rules:gif_6.gif

Rys.2 ERDF-Term Meta-Model

Opisy ERDF są zapisywane jako elementy z atrybutem erdf:Description. Każdy opis zawiera niepustą listę własności (mogą to być również negacje). ERDF descriptions, jak przedstawia Rys.2, rozbudowuje opisy RDF o opcjonalny atrybut erdf:negationMode umożliwiający specyfikacje dwóch rodzajów negacji, oraz dopuszcza zmienne jako argumenty(subjectExpr i valueExpr).

:pl:miw:miw08_hml_rules:gif_7.gif

Rys.3 ERDF-Description Meta-Model

Na przykład: Gerd knows Adrian, has some topic interest, but is not interested in the topic 'motor sports' zapiszemy następująco:

<erdf:Description erdf:about="#Gerd">
    <foaf:knows rdf:resource="#Adrian"/>
    <foaf:topic_interest rdf:nodeID="x"/>
    <foaf:topic_interest erdf:negationMode="Sneg"
                        rdf:resource="urn:topics:motor_sports"/>
</erdf:Description>

Inny przykład; suma w ERDF:

<erdf:DatatypePredicateAtom erdf:predicate="swrlb:add">
    <erdf:Variable> ?sum </erdf:Variable>
    <rdfs:Literal rdf:datatype="xs:int"> 40 </rdfs:Literal>
    <rdfs:Literal rdf:datatype="xs:int"> 40 </rdfs:Literal>
</erdf:Description>

Po to by wyrazić reguły ERDF za pomocą XML używamy języka reguł R2ML (REWERSE Rule Markup Language). Warto zauważyć że istnieje tutaj możliwość identyfikacji reguł poprzez nadawanie im ID. Szablon takiej reguły zamieszczam poniżej:

<r2ml:DerivationRule r2ml:ruleID="R1">
    <r2ml:conditions>
           <erdf:Description erdf:about="...">
                ...
           </erdf:Description> 
    </r2ml:conditions>
    <r2ml:conclusion>
           <erdf:Description erdf:about="...">
                ...
           </erdf:Description> 
    </r2ml:conclusion>
</r2ml:DerivationRule>

Teraz możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą Extended RDF.

<r2ml:DerivationRule r2ml:ruleID="R1">
    <r2ml:conditions>
           <erdf:Description erdf:about="?day">
                <rdf:typr rdf:resource="#Monday"/>
           </erdf:Description> 
    </r2ml:conditions>
    <r2ml:conclusion>
           <erdf:Description erdf:about="temp">
               <rdfs:Literal rdf:datatype="xs:int"> 20 </rdfs:Literal>
           </erdf:Description> 
    </r2ml:conclusion>
</r2ml:DerivationRule>

W czasie pracy nad ERDF natrafiłem również na nieco inny sposób zapisu reguł i faktów w RDF wykorzystujący notacje N3 (http://www.ninebynine.org/RDFNotes/RDFFactsAndRules.html#%5B4%5D). Poniżej krótko scharakteryzuje tą metodę:

Użycie faktów: Wyrażenia RDF występują w postaci trójek zwanych zdaniami (statements). Wszystko do czego odnoszą się zdania są zasobami z pewnymi identyfikatorami lub wartościami. Po to aby fakty były użyte w zdaniach, musimy dysponować pewną tożsamością, która z kolei odpowiada pewniej wartości zasobu.

By zapewnić taką reprezentacje faktów, wprowadza się nowe identyfikatory zasobów, powiązanych tutaj z przestrzenią nazw z prefixem rul: która wskazuje na przestrzeń nazw URI <http://id.ninebynine.ord/RDFRules/1.0/>:

  • rul:Fact – jest pomocniczym typem danych który jest stosowany jako zasób reprezentujący fakt.
  • rul:pred – to własność który określa predykat użyty przez fakt
  • rul:args – to własność określająca listę argumentów predykatu użytą w fakcie

Przykład pewnego faktu reprezentowanego w RDF /N3 jako

ex:subj ex:pred [ rdf:type rdf:List ;
                  rdf:first ex:val2 ;
                  rdf:rest [ rdf:type rdf:List ;
                             rdf:first ex:val3 ;
                             rdf:rest [ rdf:type rdf:List
                                        :
                                        ... rdf:rest rdf:nil ]]] .

Resource który reprezentuje ten fakt jest konstruowany jak pokazano w tym przykładzie RDF/N3:

[  rdf:type rul:Fact ;
   rul:pred ex:pred ;
   rul:args [ rdf:type rdf:List ;
              rdf:first ex:subj ;
              rdf:rest _:genid1 ] ] .

gdzie _:genid1 jest identyfikatorem reprezentującym „ogon” listy argumentów predykatu

Reprezentacja reguł: Podstawowa struktura reguł których używamy to zbiór faktów poprzedników (antecedent facts) i faktów z nich wynikających (consequent facts)

Reguła:

     Afact1 & Afact2 & ... -> Cfact1 & Cfact2 & ...

jest reprezentowana w RDF, używając notacji N3, jako:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rul: <http://id.ninebynine.org/RDFRules/1.0/> .
@prefix ex:  <http://example.org/#> .
 
          [ rdf:type rul:Rule ;
            rul:from Afact1 ;
            rul:from Afact2 ;
            ...
            rul:infer Cfact1 ;
            rul:infer Cfact2 ;
            ... ] .

Taka reprezentacja reguł wprowadza pewne nowe identyfikatory zasobów, powiązanych tutaj z przestrzenią nazw z prefixem rul: która wskazuje na przestrzeń nazw URI <http://id.mimesweeper.com/RDFExpert/V1.0/ess#>:

  • rul:Rule - to pomocniczy typ danych który opisuje zasób który reprezentuje regułę
  • rul:from - to właściwość która określa zasób reprezentujący fakt Afact (antecedent fact) reguły, jeden z faktów z którego może być wyciągnięty wniosek
  • rul:infer – to właściwość która wskazuje fakt Cfact (conclusion fact) który może być wywnioskowany jeśli wszystkie fakty poprzedzające (antecedent facts) są prawdą.

Tak oto poniższa reguła:

    ex:a1( ex:a1s, ex:a1v2, ex:a1v3 ) &
    ex:a2( ex:a2s, ex:a2v2 ) ->
           ex:c1( ex:c1s, ex:c1v2, ex:a1v3 ) &
           ex:c2( ex:c2s ) .

była by reprezentowana w RDF/N3 jako:

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rul: <http://id.ninebynine.org/RDFRules/1.0/> .
@prefix ex:  <http://example.org/#> .
 
      [ rdf:type rul:Rule ;
        rul:from  _:genid1 ;
        rul:from  _:genid2 ;
        rul:infer _:genid3 ;
        rul:infer _:genid4 ]

gdzie: genid1, genid2, genid3, genid4 są identyfikatorami reprezentującymi „ogon” listy argumentów predykatu np. genid2 może być opisany jako:

_:genid2 rdf:type rul:Fact ;
         rul:pred ex:a2 ;
         rul:args [ rdf:type rdf:List ;
                    rdf:first ex:a2s ;
                    rdf:rest [ rdf:type rdf:List ;
                               rdf:first ex:a2v2 ;
                               rdf:rest rdf:nil ]] .

Zmienne w ogólnym znaczeniu to identyfikatory które reprezentują pewne określone wartości, ale mogą róznież reprezentować różne wartości jeśli są użyte w innym kontekscie lub w róznych odwołaniach. Na przykład, reguła:

  parents( ?a, ?b, ?c ) &
  parents( ?b, ?d, ?e ) &
  parents( ?c, ?f, ?g ) -> grandparents( ?a, ?d, ?e, ?f, ?g )

Moze być wywołana dl zbiorów faktów które jednocześnie pasują do reguły przodka (antecedents); dla kazdego zbioru faktów, zmienne będą związane z innymi wartościami.

When a variable appears in a fact that is part of a rule, the scope of the variable is the containing rule. That is, all occurrences of a given variable that appear within the rule are required to bind to the same value in any single invocation of the rule.

Zmienne są reprezentowane przez zasób typu rul:Var, oraz posiadają rdfs:label własność która jest nazwą zmiennej. Tak oto fakt:

  ex:Parents( ?a, ?b, ?c ) .

może być reprezentowany w RDF/N3 jako:

@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix rul: <http://id.ninebynine.org/RDFRules/1.0/> .
@prefix ex:   <http://example.org/#> .
 
_:genid1 ex:Parents [ rdf:type  rdf:List ;
                      rdf:first _:genid2 ;
                      rdf:rest  [ rdf:type  rdf:List ;
                                  rdf:first _:genid3 ;
                                  rdf:rest  rdf:nil ] ] .
_:genid1 rdf:type rul:Var ;
         rdfs:label "?a" .
_:genid2 rdf:type rul:Var ;
         rdfs:label "?b" .
_:genid3 rdf:type rul:Var ;
         rdfs:label "?c" .

The identity (uniqueness) of a variable is bound to the resource that represents it, not to its name. The variable name may be used (in conjunction with scoping rules) as a syntactic device for deciding which variable occurrences refer to the same variable, and hence which at any instant or invocation must correspond to the same value. Occurrences of the same variable name within a rule is an example of multiple occurrences of the same variable.

Całość therm w RDF/N3: hekate_case_thermostat

5. OWL - Web Ontology Language

OWL jest językiem ze składnią opartą na XML, a semantyką opartą na tzw. logice deskrypcyjnej (ang. description logics). Stanowi on rozszerzenie 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.

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 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 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ę:

antecedent -> consequent   czyli   poprzednik -> następnik

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:

parent(?a,?b) ^ brother (?b,?c) -> uncle(?a,?c)

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 :

Person(Mary) ^ hasSibling(Mary, Fred) ^ Male(Fred) -> hasBrother(Mary, Fred)

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:

34    
4.45    
-34    
True   
false      
"a literal"   

Wszystkie typy danych muszą być poprzedzone prefixem przestrzeni nazw 'xsd:', np:

xsd:unsignedInt    
xsd:string    

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:

34^^xsd:unsignedInt 
"a literal"^^xsd:string

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łą:

Person(?p) ^ hasAge(?p, ?age) ^ swrlb:greaterThan(?age, 17) -> Adult(?p) 

Dla zachowania konwencji predykaty zawarte w SWRL poprzedzane są prefixem swrlb.

Person(?p) ^ hasNumber(?p, ?number) ^ swrlb:startsWith(?number, "+") -> hasInternationalNumber(?p, true) 

W SWRL negacja nie jest możliwa, czyli poniższa reguła jest błędem:

Person(?p) ^ ¬ hasCar(?p, ?c) -> CarlessPerson(?p)

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.

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

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

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:

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

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

<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>

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:

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

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

<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>

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

monday(?day) -> temp(20)  

w składni 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>

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

Strona domowa RIF http://www.w3.org/2005/rules/wiki/RIF_Working_Group

Więcej przykładów w RIF http://www.w3.org/2005/rules/wg/wiki/UC3_Worked_Example

Szczególnie przydatne do RIF http://www.w3.org/TR/2007/WD-rif-bld-20071030/

Cały thermostat w RIF https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_xtt_rif:thermostat

RIF Core Design http://www.w3.org/TR/2007/WD-rif-core-20070330/

Strona domowa R2ML http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=node/6

Szczególnie przydatne do R2ML http://www.w3.org/TR/xpath20/

Więcej przykładów w R2ML http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=node/49

Całość thermostat w R2ML https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_xtt_r2ml:thermostat

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/

Strona domowa RuleML (http://www.ruleml.org/0.91/)

Szczególnie przydatne do RuleML http://www.ruleml.org/0.91/glossary/

Więcej przykładów w RuleML http://www.ruleml.org/0.91/exa/

Uniform Resource Identifier http://pl.wikipedia.org/wiki/Uniform_Resource_Identifier/

Representing Facts and Rules in RDF http://www.ninebynine.org/RDFNotes/RDFFactsAndRules.html

Struktura Opisu Zasobów (RDF) http://www.geocities.com/pan_andrew/ResourceDescriptionFramework.htm#ref-xhtml

Strona domowa RDF http://www.w3.org/RDF/

Polskie tłumaczenie specyfikacji RDF http://www.geocities.com/pan_andrew/ResourceDescriptionFramework.htm

Strona domowa ERDF http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=ERDF

Szczególnie przydatne do ERDF http://oxygen.informatik.tu-cottbus.de/IT/Research/ERDF-JAIR-2008.pdf

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/

pl/miw/miw08_hml_rules.txt · ostatnio zmienione: 2017/07/17 08:08 (edycja zewnętrzna)
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0