Prof. Dr. Michael Philippsen / Prof. Dr. Herbert Stoyan

Algorithmik 1 Prof. Dr. Michael Philippsen / Prof. Dr. Herbert Stoyan Friedrich-Alexander-Universität Erlangen-Nürnberg Informatik 2/8 Programmiersysteme / Künstliche Intelligenz

Kapitel 11 - Korrektes Programmieren 11.1 Fehlerquellen 11.2 Verifikation 11.3 wp-kalkül 11.4 Schleifeninvarianten 11.5 Beispiel Handy aus! Algorithmik 1, WS 2004/05, Folie 11-2

Algorithmenwahl Dienst Algorithmen und Datenstrukturen Zuverlässigkeit Korrektheit Robustheit Aufwand Skalierbarkeit Algorithmik 1, WS 2004/05, Folie 11-3

11.1 Fehlerquellen Anforderungsdefinition korrekte Anforderungen Ideen, Wünsche, Bedürfnisse fehlerhafte Anforderungen Spezifikationsfehler Systemspezifikation korrekte Spezifikation induzierte Fehler aus Anforderungen Entwurf korrekter Entwurf Entwurfsfehler induzierte Fehler aus Anforderungen Spezifikation Verifikation Realisierung korrektes Programm Implementierungsfehler induzierte Fehler aus Anforderungen Spezifikation Entwurf Testen korrektes Verhalten korrektes korrigierte Programm Fehler bekannte unkorrigierte Fehler unbekannte Fehler Programm mit bekannten und unbekannten Mängeln Algorithmik 1, WS 2004/05, Folie 11-4

11.1 Fehlerquellen Regel: Je später ein Fehler in der Programmentwicklung aufgedeckt wird, desto (vielfach) teurer wird seine Behebung. Daher Ziel: Feststellung der Richtigkeit eines Programms schon ab Anforderungsdefinition und speziell bei der Realisierung. Ansatz: Verifikation: formale Korrektheitsüberlegungen schon bei der Realisierung anstellen. Mathematischer Beweis, dass (formale) Spezifikation erfüllt wird. Beachte: Entdeckung von Anforderungsfehlern im Allgemeinen nicht möglich. Wirtschaftlichkeitskonflikt: Formale Fehlerüberprüfung während der Realisierung ist meist sehr aufwändig (wenn nicht z. T. unentscheidbar), daher muss man Aufwand und späteren Gewinn gegeneinander abwägen. Algorithmik 1, WS 2004/05, Folie 11-5

1.4 Algorithmus Euklids Algorithmus zur Berechnung von ggt(a,b): Falls a=b, dann gilt: ggt(a,b)=a; //1. Fall Falls a<b, dann wende den Algorithmus ggt auf (a, b-a) an; //2. Fall Falls b<a, dann wende den Algorithmus ggt auf (a-b,b) an. //3. Fall Berechne ggt(18,12): 3. Fall berechne ggt(18-12,12) = ggt(6,12) 2. Fall berechne ggt(6,12-6) = ggt(6,6) 1. Fall Resultat ist 6. Berechne ggt(-18,-12): 2. Fall berechne ggt(-18,-12-18) = ggt(-18,-30) 3. Fall berechne ggt(-18-30,-30) = ggt(-48,-30) 2. Fall berechne ggt(-48,-30-48) = ggt(-48,-78) Algorithmus terminiert = nach endlich vielen Schritten ist Schluss Bei Eingabe a<0,b<0 und a b terminiert der Algorithmus nicht. Beweis? Eine Animation ist auf der Web-Seite zu finden. Algorithmik 1, WS 2004/05, Wiederholungsfolie

11.2 Verifikation Zusicherungen: Aussagen über Daten Beim Schreibtischlauf werden konkrete Eingaben durchgerechnet. Der Anfangszustand wird dabei durch die Anweisungen im Programm in den Endzustand überführt. Bei einer formalen Vorgehensweise zum Beweis der Korrektheit müssen aber alle möglichen Eingabedaten betrachtet werden und es muss überprüft werden, ob die gewünschte Ausgabe immer erreicht wird. Statt einer Aufzählung dieser Eingabewerte bzw. Ausgabewerte wird eine Beschreibung derselben durch Prädikate P(v) verwendet. Beispiele: P(v) : v = <Wert> //Zustand, Belegung der Variable v P(v) : Variable v liegt im Intervall [a, b]" P(v) : a v b Algorithmik 1, WS 2004/05, Folie 11-7 / H. Stoyan

11.2 Verifikation Zusicherungen ( assertions ) Die Wirkung eines Programms oder Codestücks kann durch die Angabe von Prädikaten zu Beginn und am Ende des Codes spezifiziert werden. Zusicherungen sind prädikatenlogische Aussagen über die Werte der Programmvariablen an den Stellen im Programm, an denen die jeweiligen Zusicherungen stehen. Eine Zusicherung vor einer bestimmten Anweisungsfolge wird in Bezug auf diese Vorbedingung ( pre-condition ) genannt. Entsprechend ist eine Nachbedingung ( post-condition ) eine Zusicherung nach einer Anweisungsfolge. Vorbedingung und Nachbedingung des gesamten Programms bilden eine prädikatenlogische Spezifikation. Algorithmik 1, WS 2004/05, Folie 11-8

11.2 Verifikation Beispiele für Spezifikationen Funktionsspezifikation f:x Y, y=f(x): Vorbedingung: P = {x=x 0, x0x} Nachbedingung: Q = {y=f(x 0 ), y0y} Spezifikation = (P,Q) ADT Axiom pop(push(k,x)) = k Kellerzustand = alle Elemente + Reihenfolge Vorbedingung: P = {k ist ein Keller mit Zustand k 0, x ist vom Elementtyp T des Kellers} Nachbedingung: Q = {Nach Ausführung von k :=push(k,x) und pop(k ) gilt k = k 0 } Spezifikation = (P,Q) Spezifikationen nur für funktionales Verhalten. Nicht-funktionale Eigenschaften ( nette Benutzeroberfläche, maximale zulässige Programmlaufzeit, ) gehen nicht aus der Spezifikation hervor. Algorithmik 1, WS 2004/05, Folie 11-9

11.2 Verifikation Ansatz des Schreibtischlaufs : y = 2 x := y 2 x=4, y=2 genaue Vorbedingung Anweisungsfolge genaue Nachbedingung Aussage: Wenn vor dem Code y=2 wahr ist, dann ist nach Ausführung des Codes x=4 (und y=2) wahr Allgemeinerer Ansatz: y > 1 x := y 2 x > y > 1 Algorithmik 1, WS 2004/05, Folie 11-10 schwächere Vorbedingung Anweisungsfolge schwächere Nachbedingung Aussage: Wenn vor dem Code y>1 wahr ist, dann ist nach Ausführung des Codes x>y>1 wahr

