semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Wprowadzimy teraz pojęcie niezmiennika pętli, które jest często

wykorzystywane do projektowania algorytmów i dowodzenia ich

poprawności. Rozważmy pętlę „while”, która ma postać:

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Ostatnie stwierdzenie dotyczące prawdziwości zdania g po zakończeniu pętli jest tak oczywistym, że często się o nim zapomina.

Jednak dostarcza ono ważnych informacji pozwalających uzasadnić semantyczną poprawność algorytmów. Dlatego zostało umieszczone w treści twierdzenia.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

k=4;while(k>=4) k=k+1;

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Przykład 1.Algorytm NWD Euklidesa.

Zapis w pseudokodzie

Jak znaleźć niezmiennik pętli?

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Najpierw należy pokazać, że

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Ćwiczenie

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Przykład 2.Rozważmy algorytm dzielenia całkowitego liczb naturalnych.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

void dzielenie (int x,y){ //: 0<=x i 0<=y int q,r; q=0; r=x; while(y<=r) //p: x=q*y+r i 0<=r i 0<=y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

Pokażemy, że algorytm ten jest częściowo poprawny względem warunku początkowego i końcowego .

Należy udowodnić pewną własność obliczeń algorytmu, która łączy

zachodzenie warunku początkowego z warunkiem końcowym.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Jaki warunek spełniają x, y, q, r w pętli „while” w chwili sprawdzenia warunku „y<=r” sterującego iteracją?

Określamy niezmiennik p.

Wykażemy, że za każdym razem, gdy obliczenie algorytmu rozpoczyna się stanem spełniającym warunek początkowy oraz dochodzi do warunku iteracji, to spełniony jest warunek p.

void dzielenie (int x,y){ //: 0<=x i 0<=y int q,r; q=0; r=x; while(y<=r) //p: x=q*y+r i 0<=r i 0<=y{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Możemy dojść do p dwiema drogami:

bezpośrednio z początku algorytmu

z pętli

void dzielenie (int x,y){ //: 0<=x i 0<=y int q,r; q=0; r=x; while(y<=r) //p: x=q*y+r i 0<=r i 0<=y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Jeśli dojdziemy do p z początku algorytmu, to q=0, r=x i p jest spełniony, bo zachodzi .

Jeśli już przejdziemy przez pętlę „while” i dojdziemy do p, to wiemy, że y<=r i zaszedł już warunek p: x=q*y+r i 0<=r i 0<=y .

Wtedy zostaje wykonana instrukcja złożona: q’=q+1;r’=r-y. Trzeba sprawdzić, czy dla q’ i r’ zachodzi warunek p:p: x=q’*y+r’ i 0<=r’ i 0<=y .

Alex=(q+1)*y+(r-y)=q*y+r0<=r’=r-y, bo y<=r i 0<=y.

void dzielenie (int x,y){ //: 0<=x i 0<=y int q,r; q=0; r=x; while(y<=r) //p: x=q*y+r i 0<=r i 0<=y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

Semantyczna poprawność algorytmów – dowodzenie za pomocą niezmienników

Stosując teraz indukcję względem liczby wykonanych sprawdzeń warunku iteracji „y<=r”, wnioskujemy, że przy każdym sprawdzeniu warunku iteracji zachodzi p.

Zatem, albo cały czas zachodzi „y<=r”i wtedy nie dochodzimy do , albo w pewnej chwili „y>r” i wtedy dochodzimy do , ale ponieważ p był spełniony, więc musi być spełniony .

Zwróćmy uwagę, że jeśli x=0 i y=0, to obliczenie algorytmu jest nieskończone, a więc według podanych warunków algorytm jest tylko częściowo poprawny i ma własność określoności obliczeń, ale nie ma własności stopu!

Semantyczna poprawność algorytmów – dowodzenie własności stopu.

Dowodzenie własności stopu

Kryterium liczników iteracji

Kryterium malejących wielkości

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium liczników iteracji.

Załóżmy, że dany jest algorytm:

M:{ l=c; while(p)do

{ K;

l=l+1; } }

Dobieramy teraz dwie wielkości: takie, że l<= oraz takie, które wyjaśnia zależność między wartościami zmiennych w chwili sprawdzania warunku (niezmiennika) p.

Kryterium liczników iteracjiJeżeli:1) i >=l jest w algorytmie M niezmiennikiem instrukcji

iteracyjnej „while” przy warunku początkowym ,2)K ma własność stopu względem i p,to M oraz „while(p)do K” mają własność stopu względem .

zmienna l jest licznikiem iteracji, służy do obliczania liczby wykonań instrukcji iterowanej K

Przykład 3.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium liczników iteracji.

void dzielenie1 (int x,y){ //1: 0<=x i 0<yint q,r;q=0;r=x;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

!!M:{ l=c; while(p)do

{ K;

l=l+1; } }

Zmienna q pełni rolę licznika iteracji.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium liczników iteracji.

void dzielenie1 (int x,y){ //1: 0<=x i 0<yint q,r;q=0;r=x;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

M:{ l=c; while(p)do

{ K;

l=l+1; } }

Określmy : x/y oraz : x=q*y+r i r>=0 i 0<y.Pokażemy, że i q<=x/y jest niezmiennikiem instrukcji iteracyjnej.

Przy wejściu do instrukcji mamy: q=0, r=x, x>=0, y>0, czyli zachodzi i q<=x/y oraz r>=y.

Wtedy dostajemy nowe wartości: q’=q+1 i r’=r-y.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium liczników iteracji.

void dzielenie1 (int x,y){ //1: 0<=x i 0<yint q,r;q=0;r=x;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; r=r-y;};

} //: x=q*y+r i 0<=r<y.

M:{ l=c; while(p)do

{ K;

l=l+1; } }

: x/y oraz : x=q*y+r i r>=0 i 0<y.

Łatwo pokazać, że te nowe zmienne spełniają warunek , a nierówność q<=x/y wynika z , bo:

Ćwiczenie!

x=q*y+r, y>0

q=x/y-r/y, y>0

(r>=0,y>0) q<=x/y

Stosując teraz kryterium liczników iteracji wnioskujemy, że algorytm ma własność stopu względem 1. Ponadto nierówność q<=x/y podaje ograniczenie na liczbę wykonywanych iteracji.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium malejących wielkości.

Załóżmy, że dany jest algorytm:

M:{ i=w+1; while(p)do

{ i=w; K;

} }

Dobieramy teraz trzy wielkości: i oraz w będące liczbami całkowitymi i takie, które wyjaśnia zależność między wartościami zmiennych w chwili sprawdzania warunku (niezmiennika) p.

Kryterium malejących wielkościJeżeli:1) i i>w, i w>=0 jest w algorytmie M niezmiennikiem

instrukcji iteracyjnej „while” przy warunku początkowym ,

2)K ma własność stopu względem i p,to M oraz „while(p)do K” mają własność stopu względem .

Metodę malejących wielkości stosuje się, gdy w algorytmie zwiększanie

wartości następuje w sposób nieregularny, czyli niekoniecznie o 1.

Zamiast szacować wzrost rozpatruje się jednak te wielkości, które

zmniejszają swoje wartości w trakcie wykonywania algorytmu i dla

których istnieją wartości ograniczające je z dołu.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium malejących wielkości.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium malejących wielkości.

Przykład 4.void dzielenie2 (int x,y){ //2: 0<=x i 0<yint q,r; int i;q=0;r=x; i=r+1;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; i=r; r=r-y;};

} //: x=q*y+r i 0<=r<y.

M:{ i=w+1; while(p)do

{ i=w; K;

} }

Zmienna r pełni rolę w. Wprowadzamy też pomocniczą zmienną i.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium malejących wielkości.

void dzielenie2 (int x,y){ //2: 0<=x i 0<yint q,r; int i;q=0;r=x; i=r+1;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; i=r; r=r-y;};

} //: x=q*y+r i 0<=r<y.

M:{ i=w+1; while(p)do

{ i=w; K;

} }

Ustalamy : y>0 i (i=r+1 i=r+y).∨

Przy wejściu do instrukcji „while” warunek jest spełniony, bo i=r+1.

Semantyczna poprawność algorytmów – dowodzenie własności stopu – kryterium malejących wielkości.

void dzielenie2 (int x,y){ //2: 0<=x i 0<yint q,r; int i;q=0;r=x; i=r+1;while(y<=r) //p: x=q*y+r i 0<=r i 0<y

{ q=q+1; i=r; r=r-y;};

} //: x=q*y+r i 0<=r<y.

M:{ i=w+1; while(p)do

{ i=w; K;

} }

: y>0 i (i=r+1 i=r+y).∨

Warunek zachowuje się przy każdym wykonaniu instrukcji iterowanej, bo jeśli i’ i r’ są nowymi wartościami, to i’=r oraz r’=r-y, czyli i’=r’+y.

Zatem jest niezmiennikiem iteracji.

Ponieważ r>=0, to cały warunek i r<i , i r>=0 jest niezmiennikiem iteracji.Na podstawie kryterium malejących wielkości mamy własność stopu względem 2.