11.11.2009

Bisher
Denotationale Semantik:
Jedem Programmelement wird ein Wert (in einer algebraischen
Struktur) zugeordnet.
Algebraische Spezifikation:
Abstrakter Datentyp (mehrsortige Algebra) mit
I
Sorten
I
Signatur Σ
I
Axiome
Verifikation:
gegeben: abstrakter Datentyp
konkreter Datentyp (Σ-Struktur, Implementierung)
Frage:
Erfüllt die Implementierung alle Axiome?
Wiederholung Peano-Zahlen
Abstrakter Datentyp Nat
I
Sorte Nat
I
Signatur
ΣNat
I


 Z : Nat

S : Nat → Nat
=


+ : Nat × Nat → Nat
Axiome:
∀a, b, c ∈ Nat:
a+b = b+a
a + (b + c) = (a + b) + c
a+Z
= Z
Abstrakter Datentyp Bool
I
Sorte Bool
I
Signatur
ΣBool
I

∨, ∧



¬
=
t, f



ite
: Bool × Bool → Bool
: Bool → Bool
: Bool
: Bool × Bool × Bool → Bool
Axiome der Booleschen Algebra und zusätzlich
∀x, y , z ∈ Bool
ite(t, x, y ) = x
ite(f, x, y ) = y
¬x
= ite(x, f, t)
x ∧y
= ite(x, y , f)
x ∨y
= ite(x, t, y )







Abstrakter Datentyp (halb-)geordnete Menge
Erweiterung von Bool um
I
Sorte Ord
I
Signatur
ΣOrd = {≤: Ord × Ord → Bool}
I
Axiome:
∀x, y , z ∈ Ord:
(x ≤ x) = t
(x ≤ y ) = t ∧ (y ≤ x) = t → x = y
(x ≤ y ) = t ∧ (y ≤ z) = t → (x ≤ z) = t
Abstrakter Datentyp OList
Liste mit Elementen aus einer geordneten Menge
Erweiterung von (Nat, Ord, Bool) um
I Sorte OList
I Signatur

empty
: OList



 append
: OList × OList → OList




reverse
: OList → OList

delete
: Ord × OList → OList
ΣOList =


cons,
sinsert
: Ord × OList → OList




 length
: OList → Nat


sortiert
: OList → Bool
I



















Axiome,
z.B. ∀k , l ∈ OList ∀e ∈ Ord
length(append(k , l))
=
length(k ) + length(l)
sortiert(l) = t → sortiert(sinsert(e, l)) = t
Konkreter Datentyp N
Abstrakter Datentyp Nat
Konkreter Datentyp N:
Implementierung in Haskell (www.haskell.org)
data N = Z | S N
plus :: N -> N -> N
plus a Z = a
plus a (S b) = S (plus a b)
Verifikation:
Beweis, dass der konkrete Datentyp N alle Axiome des
abstrakten Datentypes Nat erfüllt
Beispiel (schon früher): Verifikation des Axioms
∀m, n ∈ Nat : m + n = n + m
Konkreter Datentyp OListe
Abstrakter Datentyp OList
Konkreter Datentyp OListe:
data OListe a = Nil | Cons a (OListe a)
append :: (OListe a) -> (OListe a) -> (OListe a)
append Nil ys = ys
append (Cons e xs) ys = Cons e (append xs ys)
len :: (OListe a) -> N
len Nil = Z
len (Cons x xs) = S (len xs)
Verifikation:
Beweis, dass der konkrete Datentyp OListe alle Axiome des
abstrakten Datentypes OList erfüllt
Beispiel (Tafel): Verifikation des Axioms
∀k , l ∈ OList : length(append(k , l)) = length(k ) + length(l)