Verifikations- und Spezifikationsmethoden

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
59
Wiederholung ADT
Beispiel: ADT für natürliche Zahlen (unvollständig)
Sorten S: Nat, Bool
Signatur Σ :
→ Nat
0:
+, · : Nat × Nat
→ Nat
=, ≤ : Nat × Nat
→ Bool
Axiome Φ : ∀x, y , z ∈ Nat:
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 ≤
Axiom für totale Ordnung ≤
Axiome der Booleschen Algebra
60
ADT NatStack
Abstrakter Datentyp:
I
Sorten: Nat, NatStack, Bool
I
Signatur: Signatur von Nat und

new
: NatStack




push
: NatStack × Nat → NatStack



pop
: NatStack → NatStack
ΣNatStack =
top
: NatStack → Nat




t,
f
: Bool



isempty : NatStack → Bool
I















(einige) Axiome: ∀s ∈ NatStack, e ∈ Nat :
pop(push(s, e))
= s
top(push(s, e))
= e
isempty(new)
= t
isempty(push(s, e))
= f
pop(new)
= ...
top(new)
= ...
61
Beispiel: konkreter Datentyp zum ADT NatStack
Konkreter Datentyp (algebraische Struktur) A:
Trägermengen (Nat), ∗ (NatStack) mit
J·KA ordnet jedem Funktionssymbol aus ΣNatStack
eine Funktion entsprechenden Typs auf ∪ ∗ zu:
N
N
N N
→ NatStack
= ()
new :
JnewKA
push :
NatStack × Nat → NatStack
JpushKA ((x1 , . . . , xn ), m) = (m, x1 , . . . , xn )
pop :
NatStack
JpopKA
(s)
top :
JtopKA
NatStack
(x1 , . . . , xn )
top(new) = ?
→
NatStack
()
falls s = ()
=
(x2 , . . . , xn ) falls s = (x1 , . . . , xn )
→ Nat
= x1
pop(new) = ?
62
ADT NatList
Abstrakter Datentyp:
I Sorten: Nat, NatList
I Signatur: Signatur von Nat und

Nil
:




cons
:
Nat × NatList




reverse
:
NatList

append : NatList × NatList
ΣNatList =


insert
: Nat × NatList





delete
: Nat × NatList


length
: NatList
I
→ NatList
→ NatList
→ NatList
→ NatList
→ NatList
→ NatList
→ Nat



















Axiome, z.B. ∀k , l ∈ NatList, e ∈ Nat:
append(cons(e, k ), l) = cons(e, append(k , l))
length(Nil) = 0
reverse(reverse(l)) = l
63
Beispiel: Sortierte NatList
SNatList wie NatList
zusätzliche Sorte: Bool
zusätzliche Operationen:
<
: Nat × Nat → Bool
sortiert : NatList
→ Bool
zusätzliche Axiome: ∀l ∈ NatList, e, f ∈ Nat:
sortiert(Nil)
=
t
sortiert(cons(e, Nil))
=
t
sortiert(cons(e, cons(f , l)))
=
t falls e ≤ f ∧ sortiert(cons(f , l))
f sonst
sortiert(l) → sortiert(insert(e, l))
64
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 )
65
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
66
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]
67
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 )
68
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
69