WS 05/06 mod Verifikation

Transkript

1 3.3 Verifikation WS 05/06 mod 351 Verifikation ist der Beweis der Korrektheit eines Algorithmus relativ zu seiner Spezifikation. Die Aussagen gelten für alle Ausführungen des Algorithmus. Sie werden statisch getroffen, ohne das Programm auszuführen (im Gegensatz zum dynamischen Testen). Die Hoaresche Logik ist ein Kalkül zum Beweisen von Aussagen über Algorithmen und Programme [C.A.R. Hoare, 1969]. Nach Hoare schreiben wir: { Vorbedingung P} Algorithmus A { Nachbedingung Q} z. B. { a, b ΙN + } Euklidischer Algorithmus { x ist größter gemeinsamer Teiler von a, b } Gilt vor der Ausführung des Algorithmus A die Bedingung P, so gilt nach der Ausführung die Bedingung Q. Die Hoaresche Schreibweise { P } A { Q } überarbeitet 2005 Prof. Dr. W.Hauenschild kann als Forderung gelesen werden im Sinne einer Spezifikation. In diesem Kapitel bedeutet sie im Sinne der Verifikation eine bewiesene Aussage. P und Q sind dabei häufig Interpretationen prädikatenlogischer Formeln, die z. B. Aussagen über die Ein- und Ausgabeparameter (Vor- und Nachbedingung) machen.

2 Notation von Algorithmenelementen WS 05/06 mod 352 Anweisungsform Notation Beispiel Zuweisung Variable := Ausdruck a := x Sequenz Anweisung 1 ; a := x; Anweisung 2 b := y Bedingte Anweisung falls Bedingung : falls a > b : (bzw. Alternative) Anweisung 1 a := a - b (sonst Anweisung 2 ) (sonst b := b - a) Schleife solange Bedingung wiederhole solange a b wiederhole Anweisung falls a > b:...

3 Regel für Zuweisung WS 05/06 mod 353 Die Zuweisung x := e wertet den Ausdruck e aus und weist das Ergebnis der Variablen x zu. Beispiele: { x = 7} x := 5 { x = 5} { x 1} x := x - 1 { x 0} Wir wollen versuchen, die Nachbedingungen von Zuweisungen direkt zu erschließen. Zur Kontrolle kann dabei folgende Regel angewendet werden: Wenn man zeigen will, dass nach der Zuweisung eine Aussage Q(x) für x gilt, muss man zeigen, dass vor der Zuweisung die Aussage Q(e) für e anstelle von x gilt. { Q(e) } x := e { Q(x) } Falls also gilt: aus P folgt Q(e),dann gilt: { P } x := e { Q(x) } Beispiel: Wir wollen zeigen x = 5 (Q(x)). Wir benötigen also 5 = 5 (Q(5)). Das folgt aber, da es immer wahr ist, auch aus x = 7 (P).

4 Beispiele für Zuweisungen WS 05/06 mod 354 { Q(e) } x := e {Q(x) } in Q(x): x durch e ersetzt 1. { a > 0 } x := a { x > 0 } 2. { a > 0 a > 0 } x := a { x > 0 a > 0 } x durch a ersetzen - nicht umgekehrt 3. { a > 0 x = 7 } x := a { x > 0 x = 7 } falscher Schluss! alle x durch a ersetzen! 4. { a > 0 z > 0 } x := a { x > 0 z > 0 } z > 0 ist nicht betroffen 5. { i + 1 > 0 } i := i + 1 { i > 0 } 6. { i = 2 } { i + 1 = 3 } i := i + 1 { i = 3 } passend umformen 7. { 1 = 1 } x := 1 { x = 1 } passend umformen 8. { z = 5 } passend umformen { z = 5 1 = 1 } x := 1 { z = 5 x = 1 } 9. { i > 0 i ΙN } passend umformen { i } i := i - 1 { i 0 }

5 Konsequenzregeln WS 05/06 mod 355 Abschwächung der Nachbedingung { P } S { R } R Q { P } S { Q } Verschärfung der Vorbedingung P R { R } S { Q } { P } S { Q } Beispiel: a > 0 b > 0 a+b > 0 { a+b > 0 } x := a+b { x > 0 } { x > 0 } { x 0} {a > 0 b > 0}x := a+b{ x 0 } im Algorithmus können Implikationen in Ausführungsrichtung eingefügt werden: { a+b > 0 } x := a+b { x > 0 } { 2*x 0} y := 2*x { y 0}

6 Regel für Sequenz WS 05/06 mod 356 Der Hoaresche Kalkül definiert für jede Anweisungsform ein Regelschema. Sequenzregel: {P} {Q} {P} S 1 S 2 S 1 ; S 2 {Q} {R} {R} Bedeutung: Wenn {P} S 1 {Q} und {Q} S 2 {R} korrekte Schlüsse sind, dann ist auch {P} S 1 ; S 2 {R} ein korrekter Schluss Beispiel: { x>0 y>0 } a := x; { a>0 y>0 } { a>0 y>0 } b := y { a>0 b>0 } { x>0 y>0 } a := x; b := y { a>0 b>0 } im Algorithmus die Schritte { x>0 y>0 } a := x { a>0 y>0 } und { a>0 y>0 } b := y { a>0 b>0 } zusammensetzen: { x>0 y>0 } a := x; { a>0 y>0 } b := y { a>0 b>0 }

