Formale Methoden - Universität Augsburg

informatik.uni.augsburg.de

Formale Methoden - Universität Augsburg

Formale Methoden

Alexander Knapp, Gerhard Schellhorn

Universität Augsburg


Formale Methoden: Ziele (1)

Grundlagen für die Softwareerstellung

” Mathematik von Spezifikations- und Programmiersprachen“

◮ Vermeidung von Mißverständnissen und Unklarheiten

◮ Was bedeutet eine UML-Spezifikation?

◮ Welche Compileroptimierungen sind möglich?

◮ Ermöglichung von präzisen Vorhersagen und Tests

◮ Verständnisverbesserung

◮ Was sind ” gute“, ” gut strukturierte“ und ” gut dokumentierte“ Programme?

◮ Was sind ” saubere“ Schnittstellen?

◮ Was ist eine ” gute“ Spezifikationssprache?

A computer is a mathematical machine.

A program is a mathematical expression.

A programming language is a mathematical theory.

Programming is a mathematical activity.

— C. Anthony R. Hoare, 1989

A. Knapp, G. Schellhorn: Formale Methoden 2


Formale Methoden: Ziele (2)

Entwicklung von Software mit formalen Spezifikationen

Formale Spezifikation der Anforderungen

❀ höhere Abstraktion als direkte Programmierung

◮ Validierung, Nachweis von (Sicherheits-)Eigenschaften

❀ Qualitätsverbesserung durch frühere Fehlererkennung

◮ Methodik, um von abstrakten Anforderungen zu Programmen zu kommen

❀ modulare Softwareentwicklung

◮ Aber: formale Spezifikationen beseitigen keine Mißverständnisse mit dem

Kunden

❀ formale Methoden sind für den Softwareingenieur, nicht für den Kunden

A. Knapp, G. Schellhorn: Formale Methoden 3


Formale Methoden: Ziele (3)

Formaler, systemunterstützter Nachweis von Eigenschaften

◮ Beweise von Eigenschaften sichern Qualität der Spezifikation

◮ Beweise für die Korrektheit von Programmen bzgl. Spezifikation sichern

Qualität der Programme

◮ formale Beweise kosten Zusatzaufwand

❀ Grad der Formalisierung immer eine Kosten/Nutzen-Abwägung!

Proofs of programs are too boring for the social

process of mathematics to work.

— Richard DeMillo, Richard Lipton, Alan Perlis, 1979

A. Knapp, G. Schellhorn: Formale Methoden 4


Spezifikationssprachen

Eine Spezifikationssprache ist eine Sprache zur Beschreibung von

Softwaresystemen oder der Anforderungen an Softwaresysteme.

Beispiele

◮ automatenartige Spezifikationen (Statecharts etc.)

◮ algebraische Spezifikationen

◮ Programmiersprachen

Grundsätzliches Vorgehen zur Definition

◮ Festlegung von Syntax und Semantik

A. Knapp, G. Schellhorn: Formale Methoden 5


Spezifikationssprachen: Syntax und Semantik

Syntax: Wie sehen zulässige Sprachkonstrukte aus?

◮ Formal: Definition einer Menge von zulässigen Texten (Zeichenketten)

◮ bei Rechnerunterstützung typischerweise durch Grammatik gegeben

Semantik: Was bedeutet eine Zeichenkette?

◮ Formal: Zuordnung von mathematischen Strukturen (meist basierend auf

Mengenlehre)

◮ Bei Programmiersprachen: Informell im Handbuch durch Beschreibung

des Effekts jedes Konstrukts auf den Ausführungszustand

A. Knapp, G. Schellhorn: Formale Methoden 6


Formales Beweisen

◮ Einbettung von Spezifikationen in eine formale Sprache, mit der Aussagen

bewiesen werden können

Formale Beweise ersetzen mathematische Beweise durch ” Berechnung“

mit einem Kalkül

◮ keine Fehler (wenn nur Kalkülregeln fehlerfrei)

◮ Logik = Syntax + Semantik + Kalkül

◮ Grundlegende Sprachen zur Formulierung von Aussagen:

Aussagenlogik und Prädikatenlogik

A. Knapp, G. Schellhorn: Formale Methoden 7


Überblick

◮ Logische Grundlagen

◮ Aussagenlogik

◮ Prädikatenlogik

◮ Spezifikation von Datenstrukturen

◮ Semantik von Programmen

◮ Beweisen mit Programmen

◮ Von abstrakten Spezifikationen zu konkreten Programmen

◮ algebraische Verfeinerung

◮ Datenverfeinerung

A. Knapp, G. Schellhorn: Formale Methoden 8


Aussagenlogik

Ein Satz ist, was an sich verneint oder bejaht werden kann.

— Chrysipp, Dialektische Definitionen (nach Diogenes Laertios)

Der genannte Mann (Chrysipp) sagt, daß er (der Hund) öfters das fünfte

Unbeweisbare anwendet, wenn er, auf eine Kreuzung von drei Wegen

kommend, nachdem er zwei Wege, durch welche das Wild nicht gegangen

ist, berochen hat, unmittelbar durch den dritten sich wirft, ohne ihn zu

beriechen. Der alte (Meister) sagt nämlich, daß der Hund potentiell so

schließt: ” Entweder hier, oder hier, oder hier ist das Wild durchgegangen;

nun weder hier, noch hier; also hier.“

— M. Tullius Cicero, Topica 57

Es krächzen selbst die Raben auf den Dächern, welche Implikationen richtig

sind.

— Kallimachos (nach Sextus Empiricus)

A. Knapp, G. Schellhorn: Formale Methoden 9


Aussagenlogik: Syntax

(Endliche) Menge von atomaren Aussagen P (Propositionen)

◮ Proposition entweder wahr oder falsch

◮ Zeichenketten (verschieden von ” true“, ” false“, ” ¬“, ” ∧“, . . . )

◮ z. B. P = {a, b, c}

Definition Die Menge der aussagenlogischen Formeln F (P) über einer

Menge von Propositionen P ist die kleinste Menge mit:

◮ P ⊆ F (P)

◮ true, false ∈ F (P)

◮ Wenn A ∈ F (P), dann (¬A) ∈ F (P).

◮ Wenn A, B ∈ F (P), dann (A ∧ B), (A ∨ B), (A → B), (A ↔ B) ∈ F (P).

¬, ∧, ∨, →, ↔ heißen Junktoren.

A. Knapp, G. Schellhorn: Formale Methoden 10


Formeln: Notation

◮ Klammern werden entsprechend der Bindungsstärken weggelassen:

{¬} ≻ {∧} ≻ {∨} ≻ {→} ≻ {↔}

(≻ bedeutet: bindet stärker als)

◮ Außenklammern werden ebenfalls weggelassen.

◮ Aufzählungen mit ∧, ∨ sind implizit nach rechts geklammert.

Beispiele:

◮ a → ¬b ↔ c statt ((a → (¬b)) ↔ c)

◮ a ↔ ¬b ∧ c ∧ d ∨ e statt (a ↔ (((¬b) ∧ (c ∧ d)) ∨ e))

A. Knapp, G. Schellhorn: Formale Methoden 11


Formeln: Definitionsprinzip für Funktionen

Um eine Funktion f auf Formeln F (P) zu definieren, verfahre rekursiv:

1. f (p) für Propositionen p ∈ P

2. f (false), f (true)

3. f (¬A) unter Zuhilfenahme von f (A)

4. f (A ∧ B), f (A ∨ B), f (A → B), f (A ↔ B) unter Zuhilfenahme von f (A), f (B)

Beispiele:

◮ Anzahl der Junktoren

◮ (endliche) Menge der vorkommenden Propositionen

◮ Menge der Unterformeln einer Formel

A. Knapp, G. Schellhorn: Formale Methoden 12


Formeln: Beweisprinzip für Eigenschaften

Um zu zeigen, daß alle Formeln in F (P) eine Eigenschaft E haben, verfahre

induktiv:

1. E(p) gilt für alle atomaren Formeln p ∈ P.

2. E(false), E(true)

3. Wenn E(A) für A ∈ F (P) gilt, dann auch E(¬A).

4. Wenn E(A) und E(B) für A, B ∈ F (P) gelten, dann auch E(A ∧ B),

E(A ∨ B), E(A → B), E(A ↔ B).

Beispiel:

◮ Alle Formeln haben eine gerade Zahl von Klammern.

A. Knapp, G. Schellhorn: Formale Methoden 13


Aussagenlogik: Semantik (1)

Zuweisung eines Wahrheitswerts für jede aussagenlogische Formel

◮ Wahrheitswert hängt nur von Wahrheitswerten der vorkommenden

Propositionen ab

Definition Eine Interpretation I : P → B ordnet jeder Proposition einen

Wahrheitswert aus B = {ff , tt} zu.

Die Semantikklammern − umschließen immer Sprachkonstrukte und liefern

deren Semantik. Hier hängt die Semantik PA I einer aussagenlogischen

Formel A von einer Interpretation I ab.

A. Knapp, G. Schellhorn: Formale Methoden 14


Aussagenlogik: Semantik (2)

Definition Für jede Interpretation I wird einer aussagenlogischen Formel A

als Semantik der folgende Wahrheitswert PA I zugeordnet:

◮ Pp I = I(p)

◮ Pfalse I = ff

◮ Ptrue I = tt

◮ P¬A I = tt gdw. PA I = ff

◮ PA ∧ B I = tt gdw. PA I = tt und PB I = tt

◮ PA ∨ B I = tt gdw. PA I = tt oder PB I = tt

◮ PA → B I = tt gdw. PA I = ff oder PB I = tt

◮ PA ↔ B I = tt gdw. PA I = PB I

Die Definitionen für ∧, ∨, &c. entsprechen den üblichen Wahrheitstafeln.

A. Knapp, G. Schellhorn: Formale Methoden 15


Modelle

Definition Eine Interpretation I heißt ein Modell einer aussagenlogischen

Formel A, geschrieben als I |= A, falls PA I = tt.

Definition Sei A eine aussagenlogische Formel.

◮ A ist erfüllbar, wenn es ein Modell von A gibt.

◮ A ist widersprüchlich (eine Kontradiktion), wenn es kein Modell von A gibt.

◮ A ist allgemeingültig (eine Tautologie), geschrieben als |= A, wenn jede

Beispiele:

Interpretation ein Modell von A ist.

◮ a ∨ ¬a ist allgemeingültig.

◮ a ∨ ¬b ist erfüllbar, aber nicht allgemeingültig.

◮ a ∧ ¬a ist widersprüchlich.

Es gilt: A ist erfüllbar gdw. ¬A ist nicht allgemeingültig.

A. Knapp, G. Schellhorn: Formale Methoden 16


Tautologien (1)

1. (A ∨ B) ↔ (B ∨ A) Kommutativität ∨

2. (A ∨ B) ∨ C ↔ A ∨ (B ∨ C) Assoziativität ∨

3. A ∨ A ↔ A Idempotenz ∨

4. (A ∧ B) ↔ (B ∧ A) Kommutativität ∧

5. (A ∧ B) ∧ C ↔ A ∧ (B ∧ C) Assoziativität ∧

6. A ∧ A ↔ A Idempotenz ∧

7. A ∨ (B ∧ C) ↔ (A ∨ B) ∧ (A ∨ C) Distributivität ∨

8. A ∧ (B ∨ C) ↔ (A ∧ B) ∨ (A ∧ C) Distributivität ∧

9. ¬(A ∨ B) ↔ ¬A ∧ ¬B DeMorgan ∨

10. ¬(A ∧ B) ↔ ¬A ∨ ¬B DeMorgan ∧

11. A ∧ (A ∨ B) ↔ A Redundanz ∧

12. A ∨ (A ∧ B) ↔ A Redundanz ∨

13. ¬¬A ↔ A Doppelnegation

A. Knapp, G. Schellhorn: Formale Methoden 17


Tautologien (2)

14. (A → B) → ((B → C) → (A → C)) Transitivität

15. A → ((A → B) → B) Modus Ponens

16. (A → ¬A) → ¬A Selbstwiderlegung

17. (A → B) ↔ (¬B → ¬A) Kontraposition

18. (A ∧ ¬A) → B Ex falso quodlibet

19. (A → B) ↔ (¬A ∨ B) Implikation vs. Disjunktion

20. (A ↔ B) ↔ (A → B) ∧ (B → A) Äquivalenz ∧

21. (A ↔ B) ↔ (A ∧ B) ∨ (¬A ∧ ¬B) Äquivalenz ∨

22. (A → B) ∧ (¬A → B) → B Fallunterscheidung

23. A → (B → C) ↔ A ∧ B → C geschachtelte Implikation

24. (A ↔ B) ↔ (B ↔ A) Kommutativität ↔

25. ((A ↔ B) ↔ C) ↔ (A ↔ (B ↔ C)) Assoziativität ↔

A. Knapp, G. Schellhorn: Formale Methoden 18


Tautologien (3)

Analog auch Or-true &c.

26. (A ∧ false) ↔ false And-false

27. (A ∧ true) ↔ A And-true

28. (A → false) ↔ ¬A Imp-false

29. (A → true) ↔ true Imp-true

30. (true → A) ↔ A true-Imp

31. (false → A) ↔ true false-Imp

32. (A ↔ true) ↔ A Equiv-true

33. (A ↔ false) ↔ ¬A Equiv-false

34. (A ∨ ¬A) ↔ true triviale Disjunktion

35. (A ∧ ¬A) ↔ false triviale Konjunktion

A. Knapp, G. Schellhorn: Formale Methoden 19


Folgerbarkeit

Folgerung von Theoremen aus (als wahr angenommenen) Axiomen

Ax ⊆ F (P)

Definition Eine Interpretation I heißt ein Modell einer Menge von

aussagenlogischen Formeln Ax, geschrieben als I |= Ax, falls PA I = tt für

alle A ∈ Ax. Die Menge Ax heißt erfüllbar, wenn es ein Modell von Ax gibt.

Für endliche Mengen Ax ist I |= Ax äquivalent zu I |=

A∈Ax A.

Definition Eine aussagenlogische Formel A ist eine Folgerung aus einer

Menge von aussagenlogischen Formeln Ax, geschrieben als Ax |= A, wenn für

jede Interpretation I mit I |= Ax auch I |= A gilt.

A. Knapp, G. Schellhorn: Formale Methoden 20


Folgerbarkeit und Erfüllbarkeit

Satz Zu Ax |= A sind äquivalent:

◮ Ax ∪ {¬A} ist nicht erfüllbar.

◮ |= ( Ax) → A, falls Ax endlich.

◮ Reduktion des Folgerbarkeitsproblem auf die Suche nach einer

erfüllenden Interpretation

A. Knapp, G. Schellhorn: Formale Methoden 21


Erfüllbarkeit: Beispiel (1)

n-Damen-Problem

◮ Ist es möglich, auf einem Schachbrett mit n × n Feldern n Damen so zu

plazieren, daß keine Dame direkt eine andere Dame schlagen kann?

◮ Suche einer Aufstellung, in der in jeder Zeile genau eine Dame, und auf

keiner Spalte und keiner Diagonale zwei Damen

A. Knapp, G. Schellhorn: Formale Methoden 22


Erfüllbarkeit: Beispiel (2)

Codierung des n-Damen-Problems

◮ n 2 Variablen der Form p (x,y) mit x, y ∈ {1, . . . , n}

◮ p (x,y) für ” auf Feld (x, y) steht eine Dame“

1. In jeder Zeile und Spalte nur eine Dame

F1 ≡ n n

x=1 y=1

p(x,y) → n i=x+1 ¬p

(i,y)

F2 ≡ n

n

x=1 y=1 p (x,y) → n i=y+1 ¬p

(x,i)

2. Auf jeder Diagonale nur eine Dame

F3 ≡ n

n

x=1 y=1 p (x,y) →

min(n−x,n−y)

i=1 ¬p (x+i,y+i) ∧

n

n

x=1 y=1 p (x,y) →

min(x−1,n−y)

i=1 ¬p (x−i,y+i)

3. In jeder Zeile (mindestens) eine Dame

F4 ≡ n

y=1

n

x=1 p (x,y)

A. Knapp, G. Schellhorn: Formale Methoden 23


Sequenzenkalkül

◮ Ableitung aller allgemeingültigen Aussagen

◮ Erfunden von Gerhard Gentzen (1934)

◮ Hier: Fassung nach Oiva Ketonen (1944)

◮ arbeitet auf Sequenzen

◮ Charakteristik: versucht, Beweisziel auf Axiome zu reduzieren (schrittweise

Vereinfachung des Problems); am menschlichen Beweisen orientiert

◮ Nur einer von vielen möglichen Kalkülen: Hilbertkalkül, natürliches

Schließen, Tableaukalkül, Modellelimination, Resolutionskalkül

A. Knapp, G. Schellhorn: Formale Methoden 24


Sequenzen

Definition Seien A1, . . . , Am, B1, . . . , Bn ∈ F (P).

A1, . . . , Am ⇒ B1, . . . , Bn heißt Sequenz.

A1, . . . , Am

heißt Antezedent (m ≥ 0).

B1, . . . , Bn heißt Sukzedent (n ≥ 0).

◮ Γ, Γ1, ∆, . . . bezeichnen Listen von Formeln

◮ Γ = A1, . . . , Am = [A1, . . . , Am]

◮ ∆ = B1, . . . , Bn = [B1, . . . , Bn]

Γ ⇒ ∆ = A1, . . . , Am ⇒ B1, . . . , Bn

Γ, A ⇒ B = A1, . . . , Am, A ⇒ B

Γ, A ∧ B, ∆ ⇒ = A1, . . . , Am, A ∧ B, B1, . . . , Bn ⇒

[A1, . . . , Am] = A1 ∧ . . . ∧ Am

[] = true

[B1, . . . , Bn] = B1 ∨ . . . ∨ Bn

[] = false

A. Knapp, G. Schellhorn: Formale Methoden 25


Sequenzen: Semantik

Auffassung einer Sequenz Γ ⇒ ∆ als Γ → ∆

Definition Eine Interpretation I ist ein Modell einer Sequenz Γ ⇒ ∆,

geschrieben als I |= Γ ⇒ ∆, wenn I |= Γ → ∆.

Eine Sequenz Γ ⇒ ∆ ist eine Folgerung aus einer Menge von

aussagenlogischen Formeln Ax, geschrieben als Ax |= Γ ⇒ ∆, wenn für jede

Interpretation I mit I |= Ax auch I |= Γ ⇒ ∆ gilt.

◮ Insbesondere: Γ ⇒ ist wahr, falls die Formeln in Γ widersprüchlich sind.

A. Knapp, G. Schellhorn: Formale Methoden 26


Formeln und Sequenzen

Lemma Sei I eine Interpretation, A eine aussagenlogische Formel und Ax

eine Menge von aussagenlogischen Formeln.

I |= A ⇐⇒ I |= ⇒ A

I |= ¬A ⇐⇒ I |= A ⇒

Ax |= A ⇐⇒ Ax |= ⇒ A

Ax |= ¬A ⇐⇒ Ax |= A ⇒

Definition Folgende Formeln und Sequenzen werden miteinander

identifiziert:

Γ ⇒ ∆ ≡ Γ → ∆, falls Γ nicht leer

⇒ ∆ ≡ ∆, falls ∆ nicht leer

⇒ A ≡ A

⇒ ≡ false

A. Knapp, G. Schellhorn: Formale Methoden 27


Eigenschaften von Sequenzen

Lemma Seien I eine Interpretation, A, B aussagenlogische Formeln und

Γ, Γ1, Γ2, ∆, ∆1, ∆2 Listen von aussagenlogischen Formeln.

I |= Γ1, Γ2 ⇒ ∆ ⇐⇒ I |= Γ2, Γ1 ⇒ ∆

I |= Γ ⇒ ∆1, ∆2 ⇐⇒ I |= Γ ⇒ ∆2, ∆1

I |= Γ ⇒ A, ∆ ⇐⇒ I |= Γ, ¬A ⇒ ∆

I |= Γ, A ⇒ ∆ ⇐⇒ I |= Γ ⇒ ¬A, ∆

I |= Γ ⇒ A ∨ B, ∆ ⇐⇒ I |= Γ ⇒ A, B, ∆

I |= Γ ⇒ A → B, ∆ ⇐⇒ I |= A, Γ ⇒ B, ∆

I |= Γ ⇒ A ∧ B, ∆ ⇐⇒ I |= Γ ⇒ A, ∆ und I |= Γ ⇒ B, ∆

A. Knapp, G. Schellhorn: Formale Methoden 28


Form von Kalkülregeln

Regel

Γ1 ⇒ ∆1 . . . Γn ⇒ ∆n

Γ ⇒ ∆

◮ Γ ⇒ ∆ heißt Konklusion der Regel

◮ Γ1 ⇒ ∆1, . . . , Γn ⇒ ∆n heißen Prämissen der Regel

◮ Regeln ohne Prämissen (n = 0) heißen Axiome

◮ Regel gelesen als: Aus den Prämissen läßt sich die Konklusion ableiten

◮ Verwendung der Regel: Reduktion der Konklusion auf die Prämissen

A. Knapp, G. Schellhorn: Formale Methoden 29


Regeln des Sequenzenkalküls für Aussagenlogik (AL) (1)

Schreibweise: Interessierende Formel am Anfang

A, Γ ⇒ B, ∆

Γ ⇒ A → B, ∆ statt

(A) A, Γ ⇒ A, ∆

(Lfalse) false, Γ ⇒ ∆

Γ1, A, Γ2 ⇒ ∆1, B, ∆2

Γ1, Γ2 ⇒ ∆1, A → B, ∆2

(Rtrue) Γ ⇒ true, ∆

A. Knapp, G. Schellhorn: Formale Methoden 30


Regeln des Sequenzenkalküls für Aussagenlogik (AL) (2)

Γ ⇒ A, ∆

(L¬)

¬A, Γ ⇒ ∆

A, B, Γ ⇒ ∆

(L∧)

A ∧ B, Γ ⇒ ∆

A, Γ ⇒ ∆ B, Γ ⇒ ∆

(L∨)

A ∨ B, Γ ⇒ ∆

A, Γ ⇒ ∆

(R¬)

Γ ⇒ ¬A, ∆

Γ ⇒ A, ∆ Γ ⇒ B, ∆

(R∧)

Γ ⇒ A ∧ B, ∆

Γ ⇒ A, B, ∆

(R∨)

Γ ⇒ A ∨ B, ∆

A. Knapp, G. Schellhorn: Formale Methoden 31


Regeln des Sequenzenkalküls für Aussagenlogik (AL) (3)

Γ ⇒ A, ∆ B, Γ ⇒ ∆

(L→)

A → B, Γ ⇒ ∆

A, B, Γ ⇒ ∆ Γ ⇒ A, B, ∆

(L↔)

A ↔ B, Γ ⇒ ∆

Γ ⇒ A, ∆ A, Γ ⇒ ∆

(Cut)

Γ ⇒ ∆

A, Γ ⇒ B, ∆

(R→)

Γ ⇒ A → B, ∆

A, Γ ⇒ B, ∆ B, Γ ⇒ A, ∆

(R↔)

Γ ⇒ A ↔ B, ∆

Γ1 ⇒ ∆1

(Weak)

Γ1, Γ2 ⇒ ∆1, ∆2

A. Knapp, G. Schellhorn: Formale Methoden 32


Sequenzenkalkül für AL: Beispiele







¬(a ∨ b) ⇒ ¬a ∧ ¬b ¬a ∧ ¬b ⇒ ¬(a ∨ b)

⇒ ¬(a ∨ b) ↔ ¬a ∧ ¬b

⇒ a ∨ b, ¬a ∧ ¬b

¬(a ∨ b) ⇒ ¬a ∧ ¬b (L¬)

⇒ a, b, ¬a ∧ ¬b

⇒ a ∨ b, ¬a ∧ ¬b (R∨)

⇒ a, b, ¬a ⇒ a, b, ¬b

⇒ a, b, ¬a ∧ ¬b

a ⇒ a, b

⇒ a, b, ¬a (R¬)

a ⇒ a, b (A)

(R∧)

(R↔)

A. Knapp, G. Schellhorn: Formale Methoden 33


Ableitbarkeit

Definition Eine Sequenz Γ ⇒ ∆ heißt mit AL ableitbar aus einer Menge

von aussagenlogischen Formeln Ax, geschrieben als Ax ⊢AL Γ ⇒ ∆, wenn es

eine Ableitung in AL für Γ ⇒ ∆ aus Ax gibt, d. h. einen geschlossenen

Beweisbaum, der als Wurzel die Sequenz Γ ⇒ ∆ (die Konklusion) hat, als

Blätter Sequenzen ⇒ A mit A ∈ Ax (die Prämissen) und dessen innere Knoten

durch Regeln von AL gebildet sind.

Beweisprinzip für Beweisbäume (Ableitungen)

◮ Zeige, daß alle Blätter die Eigenschaft haben und alle Regeln die

Eigenschaft erhalten.

A. Knapp, G. Schellhorn: Formale Methoden 34


Ableitbarkeit in AL: Beispiel

Ableitung für die Sequenz ⇒ ¬(a ∨ b) ↔ ¬a ∧ ¬b (DeMorgan ∨)

a ⇒ a, b (A)

⇒ a, b, ¬a (R¬)

b ⇒ a, b (A)

⇒ a, b, ¬b (R¬)

(R∧)

⇒ a, b, ¬a ∧ ¬b

⇒ a ∨ b, ¬a ∧ ¬b (R∨)

¬(a ∨ b) ⇒ ¬a ∧ ¬b (L¬)

a ⇒ a, b (A) b ⇒ a, b (A)

(L∨)

a ∨ b ⇒ a, b

a ∨ b, ¬b ⇒ a (L¬)

a ∨ b, ¬a, ¬b ⇒ (L¬)

¬a, ¬b ⇒ ¬(a ∨ b) (R¬)

¬a ∧ ¬b ⇒ ¬(a ∨ b) (L∧)

(R↔)

⇒ ¬(a ∨ b) ↔ ¬a ∧ ¬b

A. Knapp, G. Schellhorn: Formale Methoden 35


Theorembeweiser KIV für AL

◮ In Datei specification

specification

constants a : bool;

b : bool;

c : bool;

end specification

◮ In Datei sequents

lemmas

tertium-non-datur: ⊢ a ∨ ¬ a ;

DeMorgan-∨: ⊢ ¬ (a ∨ b) ↔ ¬ a ∧ ¬ b ;

DeMorgan-∧: ⊢ ¬ (a ∧ b) ↔ ¬ a ∨ ¬ b ;

Hilbert-1: ⊢ a → (b → a) ;

Hilbert-2: ⊢ (a → b) → (¬ b → ¬ a) ;

Hilbert-3: ⊢ ((a → b) → (a → c)) → (a → (b → c)) ;

A. Knapp, G. Schellhorn: Formale Methoden 36


Verwendung von Schnitt und Abschwächung

Schnitt (Cut) und Abschwächung (Weak) für Ableitungen von Tautologien in

AL nicht nötig

Für Ableitungen aus Axiomen entsprechen Schnitt und Abschwächung der

Verwendung eines Lemmas

◮ Zu zeigen: Ax ⊢AL Γ ⇒ ∆

◮ Einführung von A ∈ Ax zu Ax ⊢AL A, Γ ⇒ ∆:

⇒ A

A, Γ ⇒ ∆ Γ ⇒ A, ∆ (Weak)

(Cut)

Γ ⇒ ∆

A. Knapp, G. Schellhorn: Formale Methoden 37


Regelkorrektheit und Regelinvertierbarkeit von AL

Lemma Für jede Regel (Γ1 ⇒ ∆1 . . . Γn ⇒ ∆n)/(Γ ⇒ ∆) von AL und

jede Interpretation I folgt aus I |= {Γ1 ⇒ ∆1, . . . , Γn ⇒ ∆n}, daß I |= Γ ⇒ ∆.

Lemma Für jede Regel (Γ1 ⇒ ∆1 . . . Γn ⇒ ∆n)/(Γ ⇒ ∆) von AL außer

der Abschwächungsregel (Weak) und jede Interpretation I folgt aus

I |= Γ ⇒ ∆, daß I |= {Γ1 ⇒ ∆1, . . . , Γn ⇒ ∆n}.

A. Knapp, G. Schellhorn: Formale Methoden 38


Korrektheit

Satz Wenn I |= {Γ1 ⇒ ∆1, . . . , Γn ⇒ ∆n} und

{Γ1 ⇒ ∆1, . . . , Γn ⇒ ∆n} ⊢AL Γ ⇒ ∆, dann I |= Γ ⇒ ∆.

Beweisskizze Regelkorrektheit und Induktion über Anzahl der angewandten Regeln

Insbesondere: Korrektheit von AL

◮ Wenn Ax ⊢AL Γ ⇒ ∆, dann Ax |= Γ ⇒ ∆.

A. Knapp, G. Schellhorn: Formale Methoden 39


Invertierbarkeit

Lemma Hat ein Beweisbaum ohne (Weak) die Konklusion Γ ⇒ ∆ und eine

Prämisse Γ ′ ⇒ ∆ ′ mit I |= Γ ′ ⇒ ∆ ′ für eine Interpretation I, so ist auch

I |= Γ ⇒ ∆.

Beweisskizze Regelinvertierbarkeit und Induktion über Anzahl angewandter Regeln

Korrektheit verlangt, daß, wenn die Prämissen eines Beweisbaums wahr sind,

dann auch die Konklusion wahr ist.

◮ Invertierbare Regeln gehen nie fehl: Ist die Konklusion beweisbar, so auch

die Prämissen.

◮ Allerdings kann eine unpassende Regel den Beweisbaum doppelt so groß

machen.

A. Knapp, G. Schellhorn: Formale Methoden 40


Terminierung

Satz Sei Γ ⇒ ∆ eine Sequenz. Dann terminiert jedes Bilden eines

Beweisbaums ohne (Cut) und (Weak).

Beweisskizze Die maximale Höhe jedes Beweisbaums ist gleich der Anzahl der

Junktoren in der Ausgangssequenz, da jede Regelanwendung (ohne (Cut) und

(Weak)) wenigstens einen Junktor beseitigt.

A. Knapp, G. Schellhorn: Formale Methoden 41


Entscheidbarkeit

Satz Die Allgemeingültigkeit einer aussagenlogischen Formel ist

entscheidbar durch Anwenden der Regeln des Sequenzenkalküls AL ohne

(Cut) und (Weak): Es entsteht genau dann ein geschlossener Beweisbaum,

wenn die Formel allgemeingültig ist.

Beweisskizze Wegen Korrektheit Konklusion eines geschlossenen Beweisbaums

allgemeingültig.

Existenz eines geschlossenen Beweisbaums für allgemeingültige Formel als

Konklusion: Bildungsprozeß terminiert; angenommen ergibt keinen geschlossenen

Beweisbaum, d. h., es existiert eine Prämisse, auf die keine Regel anwendbar ist. Dann

enthält die Prämisse nur atomare Aussagen und evtl. true links und false rechts, und

Antezedent und Sukzedent haben keine gemeinsamen atomaren Aussagen. Wähle

Interpretation I so, daß Atome im Antezedent wahr, im Sukzedent falsch; dann macht I

die Prämisse falsch. Nach Invertierbarkeit ist die Konklusion für I falsch, im

Widerspruch zur Allgemeingültigkeit der Konklusion.

A. Knapp, G. Schellhorn: Formale Methoden 42


Erfüllbarkeit

Verwendung des Sequenzenkalküls zur Konstruktion erfüllender Belegungen

Satz Gegeben eine aussagenlogische Formel A erhält man alle erfüllenden

Belegungen wie folgt:

1. Bilde die Sequenz A ⇒ und wende Sequenzenkalkül an.

2. Zu jeder offenen Prämisse bilde die Belegungen I, die die Atome im

Antezedent wahr, die im Sukzedent falsch machen (alles andere beliebig).

A. Knapp, G. Schellhorn: Formale Methoden 43


Erfüllbarkeit: Beispiel

Erfüllende Belegungen für ¬a ↔ (b ∨ c)

◮ Sequenzenkalkül

b ⇒ a c ⇒ a

b ∨ c ⇒ a

¬a, b ∨ c ⇒

a ⇒ b, c

⇒ ¬a, b, c

⇒ ¬a, b ∨ c

¬a ↔ (b ∨ c) ⇒

◮ Erfüllende Belegungen

a b c

ff tt ff b ⇒ a

ff tt tt b ⇒ a

ff ff tt c ⇒ a

ff tt tt c ⇒ a

tt ff ff a ⇒ b, c

A. Knapp, G. Schellhorn: Formale Methoden 44


Schwache Vollständigkeit

Satz Wenn |= Γ ⇒ ∆, dann ⊢AL Γ ⇒ ∆.

Beweisskizze Bilde Beweisbaum (ohne (Cut) und (Weak)), bis keine Regel mehr

anwendbar ist (Termination); falls er keine offene Prämisse hat, ist die Formel

allgemeingültig wegen Korrektheit. Sonst bilde eine Belegung I, die eine offene

Prämisse falsch macht; nach Regelinvertierbarkeit ist auch die Konklusion falsch für I,

also nicht allgemeingültig.

A. Knapp, G. Schellhorn: Formale Methoden 45


Deduktionstheorem

Satz Ax ∪ {B} ⊢AL ⇒ C gdw. Ax ⊢AL B ⇒ C

gdw. Ax ⊢AL ⇒ B → C.

Beweisskizze

” ⇒“ in der oberen Äquivalenz: Füge in geschlossenem Beweisbaum

für Ax ∪ {B} ⊢AL ⇒ C allen Sequenzen links die Formel B hinzu; ergibt Beweisbaum.

Die Prämisse B wird zum Axiom und verschwindet; Prämissen der Form B ⇒ Ax

werden mit Abschwächung wieder zu Ax. Die Konklusion ist das gewünschte Resultat.

” ⇐“ in der oberen Äquivalenz: Hänge an geschlossenen Beweisbaum für

Ax ⊢AL B ⇒ C einen Beweisbaum für Lemmaanwendung von B mit Γ leer und ∆ = C

an.

Untere Äquivalenz: Verwendung der ersten Äquivalenz.

A. Knapp, G. Schellhorn: Formale Methoden 46


Starke Vollständigkeit

Satz Ist Ax endlich, dann gilt mit Ax |= Γ ⇒ ∆, daß Ax ⊢AL Γ ⇒ ∆.

Beweisskizze Ax |= Γ ⇒ ∆ gdw. |= Ax, Γ ⇒ ∆ nach Folgerbarkeit; |= Ax, Γ ⇒ ∆

impliziert ⊢AL Ax, Γ ⇒ ∆ nach schwacher Vollständigkeit; ⊢AL Ax, Γ ⇒ ∆ gdw.

Ax ⊢AL Γ ⇒ ∆ nach Deduktionstheorem.

Starke Vollständigkeit gilt auch für unendliche Mengen Ax.

A. Knapp, G. Schellhorn: Formale Methoden 47


Konsistenz

Definition Eine Menge Ax von Axiomen heißt konsistent, wenn sich aus Ax

die leere Sequenz nicht ableiten läßt.

◮ Kalkül korrekt gdw. jede erfüllbare Menge konsistent

◮ Kalkül vollständig gdw. jede konsistente Menge erfüllbar

Daraus Vollständigkeitssatz: Für jede konsistente Menge Konstruktion eines

Modells.

A. Knapp, G. Schellhorn: Formale Methoden 48


Substitution (1)

Definition Für aussagenlogische Formeln A, B, C heißt A{B ↦→ C} die

Substitution (oder Ersetzung) von B durch C in A, gegeben durch:


◮ p{B ↦→ C} =

C, falls p = B

p, falls p = B


◮ (¬A){B ↦→ C} =

C,

¬(A{B ↦→ C}),


C,

falls (¬A) = B

falls (¬A) = B

falls (A ∧ A ′ ) = B

◮ (A ∧ A ′ ){B ↦→ C} =

◮ analog für die anderen Junktoren

(A{B ↦→ C}) ∧ (A ′ {B ↦→ C}), falls (A ∧ A ′ ) = B

A. Knapp, G. Schellhorn: Formale Methoden 49


Substitution (2)

Lemma Ist I |= B ↔ C, dann gilt für jedes A: I |= A gdw. I |= A{B ↦→ C}.

◮ Formeln können durch äquivalente Formeln ersetzt werden.

◮ Insbesondere darf man B durch C ersetzen, wenn B ↔ C eine Tautologie

ist.

A. Knapp, G. Schellhorn: Formale Methoden 50


Vereinfachung von Sequenzen (1)

◮ Reine Anwendung von Sequenzenkalkülregeln ergibt oft lange Beweise;

Substitution für Abkürzungen

A → B{A ↦→ true}, Γ ⇒ ∆

A → B, Γ ⇒ ∆

A ∨ B{A ↦→ false}, Γ ⇒ ∆

A ∨ B, Γ ⇒ ∆

A, Γ{A ↦→ true} ⇒ ∆{A ↦→ true}

A, Γ ⇒ ∆

A{B ↦→ false} → B, Γ ⇒ ∆

A → B, Γ ⇒ ∆

Γ ⇒ A ∧ B{A ↦→ true}, ∆

Γ ⇒ A ∧ B, ∆

Γ{A ↦→ false} ⇒ A, ∆{A ↦→ false}

Γ ⇒ A, ∆

Beispiel: Für ⇒ A ∧ A zeige ⇒ A ∧ A{A ↦→ true}, d. h. ⇒ A ∧ true, also ⇒ A

mit (And-true).

A. Knapp, G. Schellhorn: Formale Methoden 51


Vereinfachung von Sequenzen (2)

Zulässigkeit der Regel

A, Γ{A ↦→ true} ⇒ ∆{A ↦→ true}

A, Γ ⇒ ∆

Def. Sem. Seq.

⇐⇒

I |= A, Γ ⇒ ∆

I |= A ∧ Γ → Taut. 23

⇐⇒


I |= A → ( Γ → Def. Sem. Impl.

⇐⇒

∆)

I |= A ⇒ I |= Γ → Taut. 32

⇐⇒


I |= A ↔ true ⇒ I |= Γ → Subst.lem.

⇐⇒


I |= A ↔ true ⇒ I |= ( Γ → Def. Subst.fkt.

⇐⇒

∆){A ↦→ true}

I |= A ↔ true ⇒ I |= Γ{A ↦→ true} → Taut. 32

⇐⇒

∆{A ↦→ true}

I |= A ⇒ I |= Γ{A ↦→ true} → Def. Sem. Impl.

⇐⇒

∆{A ↦→ true}

I |= A → ( Γ{A ↦→ true} → Taut. 23

⇐⇒

∆{A ↦→ true})

I |= A ∧ Γ{A ↦→ true} → ∆{A ↦→ true}

Def. Sem. Seq.

⇐⇒ I |= A, Γ{A ↦→ true} ⇒ ∆{A ↦→ true}

A. Knapp, G. Schellhorn: Formale Methoden 52


Resolutionskalkül

◮ Nachweis der Unerfüllbarkeit von Aussagen

◮ erfunden von J. Alan Robinson (1965)

◮ operiert auf Klauselmengen

◮ aus konjunktiver Normalform

◮ Charakteristik: spezialisierte Schnittregel; geeignet für maschinelles

Beweisen

A. Knapp, G. Schellhorn: Formale Methoden 53


Literale und konjunktive Normalform

Definition Ein Literal ist eine Proposition oder eine negierte Proposition.

Definition Eine Formel ist in konjunktiver Normalform (CNF), wenn sie

◮ eine Konjunktion von Disjunktionen von Literalen ist;

◮ in jeder Disjunktion jede Proposition nur einmal vorkommt.

A. Knapp, G. Schellhorn: Formale Methoden 54


Existenz der konjunktiven Normalform (1)

Satz Zu jeder Formel A gibt es eine äquivalente Formel B, die entweder

true oder false oder in konjunktiver Normalform ist.

Beweisskizze Wiederholtes Umschreiben der Formel mittels Substitutionslemma.

◮ Implikationen und Äquivalenzen beseitigen mit Tautologien 19 und 21.

◮ true, false beseitigen mit And-false, And-true, Or-false, &c. Falls das Ergebnis true

oder false ist, fertig.

◮ Negation nach innen schieben mit DeMorgan (Tautologien 9 und 10),

Doppelnegationen beseitigen (Tautologie 13).

◮ ∨ über ∧ distribuieren mit Tautologie 7.

◮ doppelte Literale in Disjunktionen beseitigen mit Tautologie 3.

◮ Disjunktionen, die A und ¬A enthalten löschen.

A. Knapp, G. Schellhorn: Formale Methoden 55


Existenz der konjunktiven Normalform (2)

Alternative Konstruktion der konjunktiven Normalform

◮ Bilde Sequenz ⇒ A und wende Sequenzenkalkül an. Die entstehenden

Prämissen seien P1, . . . , Pk.

◮ Für eine Prämisse P = A1, . . . , Am ⇒ B1, . . . , Bn sei

disj(P) = ¬A1 ∨ . . . ∨ ¬Am ∨ B1 ∨ . . . ∨ Bn.

◮ Dann gilt |= A ↔

1≤i≤k disj(Pi) wegen Korrektheit und Invertierbarkeit.


1≤i≤k disj(Pi) ist also die konjunktive Normalform.

◮ Spezialfälle: Wenn keine Prämisse: true; wenn leere Prämisse: false.

A. Knapp, G. Schellhorn: Formale Methoden 56


Konjunktive Normalform: Beispiel

Konstruktion einer konjunktiven Normalform von ¬a ↔ (b ∨ c)

◮ Methode (1)

¬a ↔ (b ∨ c)

(¬a → b ∨ c) ∧ (b ∨ c → ¬a) Taut. 21

gdw. (¬¬a ∨ b ∨ c) ∧ (¬(b ∨ c) ∨ ¬a) Taut. 19

gdw. (a ∨ b ∨ c) ∧ (¬b ∧ ¬c ∨ ¬a) Taut. 9, 13

gdw. (a ∨ b ∨ c) ∧ (¬b ∨ ¬a) ∧ (¬c ∨ ¬a) Taut. 5 (CNF)

◮ Methode (2)

⇒ a, b, c a, b ⇒

¬a ⇒ b, c b ⇒ ¬a

¬a ⇒ b ∨ c

⇒ ¬a ↔ (b ∨ c)

a, c ⇒

c ⇒ ¬a

b ∨ c ⇒ ¬a

A. Knapp, G. Schellhorn: Formale Methoden 57


Tseitin-Codierung

Erzeugung einer erfüllbarkeitsäquivalenten CNF-Formel A ′ zu einer Formel A

◮ Einführung von Hilfspropositionen für Junktoren

◮ A ′ linear in der Größe von A

Beispiel: a → (b ∧ c)

◮ Einführung von x2 für b ∧ c und

Einführung von x1 für a → x2

x1 ↔ (a → x2)

x2 ↔ (b ∧ c)

◮ daraus konjunktive Normalform

(x1 ∨ a) ∧ (x1 ∨ ¬x2) ∧ (¬x1 ∨ ¬a ∨ x2)

∧ (¬x2 ∨ b) ∧ (¬x2 ∨ c) ∧ (x2 ∨ ¬b ∨ ¬c)

∧ (x1)

A. Knapp, G. Schellhorn: Formale Methoden 58


Klauseln

Definition Eine Klausel ist eine Menge von Literalen. Eine Klauselmenge ist

eine Menge von Klauseln.

◮ Eine Klausel wird als Disjunktion interpretiert; die leere Klausel wird als

false angesehen.

◮ Eine Klauselmenge wird als Konjunktion interpretiert; die leere

Klauselmenge entspricht true.

Damit: Formeln in konjunktiver Normalform und true, false entsprechen

Klauselmengen.

Beispiel

◮ (a ∨ b ∨ c) ∧ (¬b ∨ ¬a) ∧ (¬c ∨ ¬a) ≡ {{a, b, c}, {¬b, ¬a}, {¬c, ¬a}}

A. Knapp, G. Schellhorn: Formale Methoden 59


Resolutionskalkül

Lemma Sind die Klauseln C1 und C2 mit p ∈ C1 und ¬p ∈ C2 gemeinsam

erfüllbar, dann ist die Klausel (C1 ∪ C2) \ {p, ¬p} erfüllbar.

Resolutionsregel

p, C1 ¬p, C2

C1, C2

Satz Eine Klauselmenge C ist genau dann unerfüllbar, wenn sich aus C

durch Anwendung der Resolutionsregel die leere Klausel ableiten läßt.

Beispiel: (¬a ∨ b) ∧ (a) ∧ (¬b)

¬a, b a

¬b b


A. Knapp, G. Schellhorn: Formale Methoden 60


Unit-Resolution

Lemma Die Klauseln {ℓ} und C mit ¬ℓ ∈ C sind genau dann gemeinsam

erfüllbar, wenn C \ {¬ℓ} erfüllbar ist.

Unit-Resolutionsregel

ℓ ¬ℓ, C

C

Boolean constraint propagation (BCP)

◮ Ersetzung der Klauseln {ℓ} und C mit ¬ℓ ∈ C in einer Klauselmenge C

durch C \ {¬ℓ} zu neuer Klauselmenge C ′

Beispiel: Anwendung von BCP auf (a) ∧ (¬a ∨ b) ∧ (c ∨ ¬b ∨ d)

(a) ∧ (¬a ∨ b) ∧ (c ∨ ¬b ∨ d)

❀ (b) ∧ (c ∨ ¬b ∨ d)

❀ c ∨ d

A. Knapp, G. Schellhorn: Formale Methoden 61


Davis-Putnam-Logemann-Loveland-Algorithmus

Prüfung einer aussagenlogischen Formel in CNF auf Erfüllbarkeit

◮ Grundlage vieler SAT-Beweiser zur Auffindung einer erfüllenden Belegung

DPLL(A) ≡

A ′ ← BCP(A)

if A ′ = true

then return true

else if A ′ = false

then return false

else p ← choose vars(A ′ )

return DPLL(A ′ {p ↦→ true}) ∨ DPLL(A ′ {p ↦→ false}) fi fi

A. Knapp, G. Schellhorn: Formale Methoden 62


SAT-Beweiser

Eingabeformat (DIMACS):

◮ Propositionen sind positive Zahlen, negiertes Atom n ist -n.

◮ Klausel als Folge von Literalen geschrieben, durch Leerzeichen getrennt, 0

beendet Klausel; Klauseln hintereinander geschrieben

◮ Zu Beginn der Datei eine Zeile mit: p cnf m n

Ausgabeformat

◮ m ist die Nummer der maximalen Nummer einer Proposition

◮ n ist die Zahl der noch folgenden Zeilen in der Datei

◮ Liste der Propositionen, die mit tt zu belegen sind

Beispiel: a ∧ (¬b ∨ a) ∧ (c ∨ ¬d)

p cnf 4 3

1 0

-2 1 0

3 -4 0

Ausgabe etwa 1 3

A. Knapp, G. Schellhorn: Formale Methoden 63


Zusammenfassung

◮ Aussagenlogik

◮ Syntax und Semantik

◮ Modelle, Folgerbarkeit, Erfüllbarkeit

◮ Sequenzenkalkül AL

◮ Korrektheit und Vollständigkeit

◮ Theorembeweiser KIV

◮ Resolutionskalkül

◮ Konjunktive Normalform, Klauseln

◮ SAT-Beweiser

A. Knapp, G. Schellhorn: Formale Methoden 64


Prädikatenlogik

Denn wenn A von jedem B und B von jedem C, muß A von jedem C

ausgesagt werden.

— Aristoteles, Analytica Priora A 4, 25b37ff.

Daraus der Vers: . . .

Barbara, celarent, darii, ferion, baralipton,

Celantes, dabitis, fapesmo, frisesomorum;

Cesare, camestres, festino, baroco; darapti,

Felapto, disamis, datisi, bocardo, ferison.

— Petrus Hispanus, Summulae Logicales 4.17

⊢ : . (z) . ϕz ⊃ ψz : ϕx : ⊃ . ψx . . .

Dies ist eine Form des Syllogismus in Barbara. Man setze z. B. ϕz . = . z ist

ein Mensch, ψz . = . z ist sterblich, x = Sokrates. Dann wird die Aussage

zu: ” Wenn alle Menschen sterblich sind und Sokrates ein Mensch ist, dann

ist Sokrates sterblich.“

— Alfred N. Whitehead, Bertrand Russell, Principia Mathematica, *10.26

A. Knapp, G. Schellhorn: Formale Methoden 65


Signaturen

Definition Eine Signatur Σ = (S, F, P) besteht aus:

◮ einer endlichen Menge S von Sorten

◮ einer endlichen Menge F von Funktionssymbolen f : s → s mit

◮ Argumentsortens = s1 . . . sn ∈ S ∗ (Liste von Sorten)

◮ Resultatsorte s ∈ S

◮ endlicher Menge P von Prädikatsymbolen p : s

◮ Ein Funktionssymbol mit leerer Argumentliste heißt Konstante.

◮ Ein Prädikatsymbol mit leerer Argumentliste heißt Proposition.

A. Knapp, G. Schellhorn: Formale Methoden 66


Signaturen: Beispiele

” Zugriffsmöglichkeiten“ auf einen Datentypen

◮ Gruppen

ΣGrp = ({Elt}, {1 : → Elt, · : Elt Elt → Elt, −1 : Elt → Elt}, ∅)

◮ Natürliche Zahlen

ΣNat1 = ({Nat}, {0 : → Nat, s : Nat → Nat}, ∅)

ΣNat2 = ({Nat}, {0 : → Nat, 1 : → Nat, + : Nat Nat → Nat},

{< : Nat Nat})

◮ Wahrheitswerte

ΣBool = ({Bool}, ∅, {true : , false : })

◮ Listen

ΣList = ({Elt, List}, {empty : → List, cons : Elt List → List},

{isEmpty : List})

A. Knapp, G. Schellhorn: Formale Methoden 67


Signaturen in KIV

specification

sorts s1; s2; nat; set;

constants c1, c2 : s1;

∅ : set;

functions f : s1 × s2 → s2;

+ : nat × nat → nat;

* : nat × nat → nat;

predicates p : s1 × s2;

⊆ : set × set;

end specification

A. Knapp, G. Schellhorn: Formale Methoden 68


Terme

Definition Eine Variablenmenge X für eine Signatur Σ = (S, F, P) ist die

Vereinigung von abzählbar unendlichen Mengen Xs für jede Sorte s ∈ S.

Definition Seien Σ = (S, F, P) eine Signatur und X eine Variablenmenge

für Σ. Dann sind die Mengen T (Σ, X)s der Terme der Sorte s über Σ und X

gegeben durch

◮ x ∈ Xs ist ein Term der Sorte s.

◮ Sind t1, . . . , tn Terme der Sorten s1, . . . , sn und f : s1 . . . sn → s ∈ F, dann

ist f (t1, . . . , tn) ein Term der Sorte s.

T (Σ, X) sind alle Terme (aller Sorten) über Σ und X.

Beispiele:

◮ In ΣGrp: −1 (1), ·(x, 1) für x ∈ XElt

◮ In ΣNat1: 0, s(s(s(0)))

A. Knapp, G. Schellhorn: Formale Methoden 69


Algebren

Definition Eine Algebra A = ((As)s∈S, (f A )f ∈F, (p A )p∈P) über einer

Signatur Σ = (S, F, P) (kurz: eine Σ-Algebra) besteht aus:

◮ nichtleeren Mengen As für jede Sorte s ∈ S (Trägermengen)

◮ Funktionen f A : As1 × · · · × Asn → As für alle f : s1 . . . sn → s ∈ F

◮ Mengen p A ⊆ As1 × · · · × Asn für alle p : s1 . . . sn ∈ P

Die Klasse aller Σ-Algebren über Σ wird mit Alg(Σ) bezeichnet.

A. Knapp, G. Schellhorn: Formale Methoden 70


Algebren: Beispiele

Mögliche ” Interpretationen“ von Datentyp-Signaturen

◮ Für ΣGrp: AGrp+ additiv

AElt = Z

1 AGrp+ = 0, · AGrp+(x, y) = x + y, −1AGrp+ (x) = −x

◮ Für ΣNat1: ANat∗

ANat = {∗}

0 ANat∗ = ∗, s ANat∗(x) = x

◮ Für ΣList: A List(Nat) Listen über natürlichen Zahlen

AElt = N, AList = N ∗

empty A List(Nat) = ε, cons A List(Nat)(x, l) = x :: l

isEmpty A List(Nat) = {ε}

A. Knapp, G. Schellhorn: Formale Methoden 71


Belegungen

Definition Eine Belegung (valuation) v :

s∈S (Xs → As) ist eine Abbildung,

die jedem Variablensymbol x ∈ Xs einen Wert v(x) ∈ As zuordnet.

Definition Die Abänderung v{x ↦→ a} der Belegung v für x ∈ Xs und a ∈ As

ist gegeben durch


(v{x ↦→ a})(y) =

v(y)

a

falls x = y

falls x = y .

A. Knapp, G. Schellhorn: Formale Methoden 72


Semantik von Termen

Definition Sei A eine Σ-Algebra und v eine Belegung. Dann ist die

Semantik (Auswertung) T t A v eines Terms t ∈ T (Σ, X)s der Sorte s der

Wert in As mit

◮ T x A v = v(x), falls x ∈ X;

◮ T f (t1, . . . , tn) A v = f A (T t1 A v, . . . , T tn A v) für

f : s1 . . . sn → s ∈ F und ti ∈ T (Σ, X)si .

A. Knapp, G. Schellhorn: Formale Methoden 73


Variablen eines Terms

Für Terme gilt ein analoges Definitions- und Beweisprinzip wie für

aussagenlogische Formeln.

Definition Die Variablen var(t) eines Terms sind

◮ var(x) = {x} für x ∈ X;

◮ var(f (t1, . . . , tn)) = var(t1) ∪ . . . ∪ var(tn).

Die Semantik eines Terms hängt nur von der Belegung der Variablen in var(t)

ab (Koinzidenzlemma).

Satz Sind v und w Belegungen und gilt v(x) = w(x) für alle Variablen

x ∈ var(t), so ist T t A v = T t A w.

◮ Für Auswertung von Termen t mit var(t) = ∅ Belegung irrelevant.

◮ Schreibweise: T t A statt T t A v, falls var(t) = ∅

A. Knapp, G. Schellhorn: Formale Methoden 74


Substitution in Termen

Definition Die Substitution einer Variablen x durch einen Term t in einem

Term u, geschrieben als u{x ↦→ t}, ist gegeben durch


◮ y{x ↦→ t} =

t

y

falls y = x

falls y = x

für y ∈ X;

◮ f (t1, . . . , tn){x ↦→ t} = f (t1{x ↦→ t}, . . . , tn{x ↦→ t}).

Die Semantik des Terms u{x ↦→ t} ist dieselbe wie die des Terms u unter einer

Belegung, in der x den Wert von t hat (Substitutionslemma).

Lemma T u{x ↦→ t} A v = T u A v{x ↦→ T t A v}.

A. Knapp, G. Schellhorn: Formale Methoden 75


Formeln

Definition Für eine Signatur Σ = (S, F, P) und eine Variablenmenge X für

Σ ist die Menge der prädikatenlogischen Formeln F (Σ, X) gegeben durch

◮ true, false ∈ F (Σ, X);

◮ t1 = t2 ∈ F (Σ, X), falls t1, t2 ∈ T (Σ, X)s für ein s ∈ S;

◮ p(t1, . . . , tn) ∈ F (Σ, X), falls p : s1 . . . sn ∈ P und ti ∈ T (Σ, X)si für

1 ≤ i ≤ n;

◮ Wenn ϕ, ψ ∈ F (Σ, X), dann

(¬ϕ), (ϕ ∧ ψ), (ϕ ∨ ψ), (ϕ → ψ), (ϕ ↔ ψ) ∈ F (Σ, X);

◮ Wenn ϕ ∈ F (Σ, X) und x ∈ X, dann (∀x . ϕ), (∃x . ϕ) ∈ F (Σ, X).

A. Knapp, G. Schellhorn: Formale Methoden 76


Formeln: Notation

◮ Es gelten dieselben Präzendenz- und Klammerregeln wie bei

Aussagenlogik.

◮ Zusätzlich: Quantoren binden am schwächsten

∀x . ϕ ∧ ψ ↔ ∃y . π ∨ ρ ≡ (∀x . ((ϕ ∧ ψ) ↔ (∃y . (π ∨ ρ))))

◮ Quantoren binden immer soweit nach rechts wie möglich.

◮ Abkürzung: Listen von Quantoren

∀x1, x2, . . . , xn . ϕ ≡ ∀x1 . ∀x2 . . . . ∀xn . ϕ

Beispiele:

◮ In ΣGrp: ∀x . ·(x, −1 (x)) = 1

◮ In ΣNat2: ∀m, n .


Prädikatenlogische Spezifikationen in KIV

specification

sorts nat;

constants zero : nat;

one : nat;

functions . + . : nat × nat → nat prio 9 right;

predicates . < . : nat × nat;

variables m, n, k : nat;

axioms commutativity+ : m + n = n + m;

less : m < n ↔ ∃ k. ¬ (k = zero) ∧ m + k = n;

end specification

A. Knapp, G. Schellhorn: Formale Methoden 78


Semantik von Formeln

Definition Für eine Algebra A und eine Belegung v ist die Semantik einer

Formel FA A v der Wahrheitswert aus B mit

◮ Ftrue A v = tt

◮ Ffalse A v = ff

◮ Ft1 = t2 A v = tt gdw. T t1 A v = T t2 A v

◮ Fp(t1, . . . , tn) A v = tt gdw. (T t1 A v, . . . , T tn A v) ∈ p A

◮ F¬ϕ A v = tt gdw. Fϕ A v = ff

◮ Fϕ ∧ ψ A v = tt gdw. Fϕ A v = tt und Fψ A v = tt

◮ Fϕ ∨ ψ A v = tt gdw. Fϕ A v = tt oder Fψ A v = tt

◮ Fϕ → ψ A v = tt gdw. Fϕ A v = ff oder Fψ A v = tt

◮ Fϕ ↔ ψ A v = tt gdw. Fϕ A v = Fψ A v

◮ F∀x . ϕ A v = tt gdw. f. a. a ∈ As: Fϕ A v{x ↦→ a} = tt (für x ∈ Xs)

◮ F∃x . ϕ A v = tt gdw. ex. a ∈ As: Fϕ A v{x ↦→ a} = tt (für x ∈ Xs)

A. Knapp, G. Schellhorn: Formale Methoden 79


Variablen einer Formel

Definition Die Variablen var(ϕ) einer Formel ϕ sind gegeben durch

◮ var(true) = var(false) = ∅

◮ var(t1 = t2) = var(t1) ∪ var(t2)

◮ var(p(t1, . . . , tn)) = var(t1) ∪ . . . ∪ var(tn)

◮ var(¬ψ) = var(ψ)

◮ var(ψ ⋆ π) = var(ψ) ∪ var(π) für ⋆ ∈ {∧, ∨, →, ↔}

◮ var(Qx . ψ) = {x} ∪ var(ψ) für Q ∈ {∀, ∃}

A. Knapp, G. Schellhorn: Formale Methoden 80


Freie Variablen einer Formel

Definition Die freien Variablen fvar(ϕ) einer Formel ϕ sind gegeben durch

◮ fvar(true) = fvar(false) = ∅

◮ fvar(t1 = t2) = var(t1) ∪ var(t2)

◮ fvar(p(t1, . . . , tn)) = var(t1) ∪ . . . ∪ var(tn)

◮ fvar(¬ψ) = fvar(ψ)

◮ fvar(ψ ⋆ π) = fvar(ψ) ∪ fvar(π) für ⋆ ∈ {∧, ∨, →, ↔}

◮ fvar(Qx . ψ) = fvar(ψ) \ {x} für Q ∈ {∀, ∃}

Eine Formel ohne freie Variablen heißt geschlossen.

A. Knapp, G. Schellhorn: Formale Methoden 81


Koinzidenzlemma für Formeln

Die Semantik einer Formel hängt nur von den freien Variablen ab

(Koinzidenzlemma).

Lemma Sind zwei Belegungen v und w gleich für alle freien Variablen einer

Formeln ϕ, dann gilt Fϕ A v = Fϕ A w.

◮ Für geschlossene Formeln ϕ Belegung v irrelevant.

A. Knapp, G. Schellhorn: Formale Methoden 82


Substitution in Formeln

Definition Die Substitution ϕ{x ↦→ t} einer Variablen x durch einen Term t in

einer Formel ϕ ist gegeben durch

◮ true{x ↦→ t} = true

◮ false{x ↦→ t} = false

◮ (t1 = t2){x ↦→ t} = t1{x ↦→ t} = t2{x ↦→ t}

◮ p(t1, . . . , tn){x ↦→ t} = p(t1{x ↦→ t}, . . . , tn{x ↦→ t})

◮ (¬ψ){x ↦→ t} = ¬(ψ{x ↦→ t})

◮ (ψ ⋆ π){x ↦→ t} = ψ{x ↦→ t} ⋆ π{x ↦→ t}


Qy . ψ falls y = x oder x /∈ fvar(ψ)

⎪⎨ Qy . ψ{x ↦→ t} falls y = x, y /∈ var(t), x ∈ fvar(ψ)

◮ (Qy . ψ){x ↦→ t} = Qz . (ψ{y ↦→ z}){x ↦→ t}

⎪⎩

falls y = x, y ∈ var(t), x ∈ fvar(ψ)

(z neu, d. h. z /∈ fvar(ψ) ∪ var(t))

A. Knapp, G. Schellhorn: Formale Methoden 83


Substitutionslemma für Formeln

Die Formel ϕ{x ↦→ t} ist wahr in der Algebra A unter der Belegung v genau

dann, wenn die Formel ϕ unter einer abgeänderten Belegung wahr ist, in der x

den Wert von t hat (Substitutionslemma).

Lemma Fϕ{x ↦→ t} A v = Fϕ A v{x ↦→ T t A v}.

Beispiel für Umbenennung bei Quantoren:

◮ ∃m . n < m wahr über den natürlichen Zahlen (bei jeder Belegung von n).

◮ Nach dem Lemma darf für n jeder Term eingesetzt werden, und man erhält

wieder eine wahre Aussage.

◮ Ersetzen von n durch m · m würde ohne Umbenennung aber

∃m . m · m < m ergeben, was falsch ist.

◮ Das richtige Ergebnis ist ∃m0 . m · m < m0.

A. Knapp, G. Schellhorn: Formale Methoden 84


Gültigkeit und Modelle

Definition Die Formel ϕ ist in A unter der Belegung v gültig, geschrieben als

A, v |= ϕ, wenn Fϕ A v = tt.

Eine Algebra A ist ein Modell der Formel ϕ, geschrieben als A |= ϕ, wenn für

alle Belegungen v gilt: A, v |= ϕ.

Eine Algebra A ist ein Modell für die Formelmenge Φ, geschrieben als A |= Φ,

falls A |= ϕ für alle ϕ ∈ Φ.

Definition Sei ϕ eine Formel und Φ eine Formelmenge.

◮ ϕ ist eine Tautologie, in Zeichen |= ϕ, falls A |= ϕ für alle A ∈ Alg(Σ).

◮ ϕ ist erfüllbar in der Algebra A, falls es eine Belegung v mit A, v |= ϕ gibt.

◮ Φ ist erfüllbar in der Algebra A, falls es eine Belegung v mit A, v |= ϕ für

alle ϕ ∈ Φ gibt.

◮ ϕ ist erfüllbar, falls ϕ ist erfüllbar in einer Algebra.

◮ Φ ist erfüllbar, falls Φ erfüllbar in einer Algebra.

A. Knapp, G. Schellhorn: Formale Methoden 85


Tautologie, Erfüllbarkeit: Beispiele

◮ x = x, p(x) ∨ ¬p(x) sind Tautologien.

◮ p(x) hat Modelle, ist erst recht erfüllbar (in mehr Algebren als den

Modellen).

◮ x = y ist erfüllbar (in jeder Algebra) und hat ein Modell (das

einelementige).

◮ x = y, p(x) ∧ ¬p(y) sind erfüllbar (aber nicht in jeder Algebra), haben

Es gilt:

keine Modelle

◮ ϕ ist Tautologie ⇒ ϕ hat Modell ⇒ ϕ ist erfüllbar, aber keine Umkehrung

◮ ϕ ist nicht erfüllbar genau dann, wenn ¬ϕ eine Tautologie ist.

A. Knapp, G. Schellhorn: Formale Methoden 86


Folgerbarkeit

Definition Eine Formel ϕ ist eine Folgerung aus der Formelmenge Φ,

geschrieben als Φ |= ϕ, falls für alle A ∈ Alg(Σ) gilt: A |= Φ impliziert A |= ϕ.

Φ als Axiome einer Datentypspezifikation

Beispiel

◮ Für ΣGrp: ΦGrp

∀x . x · 1 = x

∀x . 1 · x = x

∀x, y, z . x · (y · z) = (x · y) · z

∀x . x · x −1 = 1

∀x . x −1 · x = 1

◮ Dann ΦGrp |= ∀e . (∀x . x · e = x ∧ e · x = x) → e = 1.

A. Knapp, G. Schellhorn: Formale Methoden 87


Eigenschaften der Prädikatenlogik

Definition Ist fvar(ϕ) = {x1, . . . , xn}, so ist der Allabschluß

cl ∀ (ϕ) = ∀x1, . . . , xn . ϕ.

1. A, v |= ϕ gdw. nicht A, v |= ¬ϕ (geschrieben als A, v |= ¬ϕ)

2. A, v |= ϕ oder A, v |= ¬ϕ

3. A |= ϕ oder A |= ¬ϕ, falls ϕ geschlossen

4. A |= ϕ gdw. A |= ¬ϕ, falls ϕ geschlossen

5. A |= ϕ gdw. A |= cl ∀ (ϕ)

6. Φ |= ϕ gdw. Φ |= cl ∀ (ϕ)

7. Φ ∪ {ϕ} |= ψ gdw. Φ ∪ {cl ∀ (ϕ)} |= cl ∀ (ψ)

8. Φ ∪ {ϕ} |= ψ gdw. Φ |= cl ∀ (ϕ) → ψ

Aus Φ ∪ {ϕ} |= ψ folgt nur für geschlossenes ϕ, daß Φ |= ϕ → ψ. Implikation

und Folgerbarkeit fallen also nicht zusammen:

◮ x > 0 |= ∀x . x > 0 ist wahr, |= x > 0 → ∀x . x > 0 ist falsch (über N)

A. Knapp, G. Schellhorn: Formale Methoden 88


Eigenschaften von Quantoren

Satz Wenn z /∈ fvar(ϕ) \ {y}, so gelten:

A, v |= ∀y . ϕ gdw. A, v |= ∀z . ϕ{y ↦→ z} ,

|= (∀y . ϕ) ↔ (∀z . ϕ{y ↦→ z}) .

Beweisskizze Aus Substitutionslemma.

Satz Für jede Formel ϕ gelten

|= (∀x . ϕ) → ϕ{x ↦→ t} ,

|= ϕ{x ↦→ t} → (∃x . ϕ) .

Beweisskizze Aus Substitutionslemma.

A. Knapp, G. Schellhorn: Formale Methoden 89


Tautologien für Quantoren (1)

Sei y /∈ fvar(ϕ).

Q1. (∀x . ϕ) ↔ (∀y . ϕ{x ↦→ y})

Q2. (∃x . ϕ) ↔ (∃y . ϕ{x ↦→ y})

Q3. (¬∀x . ϕ) ↔ (∃x . ¬ϕ)

Q4. (¬∃x . ϕ) ↔ (∀x . ¬ϕ)

Q5. (∀x . ∀y . ϕ) ↔ (∀y . ∀x . ϕ)

Q6. (∃x . ∃y.ϕ) ↔ (∃y . ∃x . ϕ)

Q7. (∃x . ϕ ∨ ψ) ↔ ((∃x . ϕ) ∨ (∃x . ψ))

Q8. (∀x . ϕ ∧ ψ) ↔ ((∀x . ϕ) ∧ (∀x . ψ))

A. Knapp, G. Schellhorn: Formale Methoden 90


Tautologien für Quantoren (2)

Q9. (∃x . ϕ ∧ ψ) → ((∃x . ϕ) ∧ (∃x . ψ))

Q10. ((∀x . ϕ) ∨ (∀x . ψ)) → (∀x . ϕ ∨ ψ)

Q11. (∀x . ϕ → ψ) → ((∀x . ϕ) → (∀x . ψ))

Q12. (∀x . ϕ ↔ ψ) → ((∀x . ϕ) ↔ (∀x . ψ))

Q13. (∀x . ϕ) → ϕ{x ↦→ t}

Q14. ϕ{x ↦→ t} → ∃x . ϕ

Q15. (∃x . ∀y . ϕ) → ∀y . ∃x . ϕ

A. Knapp, G. Schellhorn: Formale Methoden 91


Tautologien für Quantoren (3)

Sei x /∈ fvar(ψ).

Q16. (∀x . ψ) ↔ ψ

Q17. (∃x . ψ) ↔ ψ

Q18. (∃x . ϕ ∨ ψ) ↔ ((∃x . ϕ) ∨ ψ)

Q19. (∀x . ϕ ∨ ψ) ↔ ((∀x . ϕ) ∨ ψ)

Q20. (∃x . ϕ ∧ ψ) ↔ ((∃x . ϕ) ∧ ψ)

Q21. (∀x . ϕ ∧ ψ) ↔ ((∀x . ϕ) ∧ ψ)

Q22. (∃x . ψ → ϕ) ↔ (ψ → ∃x . ϕ)

Q23. (∀x . ψ → ϕ) ↔ (ψ → ∀x . ϕ)

Q24. (∀x . ϕ → ψ) ↔ ((∃x . ϕ) → ψ)

Q25. (∃x . ϕ → ψ) ↔ ((∀x . ϕ) → ψ)

A. Knapp, G. Schellhorn: Formale Methoden 92


Substitution von Formeln durch Formeln

Umformungen mittels Tautologien, lokale Simplifikation

Definition Für Formeln ϕ, ψ, π ist die Substitution von ψ durch π in ϕ,

geschrieben als ϕ{ψ ↦→ π}, definiert wie in der Aussagenlogik; zusätzlich für

Q ∈ {∀, ∃}:

◮ (Qx . ϕ){ψ ↦→ π} = π, falls ψ = Qx . ϕ;

◮ (Qx . ϕ){ψ ↦→ π} = Qx . (ϕ{ψ ↦→ π}), falls x /∈ fvar(ψ) ∪ fvar(π);

◮ (Qx . ϕ){ψ ↦→ π} = Qy . ((ϕ{x ↦→ y}){ψ ↦→ π}) mit

y /∈ fvar(ϕ) ∪ fvar(ψ) ∪ fvar(π), falls x ∈ fvar(ψ) ∪ fvar(π).

Lemma Wenn A, v |= ψ ↔ π, dann A, v |= ϕ{ψ ↦→ π} ↔ ϕ.

A. Knapp, G. Schellhorn: Formale Methoden 93


Pränex-Normalform

Satz Zu jeder Formel ϕ gibt es eine quantorenfreie Formel ψ, Quantoren

Q1, . . . , Qn ∈ {∀, ∃} und Variablen x1, . . . xn, sodaß

gilt.

|= ϕ ↔ Q1x1 . . . . Qnxn . ψ

Beweisskizze

◮ Ersetze Äquivalenzen durch Konjunktion von zwei Implikationen.

◮ Schiebe Quantoren nach außen (zuerst den äußersten); mit Q3, Q4, Q18–Q25

(rechte durch linke Seite ersetzen).

◮ Wenn das nicht geht, weil eine gebundene Variable auch frei in π ist, benenne die

gebundene Variable vorher um mit Q1, Q2.

A. Knapp, G. Schellhorn: Formale Methoden 94


Tautologien für Gleichheit

Sei x /∈ var(t ′ ).

E1. t = t Reflexivität

E2. t1 = t2 → t2 = t1 Symmetrie

E3. t1 = t2 ∧ t2 = t3 → t1 = t3 Transitivität

E4. t1 = u1 ∧ . . . ∧ tn = un →

Kongruenz für f

f (t1, . . . , tn) = f (u1, . . . , un)

E5. t1 = u1 ∧ . . . ∧ tn = un →

Kongruenz für p

(p(t1, . . . , tn) ↔ p(u1, . . . , un))

E6. t = u → s{x ↦→ t} = s{x ↦→ u} Einsetzung in Term s

E7. t = u → ϕ{x ↦→ t} ↔ ϕ{x ↦→ u} Einsetzung in Formel ϕ

E8. ∃x . x = t nichtleere Trägermengen

E9. (∃x . x = t ′ ∧ ϕ) ↔ ϕ{x ↦→ t ′ } Beseitigung Existenzquantor

E10. (∀x . x = t ′ → ϕ) ↔ ϕ{x ↦→ t ′ } Beseitigung Allquantor

E11. (∀x . x = t ′ ∨ ϕ) ↔ ϕ{x ↦→ t ′ } Beseitigung Allquantor

A. Knapp, G. Schellhorn: Formale Methoden 95


Sequenzen

Wie in der Aussagenlogik ist eine Sequenz eine Kurzschreibweise für eine

Formel:

A, v |= Γ ⇒ ∆ ⇐⇒ A, v |= Γ → ∆

Definition Eine Algebra A ist ein Modell einer Sequenz Γ ⇒ ∆,

geschrieben als A |= Γ ⇒ ∆, falls A |= cl ∀ ( Γ → ∆).

A. Knapp, G. Schellhorn: Formale Methoden 96


Regeln des Sequenzenkalküls PL

◮ Regeln des aussagenlogischen Sequenzenkalküls werden übernommen.

◮ Zusätzlich je eine Regel für Quantor und Gleichheit links und rechts.

ϕ{x ↦→ t}, ∀x . ϕ, Γ ⇒ ∆

(L∀)

∀x . ϕ, Γ ⇒ ∆

ϕ{x ↦→ y}, Γ ⇒ ∆

(L∃)

∃x . ϕ, Γ ⇒ ∆

(Refl) Γ ⇒ t = t, ∆

(1) y /∈ (fvar(ϕ) \ {x}) ∪ fvar(Γ) ∪ fvar(∆)

(2) auch mit t = x statt x = t

Γ ⇒ ϕ{x ↦→ t}, ∃x . ϕ, ∆

(R∃)

Γ ⇒ ∃x . ϕ, ∆

(1) (R∀) Γ ⇒ ϕ{x ↦→ y}, ∆

Γ ⇒ ∀x . ϕ, ∆ (1)

x = t, Γ{x ↦→ t} ⇒ ∆{x ↦→ t}

(Eq) (2)

x = t, Γ ⇒ ∆

A. Knapp, G. Schellhorn: Formale Methoden 97


Ableitbarkeit, Korrektheit, Invertierbarkeit

Definition Eine Sequenz Γ ⇒ ∆ ist aus einer Menge von Formlen Φ

ableitbar, geschrieben als Φ ⊢PL Γ ⇒ ∆, falls es einen mit den Regeln von PL

gebildeten Beweisbaum mit Konklusion Γ ⇒ ∆ und Prämissen der Form ⇒ ϕ

mit ϕ ∈ Φ gibt.

Satz Für einen Baum mit Konklusion Γ ⇒ ∆ und Prämissen

Γ1 ⇒ ∆1, . . . Γn ⇒ ∆n gilt:

◮ Γ1 ⇒ ∆1, . . . Γn ⇒ ∆n |= Γ ⇒ ∆ (Korrektheit)

◮ Wenn Φ ⊢PL Γ ⇒ ∆, dann Φ |= Γ ⇒ ∆ (Korrektheit von PL).

◮ Falls keine Abschwächung vorkommt, gilt für jedes 1 ≤ i ≤ n, daß

Γ ⇒ ∆ |= Γi ⇒ ∆i (Invertierbarkeit).

Beweisskizze Wie für AL: Behauptung gilt für jede Regel, Induktion über die Anzahl

der angewandten Regeln

A. Knapp, G. Schellhorn: Formale Methoden 98


Ableitbarkeit in PL: Beispiel (1)

Ableitung für die Sequenz ⇒ (∃x . ∀y . ϕ) → ∀y . ∃x . ϕ (Q15)

(A)

(ϕ{x ↦→ z}){y ↦→ w}, ∀y . ϕ1 ⇒ (ϕ{y ↦→ w}){x ↦→ z}, ∃x . ϕ2

(R∃)

(ϕ{x ↦→ z}){y ↦→ w}, ∀y . ϕ{x ↦→ z} ⇒ ∃x . ϕ{y ↦→ w}

(L∀)

∀y . ϕ{x ↦→ z} ⇒ ∃x . ϕ{y ↦→ w}

(∀y . ϕ){x ↦→ z} ⇒ (∃x . ϕ){y ↦→ w} =

(R∀)

(∀y . ϕ){x ↦→ z} ⇒ ∀y . ∃x . ϕ

(L∃)

∃x . ∀y . ϕ ⇒ ∀y . ∃x . ϕ

⇒ (∃x . ∀y . ϕ) → ∀y . ∃x . ϕ (R→)

wobei w, z /∈ fvar(ϕ), ϕ1 = ϕ{x ↦→ z}, ϕ2 = ϕ{y ↦→ w}

A. Knapp, G. Schellhorn: Formale Methoden 99


Ableitbarkeit in PL: Beispiel (2)

Ableitung für die Sequenz ⇒ ∀x, y, z . x = y ∧ x = z → y = z

x = y, y = z ⇒ y = z (A)

x = y, x = z ⇒ y = z (Eq)

x = y ∧ x = z ⇒ y = z (L∧)

⇒ x = y ∧ x = z → y = z (R→)

⇒ ∀z . x = y ∧ x = z → y = z (R∀)

⇒ ∀y, z . x = y ∧ x = z → y = z (R∀)

⇒ ∀x, y, z . x = y ∧ x = z → y = z (R∀)

A. Knapp, G. Schellhorn: Formale Methoden 100


Ableitbarkeit in PL: Beispiel (3)

Ableitung für die Sequenz ⇒ ∀e . (∀x . x · e = x) → e = 1 aus ΦGrp

[. . .] e = 1, 1 · e = e, 1 · e = 1 ⇒ e = 1 (A)

1 · e = e ∧ 1 · e = 1 → e = 1, 1 · e = e, 1 · e = 1 ⇒ e = 1 (L→)

3 × (L∀)

∀x, y, z . x = y ∧ x = z → y = z, 1 · e = e, 1 · e = 1 ⇒ e = 1

(Lem2)

1 · e = e, 1 · e = 1 ⇒ e = 1

∀x . 1 · x = x, 1 · e = 1 ⇒ e = 1 (L∀)

(Lem1)

1 · e = 1 ⇒ e = 1

∀x . x · e = x ⇒ e = 1 (L∀)

⇒ (∀x . x · e = x) → e = 1 (R→)

⇒ ∀e . (∀x . x · e = x) → e = 1 (R∀)

◮ (Lem1): (Cut) für ∀x . 1 · x = x aus ΦGrp

◮ (Lem2): (Cut) für ∀x, y, z . x = y ∧ x = z → y = z

A. Knapp, G. Schellhorn: Formale Methoden 101


Beweisen mit Prädikatenlogik in KIV

Bisher: Basis-PL-Kalkül (mit “use basic rules”); in Zukunft KIV-Kalkül: alles was

im Basiskalkül umständlich mit mehreren Schritten gemacht werden muss, wird

in natürliche Schritte zusammengefasst:

◮ Regeln zur Verwendung von Lemmata, d. h. anderer (schon bewiesener)

Theoreme oder Axiome (statt nur cut-Regel)

◮ Gleichungseinsetzen für beliebige Gleichungen t = u

◮ Gleichungseinsetzen an speziellen Positionen (statt überall)

◮ Gleichungseinsetzen und (L∀), (R∃) mit “discard”

◮ Fallunterscheidungsregel (“case distinction”) faßt alle aussagenlogischen

Regeln mit zwei Prämissen zusammen ((L∨), (L→),(L↔), (R∧),(R↔))

◮ Regel “prop simplification”, um AL-Regeln mit einer Prämisse

anzuwenden, wird aber normalerweise nicht verwendet

◮ stattdessen: Simplifier-Regel

A. Knapp, G. Schellhorn: Formale Methoden 102


Der Simplifier in KIV

KIV-Simplifier macht viele Vereinfachungen automatisch

◮ wendet aussagenlogische Regeln mit weniger als zwei Prämissen an,

ausserdem (Refl)

◮ wendet (R∀), (L∃) an

◮ wendet kontextabhängige Substitutionen (wie etwa

A, Γ{A ↦→ true} ⇒ ∆{A ↦→ true}/A, Γ ⇒ ∆) an

◮ setzt x = t mit x /∈ var(t) ein und entfernt x = t

◮ setzt Gleichungen u = t ein, falls t ” einfacher“ als u

◮ Weglassen überflüssiger Quantoren mit (Q16–Q23), (E9–E11)

◮ Rewriting: Umschreiben von Gleichungen mit gegebenen Theoremen

durch automatischem insert rewrite lemma mit Theoremen (später)

KIV macht nach jeder Regelanwendung einen Test, ob der KIV-Simplifier

Prämissen schliessen kann. Wenn ja, bekommt man diese Prämissen nicht zu

sehen (abstellbar mit der Option “no automatic predtest”).

A. Knapp, G. Schellhorn: Formale Methoden 103


KIV-Kalkül: Allgemeines Einsetzen von Gleichungen

Allgemeine Substitution aus

t = u, Γ{x ↦→ u} ⇒ ∆{x ↦→ u} ⊢PL t = u, Γ{x ↦→ t} ⇒ ∆{x ↦→ t}

◮ x ” markiert“ die Ersetzungsstellen

Im KIV-Kalkül deshalb als (Eq) die Regel

t = u, Γ{x ↦→ u} ⇒ ∆{x ↦→ u}

(insert equation)

t = u, Γ{x ↦→ t} ⇒ ∆{x ↦→ t}

Beispiel:

e = 1 · e, 1 = 1 · e ⇒ 1 = 1 · e

e = 1 · e, 1 = 1 · e ⇒ 1 = e

(insert equation)

wegen (1 = e) ≡ (1 = x){x ↦→ e} und (1 = 1 · e) ≡ (1 = x){x ↦→ 1 · e}

A. Knapp, G. Schellhorn: Formale Methoden 104


KIV-Kalkül: Lemmaanwendung

Anwendung von Axiomen mit (Cut), (L∀) und evtl. (insert equation) oft

umständlich

Im KIV-Kalkül spezielle Regel

(insert lemma) Γ′ ⇒ ∆ ′ Γ ⇒ ( Γ ′ )θ, ∆ ( ∆ ′ )θ, Γ ⇒ ∆

Γ ⇒ ∆

◮ Γ ′ ⇒ ∆ ′ ist das Lemma (Axiom oder anderes Theorem)

◮ θ ist eine Substitution für die freien Variablen des Lemmas

Beispiel: Lemma x = y, x = z ⇒ y = z

x = y, x = z ⇒ y = z

1 · e = e, 1 · e = 1 ⇒ 1 · e = e ∧ 1 · e = 1, e = 1

e = 1, 1 · e = e, 1 · e = 1 ⇒ e = 1

1 · e = e, 1 · e = 1 ⇒ e = 1

mit θ = {x ↦→ 1 · e, y ↦→ e, z ↦→ 1}

(insert lemma)

A. Knapp, G. Schellhorn: Formale Methoden 105


KIV-Kalkül: Ersetzungslemmata

(insert rewrite lemma) Γ′ ⇒ ϕ → t = u Γ ⇒ ( Γ ′ ∧ ϕ)θ, ∆ Γ ′′ ⇒ ∆ ′′

Γ ⇒ ∆

◮ Γ ′ ⇒ ϕ → t = u ist das Lemma (Γ ′ und Vorbedingung ϕ dürfen fehlen)

◮ θ ist eine Substitution für die freien Variables des Lemmas

◮ Γ ′′ ⊢ ∆ ′′ entsteht aus Γ ⊢ ∆ durch Ersetzen von tθ durch uθ

◮ Lemmata der Form Γ ′ ⇒ ϕ → (ψ ↔ π) mit ψ Literal erlaubt: Dann wird

ψθ durch πθ ersetzt

A. Knapp, G. Schellhorn: Formale Methoden 106


Deduktionstheorem

Satz Φ ∪ {ϕ} ⊢PL ⇒ ψ gdw. Φ ⊢PL cl ∀ (ϕ) ⇒ ψ

gdw. Φ ⊢PL ⇒ cl ∀ (ϕ) → ψ

Beweisskizze Obere Äquivalenz wie für Aussagenlogik mit zwei Zusätzen:

◮ Für ” ⇒“ muß cl ∀ (ϕ) (nicht nur ϕ) in jedem Antezedent addiert werden.

◮ Damit bleiben bei (R∀) und (L∃) die Variablenbedingungen gültig.

◮ Prämissen cl ∀ (ϕ) ⇒ ϕ können mit (L∀) geschlossen werden.

◮ Bei ” ⇐“ braucht man (Cut) mit ⇒ cl ∀ (ϕ) (für das Axiom ϕ).

◮ Die Prämisse ⇒ cl ∀ (ϕ), ψ kann mit (Weak), dann (R∀) zum Axiom ϕ

reduziert werden.

A. Knapp, G. Schellhorn: Formale Methoden 107


Konsistenzlemma

Definition Eine Menge Φ von Formeln heißt konsistent, falls Φ ⊢ PL ⇒.

Lemma Jede konsistente Menge prädikatenlogischer Formeln hat ein

Modell.

Ohne Beweis (Kurt Gödel 1929)

A. Knapp, G. Schellhorn: Formale Methoden 108


Vollständigkeitssatz

Satz Für eine Formel ϕ und eine Formelmenge Φ gilt

Φ |= ϕ ⇒ Φ ⊢PL ⇒ ϕ

Beweisskizze

Φ |= ϕ

⇔ Φ ∪ {¬ cl ∀ (ϕ)} hat kein Modell (Def. Φ |= ϕ)

⇒ Φ ∪ {¬ cl ∀ (ϕ)} ⊢PL ⇒ (Konsistenzlemma)

⇔ Φ ⊢PL ⇒ cl ∀ (ϕ) (Deduktionstheorem)

⇒ Φ ⊢PL ⇒ ϕ (mit Regel (R∀))

Intuition: Korrektheit und Vollständigkeit von PL garantieren, daß

” Berechnungen im Kalkül“ genau die Theoreme ergeben, die in allen

Datenstrukturen der Axiome gelten.

A. Knapp, G. Schellhorn: Formale Methoden 109


Endlichkeitssatz

Satz Eine Menge von Formeln Φ hat genau dann ein Modell, wenn jede

endliche Teilmenge von Φ ein Modell hat.

Beweisskizze Für ” ⇐“: Nach Konsistenzlemma reicht es zu zeigen, daß Φ konsistent

ist.

◮ Angenommen, Φ wäre inkonsistent.

◮ Dann gibt es einen Beweis für die leere Sequenz (false).

◮ Der Beweis verwendet nur endliche viele Axiome.

◮ Somit ist schon diese endliche Menge inkonsistent und hat kein Modell, im

Widerspruch zur Annahme.

A. Knapp, G. Schellhorn: Formale Methoden 110


Unentscheidbarkeit der Prädikatenlogik

Satz Es gibt kein Entscheidungsverfahren für die Allgemeingültigkeit von

prädikatenlogischen Formeln.

Ohne Beweis (Alonzo Church 1936)

Zählt man alle Beweise des Sequenzenkalküls auf, so wird darin jede

allgemeingültige Formel irgendwann vorkommen, aber das Verfahren kann

nicht so verschärft werden, daß es auch für alle nicht allgemeingültigen

Formeln immer abbricht.

Somit ist Prädikatenlogik ” schwierig“ im Gegensatz zur Aussagenlogik, für die

der Sequenzenkalkül ein Entscheidungsverfahren ist.

Das Problem bei PL liegt bei der Frage, welche Terme t man bei den Regeln

(L∀) und (R∃) wählen soll.

A. Knapp, G. Schellhorn: Formale Methoden 111


Zusammenfassung

◮ Prädikatenlogik

◮ Syntax: Signaturen, Terme, Formeln

◮ Semantik: Algebren

◮ Modelle, Folgerbarkeit, Erfüllbarkeit

◮ Sequenzenkalkül PL

◮ Korrektheit und Vollständigkeit

◮ Beweisen in KIV

◮ Unentscheidbarkeit der Prädikatenlogik

A. Knapp, G. Schellhorn: Formale Methoden 112


Semantische Beschreibung von Softwaresystemen

Operationale Sicht

◮ Semantischer Bereich: Zustandsübergangssysteme (Automaten)

◮ Zustände, Zustandsübergänge, Abläufe

Algebraische Sicht

◮ Semantischer Bereich: Algebren

◮ Datentypen mit Sorten und Operationen

A. Knapp, G. Schellhorn: Formale Methoden 113


Algebraische Sicht: Automaten

specification

sorts state;

predicates trans : state × state;

initial : state;

final : state;

end specification

Abläufe eines Automaten als Folgen [s1, . . . , sn] von Zuständen

initial(s1) ∧ final(sn) ∧ ∀k . k < n → trans(sk, sk + 1)

A. Knapp, G. Schellhorn: Formale Methoden 114


Algebraische Sicht: Abstrakte Syntaxbäume

specification

sorts prog;

boolexpr;

. . .

functions (: Konstruktoren :)

mkif : boolexpr × prog × prog → prog;

mkwhile : boolexpr × prog → prog;

. . .

(: Selektoren :)

test : prog → boolexpr;

thenbranch : prog → prog;

. . .

variables b : boolexpr;

p1, p2 : prog;

. . .

axioms test(mkif(b, p1, p2)) = b;

thenbranch(mkif(b, p1, p2)) = p1;

. . .

end specification

A. Knapp, G. Schellhorn: Formale Methoden 115


Algebraische Sicht: Syntax und Semantik

Syntax und semantische Bereiche als Datentypen beschreibbar

Relation zwischen Syntax und semantischen Bereichen als Abbildung

◮ sem : prog → set(trace)

◮ Semantik von Programmier- und Spezifikationssprachen

A. Knapp, G. Schellhorn: Formale Methoden 116


Algebraische Spezifikationen

Ziel: Festlegung eines bestimmten Datentyps (Algebra)

◮ Welche Operationen?

◮ Welche Axiome?

◮ Welche Datentypen können überhaupt spezifizieren werden?

◮ Sind alle wahren Aussagen über dem Datentyp beweisbar?

A. Knapp, G. Schellhorn: Formale Methoden 117


Einfache Spezifikationen

Definition Eine einfache Spezifikation Sp = (Σ, X, Ax) besteht aus einer

Signatur Σ, einer Variablenmenge X für Σ und einer entscheidbaren Menge

von Axiomen Ax ⊆ F (Σ, X).

◮ ” Axiomenschemata“ führen auf unendliche Mengen von Axiomen

Definition Eine Algebra A ist ein Modell einer einfachen Spezifikation

Sp = (Σ, X, Ax), geschrieben als A |= Sp oder A ∈ Mod(Sp), falls

A ∈ Alg(Σ) und A |= Ax.

◮ Lose Semantik von Sp: Modellklasse Mod(Sp)

Definition Eine Formel ϕ ∈ F (Σ, X) folgt aus einer einfachen Spezifikation

Sp = (Σ, X, Ax), geschrieben als Sp |= ϕ, falls für alle M ∈ Mod(Sp) gilt:

M |= ϕ.

A. Knapp, G. Schellhorn: Formale Methoden 118


Einfache Spezifikationen: Beispiel

Bool = specification

sorts bool;

constants tt, ff : bool;

variables b : bool;

axioms ax1: tt = ff;

ax2: b = tt ∨ b = ff;

end specification

◮ B ∈ Mod(Bool) mit tt B = tt, ff B = ff

◮ Mod(Bool) = {B}?

A. Knapp, G. Schellhorn: Formale Methoden 119


Homomorphismen

Definition Sei Σ = (S, F, P) eine Signatur. Für zwei Algebren

A, B ∈ Alg(Σ) ist ein Σ-Homomorphismus h : A → B eine Familie von

Abbildungen (hs)s∈S mit

◮ hs : As → Bs

◮ Für jedes f : s1 . . . sn → s ∈ F gilt

hs(f A (a1, . . . , an)) = f B (hs1 (a1), . . . , hsn(an)) .

◮ Für jedes p : s1 . . . sn ∈ P gilt:

(a1, . . . , an) ∈ p A ⇐⇒ (hs1 (a1), . . . , hsn(an)) ∈ p B .

◮ Ein Σ-Homomorphismus ist eine Familie von Abbildungen zwischen den

Trägermengen zweier Algebren, die mit den Funktions- und

Prädikatsymbolen verträglich ist.

◮ Verallgemeinerung von Homomorphismen für Gruppen, Ringe &c.

A. Knapp, G. Schellhorn: Formale Methoden 120


Isomorphismus, Monomorphie

Definition Ein Σ-Homomorphismus (hs)s∈S ist ein Σ-Isomorphismus, falls

alle hs bijektiv sind.

Zwei Σ-Algebren A, B heißen isomorph, geschrieben als A ∼ = B, falls ein

Σ-Isomorphismus h : A → B existiert.

◮ Ein Isomorphismus h : A → B benennt die Elemente von A in die

Elemente von B um.

Definition Eine Spezifikation Sp ist monomorph, wenn für alle

A, B ∈ Mod(Sp) gilt: A ∼ = B.

A. Knapp, G. Schellhorn: Formale Methoden 121


Monomorphie: Beispiel

Die Spezifikation Bool spezifiziert B bis auf Isomorphie.

Beweisskizze Sei A ∈ Mod(Bool).

◮ Dann enthält Abool die Elemente tt A und ff A (nach Definition).

◮ Wegen A |= ax1 sind die beiden Elemente verschieden.

◮ Wegen A |= ax2 gibt es keine weiteren Elemente in Abool.

◮ Also folgt aus A ∈ Mod(Bool), daß Abool = {tt A , ff A }.

◮ Definiere h : A → B durch hbool(tt A ) = tt, hbool(ff A ) = ff .

◮ h ist mit den Funktionssymbolen (hier: Konstanten) verträglich, da

tt B = tt, ff B = ff ; h ist also ein Homomorphismus.

◮ h ist ein Isomorphismus, da injektiv und surjektiv.

A. Knapp, G. Schellhorn: Formale Methoden 122


Axiomatisierung der natürlichen Zahlen

Signatur ΣNat = ({Nat}, {0 : → Nat, s : Nat → Nat}, ∅)

Peano-Axiome für ΣNat-Algebren A

P1 0 ist kein Wert der Nachfolgerfunktion s.

◮ A |= ∀n . s(n) = 0

P2 Die Nachfolgerfunktion s ist injektiv.

◮ A |= ∀m, n . s(m) = s(n) → m = n

P5 Für jede Teilmenge X von ANat gilt: Ist 0 A ∈ X und ist mit n ∈ X stets

s A (n) ∈ X, so ist X = ANat.

◮ A |= ∀X . (X(0) ∧ ∀x . X(x) → X(s(x))) → ∀y . X(y)

Insbesondere: N erfüllt Peano-Axiome.

◮ 0 N = 0, s N (n) = n + 1

(P5) Induktionsprinzip

◮ ” ad-hoc“-Formalisierung in Prädikatenlogik zweiter Stufe

A. Knapp, G. Schellhorn: Formale Methoden 123


Peano-Axiome: Charakterisierung der natürlichen Zahlen (1)

Satz Die Peano-Axiome (P1, P2, P5) charakterisieren N bis auf Isomorphie.

Beweisskizze Sei A ein Modell von (P1), (P2) und (P5).

◮ Setze M = {T 0 A, T s(0) A, T s(s(0)) A, . . . , T s n (0) A, . . .}

◮ mit s n (0) für den Term s(s(. . . (0) . . .)) mit n Vorkommen von s

◮ Dann gilt M ⊆ ANat und aus (P5) folgt, daß M = ANat.

◮ Setze h : N → A mit hNat(n) = T s n (0) A.

◮ Dann ist h ein Homomorphismus, da 0 N = 0, T s n (0) N = n.

◮ Weiters ist hNat surjektiv, da ANat = {T s n (0) A | n ∈ N}.

A. Knapp, G. Schellhorn: Formale Methoden 124


Peano-Axiome: Charakterisierung der natürlichen Zahlen (2)

Beweisskizze (Forts.)

◮ hNat ist auch injektiv, d. h. m = n ⇒ T s m (0) A = T s n (0) A für alle m, n ∈ N,

durch Induktion über m:

◮ Für m = 0: direkt mit (P1).

◮ Schluß von m auf m + 1:

◮ Induktionshypothese:

Für alle n ∈ N gilt: m = n ⇒ T s m (0) A = T s n (0) A.

◮ Zu zeigen:

Für alle n ∈ N gilt: m + 1 = n ⇒ T s m+1 (0) A = T s n (0) A.

◮ Für n = 0 ebenfalls direkt mit (P1).

◮ Für n = 0, ist n = n ′ + 1 für ein n ′ ∈ N.

◮ Da m + 1 = n, ist m = n ′ .

◮ Induktionshypothese mit n ′ für n liefert: T sm (0) A = T sn′ (0) A.

◮ Mit (P2) folgt die Behauptung.

A. Knapp, G. Schellhorn: Formale Methoden 125


Ausdrucksschwäche der Prädikatenlogik (1)

Satz Es gibt keine einfache Spezifikation Sp = (Σ, X, Ax) mit Sorte Nat und

Funktionssymbolen 0 : Nat, s : Nat → Nat in Σ, die bis auf Isomorphie als

einziges Modell die natürlichen Zahlen hat.

◮ Satz von Thoralf Skolem (1934)

◮ Prädikatenlogische Axiome können nicht ausdrücken, daß es neben den

” echten“ natürlichen Zahlen keine weiteren Zahlen gibt.

A. Knapp, G. Schellhorn: Formale Methoden 126


Ausdrucksschwäche der Prädikatenlogik (2)

Beweisskizze Habe Sp die natürlichen Zahlen als Modell: N |= Ax

◮ Erweitere Σ um neue Konstante c : Nat zu Σ ′ .

◮ Dann gilt für alle ϕ ∈ F (Σ, X), daß (Σ, X, Ax) |= ϕ genau dann, wenn

(Σ ′ , X, Ax) |= ϕ.

◮ Setze Ax ′ = Ax ∪ {c = 0, c = s(0), . . .}.

◮ Jede endliche Teilmenge von Ax ′ hat N (für geeignetes c N ) als Modell.

◮ Aus Endlichkeitssatz folgt: Ax ′ hat ein Modell A ′ .

◮ A ′ muß ein Element a = cA′ enthalten, das ungleich T sn (0) A für alle n ∈ N

ist.

◮ Somit ist A ′ betrachtet über Σ ein Modell von Ax, das nicht isomorph zu N ist.

A. Knapp, G. Schellhorn: Formale Methoden 127


Ausdrucksschwäche der Prädikatenlogik (3)

Prädikatenlogik kann nicht ausdrücken, daß es außer den Zahlen 0, 1, 2, . . .

(d. h. den aus 0 und s gebildeten Termen 0, s(0), s(s(0)), . . . ) keine weiteren

Elemente gibt.

Dasselbe Problem gibt es auch für andere Datentypen:

◮ Alle ganzen Zahlen sind mit 0, +1, −1 gebildet.

◮ Alle Listen sind die aus [] und + gebildeten Terme:

[], a + [], a + b + [], . . .

◮ Terme dürfen Elementvariablen enthalten

◮ Alle (endlichen) Graphen bekommt man aus dem leeren Graphen ∅ durch

Addieren von Knoten mit addnode und Kanten mit addedge.

◮ Alle Arrays bekommt man durch mkarray(n) (erzeugt Array der Größe n)

und put(a, i, d) (schreibt an Position i das Datum d).

Gemeinsame Idee: Alle Datenelemente durch endlich-malige Anwendung von

Konstruktoren bildbar.

A. Knapp, G. Schellhorn: Formale Methoden 128


Generiertheitsklauseln

Spezialaxiome für: Daten eines Datentyps sind genau die mit bestimmten

Konstruktoren gebildeten Terme.

Definition Eine Generiertheitsklausel s〈C〉 für eine Signatur Σ = (S, F, P)

besteht aus einer Sorte s ∈ S und einer endlichen Menge von Konstruktoren

C ⊆ F, wobei die Ergebnissorte jedes f ∈ C die Sorte s ist und für wenigstens

ein f ∈ C alle Argumentsorten ungleich s sind. Die Menge aller

Generiertheitsklauseln für ein Σ wird mit G (Σ) bezeichnet.

Ein Konstruktorterm t hat die Sorte s, ist mit Konstruktoren gebildet und enthält

nur Variablen anderer Sorten, ist also aus T ((S, C, ∅), X \ Xs)s.

Beispiel: Listen

◮ Generiertheitsklausel List〈{[], +}〉

◮ Konstruktorterme [], x + y + [] für x, y ∈ XElt

A. Knapp, G. Schellhorn: Formale Methoden 129


Generiertheitsklauseln: Semantik

Jedes Element der generierten Sorte ist der Wert eines Konstruktorterms,

wenn man die Parametervariablen geeignet belegt.

Definition Eine Generiertheitsklausel s〈C〉 gilt über einer Algebra A,

geschrieben als A |= s〈C〉, wenn es für jedes a ∈ As eine Belegung v und

einen Konstruktorterm t ∈ T ((S, C, ∅), X \ Xs)s mit a = T t A v gibt.

Beispiel: Liste über den natürlichen Zahlen [2, 5]

◮ Konstruktorterm x + y + []

◮ Belegung v der Variablen x, y als v(x) = 2 und v(y) = 5

◮ Dann: T x + y + [] A List(Nat) v = [2, 5].

A. Knapp, G. Schellhorn: Formale Methoden 130


Elementare Spezifikationen

Definition Eine elementare Spezifikation Sp = (Σ, X, Ax, Gen) besteht aus

einer Signatur Σ, einer Variablenmenge für Σ, einer entscheidbaren Menge

Ax ⊆ F (Σ, X) von Axiomen und einer Menge Gen ⊆ G (Σ) von

Generiertheitsklauseln.

Definition Eine Algebra A ist ein Modell einer elementaren Spezifikation

Sp = (Σ, X, Ax, Gen), geschrieben als A |= Sp oder A ∈ Mod(Sp), falls

A ∈ Alg(Σ), A |= Ax und A |= Gen.

Definition Eine Formel ϕ ∈ F (Σ, X) folgt aus einer elementaren

Spezifikation Sp = (Σ, X, Ax, Gen), geschrieben als Sp |= ϕ, falls für alle

M ∈ Mod(Sp) gilt: M |= ϕ.

A. Knapp, G. Schellhorn: Formale Methoden 131


Basis-Spezifikation der natürlichen Zahlen

◮ In KIV: induction s generated by C für s〈C〉

Nat-basic = specification

sorts nat;

constants 0 : nat;

functions . +1 : nat → nat;

induction nat generated by 0, +1;

variables m, n : nat;

axioms P1: 0 = n +1;

P2: m +1 = n +1 ↔ m = n;

end specification

Satz Nat-basic ist konsistent und monomorph für N.

Beweisskizze Analog zum Beweis, daß die Peano-Axiome monomorph sind: Die

Generiertheitsklausel garantiert (anstelle von (P5)) für jedes Modell A, daß

ANat = {T 0 A, T s(0) A, T s(s(0)) A, . . . , T s n (0) A, . . . }.

A. Knapp, G. Schellhorn: Formale Methoden 132


Spezifikation der natürlichen Zahlen

Nat = specification

sorts nat;

constants 0 : nat;

functions . +1 : nat → nat;

. + . : nat × nat → nat; (: prio 9 left :)

. ∗ . : nat × nat → nat prio 10 left;

induction nat generated by 0, +1;

variables m, n : nat;

axioms P1: 0 = n +1;

P2: m +1 = n +1 ↔ m = n;

P3a: m + 0 = m;

P3b: m + n +1 = (m + n) +1;

P4a: m ∗ 0 = 0;

P4b: m ∗ n +1 = m ∗ n + m;

end specification

Satz Nat ist konsistent und monomorph für N.

Beweisskizze Die Definitionen von + und ∗ folgen einem strukturellem

Rekursionsschema; ein solches Schema definiert immer genau eine Funktion.

A. Knapp, G. Schellhorn: Formale Methoden 133


Basis-Spezifikation von Listen

List-basic = specification

sorts elem;

list;

constants [] : list;

functions . + . : elem × list → list;

induction list generated by [], +;

variables a, b : elem;

variables x, y : list;

axioms [] = a + x;

a + x = b + y ↔ a = b ∧ x = y;

end specification

Satz List-basic ist konsistent. Die Spezifikation ist nicht monomorph, aber

jedes Modell A ist isomorph zur Algebra der Listen mit Elementen aus Aelem.

◮ Monomorphie ” modulo der Elemente“

A. Knapp, G. Schellhorn: Formale Methoden 134


Induktionsprinzip aus Generiertheitsklauseln: Beispiele (1)

Generiertheitsklausel s〈{c : s, f : s → s}〉

◮ Jedes Element der Trägermenge darstellbar als Konstruktorterm

f(f(. . . f(c)))

◮ Intuition: wie natürliche Zahlen (ohne (P1), (P2))

Induktionsformeln

ϕ{x ↦→ c} ∧ (∀x . ϕ → ϕ{x ↦→ f(x)}) → ∀x . ϕ

Induktionsregel

Γ{x ↦→ c} ⇒ ∆{x ↦→ c} IH, Γ{x ↦→ f(x)} ⇒ ∆{x ↦→ f(x)}

Γ ⇒ ∆

mit IH = ∀y . Γ → ∆, y = fvar(Γ ⇒ ∆) \ {x}

A. Knapp, G. Schellhorn: Formale Methoden 135


Induktionsprinzip aus Generiertheitsklauseln: Beispiele (2)

Generiertheitsklausel s〈{c : s, g : s ′ s s → s}〉

◮ Konstruktorterme: c, g(y, c, c), g(y0, g(y1, c, c), g(y2, c, c)), . . .

◮ Intuition: wenn alle Terme verschieden, Binärbäume mit Blättern c und

inneren Knoten g (mit Inhalt aus s ′ )

◮ Die Terme müssen nicht alle verschieden sein: Auch endliche Mengen mit

c A = ∅, g A (y, m0, m1) = {y} ∪ m0 ∪ m1 mögliche Algebra

Induktionsformeln

ϕ{x ↦→ c}∧(∀x1, x2 . ϕ{x ↦→ x1}∧ϕ{x ↦→ x2}→ϕ{x ↦→ g(y, x1, x2)})→∀x . ϕ

Induktionsregel

Γ{x ↦→ c} ⇒ ∆{x ↦→ c}

IH1, IH2, Γ{x ↦→ g(y, x1, x2)} ⇒ ∆{x ↦→ g(y, x1, x2)}

Γ ⇒ ∆

mit IHi = ∀y . Γ{x ↦→ xi} → ∆{x ↦→ xi} für i ∈ {1, 2}, y = fvar(Γ ⇒ ∆) \ {x}

A. Knapp, G. Schellhorn: Formale Methoden 136


Regel der strukturellen Induktion

Für Generiertheitsklausel s〈{f1, . . . , fn}〉 strukturelle Induktionsregel

mit

IH1, Γ1 ⇒ ∆1 . . . IHn, Γn ⇒ ∆n

Γ ⇒ ∆

◮ Pro Konstruktor fi : s1 . . . sk → s ∈ C eine Prämisse

Γi ⇒ ∆i = Γ{x ↦→ fi(x1, . . . , xk)} ⇒ ∆{x ↦→ fi(x1, . . . , xk)}

◮ Die Variablen x1, . . . , xk sind dabei neue Argumentvariablen.

◮ Pro Konstruktor fi : s1 . . . sk → s ∈ C eine Induktionshypothese

IHi =

sj=s IH{x ↦→ xj}

für genau die Argumente xj, deren Sorte s ist; wobei

IH = ∀y. Γ → ∆ mit y = fvar(Γ ⇒ ∆) \ {x}

A. Knapp, G. Schellhorn: Formale Methoden 137


Kalkül mit struktureller Induktion

Definition Eine Sequenz Γ ⇒ ∆ ist aus einer elementaren Spezifikation Sp

induktiv ableitbar, geschrieben als Sp ⊢IND Γ ⇒ ∆, wenn sie aus den Axiomen

und den Generiertheitsklauseln von Sp durch Anwendung des

Sequenzenkalküls und der Regel der strukturellen Induktion ableitbar ist.

Satz Die Induktionsregel ist korrekt für jede Algebra, die die entsprechende

Generiertheitsklausel erfüllt. Insbesondere gilt

Sp ⊢IND Γ ⇒ ∆ ⇒ Sp |= Γ ⇒ ∆

Der Kalkül ist nicht vollständig.

A. Knapp, G. Schellhorn: Formale Methoden 138


Wechselseitig rekursive Konstruktoren

Beispiel: Bäume mit endlich vielen Prämissen

◮ Konstruktor für Bäume: mktree : Node Treelist → Tree

◮ Konstruktoren für Baumlisten:

[] : Treelist (leere Liste)

+ : Tree Treelist → Treelist (Element vorne an Liste anhängen)

◮ Konstruktorterme aus

T (({Node, Tree, Treelist}, {mktree, [], +}, ∅), XNode)Tree bzw.

T (({Node, Tree, Treelist}, {mktree, [], +}, ∅), XNode)Treelist

sollen alle Bäume bzw. Baumlisten beschreiben.

◮ Zwei einzelne Generiertheitsklauseln Tree〈{mktree}〉 und Treelist〈{[], +}〉

würden Graphen erlauben, z. B. t = mktree(n, tl), tl = t + []

Ähnlich in Programmiersprachen: Ausdrücke und Listen von Ausdrücken;

Anweisungen und Blöcke

A. Knapp, G. Schellhorn: Formale Methoden 139


Allgemeine Generiertheitsklauseln

Definition Eine allgemeine Generiertheitsklausel G〈C〉 für eine Signatur

Σ = (S, F, P) besteht aus einer Menge von Sorten G ⊆ S und einer endlichen

Menge von Konstruktoren C ⊆ F, wobei die Ergebnissorte jedes f ∈ C eine

Sorte in G ist und für wenigstens ein f ∈ C alle Argumentsorten nicht aus G

sind.

Ein Konstruktorterm t hat eine Sorte aus G, ist mit Konstruktoren gebildet und

enthält nur Variablen von Sorten nicht aus G, ist also aus

T ((S, C, ∅), X \

g∈G Xg)s für ein Sorte s ∈ G.

Definition Eine allgemeine Generiertheitsklausel G〈C〉 gilt über einer

Algebra A, geschrieben als A |= G〈C〉, wenn es für jedes s ∈ G und jedes

a ∈ As eine Belegung v und einen Konstruktorterm

t ∈ T ((S, C, ∅), X \

g∈G Xg)s mit a = T t A v gibt.

Beispiel: Bäume mit endlichen vielen Prämissen

◮ Generiertheitsklausel {Tree, Treelist}〈{mktree, +, []}〉

A. Knapp, G. Schellhorn: Formale Methoden 140


Allgemeine Generiertheitsklauseln: Induktion

Beispiel: Bäume mit endlich vielen Prämissen

◮ Jetzt zwei Induktionsbehauptungen ϕ für Bäume und ψ für Baumlisten.

Induktionsregel

⇒ ψ{tl ↦→ []} ϕ, ψ ⇒ ψ{tl ↦→ t + tl} ψ ⇒ ϕ{t ↦→ mktree(n, tl)}

⇒ ∀t . ϕ ∧ ∀tl . ψ

A. Knapp, G. Schellhorn: Formale Methoden 141


Strukturell-rekursive Definitionen von Funktionen

Dem Induktionsprinzip entspricht die Definition durch strukturelle Rekursion.

Beispiel: Definition von + und ∗ über den natürlichen Zahlen (mit Nat〈{0, s}〉)

plus-base: m + 0 = m plus-rec: m + s(n) = s(m + n)

mult-base: m ∗ 0 = 0 mult-rec: m ∗ s(n) = m ∗ n + m

Axiome folgen dem strukturellen Rekursionsschema

◮ f -base: f (y, 0) = t; f -rec: f (y, s(n)) = t ′

◮ rekursive Position nicht notwendig an letzter Stelle

◮ An rekursiver Position Konstruktor mit Argumentvariablen: 0 bzw. s(n)

◮ Variablen y ∪ {n} paarweise verschieden

◮ var(t) ⊆ y und t enthält kein Vorkommen von f

◮ var(t ′ ) ⊆ y ∪ {n} und t ′ enthält nur Aufrufe von f (u, n) mit Termen u

A. Knapp, G. Schellhorn: Formale Methoden 142


Strukturelle Rekursion und Induktion

◮ Sei f durch strukturelle Rekursion definiert

f -base: f (y, 0) = t f -rec: f (y, s(n)) = t ′

◮ Gegeben sei eine Behauptung ϕ, in der ein Term f (u, x) vorkommt (mit

beliebigen Termen u).

◮ Dann ergibt Induktion über x zwei Prämissen: ϕ{x ↦→ 0}, ϕ{x ↦→ s(x)};

auf die erste ist f -base, auf die zweite f -rec anwendbar.

◮ In KIV: Häufig f -base und f -rec Simplifierregeln

◮ Generelles Vorgehen für induktive Beweise

◮ Suche Variable, die nur an rekursiven Positionen eines f vorkommt.

◮ Induziere über diese Variable, wende jeweils passendes Axiom an.

◮ Umgekehrt: Induktion über Variable, die an keiner rekursiver Position

vorkommt, nicht sinnvoll

◮ Schwieriger: gemischte Fälle (häufig Lemmas, Verallgemeinerung &c.)

A. Knapp, G. Schellhorn: Formale Methoden 143


Strukturell-rekursive Definition von Prädikaten

Beispiel: Definition von even und grt über den natürlichen Zahlen

even-base: even(0) even-rec: even(s(n)) ↔ ¬even(n)

gt-base: gt(0, m) ↔ false gt-rec: gt(s(n), m) ↔ m = n ∨ gt(n, m)

Axiome folgen dem strukturellen Rekursionsschema

◮ p-base: p(y, 0) ↔ ϕ; p-rec: p(y, s(n)) ↔ ϕ ′

◮ An rekursiver Position Konstruktor mit Argumentvariablen: 0 bzw. s(n)

◮ rekursive Position bei gt ist die erste Stelle

◮ Variablen y ∪ {n} paarweise verschieden

◮ fvar(ϕ) ⊆ y und ϕ enthält kein Vorkommen von p

◮ fvar(ϕ ′ ) ⊆ y ∪ {n} und ϕ ′ enthält nur Aufrufe von p(u, n) mit Termen u

A. Knapp, G. Schellhorn: Formale Methoden 144


Strukturelle Rekursion: Beispiele

Listen von natürlichen Zahlen mit List〈{[] : List, + : Nat List → List}〉

◮ Definition von append : List List → List durch

append-base: append([], y) = y

append-rec: append(m + x, y) = m + append(x, y)

◮ Definition von ordered : List

ordered-base: ordered([])

ordered-rec: ordered(m + x) ↔

ordered(x) ∧ (x = [] ∨ ∃n, y . x = n + y ∧ m < n)

◮ Alternativ: Umformung von ordered-rec mit x = [] ∨ ∃n, y . x = n + y zu

ordered-rec1: ordered(m + [])

ordered-rec2: ordered(m + n + y) ↔ m < n ∧ ordered(n + y)

A. Knapp, G. Schellhorn: Formale Methoden 145


Strukturelle Rekursion mit Fallunterscheidung

Listen über Nat mit List〈{[] : List, + : Nat List → List}〉

◮ Definition von remove : Nat List → List durch

remove-base: remove(m, []) = []

remove-rec1: m = n → remove(m, n + x) = remove(m, x)

remove-rec2: m = n → remove(m, n + x) = n + remove(m, x)

◮ Alternative Formulierung von remove-rec1

remove-rec1: remove(m, m + x) = remove(m, x)

Aufspaltung von Basis- oder Rekursionsfall nach Bedingungen

f -rec1: ϕ1 → f (y, n + x) = t1

. . .

f -reck: ϕk → f (y, n + x) = tk

◮ Einschränkungen für Bedingungen ϕi wie für ti

◮ Bedingungen gegenseitig ausschließend und überdeckend ( ϕi ↔ true)

◮ typisch für parameterisierte Datentypen (Listen über . . . , Bäume über . . . )

A. Knapp, G. Schellhorn: Formale Methoden 146


KIV-Simplifier

Beobachtung: Viele Gleichungen und Äquivalenzen dienen zur Vereinfachung

◮ datenstrukturunabhängig: Tautologien wie ϕ ∧ ϕ ↔ ϕ

◮ datenstrukturabhängige Regeln

Beispiel: Natürliche Zahlen

◮ ⊢ n + 0 = n zum Ersetzen von t + 0 durch t

Selbstdefinierte Simplifierregeln

◮ markierte Axiome oder (schon bewiesene) Theoreme

Für das Verständnis von KIV wichtig: Welche Simplifierregel hat welchen Effekt?

A. Knapp, G. Schellhorn: Formale Methoden 147


KIV-Simplifier: Lokale und globale Regeln

Zwei Klassen von Simplifierregeln

◮ lokale Simplifierregeln werden in Beweisen über der Spezifikation, in der

sie definiert sind, benutzt.

◮ globale Simplifierregeln werden in Beweisen in Spezifikationen, die über

der, in der sie definiert sind, benutzt.

Pragmatik

◮ Lokal werden Axiome als Simplifierregeln verwendet.

◮ Global werden Theoreme verwendet, die ” gute“ Simplifierregeln sind.

Eintragen von Theoremen als Simplifierregeln durch used for: s, ls;

nach Sequenz in specification/sequents-Datei

A. Knapp, G. Schellhorn: Formale Methoden 148


KIV-Simplifier: Typen von Simplifierregeln

Termersetzungsregel (Rewriteregel)

◮ Form: Γ ⊢ ϕ → (t = u)

◮ Effekt: (Instanzen von) t durch u ersetzen

Formelersetzungsregel (Äquivalenzregel)

◮ Form: Γ ⊢ ϕ → (ψ ↔ χ)

◮ Effekt: (Instanzen von) ψ durch χ ersetzen

Assoziativität und Kommutativität

◮ Form: ⊢ (a + b) + c = a + (b + c) und ⊢ a + b = b + a

◮ Effekt: Alle anderen Regeln modulo Assoziativität und Kommutativität

anwenden

A. Knapp, G. Schellhorn: Formale Methoden 149


KIV-Simplifier: Pragmatik von Bedingungen (1)

Rewrite- und Äquivalenzregeln haben die Form

Γ ⊢ ϕ → t = u und Γ ⊢ ϕ → (ψ ↔ χ)

Vorbedingungen Γ und ϕ: Als Formel dieselbe Bedeutung, aber unterschiedlich

behandelt:

◮ Γ darf beliebige Formeln enthalten

◮ ϕ muß Konjunktion ϕ1 ∧ . . . ∧ ϕn von Literalen sein

◮ Literal: evtl. negierte Gleichung oder Prädikatformel

◮ (Instanzen von) ϕ1, . . . , ϕn werden in der Sequenz gesucht:

nicht-negierte Formeln im Antezedent, negierte im Sukzedent

◮ Γ wird versucht, durch rekursiven Simplifieraufruf zu beweisen

A. Knapp, G. Schellhorn: Formale Methoden 150


KIV-Simplifier: Pragmatik von Bedingungen (2)

Wann Vorbedingungen in Γ, wann in ϕ1, . . . , ϕn?

◮ Vorbedingungen vor ” ⊢“ in Γ nur,

wenn sie in sinnvollen Sequenzen immer erfüllt sind.

◮ sonst viele nutzlose Simplifieraufrufe

◮ Typische sinnvolle Vorbedingungen: Definiertheitsbedingungen

◮ m −1 (Vorgänger von m) ist nur für m = 0 definiert

◮ m − n ist nur für n ≤ m definiert

◮ .rest und .last sind nur für nichtleere Listen definiert

◮ Arrays: i < #a sollte für Zugriff a[i] immer wahr sein

A. Knapp, G. Schellhorn: Formale Methoden 151


KIV-Simplifier: Beispiele zu Vorbedingungen

◮ n = 0 ⊢ (m < n − 1 ↔ m + 1 < n)

Vorbedingung im Antezedent, da 0 − 1 nicht sinnvoll ist

◮ ⊢ m < n → (n < m + 2 ↔ m + 1 = n)

Vorbedingung nicht im Antezedent, sonst, sobald Instanzen von

n < m + 2 vorkommen: viele unnötige Beweisversuche für m < n

◮ m ≤ n ⊢ (n − m) + m = n

beweist z. B. die Sequenz

f(x) > 5 ⊢ (f(x) − 3) + 3 = f(x)

(da der Simplifier f(x) > 5 ⊢ 3 ≤ f(x) beweisen kann)

⊢ m ≤ n → (n − m) + m = n

beweist die Sequenz nicht, da 3 ≤ f(x) nicht in der Sequenz vorkommt

A. Knapp, G. Schellhorn: Formale Methoden 152


KIV-Simplifier: Rewrite-Regeln

Γ ⊢ ϕ → t = u

ersetzt (Instanzen von) t durch u, wenn Vorbedingungen gelten

◮ fvar(ϕ) ∪ var(t) muß alle freien Variablen abdecken

◮ t und u müssen Terme sein, t darf keine Variable sein

Beispiele:

◮ ⊢ (m + n) − n = m

◮ ⊢ i > 0 → sqrt(iˆ2) = i (i Ganzzahl)

◮ ⊢ (s1 ∪ s2) \ s2 = s1 \ s2 (Mengen)

◮ ⊢ y = [] → append(x, y).last = y.last (Listen)

A. Knapp, G. Schellhorn: Formale Methoden 153


KIV-Simplifier: Äquivalenzregeln

Γ ⊢ ϕ → (ψ ↔ χ)

ersetzt (Instanzen von) ψ durch χ, wenn Vorbedingungen gelten

◮ fvar(ϕ) ∪ fvar(ψ) muß alle freien Variablen abdecken

◮ ψ muß Prädikat oder Gleichung sein, χ ist beliebige Formel

◮ Vereinfachung: falls ψ keine Gleichung, statt (ψ ↔ true) nur ψ

◮ Vereinfachung: statt (ψ ↔ false) nur ¬ ψ

Beispiele:

◮ ⊢ sorted([a]), #(x) = 0 ↔ x = [] (Listen)

◮ ⊢ m + n < m + n0 ↔ n < n0

◮ ⊢ n = 0 ⊢ (m < n −1 ↔ m +1 < n)

A. Knapp, G. Schellhorn: Formale Methoden 154


KIV-Simplifier: Äquivalenzregeln mit Konjunktion, Disjunktion

Äquivalenzregel ⊢ a ∈ s1 ∪ s2 ↔ a ∈ s1 ∨ a ∈ s2 führt auf

Γ ⊢ a ∈ s1, a ∈ s2, ∆

Γ ⊢ a ∈ s1 ∪ s2, ∆

Γ, a ∈ s1 ⊢ ∆, a ∈ s2

Γ, a ∈ s1 ∪ s2 ⊢ ∆, a ∈ s2

Γ, a ∈ s2 ⊢ ∆, a ∈ s1

Γ, a ∈ s1 ∪ s2 ⊢ ∆, a ∈ s1

Kein Effekt auf Γ1, a ∈ s1 ∪ s2, Γ2 ⊢ ∆ (wenn a ∈ s1 und a ∈ s2 nicht in ∆)

◮ Verschachtelte aussagenlogische Ausdrücke schwer zu lesen

Dasselbe, falls χ in Äquivalenzregel Γ ⊢ ϕ → (ψ ↔ χ) eine Konjunktion (mit

Antezedent und Sukzendent vertauscht); z. B.

⊢ a ∈ s1 ∩ s2 ↔ a ∈ s1 ∧ a ∈ s2

A. Knapp, G. Schellhorn: Formale Methoden 155


KIV-Simplifier: Weitere Äquivalenzregeln

◮ Wenn in Γ ⊢ ϕ → (ψ ↔ χ) das χ keine Konjunktion oder Disjunktion ist,

wird immer ersetzt

◮ Deshalb: Die Regel

⊢ a ∈ s1 ∪ s2 ↔ ¬ ¬(a ∈ s1 ∨ a ∈ s2)

umgeht den Effekt der Disjunktion (nur selten verwendet)

◮ Regel, die nur auf ψ (Prädikat oder Gleichung) im Antezedent angewandt

wird:

Γ ⊢ ϕ → (¬ ¬ ψ ↔ ¬ χ)

◮ Regel, die nur auf ψ im Sukzedent angewandt wird:

Γ ⊢ ϕ → (¬ ψ ↔ χ)

A. Knapp, G. Schellhorn: Formale Methoden 156


KIV-Simplifier: Pragmatik für einseitige Regeln

Verwendung von ⊢ ϕ → ψ als Simplifierregel, wobei ϕ komplexe Formel, ψ

einfache, schwächere Formel

Beispiel: ⊢ prime(n) → n > 1

◮ Direkte Verwendung als Simplifierregel ergibt:

◮ Beweisziele prime(n), Γ ⊢ n > 1, ∆ werden geschlossen

◮ Aus Beweiszielen prime(n), n > 1, Γ ⊢ ∆ wird n > 1 gelöscht

◮ Letzteres ist unerwünscht, da n > 1 evtl. eine nützliche Vorbedingung ist.

◮ Deshalb besser: ⊢ prime(n) → (¬ n > 1 ↔ false)

Beispiel: ⊢ prime(n) ∧ n = 2 → ¬ even(n) (ψ negiert)

◮ Besser: ⊢ prime(n) ∧ n = 2 → (¬ ¬ even(n) ↔ false)

A. Knapp, G. Schellhorn: Formale Methoden 157


KIV-Simplifier: Beispiele für Äquivalenzregeln

◮ ⊢ m ≤ n → (n < m ↔ false)

◮ beweist m ≤ n, n < m, Γ ⊢ ∆

◮ entfernt in m ≤ n, Γ ⊢ n < m, ∆ das n < m

◮ ⊢ (s1 \ s2) \ s3 = (s1 \ s3) \ s2 ↔ true

◮ beweist Gleichung im Sukzedent, entfernt sie im Antezedent

◮ ⊢ s ∩ s0 = ∅ ∧ a ∈ s → ¬ a ∈ s0 als Simplifierregel

◮ In Sequenz s ∩ s0 = ∅, a ∈ s ⊢ a ∈ s0 nicht das a ∈ s0 durch false

ersetzen (und damit entfernen). Nur im Antezedent auf

s ∩ s0 = ∅, a ∈ s, a ∈ s0 anwenden und damit Sequenz schließen

◮ Damit besser: ⊢ s ∩ s0 = ∅ ∧ a ∈ s → (¬ ¬ a ∈ s0 ↔ false)

A. Knapp, G. Schellhorn: Formale Methoden 158


KIV-Simplifier: Kommutativität und Assoziativität

◮ Assoziative und kommutative Operatoren: +, ·, min, ggT auf ganzen

Zahlen, ∪, ∩ auf Mengen, . . .

◮ Assoziative Operatoren: append auf Listen, · auf Matrizen, . . .

Simplifierregeln:

◮ Kommutativität: ⊢ m + n = n + m, kurz: C(+)

◮ Assoziativität: ⊢ (m + n) + k = n + (m + k), kurz: A(+)

◮ für assoziativ und kommutativ kurz AC(+)

◮ A, C, AC werden nicht direkt verwendet; ob eine Simplifierregel paßt, wird

Beispiele:

” modulo“ dieser Regeln geprüft

◮ ⊢ a + b ∗ c = c ∗ b + a wird mit C(+, ∗) sofort (per Reflexivität)

bewiesen.

◮ ⊢ b ∗ c ≤ (c ∗ a) ∗ b wird für AC(∗) mit der Regel ⊢ m ≤ m ∗ n bewiesen.

A. Knapp, G. Schellhorn: Formale Methoden 159


KIV-Simplifier: Regeln für Zahlen

◮ Zahlen in KIV vordefiniert:

◮ für die Sorte nat: 0, 1, 2, . . .

◮ für die Sorte int: . . . , ∼2, ∼1, 0, 1, 2, . . .

◮ Implizite Regeln in KIV: Summen, Differenzen,


KIV-Simplifier: Forwardregeln

Hinzufügung abgeleiteter Information zu Sequenzen

◮ Transitivität von Ordnungs- und Äquivalenzrelationen:

⊢ m < n ∧ n < n0 → m < n0

⊢ isperm(x, y) ∧ isperm(y, z) → isperm(x, z)

Forward-Regeln der Form

Γ ⊢ ϕ1 ∧ . . . ∧ ϕn → ψ

◮ Lokale und globale Regeln wie bei Simplifierregeln

Deklaration als used for: f, lf;

◮ Vorbedingungen werden wie bei Simplifierregeln behandelt.

◮ ψ wird genau einmal zur Sequenz hinzugefügt.

A. Knapp, G. Schellhorn: Formale Methoden 161


KIV-Simplifier: Pragmatik von Forwardregeln

◮ Transitivität unkritisch

◮ Häufig etliche Varianten notwendig

⊢ m < n ∧ n ≤ n0 → m < n0

⊢ m < n ∧ ¬n0 < n → m < n0

⊢ m ≤ n + 1 ∧ n < n0 → m ≤ n0

◮ Forward-Regeln führen leicht zu Endlosschleifen im Simplifier

◮ z. B. ⊢ m < n → m < n + 1

◮ Ein Lemma sollte nie Forward- und Simplifierregel sein.

◮ Forwardregeln auch mit Zahlen

0 < n ⊢ (∗ n) ≤ m → m = 0

A. Knapp, G. Schellhorn: Formale Methoden 162


Automatisierung in KIV: Heuristiken

◮ Flexible Automatisierung ist zentral, um bei großen Fallstudien nicht immer

wieder die gleichen Beweisschritte wiederholen zu müssen

◮ Deshalb in KIV: Automatisierung durch zuschaltbare Heuristiken

◮ Simplifier eine Heuristik; sollte man (fast) immer benutzen

◮ Für jedes Beweisziel werden alle Heuristiken der Reihen nach ausprobiert

◮ gewählte Heuristiken jederzeit änderbar

Für das Verständnis von KIV wichtig: Welche Heuristik hat welchen Effekt?

A. Knapp, G. Schellhorn: Formale Methoden 163


Wichtige Heuristiken für PL in KIV (1)

◮ Simplifier

◮ wendet die Simplifier-Regel an

◮ PL case distinction

◮ wendet Regel case distinction an

◮ für einfache bis mittelschwere Beweise

◮ Gefahr, unnötige Fallunterscheidungen zu machen

◮ if-then-else-Split

◮ if-then-else-Operator: (ϕ ⊃ σ; τ ) bezeichnet σ, falls ϕ wahr ist, sonst τ

◮ wendet (Cut)-Regel mit ϕ an

◮ Häufig einsetzbar, um sinnvolle Fallunterscheidungen zu erzwingen

◮ Beispiel: Fallunterscheidung nach Anwendung von Rewrite-Regel

abs(i) = (i ≥ 0 ⊃ i; −i)

A. Knapp, G. Schellhorn: Formale Methoden 164


Wichtige Heuristiken für PL in KIV (2)

◮ Quantifier closing

◮ Sucht Instanzen, mit denen eine Prämisse direkt geschlossen werden kann

◮ immer verwenden

◮ einziges Problem: bei sehr vielen Quantoren braucht die Heuristik viel

unnötige Zeit

◮ deshalb Spezifikationsmethodik: Prädikat (& Simplifierregeln) definieren,

statt große Quantorenformeln zu verwenden

◮ Quantifier

◮ Sucht ” sinnvolle“ Instanzen für Quantoren

◮ kann Endlosschleifen verursachen!

◮ nur bei einfachen Quantorenbeweisen einsetzbar

A. Knapp, G. Schellhorn: Formale Methoden 165


Wichtige Heuristiken für PL in KIV (3)

◮ Structural induction

◮ Macht strukturelle Induktion über ” sinnvolle“ Terme

◮ Idee für ” sinnvoll“: Variablen an rekursiven Positionen:

n ist sinnvoll in m + n, da + rekursiv über das zweite Argument definiert:

m + 0 = m, m + (n +1) = (m + n) +1

◮ Funktioniert meistens, aber nicht immer

◮ Module specific

◮ eigentlich eine Meta-Heuristik: erlaubt heuristische Anwendung von Regeln

durch Patterns

◮ Pattern: Gibt Formeln (oder Schemata für Formeln) an, die in der Sequenz

vorkommen müssen bzw. nicht vorkommen dürfen & Regel die angewandt

werden soll

◮ Alle Patterns stehen in der Datei module-specific

A. Knapp, G. Schellhorn: Formale Methoden 166


Heuristiksätze in KIV

◮ In KIV drei vordefinierte Heuristiksätze:

◮ PL Heuristics: minimale Menge sinnvoller Heuristiken

◮ PL Heuristics + Case Splitting: Keine Induktion, FU automatisch

◮ PL Heuristics + Struct. Ind.: versucht Ziel induktiv zu beweisen und

Fallunterscheidungen (FU) automatisch zu machen

◮ Standardüberlegung zur Wahl des Heuristiksatzes:

◮ Ist der Beweis induktiv?: Wenn ja, PL Heuristics + Struct. Ind.

◮ Wenn nein, sind die Fallunterscheidungen im Beweis ungefähr die, die sich

aus den aussagenlog. Verknüpfungen der Sequenz ergeben?

◮ Wenn ja, PL Heuristics + Case Splitting, sonst nur PL Heuristics

◮ Für größere Projekte definiert man häufig seinen eigenen Standardsatz (in

Datei default-heuristics)

◮ Weitere Heuristiken für Programme; dort noch wichtiger, da Programme

mehr Struktur haben.

A. Knapp, G. Schellhorn: Formale Methoden 167


Natürliche Zahlen: Peano-Axiom 5 vs. Induktion

Induktionsaxiom codiert (P5) für ΣNat-Formeln ϕ

◮ Induktionsaxiom: ϕ{n ↦→ 0} ∧ (∀n . ϕ → ϕ{n ↦→ s(n)}) → ∀n . ϕ

◮ Instanz von (P5) für X = {n | ϕ(n)}

(P5) spricht über alle Teilmengen von N

◮ Es gibt nur abzählbar viele Formeln.

◮ Zeichenketten sind numerierbar, z. B. durch ASCII-Code.

◮ Die Teilmengen von N sind nicht abzählbar:

◮ Angenommen X0, X1, X2, . . . wäre eine Aufzählung der Teilmengen.

◮ Setze X = {k | k ∈ Xk}.

◮ Dann kommt X nicht in der Aufzählung vor; Widerspruch.

Gibt es eine konsistente, entscheidbare Menge von Axiomen, sodaß alle

wahren Formeln über N bewiesen werden können?

A. Knapp, G. Schellhorn: Formale Methoden 168


Natürliche Zahlen ohne Multiplikation

Satz Die Formeln über den natürlichen Zahlen mit 0, +, < sind

entscheidbar.

Ohne Beweis (Moj˙zsez Presburger 1929)

◮ keine Multiplikation

◮ Aufwand doppelt exponentieller in der Länge der Formel

Lineare Arithmentik erfordert keine Kreativität, nur viel Rechenaufwand

◮ Entscheidbarkeit gilt nur ohne weitere Funktionen.

◮ Entscheidungsprozeduren auch für andere ” einfache“ Datentypen

◮ verwendet etwa in PVS, automatischen Theorembeweisern

◮ Kombination mehrerer Entscheidungsprozeduren und mit zusätzlichen

Funktionen schwierig (Verfahren von Nelson und Oppen, 1979)

A. Knapp, G. Schellhorn: Formale Methoden 169


Gödelscher Unvollständigkeitssatz (1)

Satz Es gibt keine konsistente, entscheidbare Menge von Formeln über

(0, s, +, ·), die (P1–4) und n = 0 → ∃m . n = s(m) enthält oder impliziert, mit

der sich alle in N wahren Aussagen ableiten lassen.

◮ Satz von Kurt Gödel (1930)

◮ Unvollständigkeit einer Axiomenmenge (für N) heißt, daß nicht alle wahren

Aussagen über N bewiesen werden können.

◮ Ein Kalkül heißt vollständig, wenn alle in allen Modellen wahren Aussagen

bewiesen werden können.

A. Knapp, G. Schellhorn: Formale Methoden 170


Gödelscher Unvollständigkeitssatz (2)

Beweisskizze Zunächst: Für einen Algorithmus und eine Numerierung seiner Einund

Ausgabedaten läßt sich eine Formel α(x, y) über 0, s, + und · angeben mit:

α(s m (0), s n (0)) gilt genau dann, wenn der Algorithmus mit Eingabe Nummer m die

Ausgabe Nummer n liefert.

◮ Intuitiv: ” Jeder Algorithmus kann in eine Zahlenrechnung codiert werden.“

Formeln und Beweisbäume sind numerierbar; Ableitbarkeit und Substitution sind

Algorithmen.

◮ Es gibt eine Formel Abl(x) mit: Abl(s n (0)) gilt genau dann, wenn die Formel

Nummer n ableitbar ist.

◮ Es gibt eine Formel Subst(x, y) mit: Subst(s m (0), s n (0)) gilt genau dann, wenn die

Formel Nummer n aus der Formel Nummer m mit Ersetzung der freien Variablen

durch s m (0) entsteht.

Setze G(x) = ∀y . Subst(x, y) → ¬Abl(y). Die Formel habe Nummer k.

◮ Die Gödelformel G(s k (0)) sagt: ” Die Formel mit meiner Nummer ist nicht

ableitbar“. (Instanz des Lügnerparadoxons)

◮ Diese Formel ist nicht ableitbar, aber wahr.

A. Knapp, G. Schellhorn: Formale Methoden 171


Gödelscher Unvollständigkeitssatz (3)

Es gibt keine ” gute“ Axiomenmenge, mit der alle wahren Aussagen über N

herleitbar sind.

◮ Induktionsaxiome reichen nicht, um alle wahren Aussagen zu finden.

◮ Die Menge der wahren Aussagen über N wäre aussreichend, ist also nicht

entscheidbar.

◮ Scheitern des Hilbertschen Programms, die Mathematik auf ” einfachen“

Grundlagen aufzubauen

Für praktische Beweise ist die Gödelformel wenig relevant.

A. Knapp, G. Schellhorn: Formale Methoden 172


Ω-Kalkül

Für eine Signatur Σ = (S, F, P) und eine Generiertheitsklausel s〈C〉 ∈ G (Σ)

Ω-Regel

(⇒ ϕ{x ↦→ t}) t∈T ((S,C,∅),X\Xs)s

⇒ ϕ

◮ Ω-Regel hat i. A. unendlich viele Prämissen, deshalb auf Rechnern nicht

implementierbar

Definition Eine Sequenz Γ ⇒ ∆ ist aus einer elementaren Spezifikation Sp

Ω-ableitbar, geschrieben als Sp ⊢ω Γ ⇒ ∆, wenn sie aus den Axiomen und

den Generiertheitsklauseln von Sp durch Anwendung des Sequenzenkalküls

und der Ω-Regeln für jede Generiertheitsklausel ableitbar ist.

◮ Beweisbäume sind endlich hoch aber unendlich breit: Infinitärer Kalkül

A. Knapp, G. Schellhorn: Formale Methoden 173


Ω-Kalkül: Korrektheit und Vollständigkeit

Satz Für eine Formel ϕ und eine elementare Spezifikation Sp gilt

Sp ⊢ω ϕ ⇔ Sp |= ϕ

◮ Wenn man von der Ableitbarkeit von ϕ(0), ϕ(s(0)), ϕ(s(s(0))), . . . auf

∀n . ϕ(n) schließen darf, reicht das aus, um die natürlichen Zahlen als

” minimale Menge“ zu charakterisieren.

◮ Das Problem ist also lediglich, daß manchmal der Beweis nicht per

Induktion geht: ϕ(n) → ϕ(s(n)) ist nicht immer beweisbar.

A. Knapp, G. Schellhorn: Formale Methoden 174


Beinahe-Vollständigkeit der strukturellen Induktion (1)

Spezifikation von x from a: Liste x ab dem erstem Vorkommen des Elements a

(exklusiv); falls a in x nicht vorkommt, die leere Liste.

specification

sorts elem; list;

constants [] : list;

functions . + . : elem × list → list;

. from . : list × elem → list;

induction list generated by [], +;

variables a, b : elem;

x, y : list;

axioms [] = a + x; x = y → a + x = b + y;

[] from a = [];

(a + x) from a = x;

a = b → (b + x) from a = x from a;

end specification

Spezifikation monomorph modulo der Elemente; genau eine Listenfunktion

from

A. Knapp, G. Schellhorn: Formale Methoden 175


Beinahe-Vollständigkeit der strukturellen Induktion (2)

◮ Für die Funktion from gilt ∀x . ϕ mit ϕ(x) = x = [] → x from a = x

◮ Es lassen sich ϕ([]), ϕ(b + []), . . . beweisen:

[] = [] → [] from a = []

b + [] = [] → (b + []) from a = b + []

b + c + [] = [] → (b + c + []) from a = b + c + []

b + c + d + [] = [] → (b + c + d + []) from a = b + c + d + []

. . .

◮ Aber: Induktionsschluß x from a = x → (b + x) from a = b + x nicht

durchführbar

◮ Man muß die Aussage für Induktion verallgemeinern:

x = [] → x from a < x

x = [] → #(x from a) < #x

◮ Dazu neues Prädikat < (ist Endstück) oder neue Funktion # (Länge)

notwendig; beide können rekursiv definiert werden

A. Knapp, G. Schellhorn: Formale Methoden 176


Beinahe-Vollständigkeit der strukturellen Induktion (3)

Im allgemeinen benötigt man für ein ϕ mit Sp |= ϕ eine Erweiterung Sp ′ von Sp

um neue, rekursiv definierte Funktionen, damit Sp ′ ⊢IND ϕ gilt.

◮ Die Induktions-Regel ist nicht vollständig, manchmal ist ϕ(n) → ϕ(s(n))

nicht beweisbar.

◮ In diesem Fall muß man die Behauptung verallgemeinern: Die

zusätzlichen Symbole von Sp ′ machen eine passend verallgemeinerte

Induktionshypothese ψ für den Beweis von ϕ ausdrückbar:

Sp ′ ⊢IND ψ(x) → ϕ(x) und Sp ′ ⊢IND ψ(n) → ψ(s(n))

◮ Die Erweiterung Sp ′ ist je nach ϕ verschieden (kein uniformes Sp ′ ).

◮ In jedem Sp ′ gibt es eine Formel ϕ ′ , die wahr aber nicht ableitbar ist.

◮ Kreativitität also für Verallgemeinerung und passende Hilfsfunktionen

A. Knapp, G. Schellhorn: Formale Methoden 177


Spezifikation von Datentypen

Vorgehen

◮ Definition der benötigten Sorten

◮ Definition der Konstruktoren und Generiertheitsklauseln

◮ Datentypen auf Rechnern generiert

◮ Definition weiterer Operationen und Axiome

◮ Keine Einführung von Inkonsistenzen, möglichst monomorphe

Charakterisierung

A. Knapp, G. Schellhorn: Formale Methoden 178


Freie und nichtfreie Datentypen

Manche Datentypen sind frei erzeugt: Zwei verschiedene Konstruktorterme

repräsentieren auch immer zwei verschiedene Elemente.

nat freely generated by 0, +1

nat generated by 0, 1, + 0 + 0 = 0

list freely generated by [], +

integer generated by 0, +1, −1 0 +1 −1 = 0

set generated by ∅, ins ins(a, ins(a, ∅)) = ins(a, ∅)

set generated by ∅, {.}, ∪ {a} ∪ {a} = {a}

stack freely generated by empty, push

bintree freely generated by mkleaf, mkbranch

graph generated by ∅, +node, +edge ∅ +node n +node n =

∅ +node n

array generated by mkar, put put(put(mkar(n), i, d), i, d) =

put(mkar(n), i, d)

A. Knapp, G. Schellhorn: Formale Methoden 179


Freie Erzeugtheitsklauseln

Definition Eine freie Generiertheitsklausel G 〈C 〉 für eine Signatur

Σ = (S, F, P) besteht aus einer Menge von Sorten G ⊆ S und einer endlichen

Menge von Konstruktoren C ⊆ F, wobei die Ergebnissorte jedes f ∈ C eine

Sorte G ist und für wenigstens ein f ∈ C alle Argumentsorten nicht Sorten aus

G sind.

Definition Eine freie Generiertheitsklausel G 〈C 〉 gilt über einer Algebra A,

geschrieben als A |= G 〈C 〉, wenn A |= G〈C〉 gilt, für jedes f ∈ C die Funktion

f A injektiv ist, und für f : s1 . . . sn → s, f ′ : s ′ 1 . . . s′ n ′ → s mit f = f ′ ∈ C, s ∈ G

und a1 ∈ As1 , . . . , an ∈ Asn , a′ 1 ∈ A s ′ 1 , . . . , a′ n ′ ∈ As n ′ gilt:

f A (a1, . . . , an) = f ′A (a ′ 1 , . . . , a′ n ′).

Insbesondere sind Terme mit verschiedenen Konstruktoren immer verschieden.

A. Knapp, G. Schellhorn: Formale Methoden 180


Axiome für freie Datentypen

Beispiel: Konstante c, einstellige Funktion f, zweistellige Funktion g

◮ Verschiedenheit der Konstruktoren c, f und g:

c = f(x), f(x) = g(y, z), c = g(x, y)

◮ Injektivität der Konstruktoren:

f(x) = f(y) ↔ x = y, g(x, y) = g(u, v) ↔ x = u ∧ y = v

A. Knapp, G. Schellhorn: Formale Methoden 181


Freie Generiertheitsklauseln als Abkürzung

Satz Es gilt A |= G 〈C 〉 genau dann, wenn

◮ A |= G〈C〉

◮ Für alle f ∈ C gilt A |= f (x) = f (y) ↔x = y.

◮ Für alle f = g ∈ C mit derselben Zielsorte gilt A |= f (x) = g(y).

Freie Generiertheit ist also durch Axiome und Generiertheit ausdrückbar.

In KIV:

◮ G freely generated by C für G 〈C 〉

◮ G freely generated by C als Abkürzung; daraus werden die Axiome

für freie Generiertheit erzeugt.

A. Knapp, G. Schellhorn: Formale Methoden 182


Freie Datentypen: Beispiele (1a)

Wochentage

Weekday = specification

sorts weekday;

constants Mon, Tue, Wed, Thu, Fri, Sat, Sun : weekday;

induction weekday freely generated by

Mon, Tue, Wed, Thu, Fri, Sat, Sun;

variables w : weekday;

end specification

Generierte Axiome:

◮ Die Konstanten Mon, Tue, Wed, . . . sind paarweise verschieden:

Mon = Tue, Mon = Wed, Mon = Thu, Mon = Fri, . . .

A. Knapp, G. Schellhorn: Formale Methoden 183


Freie Datentypen: Beispiele (1b)

Induktionsregel für die Sorte weekday

Γ{w ↦→ Mon} ⇒ ∆{w ↦→ Mon} . . . Γ{w ↦→ Sun} ⇒ ∆{w ↦→ Sun}

Γ ⇒ ∆

Damit: Beweise durch Fallunterscheidung nach dem Tag

◮ Verallgemeinerung: Aufzählungstypen

A. Knapp, G. Schellhorn: Formale Methoden 184


Freie Datentypen: Beispiele (2a)

Paare

Pair = specification

sorts elem1, elem2, pair;

functions mkpair : elem1 × elem2 → pair;

induction pair freely generated by mkpair;

variables a, a1, a2 : elem1; b, b1, b2 : elem2; p : pair;

end specification

Generiertes Axiom:

mkpair(a1, b1) = mkpair(a2, b2) ↔ a1 = a2 ∧ b1 = b2

A. Knapp, G. Schellhorn: Formale Methoden 185


Freie Datentypen: Beispiele (2b)

Induktionsregel für die Sorte pair

Γ{p ↦→ mkpair(a, b)} ⇒ ∆{p ↦→ mkpair(a, b)}

Γ ⇒ ∆

Damit: Variable p expandiert zu mkpair(a, b)

◮ Verallgemeinerung: Tupel

A. Knapp, G. Schellhorn: Formale Methoden 186


Freie Datentypen: Beispiele (3)

Natürliche Zahlen

Nat = specification

sorts nat;

constants 0 : nat;

functions . +1 : nat → nat;

induction nat freely generated by 0, +1;

variables n : nat;

end specification

Axiome für natürliche Zahlen daraus generiert

A. Knapp, G. Schellhorn: Formale Methoden 187


Freie Datentypen: Beispiele (4a)

Listen

List = specification

sorts list, elem;

constants [] : list;

functions . + . : elem × list → list;

induction list freely generated by [], +;

variables a, b : elem; l, l1, l2 : list;

end specification

Generierte Axiome:

[] = a + l,

a + l1 = b + l2 ↔ a = b ∧ l1 = l2

A. Knapp, G. Schellhorn: Formale Methoden 188


Freie Datentypen: Beispiele (4b)

Induktionsregel für die Sorte list

Γ{l ↦→ []} ⇒ ∆{l ↦→ []}

∀y . Γ → ∆, Γ{l ↦→ a + l} ⇒ ∆{l ↦→ a + l}

wobei y = fvar(Γ ⇒ ∆) \ {l}

Γ ⇒ ∆

A. Knapp, G. Schellhorn: Formale Methoden 189


KIV: Data Specifications

Häufige Situation:

◮ freie Generiertheit mit Konstruktoren c

◮ Selektoren, die aus c(x1, . . . , xn) die xi auswählen

◮ Testprädikate ” ist mit Konstruktor c gebildet“

◮ Ordnung ” ist Unterterm von“

◮ Größenfunktion ” Anzahl nichtkonstanter Konstruktoren“

Für Datendefinitionen eigenes KIV-Syntaxkonstrukt data specification

zur Vermeidung unnötiger Schreibarbeit

A. Knapp, G. Schellhorn: Formale Methoden 190


KIV-Data Specifications: Beispiele (1)

Wochentage

Weekday = data specification

weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun;

variables w : weekday;

end data specification

Axiome für freie Generiertheit (Mon = Tue, &c.) werden wie bei einem

freely generated by erzeugt.

A. Knapp, G. Schellhorn: Formale Methoden 191


KIV-Data Specifications: Beispiele (2)

Paare

Pair = data specification

using Elem1, Elem2;

pair = mkpair (. .1 : elem1; . .2 : elem2);

variables p : pair;

end data specification

Für jeden Selektor wird ein Axiom generiert:

mkpair(a, b).1 = a

mkpair(a, b).2 = b

A. Knapp, G. Schellhorn: Formale Methoden 192


KIV-Data Specifications: Beispiele (3)

Natürliche Zahlen

Nat = data specification

nat = 0 | . +1 (. −1 : nat);

order predicates . < . : nat × nat;

variables k, m, n : nat;

end data specification

Neues Axiom für den Selektor −1 (0 −1 ist nicht spezifiziert)

n +1 −1 = n

Neue Axiome für das Prädikat < (strukturell-rekursive Definition)

¬m < 0

m < n +1 ↔ (m = n ∨ m < n)

Irreflexivität und Transitivität werden auch generiert (könnte man beweisen)

¬n < n

m < n ∧ n < k → m < k

A. Knapp, G. Schellhorn: Formale Methoden 193


KIV-Data Specifications: Beispiele (4a)

Listen

List = data specification

using Nat, Elem;

list = [] with nilp

| . + . (. .first : elem; . .rest : list) with consp;

order predicates . ≪ . : list × list;

(: ist Unterterm für Listen: ist Endstück :)

size functions length : list → nat;

variables l : list;

end data specification

A. Knapp, G. Schellhorn: Formale Methoden 194


Partielle Funktionen

Anwendung eines Selektors auf einen falschen Summanden

◮ Was sind [].first und [].rest?

◮ Ähnlich für 0 −1 oder n/0 (natürliche Zahlen) oder

“Out-of-bounds”-Zugriffe a[i] für Arrays

Allgemeiner: Behandlung partieller Funktionen

◮ Prädikatenlogik kennt keine partiellen Funktionen

◮ Mehrere Möglichkeiten: Erweiterung der Logik, Unterspezifikation,

Fehlerelemente, . . .

A. Knapp, G. Schellhorn: Formale Methoden 195


Unterspezifikation

◮ [].rest und n/0 bleiben unspezifiziert

◮ Vorteil: kein unnötiger Overhead

◮ Konsequenz: [].rest muß irgendeine Liste sein, da Funktion total

◮ Die Spezifikation ist dann nicht monomorph:

In Modell A: T [].rest A = [].

In Modell B: T [].rest B = [a] mit einem Element a.

In Modell C: T [].rest C = [b] mit einem Element b = a.

◮ Konsequenz: Wenn [].rest bzw. n/0 in Programmen aufgerufen wird,

dann muß

◮ entweder die Implementierung irgendeine Liste/Zahl zurückgeben (und

keine Exception auslösen)

◮ oder in der Programmsemantik dieser Fall speziell behandelt werden (bei

Exceptions muß das sowieso sein, Programmabbruch geht einfacher)

A. Knapp, G. Schellhorn: Formale Methoden 196


KIV-Data Specifications: Beispiele (4b)

Neue Axiome für List

◮ Axiome für nilp und consp (eines pro Konstruktur)

nilp([]) ¬nilp(a + l)

¬consp([]) consp(a + l)

◮ Axiome für die Selektoren (je eines pro Verwendung)

(a + l).first = a kein Axiom für [].first

(a + l).rest = l kein Axiom für [].rest

◮ Axiome für das Ordnungsprädikat ” ist Endstück“ (strukt.-rek. Def.)

¬l ≪ [] l ≪ (a + l1) ↔ l = l1 ∨ l ≪ l1

¬l ≪ l l1 ≪ l2 ∧ l2 ≪ l3 → l1 ≪ l3

beweisbar, aber der Einfachheit halber generiert

◮ Axiome für die Größenfunktion ” Länge“ (zählt nur nicht-konst. Konstr.)

length([]) = 0 length(a + l) = length(l) +1

A. Knapp, G. Schellhorn: Formale Methoden 197


KIV-Kalkül: Elimination für Selektoren

◮ Listen haben (Postfix-)Selektoren

◮ .first (erstes Element)

◮ .rest (Rest der Liste)

◮ Beseitigung von Selektoren mit Hilfe von (insert elim lemma)

◮ Benötigt wird Lemma

⊢ x = [] → a = x.first ∧ y = x.rest ↔ x = a + y

◮ Eliminationsregel sucht einen Term t.first oder t.rest

◮ Wenn t = [] gilt, wird t = a + y ersetzt (neue Variablen a, y)

◮ Damit wird aus t.first bzw. t.rest jetzt a bzw. y

t = a + y, Γ(a, y, a + y) ⊢ ∆(a, y, a + y)

t = [], Γ(t.first, t.rest, t) ⊢ ∆(t.first, t.rest, t)

A. Knapp, G. Schellhorn: Formale Methoden 198


KIV-Kalkül: Elimination für andere Funktionen

◮ Manchmal geht Elimination auch für andere ” unbeliebte“ Funktionen, etwa

Minus und Division

◮ Lemma für Minus: n ≤ m ⊢ n0 = m − n ↔ m = n0 + n

◮ Vorteil: Man kann auf Simplifierregeln für − verzichten

◮ Nachteil: Neue Variable n0 wird eingeführt (manchmal unintuitiv)

Γ(n0 + n, n, n0) ⊢ ∆(n0 + n, n, n0)

n ≤ m, Γ(m, n, m − n) ⊢ ∆(m, n, m − n)

◮ KIV-Heuristik Elimination gesteuert durch Eliminationsregeln

(analog zu: Simplifier durch Simplifierregeln)

◮ KIV-Eingabe analog zu Simplifierregeln: used for: e; &c.

A. Knapp, G. Schellhorn: Formale Methoden 199


KIV-Data Specifications: Beispiele (5)

◮ Bäume (gegenseitig rekursive Definition) und Binärbäume sind freie

Datentypen.

◮ Abstrakte Syntaxbäume von Sprachen sind freie Datentypen.

◮ Auch Terme und Formeln sind freie Datentypen:

formula = . = . ( . .term1 : term; . .term2 : term)

| ∀ . . . ( . .var : var; . .fma : formula)

| ...

A. Knapp, G. Schellhorn: Formale Methoden 200


KIV-Data Specifications: Allgemeine Form (1)

Eine KIV-Datentyp-Definition hat die Form (optionales in eckigen Klammern)

s = c1(σ1,1 : s1,1; . . . ; σ1,n1 : s1,n1 ) [with p1]

| . . .

| ck(σk,1 : sk,1; . . . ; σk,nk : sk,nk ) [with pk];

◮ Überladene Selektoren: σi,j = σi ′ ,j ′ erlaubt, falls si,j = si ′ ,j ′,

ansonsten alle Operationen paarweise verschieden

A. Knapp, G. Schellhorn: Formale Methoden 201


Datentyp-Definitionen in Java

abstract class s {

}

/* Subklasse für Konstruktor c1 */

class c1 extends s {

s11 sel11; // ein Feld pro Selektor

s12 sel12;

...

}

/* Konstruktor */

public c1(s11 sel11, s12 sel12, ...) {

this.sel11 = sel1; this.sel12 = sel12; ...

}

/* Subklasse für Konstruktor c2 */

class c2 extends s {

...

}

A. Knapp, G. Schellhorn: Formale Methoden 202


KIV-Data Specifications: Allgemeine Form (2)

Syntax von KIV-Data Specifications

data specification

using 〈specname1〉, 〈specname2〉, . . .;

〈Datentyp-Definition für Sorte s1〉;

〈Datentyp-Definition für Sorte s2〉;

. . .

order predicates p1 : s1 × s1;

p2 : s2 × s2;

. . .

size functions f1 : s1 → nat;

. . .

variables x1 : s1; . . .

end data specification

◮ Die Sorten sind gegenseitig rekursiv (eine Generiertheitsklausel für alle)

◮ wenn size function, dann für alle Sorten, und using nat

A. Knapp, G. Schellhorn: Formale Methoden 203


KIV-Data Specifications: Eigenschaften

Satz Eine Data Specification, die keine anderen Datentypen verwendet, ist

konsistent. Sie ist monomorph, bis auf unspezifizierte Selektoren.

◮ Die natürlichen Zahlen sind also als Spezialfall monomorph, genauso

Aufzählungstypen.

◮ Für Listen von Elementen, Tupel &c. gilt Analoges.

A. Knapp, G. Schellhorn: Formale Methoden 204


Zusammenfassung

◮ Einfache Spezifikationen

◮ Homomorphismen, Isomorphismen

◮ Monomorphie

◮ Elementare Spezifikationen

◮ Generiertheitsklauseln

◮ Strukturelle Induktion

◮ Strukturelle Rekursion

◮ KIV: Simplifier und Heuristiken

◮ Unvollständigkeit der Arithmetik

◮ Ω-Regel

◮ Freie Datentypen

◮ Freie Generiertheitsklauseln

◮ KIV-Data Specifications

A. Knapp, G. Schellhorn: Formale Methoden 205


Strukturierte Spezifikationen

Spezifikationen werden sehr schnell sehr groß: Strukturierung

◮ Übersichtlichkeit & Verständlichkeit

◮ Wiederverwendung von Komponenten

◮ unabhängige Entwicklung von Komponenten

◮ Strukturierung und Wiederverwendung von Beweisen

A. Knapp, G. Schellhorn: Formale Methoden 206


Strukturierte Spezifikationen in KIV

◮ KIV zeigt strukturierte Spezifikationen als Spezifikationsgraph an.

◮ In KIV enthält jeder Knoten neben der Spezifikation außerdem eine

Theorembasis.

◮ Die Theorembasis enthält eine Menge von Theoremen (Sequenzen) über

der Gesamtsignatur.

◮ Für jede Sequenz kann ein Beweis vorhanden sein, der zeigt, daß die

Sequenz aus der Spezifikation und anderen Theoremen folgt (keine

zyklischen Abhängigkeiten).

◮ Theoreme aus darunterliegenden Spezifikationen werden mit

(insert spec-lemma) statt (insert lemma) angewendet.

◮ KIV hat ein Korrektheitsmanagement, um Abhängigkeiten zwischen

Beweisen zu verwalten.

A. Knapp, G. Schellhorn: Formale Methoden 207


Vereinigung und Anreicherung

◮ Vereinigung Sp1 + Sp2

◮ wirft Signaturen und Axiome zusammen

◮ KIV-Syntax: union specification

〈Spec1〉 + 〈Spec2〉 + . . .

end union specification

◮ Anreicherung Sp ✁ (Σ, X, Ax, Gen)

◮ addiert neue Signaturen und Axiome

◮ KIV-Syntax: enrich 〈Spec1〉, 〈Spec2〉, . . . with

〈sig〉 〈ind〉 〈ax〉

end enrich

◮ implizit: Ausgangsspezifikation der Anreicherung ist die Vereinigung von

〈Spec1〉, 〈Spec2〉, . . .

A. Knapp, G. Schellhorn: Formale Methoden 208


Anreicherung

◮ Hinzunahme neuer Axiome macht eine Spezifikation schnell inkonsistent;

es sind nur ” konsistenzerhaltende“ Anreicherungen gewünscht.

Formaler Begriff: Konsistenzerhaltend = hierarchiepersistent

◮ Neue Operationen sollten ” monomorphieerhaltend“ sein: Wenn genau ein

Datentyp spezifiziert ist, sollte die Operation ebenfalls eindeutig festgelegt

sein.

Formaler Begriff: Monomorphieerhaltend = eindeutig

Vorgehen

◮ Anreicherung nur durch rekursive und nichtrekursive Definitionen für neue

Operationen. Diese sind hierarchiepersistent und eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 209


Erweiterungen und Redukte

Definition Eine Signatur Σ ′ = (S ′ , F ′ , P ′ ) heißt Erweiterung von

Σ = (S, F, P), geschrieben als Σ ⊆ Σ ′ , wenn S ⊆ S ′ , F ⊆ F ′ und P ⊆ P ′ und

Funktionen und Prädikate dieselben Sorten haben.

Sei Σ = (S, F, P), Σ ′ = (S ′ , F ′ , P ′ ), A ′ = ((A ′ s)s∈S

′, (f A′

)f ∈F ′, (pA′ )p∈P ′) mit

Σ ⊆ Σ ′ und A ′ ∈ Alg(Σ ′ ).

Dann ist A ′ |Σ = ((As)s∈S, (f A′ |Σ )f ∈F, (p A′ |Σ )p∈P) eine Σ-Algebra mit

◮ As = A ′ s

◮ f A′ |Σ = f A ′

◮ p A′ |Σ = p A ′

für alle s ∈ S

für alle f ∈ F

für alle p ∈ P

Definition Ist Σ ⊆ Σ ′ und A ′ ∈ Alg(Σ ′ ), so heißt A ′ |Σ, das Redukt von A ′

auf Σ und A ′ eine Erweiterung von A|Σ.

A. Knapp, G. Schellhorn: Formale Methoden 210


Anreicherung und Algebren

◮ Wenn A ∈ Alg(Σ) und Σ ⊆ Σ ′ , dann gibt es eine Erweiterung A ′ mit

A ′ |Σ = A.

◮ Ist A ′ ∈ Mod(Sp ✁ (Σ ′ , X ′ , Ax ′ , Gen ′ )), dann ist A ′ |Σ(Sp) ∈ Mod(Sp)

(wobei Σ(Sp) die Signatur von Sp ist).

◮ Wann kann jedes Modell von Sp erweitert werden?

◮ Wann ist die Erweiterung konsistent?

◮ Wann gibt es nur eine Erweiterung?

A. Knapp, G. Schellhorn: Formale Methoden 211


Hierarchiepersistenz

Eine Anreicherung ist hierarchiepersistent, wenn sie die Bedeutung alter

Symbole nicht einschränkt: Jedes Modell der Ausgangsspezifikation läßt sich

erweitern.

Definition Eine Anreicherung Sp ′ = Sp ✁ (Σ, X, Ax, Gen) heißt

hierarchiepersistent, wenn es für jedes A ∈ Mod(Sp) ein A ′ ∈ Mod(Sp ′ ) mit

A ′ |Σ(Sp) = A gibt.

◮ Eine hierarchiepersistente Anreicherung einer konsistenten Spezifikation

ist konsistent.

A. Knapp, G. Schellhorn: Formale Methoden 212


Eindeutigkeit

Eine Anreicherung ist eindeutig, wenn man für die neuen Symbole nicht zwei

echt verschiedene Bedeutungen finden kann, sofern man eine für die alten

festlegt.

◮ Es ist aber möglich, daß sich nur bestimmte alte Datenstrukturen (im

schlimmsten Falle keine) erweitern lassen.

Definition Eine Anreicherung Sp ′ = Sp ✁ (Σ, X, Ax, Gen) ist eindeutig, wenn

je zwei Modelle A ′ , A ′′ ∈ Mod(Sp ′ ) mit A ′ |Σ(Sp) = A ′′ |Σ(Sp) isomorph sind.

◮ Eine eindeutige Anreicherung einer monomorphen Spezifikation ist

monomorph.

A. Knapp, G. Schellhorn: Formale Methoden 213


Reine Signaturerweiterung und zusätzliche Axiome

Satz Sp ✁ (Σ, ∅, ∅, ∅) ist hierarchiepersistent.

Satz Sp ✁ (∅, X, Ax, Gen) ist eindeutig. Die Anreicherung ist bei Gen = ∅

aber nur hierarchiepersistent, wenn die neuen Axiome aus den alten folgen.

Satz Sp ✁ ((S, C, ∅), ∅, ∅, S 〈C 〉) ist eindeutig und hierarchiepersistent.

A. Knapp, G. Schellhorn: Formale Methoden 214


Eigenschaften von Datendefinitionen

Satz Eine Datendefinition ist eine spezielle Anreicherung der verwendeten

Spezifikationen und ist hierarchiepersistent. Sie ist eindeutig, bis auf

unspezifizierte Selektoren.

Für List: Beschreibung exakt des Datentyps der Listen

◮ Zu jedem Elementtyp gibt es einen Listentyp.

◮ Genau ein Listentyp für jeden Elementtyp, bis auf die Festlegung von

[].first und [].rest.

A. Knapp, G. Schellhorn: Formale Methoden 215


Anreicherung: Beispiele (1)

Partielle und totale Ordnungen

POElem = specification

sorts elem;

predicates . < . : elem × elem;

variables a, b, c : elem;

axioms ¬ a < a;

a < b ∧ b < c → a < c;

end specification

TOElem = enrich POElem with

axioms a < b ∨ a = b ∨ b < a;

end enrich

◮ Die Anreicherung TOElem ist nicht hierarchiepersistent, aber (trivial)

eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 216


Anreicherung: Beispiele (2)

Ringe und Körper

Ring = specification

sorts elem;

constants 0, 1 : elem;

functions . + . : elem × elem → elem;

− . : elem → elem;

. ∗ . : elem × elem → elem;

variables a, b, c : elem;

axioms a + 0 = a; a + (− a) = 0; 1 ∗ a = a;

a ∗ (b + c) = a ∗ b + a ∗ c; ...

end specification

Field = enrich Ring with

functions . −1 : elem → elem;

axioms a = 0 → a ∗ (a −1 ) = 1;

end enrich

◮ Die Anreicherung Field ist nicht hierarchiepersistent; sie ist fast eindeutig,

bis auf das unspezifizierte inverse Element der 0.

A. Knapp, G. Schellhorn: Formale Methoden 217


Anreicherung: Verwendungen

Anreicherung wird also zu zwei Zwecken verwendet:

◮ hierarchiepersistent: um neue Funktionalität zu spezifizieren

◮ der Standardfall

◮ häufig auch eindeutig, aber manchmal will man auch nur ” interessante“ Fälle

definieren

◮ nicht hierarchiepersistent und eindeutig: um kleinere Klassen von

Modellen auszuzeichnen

◮ Gefahr der Inkonsistenz

◮ sollte man in Softwarespezifikationen besser vermeiden

◮ Besser: Man beweise, daß die Modelle der einen Spezifikation eine

Teilmenge der Modelle einer anderen sind.

◮ Spezialfall von Verfeinerung

A. Knapp, G. Schellhorn: Formale Methoden 218


Transitivität von Hierarchiepersistenz und Eindeutigkeit

Satz Seien

◮ Sp1 = Sp ✁ (Σ, X, Ax, Gen),

◮ Sp2 = Sp1 ✁ (Σ ′ , X ′ , Ax ′ , Gen ′ )

◮ Sp3 = Sp ✁ (Σ ∪ Σ ′ , X ∪ X ′ , Ax ∪ Ax ′ , Gen ∪ Gen ′ )

Dann gilt:

◮ Sind Sp1 und Sp2 hierarchiepersistent, dann ist auch Sp3

hierarchierpersistent.

◮ Sind Sp1 und Sp2 eindeutig, dann ist auch Sp3 eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 219


Vereinigung

Satz Ist Sp1 + Sp2 eine Vereinigung, so ist sie hierarchiepersistent als

Anreicherung von Sp1 um die Differenz von Sp2 und Sp1 (und umgekehrt), wenn

◮ der beiden gemeinsame Teil ausschließlich in gemeinsamen

Unterspezifikationen Sp ′ 1 , . . . , Sp′ n definiert ist;

◮ die Anreicherungen von Sp ′ i zu Sp1 und Sp2 hierarchiepersistent sind;

◮ für jede Vereinigung Sp ′ i + Sp′ j dasselbe Kriterium wie für Sp1 + Sp2 gilt.

Kriterium für Hierarchiepersistenz von Vereinigungen

◮ Spezialfall: Die Spezifikationen haben disjunkte Signatur.

A. Knapp, G. Schellhorn: Formale Methoden 220


Modulare Spezifikationsgraphen

Für alle Spezifikationsknoten in einem Spezifikationsgraphen zeigt man: Jede

Spezifikation ist hierarchiepersistente Erweiterung jeder Teilspezifikation.

Wenn Sp1 und Sp2 dann als Durchschnitt Sp ′ = Sp ′ 1 + . . . + Sp′ n haben, dann

◮ sind sowohl Sp1 als auch Sp2 hierarchiepersistente Erweiterung von Sp ′ ;

◮ jedes Modell A von Sp ′ kann also zu A1 ∈ Mod(Sp1), A2 ∈ Mod(Sp2)

erweitert werden, mit A1|Σ(Sp ′ ) = A2|Σ(Sp ′ ) = A.

◮ Die beiden Modelle können also ” zusammengeworfen“ werden zu einem

Modell von Sp1 + Sp2 (und das geht für alle A1, A2 wegen

Hierarchiepersistenz).

◮ Wenn also alle elementaren Spezifikationen konsistent sind, alle

Anreicherungen hierarchiepersistent, und die Vereinigungen das Kriterium

erfüllen (modularer Spezifikationsgraph), dann ist die Gesamtspezifikation

konsistent.

A. Knapp, G. Schellhorn: Formale Methoden 221


Nichtrekursive Definitionen

Definitionen zur Abkürzung großer Terme und Formeln

◮ Prädikat: p(x) ↔ ϕ (p kommt in Formel ϕ nicht vor, fvar(ϕ) ⊆ x)

◮ Funktion: f (x) = t (f kommt im Term t nicht vor, var(t) ⊆ x)

A. Knapp, G. Schellhorn: Formale Methoden 222


Nichtrekursive Definitionen: Beispiele (1)

Anreicherung um nichtrekursives Prädikat

NatDiv = enrich Nat with

predicates | : nat × nat;

axioms m | n ↔ ∃ k . k * m = n;

end enrich

◮ Die Anreicherung NatDiv ist hierarchiepersistent und eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 223


Nichtrekursive Definitionen: Beispiele (2)

Anreicherung um nichtrekursives Prädikat mit Fallunterscheidung

NatPrime = enrich NatDiv with

predicates prime : nat;

axioms ¬ prime(0);

¬ prime(1);

n ≥ 2 → (prime(n) ↔

∀ m . m | n → m = 1 ∨ m = n);

end enrich

◮ Die Anreicherung NatPrime ist hierarchiepersistent und eindeutig (da

Fallunterscheidung nach n = 0, n = 1, n ≥ 2 vollständig).

A. Knapp, G. Schellhorn: Formale Methoden 224


Nichtrekursive Definitionen: Beispiele (3)

Anreicherung um nichtrekursive Konstante

Nat12 = enrich Nat with

constants 1 : nat;

2 : nat;

axioms 1 = 0 +1

2 = 0 +1 +1;

end enrich

◮ Die Anreicherung Nat12 ist hierarchiepersistent und eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 225


Nichtrekursive Definitionen: Beispiele (4)

◮ m ≤ n ↔ ∃k . m + k = n

◮ m < n ↔ m ≤ n ∧ m = n

◮ m > n ↔ n < m

◮ even(n) ↔ ∃m . n = m + m

◮ odd(n) ↔ ¬even(n)

◮ m < n → min(m, n) = m, ¬m < n → min(m, n) = n

◮ x ≥ 0 → abs(x) = x, x < 0 → abs(x) = −x

◮ last(l + (a + [])) = a (unvollständige Definition)

◮ a ∈ l ↔ ∃l ′ , l ′′ . l ′ + a + l ′′ = l

◮ isprefix(l, l ′ ) ↔ ∃l ′′ . l + l ′′ = l ′

◮ nodups(l) ↔ ¬∃l1, l2, l3, a . l = l1 + a + l2 + a + l3

A. Knapp, G. Schellhorn: Formale Methoden 226


Nichtrekursive Definitionen: Allgemeine Form

◮ Prädikat: p(x) ↔ ϕ (p kommt in Formel ϕ nicht vor, fvar(ϕ) ⊆ x)

◮ Funktion: f (x) = t (f kommt im Term t nicht vor, var(t) ⊆ x)

◮ Prädikat mit zwei vollständigen Fällen:

γ(x, y) → (p(x, y) ↔ ϕ1(x, y)),

¬γ(x, y) → (p(x, y) ↔ ϕ2(x, y))

◮ Funktionen mit drei unvollständigen Fällen:

γ1(x, y) ∧ γ2(x, y) → f (x, y) = t1,

γ1(x, y) ∧ ¬γ2(x, y) → f (x, y) = t2,

¬γ1(x, y) ∧ γ2(x, y) → f (x, y) = t3

Satz Die Hinzunahme einer neuen Operation (Funktion oder Prädikat) mit

nichtrekursiver Definition ist immer hierarchiepersistent. Wenn die Fälle

vollständig sind, ist die Erweiterung eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 227


Rekursive Definitionen

◮ Datentypen bestehen aus (der Semantik von) Konstruktortermen.

◮ Rekursive Definitionen geben Definition durch Reduktion auf kleinere

Konstruktorterme.

◮ Rekursive Definitionen entsprechen einem rekursiven Programm, das den

Term abläuft (das Programm terminiert immer).

Satz Die Hinzunahme einer neuen Operation mit rekursiver Definition zu

einem freien Datentyp ist immer hierarchiepersistent. Wenn die Fälle vollständig

sind, ist die Erweiterung immer eindeutig.

A. Knapp, G. Schellhorn: Formale Methoden 228


Rekursive Definitionen: Beispiele (1)

Anreicherung um rekursive Funktion

Length = enrich List with

functions length : list → nat;

axioms ax1: length([]) = 0;

ax2: length(a + l) = length(l) +1;

end enrich

◮ Length ist hierarchiepersistent und eindeutig.

◮ Dabei darf ax2 nicht durch length(x) = length(x.rest) +1 ersetzt

werden.

A. Knapp, G. Schellhorn: Formale Methoden 229


Rekursive Definitionen: Beispiele (2)

Anreicherung um rekursive Funktion

Append = enrich List with

functions . + . : list × list → list;

axioms [] + l = l;

(a + l) + l’ = a + (l + l’);

end enrich

◮ Append ist hierarchiepersistent und eindeutig.

◮ Dabei ist + überladen: sowohl Element vor Liste hängen, als auch zwei

Listen zusammenhängen

A. Knapp, G. Schellhorn: Formale Methoden 230


Rekursive Definitionen: Beispiele (3)

Anreicherung um rekursives Prädikat mit Fallunterscheidung

Ordered = enrich List with

predicates ordered : list;

axioms ordered([]);

ordered(a + []);

ordered(a + b + l) ↔ a < b ∧ ordered(b + l);

end enrich

◮ Ordered ist hierarchiepersistent und eindeutig, da die Fallunterscheidung

vollständig ist (jede Liste ist entweder gleich [], a + [] oder a + b + l).

A. Knapp, G. Schellhorn: Formale Methoden 231


Umbenennung

Umbenennung Spρ

◮ benennt die Operationen einer Spezifikation um

◮ nützlich um zwei Kopien zu erhalten

◮ KIV-Syntax: rename 〈Spec〉 by morphism

〈renaming1〉;

. . .

〈renamingn〉;

end rename

mit 〈renaming〉 von der Form 〈sort/op/var〉 → 〈sort/op/var〉

◮ identische Umbenennungen weglassen (werden beim Ansehen der

Spezifikation aber angezeigt)

◮ Nicht zwei Symbole auf dasselbe abbilden: injektiv umbenennen

◮ entweder alle Variablen oder keine umbenennen

A. Knapp, G. Schellhorn: Formale Methoden 232


Umbenennung: Beispiel

Listen zu Stacks

rename List by morphism

list → stack;

[] → empty;

(: Typangabe für überladenes Symbol :)

+ :: (elem × list → list) → push prio 0;

(: pop soll nicht mehr Postfix sein, default übernimmt prio :)

.rest → pop prio 0;

(: top soll nun Präfix sein :)

.first → top .;

(: eigentlich keine Stack-Operation, nur um Overloading zu zeigen :)

+ :: (list × list → list) → concat prio 0;

x → st;

y → st0;

z → st1;

end rename

A. Knapp, G. Schellhorn: Formale Methoden 233


Generische Spezifikation

Generische Spezifikation

◮ KIV-Syntax: generic specification

parameter 〈Spec〉

using 〈Spec1〉, . . . , 〈Specn〉

target

〈sig〉 〈ind〉 〈ax〉

end generic specification

◮ wie Anreicherung (von 〈Spec〉, 〈Spec1〉, . . . , 〈Specn〉), nur wird von

〈Spec〉 explizit gesagt, daß es sich um einen Parameter handelt

◮ Vereinigung und Anreicherung übernimmt den (oder die) Parameter der

Unterspezifikationen

◮ Variante: generic data specification: wie data

specification, nur mit Parameter

A. Knapp, G. Schellhorn: Formale Methoden 234


Generische Spezifikationen: Aktualisierung (1)

Aktualisierung

◮ instantiiert Parameter (oder einen Parameter) einer Spezifikation

◮ KIV-Syntax:

actualize 〈Spec〉 with 〈ASpec1〉, . . . , 〈ASpecn〉 by morphism

〈renaming1〉;

. . .

〈renamingm〉;

end actualize

mit 〈renaming〉 von der Form 〈sort/op/var〉 → 〈sort/op/var〉

◮ Die Vereinigung von 〈ASpec1〉, . . . , 〈ASpecn〉 heißt aktuelle Spezifikation

◮ identische Umbenennungen weglassen

◮ entweder alle Variablen oder keine umbenennen

A. Knapp, G. Schellhorn: Formale Methoden 235


Generische Spezifikationen: Aktualisierung (2)

Aktualisierung

◮ Der Parameter muß in die aktuelle Spezifikation abgebildet werden.

◮ Abbildung darf auch nicht injektiv sein:

pair(elem1, elem2) → pair(nat, nat)

◮ Der Nicht-Parameter-Teil darf nur injektiv und disjunkt zur aktuellen

Spezifikation umbenannt werden, z. B. list → natlist

◮ Die instantiierten Axiome des Parameters müssen Axiome in der aktuellen

Spezifikation sein.

◮ Verallgemeinerung instantiated specification

◮ Axiome müssen bewiesen werden

◮ mapping statt morphism erlaubt es, eine Sorte auf ein Tupel von Sorten

abzubilden

A. Knapp, G. Schellhorn: Formale Methoden 236


Aktualisierung: Beispiel (1)

Order = specification

sorts elem;

constants d : elem;

predicates ≪ : elem × elem

variables a, b, c : elem;

axioms ¬ a ≪ a; a ≪ b ∧ b ≪ c → a ≪ c;

¬ a ≪ d; (: d ist minimal :)

end specification

List-Ord = generic data specification

parameter Order;

using Nat

list = [] | . + . (. .first : elem; . .rest : list);

size functions length : list → nat;

end generic data specification

A. Knapp, G. Schellhorn: Formale Methoden 237


Aktualisierung: Beispiel (2)

Nat-List = actualize List-Ord with Nat by morphism

list → natlist;

elem → nat;

≪ →


Nichtfreie Datentypen

Orderedlist = enrich List with

predicates . < . : elem × elem;

ordered : list;

axioms ¬ a < a;

a < b ∨ a = b ∨ b < a;

a < b ∧ b < c → a < c;

ordered([]);

ordered(a + []);

ordered(a + b + l) ↔ a < b ∧ ordered (b + l);

end enrich

◮ Hinzunahme von ∀l . ordered(l) wäre inkonsistent.

◮ Allgemein: Ein generierter Datentyp enthält immer alle Konstruktorterme.

Man kann nicht nachträglich Terme ausschließen. Man kann nur einen

nichtfreien Datentyp bilden, der Terme identifiziert.

A. Knapp, G. Schellhorn: Formale Methoden 239


Spezifikation nichtfreier Datentypen

◮ Spezifikationen nichtfreier Datentypen werden sehr leicht inkonsistent oder

uneindeutig.

◮ Deshalb: Standardvorgehen, das für alle containerartigen Datentypen, die

Elemente ” enthalten“, funktioniert (z. B. Arrays, Graphen, Mengen,

Multimengen, etc.)

◮ Einzige Ausnahme für das Standardvorgehen: Ganze Zahlen (spezieller

Nachweis, daß Integerspezifikation monomorph)

A. Knapp, G. Schellhorn: Formale Methoden 240


Standardvorgehen zur Spezifikation nichtfreier Datentypen

◮ Grundidee: Konstruiere nichtfreien Datentyp durch Zusammenfassung von

Termen in Klassen, die gleich sind.

◮ Als erstes nach der Bestimmung der Konstruktoren: Definiere Gleichheit

durch Extensionalitätsaxiom: x = y ↔ EQ(x, y)

◮ Dann: die in EQ verwendeten Operationen werden rekursiv definiert.

◮ Damit Monomorphie: höchstens ein Datentyp spezifiziert

◮ Aber: rekursive Definitionen können inkonsistent sein.

A. Knapp, G. Schellhorn: Formale Methoden 241


Beispiel einer inkonsistenten rekursiven Definition

◮ Annahmen

◮ Mengen von natürlichen Zahlen definiert, mit ∅ und insert generiert

◮ Aus den Axiomen folgt: insert(a, insert(a, ∅)) = insert(a, ∅)

◮ Rekursive Definition

sum(∅) = 0 ,

sum(insert(a, s)) = a + sum(s)

inkonsistent, da aus insert(1, insert(1, ∅)) = insert(1, ∅) folgt, daß

2 = sum(insert(1, insert(1, ∅))) = sum(insert(1, ∅)) = 1

◮ Korrekte Definition

sum(∅) = 0 ,

¬a ∈ s → sum(insert(a, s)) = a + sum(s)

(im Fall a ∈ s ist insert(a, s) = s)

◮ Operation sum muß mit der Definition der Gleichheit auf Mengen, d. h.

dem Extensionalitätsaxiom verträglich sein.

A. Knapp, G. Schellhorn: Formale Methoden 242


Standardvorgehen: Beispiele (1a)

Arrays

Array = generic specification

parameter Elem;

using Nat;

target

sorts array;

functions mkar : nat → array;

. [ . , . ] : array × nat × elem → array;

. [ . ] : array × nat → elem;

# . : array → nat;

induction array generated by mkar, . [ . , . ];

variables d : elem; ar, ar1, ar2 : array;

A. Knapp, G. Schellhorn: Formale Methoden 243


Standardvorgehen: Beispiele (1b)

Festlegungen:

◮ Konstruktor mkar(n) liefert ein Array mit unbekannten Elementen

◮ Alternative: mkar(n, d) mit Initialelement d

◮ Für m ≥ #a ist Selektion a[m] unspezifiziert

◮ Für m ≥ #a ist Modifikation die Identität: a[m, d] = a

◮ Alternativen: liefert irgendein Array, ein Array gleicher Größe

axioms ar1 = ar2 ↔ # ar1 = # ar2 ∧

∀ n . n < # ar1 → ar1[n] = ar2[n];

# mkar(n) = n;

# ar[m , d] = # ar;

m < # ar → ar[m , d][m] = d;

n = m → ar[m , d][n] = ar[n];

end generic specification

A. Knapp, G. Schellhorn: Formale Methoden 244


Beweisverpflichtungen für nichtfreie Datentypen

◮ Der freie Datentyp existiert immer, rekursvie Definitionen dort eindeutig

◮ Durch die EQ-Formel aus dem Extensionalitätsaxiom werden die

Konstruktorterme in Klassen eingeteilt, die gleich sind.

◮ Damit EQ eine sinnvolle Klasseneinteilung bewirkt, muß gelten:

◮ Reflexivität: EQ(a, a)

◮ Symmetrie: EQ(a, b) → EQ(b, a)

◮ Transitivität: EQ(a, b) ∧ EQ(b, c) → EQ(a, c)

◮ Verträglichkeit: EQ(a, b) → f (a) = f (b)

◮ für a, b aus der gleichen Klasse muß Operation f dasselbe liefern

◮ Um die Konsistenz eines nichtfreien Datentyps formal zu zeigen, muß EQ

eine Kongruenz (= Äquivalenzrelation + Verträglichkeit) über dem freien

Datentyp sein

A. Knapp, G. Schellhorn: Formale Methoden 245


Standardvorgehen: Beispiele (1c)

Das Extensionalitätsaxiom ist eine Kongruenz; für

EQ(ar1, ar2) = #ar1 = #ar2 ∧ ∀n . n < #ar1 → ar1[n] = ar2[n]

läßt sich (ohne das Exensionalitätaxiom) zeigen:

◮ Reflexivität: EQ(ar1, ar1)

◮ Symmetrie: EQ(ar1, ar2) → EQ(ar2, ar1)

◮ Transitivität: EQ(ar1, ar2) ∧ EQ(ar2, ar3) → EQ(ar1, ar3)

◮ Verträglichkeit mit #: EQ(ar1, ar2) → #ar1 = #ar2

◮ Verträglichkeit mit Auswahl: EQ(ar1, ar2) → ar1[n] = ar2[n]

◮ Verträglichkeit mit Änderung: EQ(ar1, ar2) → EQ(ar1[n, d], ar2[n, d])

allerdings nur mit vollständig definiertem Selektor, z. B. mit

#ar ≤ n → ar[n] = mkar(0)[0]

A. Knapp, G. Schellhorn: Formale Methoden 246


Standardvorgehen: Beispiele (2a)

Geordnete Listen

Orderedlist = specification

sorts elem, ordlist;

constants [] : ordlist;

functions . + . : elem × ordlist → ordlist;

min : ordlist → elem;

butmin : ordlist → ordlist;

predicates . < . : elem × elem;

variables a, b, c : elem;

l, l’ : ordlist;

induction ordlist generated by [], +;

A. Knapp, G. Schellhorn: Formale Methoden 247


Standardvorgehen: Beispiele (2b)

axioms ¬ a < a;

a < b ∨ a = b ∨ b < a;

a < b ∧ b < c → a < c;

l = l’ ↔ l = [] ∧ l’ = []

∨ l = [] ∧ l’ = []

∧ min(l) = min(l’)

∧ butmin(l) = butmin(l’);

min(a + []) = a;

a < b → min(a + b + l) = min(a + l);

¬ a < b → min(a + b + l) = min(b + l);

butmin(a + []) = [];

a < b → butmin(a + b + l) = b + butmin(a + l);

¬ a < b → butmin(a + b + l) = a + butmin(b + l);

end specification

A. Knapp, G. Schellhorn: Formale Methoden 248


Standardvorgehen: Beispiele (3a)

Speicher

Store = generic specification

parameter Loc+Data (: Parametersorten loc, data :)

using Nat

target

sorts store;

constants (: leerer Speicher :)

∅ : store;

functions (: Schreiben :)

. [ . , . ] : store × loc × data → store;

(: Lesen :)

. [ . ] : store × loc → data;

(: Anzahl allokierter Adressen :)

# . : store → nat;

(: Freigeben :)

. -- . : store × loc → store;

(: neue, nicht allokierte Adresse :)

new : store → loc;

predicates (: Adresse ist allokiert :)

. ∈ . : loc × store;

A. Knapp, G. Schellhorn: Formale Methoden 249


Standardvorgehen: Beispiele (3b)

Entscheidungen:

◮ Schreib-Konstruktor allokiert Adresse, falls noch nicht vorhanden

◮ Alternative: separates Allokieren

◮ Falls a /∈ st, liefert Selektion st[a] immer dasselbe unspezifizierte

Datum ∅[a].

◮ Alternative: das unspezifizierte Element ändert sich evt. beim Schreiben

(Axiom At-other und st1[a] = st2[a] in Extension mit zusätzlicher

Vorbedingung a ∈ st)

◮ unbeschränkte Zahl an Adressen vorhanden (keine Memory overflows

betrachtet)

nur unendliche Parameter für loc verwendbar (nicht hierarchiepersistent)

◮ Alternativen: new : store → loc or overflow oder Prädikat

full(st)

A. Knapp, G. Schellhorn: Formale Methoden 250


Standardvorgehen: Beispiele (3c)

induction store generated by

∅, . [ . , . ] :: (store × loc × data → store);

variables a, b : loc; d : data; st, st1, st2 : store;

axioms

Extension: st1 = st2 ↔ ∀ a . (a ∈ st1 ↔ a ∈ st2)

∧ st1[a] = st2[a];

In-empty: ¬ a ∈ ∅;

In-insert: a ∈ st[b, d] ↔ a = b ∨ a ∈ st;

At-same: st[a, d][a] = d;

At-other: a = b → st[b, d][a] = st[a];

Size-base: # ∅ = 0;

Size-rec: ¬ a ∈ st → # st[a, d] = # st + 1;

(: a ∈ st → # st[a, d] = # st ist beweisbar :)

Del-base: ∅ -- b = ∅;

Del-same: st[a, d] -- a = st -- a ;

Del-other: a = b → (st[b, d] -- a) = (st -- a)[b, d];

New: ¬ new(st) ∈ st;

end generic specification

A. Knapp, G. Schellhorn: Formale Methoden 251


Spezifikation der ganzen Zahlen (1)

◮ Integers sind von 0, +1, −1 generiert

◮ Damit beliebig gemischte Terme: 0 +1 −1 −1 +1 +1 . . . −1 +1

◮ In einer Algebra A (ohne Axiome) können diese beliebig gleich oder

verschieden sein.

◮ Zwei Ziele für die Axiome, um die Integers als einzige Algebra zu haben:

1. Alle Werte aus Aint sind

◮ T 0 +1 . . . +1

A = T 0 +1


n A = S n mit n > 0 oder

n ×

◮ T 0 −1 . . . −1

A = T 0 −1


m ×

m A = P m mit m > 0 oder

◮ T 0 A = 0 A

2. 0 A , S n und P m sind alle verschieden.

◮ Dann Isomorphismus h : A → Z mit h(S n ) = n, h(P m ) = −m, h(0 A ) = 0.

A. Knapp, G. Schellhorn: Formale Methoden 252


Spezifikation der ganzen Zahlen (2)

Ziel 1: Keine weiteren Elemente außer S n , 0, P m

Axiome: predsucc: i −1 +1 = i succpred: i +1 −1 = i

Für jeden Konstruktorterm t gilt (in jedem Modell der Axiome): |= t = 0 oder

|= t = 0 +1 n oder |= t = 0 −1 m (und damit T t A ∈ {S n , 0 A , P m }).

Durch Induktion über die Anzahl k der Konstruktoren in t:

◮ k = 0: Dann ist t = 0 und die Behauptung gilt.

◮ k → k + 1:

◮ Es gilt: t = t ′ +1 oder t = t ′ −1.

◮ Nach Induktionsvoraussetzung |= t ′ = 0 +1 n oder |= t = 0 −1 m oder

|= t ′ = 0.

◮ Zwei interessante Fälle mit insert rewrite lemma:

t = t ′ −1 und |= t ′ = 0 +1 n : Verwendung von predsucc

t = t ′ +1 und |= t ′ = 0 −1 m : Verwendung von succpred

A. Knapp, G. Schellhorn: Formale Methoden 253


Spezifikation der ganzen Zahlen (3)

Ziel 2: Die Elemente S n , 0 A und P m sind alle verschieden.

Problem: Endlich viele Ungleichungen (z. B. 0 +1n = 0 +1n′ für n = n ′

genügen nicht, da es beliebig große Zn (sogar Körper, wenn n Primzahl) gibt.

Auch rekursive Definitionen von Addition und Multiplikation gelten in Zn.

Deshalb: Definition der


Spezifikation der ganzen Zahlen (4)

Reduktion der Fälle: Mit den Axiomen

irrefl: ¬i < i trans: i < j ∧ j < k → i < k

läßt sich Fall (4) beweisen, und Fall (1b) kann auf Fall (1a) (und analog (2b)/(3b)

auf (2a)/(3a)) reduziert werden:

Zu zeigen ist: Wenn 0 ≤ m < n, dann |= ¬0 +1 n < 0 +1 m .

◮ Wegen (1a): |= 0 +1 m < 0 +1 n .

◮ Nach Transitivität: |= i < j ∧ j < i → i < i

◮ Zusammen mit Irreflexivität und Aussagenlogik also: |= i < j → ¬j < i

◮ Zusammen mit (1a) also: |= ¬0 +1 n < 0 +1 m .

A. Knapp, G. Schellhorn: Formale Methoden 255


Spezifikation der ganzen Zahlen (5)

Weitere Reduktion: (2a) kann auf (1a) reduziert werden mit dem Axiom

remsucc: i < j ↔ i +1 < j +1

Es gilt auch (durch Einsetzen von i ′ = i −1, j ′ = j −1 und predsucc)

rempred: i −1 < j −1 ↔ i < j

Denn: Sei 0 ≤ m < n.

Mit (1a): |= 0 +1 m < 0 +1 n

Mit rempred m + n mal: |= 0 +1 m −1 m+n < 0 +1 n −1 m+n

Mit succpred m + n mal: |= 0 −1 n < 0 −1 m

Analog: (3a) kann auf (1a) reduziert werden.

A. Knapp, G. Schellhorn: Formale Methoden 256


Spezifikation der ganzen Zahlen (6)

Es bleibt also, Axiome zu finden, so daß Fall (1a): |= 0 +1 m < 0 +1 n für

0 ≤ m < n gilt.

Axiom wie bei natürlichen Zahlen:

less-recsucc: i < j +1 ↔ i < j ∨ i = j

Aus dem Axiom folgt speziell (für i = j):

less-succ: i < i +1

Damit 0 < 0 +1, 0 +1 < 0 +1 +1, . . . . Mit Transitivität folgt die Behauptung

(exakter Beweis: Induktion über Konstruktorenzahl wie vorher).

Ähnliches Problem wie bei der from-Funktion: less-succ genügt für

Monomorphie, aber ¬∃i . 0 < i < 0 +1 ist wegen des schwachen

Induktionsprinzips wohl nur mit less-recsucc beweisbar.

A. Knapp, G. Schellhorn: Formale Methoden 257


Spezifikation der ganzen Zahlen: Zusammenfassung

Integer = specification

sorts int;

constants 0 : int;

functions . +1 : int → int;

. −1 : int → int;

. + . : int × int → int;

predicates . < . : int × int;

induction int generated by 0, +1, −1;

variables i, j : int;

axioms i +1 −1 = i;

i −1 +1 = i;

¬ i < i;

i < j ∧ j < k → i < k;

i < j ↔ i +1 < j +1;

i < j +1 ↔ i < j ∨ i = j;

i + 0 = i;

i + (j +1) = (i + j) +1;

i + (j −1) = (i + j) −1;

end specification

A. Knapp, G. Schellhorn: Formale Methoden 258


Resolution und Skolemisierung

Aussagenlogik

◮ Konjunktive Normalform

◮ Klauseln

◮ darauf basierend SAT-Beweiser

Prädikatenlogik

◮ Pränex-Normalform mit konjunktiver Normalform

Q1x1 . Q2x2 . . . . . Qnxn .

i


j Li,j

Jedes Li,j ist Literal (also evtl. negierte Gleichung oder Prädikat)

◮ Skolemisierung: Beseitigung von Existenzquantoren

◮ damit: Klauseln

◮ darauf basierend Resolutions-Beweiser

A. Knapp, G. Schellhorn: Formale Methoden 259


Skolemisierung (1)

Satz Sei ψ = ∀x . ∃y . ϕ(x, y) eine geschlossene Formel über Σ = (S, F, P)

mits den Sorten von x und s ′ die Sorte von y. Sei f : s → s ′ ein neues

Funktionssymbol, das nicht in F vorkommt, und χ = ∀x . ϕ(x, f (x)). Dann gilt: ψ

hat genau dann ein Modell über Σ, wenn χ ein Modell über (S, F ∪ {f }, P) hat.

Der Satz gestattet es, in der Pränexnormalform den äußersten Existenzquantor

zu beseitigen. Iteration beseitigt alle Existenzquantoren. Das ergibt die

Skolem-Normalform.

A. Knapp, G. Schellhorn: Formale Methoden 260


Skolemisierung (2)

Beweisskizze

” ⇒“: Wenn ψ ein Modell A hat, gibt es zu jeder Belegung a der

Variablen x eine Belegung b für y, sodaß ψ wahr wird. Also läßt sich das Modell zu A ′

erweitern durch Definition einer Funktion f A′

, sodaß f A′ (a) = b.

(Der Beweis verwendet das Auswahlaxiom der Mengenlehre: Ist M eine Menge

nichtleerer Mengen, dann gibt es eine Auswahlfunktion f : M → M mit f (M) ∈ M

für jedes M ∈ M. Hier: M Menge aller Ma = {b | Fϕ(x, y) A v{x, y ↦→ a, b} = tt}.)

” ⇐“: ϕ{y ↦→ f (x)} → ∃y . ϕ ist Tautologie.

A. Knapp, G. Schellhorn: Formale Methoden 261


Klauseln für Prädikatenlogik

Definition Ein (prädikatenlogisches) Literal ist ein Prädikat, eine Gleichung

oder die Negation eines der beiden. Eine Klausel C = {L1, . . . Ln} ist eine

Menge von Literalen; die Semantik der Klausel ist die Formel cl ∀ (L1 ∨ . . . ∨ Ln).

Eine Klauselmenge C = {C1, . . . , Cm} ist eine endliche Menge von Klauseln;

Die Semantik der Klauselmenge ist die Formel

1≤i≤m Ci.

◮ In einer Klausel sind die Variablen wie in einem Axiom implizit

allquantifiziert.

A. Knapp, G. Schellhorn: Formale Methoden 262


Transformation von Formeln in Klauseln

Satz Zu jeder Formel ϕ gibt es eine Klauselmenge C (ϕ), sodaß ϕ genau

dann ein Modell hat, wenn C (ϕ) ein Modell hat.

Beweisskizze

◮ Bilde Pränexnormalform.

◮ Bringe Rumpf in konjunktive Normalform.

◮ Skolemisiere.

◮ Schiebe die übrigbleibenden Allquantoren über die Konjunktionen nach innen mit

(∀x . ψ ∧ χ) ↔ (∀x . ψ) ∧ (∀x . χ).

◮ Es ergibt sich eine Konjunktion von allquantifzierten Disjunktionen.

A. Knapp, G. Schellhorn: Formale Methoden 263


Klauseln und Beweise

Satz Jedes Beweisproblem Ax |= ϕ mit endlicher Axiomenmenge läßt sich

in eine Klauselmenge C transformieren, sodaß Ax |= ϕ genau dann, wenn C

kein Modell hat.

Beweisskizze Es gilt:

Ax |= ϕ

⇔ Ax ∪ {¬ cl ∀ (ϕ)} hat kein Modell

⇔ {C (ψ) | ψ ∈ Ax ∪ {¬ cl ∀ (ϕ)}} hat kein Modell

A. Knapp, G. Schellhorn: Formale Methoden 264


Resolutionskalkül für Prädikatenlogik

Resolutionskalkül

◮ Berechne Klauselmenge zum Problem Ax |= ϕ.

◮ Nehme inkrementell neue Klauseln hinzu.

◮ Sobald die leere Klausel (entspricht ff ) hinzugenommen wird, hat die

Menge kein Modell, d. h. der Beweis war erfolgreich.

◮ Wesentliche Regel zum Klauseln hinzunehmen: Resolution.

◮ Schwierig: Gleichheit behandeln mit Paramodulation, Superposition

Beispiel

{p(x, g(z)), q(x, z)} {¬p(f(w), y), r(w, y)}

{q(f(w), z), r(w, g(z))}

A. Knapp, G. Schellhorn: Formale Methoden 265


Skolemisierung und Klauseln

Skolemisierung

◮ Skolemisierung besagt: man kann auf Existenzquantoren verzichten,

Allquantoren implizit

◮ Programmiersprachen verzichten auch auf Quantoren

◮ Spezifikationssprache nur mit rekursiven Definitionen: ACL2

Klauseln

◮ Eine Klausel der Form {P, ¬P1, . . . , ¬Pn} heißt Hornklausel.

◮ Man schreibt sie auch P ← P1 ∧ . . . ∧ Pn

◮ Algorithmus: Beweise P, indem P1, . . . , Pn bewiesen wird.

◮ Suchbaum für die Lösung, terminiert mit Fakten P ←.

◮ Programmiersprache Prolog

A. Knapp, G. Schellhorn: Formale Methoden 266


Logiken höherer Stufe

◮ Prädikatenlogik = Logik erster Stufe

◮ schwache Logik 2. Stufe erlaubt Funktions- und Prädikatvariablen und

Quantoren darüber

◮ volle Logik 2. Stufe (“second order logic”) erlaubt Funktionen als

Argumente von Funktionen (2. Stufe), z. B.

compose : (A → B) × (B → C) → (A → C)

◮ Logik 3. Stufe hat Variablen und Quantoren für Funktionen mit Funktionen

als Argument etc.

◮ Allgemeine Higher-Order-Logik (HOL) erlaubt beliebige Funktionen mit

beliebigen Typen.

A. Knapp, G. Schellhorn: Formale Methoden 267


HOL: Typen

Definition Sei S eine Menge von Sorten mit bool ∈ S. Dann ist die Menge

der Typen T definiert durch

◮ Für jede Sorte s ∈ S ist s ∈ T .

◮ Wenn τ1, . . . , τn, τ ∈ T , dann ist der Funktionstyp

τ1 × . . . × τn → τ ∈ T .

Eine Signatur Σ = (S, F) besteht aus Sorten S und typisierten Operationen

f : τ ∈ F.

A. Knapp, G. Schellhorn: Formale Methoden 268


HOL: Semantik von Typen

Definition Sei Σ = (S, F) eine Signatur. Eine Σ-HOL-Algebra enthält für

jede Sorte s eine Trägermenge As und Abool = {ff , tt}. Die Standardsemantik

eines Funktionstyps τ1 × . . . × τn → τ ∈ T ist die Menge aller Funktionen

Aτ1×...×τn→τ = Aτ1 × . . . × Aτn → Aτ . Jede Operation f : τ ∈ F erhält als

Semantik ein f A ∈ Aτ .

Alternativen zur Standardsemantik

◮ die Menge der durch einen Algorithmus berechenbaren Funktionen

◮ die Menge der syntaktisch ausdrückbaren Funktionen, etc.

A. Knapp, G. Schellhorn: Formale Methoden 269


HOL: Ausdrücke

Definition HOL-Ausdrücke e ∈ E (Σ, X)τ des Typs τ ∈ T über der Signatur

Σ und über den Variablen X = (Xτ )τ∈T sind rekursiv gegeben durch

◮ x ∈ Xτ ist ein Ausdruck des Typs τ .

◮ f ∈ Fτ ist ein Ausdruck des Typs τ .

◮ Sind e1, . . . , en Ausdrücke der Typen τ1, . . . , τn und ist e vom Typ

τ1 × . . . × τn → τ dann ist e(e1, . . . , en) ein Ausdruck des Typs τ .

◮ Sind e1, e2 vom Typ τ , so ist e1 = e2 ein Ausdruck des Typs bool.

◮ Wenn e ein Ausdruck des Typs bool und x eine Variable ist, so sind ∀x . e

und ∃x . e Ausdrücke des Typs bool.

◮ Sind e1, e2 Ausdrücke des Typs τ und e ein Ausdruck des Typs bool, so ist

(e ⊃ e1; e2) ein Ausdruck der Sorte τ .

A. Knapp, G. Schellhorn: Formale Methoden 270


HOL: Semantik von Ausdrücken

Definition Gegeben eine HOL-Algebra A und eine Belegung v. Dann ist die

Semantik Ee A v eines Ausdrucks e des Typs τ das folgende Element aus Aτ :

◮ Ex A v = v(x) für x ∈ X

◮ Ef A v = f A für f ∈ F

◮ Ee(e1, . . . , en) A v = (Ee A v) (Ee1 A v, . . . , Een A v)

◮ Ee1 = e2 A v = tt, falls Ee1 A v = Ee2 A v (sonst ff )

◮ E∀x . e A v = tt, falls, wenn x ∈ Xτ , für alle a ∈ Aτ gilt:

Ee A v{x ↦→ a} = tt (sonst ff )

◮ E∃x . e A v = tt, falls, wenn x ∈ Xτ , es ein a ∈ Aτ gibt mit

Ee A v{x ↦→ a} = tt (sonst ff )

◮ E(e ⊃ e1; e2) A v: falls Ee A v = tt, dann Ee1 A v, sonst Ee2 A v.

A. Knapp, G. Schellhorn: Formale Methoden 271


HOL: λ-Ausdrücke

◮ HOL erlaubt die Definition von anonymen Funktionen:

λn . n + 2 ist die Funktion, die jedem n den Wert n + 2 zuordnet.

◮ Allgemeine Definition:

Ist e ein Ausdruck des Typs τ und sind x1, . . . , xn Variablen der Typen

τ1, . . . , τn, so ist λx1, . . . , xn . e eine Funktion vom Typ τ1 × . . . × τn → τ

◮ Semantik: Eλx . e A v ist die Funktion, die zu jedem a passenden Typs

als Ergebnis Ee A v{x ↦→ a} berechnet.

A. Knapp, G. Schellhorn: Formale Methoden 272


HOL: Varianten und Vereinfachungen

◮ Eine Funktion f : A × B → C ist äquivalent zu f : A → (B → C): Currying

◮ Deshalb: Man kann auf mehrstellige Funktionen verzichten.

◮ Quantoren können als Abkürzung aufgefaßt werden: ∀x . ϕ gilt genau

dann, wenn λx . ϕ = λx . true.

◮ Notation: Wenn nur einstellige Funktionen: Schreibe f x statt f (x) wie in

funktionalen Programmiersprachen

◮ Einstellige Funktionen mit Polymorphie (Generics in Java) z. B. in Isabelle

◮ In KIV: nur mehrsortig, mehrstellige Funktionen, Parametrisierung statt

Polymorphie

A. Knapp, G. Schellhorn: Formale Methoden 273


HOL: Axiome

Die Erweiterung der Logik erfordert zusätzliche Axiome:

◮ Extensionalität: f = g ↔ ∀x . f (x) = g(x)

◮ realisiert als Regeln (expand left) und (expand right)

◮ β-Reduktion: (λx . f )(e) = f {x ↦→ e}

◮ im Simplifier

◮ Auswahlaxiom: (∀x . ∃y . ϕ) → ∃f . ∀x . ϕ{y ↦→ f (x)}

◮ realisiert als Regeln (choice left), (choice right)

A. Knapp, G. Schellhorn: Formale Methoden 274


Eigenschaften von HOL

◮ HOL-Kalkül ist (sehr) unvollständig, aber auch sehr ausdrucksstark

◮ Mengenlehre (mit evtl. unendlichen Mengen!) läßt sich codieren: Statt

{x | ϕ(x)} charakteristische (boolesche) Funktion λx . ϕ(x)

◮ Es gibt jetzt eine Formel für strukturelle Induktion mit Variable

P : nat → bool

∀P . (P(0) ∧ ∀n . P(n) → P(n+1)) → ∀n . P(n)

◮ automatisches Beweisen wird wesentlich schwieriger

A. Knapp, G. Schellhorn: Formale Methoden 275


Existenz und Eindeutigkeit: Beispiele (1a)

Spezifikation der Ganzzahldivision x div y

Nat ✁ div : nat nat → nat, Ax

Alternativen für Axiome Ax

◮ Ax1: y = 0 → (x div y = k ↔ k ∗ y ≤ x ∧ x < (k + 1) ∗ y)

◮ Ohne y = 0 inkonsistent

◮ Es gilt, daß ein passendes k immer existiert:

Nat |= ∀x, y . ∃k . y = 0 → k ∗ y ≤ x ∧ x < (k + 1) ∗ y

◮ div ist die Skolemfunktion dieser Formel

◮ Die entsprechende Formel mit Skolemfunktion eingesetzt ist:

Ax2: y = 0 → (x div y) ∗ y ≤ x ∧ x < ((x div y) + 1) ∗ y

◮ Wegen Skolemisierung Anreicherung mit Ax2 hierarchiepersistent

A. Knapp, G. Schellhorn: Formale Methoden 276


Existenz und Eindeutigkeit: Beispiel (1b)

◮ Ax2 ist äquivalent zu ” →“ in der Äquivalenz von Ax1

◮ Die Rückrichtung ” ←“ in der Äquivalenz verlangt, daß k eindeutig ist.

◮ Gäbe es zwei verschiedene k, die Ax1 erfüllen, wäre die Spezifikation

inkonsistent.

◮ Bei Ax2 ist die Spezifikation i. a. nicht eindeutig: Es gibt evtl. mehrere

Funktionen

◮ k ist aber eindeutig, denn es gilt:

|= y = 0 ∧ k ∗ y ≤ x < (k + 1) ∗ y ∧ k ′ ∗ y ≤ x < (k ′ + 1) ∗ y → k = k ′

◮ Eindeutigkeit garantiert, daß auch die Anreicherung eindeutig ist.

◮ Damit: Mit Ax1 zu spezifizieren, erfordert Nachweis der Existenz und der

Eindeutigkeit; mit Ax2 zu spezifizieren, erfordert nur Nachweis der

Existenz. Beide Axiome laufen ohne Beweise Gefahr, inkonsistent zu

werden.

A. Knapp, G. Schellhorn: Formale Methoden 277


Spezifikation über Existenz und Eindeutigkeit

Satz Sei ϕ(x, y) eine Formel mit freien Variablen x der Sortens und y der

Sorte s ′ über einer Spezifikation Sp. Außerdem sei

Dann gilt:

exists = ∀x . ∃y . ϕ(x, y)

unique = ∀x, y, z . ϕ(x, y) ∧ ϕ(x, z) → y = z

Sp ′ = Sp ✁ f : s → s ′ , f (x) = y ↔ ϕ(x, y)

Sp ′′ = Sp ✁ f : s → s ′ , ϕ(x, f (x))

◮ Wenn Sp |= exists, dann sind Sp ′ und Sp ′′ inkonsistent.

◮ Wenn Sp |= exists, dann ist Sp ′′ hierarchiepersistent.

◮ Wenn Sp |= unique, dann sind Sp ′ und Sp ′′ eindeutig.

◮ Wenn Sp |= unique, ist Sp ′ inkonsistent (aber nicht notwendig Sp ′′ ).

◮ Wenn Sp |= exists und Sp |= unique, sind Sp ′ und Sp ′′ äquivalent.

A. Knapp, G. Schellhorn: Formale Methoden 278


Existenz und Eindeutigkeit: Beispiele (2)

Spezifikation von .last und .butlast mit

last-butlast: x = [] → x.butlast + x.last = x

◮ Beweisbar ist: ∀x . ∃a . ∃y . x = [] → y + a = x

◮ Mit vorigem Satz ist Hinzunahme von .last mit Axiom

onlylast: ∀x . ∃y . x = [] → y + x.last = x

hierarchiepersistent

◮ Dieses Axiom hat wieder die Form ∀x . ∃y . . . .; also ist die Hinzunahme

von last-butlast hierarchiepersistent

◮ onlylast folgt aus last-butlast

◮ .last und .butlast sind eindeutig spezifiziert, weil

∀x . x = [] ∧ y + a = x ∧ y ′ + a ′ = x → y = y ′ ∧ a = a ′ gilt.

A. Knapp, G. Schellhorn: Formale Methoden 279


Existenz und Eindeutigkeit: Beispiele (1c)

Ganzzahldivision mit Existenz und Eindeutigkeit zu definieren, erfordert

Beweise.

Rekursive Ansätze

◮ Versuch 1: strukturell über y

◮ x div 0 wird nicht spezifiziert.

◮ Welches ϕ in x div (y +1) = ϕ(x div y) wählen?

◮ Versuch 2: strukturell über x

◮ div-base: y = 0 → 0 div y = 0

◮ Welches ϕ für div-rec: y = 0 → x +1 div y = ϕ(x div y) wählen?

◮ Es geht mit ϕ(z) = (x mod y = y −1 ⊃ z +1; z)

◮ Einfachere, implementierungsnahe rekursive Definition

div-base: x < y → x div y = 0

div-rec: y = 0 ∧ x ≥ y → x div y = (x − y) div y +1

◮ Korrektheit? Korrekt für y = 0? Eindeutigkeit?

A. Knapp, G. Schellhorn: Formale Methoden 280


Existenz und Eindeutigkeit: Beispiele (3)

Löschen aus Multimengen

◮ Axiome zum Löschen aller Vorkommen (delall) aus Multisets mit Hilfe des

Löschens eines Vorkommens (delone)

¬a ∈ s → delall(s, a) = s

a ∈ s → delall(s, a) = delall(delone(s, a), a)

◮ implementierungsnah

◮ Sinnvolle Definition?

A. Knapp, G. Schellhorn: Formale Methoden 281


Allgemeine rekursive Definition

Definition Eine allgemeine rekursive Definition für ein f ist gegeben durch

eine Menge von Axiomen der Form ϕ → f (x) = t, wobei sich die

Vorbedingungen ϕ gegenseitig ausschließen und f nicht enthalten, und in ϕ

und t nur die freien Variablen x vorkommen.

Wenn die Formeln ϕ alle Fälle abdecken, so heißt die Definition vollständig.

◮ In t dürfen (ein oder mehrere) rekursive Aufrufe f ( t ′ ) vorkommen.

◮ Vollständige Definitionen kann man durch Verwendung des

“if-then-else”-Operators ⊃ immer in der Form f (x) = t schreiben.

A. Knapp, G. Schellhorn: Formale Methoden 282


Rekursion und Nichtterminierung (1)

Ein rekursives Programm liefert immer eine eindeutige partielle Funktion (bei

Nichterminierung undefiniert). In Logik wird eine totale Funktion erzwungen. Die

Spezifikation kann dann uneindeutig oder auch inkonsistent sein.

Beispiele

◮ f(n) = f(n): Programm terminiert nicht, spezifiziert wird eine beliebige

Funktion

◮ f(n) = f(n +1) (über den natürlichen Zahlen): Programm terminiert nicht,

spezifiziert wird eine konstante Funktion

◮ f(n) = f(n) +1: Programm terminiert nicht, Spezifikation ist inkonsistent

◮ leq(i, j) ↔ i = j ∨ leq(i, j −1) (über den ganzen Zahlen): terminiert genau

für i ≤ j (und liefert true), Spezifikation hat auch: leq(i, j) gilt für alle i, j als

Modell.

A. Knapp, G. Schellhorn: Formale Methoden 283


Rekursion und Nichtterminierung (2)

Wenn die Rekursion nicht terminiert, ergibt sich in der Spezifikation Beliebiges.

Wir zeigen: Wenn die Rekursion immer terminiert, dann ergibt sich eine

eindeutig spezifizierte Funktion. Diese ist dann auch das Ergebnis der

Rekursion.

Sicherstellung der Termination

◮ Definiere Relation x ′ ≺ x durch ” f ( x ′ ) ist rekursiver Aufruf in f (x)“.

◮ Zeige, daß die Argumente abnehmen, und das nicht unendlich oft können.

◮ Nachweis, daß ≺ eine noethersche Relation ist.

A. Knapp, G. Schellhorn: Formale Methoden 284


Noethersche Relationen

Definition Sei A eine Menge und ≺ ⊆ A × A. Die Relation ≺ heißt

noethersch (oder wohlfundiert, engl. well-founded), wenn es keine unendlichen

≺-Ketten der Form . . . ≺ a3 ≺ a2 ≺ a1 ≺ a0 in A gibt.

Beispiele und Gegenbeispiele:

◮ < auf N ist noethersch.

◮ ⊂ auf endlichen Mengen ist noethersch (aber nicht ⊆).

◮ x ≪ y definiert durch length(x) < length(y) auf Listen ist noethersch.

◮ < auf Z ist nicht noethersch.

A. Knapp, G. Schellhorn: Formale Methoden 285


Noethersche Relationen: Beispiele (1)

Satz Ordnungsprädikate aus Datendefinitionen sind noethersch.

Beweisskizze t ≺ t ′ bedeutet, daß t weniger Konstruktoren als t ′ hat. Also kann eine

Kette, die bei t beginnt, nur Anzahl der Konstruktoren von t lang sein.

◮ insbesondere < für Nat noethersch

Satz Sei für einen Datentyp D eine Größenfunktion # : D → N gegeben.

Dann ist d ≺ d ′ definiert durch #(d) < #(d ′ ) eine noethersche Relation.

Beweisskizze Eine unendliche Kette . . . ≺ d2 ≺ d1 ≺ d0 ergäbe auch eine

unendliche Kette . . . < #(d2) < #(d1) < #(d0).

◮ Insbesondere für Größenfunktionen length für Listen, Kardinalität für

Mengen, die size functions in Datendefinitionen

◮ Fast alle Terminerungsbeweise funktionieren mit einer Größenfunktion.

A. Knapp, G. Schellhorn: Formale Methoden 286


Noethersche Relationen: Beispiele (2)

Satz Sind A und B Mengen und ≺1 ⊆ A × A und ≺2 ⊆ B × B noethersch,

so ist auch die lexikalische Kombination ≺ ⊆ (A × B) × (A × B) von ≺1 und

≺2 mit

(a, b) ≺ (a ′ , b ′ ) gdw. a ≺1 a ′ ∨ (a = a ′ ∧ b ≺2 b ′ )

noethersch.

Beweisskizze Angenommen es gäbe eine Kette . . . ≺ (a2, b2) ≺ (a1, b1) ≺ (a0, b0).

◮ Dann nimmt ai nach Definition in jedem Schritt (bzgl. ≺1) ab oder bleibt gleich.

◮ ai kann nicht unendlich oft abnehmen, da ≺1 noethersch ist. Also wird ai

irgendwann konstant.

◮ Ab dieser Stelle nimmt bi unendlich oft ab, im Widerspruch zur Voraussetzung,

daß ≺2 noethersch ist.

A. Knapp, G. Schellhorn: Formale Methoden 287


Noethersche Relationen und partielle Ordnungen

Satz Sei ≺ ⊆ A × A eine noethersche Relation.

◮ ≺ ist irreflexiv.

◮ Ist ≺ ′ ⊆ ≺, so ist ≺ ′ noethersch.

◮ Die transitive Hülle ≺ + ist noethersch und eine partielle Ordnung.

◮ Insbesondere kann man bei noetherschen Relationen immer Transitivität

fordern.

A. Knapp, G. Schellhorn: Formale Methoden 288


Noethersche Relationen und Rekursion

Für eine allgemeine rekursive Definition von f definiere man ein Prädikat

x ′ ≺ x, das genau dann zutrifft, wenn

◮ es einen Fall ϕ → f (x) = t gibt

◮ ϕ gilt und x ′ = t ′ für einen rekursiven Aufruf f ( t ′ ) in t.

Dann: Rekursion terminiert immer, genau dann, wenn ≺ noethersch.

Beispiel: Ganzzahldivision

◮ Axiom: y = 0 ∧ x ≥ y → x div y = (x − y) div y +1

◮ Zugehörige Relation:

(x ′ , y ′ ) ≺ (x, y) ↔ y = 0 ∧ x ≥ y ∧ x ′ = x − y ∧ y ′ = y.

◮ Es gilt offenbar: (x ′ , y ′ ) ≺ (x, y) → x ′ < x

◮ Damit ist nach dem vorigem Satz ≺ noethersch.

Allgemein: Man zeige für eine bekannte noethersche Relation, daß die

Argumente im rekursiven Aufruf abgenommen haben.

A. Knapp, G. Schellhorn: Formale Methoden 289


Wohlfundierte Rekursion

Satz Sei ≺ eine noethersche Relation, und sei eine vollständige allgemein

rekursive Definition mit Axiomen ϕ → f (x) = t gegeben. Dann gibt es zu jedem

Ausdruck e(x), der f nicht enthält, immer genau eine totale Funktion f , die die

folgenden abgeänderten Axiome erfüllt: ϕ → f (x) = t{f ↦→ f ′ }, wobei

f ′ (y) = (y ≺ x ⊃ f (y); e(y)).

Ohne Beweis

◮ Für fixe Stelligkeit im Kalkül beweisbar.

◮ Intuition: Die Rekursion wird abgebrochen (und irgendein e(y) als

Ergebnis genommen), wenn die Argumente nicht kleiner geworden sind.

◮ Für unvollständige Definitionen gilt, daß es zu jeder Ergänzung zu einer

vollständigen Definition eine Funktion gibt, die Definition also nicht mehr

eindeutig ist.

A. Knapp, G. Schellhorn: Formale Methoden 290


Wohlfundierte Rekursion: Beispiele

Ganzzahldivision

◮ Originalaxiom: y = 0 ∧ x ≥ y → x div y = (x − y) div y +1

◮ Modifiziertes Axiom (mit < ⊆ N × N als noetherscher Ordnung):

y = 0 ∧ x ≥ y → x div y = (x − y < x ⊃ (x − y) div y +1; e(x, y))

◮ Äquivalent zum Originalaxiom, da der “else”-Fall nie verwendet wird.

Löschen aus einer Multimenge

◮ Originalaxiom: a ∈ s → delall(s, a) = delall(delone(s, a), a)

◮ Modifiziertes Axiom (für Größe der Multimenge):

a ∈ s → delall(s, a) = delall(#delone(s, a) < #s ⊃

delall(delone(s, a), a); e(s, a))

◮ Äquivalent zum Original, da a ∈ s → #delone(s, a) < #s beweisbar ist.

Man kann allgemeine rekursive Definitionen auch nur dann erlauben, wenn ein ≺

angegeben wird und die Äquivalenz von Original und modifiziertem Axiom gezeigt

werden kann (als Option z. B. in Isabelle).

A. Knapp, G. Schellhorn: Formale Methoden 291


Charakterisierung noetherscher Relationen

Satz Eine Relation ≺ ⊆ A × A ist genau dann noethersch, wenn jede

nicht-leere Menge M ⊆ A ein ≺-minimales Element besitzt, es also ein

Element a ∈ M gibt, zu dem kein b ∈ M mit b ≺ a existiert.

Beweisskizze

” ⇒“: Angenommen es gibt eine Menge M ohne ≺-minimales Element.

◮ Wähle ein erstes Element a0 ∈ M (existiert, da M = ∅).

◮ Da es kein ≺-minimales Element in M ist, gibt es ein a1 ∈ M mit a1 ≺ a0.

◮ Zu a1 gibt es weiteres Element a2 ∈ M mit a2 ≺ a1 usw.

◮ Nach dem Auswahlaxiom kann man also eine unendliche absteigende Kette

konstruieren.

” ⇐“: Eine unendliche ≺-Kette als Menge {. . . , a1, a0} ist eine nicht-leere Menge ohne

≺-minimales Element.

A. Knapp, G. Schellhorn: Formale Methoden 292


Noethersche Relationen in Logik

Satz Sei ≺ ein zweistelliges Prädikatsymbol. Es gibt keine

prädikatenlogische Formel ϕ (in der ≺ vorkommt), sodaß gilt: A |= ϕ genau

dann, wenn ≺ A eine noethersche Relation ist.

Beweisskizze Falls es ein ϕ gäbe, betrachte man die Formelmenge

{. . . , c2 ≺ c1, c1 ≺ c0, ϕ} mit neuen Konstanten c0, c1, . . .. Die ganze Menge hat kein

Modell, aber jede endliche Teilmenge hat ein Modell, im Widerspruch zum

Endlichkeitssatz.

◮ In Higher-Order-Logik läßt sich eine solche Formel angeben

wf(≺) ↔ ∀P . (∃x . P(x)) → ∃y . P(y) ∧ ¬∃z . z ≺ y ∧ P(z)

◮ Prädikat P für Menge, ∃x . P(x) bedeutet, daß die Menge nicht leer ist, y ist

ein ≺-minimales Element

A. Knapp, G. Schellhorn: Formale Methoden 293


Noethersche Induktion

Satz Eine Relation ≺ ⊆ A × A is noethersch genau dann, wenn für jedes

P ⊆ A gilt: Wenn für jedes a ∈ A aus der Gültigkeit von P(a ′ ) für alle Elemente

a ′ ≺ a die Gültigkeit von P(a) gefolgert werden kann, so gilt P für alle Elemente

von A:

∀a . (∀a ′ . (a ′ ≺ a → P(a ′ )) → P(a)) → ∀b . P(b)

Beweisskizze

” ⇒“: Sei ≺ noethersch und der Vordersatz richtig, es gebe aber ein b

für das P(b) falsch ist. Dann ist die Menge aller b, für die P(b) falsch ist, nicht leer und

hat damit ein ≺-minimales Element a. Für alle Elemente a ′ ≺ a ist P(a ′ ) dann richtig,

und also nach dem Vordersatz auch P(a), im Widerspruch zur Annahme.

” ⇐“: Angenommen M ist eine nicht-leere Menge, die kein ≺-minimales Element hat.

Setze P(b) zu b /∈ M. Falls für ein a alle a ′ ≺ a nicht in M sind, so kann auch a nicht in

M sein, sonst wäre es ein ≺-minimales Element von M. Aus der Implikation folgt also:

kein Element ist in M, im Widerspruch zur Annahme.

A. Knapp, G. Schellhorn: Formale Methoden 294


Noethersche Induktionsregel

Definition Sei y = fvar(Γ ⇒ ∆) \ {x} und ≺ noethersch. Dann ist die

noethersche Induktionsregel über x gegeben durch

Beispiele

(Ind≺) ∀y . ∀x′ . x ′ ≺ x → ( Γ → ∆){x ↦→ x ′ }, Γ ⇒ ∆

Γ ⇒ ∆

◮ Natürliche Zahlen: ∀n0 . n0 < n → ϕ(n0) ⇒ ϕ(n)

⇒ ϕ(n)

◮ Listen: ∀l0 . (l0 ≪ l) → ϕ(l0) ⇒ ϕ(l)

⇒ ϕ(l)

A. Knapp, G. Schellhorn: Formale Methoden 295


Noethersche Induktion in KIV (1)

◮ In KIV ist die Regel (induction) mit den vordefinierten Ordnungsprädikaten

(pro Sorte eines) und den Größenfunktionen anwendbar.

◮ Größenfunktionen für nichtfreie Datentypen kann man mit ” Unit – Add

HeuristicInfo“ hinzufügen.

◮ Die Induktionshypothese wird in KIV als ” Ind-Hyp“ abgekürzt angezeigt.

◮ ” Goal-Again with Ind-Hyp“ zeigt die Induktionshypothese an.

◮ Anwendung der Induktionshypothese mit (apply induction) (statt (all left)).

A. Knapp, G. Schellhorn: Formale Methoden 296


Noethersche Induktion in KIV (2)

◮ Strukturelle Induktion für strukturell rekursiv definierte Funktionen

◮ Analog: Noethersche Induktion für wohlfundiert allgemein rekursiv

definierte Funktionen

◮ Typischer Beweis: Induktion — Definition anwenden —

Induktionshypothese anwenden

◮ Allerdings: Im Gegensatz zu struktureller Induktion kann die Definition

nicht als Rewriteregel angewandt werden. Für echte Programme gibt es

daher die KIV-Heuristik ” einmal Definition anwenden“.

A. Knapp, G. Schellhorn: Formale Methoden 297


Zusammenfassung

◮ Strukturierte Spezifikationen

◮ Anreicherung, Vereinigung, Umbenennung

◮ Hierarchiepersistenz, Eindeutigkeit

◮ Generische Spezfikationen

◮ Nichtfreie Datentypen

◮ Nichtrekursive, rekursive und allgemein rekursive Definitionen

◮ Noethersche Relationen, noethersche Induktion

◮ Resolution

◮ Higher-Order-Logik

A. Knapp, G. Schellhorn: Formale Methoden 298


Deduktion über Programme (1)

Alternative 1: Definition der Semantik von Programmen als Funktion auf einer

Datenstruktur: − : Program → SemanticValue

Vorteile:

Formale Definition und Beweise über die Semantik möglich: Korrektheit

der Typisierung, korrekte Compilation, etc.

◮ Keine Änderung der Logik

Nachteile:

◮ Kalkül für Programme muß reduziert werden auf Prädikatenlogik;

aufwendig, ineffizient

◮ Syntax der Programme (Parsing) exakt zu imitieren erfordert sehr viel

Flexibilität

◮ Programmvariablen nicht Variablen der Logik; man erbt keine Typisierung

◮ allerdings nutzt das nichts, wenn die Typen der Logik nicht den Typen der

Programmiersprache entsprechen

A. Knapp, G. Schellhorn: Formale Methoden 299


Deduktion über Programme (2)

Alternative 2: Erweiterung der Logik

◮ Programmvariablen sind Variablen der Logik.

◮ Ein Zustand eines Programms ist eine Belegung der Logik.

◮ Abstrakte Programme, die über abstrakte Datentypen (auch solche, die

nicht direkt schon in einer Programmiersprache vorhanden sind) und

abstrakte Konzepte reden, ohne schon mit allen Details von Programmen

” belastet“ zu sein.

A. Knapp, G. Schellhorn: Formale Methoden 300


Programme: Syntax

Definition Die Menge der Programme p ∈ P(Σ, X) besteht aus

◮ Sofortige Termination: skip

◮ Nichtterminierung: abort

◮ Parallele Zuweisung: x1 := t1, x2 := t2, . . ., xn := tn

◮ mit Variablen xi ∈ X, Termen ti ∈ T (Σ, X)

◮ kurz: x :=t

◮ Sequentielle Komposition: p1 ; p2

◮ Fallunterscheidung: if b then p1 else p2

◮ b ist (normalerweise) quantorenfreie Formel aus F (Σ, X)

◮ Abkürzung: if b then p für if b then p else skip

◮ Schleife: while b do p

◮ In konkreter Syntax Blöcke begin p end für eindeutige Klammerung.

A. Knapp, G. Schellhorn: Formale Methoden 301


Programme: Zustände

Für eine Σ-Algebra A betrachtet man die Menge

SA = {v | v :

s∈S Xs → As}

der Variablenbelegungen.

◮ Im folgenden meist nur S (ohne Index), wenn Algebra A klar.

◮ Eine Variablenbelegung aus S kann man als einen Zustand eines

Programms ansehen.

◮ Einfachster Fall eines Zustands; genügt für abstrakte Programme.

◮ Für komplexere Programme allgemeiner: Ein Zustand enthält eine

Variablenbelegung.

A. Knapp, G. Schellhorn: Formale Methoden 302


Programmsemantik: Ein-/Ausgabe-Verhalten

Für die Definition einer Semantik von Programmen oder auch anderen

Spezifikations- und Programmierkonstrukten hat man immer zwei

Möglichkeiten, je nachdem welche Eigenschaften interessant sind.

Alternative 1: Beschreibung des Effekts, d. h. des Ein- Ausgabeverhaltens eines

Programms oder Ausdrucks

◮ Big-step Semantik: p(input) = output

◮ genügt für den Korrektheitsnachweis von Kalkülen für sequentielle

Programme

◮ auch relevant für funktionale und sequentielle objektorientierte Programme

und Ausdrücke

◮ auch verwendet für die Definition von Logik

A. Knapp, G. Schellhorn: Formale Methoden 303


Programmsemantik: Abläufe

Alternative 2: Berücksichtigung von Zwischenzuständen

◮ Explizite Trace-Semantik (Menge von Abläufen) oder implizite small-step

Semantik (Schritte von (p, v) nach (p ′ , v ′ ); die Abläufe ergeben sich

generisch)

◮ feingranularer und maschinennäher als Alternative 1

◮ relevant für Compilerbau: jeder Schritt wird durch Maschineninstruktionen

implementiert

◮ relevant für parallele Systeme (z. B. Threads, Statecharts)

◮ relevant für die Modellierung von allen Systemen, die evtl. endlos laufen

(z. B. Betriebssysteme, eingebettete Systeme etc.)

◮ notwendig als Semantik für Kalküle, die über die Zwischenzustände reden

(Temporallogik: ” es gilt ständig ϕ“, ” es gilt immer wieder ϕ“)

A. Knapp, G. Schellhorn: Formale Methoden 304


Programme: Relationale Semantik (1)

Ein Programm überführt einen Anfangszustand in einen Endzustand:

p : S → S

Probleme mit dieser Semantik:

◮ Was ist die Semantik von abort?

◮ Addiere ⊥ mit der Bedeutung ” terminiert nicht“: p : S → S ∪ {⊥}

◮ Wie auf indeterministische Programme erweitern?

◮ nicht nur ein Ergebnis, sondern potentiell mehrere

A. Knapp, G. Schellhorn: Formale Methoden 305


Programme: Relationale Semantik (2)

Deshalb: Relationale Semantik

Rp ⊆ S × S

◮ (v, v ′ ) ∈ Rp bedeutet: Zustand v wird von p in v ′ überführt

◮ Wenn zu v kein v ′ mit (v, v ′ ) ∈ Rp vorhanden ist: s terminiert nicht,

wenn in v gestartet

◮ Wenn {(v, v ′ ), (v, v ′′ )} ⊆ Rp, so ist das Programm mit v gestartet

indeterministisch mit zwei möglichen Endzuständen: v ′ und v ′′

◮ Derzeit betrachtete Programme sind deterministisch: zu jedem v

höchstens ein v ′

A. Knapp, G. Schellhorn: Formale Methoden 306


Programme: Relationale Semantik (3)

Definition Die relationale Semantik Rp A eines Programmes

p ∈ P(Σ, X) bzgl. der Algebra A ∈ Alg(Σ) ist rekursiv gegeben durch

Rabort A = ∅

Rskip A = {(v, v) | v ∈ SA}

Rx :=t A = {(v, w) | w = v{x ↦→ T t A v}}

Rp1 ; p2 A = {(u, w) | ∃v . (u, v) ∈ Rp1 A ∧ (v, w) ∈ Rp2 A}

Rif b then p1 else p2 A =

{(v, w) | (A, v |= b ∧ (v, w) ∈ Rp1 A) ∨

(A, v |= ¬b ∧ (v, w) ∈ Rp2 A)}

Rwhile b do p A =


n∈N R(if b then p else abort)n ; if b then abort A

wobei pn = p ; ...; p (formal p


n mal

0 = skip, pn+1 = p ; pn )

A. Knapp, G. Schellhorn: Formale Methoden 307


Korrektheitsbegriffe für Programme

Partielle Korrektheit: {ϕ} p {ψ}

◮ Falls zu Beginn ϕ gilt und p terminiert,

◮ dann gilt anschließend ψ.

Totale Korrektheit: [ϕ] p [ψ]

◮ Falls zu Beginn ϕ gilt,

◮ dann terminiert p und anschließend gilt ψ.

◮ ϕ heißt Vorbedingung für das Programm p, ψ die Nachbedingung.

◮ Die Angabe einer Vor- und Nachbedingung ist die Standardmethode, um

die Funktionalität einzelner Programme (Prozeduren, Methoden) zu

spezifizieren.

◮ Vor- und Nachbedingung zusammen heißen oft Kontrakt.

A. Knapp, G. Schellhorn: Formale Methoden 308


Korrektheitsaussagen: Semantik

Definition Sei p ∈ P(Σ, X), A ∈ Alg(Σ), ϕ, ψ ∈ F (Σ, X).

◮ A |= {ϕ} p {ψ}, falls für jedes v ∈ SA mit A, v |= ϕ und jedes w ∈ SA

mit (v, w) ∈ Rp A gilt: A, w |= ψ.

◮ A |= [ϕ] p [ψ], falls es für jedes v ∈ SA mit A, v |= ϕ ein w ∈ SA gibt mit

(v, w) ∈ Rp A und A, w |= ψ.

A. Knapp, G. Schellhorn: Formale Methoden 309


Korrektheitsaussagen: Beispiele

Partielle Korrektheit

◮ |= {true} x := 2 {x = 2}

◮ |= {x = 2} x := x + 1 {x = 3}

◮ |= {x = y} x := x + 1 {x − 1 = y}

◮ |= {x = a ∧ y = b} x := y, y := x {x = b ∧ y = a}

◮ |= {x = 2} abort {x > 2}

Unterschied partielle und totale Korrektheit

◮ |= {true} if y = 0 then abort else x := 1 {x = 1}

◮ |= [true] if y = 0 then abort else x := 1 [x = 1]

◮ |= [y = 0] if y = 0 then abort else x := 1 [x = 1]

A. Knapp, G. Schellhorn: Formale Methoden 310


Hoare-Kalküle

◮ Entwickelt von Robert W. Floyd (1967) und Charles A. R. Hoare (1969)

Sp ⊢HP {ϕ} p {ψ}

Sp ⊢HT [ϕ] p [ψ]

◮ Kalküle HP, HT: Regeln zur Behandlung von Programmen zusammen mit

Regeln des Sequenzenkalküls

A. Knapp, G. Schellhorn: Formale Methoden 311


Hoare-Kalkül für partielle Korrektheit: Regeln (1)

(skiphp)

(aborthp)

(assignhp)

(seqhp)

{ϕ} skip {ϕ}

{ϕ} abort {ψ}

{ϕ{x ↦→t}}x :=t {ϕ}

{ϕ} p1 {ψ} {ψ} p2 {χ}

{ϕ} p1 ; p2 {χ}

A. Knapp, G. Schellhorn: Formale Methoden 312


Hoare-Kalkül für partielle Korrektheit: Regeln (2)

(ifhp)

(whilehp)

(conshp)

{ϕ ∧ b} p1 {ψ} {ϕ ∧ ¬b} p2 {ψ}

{ϕ} if b then p1 else p2 {ψ}

{ϕ ∧ b} p {ϕ}

{ϕ} while b do p {ϕ ∧ ¬b}

{ϕ ′ } p {ψ ′ }

{ϕ} p {ψ} , falls Sp ⊢PL ϕ → ϕ ′ , Sp ⊢PL ψ ′ → ψ

◮ In (whilehp) ϕ Invariante

A. Knapp, G. Schellhorn: Formale Methoden 313


Hoare-Kalkül für partielle Korrektheit: Beweisabriß

Proof outline

◮ Einfügung von Zusicherungen {ϕ} nach jeder Zeile eines Programms

◮ eventuell Auslassung von (conshp)-Anwendungen

◮ Insbesondere Angabe der Invariante

A. Knapp, G. Schellhorn: Formale Methoden 314


Hoare-Kalkül für partielle Korrektheit: Beispiel (1)

Beweisabriß

{x ≥ 0 ∧ y > 0}

ϕ1: {x = 0 ∗ y + x ∧ x ≥ 0 ∧ y > 0}

d := 0;

ψ1 = ϕ2: {x = d ∗ y + x ∧ x ≥ 0 ∧ x ≥ 0 ∧ y > 0}

r := x;

ψ2 = Inv: {x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0}

while r ≥ y do begin

Inv ∧ r ≥ y: {x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r ≥ y}

Inv{d ↦→ d + 1}{r ↦→ r − y}:

{x = (d + 1) ∗ y + (r − y) ∧ r − y ≥ 0 ∧ x ≥ 0 ∧ y > 0}

r := r − y;

Inv{d ↦→ d + 1}: {x = (d + 1) ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0}

d := d + 1;

Inv: {x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0}

end

Inv ∧ r < y: {x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r < y}

{d = x div y}

A. Knapp, G. Schellhorn: Formale Methoden 315


Hoare-Kalkül für partielle Korrektheit: Beispiel (2)

{d = x div y}

Inv ∧ r < y

{x ≥ 0 ∧ y > 0}

ϕ1

d := 0

ψ1

ϕ2

r := x

ψ2

Inv

r ≥ y

r := r − y

d := d + 1

Inv

Inv ∧ r ≥ y

Inv{d ↦→ d + 1}{r ↦→ r − y}

Inv{d ↦→ d + 1}

A. Knapp, G. Schellhorn: Formale Methoden 316


Hoare-Kalkül für partielle Korrektheit: Beispiel (3)

Inv ∧ r < y

d = x div y

x ≥ 0 ∧ y > 0

Inv{r ↦→ x}{d ↦→ 0}

r < y

Inv{r ↦→ x}

Inv

d := 0

r := x

r ≥ y

Inv ∧ r ≥ y

Inv{d ↦→ d + 1}{r ↦→ r − y}

r := r − y

Inv{d ↦→ d + 1}

d := d + 1

A. Knapp, G. Schellhorn: Formale Methoden 317


Hoare-Kalkül für totale Korrektheit

HT wie HP (mit [−] statt {−}), nur Änderungen für abort und while wegen

möglicher Nichtterminierung.

Bedingung bei abort-Regel: Vorbedingung muß falsch sein:

(abortht) [ϕ] abort [ψ], falls ⊢PL ¬ϕ

Bedingung bei while-Regel: Schleife darf nur endlich oft durchlaufen werden:

Benutze dazu noethersche Ordnung ≺ und einen Term t, der durch das

Programm bzgl. ≺ verkleinert wird, sowie eine Variable x /∈ var(p).

(whileht)

[ϕ ∧ b ∧ x = t] p [ϕ ∧ t ≺ x]

[ϕ] while b do p [ϕ ∧ ¬b]

A. Knapp, G. Schellhorn: Formale Methoden 318


Hoare-Kalkül für totale Korrektheit: Beispiel

Beweisabriß

[x ≥ 0 ∧ y > 0]

[x = 0 ∗ y + x ∧ x ≥ 0 ∧ y > 0]

d := 0;

[x = d ∗ y + x ∧ x ≥ 0 ∧ x ≥ 0 ∧ y > 0]

r := x;

[x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0]

while r ≥ y do begin

[x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r ≥ y ∧ a = r]

[x = (d + 1) ∗ y + (r − y) ∧ r − y ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r − y < a]

r := r − y;

[x = (d + 1) ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r < a]

d := d + 1;

[x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r < a]

end

[x = d ∗ y + r ∧ r ≥ 0 ∧ x ≥ 0 ∧ y > 0 ∧ r < y]

[d = x div y]

A. Knapp, G. Schellhorn: Formale Methoden 319


Korrektheit der Hoare-Kalküle

Satz Die Hoare-Kalküle für partielle und totale Korrektheit sind korrekt. Es

gilt:

und

Sp ⊢HP {ϕ} p {ψ} ⇒ Sp |= {ϕ} p {ψ}

Sp ⊢HT [ϕ] p [ψ] ⇒ Sp |= [ϕ] p [ψ]

Ohne Beweis

A. Knapp, G. Schellhorn: Formale Methoden 320


Unvollständigkeit des Hoare-Kalküls

Nat = data specification

nat = 0 | . +1 (. -1 : nat)

end data specification

{x = 0 ∧ y = y0}

while y = 0 do begin

y := y -1;

x := x +1

end

{x = y0}

Schleifeninvariante x + y = y0 keine Formel in Nat

◮ selbes Problem wie bei Induktionshypothesen

A. Knapp, G. Schellhorn: Formale Methoden 321


Relative Vollständigkeit des Hoare-Kalküls

Satz Die Hoare-Kalküle für partielle und totale Korrektheit sind

unvollständig.

Wenn die zugrundeliegende Spezifikation die Arithmetik mit (0, 1, +, ∗) enthält,

ist der Kalkül vollständig, wenn man annimmt, alle wahren Aussagen über

(0, 1, +, ∗) seien als Axiome vorhanden (relative Vollständigkeit).

Ohne Beweis (Stephen A. Cook 1978)

◮ Die Unvollständigkeit liegt daran, daß ” eine Schleife wird endlich oft iteriert“

dieselbe Problematik wie die Generiertheitsklausel hat (jede natürliche

Zahl kann mit endlich vielen s-Aufrufen errreicht werden).

◮ Die relative Vollständigkeit folgt daraus, daß man mit (0, 1, +, ∗) alle

Programme in arithmetische Formeln codieren kann.

A. Knapp, G. Schellhorn: Formale Methoden 322


Dynamische Logik

◮ Modale Logik für Korrektheit von Programmen

◮ Erweiterung der Formeln um Programme, Erweiterung des Kalküls für

neue Formeln

◮ Entwickelt von Vaughan R. Pratt (1976)

◮ basierend auf Andrzej Salwickis algorithmischer Logik (1970)

◮ Bezeichnung ” dynamische Logik“ von David Harel (1977)

A. Knapp, G. Schellhorn: Formale Methoden 323


Dynamische Logik: Syntax (1)

Definition Die Menge D(Σ, X) der Formeln der dynamischen Logik über

der Signatur Σ und der Variablenmenge X enthält

◮ alle prädikatenlogischen Formeln F (Σ, X)

◮ für p ∈ P(Σ, X) und ϕ ∈ D(Σ, X) auch [p]ϕ und 〈p〉ϕ.

Informelle Bedeutung

◮ [p]ϕ: ” Wenn p terminiert, gilt anschließend ϕ“

◮ 〈p〉ϕ: ” p hält, und anschließend gilt ϕ“

In KIV sind statt der prädikatenlogischen Formeln ϕ alle Higher-Order-Formeln

(boolesche Ausdrücke) zugelassen.

A. Knapp, G. Schellhorn: Formale Methoden 324


Einordnung der dynamischen Logik

◮ Dynamische Logik ist eine (Multi-)Modallogik.

◮ Für jedes Programm gibt es einen Modal-Operator ✷ und einen

Modal-Operator ♦ (mit dem Programm in der “box” und dem “diamond”).

◮ Modallogik mit Formeln ✷ϕ und ♦ϕ stammen aus der philosophischen

Logik.

◮ Alethisch: ” Es ist notwendig, daß ϕ“, ” es ist möglich, daß ϕ“

◮ Epistemisch: ” Ich halte es für gewiß, daß ϕ“, ” ich halte es für möglich, daß ϕ“

◮ Deontisch: ” Es wird geboten, daß ϕ“, ” es ist erlaubt, daß ϕ“

◮ Temporal: ” ϕ gilt in der Zukunft immer“, ” ϕ gilt irgendwann in der Zukunft“

A. Knapp, G. Schellhorn: Formale Methoden 325


Dynamische Logik: Syntax (2)

◮ Modal-Operatoren binden stärker als Junktoren:

[p]ϕ ∧ ψ bedeutet ([p]ϕ) ∧ ψ

◮ Schachtelung möglich:

〈p1〉〈p2〉ϕ bedeutet 〈p1〉(〈p2〉ϕ)

◮ Auch gemischte Schachtelung: [p1](∀x . ϕ ∧ 〈p2〉ψ)

◮ Auch in dynamischer Logik betrachtet man Sequenzen, z. B.

〈p1〉ϕ, ψ ⇒ 〈p2〉〈p1〉χ, ρ

A. Knapp, G. Schellhorn: Formale Methoden 326


Dynamische Logik: Semantik

Definition Die Semantik von Formeln der dynamischen Logik ist definiert als

A, v |= [p]ϕ ⇐⇒ für alle w ∈ SA: wenn (v, w) ∈ Rp A, dann A, w |= ϕ

A, v |= 〈p〉ϕ ⇐⇒ es gibt ein w ∈ SA mit (v, w) ∈ Rp A und A, w |= ϕ

◮ Es gilt: [p]ϕ ↔ ¬〈p〉¬ϕ

◮ Man könnte also Box mit Hilfe von Diamond definieren.

◮ Hoare-Tripel können als spezielle Formeln der dynamischen Logik

angesehen werden:

A, v |= {ϕ} p {ψ} ⇐⇒ A, v |= ϕ → [p]ψ

A, v |= [ϕ] p [ψ] ⇐⇒ A, v |= ϕ → 〈p〉ψ

A. Knapp, G. Schellhorn: Formale Methoden 327


Dynamische Logik als Verallgemeinerung der Hoare-Logiken

◮ Wenn x in p vorkommt, x0 aber nicht, so besagt 〈p〉x = x0: ” Am Ende von

p hat x den Wert, den x0 jetzt hat“.

◮ 〈p1〉x = x0 → 〈p2〉x = x0 besagt: ” Wann immer p1 in x einen Wert x0

ausrechnet, so tut das auch p2“

◮ Man kann in dynamischer Logik also über Programmähnlichkeit reden;

wichtig, wenn man von einer abstrakten Spezifikation (mit abstrakten

Programmen) zu konkreten übergehen will (Verfeinerung).

A. Knapp, G. Schellhorn: Formale Methoden 328


Dynamische Logik: Beispiele

◮ |= [x := 1]x = 1

◮ |= x = x0 → [x := x + 1]x = x0 + 1

◮ |= x = x0 → 〈x := x + 1〉x = x0 + 1

Unterschied Box und Diamond:

◮ |= x = 5 → [abort]x = 5

◮ |= x = 5 → 〈abort〉x = 5

In Sequenzen Programme auch im Antezedent:

◮ |= x = x0 ⇒ [x := x + 1]x = x0 + 1

◮ |= x > 0 ⇒ 〈while x > 1 do x := x − 1〉x = 1

◮ |= 〈if x > 0 then y := 1 else abort〉y = y0 ⇒ y0 = 1 ∧ x > 0

◮ |= [if x > 0 then y := 1 else abort]y = y0 ⇒

y0 = 1 ∧ x > 0 ∨ x = 0

A. Knapp, G. Schellhorn: Formale Methoden 329


Sequenzenkalkül DL für dynamische Logik

Symbolische Ausführung von Programmen

Ausführung des Programms

p1 ; p2 ; . . . ; pn

(pi ohne ; auf oberster Ebene)

◮ Annahme: Initialer Zustand erfüllt Vorbedingung ϕ0.

◮ Berechne ϕ1, die stärkste Formel, die nach p1 gilt;

◮ berechne ϕ2, die stärkste Formel, die nach p1 ; p2 gilt;

◮ . . . solange, bis das Programm abgearbeitet ist.

◮ Zum Schluß: Teste, ob ϕn die Nachbedingung impliziert (nur noch PL).

◮ Gegenüber Hoare-Kalkül: Kein Raten von Zwischenformeln bzw.

Rückwärtsausführen, stattdessen Zuweisung vorwärts ausführen.

◮ Symbolische Ausführung sowohl im Antezedent als auch im Sukzedent.

A. Knapp, G. Schellhorn: Formale Methoden 330


Sequenzenkalkül DL: Sequentielle Komposition

(L[;]) [p1][p2]ϕ, Γ ⇒ ∆

[p1 ; p2]ϕ, Γ ⇒ ∆

(L〈;〉) 〈p1〉〈p2〉ϕ, Γ ⇒ ∆

〈p1 ; p2〉ϕ, Γ ⇒ ∆

◮ Normalisierung

(R[;]) Γ ⇒ [p1][p2]ϕ, ∆

Γ ⇒ [p1 ; p2]ϕ, ∆

(R〈;〉) Γ ⇒ 〈p1〉〈p2〉ϕ, ∆

Γ ⇒ 〈p1 ; p2〉ϕ, ∆

◮ In KIV: Nie explizit angewendet; die erste Anweisung wird bei jeder

Regelanwendung (in allen Programmformeln) immer automatisch

abgespalten; Programmformeln werden nach vorne rotiert.

A. Knapp, G. Schellhorn: Formale Methoden 331


Sequenzenkalkül DL: Zuweisung (1)

Originalregel im Hoare-Kalkül würde besagen:

Γ ⇒ ([p]ϕ){x ↦→ t}, ∆

Γ ⇒ [x := t][p]ϕ, ∆

Aber ([p]ϕ){x ↦→ t} kann nicht [p{x ↦→ t}](ϕ{x ↦→ t}) sein:

◮ Für t = 3 und p = x := x + 1 ergäbe sich

([x := x + 1]x = 5){x ↦→ 3} = [3 := 3 + 1]3 = 5

◮ Die Substitution müßte den Effekt der Zuweisung in das Programm

” hineinziehen“. Das geht für die Zuweisung hier (Resultat wäre x := 3 + 1

und die Nachbedingung bliebe x = 5), aber nicht für allgemeine

Programme (insbesondere Schleifen).

◮ Substitution wird aber für Quantorenregeln (L∀), (R∃) gebraucht.

A. Knapp, G. Schellhorn: Formale Methoden 332


Dynamische Logik: Substitution und Umbenennung

Definition Das Resultat einer Substitution in einer Programmformel ist

([p]ϕ){x ↦→t} = [x :=t][p]ϕ

(〈p〉ϕ){x ↦→t} = 〈x :=t〉〈p〉ϕ

Damit ist die Hoare-Regel für DL für eine Programmformel ϕ nicht verwendbar.

◮ Bei (R∀), (L∃) werden Variablen in neue umbenannt; das geht auch für

Programmformeln.

Definition Die in einem Programm p vorkommenden Variablen werden mit

var(p) bezeichnet.

Für eine Programmformel π = [p]ϕ oder π = 〈p〉ϕ ist die Menge der freien

Variablen fvar(π) gegeben durch var(p) ∪ fvar(ϕ).

A. Knapp, G. Schellhorn: Formale Methoden 333


Sequenzenkalkül DL: Zuweisung (2)

(L[:=]1) ϕ{x ↦→t}, Γ ⇒ ∆

[x :=t]ϕ, Γ ⇒ ∆

(R[:=]1) Γ ⇒ ϕ{x ↦→t}, ∆

Γ ⇒ [x :=t]ϕ, ∆

(1) y /∈ fvar([x :=t][p]ϕ) ∪ fvar(Γ) ∪ fvar(∆)

◮ Analog: (L〈:=〉1), (L〈:=〉2), (R〈:=〉1), (R〈:=〉2)

(L[:=]2) y =t, [p{x ↦→ y}]ϕ{x ↦→ y}, Γ ⇒ ∆

[x :=t][p]ϕ, Γ ⇒ ∆ (1)

(R[:=]2) y =t, Γ ⇒ [p{x ↦→ y}]ϕ{x ↦→ y}, ∆

Γ ⇒ [x :=t][p]ϕ, ∆ (1)

◮ Neue Programmvariablen y bezeichnen die neuen Werte von x

◮ In KIV: (assign left/right) kombinieren beide Regeln: ” Hoare-Regeln“

(L/R[:=]1), falls ϕ kein Programm enthält, sonst (L/R[:=]2).

A. Knapp, G. Schellhorn: Formale Methoden 334


Sequenzenkalkül DL: Fallunterscheidung

(L[if]) b, [p1]ϕ, Γ ⇒ ∆ ¬b, [p2]ϕ, Γ ⇒ ∆

[if b then p1 else p2]ϕ, Γ ⇒ ∆

(R[if]) Γ, b ⇒ [p1]ϕ, ∆ Γ, ¬b ⇒ [p2]ϕ, ∆

Γ ⇒ [if b then p1 else p2]ϕ, ∆

◮ Analog: (L〈if〉), (R〈if〉),

◮ KIV versucht immer die Tests zu entscheiden (per Simplifier), damit nur

eine Prämisse entsteht.

A. Knapp, G. Schellhorn: Formale Methoden 335


Sequenzenkalkül DL: Schleife

Γ ⇒ ψ, ∆ ψ, b ⇒ [p]ψ ψ, ¬b ⇒ ϕ

(R[while])

Γ ⇒ [while b do p]ϕ, ∆

Γ ⇒ ψ, ∆ ψ, b, x = t ⇒ 〈p〉(ψ ∧ t ≺ x) ψ, ¬b ⇒ ϕ

(R〈while〉) (2)

Γ ⇒ 〈while b do p〉ϕ, ∆

(2) x /∈ fvar([while b do p]ϕ)

◮ Analog: (L[while]), (L〈while〉)

◮ In KIV: Die Schleifeninvariante ψ und die Schranke t müssen von Hand

eingegeben werden.

A. Knapp, G. Schellhorn: Formale Methoden 336


Sequenzenkalkül DL: (Nicht-)Termination

Γ ⇒ ∆

(L[abort])

[abort]ϕ, Γ ⇒ ∆

(L〈abort〉) 〈abort〉ϕ, Γ ⇒ ∆

ϕ, Γ ⇒ ∆

(L[skip])

[skip]ϕ, Γ ⇒ ∆

ϕ, Γ ⇒ ∆

(L〈skip〉)

〈skip〉ϕ, Γ ⇒ ∆

(R[abort]) Γ ⇒ [abort]ϕ, ∆

Γ ⇒ ∆

(R〈abort〉)

Γ ⇒ 〈abort〉ϕ, ∆

Γ ⇒ ϕ, ∆

(R[skip])

Γ ⇒ [skip]ϕ, ∆

Γ ⇒ ϕ, ∆

(R〈skip〉)

Γ ⇒ 〈skip〉ϕ, ∆

A. Knapp, G. Schellhorn: Formale Methoden 337


Lokale Variablen

Neues Programmkonstrukt let x =t in p für lokale Variablen

◮ Variablen x duplikatfrei

Relationale Semantik

Rlet x =t in p A =

{(v, v ′ ) | ∃v ′′ . (v{x ↦→ T t A v}, v ′′ ) ∈ Rp A ∧

v ′ = v ′′ {x ↦→ v(x)}}

A. Knapp, G. Schellhorn: Formale Methoden 338


Lokale Variablen: Kalkülregeln

Der partielle (und genauso der totale) Hoare-Kalkül wird um die folgende Regel

erweitert (y sind neue Variablen):

(lethp) {x =t{x ↦→ y} ∧ ϕ{x ↦→ y}} p {ψ{x ↦→ y}}

{ϕ} let x =t in p {ψ}

Für die Dynamische Logik erhält man (y sind neue Variablen):

(L[let]) y =t, [p{x ↦→ y}]ϕ, Γ ⇒ ∆

[let x =t in p]ϕ, Γ ⇒ ∆

(R[let]) y =t, Γ ⇒ [p{x ↦→ y}]ϕ, ∆

Γ ⇒ [let x =t in p]ϕ, ∆

und dieselben Regeln für Diamonds statt Boxes.

A. Knapp, G. Schellhorn: Formale Methoden 339


Prozeduren: Syntax (1)

Neues Programmkonstrukt q(t; z) für Prozeduraufrufe

◮ q ist Prozedurname.

◮ Termet der Sortens sind (aktuelle) Eingabeparameter.

◮ Paarweise verschiedene Variablenz der Sortens ′ sind (aktuelle)

In KIV:

I/O-Parameter.

◮ Konvention für Prozedurenamen: q#

◮ Prozedurdefinitionen q# s : s ′ ∈ Proc sind neuer Bestandteil der Signatur

einer DL-Spezifikation: Σ = (S, F, P, Proc)

◮ s : s ′ heißt (Aufrufs-)Modus der Prozedur.

◮ Definitionen zwischen predicates und variables per

procedures q# s1 × . . . × sn : s ′ 1 × . . . × s′ m;

A. Knapp, G. Schellhorn: Formale Methoden 340


Prozeduren: Syntax (2)

Eine Prozedurdeklaration hat die Form q(x; y) p mit formalen

Eingabeparametern x und formalen I/O-Parametern y. Die Parameter x, y sind

paarweise verschieden. Eine DL-Spezfikation enthält neben Signatur,

Variablen, Axiomen und Generiertheitsklauseln eine Menge von

Prozedurdeklarationen Decl mit paarweise verschiedenen Prozeduren:

DLSpec = ((S, F, P, Proc), X, Ax, Gen, Decl).

In KIV:

◮ Es ist nicht erforderlich, für jede Prozedur eine Deklaration anzugeben.

Man kann Prozeduren auch nur mit Axiomen (z. B. Vor-/Nachbedingung)

spezifizieren.

◮ Gegenseitige Rekursion ist erlaubt.

A. Knapp, G. Schellhorn: Formale Methoden 341


Prozedurdeklarationen in KIV: Beispiel (1)

Prozedurdeklarationen nach axioms

procedures f# nat : nat;

declaration f#(x; y) begin

if x = 0

then y := 1

else begin

f#(x -1; y); y := y * x

end

end;

Die Prozedur ist funktional (das Ergebnis in y hängt nicht vom Anfangswert ab;

i. e. y wird nur als Ausgabeparameter benutzt). Sie verwendet keine globalen

Variablen.

A. Knapp, G. Schellhorn: Formale Methoden 342


Prozedurdeklarationen in KIV: Beispiel (2)

procedures MAXL# natlist : nat;

MAX# nat, nat : nat;

declaration MAX#(m, n; n0) begin

if m < n

then n0 := n

else n0 := m

end;

MAXL#(x; n) begin

if x = []

then n := 0

else begin

MAXL#(x.rest; n); MAX#(n, x.first; n)

end

end;

A. Knapp, G. Schellhorn: Formale Methoden 343


KIV-Prozeduren: Funktionsprozeduren

◮ Prozeduren in KIV relativ einfach, keine Funktionsprozeduren (oder

äquivalent Methoden mit Ergebnis).

Zusätzliche Komplexität von Funktionsprozeduren:

◮ Terme müssen jetzt auch Prozedurnamen enthalten.

◮ Eine Möglichkeit: Prozedurnamen = Funktionsbezeichner für Funktionen

mit einem Spezialergebnis ⊥ für Nichtterminierung.

◮ Nichtterminierung (und evtl. Exceptions) muß nicht nur auf der

Programmebene, sondern auch auf der Termebene (also überall)

berücksichtigt werden.

A. Knapp, G. Schellhorn: Formale Methoden 344


KIV-Prozeduren: Alternative zur Modellierung

Deklarationen in KIV sind Teil der Spezifikation.

Alternative: Deklarationen sind Teil des Zustands (oder gleichwertig: neben

dem Zustand noch eine Umgebung für die Semantikdefinition).

◮ Vorteil: Die Semantik einer kompletten Klasse oder eines Pakets wird

spezifizierbar, Deklarationen sind dynamisch überschreibbar.

Programmiersprachensemantiken wählen deshalb meist diese Alternative.

◮ Nachteil: Keine nur spezifizierten und nicht implementierten Prozeduren.

Mit DL-Axiomen für Prozeduraufrufe kann man beliebige partielle

Funktionen (Definitionsbereich = Terminierungsbereich) beschreiben.

A. Knapp, G. Schellhorn: Formale Methoden 345


Prozeduren: Relationale Semantik

Analogie: Schleifen sind spezielle Form der Rekursion (tail recursion).

while b do p

entspricht dem Aufruf einer Prozedur w mit

w() begin if b then p; w() else skip end

Der Zahl der Schleifendurchläufe entspricht gerade der Rekursionstiefe.

◮ Bei Schleifen kann die Semantik iteriert werden: Rif b then p n ; bei

Prozeduren nicht so einfach.

◮ Für Schleifen geht es auch syntaktisch: loop p times n in KIV; das geht

auch für Prozeduren.

A. Knapp, G. Schellhorn: Formale Methoden 346


Tiefenbeschränkte Rekursion

Beschränkung der Rekursionstiefe in Analogie zur Beschränkung der

Iterationszahl mit loop.

Neues Programmkonstrukt q(t; z) : c für beschränkten Prozeduraufruf

◮ c Term der Sorte nat: maximale Rekursionstiefe (an der Obergrenze

abort)

Einführung einer Funktion p ↓ c, die im Rumpf von q alle Aufrufe mit der

Schranke c versieht, u. a.:

◮ skip ↓ c = skip

◮ p ; p ′ ↓ c = (p ↓ c) ; (p ′ ↓ c)

◮ q(t; z) ↓ c = q(t; z) : c

◮ (q(t; z) : c ′ ) ↓ c = q(t; z) : min(c, c ′ )

◮ kann undefiniert bleiben, wenn (wie in KIV) beschränkte Prozeduraufrufe

innerhalb von Deklarationen verboten sind

A. Knapp, G. Schellhorn: Formale Methoden 347


Tiefenbeschränkte Rekursion: Relationale Semantik

Relationale Semantik für q(x; y) p ∈ Decl

Rq(t; z) : c A = {(v, v ′ ) | ∃n . n + 1 = T c A v ∧

∃v ′′ . (v{x,y ↦→ T t A v, v(z)}, v ′′ ) ∈ Rp ↓ ˆn A ∧

v ′ = v ′′ {x,y ↦→ v(x), v(y)}{z ↦→ v ′′ (y)}}

Rq(t; z) A =

n∈N Rq(t; z) : ˆn A

◮ ˆn steht für den Term 0 + 1 + . . . + 1, der die Zahl n bezeichnet.

A. Knapp, G. Schellhorn: Formale Methoden 348


Semantik von (implementationslosen) Prozeduren

Die Semantik einer Prozedur q s : s ′ ist eine Relation über den Parametern:

Rq A ⊆ As × As ′ × As ′

◮ (a,a ′ ,a ′′ ) ∈ Rq A bedeutet: Die Prozedur q, aufgerufen mit

◮ Eingaben a für die Eingabe-Variablen

◮ Eingaben a ′ für die Ein/Ausgabe-Variablen

terminiert mit Ausgabe a ′′ in den Ein/Ausgabe-Variablen.

◮ In KIV: keine globale Variablen, stattdessen I/O-Parameter

◮ auch vorteilhaft für Beweise

◮ Alternative: nur globale Variablen, keine Parameter (vgl. µ-Kalkül)

◮ Implementierungen ersetzen evtl. I/O-Parameter durch globale Variablen

◮ Normalfall in KIV sind funktionale Prozeduren:

◮ I/O-Variablen dienen nur der Ausgabe;

◮ a ′′ und Terminierung hängen nicht von a ′ ab.

◮ Funktionale Prozeduren haben etwas einfachere Regeln.

◮ Wenn nicht funktional, Schlüsselwort nonfunctional am Ende der

Prozedurdefinition

A. Knapp, G. Schellhorn: Formale Methoden 349


Prozeduren: DL-Kalkülregeln (1)

(R〈()〉1) x′ =t,y ′ = z, Γ ⇒ 〈p{x,y ↦→ x ′ ,y ′ }〉ϕ{z ↦→ y ′ }, ∆

Γ ⇒ 〈q(t; z)〉ϕ, ∆

(R〈()〉2) Γ ⇒ ∃n . 〈q(t; z) : n〉ϕ, ∆

Γ ⇒ 〈q(t; z)〉ϕ, ∆

(R〈():〉)

n = c − 1,x ′ =t,y ′ = z, Γ ⇒

c = 0 ∧ 〈(p ↓ n){x,y ↦→ x ′ ,y ′ }〉ϕ{z ↦→ y ′ }, ∆

mit neuen Variabeln n, x ′ , y ′ .

Γ ⇒ 〈q(t; z) : c〉ϕ, ∆

Analoge Regeln für die linke Seite und Boxen

◮ In KIV: (〈()〉2) “proc omega”.

A. Knapp, G. Schellhorn: Formale Methoden 350


Prozeduren: DL-Kalkülregeln (2)

(L〈exec〉) Γ ⇒t =t ′ , ∆ 〈q(t; z)〉z = z ′ , ϕ{z ↦→ z ′ }, ψ{y ↦→ z ′ }, Γ ⇒ ∆

〈q(t; z)〉ϕ, 〈q(t ′ ; y)〉ψ, Γ ⇒ ∆

(R〈exec〉) Γ ⇒t =t ′ , ∆ 〈q(t; z)〉z = z ′ , ϕ{z ↦→ z ′ }, Γ ⇒ ψ{y ↦→ z ′ }, ∆

〈q(t; z)〉ϕ, Γ ⇒ 〈q(t ′ ; y)〉ψ, ∆

◮ Gilt so für funktionale Prozeduren und neue Variablenz ′ .

◮ Für nichtfunktionale Prozeduren muß in der ersten Prämissez = y

hinzugefügt werden.

◮ nicht invertierbar (t =t ′ kann falsch sein)

◮ Anwendung bei Induktion, um den Aufruf aus der Induktionsvoraussetzung

gegen den gerade aktuellen Aufruf zu ” kürzen“.

◮ In KIV: (L〈exec〉) “contract call left”, (R〈exec〉) “execute call”

A. Knapp, G. Schellhorn: Formale Methoden 351


Deklarationen als Abkürzung für Axiome

Satz Eine Prozedurdeklaration q(x; y) p ist äquivalent zu den Axiomen

◮ 〈q(t; z)〉ϕ ↔ (〈x ′ , y ′ :=t, z; p{x,y ↦→ x ′ ,y ′ }〉ϕ{z ↦→ y ′ }

◮ 〈q(t; z)〉ϕ ↔ ∃n . 〈q(t; z) : n〉ϕ

◮ c = 0 → ¬〈q(t; z) : c〉ϕ

◮ c = 0 ∧ n = c − 1 → (〈q(t; z) : c〉ϕ ↔

〈x ′ , y ′ :=t, z; (p ↓ n){x,y ↦→ x ′ ,y ′ }〉ϕ{z ↦→ y ′ })

mit neuen Variablen n, x ′ , y ′ .

Die Axiome ergeben sich direkt aus den Regeln (R〈()〉1), (R〈()〉2), (R〈():〉).

A. Knapp, G. Schellhorn: Formale Methoden 352


Prozeduren im Hoare-Kalkül

Die Tiefenbeschränkung wird zum Beweis von semantischen Aussagen

gebraucht (Analoga zu Koinzidenzlemma etc.). Außerdem rechtfertigt sie

folgendes Vorgehen im Hoare-Kalkül für partielle Korrekheit (Skizze):

◮ Gezeigt werden soll {ϕ} q(x; y) {ψ} für rekursive Prozedur q(x; y) p.

◮ Dazu genügt es, einen Hoare-Kalkül-Beweisbaum mit Konklusion

{ϕ} p {ψ} zu bilden. Der Beweisbaum darf jetzt offene Prämissen für die

inneren Aufrufe haben.

◮ grob von der Form {ϕ{x,y ↦→t,z}} q(t; z) {ψ{x,y ↦→t,z}}.

◮ Details recht kompliziert: Globale Variablen, lokale Bindungen

zwischendurch, logische Hilfsvariablen

◮ Rechtfertigung: Innere Aufrufe haben (implizit) geringere Rekursionstiefe.

◮ Aber: genügt nur für partielle Korrekheit, für totale Korrektheit wird auch

noch eine noethersche Ordnung ≺ benötigt.

◮ In dynamischer Logik entfallen diese Probleme: einfache explizite

Induktion über die Rekursionstiefe bzw. noethersche Induktion.

A. Knapp, G. Schellhorn: Formale Methoden 353


Kontrakte

Ein Kontrakt für eine Prozedur q (oder auch für eine Methode) besteht

(mindestens) aus

◮ einer Vorbedingung ϕ

◮ einer Nachbedingung ψ

◮ der Angabe der Eingabe-Parameter (und evtl. gelesene globale Variablen)

◮ der Angabe der Ausgabe-Parameter (und evtl. geschriebene globale

Variablen)

◮ Weiters informelle Beschreibung: u. a. Name und Zweck der Prozedur,

Querverweise zu Anwendungsfällen, etc.

A. Knapp, G. Schellhorn: Formale Methoden 354


Kontrakte: Semantik

Eine Implementierung mit Rumpf p erfüllt einen Kontrakt, falls der Rumpf total

korrekt bzgl. der Vor- und Nachbedingungen ist, falls also [ϕ] p [ψ] (Hoare) bzw.

ϕ → 〈p〉ψ (dynamische Logik) gilt.

◮ Diese Interpretation von Kontrakten ist sehr stark. Man hätte gerne eine

interne Datenrepräsentation.

◮ Wenn die Vorbedingung nicht eingehalten wird, darf Beliebiges passieren:

Absturz, Exception, Nichtterminierung, reguläres Ergebnis, illegaler

Speicher etc.

A. Knapp, G. Schellhorn: Formale Methoden 355


Kontrakte für Java/C#

◮ Für Java oder C# sind die Argumente Eingabeparameter und das Ergebnis

der einzige Ausgabeparameter.

◮ Es gibt immer genau einen I/O-Parameter: den Speicher.

◮ ” Der Speicher wird gelesen/modifiziert“ ist unnötig (und zu schwach);

deshalb genauere Angaben, welche Objekte/Assoziationen

gelesen/geschrieben/erzeugt werden, sind in Vor- und Nachbedingung

erforderlich.

◮ Die Nachbedingung kann auch: ” löst für bestimmte Eingaben eine

bestimmte Ausnahme aus“ lauten. Sinnvollerweise teilt man die

Nachbedingung deshalb in einen regulären und einen Exception-Teil.

A. Knapp, G. Schellhorn: Formale Methoden 356


Vollständigkeit der dynamischen Logik (1)

In dynamischer Logik kann man (im Gegensatz zu Hoare-Kalkül) Programme

vergleichen:

◮ 〈p〉true → 〈p ′ 〉true für ” Wenn p terminiert, so auch p ′ “.

◮ Sei x = var(p) ∪ var(p ′ ) und x ′ neue Variablen: 〈p〉x = x ′ ↔ 〈p ′ 〉x = x ′ für

” p und p′ berechnen dasselbe (Ergebnis x ′ )“; oder äquivalent: ” die

Semantik von p und p ′ ist gleich (Rp A = Rp ′ A)“.

Auch bei Induktionsbeweisen für totale/partielle Korrektheit von rekursiven

Prozeduren entstehen nach Anwendung der Induktionshypothese:

◮ eine Programmformel im Antezedent mit nur dem rekursiven Aufruf und

der Nachbedingung (aus der Induktionshypothese)

◮ eine Programmformel im Sukzedent (durch Ausführen entstanden). Sie

beginnt mit einem rekursiven Aufruf, für den man die Induktionshypothese

benötigt.

Deshalb benötigt man in dynamischer Logik noch Regeln für zwei Programme.

A. Knapp, G. Schellhorn: Formale Methoden 357


Vollständigkeit der dynamischen Logik (2)

Dynamische Logik kann vollständig axiomatisiert werden modulo der

Unvollständigkeit der natürlichen Zahlen. Die Axiome sind (im wesentlichen) die

bisherigen Regeln und die Axiome

◮ (ϕ → ψ) → (〈p〉ϕ → 〈p〉ψ)

” Wenn ϕ ψ impliziert, und ϕ nach p gilt, dann auch ψ“.

◮ Sei x = lvar(p) und x ′ neue Variablen:

〈p〉〈p ′ 〉ϕ ↔ ∃x ′ . 〈p〉x = x ′ ∧ 〈p ′ {x ↦→ x ′ }〉ϕ{x ↦→ x ′ }

” Damit nach p und p′ ϕ gilt, muß es einen Zwischenzustand x ′ geben, der

nach p erreicht wird; wenn man auf diesem p ′ rechnen läßt, ergibt sich

zum Schluß ϕ für x ′ “.

Dabei sind lvar(p) die (potentiell) von p modifizierten Variablen (= linke Seiten

von Zuweisungen + I/O-Parameter von Aufrufen).

A. Knapp, G. Schellhorn: Formale Methoden 358


DL-Kalkül: Einführung von Zwischenzuständen

(L〈split〉) 〈p〉x = x′ , ϕ{x ↦→ x ′ }, Γ ⇒ ∆

〈p〉ϕ, Γ ⇒ ∆

wobei x = lvar(p), x ′ neue Variablen

◮ Die Regel wird meist angewendet, wenn p ein Prozeduraufruf (geht aber

nie fehl).

◮ Führt einen Zustand x ′ am Ende von p ein; der Zwischenzustand wird

explizit gebraucht, wenn man Lemmas hat (z. B. zwei Aufrufe sequentiell,

Lemma macht Aussage über den zweiten).

A. Knapp, G. Schellhorn: Formale Methoden 359


Semantik von Programmiersprachen

Behandlung verschiedener Konzepte von Programmiersprachen

◮ Schleifen und Rekursion, Terminierung

◮ Parameterübergabe-Mechanismen: call-by-value, call-by-reference oder

call-by-name

◮ Nichtdeterminismus: (un-)beschränkt, dämonisch, erratisch oder angelisch

◮ Kopiersemantik vs. Pointersemantik

◮ Semantik von Sprüngen: Exceptions, breaks, returns, gotos

◮ Higher-Order-Funktionen: lazy vs. strikte Semantik

◮ Typsysteme: Polymorphie, Overloading, Casts, dynamische Bindung etc.

◮ Parallelität: Interleaving, synchron, asynchron, Fairness

◮ Übergang von Semantik zu Kalkül

A. Knapp, G. Schellhorn: Formale Methoden 360


Programmiersprachensemantik in Theorembeweisern (1)

Semantikdefinition in Theorembeweisern wie KIV kann auf zwei Ebenen

erfolgen:

Ebene 1 (die ” Meta-Ebene“): Semantik für die in KIV eingebauten Programme p

◮ Semantik − von Programmen ist außerhalb von KIV spezifiziert.

◮ p arbeitet auf logischen Variablenbelegungen und spezifizierten

Datenstrukturen (Algebren), genau wie die Semantik von Prädikatenlogik.

◮ Semantik wird benutzt, um Sinnhaftigkeit von Hoare-Kalkül und

dynamischer Logik zu zeigen.

◮ Verwendet wird zum Schluß nur der Kalkül, um Eigenschaften von

programmierten/spezifizierten Anwendungen nachzuweisen.

◮ Der implementierte Kalkül hat das Risiko, Fehler zu enthalten, wenn die

(informellen) mathematischen Beweise fehlerhaft sind. Das Risiko ist

gering für ” Standard-while-Programme“, größer für Java oder Statecharts.

A. Knapp, G. Schellhorn: Formale Methoden 361


Programmiersprachensemantik in Theorembeweisern (2)

Ebene 2 (die ” Objekt-Ebene“): Semantik für in KIV spezifizierte Programme

◮ p ist Variable eines spezifizierten Datentyps Prog.

◮ . : Prog → State × State → bool ist in KIV definierte

Funktion.

◮ Zweck: präzise Semantikdefinition und Validierung für eine Programmieroder

Spezifikationssprache

◮ Korrektheitsbeweise, systematische Tests für Compiler

◮ Aufdecken von Fehlern (z. B. im Java-Compiler)

◮ Korrektheitsbeweise für Kalkülregeln

◮ Aber auf dieser Grundlage ist es schwierig, effizient Anwendungen in der

Programmier- und Spezifikationssprache zu verifizieren (z. B.

Substitutionsfunktion programmiert (Ebene 1) vs. spezifiziert (Ebene 2)).

A. Knapp, G. Schellhorn: Formale Methoden 362


Zustände

Semantischer Bereich State = Id → N

◮ Abbildungen σ von Programmvariablen Id auf natürliche Zahlen

◮ Variablenzugriff σ(x), Variablenmodifikation σ{x ↦→ n}

Formalisierung in KIV

◮ Sorte Id mit Variablen id

◮ Sorte Idxnat der Paare aus Id und nat mit Konstruktor .


Ausdrücke

Syntaktische Bereiche

◮ AExp ∋ t für arithmetische Ausdrücke

◮ BExp ∋ b für boolesche Ausdrücke

Semantische Funktionen

◮ − : AExp → State → N

◮ − : BExp → State → B

Formalisierung in KIV

◮ Sorten AExp und BExp

◮ . +_ . : AExp × AExp → AExp etc.

◮ Für arithmetische und boolesche Ausdrücke zwei Funktionen

. : AExp → State → nat;

. : BExp → State → bool;

◮ Verwendung bereits spezifizierter Funktionen auf nat und bool

A. Knapp, G. Schellhorn: Formale Methoden 364


Programme

Syntaktischer Bereich

◮ Prog ∋ p für Programme über AExp und BExp

◮ Vereinfachung: keine simultanen Zuweisungen

Semantische Funktion

◮ − : Prog → ℘(State × State)

◮ aus relationaler Semantik

Formalisierung in KIV

◮ Sorte Prog mit Variable α (statt p)

◮ Für relationale Semantik Funktion höherer Ordnung

. : Prog → State × State → bool

◮ Relationsvariable R : State × State → bool

◮ Relationsiteration durch rekursiv definierte Funktion

. ˆ . : (State × State → bool) × nat →

(State × State → bool)

◮ α ˆ n ist Semantik von α n

A. Knapp, G. Schellhorn: Formale Methoden 365


Natürliche Semantik (1)

Definition Natürliche Semantik (engl. natural semantics) definiert eine

“big-step”-Semantik eines Programms p ∈ Prog durch die Ableitbarkeit von

〈p, σ〉 → σ ′ für σ, σ ′ ∈ State im folgenden Regelsystem Rns.

(skipns) 〈skip, σ〉 → σ

(assignns) 〈x := t, σ〉 → σ{x ↦→ t σ}

(seqns) 〈p1, σ〉 → σ1

〈p2, σ1〉 → σ2

〈p1 ; p2, σ〉 → σ2

A. Knapp, G. Schellhorn: Formale Methoden 366


Natürliche Semantik (2)

(if tt

ns)

(if ff

ns)

〈p1, σ〉 → σ1

, falls b σ = tt

〈if b then p1 else p2, σ〉 → σ1

〈p2, σ〉 → σ2

, falls b σ = ff

〈if b then p1 else p2, σ〉 → σ2

(while tt

ns) 〈p, σ〉 → σ′ 〈while b do p, σ ′ 〉 → σ ′′

〈while b do p, σ〉 → σ ′′

(while ff

ns) 〈while b do p, σ〉 → σ , falls b σ = ff

◮ Keine Regel für abort

, falls b σ = tt

◮ Bedeutung des Regelsystems analog zur Definition von

Ableitungsbäumen für Prädikatenlogik

A. Knapp, G. Schellhorn: Formale Methoden 367


Formalisierung natürlicher Semantik

◮ Gibt es immer eine wohldefinierte Menge ableitbarer Konklusionen?

Welche Prämissen sind in Ordnung?

◮ Alternative 1: Explizite Bäume tree mit Tripeln aus (p, σ, σ ′ ) als Inhalt der

Knoten und Prädikat ok(tree), das feststellt, ob die Regeln korrekt

angewendet wurden: aufwendig, interessant ist nur die Menge möglicher

Tripel in der Konklusion.

◮ Alternative 2: Die ableitbaren Tripel sind die kleinste unter

Regelanwendung abgeschlossene Menge: Definiere zu einer Menge T

von schon abgeleiteten Tripeln die mit einer Regelanwendung daraus

ableitbaren Tripel ˆRns(T). Dann sollte gelten: 〈p, σ〉 → σ ′ ist mit Rns

ableitbar genau dann, wenn (p, σ, σ ′ ) ∈ {T | ˆRns(T) ⊆ T}.

◮ Alternative 3: Definiere die Menge der mit einem Baum der Höhe n

herleitbaren Tripel: Das ist gerade ˆR n ns(∅). Semantik ist also: 〈p, σ〉 → σ ′

ist mit Rns ableitbar genau dann, wenn es ein n ∈ N mit (p, σ, σ ′ ) ∈ ˆR n ns(∅)

gibt.

A. Knapp, G. Schellhorn: Formale Methoden 368


Ableitungsoperator ˆRns

Informell: (p, σ, σ ′ ) ∈ ˆRns(T) gdw. ” (p, σ, σ ′ ) ist Konklusion einer Regel mit

Prämissen aus T“

Damit: (p, σ, σ ′ ) ∈ ˆRns(T) genau dann, wenn

p = skip und σ = σ ′

oder ex. x, t mit p = x := t, σ ′ = σ{x ↦→ t σ}

oder ex. p1, p2, σ ′′ mit p = p1 ; p2, (p1, σ, σ ′′ ) ∈ T und (p2, σ ′′ , σ ′ ) ∈ T

oder ex. b, p1, p2 mit p = if b then p1 else p2, b σ = tt und (p1, σ, σ ′ ) ∈ T

oder ex. b, p1, p2 mit p = if b then p1 else p2, b σ = ff und (p2, σ, σ ′ ) ∈ T

oder ex. b, p ′ , σ ′′ mit p = while b do p ′ , b σ = tt und

(p ′ , σ, σ ′′ ) ∈ T und (while b do p ′ , σ ′′ , σ ′ ) ∈ T

oder ex. b, p ′ mit p = while b do p ′ , b σ = ff und σ = σ ′

Formalisierung in KIV:

◮ Datentypspezifikation Prog für Programme

◮ Funktion REC : (Prog × State × State → bool) →

Prog × State × State → bool

A. Knapp, G. Schellhorn: Formale Methoden 369


Regelsysteme

Nur positive Prämissen

◮ Ableitungsbäume lassen sich mit Regeln der Form 〈p′ , σ1〉 → σ2

nicht

〈p, σ〉 → σ ′

immer fortsetzen.

Nur endlich viele Prämissen

◮ Für Regeln der Form (〈pn, σn〉 → σ ′ n)n∈N

〈p, σ〉 → σ ′

gibt es nicht notwendig ein

k ∈ N, sodaß der Ableitungsbaum aus Unterbäumen der Höhe k − 1

gebildet werden kann (Prämisse l benötige l Ableitungsschritte).

◮ Damit werden Alternative 1 und Alternative 3 zur Interpretation

ausgeschlossen.

A. Knapp, G. Schellhorn: Formale Methoden 370


Fixpunkte monotoner Funktionen (1)

Menge U, Funktion f : ℘(U) → ℘(U)

◮ f monoton, wenn für alle M1, M2 ⊆ U: ist M1 ⊆ M2, dann f (M1) ⊆ f (M2)

◮ M ⊆ U Fixpunkt von f , wenn f (M) = M

◮ M ⊆ U kleinster Fixpunkt von f , wenn M Fixpunkt von f und für jeden

Fixpunkt M ′ von f : M ⊆ M ′

Satz Sei U eine Menge und f : ℘(U) → ℘(U) eine monotone Funktion.

Dann ist die durch f induktiv definierte Menge µ(f ) = {M ⊆ U | f (M) ⊆ M}

der kleinste Fixpunkt von f .

◮ Fixpunktsatz von Knaster und Tarski für Mengen

◮ Anwendung: Setze U zu Menge der Tripel (p, σ, σ ′ ) und f = ˆRns.

µ(ˆRns) ist die Menge der ableitbaren Konklusionen.

◮ Monotonie entspricht positiven (nicht notwendigerweise endlich vielen)

Prämissen.

A. Knapp, G. Schellhorn: Formale Methoden 371


Fixpunkte monotoner Funktionen (2)

Beweisskizze Sei F = {M ⊆ U | f (M) ⊆ M}, also µ(f ) = F.

◮ Es gilt f (µ(f )) ⊆ µ(f ). Sei dazu M ∈ F:

◮ f (M) ⊆ M nach Definition von F

◮ µ(f ) ⊆ M, da jedes Element von F Obermenge des Durchschnitts F

◮ Wegen der Monotonie von f gilt f (µ(f )) ⊆ f (M)

◮ Also f (µ(f )) ⊆ M.

◮ Da das für jedes M ∈ F gilt, ist f (µ(f )) ⊆ µ(f ).

◮ Es gilt µ(f ) ⊆ f (µ(f )):

◮ Wegen f (µ(f )) ⊆ µ(f ) und der Monotonie von f gilt f (f (µ(f ))) ⊆ f (µ(f )),

also f (µ(f )) ∈ F.

◮ Also µ(f ) ⊆ f (µ(f )), da jedes Element Obermenge des Durchschnitts

◮ Wegen f (µ(f )) ⊆ µ(f ) und µ(f ) ⊆ f (µ(f )) ist µ(f ) Fixpunkt.

◮ Jeder andere Fixpunkt M von f ist wegen f (M) = M in F und damit µ(f ) ⊆ M

nach Definition von µ(f ).

A. Knapp, G. Schellhorn: Formale Methoden 372


Fixpunkte monotoner Funktionen (3)

Formalisierung in KIV:

◮ Allgemeine Fixpunkttheorie mit Sorte elem für die Elemente von U

◮ Teilmengen von U: boolesche Funktionen S : elem → bool

◮ Mengen von Teilmengen von U: SS : (elem → bool) → bool

◮ Statt x ∈ S und S ∈ SS also S(x) und SS(S)

◮ S ⊆ S0 definiert als ∀ x . S(x) → S0(x)

◮ Die Elemente x ∈ SS sind die x mit ∀ S . SS(S) → S(x)

◮ Zur Anwendung des generischen Theorems wird eine Instanz der Theorie

mit Prog × State × State für elem und REC für f zu bilden

(instantiated specification).

A. Knapp, G. Schellhorn: Formale Methoden 373


Fixpunkte für ˆRns

◮ Der Operator ˆRns ist monoton.

◮ Hinreichendes Kriterium für Monotonie: Alle Vorkommen von T in der

Definition von ˆRns unter einer geraden Zahl von Negationen (wobei

Implikation eine Negation für die Vorbedingung addiert, und Äquivalenz

verboten ist).

Formalisierung in KIV (für REC):

◮ Argument im wesentlichen, daß alles, was in der REC-Definition an

Operatoren vorkommt: Konjunktion, Disjunktion (keine Negation) sowie

Quantoren, monotone Operatoren sind.

A. Knapp, G. Schellhorn: Formale Methoden 374


Eigenschaften der Definition der natürlichen Semantik

◮ Nach dem Fixpunktsatz von Knaster-Tarski ist die kleinste Menge der

unter Regelanwendung abgeschlossenen Tripel (p, σ, σ ′ ) wohldefiniert

und gleich µ(ˆRns) = {T | ˆRns(T) ⊆ T}.

◮ Die Definition (σ, σ ′ ) ∈ p ⇔ (p, σ, σ ′ ) ∈ µ(ˆRns) gibt also eine formale

Definition der natürlichen Semantik.

◮ Formalisierung in KIV

. : Prog → State × State → bool

◮ Es gilt ˆRns(µ(ˆRns)) = µ(ˆRns), was informell bedeutet: ” Nochmaliges

Anwenden einer Regel auf die mit den Regeln gewinnbaren Konklusionen

(= µ(ˆRns)) gibt nichts Neues mehr“.

A. Knapp, G. Schellhorn: Formale Methoden 375


Bedeutung von ˆRns(µ(ˆRns)) = µ(ˆRns) (1)

Intuitiv: ” Die Konklusion ist genau dann ableitbar, wenn es alle Prämissen sind“.

Ausgeschrieben: (σ, σ ′ ) ∈ p genau dann, wenn

p = skip und σ = σ ′

oder ex. x, t mit p = x := t, σ ′ = σ{x ↦→ t σ}

oder ex. p1, p2, σ ′′ mit p = p1 ; p2, (σ, σ ′′ ) ∈ p1 und (σ ′′ , σ ′ ) ∈ p2

oder ex. b, p1, p2 mit p = if b then p1 else p2, b σ = tt und (σ, σ ′ ) ∈ p1

oder ex. b, p1, p2 mit p = if b then p1 else p2, b σ = ff und (σ, σ ′ ) ∈ p2

oder ex. b, p ′ , σ ′′ mit p = while b do p ′ , b σ = tt und

(σ, σ ′′ ) ∈ p ′ und (σ ′′ , σ ′ ) ∈ while b do p ′

oder ex. b, p ′ mit p = while b do p ′ , b σ = ff und σ = σ ′

A. Knapp, G. Schellhorn: Formale Methoden 376


Bedeutung von ˆRns(µ(ˆRns)) = µ(ˆRns) (2)

Durch Einsetzen einer Regelkonklusion bekommt man Äquivalenzen zwischen

Konklusion und der Konjunktion der Prämissen für jede Regel (falls

Seitenbedingung gilt):

◮ Einsetzen von p1 ; p2 für p: (σ, σ ′ ) ∈ p1 ; p2 ⇔

es gibt σ ′′ mit (σ, σ ′′ ) ∈ p1 und (σ ′′ , σ ′ ) ∈ p2

◮ Einsetzen von while b do p ′ für p ergibt Abwickeln und Verlassen einer

Schleife:

Wenn b σ = tt, dann: (σ, σ ′ ) ∈ while b do p ′ ⇔

es gibt σ ′′ mit (σ, σ ′′ ) ∈ p ′ und (σ ′′ , σ ′ ) ∈ while b do p ′

Wenn b σ = ff , dann: (σ, σ ′ ) ∈ while b do p ′ ⇔

σ = σ ′

◮ Zusammenfassung zu einem Theorem möglich

A. Knapp, G. Schellhorn: Formale Methoden 377


Stetige mengenwertige Funktionen

Menge U

◮ ω-Kette in U: M0 ⊆ M1 ⊆ . . . mit Mi ⊆ U für i ∈ N

◮ Kette (engl. chain) für Indexmenge I: (Mi)i∈I mit Mi ⊆ U und für alle

i, j ∈ I: Mi ⊆ Mj oder Mj ⊆ Mi

◮ In KIV: Ketten für N statt ω-Ketten

Definition Sei U eine Menge. Eine Funktion f : ℘(U) → ℘(U) ist stetig,

wenn für alle ω-Ketten M0 ⊆ M1 ⊆ . . . gilt:

f (

n∈N Mn) =

n∈N f (Mn)

◮ Wenn f monoton, gilt ⊇.

A. Knapp, G. Schellhorn: Formale Methoden 378


Stetigkeit für natürliche Semantik

◮ Sei f wieder ˆRns und M0 = ∅, Mi+1 = ˆRns(Mi)

◮ Mn enthält genau die mit einem Baum der Höhe n erhaltbaren

Konklusionen.

◮ Wegen der Monotonie von ˆRns wachsen die Mengen, bilden also eine

ω-Kette.

◮ Stetigkeit fordert: ˆRns(

n∈N Mn) ⊆

n∈N ˆRns(Mn) =

n∈N Mn

◮ Stetigkeit sagt also: Wenn man alle mit irgendeiner endlichen Zahl

erhaltbaren Konklusionen nimmt (=

n∈N Mn) und auf diese noch einmal

eine Regel anwendet, kommt nichts Neues dazu.

◮ Stetigkeit gilt nicht für unendlich viele Prämissen; dort gibt es legale

Bäume unbeschränkter Höhe; sie gilt immer, wenn man endlich viele

Prämissen hat: dann gibt es keine Bäume unbeschränkter Höhe.

A. Knapp, G. Schellhorn: Formale Methoden 379


Stetigkeit und Monotonie

Satz Jede stetige Funktion f : ℘(U) → ℘(U) ist monoton.

Beweisskizze Sei M0 ⊆ M1.

◮ Bilde ω-Kette durch M2 = M3 = · · · = M1.

◮ Dann

n∈N Mn = M1, also f (

n∈N Mn) = f (M1)

◮ Andererseits

n∈N f (Mn) = f (M0) ∪ f (M1).

◮ Wegen Stetigkeit f (M1) = f (M0) ∪ f (M1).

◮ Also f (M0) ⊆ f (M1).

A. Knapp, G. Schellhorn: Formale Methoden 380


Stetigkeit von ˆRns

Satz

ˆRns ist stetig.

Beweisskizze Sei M0 ⊆ M1 ⊆ . . . eine ω-Kette.

◮ Sei (p, σ, σ ′ ) ∈ ˆRns(

n∈N Mn).

◮ Dann ist (p, σ, σ ′ ) mit einer Regel und m Prämissen (pk, σk, σ ′ k ) entstanden.

◮ Alle Prämissen sind in

n∈N Mn.

◮ Also gibt es für jedes k ∈ {1, . . . , m} ein nk, sodaß (pk, σk, σ ′ k ) ∈ Mnk .

◮ Sei n0 = max({n1, . . . , nm}).

◮ Dann sind alle Prämissen der Regeln in Mn0 .

◮ Somit ist die Konklusion in ˆRns(Mn0) und also auch in

n∈N ˆRns(Mn).

◮ Allgemein gilt: Regelsysteme mit nur endlich vielen, sämtlich positiven

Prämissen ergeben stetige Operatoren.

A. Knapp, G. Schellhorn: Formale Methoden 381


Fixpunkte stetiger Funktionen (1)

Satz Sei U eine Menge und f : ℘(U) → ℘(U) eine monotone Funktion.

Dann gilt:

1. Die Mengen f n (∅) bilden eine ω-Kette in U.

2. Für alle n ist f n (∅) ⊆ µ(f ).

3. Falls f stetig ist, gilt der Fixpunktsatz von Kleene (für mengenwertige

Funktionen):

µ(f ) =

n∈N f n (∅)

Beweisskizze

◮ Offenbar ∅ ⊆ f (∅). Wegen Monotonie gilt f (∅) ⊆ f 2 (∅), f 2 (∅) ⊆ f 3 (∅), . . . ; also

induktiv Behauptung (1).

◮ Offenbar ∅ ⊆ µ(f ). Wegen Monotonie gilt f (∅) ⊆ f (µ(f )) = µ(f ),

f 2 (∅) ⊆ f (µ(f )) = µ(f ), . . . ; also induktiv Behauptung (2).

A. Knapp, G. Schellhorn: Formale Methoden 382


Fixpunkte stetiger Funktionen (2)

Beweisskizze

◮ Sei F =

n∈N f n (∅); zu zeigen ist F = µ(f ).

◮ Wegen (2) gilt F ⊆ µ(f ); also bleibt zu zeigen µ(f ) ⊆ F.

◮ Es genügt f (F) = F zu zeigen, da µ(f ) der kleinste Fixpunkt ist.

◮ Es gilt: f (F) = f (

n∈N f n (∅)) =

n∈N f n+1

(∅), wegen Stetigkeit; und

n∈N f n+1 (∅) = ∅ ∪

1≤n∈N f n (∅) =

n∈N f n (∅) = F.

◮ Für stetige Funktion muß man nur endlich oft iterieren, um die Menge der

ableitbaren Konklusionen zu bekommen.

◮ Für nur monotone Funktionen kann man weiteriterieren und bleibt immer

unterhalb des Fixpunkts. Sobald irgendeine Iteration nicht mehr größer

wird, hat man den Fixpunkt. Mit Theorie der Ordinalzahlen: Wenn man

” genügend unendlich oft“ iteriert, erreicht man µ(f ).

A. Knapp, G. Schellhorn: Formale Methoden 383


Äquivalenz der natürlichen zur relationalen Semantik

Satz Wenn eine Ableitung für 〈p, σ〉 → σ ′ in der natürlichen Semantik

existiert, dann ist (σ, σ ′ ) ∈ p in der relationalen Semantik, und umgekehrt.

Formalisierung in KIV:

◮ ” ⇒“ durch Induktion über n in REC ˆ n (Zahl der angewandten Regeln)

◮ ” ⇐“ durch strukturelle Induktion über den Aufbau des Programms

◮ Beides hat dieselbe Struktur, einzige Ausnahme ist die Schleife

◮ Benötigt wird als Lemma, daß in der natürlichen Semantik

(while b do p, σ, σ ′ ) genau dann ableitbar ist, wenn es ein n gibt, sodaß

((if b then p else abort) n , σ, σ ′ ) ableitbar ist und b σ ′ = ff .

◮ Beweis ” ⇒“ wieder durch Induktion über Zahl der angewandten Regeln.

◮ Beweis ” ⇐“ durch Induktion über n.

A. Knapp, G. Schellhorn: Formale Methoden 384


Prozeduren: Natürliche Semantik

Natürliche Semantik für Prozeduraufrufe

〈p, σ{x,y ↦→ t σ, σ(z)}〉 → σ

(callns)

′′

〈q(t; z), σ〉 → σ ′′ {x,y ↦→ σ(x), σ(y)}{z ↦→ σ ′′ (y)} ,

wobei q(x; y) p ∈ Decl

◮ Die formalen Parameter x, y an die ausgewertete Argumentet,z binden;

◮ p ausführen, ergibt σ ′′ ;

◮ für die formalen Parameter wieder die Ausgangswerte nehmen;

◮ die Output-Parameterz mit den Ergebniswerten σ ′′ (y) überschreiben;

◮ nicht umgekehrt, wennz und y gemeinsame Variablen haben

◮ falls keine globalen Variablen vorhanden sind, kann man als Endzustand

einfacher σ{z ↦→ σ ′′ (y)} nehmen.

A. Knapp, G. Schellhorn: Formale Methoden 385


Prozeduren: Formalisierung in KIV

◮ Sorte Proc für Prozedurnamen mit Variable q

◮ Für Deklarationen Vereinfachung: nur ein Eingabe-, und ein I/O-Parameter

◮ allgemeiner: Listen und Test auf Duplikatfreiheit

◮ Spezifikation Decl mit drei Funktionen (einfacher zu spezifizieren als eine

Funktion, die ein Tripel liefert):

◮ inparam : Proc → Id

◮ ioparam : Proc → Id

◮ body : Proc → Prog

◮ Jedes q hat dadurch die Deklaration

q(inparam(q); ioparam(q)). body(q)

A. Knapp, G. Schellhorn: Formale Methoden 386


Speicher: Kopiersemantik

Funktionale Programmiersprachen haben ebenso wie Prädikatenlogik und die

abstrakte KIV-Programmiersprache Kopiersemantik.

◮ Bei Kopiersemantik ändert eine Zuweisung an eine Variable einfach die

Belegung (den Wert) der Variable.

◮ Die Zuweisung hat keinen Effekt auf den Inhalt anderer Variablen

(referentielle Transparenz).

◮ Einfachere Semantik, damit leichter verständlich und einfacher zu

verifizieren.

A. Knapp, G. Schellhorn: Formale Methoden 387


Speicher: Pointersemantik

Imperative (und objektorientierte) Programmiersprachen haben aus

Effizienzgründen meistens Pointersemantik.

◮ Die Belegung σ(x) einer Variable x ist immer

◮ eine Referenz vom Typ ref (Compilerbau: “boxed objects”) oder

◮ von einem primitiven Typ wie bool oder int (“unboxed objects”).

◮ Es gibt immer einen globalen Speicher (engl. heap) h : ref ⇀ data.

◮ Schlüssel sind vom Typ ref mit einer Konstante null.

◮ Werte sind vom Typ data mit ref ⊆ data

◮ Eine Zuweisung an x ändert (wenn boxed) den Speicher, nicht die

Referenz in der Belegung.

A. Knapp, G. Schellhorn: Formale Methoden 388


Speicher: Formalisierung in KIV (1)

Einfache Sprache mit Speicher

◮ Nur eine Sorte Objekte: NatxRef mit zwei Feldern vom Typ nat und

Ref

◮ Zugriff per o.val und o.next

◮ Speichermodifikationen nur auf Programm-, nicht auf Ausdrucksebene

(Semantik von Ausdrücken kann Funktion mit Wert bleiben).

◮ Variablen für Objektreferenzen oid : OId

◮ Zustände st speichern jetzt:

◮ natürliche Zahlen für Identifikatoren: st[id] : nat

◮ Referenzen für Objekte: st[oid] : Ref

◮ Speicher Instanz des nicht-freien Datentyps Store(loc, data)

◮ Schlüssel (loc) vom Typ Ref

◮ Werte (data) vom Typ NatxRef (mit Selektoren .nat und .ref)

◮ Heapzugriff hp[r] : NatxRef

◮ Heapmodifikation hp[r, n0 × r0]

A. Knapp, G. Schellhorn: Formale Methoden 389


Speicher: Formalisierung in KIV (2)

Neue Ausdrücke o : OExp für Objekte (genauer: Referenzen auf Objekte)

bestehend aus:

◮ v(oid) (Variable für Objekt)

◮ o.next (Zugriff auf next-Feld)

◮ null

Neue arithmetische und boolesche Ausdrücke:

◮ neuer arithmetischer Ausdruck: o.val (val-Feld)

◮ neuer boolescher Ausdruck: o = o’ (Referenzvergleich)

A. Knapp, G. Schellhorn: Formale Methoden 390


Speicher: Formalisierung in KIV (3)

Auf Programmebene gibt es jetzt vier verschiedene Zuweisungsarten:

1 id _:= e wie bisher (Zuweisung an lokale Variable)

2a oid .val _:= e Zuweisung an val-Feld

2b oid .next _:= o Zuweisung an next-Feld

3 oid _:=new neues Objekt erzeugen (mit 0 × null als Inhalt)

◮ Zuweisung (1) und (2a–b) sind auch in Java unterschiedlich.

◮ Zuweisung (3) ist Ersatz dafür, daß keine Seiteneffekte (hier: Allokation)

auf Termebene vorhanden sind.

◮ Vereinfachung: eigentlich OExp’s auf der linken Seite, hier nur OId’s

A. Knapp, G. Schellhorn: Formale Methoden 391


Seiteneffekte

Ausdrücke mit Seiteneffekten auf den Zustand

Formalisierung in KIV:

◮ Neue Expression id ++ (Postinkrement)

◮ Ergebnis ist aktueller Wert von id, id wird als Seiteneffekt erhöht

◮ Auswirkungen auf Semantik: e(st) muß jetzt Paar aus Wert und

neuem Zustand zurückgeben

◮ . : AExp → State → pair(State, nat)

◮ Zustand muß propagiert werden, z. B.

e +_ e0(st) = (st’ × n) ↔ ∃ st0, n0, n1.

e(st) = (st0 × n0) ∧

e0(st0) = (st’ × n1) ∧ n = n0 + n1

◮ st: Anfangszustand; st0: Zustand nach Auswertung von e;

st’: Endzustand

A. Knapp, G. Schellhorn: Formale Methoden 392


Nichtterminierung

Nichtterminierende Ausdrücke

Formalisierung in KIV:

◮ neuer Ausdruck nonterm

◮ Ausdruckssemantik muß Relation statt Funktion werden (Alternative:

Funktion mit ⊥-Ergebnis)

. : AExp → State


Startzustand

× State


Endzustand

× nat


Ergebnis

→ bool


Prädikat kann auf (st, st’, n) zutreffen oder nicht

◮ Axiom: ¬ nonterm(st, st’, n)

◮ Axiom für Addition lautet jetzt:

e +_ e0(st, st’, n) ↔ ∃ st0, n0, n1.

e(st, st0, n0) ∧

e0(st0, st’, n1) ∧ n = n0 + n1

◮ muß jetzt auch bei booleschen Ausdrücken beachtet werden:

. : BExp → State × State × bool → bool

A. Knapp, G. Schellhorn: Formale Methoden 393


Ausnahmen (1)

Ein Ausdruck kann eine Ausnahme auslösen.

Formalisierung in KIV:

◮ Minus auf natürlichen Zahlen: underflowexception (Konstante einer

Datenstruktur)

◮ Berechnung erhält ein neues Ergebnis, den Ausführungsmodus mo :

Mode mit Mode = ok | underflowexception

◮ mo = ok bedeutet normale Beendigung

◮ mo = underflowexception bedeutet Sprung bis zum nächsten Catch

für diese Exception

◮ Java Manual spricht informell von “normal completion” vs. “abrupt

completion” (mit einer “reason”, i. e. der Exception); für Java damit, da

auch break’s und return’s Sprünge sind:

Mode = ok | Exception(. . .) | Return | Break | Continue

A. Knapp, G. Schellhorn: Formale Methoden 394


Ausnahmen (2)

◮ . : AExp →

State


Startzustand

× State


Endzustand

× Mode


Ergebnismodus

× nat


Ergebnis, falls

Modus ok

→ bool

◮ Analog für BExp und Prog:

. : BExp → State × State × Mode × bool → bool

. : Prog → State × State × Mode → bool

◮ Neues Programmkonstrukt: try(p : Prog; mo : Mode; p’ : Prog)

◮ Führt p aus

◮ mo ist die Ausnahme die abgefangen wird

◮ eigentlich nur vom Typ Exception, einfachheitshalber ein Modus

◮ Wenn Ergebnismode von p gleich mo, dann wird p’ ausgeführt

A. Knapp, G. Schellhorn: Formale Methoden 395


Erweiterungen für Java

◮ Einige Datentypen (byte, short, . . . ) mit vielen Funktionen

◮ Algebraische Spezifikation der Klassenhierarchie c1 ≤ c2 (inkl. Interfaces)

◮ body : Type → Prog für dynamischen Methodenlookup

◮ Semantik eines Methodenaufrufs mit dynamischem Lookup

◮ Statische Typisierungsfunktion: class : Id → Class

◮ Damit: Wohlgetypte Programme (rekursiv definiertes Prädikat)

◮ Speicher mit Paaren aus Referenz und Feldname oder Array-Index als

Schlüssel; Werte nur primitive Datentypen oder Referenzen

◮ Wohlgetypte Speicher h mit class(h(i.f )) ≤ class(i.f )

◮ Beweis, dass während des Ablaufs eines wohlgetypten Programms ein

wohlgetypter Speicher wohlgetypt bleibt

◮ Für Verifikation (z. B. in KIV) : Parser, Kalkül

A. Knapp, G. Schellhorn: Formale Methoden 396


Zusammenfassung

◮ Semantik von Programmen

◮ Relationale und natürliche Semantik

◮ Fixpunktsätze von Knaster-Tarski und Kleene

◮ Äquivalenz der Semantiken

◮ Lokale Variablen, Prozeduren, Speicher, Ausnahmen

◮ Programmkorrektheit

◮ partielle und totale Korrektheit

◮ Hoare-Kalkül

◮ Dynamische Logik

A. Knapp, G. Schellhorn: Formale Methoden 397


Interpreter aus natürlicher Semantik (1)

REC#(p; st) begin

if p = mkskip then skip

else if p = mkabort then abort

else if assignp(p) then st := st[p.id


Monotonie von Programmen

Kontexte C(X)

◮ Programme mit ” Löchern“ X, z. B.

C(X) = if x = 3 then X; let y = 5 in X; y = x + 3

◮ Einsetzen von Programm p in Kontext C(X): Ersetzung aller Vorkommen

von X durch p.

Satz Sei C(X) ein Kontext. Wenn Rp1 A ⊆ Rp2 A, dann

RC(p1) A ⊆ RC(p2) A.

Beweisskizze Strukturelle Induktion über C(X).

◮ Ein rekursiv definierter Interpreter ergibt also automatisch eine monotone

Funktion (man kann eine Prozedur gar nicht rekursiv ” nicht aufrufen“).

◮ Deshalb werden in KIV rekursive Programme gegenüber induktiven

Definitionen bevorzugt (kein Monotonie-Beweis erforderlich).

◮ Andere Systeme (Isabelle, HOL, Coq etc.) haben Unterstützung für die

Automatisierung des Monotoniebeweises (direkte Eingabe der Regeln).

A. Knapp, G. Schellhorn: Formale Methoden 399


Interpreter aus natürlicher Semantik (2)

◮ Die KIV-Programmiersprache kann sich selbst interpretieren (aber:

Zirkelschluss, wenn nicht einmal direkt eine Semantik definiert ist).

◮ Die KIV-Programmiersprache kann auch für beliebige andere

Programmiersprachen die Semantik liefern (etwa Java, Prolog).

◮ Wenn mehrere Regeln auf dasselbe Programmkonstrukt anwendbar sind,

wird das Programm indeterministisch.

◮ Der rekursive Interpreter ist für den Compilerbau ungeeignet, da man

Rekursion beim Compilieren loswerden will.

A. Knapp, G. Schellhorn: Formale Methoden 400


Iterative Programmauswertung

Small-Step-Semantik

◮ 〈p, σ〉 ⇒ 〈p ′ , σ ′ 〉 bedeutet: ” p geht vom Zustand σ in einem Schitt nach σ ′

und das dann übrigbleibende Restprogramm ist p ′ “

◮ Die Granularität der Schritte ist frei wählbar.

◮ gut geeignet für Interleaving-Parallelität

Abläufe entstehen durch Aneinanderhängen von Einzelschritten:

〈p0, σ0〉 ⇒ 〈p1, σ1〉 ⇒ 〈p2, σ2〉 ⇒ . . .

◮ Leeres Programm ε für Endzustände mit ε ; p = p ; ε = p

◮ Ablauf terminiert, wenn Ablauf endlich lang und Ablauf endet mit dem

leeren Programm ε

A. Knapp, G. Schellhorn: Formale Methoden 401


Strukturell-operationelle Semantik (1)

Definition Strukturell-operationelle Semantik (engl. structural operational

semantics, SOS) definiert eine “small-step”-Semantik eines Programms

p ∈ Prog durch die Ableitbarkeit von 〈p, σ〉 ⇒ 〈p ′ , σ ′ 〉 für σ, σ ′ ∈ State im

folgenden Regelsystem Rsos.

(skipsos) 〈skip, σ〉 ⇒ 〈ε, σ〉

(skipsos) 〈abort, σ〉 ⇒ 〈abort, σ〉

(assignsos) 〈x := a, σ〉 ⇒ 〈ε, σ{x ↦→ T a σ}〉

(seqsos)

〈p1, σ〉 ⇒ 〈p ′ 1 , σ′ 〉

〈p1 ; p2, σ〉 ⇒ 〈p ′ 1 ; p2, σ ′ 〉

A. Knapp, G. Schellhorn: Formale Methoden 402


Strukturell-operationelle Semantik (2)

(if tt

sos) 〈if b then p1 else p2, σ〉 ⇒ 〈p1, σ〉, falls b σ = tt

(if ff

sos) 〈if b then p1 else p2, σ〉 ⇒ 〈p2, σ〉, falls b σ = ff

(while tt

sos) 〈while b do p, σ〉 ⇒ 〈p ; while b do p, σ〉, falls b σ = tt

(while ff

sos) 〈while b do p, σ〉 ⇒ 〈ε, σ〉, falls b σ = ff

Satz Die strukturell-operationelle Semantik und die relationale Semantik

sind äquivalent:

◮ 〈p, σ〉 ⇒ · · · ⇒ 〈ε, σ ′ 〉 gdw. (σ, σ ′ ) ∈ Rp.

◮ 〈p, σ〉 ⇒ 〈p1, σ1〉 ⇒ 〈p2, σ2〉 ⇒ . . . gdw. ¬∃σ ′ . (σ, σ ′ ) ∈ Rp.

A. Knapp, G. Schellhorn: Formale Methoden 403


Strukturell-operationelle Semantik: Lokale Variablen

Lokale Variablen komplexer als in natürlicher Semantik

◮ Zusätzlich zum Zustand Stack, der lokalen Variablen Werte zuordnet und

die globalen Werte überlagert.

◮ Der Stack kann in den Zustand integriert werden:

◮ push(λ, σ) legt die Variablenzuordnung λ = {x ↦→ n} auf den Stack

◮ Pseudoprogramm pop(σ) deallokiert Variablenzuordnung

◮ Variablenzugriff push({x ↦→ n}, σ)(x) = (σ{x ↦→ n})(x)

◮ Damit Regel

(letsos) 〈let x = a in p, σ〉 ⇒ 〈p ; pop(σ), push({x ↦→ T a σ}, σ)〉

◮ Die Prozeduraufrufsregel wird nach demselben Prinzip definiert.

A. Knapp, G. Schellhorn: Formale Methoden 404


Strukturell-operationelle Semantik: Interleaving

Interleaving-Parallelität mit Konvention (ε p) = (p ε) = p:

(par 1 〈p1, σ〉 ⇒ 〈p

sos)

′ 1 , σ′ 〉

〈p1 p2, σ〉 ⇒ 〈p ′ 1 p2, σ ′ 〉

(par 2 sos)

〈p2, σ〉 ⇒ 〈p ′ 2 , σ′ 〉

〈p1 p2, σ〉 ⇒ 〈p1 p ′ 2 , σ′ 〉

A. Knapp, G. Schellhorn: Formale Methoden 405


Strukturell-operationelle Semantik: Sequentielle Komposition

Das zur Small-Step-Semantik gehörige Programm ist fast tail-rekursiv (i. e. fast

eine Schleife). Einzige Ausnahme ist die sequentielle Komposition.

Dieses Problem läßt sich beseitigen, indem statt eines Programms ein Stack

von Programmen ps abgearbeitet wird:

Statt 〈p, σ〉 ⇒ 〈p ′ , σ ′ 〉 also 〈p + ps, σ〉 ⇒ 〈p ′ + ps, σ ′ 〉

Das leere Programm kann entfallen (stattdessen leere Liste) und die seq-Regel

lautet einfach:

(seqsos) 〈p ; p ′ + ps, σ〉 ⇒ 〈p + p ′ + ps, σ〉

A. Knapp, G. Schellhorn: Formale Methoden 406


Interpreter aus strukturell-operationeller Semantik (1)

while ps = [] do

do let p = ps.first

in begin

ps := ps.rest;

ASTEP#(p; ps, st)

end

ASTEP#(p; ps, st) begin

if p = mkskip then skip

else if p = mkabort then ps := p + ps

else if assignp(p) then st := st[p.id


Interpreter aus strukturell-operationeller Semantik (2)

Die while-Schleife ist ein Interpreter mit einem abstrakten Schritt

ASTEP#(ainstr) pro abstrakter Instruktion ainstr (sequentielle

Komposition, if, while etc.), der die Instruktion ausführt.

Verwaltet wird ein globaler Zustand aus Restprogramm (die Liste ps) und

momentaner Belegung.

Äquivalente Sichtweise: Automat mit abstrakter Zustandsmenge Q (hier:

Prog ∗ × State) und einer Regelmenge für die Zustandsübergänge.

Die operationale Definition derartiger ” programmhafter“ Automaten ist eine

Grundidee von Abstract State Machines.

A. Knapp, G. Schellhorn: Formale Methoden 408


Compilation

◮ Jede Instruktion ainstr wird compiliert: cinstrs = compile(ainstr).

◮ Resultat ist eine Sequenz cinstrs von konkreten Maschineninstruktionen

(Bytecode/Assemblercode).

◮ Benötigt wird dann ein konkreter Interpreter für diesen Code, ähnlich zum

Interpreter für abstrakte Anweisungen, mit einem CStep.

Es sollte (in etwa) für cinstrs = compile(ainstr) gelten:

◮ Wenn AStep(ainstr) von einem Zustand as zum nächsten Zustand as ′

führt,

◮ dann führt auch CStep(cinstrs) von as zu as ′ .

Probleme:

◮ Meist mehrere konkrete Schritte für eine Instruktion.

◮ Der Zustand cs des Maschinencode-Interpreters ist meist anders als eine

Liste von Programmen.

A. Knapp, G. Schellhorn: Formale Methoden 409


Indeterminismus

Indeterminismus (engl. non-determinism) ist oft nützlich und elegant für

Spezifikationen:

◮ Ein Scheduler wählt einen Prozeß für den nächsten Schritt aus. Man will

aber davon abstrahieren, wie er genau implementiert ist.

◮ Security: Irgendeine Smartcard soll einen nächsten Protokollschritt

machen.

◮ Safety (Elbtunnel-Fallstudie): Das Fahrzeug fährt auf der rechten oder

linken Spur.

◮ Der Benutzer macht irgendeine Eingabe.

◮ Eine Zufallszahl wird gewählt.

◮ Graph azyklisch gdw. ein Programm, das (indeterministisch) immer eine

der Kanten entlanggeht, terminiert immer.

◮ Komplexitätstheorie: Eine Belegung von Variablen soll gefunden werden,

die einen booleschen Ausdruck wahrmacht: Man rate eine. (vgl. P vs. NP)

Beispiele subsumiert durch: Wähle irgendein Element aus einer Menge.

A. Knapp, G. Schellhorn: Formale Methoden 410


Indeterministische Auswahl: Syntax

Neues Programmkonstrukt choose x with b in p ifnone p ′ für

indeterministische Auswahl

◮ Wenn eine Belegung k für x existiert, die b im momentanen Zustand erfüllt,

dann binde die lokalen Variablen x an solche k und führe p aus.

◮ Wenn b im momentanen Zustand für alle Belegungen von x falsch ist,

führe stattdessen p ′ aus.

◮ Konvention: ifnone wird weggelassen, wenn irrelevant (= abort

gesetzt).

◮ Konstruktive Implementierung nur, wenn endlich viele x in Frage kommen.

A. Knapp, G. Schellhorn: Formale Methoden 411


Indeterministische Auswahl: Semantik

Natürliche Semantik

(choose tt

ns)

(choose ff

ns)

Relationale Semantik

〈p, σ{x ↦→ k}〉 → σ ′

〈choose x with b in p ifnone p ′ , σ〉 → σ ′ {x ↦→ σ(x)} ,

falls b σ{x ↦→ k} = tt

〈p ′ , σ〉 → σ ′

〈choose x with b in p ifnone p ′ ,

, σ〉 → σ ′

falls ∀ k . b σ{x ↦→ k} = ff

Rchoose x with b in p ifnone p ′ A = {(v, v ′ ) |

((∀ k . T b A v{x ↦→ k} = ff ) ∧ (v, v ′ ) ∈ Rp ′ A)

∨ (∃ k . T b A v{x ↦→ k} = tt ∧ (v, v ′′ ) ∈ Rp A v{x ↦→ k} ∧

v ′ = v ′′ {x ↦→ v(x)})}

A. Knapp, G. Schellhorn: Formale Methoden 412


Indeterministische Auswahl: Spezialfälle

Zwei typische Spezialfälle lassen sich als Abkürzungen definieren:

◮ Indeterministische Auswahl zwischen zwei Programmen (mit b neu)

p1 or p2 für

choose b with true in if b then p1 else p2

◮ Zufallszuweisung (mit x ′ neu)

x := ? für choose x ′ with true in x := x ′

Die Semantik von p1 or p2 ergibt sich zu

(or 1 ns)

bzw.

〈p1, σ〉 → σ ′

〈p1 or p2, σ〉 → σ ′

(or 2 ns)

Rp1 or p2 A = Rp1 A ∪ Rp2 A

〈p2, σ〉 → σ ′

〈p1 or p2, σ〉 → σ ′

A. Knapp, G. Schellhorn: Formale Methoden 413


Beschränkter Indeterminismus

Satz Wenn man in Programmen zwar or, aber kein choose erlaubt, erhält

man beschränkten Indeterminismus: jedes solche Programm kann nur endlich

viele Endzustände erreichen.

Beweisskizze Zuerst Nachweis für p ↓ n durch Induktion über n; damit hat man eine

Induktionsvoraussetzung für Aufrufe. Dann Induktion über die Struktur von

Programmen.

◮ Mit Hilfe von n := 0 or n := 1 or . . . or n := k Auswahl aus k

Elementen.

◮ Beschränkter Indeterminismus ist ” gutartiger“ als unbeschränkter.

A. Knapp, G. Schellhorn: Formale Methoden 414


Indeterminismus: Terminierungsproblem (1)

Beobachtung: Rskip or abort A = Rskip A ∪ ∅ = Rskip A.

◮ angelische Semantik (engl. angelic semantics)

Unter welchen Umständen ist es sinnvoll, daß skip und skip or abort

gleichwertig sind?

◮ Für partielle Korrektheit ist die angelische Semantik ausreichend: Es gilt

{ϕ} skip or abort {ψ} gdw. {ϕ} skip {ψ} gdw. ϕ → ψ.

◮ Für Komplexitätstheorie auch ausreichend: das Richtige kann geraten

werden.

◮ Für garantierte Terminierung (und totale Korrektheit) nicht das Richtige.

Für totale Korrektheit sind mögliche und sichere Nichtterminierung gleich.

Damit dämonische Semantik (engl. demonic semantics), in der

Rskip or abortdem A = Rabortdem A.

A. Knapp, G. Schellhorn: Formale Methoden 415


Indeterminismus: Terminierungsproblem (2)

◮ Dämonische Semantik sehr verbreitet in der Literatur; auch auch für

parallele Syteme verwendet (CSP).

◮ Volle Freiheit gibt erratische Semantik (engl. erratic semantics).

◮ Genügt allerdings für parallele Programme oft auch nicht: evtl. wird

Fairness (jede Wahl kommt mindestens irgendwann dran) relevant.

◮ Grundlage sowohl der dämonischen als auch der erratischen Semantik:

Die Menge der Zustände für die ein Programm garantiert terminiert.

Das Terminierungsproblem ist nur relevant für indeterministische Programme.

Wenn man nur deterministische Programme hat, ist Nichterminierung

äquivalent dazu, daß es keinen erreichbaren Endzustand gibt.

A. Knapp, G. Schellhorn: Formale Methoden 416


Garantierte Terminierung (1)

Definition Der (garantierte) Terminierungsbereich eines Programms p ist die

durch die folgenden Regeln beschriebene Menge Rp↓ A:

v ∈ Rskip↓ A

v ∈ Rp1↓ A (v ′ ∈ Rp2↓ A) (v,v ′ )∈Rp1 A

v ∈ Rp1 ; p2↓ A

v ∈ Rp1↓ A

, T b A v = tt

v ∈ Rif b then p1 else p2↓ A

v ∈ Rp↓ A (v ′ ∈ Rwhile b do p↓ A) (v,v ′ )∈Rp A

, T b A v = tt

v ∈ Rwhile b do p↓ A

v{x,y ↦→ T t A v, v(z)} ∈ Rp↓ A

, q(x; y) p ∈ Decl

v ∈ Rq(t; z)↓ A

(und analoge Regeln für if und while, wenn b falsch)

A. Knapp, G. Schellhorn: Formale Methoden 417


Garantierte Terminierung (2)

(v{x ↦→ k} ∈ Rp↓ A) k∈K

v ∈ Rchoose x with b in p ifnone p ′ ↓ A ,

wobei K = { k | T b A v{x ↦→ k} = tt}, falls K = ∅

v ∈ Rp ′ ↓ A

v ∈ Rchoose x with b in p ifnone p ′ ↓ A ,

falls { k | T b A v{x ↦→ k} = tt} = ∅

◮ Die Regeln für sequentielle Komposition und while haben soviele

Prämissen, wie p1 bzw. p Ergebniszustände liefert. Die Regel für choose

hat soviele Prämissen, wie es Auswahlmöglichkeiten für k gibt; bei

unbeschränktem Indeterminismus gibt es also evtl. unendlich viele.

◮ Abgeleitete Regel: v ∈ Rp1↓ A v ∈ Rp2↓ A

v ∈ Rp1 or p2↓ A

A. Knapp, G. Schellhorn: Formale Methoden 418


Monotonie und Stetigkeit des Terminierungsbereichs

Satz Die induktive Definition des Terminierungsbereichs definiert einen

monotonen Operator. Wenn jedes choose nur eine endliche Auswahl trifft, so

ist der Operator stetig.

Beweisskizze Nur positive Aufrufe in den Prämissen. Wenn choose nur eine

endliche Auswahl trifft, hat jedes Programm nur endlich viele Endzustände, also hat

jede Regel nur endlich viele Prämissen.

◮ Damit ist der Terminierungsbereich nach dem Satz von Knaster-Tarski

wohldefiniert.

◮ Die Nicht-Stetigkeit macht den Satz von Kleene nicht anwendbar.

Insbesondere ist der Terminierungsbereich nicht einfach (per Iteration über

Schleifenzahl oder Rekursionstiefe) axiomatisierbar.

A. Knapp, G. Schellhorn: Formale Methoden 419


Unbeschränkter Indeterminismus: Beispiel

while m = 1

do if m = 0

then choose m’ with m’ > 0

in m := m’

else m := m -1

◮ Wenn mit m > 0 gestartet, zählt die Schleife bis 1 herunter.

◮ Für m = 0 setzt der erste Durchlauf m auf einen beliebigen Wert > 0.

◮ Also: Die Schleife terminiert immer: Rwhile . . . ↓ A = SA (alle

Zustände).

◮ Aber: Es gibt kein n, sodaß die Schleife nach höchstens n Schritten

terminiert.

◮ Das erste Abwickeln für m = 0 ergibt unendlich viele Prämissen (eine mit m

= 1, eine mit m = 2 usw.). Die erste Prämisse braucht 0

Regelanwendungen, die nächste 1 usw. zum Beweis, daß Terminierung

gilt.

A. Knapp, G. Schellhorn: Formale Methoden 420


Erratische Semantik (1)

Definition Die erratische Semantik Rp⊥ A eines Programms p ist eine

Relation auf (SA ∪ {⊥}) × (SA ∪ {⊥}), wobei ⊥ für Nichtterminierung steht.

Sie ist gegeben durch

Rp⊥ A = Rp A ∪ (((SA ∪ {⊥}) \ Rp↓ A) ×{⊥}) .


Nichtterminierung möglich

◮ Das Paar (⊥, ⊥) ist immer in der Semantik: ” Wenn schon vorher nicht

terminiert, dann kommt das Programm nicht dran, und es bleibt bei

Nichtterminierung“.

A. Knapp, G. Schellhorn: Formale Methoden 421


Erratische Semantik (2)

◮ Für die meisten Programmkonstrukte gelten die alten Gesetze, es kommt

immer nur (⊥, ⊥) hinzu. Beispiele:

◮ Rp1 ; p2⊥ A = Rp1⊥ A ; Rp2⊥ A

◮ Für v = ⊥ gilt: (v, v ′ ) ∈ Rif b then p1 else p2⊥ A gdw.

Wenn T b A v = tt, dann (v, v ′ ) ∈ Rp1⊥ A, sonst (v, v ′ ) ∈ Rp2⊥ A.

◮ Deshalb sind die Kalkülregeln fast dieselben wie für Diamonds.

◮ Nur für Schleifen und Rekursion gibt es keine einfache Definition: man

braucht separate Definitionen.

A. Knapp, G. Schellhorn: Formale Methoden 422


Dämonische Semantik

Das Element ⊥ drückt Unkenntnis über das Ergebnis des Programmlaufs aus

(i.e. Unspezifiziertheit des Endzustands, kann Nichtterminierung, aber auch

etwas anderes sein).

Definition Die dämonische Semantik Rpdem A eines Programms p ist

eine Relation auf (SA ∪ {⊥}) × (SA ∪ {⊥}), gegeben durch

Rpdem A = Rp A ∪ ((SA ∪ {⊥}) \ Rp↓ A)


Nichtterminierung möglich

× (SA ∪ {⊥})


jedes Ergebnis

◮ Recht unintuitiv ist, daß in Rpdem A immer alle Paare (⊥, v ′ ) enthalten

sind.

◮ Für beschränkten Indeterminismus direkt als induktive Relation definierbar.

◮ Es gilt Rabortdem A = (SA ∪ {⊥}) × (SA ∪ {⊥}) und damit wie

gewünscht: Rskip or abortdem A =

Rskipdem A ∪ Rabortdem A = Rabortdem A.

A. Knapp, G. Schellhorn: Formale Methoden 423

.


wp-Kalkül

Wir addieren einen neuen Operator 〈|p|〉ϕ zur Logik mit der Bedeutung: p

terminiert immer und es gilt anschließend ϕ:

A, v |= 〈|p|〉ϕ ⇔ v ∈ Rp↓ A ∧ ∀(v, v ′ ) ∈ Rp A . A, v ′ |= ϕ

◮ Damit befinden wir uns nicht mehr in der dynamischen Logik, sondern im

wp-Kalkül (Edsger W. Dijkstra).

◮ Den Operator findet man häufig als wp(p, ϕ) geschrieben, da er die

schwächste Vorbedingung (engl. weakest precondition) beschreibt, sodaß

nach p ϕ gilt.

◮ [p]ϕ findet man auch als die schwächste liberale Vorbedingung (engl.

weakest liberal precondition) wlp(p, ϕ).

A. Knapp, G. Schellhorn: Formale Methoden 424


Kalkülregeln für totale Korrektheit

◮ Für deterministische Konstrukte (Zuweisung, sequentielle Komposition,

if, let) gelten dieselben Kalkülregeln für wp wie für Diamonds.

◮ Für Schleifen und Aufrufe weiterhin noethersche Induktion, insbesondere

ist die Invariantenregel für totale Korrektheit immer noch korrekt (die

Größe der Variable x muß jetzt für jeden Durchlauf durch den

Schleifenrumpf abnehmen).

Korrektheitsnachweis: Es gelten im wesentlichen dieselben Semantikregeln für

Rp⊥ A wie für Rp A.

A. Knapp, G. Schellhorn: Formale Methoden 425


Kalkülregel für Schleifen

◮ Für unbeschränkt indeterministische Programme gelten nur noch die

Implikationen

∃n . 〈|loop if b then p times n|〉(¬b ∧ ϕ) → 〈|while b do p|〉ϕ

∃n . 〈|q(x; y) : n|〉ϕ → 〈|q(x; y)|〉ϕ

und nicht mehr die Äquivalenzen.

◮ Die Regel (L〈()〉2) wäre für wp inkorrekt.

◮ Nur relevant, wenn man als Voraussetzung in einer Aussage die

Terminierung eines unbeschränkt indeterministischen Programms hat

(sollte man vermeiden, praktisch fast nicht relevant).

◮ Nicht mehr vollständig: ein für den Zustand σ terminierendes Programm p

definiert eine (beliebige) noethersche Ordnung (über die man induzieren

müßte) durch die Small-Step-Semantik:

σ ′′ ≺ σ ′ ⇔ 〈p, σ〉 ⇒ · · · ⇒ 〈p ′ , σ ′ 〉 ⇒ · · · ⇒ 〈p ′′ , σ ′′ 〉 ⇒ . . .

A. Knapp, G. Schellhorn: Formale Methoden 426


Kalkülregeln für or

(R[or]) Γ ⇒ [p1]ϕ, ∆ Γ ⇒ [p2]ϕ, ∆

Γ ⇒ [p1 or p2]ϕ, ∆

(R〈or〉) Γ ⇒ 〈p1〉ϕ, 〈p2〉ϕ, ∆

Γ ⇒ 〈p1 or p2〉ϕ, ∆

(R〈|or|〉) Γ ⇒ 〈|p1|〉ϕ, ∆ Γ ⇒ 〈|p2|〉ϕ, ∆

Γ ⇒ 〈|p1 or p2|〉ϕ, ∆

Definitionen von (L . . . or . . . ) analog

A. Knapp, G. Schellhorn: Formale Methoden 427


Kalkülregeln für choose

(R[choose]) b{x ↦→ y}, Γ ⇒ [p{x ↦→ y}]ϕ, ∆ ∀x . ¬b, Γ ⇒ [p′ ]ϕ, ∆

Γ ⇒ [choose x with b in p ifnone p ′ ]ϕ, ∆

(R〈choose〉) Γ ⇒ ∃y . b{x ↦→ y} ∧ 〈p{x ↦→ y}〉ϕ, (∀x . ¬b) ∧ 〈p′ 〉ϕ, ∆

Γ ⇒ 〈choose x with b in p ifnone p ′ 〉ϕ, ∆

(R〈|choose|〉) b{x ↦→ y}, Γ ⇒ 〈|p{x ↦→ y}|〉ϕ, ∆ ∀x . ¬b, Γ ⇒ 〈|p′ |〉ϕ, ∆

Γ ⇒ 〈|choose x with b in p ifnone p ′ |〉ϕ, ∆

Die Variablen y sind neu; Definitionen von (L. . . choose . . . ) analog

A. Knapp, G. Schellhorn: Formale Methoden 428


Induktive Semantik und Programmsemantik

Auch indeterministische Interpreter sind sinnvolle Definitionen:

Satz Sei C(X) ein Kontext. Dann gilt:

◮ Wenn Rp1 A ⊆ Rp2 A, dann RC(p1) A ⊆ RC(p2) A.

◮ Wenn alle Ergebnisse (i. e. Endzustände) von p1 auch Ergebnisse von p2

sind, so sind alle Ergebnisse von C(p1) auch Ergebnisse von C(p2).

◮ Wenn Rp1↓ A ⊆ Rp2↓ A, dann RC(p1)↓ A ⊆ RC(p2)↓ A.


” Wenn p2 häufiger terminiert als p1, so terminiert auch C(p2) häufiger als

C(p1)“.

Korollar Die durch die induktiven Relationen definierte Programmsemantik

stimmt mit der des rekursiven Interpreters REC# (erweitert um choose)

überein. Es gilt:

〈REC#(p; st)〉st = st’ ↔ p(st, st’)

〈|REC#(p; st)|〉true ↔ p ↓(st)

A. Knapp, G. Schellhorn: Formale Methoden 429


Zusammenfassung

◮ Semantik von Programmen

◮ Relationale, natürliche und strukturell-operationelle Semantik

◮ Fixpunktsätze von Knaster-Tarski und Kleene

◮ Äquivalenz der Semantiken

◮ Lokale Variablen, Prozeduren, Speicher, Ausnahmen

◮ Programmkorrektheit

◮ partielle und totale Korrektheit

◮ Hoare-Kalkül

◮ Dynamische Logik

◮ Indeterminismus

◮ angelische, dämonische, erratische Semantik

◮ wp-Kalkül

A. Knapp, G. Schellhorn: Formale Methoden 430


Motivation: Datentypen mit Zuständen

Bisher: Datenstrukturen werden als algebraische Datentypen spezifiziert. Diese

sind zustandslos (bzw. haben einen Zustand als Argument/Resultat, der damit

immer auch sichtbar ist).

Andere Sichtweise: Ein abstrakter Datentyp bietet Funktionalität (z. B. durch

Methoden) nach außen an, hat aber einen impliziten internen Zustand, der nur

über die Funktionen zugänglich ist (information hiding). Die Funktionen sind

durch Kontrakte spezifiziert.

Die algebraische Sichtweise entspricht stärker der Sicht funktionaler

Programmiersprachen, die zweite Sichtweise eher der objektorientierten Sicht

(aber auch dort gibt es zustandslose Interfaces). Auch für die zweite Sicht

werden zur Definition des Zustands algebraische Datentypen benötigt.

A. Knapp, G. Schellhorn: Formale Methoden 431


Spezifikation von Kontrakten

Es gibt drei Möglichkeiten einen Kontrakt zu definieren:

◮ per Vorbedingung ϕ und Nachbedingung ψ;

◮ in einer gemeinsamen relationalen Spezifikation Op;

◮ als Programm mit einem choose.

Beispiel (Revertieren einer Liste):

◮ Eingabevariable: x

◮ Ausgabevariable: x

◮ Vorbedingung: x = x0

◮ Nachbedingung: x = reverse(x0)

A. Knapp, G. Schellhorn: Formale Methoden 432


Kontrakt als Relation: Beispiel

Spezifikation als Relation: Op(x, x ′ ) = ∃x0 . x = x0 ∧ x ′ = reverse(x0)

◮ Benötigt wird Konvention für Start- und Endwert einer Variable:

◮ Hier wie in Z: x bezeichnet den Startwert, x ′ den Endwert

◮ VDM: pre(x) für den alten, x für den neuen

◮ JML: \old(x) und x für den neuen

◮ Die Relation ist die Konjunktion von Vor- und Nachbedingung, wobei in der

Nachbedingung x ′ statt x genommen wird.

◮ In der Relation stehen nur die Programmvariablen.

◮ Hilfsvariable x0 wird existenzquantifiziert, fällt weg. Im Beispiel kann zu

x ′ = reverse(x) vereinfacht werden.

◮ Relationale Spezifikation ist etwas eleganter als getrennte Vor- und

Nachbedingung (Programmvariablen klar, keine Hilfsvariablen).

A. Knapp, G. Schellhorn: Formale Methoden 433


Kontrakte als Relationen

◮ Allgemeine Definition einer Relation für Vorbedingung ϕ und

Nachbedingung ψ also:

Op(x,x ′ ) = ∃x0 . ϕ ∧ ψ{x ↦→ x ′ }

wobei x0 alle Nicht-Programmvariablen sind.

◮ Die (implizite) Vorbedingung ist jetzt

pre(Op) = ∃x ′ . Op(x,x ′ )

Schreibweise in der Spezifikationssprache Z:

Op

∆x

ϕ

ψ{x ↦→ x ′ }

A. Knapp, G. Schellhorn: Formale Methoden 434


Kontrakt mit choose

Beobachtung: Mit folgendem indeterministischen Programm kann man den

Kontrakt trivial erfüllen:

Op(x; x ′ ) choose x ′ with x ′ = reverse(x)

in x := x ′ ifnone chaos(x)

Dabei ist chaos(x) ein Programm, das irgendetwas tut, wenn die

Vorbedingung nicht erfüllt ist:

chaos(x) = choose x ′ , boolvar with true

in if boolvar then abort else x := x ′

Das choose-Program ist also so etwas wie die ” allgemeinste

Implementierung“.

Im Beispiel wird chaos(x) nie aufgerufen, da jede Liste revertiert werden kann;

das Programm kann vereinfacht werden zu

Op(; x) x := reverse(x)

A. Knapp, G. Schellhorn: Formale Methoden 435


Operationale Definition von Kontrakten

Ein Kontrakt, der gegeben ist durch

◮ eine Relation Op oder

◮ Vor- und Nachbedingungen ϕ, ψ mit Variablen x

kann auch operational spezifiziert werden als

bzw. als

Op(x; x ′ ) choose x ′ with Op(x,x ′ )

in x := x ′ ifnone chaos(x)

Op(x; x ′ ) choose x ′ with ∃x0 . ϕ ∧ ψ{x ↦→ x ′ }

in x := x ′ ifnone chaos(x)

A. Knapp, G. Schellhorn: Formale Methoden 436


Operationale und relationale Spezifikationen (1)

Operationale Spezifikationen

◮ Vorteil: Ein abstraktes Programm muß bei falscher Vorbedingung nicht mit

chaos reagieren. Alternativen z. B. abort oder “contract exception”.

Spezifikation mit Programmen ist etwas mächtiger als mit Kontrakten.

◮ Vorteil: Spezifikation kann Kontrollstruktur haben (sequentielle

Komposition, Fallunterscheidung etc.)

◮ Vorteil (?): x := reverse(x) ist für Informatiker ” natürlicher“ als

x ′ = reverse(x)

◮ Nachteil: Die allgemeine Übersetzung eines Kontrakts in ein

choose-Programm ist recht konkret: Relationen abstrakter

A. Knapp, G. Schellhorn: Formale Methoden 437


Operationale und relationale Spezifikationen (2)

Relationale Spezifikationen

◮ Vorteil: Reine Prädikatenlogik (keine Big-Step-Semantik etc.)

◮ Nachteil: Frameproblem:

Der Zustand sei x1, x2, . . . , xn, Operation Op1 verdoppele x1:

◮ operational

x1 := 2 ∗ x1

◮ relational

Op1(x1, . . . , xn, x ′ 1, . . . , x ′ n) ↔ x ′ 1 = 2 ∗ x1 ∧ x ′ 2 = x2 ∧ . . . ∧ x ′ n = xn

A. Knapp, G. Schellhorn: Formale Methoden 438


Abstrakte Datentypen

Definition Ein abstrakter Datentyp (St, Init, (Opi)i∈I) besteht aus

◮ einer Zustandsmenge St;

◮ Typischerweise besteht St aus der Belegung eines Vektors von Variablen mit

algebraisch spezifizierten Datentypen.

◮ einer Menge von Initialzuständen Init ⊆ St;

◮ Einer Familie (für i ∈ I) von Operationen Opi ⊆ Ini × St × St × Outi.

◮ Operationen entsprechen (relational definierten) Kontrakten.

◮ Jede Operation

◮ hat Eingaben aus Ini (kann für einzelne Operationen wegfallen);

◮ modifiziert den Zustand aus St;

◮ und hat eine Ausgabe aus Outi (kann für einzelne Operationen wegfallen).

A. Knapp, G. Schellhorn: Formale Methoden 439


Abstrakte Datentypen: Beispiele (1)

Ein Java-Objekt kann als abstrakter Datentyp aufgefaßt werden:

◮ St ist die Menge der möglichen Belegungen der Felder.

◮ Init sind die Ergebnisse der Konstruktoren.

◮ Opi sind Kontrakte für die Methoden des Objekts.

◮ Die Felder des Objekts sind privat (nur über die Methoden zugänglich).

Ein Java-Klasse kann als abstrakter Datentyp aufgefasst werden:

◮ St ist die Menge der möglichen Objektmengen einer Klasse.

◮ Init (einelementig) ist das Ergebnis der statischen Initialisierung.

◮ Opi sind Kontrakte für die Methoden der Klasse.

A. Knapp, G. Schellhorn: Formale Methoden 440


Abstrakte Datentypen: Beispiele (2)

Ein ganzes Softwaresystem kann als abstrakter Datentyp aufgefaßt werden.

◮ St ist die Menge der Systemzustände (z. B. die Menge der möglichen

Instanzen eines Konzeptmodells).

◮ Init sind die Initialzustände.

◮ Opi sind Kontrakte für die Systemoperationen.

Ein Programmierspracheninterpreter kann als abstrakter Datentyp aufgefaßt

werden.

◮ St besteht aus Variablenbelegung und dem abzuarbeitendem

Restprogramm.

◮ Init legt das Gesamtprogramm fest, das zu bearbeiten ist (ein

Initalzustand pro Programm).

◮ Opi verarbeitet eine Instruktion.

A. Knapp, G. Schellhorn: Formale Methoden 441


Algebraischer Datentyp queue

Gegeben seien algebraisch spezifizierte Queues von Integers (hier als Instanz

von Listen, es geht auch direkt) mit Operationen:

◮ Sorte intqueue

◮ Konstante emq (die leere Queue)

◮ Funktion enq : queue × int → queue (hinten an die Queue anfügen)

◮ Funktion deq : queue × queue (vorne wegnehmen)

◮ Funktion hd : queue × int (vorderstes Element)

A. Knapp, G. Schellhorn: Formale Methoden 442


Abstrakter Datentyp queue

◮ Zustand = eine Variable q vom Typ queue

◮ Initialzustand: q = emq

◮ int⊥ = mki⊥( . .i : int) | ⊥

(freier Datentyp für das Resultat von DEQ)

◮ Zwei Operationen:

◮ ENQ ⊆ int × queue × queue mit Kontrakt:

ENQ(i, q, q’) ↔ q’ = enq(i, q)

◮ DEQ ⊆ queue × queue × int⊥ mit Kontrakt:

DEQ(q, q’, i⊥) ↔ (q = [] ⊃

q’ = deq(q) ∧ i⊥ = mki⊥(hd(q));

q’ = q ∧ i⊥ = ⊥)

◮ ⊥ könnte in einer Implementierung eine Exception werden, aber auch ein

Spezialwert bleiben.

Wenn der Zustand einfach eine Variable eines Datentyps ist, ergibt sich fast

eine Duplikation des algebraischen Datentyps.

A. Knapp, G. Schellhorn: Formale Methoden 443


Abstrakte Datentypen: Verwendung

◮ Ein abstrakter Datentyp wird immer innerhalb einer Umgebung verwendet.

◮ Die Umgebung kann sehr verschieden sein:

◮ ein Programm, wenn ein Objekt oder eine Klasse definiert wird;

◮ eine einfache Kontrollschleife für einen Interpreter;

◮ Benutzer, die die Operationen per Knopfdruck aufrufen;

◮ für ein System: eine beliebige Systemumgebung aus anderen Rechnern

(Clients, die auf einen Server zugreifen, etc.)

◮ Zwei Grundannahmen:

◮ Operationen sind atomar ( ” Transaktionscharakter“);

◮ beobachtet werden nur Eingabe und Ausgabe, der Zustand ist unsichtbar.

A. Knapp, G. Schellhorn: Formale Methoden 444


Ablauf eines abstrakten Datentyps

Definition Ein (endlicher) Ablauf eines abstrakten Datentyps

(St, Init, (Opi)i∈I) ist eine Folge

mit

σ0

◮ σ0 ∈ Init

k0,in0,out0

−−−−−→ σ1

◮ (ini, σi, σi+1, outi) ∈ Opki

k1,in1,out1

−−−−−→ σ2 −→ . . . −→ σn−1

für 0 ≤ i < n.

◮ Der letzte Schritt kann auch σn−1

verletzt wurde, i. e. falls

gilt.

kn−1,inn−1,outn−1

−−−−−−−−−−→ σn

kn−1,inn−1

−−−−−−→ ⊥ sein, falls die Vorbedingung

¬∃outn−1, σn . (inn−1, σn−1, σn, outn−1) ∈ OPkn−1

A. Knapp, G. Schellhorn: Formale Methoden 445


Abstract State Machines (1)

Definition Eine Abstract State Machine (ASM) (Σ, Init, (Rulei)i∈I, Fin)

besteht aus

◮ einer (endlichen) prädikatenlogischen Signatur Σ;

◮ Daraus ergibt sich die Zustandsmenge als alle Σ-Algebren St = Alg(Σ).

◮ einer Menge von Anfangszuständen Init ⊆ St;

◮ einer Menge von Regeln Rulei, die den Zustand modifizieren;

◮ Regeln sind Programme mit choose und Funktionsmodifikation

f (t) := t ′ .

◮ einer Menge Fin ⊆ St von Endzuständen.

◮ Beobachtung des Endzustands

A. Knapp, G. Schellhorn: Formale Methoden 446


Abstract State Machines (2)

Entwickelt von Yuri Gurevich (1984)

◮ ASMs sind eine Instanz der operationalen Idee für Kontrakte.

◮ Algebren als Zustände sind so allgemein wie möglich

◮ Theoretische Untersuchungen zur Frage: Was ist ein Algorithmus?

◮ Ein-/Ausgabe muß in den Zustand integriert werden.

◮ Eine Σ-Algebra belegt jetzt modifizierbare Funktionen (endlich viele).

◮ Eine modifizierbare Konstante ist dasselbe wie eine Programmvariable.

◮ Eine modifizierbare Funktion entspricht einer (second-order) Variable für

Funktionen.

◮ Funktionsmodifikation f (t) := t ′ entspricht

f := (λ x . x = t ⊃ t ′ ; f (x)).

◮ f (t) := t ′ kann man auch so in KIV eintippen.

◮ Es gibt Erweiterungen von ASMs für Parallelität: forall x with b do p

A. Knapp, G. Schellhorn: Formale Methoden 447


Verfeinerung

Die Grundfrage, auf die Verfeinerung (engl. refinement) eine Antwort gibt, ist:

Gegeben eine abstrakte Beschreibung eines Systems. Wie kommt man

systematisch und schrittweise zu einer korrekten Implementierung?

Verfeinerung gibt es in einer großen Zahl von Varianten:

◮ für algebraische (zustandslose) Systeme

(algebraisches Refinement, Moduln)

◮ für parallele (ereignisbasierte) Systeme

(CSP-Refinement/(Bi-)Simulation)

◮ für zustandsbasierte Datentypen:

◮ relational: Data Refinement

◮ operational: ASM Refinement

◮ für Automaten: IO-Automata Refinement

A. Knapp, G. Schellhorn: Formale Methoden 448


Data Refinement (1)

Grundidee:

◮ Gegeben sei der ADT (ASt, AInit, (AOpi)i∈I).

◮ Der Zustand in ASt ist nach außen hin unsichtbar. Er kann deshalb durch

einen konkreten Zustand ersetzt werden, wenn sich die Funktionalität nach

außen hin nicht ändert.

◮ Sei also ein ” konkreterer Datentyp“ (CSt, CInit, (COpi)i∈I) gegeben.

◮ Der konkrete Datentyp ist eine korrekte Verfeinerung des abstrakten, wenn

jede Umgebung, die annimmt, den abstrakten Datentyp zu verwenden, es

nicht bemerken kann, daß sie in Wirklichkeit den konkreten verwendet.

◮ Es gilt also das Substitutionsprinzip, daß alle abstrakten durch konkrete

Operationen ersetzt werden können.

◮ Das Verfahren kann iteriert werden und damit ein schrittweiser Übergang

von abstrakter Spezifikation zu konkreter Implementierung erreicht

werden.

A. Knapp, G. Schellhorn: Formale Methoden 449


Data Refinement (2)

Definition Gegeben seien zwei abstrakte Datentypen

ADT = (ASt, AInit, (AOpi)i∈I) und CDT = (CSt, CInit, (COpi)i∈I). Dann heißt

CDT eine korrekte Verfeinerung von ADT, wenn für jeden Ablauf von CDT ein

passender abstrakter Ablauf existiert: Wenn

cσ0

k0,in0,out0

−−−−−→ cσ1

k1,in1,out1

kn−1,inn−1,outn−1

−−−−−→ cσ2 −→ . . . −→ cσn−1 −−−−−−−−−−→ cσn

ein Ablauf von CDT ist, dann gibt es Zustände aσ0, . . . , aσn ∈ ASt, sodaß

aσ0

k0,in0,out0

−−−−−→ cσ1

k1,in1,out1

kn−1,inn−1,outn−1

−−−−−→ aσ2 −→ . . . −→ aσn−1 −−−−−−−−−−→ aσn

(mit denselben Ein- und Ausgaben) ein Ablauf von ADT ist.

◮ Der konkrete Datentyp kann durchaus weniger Abläufe haben: Er ist dann

weniger indeterministisch.

A. Knapp, G. Schellhorn: Formale Methoden 450


Data Refinement (3)

◮ Bei Data Refinement müssen beide Datentypen dieselbe Granularität der

Operationen und dieselben Ein-/Ausgaben haben.

◮ Erweiterungen betreffen also:

◮ Verkleinerung (oder allgemeiner: Wechsel) der Granularität

◮ Wechsel der Datenrepräsentation für Ein-/Ausgaben.

◮ Andere Fragestellungen sind:

◮ Was ist mit unendlichen Abläufen? (relevant?)

◮ Will man auch Deadlocks modellieren?

A. Knapp, G. Schellhorn: Formale Methoden 451


Data Refinement: Beispiel

queue wird durch einen Speicher st und einen Zeiger r, der auf den Anfang

der Liste zeigt, repräsentiert. Der konkrete Datentyp wird gleich durch ein

Programm implementiert, nicht zuerst spezifiziert.

◮ Der Speicher hat als Schlüssel References (Typ ref) mit null : ref.

◮ Der Speicher enthält als Daten (freier Datentyp):

conscell = . × . (. .1 : int; . .2 : ref)

◮ Die null-Referenz entspricht einer leeren Queue.

◮ enq# relativ einfach

◮ deq# muß die Verkettung bis zum Ende ablaufen, dann hinten anhängen.

A. Knapp, G. Schellhorn: Formale Methoden 452


Data Refinement: Repräsentationsrelation

Benötigt wird eine Repräsentationsrelation (oder auch eine Simulation,

Kopplungsinvariante, Abstraktionsrelation engl. simulation, representation

relation, coupling invariant) R ⊆ ASt × CSt zwischen den beiden Zuständen.

R(aσ, cσ) besagt: Der Zustand cσ repräsentiert den abstrakten Zustand aσ. Die

Relation ist meist eine partielle Funktion (deshalb auch Abstraktionsfunktion):

ein konkretes Datum repräsentiert höchstens ein abstraktes.

A. Knapp, G. Schellhorn: Formale Methoden 453


Repräsentationsrelation: Beispiel (1)

Im Speicher st steht unter r eine lineare, nichtzyklische Kette von Zellen,

deren Inhalte die Inhalte der Queue q sind.

abs(r, st, q) besagt ” Speicherinhalt unter r in st repräsentiert die Queue

q“. Formale Definition:

abs(r, st, q) ↔

(r = null ⊃

q = emq;

( r ∈ st (: r ist allokiert :)

∧ ¬ cyclic(r, st) (: kein zyklischer Pfad von r aus :)

∧ q = emq

∧ hd(q) = st[r].1 (: erstes Datum paßt :)

∧ abs(st[r].2, st, deq(q)))); (: Rest paßt :)

A. Knapp, G. Schellhorn: Formale Methoden 454


Repräsentationsrelation: Beispiel (2)

cyclic(r, st) bedeutet, daß es einen Pfad im Speicher gibt mit erstes

Element = r, in dem sich ein Element wiederholt.

Für die formale Definition werden Listen von Referenzen x benötigt. Damit

rekursive Definition von path(x, st) ( ” x ist ein Pfad im Speicher st“):

path-empty: ¬ path([], st);

path-one: path(r ’, st) ↔ r ∈ st ∧ r = null;

path-cons: path(r + r0 + x, st) ↔

r ∈ st ∧ r = null ∧

st[r].2 = r0 ∧ path(r0 + x, st);

Damit

cyclic-def: cyclic(r, st) ↔

∃ x. r = x.first ∧ path(x, st) ∧ dups(x);

Dabei bedeutet dups(x), daß x Duplikate hat:

dups: dups(x) ↔ ∃ a, x0, y, z. x = x0 + a + y + a + z;

A. Knapp, G. Schellhorn: Formale Methoden 455


Data Refinement: Korrektheitsnachweis (1)

Hinreichendes Kriterium: Die Repräsentationsrelation ist eine

Vorwärtssimulation (engl. forward/downward simulation). Informell muß gelten:

◮ Zu jedem konkreten Initialzustand cσ gibt es einen passenden

Initialzustand aσ mit R(aσ, cσ).

◮ Wenn die Vorbedingung von AOpi wahr ist, und R(aσ, cσ) gilt, dann ist

auch die Vorbedingung von COpi wahr.

◮ Wenn R(aσ, cσ) gilt, beide Vorbedingungen wahr sind, COpi bei Eingabe

in und Startzustand cσ Endzustand cσ ′ mit Ausgabe out hat, dann gibt es

einen passenden Endzustand aσ ′ von AOpi für dieselbe Ein- und

Ausgabe, der wieder R(aσ ′ , cσ ′ ) erfüllt.

in, aσ

R

in, cσ

AOpi

COpi

aσ ′ , out

R

cσ ′ , out

in, aσ

R

in, cσ

AOpi

COpi

A. Knapp, G. Schellhorn: Formale Methoden 456



Data Refinement: Korrektheitsnachweis (2)

Satz Die Verfeinerung ist korrekt, wenn eine Vorwärtssimulation R gefunden

werden kann, für die gilt:

◮ Initialisierung:

Init(cσ) → ∃aσ . R(aσ, cσ)

◮ Anwendbarkeit:

R(aσ, cσ) ∧ pre(AOpi)(in, aσ) → pre(COpi)(in, cσ)

◮ Korrektheit:

R(aσ, cσ) ∧ pre(AOpi)(in, aσ) ∧ COpi(in, cσ, cσ ′ , out) →

∃aσ ′ . AOpi(in, aσ, aσ ′ , out) ∧ R(aσ ′ , cσ ′ )

wobei pre(Opi)(in, σ) ↔ ∃σ ′ , out . Opi(in, σ, σ ′ , out).

Für das Queue-Beispiel sind alle Teile mit pre irrelevant, da alle

Vorbedingungen wahr sind.

A. Knapp, G. Schellhorn: Formale Methoden 457


Korrektheitsnachweis: Beispiel

Im Queue-Beispiel sind die Vorbedingungen (pre) immer wahr. Damit ist die

Verfeinerung von Queues zur Implementierung korrekt, wenn folgende

Sequenzen bewiesen werden können:

◮ Initialisierung:

⊢ 〈|emq#(; r, st)|〉abs(r, st, emq)

◮ Korrektheit für enq#:

abs(r,st,q) ⊢ 〈|enq#(i; r, st)|〉abs(r, st, enq(q,i))

◮ Korrekhteit für deq# (Fall: nichtleeres q):

abs(r, st, q), q = emq ⊢

〈|deq#(; r, st, i⊥)|〉(abs(r, st, deq(q)) ∧

i⊥ = mki⊥(hd(q)))

◮ Korrekheit für deq# (Fall: leeres q):

abs(r, st, emq) ⊢

〈|deq#(; r, st, i⊥)|〉(abs(r, st, emq) ∧ i⊥ = ⊥)

A. Knapp, G. Schellhorn: Formale Methoden 458


Zusammenfassung

◮ Relationale und operationale Kontrakte

◮ Abstrakte Datentypen

◮ Abstract State Machines

◮ Data Refinement

◮ Repräsentationsrelation

◮ Vorwärtssimulation

A. Knapp, G. Schellhorn: Formale Methoden 459

Weitere Magazine dieses Users
Ähnliche Magazine