Verifikation von Programmen

Transkript

1 Verifikation von Programmen OOPM, Ralf Lämmel

2 380 Was tun? (Mit den Spezifikationen) Dokumentation Überprüfen der Bedingungen zur Laufzeit Verifizieren der Bedingungen vor Laufzeit Ableitung einer korrekten Implementation aus Spezifikation Verwendung der Spezifikation zur Testdatengenerierung

3 381 Entwicklung korrekter Programme 1. Ansatz OOPM Aufstellung einer Spezifikation (Problembeschreibung). Erstellung einer Implementation (Problemlösung). Beweis über Einhaltung der Spezifikation durch Programm. 2. Ansatz Aufstellung einer Spezifikation. Schrittweise Ableitung einer (effizienten) Implementation. Korrektheit folgt aus Konstruktion. OOPM

4 382 Programme mit Spezifikation = Tripel { P } S { Q } S ist eine Anweisung. P und Q sind Zusicherungen (Bedingungen) P heißt Vorbedingung. Q heißt Nachbedingung.

5 383 Formale Bedeutung von Tripeln { P } S { Q } Zwei Optionen: Totale Korrektheit: Jede Ausführung von S ausgehend von einem Zustand, in dem P gilt, wird normal zum Halt kommen in einem Zustand, in dem Q gilt. Partielle Korrektheit: Jede Ausführung von S ausgehend von einem Zustand, in dem P gilt, wird entweder nicht normal zum Halt kommen (z.b. nicht terminieren) oder normal zum Halt kommen in einem Zustand, in dem Q gilt.

6 384 Spezifikation für die Division mit Rest { x >= 0 && y > 0 } q = 0; r = x; while (r >= y) { r = r - y; q = q + 1; } { x == y * q + r && r < y && r >= 0 && q >= 0 } Wie können wir einen Beweis angehen?

7 Ein Tripel wird zerlegt in viele Teilbeweise mit kleineren Tripeln. { x >= 0 && y > 0 } q = 0; {? } r = x; {? } while (r >= y) { {? } r = r - y; {? } q = q + 1; Betrachtung der Optionen für S in { P } S { Q } Zuweisung Anweisungssequenz While-Schleife {? } } { x == y * q + r && r < y && r >= 0 && q >= 0 } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 385

8 Zusammenfassung der Beweisschritte für Division mit Rest { x >= 0 && y > 0 } q = 0; {? } r = x; 7.Zuweisung 6.Zuweisung {? } while (r >= y) { 5.Zuweisung {? } r = r - y; {? } 4.Zuweisung q = q + 1; {? } 3.Sequenz } { x == y * q + r && r < y && r >= 0 && q >= 0 } QED 1.Sequenz 2.While Der Beweis beginnt von hinten. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 386

9 387 Beweisschritte für Sprachkonstruktionen Zuweisung Anweisungssequenz While-Schleife

10 OPTION Annahme Nur Q ist gegeben. Vorgehensweise Ermittle P aus Q. Beispiel Beweis einer Zuweisung { P } v = t; { Q } Ersetze v in Q durch t. Instanzierung v t P Q x y y==0 x==0 { y==0 } x = y; { x==0 } Wir lesen also die Vorbedingung P aus dem Programm ab.

11 OPTION Annahme Beweis einer Zuweisung { P } v = t; { Q } P und Q sind gegeben. Vorgehensweise Ermittle P aus Q. Ersetze v in Q durch t. Instanzierung v t P x y y==0 P y>=0 Q x>=0 Überprüfe dass P P Beispiel { y==0 } x = y; { x>=0 } P is notwendig für Q. P ist stärker als P. P ist hinreichend für Q.

12 OPTION Beweis einer Zuweisung { P } v = t; { Q } Annahme Nur P ist gegeben. Vorgehensweise Keine allgemeine, systematische Vorgehensweise

