3.2.6 Sprünge. Hier: Beschränkung auf gute Sprünge wie return break continue. Beachte: Ein Sprung hat keinen Effekt auf die Programmvariablen.

Transkript

1 3.2.6 Sprünge (1.3.5 ) Hier: Beschränkung auf gute Sprünge wie return break continue Beachte: Ein Sprung hat keinen Effekt auf die Programmvariablen. { P }... { Q } break L;... { Q } { P } L : {... { Q } break L;... } { Q } { Q } break L; muss für alle break L; im Block gelten 3.2 1

2 { I C }... { I } continue L;... { I } { I } while( C ){... { I } continue L;... } { I C } { I } continue L; muss für alle continue L; im Schleifenrumpf gelten. Ähnliche Regeln gelten für break und continue in anderen Kontexten

3 3.2.7 Prozeduren Eigentliche Prozeduren void m(t x){...} : { P(v,x) }... { Q( v,v,x) } return;... { Q('v,v,x) } { P(v,x) } {... return;... } { Q(v,v,x) } { Q } muss vor jedem return im Block gelten Beachte: x bedeutet stets das alte x! (weil x Wertparameter ist, ) 3.2 3

4 Beispiel ohne return : int value; /** * pre: value>d && d>0 * post: value'==value-d && value'>0 */ void decr(int d) { {value>d && d>0 } value -= d; {value=='value-d && value>0 } } 3.2 4

5 Funktionsprozeduren T m(...){...} : { P }... { Q result E } return E ;... { True } { P } {... return E ;... } { Q } Q bezieht sich auch auf die Pseudovariable result (3.1.3, S. 19). {Q result E } muss vor jedem return E; im Block gelten. Die E müssen erfolgreich und effektfrei ausgewertet werden können

6 3.2.8 Prozeduraufrufe Eigentliche Prozeduren ohne Parameter mit Parametern Funktionsprozeduren Rekursive Prozeduren 3.2 6

7 Eigentliche Prozeduren ohne Parameter /** * pre: P(v) * post: Q(v,v ) **/ void m() {...} { P } m { Q } { P } m(); { Q } P, Q machen Aussagen über alle in der direkten Umgebung von m sichtbaren Variablen v (3.1.3 ). Praktische Konvention: in P, Q nicht erwähnte Variablen bleiben unverändert (das erspart Aussagen der Art a=a ). P, Q enthalten keine lokalen Variablen von m

8 Beispiel: float x,y; final float eps =...; /** * pre: x>=0 * post: abs(x'*x'-x)<eps && x'>=0 **/ void sqrt() {...} Die Regel erlaubt beispielsweise den Schluss {x>=0 } sqrt(); {abs(x*x-'x)<eps && y='y } aber beispielsweise nicht {x=y*y && y>=1 } sqrt(); {abs(x-y)<eps } Ursachen: - explizite Bezugnahme auf alte Werte, - kein Einbeziehen weiterer, im Kontext benötigter Zusicherungen

9 Daher: { P(v) } m { Q(v,v ) } { P(v) v Q(v,v ) R(v ) } m(); { R(v) } Beh.: {x=y*y && y>=1 } sqrt(); {abs(x-y)<eps } Bew.: {x=y*y && y>=1 } {x>=0 && any(\x' y' -> gilt mit x'==y und y'==y abs(x'*x'-y*y)<eps && x'>=0 && y'==y && abs(x'*x'-y'*y')<eps && x'>=0 && y'>=1 )float } sqrt(); {abs(x*x-y*y)<eps && x>=0 && y>=1 } {abs(x+y)*abs(x-y)<eps && x>=0 && y>=1 } {abs(x-y)<eps } QED

10 Eigentliche Prozeduren mit Parametern /** * pre: P(v,x) * post: Q(v,v,x) **/ void m(t x) {...} { P } m { Q } { P x E } m(e); { Q x 'E } bzw. { P(v,x) } m { Q(v,v,x) } { P(v,E) v Q(v,v,E) R(v ) } m(e); { R(v) } sofern die Auswertung von E erfolgreich und ohne Effekte ist

11 Beispiel: float r,y; final float eps =...; /** * pre: x>=0 * post: abs(r'*r'-x)<eps && r'>=0 **/ void sqrt(float x) {... } Die erste Regel erlaubt lediglich Schlüsse wie {True } {y*y>=0 } sqrt(y*y); {abs(r*r-'y*'y)<eps && y=='y } {abs(r*r-y*y)<eps }

12 Beh.: {y>=1 } sqrt(y*y); {abs(r-y)<eps } Bew. nicht korrektes Haskell! mit zweiter Regel: {y>=1 } {y*y>=0 && any(\(r',y') -> gilt mit r'==y und y'==y abs(r'*r'-y*y)<eps && r'>=0 && y'==y && abs(r'*r'-y'*y')<eps && r'>=0 && y'>=1 ) (float,float) } sqrt(y*y); {abs(r*r-y*y)<eps && r>=0 && y>=1 } {abs(r+y)*abs(r-y)<eps && r>=0 && y>=1 } {abs(r-y)<eps } (wie auf s. 8) QED

13 Variablenparameter statt Wertparameter: /** * pre: P(v,x) * post: Q(v,v,x,x ) **/ void m(var T x) {...} { P(v,x) } m { Q(v,v,x,x ) } { P(v,A) v,a Q(v,v,A,A ) R(v,A ) } m(a); { R(v,A) } unter der Bedingung der Alias-Freiheit (vgl !): wenn m auf eine Variable unter verschiedenen Namen zugreifen kann, dann darf es dabei keine Schreibzugriffe geben!

14 Warum Alias-Freiheit? int a, b; /** * pre: -- * post: a'==1 && b'==2 && x'==3 && y'==4 */ void m(var int x, VAR int y) { a = 1; b = 2; x = 3; y = 4; } Man beweist leicht {True } m(a,a); {a==1 && b==2 && a==3 && a==4 }... und was sich wirklich ergibt ist implementierungsabhängig!

15 Ergebnisparameter : /** * pre: P(v) * post: Q(v,v,x ) **/ void m(out T x) {...} { P(v) } m { Q(v,v,x ) } { P(v) (Q(v,v,A ) R(v,A )) } m(a); { R(v,A) } ebenfalls unter der Bedingung der Alias-Freiheit!

16 Folgerung: Spezifikation muss Angabe enthalten, auf welche nichtlokalen Variablen und welche Parameter schreibend zugegriffen wird! Aufruf muss aliasfrei sein. Achtung z.b. bei m(a[i],a[k])! Fazit: Variablen- und Ergebnisparameter sind mit Vorsicht zu genießen

17 Funktionsprozeduren ohne Nebenwirkungen /** * pre: P(v,x) * post: Q(result,v,x) (Keine Nebenwirkungen: v = v) */ (Konvention: result ohne ) Res m(arg x) {...} { P(v,x) } m { Q(result,v,x } P(v,E) Q(m(E), v, E) sofern die Auswertung von E erfolgreich und ohne Effekte ist

18 Beispiel: final float eps =...; /** * pre: x >= 0 * post: abs(result*result - x) < eps */ float sqrt(float x) {...}... sqrt(a*a)... Dafür gilt P(v,E) tatsächlich: a*a >= 0 Somit liefert die Regel abs(sqrt(a*a)*sqrt(a*a) - a*a) < eps

19 3.2.9 Rekursive Prozeduren Korrektheit der Prozedur setzt Korrektheit der Prozedur voraus?? Genauer:... setzt Korrektheit der Prozedur für andere Eingabe voraus. Verifikation durch vollständige Induktion über die linear geordneten Eingabedaten e 0, e 1, e 2,

20 Explizite Induktion: beweisen, dass die Prozedur mit korrektem Ergebnis terminiert, I. falls sie - für e 0,e 1,...,e k - keinen rekursiven Aufruf ausführt, II. falls - für e n mit n>k - alle rekursiven Aufrufe sich auf Eingabedaten e i mit i<n beziehen und diese Aufrufe mit korrekten Ergebnissen terminieren. Implizite Induktion: beweisen, dass die Prozedur partiell korrekt ist, falls sie partiell korrekt ist (!); beweisen, dass die Rekursion terminiert. (Vgl. Schleifen)

21 int f; /** * pre: n >= 0 * post: f' == fact n */ void fakultaet(int n) { {n>=0 } {n>=0 && n=='n } if(n==0) {n==0 && n=='n } {1==fact 'n } f = 1; {f==fact 'n } else { {n>0 && n=='n } Beispiel 1 - Fakultät: Partielle Korrektheit

22 else { {n>0 && n=='n } {n-1>=0 && any(\(f',n') -> Regel aus (S. 11) f'==fact(n-1) && n'==n && f'==fact(n-1) && n'=='n )(int,int) } fakultaet(n-1); {f==fact(n-1) && n=='n } {f*n==fact n && n=='n } f *= n; {f==fact n && n=='n } {f==fact 'n } } // end if {f==fact 'n } (Beachte Regel aus 3.2.7) } // end fakultaet n'==n gehört zu Q(v,v,E), weil das n in der Umgebung des rekursiven Aufrufs für diesen Aufruf nicht das n der Spezifikation ist

23 Termination: (vollständige Induktion:) I. Die Methode terminiert für n=0. II. Für ein bestimmtes n>0 führt die Methode einen rekursiven Aufruf mit Argument n-1 durch, terminiert also genau dann, wenn sie für n-1 terminiert. III. Somit terminiert sie für alle n

24 Beispiel 2: Türme von Hanoi (1.4.3 ) /** Stack-Parameter werden wie Variablen-Parameter behandelt! * pre: n >= 0 * post: src' == drop n src && * dst' == take n src ++ dst && * aux' == aux */ void hanoi(int n, Stack src, Stack dst, Stack aux) { } if(n>0) { hanoi(n-1, src, aux, dst); move(src,dst); // hanoi(n-1, aux, dst, src); } Termination ist gesichert (wie oben bei Fakultät). Partielle Korrektheit - Beweisskizze:

25 {src == 'src && dst == 'dst && aux == 'aux } { s a d..... } hanoi(n-1, src, aux, dst); {src == drop(n-1)'src && aux == take(n-1)'src ++ 'aux && dst == 'dst } { s d a..... } move(src,dst); {src == drop n 'src && dst == head(drop(n-1)'src) ++ 'dst && aux == take(n-1)'src ++ 'aux... } { a d s Q(aux,a,dst,d,src,s ) R(s,d,a ) } hanoi(size-1, aux, dst, src); {src == drop n 'src && dst == take n 'src ++ 'dst && aux == 'aux R(src,dst,aux) }

26 Nachweis der Korrektheit des letzten Aufrufs: {src == drop n 'src && dst == head(drop(n-1)'src) ++ 'dst && aux == take(n-1)'src ++ 'aux } { a d s Q(aux,a,dst,d,src,s ) R(s,d,a ) } a'==drop(n-1)aux && d'==take(n-1)aux ++ dst && s'==src s'==drop n 'src && d'==take n 'src ++ 'dst && a'=='aux wird erfüllt durch s'==src wegen a'=='aux wegen d'==take n 'src ++ 'dst wegen und (für die anderen Aufrufe entsprechend)