Reduction Rules Stefan Hertel, Thomas Wöllert

Vortrag

Reduction Rules

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

von Stefan Hertel (sh_ccbiker@gmx.de)Thomas Wöllert (thomas@woellert.net)

β- and η-Conversion

Reduction Rules Stefan Hertel, Thomas Wöllert

Inhalt

β-KonversionGrammatik 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 [...])

Einführung - Reduktion von Prozeduren

Reduction Rules Stefan Hertel, Thomas Wöllert

Inhalt – Einführung

β-KonversionGrammatik 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 [...])

Einführung - Reduktion von Prozeduren

Reduction Rules Stefan Hertel, Thomas Wöllert

Reduktion von Prozeduren I

ProblemstellungAuswertung eines Prozeduraufrufs.

(def foo(lambda (x y)

(+ (* x 3) y))

);

(foo (+ 4 1) 7);

A-priori KenntnisTritt 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 (+ 4 1) 7);

(+ (* (+ 4 1) 3) 7);

22;

Regel (informell)Um das Resultat eines Prozeduraufrufs zu erhalten, müssen die formalen Parameter imbody der Prozedur durch ihre passenden Argumente (vom Aufruf der Prozedur) ersetzt werden. (ABER: Einschränkungen dieser Regel notwendig! Siehe 4.3.1)

Reduction Rules Stefan Hertel, Thomas Wöllert

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 (+ 4 1) 7);

=> ((lambda (x y) (+ (* x 3) y))(+ 4 1)7

);

=> (+ (* (+ 4 1) 3) 7);

=> 22;

Reduction Rules Stefan Hertel, Thomas Wöllert

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 (+ 4 1) 7);

=> (foo 5 7);

=> (+ (* 5 3) 7);

=> (+ 15 7);

=> 22;

Reduction Rules Stefan Hertel, Thomas Wöllert

Reduktion von Prozeduren IV

(def c+(lambda (n)

(lambda (m)(+ n m)

))

);

((c+ 5) 3);

=> ((lambda (m) (+ 5 m)) 3);

=> (+ 5 3);

=> 8;

Schrittweise Ausführung der Ersetzung (Variante 3)Ebenso ist es möglich, die aufgerufenen Prozeduren schrittweise zu ersetzen.

Reduction Rules Stefan Hertel, Thomas Wöllert

Reduktion von Prozeduren V

„Sugaring Rules“ transformierenEinige Spezialformen (z.B. let) stellen nur syntaktischen „Zucker“ anderer Formen dar. Solche „Zucker Regeln“ können daher ebenso durch Transformationen ausgedrückt werden.

(let ((var1 exp

1) ... (var

n exp

n))

body)

((lambda (var1 ... var

n) body)

exp1 ... exp

n)

(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;

Anwendung mit ErsetzungenDiese Regeln können zusammen mit den (bereits vorgestellten) Ersetzungen angewendet werden, um komplexe Ausdrücke auszuwerten.

Reduction Rules Stefan Hertel, Thomas Wöllert

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 1 2 3)))(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.

Reduction Rules Stefan Hertel, Thomas Wöllert

Inhalt – -Konversionβ

β-KonversionGrammatik 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 [...])

Einführung - Reduktion von Prozeduren

Reduction Rules Stefan Hertel, Thomas Wöllert

Grammatik des Lambda-Kalkül

Untersuchung im Kontext des Lambda-KalkülZur genaueren Untersuchung der vorgestellten Transformationen benutzen wir als Kontext die Sprache des Lambda-Kalkül.

<exp> ::= <varref>| (lambda (<var>) <exp>)| (<exp> <exp>)

Erweiterung der GrammatikDa 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 KontextIn dieser Grammatik wird die Transformation auf Prozeduraufrufe folgender Form angewendet ...

((lambda (var) exp) rand)

Reduction Rules Stefan Hertel, Thomas Wöllert

Transformationsregel und Probleme

IdeeDie 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.

((lambda (var) exp) rand)

exp[rand/var]

ProblemBei 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.

Reduction Rules Stefan Hertel, Thomas Wöllert

Formalisierung der Substitution I

ErsetzungsregelnWie im vorherigen Beispiel gesehen müssen die Ersetzungsregeln formal festgelegt werden, um fehlerfrei zu arbeiten.

1.RegelWenn E die Variable x ist, ergibt sich als Resultat der Ausdruck M.

E[M/x]

x[M/x] = M

2.RegelWenn 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.RegelWenn 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])

