Allgemeine Hinweise 1 Prolog Aussagenlogik und Resolution

Lehrstuhl für Softwaretechnik und Programmiersprachen
Professor Dr. Michael Leuschel
Softwaretechnik und Programmiersprachen – Sommersemester 2010
Prolog Übungsaufgaben
Allgemeine Hinweise
In diesem Dokument finden Sie eine Sammlung von Übungsaufgaben zum Thema Prolog
Die Übungsleiter werden Sie informieren welche Aufgaben in welcher Übung besprochen werden
Ansprechpartner, Sprechstunden
Bei Fragen wenden Sie sich bitte an Jens Bendisposto, bendisposto@cs.uni-duesseldorf.de,
oder die Übungsleiter
1 Prolog
Verwendete Prolog-Systeme
Ein Großteil der Aufgaben zu Prolog werden Programmieraufgaben sein. Zum Lösen der Aufgaben benötigen Sie
einen Prolog-Interpreter. SWI-Prolog (www.swi-prolog.org) ist eine freie, umfangreiche Prolog-Implementierung,
die Sie verwenden können.
Andere Prolog-Systeme sind XSB und das kommerzielle SICStus. Zu SICStus gibt es eine Campuslizenz.
Falls Sie das System installieren möchten, sprechen Sie uns bitte an.
Wir gehen im Folgenden davon aus, dass sie SWI verwenden.
Arbeitszyklus Komandozeile
Programme können in einem beliebigen Texteditor entwickelt werden. Auf der Kommandozeile werden diese
dann folgendermaßen ausgeführt:
swipl -s programm.pl
?-
Sie sehen dann ein paar Status-Informationen und das interaktive Prolog-Prompt:
Es kann auch als Anfrage consult(’programm.pl’). eingegeben werden. Um ein Programm nach Änderungen
erneut zu Laden, wird reconsult(’programm.pl’). verwendet.
Sie verlassen das Programm mit halt..
Kleiner Ratschlag
Es wird dringend empfohlen, die Übungen zu machen und sich mit Arbeitsweise und Programmierung von
Prolog vertraut zu machen. Eine neue Programmiersprache – insbesondere ein neues Programmierkonzept –
erlernt man nur durch Üben, nicht nur durch das Ansehen von Beispielen.
Weiterhin sind die Übungsaufgaben so aufgebaut, dass sie für das Lösen der Projektaufgabe extrem nützlich
sein werden.
Aussagenlogik und Resolution
Formalisieren Sie die folgenden Aussagen in Aussagenlogik:
1. Das System heizt, wenn der Deckel geschlossen ist und Strom an ist.
2. Wenn das Lämpchen leuchtet, ist der Strom an.
3. Das Lämpchen leuchtet.
4. Der Deckel ist geschlossen.
Bringen Sie die Aussagen in die konjunktive Normalform und beweisen Sie mittels linearer Resolution, dass das
System heizt.

