Cours d'algorithmique 10 / Intranet 1 19 décembre 2006 Cours d’Algorithmique Logique de Hoare (fin) : Les boucles et les invariants.

Présentation au sujet: "Cours d'algorithmique 10 / Intranet 1 19 décembre 2006 Cours d’Algorithmique Logique de Hoare (fin) : Les boucles et les invariants."— Transcription de la présentation:

1 Cours d'algorithmique 10 / Intranet 1 19 décembre 2006 Cours d’Algorithmique Logique de Hoare (fin) : Les boucles et les invariants.

2 19 décembre 2006Cours d'algorithmique 10 / Intranet2 Trier et chercher, recherche textuelle Trier et chercher, recherche textuelle Listes et arbres Listes et arbres Le back-track Le back-track Arbres équilibrés Arbres équilibrés Récursivité et induction sur la structure Récursivité et induction sur la structure Divide and conquer, algorithmes gloutons Divide and conquer, algorithmes gloutons Minimax, alpha-beta Minimax, alpha-beta Dérécursion Dérécursion Divers problèmes particuliers Divers problèmes particuliers Logique de Hoare Logique de Hoare Programmation dynamique Programmation dynamique Complexité et calculabilité Complexité et calculabilité Les grandes lignes du cours

3 19 décembre 2006Cours d'algorithmique 10 / Intranet3 Logique de Hoare ----------------------------------------------------------------- W H I L E e t l e s I N V A R I A N T S D E B O U C L E

4 19 décembre 2006Cours d'algorithmique 10 / Intranet4 Logique de Hoare ----------------------------------------------------------------- L’exemple qui nous sert à illustrer la notion d’invariant : L’exemple qui nous sert à illustrer la notion d’invariant : – PRE : V, D  N – POST: Q, R  N telles V = Q * D + R et R < D. C’est la spécification de la division euclidienne ! C’est la spécification de la division euclidienne ! I I

5 19 décembre 2006Cours d'algorithmique 10 / Intranet5 Logique de Hoare ----------------------------------------------------------------- Exemple : V = 17, D = 5 V = 17, D = 5, Q = 0 Q <- 0 ; R <- V ; while R >= D Q <- Q + 1 ; Q <- Q + 1 ; R <- R - D R <- R - D V = 17, D = 5, Q = 0, R = 17 V = 17, D = 5, Q = 1, R = 17 V = 17, D = 5, Q = 1, R = 12 Y a-t-il quelque-chose de commun entre les différentes itérations ? OUI : V = Q * D + R V = 17, D = 5, Q = 2, R = 12 V = 17, D = 5, Q = 2, R = 7

6 19 décembre 2006Cours d'algorithmique 10 / Intranet6 Logique de Hoare ----------------------------------------------------------------- Exemple : V = 17, D = 5 V = 17, D = 5, Q = 0 Q <- 0 ; R <- V ; while R >= D Q <- Q + 1 ; Q <- Q + 1 ; R <- R - D R <- R - D V = 17, D = 5, Q = 0, R = 17 Y a-t-il quelque-chose de commun entre les différentes itérations ? OUI : V = Q * D + R V = 17, D = 5, Q = 2, R = 7 V = 17, D = 5, Q = 3, R = 7 V = 17, D = 5, Q = 3, R = 2 A la fin : V = Q * D + R et R < D

7 19 décembre 2006Cours d'algorithmique 10 / Intranet7 Logique de Hoare ----------------------------------------------------------------- Les valeurs de V, D, Q, R peuvent changer. Les valeurs de V, D, Q, R peuvent changer. Mais la relation V = Q * D + R reste toujours vérifiée. Mais la relation V = Q * D + R reste toujours vérifiée. C’est ce qu’on appelle un « invariant » ! C’est ce qu’on appelle un « invariant » ! Un invariant est un prédicat qui : Un invariant est un prédicat qui : – est vrai à chaque début de boucle, – et à chaque fin de boucle, – c’est-à-dire début de la boucle suivante. (Les tests ne font pas d’affectation !) (Les tests ne font pas d’affectation !)

