Prolog Rekursion?
Hallo,
ich bin gerade dabei Prolog zu lernen, komme aber bei der Rekursion nicht weiter, ich verstehe einfach nicht wie das genau abläuft, wenn ich z.B.:
zahl(0).
zahl(plusEins(X)) :- zahl(X).
in meiner Datenbasis stehen hab. Warum weiß dann Prolog, dass
zahl(plusEins(plusEins(0))) true ist?
wenn man für X = 0 hat ist ja zahl(0) und somit durch Implikation der Term zahl(plusEins(0)) auch erfüllt. Aber warum soll dann zahl(plusEins(plusEins(0))) auch erfüllt sein?
1 Antwort
Die Magie der Rekursion in Prolog (und in der Informatik allgemein) liegt in der Fähigkeit, die gleiche Logik auf immer kleinere Teile eines Problems anzuwenden, bis man einen Zustand erreicht, den man direkt lösen kann - diesen Zustand nennt man Basisfall oder Basisfälle.
In Ihrem Beispiel ist `zahl(0).` der Basisfall. Dieser gibt an, dass `0` eine Zahl ist.
Die rekursive Regel `zahl(plusEins(X)) :- zahl(X).` bedeutet so viel wie "Wenn X eine Zahl ist, dann ist `plusEins(X)` auch eine Zahl". In diesem Sinne "erweitert" es das, was als "Zahl" definiert ist, über den Basisfall hinaus.
Wenn Prolog nun gefragt wird, ob `zahl(plusEins(plusEins(0)))` eine Zahl ist, geht es folgendermaßen vor:
1. Es überprüft, ob es diese Behauptung direkt in seiner Datenbank (den Fakten und Regeln, die es kennt) finden kann. In diesem Fall kann es das nicht.
2. Da es die Behauptung nicht direkt finden kann, sucht es nach einer Regel, die passen könnte. Es findet die Regel `zahl(plusEins(X)) :- zahl(X).`
3. Es versucht, die Regel anzuwenden, indem es `X` mit `plusEins(0)` ersetzt (das ist das, was übrig bleibt, wenn man von `plusEins(plusEins(0))` das äußerste `plusEins(...)` entfernt).
4. Nun muss es überprüfen, ob `zahl(plusEins(0))` wahr ist. Wieder kann es diese Behauptung nicht direkt finden, also wendet es die Regel erneut an, diesmal ersetzt es `X` mit `0`.
5. Jetzt muss es überprüfen, ob `zahl(0)` wahr ist. Diesmal kann es die Behauptung direkt in seiner Datenbank finden, da `zahl(0).` ein Fakt ist, den Sie definiert haben. Also ist `zahl(0)` wahr.
6. Da `zahl(0)` wahr ist, folgt daraus (gemäß der Regel), dass `zahl(plusEins(0))` wahr ist.
7. Und da `zahl(plusEins(0))` wahr ist, folgt daraus (wieder gemäß der Regel), dass `zahl(plusEins(plusEins(0)))` wahr ist.
In diesem Sinne "arbeitet" sich Prolog von innen nach außen durch die verschachtelten `plusEins(...)` Aufrufe, bis es beim Basisfall `0` ankommt. Dann arbeitet es sich zurück und bestätigt, dass jeder der darüberliegenden Aufrufe auch wahr ist, weil der darunter liegende wahr ist.
Das ist das grundlegende Prinzip der Rekursion in Prolog. Es ist ein wenig gewöhnungsbedürftig, wenn man es das erste Mal sieht, aber mit etwas Übung wird es klarer und beginnt Sinn zu machen. Es ist eine sehr mächtige Technik, die es ermöglicht, viele Probleme auf sehr elegante Weise zu lösen.
Danke danke, das hat mir gerade sehr geholfen, super erklärt :3