Spaß mit Zahlen
In der Vorlesung haben sie die Beschreibung der natürlichen Zahlen mittels der folgenden zwei Axiome gesehen
(Peano-Arithmetik):
0 ∈ N
∀X X ∈ N → s(X) ∈ N
Eine etwas andere Schreibweise, die wir im folgenden nutzen, ist:
nat(0)
∀X nat(X) → nat(s(X))
Die Addition (add(X, Y, Z): Z ist die Summe von X und Y ) wurde folgendermaßen definiert:
• Setzten Sie die Addition in Prolog um.
• Definieren Sie die Multiplikation in Prolog.
• Definieren Sie “kleiner als”.
• Implementieren Sie Modulo.
2 Unifikation
∀X add(0, X, X)
∀X, Y, Z add(X, Y, Z) → add(s(X), Y, s(Z))
Geben Sie zu den folgenden Paaren von Termen an, ob sie unifizierbar sind und –wenn ja– geben sie einen
allgemeinsten Unifkator σ (most general unificator – mgu) an.
1. punkt und punkt
2. loves(brad, janet) und loves(brad, X)
3. punkt(1, 2, 3) und punkt(1, R)
4. nat(nat(X)) und nat(Y )
5. greater(nat(0), nat(nat(X))) und greater(nat(X), nat(Y ))
6. cons(A, cons(B, nil)) und cons(val, cons(C, R))
7. snafu(foo, A) und snafu(A, bar)
8. triple(pair(X), pair(Y ), Z) und triple(Z, pair(X), pair(Z))
Ein Zoo
Wir betrachten einen Zoo mit den folgenden Tieren: Löwe, Tieger, Papagei, Pinguin, Zebra, Kolibri, Adler,
Nashorn.
1. Entwickeln Sie eine Datenbank, die die Tiere des Zoos verwaltet, es uns also ermöglicht herauszufinden,
ob ein bestimmtes Tier im Zoo ist.
2. Erweitern Sie das Program, so dass wir herausfinden können, ob ein Tier ein Raubtier ist.
3. Wenn Sie nun fragen, ob ein Wolf ein Raubtier ist, welche Antwort bekommen Sie? Warum? Ist es die
erwartete Antwort? Wie könnte man das Programm erweitern, um die erwartete Antwort zu bekommen?
4. Erweitern Sie nun das Program, so dass wir herausfinden können, ob ein Tier ein Vogel ist; erweitern Sie
das Programm, so dass wir herausfinden können, ob ein Tier fliegen kann.
5. Überlegen Sie sich eine elegante Lösung um sicherzustellen, dass ein Pinguin als nicht-fliegender Vogel
erkannt wird.

Prolog als Datenbank
Sie sollen ein Sicherheitssystem für ein Büro entwerfen. Das Büro hat zwei Haupteingänge, und die einzelnen
Räume sind mit Buchstaben bezeichnet:
Aufgabe 1
Halten Sie die Topologie des Büros in einem Prolog-Programm fest. Nach der Fertigstellung wollen wir mit der
folgenden Abfrage feststellen können, ob zwei Räume verbunden sind:
% Sind Raum a und b verbunden?
?- tuer(a, b).
true
Aufgabe 2
Wenn eine Tür von a nach b geht, geht diese natürlich auch von b nach a. Unterstützt Ihr Programm das? Stellen
Sie sicher, dass Ihr Programm das unterstützt. Stellen Sie weiterhin sicher, dass Abfragen wie tuer(X, a)
ebenfalls funktionieren.
Ein Hinweis: Eine Triviale Lösung wäre es, jede Tür zweimal in die Datenbank aufzunehmen (für beide
Richtungen). Versuchen Sie, eine Lösung ohne Redundanz zu finden.
Aufgabe 3
Erstellen Sie eine Regel erreichbar(Raum1, Raum2), die true ergibt, wenn zwei Räume verbunden sind.
Erstellen Sie eine Regel erreichbar(Raum1, Raum2, Weg), die den Weg zwischen zwei Räumen ausdruckt.
Dazu ein paar Hinweise:
(1) Sie können Weg erstellen, indem Sie einfach die Teile als String zusammensetzen, etwa folgendermaßen:
verbinde(X, Y, X -> Y).
Ausgeführt würde das folgendermaßen aussehen:
?- verbinde (a, b, AB).
AB = a->b
(2) Ein bessere Möglichkeit wäre, eine Liste für Weg zu benutzen. Listen wurden in der Vorlesung jedoch
noch nicht behandelt. Sie dürfen sich aber trotzdem gern daran versuchen, wenn Sie wollen.
Aufgabe 4
Nun sollen Nutzer eingeführt werden, die nur Zugang zu bestimmten Räumen haben.
Datenstruktur, die das festhält.
Entwickeln Sie eine
Aufgabe 5
Nutzer müssen von Außerhalb (also “outside” im Plan) zu den Räumen kommen, zu denen sie Zugang haben.
Schreiben Sie also ein Programm das prüft, ob ein Nutzer zu einem Raum Zugangsrechte hat, und diesen Raum
auch von outside erreichen kann (also muss der Nutzer auch für alle Räume, die zwischen outside und dem
Raum liegen, Zugangsrechte haben).

