Verifikations- und Spezifikationsmethoden

Was bisher geschah
I
Formale Methoden in der Informatik
I
Wiederholung klassische Logik
I
Konkrete Datentypen (algebraische Strukturen)
I
Abstrakte Datentypen
I
Zusammenhang abstrakte – konkrete Datentypen
I
interaktive Beweise mit Coq
I
Rekursive Datentypen :
Peano-Zahlen, Listen, Binärbäume
70
Wiederholung 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 )
71
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}
Coq:
Inductive N : Set :=
| Z : N
| S : N -> N.
Haskell: data N = Z | S N
72
Beispiel Listen
Listen (polymorph, Elementtyp a)
1. nil ∈ Listh a i
2. xs ∈ Listh a i ∧ x∈a → cons(x,xs) ∈ Listh a i
Coq:
Inductive List (a: Set) : Set :=
| nil : List a
| cons : a -> List a -> List a.
Haskell:
data List a = Nil
| Cons { head :: a, tail :: List a}
Haskell kurz: data [a] = [] | a : [a]
73
Beispiel Binärbäume
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.
Haskell:
data BinTree a = Leaf
| Branch { left :: BinTree a,
key
:: a,
right :: BinTree a}
oder kurz
data BinTree a = Leaf
| Branch ( BinTree a ) a ( BinTree a )
74
Funktionen auf Peano-Zahlen
Addition: (induktiv nach x)
y
falls x = Z
x +y =
S(x 0 + y ) falls x = S(x 0 )
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
75
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
76
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 .
77
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
78
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)
79
Strukturelle Induktion auf Bäumen
I
I
Funktionen Größe, Verdoppeln aller Schlüssel
Nachweis, dass sum doublea llt = 2 ∗ (sumt)|
I
Suchbaum-Eigenschaft
I
Funktionen insert, delete auf Suchbäumen
I
Nachweis, dass insert und delete Suchbaum-Eigenschaft
erhalten
80
Strukturelle Induktion auf Bäumen
81