13 391 Beweis einer Anweisungssequenz { P } A1; A2 { Q } Annahme Nur Q ist gegeben. Vorgehensweise Zerlege das Problem. { P } A1 { R } { R } A2 { Q } Instanzierung A1 A2 x++; x++; P x>0 R x>1 Q x>2 Führe die Teilbeweise. Beispiel { x>0 } x++; x++; { x>2 } Zwischenrechnung nächste Seite

14 392 Zwischenrechnung Zu zeigen: { x > 1 } x++; { x > 2 } Beweis: Zuckerexpansion für x++ {? } x=x+1; { x > 2 } Ablesen der Vorbedingung { x+1 > 2 } x=x+1; { x > 2 } Vereinfachung von x+1 > 2 { x > 1 } x++; { x > 2 } wzbw.

15 393 Beweis einer While-Schleife { P } while (B) S { Q }?

16 394 // Vor der Schleife Die wesentliche Idee ist, dass eine Schleife eine Invariante I bewahrt. Sie gilt überall. while (B) I gilt hier. // Am Anfang des Schleifenkörpers I gilt hier. B gilt auch. S // Am Ende des Schleifenkörpers I gilt hier. // Nach der Schleife I gilt hier. B gilt nicht.

17 395 Beweis einer Schleife { P } while (B) S { Q } Annahme Nur Q ist gegeben. Vorgehensweise Identifiziere die Invariante I. Zerlege das Problem. { I && B } S { I } I &&!B Q Führe die Teilbeweise. Beispiel { x>=y } while (x>y) x--; { x==y } Instanzierung B x>y S x-- P x>=y Q x==y I x>=y

18 396 Anwendung auf Division mit Rest Schleifeninvariante r >= y { I } Schleifenbedingung r := x; Type to enter text { I && B } r = r - y { I &&!B } q = q + 1 { I } Wie ist I hier beschaffen?

19 397 Ermittlung der Invariante & Co I x == q * y + r && r >= 0 && q >= 0 Heureka! I &&!B x == q * y + r && r < y && r >= 0 && q >= 0 Letzteres ist die Nachbedingung des Programms.

20 { P } S1 { Q }, { Q } S2 { R } { P[x/t] } x = t { P } { P } S1; S2 { R } Mechanisierung der Beweisschritte auf der Basis formaler Regeln { I && B } S { I } { I } while (B) S { I &&!B } P Q, { Q } S { R } { P } S { R } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 398

21 399 Hoare-Regel für die While-Schleife Voraussetzung { I && B } S { I } { I } while (B) S { I &&!B } Schlussfolgerung B ist die Schleifenbedingung. S ist der Schleifenkörper. I ist die Schleifeninvariante. I muss (fast) überall gelten: - vor und nach der Schleife. - vor und nach jedem Schleifendurchlauf.

22 400 Einsetzen in die Schleife { I && B } S { I } { I } while B S { I &&!B } r >= y { I } Schleifeninvariante Schleifenbedingung r := x; Type to enter text { I && B } r = r - y { I &&!B } q = q + 1 { I }

23 401 Vorkommende Bedingungen { I && B } S { I } { I } while B S { I &&!B } B r >= y (Ablesen aus dem Programm) I x == q * y + r && r >= 0 && q >= 0 Heureka!!B r < y (Symbolische Negation von B) I &&!B x == q * y + r && r < y && r >= 0 && q >= 0 Letzteres ist die Nachbedingung des Programms.

24 402 Einsetzen in die Schleife { I && B } S { I } { I } while B S { I &&!B } r >= y { I x == q * y + r && r >= 0 && q >= 0 } Type to enter text { I && B... && r >= y } r = r - y Zu zeigen! q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 } { I &&!B... && r < y }

25 403 Zu zeigen: Korrektheit des Schleifenkörpers Type to enter text { I && B... && r >= y } r = r - y q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 } Plan: Wir führen unsere Beweise weiterhin von hinten.

26 404 Betrachtung von Anweisungsfolgen { I && B... && r >= y } r = r - y??? q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 }