Listen, Listen, Listen
Aufgabe 1
Schreiben Sie ein Programm, das eine Liste de-dupliziert, also mehrfach enthaltene Elemente löscht, also
[a, b, a, c] wird zu [a, b, c] oder [b, a, c].
Aufgabe 2
Schreiben Sie ein Programm, das jedes Element einer Liste verdoppelt, also [a, b, c] wird zu [a, a, b, b, c, c].
Aufgabe 3
Es gibt verschiedene Möglichkeiten, Listen umzudrehen. Hier sind zwei mögliche Programme:
% reverse Version a
reverse([], []).
reverse([X|Xs], Zs) :- reverse(Xs, Ys), append(Ys, [X], Zs).
% reverse Version b
reverse([], []).
reverse(Xs, Ys) :- reverse(Xs, [], Ys).
reverse([X|Xs], Acc, Ys) :- reverse(Xs, [X|Acc], Ys).
reverse([], Ys, Ys).
• Welche der beiden Versionen gefällt Ihnen besser? Warum?
• Zeichnen Sie den Proof-Tree für beide Programme, wenn der folgende Ausdruck ausgewertet wird:
reverse([a, b, c], [c, b, a]).
• Wie ist die Laufzeit der beiden Programme?
Inspektion von Strukturen
Aufgabe 1
Was ergeben die folgenden Ausdrücke? Und warum?
?- compound(a).
?- atom(a).
?- compound(X).
?- atom(X).
?- compound(a(b)).
?- atom(a(b)).
?- compound([]).
?- atom([]).
?- compound([[]]).
?- atom([[]]).
Aufgabe 2
Was ergeben die folgenden Ausdrücke? Und warum?
?- functor(a, F, A).
?- functor(father(michael, tyler), F, A).

?- arg(1, father(michael, tyler), X).
?- arg(2, father(michael, X), tyler).
?- functor([], F, A).
?- functor([a], F, A).
?- arg(1, [a], X).
?- arg(2, [a], X).
?- arg(3, [a], X).
?- arg(1, [], X).
Schreiben Sie ein Programm subterm(T1, T2), das wahr ergibt, wenn T1 ein Unter-Term von T2 ist, also
z.B.
?- subterm(a, x(a)).
true
?- subterm(a, x(b)).
false
Sie dürfen annehmen, dass keiner der Terme Variablen enthält.
Listen und Zahlen
Aufgabe 1
Schreiben Sie ein Programm, dass die Werte einer Liste aufaddiert. Z.B. sumlist([2, 3, 4], X) ergibt X=9.
Aufgabe 2
Schreiben Sie ein Programm, dass den größten gemeinsamen Teiler identifiziert. Z.B. ggt(6, 9, X) ergibt X=3.
Aufgabe 3
Schreiben Sie ein Programm, dass eine Liste von Zahlen erzeugt. Die Anfangs- und Endzahl wird als Argument
gegeben. Z.B. range(1, 5, X) ergibt X=[1, 2, 3, 4, 5].
Aufgabe 4
Schreiben Sie ein Programm, dass alle Permuationen einer Liste erstellt. Z.B. perm([1, 2, 3], X) ergibt
X=[1, 2, 3], X=[1, 3, 2], X=[2, 1, 3], X=[2, 3, 1], X=[3, 1, 2] und X=[3, 2, 1].
Acht Damen
Das Acht-Damen-Problem ist ein klassisches Schach-Rätsel. Es sollen jeweils acht Damen auf einem Schachbrett
so aufgestellt werden, dass keine zwei Damen einander nach den Schachregeln schlagen können. Die Figurenfarbe
wird dabei ignoriert und es wird angenommen, dass jede Figur jede andere angreifen könnte. Anders
ausgedrückt, es sollen sich keine zwei Damen die gleiche Reihe, Linie oder Diagonale teilen. Es gibt mehrere
Lösungen, eine davon ist zum Beispiel:

