sémantique axiomatique

CSI 3525, Sémantique axiomatique, page 1

Sémantique axiomatique

• Assignations• Composition d’instructions• L’instruction "if-else" • L’instruction "while"• Rétrécissement et élargissement• Arrêt• L’instruction "if"


Vérification d’un programme

La vérification des programmes est faite en deux étapes:

1. L’association d’une formule a chaque étape du programme.

2. La démonstration que le résultat finale est la conséquence logique des conditions initiales, après être passé par les étapes du programme.


Qu’est-ce que la sémantique axiomatique?

• La sémantique axiomatique des assignations, instructions composés, instructions conditionnelles et instructions itératives fut développée par le Professeur C. A. R. Hoare.

• Les éléments de base sont les formules pour l’assignation et la condition.

• L’effet des autres instructions est décrit par la règle d’inférence qui combine les formules d’assignations et de conditions (tout comme les instructions sont elle même des combinaisons d’assignations et de conditions).


L’assignation

Soit une formule contenant la variable v.

v e est alors définie comme la formule obtenue

à partir de quand toutes les occurrences de la

variable v sont remplacées par l’expression e.


Remplacement, un exemple

Avant le remplacement:

h >= 0 & h <= n & n > 0

h 0 0 >= 0 & 0 <= n & n > 0

Après le replacement


Autre exemple

m == min(ai pour 1 <= i <= k–1) &

k–1 <= N

k k+1 m == min(ai pour 1 <= i <= (k+1) – 1) &

(k+1)–1 <= N

m == min(ai pour 1 <= i <= k) & k <= N


L’axiome pour l’assignation

{v e } v = e {}

Exemple:

{ 0 >= 0 & 0 <= n & n > 0 }

x = 0;

{ x >= 0 & x <= n & n > 0 }


Deux exercices

{ ??? } z = z + 1; { z <= N }

{ a > b } a = a – b; { ??? }


Composition d’instructions

Supposons que

{´ } S ´ {´´ }

et

{´´ } S ´´ {´´´ }

Alors, on conclu que

{´ } S ´ S ´´ {´´´ }

En autre mots:

{´ } S ´ {´´ } S ´´ {´´´ }


Un exemple

x = 0; f = 1;while (x != n) { x = x + 1; f = f * x;}

Nous voulons prouver:

{ f == x! }x = x + 1;f = f * x;

{ f == x! }


Appliquons la règle d’inférence pour la composition.

´ est f == x!

´´´ est f == x!

S ´ est x = x + 1;

S ´´ est f = f * x;

Le factoriel


Nous cherchons le ´´ pour lequel:

{ f == x! } x = x + 1;

{´´ }

f = f * x; { f == x! }

Observons que: f == x! f == ((x + 1) – 1)!

Et donc: f == (x – 1)! x x + 1 f == x!

{ f == x! } x = x + 1; {f == (x – 1)! }

´ ´´S ´

Le factoriel (2)


Maintenant, observons que:

f == (x – 1)! f * x == (x – 1)! * x == x!

Donc, nous avons:

f == x! f f * x f == (x – 1)!

Et ainsi:

{f == (x – 1)! } f = f * x; {f == x! }

QED

´´ ´´´S ´´

Le factoriel (3)


L’instruction "if-else"

Supposons que

{ & } S´ {}

et

{ & } S´´ {}


{} if ( ) S ´ else S ´´ {}

Peu importe le cas choisi par l’instruction ‘if-else’, le résultat est la même formule ‘’. Donc l’instruction ‘if-else’ en entier résulte en la formule ‘’.


L’instruction

if ( a < 0 ) b = -a; else b = a;

Rend la formule b == abs(a) vrai.

Plus spécifiquement:

{true}if ( a < 0 ) b = -a; else b = a;{ b == abs(a) }

est true est b == abs(a) est a < 0

S´ est b = -a;S´´ est b = a;

"if-else", un exemple


Considerons chaque cas. Premièrement, si est vrai:

true & a < 0 a < 0 – a == abs(a)Alors, d’après l’axiome de l’assignation:

{– a == abs(a)} b = -a; {b == abs(a)}

De la même façon, si est vrai:

true & a < 0 a 0 a == abs(a)Alors:

{a == abs(a)} b = a; {b == abs(a)}

"if-else", un exemple (2)


Donc S´ et S´´ résultent en: b == abs(a)

Nous avons donc prouvé:{true}if ( a < 0 ) b = -a; else b = a;{ b == abs(a) }

En autre mots, cette expression conditionnelle trouve abs(a). Elle fait avec aucune précondition: "true" signifie qu’il n’y a aucune restriction sur les valeurs initiales de a et b.

"if-else", un exemple (3)


