Dynamische Logik. A. Salwicki 1970 ( algorithmische Logik ), V.R. Pratt 1976, D. Harel 1977

Transkript

1 Dynamische Logik A. Salwicki 1970 ( algorithmische Logik ), V.R. Pratt 1976, D. Harel 1977 Idee: Erfinde nicht einfach einen komplett neuen Kalkül für neue Objekte (hier: Hoare-Tripel) sondern bilde Programmformeln und erweitere Kalkül um diese neuen Formeln. 191

2 Dynamische Logik: Syntax Die Menge DLFor(Σ,X) der DL-Formeln über der Signatur Σ und der Variablenmenge X enthält Alle prädikatenlogischen Formeln von For(Σ,X) Für α DLProg(Σ,X) und ψ DLFor(Σ,X) auch [α]ϕ ( box alpha phi ) Informelle Bedeutung: Wenn α terminiert, gilt nachher ϕ α ϕ ( diamond alpha phi ) Informelle Bedeutung: α hält, und nachher gilt ϕ Klassifikation: Dynamische Logik ist eine (Multi-)Modallogik. Modallogik mit Formeln ϕ (und ϕ) stammen aus der Philosophie: ich weiss ϕ ich glaube ϕ, ϕ ist möglich Temporallogik: irgendwann wird ϕ wahr sein 192

3 Bemerkungen zur Syntax Boxen und Diamonds binden stärker als Aussagenlogik: [α]ψ χ bedeutet ([α]ψ) χ Schachtelung möglich: α β ψ bedeutet α ( β ψ ) Auch gemischte Schachtelung ist erlaubt: [α] x. ϕ β ψ Auch in DL betrachtet man Sequenzen, z.b. α ψ,γ. Wenn x in α vorkommt, x 0 aber nicht, so besagt α x = x 0 : Am Ende von α hat x den Wert, den x 0 jetzt hat α x = x 0 β x = x 0 bedeutet: Wann immer α in x einen Wert x 0 ausrechnet so tut das auch β Man kann in DL also über Programmähnlichkeit reden Es gilt: [α]ψ α ψ Man könnte also Box mit Hilfe von Diamond definieren 193

4 Semantik der Dynamischen Logik Die Semantik von Formeln der Prädikatenlogik wird erweitert durch A,v = [α]ψ : für alle w : (v,w) [[α]] A,w = ψ. A,v = α ψ : es gibt w : (v,w) [[α]] und A,w = ψ. Damit gilt A,v = ϕ{α}ψ A,v = ϕ [α]ψ A,v = ϕ α ψ A,v = ϕ α ψ, Hoare-Tripel sind also spezielle Formeln der Dynamischen Logik. 194

5 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/Diamond: = x = 5 [abort] x = 5 = x = 5 abort x = 5 Sequenzen mit Programmen, 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 195

6 Kalkül für Dynamische Logik Grundidee: Symbolische Ausführung von Programmen Betrachte Ausführung des Programms α 1 ;α 2 ;...;α n (α i ohne ; (compound) auf top-level) Annahme: Initialer Zustand erfüllt Vorbedingung ϕ 0 Berechne ϕ 1, die stärkste Formel, die nach α 1 gilt Berechne ϕ 2, die stärkste Formel, die nach α 1 ;α 2 gilt... solange bis das Programm verschwunden ist Zum Schluss: Teste ob ϕ n die Nachbedingung impliziert (nur noch PL) Gegenüber Hoare-Kalkül: kein Raten von Zwischenformeln bei seq. Ausführung, Zuweisung vorwärts ausführen! Symb. Ausführung geht sowohl im Antezedent als auch im Sukzedent! 196

7 DL-Kalkül: Normalisierung normalize right normalize left Γ α β ψ, Γ α;β ψ, Γ [α][β]ψ, Γ [α;β]ψ, α β ψ,γ α;β ψ,γ [α][β]ψ,γ [α;β]ψ,γ In KIV: Nie explizit angewandt, die erste Anweisung wird bei jeder Regelanwendung (in allen Programmformeln) immer automatisch abgespalten. KIV rotiert immer die Programmformeln nach vorne. 197

8 DL-Kalkül: Zuweisungen (1) assign right (Hoare-Regel in DL) assign right (Dynamische Logik) Γ ψ τ x, Γ [x := τ]ψ, Γ,x = τ [α x x ]ψ x x, Γ [x := τ][α]ψ, wobei x eine neue Variable ist (bezeichnet den neuen Wert von x) Beachte: Programmvariablen werden umbenannt! 198

