[Semantic Web Technologies] Lösungen zu den OWL Aufgaben

Hallo zusammen, stelle euch hier mal ein paar Lösungen zu den OWL Aufgaben aus Blatt 3 ein.

Übung 4

a) Modellieren Sie die folgenden Sätze in OWL DL indem Sie Ausschnitte aus entsprechenden
OWL-Dokumenten in RDF/XML oder Turtle-Syntax angeben:

Die Klasse Gemüse ist eine Unterklasse von PizzaBelag.

Gemüse ⊑ PizzaBelag
ex:Gemüse rdfs:subClassOf ex:Pizza .
<owl:Class rdf:ID="Gemüse">
   <rdfs:subClassOf rdf:resource="Pizza" />
</owl:Class>

Die Klasse PizzaBelag hat keine gemeinsamen Elemente mit der Klasse Pizza.

PizzaBelag ⊓ Pizza ≡ ⊥
ex:PizzaBelag owl:disjointWith ex:Pizza .
<owl:Class rdf:ID="PizzaBelag">
   <owl:disjointWith rdf:resource="Pizza" />
</owl:Class>

Das Individuum Aubergine ist ein Element der Klasse Gemüse.

Gemüse( Aubergine )
Aubergine a Gemüse .
<Gemüse rdf:ID="Aubergine" />

Die abstrakte Rolle hatBelag besteht ausschließlich zwischen Elementen der Klasse Pizza
und der Klasse PizzaBelag.

∃hatBelag.⊤ ⊑ Pizza
⊤ ⊑ ∀hatBelag.PizzaBelag
hatBelag a owl:ObjectProperty;
         rdfs:domain Pizza;
         rdfs:range  PizzaBelag.
<owl:ObjectProperty rdf:ID="hatBelag">
   <rdfs:domain rdf:resource="Pizza" />
   <rdfs:range  rdf:resource="PizzaBelag" />
</owl:ObjectProperty>

Pizzen haben immer mindestens zwei Beläge.

Pizza ⊑ ≥2 hatBelag
Pizza    a owl:Class;
         rdfs:subClassOf _:bNode1.
_:bNode1 a owl:Restriction;
         owl:onProperty hatBelag;
         owl:minCardinality "2"^^xsd:nonNegativeInteger.

ODER einfacher:

Pizza  a owl:Class;
       rdfs:subClassOf [  a owl:Restriction;
                          owl:onProperty hatBelag;
                          owl:minCardinality "2"^^xsd:nonNegativeInteger ] .
<owl:Class rdf:ID="Pizza">
   <rdfs:subClassOf>
      <owl:Restriction>
         <owl:onProperty rdf:resource="hatBelag" />
         <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">
            2
         </owl:minCardinality>
      </owl:Restriction>
   </rdfs:subClassOf>
</owl:Class>

Jede Pizza der Klasse PizzaMargarita hat Tomate als Belag.

PizzaMargarita ⊑ ∃hatBelag.Tomate
PizzaMargarita a owl:Class
               rdfs:subClassOf [ a owl:Restriction;
                                 owl:onProperty hatBelag;
                                 owl:someValuesFrom Tomate ] .
<owl:Class rdf:ID="PizzaMargarita">
   <rdfs:subClassOf>
      <owl:Restriction>
         <owl:onProperty rdf:resource="hatBelag">
         <owl:someValuesFrom rdf:resource="Tomate">
      </owl:Restriction>
   </rdfs:subClassOf>
</owl:Class>

Die Klasse Vegetarische Pizza besteht aus den Elementen, die sowohl in der Klasse
PizzaOhneFleisch als auch in der Klasse PizzaOhneFisch sind.

VegetarianPizza ⊑ PizzaOhneFleisch ⊓ PizzaOhneFisch

VegetarianPizza a owl:Class
                owl:intersectionOf ( PizzaOhneFleisch
                                     PizzaOhneFisch ).
<owl:Class rdf:ID="VegetarianPizza">
   <owl:intersectionOf rdf:parseType="Collection">
      <owl:Class rdf:about="#PizzaOhneFleisch" />
      <owl:Class rdf:about="#PizzaOhneFisch" />
   </owl:intersectionOf>
</owl:Class>

Keine Pizza der Klasse PizzaMargarita hat Belag aus der Klasse Fleisch.