Reduction Rules Stefan Hertel, Thomas Wöllert

Formalisierung der Substitution II

Besondere Beachtung verlangt die Ersetzung, wenn E die Form (lambda (y) E') besitzt.

4.RegelWenn 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.RegelDie Ersetzung wird ebenfalls beendet wenn x in E' nicht frei ist.

(lambda (y) E')[M/x] = (lambda (y) E')

6.RegelWenn 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.RegelWenn 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])

Reduction Rules Stefan Hertel, Thomas Wöllert

-Konversion, -Redex und -Reduktion Iβ

Definition - β-KonversionDie 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 - β-RedexEin Ausdruck, auf den die β-Konversion angewendet werden kann, heisst β-Redex.

((lambda (x) E) M)

Definition - β-ReduktionWird 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));

Reduction Rules Stefan Hertel, Thomas Wöllert

-Konversion, -Redex und -Reduktion IIβ

BeispieleAuf die folgenden Ausdrücke wurde die β-Reduktion angewendet. (Aufgabe 4.2.1)

((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) E) M) = E[M/x]

((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)

Reduction Rules Stefan Hertel, Thomas Wöllert

(beta-redex? [...]) I

AufgabenstellungEs 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))

))

));

Reduction Rules Stefan Hertel, Thomas Wöllert

(beta-redex? [...]) II

; Beispiele aus Aufgabe 4.2.1(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 4.2.2(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))));>> ();

((lambda (x) E) M)

Reduction Rules Stefan Hertel, Thomas Wöllert

(substitute [...]) I

AufgabenstellungGegeben 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))

))))));

Reduction Rules Stefan Hertel, Thomas Wöllert

(substitute [...]) II

; Beispiele aus Aufgabe 4.2.3(unparse (substitute (parse '(a b)) (parse 'c) 'b));>> (a c);

(unparse (substitute (parse '(LAMBDA (a) (a b))) (parse 'a) 'b));>> (LAMBDA (symbol123) (symbol123 a));

Reduction Rules Stefan Hertel, Thomas Wöllert

(beta-reduce [...]) I

AufgabenstellungDie β-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))

))

))

));

Reduction Rules Stefan Hertel, Thomas Wöllert

(beta-reduce [...]) II

; Beispiele aus Aufgabe 4.2.4(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 4.2.1(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 4.2.4(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.

Reduction Rules Stefan Hertel, Thomas Wöllert

Inhalt – -Konversionη

β-KonversionGrammatik 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 [...])

Einführung - Reduktion von Prozeduren

Reduction Rules Stefan Hertel, Thomas Wöllert

-Konversion, -Redex und -Reduktion Iη

Definition - η-KonversionDie η-Konversion wird durch Anwendung der unten beschriebenen Regel durchgeführt.

(lambda (x) (E x)) = E

Definition - η-RedexEin Ausdruck, auf den die η-Konversion angewendet werden kann, heisst η-Redex, wobei x in E nicht frei sein darf.

(lambda (x) (E x))

Definition - η-ReduktionWird die η-Konversion von links-nach-rechts angewendet, um ein η-Redex zu transformieren, wird von der η-Reduktion gesprochen.

IdeeFalls 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);

Reduction Rules Stefan Hertel, Thomas Wöllert

(eta-redex? [...]) I

AufgabenstellungEs 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)

)))));

Reduction Rules Stefan Hertel, Thomas Wöllert

; Beispiele aus Aufgabe 4.2.5(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))));>> ();

((lambda (x) (E x))

(eta-redex? [...]) II

Reduction Rules Stefan Hertel, Thomas Wöllert

(eta-reduce [...]) I

AufgabenstellungDie η-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)

))

))

));

Reduction Rules Stefan Hertel, Thomas Wöllert

(eta-reduce [...]) II

; Beispiel aus Aufgabe 4.2.6(unparse (eta-reduce (parse '(LAMBDA (x) ((LAMBDA (y) y) x)))));>> (LAMBDA (y) y);

; Beispiel aus Aufgabe 4.2.5(unparse (eta-reduce (parse '(LAMBDA (x) (y x)))));>> y;

Reduction Rules Stefan Hertel, Thomas Wöllert

(eta-expand [...])

AufgabenstellungEin vorhandener Ausdruck exp soll in die folgende Form gebracht werden.

; 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)))))))

));

((lambda (x) (exp x))

; Beispiele aus Aufgabe 4.2.7(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));

Reduction Rules Stefan Hertel, Thomas Wöllert

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)

));