8 19 décembre 2006Cours d'algorithmique 10 / Intranet8 Logique de Hoare ----------------------------------------------------------------- Pour écrire un corps de boucle, il faut connaître l’invariant de la boucle ! Pour écrire un corps de boucle, il faut connaître l’invariant de la boucle ! Votre code sera exécuté par le « i » tour de boucle, quel que soit la valeur de « i ». Votre code sera exécuté par le « i » tour de boucle, quel que soit la valeur de « i ». Pour savoir ce que vous devez faire au « i » tour de boucle, vous devez vous souvenir de ce que vous avez fait pendant les « i – 1 » premiers tours. Pour savoir ce que vous devez faire au « i » tour de boucle, vous devez vous souvenir de ce que vous avez fait pendant les « i – 1 » premiers tours. Ceci revient à connaître « l’invariant » ! Ceci revient à connaître « l’invariant » ! e e

9 19 décembre 2006Cours d'algorithmique 10 / Intranet9 Logique de Hoare ----------------------------------------------------------------- Quel est l’invariant ? Quel est l’invariant ? Avant le « i » tour de boucle, nous avons fait les tours de boucle de « 1 » à « i – 1 ». Avant le « i » tour de boucle, nous avons fait les tours de boucle de « 1 » à « i – 1 ». Nous avons donc sommé dans « s » les valeurs de « 1 » à « i – 1 ». Nous avons donc sommé dans « s » les valeurs de « 1 » à « i – 1 ». Invariant : s =  j Invariant : s =  j s <- 0 ; i <- 1 ; while ( i <= n ) do s <- s + i ; s <- s + i ; i <- i + 1 i <- i + 1 e j = 1 i – 1

10 19 décembre 2006Cours d'algorithmique 10 / Intranet10 Logique de Hoare ----------------------------------------------------------------- Règle pour le programme while C do  : Règle pour le programme while C do  : Nous dirons que « I » est l’invariant ! Nous dirons que « I » est l’invariant ! La condition { I, C }  { I } vérifie que « I » est bien invariant ! ! ! La condition { I, C }  { I } vérifie que « I » est bien invariant ! ! ! La post-condition { I,  C } est évidente ! La post-condition { I,  C } est évidente ! Il suffit alors que { I } soit vrai au début ! Il suffit alors que { I } soit vrai au début ! { I } while C do  { I,  C } { I, C }  { I }

11 19 décembre 2006Cours d'algorithmique 10 / Intranet11 Logique de Hoare ----------------------------------------------------------------- Dans la pratique, nous avons une post-condition Q et le code while C do  : Dans la pratique, nous avons une post-condition Q et le code while C do  : Quel prédicat « I » faut-il choisir comme invariant ? Quel prédicat « I » faut-il choisir comme invariant ? C’est l’utilisateur qui doit faire une proposition ! C’est l’utilisateur qui doit faire une proposition ! Nouvelle syntaxe : while C do  inv I Nouvelle syntaxe : while C do  inv I { ??? } while C do  { Q } { ???, C }  { ??? }

12 19 décembre 2006Cours d'algorithmique 10 / Intranet12 Logique de Hoare ----------------------------------------------------------------- Règle pour le programme while C do  inv I : Règle pour le programme while C do  inv I : Nous devons prouver que I,  C => Q ! Nous devons prouver que I,  C => Q ! Nous calculons la pré-condition « F » de { F }  { I } ! Nous calculons la pré-condition « F » de { F }  { I } ! Nous prouvons que I, C => F ! Nous prouvons que I, C => F ! A ce moment, nous connaissons la pré-condition « I » ! A ce moment, nous connaissons la pré-condition « I » ! { F }  { I } I, C => F I,  C => Q { I } while C do  inv I { Q }

13 19 décembre 2006Cours d'algorithmique 10 / Intranet13 Logique de Hoare ----------------------------------------------------------------- Règle pour le programme while C do  inv I : Règle pour le programme while C do  inv I : Attention, il y a deux obligations de preuve ! Attention, il y a deux obligations de preuve ! Elles sont semi-automatisables. Elles sont semi-automatisables. Un prouveur peut ne pas trouver la preuve ! Un prouveur peut ne pas trouver la preuve ! Un prouveur ne saura jamais dire si elle n’existe pas ! ! ! Un prouveur ne saura jamais dire si elle n’existe pas ! ! ! { F }  { I } I, C => F I,  C => Q { I } while C do  inv I { Q }

14 19 décembre 2006Cours d'algorithmique 10 / Intranet14 Logique de Hoare ----------------------------------------------------------------- U N P R E M I E R E X E M P L E

