Formal Methods and Functional Programming

Formal Methods and
Functional Programming
Woche 7
1. April
Organisatorisches
Ab nächster Woche: Formal Methods
Übungsgruppen Dienstag (Englisch):
I Alex Summers, ETZ G 91
I Milos Novacek, NO D 11
I Uri Juhasz, NO E 11
Übungsgruppen Mittwoch (Deutsch):
I Cyril Steimer, IFW C 33
I Alex Viand, IFW A 34
Programm
I
Blatt 6
I
I
I
I
Blatt 7
I
I
I
Lazy & eager evaluation
Induktion (mal wieder)
Damenproblem
wird nicht korrigiert! Musterlösung verfügbar
bei Fragen → Mail
Monads
β-Reduktion
(λx. e1) e2
I
I
Grundregel beim Auswerten
ggf. α-Konversion notwendig
(λx y . x) y
I
e1[x 7→ e2]
λz. y
Auswertungsstrategie gibt an, wo und in welcher
Reihenfolge β-Reduktion stattfindet
Aufgabe 1 – Lazy evaluation
(λx. x (λy . x y )) (λx. (λy . y ) x)
= (λx. (λy . y ) x) (λy . (λx. (λy . y ) x) y )
= (λy . y ) (λy . (λx. (λy . y ) x) y )
= (λy . (λx. (λy . y ) x) y )
Aufgabe 1 – Eager evaluation
(λx. x (λy . x y )) (λx. (λy . y ) x)
= (λx. x (λy . x y )) (λx. x)
= (λx. x) (λy . (λx. x) y )
= (λx. x) (λy . y )
= (λy . y )
Aufgabe 2 – Ein Versuch
Induktionsbeweis für ∀xs :: [Int]. P(xs) mit
P(xs) ≡ sum (addShifted xs 1) = 1 + 2 * sum xs
...
Induktionsschritt: x :: Int beliebig, . . .
sum (addShifted (x:xs) 1)
= sum ((x+1):addShifted xs x)
= (x+1) + sum (addShifted xs x)
= 1 + x + sum (addShifted xs x)
-- addShifted.2
-- sum.2
Wir können die IH P(xs) nicht benutzen!
Aufgabe 2 – Die Lösung
Die IH ist zu schwach; wir verallgemeinern:
P(xs) ≡ ∀i :: Int. sum (addShifted xs i) = i + 2 * sum xs
I
I
Induktionsbeweis erfolgreich
zu zeigende Aussage folgt als Spezialfall
N.B. Reihenfolge der Quantoren ist relevant, vergleiche
∀xs :: [Int]. ∀i :: Int. . . .
∀i :: Int. ∀xs :: [Int]. . . .
Monads
The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category
theory. From the perspective of a Haskell programmer,
however, it is best to think of a monad as an abstract
datatype of actions. Haskell’s do expressions provide a
convenient syntax for writing monadic expressions.
(http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC-Base.html)
Mmh okay . . .
do revisited
main = do
putStrLn "Give me some text:"
input <- getLine
putStrLn ("You entered " ++ input)
I
I
I
Verknüpfung von Aktionen
Reihenfolge relevant
Resultate (input) können Aktionen beeinflussen
do revisited (2)
myMap = Map.fromList
[("a", 5), ("b", 7)]
import Data.Map.Lazy as Map
mapAdd m k1 k2 = do
x1 <- Map.lookup m k1
x2 <- Map.lookup m k2
return (x1 + x2)
? mapAdd myMap "a" "b"
Just 12
? mapAdd myMap "a" "z"
Nothing
? mapAdd myMap "x" "y"
Nothing
Alternative Implementierung?
Behind the Scenes
class Monad m where
I return :: a -> m a
I (>>=) :: m a -> (a -> m b) -> m b
I (>>) :: m a -> m b -> m b
Standardimpl.: x >> y = x >>= (\_ -> y)
I fail :: String -> m a
Behind the Scenes (2)
do ist syntactic sugar:
x = do
expr1
z <- expr2
expr3
x = expr1 >>= (\_ ->
expr2 >>= (\z ->
expr3))
(Unterschied bei pattern matching)
Viel Spass mit Formal Methods!