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

  1. Vegetarier(x) ∧ Fischprodukt(y) → magNicht(x,y)
  2. hatBestellt(x,y) ∧ magNicht(x,y) → Unglücklich(x)
  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) →
  7. ∃hatBestellt.ThaiCurry(markus)
  8. 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:

  1. Algorithmen, die alle Schlüsse aus einem Teil der  SWRL-Wissensbasen ziehen
  2. 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:
  1. alle Regelatome verwenden SROIQ-Konzepte und -Rollen,
  2. 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
  1. Normalisiere die Regel.
  2. 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.
  3. 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) .
  4. 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 entferne C 1 (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 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 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 1 (x,x 2 ) ∧ ... ∧ 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 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 entferne C 1 (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:
∃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:

  1. logikbasiert (z.B. Prädikatenlogik, Logikprogrammierung)
  2. “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