L’instruction "while"

Un invariant de boucle est une condition qui est satisfaite immédiatement avant le début d’une boucle, demeure vrai lors de son exécution, et est toujours satisfaite à la sortie de la boucle.

Supposons que

{ & } S {}

[C’est à dire, S préserve (l’invariant de boucle)]Alors, on conclu que

{ } while ( ) S { & }

En autant que la boucle se termine (qu’elle n’est pas infini).


Le factoriel (encore)

x = 0; f = 1;while ( x != n ) {x = x + 1;f = f * x;

}

On sait que n ≥ 0. Après les instructionsx = 0; f = 1;

ce qui implique que f == x! (1 == 0!)Nous avons déjà démontré que:{ f == x! } x = x + 1; f = f * x; { f == x! }


Maintenant, est f == x! est x != n est x == n

En utilisant la règle d’inférence pour les boucles "while":

{ f == x! }while ( x != n ) { x = x + 1; f = f * x;}{ f == x! & x == n}

Le factoriel (encore) (2)


Alors après la boucle, on a:

f == x! & x == n f == n!

Ainsi:{ true } x = 0; f = 1; { f == x! }

et:{ f == x! } while ( x != n ) {

x = x + 1; f = f * x;}

{ f == n!}



Donc, nous avons montré que la boucle détermine f == n!, avec aucune précondition sur les valeurs initiales de f et n, tant que n ≥ 0.

Ainsi, avec l’axiome de la composition:{ true } x = 0; f = 1;

while ( x != n ) { x = x + 1; f = f * x;}

{ f == n!}

Donc, le programme calcule le factoriel de n.



Le résonnement est le suivant pour la boucle: une variable est ajustée rendant l’invariant temporairement faux, mais un autre ajustement est fait qui rétablie l’invariant. Donc l’invariant est vérifié à la fin de la boucle.

{ f == x! } x = x + 1; {f == (x – 1)! }L’invariant est maintenant temporairement faux

{f == (x – 1)! } f = f * x; {f == x! }L’invariant est maintenant rétablie

Ce raisonnement n’est pas valide pour les boucles infinie:la condition & n’est pas atteinte, et la situation est indéterminée suivant la boucle.



Rétrécissement et élargissement

Supposons que

´

et

{} S { }


{´ } S { }

Supposons que

{} S { }

et

´


{ } S { ´ }

Ces règles peuvent permettre de rétrécir une précondition, ou d’élargir une postcondition.


Nous avons vu que n! est calculé pour tout n>=0, avec {true} comme précondition (le calcul réussit toujours);

Donc, selon l’axiome du rétrécissement, le calcul de n! réussira également pour n == 5.

Rétrécissement et élargissement, un exemple


Autre exemple

{ N >= 1 } { N >= 1 & 1 == 1 & a1 == a1 } i = 1; s = a1;

{ N >= 1 & i == 1 & s == a1 } { N >= 1 & s == a1 + … + ai } INVARIANTwhile ( i != N ) {

{ N >= 1 & s == a1 + … + ai & i != N }i = i + 1;

{ N >= 1 & s == a1 + … + ai–1 & i – 1 != N }s = s + ai;

{ N >= 1 & s == a1 + … + ai }}

{ N >= 1 & s == a1 + … + ai & i == N } { N >= 1 & s == a1 + … + aN }


• Nous avons montré que ce programme calcul la somme de a1, ..., aN.

• La précondition N >= 1 est seulement nécessaire pour démontrer la terminaison.

Autre exemple (2)


Arrêt

• Les preuves précédentes sont seulement partiellement correcte.

• Il reste a démontrer que les boucles se terminent.• Une preuve correcte doit également montrer que

toutes les boucles auront toujours un nombre fini d’itérations.

• On peut montrer qu’une boucle se terminera en montrant que chaque itération nous rapproche de la condition d’arrêt.


Encore le factoriel

• Initialement, x == 0.

• Chaque itération incrémente x de 1, donc, on passe par les nombres: 0, 1, 2, ...

• n >= 0 sera nécessairement un de ces nombres

• Ce raisonnement ne fonctionnerait pas pour n < 0, et la condition d’arrêt ne serait pas atteinte pour ces valeurs.


Une fonction décroissante

• Une boucle termine quand une fonction des variables du programme atteint 0 lors de l’exécution de la boucle.

• Pour le factoriel, la fonction pourrait être n – x. La valeur de la fonction est initialement n et diminue de 1 à chaque itération.

• Pour la somme, on peut choisir N – i.


Multiplication par des additions successives