15 19 décembre 2006Cours d'algorithmique 10 / Intranet15 Logique de Hoare ----------------------------------------------------------------- POST : POST : R <- V ; Q <- 0 ; while ( R >= D ) do Q <- Q + 1 ; Q <- Q + 1 ; R <- R – D R <- R – D inv I inv I Q = { V = D * Q + R, 0 <= R < D }

16 19 décembre 2006Cours d'algorithmique 10 / Intranet16 Logique de Hoare ----------------------------------------------------------------- POST : POST : R <- V ; Q <- 0 ; while ( R >= D ) do Q <- Q + 1 ; Q <- Q + 1 ; R <- R – D R <- R – D inv I inv I Q = { V = D * Q + R, 0 <= R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } Sans problème : I,  C => Q

17 19 décembre 2006Cours d'algorithmique 10 / Intranet17 Logique de Hoare ----------------------------------------------------------------- POST : POST : R <- V ; Q <- 0 ; while ( R >= D ) do Q <- Q + 1 ; Q <- Q + 1 ; R <- R – D R <- R – D inv I inv I Q = { V = D * Q + R, 0 <= R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } Sans problème : I,  C => Q F = { V = D * Q + R, D <= R } { V = D * Q + R, 0 <= R } { V = D * Q + R – D, 0 <= R – D } Après simplification !

18 19 décembre 2006Cours d'algorithmique 10 / Intranet18 Logique de Hoare ----------------------------------------------------------------- { F }  { I } I,  C => Q { I } while C do  inv I { Q } I, C => F { V = D * Q + R, 0 = D } !!!!!!=> { V = D * Q + R, D <= R }

19 19 décembre 2006Cours d'algorithmique 10 / Intranet19 Logique de Hoare ----------------------------------------------------------------- POST : POST : R <- V ; Q <- 0 ; while ( R >= D ) do Q <- Q + 1 ; Q <- Q + 1 ; R <- R – D R <- R – D inv I inv I Q = { V = D * Q + R, 0 <= R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } et { R < D } = { V = D * Q + R, 0 <= R } Sans problème : I,  C => Q F = { V = D * Q + R, D <= R } { V = D * Q + R, 0 <= R } { V = D * Q + R – D, 0 <= R – D } I = { V = D * Q + R, 0 <= R } Sans problème : I, C => F { V = D * 0 + R, 0 <= R } { V = D * 0 + V, 0 = 0 } PRE : PRE :

20 19 décembre 2006Cours d'algorithmique 10 / Intranet20 Logique de Hoare ----------------------------------------------------------------- U N D E U X I E M E E X E M P L E

21 19 décembre 2006Cours d'algorithmique 10 / Intranet21 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) }

22 19 décembre 2006Cours d'algorithmique 10 / Intranet22 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) } = { pgcd( x, 0 ) = pgcd( a, b ) } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ) } Sans problème : I,  C => Q

23 19 décembre 2006Cours d'algorithmique 10 / Intranet23 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) } = { pgcd( x, 0 ) = pgcd( a, b ) } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ) } Sans problème : I,  C => Q F = { pgcd( y, x % y ) = pgcd( a, b ) } { pgcd( x, y ) = pgcd( a, b ) } { pgcd( m, y ) = pgcd( a, b ) } { pgcd( m, x%y ) = pgcd( a, b ) }

24 19 décembre 2006Cours d'algorithmique 10 / Intranet24 Logique de Hoare ----------------------------------------------------------------- I, C => F { pgcd( x, y ) = pgcd( a, b ) } et { y <> 0 } ???=> { pgcd( y, x % y ) = pgcd( a, b ) } ? ? ? Maths : x >= y et y <> 0 => pgcd( x, y ) = pgcd( y, x % y ) Nous devons renforcer l’invariant : { pgcd( x, y ) = pgcd( a, b ), x >= y }

25 19 décembre 2006Cours d'algorithmique 10 / Intranet25 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) } = { pgcd( x, 0 ) = pgcd( a, b ) } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), x >= y } Sans problème : I,  C => Q