7 Regel für Alternative und bedingte Anweisung Alternative: WS 05/06 mod 357 { P B } { P B } S 1 { Q 1 } S 2 { Q 2 } { P } falls B: S 1 sonst S 2 { Q 1 Q 2 } Aus der gemeinsamen Vorbedingung P führen beide Zweige auf dieselbe Nachbedingung Q 1 Q 2 Beispiel: { a > 0 } b := a { b > 0 } { b 0 } { (a > 0) } { -a 0 } b := - a { b 0 } { } falls a > 0: b := a sonst b := - a { b 0 } Bedingte Anweisung: { P B } P B S { Q 1 } { Q 2 } { P } falls B: S { Q 1 Q 2 } im Algorithmus: { a>0 b>0 a b } falls a > b : { a>0 b>0 a>b } { a-b>0 b>0 } a := a - b { a>0 b>0 } sonst { a>0 b>0 b>a } { a>0 b-a>0 } b := b - a { a>0 b>0 } { a>0 b>0 }

8 Regel für Schleifen WS 05/06 mod 358 Wiederholung, Schleife: { INV B } S {INV } {INV } solange B wiederhole S { INV B} Eine Aussage INV heißt Schleifeninvariante, wenn man zeigen kann, dass sie an folgenden Stellen gilt: vor der Schleife, vor und nach jeder Ausführung von S und nach der Schleife. Beispiel: Algorithmus zum Potenzieren (Bedingung: y ΙN ) a := x; b := y; z := 1; INV: z a b = x y b ΙN { INV } solange b > 0 wiederhole { INV b > 0 } { z a a b-1 = x y (b-1) ΙN } b := b - 1; { z a a b = x y b ΙN } z := z a { INV } { INV b 0 } { z a b = x y b = 0 } { z = x y }

9 Terminierung von Schleifen WS 05/06 mod 359 Die Terminierung einer Schleife muss zusätzlich nachgewiesen werden. 1. Gib einen ganzzahligen Ausdruck E an über Variablen, die in der Schleife vorkommen, und zeige, dass E bei jeder Iteration durch S verkleinert wird. 2. Zeige, dass E nach unten begrenzt ist, z. B. dass 0 E eine Invariante der Schleife ist. Das kann zum Beispiel durch folgende Erweiterung der Schleifenregel bewiesen werden: { INV E ΙN E = k B } S {INV E ΙN E < k } {INV } solange B wiederhole S { INV B} Es kann auch eine andere Grenze als 0 gewählt werden. E kann auch streng monoton wachsen und nach oben begrenzt sein. Nichtterminierung wird bewiesen, indem man zeigt, dass R B eine Invariante der Schleife ist und dass es eine Eingabe gibt, so dass R B vor der Schleife gilt. R kann einen speziellen Zustand charakterisieren, in dem die Schleife nicht anhält. Es gibt Schleifen, für die man nicht entscheiden kann, ob sie für jede Vorbedingung terminieren.

10 Beispiele zur Terminierung WS 05/06 mod { a > 0 b > 0} terminiert Schleife1 solange a b wiederhole Schleife2 solange a > b wiederhole a := a - b; Schleife3 solange a < b wiederhole b := b - a 2. { a > 0 b > 0} terminiert nicht immer Schleife1 solange a b wiederhole Schleife2 solange a b wiederhole a := a - b; Schleife3 solange a < b wiederhole b := b - a 3. { n ΙN n > 1 } Terminierung ist unbewiesen solange n > 1 wiederhole falls n gerade: n := n / 2 sonst n := 3 * n + 1

11 Denksportaufgabe zu Invarianten WS 05/06 mod 361 In einem Topf seien s schwarze und w weiße Kugeln, s + w > 0 solange mindestens 2 Kugeln im Topf sind nimm 2 beliebige Kugeln heraus falls sie gleiche Farbe haben: wirf beide weg und lege eine neue schwarze Kugel in den Topf falls sie verschiedene Farben haben: lege die weiße Kugel zurück in den Topf und wirf die schwarze Kugel weg Welche Farbe hat die letzte Kugel? Finden Sie Invarianten, die die Frage beantworten.

12 Verifikation: Algorithmus berechnet ggt WS 05/06 mod 362 Vorbedingung: a, b ΙN + ; sei G größter gemeinsame Teiler von a und b Nachbedingung: x = G Algorithmus mit { Aussagen über Variable }: { G ist ggt von a und b a ΙN + b ΙN + } x := a; y := b; { INV: G ist ggt von x und y x ΙN + y ΙN + } solange x y wiederhole Terminierung der Schleife: E = x+y fällt monoton E = x+y > 0 ist Invariante { INV x y } falls x > y : { G ist ggt von x und y x>y x ΙN + y ΙN + } { G ist ggt von x-y und y x-y ΙN + y ΙN + } x := x - y { INV } sonst { G ist ggt von x und y y>x x ΙN + y ΙN + } { G ist ggt von x und y-x x ΙN + y-x ΙN + } y := y - x { INV } { INV } / { INV x = y } { x = G }

13 Verifikation: Algorithmus sucht Minimum WS 05/06 mod 363 Vorbedingung: (a 1,..., a n ) ist Folge natürlicher Zahlen Nachbedingung: j die Position und min der Wert eines minimalen Elements der Folge Idee: Beginne links mit a 1 ; nimm bei jedem Schritt das nächste Element dazu und prüfe, ob es kleiner ist als das bisher gefundene Minimum. Falls ja, ändere Position und Wert. {INV} = { i {1,.., n } a j = min {a 1,..,a i } min = a j } Algorithmus: i := 1; min := a 1 ; j := 1; solange i < n wiederhole i := i + 1; 2005 Prof. Dr. W. Hauenschild 1 falls a i < min : min := a i ; j := i;