--- pl:miw:miw08_hml_rules [2008/05/19 12:15]
miw
+++ 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]]
+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:
+  * wartosc logiczna: np: B
-====== Projekt ======
+<code xml>
+<Var> B </Var>
+</code>
-  Jeżeli dzień=poniedziałek wtedy temp=20st
+  * stałe argumenty: np: 300
-mamy 2 atrybuty:
+<code xml>
-  * dzień, przyjmuje wart symboliczne ze zb: pon-niedz
+<arg><Const type="rds:long"> 300 </Const></arg>
-  * temp, jest liczbą, np. float, z zakresu, np. 0-20st
+</code>
-Rozważania na temat zapisu powyższej reguły za pomocą:
+  * suma: n+1
-  * [[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)]]
+<Uniterm>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:ruleML|Rule Markup Language (RuleML)]]
+<op><Const type="rif:iri"> op:numeric-add </Const></op>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:rdf|Resource Description Framework (RDF) / Extended RDF (ERDF)]]
+<arg><Const type=""> 1 </Const></arg>
-  * [[https://ai.ia.agh.edu.pl/wiki/pl:miw:miw08_hml_rules:owl|Web Ontology Language (OWL) / Semantic Web Rule Language (SWRL)]]
+<arg><Var> n </Var></arg>
+</Uniterm>
+</code>
-===== 08.02.26 =====
+  * różnica: 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-subtract </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ówność: (wyr_1) = (wartosc)
-Sposób przedstawiania atrybutów w [[http://www.w3.org/TR/rif-bld/|Presentation syntax]] :
+<code xml>
+<Equal>
+<arg> wyr_1 </arg>
+<arg> wartosc </arg>
+</Equal>
+</code>
-        nazwa_atrybutu->wartość_atrybutu^^type
+  * nierówność:  n > 0
-Sposób przedstawiania atrybutów w [[http://www.w3.org/TR/rif-bld/|XML syntax]]:
+<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>
-        <slot><Const>nazwa_atrybutu</Const><Var type=””>wartość_atrybutu</Var></slot>
+  * nierówność:  n <= 1
+<code xml>
+<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>
-**Przykład:**
+  * suma logiczna : (wyr_1) and (wyr_2)
-  * Presentation syntax
-        author^^rif:local -> ?Author
+<code xml>
-        price^^rif:local -> 49^^xsd:integer
+<And>
+<formula>
+(wyr_1)
+</formula>
+<formula>
+(wyr_2)
+</formula>
+</And>
+</code>
+  * warunek if : (conclusion) if (conditions)
-  * XML syntax
 <code xml>
-        <slot><Const type="rif:local">author</Const><Var>Author</Var></slot>
+<Implies>
-        <slot><Const type="rif:local">price</Const><Const type="xsd:integer">49</Const></slot>
+<if>
+(conditions)
+</if>
+<then>
+(conclusion)
+</then>
+</Implies>
 </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# .
+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:
-rif:local (dla stałych symboli niewidocznych poza daną formułą rif).
-**RIF RDF oraz OWL Kompatybilność**
+<code xml>
+<?xml version="1.0" encoding="UTF-8"?>
-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.
+<Ruleset>
-Dokument http://www.w3.org/TR/rif-rdf-owl  określa kompatybilność RIF i RDF(S).
+<rule>
-Przyszła wersja tego dokumentu będzie również określać kompatybilność z ontologią OWL.
+  <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>
-  * Zgodność pomiędzy stałymi symbolami w RIF oraz nazwami w RDF graphs np.:
+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]].
-        RDF -   "literal string"
+===== 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).
-        RIF -   "literal string"^^xsd:string
+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:
-  * 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.:
+  * wartość logiczna: np: B
-RDF triple:
+<code xml>
-       john uncleOf marry
+<r2ml:GenericVariable r2ml:name="B"/>
+</code>
-Formuła RIF frame:
+  * stałe argumenty: np: 300
-       "john"^^rif:iri["uncleOf"^^rif:iri -> "mary"^^rif:iri]
+<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>
+  * równość: (wyr_1) = (wartosc)
+<code xml>
+<r2ml:EqualityAtomr2ml:isNegated="false">
+   <r2ml:ObjectVariabler2ml:name="wyr_1"/>
+   <r2ml:ObjectVariabler2ml:name="wartosc"/>
+</r2ml:EqualityAtom>
+</code>
+  * nierówność:  n > 0
+<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>
+  * nierówność:  n <= 1
+<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>
+  * suma logiczna : (wyr_1) and (wyr_2)
+<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>
+  * warunek if : (conclusion) if (conditions)
+<code xml>
+<r2ml:DerivationRule>
+<r2ml:conditions>
+     (conditions)
+</r2ml:conditions>
+<r2ml:conclusion>
+     (conclusion)
+</r2ml:conclusion>
+</r2ml:DerivationRule>
+</code>
+  * funkcje: fun_name(B)
+<code xml>
+<r2ml:GenericFunctionTermr2ml:genericFunctionID=" fun_name ">
+  <r2ml:arguments>
+  <r2ml:GenericVariabler2ml:name="B"/>
+  </r2ml:arguments>
+</r2ml:FunctionTerm>
+</code>
+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:
+<code xml>
+<?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>
+</code>
+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):
-====== Sprawozdanie ======
+  * 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>
+<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>
+</code>
+-------------------------------------------------------------------------------------------------------------------------------------------------------
+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:
+**
+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
+<code xml>
+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 ]]] .
+</code>
+Resource który reprezentuje ten fakt jest konstruowany jak pokazano w tym przykładzie RDF/N3:
+<code xml>
+[  rdf:type rul:Fact ;
+   rul:pred ex:pred ;
+   rul:args [ rdf:type rdf:List ;
+              rdf:first ex:subj ;
+              rdf:rest _:genid1 ] ] .
+</code>
+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:
+<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/#> .
+          [ rdf:type rul:Rule ;
+            rul:from Afact1 ;
+            rul:from Afact2 ;
+            ...
+            rul:infer Cfact1 ;
+            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#>:
+  * 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:
+<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/#> .
+      [ rdf:type rul:Rule ;
+        rul:from  _:genid1 ;
+        rul:from  _:genid2 ;
+        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 ;
+         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 ]] .
+</code>
+**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:
+<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/#> .
+_: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" .
+</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.
+Indywidua są zaznaczane za pomocą ich nazw w OWL. Przykładem indywiduum może być 'Fred' lub 'Mary'. Przykład reguły w SWRL określającej własność hasBrother, korzystającej z indywiduum :
+<code xml>
+Person(Mary) ^ hasSibling(Mary, Fred) ^ Male(Fred) -> hasBrother(Mary, Fred)
+</code>
+Podstawowe typy takie jak integer, long, float czy double są określane za pomocą XML Schema datatypes. Wartości typu Boolean czyli prawda i fałsz są przedstawiane za pomocą vartości "true" i "false". Przykłady literałów:
+<code xml>
+
+.45
+-34
+True
+false
+"a literal"
+</code>
+Wszystkie typy danych muszą być poprzedzone prefixem przestrzeni nazw 'xsd:', np:
+<code xml>
+xsd:unsignedInt
+xsd:string
+</code>
+Nie wszystkie typy danych XML Schema są obecnie obsługiwane. Do tych wpieranych zaliczamy  xsd:int, xsd:short, xsd:long, xsd:boolean, xsd:float, xsd:double, xsd:string, xsd:time, xsd:anyURI, xsd:base64Binary, xsd:xsd:byte, xsd:duration, xsd:dateTime, oraz xsd:date.
+Literały mogą być sprecyzowane typem danych przez poprzedzenie ich parą "^^" oraz nazwą typu danej, np:
+<code xml>
+^^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 171: / 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.1211192124.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