26 19 décembre 2006Cours d'algorithmique 10 / Intranet26 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) } = { pgcd( x, 0 ) = pgcd( a, b ) } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } Sans problème : I,  C => Q F = { pgcd( y, x % y ) = pgcd( a, b ) } { pgcd( x, y ) = pgcd( a, b ), x >= y } {..., m >= y } {..., m >= x % y } = { pgcd( x, y ) = pgcd( a, b ), x >= y }

27 19 décembre 2006Cours d'algorithmique 10 / Intranet27 Logique de Hoare ----------------------------------------------------------------- I, C => F { pgcd( x, y ) = pgcd( a, b ), x >= y } et { y <> 0 } !!!!!!=> { pgcd( y, x % y ) = pgcd( a, b ) } Maths : x >= y et y <> 0 => pgcd( x, y ) = pgcd( y, x % y )

28 19 décembre 2006Cours d'algorithmique 10 / Intranet28 Logique de Hoare ----------------------------------------------------------------- x <- a ; y <- b ; while ( y <> 0 ) do m <- y ; m <- y ; y <- x % y ; y <- x % y ; x <- m x <- m inv I inv I POST : POST : Q = { x = pgcd( a, b ) } = { pgcd( x, 0 ) = pgcd( a, b ) } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } = { pgcd( x, y ) = pgcd( a, b ), y = 0 } Sans problème : I,  C => Q F = { pgcd( y, x % y ) = pgcd( a, b ) } { pgcd( x, y ) = pgcd( a, b ), x >= y } {..., m >= y } {..., m >= x % y } Sans problème : I, C => F I = { pgcd( x, y ) = pgcd( a, b ), x >= y } { pgcd( a, b ) = pgcd( a, b ), a >= b } = { a >= b } PRE : PRE : = { pgcd( x, y ) = pgcd( a, b ), x >= y }

29 19 décembre 2006Cours d'algorithmique 10 / Intranet29 Logique de Hoare ----------------------------------------------------------------- U N T R O I S I E M E E X E M P L E

30 19 décembre 2006Cours d'algorithmique 10 / Intranet30 Logique de Hoare ----------------------------------------------------------------- s <- 0 ; c <- 1 ; while ( c <= n ) do s <- s + c ; s <- s + c ; c <- c + 1 c <- c + 1 inv I inv I POST : POST : i = 1 c – 1 = { c <= n + 1, s =  i } Sans problème : I,  C => Q Q = { s =  i } = { s =  i, c n } i = 1 n c – 1

31 19 décembre 2006Cours d'algorithmique 10 / Intranet31 Logique de Hoare ----------------------------------------------------------------- s <- 0 ; c <- 1 ; while ( c <= n ) do s <- s + c ; s <- s + c ; c <- c + 1 c <- c + 1 inv I inv I POST : POST : i = 1 c – 1 = { c <= n + 1, s =  i } Sans problème : I,  C => Q Q = { s =  i } = { s =  i, c n } i = 1 n c – 1 F = { c <= n, s =  i } I =... i = 1 c – 1 Après simplification !

32 19 décembre 2006Cours d'algorithmique 10 / Intranet32 Logique de Hoare ----------------------------------------------------------------- s <- 0 ; c <- 1 ; while ( c <= n ) do s <- s + c ; s <- s + c ; c <- c + 1 c <- c + 1 inv I inv I POST : POST : i = 1 c – 1 = { c <= n + 1, s =  i } Sans problème : I,  C => Q Q = { s =  i } = { s =  i, c n } i = 1 n c – 1 F = { c <= n, s =  i } I =... i = 1 c – 1 Sans problème : I, C => F

33 19 décembre 2006Cours d'algorithmique 10 / Intranet33 Logique de Hoare ----------------------------------------------------------------- s <- 0 ; c <- 1 ; while ( c <= n ) do s <- s + c ; s <- s + c ; c <- c + 1 c <- c + 1 inv I inv I POST : POST : i = 1 c – 1 = { c <= n + 1, s =  i } Sans problème : I,  C => Q Q = { s =  i } = { s =  i, c n } i = 1 n c – 1 F = { c <= n, s =  i } I =... i = 1 c – 1 Sans problème : I, C => F i = 1 c – 1 I = { c <= n + 1, s =  i } i = 1 1 – 1 { 1 = 0 } PRE : PRE :