27 405 Hoare-Regel für die Anweisungsverkettung { P } S1 { Q }, { Q } S2 { R } { P } S1; S2 { R } Zwei Anweisungen S 1 und S 2, welche nacheinander ausgeführt werden, 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.

28 406 TODO: Ablesen der Zwischen- und Vorbedingungen von hinten anfangend Type to enter text {??? } r = r - y {??? } q = q + 1 { I x == q * y + r && r >= 0 && q >= 0 }

29 407 Hoare-Regel (Axiom) für Zuweisung { P[x/t] } x = t { P } Das ist ein Axiom -- eine Regel ohne Prämissen. Substitution von x durch t. Wir setzen hier voraus, dass t keine Seiteneffekte hat.

30 408 Hintere Zuweisung in der Schleife { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Ermittlung der Vorbedingung aus der Nachbedingung. Substituiere q durch q + 1.

31 409 TODO: Ablesen der Vorbedingung Type to enter text {??? } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Nun müssen wir weiter nach vorn gehen.

32 410 Vordere Zuweisung in der Schleife { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } Ermittlung der Vorbedingung aus der Nachbedingung. Substituiere r durch r - y.

33 411 Betrachtung von Anweisungsfolgen { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y { x == (q + 1) * y + r && r >= 0 && q + 1 >= 0 } q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.

34 412 Betrachtung von Anweisungsfolgen { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.

35 413 Anpassung von Bedingungen Haben : Mechanisch abgeleitete Vorbedingung { x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 }

36 414 Anpassung von Bedingungen Soll : Ursprüngliche Spezifikation des Schleifenkörpers { I && B x == q * y + r && r >= 0 && q >= 0 && r >= y } r = r - y q = q + 1 { x == q * y + r && r >= 0 && q >= 0 } { I && B } S { I } { I } while B S { I &&!B }

37 415 Anpassung von Bedingungen Soll x == q * y + r && r >= y && r >= 0 && q >= 0 Haben x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 Plan: Wir ordnen die einzelnen Operanden der Konjunktionen aus den beiden Formeln einander zu.

38 Anpassung von Bedingungen Soll x == q * y + r && r >= y && r >= 0 && q >= 0 Haben x == (q + 1) * y + (r - y) && r - y >= 0 && q + 1 >= 0 Nebenrechnung x == (q + 1) * y + (r - y) x == q * y + y + r - y (Ausmultiplizieren) (... +y und... -y) x == q * y + r (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 416

39 417 Anpassung von Bedingungen Soll... && r >= y && r >= 0 && q >= 0 Haben... && r - y >= 0 && q + 1 >= 0 Nebenrechnung r - y >= 0 (Addiere y) r >= y

40 418 Anpassung von Bedingungen Soll... &&... && r >= 0 && q >= 0 Haben... &&... && q + 1 >= 0 Soll Haben q >= 0 q + 1 >= 0 Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern.

41 419 Anpassung von Bedingungen Soll... &&... && r >= 0 &&... Haben... &&... &&... Soll Haben r >= 0 true Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern.

42 420 Schwäche/Stärke von Bedingungen Zielstellung: Vorbedingungen so schwach wie möglich. Nachbedingungen so stark wie möglich. Definitionen x ist schwächer als y wenn y x. x ist echt schwächer als y wenn nicht auch x y.

43 421 Hoare-Regel für die Verstärkung der Vorbedingung P Q, { Q } S { R } { P } S { R }

44 422 Die Schleife ist bewiesen. { I && B } S { I } { I } while B S { I &&!B } r >= y { I x == q * y + r && r >= 0 && q >= 0 } Type to enter text { I && B... && r >= y } r = r - y q = q + 1 { I } { I &&!B... && r < y }

45 Fortsetzung des Gesamtbeweises (ohne neue Ideen) q = 0 { x >= 0 && y > 0 } r = x r >= y { x == q * y + r && r >= 0 && q >= 0 } Verbleibender Programmteil r = r - y r := x; q = q + 1 { x == q * y + r && r < y && r >= 0 && q >= 0 } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 423

46 424 Hintere Zuweisung { x == q * y + x && x >= 0 && q >= 0 } r = x { x == q * y + r && r >= 0 && q >= 0 }

47 425 Vordere Zuweisung { x == 0 * y + x && x >= 0 && 0 >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 }

48 426 Vordere Zuweisung (nach Vereinfachung) { x >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 }

49 427 Betrachtung von Anweisungsfolgen { x >= 0 } q = 0 { x == q * y + x && x >= 0 && q >= 0 } r = x { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck.

50 Betrachtung von Anweisungsfolgen { x >= 0 } q = 0 r = x { x == q * y + r && r >= 0 && q >= 0 } Die innere Bedingung war nur Mittel zum Zweck. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 428

51 429 Anpassung von Bedingungen Soll x >= 0 && y > 0 Haben x >= 0 Soll Haben Die Ableitung der Vorbedingung aus der Nachbedingung ergibt die schwächste, solche Bedingung. Wir können auch mehr fordern -- etwa mit dem Ziel der Terminierung im Auge.

52 Das Programm mit Spezifikation ist korrekt. { x >= 0 && y > 0 } q = 0 r = x r >= y r = r - y r := x; q = q + 1 { x == q * y + r && r < y && r >= 0 && q >= 0 } Q.E.D. (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 430

53 431 Zusammenfassung der Methode zum Beweis der Korrektheit mit Hoare-Regeln Programme mit Spezifikationen: { Vorbedingung } Programm { Nachbedingung } Vor- und Nachbedingungen sind logische Formeln: Hoare- Tripel Formeln beschreiben Annahmen über Variablenbelegungen. Es gibt Korrektheitsregeln für jede Anweisungsform. Vorgehenweise beim Korrektheitsbeweis Ergänze alle Programmstücke mit Vor- und Nachbedingungen. Überprüfe alle Tripel auf Korrektheit gemäß Regeln.

54 432 Beweisregeln A1,..., An A0 Jedes Ai ist... entweder ein Hoare-Tripel oder eine prädikatenlogische Formel. Benutzung Boolescher Ausdrücke der Programmiersprache.

55 433 Arten von Regeln Programmiersprachenabhängige Regeln Zuweisung If-Anweisung... Programmiersprachenunabhängige Regeln Anpassung von Vor- und Nachbedingungen Prädikatenlogische Regeln

56 Hoare-Regel für If-Then-Else { P && B } S1 { R }, { P &&!B } S2 { R } { P } if (B) S1 else S2 { R } P && B S 1 P B Ja Nein P &&!B S 2 R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 434

57 Hoare-Regel für If-Then { P && B } S { R }, P &&!B R { P } if (B) S { R } P && B S P B Ja Nein P &&!B Leere Anweisung R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 435

58 436 Hoare-Regel für die Verstärkung der Vorbedingung P Q, { Q } S { R } { P } S { R }

59 437 Hoare-Regel für die Abschwächung der Nachbedingung { P } S { Q }, Q R Diese Regel wird im Beispielbeweis nicht verwendet. { P } S { R }

60 Im Beispiel verwendete Regeln { P } S1 { Q }, { Q } S2 { R } { P[x/t] } x = t { P } { P } S1; S2 { R } { I && B } S { I } { I } while (B) S { I &&!B } P Q, { Q } S { R } { P } S { R } (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 438

61 439 2 Fangfragen { x >= 0 && y > 0 } Können wir die Vorbedingung abschwächen so dass auch Division mit Rest für negative Zahlen korrekt modelliert ist oder müssen wir zusätzlich das Programm ändern? q = 0; r = x; while (r y) { r = r - y; q = q + 1; } Schließen wir aus, dass x und y nicht geändert wurden? Taugt die Beweismethode dazu? { x == y q + r && r < y && r >= 0 && q >= 0 }

62 440 Situationen beim Beweisen Tote Schleife Endlosschleife Inkorrekte Schleife Erfolgreicher Beweis...

63 441 Tote Schleife { I &&!B } B r := x; Type { I to && enter B } text { I &&!B } S { I } Die Schleifenbedingung ist definitiv vor der Schleife unerfüllt.

64 442 Endlosschleife { I } B r := x; Type to enter text { I && B } S { I && B } { I &&!B } Der Schleifenkörper stellt immer wieder die Gültigkeit der Schleifenbedingung her.

65 443 Inkorrekte Schleife { I } B Type to enter text { I &&!B } S { I } { I &&!B } Der Schleifenkörper verlangt, dass die negierte Schleifenbedingung zum Eintritt in die Schleife gelten muss.

66 444 Erfolgreicher Beweis { I } B r := x; Type to enter text { I && B } S { I } { I &&!B } Die Vorbedingung (eventuell durch Abschwächung) lässt sich aus der Nachbedingung ableiten.

67 Zusammenfassung Einfache Programme sind nicht einfach korrekt. Softwareentwickler benötigen mathematische Fähigkeiten. Softwareentwicklung benötigt Beweisautomatisierung. Kosten von Korrektheit motivieren Wiederverwendung. Ausblick Schnittstellen Zeiger Abstrakte Datentypen

68 Weitere Verifikationsbeispiele (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 446

69 { 447 Verifikationsbeispiel: Schnelle Potenzierung Problem Berechne x n Naive Methode x n = x *... * x n mal Kosten: n - 1 Multiplikationen Wie geht das schneller?

70 448 Schnelle Potenzierung Zu berechnen: x n Fall 1: n ist gerade, etwa n = 2k Berechne x = x 2. Gib x k zurück. Fall 2: n ist ungerade, etwa n = 2k + 1 Berechne x = x 2. Gib x * x k zurück. Dies ergibt O(log n) Multiplikationen.

71 449 Imperative, iterative Implementation Schneller Exponentation public static int power(int x, int n) { int k = n; int p = x; int y = 1; while (k>0) if (k % 2 == 0) { p = p * p; k = k / 2; } else { y = y * p; k = k - 1; } return y; }

72 450 Formierung eines Hoare-Tripels { n >= 0 } int k = n; int p = x; int y = 1; while (k>0) if (k % 2 == 0) { p = p * p; k = k / 2; } else { y = y * p; k = k - 1; } { y == x n }

73 451 Was ist die Schleifen-Invariante I? Ansatz: Wie stehen die Programmvariablen in Beziehung? x und n sind konstant. Wir setzen n = 10. y p k x n 1 x 10 x 10 1 x 2 5 x 10 x 2 x 2 4 x 10 x 2 x 4 2 x 10 x 2 x 8 1 x 10 x 10 x 8 0 x 10 y * p k x 10 x 10 x 10 x 10 x 10 x 10 Wie man leicht sieht: I y * p k == x n && k >= 0

74 452 Verifikation der While-Schleife { I y * p k == x n && k >= 0 } while k > 0 Type to enter text { I B... && k > 0 } if (k % 2) == 0 { p := p * p; k := k / 2; } else { y = y * p; k = k - 1; } { I } { I!B... &&!(k > 0) }

75 453 Verifikation der Fallunterscheidung { I && B y * p k == x n && k >= 0 && k > 0 } { B k % 2 == 0 } Ja Nein { I && B && B } y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 { I && B &&!B } y * p k == x n && k >= 0 && k > 0 &&!(k % 2 == 0) p := p * p; k := k / 2; { I } y = y * p; k = k - 1; { I } { I y * p k == x n && k >= 0 }

76 Hoare-Regel für If-Then-Else { P && B } S1 { R }, { P &&!B } S2 { R } { P } if B S1 else S2 { R } P && B S 1 P B Ja Nein P &&!B S 2 R R R (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 454

77 Fall 1: Then -Zweig { I && B && B } y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 Soll? y * (p * p) k / 2 == x n && k / 2 >= 0 p = p * p; Haben y * p k / 2 = x n && k / 2 >= 0 k = k / 2; { I } y * p k == x n && k >= 0 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 455

78 456 Fall 1: Then -Zweig Soll y * p k == x n && k >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k / 2 >= 0 && k > 0 && k % 2 == 0 y * (p * p) k / 2 == x n && k / 2 >= 0 Haben

79 457 Fall 2: Else -Zweig Übungsaufgabe

80 458 Verifikationsbeispiel: Berechnung des Quadrats einer Zahl Restriktionen: ohne Verwendung von * mit Verwendung von +. Eine Option für den Lösungsansatz:

81 459 Veranschaulichung der Generierung der Quadratzahlen Quelle:

82 Imperative, iterative Implementation i = 0 k = -1 y = 0 i < n i = i + 1 r := x; k = k + 2 y = y + k 3 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 460

83 Formierung eines Hoare-Tripels { P } i = 0 k = -1 y = 0 i < n i = i + 1 r := x; k = k + 2 y = y + k { Q } 3 Welches sind die Vor- und Nachbedingungen? (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 461

84 462 Aufstellung der Spezifikation { n >= 0 } i = 0 k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3

85 463 Beweis von hinten { n >= 0 } i = 0 k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3 Wir wenden die Beweisregel für While-Schleifen an.

86 464 Hoare-Regel für die While-Schleife { I && B } S { I } { I } while B S { I &&!B }

87 465 Anwendung der Schleifenregel i < n { I } Type to enter text i = i + 1 { I && B } k = k + 2 y = y + k { I } { I &&!B } 6

88 466 Was ist die Schleifen-Invariante I? Ansatz: Wie stehen die Programmvariablen in Beziehung? n ist konstant. Wir setzen n = 4. i k y n k == 2*i - 1 y == i*i 0 <= i <= n I k == 2*i - 1 && y == i*i && i <= n

89 467 Verifikation der Schleife i < n { I k == 2*i - 1 && y == i*i && i <= n } Type to enter text i = i + 1 k = k + 2 y = y + k { I && B... && i < n } Zu vereinfachen! { I } { I &&!B... &&!(i < n) } i <= n && i < n i < n

90 468 Verifikation des Schleifenkörpers i < n Type to enter text { k == 2*i 1 && y == i*i && i < n } { k + 2 == 2*(i+1) 1 && y + k + 2 == (i+1)* (i+1) && i+1 <= n } i = i + 1 { k + 2 == 2*i 1 && y + k + 2 == i*i && i <= n } k = k + 2 Soll Haben { k == 2*i 1 && y + k == i*i && i <= n } y = y + k { k == 2*i 1 && y == i*i && i <= n } k + 2 == 2*(i + 1) 1 k + 2 == 2*i k == 2*i 1 y + k + 2 == (i +1)* (i +1) y + k == i*i + 2*i + 1 y + 2*i == i*i + 2*i + 1 y + 2*i + 1 == i*i + 2*i + 1 y == i*i i+1 <= n i < n

91 469 Restliche Zuweisungen zu verifizieren { n >= 0 } i = 0 Type to enter k = -1 y = 0 i < n r := x; i = i + 1 k = k + 2 y = y + k { y = n*n } 3

92 Restliche Zuweisungen zu verifizieren { n >= 0 } { -1 == 2*0-1 && 0 == 0*0 && 0 <= n } i = 0 { -1 == 2*i - 1 && 0 == i*i && i <= n } k = -1 y = 0 { k == 2*i - 1 && 0 == i*i && i <= n } { k == 2*i - 1 && y == i*i && i <= n } -1 == 2*0-1 && 0 == 0*0 && 0 <= n n >= 0 (C) Ralf Lämmel, OOPM, Universität Koblenz-Landau 470

93 { 471 Eine Übungsaufgabe Problem (wie zuvor): Berechnen des Quadrats einer Zahl ohne Verwendung von * mit Verwendung von +. Eine andere Option für ein Lösungsansatz: n 2 = n n n mal Aufgabe: Programm Spezifikation Korrektheitsbeweis