PizzaMargarita ⊑ ¬(∃hatBelag.Fleisch)
PizzaMargarita a owl:Class;
               rdfs:subClassOf [ a owl:Class
                                 owl:complementOf [ a owl:Restriction;
                                                    owl:onProperty hatBelag;
                                                    owl:someValuesFrom Fleisch ] . ] .
<owl:Class rdf:ID=PizzaMargarita>
   <owl:complementOf>
      <owl:Restriction>
         <owl:onProperty rdf:resource="hatBelag" />
         <owl:someValuesFrom rdf:resource="Fleisch" />
      </owl:Restriction>
   </owl:complementOf>
</owl:Class>

b) Entscheiden Sie, ob die folgenden Aussagen im Zusammenhang mit der Pizza-Ontologie aus a) sinnvoll wären:

  • Die Rolle hatZutat ist transitiv.

Ist sinnvoll. Damit wird die Zutat einer Zutat auch eine Zutat der Pizza usw.

  • Die Rolle hatBelag ist funktional.

Nicht sinnvoll. Sonst hätte jede Pizza nur genau einen einzigen Belag.

  • Die Rolle hatBelag ist invers funktional.

Ist sinnvoll. Ein ganz konkreter Belag (etwa genau diese eine Scheibe Salami ) darf damit jeweils nur auf einer Pizza auftreten.

Übung 5

a) Es soll das Konzept vegetarische Pizza definiert werden. Welche der folgenden Definitionen ist dafür angemessen? Geben Sie dazu jeweils eine natürlichsprachliche Beschreibung der logischen Formeln an.

(a) VegetarischePizza ≡ Pizza ⊓ ¬∃hatZutat.(Fleisch ⊓ Fisch)

Eine VegetarischePizza ist das gleiche wie eine Pizza, die keine Zutat enthält, die Fisch und gleichzeitig Fleisch ist

(b) VegetarischePizza ≡ Pizza ⊓ ∀hatBelag.(¬Fleisch ⊔ ¬Fisch)

Eine VegetarischePizza ist das gleiche wie eine Pizza, bei der alle Beläge entweder nicht Fleisch oder nicht Fisch sind.

(c) VegetarischePizza ≡ Pizza ⊓ ¬∃ hatBelag.Fleisch ⊓ ¬∃ hatBelag.Fisch

Eine VegetarischePizza ist das gleiche wie eine Pizza, die keinen Fleischbelag und keinen Fischbelag hat.

(d) VegetarischePizza ≡ Pizza ⊓ ∃ hatBelag.¬Fleisch ⊓ ∃ hatBelag.¬Fisch

Eine VegetarischePizza ist das gleiche wie eine Pizza, die einen Belag hat, der nicht Fleisch ist und einen Belag hat, der nicht Fisch ist.

(e) VegetarischePizza ≡ Pizza ⊓ ∀hatZutat.(¬Fleisch ⊓ ¬Fisch)

Eine VegetarischePizza ist das gleiche wie eine Pizza, bei der bei jeder Zutat gilt, dass diese weder Fleisch noch Fisch ist.

– Nur die Definitionen (c) und (e) passen.

b) Gegeben sei folgende Ontologie in DL-Syntax:

hatBelag ⊑ hatZutat     ∃hatBelag.⊤ ⊑ Pizza   ⊤ ⊑ ∀hatBelag.PizzaBelag
Gemüse ⊓ Käse ⊑ ⊥       Käse ⊓ Fleisch ⊑ ⊥
Gemüse ⊓ Fleisch ⊑ ⊥    Käse ⊓ Fisch ⊑ ⊥
Gemüse ⊓ Fisch ⊑ ⊥      Fleisch ⊓ Fisch ⊑ ⊥

Betrachten Sie nun zusätzlich die folgenden Klassendefinitionen:

KäsePizza       ≡ Pizza ⊓ ∃hatBelag.Käse
PizzaSpinat     ≡ ∃hatBelag.Spinat ⊓ ∃hatBelag.Käse ⊓
                  ∀hatBelag.(Spinat ⊔ Käse)
PizzaCarnivorus ≡ Pizza ⊓ ∀hatBelag.(Fleisch ⊓ Fisch)
LeerePizza      ≡ Pizza ⊓ ¬∃hatBelag.⊤

