SlideWiki | Regeln im Semantic Web

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

Relevante Informationen nicht in OWL-Ontologie darstellbar:

\((\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 ungeeignet zur Programmierung:

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

Regelsprachen sind untereinander kaum kompatibel!

→ Wahl der geeigneten Regelsprache sehr wichtig

Mögliche Kriterien:

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

Logische Regeln (Implikationen in Prädikatenlogik):

klar definiert, umfassend erforscht, gut verstanden
sehr gut kompatibel mit OWL DL und RDF
ohne Einschränkungen nicht entscheidbar

Prozedurale Regeln (z.B. Production Rules):

viele unabhängige Ansätze, oft nur vage definiert
Verwendung oft wie Programmiersprachen, Beziehung zu OWL und RDF unklar
effiziente Abarbeitung möglich

Logikprogrammierung (z.B. Prolog, F-Logik):

klar definiert, aber viele unterschiedliche Ansätze
teilweise kompatibel mit OWL und RDF
Entscheidbarkeit/Komplexität stark vom gewählten Ansatz abhängig

Schwerpunkt dieser Vorlesung: prädikatenlogische Regeln

(die aber auch die Grundlage der Logikprogrammierung sind)

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

Beispiele:

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

Einschränkung auf Horn-Regeln ohne Funktionssymbole

→ 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

Standardsemantik der Prädikatenlogik!

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)

Erweiterungen von Datalog:

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

Wir können folgern:

Gericht(ThaiCurry)
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

SWRL ist unentscheidbar

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

Beobachtung

Manche SWRL-Regeln lassen sich bereits in OWL 2 (also der Beschreibungslogik SROIQ) ausdrücken.

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)

Klassenausdrücke
Klassennamen	A, B
Konjunktion	C \(\sqcap\) D
Disjunktion	C \(\sqcup\) D
Negation	¬C
Exist. Rollenrestr.	∃R.C
Univ. Rollenrestr.	∀R.C
Self	∃S.Self
Größer-als	≥n S.C
Kleiner-als	≤n S.C
Nominale	{a}
Rollen
Rollennamen	R, S, T
einfache Rollen	S, T
Inverse Rollen	R⁻
Universelle Rolle	U

Tbox (Klassenaxiome)
Inklusion	C \(\sqsubseteq\) D
Äquivalenz	C ≡ D
Rbox (Rollenaxiome)
Inklusion	R1 \(\sqsubseteq\) R2
Allgem. Inkl.	\(R_1^{(-)}\circ\ldots \circ R_n^{(-)}\sqsubseteq R\) R
Transitivität	Tra(R)
Symmetrie	Sym(R)
Reflexivität	Ref(R)
Irreflexivität	Irr(S)
Disjunktheit	Dis(S,T)
Abox (Fakten)
Klassenzugehörigkeit	C(a)
Rollenbeziehung	R(a,b)
Neg. Rollenbeziehung	¬S(a,b)
Gleichheit	a ≈ b
Ungleichheit	a \(\not\approx\) b

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

Alle SROIQ-Axiome können als SWRL-Regeln geschrieben werden:

C \(\sqsubseteq\) D entspricht C(x) → D(x)
R \(\sqsubseteq\) S entspricht R(x,y) → S(x,y)

Einige Klassen können innerhalb von Regeln „zerlegt“ werden:

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)

SROIQ-Rollenaxiome liefern weitere Regeln:

hatMutter ◦ hatBruder \(\sqsubseteq\) hatOnkel
entspricht
hatMutter(x,y) ∧ hatBruder(y,z) → hatOnkel(x,z)

Noch mehr Regeln

Was ist mit

  magNicht(x,z) ∧ Gericht(y) ∧ enthält(y,z) → magNicht(x,y)?

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)

Einfacheres Beispiel: Mann(x) ∧ hatKind(x,y) → vaterVon(x,y)

Idee

Ersetze Mann(x) durch ein Rollen-Atom, so dass die Regel als allgemeine Rolleninklusion mit ◦ darstellbar wird.

Trick: mit ∃R.Self kann man Klassen in Rollen umwandeln:

Hilfsrolle R _Mann
Hilfsaxiom Mann ≡ ∃R _Mann .Self
Intuition: „Männer sind genau die Dinge, die ein R _Mann -Beziehung zu sich selbst haben.“

Mit diesem Hilfsaxiom kann die Regel geschrieben werden als:

R _Mann ◦ hatKind \(\sqsubseteq\) vaterVon

