Verifikations- und Spezifikationsmethoden

Was bisher geschah
◮ Formale Methoden in der Informatik
◮ sicherheitskritische Anwendungen
◮ Spezifikation: mathematisch korrekte Beschreibung von
Anforderungen an Software und Systeme
◮ Verifikation: Nachweis der Korrektheit von Entwürfen,
Software und Systemen relativ zu einer Spezifikation
◮ Sematik von Programmen (operational, axiomatisch,
algebraisch)
◮ Wiederholung klassische Logik
◮ Beweise in klassischer Logik (Resolution)

ADT – Motivation
Algebraische Spezifikation abstraker Datentypen:
Formale Methode zur Spezifikation und zum Nachweis der
Korrektheit von Programmen (Schnittstellen).
axiomatisch Menge von Axiomen definiert den Datentyp
(als Klasse aller Strukturen, die diese Axiome
erfüllen)
applikativ basiert auf einfachen mathematischen
Grundkonzepten: Mengen, Funktionen
(keine Programmlogik, Ablaufsteuerung)
◮ Beschreibung der beabsichtigten Funktionalität
◮ keine Beschreibung der Repräsentation der Daten

Datentypen
(Konkreter) Datentyp:
◮ (nichtleere) Menge A von Werten
◮ Menge von auf A definierten Operationen
Beispiel:
◮ Wertebereich bool = {t, f}
mit den Operationen
AND : bool × bool → bool
OR : bool × bool → bool,
XOR : bool × bool → bool,
NOT : bool → bool,
true : bool,
false : bool,
◮ Wertebereich string mit
den Operationen reverse, ++ usw.
◮ Wertebereich int mit
den Operationen +, ·, 0, 1 usw.

Algebraische Strukturen
Algebraische Struktur A = (A, Ω) mit
◮ Trägermenge A
◮ Menge Ω = {f 1 , f 2 , . . .} von Operationen (mit fester
Stelligkeit)
Beispiele:
◮ (N, +, 0) mit den üblichen Rechenregeln
◮ (N, +, 27) mit den üblichen Rechenregeln
◮ ({t, f}, ∨, ∧, t)
◮ ({0, 1}, max, min, 1)
◮ ({0, 1, 2}, +( mod 3), 0)
◮ (A ∗ , ◦, ε) (◦ Verkettung, ε leeres Wort)
◮ (2 X , ∪, ∩, ∅)

Signaturen
Signatur Σ:
◮ Menge von Sorten (Mengen von Werten)
◮ Menge von Funktionssymbolen mit Typdeklaration
Beispiel:
Signatur Σ:
◮ eine Sorte A,
◮ zwei Funktionssymbole f : A × A → A und c : A

Beispiele: Signaturen
◮ Signatur für Halbgruppen:
◮ eine Sorte A
◮ Funktionssymbol · : A × A → A
◮ Signatur für Monoide:
◮ eine Sorte A
◮ Funktionssymbole · : A × A → A und e : A
◮ Signatur für Boolesche Algebren:
◮ eine Sorte B
◮ Funktionssymbole ∨ : B × B → B, ∧ : B × B → B,
¬ : B → B, true : B, false : B
Signatur sagt nichts über die Bedeutung der
Funktionssysmbole.

Σ-Strukturen
Wann passt eine algebraische Struktur zu einer Signatur?
gegeben: Signatur Σ
Algebraische Struktur A heißt genau dann Σ-Struktur, wenn
sich jedem Funktionssysmbol aus der Signatur genau eine
Funktion auf A zuordnen lässt.
Beispiele:
◮ Signatur für Monoide:
◮ eine Sorte A
◮ zwei Funktionssymbole · : A × A → A und e : A
passende Strukturen: (N, +, 0), (N, +, 12), (2 X , ∪, ∅),
({0, 1, 2}, +( mod 3), 0), . . .
◮ Signatur für Boolesche Algebren
◮ eine Sorte B
◮ Funktionssymbole ∨ : B × B → B, ∧ : B × B → B,
¬ : B → B t : B f : B
passende Strukturen: ({0, 1}, max, min, x ↦→ 1 − x, 1, 0),
(2 X , ∪, ∩, , X, ∅), (R, +, ·, √ , 12, 27), . . .

