[Progra] Prolog Fragen

[NightmareVirus]

EDIT: och bin ich doof, ja der Fehler ist bei der Liste wo ich fälschlicherweise ein '|' anstelle eines ',' verwendet hab...


Hallo. Hab n Prologprogramm geschrieben, und das macht irgendwie nicht das was es machen soll.

Das Programm ist dass zu Aufgabe 1 von Ü13.
mein Code:

Code: Alles auswählen

bergabfahrt(Start, Zwischenziel, [Start| Zwischenziel], Linie) :- nachfolger(Start, Zwischenziel, Linie).
bergabfahrt(Start, Ziel, [Start| XS], Linie) :- nachfolger(Start, Zwischenziel, Linie),
                                                bergabfahrt(Zwischenziel, Ziel, XS, Linie).

Code der Musterlösung:

Code: Alles auswählen

bergabfahrt(X, Y, [X, Y], L) :- nachfolger(X, Y, L).
bergabfahrt(X, Z, [X|AS], L) :- nachfolger(X, Y, L),
                                bergabfahrt(Y, Z, AS, L).

Ausser das ich andere Variablennamen nutze sehe ich irgendwie keinen Unterschied zwischen den beiden Programmen, dennoch sind die Ausgaben verschieden (beides in meinem Prolog getestet).

Meine Ausgabe:

AS = [hochsteg|burg],
L = 5 ;

AS = [hochsteg, niedersteg|burg],
L = 1 ;

No

Ausgabe der Musterlösung:

AS = [hochsteg, burg],
L = 5

[/code]

[NightmareVirus]

Gleiche Aufgabe wie oben.

Kann es sein dass die 2. Beispielanfrage

bergabfahrt(hochsteg,burg,AS,L). ergibt
AS = [hochsteg,niedersteg,burg], L = 1.

nicht eigentlich

?- bergabfahrt(hochsteg,burg,AS,L).

AS = [hochsteg, burg],
L = 5 ;

AS = [hochsteg, niedersteg, burg],
L = 1 ;

lauten sollte... so kommts zumindest bei mir raus, und das macht meiner Ansicht uach mehr sinn.

[theTux]

Die Reihenfolge hängt von deiner Implementierung ab. Wenn du nach der ersten Variablenbelegung nicht ;, sondern Enter drückst, kommt auch nur das eine raus - sollte also ok sein.

[NightmareVirus]

Aufgabe 2, Übungsblatt 13

Wenn ich bei der Musterlösung die funktion groesser aufrufe mit:

Code: Alles auswählen

3 ?- groesser(4,2).

erhalte ich als antwort No.

irgendwie funktioniert die Funktion bei mir nur mit:

Code: Alles auswählen