34 19 décembre 2006Cours d'algorithmique 10 / Intranet34 Logique de Hoare ----------------------------------------------------------------- s <- 1 ; c <- 2 ; while ( c <= n ) do...... i = 1 c – 1 I = { c <= n + 1, s =  i } i = 1 2 – 1 { 2 = 1 } PRE : PRE : Une autre initialisation : Une autre initialisation : POST : POST : Q = { s =  i } i = 1 n

35 19 décembre 2006Cours d'algorithmique 10 / Intranet35 Logique de Hoare ----------------------------------------------------------------- s <- 6 ; c <- 2 ; while ( c <= n ) do...... i = 1 c – 1 I = { c <= n + 1, s =  i } i = 1 2 – 1 { 2 = 1, 6 = 1 } = { FAUX } PRE : PRE : Une mauvaise initialisation : Une mauvaise initialisation : POST : POST : Q = { s =  i } i = 1 n

36 19 décembre 2006Cours d'algorithmique 10 / Intranet36 Logique de Hoare ----------------------------------------------------------------- s <- 6 ; c <- 2 ; while ( c <= n ) do...... i = 1 c – 1 I = { c <= n + 1, s =  i } i = 1 2 – 1 { 2 = 1, 6 = 1 } = { n >= 1 } PRE : PRE : Une mauvaise initialisation : Une mauvaise initialisation : POST : POST : Q = { s =  i } i = 1 n

37 19 décembre 2006Cours d'algorithmique 10 / Intranet37 Logique de Hoare ----------------------------------------------------------------- s <- 6 ; c <- 2 ; while ( c <= n ) do...... i = 1 c – 1 I = { c <= n + 1, s =  i } i = 1 2 – 1 { 2 = 1, 6 = 1 } = { n >= 3 } PRE : PRE : Une mauvaise initialisation : Une mauvaise initialisation : POST : POST : Q = { s =  i } i = 1 n

38 19 décembre 2006Cours d'algorithmique 10 / Intranet38 POST : POST : Logique de Hoare ----------------------------------------------------------------- Un mauvais invariant : Un mauvais invariant : Q = { s =  i } = { s =  i, c n } i = 1 n... while ( c <= n ) do s <- s + c + 3 ; s <- s + c + 3 ; c <- c + 1 c <- c + 1 inv I inv I i = 1 c – 1 = { c <= n + 1, s =  i } i = 1 c – 1 Sans problème : I,  C => Q

39 19 décembre 2006Cours d'algorithmique 10 / Intranet39 POST : POST : Logique de Hoare ----------------------------------------------------------------- Un mauvais invariant : Un mauvais invariant : Q = { s =  i } = { s =  i, c n } i = 1 n... while ( c <= n ) do s <- s + c + 3 ; s <- s + c + 3 ; c <- c + 1 c <- c + 1 inv I inv I i = 1 c – 1 = { c <= n + 1, s =  i } i = 1 c – 1 I =... F = { c <= n, s + 3 =  i } i = 1 c – 1 Après simplification ! Sans problème : I,  C => Q

40 19 décembre 2006Cours d'algorithmique 10 / Intranet40 Logique de Hoare ----------------------------------------------------------------- I, C => F { c <= n + 1, s =  i } et { c <= n } NON=> { c <= n + 1, s + 3 =  i } i = 1 c – 1 i = 1 c – 1 // Sinon, nous aurions 3 = 0 !

41 19 décembre 2006Cours d'algorithmique 10 / Intranet41 POST : POST : Logique de Hoare ----------------------------------------------------------------- Un mauvais invariant : Un mauvais invariant : Q = { s =  (i + 3) } = { s =  (i + 3), c <= n + 1, c > n } c > n } i = 1 n... while ( c <= n ) do s <- s + c + 3 ; s <- s + c + 3 ; c <- c + 1 c <- c + 1 inv I inv I i = 1 c – 1 = { c <= n + 1, s =  (i + 3) } i = 1 c – 1 Sans problème : I,  C => Q I =... F = { c <= n, s =  (i + 3) } i = 1 c – 1 Après simplification ! Sans problème : I, C => F

42 19 décembre 2006Cours d'algorithmique 10 / Intranet42 Logique de Hoare ----------------------------------------------------------------- Attention : Attention : Tout ceci n’empêche pas un programme de boucler ! Tout ceci n’empêche pas un programme de boucler ! Nous affirmons seulement que Nous affirmons seulement que – si le programme s’arrête, – alors il rend le résultat indiqué !