Lernziele
- Regelsprachen im Semantic Web
- Zusammenhang zwischen OWL und Regeln
Die Grenzen von OWL
Konzepte als Anfragesprache ungenügend:- „Welche Paare von Personen haben ein gemeinsames Elternteil?“
- „Welche Personen wohnen bei einem ihrer Eltern?“
- „Welche Paare (direkter oder indirekter) Nachkommen gibt es?“
- \((\forall x)(\forall y)(\forall z)\; (\mathsf{bruder}(y,z) \wedge \mathsf{vater}(x,y) \to \mathsf{onkel}(x,z))\)
- \((\forall x)\; (\mathsf{liebt}(x,x) \to \mathsf{Narzist}(x))\)
- OWL ist entscheidbar: es kann grundsätzlich nicht alles Programmierbare ausdrücken ( Halteproblem ).
- OWL wird nicht „abgearbeitet“, es ist nicht prozedural : Bestimmte Erweiterungen (Built-ins) sind nur schwer zu realisieren.
1/4: Logische Regeln
- Implikationen in Prädikatenlogik
- Zum Beispiel: \[F\to G \;\;\; (\equiv\;\neg F \vee G)\]
- Logische Erweiterung der Wissensbasis → statisch
- Open World
- Deklarativ (beschreibend)
2/4: Prozedurale Regeln
- z.B. Production Rules
- „If X then Y else Z“
- Ausführbare Maschinen-Anweisungen → dynamisch
- Operational (Bedeutung = Effekt bei Ausführung)
3/4: Logikprogrammierung
- z.B. Prolog, F-Logik
-
mann(X) <- person(X) AND NOT frau(X)
- Approximation logischer Semantik mit operationalen Aspekten, Built-ins möglich
- häufig Closed World
- „Semi-deklarativ“
4/4 Ableitungsregeln eines Kalküls
- z.B. Regeln zur RDF-Semantik
- Regeln nicht als Teil der Wissensbasis, „Meta-Regeln“
- nicht Thema dieser Vorlesung
Welche Regelsprache
- Klare Spezifikation von Syntax und Semantik?
- Unterstützung durch Software-Tools?
- Welche Ausdrucksmittel werden benötigt?
- Komplexität der Implementierung? Performanz?
- Kompatibilität mit bestehenden Formaten wie OWL?
- Deklarativ (Beschreiben) oder operational (Programmieren)?
- ...
Welche Regelsprache
- klar definiert, umfassend erforscht, gut verstanden
- sehr gut kompatibel mit OWL DL und RDF
- ohne Einschränkungen nicht entscheidbar
- viele unabhängige Ansätze, oft nur vage definiert
- Verwendung oft wie Programmiersprachen, Beziehung zu OWL und RDF unklar
- effiziente Abarbeitung möglich
- klar definiert, aber viele unterschiedliche Ansätze
- teilweise kompatibel mit OWL und RDF
- Entscheidbarkeit/Komplexität stark vom gewählten Ansatz abhängig
Prädikatenlogik als Regelsprache
- Regeln als Implikationsformeln der Prädikatenlogik: \[\underbrace{A_1 \wedge A_2\wedge \ldots\wedge A_n}_{\textrm{Rumpf}} \to \underbrace{H_{}}_{\mathrm{Kopf}}\] → Semantisch äquivalent zu Disjunktion: \[ H\vee \neg A_1 \vee\neg A_2\vee \ldots\vee\neg A_n\]
- Konstanten, Variablen und Funktionssymbole erlaubt
-
Quantoren für Variablen werden oft weggelassen:
Variablen als universell quantifiziert verstanden (d.h. Regel gilt für alle Belegungen) -
Disjunktion mit mehreren nicht-negierten Atomen
→ disjunktive Regel: \[ \underbrace{A_1 \wedge A_2\wedge \ldots\wedge A_n}_{\textrm{Rumpf}} \to \underbrace{H_1 \vee H_2 \vee \ldots\vee H_m}_{\mathrm{Kopf}}\]
Arten von Regeln
Bezeichnungen für „Regeln“ der Prädikatenlogik:- Klausel: Disjunktion von atomaren Aussagen oder negierten atomaren Aussagen
- Hornklausel: Klausel mit höchstens einem nicht-negiertem Atom
- Definite Klausel: Klausel mit genau einem nicht negiertem Atom
- Fakt: Klausel aus einem einzigen nicht-negiertem Atom
- Klausel: \[\mathsf{Person}(x) \;\to\;\mathsf{Frau}(x) \vee \mathsf{Mann}(x)\]
- definite Klausel: \[\mathsf{Mann}(x) \wedge \mathsf{hatKind}(x,y) \;\to\;\mathsf{Vater}(x)\]
- Funktionsymbol: \[\mathsf{hatBruder}(\mathsf{mutter}(x),y) \;\to\;\mathsf{hatOnkel}(x,y)\]
- Hornklausel, "Integritätsbed": \[\mathsf{Mann}(x) \wedge \mathsf{Frau}(x) \;\to\;\]
- Fakt: \[\mathsf{Frau}(\mathsf{gisela})\]
Datalog
→ Datalog-Regeln
Datalog
- logische Regelsprache, ursprünglich Grundlage deduktiver Datenbanken
- Wissensbasen („Datalog-Programme“) aus Horn-Klauseln ohne Funktionssymbole
- entscheidbar
- effizient für große Datenmengen, Gesamtkomplexität wie OWL Lite (EXPTIME)
Semantik von Regeln
- Semantik weithin bekannt und gut verstanden
- mit anderen prädikatenlogischen Ansätzen kompatibel (z.B. Beschreibungslogik)
Semantik von Datalog
Semantik definiert über über logische Modelle:- Interpretation \(\mathcal{I}\) mit Domäne \(\Delta_{\mathcal{I}}\)
- Auswertung von Variablen: Variablenzuweisung \(\mathcal{Z}\) (Abbildung von Variablen auf \(\Delta_{\mathcal{I}}\))
- Interpretation von Formeln und Termen unter \(\mathcal{I}\) (und \(\mathcal{Z}\)):
- Interpretation einer Konstante: \(a^{\mathcal{I},\mathcal{Z}} = a^{\mathcal{I}} \in \Delta_{\mathcal{I}}\)
- Interpretation einer Variable: \(x^{\mathcal{I},\mathcal{Z}} =\mathcal{Z}(x) \in \Delta_{\mathcal{I}}\)
- Interpretation eines n-stelligen Prädikats: \(p^{\mathcal{I}} \in \Delta_{\mathcal{I}}^n\)
- \(\mathcal{I},\mathcal{Z}\models p(t_1,\ldots,t_n)\) genau dann wenn \((t_1^{\mathcal{I},\mathcal{Z}},\ldots,t_n^{\mathcal{I},\mathcal{Z}})\in p^{\mathcal{I}}\),
- \(\mathcal{I}\models B\to H\) genau dann wenn für jede Variablenzuweisung \(\mathcal{Z}\) gilt: entweder \(\mathcal{I},\mathcal{Z}\models H\) oder \(\mathcal{I},\mathcal{Z}\not\models B\).
- \(\mathcal{I}\) ist ein Modell für eine Regelmenge, wenn gilt: \(\mathcal{I}\models B\to H\) für alle Regeln \(B\to H\) dieser Menge
Datalog in der Praxis
Datalog in der Praxis:- verschiedene Implementierungen verfügbar
- Anpassungen für das Semantic Web: Datentypen aus XML Schema, URIs (z.B. IRIS)
- disjunktives Datalog erlaubt Disjunktionen in Köpfen
- nichtmonotone Negation (keine prädikatenlogische Semantik)
- Einbindung von Informationen aus OWL-Ontologien
(z.B. dl-programs, dlvhex)
→ lose Kopplung von OWL und Datalog (nicht über gemeinsame prädikatenlogische Semantik)
Wie kann man Datalog und OWL DL kombinieren?
SWRL – „Semantic Web Rule Language“
- Vorschlag einer OWL-Regelerweiterung
- Idee: Datalog-Regeln mit Bezug zu OWL-Ontologie
- Symbole in Regeln können OWL-Bezeichner sein, oder neue Datalog-Bezeichner
- Zusätzliche Built-Ins zur Verarbeitung von Datentypen
- mehrere syntaktische Darstellungen
Semantik von SWRL
OWL DL (Beschreibungslogik) und Datalog verwenden die gleichen Interpretationen:
- OWL-Individuen sind Datalog-Konstanten
- OWL-Klassen sind einstellige Datalog-Prädikate
- OWL-Rollen sind zweistellige Datalog-Prädikate
→ I kann gleichzeitig Modell sein für OWL-Ontologie und Menge von Datalog-Regeln
→ Schlussfolgerung über OWL-Datalog-Kombination möglich
Beispiel
Kombinierte SWRL-Wissensbasis (Datalog + Beschreibungslogik):
- Vegetarier(x) ∧ Fischprodukt(y) → magNicht(x,y)
- hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)
- hatBestellt(x,y) → Gericht(y)
- magNicht(x,z) ∧ Gericht(y) ∧ enthält(y,z) → magNicht(x,y)
- → Vegetarier(markus)
- Glücklich(x) ∧ Unglücklich(x) →
- ∃hatBestellt.ThaiCurry(markus)
- ThaiCurry ⊑ ∃enthält.Fischprodukt
magNicht(markus,ThaiCurry)
Unglücklich(markus)
Wie schwer ist SWRL
- Logisches Schließen in OWL DL ist NEXPTIME-vollständig.
- Logisches Schließen in OWL 2 DL ist 2NEXPTIME-vollständig.
- Logisches Schließen in Datalog ist EXPTIME-vollständig.
→ Wie schwer ist logisches Schließen in SWRL?
Logisches Schließen in SWRL ist unentscheidbar
(für OWL und damit auch für OWL 2).
Unentscheidbarkeit von SWRL
Es gibt keinen Algorithmus, mit dem man alle logischen Schlüsse aus allen SWRL-Wissensbasen ziehen kann, selbst wenn man beliebig (endlich) viel Rechenzeit und Speicher zur Verfügung hat.
Praktisch möglich dagegen sind:
- Algorithmen, die alle Schlüsse aus einem Teil der SWRL-Wissensbasen ziehen
- Algorithmen, die aus allen SWRL-Wissensbasen einen Teil der Schlüsse ziehen
Beides ist trivial möglich, wenn der entsprechende „Teil“ nur sehr klein ist.
Description Logic Rules
- Identifizierung dieser Description Logic Rules liefert ein entscheidbares Fragment von SWRL
- Ziel: „Versteckte“ Ausdrucksstärke von OWL 2 nutzen
- Implementierung direkt durch OWL-2-Tools
SROIQ (rot = zusätzlich zu SHOIN)
|
|
Rolleninklusion
\(R_1^{(-)}\circ\ldots \circ R_n^{(-)}\sqsubseteq R\)
Beispiel:
\(locatedIn \circ partOf \sqsubseteq locatedIn \)
Modellierungsaufgabe: Der Bruder der Mutter ist ein Onkel.
Rolleninklusion
\(R_1^{(-)}\circ\ldots \circ R_n^{(-)}\sqsubseteq R\)
Beispiel:
\(locatedIn \circ partOf \sqsubseteq locatedIn \)
Modellierungsaufgabe: Der Bruder der Mutter ist ein Onkel.
Lösung:
\(hatMutter \circ hatBruder \sqsubseteq hatOnkel \)
Self und Universelle Rolle
Beispiel Self:
\( \top \equiv \exists knows.Self \)
"Jeder kennt sich selbst."
Universelle Rolle: U
Analog zu \( \top \) bzw. owl:Thing bei Klassen.
Einfache Regeln mit SROIQ
- C \(\sqsubseteq\) D entspricht C(x) → D(x)
- R \(\sqsubseteq\) S entspricht R(x,y) → S(x,y)
-
Glücklich \(\sqcap\) Unglücklich \(\sqsubseteq\) ⊥
entspricht
Glücklich(x) ∧ Unglücklich(x) → -
∃wohnort.∃liegtIn.EULand \(\sqsubseteq\) EUBürger
entspricht
wohnort(x,y) ∧ liegtIn(y,z) ∧ EULand(z) → EUBürger(x)
-
hatMutter ◦ hatBruder \(\sqsubseteq\) hatOnkel
entspricht
hatMutter(x,y) ∧ hatBruder(y,z) → hatOnkel(x,z)
Noch mehr Regeln
- Regelkopf mit zwei Variablen → nicht durch Subklassen-Axiom darstellbar
- Regelrumpf enthält Klassenausdrücke → nicht durch Subproperty-Axiom darstellbar
Trotzdem ist diese Regel in OWL 2 darstellbar!
Noch mehr Regeln (II)
- Hilfsrolle R Mann
- Hilfsaxiom Mann ≡ ∃R Mann .Self
- Intuition: „Männer sind genau die Dinge, die ein R Mann -Beziehung zu sich selbst haben.“
Noch mehr Regeln (III)
magNicht(x,z) ∧ Gericht(y) ∧ enthält(y,z) → magNicht(x,y)
\[Gericht \equiv \exists R_{Gericht}.\mathsf{Self}\]
\[magNicht \circ enthält^{-} \circ R_{Gericht} \sqsubseteq magNicht\]
Noch mehr Regeln (IV)
Vegetarier(x) ∧ Fischprodukt(y) → magNicht(x,y)
- Hilfsrollen R Vegetarier und R Fischprodukt
- Hilfsaxiome Vegetarier ≡ ∃R Vegetarier .Self und Fischprodukt ≡ ∃R Fischprodukt .Self
Die Grenzen von Description Logic Rules
hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)
-
Rollen umkehren, z.B.
enthält(y,z) → enthält − (z,y)
-
Seitenarme „aufrollen“, z.B.
liegtIn(y,z) ∧ EULand(z) → ∃liegtIn.EULand(y)
-
Konzepte durch Rollen ersetzen, z.B.
Mann(x) → R Mann (x,x)
- Ketten in Rolleninklusionen umwandeln (∧ durch ◦ ersetzen)
Description Logic Rules: Definition
Vorbereitung: Regel normalisieren-
Für jedes
Vorkommen
(!) einer Konstante a der Regel:
Füge im Rumpf {a}(x) mit einer neuen Variable x ein und ersetze das Vorkommen von a durch x. - Ersetze jedes Atom R(x,x) durch ∃R.Self(x).
- Knoten = Variablen der Regel
- Kanten = Rollenatome des Regelrumpfes (ohne Richtung!)
- alle Regelatome verwenden SROIQ-Konzepte und -Rollen,
- der Abhängigkeitsgraph der normalisierten Regel hat keine Zyklen
Beispiel
-
(1) Vegetarier(x) ∧ Fischprodukt(y) → magNicht(x,y)
-
(3) hatBestellt(x,y) → Gericht(y)
-
(4) magNicht(x,z) ∧ Gericht(y) ∧ enthält(y,z) → magNicht(x,y)
-
(5) → Vegetarier(markus)
-
(6) Glücklich(x) ∧ Unglücklich(x) →
hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)
ist keine DL Rule
Umwandlung von DL Rules nach SROIQ (I)
- Normalisiere die Regel.
-
Für jedes Paar von Variablen
x
undy
:
Sindx
undy
im Abhängigkeitsgraph nicht verbunden, d.h. es gibt keinen Pfad zwischenx
undy
, dann füge im RumpfU(x,y)
ein. -
Der Regelkopf hat nun die Form
D(z)
oderS(z,z')
.
Für jedes AtomR(x,y)
im Rumpf:
Falls im Abhängigkeitsgraph der Pfad vonz
nachy
kürzer ist als der vonz
nachx
, so ersetzeR(x,y)
mitR − (y,x)
. -
Falls im Rumpf ein Atom
R(x,y)
vorkommt, so dassy
in keinem anderen zweistelligen Atom der Regel auftritt:-
Wenn der Rumpf
n
einstellige AtomeC 1 (y),...,C n (y)
enthält, dann definiere \(E:=C_1\sqcap\ldots\sqcap C_n\) und entferneC 1 (y),...,C n (y)
aus dem Rumpf. Andernfalls definiere \(E:=\top\). -
Ersetze
R(x,y)
durch∃R.E(x)
.
R(x,y)
gibt. -
Wenn der Rumpf
Umwandlung von DL Rules nach SROIQ (II)
-
Falls der Regelkopf einstellig ist, dann hat die Regel die Form
C 1 (x) ∧ ... ∧ C n (x) → D(x)
.
Ersetze sie durch \(C_1\sqcap\ldots\sqcap C_n\sqsubseteq D\). -
Falls der Regelkopf zweistellig ist, dann
-
Für jedes einstellige
Atom C(z)
im Rumpf:
Erzeuge ein neues AxiomC ≡ ∃R C .Self
(die RolleR C
ist neu)
und ersetzeC(z)
durchR C (z,z)
. -
Die Regel hat nun die Form
R 1 (x,x 2 ) ∧ ... ∧ R n (x n ,y) → S(x,y)
.
Ersetze sie durch \(R_1\circ\ldots\circ R_n\sqsubseteq S\).
-
Für jedes einstellige
Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:arbeitetIn(w,x) ∧ anstellung(w,FEST) ∧ Uni(x) ∧ Doktorand(y) ∧ betreutVon(y,w) → professorVon(w,y)Nächster Schritt:
Normalisiere die Regel.
-
Für jedes
Vorkommen
einer Konstante a der Regel:
Füge im Rumpf {a}(x) mit einer neuen Variable x ein und ersetze das Vorkommen von a durch x. - Ersetze jedes Atom R(x,x) durch ∃R.Self(x).
Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:arbeitetIn(w,x) ∧ anstellung(w,z) ∧ {FEST}(z) ∧ Uni(x) ∧ Doktorand(y) ∧ betreutVon(y,w) → professorVon(w,y)Nächster Schritt:
Konstruiere den Abhängigkeitsgraph:
Ungerichteter Graph mit
- Knoten = Variablen der Regel
- Kanten = Rollenatome des Regelrumpfes (ohne Richtung!)
Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:arbeitetIn(w,x) ∧ anstellung(w,z) ∧ {FEST}(z) ∧ Uni(x) ∧ Doktorand(y) ∧ betreutVon(y,w) → professorVon(w,y)Nächster Schritt:
Für jedes Paar von Variablen
x
und
y
: Sind
x
und
y
im
Abhängigkeitsgraph nicht verbunden, d.h. es gibt keinen Pfad
zwischen
x
und
y
, dann füge im Rumpf
U(x,y)
ein.
Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:arbeitetIn(w,x) ∧ anstellung(w,z) ∧ {FEST}(z) ∧ Uni(x) ∧ Doktorand(y) ∧ betreutVon(y,w) → professorVon(w,y)Nächster Schritt:
Der Regelkopf hat nun die Form
D(z)
oder
S(z,z0)
. Für jedes Atom
R(x,y)
im Rumpf: Falls im Abhängigkeitsgraph der Pfad von
z
nach
y
kürzer ist als der von
z
nach
x
, so ersetze
R(x,y)
mit
R
−
(y,x)
.Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:arbeitetIn(w,x) ∧ anstellung(w,z) ∧ {FEST}(z) ∧ Uni(x) ∧ Doktorand(y) ∧ betreutVon–(w,y) → professorVon(w,y)Nächster Schritt:
Falls im Rumpf ein Atom R(x,y) vorkommt, so dass y in keinem anderen zweistelligen Atom der Regel auftritt:
-
Wenn der Rumpf n einstellige Atome
C 1 (y),...,C n (y)
enthält, dann definiere \(E:=C_1\sqcap\ldots\sqcap C_n\) und entferneC 1 (y),...,C n (y)
aus dem Rumpf. Andernfalls definiere \(E := \top\). -
Ersetze
R(x,y)
durch∃R.E(x)
.
R(x,y)
gibt.Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:∃arbeitetIn.Uni(w) ∧ ∃anstellung.{FEST}(w) ∧ Doktorand(y) ∧ betreutVon–(w,y) → professorVon(w,y)Nächster Schritt:
Für jedes einstellige Atom
C(z)
im Rumpf:
Erzeuge ein neues Axiom
C ≡ ∃R
C
.Self
(die Rolle
R
C
ist neu) und
ersetze
C(z)
durch
R
C
(z,z)
.Übung
Konvertieren Sie folgende Regel in SROIQ-Axiome:∃R1.Self ≡ ∃arbeitetIn.Uni ∃R2.Self ≡ ∃anstellung.{FEST} ∃R3.Self ≡ Doktorand R1(w,w) ∧ R2(w,w) ∧ R3(y,y) ∧ betreutVon−(w,y) → professorVon(w,y)Nächster Schritt:
Die Regel hat nun die Form
R1(x,x2) ∧ ... ∧ Rn(xn,y) → S(x,y)
.
Ersetze sie durch \(R_1\circ\ldots\circ R_n\sqsubseteq S\).
Übung: Lösung
\[ \exists R_1.Self \equiv \exists arbeitetIn.Uni \] \[ \exists R_2.Self \equiv \exists anstellung . \{ FEST \} \] \[ \exists R_3.Self \equiv Doktorand \]\[ R_1 \circ R_2 \circ betreutVon^{-} \circ R_3 \sqsubseteq professorVon \]
Rule Interchange Format (RIF)
- engl.: Rule Interchange Format (RIF)
- am 22. Juni 2010 als W3C-Standard verabschiedet
- Fokus liegt auf dem Austausch von Regeln – nicht ein Format für alle Regelsprachen
- einzelne Sprache kann nicht verschiedene Paradigmen und Bedürfnisse für Regelbenutzungen erfüllen
- Familie von Sprachen, die Dialekte (dialects) genannt werden
- RIF ist einheitlich (uniform) und erweiterbar (extensible)
RIF Dialekte
Konzentration auf zwei Arten von Dialekten:
- logikbasiert (z.B. Prädikatenlogik, Logikprogrammierung)
-
“rules with actions” (z.B. Produktionsregeln)
RIF bietet Framework zur Definition eigener Dialekte
RIF mit RDF und OWL kompatibel:
- kann semantisch kombiniert werden mit OWL/RDF
- RDF-Syntax für RIF vorhanden
RIF Dokumente
|
||
Dokument
|
Beschreibung
|
|
RIF-BLD:
The Basic Logic Dialect |
definite Hornklauseln,
Standard-Prädikatenlogik-Semantik
|
|
RIF-PRD:
The Production Rule Dialect |
deckt Vielzahl von Produktionsregelsystemen ab
|
|
RIF-Core:
The Core Dialect |
ermöglicht
Regelaustausch
zwischen Systemen mit Logikregeln
und Produktionsregeln
|
|
RIF-FLD:
The Framework for Logic Dialect |
logisches
Erweiterungsframework
um Anstrengungen zu minimieren
neue Logikdialekte zu definieren
|
|
RIF-RDF+OWL:
RDF und OWL Kompatibilität |
Kombination von RIF mit RDF oder
OWL
|
|
RIF-DTB:
Datatypes und Build-ins |
enthält Datentypen, Funktionen und
Prädikate für RIF-Dialekte
|
|
RIF+XML-Data:
|
spezifiziert, wie RIF mit XML Datenquellen kombiniert werden kann (Import, Semantik)
|
|
RIF-OWLRL:
OWL 2 RL in RIF |
Axiomatisierung von OWL 2 RL in
RIF
|
|
RIF in RDF
|
umkehrbares Mapping von RIF auf
RDF
|
|
RIF-UCR:
Use Cases and requirements |
Sammlung von Anwendungsfällen
|
|
RIF-Test:
Test Cases |
Konformitätstests
für
RIF-Implementierungen
|
RIF Core
ist der einfachste RIF Dialekt
Ein Core Dokument besteht aus
- Direktiven wie Import Prefixeinstellung für URIs
- eine Sequenz von logischen Schlussfolgerungen
RIF Core Beispiel
Document( Prefix(cpt http://example.com/concepts#) Prefix(person http://example.com/people#) Prefix(isbn http://.../isbn/) Group ( Forall ?Buyer ?Book ?Seller ( cpt:buy(?Buyer ?Book ?Seller ):− cpt:sell(?Seller ?Book ?Buyer) ) cpt:sell(person:John isbn:000651409X person:Mary) ) )Daraus lässt sich folgende Beziehung ableiten:
cpt:buy(person:Mary isbn:00065409X person:John)
Ausdrucksstärke von RIF Core
- Datalog als Basis
- enthält Schnittmenge von RIF-BLD (Basic Logic Dialect) und RIF-PRD (Production Rule Dialect)
- einige Erweiterungen: Datentypen (RIF-DTB), IRIs
- Forward-Chaining möglich
Kombination von RDF + RIF
Typisches Szenario:
- die Daten der Anwendung sind in RDF verfügbar
- die Regeln für die Daten werden durch RIF beschrieben
- ein RIF Prozessor erzeugt neue Beziehungen
RDF + RIF kompatibel:
- RDF Triples sind in RIF Repräsentierbar
Beispiel in Turtle-basierter Syntax
{ ?x rdf:type p:Novel ; p:page_number ?n ; p: price [ p:currency :Euro ; rdf:value ?z ] . ?n > "500" ^^xsd:integer . ?z < " 20.0 " ^^xsd:double . } => { <me> p:buys ?x }

Das Gleiche mit RIF Präsentationssyntax
Document ( Prefix ... Group ( Forall ?x ?n ?z ( <me> [p:buys−>?x ] :− And ( ?x rdf:type p:Novel ?x[p:page_number−>?n p:price−>_abc] _abc [p:currency−>:Euro rdf:value−>?z] External(pred:numeric−greater−than(?n "500"^^xsd:integer)) External(pred:numeric−less−than(?z "20.0"^^xsd:double)) ) ) ) )
Neue Beziehungen entdecken...
Forall ?x ?n ?z (in Kombination mit:[p:buys−>?x] :− And( ?x rdf:type p:Novel ?x[p:page_number−>?n p:price−>_abc] _abc[p:currency −>:Euro rdf:value−>?z ] External(pred:numeric−greater−than(?n "500"^^xsd:integer)) External(pred:numeric−less−than(?z "20.0"^^xsd:double)) ) )
<http://.../isbn/...> a p:Novel ; p:page_number "600"^^xsd:integer ; p: price [ rdf:value "15.0"^^xsd:double ; p:currency :Euro ] .führt zu:
<me> p:buys <http://...isbn/...> .
Was ist mit OWL 2 RL?
OWL 2 RL steht für OWL Rule Language
OWL 2 RL ist die Schnittmenge von RIF Core und OWL
- Folgerungen in OWL RL können mit RIF Regeln ausgedrückt werden
- RIF Core engines können sich wie OWL RL engines verhalten
- wie beschrieben im Dokument RIF-OWLRL kann OWL 2 RL direkt in RIF verarbeitet werden
Ausblick: Kombination von SPARQL 1.1 und RIF

Zusammenfassung
Prädikatenlogische Regelerweiterungen für OWL DL
- Datalog als gut bekannter Formalismus
- Kombination mit OWL möglich: SWRL
- Semantik durch Erweiterung beschreibungslogischer Interpretation von OWL
- SWRL ist unentscheidbar
Description Logic Rules
- in OWL 2 ausdrückbares SWRL-Fragment
- indirekte Unterstützung durch alle OWL-2-Tools
- Definition und Algorithmus basieren auf Abhängigkeitsgraph
RIF (Rule Interchange Format)
- W3C-Standard zum Austausch von Regeln
- erweiterbare Familie von Sprachen
Auch relevant:
- SPARQL 1.1 Entailment Regimes
- konjunktive Anfragen für OWL-DL
- DL-safe rules (Variablen können nur Konstanten als Werte annehmen)
Miniprojekt
Literatur
- Semantic Web Grundlagen Springer 2008, 277 S., Softcover ISBN: 978-3-540-33993-9
- Ivan Herman “Introduction to Semantic Web Technologies” (2010 Semantic Technology Conference)
- W3C-Spezifikationsseiten z.B. zu RIF