Vortrag. Vortrag im Rahmen der Master-Vorlesung Semantik von Programmiersprachen an der FH München, Fachbereich Informatik

Transkript

1 Vortrag β- and η-conversion Vortrag im Rahmen der Master-Vorlesung Semantik von Programmiersprachen an der FH München, Fachbereich Informatik von Stefan Hertel Thomas Wöllert

2 Inhalt Einführung - Reduktion von Prozeduren β-konversion Grammatik des Lambda-Kalküls (Wiederholung Transformationsregel und Probleme Formalisierung der Substitution β-konversion, -Redex und -Reduktion Implementierung (beta-redex? [...] Implementierung (substitute [...] Implementierung (beta-reduce [...] η-konversion η-konversion, -Redex und -Reduktion Implementierung (eta-redex? [...] Implementierung (eta-reduce [...] Implementierung (eta-expand [...]

3 Inhalt Einführung Einführung - Reduktion von Prozeduren β-konversion Grammatik des Lambda-Kalküls (Wiederholung Transformationsregel und Probleme Formalisierung der Substitution β-konversion, -Redex und -Reduktion Implementierung (beta-redex? [...] Implementierung (substitute [...] Implementierung (beta-reduce [...] η-konversion η-konversion, -Redex und -Reduktion Implementierung (eta-redex? [...] Implementierung (eta-reduce [...] Implementierung (eta-expand [...]

4 Reduktion von Prozeduren I Problemstellung Auswertung eines Prozeduraufrufs. (def foo (lambda (x y (+ (* x 3 y ; (foo ( ; A-priori Kenntnis Tritt im body der Prozedur eine Referenz auf einen ihrer formalen Parameter auf (x oder y, kann das passende Argument des Aufrufs anstatt dieses Parameters erscheinen. (foo ( ; (+ (* ( ; 22; Regel (informell Um das Resultat eines Prozeduraufrufs zu erhalten, müssen die formalen Parameter im body der Prozedur durch ihre passenden Argumente (vom Aufruf der Prozedur ersetzt werden. (ABER: Einschränkungen dieser Regel notwendig! Siehe 4.3.1

5 Reduktion von Prozeduren II Schrittweise Ausführung der Ersetzung (Variante 1 In jedem Schritt wird ein Unterausdruck durch einen äquivalenten Unterausdruck ersetzt. (def foo (lambda (x y (+ (* x 3 y ; (foo ( ; => ((lambda (x y (+ (* x 3 y ( ; => (+ (* ( ; => 22;

6 Reduktion von Prozeduren III Schrittweise Ausführung der Ersetzung (Variante 2 Alternativ können auch die Argumente des Aufrufs zuerst ausgewertet werden. Erst danach werden die Ersetzungen vorgenommen. (def foo (lambda (x y (+ (* x 3 y ; (foo ( ; => (foo 5 7; => (+ (* 5 3 7; => (+ 15 7; => 22;

7 Reduktion von Prozeduren IV Schrittweise Ausführung der Ersetzung (Variante 3 Ebenso ist es möglich, die aufgerufenen Prozeduren schrittweise zu ersetzen. (def c+ (lambda (n (lambda (m (+ n m ; ((c+ 5 3; => ((lambda (m (+ 5 m 3; => (+ 5 3; => 8;

8 Reduktion von Prozeduren V Sugaring Rules transformieren Einige Spezialformen (z.b. let stellen nur syntaktischen Zucker anderer Formen dar. Solche Zucker Regeln können daher ebenso durch Transformationen ausgedrückt werden. (let ((var 1 exp 1... (var n exp n body ((lambda (var 1... var n body exp 1... exp n Anwendung mit Ersetzungen Diese Regeln können zusammen mit den (bereits vorgestellten Ersetzungen angewendet werden, um komplexe Ausdrücke auszuwerten. (let ((x 3 (add5 (c+ 5 (add5 x; => (let ((x 3 (add5 (lambda (m (+ 5 m (add5 x; => ((lambda (x add5 (add5 x 3 (lambda (m (+ 5 m; => ((lambda (m (+ 5 m 3; => (+ 5 3; => 8;

9 Reduktion von Prozeduren VI Literal representation of a value In den vorherigen Beispielen wurde mit der literarischen Repräsentation der Werte gearbeitet. Es ist nicht möglich, die Werte selbst in den Ausdrücken zu verwenden. Bisher wurden nur numerische Literale benutzt, daher ist es schwierig den Unterschied zu erkennen. Der Unterschied wird klar, wenn die Werte Listen enthalten. In diesem Beispiel ist die literarische Repräsentation der Liste mit quote markiert. (let ((second (lambda (x (car (cdr x (second (list 1 2 3; => ((lambda (second (second (list (lambda (x (car (cdr x; => ((lambda (x (car (cdr x (list 1 2 3; => ((lambda (x (car (cdr x '(1 2 3; => (car (cdr '(1 2 3; => (car '(2 3; => 2; Wäre in diesem Beispiel die Liste (1 2 3 benutzt worden: (car (cdr (1 2 3, hätte eine Application der Zahl 1 und weiterer Argumente vorgelegen.

10 Inhalt β-konversion Einführung - Reduktion von Prozeduren β-konversion Grammatik des Lambda-Kalküls (Wiederholung Transformationsregel und Probleme Formalisierung der Substitution β-konversion, -Redex und -Reduktion Implementierung (beta-redex? [...] Implementierung (substitute [...] Implementierung (beta-reduce [...] η-konversion η-konversion, -Redex und -Reduktion Implementierung (eta-redex? [...] Implementierung (eta-reduce [...] Implementierung (eta-expand [...]

11 Grammatik des Lambda-Kalkül Untersuchung im Kontext des Lambda-Kalkül Zur genaueren Untersuchung der vorgestellten Transformationen benutzen wir als Kontext die Sprache des Lambda-Kalkül. <exp> ::= <varref> (lambda (<var> <exp> (<exp> <exp> Erweiterung der Grammatik Da in vielen Fällen Konstanten zum Lambda-Kalkül hinzugefügt werden, erweitern wir die Grammatik um Zahlen. Dies beeinträchtigt in keiner Weise die theoretischen Eigenschaften des Lambda-Kalkül. <exp> ::= <number> Aufrufe in diesem Kontext In dieser Grammatik wird die Transformation auf Prozeduraufrufe folgender Form angewendet... ((lambda (var exp rand

12 Transformationsregel und Probleme ((lambda (var exp rand Idee Die Idee ist, dass der Ausdruck exp äquivalent zu einem neuen Ausdruck ist, der entsteht, wenn man in exp die Referenzen von var durch rand ersetzt. exp[rand/var] Problem Bei der Umbenennung von Variablen muss darauf geachtet werden, Konflikte zu vermeiden. Variablen gleichen Namens können unterschiedlich sein. In solch einem Fall können freie Variablen in rand durch Bindungen von var in einem Lambda- Ausdruck in exp eingefangen werden. ((lambda (x (lambda (y (x y (y w ; => (lambda (y ((y w y; Die obige Transformation nach der vorgestellten Idee produziert ein falsches Ergebnis. Die Referenz y in (y w muss frei bleiben. Die Lösung besteht darin, den Namen der inneren Variablen y zu ändern (z.b. z. Dieser neue Name darf in (y w nicht frei sein.

13 Formalisierung der Substitution I Ersetzungsregeln Wie im vorherigen Beispiel gesehen müssen die Ersetzungsregeln formal festgelegt werden, um fehlerfrei zu arbeiten. E[M/x] 1.Regel Wenn E die Variable x ist, ergibt sich als Resultat der Ausdruck M. x[m/x] = M 2.Regel Wenn E eine andere Variable y oder Konstante c ist, ergibt sich als Resultat diese Variable oder Konstante. y[m/x] = y (mit y!= x c[m/x] = c 3.Regel Wenn E eine Application der Form (F G ist, wird die Ersetzung an F und G vorgenommen. (F G[M/x] = (F[M/x] G[M/x]

14 Formalisierung der Substitution II Besondere Beachtung verlangt die Ersetzung, wenn E die Form (lambda (y E' besitzt. 4.Regel Wenn gilt y = x (die Variable, die wir ersetzen, wird die Ersetzung abgebrochen, da in (lambda (x E' die Variable x nicht frei ist. (lambda (x E'[M/x] = (lambda (x E' 5.Regel Die Ersetzung wird ebenfalls beendet wenn x in E' nicht frei ist. (lambda (y E'[M/x] = (lambda (y E' 6.Regel Wenn gilt y!= x und y nicht frei in M ist, kann die Ersetzung in E' vorgenommen werden. (lambda (y E'[M/x] = (lambda (y E'[M/x] 7.Regel Wenn y!= x, x in E' frei und y in M frei ist, kann versehentliches Einfangen auftreten. Die Lösung ist y umzubenennen (α-konversion. Der neue Name darf in E' und M nicht frei sein. (lambda (y E'[M/x] = (lambda (z (E'[z/y][M/x]

15 β-konversion, -Redex und -Reduktion I Definition - β-konversion Die Konversion wird durch Anwendung der unten beschriebenen Regel durchgeführt. Dabei müssen die zuvor aufgestellten Ersetzungsregeln beachtet werden. ((lambda (x E M = E[M/x] Definition - β-redex Ein Ausdruck, auf den die β-konversion angewendet werden kann, heisst β-redex. ((lambda (x E M Definition - β-reduktion Wird die β-konversion von links-nach-rechts angewendet, um ein β-redex zu transformieren, wird von der β-reduktion gesprochen. Eine Anwendung von rechts-nach-links ist ebenfalls möglich, z.b. wenn let in ein Programm eingebracht wird, um Wiederholungen eines Ausdrucks zu vermeiden. ((f (a (b c (a (b c; => ((lambda (x ((f x x (a (b c; => (let ((x (a (b c ((f x x;

16 β-konversion, -Redex und -Reduktion II Beispiele Auf die folgenden Ausdrücke wurde die β-reduktion angewendet. (Aufgabe ((lambda (x E M = E[M/x] ((lambda (x (x (y x z; => (x (y x[z/x] => (z (y z; (1., 2., 3. Regel ((lambda (x (x y (lambda (y (x y; => (x y[(lambda (y (x y/x] => ((lambda (y (x y y; (1., 2., 3. Regel ((lambda (x (lambda (y ((x y z (lambda (a y; => (lambda (y ((x y z[(lambda (a y/x] => (lambda (Y (((lambda (a y Y z; (1., 2., 3., 7. Regel ((lambda (x (lambda (y ((lambda (x (z x (lambda (y (z y (lambda (y y; => (lambda (y ((lambda (x (z x (lambda (y (z y[(lambda (y y/x] => (lambda (y ((lambda (x (z x (lambda (y (z y; (5. Regel

17 (beta-redex? [...] I Aufgabenstellung Es soll geprüft werden, ob ein gegebener Ausdruck ein β-redex ist. ((lambda (x E M ; USAGE: (beta-redex? <parsed-lambda-calculus-expression> ; EXAMPLE: (beta-redex? (parse '((LAMBDA (x (y x z; (def beta-redex? (lambda (exp (if (null? (vector? exp (error 'ERR:beta-redex?:given-expression-must-be-parsed-before-calling-beta-redex? (variant-case exp '( (APP (rator rand (variant-case rator '( (LAMBDA (formal body t (else nil (else nil ;

18 (beta-redex? [...] II ((lambda (x E M ; Beispiele aus Aufgabe (beta-redex? (parse '((LAMBDA (x (x (y x z; >> t; (beta-redex? (parse '((LAMBDA (x (x y (LAMBDA (y (x y; >> t; (beta-redex? (parse '((LAMBDA (x (LAMBDA (y ((x y z (LAMBDA (a y; >> t; (beta-redex? (parse '((LAMBDA (x (LAMBDA (y ((LAMBDA (x (z x (LAMBDA (y (z y (LAMBDA (y y; >> t; ; Beispiele aus Aufgabe (beta-redex? (parse '(LAMBDA (x (y z; >> (; (beta-redex? (parse '((LAMBDA (x (y x z; >> t; (beta-redex? (parse '(LAMBDA (x ((LAMBDA (x (y x z; >> (;

19 (substitute [...] I Aufgabenstellung Gegeben sind die Ausdrücke E, M und die Variable x. Nun soll die Ersetzung E[M/x] durchgeführt werden. (def substitute (lambda (expre exprm varx (if (null? (vector? expre (error 'ERR:substitute:given-first-expression-must-be-parsed-before-calling-substitute (if (null? (vector? exprm (error 'ERR:substitute:given-second-expression-must-be-parsed-before-calling-substitute (variant-case expre `( (VARREF (var (if (eq? var ',varx ',exprm ',expre (LAMBDA (formal body (cond ((eq? formal ',varx ',expre ((null? (FREE? body ',varx ',expre ((null? (eq? formal ',varx (if (null? (FREE? ',exprm formal (make-lambda (list formal (substitute body ',exprm ',varx (if (FREE? body ',varx (substitute (alpha-convert-ast ',expre (symbol ',exprm ',varx (error 'ERR:substitute:undecided:y-isNotEqual-x-and-y-isFreeInM-but-x-isNotFreeInEDash (t (error 'ERR:substitute:should-never-hit-because-X-either-equals-Y-or-not (APP (rator rand (make-app (list (substitute rator ',exprm ',varx (substitute rand ',exprm ',varx (else (error 'substitute:invalid-abstract-syntax ;

20 (substitute [...] II ; Beispiele aus Aufgabe (unparse (substitute (parse '(a b (parse 'c 'b; >> (a c; (unparse (substitute (parse '(LAMBDA (a (a b (parse 'a 'b; >> (LAMBDA (symbol123 (symbol123 a;

21 (beta-reduce [...] I Aufgabenstellung Die β-reduktion soll auf einen gegebenen β-redex Ausdruck angewendet werden. ; USAGE: (beta-reduce <parsed-lambda-calculus-beta-redex-expression> ; EXAMPLE: (unparse (beta-reduce (parse '((LAMBDA (x (y x z; (def beta-reduce (lambda (exp (if (null? (vector? exp (error 'ERR:beta-reduce:given-expression-must-be-parsed-before-calling-beta-reduce (if (null? (beta-redex? exp (error 'ERR:beta-reduce:given-expression-is-no-beta-redex (variant-case exp '( (APP (rator rand (variant-case rator `( (LAMBDA (formal body (substitute body ',rand formal (else (error 'ERR:beta-reduce:no-lambda-found-in-given-expression (else (error 'ERR:beta-reduce:no-application-found-in-given-expression ;

22 (beta-reduce [...] II ; Beispiele aus Aufgabe (unparse (beta-reduce (parse '((LAMBDA (x (y x z; >> (y z; (unparse (beta-reduce (parse '((LAMBDA (x (LAMBDA (y (x y (y w; >> (LAMBDA (symbol123 ((y w symbol123; ; Beispiele aus Aufgabe (unparse (beta-reduce (parse '((LAMBDA (x (x (y x z; >> (z (y z; (unparse (beta-reduce (parse '((LAMBDA (x (x y (LAMBDA (y (x y; >> ((LAMBDA (y (x y y; (unparse (beta-reduce (parse '((LAMBDA (x (LAMBDA (y ((x y z (LAMBDA (a y; >> (LAMBDA (symbol123 (((LAMBDA (a y symbol123 z; (unparse (beta-reduce (parse '((LAMBDA (x (LAMBDA (y ((LAMBDA (x (z x (LAMBDA (y (z y (LAMBDA (y y; >> (LAMBDA (y ((LAMBDA (x (z x (LAMBDA (y (z y; ; Spezielles Beispiel aus Aufgabe (unparse (beta-reduce (parse '((LAMBDA (x (x x (LAMBDA (x (x x; >> ((LAMBDA (x (x x (LAMBDA (x (x x; Im letzten Beispiel entspricht das Resultat dem eingegebenen Ausdruck. Dies liegt nicht daran, dass keine Ersetzung stattgefunden hätte. Die Ersetzung liefert wieder den gleichen Ausdruck.

23 Inhalt η-konversion Einführung - Reduktion von Prozeduren β-konversion Grammatik des Lambda-Kalküls (Wiederholung Transformationsregel und Probleme Formalisierung der Substitution β-konversion, -Redex und -Reduktion Implementierung (beta-redex? [...] Implementierung (substitute [...] Implementierung (beta-reduce [...] η-konversion η-konversion, -Redex und -Reduktion Implementierung (eta-redex? [...] Implementierung (eta-reduce [...] Implementierung (eta-expand [...]

24 η-konversion, -Redex und -Reduktion I Idee Falls eine Prozedur einfach eine zweite Prozedur aufruft und dabei ihre Argumente an die zweite Prozedur übergibt, kann die erste Prozedur entfernt werden. (def extend-ff (lambda (sym val ff (make-extended-ff sym val ff; (def extend-ff make-extended-ff; Definition - η-konversion Die η-konversion wird durch Anwendung der unten beschriebenen Regel durchgeführt. (lambda (x (E x = E Definition - η-redex Ein Ausdruck, auf den die η-konversion angewendet werden kann, heisst η-redex, wobei x in E nicht frei sein darf. (lambda (x (E x Definition - η-reduktion Wird die η-konversion von links-nach-rechts angewendet, um ein η-redex zu transformieren, wird von der η-reduktion gesprochen.

25 (eta-redex? [...] I Aufgabenstellung Es soll geprüft werden, ob ein gegebener Ausdruck ein η-redex ist. (lambda (x (E x (def eta-redex? (lambda (exp (if (null? (vector? exp (error 'ERR:beta-redex?:given-expression-must-be-parsed-before-calling-beta-redex? (variant-case exp '( (LAMBDA (formal body (let ((form formal (variant-case body `( (APP (rator rand (let ((freelist (FREE_VARS rator (if (inlist? freelist ',form nil (variant-case rand '( (VARREF (var (= var ',form (else nil (else nil (else nil ;

26 (eta-redex? [...] II ((lambda (x (E x ; Beispiele aus Aufgabe (eta-redex? (parse '(LAMBDA (x (y x; >> t; (eta-redex? (parse '(LAMBDA (x ((LAMBDA (y y x; >> t; (eta-redex? (parse '((LAMBDA (x (y x z; >> (; (eta-redex? (parse '(LAMBDA (x ((LAMBDA (y x x; >> (;

27 (eta-reduce [...] I Aufgabenstellung Die η-reduktion soll auf einen gegebenen η-redex Ausdruck angewendet werden. ; USAGE: (eta-reduce <parsed-lambda-calculus-beta-redex-expression> ; EXAMPLE: (unparse (eta-reduce (parse '(LAMBDA (x (y x; (def eta-reduce (lambda (exp (if (null? (vector? exp (error 'ERR:eta-reduce:given-expression-must-be-parsed-before-calling-eta-reduce (if (null? (eta-redex? exp (error 'ERR:eta-reduce:given-expression-is-no-eta-redex (variant-case exp '( (LAMBDA (formal body (variant-case body `( (APP (rator rand rator (else exp (else exp ;

28 (eta-reduce [...] II ; Beispiel aus Aufgabe (unparse (eta-reduce (parse '(LAMBDA (x ((LAMBDA (y y x; >> (LAMBDA (y y; ; Beispiel aus Aufgabe (unparse (eta-reduce (parse '(LAMBDA (x (y x; >> y;

29 (eta-expand [...] Aufgabenstellung Ein vorhandener Ausdruck exp soll in die folgende Form gebracht werden. ((lambda (x (exp x ; USAGE: (eta-expand <parsed-lambda-calculus-expression> ; EXAMPLE: (unparse (eta-expand (parse '(LAMBDA (y y; (def eta-expand (lambda (exp (let ((newsym (symbol (make-lambda (list newsym (make-app (list exp (make-varref (list newsym ; ; Beispiele aus Aufgabe (unparse (eta-expand (parse '(LAMBDA (y y; >> (LAMBDA (symbol123 ((LAMBDA (y y symbol123; (unparse (eta-expand (parse '((LAMBDA (v (LAMBDA (y (v y (LAMBDA (x x; >> (LAMBDA (symbol123 (((LAMBDA (v (LAMBDA (y (v y (LAMBDA (x x symbol123;

30 Ende End Fin - Conclude Vielen Dank für Eure Aufmerksamkeit! Fragen? (prog (println 'Vielen 'Dank (if (eq? fragen 1 (error 'ERR:gotta-go (println 'Thanks ;