... im GGT-Programm (1):

(1)

... im GGT-Programm (1):

Zuweisung:

Nachbedingung: A

schwächste Vorbedingung:

A

[

_x

−

_y

/

_x

] ≡

_ggT

(

_a,_b

) =

_ggT

(

_x

−

_y, _y

)

≡

_ggT

(

_a,b

) =

_ggT

(

_x, y

)

(2)

... im GGT-Programm (2):

Zuweisung:

Nachbedingung: A

schwächste Vorbedingung:

A

[

_y

−

_x

/

_y

] ≡

_ggT

(

_a,_b

) =

_ggT

(

_x, _y

−

_x

)

≡

_ggT

(

_a,b

) =

_ggT

(

_x, y

)

≡

_A

(3)

Zusammenstellung:

x = read(); write(e); x = e;

B [e/x]

B

B B

B

∀ x.

WP

[[

]](

_B

) ≡

_B

WP

[[

]](

_B

) ≡

_B

[

_e

/

_x

]

(4)

Diskussion:

• Die Zusammenstellung liefert für alle Aktionen jeweils die schwächsten Vorbedingungen für eine Nachbedingung B.

• Eine Ausgabe-Anweisung ändert keine Variablen. Deshalb ist da die schwächste Vorbedingung B selbst ;-)

• Eine Eingabe-Anweisung ändert die Variable auf unvorhersehbare Weise.

Damit nach der Eingabe B gelten kann, muss B vor der Eingabe für jedes mögliche gelten ;-)

(5)

Orientierung:

Start

no yes

yes write(x); no

x != y

x < y y = b = read();

x = a = read();

A

B A

A A A

true

a = x

(6)

Für die Anweisungen: berechnen wir:

WP

[[

]] (

_A

) ≡

_A

[

_b

/

_y

]

≡

_ggT

(

_a, _b

) =

_ggT

(

_x, _b

)

(7)

WP

[[

]] (

_A

) ≡

_A

[

_b

/

_y

]

≡

_ggT

(

_a, _b

) =

_ggT

(

_x, _b

)

WP

[[

]] (

_ggT

(

_a,_b

) =

_ggT

(

_x, _b

))

≡ ∀

_b. _ggT

(

_a, _b

) =

_ggT

(

_x, _b

)

(8)

Orientierung:

Start

no yes

Stop

yes write(x); no

y=y−x;

x=x−y;

x != y

x < y y = b = read();

x = a = read();

A B

B

A

A A A

true

a = x

(9)

WP

[[

]] (

_a

=

_x

) ≡

_a

=

_a

≡

true

WP

[[

]] (

true

) ≡ ∀

_a. true

true :-)

(10)

Teilproblem 2: Verzweigungen

no yes

b B

A

B

₀ ₁

Es sollte gelten:

• A

∧ ¬

_b

⇒

_B₀ und

• A

∧

_b

⇒

_B₁ .

(11)

Das ist der Fall, falls A die schwächste Vorbedingung der Verzweigung:

WP

[[

_b

]] (

_B₀, B₁

) ≡ ((¬

_b

) ⇒

_B₀

) ∧ (

_b

⇒

_B₁

)

impliziert :-)

Die schwächste Vorbedingung können wir umschreiben in:

(12)

Das ist der Fall, falls A die schwächste Vorbedingung der Verzweigung:

WP

[[

_b

]] (

_B₀, B₁

) ≡ ((¬

_b

) ⇒

_B₀

) ∧ (

_b

⇒

_B₁

)

impliziert :-)

Die schwächste Vorbedingung können wir umschreiben in:

WP

[[

_b

]] (

_B₀, B₁

) ≡ (

_b

∨

_B₀

) ∧ (¬

_b

∨

_B₁

)

≡ (¬

_b

∧

_B₀

) ∨ (

_b

∧

_B₁

) ∨ (

_B₀

∧

_B₁

)

(13)

Beispiel:

B₀

≡

_x

>

_y

∧

_y

>

0 B₁

≡

_x

>

0

∧

_y

>

_x Sei b die Bedingung y

>

_x.

Dann ist die schwächste Vorbedingung:

(14)

Beispiel:

B₀

≡

_x

>

_y

∧

_y

>

0 B₁

≡

_x

>

0

∧

_y

>

_x Sei b die Bedingung y

>

_x.

Dann ist die schwächste Vorbedingung:

(

_x

>

_y

∧

_y

>

0

) ∨ (

_x

>

0

∧

_y

>

_x

) ∨

