Programmieren in Haskell

Transkript

1 Programmieren in Haskell Programmiermethodik Programmieren in Haskell 1

2 Was wir heute machen Spezifikation Strukturelle Rekursion Strukturelle Induktion Programmieren in Haskell 2

3 Spezifikation sort [8, 3, 5, 3, 6, 1] [1, 3, 3, 5, 6, 8] sort "hello world" " dehllloorw" sort ["Bein", "Anfall", "Anna"] ["Anfall", "Anna", "Bein"] sort [(1, 7), (1, 3), (2, 2)] [(1, 3), (1, 7), (2, 2)] Programmieren in Haskell 3

4 sort :: (Ord a) => [a] -> OrdList a Programmieren in Haskell 4

5 sort :: (Ord a) => [a] -> OrdList a ordered :: (Ord a) => [a] -> Bool ordered [] = True ordered [a] = True ordered (a1:a2:as) = a1 <= a2 && ordered (a2:as) Programmieren in Haskell 4

6 sort :: (Ord a) => [a] -> OrdList a ordered :: (Ord a) => [a] -> Bool ordered [] = True ordered [a] = True ordered (a1:a2:as) = a1 <= a2 && ordered (a2:as) Spezifikation 1: Für alle Listen x :: [τ] muß gelten: ordered (sort x) = True. (1) Programmieren in Haskell 4

7 sort :: (Ord a) => [a] -> OrdList a ordered :: (Ord a) => [a] -> Bool ordered [] = True ordered [a] = True ordered (a1:a2:as) = a1 <= a2 && ordered (a2:as) Spezifikation 1: Für alle Listen x :: [τ] muß gelten: Reicht das? ordered (sort x) = True. (1) Programmieren in Haskell 4

8 sort :: (Ord a) => [a] -> OrdList a ordered :: (Ord a) => [a] -> Bool ordered [] = True ordered [a] = True ordered (a1:a2:as) = a1 <= a2 && ordered (a2:as) Spezifikation 1: Für alle Listen x :: [τ] muß gelten: Reicht das? Nein: \x -> [] ordered (sort x) = True. (1) Programmieren in Haskell 4

9 Multimengen die leere Multimenge, a die einelementige Multimenge, die genau ein Vorkommen von a enthält, x y die Vereinigung der Elemente von x und y; das + im Vereinigungszeichen deutet an, daß sich die Vorkommen in x und y akkumulieren. x = x (2) x = x (3) x y = y x (4) (x y) z = x (y z) (5) Programmieren in Haskell 5

10 bag :: [a] -> Bag a bag [] = bag (a:as) = a bag as Spezifikation 2: Für alle Listen x :: [τ] muß gelten: ordered (sort x) = True bag (sort x) = bag x. (6) Programmieren in Haskell 6

11 Strukturelle Rekursion auf Listen length :: [a] -> Int length [] = 0 length (a:as) = 1 + length as -- vordefiniert Programmieren in Haskell 7

12 Rekursionsbasis: [] Rekursionsschritt: (a:as) Schema der strukturellen Rekursion auf Listen: f :: [σ] -> τ f [] = e 1 f (a : as) = e 2 where s = f as Programmieren in Haskell 8

13 Sortieren durch Einfügen insertionsort :: (Ord a) => [a] -> OrdList a insertionsort [] = e 1 insertionsort (a : as) = e 2 where s = insertionsort as Programmieren in Haskell 9

14 Sortieren durch Einfügen insertionsort :: (Ord a) => [a] -> OrdList a insertionsort [] = e 1 insertionsort (a : as) = e 2 where s = insertionsort as insertionsort :: (Ord a) => [a] -> OrdList a insertionsort [] = [] insertionsort (a:as) = insert a (insertionsort as) Programmieren in Haskell 9

15 Erweitertes Rekursionsschema: g :: σ 1 -> [σ 2 ] -> τ g i [] = e 1 g i (a : as) = e 2 where s = g e 3 as insert :: (Ord a) => a -> OrdList a -> OrdList a insert a [] = e 1 insert a (a : as) = e 2 where s = insert e 3 as Programmieren in Haskell 10

16 insert a [] = [a] insert a (a : as) a <= a = e 21 otherwise = e 22 where s = insert e 3 as insert :: (Ord a) => a -> [a] -> [a] insert a [] = [a] insert a (a :as) a <= a = a:a :as otherwise = a :insert a as Programmieren in Haskell 11

17 isort (8 : 3 : 5 : 3 : 6 : 1 : []) ins 8 (isort (3 : 5 : 3 : 6 : 1 : [])) (Def. isort) ins 8 (ins 3 (isort (5 : 3 : 6 : 1 : []))) (Def. isort)... ins 8 (ins 3 (ins 5 (ins 3 (ins 6 (ins 1 []))))) (Def. isort) ins 8 (ins 3 (ins 5 (ins 3 (ins 6 (1 : []))))) (Def. ins) ins 8 (ins 3 (ins 5 (ins 3 (1 : ins 6 [])))) (Def. ins) ins 8 (ins 3 (ins 5 (1 : ins 3 (ins 6 [])))) (Def. ins)... 1 : ins 8 (ins 3 (ins 5 (ins 3 (ins 6 [])))) (Def. ins) Programmieren in Haskell 12