Aufgabe 1
Schreiben Sie ein Programm, dass das 8-Damen-Problem löst.
Aufgabe 2
Statt dem 8-Damen-Problem, schreiben Sie das Programm generischer für das N-Damen-Problem (N ist die
größe des Schachbrettes und die Anzahl der Damen).
Aufgabe 3
Versuchen Sie ein möglichst effizientes Programm zu schreiben.
Puzzles
Aufgabe 1
Zum Warmwerden beschäftigen wir uns mit dem 15-Puzzle. Bei dem Puzzle sollen die Zahlen durch Verschieben
sortiert werden.
Schreiben Sie ein Programm, dass das 15-Puzzle-Problem löst.
Die Datenstruktur für ein 15-Puzzle soll folgendermaßen aussehen:
% Die Datenstruktur ist ein Prädikat c mit drei Listen, die die Zahlen 1-15 und x enthalten:
% c([x, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]).
Dann definieren Sie eine Übergangs-Funktion (Successor-Function), die das Puzzle von einem Zustand zum
nächsten überführt, also z.B.:
?- s(c([x, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]), R).
R = c([4, 1, 2, 3], [x, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]) ;
R = c([1, x, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]) .
Implementieren Sie nun ein Programm zur Lösungsfindung, dass den “konventionellen” Weg beschreitet: Sie
suchen eine potentielle Lösung und lassen Prolog diese Lösung testen. Wie können Sie sicherstellen, dass das
Programm immer eine Lösung findet, angenommen dass es eine gibt? Wie bewerten Sie die Performance?
Aufgabe 2
Nun wollen wir eine Lösung implementieren, die A* nutzt. Um A* zu implementieren, benötigen Sie eine pathcost-function
g(x) und eine heuristic-function h(x). Implementieren Sie g(x) und h(x) Ihrer Wahl - aber nicht
die in Aufgabe 3 geforderte!

Aufgabe 3
Implementieren Sie eine Heuristik-Funktion, die die “Manhattan-Entfernung” berechnet. Bei der Manhattan-
Entfernung werden die Entfernungen der X- und Y-Koordinate einfach zusammenaddiert. Z.B. hat “zwei nach
rechts, einen nach oben” eine Entfernung von drei.
Das Tantrix-Spiel
Bei Tantrix handelt es sich um ein Legespiel, das mit sechseckigen Kacheln gespielt wird. Jede Kachel ist mit
drei farbigen Linien bedruckt, die den Kanten der Kachel eine entsprechende Farbe zuordnen. Im folgenden
sind einige typische Tantrix-Kacheln gezeigt.
Das Ziel des Spieles ist, die Kacheln so anzuordnen, dass nur zusammenpassende Kacheln aneinander liegen.
Es gib mehrere Variationen des Spieles, von denen wir nur eines hier bearbeiten werden.
Das Tantrix-Rotationspuzzle
Sie sollen das folgende Tantrix-Problem bearbeiten:
Sie bekommen ein Anzahl angeordneter Tantrix-Kacheln. Schreiben Sie ein Programm, dass diese Kacheln
so rotiert, dass alle Kanten zusammen passen. Das folgende Bild zeigt eine Aufgabe mit vier Kacheln (a) und
die dazugehörige Lösung (b). Beachten Sie, das wirklich nur rotiert wurde - nicht verschoben oder vertauscht.
Die Details zu Tantrix
1. Alle Linien auf einer Kachel haben unterschiedliche Farben (es gibt also immer genau drei Farben pro
Kachel).
2. Es gibt Tantrix-Spiele mit unterschiedlich vielen Farben. Ihr Programm muss das unterstützen können.
Die Details zum Programm
Das zu lösende Puzzle wird folgendermaßen an Ihr Programm übergeben: Für jede Kachel bekommen Sie zwei
Koordinaten eines Koordinatensystems, das so aussieht:
Zusätzlich bekommen Sie die Kantenfarben als einfache Bezeichner. Das in der Abbildung gezeigte Problem
würde dann wie folgt aussehen:
% Die Kacheln haben eine Position (x, y) und sechs Farben, im Uhrzeigersinn,
% beginnend mit der unteren Kante
setup(
[kachel(0, 0, b, b, r, y, r, y),

kachel(1, 0, g, r, g, r, b, b),
kachel(1, 1, y, b, r, y, r, b),
kachel(0,-1, b, g, g, b, r, r)
]
).
% Die Loesung ist eine Liste mit einer Liste pro Kachel. Die Kachel-Listen
% enthalten drei Elemente: die Koordinaten der Kachel und die Anzahl der Schritte,
% die die Kachel im Uhrzeigersinn gedreht werden muss.
setup(P), solve(P,L), L = [[0, 0, 4], [1, 0, 3], [1, 1, 0], [0,-1, 5]].