_false

≡

_x

>

0

∧

_y

>

0

∧

_x

6=

_y

(15)

... im GGT-Beispiel:

b

≡

_y

>

_x A

∧

_A

≡

_A

¬

_b

∧

_A

≡

_x

≥

_y

∧

_ggT

(

_a,_b

) =

_ggT

(

_x, _y

)

b

∧

_A

≡

_y

>

_x

∧

_ggT

(

_a,_b

) =

_ggT

(

_x, _y

)

==⇒ Die schwächste Vorbedingung ist:

(16)

... im GGT-Beispiel:

b

≡

_y

>

_x A

∧

_A

≡

_A

¬

_b

∧

_A

≡

_x

≥

_y

∧

_ggT

(

_a,_b

) =

_ggT

(

_x, _y

)

b

∧

_A

≡

_y

>

_x

∧

_ggT

(

_a,_b

) =

_ggT

(

_x, _y

)

==⇒ Die schwächste Vorbedingung ist:

ggT

(

_a, _b

) =

_ggT

(

_x, _y

)

(17)

Orientierung:

Start

no yes

yes write(x); no

x != y

x < y y = b = read();

x = a = read();

A

B A

A A A

true

a = x

(18)

Analog argumentieren wir für die Zusicherung vor der Schleife:

b

≡

_y

6=

_x B

∧

_A

≡

_B

¬

_b

∧

_B

≡

_B

b

∧

_A

≡

_A

∧

_x

6=

_y

==⇒ _A

≡ (

_A

∧

_x

=

_y

) ∨ (

_A

∧

_x

6=

_y

) ∨

_B ist die schwäch- ste Vorbedingung für die Verzweigung :-)

(19)

Zusammenfassung der Methode:

• Annotiere jeden Programmpunkt mit einer Zusicherung.

• Überprüfe für jede Anweisung s zwischen zwei Zusicherungen A und B, dass A die schwächste Vorbedingung von s für B impliziert, d.h.:

A

⇒

_WP

[[

_s

]](

_B

)

• Überprüfe entsprechend für jede Verzweigung mit Bedingung b, ob die Zusicherung A vor der Verzweigung die schwächste Vorbedingung für die Nachbedingungen B₀ und B₁ der

Verzweigung impliziert, d.h.

(20)

3.2 Korrektheit

Fragen:

• Welche Programm-Eigenschaften können wir mithilfe lokal konsistenter Annotierungen garantieren ?

• Wie können wir nachweisen, dass unser Verfahren keine falschen Ergebnisse liefert ??

(21)

Erinnerung (1):

• In MiniJava können wir ein Zustand σ _{aus einer} Variablen-Belegung, d.h. einer Abbildung der

Programm-Variablen auf ganze Zahlen (ihren Werten), z.B.:

σ

= {

_x

7→

5, y

7→ −

42

}

• Ein Zustand σ erfüllt eine Zusicherung A , falls

// wir substituieren jede Variable in A durch ihren Wert in σ

(22)

Erinnerung (1):

• In MiniJava können wir ein Zustand σ _{aus einer} Variablen-Belegung, d.h. einer Abbildung der

Programm-Variablen auf ganze Zahlen (ihren Werten), z.B.:

σ

= {

_x

7→

5, y

7→ −

42

}

• Ein Zustand σ _erfüllt eine Zusicherung A , falls A

[

^σ

(

_x

)/

_x

]

_x_∈_A

// wir substituieren jede Variable in A durch ihren Wert in σ eine wahre Aussage ist, d.h. äquivalent true.

Wir schreiben: σ

| =

_A.

(23)

Beispiel:

σ

= {

_x

7→

5, y

7→

2

}

A

≡ (

_x

>

_y

)

A

[

5

/

_x, 2

/

_y

] ≡ (

5

>

2

)

≡

true

(24)

Beispiel:

σ

= {

_x

7→

5, y

7→

2

}

A

≡ (

_x

>

_y

)

A

[

5

/

_x, 2

/

_y

] ≡ (

5

>

2

)

≡

true

σ

= {

_x

7→

5, y

7→

12

}

A

≡ (

_x

>

_y

)

A

[

5

/

_{x, 12}

/

_y

] ≡ (

5

>

12

)

≡

false

(25)

Triviale Eigenschaften:

σ

| =

true für jedes σ σ

| =

false für kein σ

σ

| =

_A₁ und σ

| =

_A₂ ist äquivalent zu σ

| =

_A₁

∧

