--- pl:miw:miw08_hml_rules [2008/04/29 12:51]
gjn
+++ pl:miw:miw08_hml_rules [2019/06/27 15:50] (aktualna)
@@ Linia 1: / Linia 1: @@
 ====== Opis ======
+__**Projekt zakończony**__
 Michał, Rogula, <michal.rogula@wp.pl>
   - Porównać i omówić metody reprezentowania atrybutów w językach:
@@ Linia 13: / Linia 15: @@
   * 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ą:
+  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rif|Rule Interchange Format (RIF)]]
+  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:r2ml|Rewerse Rule Markup Language (R2ML)]]
+  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:ruleML|Rule Markup Language (RuleML)]]
+  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rdf|Resource Description Framework (RDF) / Extended RDF (ERDF)]]
+  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:owl|Web Ontology Language (OWL) / Semantic Web Rule Language (SWRL)]]
 ====== Spotkania ======
-===== 08.02.26 =====
-  * rif
-  * rdf/owl<->rif
-===== 08.03.04 =====
+[[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:spotkania|SPOTKANIA]]
-  * repr. w RDF (attrybuty)
-  * <del>próba zapisu [[hekate:hekate_case_thermostat]] org. reguł w RIF, RDF</del>
-===== 080311 =====
-  * próba zapisu [[hekate:hekate_case_thermostat]] org. reguł w RIF, RDF
-===== 080318 =====
-  * j.w.
-===== 080408 =====
-  * całość therm w RDF, osobna przestrz nazw
-  * zapis ARD w RDF [[hekate:hekate_markup_language]]
-===== 080422 =====
-  * zapis grafów w rdf
-  * 3 predykaty:
-    * w ARD season //depends on//month
-    * w TPH (shi.)
-      * Th,Temp //finalizes// Therm
-      * Time //splited from// Th,Temp
-===== 080429 =====
+====== Sprawozdanie ======
-  * reguły
+===== 1. RIF(Rule Interchange Format) =====
+RIF jest stworzonym przez W3C [[http://www.w3.org/|(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. [[http://www.w3.org/2005/rules/wg/draft/rif-fld/|RIF Framework for Logic Dialects ]] oraz [[http://www.w3.org/2005/rules/wg/draft/rif-bld/|RIF Basic Logic Dialect]]
-===== 080520 =====
+[[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rif:rifattribute|Atrybuty w RIF + RDF oraz OWL Kompatybilność]]
-  * SWRL
-  * RDF
-  * [[http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=ERDF|ERDF]]
-====== Projekt ======
+Dokładny opis specyfikacji RIF można znaleźć w projekcie [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_xtt_rif|XTT_RIF]]. Dla mnie istotna, z punktu widzenia projektu, jest wiedza jak zapisywać typowe dla reguł elementy tj:
-  Jeżeli dzień=poniedziałek wtedy temp=20st
+  * wartosc logiczna: np: B
-mamy 2 atrybuty:
+<code xml>
-  * dzień, przyjmuje wart symboliczne ze zb: pon-niedz
+<Var> B </Var>
-  * temp, jest liczbą, np. float, z zakresu, np. 0-20st
+</code>
-Rozważania na temat zapisu powyższej reguły za pomocą:
+  * stałe argumenty: np: 300
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rif|Rule Interchange Format (RIF)]]
+<code xml>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:r2ml|Rewerse Rule Markup Language (R2ML)]]
+<arg><Const type="rds:long"> 300 </Const></arg>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:ruleML|Rule Markup Language (RuleML)]]
+</code>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rdf|Resource Description Framework (RDF)]]
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:owl|Web Ontology Language (OWL)]]
-===== 08.02.26 =====
+  * suma: n+1
-**RIF**(Rule Interchange Format) 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). (def: http://www.webopedia.com/TERM/R/Rule_Interchange_Format.html)
-[[http://www.w3.org/TR/rif-bld/|Dokumentacja RIF]] przedstawia dwa rodzaje składni. Są to tzw:
+<code xml>
-  * Presentation syntax – Używana w formalnych definicjach, szczególnie dla semantyki.
+<Uniterm>
-  * XML syntax -  Jest to tzw. XML serialization składni prezentacji. Kluczowe cechy tej składni wywodzą się  ze składni prezentacji, lecz niektóre aspekty związane z wymianą reguł nie mają swoich odpowiedników w presentation syntax.
+<op><Const type="rif:iri"> op:numeric-add </Const></op>
+<arg><Const type=""> 1 </Const></arg>
+<arg><Var> n </Var></arg>
+</Uniterm>
+</code>
-**Atrybut** to parametr zawierający dodatkowe informacje o elemencie struktury logicznej identyfikowanym przez dany znacznik.
+  * różnica: n-1
-Sposób przedstawiania atrybutów w [[http://www.w3.org/TR/rif-bld/|Presentation syntax]] :
+<code xml>
+<Uniterm>
+<op><Const type="rif:iri"> op:numeric-subtract </Const></op>
+<arg><Const type=""> 1 </Const></arg>
+<arg><Var> n </Var></arg>
+</Uniterm>
+</code>
-        nazwa_atrybutu->wartość_atrybutu^^type
+  * równość: (wyr_1) = (wartosc)
-Sposób przedstawiania atrybutów w [[http://www.w3.org/TR/rif-bld/|XML syntax]]:
+<code xml>
+<Equal>
+<arg> wyr_1 </arg>
+<arg> wartosc </arg>
+</Equal>
+</code>
-        <slot><Const>nazwa_atrybutu</Const><Var type=””>wartość_atrybutu</Var></slot>
+  * nierówność:  n > 0
+<code xml>
+<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>
+</code>
-**Przykład:**
+  * nierówność:  n <= 1
-  * Presentation syntax
-        author^^rif:local -> ?Author
+<code xml>
-        price^^rif:local -> 49^^xsd:integer
+<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>
+</code>
+  * suma logiczna : (wyr_1) and (wyr_2)
-  * XML syntax
 <code xml>
-        <slot><Const type="rif:local">author</Const><Var>Author</Var></slot>
+<And>
-        <slot><Const type="rif:local">price</Const><Const type="xsd:integer">49</Const></slot>
+<formula>
+(wyr_1)
+</formula>
+<formula>
+(wyr_2)
+</formula>
+</And>
 </code>
-Prefix xsd: oznacza przestrzeń nazw XML http://www.w3.org/2001/XMLSchema#, a prefix rif: URI przestrzeni nazw RIF http://www.w3.org/2007/rif# .
+  * warunek if : (conclusion) if (conditions)
-rif:local (dla stałych symboli niewidocznych poza daną formułą rif).
-**RIF RDF oraz OWL Kompatybilność**
+<code xml>
+<Implies>
+<if>
+(conditions)
+</if>
+<then>
+(conclusion)
+</then>
+</Implies>
+</code>
-RIF definiuje sposób przenoszenia regół w sieci. Reguły wymieniane poprzez RIF mogą się odnosić się do zewnętrznych źródeł danych i mogą bazować na pewnych modelach które są reprezentowane za pomocą języków różnych od RIF np: RDF , RDFS, OWL.
+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:
-Dokument http://www.w3.org/TR/rif-rdf-owl  określa kompatybilność RIF i RDF(S).
-Przyszła wersja tego dokumentu będzie również określać kompatybilność z ontologią OWL.
-  * Zgodność pomiędzy stałymi symbolami w RIF oraz nazwami w RDF graphs np.:
+<code xml>
+<?xml version="1.0" encoding="UTF-8"?>
-        RDF -   "literal string"
+<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>
+</code>
-        RIF -   "literal string"^^xsd:string
+W analogiczny sposób możemy zapisać większość reguł. Przykładem może być tu całość [[https://ai.ia.agh.edu.pl/wiki/hekate:hekate_case_thermostat|HeKatE Case Thermostat]] którego reguły przedstawione w RIF wyglądają nastepująco: [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_xtt_rif:thermostat|therm in RIF]].
-  * Zgodność pomiędzy zdaniami w RDF (trojki postaci: s p o) i pewnymi rodzajami formuł w RIF (formula w postaci: s'[p' -> o'], gdzie s', p', oraz o' są symbolami RIF zgodnymi odpowiednio z symbolami RDF’a s, p, oraz o), np.:
+===== 2. R2ML – Reverse Rule Markup Language =====
+R2ML powstał z inicjatywy [[http://oxygen.informatik.tu-cottbus.de/rewerse-i1/|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 [[http://www.omg.org/technology/documents/formal/ocl.htm|Object Constraint Language (OCL)]], Semantic Web Rule Language (SWRL) oraz Rule Markup Language (RuleML).
-RDF triple:
+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:
-       john uncleOf marry
-Formuła RIF frame:
+  * wartość logiczna: np: B
-       "john"^^rif:iri["uncleOf"^^rif:iri -> "mary"^^rif:iri]
+<code xml>
+<r2ml:GenericVariable r2ml:name="B"/>
+</code>
+  * stałe argumenty: np: 300
+<code xml>
+<r2ml:TypedLiteral r2ml:lexicalValue="300" r2ml:datatype="xs:integer"/>
+</code>
+  * suma: n+1
+<code xml>
+<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>
+</code>
+  * różnica: n-1
+<code xml>
+<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>
+</code>
-===== 08.03.04 =====
+  * równość: (wyr_1) = (wartosc)
-**RDF** (Resource Description Framework) 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).
+<code xml>
-Do opisu zasobów używa się tzw. stwierdzeń (ang. statements), które składają się z:
+<r2ml:EqualityAtomr2ml:isNegated="false">
-	* Podmiotu – opisywany zasób.
+   <r2ml:ObjectVariabler2ml:name="wyr_1"/>
-	* Orzeczenia (predykatu) – nazwa cechy lub relacji dotyczącej opisywanego podmiotu.
+   <r2ml:ObjectVariabler2ml:name="wartosc"/>
-	* Obiektu – inny zasób lub stała wartość określona mianem literału.
+</r2ml:EqualityAtom>
+</code>
+  * nierówność:  n > 0
-Sposób przedstawiania atrybutów w [[http://www.w3.org/TR/rdf-primer/|RDF]]:
+<code xml>
+<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>
+</code>
-	< opisywany_zasob > < nazwa_atrybutu > „wartosc_atrybutu”.
+  * nierówność:  n <= 1
-**Przykład opisu w RDF pewnego „zasobu”:**
+<code xml>
+<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>
+</code>
-Zwykłe zdanie:
+  * suma logiczna : (wyr_1) and (wyr_2)
-        Janek jest twórcą dokumentu http://www.dokumenty.org/dokument1
+<code xml>
+<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>
+</code>
-Zdanie RDF:
+  * warunek if : (conclusion) if (conditions)
-        http://www.dokumenty.org/dokument1 posiada własność twórca której wartością jest Janek
+<code xml>
+<r2ml:DerivationRule>
+<r2ml:conditions>
+     (conditions)
+</r2ml:conditions>
+<r2ml:conclusion>
+     (conclusion)
+</r2ml:conclusion>
+</r2ml:DerivationRule>
+</code>
-Właściwa forma RDF (musi być zakonczona kropką):
+  * funkcje: fun_name(B)
-        <http://www.dokumenty.org/dokument1> <http://purl.org/dc/elements/1.1/creator> „Janek”.
+<code xml>
+<r2ml:GenericFunctionTermr2ml:genericFunctionID=" fun_name ">
+  <r2ml:arguments>
+  <r2ml:GenericVariabler2ml:name="B"/>
+  </r2ml:arguments>
+</r2ml:FunctionTerm>
+</code>
-Graf RDF:
+Teraz możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą R2ML.
+Przedstawmy go w postaci:
-{{:pl:miw:rdf.png|:pl:miw:rdf.png}}
+		temp = 20    if    day = monday
+wówczas zapis w R2ML wyglada następująco:
-Styl XML:
 <code xml>
-        <?xml version="1.0"?>
+<?xml version="1.0" encoding="UTF-8" ?>
-        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+<r2ml:RuleBase xmlns:r2ml="http://www.rewerse.net/I1/2006/R2ML"
-        <rdf:Description rdf : about="subject">
+          xmlns:r2mlv="http://www.rewerse.net/I1/2006/R2ML/R2MLV"
-        <predicate>Object</predicate>
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        </rdf:Description>
+          xmlns:xs="http://www.w3.org/2001/XMLSchema"
-        </rdf:RDF>
+          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>
 </code>
-Nasz przykład zapisany w XML:
+Inne przykłady przedstawienia reguł za pomocą R2ML można znaleźć na stronie: [[http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=node/17|Rule Examples]]. Ciekawym przykładem może być również całość [[https://ai.ia.agh.edu.pl/wiki/hekate:hekate_case_thermostat|hekate_case_thermostat]] zapisana w R2ML: [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_xtt_r2ml:thermostat|Therm in R2ML]]
+===== 3. RuleML - Rule Markup Language =====
+RuleML jest językiem powstałym w ramach inicjatywy [[http://www.w3.org/2001/sw/|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
+<code xml>
+<Var> B </Var>
+</code>
+  * stałe argumenty: 20
+<code xml>
+<Data xsi:type = "xs:integer"> 20 </Data>
+</code>
+  * suma: n+1
+<code xml>
+<Expr>
+<Fun in="yes"> add </Fun>
+    <Var> n </Var>
+    <Ind> 1 </Ind>
+</Expr>
+</code>
+  * różnica: n-1
+<code xml>
+<Expr>
+<Fun in="yes"> subtract </Fun>
+   <Var> n </Var>
+   <Ind> 1 </Ind>
+</Expr>
+</code>
+  * równość: (wyr_1) = (wartosc)
+<code xml>
+<Equal oriented="yes">
+  <lhs>
+     (wyr_1)
+  </lhs>
+  <rhs>
+     (wartosc)
+  </rhs>
+</Equal>
+</code>
+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
+<code xml>
+<Rel> greaterThan </Rel>
+    <Var>n</Var>
+    <Ind>0</Ind>
+</code>
+  * nierówność:  n <= 1
+<code xml>
+<Rel> lessThanorEqual </Rel>
+    <Var>n</Var>
+    <Ind>0</Ind>
+</code>
+  * suma logiczna : (wyr_1) and (wyr_2)
+<code xml>
+<And>
+  <Atom>
+       (wyr_1)
+  </Atom>
+  <Atom>
+       (wyr_2)
+  </Atom>
+</And>
+</code>
+  * warunek if : (conclusion) if (conditions)
+<code xml>
+<Implies>
+  <head>
+    (conclusion)
+  </head>
+  <body>
+    (conditions)
+  </body>
+</Implies>
+</code>
+  * funkcje: fun_name(B)
+<code xml>
+<Fun in="…" val="…"> fun_name </Fun>
+   <Var> B </Var>
+</code>
+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:
+<code xml>
+<?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>
+</code>
+===== 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.
+[[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rdf:rdfexample|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 **[[http://oxygen.informatik.tu-cottbus.de/rewerse-i1/?q=ERDF|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|: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|: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|: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:
+<code xml>
+<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>
+</code>
+Inny przykład; suma w ERDF:
+<code xml>
+<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>
+</code>
+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:
+<code xml>
+<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>
+</code>
+Teraz możemy spróbować zapisać nasz przykład (Jeżeli dzień=poniedziałek wtedy temp=20st) za pomocą Extended RDF.
 <code xml>
-        <?xml version="1.0"?>
+<r2ml:DerivationRule r2ml:ruleID="R1">
-        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    <r2ml:conditions>
-                 xmlns:DC="http://purl.org/dc/elements/1.1/">
+           <erdf:Description erdf:about="?day">
-        <rdf:Description rdf : about="http://www.dokumenty.org/dokument1">
+                <rdf:typr rdf:resource="#Monday"/>
-        <DC:creator resource = "http://www.tworcy.org/janek">
+           </erdf:Description>
-        </rdf:Description>
+    </r2ml:conditions>
-        </rdf : RDF>
+    <r2ml:conclusion>
+           <erdf:Description erdf:about="temp">
+               <rdfs:Literal rdf:datatype="xs:int"> 20 </rdfs:Literal>
+           </erdf:Description>
+    </r2ml:conclusion>
+</r2ml:DerivationRule>
 </code>
-Użyty jest tu predykat pochodzący z “biblioteki” Dublin Core (słownictwo zdefiniowane do opisu metadanych różnych dokumentów -  w szczególności bibliotecznych: daty utworzenia, autora itp.). Jest to oznaczone w korzeniu dokumentu (którym jest zawsze znacznik rdf:RDF). Podmioty definiujemy znacznikiem rdf:Description z atrybutem rdf:abort zawierającym URI zasobu. Zdania opisujące ten podmiot są zapisywane jako węzły potomne. Obiekty, które są jednocześnie zasobami zapisujemy w postaci węzła skróconego z URI tego zasobu umieszczonym w atrybucie rdf:resorce.
+-------------------------------------------------------------------------------------------------------------------------------------------------------
-===== 08.03.11 =====
+W czasie pracy nad ERDF natrafiłem również na nieco inny sposób zapisu reguł i faktów w RDF wykorzystujący [[http://en.wikipedia.org/wiki/Notation_3|notacje N3]] (http://www.ninebynine.org/RDFNotes/RDFFactsAndRules.html#%5B4%5D). Poniżej krótko scharakteryzuje tą metodę:
 **Użycie faktów:
@@ Linia 203: / Linia 582: @@
-Przykład pewnego faktu reprezentowanego w RDF /N3 (notacja3 - http://en.wikipedia.org/wiki/Notation_3) jako
+Przykład pewnego faktu reprezentowanego w RDF /N3 jako
-         ex:subj ex:pred [ rdf:type rdf:List ;
+<code xml>
+ex:subj ex:pred [ rdf:type rdf:List ;
                   rdf:first ex:val2 ;
                   rdf:rest [ rdf:type rdf:List ;
@@ Linia 212: / Linia 592: @@
                                         :
                                         ... rdf:rest rdf:nil ]]] .
+</code>
 Resource który reprezentuje ten fakt jest konstruowany jak pokazano w tym przykładzie RDF/N3:
-        [  rdf:type rul:Fact ;
+<code xml>
-           rul:pred ex:pred ;
+[  rdf:type rul:Fact ;
-           rul:args [ rdf:type rdf:List ;
+   rul:pred ex:pred ;
-                      rdf:first ex:subj ;
+   rul:args [ rdf:type rdf:List ;
-                      rdf:rest _:genid1 ] ] .
+              rdf:first ex:subj ;
+              rdf:rest _:genid1 ] ] .
+</code>
 gdzie _:genid1 jest identyfikatorem reprezentującym „ogon” listy argumentów predykatu
@@ Linia 230: / Linia 613: @@
        Afact1 & Afact2 & ... -> Cfact1 & Cfact2 & ...
-jest reprezentowana w RDF (używając notacji3 (N3 - http://en.wikipedia.org/wiki/Notation_3)) jako:
+jest reprezentowana w RDF, używając notacji N3, jako:
+<code xml>
+@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/#> .
-       @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 ;
@@ Linia 242: / Linia 626: @@
             rul:infer Cfact2 ;
             ... ] .
+</code>
 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#>:
@@ Linia 259: / Linia 643: @@
 była by reprezentowana w RDF/N3 jako:
+<code xml>
+@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/#> .
-      @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 ;
@@ Linia 268: / Linia 653: @@
         rul:infer _:genid3 ;
         rul:infer _:genid4 ]
+</code>
 gdzie: genid1, genid2, genid3, genid4 są identyfikatorami reprezentującymi „ogon” listy argumentów predykatu np. genid2 może być opisany jako:
+<code xml>
-      _:genid2 rdf:type rul:Fact ;
+_:genid2 rdf:type rul:Fact ;
-               rul:pred ex:a2 ;
+         rul:pred ex:a2 ;
-               rul:args [ rdf:type rdf:List ;
+         rul:args [ rdf:type rdf:List ;
-                          rdf:first ex:a2s ;
+                    rdf:first ex:a2s ;
-                          rdf:rest [ rdf:type rdf:List ;
+                    rdf:rest [ rdf:type rdf:List ;
-                                     rdf:first ex:a2v2 ;
+                               rdf:first ex:a2v2 ;
-                                     rdf:rest rdf:nil ]] .
+                               rdf:rest rdf:nil ]] .
+</code>
 **Zmienne
 **
@@ Linia 296: / Linia 681: @@
 może być reprezentowany w RDF/N3 jako:
+<code xml>
+@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/#> .
-    @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+_:genid1 ex:Parents [ rdf:type  rdf:List ;
-    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+                      rdf:first _:genid2 ;
-    @prefix rul: <http://id.ninebynine.org/RDFRules/1.0/> .
+                      rdf:rest  [ rdf:type  rdf:List ;
-    @prefix ex:   <http://example.org/#> .
+                                  rdf:first _:genid3 ;
-    _:genid1 ex:Parents [ rdf:type  rdf:List ;
+                                  rdf:rest  rdf:nil ] ] .
-                          rdf:first _:genid2 ;
+_:genid1 rdf:type rul:Var ;
-                          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 ;
+_:genid2 rdf:type rul:Var ;
          rdfs:label "?b" .
-    _:genid3 rdf:type rul:Var ;
+_:genid3 rdf:type rul:Var ;
-             rdfs:label "?c" .
+         rdfs:label "?c" .
+</code>
 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: ** [[pl:miw:miw08_hml_rules: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 [[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.
-===== 080408 =====
+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 :
-**Całość therm w RDF: ** [[pl:miw:miw08_hml_rules:hekate_case_thermostat]]
+<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>
+
+.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.
-====== Sprawozdanie ======
+Literały mogą być sprecyzowane typem danych przez poprzedzenie ich parą "^^" oraz nazwą typu danej, np:
+<code xml>
+^^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 ======
+** 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/
@@ Linia 345: / Linia 895: @@
 **Struktura Opisu Zasobów (RDF)** http://www.geocities.com/pan_andrew/ResourceDescriptionFramework.htm#ref-xhtml
-**RIF Core Design** http://www.w3.org/TR/2007/WD-rif-core-20070330/
+**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.1209466295.txt.gz · ostatnio zmienione: 2019/06/27 15:58 (edycja zewnętrzna)

Pokaż stronę Poprzednie wersje

Menadżer multimediów Do góry

AIwiki

Menu

Dla Studentów

Old specialized AI courses

SMaDA/SMaIDA/AIDA

Informatyka (EAIiIB)

Studia Dr

Inne materialy dydaktyczne

Archiwum

Dyplomanci

Geist Season of Code

HeKatE

Public

Różnice