18 Strukturelle Rekursion auf Bäumen data Tree a = Nil Leaf a Br (Tree a) (Tree a) deriving Show Rekursionsbasis (Nil) Das Problem wird für den leeren Baum gelöst. Rekursionsbasis (Leaf a) Das Problem wird für das Blatt Leaf a gelöst. Rekursionsschritt (Br l r) Um das Problem für den Baum Br l r zu lösen, werden rekursiv Lösungen für l und r bestimmt, die zu einer Lösung für Br l r erweitert werden. Programmieren in Haskell 13

19 Schema der strukturellen Rekursion of Bäumen: f :: Tree σ -> τ f Nil = e 1 f (Leaf a) = e 2 f (Br l r) = e 3 where sl = f l sr = f r Programmieren in Haskell 14

20 size :: Tree a -> Integer size Nil = 1 size (Leaf _) = 1 size (Br l r) = size l + size r depth :: Tree a -> Integer depth Nil = 0 depth (Leaf _) = 0 depth (Br l r) = max (depth l) (depth r) + 1 Programmieren in Haskell 15

21 Das allgemeine Rekursionsschema data T a 1... a m = C 1 t t 1n1... C r t r1... t rnr Seien l i1,..., l ipi mit 1 l i1 < l i2 < < l ipi n i die Positionen, an denen der Konstruktor C i rekursiv ist Programmieren in Haskell 16

22 Allgemeines Schema der strukturellen Rekursion: f :: T σ 1... σ m -> τ f (C 1 x x 1n1 ) = e 1 where s 11 = f x 1l s 1p1 = f x 1l1p1 f (C r x r1... x rnr ) = e r where s r1 = f x rlr1... s rpr = f x rlrp r Programmieren in Haskell 17

23 Verstärkung der Rekursion reverse :: [a] -> [a] -- vordefiniert reverse [] = [] reverse (a:as) = reverse as ++ [a] Programmieren in Haskell 18

24 Verstärkung der Rekursion reverse :: [a] -> [a] -- vordefiniert reverse [] = [] reverse (a:as) = reverse as ++ [a] Spezifikation: reel :: [a] -> [a] -> [a] reel x y = reverse x ++ y Programmieren in Haskell 18

25 Rekursionsbasis (x = []): reel [] y = reverse [] ++ y (Spezifikation) = [] ++ y (Def. reverse) = y (Def. (++)) Programmieren in Haskell 19

26 Rekursionsschritt (x = a:as): reel (a:as) y = reverse (a:as) ++ y (Spezifikation) = (reverse as ++ [a]) ++ y (Def. reverse) = reverse as ++ ([a] ++ y) (Ass. (++)) = reverse as ++ (a:y) (Def. (++)) = reel as (a:y) (Spezifikation) Programmieren in Haskell 20

27 reel :: [a] -> [a] -> [a] reel [] y = y reel (a:as) y = reel as (a:y) Programmieren in Haskell 21

28 reel :: [a] -> [a] -> [a] reel [] y = y reel (a:as) y = reel as (a:y) reverse xs = reverse xs ++ [] (Def. (++)) = (reel xs []) (Spezifikation) Programmieren in Haskell 21

29 reel :: [a] -> [a] -> [a] reel [] y = y reel (a:as) y = reel as (a:y) reverse xs = reverse xs ++ [] (Def. (++)) = (reel xs []) (Spezifikation) reverse :: [a] -> [a] reverse as = reel as [] Programmieren in Haskell 21

30 Strukturelle Induktion auf Listen Induktionsbasis ([]): Wir zeigen die Aussage zunächst für die leere Liste []. Induktionsschritt (a:as): Wir nehmen an, daß die Aussage für die Liste as gilt, und zeigen, daß sie unter dieser Voraussetzung auch für a:as gilt. Beweisregel: Φ([]) ( a, as) Φ(as) = Φ(a:as) ( x) Φ(x) Programmieren in Haskell 22

31 Spezifikation von insert: ordered x = True = ordered (insert a x) = True (7) bag (insert a x) = a bag x (8) Programmieren in Haskell 23

32 Φ(x) ( a) bag (insert a x) = a bag x (9) Induktionsbasis (x = []): bag (insert a []) = bag [a] (Def. insert) = a bag [] (Def. bag) Programmieren in Haskell 24

33 Φ(x) ( a) bag (insert a x) = a bag x Induktionsschritt (x = a :as): Fall a <= a = True: bag (insert a (a :as)) = bag (a:a :as) (Def. insert) = a bag (a :as) (Def. bag) Programmieren in Haskell 25

34 Φ(x) ( a) bag (insert a x) = a bag x Induktionsschritt (x = a :as): Fall a <= a = False: bag (insert a (a :as)) = bag (a :insert a as) (Def. insert) = a bag (insert a as) (Def. bag) = a ( a bag as) (I.V.) = a ( a bag as) (Ass., Komm. ) = a bag (a :as) (Def. bag) Programmieren in Haskell 26