11.2 Verifikation Verifikation von imperativen Programmen Eine Verifikation prüft, ob ein Programm bestimmte Zusicherungen erfüllt, d.h. ob die Nachbedingung Q einer Anweisungsfolge A erfüllt ist, wenn diese im Falle einer erfüllten Vorbedingung P abgearbeitet worden ist. Partielle Korrektheit: Wenn die Ausführung von A in einem Zustand, der P genügt, beginnt und falls die Ausführung von A nach endlich vielen Schritten terminiert, dann erfüllt der erreichte Zustand Q. Schreibweise: P {A} Q Totale Korrektheit verlangt außerdem den Beweis der Terminierung. Schreibweise: {P} A {Q} Ganzer Ausdruck P {A} Q ist logische Formel, die wahr oder falsch sein kann Algorithmik 1, WS 2004/05, Folie 11-11 / H. Stoyan

11.2 Verifikation Beispiele: {P: i beliebig} i=7 {Q: i=7} Nach endlich vielen (hier: einem) Schritt terminiert die Anweisung. Wenn vor Ausführung der Zustand P erfüllt war, dann ist nach Ausführung der Zustand Q erfüllt. {P: i beliebig, j beliebig} j=2; i=7 {Q: i=7 v j=2} aber {P: i beliebig, j beliebig} i=2; i=7 {Q: i=7 v j beliebig} Will man etwas über j wissen? {P: i beliebig} i=2; i=7 {Q: i=7} Man muss nicht nur bedenken, was die einzelne Anweisung bewirkt, sondern auch, welche Teile der Vorbedingung in die Nachbedingung übernommen bzw. verändert werden. Algorithmik 1, WS 2004/05, Folie 11-12

11.2 Verifikation Beweis der Terminierung kann schwierig oder gar unmöglich sein. Terminiert das folgende Programm oder nicht? (Goldbachsche Vermutung) x = 4 while (istsummevon2primzahlen(x)) x+=2; x > 2 Auf das sog. Halteproblem geht die Theoretische Informatik ein. Algorithmik 1, WS 2004/05, Folie 11-13 / H. Stoyan

11.2 Verifikation Verifikation von imperativen Programmen Wir haben es nicht mit einem Zustand zu tun, über den wir Aussagen machen wollen, sondern mit einer Folge von Zuständen z 0, z 1,..., z n während des Ablaufs eines Programms. Da imperative Programme lineare Kontrollstrukturen haben, folgt aus der Korrektheit von Teilen die Korrektheit der Sequenz. Verifikationskalküle verwenden (rein syntaktische) Regelwerke zur Ableitung zu verifizierender Aussagen: Regeln sind rein mechanisch anwendbar; können korrekt sein: alles, was abgeleitet werden kann, ist wahr; können vollständig sein: alles, was wahr ist, kann abgeleitet werden. Algorithmik 1, WS 2004/05, Folie 11-14

11.2 Verifikation Vorgehensweise bei Verifikationskalkülen Vorwärts: P Programm? gegeben P und Programm bestimme gute Nachbedingung beweise: gute Nachbedingung angegebene Nachbed. Rückwärts:? Programm Q gegeben Q und Programm bestimme gute Vorbedingung beweise: angegebene Vorbed. gute Vorbedingung Algorithmik 1, WS 2004/05, Folie 11-15 / H. Stoyan

11.2 Verifikation P heißt schwächer als P' genau dann, wenn P' Y P Für Zusicherungen gibt es viele Möglichkeiten. Es gibt schwächere oder stärkere Zusicherungen: ist schwächer als y > 1 x := y 2 x > y > 1 y > 1 x := y 2 x > 1 3 < y < 5 x := y 2 x > 10 v y < 5 ist stärker als ist schwächer als Algorithmik 1, WS 2004/05, Folie 11-16 / H. Stoyan

11.2 Verifikation Vorwärts- und Rückwärtsanalyse Vorwärtsanalyse eine Vorbedingung eine Nachbedingung viele Vorbedingungen Es gibt viele Einflussfaktoren, die zur Nachbedingung führen. Welche sind wichtig? Algorithmik 1, WS 2004/05, Folie 11-17 Rückwärtsanalyse viele Nachbedingungen Es ist schwer, genau die Ziel-Bedingung, die man zeigen will, zu treffen und unbedeutendes zu ignorieren.

11.2 Verifikation Stärke/Schwäche von Zusicherungen Disjunktion ( oder, ) von Prädikaten entspricht der Vereinigung ( ) der durch sie beschriebenen Zustandsmengen. Konjunktion ( und, ) von Prädikaten entspricht der Schnittmenge ( ) der durch sie beschriebenen Zustandsmengen. a(b) c(d,e) d(f) true a(b) c(d,e) Zunehmende Schwäche a(b) c(d,e) d(f) Algorithmik 1, WS 2004/05, Folie 11-18

11.3 wp-kalkül wp-kalkül als Mittel der Rückwärtsanalyse (1) y = 2 ist stärker als y > 1 ist stärker als Minimum: wp x := y 2 x > y > 1 x := y 2 x > y > 1 Zu beweisender Zustand am Programmende (Nachbeding.) Idee: Untersuche statt vieler Vorbedingungen nur die schwächste Vorbedingung (weakest precondition): Ausgehend von dieser wird die Nachbedingung gerade noch erfüllt. Algorithmik 1, WS 2004/05, Folie 11-19

11.3 wp-kalkül wp-kalkül als Mittel der Rückwärtsanalyse (2) i beliebig, j beliebig j := 2 j := 2 i beliebig, j=2 i beliebig, j=2 bestimme schwächste Vorbedingung als Nachbedingung der vorhergehenden Anweisung auffassen. i := 7 i=7, j=2 zu zeigen bestimme schwächste Vorbedingung Algorithmik 1, WS 2004/05, Folie 11-20

11.3 wp-kalkül wp-kalkül als Mittel der Rückwärtsanalyse (3) Definition: Wenn Q ein Prädikat ist und A eine Anweisungsfolge, dann ist die schwächste Vorbedingung von A in Bezug auf Q, wp(a,q), ein Prädikat, das die Menge aller Startzustände beschreibt, so dass wenn die Ausführung von A in einem dieser Zustände beginnt, dann endet (terminiert) die Ausführung in einem Zustand, der Q genügt. wp("programm", Nachbedingung) = schwächste Vorbedingung Beachte: wp enthält Terminierung. Wenn wp(a,true) false, dann heißt das, dass A terminiert. Algorithmik 1, WS 2004/05, Folie 11-21