Axiome
Bedeutung der Funktionssysmbole wird durch Axiome
(Bedingungen) bestimmt.
Darstellung der Axiome als
◮ logische Formeln
◮ Gleichungen zwischen Termen
Beispiele:
◮ Assoziativität
◮ Rechenregeln
◮ Gesetze der Booleschen Algebra

Beispiel: Kommutative Monoide
Signatur: Sorte A, Operationen · : A × A → A, e : A
Axiome:
(1) ∀a, b ∈ A : a + b = b + a
(2) ∀a, b, c ∈ A : (a + b) + c = a + (b + c)
(3) ∀a ∈ A : a + 0 = a
Beispiele:
◮ (N, +, 0) erfüllt Signatur und Axiome
◮ (N, +, 3) erfüllt Signatur, aber Axiom (3) nicht
◮ (A ∗ , ◦, ε) erfüllt Signatur, aber Axiom (1) nicht
◮ (2 X , ∪, ∅) erfüllt Signatur und Axiome
◮ (2 X , ∪, , ∅) erfüllt Signatur nicht

Abstrakte Datentypen
Spezifikation eines abstrakten Datentyps:
◮ Signatur Σ (Syntax) und
◮ Menge von Axiomen (Semantik)
Beispiele:
◮ Bool
◮ Nat
Jeder ADT repräsentiert eine Menge konkreter Datentypen
(genau die Menge aller Strukturen passender Signatur, die alle
Axiome erfüllen)

ADT Bool
◮ Signatur
⎧
⎨ ∨, ∧ : Bool × Bool → Bool
Σ Bool = ¬ : Bool → Bool
⎩
f, t : Bool
◮ Menge von Axiomen
¬t = f
∀x, y ∈ Bool : x ∨ y = y ∨ x
⎫
⎬
∀x, y, z ∈ Bool : x ∨ (y ∨ z) = (x ∨ y) ∨ z
∀x ∈ Bool : ¬¬x = x
∀x ∈ Bool : f ∧ x = f
∀x ∈ Bool : t ∧ x = x
∀x, y ∈ Bool : x ∨ y = ¬(¬x ∧ ¬y)
⎭

ADT Nat
◮ eine Sorte Nat
◮ Signatur
⎧
null
⎪⎨
succ
Σ Nat =
plus ⎪⎩
mult
⎫
: Nat
⎪⎬
: Nat → Nat
: Nat × Nat → Nat ⎪⎭
: Nat × Nat → Nat
◮ Menge von Axiomen, z.B. ∀x, y, z ∈ Nat:
plus(x, null) = x
plus(null, x) = x
plus(x, y) = plus(y, x)
plus(x, plus(y, z)) = plus(plus(x, y), z)
mult(x, succ(null)) = x
mult(x, y) = mult(y, x)

Konkrete Datentypen
Abstrakter Datentyp:
◮ Signatur Σ
◮ Menge Φ von Axiomen
passender konkreter Datentyp:
Σ-Struktur A,
in welcher alle Axiome aus Φ erfüllt sind
Beispiel: Abstrakter Datentyp Bool
◮ Σ Bool
◮ Axiome der Booleschen Algebra
Konkrete Datentypen:
◮ ({0, 1}, max, min, x ↦→ 1 − x, 0, 1)
◮ (2 X , ∪, ∩, , ∅, X)