groesser(1 ?- groesser(succ(1),zero).

Yes

2 ?- groesser(succ(4),succ(3)).

No

funktioniert schon wieder nicht mehr... is das normal?

[theTux]

Lies' dir nochmal die Aufgabenstellung durch...

[NightmareVirus]

ah die abfragen ham die Form

Code: Alles auswählen

groesser(succ(succ(succ(zero)),succ(zero)).

allet kla...

[aRo]

hallo!

Ich habe da noch eine ganz kurze, dumme Frage. Ich will das Minimum einer Liste "suchen", besser gesagt, soll mein Prädikat erfüllt sein, wenn X das Minimum der Liste ist.

Das bei meiner Implementierung X nicht Bestandteil der Liste sein muss, ist mir klar, aber auch schon so klappt es nicht:

Code: Alles auswählen

min(X,[]).
min(X,[Y|Rest]) :- X<=Y, min(X,[Rest]).

Ich sehs nicht

[HE]

Code: Alles auswählen

min(X,[]).
min(X,[Y|Rest]) :- X<=Y, min(X,[Rest]).

Ich sehs nicht

Naja, erstmal ist min(X,[]) ja Unsinn. min(X,[X]) ist dafür aber recht wahr, also nehmen wir dann das. Dann ist es immer ganz schön, nur instantiierte Variablen zu verwenden, d.h. erst das Minimum der Rest-Liste ermitteln, dann denn Rest. Und dann kommen wir dahin:

Code: Alles auswählen

min(X,[X]).
min(X,[Y|R]) :- min(T,R), Y < T, X=Y.
min(X,[Y|R]) :- min(T,R), Y > T, X=T.


[aRo]

moment, moment.
1. deinen Code verstehe ich leider gar nicht , dein T verwirrt mich.
Was wäre denn das T bei der ersten Übergabe von
min(X,[1,2,3])?

Und wieso ist min(X,[]). Unsinn? Wenn ich doch nur prüfen möchte, ob mein X kleiner als jedes Element der Liste ist.

[sumpfmensch]

Code: Alles auswählen

min(X,[X]).
min(X,[Y|R]) :- min(T,R), Y < T, X=Y.
min(X,[Y|R]) :- min(T,R), Y > T, X=T.


die erste aussage ist ja klar.

die zweite bedeutet:
"X ist das Minimum von [Y|R] wenn das minimum von R (T) größer ist als X (bzw. Y ... da X=Y)"
also jetzt auch klar

die dritte bedeutet:
"X ist das Minimum von [Y|R] wenn X das Minimum der Restliste (R) ist und Y größer als X"
sollte jetzt auch klar sein


ich persönlich finds einfacher wenn so wenig variablen wie möglich vorhanden sind.
D.h. ich würde die aussagen folgendermaßen schreiben:

Code: Alles auswählen

min(X,[X]).
min(X,[X|R]) :- min(T,R), X < T.
min(X,[Y|R]) :- min(X,R), Y >X.


und ob min(X,[]) sinn macht ... da lässt sich drüber streiten...
ich würde auch für nein voten

[mirko]

Und wieso ist min(X,[]). Unsinn?

weil 5 nicht das kleinste element einer leeren liste ist
genausowenig wie 2 oder 7 oder 12 oder a. so könnte man aber alles einsetzen...

[aRo]

okay, denke ich habs nun verstanden.

Wenn ich folgende Ausdrücke unifizieren möchte:

Code: Alles auswählen

u(u(X,v(a)),Y) und u(Y,u(v(b),X))

Dann ist im ersten Schritt

{Y=u(X,v(a))}

und
im Zweiten würde ich versuchen den MGU von

Code: Alles auswählen

u(X,v(a)) und u(v(b),X))

zu bilden.

Dann hätten wir und


Okay, dass das nicht funktioniert sieht man. Aber wieso ist das ein ClashFailure? Okay, ein Occur Failure ist es nicht, weil nirgendwo eine Variable auftaucht, aber bei einem ClashFailure müssen doch die äußeren Funktionen unterschiedlich sein, oder?

[mirko]

dann geh halt noch eine ebene tiefer. um das mgu von v(a) und v(b) zu bestimmen, musst das mgu des ersten parameters von v bestimmen. der ist bei v(a) a und bei v(b) b. also brauchst du MGU(a,b). und dann hast du definitiv nen clash-failure.

[aRo]

okay, ich habe jetzt verstanden was wirklich mit einem ClashFailure gemeint ist.

Prolog und ich werden leider nicht richtig Freunde. Wenn ich z.B. eine Funktion implementieren will, die von einer Liste das erste größere Element zurückliefert, als mein gegebenes, verstehe ich eine Sache nicht.

Also z.B. soll nimm1gr([1,2,3,4,5],2,X) die 3 liefern, weil die 3 das erste Element der Liste ist, das größer als 2 ist.

so funktioniert es:

Code: Alles auswählen

nimm1gr([X|R],E,X) :- E<X.
nimm1gr([X|R],E,Y) :- nimm1gr(R,E,Y).

so nicht

Code: Alles auswählen

nimm1gr([X|R],E,X) :- E<X.
nimm1gr([X|R],E,Y) :- X<=E, nimm1gr(R,E,Y).


warum? Was ist an X<=E falsch?

[Neronus]

okay, ich habe jetzt verstanden was wirklich mit einem ClashFailure gemeint ist.

Prolog und ich werden leider nicht richtig Freunde. Wenn ich z.B. eine Funktion implementieren will, die von einer Liste das erste größere Element zurückliefert, als mein gegebenes, verstehe ich eine Sache nicht.

Also z.B. soll nimm1gr([1,2,3,4,5],2,X) die 3 liefern, weil die 3 das erste Element der Liste ist, das größer als 2 ist.

so funktioniert es:

Code: Alles auswählen

nimm1gr([X|R],E,X) :- E<X.
nimm1gr([X|R],E,Y) :- nimm1gr(R,E,Y).

so nicht

Code: Alles auswählen

nimm1gr([X|R],E,X) :- E<X.
nimm1gr([X|R],E,Y) :- X<=E, nimm1gr(R,E,Y).


warum? Was ist an X<=E falsch?

Es gibt <= als operator in Prolog nicht. Das heisst =<.

Ausserdem ist ein weiterer Unterschied zwischen beiden Loesungen, dass die 2. Loesung tatsaechlich nur das 1. Element ausspuckt, und, wenn man nach weiteren Loesungen fragt, No gibt. Das erste Programm wirft alle Zahlen zurueck, die groesser sind als die gegebene Zahl.