11.3 wp-kalkül Formal Wenn eine Vorbedingung P die Terminierung von A garantiert und wenn gilt {P} A {Q}, dann gilt P Y wp (A, Q) Somit: { wp(a,q) } A {Q} Beispiel: {P: y = 1} x := y {Q: x = 1} wp( "x := y", x=1) = (y=1) bedeutet: wenn nach Ausführung von x := y gelten soll: x=1, dann muss vorher mindestens y=1 gegolten haben Anders ausgedrückt: { wp("x := y", x=1) } x := y { x = 1 } Es gilt wegen P Y wp (A, Q) : (y = 1) Y (y = 1) Algorithmik 1, WS 2004/05, Folie 11-22

11.3 wp-kalkül Vorgehen bei der Programmverifikation mit wp-kalkül Q := Endebedingung des Programms A := letzte Anweisung des Programms P := wp(a, Q) Anfang des Programms erreicht? P impliziert durch Spezifikation der Eingabedaten? ja ja nein nein Q := P A := vorhergehende Anweisung Programm ist korrekt Programm ist fehlerhaft Algorithmik 1, WS 2004/05, Folie 11-23

11.3 wp-kalkül Sequenzregel Zwei Programmstücke S 1 und S 2 können zu einem Programmstück S 1 ; S 2 zusammengesetzt werden, wenn die Nachbedingung von S 1 mit der Vorbedingung von S 2 identisch ist. P S 1 Q Q S 2 P S 1 wp ( "S 1 ; S 2 ",R) = wp ( S S 1, wp ( S 2,R)) 2 R R Algorithmik 1, WS 2004/05, Folie 11-24

11.3 wp-kalkül Erweiterung der Sequenzregel Q Y Q' Wenn Q' eine Konsequenz von Q ist, gilt auch: P S 1 Q P S 1 aus {P} S 1 {Q} und {Q'} S 2 folgt {R} Q' S 2 {P} S 1 ; S 2 {R} S 2 R R Algorithmik 1, WS 2004/05, Folie 11-25 Klar: Wenn Q' schon schwächste Vorbedingung, dann kann Q nicht noch schwächer sein!

11.3 wp-kalkül Zuweisungsregel wp ("x := e", Q) = zulässig(x) v zulässig(e) v Q[x/e] wobei x eine Variable und e ein Ausdruck ist. Die Nachbedingung Q kann nur erreicht werden, wenn sowohl x als auch e fehlerfrei ausgewertet werden können. (Die zulässig()-prädikate werden oft weggelassen.) Zur Konstruktion der Vorbedingung wird mit der Nachbedingung Q begonnen, darin werden alle Vorkommen der Variablen x durch den Ausdruck e substituiert; man nimmt also sozusagen den Effekt der Anweisung zurück. Algorithmik 1, WS 2004/05, Folie 11-26

11.3 wp-kalkül Zuweisungsregel am Beispiel: wp("v:=v+1", v = m) = (v = m)[v/(v+1)] = (v+1 = m) = (v = m-1) Algorithmik 1, WS 2004/05, Folie 11-27

11.3 wp-kalkül Beispiel: Vertauschen der Werte der Variablen x und y Zu verifizieren: {P: y=x x=y} h:=x; x:=y; y:=h {Q: x=x y=y} Verifikation: wp ( "h:=x; x:=y; y:=h", x=x y=y ) = wp ( "h:=x; x:=y", wp( "y:=h", x=x y=y) ) = wp ( "h:=x; x:=y", (x=x h=y) ) = wp ( "h:=x", wp( "x:=y", (x=x h=y) ) ) = wp ( "h:=x", (y=x h=y) ) = (y=x x=y) stimmt mit P überein, daher ist das Programmstück korrekt. Sequenzregel Zuweisungsregel Algorithmik 1, WS 2004/05, Folie 11-28

11.3 wp-kalkül Definitionen wp (leer, Q) = Q Wenn nichts passiert, ändern sich die Bedingungen nicht. leer bewirkt keine Zustandsänderung. Damit nach leer Q gelten kann, muss vor leer mindestens Q gegolten haben. wp (crash, Q) = false Fehler dürfen nicht passieren. crash ist der Versuch, eine Anweisung auszuführen, deren Vorbedingung nicht erfüllt ist. Analog: false beliebige Aussage Algorithmik 1, WS 2004/05, Folie 11-29

11.3 wp-kalkül Ein paar einfache Rechenregeln (1) Ausgeschlossene Wunder wp ( A, false ) = false Da false nicht erfüllbar ist, muss auch die zugehörige Vorbedingung unerfüllbar sein. Aus P Y P, Q Y Q und {P} A {Q} folgt {P } A {Q } Vorbedingung kann verschärft werden, Nachbedingung kann abgeschwächt werden. Monotonie (folgt sofort aus obigem) Wenn Q Y R dann wp ( A, Q ) Y wp ( A, R ) Algorithmik 1, WS 2004/05, Folie 11-30

11.3 wp-kalkül Ein paar einfache Rechenregeln (2) Distributivität der Konjunktion wp ( A, Q ) wp ( A, R ) = wp ( A, Q R ) Y: Zustand Z, der durch A zu Q führt und der durch A zu R führt, führt natürlich auch zu QvR Z: Zustand Z führt durch A zu QvR. Dann führt Z durch A auch zu Q und ebenso zu R (abgeschwächte Nachbedingung.) Algorithmik 1, WS 2004/05, Folie 11-31

11.3 wp-kalkül Ein paar einfache Rechenregeln (3) Distributivität der Disjunktion wp ( A, Q ) wp ( A, R ) Y wp ( A, Q R ) Z gilt i.a. nicht: wp( wirf Münze, Zahl w Wappen) Es gibt bei dieser zufallsabhängigen Aktion keine Vorbedingung, so dass auf jeden Fall Zahl oben liegt. Daher: wp( wirf Münze, Zahl) = false Ebenso: wp( wirf Münze, Wappen) = false. Falsch ist: false w false Z true = gilt bei deterministischen Programmen Algorithmik 1, WS 2004/05, Folie 11-32

11.3 wp-kalkül Fallunterscheidung: if-then-else-regel wp ("if b then S 1 else S 2 ", Q ) = [ b Y wp (S 1, Q) ] [ b Y wp (S 2,Q) ] Wenn b gilt, dann muss als Vorbedingung mindestens wp (S 1, Q) gelten, damit Q als Nachbedingung gilt. Wenn b nicht gilt, dann muss als Vorbedingung mindestens wp (S 2,Q) gelten, damit Q als Nachbedingung gilt. Zusätzlich muss zulässig(b) gelten. b muss seiteneffektfrei sein. Algorithmik 1, WS 2004/05, Folie 11-33

Algorithmik 1, WS 2004/05, Folie 11-34 11.3 wp-kalkül Kleiner Logik-Exkurs (B Y Q) v ( B Y R) ] ( B w Q) v (B w R) ] (B v ( B w Q)) w (R v ( B w Q)) //Distributivgesetz ] ((B v B) w (B v Q)) w ((R v B) w (R v Q)) //Distributivgesetz ] (B v B) w (B v Q) w (R v B) w (R v Q) //Assoziativgesetz ] (B v Q) w ( B v R) w (R v Q) //B v B = false ] (B v Q) w ( B v R) I I I B w Q I I Q I I B I I I I I I I BYQ Q B I I R v Q I I I I R I I I I (BvQ)w( BvR) I I BvR I I I I I I I I I I BvQ Q B

