Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence
|
|
|
- Hannelore Messner
- vor 5 Jahren
- Abrufe
Transkript
1 Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence David Sabel Goethe-Universität, Frankfurt 19. August 2008
2 Einleitung Übersicht 1 Motivation und Einleitung 2 Der amb-kalkül 3 Kontextuelle Gleichheit und Korrektheit von Programmtransformationen 4 Standardisierung und weitere Beweismethoden 5 Die nebenläufige abstrakte Maschine 6 Fazit & Ausblick David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 2
3 Einleitung Motivation Motivation Compiler-Korrektheit Korrektheit: Transformation ohne Änderung der Programmsemantik Benötigt formales Modell zur einheitlichen Beschreibung der Semantik Techniken für Korrektheitsnachweise von Programmtransformationen Welche Programmiersprachen? Parallele / Nebenläufige Programmierkonstrukte: Hardware: Multicore-Architekturen, Software: Multiuser-, Multithreaded-Systeme Funktionale Programmiersprachen (FP): deklarativ, modularer Entwurf, mathematisch einfach(er) handhabbar, Typisierung Verzögert-auswertende FP: erlauben Parallelisierung, Umgang mit unendlichen Datenstrukturen (z.b. Ströme) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 3
4 Einleitung Motivation Untersuchung Modell Kernsprache einer verzögert auswertenden FP mit letrec, Datenkonstruktoren, case-ausdrücken, seq McCarthy s [McCarthy, 1963] amb-operator: amb s t wählt s oder t, aber muss divergentes Argument vermeiden nebenläufige Auswertung von s und t unter Beachtung von Fairness viele nichtdeterministische Operatoren kodierbar Programmtransformationen Transformationen / Optimierung innerhalb derselben Sprache z.b. Prozedureinsetzung, partielles Auswerten,... Übersetzung von einer Sprache in eine (maschinennähere) Sprache. David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 4
5 Einleitung Motivation Welche Semantik? Axiomatische Detationale Formale Semantik Operationale axiomatische Semantik: eher für imperative PS detationale Semantik: schwer im nichtdeterministischen Fall, amb: keine brauchbaren detationalen Modelle Gewählter Ansatz Operationale small-step Semantik kontextuelle Äquivalenz bezüglich may- und must-konvergenz kanischen Gleichheitsbegriff mit maximaler Menge an Gleichheiten David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 5
6 Einleitung Motivation Related work Schmidt-Schauß 03, TR FUNDIO-calculus Diagramme, faire must, Kontextlemma Carayol et al. 05, TCS encoding amb in π-calculus amb, faire must Ong 93, LICS ndeterminism functional setting erste may/must Moran 98, Diss. call-by-name, call-by-need and amb amb, may/must Kutzner&Schmidt-Schauß 98, ICFP ndet. call-by-need lambda-calculus Diagramme, may/must Moran et al. 03, SciCo erratic fudgets Kontextlemma, may/must, Anwendungen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 6
7 Einleitung Syntax Kodierungen Semantik Fairness Der amb-kalkül Syntax E ::= V (Variable) (λv.e) (Abstraktion) (E 1 E 2 ) (Applikation) (letrec V 1 = E 1,... V n = E n in E) (letrec-ausdruck) (case T E Alt 1... Alt T ) (case-ausdruck) (c T,i E 1... E ar(ct,i )) (Konstruktorapplikation) (seq E 1 E 2 ) (seq-ausdruck) (amb E 1 E 2 ) (amb-ausdruck) Alt ::= ((c T,i V 1... V ar(ct,i )) E) (case-alternative) klassischer Lambdakalkül +rekursive let-ausdrücke +case & Konstruktoren +sequentielle Auswertungen +nichtdeterministisches amb if s 1 then s 2 else s 3 case Bool s 1 (True s 2) (False s 3) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 7
8 Einleitung Syntax Kodierungen Semantik Fairness Kodierungen mittels amb par λx.λy.amb (seq x y) y spar λx.λy.amb (seq x (seq y (Pair x y))) (seq y (seq x (Pair x y))) choice λx.λy.((amb λz 1.x λz 2.y) True) dchoice λx.λy.amb (seq x (seq y x)) (seq y (seq x y)) por λx.λy.amb (if x then True else y) (if y then True else x) pconv λx.λy.λz.if (amb (seq x True) (seq y True)) then z else z a 1 b 1 b 2 a 2 a 3 b 3 a 4 b 4 b 5... merge a 1 a 2 a 3 a 4... b 1 b 2 b 3 b 4 b 5... Divergenz-vermeidendes Merge (kodierbar): Falls ein Eingabestrom endlich oder partiell, dann erscheinen alle Elemente des anderen Unendlich-faires Merge (kodierbar): Wenn ein Eingabestrom unendlich, dann erscheinen alle Elemente des anderen Faires Merge: amb kann faires Merge nicht kodieren [Panangaden, 1988] David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 8
9 Einleitung Syntax Kodierungen Semantik Fairness Semantik Kontexte C C: Ausdrücke mit einem Loch [ ] Werte: Abstraktionen λx.s und Konstruktorapplikationen (c T,i s 1... s ar(ct,i )) Deterministische Reduktionsregeln (lbeta) (λx.s) r (letrec x = r in s) (cp) letrec x 1 = λx.s, x 2 = x 1..., x m = x m 1... C[x m]... letrec x 1 = λx.s, x 2 = x 1,... x m = x m 1... C[λx.s] Regeln zur case- und seq-auswertung, let-verschiebungen Nichtdeterministische Reduktionsregeln: (amb) (amb-l) amb v t v (v Wert) letrec x 1 = v, x 2 = x 1..., x m = x m 1... C[amb x m t]... (v Wert) letrec x 1 = v, x 2 = x 1,... x m = x m 1... C[x m]... (amb-r) amb t v v (v Wert) letrec x 1 = v, x 2 = x 1..., x m = x m 1... C[amb t x m]... (v Wert) letrec x 1 = v, x 2 = x 1,... x m = x m 1... C[x m]... David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 9
10 Einleitung Syntax Kodierungen Semantik Fairness Normalordnungsreduktion = Anwenden einer Reduktionsregel mithilfe eines maximalen Reduktionskontextes Maximalen Reduktionkontext finden: Unwinding-Algorithmus UW uw((s t), R) uw(s, R[([ ] t)]) uw(seq s t, R) uw(s, R[seq [ ] t]) uw(case T s alts, R) uw(s, R[case T [ ] alts]) uw(amb s t, R) uw(s, R[amb [ ] t]) oder uw(t, R[amb s [ ]]) uw(x, (letrec x = s, Env in R )) uw(s, (letrec x = [ ], Env in R [x])) uw(x, (letrec y = R, x = s, Env in t)) uw(s, (letrec y = R [x], x = [ ], Env in t)) uw(s, R) (s, R) falls keine andere Regel anwendbar Beispiel: letrec x 2 = λx.x, x 1 = (x 2 x 1 ), x 3 = (amb (x 2 x 1 ) y) in amb x 1 x 3 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 10
11 Einleitung Syntax Kodierungen Semantik Fairness Normalordnungsreduktion = Anwenden einer Reduktionsregel mithilfe eines maximalen Reduktionskontextes Maximalen Reduktionkontext finden: Unwinding-Algorithmus UW uw((s t), R) uw(s, R[([ ] t)]) uw(seq s t, R) uw(s, R[seq [ ] t]) uw(case T s alts, R) uw(s, R[case T [ ] alts]) uw(amb s t, R) uw(s, R[amb [ ] t]) oder uw(t, R[amb s [ ]]) uw(x, (letrec x = s, Env in R )) uw(s, (letrec x = [ ], Env in R [x])) uw(x, (letrec y = R, x = s, Env in t)) uw(s, (letrec y = R [x], x = [ ], Env in t)) uw(s, R) (s, R) falls keine andere Regel anwendbar Beispiel: letrec x 2 = λx.x, x 1 = (x 2 x 1 ), x 3 = (amb (x 2 x 1 ) y) in amb x 1 x 3 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 10
12 Einleitung Syntax Kodierungen Semantik Fairness Normalordnungsreduktion = Anwenden einer Reduktionsregel mithilfe eines maximalen Reduktionskontextes Maximalen Reduktionkontext finden: Unwinding-Algorithmus UW uw((s t), R) uw(s, R[([ ] t)]) uw(seq s t, R) uw(s, R[seq [ ] t]) uw(case T s alts, R) uw(s, R[case T [ ] alts]) uw(amb s t, R) uw(s, R[amb [ ] t]) oder uw(t, R[amb s [ ]]) uw(x, (letrec x = s, Env in R )) uw(s, (letrec x = [ ], Env in R [x])) uw(x, (letrec y = R, x = s, Env in t)) uw(s, (letrec y = R [x], x = [ ], Env in t)) uw(s, R) (s, R) falls keine andere Regel anwendbar Beispiel: letrec x 2 = λx.x, x 1 = (x2 x 1 ), x 3 = (amb (x 2 x 1 ) y) in amb x 1 x 3 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 10
13 Einleitung Syntax Kodierungen Semantik Fairness Normalordnungsreduktion = Anwenden einer Reduktionsregel mithilfe eines maximalen Reduktionskontextes Maximalen Reduktionkontext finden: Unwinding-Algorithmus UW uw((s t), R) uw(s, R[([ ] t)]) uw(seq s t, R) uw(s, R[seq [ ] t]) uw(case T s alts, R) uw(s, R[case T [ ] alts]) uw(amb s t, R) uw(s, R[amb [ ] t]) oder uw(t, R[amb s [ ]]) uw(x, (letrec x = s, Env in R )) uw(s, (letrec x = [ ], Env in R [x])) uw(x, (letrec y = R, x = s, Env in t)) uw(s, (letrec y = R [x], x = [ ], Env in t)) uw(s, R) (s, R) falls keine andere Regel anwendbar Beispiel: letrec x 2 = λx.x, x 1 = (x2 x 1 ), x 3 = (amb (x 2 x 1 ) y) in amb x 1 x 3 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 10
14 Einleitung Syntax Kodierungen Semantik Fairness Normalordnungsreduktion = Anwenden einer Reduktionsregel mithilfe eines maximalen Reduktionskontextes Maximalen Reduktionkontext finden: Unwinding-Algorithmus UW uw((s t), R) uw(s, R[([ ] t)]) uw(seq s t, R) uw(s, R[seq [ ] t]) uw(case T s alts, R) uw(s, R[case T [ ] alts]) uw(amb s t, R) uw(s, R[amb [ ] t]) oder uw(t, R[amb s [ ]]) uw(x, (letrec x = s, Env in R )) uw(s, (letrec x = [ ], Env in R [x])) uw(x, (letrec y = R, x = s, Env in t)) uw(s, (letrec y = R [x], x = [ ], Env in t)) uw(s, R) (s, R) falls keine andere Regel anwendbar Beispiel: letrec x 2 = λx.x, x1 = (x2 x 1 ), x 3 = (amb (x 2 x 1 ) y) in amb x 1 x 3 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 10
15 Einleitung Syntax Kodierungen Semantik Fairness May- und Must-Konvergenz Weak Head Normal Form (WHNF) Werte (Abstraktionen, Konstruktoranwendungen) letrec Env in v, wobei v ein Wert ist letrec x 1 = (c T,i s 1... s n), x 2 = x 1,..., x m = x m 1, Env in x m May-Konvergenz s gdw. t : s, t, t WHNF reduzibel zu einer WHNF Must-Divergenz s gdw. s nicht reduzibel zu einer WHNF David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 11
16 Einleitung Syntax Kodierungen Semantik Fairness May- und Must-Konvergenz Weak Head Normal Form (WHNF) Werte (Abstraktionen, Konstruktoranwendungen) letrec Env in v, wobei v ein Wert ist letrec x 1 = (c T,i s 1... s n), x 2 = x 1,..., x m = x m 1, Env in x m May-Konvergenz s gdw. t : s, t, t WHNF reduzibel zu einer WHNF Must-Konvergenz s gdw. t : s, t = t Must-Divergenz s gdw. s nicht reduzibel zu einer WHNF May-Divergenz s gdw. s jeder Nachfolger ist may-konvergent = t : s, t, t reduzibel zu must-divergentem Term David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 11
17 Einleitung Syntax Kodierungen Semantik Fairness Normalordungsreduktion ist nicht fair Fairness in einer unendlichen Reduktionssequenz, wird jeder Redex nach einer endlichen Anzahl von Schritten reduziert Normalordnungsreduktion kann einen Redex unendlich oft igrieren: amb Ω 1 True amb Ω 2 True amb Ω 3 True amb Ω 4 True amb Ω 5 True... David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 12
18 Einleitung Syntax Kodierungen Semantik Fairness Normalordungsreduktion ist nicht fair Fairness in einer unendlichen Reduktionssequenz, wird jeder Redex nach einer endlichen Anzahl von Schritten reduziert Normalordnungsreduktion kann einen Redex unendlich oft igrieren: amb Ω 1 True amb Ω 2 True amb Ω 3 True True amb Ω 4 True amb Ω 5 True... David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 12
19 Einleitung Syntax Kodierungen Semantik Fairness Normalordungsreduktion ist nicht fair Fairness in einer unendlichen Reduktionssequenz, wird jeder Redex nach einer endlichen Anzahl von Schritten reduziert Normalordnungsreduktion kann einen Redex unendlich oft igrieren: amb Ω 1 True amb Ω 2 True amb Ω 3 True True amb Ω 4 True amb Ω 5 True... = verwendet man Normalordnungsreduktion so ist amb nicht Divergenz-vermeidend! David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 12
20 Einleitung Syntax Kodierungen Semantik Fairness Fairness zusichern Hinzufügen von Ressourcen: Antierte Varianten statt amb s t nun amb m,n s t mit m, n IN 0 (am Anfang alle 0) Faires Unwinding mit Ressourcen... uwf((amb m+1,n s t), R) uwf(s, R[(amb m,n [ ] t)]) uwf((amb m,n+1 s t), R) uwf(t, R[(amb m,n s [ ])]) uwf((amb 0,0 s t), R) uwf((amb m,n s t), R), wobei m, n>0... s f t 1 Wende fairen Unwindingalgorithmus auf s an (s, R) 2 Wenn N.O.-Reduktion auf R[s ] unter Benutzung von R anwendbar (Ressourcen igrieren), dann s f t 3 Andernfalls: Gehe zu 1, mit R[s ] für s David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 13
21 Einleitung Syntax Kodierungen Semantik Fairness f Konvergenz-Äquivalenz und Beispiel: amb 0,0 Ω 1 True f f amb m 1,n Ω 2 True f f amb m 2,n Ω 3 True f True f... f f amb 0,n Ω m+1 True m, n > 0 Faire may- und must-konvergenz s F gdw. t : s f, t, t ann. WHNF s F gdw. t : s f, t = t F Theorem Für alle Ausdrücke s: s gdw. s F und s gdw. s F David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 14
22 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Prinzip der kontextuellen Gleichheit Zwei Programme sind gleich gdw. sie sich in jedem Programmkontext gleich verhalten David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 15
23 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Prinzip der kontextuellen Gleichheit Zwei Programme sind gleich gdw. sie sich in jedem Programmkontext gleich verhalten Verhalten = may- und must-konvergenz Zwei kontextuelle Präordnungen für may-konvergenz s c t gdw. C C : C[s] C[t] für must-konvergenz s c t gdw. C C : C[s] C[t] Kontextuelle Präordnung / Kontextuelle Äquivalenz c = c c c = c c David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 15
24 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheit von Programmtransformationen Programmtransformation P = binäre Relation über Ausdrücken P ist korrekt gdw. P erhält die kontextuelle Gleichheit = P c Korrektheit zu widerlegen ist einfach... finde Gegenbeispiel: Kontext, der die Ausdrücke unterscheidet Beispiel: (choice Ω True) c True denn für C = [ ] gilt C[True], aber C[(choice Ω True)], Beweisen der Korrektheit ist wesentlich schwieriger... Die unendliche Menge aller Kontexte muss betrachtet werden! David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 16
25 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Kontextlemma es reicht aus Reduktionskontexte zu betrachten s c,r t gdw. R R : R[s] = R[t] s c,r t gdw. R R : R[s] = R[t] c,r := c,r c,r c,r c für may-konvergenz c,r = c für must-konvergenz ( c,r c,r ) c David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 17
26 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheitsbeweis von Programmtransformationen Beweisskizze (zeige P c ) Sei P eine Programmtransformation Zeige für alle s, t und Reduktionskontexte R mit R[s] P R[t]: P erhält die may-konvergenz: R[s] = R[t] R[t] = R[s] P erhält die must-konvergenz: R[s] = R[t] R[t] = R[s] Das Kontextlemma impliziert dann die Korrektheit David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 18
27 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheitsbeweis von Programmtransformationen Beweisskizze (zeige P c ) Sei P eine Programmtransformation Zeige für alle s, t und Oberflächenkontexte S mit S[s] P S[t]: P erhält die may-konvergenz: S[s] = S[t] S[t] = S[s] P erhält die must-konvergenz: S[s] = S[t] S[t] = S[s] Das Kontextlemma impliziert dann die Korrektheit David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 18
28 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheitsbeweis von Programmtransformationen Beweisskizze (zeige P c ) Sei P eine Programmtransformation Zeige für alle s, t mit s S,P t: P erhält die may-konvergenz: s = t t = s P erhält die must-konvergenz: s = t t = s Das Kontextlemma impliziert dann die Korrektheit David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 18
29 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Gabel- und Vertauschungsdiagramme für P Diagramme sind meta-rewriting Regeln bp P c, f rel binäre Relation auf Ausdrücken k 1 + k 2 > 0 c, 1 S, b P rel,k 1 Gabeldiagramm f,k 2 f,k 2 is, b P rel,k 1 c, 1 Vertauschungsdiagramm David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 19
30 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Gabel- und Vertauschungsdiagramme für P Diagramme sind meta-rewriting Regeln bp P c, f rel binäre Relation auf Ausdrücken k 1 + k 2 > 0 c, 1 S, b P f,k 2 rel,k 1 Menge von Gabeldiagrammen ist vollständig gdw. es für jede s S,P r ein anwendbares Diagramm gibt t f,k 2 is, b P c, 1 rel,k 1 Menge von Vert.-diagrammen ist vollständig gdw. es für jede s is,p t r ein anwendbares Diagramm gibt David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 19
31 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der may-konvergenz zeige s = t s s WHNF S,P t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 20
32 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der may-konvergenz zeige s = t s s WHNF S,P S,P t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 20
33 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der may-konvergenz zeige s = t s S,P S,P t S,P s S,P t WHNF WHNF David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 20
34 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der may-konvergenz zeige s = t zeige t = s s S,P S,P t S,P s S,P t s is,p t t WHNF WHNF WHNF David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 20
35 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der may-konvergenz zeige s = t s S,P S,P t S,P s S,P t zeige t = s s is,p is,p t is,p s is,p t WHNF WHNF WHNF WHNF David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 20
36 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheitbeweis einer Transformation Beweisskizze Zeige für alle s, t mit s S,P t: P erhält die may-konvergenz: s = t t = s P erhält die must-konvergenz: s = t? t = s David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 21
37 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Korrektheitbeweis einer Transformation Beweisskizze Zeige für alle s, t mit s S,P t: P erhält die may-konvergenz: s = t t = s P erhält die must-konvergenz (= erhält die may-divergenz): s = t äquivalent zu t = s t = s äquivalent zu s = t s äquivalenz zu t : s, t t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 21
38 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Erhaltung der must-konvergenz zeige s = t s S,P S,P t S,P s S,P t zeige t = s s is,p is,p t is,p s is,p t mustdivergent mustdivergent mustdivergent mustdivergent David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 22
39 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Diagramme sind im Allgemeinen komplexer,a S,lll S,lll,a,a S,lll,a,lll S,lll,lll,+,lll,+,a,lamb,lll,+,lll,+,a,amb S,lamb S,gc 1,lll,,amb = speziellere Induktionsmaße und stärkere Behauptungen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 23
40 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Ergebnisse: Korrekte Programmtransformationen Alle deterministischen Kalkülregeln (d.h. partielle Auswertung ist korrekt): (lbeta) (λx.s) r (letrec x = r in s) (cp) letrec x 1 = λx.s, x 2 = x 1..., x m = x m 1... C[x m]... letrec x 1 = λx.s, x 2 = x 1,... x m = x m 1... C[λx.s]... (seq) seq v t t (v Wert) letrec x 1 = v, x 2 = x 1..., x m = x m 1... C[seq x m t]... (v Wert) letrec x 1 = (λx.s), x 2 = x 1,... x m = x m 1... C[t]... (llet-in) (letrec Env 1 in (letrec Env 2 in r)) (letrec Env 1, Env 2 in r) (llet-e) (letrec x 1 = s 1,..., x i = (letrec Env 2 in s i ),..., x n = s n in r) (letrec x 1 = s 1,..., x i = s i,..., x n = s n, Env 2 in r) (lapp) (lcase) (lseq) ((letrec Env in t) s) (letrec Env in (t s)) (case T (letrec Env in t) alts) (letrec Env in (case T t alts)) (seq (letrec Env in s) t) (letrec Env in (seq s t)) (lamb-l) (amb (letrec Env in s) t) (letrec Env in (amb s t)) (lamb-r) (amb s (letrec Env in t)) (letrec Env in (amb s t)) (case) case T c T,i... (c T,i t)... t letrec x 1 = c T,i, x 2 = x 1,..., x m = x m 1... C[case T x m... (c T,i t)...]... letrec x 1 = c T,i, x 2 = x 1,..., x m = x m 1... C[t]... case T (c T,i t 1... t n)... ((c T,i y 1... y n) t)... letrec y 1 = t 1,..., y n = t n in t letrec x 1 = (c T,i t 1... t n), x 2 = x 1,..., x m = x m 1... C[case T x m... ((c T,i z 1... z n) t)...] letrec x 1 = (c T,i y 1... y n), y 1 = t 1,..., y n = t n, x 2 = x 1,..., x m = x m 1... C[letrec z 1 = y 1,..., z n = y n in t]... David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 24
41 Einleitung Kontextuelle Äquivalenz Programmtransformationen Beweistechnik Ergebnisse Ergebnisse: Korrekte Programmtransformationen Garbage collection letrec x 1 = s 1,..., x n = s n in t t wenn x i FV (t) letrec x 1 = s 1,..., x n = s n, Env in t letrec Env in t wenn x i FV (t) Kopieren von Variablen und Konstruktoren letrec x = y,... C[x]... letrec x = y,... C[y]... letrec x = (c s i ),... C[x]... letrec x = (c y i ), {y i = s i } ar(c) i=1,... C[(c y i )]... Kopieren von Ausdrücken mit nur einem Vorkommen (Inlining) letrec x = s,... S[x]... letrec... S[s]..., wenn x nur einmal vorkommt letrec x = s in S[x] S[s], wenn x nur einmal vorkommt und einige mehr ((abs), (xch), (lappr), (lseqr), (lcons)) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 25
42 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Standardisierungstheorem wobei Wenn t C,(ptc amb), t wobei t eine WHNF ist, dann gilt t. Wenn t (C,ptc) (S,ambs), t wobei t, dann gilt t. ptc korrekte Programmtransformationen (ambs) eingeschränkte (amb)-reduktion letrec x 1 = v, x 2 = x 1..., x m = x m 1... S[amb x m t]... letrec x 1 = (λx.s), x 2 = x 1,... x m = x m 1... S[x m]... Beweis erfordert eine Untersuchung der (amb)-reduktion: c c c c c,s (amb) (ambs) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 26
43 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
44 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
45 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
46 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
47 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
48 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
49 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
50 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
51 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Endliche Simulation mit vollständigen Nachfolgermengen Vollständige Nachfolgermenge M CSS(s) eines Ausdrucks s := alle Blätter eines gültigen Schnitts des Auswertungsbaums s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 Kontextuelle Äquivalenz auf endl. Mengen M, N endliche Mengen von Ausdrücken: M N gdw. ( s M : t N : s c t) M N gdw. ( t N : s M : s c t) :=, := Theorem Seien s, t geschlossene Ausdrücke, M CSS(s), N CSS(t). M N = s c t. Beispiel s := (amb True False) und t := (amb False True) {True, False} CSS(s) CSS(t), d.h. s c t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 27
52 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Untersuchung der Kontextuellen Ordnung und Äquivalenz Der bottom-avoiding -Kontext BA (amb (λx.x) (seq [ ] (λx.ω))) (λx.x) für alle s: BA[s] gdw. s impliziert: must-konvergenz kann auf must-divergenz testen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 28
53 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Untersuchung der Kontextuellen Ordnung und Äquivalenz Der bottom-avoiding -Kontext BA (amb (λx.x) (seq [ ] (λx.ω))) (λx.x) für alle s: BA[s] gdw. s impliziert: must-konvergenz kann auf must-divergenz testen Theorem c c s c t = s c t (aber c c ) s c t gdw. C : C[s] C[t] David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 28
54 Einleitung Standardisierungstheorem Endliche Simulation Eigenschaften Kontextuelle Ordnung Charakteristische Gesetze Bewiesene charakteristische Gesetze (amb s t) c t c (amb t s), wenn s ein Ω-Term (dchoice v 1 v 2 ) c (amb v 1 v 2 ) c (choice v 1 v 2 ), geschlossene Werte v 1, v 2 (amb v v) c v, v Wert (amb s t) c (amb t s) (amb v 1 (amb v 2 v 3 )) c amb((amb v 1 v 2 ) v 3 ), v i geschlossene Werte (choice s t) c (choice t s), s, t geschlossen (choice s s) c s, s geschlossen (choice s 1 (choice s 2 s 3 )) c (choice(choice s 1 s 2 ) s 3 ), s i geschlossen (pconv s t r) c r, s, t geschlossen, s t (por s True) c True c (por True s) (por False False) c False David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 29
55 Einleitung Überblick Zustand Transition Beispiel Korrektheit Abstrakte Maschinensemantik Vorteile einer abstrakten Maschinensemantik Maschinentransitionen kleinschrittiger als Normalordnungsreduktionen Unwinding explizit durch Maschinentransitionen modelliert Ergebnisse des Unwinding auf Stacks gespeichert einfach implementierbares Modell Die Concurrent Abstract Machine CAM Basis: Sestoft s Maschine mark 1 [Sestoft, 1997] für verzögerte Auswertung Moran s Erweiterung der mark 1 um Nebenläufigkeit [Moran, 1998] aber: Syntax: Anpassungen gegenüber Moran, da seine Maschine nicht korrekt hierachische Organisation der Threads mittels Prozessbäumen eingeschränkt: nur Variablen als Argument von (Konstruktor-) Applikationen Übersetzung: (s t) letrec x = t in (s x), bzw. (c s 1... s n) letrec x 1 = s 1,... x n = s n in (c x 1... x n) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 30
56 Einleitung Überblick Zustand Transition Beispiel Korrektheit Zustand der Maschine Paar (Γ, P T ) wobei Γ ist ein Heap : Menge von Bindungen von Variablen an Ausdrücken x s und gesperrten Bindungen x. Ein Prozessbaum P T : binärer Baum wobei innere Kten Blätter mit Stacks markiert sind mit Threads markiert sind ein Thread ist ein Paar (t, S) wobei t ein Ausdruck und S ein Stack ist Stackelemente sind {# APP (x), # SEQ (s), # CASE (alts), # UPD (x)} David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 31
57 Einleitung Überblick Zustand Transition Beispiel Korrektheit Zustandstransition Blatt (Thread) nichtdeterministisch auswählen Gewählter Thread steuert Transition 3 Arten an Transitionen: Änderung des gewählten Threads und evtl. Heaps Γ t t Γ Änderung des Teilbaums direkt über dem gewählten Blatt t Γ t Γ Aufspaltung in 2 neue Threads Γ t Γ t1 t2 David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 32
58 Einleitung Überblick Zustand Transition Beispiel Korrektheit Zustandstransition Deterministische Transitionen, nur auf Thread-Ebene `(s x), S `(λy.s), #APP (x) : S `(seq s t), S `v, #SEQ (t) : S `(caset s alts), S `ct,i x 1... x n, # CASE (T, alts) : S Transitionen die den Heap benutzen {x } Γ, {x s} Γ, `x, S `v, #UPD (x) : S pushapp `s, # APP (x) : S takeapp `s[x/y], S pushseq `s, # SEQ (t) : S takeseq `t, S falls v Wert pushalts `s, # CASE (T, alts) : S takealts `t i [x i /y i ], S enter {x } Γ, update {x v} Γ, falls (c T,i y 1... y n) t i alts `s, #UPD (x) : S `v, S falls v Wert David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 33
59 Einleitung Überblick Zustand Transition Beispiel Korrektheit Zustandstransition amb-auswertung `(amb s t), S fork S `s, [] `t, [] S Γ, `v, [] P T choose-l Γ, `v, S Γ, P T S `v, [] choose-r Γ, `v, S David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 34
60 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: ( letrec x = (amb (λy.y) (λw1, w 2.w 1 )) in (amb (λz.z) x) x, [] ) mkbinds David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
61 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( (amb (λz.z) x) x, [] ) pushapp David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
62 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( (amb (λz.z) x), [#APP (x)] ) fork David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
63 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} [# APP (x)] ( λz.z, [] ) ( x, [] ) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
64 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} [# APP (x)] ( λz.z, [] ) ( x, [] ) enter David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
65 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } [# APP (x)] ( λz.z, [] ) ( (amb (λy.y) (λw1, w 2.w 1 )), [# UPD (x)] ) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
66 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } [# APP (x)] ( λz.z, [] ) ( (amb (λy.y) (λw1, w 2.w 1 )), [# UPD (x)] ) fork David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
67 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λz.z, [] ) [# APP (x)] [# UPD (x)] ( λy.y, [] ) ( λw1, w 2.w 1, [] ) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
68 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λz.z, [] ) [# APP (x)] [# UPD (x)] ( λy.y, [] ) ( λw1, w 2.w 1, [] ) choose-l David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
69 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λz.z), [#APP (x)] ) [# UPD (x)] ( λy.y, [] ) ( λw1, w 2.w 1, [] ) Heap anpassen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
70 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λz.z), [#APP (x)] ) ( (amb (λy.y) (λw1, w 2.w 1 )), [# UPD (x)] ) Heap anpassen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
71 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( λz.z), [#APP (x)] ) ( (amb (λy.y) (λw1, w 2.w 1 )), [] ) Heap anpassen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
72 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( λz.z), [#APP (x)] ) takeapp David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
73 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( x, [] ) enter David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
74 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (amb (λy.y) (λw 1, w 2.w 1 ))} ( (amb (λy.y) (λw1, w 2.w 1 )), [# UPD (x)] ) fork David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
75 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } [# UPD (x)] ( λy.y, [] ) ( λw1, w 2.w 1, [] ) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
76 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } [# UPD (x)] ( λy.y, [] ) ( λw1, w 2.w 1, [] ) choose-l David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
77 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λy.y, [#UPD (x)] ) ( λw1, w 2.w 1, [] ) David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
78 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λy.y, [#UPD (x)] ) ( λw1, w 2.w 1, [] ) Heap anpassen David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
79 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x } ( λy.y, [#UPD (x)] ) update David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
80 Einleitung Überblick Zustand Transition Beispiel Korrektheit Beispiel Heap: {x (λy.y)} ( λy.y, [] ) akzeptiere! David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 35
81 Einleitung Überblick Zustand Transition Beispiel Korrektheit Korrektheit Korrektheit im Rahmen von Übersetzungen τ :: calc A calc B Übersetzung zumindest: Konvergenzäquivalenz: τ(s) B s A und τ(s) B s A besser (bzgl. Gleichheiten): [Schmidt-Schauß et al., 2008]: Adequatheit der Übersetzung τ(s) B τ(t) = s A t Volle Abstraktheit impliziert äquivalente Gleichheitstheorien: τ(s) B τ(t) s A t David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 36
82 Einleitung Überblick Zustand Transition Beispiel Korrektheit Korrektheitsbeweis amb CAM F L let amb nur Variablen als Argumente Übersetzung Υ amb,vao amb CAM CAM F Normalordnungsreduktion Maschinenrmalordnung Maschinentransition faire Maschinentransition David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 37
83 Einleitung Überblick Zustand Transition Beispiel Korrektheit Korrektheitsbeweis amb CAM F L let amb nur Variablen als Argumente Übersetzung Υ amb,vao amb CAM CAM F Υ voll abstrakt Normalordnungsreduktion Maschinenrmalordnung Maschinentransition faire Maschinentransition unter Benutzung der Frameworks aus [Schmidt-Schauß et al., 2008] David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 37
84 Einleitung Überblick Zustand Transition Beispiel Korrektheit Korrektheitsbeweis amb CAM F L let amb nur Variablen als Argumente Übersetzung Υ amb,vao amb CAM CAM F Normalordnungsreduktion Maschinenrmalordnung Maschinentransition Υ voll abstrakt Konvergenzäquivalenz faire Maschinentransition unter Benutzung der Frameworks aus [Schmidt-Schauß et al., 2008] schwieriger Teil: Wenn s mo, dann s CAM David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 37
85 Einleitung Überblick Zustand Transition Beispiel Korrektheit Korrektheitsbeweis amb CAM F L let amb nur Variablen als Argumente Übersetzung Υ amb,vao amb CAM CAM F Normalordnungsreduktion Maschinenrmalordnung Maschinentransition faire Maschinentransition Υ voll abstrakt Konvergenzäquivalenz Konvergenzäquivalenz unter Benutzung der Frameworks aus [Schmidt-Schauß et al., 2008] schwieriger Teil: Wenn s mo, dann s CAM David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 37
86 Einleitung Fazit Programmtransformationen einer nebenläufigen Programmiersprache Operationaler Ansatz erfolgreich kontextuelle Äquivalenz mit may- & must-konvergenz ergibt erwartete Gleichungen Mit den entwickelten Methoden viele Programmtransformationen als korrekt nachweisbar Sowohl Transformationen als auch Übersetzungen Resultate von Moran verbessert und nach Änderungen zum erfolgreichen Abschluss geführt David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 38
87 Einleitung Ausblick Operationaler Ansatz auf viele Kalküle anwendbar nur small-step Reduktion, Wertbegriff twendig generisches Kontextlemma bereits entwickelt [Schmidt-Schauß & Sabel, 2007] Auf nebenläufigen Prozesskalkül mit Speicher und Futures bereits angewendet [Niehren, Sabel, Schmidt-Schauß, Schwinghammer, 2007] amb: Weitere Beweismethoden denkbar, z.b. take-lemma Verbesserung der endlichen Simulation getypte Kalküle betrachten Diagramm-Methode automatisieren David Sabel: Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence 39
Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence
Semantics of a Call-by-Need Lambda Calculus with McCarthy s amb for Program Equivalence David Sabel Institut für Informatik Fachbereich Informatik und Mathematik Goethe-Universität Frankfurt Kolloquium
Semantik und Analyse von Funktionalen Programmen (SAFP):
Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Sharing und Striktheitsanalyse titleslide Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2017/18 Stand der Folien: 30. Januar 2018 LR: Syntax E ::=
LR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln
LR: Syntax Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 E ::= V (c E 1... E ar(c) ) (seq E 1 E 2
Semantik und Analyse von Funktionalen Programmen (SAFP):
Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 Stand der Folien: 5. Februar 2015 LR: Syntax E ::=
LR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln
LR: Syntax Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Sharing und Striktheitsanalyse titleslide Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2017/18 E ::= V (c E 1... E ar(c) ) (seq E 1
Übersicht. Nebenläufige Programmierung: Praxis und Semantik. Semantische Modelle nebenläufiger Programmiersprachen. Einleitung
Stand der Folien: 24. Januar 2012 Übersicht Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Semantische Modelle nebenläufiger Programmiersprachen 1 2 Call-by-Name
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 17. Oktober 2006 Einführung in Haskell: Syntax, Reduktionen, Kernsprachen Haskell,
Concurrent Haskell with Futures. Vorlesung SAFP, WS 2017/18
Concurrent Haskell with Futures Vorlesung SAFP, WS 2017/18 Stand der Folien: 8. Februar 2018 Übersicht Der CHF-Kalkül 1 Der CHF-Kalkül Syntax Typisierung Semantik Gleichheit EFP SAFP Vorlesung SAFP, WS
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 28. Oktober 2008 Einführung in Haskell: Syntax, Reduktionen, Kernsprachen Haskell,
Automatische Prüfung und Berechnung von Überlappungen zum Vollständigkeitsnachweis von Diagrammen in Programmiersprachen höherer Ordnung
Johann Wolfgang Goethe-Universität Frankfurt am Main Fachbereich Informatik und Mathematik Institut für Informatik Diplomarbeit Automatische Prüfung und Berechnung von Überlappungen zum Vollständigkeitsnachweis
Fortgeschrittene Funktionale Programmierung
Fortgeschrittene Funktionale Programmierung 13. Vorlesung Janis Voigtländer Universität Bonn Wintersemester 2015/16 Erweiterung um Datentypen Typen: τ := Bool [τ] Terme: t := False True [ ] τ t : t case
1 Einleitung. 2 Normalordnungsreduktion. 3 Anwendungsordnung. 4 Verzögerte Auswertung. 5 Programmieren mit let in Haskell.
Stand der Folien: 25. Oktober 2010 Übersicht Einführung in die Funktionale Programmierung: Funktionale Kernsprachen: Einleitung & Der Lambda-Kalkül Dr. David Sabel 1 Einleitung 2 Normalordnungsreduktion
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen Mark 1 und Mark 2
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen und Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Zeitplan Teil 3 Meilenstein 1 Teil 1: Lexen und Parsen
Praktikum Funktionale Programmierung Organisation und Überblick
Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Sommersemester 2013 Stand der Folien: SoSe 2013 Adressen Organisatorisches Software Projekt Adressen, Termine Studienleistung
Korrektheit von Programmen und Programmiersprachen
Korrektheit von Programmen und Programmiersprachen Methoden, Analysen und Anwendungen David Sabel Goethe-Universität, Frankfurt am Main 13. November 2012 Überblick 1. Motivation 2. Grundlagen 3. Korrektheit
Grundlagen der Programmierung 2. Operationale Semantik
Grundlagen der Programmierung 2 Operationale Semantik Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 29. April 2009 Semantik von Programmiersprachen Semantik = Bedeutung
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine WWW
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 sabel@ki.informatik.uni-frankfurt.de
Einführung in die Funktionale Programmierung:
Einführung in die Funktionale Programmierung: Funktionale Kernsprachen: Einleitung & Der Lambda-Kalkül Prof. Dr. M. Schmidt-Schauß WS 2014/15 Stand der Folien: 16. Oktober 2014 Übersicht 1 Einleitung 2
Der einfach getypter Lambda-Kalkül
Der einfach getypter Lambda-Kalkül Typprüfung und Typinferenz Tobias Nipkow und Steffen Smolka Technische Universität München 1 Einleitung 2 Explizit getypter λ-kalkül 3 Implizit getypter λ-kalkül Statische
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen
Praktikum Funktionale Programmierung Teil 3: Abstrakte Maschinen Dr. David Sabel Sommersemester 2015 Stand der Folien: SoSe 2015 Übersicht FP-PR Teil 3: Abstrakte Maschinen Sommersemester 2015 D. Sabel
Semantik von Programmiersprachen
Semantik von Programmiersprachen Prof. Dr. Manfred Schmidt-Schauß SS 2013 Stand der Folien: 15. April 2013 Semantik von Programmen verschiedene Semantiken: operationale Semantik (Spezifikation eines Interpreters)
Reduktionssysteme und Termersetzungssysteme
Reduktionssysteme und Termersetzungssysteme Untersuchung von Berechnungen mittels Reduktionsregeln Simplifikation von: Datenstrukturen / Termen usw. Erkennen von gleichen Objekten durch Normalisierung
Einführung in das λ-kalkül
Einführung in das λ-kalkül Max Wagner IPD Snelting 1 3.11.2017 Max Wagner - Einführung in das λ-kalkül IPD KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Syntax Abstrakte Syntax:
Operationale Semantik: Haskell
Kapitel 4 Operationale Semantik: Haskell 4.1 Semantik von Programmiersprachen Programme sind zunächst mal nur Text. Programme sollen aber etwas im Rechner bewirken bzw. eine Funktion oder Funktionalität
Praktikum Funktionale Programmierung Teil 2: Typecheck und Transformation
Praktikum Funktionale Programmierung Teil 2: Typecheck und Transformation Dr. David Sabel Sommersemester 2015 Stand der Folien: SoSe 2015 Übersicht FP-PR Teil 2: Typecheck und Transformation Sommersemester
1. Typen 1.1 Typsicherheit 1.2 Typprüfung
1. Typen 1.1 Typsicherheit 1.2 Typprüfung Ein Typsystem ist ein praktikables, syntaktisches Verfahren, mit dem man die Abwesenheit gewisser Laufzeit-Eigenschaften eines Programms beweisen kann, indem man
Funktionale Programmierung ALP I. λ Kalkül WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I λ Kalkül WS 2012/2013 Berechenbarkeit - inspiriert durch Hilbert's Frage - im Jahr 1900, Paris - Internationaler Mathematikerkongress Gibt es ein System von Axiomen, aus denen alle Gesetze der Mathematik
Grundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
{P} S {Q} {P} S {Q} {P} S {Q} Inhalt. Hoare-Kalkül. Hoare-Kalkül. Hoare-Tripel. Hoare-Tripel. Hoare-Tripel
Inhalt Hoare-Kalkül Formale Verifizierung Hoare-Kalkül while-sprache Terminierung Partielle / totale Korrektheit 4.0 Hoare-Kalkül entwickelt von C.A.R. (Tony) Hoare (britischer Informatiker), 1969 formales
Grundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2016 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
1 Funktionale vs. Imperative Programmierung
1 Funktionale vs. Imperative Programmierung 1.1 Einführung Programme einer funktionalen Programmiersprache (functional programming language, FPL) bestehen ausschließlich aus Funktionsdefinitionen und Funktionsaufrufen.
Entwicklung eines korrekten Übersetzers
Entwicklung eines korrekten Übersetzers für eine funktionale Programmiersprache im Theorembeweiser Coq Thomas Strathmann 14.01.2011 Gliederung 1 Einleitung
Theoretische Informatik II
Theoretische Informatik II Dr. Eva Richter / Holger Arnold Universität Potsdam, Theoretische Informatik, Sommersemester 2008 Übungsblatt 3 (Version 4) Abgabetermin: 13.5.2008, 12.00 Uhr Der λ-kalkül Da
3 Exkurs: Der λ-kalkül
3 Exkurs: Der λ-kalkül Alonso Churchs λ-kalkül (ca. 1940) ist der formale Kern jeder funktionalen Programmiersprache. Der λ-kalkül ist eine einfache Sprache, mit nur wenigen syntaktischen Konstrukten und
Einführung IMP-Syntax Reduktionssemantik Maschinen-Semantik. Teil IV. Semantik imperativer Sprachen
Teil IV Semantik imperativer Sprachen 201 1. Einführung Alternativen zur Beschreibung der Semantik: natürliche Sprache (bisher, unpräzise) operational Reduktionssemantik (vgl. Haskell-Semantik in Kap.
DieÜbersetzung funktionaler Programmiersprachen
DieÜbersetzung funktionaler Programmiersprachen 107 11 Die Sprache PuF Wir betrachten hier nur die Mini-Sprache PuF( Pure Functions ). Insbesondere verzichten wir(vorerst) auf: Seiteneffekte; Datenstrukturen;
Intuitionistische Lineare Logik
Lineare Logik Intuitionistische Lineare Logik Zusammenhang zur intuitionistischen Logik Termzuweisung und funktionale Interpretation Intuitionistische Lineare Logik Sinn und Zweck : Kontrolle über Ressourcen
1 Geschichte. 2 Syntax und Konzepte. Lamdba-Kalkül
1 Geschichte 1673 Gottfried Wilhelm Leibniz entwickelt eine mechanische Rechenmaschine, beginnt zu träumen: Gibt es eine universelle Sprache, in der alle Probleme dargestellt werden können? Gibt es eine
Einführung in Funktionale Programmierung Typisierung
Einführung in Funktionale Programmierung Typisierung PD Dr. David Sabel WS 2015/16 Stand der Folien: 19. November 2015 Motivation Typen Typisierungsverfahren Ziele des Kapitels Warum typisieren? Typisierungsverfahren
Praktikum Funktionale Programmierung Teil 5: Codeerzeugung, Compiler, Interpreter und VM
Praktikum Funktionale Programmierung Teil 5: Codeerzeugung, Compiler, Interpreter und VM Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Zeitplan Teil 5 Meilenstein 1 Teil
Abstrakte Maschinen und Kode-Erzeugung für Haskell
Abstrakte Maschinen und Kode-Erzeugung für Haskell Implementierung der Reduktion: Compilierung: Terme als Bäume, Reduktion als Transformation auf Bäumen Terme als gerichtete Graphen, Template-Instantiation,
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine. Studienleistung
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 sabel@ki.informatik.uni-frankfurt.de
Formale Methoden der Softwaretechnik 1 Vorlesung vom : Grundlage von Isabelle
1 Formale Methoden der Softwaretechnik 1 Vorlesung vom 16.11.09: Grundlage von Isabelle Christoph Lüth, Lutz Schröder Universität Bremen Wintersemester 2009/10 2 Fahrplan Teil I: Grundlagen der Formalen
Optimierungen in einer formalen Semantik Konstantenfaltung und Konstantenpropagation
Optimierungen in einer formalen Semantik Konstantenfaltung und Konstantenpropagation http://pp.info.uni-karlsruhe.de/lehre/ss2011/tba/ LEHRSTUHL PROGRAMMIERPARADIGMEN 0 KIT SS Universität 2011 desdenis
Stackmaschine; Speicheradressierung
Stackmaschine; Speicheradressierung Erweiterung um globalen Speicher (Heap, Halde) pro Speicherplatz eine Zahl. Notation ist als Array SP [0..]. Zugriff mittels Adresse (Index): eine Zahl i.a.: Zahlen
Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Überladung und Konversion in Haskell. Typisierung in Haskell
Haskell, Typen, und Typberechnung Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr Manfred Schmidt-Schauß Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Sommersemester
Funktionale Programmierung ALP I. λ Kalkül. Teil 2 WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I λ Kalkül Teil 2 WS 2012/2013 Lokale Variablennamen Haskell: let x = exp1 in exp2 Lambda: λ exp1. exp2 Einfache Regel: Der Geltungsbereich eines Lambda-Ausdrucks erstreckt sich soweit wie möglich
Reduktion. 2.1 Abstrakte Reduktion
2 Reduktion In diesem Kapitel studieren wir abstrakte Eigenschaften von Regeln. In den ersten beiden Abschnitten betrachten wir nicht einmal die Regeln selbst, sondern nur abstrakte Reduktionssysteme,
Der untypisierte Lambda-Kalkül als Programmiersprache
Der untypisierte Lambda-Kalkül als Programmiersprache November 29, 2006 betreut von Prof. Tobias Nipkow Einführung In den 1930er Jahren von Alonzo Church und Stephen Kleene eingeführt Der Lambda-Kalkül
Übersicht. Einführung in die Funktionale Programmierung: Übersicht: Expression und Typen. Ziele des Kapitels
Übersicht Einführung in die Funktionale Programmierung: Typisierung Prof Dr. Manfred Schmidt-Schauß 1 Motivation 2 Typen: Sprechweisen, Notationen und Unifikation 3 Typisierungsverfahren Iteratives Typisierungsverfahren
Übersicht. Nebenläufige Programmierung: Praxis und Semantik. Synchronisation (4) Eine untere Schranke für den Platzbedarf
Übersicht Komplexitätsresultate Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Synchronisation (4) Drei Komplexitätsresultate Eine genaue Schranke für den Platzbedarf
Tableaukalkül für Aussagenlogik
Tableaukalkül für Aussagenlogik Tableau: Test einer Formel auf Widersprüchlichkeit Fallunterscheidung baumförmig organisiert Keine Normalisierung, d.h. alle Formeln sind erlaubt Struktur der Formel wird
Semantik von Programmiersprachen SS 2017
Lehrstuhl für Programmierparadigmen Denis Lohner Sebastian Ullrich denis.lohner@kit.edu sebastian.ullrich@kit.edu Semantik von Programmiersprachen SS 2017 http://pp.ipd.kit.edu/lehre/ss2017/semantik Lösungen
Übersicht. Einführung in die Funktionale Programmierung: Ziele des Kapitels. Typisierung Prof Dr. Manfred Schmidt-Schauß WS 2012/13
Übersicht Einführung in die Funktionale Programmierung: Typisierung Prof Dr. Manfred Schmidt-Schauß WS 2012/13 1 Motivation 2 Typen: Sprechweisen, Notationen und Unifikation 3 Typisierungsverfahren Iteratives
Kontextuelle Gleichheit, Korrektheit, Programmtransformationen, Auswertungsänderung
Skript CEFP, WS 2013/14 Prof. Dr. Manfred Schmidt-Schauß Fachbereich Informatik Johann Wolfgang Goethe-Universität Postfach 11 19 32 D-60054 Frankfurt Germany E-mail:schauss@ki.informatik.uni-frankfurt.de
Reduktionssysteme Termersetzungssysteme. Keine kritischen Paare. Betrachte Variablenüberlappung:
Beispiele Beispiel 9.4 Betrachte f (f (x, y), z) f (x, f (y, z)) f (f (x, y ), z ) f (x, f (y, z )) Unifizierbar mit x f (x, y ), y z f (f (f (x, y ), z ), z) t 1 = f (f (x, y ), f (z, z)) f (f (x, f (y,
Semantik. Semantik von Programmiersprachen. Prof. Tobias Nipkow, Ph. D. Erstellt von Benjamin Gufler. Erstellt mit L A TEX
Semantik Semantik von Programmiersprachen Prof. Tobias Nipkow, Ph. D. Erstellt von Benjamin Gufler Erstellt mit L A TEX II Inhaltsverzeichnis 0.1 Ziele............................................ 1 0.2
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 18. November 2008 Typcheck zu KFPT; KFPTS;... Ziele des Kapitels: Polymorphes
MODEL CHECKING 2 - AUTOMATEN
MODEL CHECKING 2 - AUTOMATEN Sommersemester 2009 Dr. Carsten Sinz, Universität Karlsruhe Model Checking 2 System (Hardware/ Software) Model Checking, Formalisierung, Beweis Übersetzung in Logik Gewünschte
Formale Methoden 2. Gaetano Geck Lehrstuhl I Logik in der Informatik WS 2015/2016
Formale Methoden 2 Gaetano Geck Lehrstuhl I Logik in der Informatik WS 2015/2016 Teil 4: Formale Sprachen 1 Motivation 2 Rechtsreguläre Grammatiken 3 Exkurs: Abgeschlossenheit 4 Strukturelle Induktion
EIDI 1 Einführung in die Informatik 1. PGdP Praktikum Grundlagen der Programmierung. Harald Räcke 2/217
EIDI 1 Einführung in die Informatik 1 PGdP Praktikum Grundlagen der Programmierung Harald Räcke 2/217 Wie löst man Probleme mithilfe von Computern? 0 Harald Räcke 3/217 Inhalte: EIDI 1 1. Was ist das Problem?
Formale Systeme. Prof. Dr. Bernhard Beckert, WS 2016/ KIT Die Forschungsuniversita t in der Helmholtz-Gemeinschaft
Formale Systeme Prof. Dr. Bernhard Beckert, WS 2016/2017 Aussagenlogik: Tableaukalku l KIT I NSTITUT F U R T HEORETISCHE I NFORMATIK www.kit.edu KIT Die Forschungsuniversita t in der Helmholtz-Gemeinschaft
Formale Systeme. Prof. Dr. Bernhard Beckert, WS 2017/ KIT Die Forschungsuniversita t in der Helmholtz-Gemeinschaft
Formale Systeme Prof. Dr. Bernhard Beckert, WS 2017/2018 Aussagenlogik: Tableaukalku l KIT I NSTITUT F U R T HEORETISCHE I NFORMATIK www.kit.edu KIT Die Forschungsuniversita t in der Helmholtz-Gemeinschaft
Übersicht Formale Semantik. Übersicht Axiomatische Semantik. Inhaltsübersicht HPS WS 2003/04. Vorlesung Höhere Programmiersprachen,
Vorlesung Höhere Programmiersprachen, WS 2003/04 Teil 2: Formale Semantik Axiomatische Semantik Inhaltsübersicht - Grundlagen (1,2) - Konzepte imperativer Programmiersprachen (2,3) - Deklarative Programmiersprachen
Lambda-Kalkül. Philipp Meyer. 28. April 2009
Lambda-Kalkül Philipp Meyer 28. April 2009 1 Einleitung Der λ-kalkül ist eine von Alonzo Church und Stephen Kleene in den 1930er Jahren eingeführtes Modell zur Beschreibung berechenbarer Funktionen. Es
Kapitel 6. Programme mit Schleifen. Wir betrachten jetzt eine einfache imperative Programmiersprache IMP. IMP verfügt
Kapitel 6 Programme mit Schleifen Wir betrachten jetzt eine einfache imperative Programmiersprache IMP. IMP verfügt über zuweisbare Variablen, Konditionale und Schleifen, hat aber keine Prozeduren. IMP
Vorsemesterkurs Informatik
Vorsemesterkurs Informatik Vorsemesterkurs Informatik Mario Holldack WS2015/16 30. September 2015 Vorsemesterkurs Informatik 1 Einleitung 2 Aussagenlogik 3 Mengen Vorsemesterkurs Informatik > Einleitung
Übung zur Vorlesung Automatisierte Logik und Programmierung I
Übung zur Vorlesung Automatisierte Logik und Programmierung I Prof. Chr. Kreitz Universität Potsdam, Theoretische Informatik Wintersemester 2008/09 Blatt 3 Abgabetermin: 26.11.08 nach der Übung Das dritte
Gliederung. Funktionale Programmierung. Pattern matching in Haskell. Pattern matching in ERLANG. Materialien zur Vorlesung
Gliederung Funktionale Programmierung Materialien zur Vorlesung D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg 1 Sommer 2011, 7.
Korrektheit imperativer Algorithmen
LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS DATABASE Abschnitt 9 Korrektheit imperativer Algorithmen Skript zur Vorlesung Einführung in die Programmierung im Wintersemester
Diskrete Strukturen Kapitel 2: Grundlagen (Beweise)
WS 2014/15 Diskrete Strukturen Kapitel 2: Grundlagen (Beweise) Hans-Joachim Bungartz Lehrstuhl für wissenschaftliches Rechnen Fakultät für Informatik Technische Universität München http://www5.in.tum.de/wiki/index.php/diskrete_strukturen_-_winter_14
An Overview of the Signal Clock Calculus
An Overview of the Signal Clock Calculus, Jennifer Möwert Inhaltsverzeichnis Synchrone Programmiersprachen Clock Calculus Synchrone Paradigmen SLTS Clocks SIGNAL Definitionen Endochrony Bäume, Jennifer
Methoden zur Interpretation LISPähnlicher. Programmiersprachen. Seminarvortrag / 53 FH AACHEN FACHBEREICH 9 TOBIAS STUMM MATR.-NR.
Methoden zur Interpretation LISPähnlicher Programmiersprachen Seminarvortrag 20.01.2017 FACHBEREICH 9 TOBIAS STUMM MATR.-NR. 4012917 1 Inhalt Motivation Lisp > Definition > Scheme Interpreter > Definition
Formale Systeme. Prof. Dr. Bernhard Beckert. Winter 2008/2009. Fakultät für Informatik Universität Karlsruhe (TH)
Formale Systeme Prof. Dr. Bernhard Beckert Fakultät für Informatik Universität Karlsruhe (TH) Winter 2008/2009 Prof. Dr. Bernhard Beckert Formale Systeme Winter 2008/2009 1 / 22 Kalküle für die Aussagenlogik
Boolsche und kartesische Abstraktion zum Model Checking von C Programmen. Seminar: Software Model Checking
Boolsche und kartesische Abstraktion zum Model Checking von C Programmen Seminar: Software Model Checking Einleitung Aufbauend auf der boolschen Abstraktion (Vortrag vor 2 Wochen) kann man, indem man Abhängigkeiten
Logik I. Symbole, Terme, Formeln
Logik I Symbole, Terme, Formeln Wie jede geschriebene Sprache basiert die Prädikatenlogik erster Stufe auf einem Alphabet, welches aus den folgenden Symbolen besteht: (a) Variabeln wie zum Beispiel v 0,v
Semantik von Programmiersprachen SS 2017
Lehrstuhl für Programmierparadigmen Denis Lohner Sebastian Ullrich denis.lohner@kit.edu sebastian.ullrich@kit.edu Semantik von Programmiersprachen SS 2017 http://pp.ipd.kit.edu/lehre/ss2017/semantik Lösungen
Funktionale Programmierung Einführung
Einführung Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 13.09.2017 15:29 Inhaltsverzeichnis Was ist imperative Programmierung.......................
Algorithmus. Was ist ein Algorithmus? Ibn Musa Al-Chwarismi persischer Mathematikers 9. Jahrhundert Buch: Regeln der Wiedereinsetzung und Reduktion.
Algorithmus Was ist ein Algorithmus? Ibn Musa Al-Chwarismi persischer Mathematikers 9. Jahrhundert Buch: Regeln der Wiedereinsetzung und Reduktion. Hier einige informelle Erklärungen zum Algorithmus P
Aussagenlogik: Syntax von Aussagen
Aussagenlogik: Syntax von Aussagen A ::= X (A A) (A A) ( A) (A A) (A A) 0 1 Prioritätsreihenfolge :,,,,. A B: Konjunktion (Verundung). A B: Disjunktion (Veroderung). A B: Implikation. A B: Äquivalenz.
De Morgan sche Regeln
De Morgan sche Regeln Durch Auswerten der Wahrheitswertetabelle stellen wir fest, dass allgemeingültig ist; ebenso (p q) p q (p q) p q. Diese beiden Tautologien werden als die De Morgan schen Regeln bezeichnet,
Grundlagen der Programmierung 2 (2.A)
Grundlagen der Programmierung 2 (2.A) Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 5. Mai 2011 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen,
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 26. Oktober 2006 Haskell - Einführung Syntax Typen Auswertung Programmierung
Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten.
4.5.5 Rekursive Typen Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten. datatype IntList = Nil Cons o f ( i n t IntList ) ; Damit
WS 2013/14. Diskrete Strukturen
WS 2013/14 Diskrete Strukturen Prof. Dr. J. Esparza Lehrstuhl für Grundlagen der Softwarezuverlässigkeit und theoretische Informatik Fakultät für Informatik Technische Universität München http://www7.in.tum.de/um/courses/ds/ws1314
Lösungen zum Aufgabenblatt 10 Logik und modelltheoretische Semantik
Lösungen zum Aufgabenblatt 10 Logik und modelltheoretische Semantik Universität München, CIS, SS 2013 Hans Leiß Abgabetermin: Do, 4.7.2013, 16 Uhr, in meinem Postfach Aufgabe 10.1 Vereinfache die folgenden
Korrektheit und Hoare-Kalkül für Imperative Programme
Korrektheit und Hoare-Kalkül für Imperative Programme Martin Wirsing in Zusammenarbeit mit Moritz Hammer und Axel Rauschmayer SS 06 Ziele Partielle und totale Korrektheit kennen lernen Die Regeln des Hoare-Kalkül
Umformung NTM DTM. Charakterisierung rek. aufz. Spr. Chomsky-3-Grammatiken (T5.3) Chomsky-0-Grammatik Rek. Aufz.
Chomsky-0-Grammatik Rek. Aufz. Satz T5.2.2: Wenn L durch eine Chomsky-0- Grammatik G beschrieben wird, gibt es eine NTM M, die L akzeptiert. Beweis: Algo von M: Schreibe S auf freie Spur. Iteriere: Führe
Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Einige andere Programmiersprachen. Typisierung in Haskell
Haskell, Typen, und Typberechnung Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Milners
5 BINÄRE ENTSCHEIDUNGS- DIAGRAMME (BDDS)
5 BINÄRE ENTSCHEIDUNGS- DIAGRAMME (BDDS) Sommersemester 2009 Dr. Carsten Sinz, Universität Karlsruhe Datenstruktur BDD 2 1986 von R. Bryant vorgeschlagen zur Darstellung von aussagenlogischen Formeln (genauer:
Theorembeweiserpraktikum SS 2016
Institut für Programmstrukturen und Datenorganisation Lehrstuhl Programmierparadigmen Am Fasanengarten 5 76131 Karlsruhe http://pp.ipd.kit.edu/ Theorembeweiserpraktikum SS 2016 http://pp.ipd.kit.edu/lehre/ss2016/tba
Ströme als unendliche Listen in Haskell
Ströme als unendliche Listen in Haskell Strom := Folge oder Liste von Daten, unbegrenzt viele Daten-Elemente. Ströme sind in Haskell als als (potentiell) unendliche Listen darstellbar und programmierbar
Imperative vs. Funktionale Programmierung
Beispiel: Entwerfe eine Funktion, die testet, ob eine Zahl n eine Primzahl ist oder nicht. Beobachtung: (1) Wenn n Primzahl ist, ist die Menge der Teiler von n leer. (2) Die Menge der Teiler von n sind
Einführung in Funktionale Programmierung. Klassifizierung von Programmierparadigmen und -sprachen. Einleitung & Motivation
Einführung in Funktionale Programmierung Einleitung & Motivation PD Dr. David Sabel Klassifizierung von Programmierparadigmen und -sprachen Insbesondere: Was unterscheidet Funktionale Programmiersprachen
15. Rekursion. Rekursive Funktionen, Korrektheit, Terminierung, Aufrufstapel, Bau eines Taschenrechners, BNF, Parsen
453 15. Rekursion Rekursive Funktionen, Korrektheit, Terminierung, Aufrufstapel, Bau eines Taschenrechners, BNF, Parsen Mathematische Rekursion 454 Viele mathematische Funktionen sind sehr natürlich rekursiv
Vorsemesterkurs Informatik
Vorsemesterkurs Informatik Ronja Düffel WS2018/19 01. Oktober 2018 Theoretische Informatik Wieso, weshalb, warum??!? 1 Modellieren und Formalisieren von Problemen und Lösungen 2 Verifikation (Beweis der
- Theorie der uninterpretierten
Theorie der uninterpretierten Funktionen Entscheidungsverfahren mit Anwendungen in der Softwareverifikation STEPHAN FALKE INSTITUT FÜR THEORETISCHE INFORMATIK (ITI) 0 KIT 13. Universität Mai 2013 des S.