Noch mehr Regeln (III)

Beispiel:

magNicht(x,z) ∧ Gericht(y) ∧ enthält(y,z) → magNicht(x,y)

wird zu

\[Gericht \equiv \exists R_{Gericht}.\mathsf{Self}\]

\[magNicht \circ enthält^{-} \circ R_{Gericht} \sqsubseteq magNicht\]

Noch mehr Regeln (IV)

Nicht so einfach:

Vegetarier(x) ∧ Fischprodukt(y) → magNicht(x,y)

Idee

Verbinde unzusammenhängende Teile im Regelrumpf durch die universelle Rolle U.

Hilfsrollen R _Vegetarier und R _Fischprodukt
Hilfsaxiome Vegetarier ≡ ∃R _Vegetarier .Self und Fischprodukt ≡ ∃R _Fischprodukt .Self

Mit diesen Hilfsaxiomen kann die Regel geschrieben werden als:

\[R_{Vegetarier} \circ U \circ R_{Fischprodukt} \sqsubseteq magNicht\]

Die Grenzen von Description Logic Rules

Nicht alle SWRL-Regeln können so dargestellt werden!

Beispiel:

hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)

ist nicht in SROIQ darstellbar.

Mögliche Umwandlungen im Regelrumpf im Überblick

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

Abhängigkeitsgraph einer Regel: Ungerichteter Graph mit

Knoten = Variablen der Regel
Kanten = Rollenatome des Regelrumpfes (ohne Richtung!)

Eine SWRL-Regel ist eine Description Logic Rule wenn gilt:

alle Regelatome verwenden SROIQ-Konzepte und -Rollen,
der Abhängigkeitsgraph der normalisierten Regel hat keine Zyklen

Beispiel

DL Rules in der früheren SWRL-Wissensbasis:


  
    
      (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) →

Regel (2)


    hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)

ist keine DL Rule

Anmerkung: Description Logic Rules müssen nach Umwandlung in SROIQ natürlich auch die Bedingungen an einfache Rollen und reguläre RBoxen erfüllen!

Umwandlung von DL Rules nach SROIQ (I)

Eingabe: Eine Description Logic Rule

Normalisiere die Regel.
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.
Der Regelkopf hat nun die Form D(z) oder S(z,z') .
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) .
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 ₁ (y),...,C _n (y) enthält, dann definiere \(E:=C_1\sqcap\ldots\sqcap C_n\) und entferne C ₁ (y),...,C _n (y) aus dem Rumpf. Andernfalls definiere \(E:=\top\).
- Ersetze R(x,y) durch ∃R.E(x) .
Wiederhole Schritt 4 solange es solche R(x,y) gibt.

Umwandlung von DL Rules nach SROIQ (II)

Die Regel kann jetzt in SROIQ ausgedrückt werden:

Falls der Regelkopf einstellig ist, dann hat die Regel die Form
C ₁ (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 Axiom C ≡ ∃R _C .Self (die Rolle R _C ist neu)
  und ersetze C(z) durch R _C (z,z) .
- Die Regel hat nun die Form
  R ₁ (x,x ₂ ) ∧ ... ∧ R _n (x _n ,y) → S(x,y) .
  Ersetze sie durch \(R_1\circ\ldots\circ R_n\sqsubseteq S\).

Diese Umformung von Regeln einer SWRL-Wissensbasis verändert ihre Erfüllbarkeit nicht.

Ü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

und

: Sind

und

im Abhängigkeitsgraph nicht verbunden, d.h. es gibt keinen Pfad zwischen

und

, 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

nach

kürzer ist als der von

nach

, 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 ₁ (y),...,C _n (y) enthält, dann definiere \(E:=C_1\sqcap\ldots\sqcap C_n\) und entferne C ₁ (y),...,C _n (y) aus dem Rumpf. Andernfalls definiere \(E := \top\).
Ersetze R(x,y) durch ∃R.E(x) .

Wiederhole Schritt 4 solange es solche


  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:

∃R₁.Self ≡ ∃arbeitetIn.Uni
∃R₂.Self ≡ ∃anstellung.{FEST}
∃R₃.Self ≡ Doktorand

R₁(w,w) ∧ R₂(w,w) ∧ R₃(y,y) ∧ betreutVon⁻(w,y) → professorVon(w,y)

Nächster Schritt:
Die Regel hat nun die Form R₁(x,x₂) ∧ ... ∧ R_n(x_n,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 (
  [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))
  )
)

in Kombination mit:

<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