11.3 wp-kalkül Es gilt (A Y B) ( A Y C) ] (A B) ( A C) Daher kann die if-then-else-regel auch umgeformt werden zu: wp ("if b then S 1 else S 2 ", Q ) = [ b Y wp (S 1, Q) ] [ b Y wp (S 2,Q) ] = [ b wp (S 1, Q) ] [ b wp (S 2,Q) ] Es muss b und mindestens die Vorbedingung wp (S 1, Q) gelten......oder aber nicht b und mindestens die Vorbedingung wp(s 2,Q) gelten. Algorithmik 1, WS 2004/05, Folie 11-35

11.3 wp-kalkül Fallunterscheidung: if-regel wp ("if b then A", Q ) = [ b Y wp (A, Q) ] [ b Y Q ] Fehlt der else-teil, ist dies identisch mit wp ("if b then A else leer", Q ) = [ b Y wp (A, Q) ] [ b Y wp (leer,q) ] = [ b Y wp (A, Q) ] [ b Y Q ] = [ b wp(a, Q)] w [ b Q ] Algorithmik 1, WS 2004/05, Folie 11-36

11.3 wp-kalkül Beispiel: Bestimmung des Maximums zweier Zahlen Was muss vor der folgenden if-anweisung mindestens gelten, damit nachher max=x erfüllt ist? wp("if (x > y) max:=x; else max:=y;", max = x) = [ x > y wp("max := x", max = x) ] if-then-else-regel [ x y wp("max := y", max = x) ] = [ x > y x = x ] [ x y y = x ] Zuweisungsregel = ( x > y x = y ) = (x y) Algorithmik 1, WS 2004/05, Folie 11-37

11.3 wp-kalkül Beispiel: wp einer if-anweisung wp("if a>(b+4) then x:=b-4 else x:=a-4",((x a)w(x b)) (a x b)) = (a>(b+4)) v wp ("x:=b-4", ((x a)w(x b)) (a x b)) w (a (b+4)) v wp ("x:=a-4", ((x a)w(x b)) (a x b)) = (a>(b+4)) v ((b-4 a) w (b-4 b)) (a b-4 b) w (a (b+4)) v ((a-4 a) w (a-4 b)) (a a-4 b) = (a>(b+4)) v ((b-4 a) w true) (a b-4 b) w (a (b+4)) v (true w (a-4 b)) (a a-4 b) = (a>(b+4)) v (true (a b-4 b)) w (a (b+4)) v (true (a a-4 b)) = (a>(b+4)) v (a b-4 b) w (a (b+4)) v (a a-4 b) = (b+4<a) v false w (a (b+4)) v false = false w false = false Algorithmik 1, WS 2004/05, Folie 11-38 / H. Stoyan

11.3 wp-kalkül Zeigen Sie, dass folgende Programm-Transformation korrekt ist: if b then { A1; A2; A3 } else { A1; A4; A3 } A1; if b then { A2; } else { A4; } A3; Achtung! Die Transformation ist natürlich nur korrekt, wenn der Wert von b durch die Ausführung von A1 nicht geändert wird! In wp-sprache: b = wp("a1", b) v b = wp("a1", b) Ansatz: Zeige, dass für alle Prädikate Q gilt wp("if b then {A1;A2;A3} else {A1;A4;A3}",Q) = wp("a1; if b then {A2} else {A4}; A3}",Q) Algorithmik 1, WS 2004/05, Folie 11-39

11.3 wp-kalkül Zeige, dass für alle Prädikate Q gilt wp("if b then {A1;A2;A3} else {A1;A4;A3}",Q) = wp("a1; if b then {A2} else {A4}; A3",Q) Beweis: wp("if b then {A1;A2;A3} else {A1;A4;A3}",Q) = (b v wp("a1", wp("a2", wp("a3",q)))) w ( b v wp("a1", wp("a4", wp("a3",q)))) = (wp("a1", b) v wp("a1", wp("a2", wp("a3",q)))) w (wp("a1", b) v wp("a1", wp("a4", wp("a3",q)))) //Voraussetzg. = wp("a1", b v wp("a2", wp("a3",q))) w wp("a1", b v wp("a4", wp("a3",q))) //Distrib. v = wp("a1", (b v wp("a2", wp("a3",q))) w ( b v wp("a4", wp("a3",q)))) //Distrib. w, determinist. = wp("a1", wp("if b then {A2} else {A4}", wp("a3",q))) = wp("a1; if b then {A2} else {A4}; A3",Q))) Algorithmik 1, WS 2004/05, Folie 11-40

11.3 wp-kalkül Allgemeine Fallunterscheidung: case-regel (1) switch-anweisung gemäß Semantik von Java: wp ( "switch b case b 1 : S 1 ; case b 2 : S 2 ;... case b n : S n ; else S n+1 ", Q ) semantisch äquivalente bzw. verhaltensäquivalente Anweisungsfolgen A/B: {P} A {Q} ] {P} B {Q} = wp ( "if b == b 1 then S 1 ; S 2 ;...; S n else if b == b 2 then S 2 ;...; S n... else S n+1 ", Q ) Algorithmik 1, WS 2004/05, Folie 11-41

11.3 wp-kalkül Allgemeine Fallunterscheidung: case-regel (2) wp ( "if b == b 1 then S 1 ; S 2 ;...; S n else if b == b 2 then S 2 ;...; S n... "und"-verknüpfung: für else S n+1 ", Q ) jedes einzelne B i gilt die = [ i: (B i Y wp (S i ;...; S n, Q)) ] Implikation B i Y wp( ) [( i: B i ) Y wp (S n+1,q)) ] //B i steht für b==b i falls keines der B i erfüllt ist, dann Wenn irgendein B i gilt, dann gilt als schwächste Vorbedingung wp (S i ;...; S n, Q), wobei gilt, falls S k = break wp (S i ;...; S k ;...; S n, Q) = wp (S i ;...; S k-1, Q) Algorithmik 1, WS 2004/05, Folie 11-42