Zusammengesetze Datentypen
Konstruktion neuer Datentypen aus (A, Ω A ) und (B, Ω B )
Kreuzprodukt der Trägermengen A × B:
C: struct, Pascal: record, Java: Object
Konstruktor A × B → C
Zugriff C → A, C → B
Beispiel: Student mit Name, Vorname,
Studentennummer
Vereinigung der Trägermengen A ∪ B:
C: union, Pascal: record (nur Variantenteil), Java:?
typisches Beispiel: Aufzählungstypen (z.B.
Wochentage)
Zugriff durch Fallunterscheidung
Interface repräsentiert disjunkte Summe aller
Typen, die es implementieren
Potenz der Trägermengen A → B:
Funktionen
Konstruktion je nach Realisierung
Zugriff: Funktionsanwendung

Mehrsortige Strukturen
Abstrakter zusammengesetzter Datentyp:
◮ Vereinigung der Signaturen
evtl. neue Symbole für Operationen mit Parametern und
Werten aus mehreren Signaturen
◮ Vereinigung der Axiommengen
und Axiome für Operationen auf verschiedenen
Wertemengen
Konkreter zusammengesetzter Datentyp:
Mehrsortige Algebra:
◮ Trägermengen zu jeder Signatur (Sorten)
◮ Operationen

Beispiel: Geordnete Menge
Abstrakter Datentyp:
◮ Sorten: M, Bool
◮ Signatur
⎧
⎪⎨
Σ NB =
⎪⎩
∨, ∧ : Bool × Bool → Bool
¬ : Bool → Bool
f, t : Bool
≤ : M × M → Bool
◮ Axiome der Booleschen Algebra
Eigenschaften von Ordnungsrelationen
Konkrete Datentypen:
◮ Trägermengen N, {0, 1} mit Booleschen Operationen auf
{0, 1} und ≤ auf N
◮ Trägermengen 2 X , {0, 1} mit Booleschen Operationen auf
{0, 1} und ⊆ auf 2 X
⎫
⎪⎬
⎪⎭

Beispiel: NatStack
Abstrakter Datentyp:
◮ Sorten: Nat, NatStack
◮ Signatur: Signatur von Nat und
⎧
⎫
new : NatStack
⎪⎨
⎪⎬
push : NatStack × Nat → NatStack
Σ NatStack =
pop : NatStack → NatStack
⎪⎩
⎪⎭
top : NatStack → Nat
◮ Axiome: ∀s ∈ NatStack, e ∈ Nat :
pop(push(s, e)) = s
top(push(s, e)) = e
pop(new) = new
top(new) = 0

Beispiel: NatStack
Konkreter Datentyp:
Trägermengen N (Nat), N ∗ (NatStack) mit
V ordnet jedem Funktionssymbol aus Σ NatStack eine Funktion
auf N ∪ N ∗ zu:
V (new) = (0)
V (push)((x 1 , . . . , x n ), m) =
{
(m, x 1 , . . . , x n )
(0) falls s = (0)
V (pop)(s) =
(x 2 , . . . , x n ) falls s = (x 1 , . . . , x n )
V (top)(x 1 , . . . , x n ) = x 1

Beispiel: NatList
Abstrakter Datentyp:
◮ Sorten: Nat, NatList
◮ Signatur: Signatur von Nat und
⎧
⎪⎨
Σ NatList =
⎪⎩
Nil
cons
reverse
append
insert
deleteFrom
length
: NatList
: Nat × NatList → NatList
: NatList → NatList
: NatList × NatList → NatList
: Nat × NatList → NatList
: Nat × 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

Beispiel: Sortierte NatList
SNatList wie NatList
zusätzliche Sorte: Bool
zusätzliche Operation (Prädikat):
sortiert : NatList → Bool
zusätzliche Axiome:
sortiert(Nil) = t
sortiert(cons(e, Nil)) = t
{ t falls e ≤ f ∧ sortiert(cons(f , l))
sortiert(cons(e, cons(f , l))) =
f sonst
sortiert(l) → sortiert(insert(e, l))
}