(1) Welche der oben aufgeführten Klassen von Pizzas würde durch einen DL-Reasoner als
Unterklasse von VegetarischePizza (gemäß einer korrekten Definition aus a ) erkannt?
Begründen Sie jeweils Ihre Entscheidung.

  • KäsePizza → NEIN, da nicht ausschließlich Käse als Belag
  • PizzaSpinat → NEIN, da die Ontologie nicht aussagt, dass Spinat ein Gemüse ist. Damit könnte Spinat z.B. auch ein Fleisch oder Fisch sein.
  • PizzaCarnivorus → JA, Fleisch und Fisch haben keine gemeinsamen Elemente
  • LeerePizza → JA, da sie keinen Belag hat und somit natürlich auch keinen Fleisch/Fischhaltigen

(2) Die Klassifikation unter (1) zeigt, dass einige der Pizzaklassen nicht das gewünschte
Konzept modellieren. Wie könnte man ihre Definition korrigieren?

  • KäsePizza → Man könnte noch anfügen  „⊓ ∀hatBelag.Käse“ damit wäre nur Käse auf dieser Pizza zugelassen
  • PizzaSpinat → Erweiterung Ontologie um „Spinat ⊑ Gemüse“
  • PizzaCarnivorus → Pizza ⊓ ∀hatBelag.(Fleisch ⊓ Fisch) ⊓ ∃hatBelag.⊤

(3) Wie würde sich das unter (1) ermittelte Ergebnis verändern, wenn man bei der Definition
von VegetarischePizza anstelle von ≡ nur ⊑ verwenden würde?

Verändertes Axiom:

VegetarischePizza ⊑ Pizza ⊓ ∀hatZutat.(¬Fleisch ⊓ ¬Fisch)

Es gilt weiterhin (mit obigen Korrekturen):

KäsePizza ⊑ Pizza ⊓ ∀hatZutat.(¬Fleisch ⊓ ¬Fisch)
...

aber daraus folgt nicht

KäsePizza ⊑ VegetarischePizza

denn dazu würde man das folgende Axiom benötigen:

Pizza ⊓ ∀hatZutat.(¬Fleisch ⊓ ¬Fisch) ⊑ VegetarischePizza

Es würde also keine Klasse mehr als Unterklasse von VegetarischePizza klassifiziert werden.

Übung 6

Gegeben seien die Individuennamen bonny und clyde, die Klassennamen Ehrlich, Klug, Verbrechen und Mensch sowie die Rollennamen verübt, verheiratetMit, und verdächtigt.

Welche der folgenden Aussagen können in OWL 1 DL gemacht werden, welche in OWL 2 DL und
welche überhaupt nicht? Geben Sie gegebenenfalls die entsprechenden Axiome an.

1. Jeder, der ehrlich ist und ein Verbrechen verübt hat, zeigt sich selbst an.

Ehrlich ⊓∃verübt.Verbrechen ⊑∃zeigtAn.Self

Self ist in OWL 1 noch nicht vorhanden

2. Wer klug und ehrlich ist, verübt kein Verbrechen.

Klug ⊓ Ehrlich  ⊑ ¬∃verübt.Verbrechen

Kann mit OWL 1 modelliert werden

3. Bonnie zeigt Clyde nicht an.

¬zeigtAn( bonny, clyde )

Negation von Rollen in OWL 1 noch nicht vorhanden

4. Niemand zeigt einen Menschen an, mit dem gemeinsam er ein Verbrechen verübt hat.

zeigtAn.(∃verübt.(Verbrechen ⊓ ∃verübt¯)) ⊑ ⊥

Das geht wohl so nicht. Wir kommen nicht mehr an denjenigen heran, mit dem das Verbrechen verübt wurde.

5. Clyde hat mindestens 10 Verbrechen verübt.

≥10(verübt.Verbrechen)(clyde)

Wegen qualifizierten Kardinalitäten in OWL 1 nicht möglich

6. Bonnie und Clyde haben mindestens ein Verbrechen gemeinsam verübt.

(∃verübt.(Verbrechen ⊓ ∃verübt¯.{clyde}))(bonnie)

Kann in OWL DL ausgedrückt werden

7. Wer gemeinsam mit seinem Ehepartner ein Verbrechen verübt hat, der ist nicht ehrlich.

¬Ehrlich ⊑ ∃verübt.(Verbrechen ⊓ ∃verübt¯.{∃verheiratetMit.?} )

Hmm, scheint so nicht zu funktionieren – Wie könnte man den Ehepartner ausdrücken – Self geht hier nicht denn das würde nur ausdrücken, dass jemand mit sich selbst verheiratet ist.