11.4 Schleifeninvariante Korrektheit von Schleifen Korrektheitsüberlegungen für Schleifen lassen sich auf die Betrachtung von while-schleifen beschränken, da sich alle Schleifenkonstrukte in while-schleifen umwandeln lassen: do A while b A; while b do A do A until b A; while b do A for (A,b,C) D A; while b do { D ; C } Algorithmik 1, WS 2004/05, Folie 11-43

11.4 Schleifeninvariante Gesucht wird wp ("while b do A", Q ) =? Idee: Schreibe die Anweisung um zu if b {A ; if b {A ; if b {A ; if b {...}}}} Zur Erinnerung: wp ("if b then A", Q ) = ( b Y Q) (b Y wp (A, Q)) Somit ergibt sich wp ("while b do A", Q ) = b Y Q b Y wp ( A, b Y Q b Y wp ( A, b Y Q b Y wp ( A,... ) ) ) Algorithmik 1, WS 2004/05, Folie 11-44

11.4 Schleifeninvariante Beispiel: Herunterzählen eines Werts/Zählschleife (1) wp ("while b do A", Q ) = b Y Q b Y wp ( A, b Y Q b Y wp ( A, b Y Q b Y wp ( A,... ) ) ) Beispielschleife: wp ("while (x>0) do x:=x-1", x=0 ) = (x>0) Y (x=0) (x>0) Y [ (x-1>0) Y (x-1=0) (x-1>0) Y [ (x-1-1>0) Y (x-1-1=0) (x-1-1>0) Y [... ] ] ] Algorithmik 1, WS 2004/05, Folie 11-45

11.4 Schleifeninvariante Beispiel: Herunterzählen eines Werts/Zählschleife (2) wp ("while (x>0) do x:=x-1", (x=0) ) = (x>0) Y (x=0) (x>0) Y [ (x-1>0) Y (x-1=0) (x-1>0) Y [ (x-1-1>0) Y (x-1-1=0) (x-1-1>0) Y [... ] ] ] Es gilt A Y ( B C ) ] (A Y B) (A Y C) Nachrechnen! Daher kann vereinfacht werden zu: wp ("while (x>0) do x:=x-1", (x=0) ) = (x 0) Y (x = 0) (x > 0) Y [ (x 1) Y (x = 1) ] (x > 0) Y [ (x > 1) Y [ (x 2) Y (x = 2) ] ] (x > 0) Y [ (x > 1) Y [ (x > 2) Y [ (x 3) Y (x = 3) ] ] ]... Noch einfacher: x 0 Algorithmik 1, WS 2004/05, Folie 11-46

11.4 Schleifeninvariante Die obige Form der unbeschränkten Konjunktion ist nicht praktikabel, führt wp des k-ten Schleifendurchlaufs auf das wp des k-1-ten Schleifendurchlauf zurück. Hier steckt das Induktionsprinzip drin! 1. Vereinfachung: Besserer Umgang mit der unbeschränkten Konjunktion: Definition: H k (Q) schwächste Vorbedingung, die garantiert, dass die Schleife höchstens k-mal (k 0) durchlaufen wird und dann Q gilt. Definition: H(Q) ::= wp( "while b do A", Q ) Algorithmik 1, WS 2004/05, Folie 11-47

11.4 Schleifeninvariante Formalisierung wp ("while b do A", Q ) = b Y Q b Y wp ( A, b Y Q b Y wp ( A, b Y Q b Y wp ( A,... ) ) ) Wegen Distributivität der Konjunktion umformen zu: wp ("while b do A", Q ) = H b Y Q 0 (Q) b Y wp ( A, b Y Q ) H 1 (Q) b Y wp ( A, b Y wp ( A, b Y Q )) H 2 (Q)... Somit gilt: H(Q) = wp ("while b do A", Q ) = H 0 (Q) H 1 (Q) H 2 (Q)... = ( k 0 : H k (Q)) Algorithmik 1, WS 2004/05, Folie 11-48 H(Q) ist die schwächste Vorbedingung, dass die Schleife endlich oft durchlaufen wird und danach Q gilt.

11.4 Schleifeninvariante Rekurrente Schleifenregel Die Schleifenzustandsfunktion H(Q) lässt sich als Rekurrenz definieren: H(Q) = ( k 0 : H k (Q)) H 0 (Q) = ( b Y Q ) H k+1 (Q) = ( b Y wp ( A, H k (Q))) Statt mit der unbeschränkten Konjunktion umgehen zu müssen, suchen wir jetzt eine Lösung der Rekurrenz, also ein H, für das gilt: H Y ( b Y Q ) und H Y ( b Y wp ( A, H )) Mit einem solchen H kann die totale Korrektheit (=partielle Korrektheit und Terminierung) der Schleife gezeigt werden. Algorithmik 1, WS 2004/05, Folie 11-49 / H. Stoyan

11.4 Schleifeninvariante Beispiel: Herunterzählen eines Werts/Zählschleife (3) wp ("while (x>0) do x:=x-1", x=0 ) = = H 0 (x=0) H 1 (x=0) H 2 (x=0)... Nachbedingung der Schleife ist zugleich Terminierungsbedingung. wobei H 0 (x=0) = (x>0) Y (x=0) und H k+1 (x=0) = (x>0) Y wp ("x:=x-1", H k (x=0)) Jetzt wird ein H gesucht, das die Rekurrenz erfüllt. Errate: H = (x 0) 1. Teil der Rekurrenzprüfung: H Y ( b Y Q ) (x 0) Y (x>0) Y (x=0) // H Y H 0 (x=0) ] (x 0) Y ( (x>0) w (x=0) ) ] (x < 0) w (x>0) w (x=0) ] true Algorithmik 1, WS 2004/05, Folie 11-50

11.4 Schleifeninvariante Beispiel: Herunterzählen eines Werts/Zählschleife (4) wp ("while (x>0) do x:=x-1", x=0 ) = = H 0 (x=0) H 1 (x=0) H 2 (x=0)... wobei H 0 (x=0) = (x>0) Y (x=0) und H k+1 (x=0) = (x>0) Y wp ("x:=x-1", H k (x=0)) 2. Teil der Rekurrenzprüfung: H Y ( b Y wp ( A, H )) (x 0) Y [ (x > 0) Y wp ("x:=x-1", (x 0)) ] ] (x 0) Y [ (x > 0) Y (x-1 0) ] ] (x 0) Y [ (x > 0) Y (x 1) ] ] (x 0) Y [ (x 0) w (x 1) ] ] (x < 0) w (x 0) w (x 1) ] true Algorithmik 1, WS 2004/05, Folie 11-51

