sequenzenkalk ul: inferenzregeln...backtracking, pruning simpli kation + heuristiken zur...
TRANSCRIPT
-
Sequenzenkalkül: Inferenzregeln
Regel: (n ≥ 0)
Γ1 ` ∆1 Γ2 ` ∆2 . . . Γn ` ∆nΓ ` ∆
• Regeln werden von unten nach oben gelesen:Um Γ ` ∆ (die Konklusion) zu beweisen, beweise stattdesseneinfachere Prämissen Γ1 ` ∆1, . . . ,Γn ` ∆n
• Bei n = 0 ist die Konklusion direkt bewiesen• n = 1: Vereinfachung• n = 2: Fallunterscheidung
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 25 / 290
-
Sequenzenkalkül: Ableitbarkeit
Γ ` ∆ ist aus einer Menge von Formeln (Axiomen) Ax ableitbar
(kurz: Ax `PL Γ ` ∆)
:⇔ Es gibt eine Ableitung (Baum) mit
• Wurzel: Γ ` ∆ (Konklusion)
• Blätter: ` ϕ mit ϕ ∈ Ax (Prämissen)
• Innere Knoten durch Regelanwendungen gebildet
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 26 / 290
-
Kalkül für Aussagenlogik
ϕ,Γ ` ϕ,∆ (axiom) false,Γ ` ∆ (false left) Γ ` true,∆ (true right)
Γ′ ` ∆′Γ ` ∆ (weakening, Γ
′ ⊆ Γ,∆′ ⊆ ∆) Γ ` ϕ,∆ ϕ,Γ ` ∆Γ ` ∆ (cut formula)
Γ ` ϕ,∆¬ ϕ,Γ ` ∆ (negation left)
ψ,Γ ` ∆Γ ` ¬ ψ,∆ (negation right)
ϕ,ψ,Γ ` ∆ϕ ∧ ψ,Γ ` ∆ (conjunction left/right)
Γ ` ϕ,∆ Γ ` ψ,∆Γ ` ϕ ∧ ψ,∆
ϕ,Γ ` ∆ ψ,Γ ` ∆ϕ ∨ ψ,Γ ` ∆ (disjunction left/right)
Γ ` ϕ,ψ,∆Γ ` ϕ ∨ ψ,∆
Γ ` ϕ,∆ ψ,Γ ` ∆ϕ→ ψ,Γ ` ∆ (implication left/right)
ϕ,Γ ` ψ,∆Γ ` ϕ→ ψ,∆
Γ ` ϕ,ψ,∆ ϕ,ψ,Γ ` ∆ϕ ↔ ψ,Γ ` ∆ (equivalence left/right)
ϕ,Γ ` ψ,∆ ψ,Γ ` ϕ,∆Γ ` ϕ ↔ ψ,∆
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 27 / 290
-
KIV: Anmeldung und Starten
• Anmelden im Praktikumsraum unter Windows mit DCE-Account• Starten der VMWare für Linux und KIV• Anmelden als user• Starten von KIV durch Click auf’s Logo
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 28 / 290
-
KIV: Organisation in Projekte
Grundlegende Organisation:
• In KIV arbeitet man in (SW-Entwicklungs-) Projekten
• Im Praktikum: Projekte”Exercise1“ . . .
”Exercise6“
für die 6 Versuche
• Jedes Projekt definiert Spezifikationen (Σ + Ax + Weiteres)
• Spezifikationen können aufeinander aufbauen⇒ Entwicklungsgraph
• Über jeder Spezifikation kann man Theoreme formulieren undbeweisen
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 29 / 290
-
KIV: Projektauswahl- und Projektebene
4 Ebenen:
1 Projektauswahlebene• Projekte anlegen, löschen, auf einem Projekt arbeiten
2 Projektebene• Zeigt den Entwicklungsgraph der Spezifikationen• Spezifikationen anlegen, ändern, löschen• Auf einer Spezifikation arbeiten
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 30 / 290
-
KIV: Spezifikations- und Beweisebene
3 Spezifikationsebene• Theoreme anlegen, ändern, löschen• Ein Theorem zum Beweisen wählen
4 Beweisebene• Beweise führen durch interaktive Anwendung von Regeln• Zwei Regelsätze: Basisregeln zum Lernen
+ für echte Beweisen optimierte Regeln• Backtracking, Pruning• Simplifikation + Heuristiken zur automatischen Anwendung von
Regeln
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 31 / 290
-
KIV: Verzeichnisstruktur
Verzeichnisstruktur:
• Im”projects“-Verzeichnis von KIV
pro Projekt ein Verzeichnis
• enthält alle relevanten Daten zum Projekt• Darin:
• Ein Unterverzeichnis specs• [Eine Datei devgraph für den Entwicklungsgraph]
• In specs: ein Unterverzeichnis für jede Spezifikation• Darin:
• Eine Datei specification für Signatur, Axiome etc.• Eine Datei sequents für Theoreme• [Ein Verzeichnis proofs das geladene Theoreme, geführte Beweise etc.
speichert]
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 32 / 290
-
Bis nächsten Freitag
Vorbereiten der ersten Hälfte vonÜbung 1 anhand der Doku!
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 33 / 290
-
Variablen und freie Variablen eines Ausdrucks
Die Variablen eines Ausdrucks (Var(e))
Var(x) = {x} x ∈ XVar(op(e1, . . . , en)) =
⋃ni=1 Var(ei )
Var(e = e ′) = Var(e) ∪ Var(e ′)Var(Qx .ϕ) = {x} ∪ Var(ϕ) Q ∈ {∀, ∃}
Die freien Variablen einer Formel (free(ϕ)) sind genauso definiert ausser:
free(Qx .ϕ) = free(ϕ) \ {x} Q ∈ {∀,∃}
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 34 / 290
-
Substitution
Die Substitution einer Variablen x durch einen Ausdruck t in e (etx)
x tx = t
y tx = y falls x 6= yop(e1, . . . , en)
tx = op((e1)
tx , . . . , (en)
tx)
(e1 = e2)tx = ((e1)
tx = (e2)
tx)
(Qy .ϕ)tx =
Qy .ϕ falls y = x ∨ x 6∈ free(ϕ)Qy .ϕtx falls y 6= x , y 6∈ free(t), x ∈ free(ϕ)Qz .(ϕzy )tx falls y 6= x , y ∈ free(t), x ∈ free(ϕ)
(z neu, d. h. z 6∈ Var(ϕ) ∪ Var(t))(Q ∈ {∀, ∃})
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 35 / 290
-
Regeln für Gleichungen
Γ ` τ = τ ,∆ (reflexivity right)
x = τ,Γτx ` ∆τxx = τ,Γ ` ∆ (insert equation)
• Statt x = τ ist auch τ = x erlaubt (Symmetrie)• KIV erlaubt auch:
• Einsetzen von Gleichungen τ = τ ′ (beides keine Variable).Ersetzt τ nur dort, wo alle Variablen frei sind.
• Einsetzen der Gleichung nur an spezifischenPositionen in Γ ` ∆ (selten gebraucht)
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 36 / 290
-
Beispiel
Ein Beweis mit Quantoren.
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 37 / 290
-
Regeln für Quantoren
• ϕτx , ∀ x .ϕ,Γ ` ∆∀ x .ϕ,Γ ` ∆ (all left)
Γ ` ϕτx ,∃ x .ϕ,∆Γ ` ∃ x .ϕ,∆ (exists right)
• ϕyx ,Γ ` ∆
∃ x .ϕ,Γ ` ∆ (exists left)Γ ` ϕyx ,∆
Γ ` ∀ x .ϕ,∆ (all right)
ϕτx die Substitution von x durch einen beliebigen Term τ in ϕ.
y ist eine neue Variable, i. e. eine, die nicht frei in Q x .ϕ,Γ,∆(Q ∈ {∀,∃}) vorkommt.
Genauer: y 6∈ (free(ϕ)\{x}) ∪ free(Γ) ∪ free(∆)
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 38 / 290
-
Intuition für Quantorenregeln (1)
all left:
• Allquantor im Antezedent: ∀ x .ϕ wird als wahr angenommen• Aus der Annahme folgt, dass auch die Annahme ϕtx für einen
beliebigen Term t wahr ist
• Jede Formel ϕtx darf hinzugenommen werden• Einziges Problem: Welches t ist nützlich (kreativ!)?
all right:
• Allquantor im Sukzedent: ∀ x .ϕ soll bewiesen werden• Dazu muss ϕ für
”jedes beliebige, feste“ Element bewiesen werden
• Eine Variable y bezeichnet so ein beliebiges Element, aber nur, wennsie neu ist
• Wenn die Variable nicht neu wäre, wäre ihr Wert nicht beliebig,sondern durch die Formeln eingeschränkt.
• Statt ∀ x .ϕ zeige man also ϕyx mit neuem y .• Keine Kreativität erforderlich
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 39 / 290
-
Intuition für Quantorenregeln (2)
ex right:• ∃ x .ϕ im Sukzedent soll bewiesen werden• Wenn ϕtx für einen Term t bewiesen werden kann, so ist ∃ x .ϕ wahr
für den Wert den t bezeichnet.
• Also darf man sich ein t (hoffentlich das”richtige“) aussuchen, um
einen Beweis für ϕtx zu führen.
ex left:• ∃ x .ϕ im Antezedent darf angenommen werden.• Es gibt also eine Belegung von x mit einem Element, für die ϕ wahr
ist
• Über das Element weiss man nur, dass ϕ wahr wird.• Eine neue Variable y können wir mit dem Element belegen, da die
Gültigkeit der Sequenz von der Belegung bisher nicht abhängt.
• Die neue Variable gibt einen”Namen“ für das existierende Element.
• Statt ∃ x .ϕ wird also ϕyx mit neuem y als Annahme verwendet.23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 40 / 290
-
Zusätzliche Regel: Insert Axiom
Γ,Cl∀ (ϕ) ` ∆
` ϕ` Cl∀ (ϕ)
all right
Γ ` Cl∀ (ϕ),∆weakening
Γ ` ∆ cut
Cl∀ (ϕ) := ∀ x1, . . . , xn.ϕ, wobei {x1, . . . , xn} = free(ϕ)
Neue Regel im Basiskalkül, um obige Schritte abzukürzen:` Ax Cl∀ (Ax),Γ ` ∆
Γ ` ∆ (insert axiom)
• KIV bietet die erste Prämisse nicht mehr an• Später: Der KIV-Kalkül hat noch komfortablere Regeln:
insert lemma & insert rewrite-lemma
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 41 / 290
-
Vorgriff: Induktion für natürliche Zahlen
• Theoretisches zu Induktion später• In KIV gibt es pro Datentyp meist eine strukturelle Induktionsregel• Nat. Zahlen: Wenn für eine Formel ϕ(n)
• ϕ(0) gilt• Für jedes n: Aus Ind.hyp. ϕ(n) folgt: ϕ(n +1)
dann gilt für ∀ n. ϕ(n)• Im Sequenzenkalkül: ϕ ist jetzt die Sequenz Γ ` ∆ (für
Induktionsformel in Formel umwandeln!)
` ϕ(0) ϕ(n) ` ϕ(n +1)Γ ` ∆
ϕ = ∀ y .∧
Γ →∨
∆, y = free(Γ→ ∆) \ {n}
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 42 / 290
-
Semantik vonFormeln und Sequenzen
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 43 / 290
-
Grundidee der Verwendung vonLogik im Softwareentwurf
Syntax: Menge von Formeln= Axiome Ax
beschreiben
��
` K,,ist beweisbar”
Voll-ständig-
keit��
Formel ϕ
beschreibt
��Semantik:
Software-Systeme:Menge von Algebren
{A,B, . . .}|=
,,ist gültig in”
Ko-rrekt-keit
OO
Eigenschaft ϕA
Ziel: Nachweis, dass ein reales Softwaresystem eine Eigenschaft hat.Technik: Formaler Beweis (
”Rechnen mit Formeln“) in KIV.
Korrektheit + Vollständigkeit garantieren, dass man das richtige tut
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 44 / 290
-
Grundidee der Verwendung vonLogik im Softwareentwurf (1)
Semantik (i. e. der Inhalt, dessen was wir tun):
• 1. Schritt: Wir wollen Softwaresysteme und funktionaleAnforderungen an solche beschreiben
• SW-Systeme sind Datenstrukturen, Programme etc.Bei eingebetteten Systemen evtl. inclusive Umgebung
• 2. Schritt: Gegeben eine beliebige Implementierung, die dieAnforderungen erfüllt, wollen wir Eigenschaften wie z. B. Korrektheitund Sicherheit nachweisen
Mathematik:Das allgemeinste Modell für ein SW-System ist eine Algebra A.
Wir wollen also Algebren beschreiben, und Eigenschaften von Algebrennachweisen.
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 45 / 290
-
Grundidee der Verwendung vonLogik im Softwareentwurf (2)
Mathematik: Sprachen zum Beschreiben von Algebren und ihrenEigenschaften heissen Logiken
Bem.: Auch Prog.sprachen sind spezielle Beschreibungen von Algebren!
Syntax
• Algebren kann man durch Formelmengen Ax beschreiben• Eigenschaften werden durch Formeln ϕ beschreiben• Statt informell zu überlegen ob eine Eigenschaft gilt, verwenden wir
einen Kalkül K , und zeigen formal: Ax `K ϕ
Gewinn: Garantie, dass SW-System Eingenschaft hat
Keine absolute Garantie: Nur so gut, wie die Genauigkeit der Beschreibungdes SW-Systems (insbes. die Umgebung bei eingebetteten Systemen!)
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 46 / 290
-
Semantik: Σ-Algebren
Eine Σ-Algebra A = ((As)s∈S , (opA)op∈OP)zu einer Signatur Σ = (S ,OP) ist ein Paar mit:
• Nichtleeren Mengen As für jede Sorte s ∈ S (Trägermengen)• Die Trägermenge Abool ist immer gleich {tt,ff}• Funktionen opA : As1 × . . .× Asn → As′ für alle op : s1, . . . , sn → s ′
• Die vordefinierten booleschen Symbole haben in jedem A die“normale” Bedeutung (Wahrheitstafeln):trueA = tt, ∧A(tt,ff) = ff, ∨A(tt,ff) = tt etc.
Die Menge aller Σ-Algebren über Σ wird mit Alg(Σ) bezeichnet.
Merke: Sorten bedeuten Datenmengen,Operationssymbole bezeichen FunktionenAlgebra = Datenstruktur, Σ entspricht Interface
Bsp: Datenmenge = Menge aller Listen, Operation: Aneinanderhängen
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 47 / 290
-
Semantik: Belegungen von Variablen
Eine Belegung (engl. valuation; auch: ein Zustand)
v :⋃
s∈S vs : Xs → As
ist eine Abbildung, die jedem Variablensymbol in Xs einen Wert in Aszuordnet
Die Abänderung vax der Belegung v für x ∈ Xs und a ∈ As ist definiertdurch:
vax (y) :=
{v(y) falls x 6= y
a falls x = y
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 48 / 290
-
Semantik von Ausdrücken
Gegeben eine Algebra A und eine Belegung v . Dann ist die Semantik[[e]]A,v eines Ausdrucks e der Sorte s das folgende Element aus As :
• [[x ]]A,v := v(x) für x ∈ Xs• [[op(e1, . . . , en)]]A,v := opA([[e1]]A,v , . . . , [[en]]A,v ) für op ∈ OP und
ei ∈ EXPR(Σ,X )• [[e1 = e2]]A,v := tt, falls [[e1]]A,v = [[e2]]A,v (sonst := ff)• [[∀ x .ϕ]]A,v := tt, falls für alle a ∈ As′ gilt: [[ϕ]]A,vax = tt (sonst := ff)
(x ∈ Xs′)• [[∃ x .ϕ]]A,v := tt, falls es ein a ∈ As′ gibt mit [[ϕ]]A,vax = tt (sonst :=
ff) (x ∈ Xs′)
Hinweis: Falls ϕ eine Formel ist, so ist [[ϕ]]A,v immer tt oder ff.(“Die Formel ist wahr oder falsch in A mit v”)
23. April 2012 D. Haneberg: Formale Methoden im Software Engineering 49 / 290