8. Jeder, der einen Verdächtigen kennt, ist selbst verdächtig.

verdächtig ° kennt¯  ⊑ verdächtig

Rollenverknüpfung gab es in OWL 1 noch nicht

Reblog this post [with Zemanta]

[Semantic Web Technologies] SPARQL Test Tool und Lösungen

Hallo zusammen,

Screenshot of the SPARQL Test ToolIn der letzten Veranstaltung hab ich festgestellt, daß ihr wohl teilweise Probleme damit habt, euch die SPARQL Queries vorzustellen. Auch waren wir uns bei den gefundenen Ergebnissen nicht immer hundertprozentig sicher, ob es auch wirklich so funktioniert. Also hab ich kurzerhand ein kleines Tool geschrieben, mit dem ihr eure Queries ausprobieren könnt.

Das Tool basiert auf  dem Jena Framework und dem zugehörigen ARQ SPARQL Prozessor. ARQ ist ein sehr mächtiges Tool, wie wir ja auch schon in der Vorlesung sehen konnten (ARQ implementiert viele Features über den Standard hinaus).

Was kann man mit diesem Tool nun machen? Die Bedienung ist ganz einfach:  Ihr gebt zunächst auf der linken Seite die Daten (im TURTLE Format) ein, auf die ihr eure Abfrage stellen wollt. Rechts oben tragt ihr dann die Query ein, die ihr ausprobieren wollt. Nach einem Druck auf den „Query“ Button werden die Daten geparst, in ein Jena Model gepackt und dann mit der eingegebenen Query abgefragt.

Das Tool kann alle vier Abfragearten (SELECT, ASK, CONSTRUCT und DESCRIBE) und merkt sich beim Beenden die zuletzt verarbeiteten Daten, so dass diese bei einem erneuten Aufruf wieder zur Verfügung stehen. Den Code der Anwendung habe ich direkt unter die GPL gestellt. Ich habe euch auch gleich zwei Pakete geschnürt. Das erste ist ein ausführbares JAR-File, das direkt alles nötige enthält. Einfach runterladen und mit java -jar ausführen. Das zweite Paket enthält den Source-Code. Dieser ist nicht sehr kompliziert und besteht lediglich aus vier Files. Zum Übersetzen und Ausführen braucht ihr die JARs des Jena Frameworks.

SPARQL Test Tool (Executable JAR File, including Jena)

SPARQL Test Tool (Source)

So, nun zu den Lösungen der SPARQL Aufgaben:

Aufgabe 1

@prefix   ex: <http://example.org/> .
@prefix   xsd: <http://www.w3.org/2001/XMLSchema#> .
ex:Sonne  ex:radius   "1.392e6"^^xsd:double ;
          ex:satellit ex:Merkur, ex:Venus, ex:Erde, ex:Mars .
ex:Merkur ex:radius   "2439.7"^^xsd:double .
ex:Venus  ex:radius   "6051.9"^^xsd:double .
ex:Erde   ex:radius   "6372.8"^^xsd:double ;
          ex:satellit ex:Mond .
ex:Mars   ex:radius   "3402.5"^^xsd:double ;
          ex:satellit ex:Phobos, ex:Deimos .
ex:Mond   ex:name     "Mond"@de, "Moon"@en ;
          ex:radius   "1737.1"^^xsd:double .
ex:Phobos ex:name     "Phobos" .
ex:Deimos ex:name     "Deimos".

Objekte, die um die Sonne oder um einen Satelliten der Sonne kreisen

SELECT ?x WHERE {
 { ex:Sonne ex:satellit ?x } UNION
 { ex:Sonne ex:satellit ?y.
   ?y       ex:satellit ?x } }

Objekte mit einem Volumen von über 2*10^10 (km^3) (Objekte mit Radius können mit der Formel V = 4/3πr^3 berechnet werden) und falls vorhanden, mit dem Objekt dessen Satellit sie sind.

SELECT ?x ?y WHERE{
 ?x ex:radius ?rad .
 FILTER( 4*3.14*?rad*?rad*?rad/3 > 20000000000 ).
 OPTIONAL { ?y ex:satellit ?x . } }

Objekte mit einem Satelliten, für den ein Name in englischer Sprache angegeben worden ist, die außerdem Satellit eines Objekts von über 3000 (km) Durchmesser sind