11.4 Schleifeninvariante Beispiel: Herunterzählen eines Werts/Zählschleife (5) Damit ist gezeigt: (x 0) = wp ("while (x>0) do x:=x-1", x=0 ) Das bedeutet: Wenn vor der Schleife H: (x 0) gilt, dann terminiert die Schleife und es gilt nach der Schleife Q: (x=0). Bei diesem Beispiel stehen die schwächste Vorbedingung, der Schleifentest und die Nachbedingung in recht engem Zusammenhang. Algorithmik 1, WS 2004/05, Folie 11-52

11.4 Schleifeninvariante Beispiel: Summation natürlicher Zahlen Wir wollen verifizieren: {P: n 0} s := 0; for (i=1; i<=n; i++) s := s + i; {Q: s=(n+1)n/2} Schleife in "Normalform" umwandeln: {P: n 0} s := 0; i := 1; while (i<=n) { s := s + i; i := i + 1; } {Q: s =(n+1)n/2} Algorithmik 1, WS 2004/05, Folie 11-53

11.4 Schleifeninvariante Gesucht wird also wp("s:=0;i:=1; while(i<=n){s:=s+i; i:=i+1;}", s =(n+1)n/2 ) Mit der Sequenzregel ergibt sich wp("s:=0;i:=1;", wp("while(i<=n){s:=s+i; i:=i+1;}", s =(n+1)n/2 ) ) Betrachte zunächst nur den inneren Ausdruck mit der Schleife. Gesucht wird schwächste Vorbedingung H: H(s =(n+1)n/2) = wp("while(i<=n){s:=s+i; i:=i+1;}", s =(n+1)n/2 ) Algorithmik 1, WS 2004/05, Folie 11-54

11.4 Schleifeninvariante Somit ergeben sich: H 0 (s =(n+1)n/2) = ( i n ) Y (s =(n+1)n/ 2) H k+1 (s =(n+1)n/2) = ( i n ) Y wp ("s:=s+i; i:=i+1;",h k (s =(n+1)n/2)) Korrektheitsanteil Welches H erfüllt die Rekurrenz? Errate: H : = s=(i-1)i/2 ( i n + 1) 1. Teil der Rekurrenzprüfung: H Y ( b Y Q) Terminierungsanteil zeige: [ s=(i-1)i/2 ( i n + 1) ] Y [ ( i n ) Y (s =(n+1)n/2) ] wenn i n: wenn i = n+1: wenn i > n+1: [ s=(i-1)i/2 ] Y [ false Y (s =(n+1)n/2) ] = true [ s=(n+1)n/2 ] Y [ true Y (s =(n+1)n/2) ] = true [ false ] Y [ true Y (s =(n+1)n/2) ] = true q.e.d. Algorithmik 1, WS 2004/05, Folie 11-55

11.4 Schleifeninvariante 2. Teil der Rekurrenzprüfung: H Y ( b Y wp ( A, H )) zeige: [ s=(i-1)i/2 ( i n + 1) ] Y [( i n ) Y wp ("s:=s+i; i:=i+1;", Mit Sequenzregel: [ s=(i-1)i/2 ( i n + 1) ] Y [( i n ) Y wp ("s:=s+i;", s=(i-1)i/2 ( i n + 1) ) ] wp("i:=i+1;", s=(i-1)i/2 ( i n + 1) ))] Mit Zuweisungsregel: [ s=(i-1)i/2 ( i n + 1) ] Y [( i n ) Y [ s+i = i(i+1)/2 ( i n) ) ] ] wenn i n+1: [ s=(i-1)i/2 ] Y [ true Y s+i = i(i+1)/2 ] = true wenn i = n+1: [ false ] Y [ false Y false ] = true wenn i > n+1: [ false ] Y [ false Y false ] = true q.e.d. Algorithmik 1, WS 2004/05, Folie 11-56