_A₂

σ

| =

_A₁ oder σ

| =

_A₂ ist äquivalent zu A A

(26)

Erinnerung (2):

• Eine Programmausführung π durchläuft einen Pfad im Kontrollfluss-Graphen :-)

• Sie beginnt in einem Programmpunkt u₀ in einem

Anfangszustand σ₀. und führt in einen Programmpunkt u_m und einen Endzustand σ_m_.

• Jeder Schritt der Programm-Ausführung führt eine Aktion aus und ändert Programmpunkt und Zustand :-)

==⇒ Wir können π als Folge darstellen:

wobei die si Elemente des Kontrollfluss-Graphen sind, d.h.

(27)

Erinnerung (2):

• Eine Programmausführung π durchläuft einen Pfad im Kontrollfluss-Graphen :-)

• Sie beginnt in einem Programmpunkt u₀ in einem

Anfangszustand σ₀. und führt in einen Programmpunkt u_m und einen Endzustand σ_m_.

• Jeder Schritt der Programm-Ausführung führt eine Aktion aus und ändert Programmpunkt und Zustand :-)

==⇒ Wir können π als Folge darstellen:

u , s u , . . . s u ,

(28)

Beispiel:

Start

x = a = read();

y = b = read();

no yes

Stop

yes write(x); no

y=y−x;

x=x−y;

x != y

x < y

3

5

6 2 4

1

0

(29)

Nehmen wir an, wir starten in Punkt 3 mit

{

_x

7→

6, y

7→

12

}

. Dann ergibt sich die Programmausführung:

π

= (

3,

{

_x

7→

6, y

7→

12

})

(

1,

{

_x

7→

6, y

7→

6

})

(

5,

{

_x

7→

6, y

7→

6

})

(

6,

{

_x

7→

6, y

7→

6

})

(30)

Satz:

Sei p ein MiniJava-Programm, Sei π _eine

Programmausführung, die im Programmpunkt u startet und zum Programmpunkt v führt.

Annahmen:

• Die Programmpunkte von p seien lokal konsistent mit Zusicherungen annotiert.

• Der Programmpunkt u sei mit A annotiert.

• Der Programmpunkt v sei mit B annotiert.

Dann gilt:

Erfüllt der Anfangszustand von π die Zusicherung A , dann erfüllt der Endzustand die Zusicherung B.

(31)

Satz:

Sei p ein MiniJava-Programm, Sei π _eine

Programmausführung, die im Programmpunkt u startet und zum Programmpunkt v führt.

Annahmen:

• Die Programmpunkte von p seien lokal konsistent mit Zusicherungen annotiert.

• Der Programmpunkt u sei mit A annotiert.

• Der Programmpunkt v sei mit B annotiert.

(32)

Bemerkungen:

• Ist der Startpunkt des Programms mit true annotiert, dann erfüllt jede Programmausführung, die den Programmpunkt v erreicht, die Zusicherung an v :-)

• Zum Nachweis, dass eine Zusicherung A an einem

Programmpunkt v gilt, benötigen wir eine lokal konsistente Annotierung mit zwei Eigenschaften:

(1) der Startpunkt ist mit true annotiert;

(2) Die Zusicherung an v impliziert A :-)

• Unser Verfahren gibt (vorerst) keine Garantie, dass v überhaupt erreicht wird !!!

• Falls ein Programmpunkt v mit der Zusicherung false

(33)

Bemerkungen:

• Ist der Startpunkt des Programms mit true annotiert, dann erfüllt jede Programmausführung, die den Programmpunkt v erreicht, die Zusicherung an v :-)

• Zum Nachweis, dass eine Zusicherung A an einem

Programmpunkt v gilt, benötigen wir eine lokal konsistente Annotierung mit zwei Eigenschaften:

(1) der Startpunkt ist mit true annotiert;

(2) Die Zusicherung an v impliziert A :-)

• Unser Verfahren gibt (vorerst) keine Garantie, dass v

(34)

Beweis:

Sei π

= (

_u₀,σ₀

)

_s₁

(

_u₁,σ₁

)

. . . s_m

(

_u_m,σ_m

)

Gelte: σ₀

| =

_A.

Wir müssen zeigen: σ_m

| =

_B.

Idee:

Induktion nach der Länge m der Programmausführung :-) m = 0:

Der Endpunkt der Ausführung ist gleich dem Startpunkt

==⇒ ^σ₀ = ^σ_m und A ≡ _B

==⇒ Behauptung gilt :-)