27.10.2011

Was bisher geschah
I
Formale Methoden in der Informatik
I
Wiederholung klassische Logik
I
Konkrete Datentypen (algebraische Strukturen)
Abstrakte Datentypen
I
I
I
Syntax: Signatur
Semantik: Axiome (FOL-Formeln, meist allquantifizierte
Gleichungen zwischen Termen)
I
Zusammenhang abstrakte – konkrete Datentypen
I
interaktive Beweise mit Coq
56
Wiederholung ADT
Beispiel: ADT für natürliche Zahlen (unvollständig)
Sorten S: N, B
Signatur Σ :
0, 1 :
→N
+, · : N × N
→N
=, ≤ : N × N
→B
Axiome Φ : ∀x, y , z :
0·x
= 0=x ·0
x · (y + z) = (x · y ) + (x · z)
Halbring-Axiome für (N, +, ·, 0, 1)
Äquivalenzrelation-Axiome für =
Halbordungs-Axiome für ≤
Axiome der Booleschen Algebra
57
Rekursive Datentypen
induktive Definition eines rekursiven Datentyps T :
IA: direkte Definition eine Menge von Basiselementen
{b1 , . . . , bn }
IS: Methode zur Konstruktion komplexer Elemente
C(x1 , . . . , xm ) aus Elementen x1 , . . . , xm
(Baumstruktur)
rekursive Definition von Funktionen f : T → . . . auf diesem
Datentyp:
IA: Definition der Funktionswerte f (x) für alle
Basiselemente x ∈ {b1 , . . . , bn }
IS: Definition des Funktionswertes f (C(x1 , . . . , xm ))
(evtl.) aus den gegebenen Werten f (x1 ), . . . , f (xm )
58
Beispiel Peano-Zahlen
Peano-Axiome:
Die Menge N aller natürlichen Zahlen ist die kleinste Menge mit
den folgenden Eigenschaften
1. Z (Zero für 0) ist eine natürliche Zahl.
(Z ∈ N)
2. Jeder Nachfolger einer natürlichen Zahl ist eine natürliche
Zahl.
(∀x : x ∈ N → S(x) ∈ N)
mathematisch:N = {Z } ∪ {S(x) | x ∈ N}
Haskell: data N = Z | S N
Coq:
Inductive N : Set :=
| Z : N
| S : N -> N.
59
Mehr Beispiele
I
Listen (polymorph, Elementtyp a)
1. nil ∈ Listh a i
2. xs ∈ Listh a i ∧ x∈a → cons(x,xs) ∈ Listh a i
Coq:
I
Inductive List (a: Set) : Set :=
| nil : List a
| cons : a -> List a -> List a.
Binärbäume (polymorph, Elementtyp a)
1. Leaf ∈ bintreeh a i
2. l, r∈ bintreeh a i ∧ x∈a → Branch(l,x,r) ∈ bintreeh a i
Coq:
Inductive bintree (a: Type): Type :=
| Leaf : bintree a
| Branch : bintree a -> a -> bintree a
-> bintree a.
60
Funktionen auf Peano-Zahlen
Addition: (induktiv nach x)
y
falls x = Z
x +y =
S(x 0 + y ) falls x = S (x’)
in Coq:
Fixpoint plus (x : N) (y : N) { struct x } : N :=
match x with
| Z => y
| S x’ => S (plus x’ y)
end.
Multiplikation:
Fixpoint mal (x : N) (y : N) { struct x } : N :=
match x with
| Z => ...
| S x’ => ...
end.
gewünschte Eigenschaften (Spezifikation), z.B.:
Assoziativität, Kommutativität, neutrale Elemente
61
Listen
Inductive List (a: Set) : Set :=
| nil : List a
| cons : a -> List a -> List a.
Funktionen auf Listen:
Länge:
Fixpoint length (a : Set) (xs : List a)
{struct xs} : N := match xs with
| nil => Z
| cons x xs’ => S (length a xs’)
end.
Verkettung:
Fixpoint append (a : Set) (xs : List a) (ys : List a)
{ struct xs} : List a := match xs with
|
nil => ys
|
cons x xs’ => cons a x ( append a xs’ ys )
end .
gewünschte Eigenschaften (Spezifikation), z.B.:
Assoziativität von append, neutrales Element
62
Binärbäume
Inductive bintree (a: Type): Type :=
| Leaf : bintree a
| Branch : bintree a -> a -> bintree a
-> bintree a.
Funktionen auf Bäumen:
Anzahl der Knoten:
Fixpoint size (a: Set) (t : bintree a) : ( nat ) :=
match t with
| Leaf => 0
| Branch l k r => (size l) + 1 + (size r)
end .
Inorder-Durchquerung:
Fixpoint inorder (a: Type) (t : bintree a) : ( List a )
match t with
| Leaf => nil a
| Branch l k r =>
app (inorder a l) (cons k (inorder a r))
end .
63
Strukturelle Induktion
zum Nachweis einer Eigenschaft P(x) für alle Elemente x des
rekursiven Datentyps T
Induktion über den Aufbau des Elementes:
IA: Nachweis von P(x) für alle Basiselemente
x ∈ {b1 , . . . , bn }
IS: Induktionsvoraussetzung: P(x) gilt für alle
Elemente x ∈ {x1 , . . . , xn }
Induktionsbehauptung: P(x) gilt auch für das
zusammengesetzte Element
C(x1 , . . . , xm )
( für alle Konstruktoren C von T )
Induktionsbeweis: Nachweis, dass IV → IB gilt
64
Strukturelle Induktion
Peano-Zahlen mit Addition:
I (beidseitige) Neutralität von 0
I Kommutativität
I Assoziativität
Peano-Zahlen mit Multiplikation:
I Definition der Multiplikation
I Neutralität von S(Z )
I Assoziativität
Listen mit Verkettung:
I Definition der Verkettung
I Neutralität der leeren Liste (rechts, links)
I Assoziativität der Verkettung
I Länge verketteter Listen ist Summe der Längen
∀k , l ∈ List : length(append(k , l)) = length(k ) + length(l)
65
Listen natürlicher Zahlen
Funktionen:
I
Summe aller Elemente
induktiver Beweis für
sum [1,2, .., n] = n ( n + 1 ) / 2
I
Jedes Element verdoppeln
induktiver Beweis für
sum double_all xs = 2 * sum xs
analog für Bäume
66