9 DL-Kalkül: Zuweisungen (2) In KIV: assign right kombiniert beide Regeln: Original-Hoare-Regel, falls nach der Zuweisung ψ kein Programm mehr enthält Sonst die DL Regel Die Regel gilt genau gleich auch für Diamonds statt Boxen Die Regel für Zuweisung auf der linken Seite sieht genauso aus: assign left wobei x eine neue Variable ist x = τ,[α x x ]ψ x x,γ [x := τ][α]ψ,γ 199

10 DL-Kalkül: if Der Kalkül der dynamischen Logik besteht u. a. aus den Regeln des Hoare-Kalküls, wie z. B. if right if positive right Γ,ε [α]ψ, Γ, ε [β]ψ, Γ [if ε then α else β]ψ, Γ,ε [α]ψ, Γ ε, Γ [if ε then α else β]ψ, Analog: if negative right, if left etc.. KIV versucht immer die Tests zu entscheiden (per Simplifier), damit nur eine Prämisse entsteht. 200

11 DL-Kalkül: while invariant right invariant right Γ INV, INV,ε [α]inv INV, ε ψ Γ [while ε do α]ψ, Γ INV, INV,ε,v = t α (INV t v) INV, ε ψ Γ while ε do α ψ, KIV: Die Schleifeninvariante INV und im zweiten Fall auch die Schranke t muss von Hand eingegeben werden (v ist neue Variable) 201

12 DL-Kalkül: abort abort right abort left Γ Γ abort ψ, Γ [abort]ψ, abort ψ,γ Γ [abort]ψ,γ 202

13 DL-Kalkül: skip skip right skip left Γ ψ, Γ skip ψ, Γ ψ, Γ [skip]ψ, ψ,γ skip ψ,γ ψ,γ [skip]ψ,γ 203

14 DL-Kalkül: lokale Variablen vardecls right x = τ,γ α x x ϕ Γ let x = τ in α ϕ vardecls left α x x ϕ,x = τ,γ let x = τ in α ϕ,γ x sind neue Variablen (bezeichnen die lokalen Variablen). Dieselbe Regel auch für Boxen. 204

15 Beispiel zur Korrekheit Liste nat. Zahlen x: m := x.first, x0 := x.rest; while x0 [] do { if x0.first > m then m := x0.first ; x0 := x0.rest } 205

16 Beispiel zur Korrekheit Maximum einer nichtleeren Liste nat. Zahlen x: x [] m := x.first, x0 := x.rest; while x0 [] do { if x0.first > m then m := x0.first ; x0 := x0.rest } m = maxl(x) wobei maxl([]) = 0, maxl(n + x) = max(n,maxl(x)) 205

17 Zur nächsten Aufgabe Invarianten vorher überlegen!!! 206

18 Prozeduren und Heuristiken für Programme 207

19 Prozeduren: Syntax Neues Programmkonstrukt : Prozeduraufruf p#(t;y) p# ist Prozedurname (das # ist übliche KIV-Konvention) Terme t der Sorten s sind Eingabe-Parameter Paarweise verschiedene Variablen y der Sorten s sind Ein-Ausgabe-Parameter s : s heisst auch der (Aufrufs-)Modus der Prozedur Prozeduren p# P s:s Spezifikation sind neuer Bestandteil der Signatur einer KIV: Deklaration zwischen predicates und variables per: procedures p# s1... sn : s 1... s m; 208