SELECT ?Objekt
{
   ?Objekt   ex:satellit ?Satellit .
   ?Satellit ex:name     ?SatName .
   FILTER( LANG(?SatName) = "en"  ).
   ?GrossObjekt ex:satellit ?Objekt .
   ?GrossObjekt ex:radius ?Radius .
   FILTER( 2*?Radius > 3000 )
}

Objekte mit zwei oder mehr Satelliten (nehmen Sie an, dass unterschiedliche URIs hier unterschiedliche Objekte bezeichnen)

SELECT DISTINCT ?x {
   ?x ex:satellit ?a .
   ?x ex:satellit ?b .
   FILTER( ! sameTERM( ?a, ?b ) ) }

Aufgabe 2

@prefix   ex: <http://example.org/> .
@prefix   xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix   rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
ex:Sonne  rdf:type ex:Himmelskörper ;
          ex:radius   "1.392e6"^^xsd:double ;
          ex:satellit ex:Merkur, ex:Venus, ex:Erde, ex:Mars .
ex:Merkur rdf:type ex:Himmelskörper ;
          ex:radius   "2439.7"^^xsd:double .
ex:Venus  rdf:type ex:Himmelskörper ;
          ex:radius   "6051.9"^^xsd:double .
ex:Erde   rdf:type ex:Himmelskörper ;
          ex:radius   "6372.8"^^xsd:double ;
          ex:satellit ex:Mond .
ex:Mars   rdf:type ex:Himmelskörper ;
          ex:radius   "3402.5"^^xsd:double ;
          ex:satellit ex:Phobos, ex:Deimos .
ex:Mond   rdf:type ex:Himmelskörper ;
          ex:name     "Mond"@de, "Moon"@en ;
          ex:radius   "1737.1"^^xsd:double .
ex:Phobos rdf:type ex:Himmelskörper ;
          ex:name     "Phobos" .
ex:Deimos rdf:type ex:Himmelskörper ;
          ex:name     "Deimos" .

Wie kann man alle Himmelskörper selektieren, die KEINEN Satelliten haben?

SELECT ?x {
 ?x rdf:type ex:Himmelskörper.
 OPTIONAL { ?x ex:satellit ?satellit }.
 FILTER( !BOUND( ?satellit ) ) }

Aufgabe 3

@prefix   ex: <http://example.org/> .
@prefix   xsd: <http://www.w3.org/2001/XMLSchema#> .
ex:a ex:value "1"^^xsd:integer ;
     ex:value "3"^^xsd:integer .
ex:b ex:value "2"^^xsd:integer .

Was erwarten Sie als Ergebnis der Anfragen?

1. SELECT ?s ?v WHERE{  ?s ex:value ?v } ORDER BY ?v

?s ?v
a 1
b 2
a 3

Wie erwartet werden die Ergebnisse nach v sortiert

2. SELECT ?s WHERE{  ?s ex:value ?v } ORDER BY ?v

?s
a
b
a

Auch hier werden die Ergebnisse wieder nach v sortiert. v wird nur
nicht angezeigt

3. SELECT ?s WHERE{  ?s ex:value ?v } ORDER BY DESC(?v) LIMIT 2

?s
a
b

Diesmal wird genau umgekehrt sortiert. Anschließend werden aber nur
noch zwei Ergebnisse angezeigt

4. SELECT DISTINCT ?s WHERE{  ?s ex:value ?v } ORDER BY ?v

?s
a
b

Ansich die selbe Anfrage wie (2) nur das wir nun mit DISTINCT
zusätzlich doppelte Werte aussortieren.

4a. SELECT DISTINCT ?s WHERE{  ?s ex:value ?v } ORDER BY ?v LIMIT 1

?s
a

Auch hier gibt es keine Überraschungen, das liegt an der festgelegten
Reihenfolge der Modifikatoren bei SPARQL:
1. Sortierung anhand von ORDER BY
2. Entfernung nicht ausgewählter Variablen
3. Entfernung doppelter Ergebnisse (DISTINCT)
4. Entfernung der Ergebniszeilen vor dem OFFSET
5. Entfernung der überschüssigen Zeilen nach LIMIT
Siehe hierzu auch im Skript zu SPARQL auf Seite 25

Anbei nochmal die Lösungen im txt Format. So lassen sich die Daten evtl. leichter kopieren / einfügen.

Lösungen zu SPARQL (txt)

Reblog this post [with Zemanta]