11.4 Schleifeninvariante Gesucht wird immer noch wp("s:=0;i:=1;", wp("while(i<=n){s:=s+i; i:=i+1;}", s =(n+1)n/2 )) Schleife auflösen, indem gefundenes H eingesetzt wird: wp("s:=0;i:=1;", s=(i-1)i/2 ( i n + 1) ) = wp("s:=0;", wp ("i:=1;", s=(i-1)i/2 ( i n + 1) ) = wp("s:=0;", s=0 ( 1 n + 1 ) ) = ( 0 n ) Somit muss vor Beginn des Codestückes mindestens 0 n gelten. Dies entspricht genau der oben angegebenen Vorbedingung P. Daher wurde die totale Korrektheit bewiesen. q.e.d. Algorithmik 1, WS 2004/05, Folie 11-57

11.4 Schleifeninvariante Der Rekurrenz-Ansatz ist einfacher als die unbeschränkte Konjunktion aber, es ist schwierig, die Lösung der Rekurrenz H zu erraten es wird gleichzeitig partielle Korrektheit und die Terminierung gezeigt. Trennung in 2 Schritt ist leichter. 2. Vereinfachung: Schleifeninvarianten Idee: teile die schwächste Vorbedingung H einer Schleife auf in: eine Bedingung b, so dass bei b die Schleife terminiert und eine Schleifeninvariante I: ein Prädikat, das vor und nach jeder Iteration einer Schleife immer wahr ist. Algorithmik 1, WS 2004/05, Folie 11-58

11.4 Schleifeninvariante Schleifeninvariante (1) Definition: Eine Invariante der Schleife while b do A ist eine Bedingung I, für die gilt: { I b } A { I } Unmittelbar vor A muss auch b gelten. Nach A (vor der nächsten Iteration) kann b gelten oder nicht. Wenn vor dem Schleifenrumpf I b gilt, dann terminiert die Ausführung von A und anschließend ist I erfüllt. I ist also vor und nach dem Schleifenrumpf erfüllt, daher Invariante. I ist leichter zu finden als H, weil man die Terminierung der Schleife nicht berücksichtigen muss. In wp-terminologie muss man zeigen: I b Y wp(a, I) I b ist also stärker als die schwächste Vorbedingung der Schleife. Algorithmik 1, WS 2004/05, Folie 11-59

11.4 Schleifeninvariante Schleifeninvariante (2) Aus { I b } A { I } bzw. aus I b Y wp(a, I) folgt, falls die Schleife terminiert: Kennt man eine Invariante I des Schleifenrumpfs, dann kann man die schwächste Vorbedingung der Schleife erschließen. Man muss zusätzlich lediglich die Terminierung zeigen. { I } while b do A { I b } bzw. I Y wp("while b do A", I b) Wenn das Schleifenende erreicht wird, dann darf b nicht mehr erfüllt sein. Algorithmik 1, WS 2004/05, Folie 11-60

11.4 Schleifeninvariante Schleifeninvariante (3) Der Zusammenhang { I b } A { I } Y { I } while b do A { I b } lässt sich für terminierende Schleifen durch Induktion beweisen. Beweisskizze: Induktionsanfang: Schleifenrumpf wird keinmal/einmal durchlaufen. Ersetze Schleife durch: if b then A Da keine weitere Iteration folgt, gilt nach A auf jeden Fall auch b. Induktionsschritt: Schleife wird k mal durchlaufen. Ersetze Schleife durch: if b then A; while b do A Dann kann Induktionsvoraussetzung für k-1 Schleifendurchläufe angewendet werden. Algorithmik 1, WS 2004/05, Folie 11-61

11.4 Schleifeninvariante Konstruktives Vorgehen bei Schleifen Bestimme I und konstruiere Rumpf S. { I } while b do { I b } S { I } { I b } { Q } Vier Schritte zum Nachweis der totalen Korrektheit: 1. Beweise, dass I vor Eintritt in die Schleife gilt. 2. Beweise, dass { I b } S { I }, dass also I tatsächlich eine Invariante ist. 3. Beweise, dass ( I b ) Y Q, so dass bei Terminierung das gewünschte Ergebnis erreicht wird. 4. Beweise, dass die Schleife terminiert. Algorithmik 1, WS 2004/05, Folie 11-62

11.5 Beispiele Euklids Algorithmus zur Berechnung von ggt(a,b): a=x; b=y; while (a!=b) { if (a>b) a=a-b; if (a<b) b=b-a; } //{Q: a=b=ggt(a,b)=ggt(x,y)} 1. Beweise, dass I vor Eintritt in die Schleife gilt. 2. Beweise, dass { I b } S { I }, dass also I tatsächlich eine Invariante ist. 3. Beweise, dass ( I b ) Y Q, so dass bei Terminierung das gewünschte Ergebnis erreicht wird. 4. Beweise, dass die Schleife terminiert. Terminierungsanteil: b: a==b Invariante: I: ggt(a,b)=ggt(x,y) Es gilt/kann verwendet werden: ggt(a+b,b)=ggt(a,b) Algorithmik 1, WS 2004/05, Folie 11-63

11.5 Beispiele Euklids Algorithmus zur Berechnung von ggt(a,b): a=x; b=y; while (a!=b) { if (a>b) a=a-b; if (a<b) b=b-a; } //{Q: a=b=ggt(a,b)=ggt(x,y)} 1. Beweise, dass I vor Eintritt in die Schleife gilt. Was ist schwächste Vorbedingung P, die vor dem Programmstart gelten muss, damit vor der Schleife I erfüllt ist. Zeige: P ist erfüllt. wp("a:=x;b:=y;", ggt(a,b)=ggt(x,y)) =wp("a:=x", ggt(a,y)=ggt(x,y)) = ggt(x,y)=ggt(x,y) = true. Vor dem Schleifeneintritt ist I erfüllt. Algorithmik 1, WS 2004/05, Folie 11-64

11.5 Beispiele Euklids Algorithmus zur Berechnung von ggt(a,b): while (a!=b) { if (a>b) a=a-b; if (a<b) b=b-a; } 2. Beweise, dass { I b } S { I }, dass also I tatsächlich eine Invariante ist. implizit Zulässigkeit: ganzzahlig(a) ganzzahlig(b) wp("if (a>b) a=a-b; if (a<b) b=b-a", ggt(a,b)=ggt(x,y)) = wp("if (a>b) a=a-b", wp("if (a<b) b=b-a", ggt(a,b)=ggt(x,y))) = wp("if (a>b) a=a-b", [a<b v wp("b=b-a", ggt(a,b)=ggt(x,y))] w [a b v ggt(a,b)=ggt(x,y)]) = wp("if (a>b) a=a-b", [a<b v ggt(a,b-a)=ggt(x,y)] w [a b v ggt(a,b)=ggt(x,y)]) = [a>b v wp("a=a-b", [a<b v ggt(a,b-a)=ggt(x,y)] w [a b v ggt(a,b)=ggt(x,y)])] w [a b v ([a<b v ggt(a,b-a)=ggt(x,y)] w [a b v ggt(a,b)=ggt(x,y)])] = [a>b v [a-b<b v ggt(a-b,b-a+b)=ggt(x,y)] w [a-b b v ggt(a-b,b)=ggt(x,y)])] w [a<b v ggt(a,b-a)=ggt(x,y)] w [a=b v ggt(a,b)=ggt(x,y)] = [b<a<2b v ggt(a-b,2b-a)=ggt(x,y)] w [a 2b v ggt(a-b,b)=ggt(x,y)])] w [a<b v ggt(a,b-a)=ggt(x,y)] w [a=b v ggt(a,b)=ggt(x,y)] Man sieht, dass aus I b obiges folgt. Algorithmik 1, WS 2004/05, Folie 11-65

11.5 Beispiele Euklids Algorithmus zur Berechnung von ggt(a,b): a=x; b=y; while (a!=b) { if (a>b) a=a-b; if (a<b) b=b-a; } //{Q: a=b=ggt(a,b)=ggt(x,y)} 3. Beweise, dass ( I b ) Y Q, so dass bei Terminierung das gewünschte Ergebnis erreicht wird. Aus I b: ggt(a,b)=ggt(x,y) a=b folgt Q trivialerweise sofort. Algorithmik 1, WS 2004/05, Folie 11-66

11.5 Beispiele Euklids Algorithmus zur Berechnung von ggt(a,b): a=x; b=y; while (a!=b) { if (a>b) a=a-b; if (a<b) b=b-a; } //{Q: a=b=ggt(a,b)=ggt(x,y)} 4.Beweise, dass die Schleife terminiert. Die Terminierung kann nur gezeigt werden für a>0,b>0: Bei jeder Iteration werden a oder b echt kleiner, bleiben aber wegen der if-bedingung größer als Null. Nach endlich vielen Verkleinerungsschritten müssen a und b entweder gleich sein, oder beide 1 erreicht haben. Mit allen 4 Schritten ist die totale Korrektheit des Algorithmus gezeigt. Algorithmik 1, WS 2004/05, Folie 11-67

11.5 Beispiele Beispiel: Anderer ggt-algorithmus { P: a = A b = B a > 0 b 0} while (b!= 0) { h := a; a := b; b := h % b; } { Q: a = ggt(a, B) } Zulässigkeit: ganz(a) ganz(b) Schleifeninvariante: I = ( a > 0 b 0 ggt(a,b) = ggt(a, B) ) Begründung: I gilt zu Beginn, nach Durchlaufen des Schleifenrumpfes: (b 0) Y ( ggt(a, b) = ggt(b, a % b) ) und am Ende, wenn die Schleife anhält: (b = 0) Y ( ggt(a, 0) = a = ggt(a, B) ) Animation auf der Algo-1-Web-Seite Algorithmik 1, WS 2004/05, Folie 11-68