{ B >= 0 & B == B & 0 == 0} POUR L’ARRÊTb = B; p = 0;{ b == B & p == 0 } { p == A * (B – b) } INVARIANTwhile ( b != 0 ) {

p = p + A;{ p == A * (B – (b – 1)) }b = b - 1;{ p == A * (B – b) }

}

{ p == A * (B – b) & b == 0} { p == A * B }La boucle termine, puisque la valeur de b atteint 0.


Exemple

Montrons que:p = a; a = b; b = p;

échange les valeurs de a et b :

{ a == A & b == B }p = a; a = b; b = p;

{ b == A & a == B }

Les étapes de la preuve:{ a == A & b == B } p = a;{ p == A & b == B } a = b;{ p == A & a == B } b = p;{ b == A & a == B }


x = x + y;

y = x - y;

x = x - y;

Exemple

Quel est l’effet de la suite d’instruction suivante sur les variables entières x, y:


{x == X & y == Y }

{x + y == X + Y & y == Y } x = x + y;

{x == X + Y & y == Y }

{x == X + Y & x - y == X } y = x - y;

{x == X + Y & y == X }

{ x - y == Y & y == X } x = x - y;

{ x == Y & y == X }

Exemple (suite)


Le plus grand commun diviseur

{ X > 0 & Y > 0 }a = X; b = Y;{ } que devrait-être l’invariant?while ( a != b ) { & a != b } {if ( a > b ) { & a != b & a > b }

a = a - b;else { & a != b & (a > b) }

b = b - a;}{ & (a != b) }{ PGCD( X, Y ) == a }


On aura besoin de ces propriétés des pgcd:

PGCD( n + m, m ) == PGCD( n, m )

PGCD( n, m + n ) == PGCD( n, m )

La première étape (de façon très formelle):

{ X > 0 & Y > 0 }

{ X > 0 & Y > 0 & X == X & Y == Y }

a = X; b = Y;

{ a > 0 & b > 0 & a == X & b == Y }

PGCD (2)


Quand la boucle termine, on a:a == b & PGCD( a, b ) == a

On voudra probablement donc cette condition dans l’invariant:

a == b & PGCD( X, Y ) == PGCD( a, b )

Au debut de la boucle:{ a > 0 & b > 0 & a == X & b == Y } {a > 0 & b > 0 & PGCD( X, Y ) == PGCD( a, b ) }

Donc l’invariant sera:a > 0 & b > 0 & PGCD( X, Y ) == PGCD( a, b )

PGCD (3)


On veut prouver que{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b) & a != b}while ......{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b)}

La condition finale sera donc:a > 0 & b > 0 &PGCD(X, Y) == PGCD(a, b) & a == b

Ce qui implique:PGCD( X, Y ) == a

PGCD (4)


La boucle consiste en une instruction conditionnelle.

La preuve sera faite si on démontre:

{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b) & a != b}

if ( a > b )a = a - b;

elseb = b - a;

{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b)}

PGCD (5)


Considérons le cas a > b:

{a > 0 & b > 0 &PGCD(X, Y) == PGCD(a, b) & a != b & a > b }

{a – b > 0 & b > 0 & PGCD(X, Y) == PGCD(a – b, b)}

a = a - b;

{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b)}

PGCD (6)


Maintenant, le cas a > b.

{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b) & a != b & (a > b) }

{a > 0 & b – a > 0 & PGCD(X, Y) == PGCD(a, b – a)}

b = b - a;

{a > 0 & b > 0 & PGCD(X, Y) == PGCD(a, b)}

PGCD (7)


Les deux cas du if-else emmènent la même condition finale. Il reste seulement à montrer que la boucle termine.On montre que max( a, b ) diminue à chaque itération de la boucle.

Soit a == A, b == B au début d’une itération. Supposons d’abord que a > b:

max( a, b ) == A,donc a – b < A, b < A,

donc max( a – b, b ) < A.

PGCD (8)


Et si a < b:

max( a, b ) == B,

b – a < B, a < B,

donc max( a, b – a ) < B.

Puisque a > 0 et b > 0, max( a, b ) > 0.

Donc la diminution de a et b ne peut pas se poursuivre indéfiniment.

QED

PGCD (9)


L’instruction "if"

Supposons que

{ & } S { }

et

&


{ } if ( ) S { }


Démontrons que:

{ N > 0 }

k = 1; m = a1;while ( k != N ) { k = k + 1;

if ( ak < m ) m = ak;}

{ m == min( 1 <= i & i <= N: ai ) }

Un exemple de "if"


Le fait que la boucle se termine est évidant:

N – k vers zéro.

L’invariant de la boucle: à la kième itération, après avoir inspecté a1, ..., ak, on sait que

m == min( 1 <= i & i <= k : ai ).