20 Prozeduren: Semantik Semantik: Prozeduren sind eine Relation über den Trägern der Parametersorten: [[p#]] A s A s A s (a,b,c) [[p]] bedeutet: Die Prozedur p#, aufgerufen mit Eingaben a für die Eingabe-Variablen Eingaben b für die Ein/Ausgabe-Variablen terminiert mit Ausgabe c in den Ein/Ausgabe-Variablen Damit das stimmt: Kein Zugriff auf globalen Variablen! Ersatz: Zusätzliche Ein/Ausgabe-Parameter Normalfall in KIV: Funktionale Prozeduren: Ein/Ausgabe-Variablen dienen nur zur Ausgabe: c (und Terminierung) hängen nicht von b ab. Wenn nicht, Schlüsselwort nonfunctional am Ende der Prozedurdefinition 209

21 Prozedurdeklarationen Möglich: Axiome für Prozeduren (Vor- und Nachbedingung) Normalerweise (hinter den axioms) Prozedurdeklarationen declarations f#(x; y) { if x = 0 then y := 1 else { f#(x -1;y); y := y * x } } Erlaubt: (gegenseitige) Rekursion Semantik: Prozeduraufruf erhält die übliche Semantik. Formal: Vereinigung aller tiefenbeschränkten Rekursionen (analog zu: Vereinigung über beschränkte Zahl von Schl.durchläufen) 210

22 Regeln für Prozeduraufrufe Falls Prozedurdeklaration p#(y; z).α gegeben: y = σ,γ αz x ϕ, y = σ, α x Γ p#(σ;x) ϕ, call right z ϕ,γ p#(σ;x) ϕ,γ call left Dabei: y sind die lokalen Variablen auf denen p# rechnet. Sie dürfen in der Sequenz nicht frei vorkommen (evtl. umbenennen) Die Regel gilt auch für Boxen statt Diamonds. 211

23 Ein Beispiel procedures MAXL# MAX# natlist : nat; nat, nat : nat; declaration MAX#(m,n; n0) { if m < n then n0 := n else n0 := m }; MAXL#(x; n) { if x = [] then n := 0 else { MAXL#(x.rest; n); MAX#(n,x.first;n) } } 212

24 Programme als Voraussetzungen: execute call Nützlich bei Induktion, um den Call aus der Induktionsvoraussetzung gegen den gerade aktuellen zu kürzen. execute call Γ σ = τ, p#(σ;x) (x = y), ϕ y x,γ ψ y z, p#(σ;x) ϕ,γ p#(τ;z) ψ, Gilt (so) nur für funktionale (und damit auch deterministische) Prozeduren (y neu): contract call Γ σ = τ p#(σ;z) (z = x ),ϕ x x,ψ x y,γ p#(σ;x) ϕ, p#(τ;y) ψ,γ 213

25 Zwischenzustände einführen: split left Die folgende Regeln wird meist für α = Prozeduraufruf angewandt (x = modifizierte Variablen von α, x neu): split left α x = x,ϕ x x,γ α ϕ,γ Führt einen Zustand x am Ende von α ein, über den man reden kann. Dieser wird bei der Anwendung von Lemmata der Form α x = x0 ϕ als Instanz für x0 gebraucht 214

26 Einfache Heuristiken für Programme symbolic execution: Wendet alle Regeln für Programme an, die keine Fallunterscheidung ergeben: assign, if positive/negative, skip, abort, let split left: Wendet die Regel split left an contract and execute: Wendet execute call, contract call an Im Heuristik-Satz DL heuristics enthalten (zusammen mit simplifier, quantifier closing, module specific). Kann immer verwendet werden. 215

27 Fallunterscheidungs-Heuristiken conditional right split: wendet if right an conditional left split: wendet if left an dl case distinction: Fallunterscheidung (conjunction right etc.), aber nur für Programmformeln Im Heuristik-Satz DL Heuristics + Case Splitting enthalten. Sollte man verwenden, wenn Beweisstruktur der Kontrollstruktur der Programme folgt (meist der Fall). Heuristik-Satz DL heuristics + Induction enthält zusätzlich Heuristiken für (noethersche) Induktion (induction, apply ind once). 216

28 Heuristiken für Prozeduraufrufe calls nonrecursive: Führt alle nichtrekursiven Aufrufe aus calls concrete: Führt alle Aufrufe aus, die konkrete Parameter haben, i. e. Terme die höchstens Parametervariablen enthalten weak unfold: Führt rekursive Prozeduren einmal aus, wenn sie in der Induktionshypothese vorkommen. Höher in der Aufrufshierarchie liegende Aufrufe bevorzugt. Weitere Aufrufe werden ausgeführt, wenn festgestellt wird, dass deren Tests so ausgehen, dass kein weiterer rekursiver Aufruf auftritt. unfold: Führt zusätzlich rekursive Prozeduren (einmal) aus, bei denen der rekursive Aufruf schon in der Sequenz vorkommt DL Heuristics enthält weak unfold, DL Heuristics + Induction enthält zusätzlich unfold. 217

29 Nichtdeterministische Programme 218

30 Nichtdet. Programme: Syntax KIV kennt noch zwei Programmkonstrukte für nichtdeterministische Programme: α or β: Wählt nichtdeterministisch eines der beiden Programme choose x with ϕ in α ifnone β Bindet lokale Variablen x (wie let) an irgendwelche Werte, die ϕ erfüllen ϕ darf von anderen Programmvariablen als nur x abhängen Führt mit den lokalen Variablen α aus. Falls überhaupt keine passenden Werte fur x existieren, die ϕ erfüllen, wird β (ohne lokale Variablen) ausgeführt. ifnone abort kann weggelassen werden (default). 219

31 Beispiele für choose Beispiele: choose n with true in α: Rät beliebige natürliche Zahl choose n with n < m in α ifnone β: Wählt natürliche Zahl n, die kleiner m ist, und führt α aus. Wenn m = 0 gilt, wird stattdessen β ausgeführt. choose boolvar with true in if boolvar then α else β Ist äquivalent zu α or β 220

32 Nichtdet. Programme: Semantik Semantik von or: [[α or β]] = [[α]] [[β]] Semantik von choose: [[choose x with ϕ in α ifnone β]] = {(v,wx v(x) ) es gibt a mit A,vx a = ϕ und (vx,w) a [[α]]} {(v,w) (v,w) [[β]] und es gibt kein a mit A,vx a = ϕ} 221

33 Ein Zusatzproblem für die Semantik Was ist die Semantik von skip? Was ist die Semantik von skip or abort? 222

34 Ein Zusatzproblem für die Semantik Was ist die Semantik von skip? Was ist die Semantik von skip or abort? Antwort: Beide sind gleich: Identität auf allen Zuständen Verhalten sich die Programme unterschiedlich? 222

35 Ein Zusatzproblem für die Semantik Was ist die Semantik von skip? Was ist die Semantik von skip or abort? Antwort: Beide sind gleich: Identität auf allen Zuständen Verhalten sich die Programme unterschiedlich? Antwort: Ja, skip terminiert garantiert, skip or abort nicht. Also: Die relationale Semantik kann nicht ausdrücken, dass ein nichtdeterministisches Programm garantiert terminiert. Damit kann es auch die dynamische Logik nicht: skip or abort true besagt, dass es einen terminierenden Ablauf gibt. 222

36 Garantierte Terminierung Definieren eine zusätzliche zweite Semantik für Programme: α ST gibt die Menge der Zustände (ST = Menge der Variablenbelegungen), für die α garantiert terminiert. Einige Fälle (while und Rekursion sind schwierig) sind: abort = skip = ST x := e = ST (α β) = α β (α;β) = {v v α und für alle w mit (v,w) [[α]] gilt: w β } choose x with ϕ in α ifnone β = {v es gibt a mit A,v a x = ϕ und für jedes solche a ist v a x α } { v es gibt kein a mit A,v a x = ϕ und v β } Beachte: Die Definition der garantierten Terminierung von compounds benutzt die relationale Semantik. 223

37 Neuer Operator: strong diamond Wir addieren einen neuen Operator ( strong diamond ) zur Logik. α ϕ besagt: α terminiert garantiert, und in allen Endzuständen gilt ϕ Formal: A,v = α ψ : v α und für alle w : (v,w) [[α]] gilt: A,w = ψ. Bemerkung: Der Operator wurde von E.W. Dijkstra 1976 erfunden, und schreibt sich in der Literatur meist wp(α,ϕ) (von weakest precondition ). Der Kalkül heisst deshalb auch wp-kalkül. Bemerkung: Die strong diamond-klammern bekommt man mit F12 (KIV-Symbol) und dann { bzw. }. 224

38 Kalkülregeln für or Das Gute an strong diamonds: Für deterministische Programme sind die Regeln für strong diamonds genau dieselben wie für diamonds. or right Γ α ψ, β ψ, Γ α β ψ, Γ [α] ψ, Γ [β] ψ, Γ [α β] ψ, Γ α ψ, Γ β ψ, Γ α β ψ, 225

39 Kalkülregeln für choose choose right Γ y.ϕ y x α y x ψ,( x. ϕ) β ψ, Γ choose x with ϕ in α ifnone β ψ, ϕ y x,γ [α y x] ψ, x. ϕ,γ [β] ψ, Γ [choose x with ϕ in α ifnone β] ψ, ϕx,γ y α x y ψ, x. ϕ,γ β ψ, Γ choose x with ϕ in α ifnone β ψ, Die Variablen y sind neue Variablen (für die lokalen Versionen von x). 226

40 Zuweisungen für heaps Im folgenden Refinement-Versuch (Theorie in der nächsten Vorlesung) werden wir Programme schreiben, die auf der Heap-Spezifikation aus Versuch 2 aufbauen. Der Inhalt von Speicherzellen hat jetzt die Form a r (ersetzt das abstrakte ce; Selektoren sind.val und.nxt). Zum Programmieren gibt es zunächst neue Zuweisungen: H[r] := a r0 überschreibt H an der Stelle r mit a r0. Der entstehende Heap ist also H[r,a r0]. Die Zuweisungen H[r].val := a und H[r].nxt := r0 sind analog. Sie überschreiben nur ein value bzw. einen.nxt-pointer. Die Ergebnis-Heaps sind H[r, a H[r].nxt] und H[r, H[r].val r0]. 227

41 Nichtdeterminismus für Speicherallokation In den Programmen wird es nötig sein, eine neue Referenz zu allokieren. Das geht am einfachsten so: choose r with r H r null in H[r] :=... Beachte: Die Auswahl der neuen Referenz allokiert die Zelle im Speicher noch nicht. Erst die Zuweisung H[r] :=... allokiert. Das Programm ist nichtdeterministisch, deshalb werden strong diamonds bei der Verifikation benötigt. 228