11.5 Beispiele Beispiel: Kleinstes gemeinsames Vielfaches kgv(a, b, c) { P: a = A b = B c = C a > 0 b > 0 c > 0 } a0 = a; b0 = b; c0 = c; while (a!= b b!= c) { if (a < b) a = a + a0; else if (b < c) b = b + b0; else c = c + c0; } { Q: a = kgv(a,b,c) } Vergleiche kgv-algorithmus in Abschnitt 4.2 Algorithmik 1, WS 2004/05, Folie 11-69

11.5 Beispiele Denkbare Schleifeninvariante: a, b, c sind Vielfache von A, B bzw. C und a, b, c kgv(a, B, C): I 1 = (A,B,C>0) p, q, r : ( (p,q,r>0) (a = p A) (b = q B) (c = r C) ) I 2 = (a kgv(a, B, C)) (b kgv(a, B, C)) (c kgv(a, B, C)) I = I 1 I 2 Dann gilt bei Schleifenabbruch p A = q B = r C = a = b = c kgv(a, B, C) und somit notwendig a = b = c = kgv(a, B, C) Terminierung: a, b, c können nur wachsen. Da kgv(a, B, C) A B C, fällt die Differenz 3 A B C - a - b - c streng monoton und ist durch 0 nach unten beschränkt. Algorithmik 1, WS 2004/05, Folie 11-70

11.5 Beispiele Verifikation am Beispiel: class Math { public static long potenzieren (long a, long b) { //{P:a>0 v b 0} long x = a; long y = b; } } long z = 1; long result = 0; while (y!=0) { if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; } //{Q:?} return z; 1.) Welcher prädikatenlogische Ausdruck ist eine angemessene Nachbedingung Q? Bei "richtiger" Verifikation kennt man natürlich die Nachbedingung, deren Erfülltheit man zeigen will. Wenn das nicht gelingt, entdeckt man (hoffentlich) den Fehler im Programm. Hier "erraten" wir zu Übungszwecken das zu zeigende Q. Algorithmik 1, WS 2004/05, Folie 11-71

11.5 Beispiele 1. Algorithmus intuitiv verstehen (a) class Math { public static long potenzieren (long a, long b) { //{P:a>0 v b 0} } } long x = a; long y = b; long z = 1; long result = 0; while (y!=0) { if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; } //{Q:?} return z; Schritt x y z Wegen modulo-2-peration betrachten wir Binärdarstellung 1 0 (6=) II (5=) II I 1 II^I II (=6) (II^I)^I I II (=6) 2 3 II ^I II*(II^I) (=6^5) Algorithmik 1, WS 2004/05, Folie 11-72

11.5 Beispiele 1. Algorithmus intuitiv verstehen (b) class Math { public static long potenzieren (long a, long b) { //{P:a>0 v b 0} long x = a; long y = b; } } long z = 1; long result = 0; while (y!=0) { if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; } //{Q:?} return z; Algorithmik 1, WS 2004/05, Folie 11-73 Der Algorithmus berechnet a^b, indem er x=a, y=b, z=1 setzt z und x schrittweise vergrößert y schrittweise verkleinert Ist die letzte Ziffer von y 1 (binär), wird z mit x multipliziert. Ist sie 0, dann wird x quadriert Dann wird die vorletzte Ziffer von y betrachtet Der Algorithmus nutzt also aus: a^b = a^(2 * b div 2 + b mod 2)

11.5 Beispiele 2. Schleifeninvariante erraten class Math { public static long potenzieren (long a, long b) { //{P:a>0 v b 0} } } long x = a; long y = b; long z = 1; long result = 0; while (y!=0) { if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; } //{Q:?} return z; Am Anfang gilt auch a^b = z * x ^ y, weil z=1, x=a und y=b. Das könnte die Invariante I sein! Am Ende soll natürlich Q:z=a^b gelten. Kann man etwas über x und y in Bezug auf z sagen? An Ende gilt: z = z * x ^ y, weil y=0. Algorithmik 1, WS 2004/05, Folie 11-74

11.5 Beispiele 3. Potentielles I mit wp-kalkül durchrechnen (a) Vor der Schleife gilt I kann leicht mit wp gezeigt werden. I als Nachbedingung der letzten Zuweisung vor while Dann rückwärts mehrfach Zuweisungsregel Dann zeigen, dass resultierendes wp schwächer ist als P. Nach der Schleife ist zu zeigen I b Y Q I b = z*x^y = a^b (y!=0) = z*x^0 = a^b = z = a^b In der Schleife? Zeige: I b Y wp(schleifenrumpf, I) Algorithmik 1, WS 2004/05, Folie 11-75

11.5 Beispiele 3. Potentielles I mit wp-kalkül durchrechnen (b) wp("x=x*x;y=y/2",z*x^y=a^b) = wp("x=x*x",z*x^(y div 2)=a^b) = z*(x*x)^(y div 2)=a^b = z*x^(2 * (y div 2))=a^b if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; wp("if (y%2)==1 { }", z*x^(2 * (y div 2))=a^b) = y gerade Y z * x^(2 * (y div 2))=a^b Für gerade y gilt: 2*(y div 2) = y v y ungerade Y Damit folgt I. wp("z=z*x; y=y-1", z*x^(2 * (y div 2))=a^b) if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; Algorithmik 1, WS 2004/05, Folie 11-76

11.5 Beispiele 3. Potentielles I mit wp-kalkül durchrechnen (c) Zweiter Teil der Konjunktion (y ungerade): wp("z=z*x; y=y-1", z*x^(2 * (y div 2))=a^b) = wp("z=z*x", z*x^(2 * ((y-1) div 2))=a^b) = z*x*x^(2 * ((y-1) div 2))=a^b = z*x*x^(y-1)=a^b //y-1 gerade = z*x^y=a^b = I Damit ist gezeigt y gerade Y I v y ungerade Y I = I = wp(schleifenrumpf, I) Da b v I Y I ist die partielle Korrektheit gezeigt! Algorithmik 1, WS 2004/05, Folie 11-77

11.5 Beispiele 4. Terminierung Die Anweisungen vor und nach der Schleife verhindern die Terminierung nicht. Vor der Schleife ist y>0. Zeige: y wird in jeder Iteration mindestens um 1 verkleinert: explizite Subtraktion um 1 Halbierung verkleinert auch um mindestens 1: y/2 y-1 ] y 2y-2 ] 2 y Für y=1 gilt y div 2 = 0. Damit ist nach endlich vielen Schritten y=0 erreicht und die Schleife terminiert. Damit ist die totale Korrektheit gezeigt. Algorithmik 1, WS 2004/05, Folie 11-78 while (y!=0) { if ((y%2)==1) { z=z*x; y=y-1; } x=x*x; y=y/2; }