35 Φ(x) ( a) ordered x = True = ordered (insert a x) = True Induktionsbasis (x = []): ordered (insert a []) = ordered [a] (Def. insert) = True (Def. ordered) Programmieren in Haskell 27

36 Induktionsschritt (x = a :as): 1. x = a 1 :as a<=a 1 = True 2. x = a 1 :as a<=a 1 = False as = [] 3. x = a 1 :as a<=a 1 = False as = a 2 :as Programmieren in Haskell 28

37 Φ(x) ( a) ordered x = True = ordered (insert a x) = True Teilfall a<=a 2 = True: ordered (insert a (a 1 :as)) = ordered (a 1 :insert a as) (Def. insert) = ordered (a 1 :a:as) (Def. insert) = a 1 <=a && a<=a 2 && ordered as (Def. ordered) = True (Vor.) Programmieren in Haskell 29

38 Φ(x) ( a) ordered x = True = ordered (insert a x) = True Teilfall a<=a 2 = False: ordered (insert a (a 1 :as)) = ordered (a 1 :insert a as) (Def. insert) = ordered (a 1 :a 2 :insert a as ) (Def. insert) = a 1 <=a 2 && ordered (a 2 :insert a as ) (Def. ordered) = ordered (a 2 :insert a as ) (Vor. unddef. (&&)) = ordered (insert a as) (Def. insert) = True (Vor. und I.V.) Programmieren in Haskell 30

39 Strukturelle Induktion auf Bäumen Induktionsbasis (Nil): Wir zeigen die Aussage für den leeren Baum Nil. Induktionsbasis (Leaf a): Wir zeigen die Aussage für das Blatt Leaf a. Induktionsschritt (Br l r): Wir nehmen an, daß die Aussage für den Teilbaum l und für den Teilbaum r gilt, und zeigen, daß sie unter dieser Voraussetzung auch für den Baum Br l r gilt. Programmieren in Haskell 31

40 Strukturelle Induktion auf Bäumen Induktionsbasis (Nil): Wir zeigen die Aussage für den leeren Baum Nil. Induktionsbasis (Leaf a): Wir zeigen die Aussage für das Blatt Leaf a. Induktionsschritt (Br l r): Wir nehmen an, daß die Aussage für den Teilbaum l und für den Teilbaum r gilt, und zeigen, daß sie unter dieser Voraussetzung auch für den Baum Br l r gilt. Φ(Nil) ( a) Φ(Leaf a) ( l, r) Φ(l) Φ(r) = Φ(Br l r) ( t) Φ(t) Programmieren in Haskell 31

41 Φ(t) size t 2^depth t Programmieren in Haskell 32

42 Φ(t) size t 2^depth t Induktionsbasis (t = Nil): size Nil = 1 (Def. size) = 2^0 (Def. (^)) = 2^depth Nil (Def. depth) Programmieren in Haskell 32

43 Φ(t) size t 2^depth t Induktionsbasis (t = Nil): size Nil = 1 (Def. size) = 2^0 (Def. (^)) = 2^depth Nil (Def. depth) Induktionsbasis (t = Leaf a): size (Leaf a) = 1 (Def. size) = 2^0 (Def. (^)) = 2^depth (Leaf a) (Def. depth) Programmieren in Haskell 32

44 Induktionsschritt (t = Br l r): Φ(t) size t 2^depth t size (Br l r) = size l + size r (Def. size) 2^depth l + 2^depth r (I.V.) 2 * 2^(max (depth l) (depth r)) (Eig. max) = 2^(max (depth l) (depth r) + 1) (Eig. (^)) = 2^depth (Br l r) (Def. depth) Programmieren in Haskell 33

45 Das allgemeine Induktionsschema data T a 1... a m = C 1 t t 1n1... C r t r1... t rnr Programmieren in Haskell 34

46 Das allgemeine Induktionsschema data T a 1... a m = C 1 t t 1n1... C r t r1... t rnr Seien l i1,..., l ipi mit 1 l i1 < l i2 < < l ipi n i die Positionen, an denen der Konstruktor C i rekursiv ist Programmieren in Haskell 34

47 Das allgemeine Induktionsschema data T a 1... a m = C 1 t t 1n1... C r t r1... t rnr Seien l i1,..., l ipi mit 1 l i1 < l i2 < < l ipi n i die Positionen, an denen der Konstruktor C i rekursiv ist ( x x 1n1 ) Φ(x 1l11 ) Φ(x 1l1p1 ) = Φ(C 1 x x 1n1 )... ( x r1... x rnr ) Φ(x rlr1 ) Φ(x ) rlrp r = Φ(C r x r1... x rnr ) ( x) Φ(x) Programmieren in Haskell 34

48 Spezialfall: Natürliche Induktion data Natural = Zero Succ Natural Φ(Zero) ( n) Φ(n) = Φ(Succ n) ( n Nat) Φ(n) Programmieren in Haskell 35