Initialement, on a:{ N > 0 } k = 1; m = a1;{ k == 1 & m == a1 } { k == 1 & m == min( 1 <= i & i <= k : ai ) }

Minimum (1)


Nous devons donc démontrer:

{ m == min( 1 <= i & i <= k : ai ) & k != N }k = k + 1;if ( ak < m ) m = ak;{ m == min( 1 <= i & i <= k : ai ) }

Minimum (2)


{ m == min( 1 <= i & i <= k : ai ) & k != N }

{ m == min( 1 <= i & i <= (k + 1) – 1: ai ) & (k + 1) – 1 != N }

k = k + 1;

{ m == min( 1 <= i & i <= k – 1: ai ) & k – 1 != N }

Notons que k – 1 != N assure l’existence de ak.

Minimum (3)


Il reste à démontrer:

{ m == min( 1 <= i & i <= k – 1: ai ) & k – 1 != N }

if ( ak < m ) m = ak;

{ m == min( 1 <= i & i <= k: ai ) }

On utilisera le fait que:

min( 1 <= i & i <= k: ai ) ==min2( min( 1 <= i & i <= k – 1: ai ), ak )

Minimum (4)


Considérons les deux cas de l’expression conditionnelle.

Premièrement, (ak < m).

{m == min(1 <= i & i <= k – 1: ai ) &k – 1 != N & (ak < m)}

{m == min2(min( 1 <= i & i <= k – 1: ai ), ak )}

{m == min(1 <= i & i <= k: ai )}

Minimum (5)


Deuxièmement, ak < m.

{m == min(1 <= i & i <= k – 1: ai ) &k – 1 != N & ak < m}

{ak == min2( min( 1 <= i & i <= k – 1: ai ), ak )}

{ak == min(1 <= i & i <= k: ai )}

m = ak;

{m == min(1 <= i & i <= k: ai )}

Donc la boucle préserve la condition

m == min( 1 <= i & i <= k: ai )

Minimum (6)


La boucle en entier fonctionne donc ainsi:

{ m == min( 1 <= i & i <= k: ai ) }

while ( k != N ) }

k = k + 1; if ( ak < m ) ak = m;

}

{ m == min( 1 <= i & i <= k: ai ) & k == N }

{ m == min( 1 <= i & i <= N: ai ) }

Nous avons montré que le programme trouve le minimum parmi N nombres, si N > 0.

QED

Minimum (7)


Encore une boucle "while"

{ B > 0 } POUR LA TERMINAISONb = 1; p = A;while ( b != B ) {

b = b + 1;p = p * A;

}{ ??? }

Exemples


{ B > 0 & 1 == 1 & A == A} POUR LA TERMINAISONb = 1; p = A;{ b == 1 & p == A } { p == A ** b } INVARIANTwhile ( b != B ) {

b = b + 1;{ p == A ** (b - 1) }p = p * A;{ p == A ** b }

}{ p == A ** b & b == B} { p == A ** B }La boucle se termine: la valeur B - b devient 0.

Exemples Encore une boucle "while“ (2)


{ N > 0 } POUR LA TERMINAISONk = 1;while ( k != N ) {

if ( Ak > Ak+1 )

{ p = Ak; Ak = Ak+1; Ak+1 = p; } k = k + 1; }{ ??? }

Un autre example avec "if"Exemples


{ N > 0 } FOR TERMINATIONk = 1;{ Ak == max( 1 <= i & i <= k: Ai ) } INVARIANTwhile ( k != N ) { { Ak == max( 1 <= i & i <= k: Ai ) & k != N } if ( Ak > Ak+1 ) { p = Ak; Ak = Ak+1; Ak+1 = p; } { Ak+1 == max( 1 <= i & i <= k+1: Ai ) } k = k + 1; { Ak == max( 1 <= i & i <= k: Ai ) }}

{Ak == max( 1 <= i & i <= k: Ai ) & k = N } {AN == max( 1 <= i & i <= N: Ai ) }

Exemples Un autre example avec "if“ (2)


{Ak == max( 1 <= i & i <= k: Ai ) & k != N }

Cas 1: Ak > Ak+1

{ Ak == max( 1 <= i & i <= k: Ai ) & k != N & Ak > Ak+1}

p = Ak; { p > Ak+1 }

Ak = Ak+1; { p > Ak }

Ak+1 = p; { Ak+1 > Ak }

{ Ak+1 == max( 1 <= i & i <= k+1: Ai ) }

Cas 2: Ak <= Ak+1

{ Ak == max( 1 <= i & i <= k: Ai ) & k != N & Ak <= Ak+1 } { Ak+1 == max( 1 <= i & i <= k+1: Ai ) }

ExamplesUn autre example avec "if“ (3)

sémantique axiomatique

Documents