Lösungen Lambda-Kalküle aus den Altklausuren

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

Lösungen Lambda-Kalküle aus den Altklausuren
hier sind mal unsere lösungen zu allen alten lambda-ausdrücken. bitte sagt, wenn ihr fehler findet!

7-2008: (\ab.aZ)
2-2009: (\d.b)
8-2009: (\G.AB)
2-2010: (\b.fb)
8-2010: (\fx.f(fx))
2-2011: (xk)(cd)


hätte noch jemand lösungen zu folgenden aufgaben?

blatt 4 - thread-sichere liste
blatt 6 - executor service
blatt 7 - lcs
blatt 9 - map-reduce und n-damen

da komm ich beim besten willen nicht auf einen grünen zweig…


ich komme bei Februar 2010 auf f

hier mal mein vorschlag:
alpha → (/f.(/x.(/x.(/g.xg))fx))(/x.f)x
beta ->(/f.(/x.((/g.fg))x))(/x.f)x
beta ->(/f.(/x.fx))(/x.f)x
alpha->(/h.(/x.hx))(/x.f)x
alpha->(/h.(/y.hy))(/x.f)x
beta->(/y.(/x.f)y)x
beta->((/x.f)x)
beta->f

so jetzt hab ich hoffentlich keine klammer vergessen…


ich glaub, du hast recht. ich hab statt des rot markierten bereichs zuerst hinten x in (\x.f) eingesetzt und das ergebnis dann vorne rein, aber ich glaub, das darf man nicht, oder? so kommt man jedenfalls auf das, was ich geschrieben hab.


Funktionsanwendung geht streng von links nach rechts, damits auch andersrum funktioniert müsste die Funktion assoziativ sein


genau, die letzten beiden parameter also (/x.f)x das sind die, die du in “die große klammer” einsetzen musst, dass ist auch das was die linksassoziativität bedeutet.
Man kann beim Lambda kalkül nur von hinten nach vorne einsetzen (von rechts nach links).


Kann man die 07-2008 auch ohne alpha lösen?

Mein Vorschlag:
----------> /X Y.(/Z X.X Z Y)(/Z.X Z)(/Y X.Y Z)
–beta–> /Y.(/Z X.X Z Y)(/Y X.Y Z)
–beta–> /Z X. X Z (/Y X.Y Z)
–beta–> /X.X (/Y X.Y Z)
–beta–> /Y X.Y Z


Pass bei Lambda genau mit der Klammerung auf.
In der Aufgabe steht
(/X Y.(/Z X.X Z Y)(/Z.X Z)(/Y X.Y Z))
→ mit dem X und Y am Beginn passiert in der Ganzen Aufgabe gar nichts.


Schaut gut aus.

Hab eine Frage. Wie weit kann man beim Lambda-Kalkül die Schritte kürzen (um Zeit zu sparen)?

Ist dies auch möglich:

(\XY.(\ZK.XZY)(\Z.XZ)(\YX.YZ)
→ beta (\XY.(\YX.YZ)(\Z.XZ)Z)
→ beta (\XY.(\Z.XZ)Z)
→ beta (\XY.XZ)


Nicht wenn man Fehler dabei macht und nicht dazu schreibt was man tut :wink:
Fixed Version:
(\XY.(\ZK.KZY)(\Z.XZ)(\YX.YZ)
→ beta,beta (\XY.(\YX.YZ)(\Z.XZ)Y)
→ alpha,beta,beta (\XY.(\Z.XZ)Z)
→ beta (\XY.XZ)


Mist ich habs schnell von meinem Block abgeschrieben. Hab aber keine alpha-Konversion gemacht.
2. Versuch:

(\XY.(\ZX.XZY)(\Z.XZ)(\YX.YZ)
→ beta → beta (\XY.(\YX.YZ)(\Z.XZ) Y)
→ beta → beta (\XY.(\Z.XZ)Z)
→ beta (\XY.XZ)

Also für
(\XYZ.XYZ) A B C
müsste man follgendes schreiben

→ beta ->beta ->beta ABC

Sowas kostet nun mal bei einer 60 Minten Klausur viel Zeit.


Und etwas falsch abzukürzen kostet Punkte :wink:
Die Aufgabe geht nicht ohne alpha-Konversion! Wenn links keine angegeben ist und man nicht aus dem Zusammenhang erschließen kann, dass eine alpha-Konversion durchgeführt wurde, gibt es Punktabzug.

Ist falsch. Würde man einfach 2 beta Konversionen durchführen, würde das Ergebnis so aussehen:

(\XY.(\ZX.XZY)(\Z.XZ)(\YX.YZ)
→ beta → beta (\XY.(\YX.YZ)(\Z.(\YX.YZ)Z) Y)


OK. Vielen Dank für die Hilfe. ´:)

Ich werde morgen mehrere betas oder alphas in einer Zeile schreiben. (nicht beta und alpha in der selben Zeile).

außer es ist genügend Zeit vorhanden :wink: