Algorithmique et Analyse d'Algorithmes - L3 Info Cours 3 ......AlgorithmiqueetAnalysed’Algorithmes...

Algorithmique et Analyse d’Algorithmes

Algorithmique et Analyse d’AlgorithmesL3 Info

Cours 3 : preuve d’algorithmes

Benjamin Wack

2020 – 2021

1 / 34


La dernière foisI Écriture d’algorithmes récursifsI Coût d’un algorithme récursifI Complexité en moyenneI Tri rapide

Aujourd’hui

I Invariant, précondition, postconditionI Spécification et correction d’un algorithmeI Terminaison d’un algorithmeI Drapeau Hollandais

2 / 34


Plan

Preuve de correction d’un algorithmeSpécification formelleAnnotations de programmes

Terminaison d’un algorithme

Drapeau HollandaisLe problème et l’algorithmeAnalyse de l’algorithme

3 / 34

Algorithmique et Analyse d’AlgorithmesPreuve de correction d’un algorithme

Spécification formelle

Plan




4 / 34



Les besoinsI Quantité astronomique de code en circulation ou en développement

(Google Chrome ou serveur World of Warcraft : 6 M lignes)(Windows 7 ou Microsoft Office 2013 : 40 M lignes)

http://www.informationisbeautiful.net

I Omniprésence dans des systèmes critiques : finance, transports,économie, santé...

I Il faut pouvoir prouver qu’un programme s’exécute correctementdans toutes les situations

Mais correct selon quels critères ? Quelles situations à considérer ?I Spécification

I des données acceptablesI du résultat attendu (généralement en fonction des données)

I exprimée dans un langage formel, généralement une propriétélogique des données et du résultat.

I ne décrit pas comment fonctionne le programme.

5 / 34









Mais correct selon quels critères ? Quelles situations à considérer ?

I SpécificationI des données acceptablesI du résultat attendu (généralement en fonction des données)



5 / 34









Mais correct selon quels critères ? Quelles situations à considérer ?I Spécification

I des données acceptablesI du résultat attendu (généralement en fonction des données)



5 / 34




Les propriétés recherchées

TerminaisonL’exécution de l’algorithme produit-elle un résultat en temps fini quellesque soient les données fournies ?

Correction partielleLorsque l’algorithme s’arrête, le résultat calculé est-il la solutioncherchée quelles que soient les données fournies ?

Terminaison + correction partielle = correction totaleQuelles que soient les données fournies, l’algorithme s’arrête et donne uneréponse correcte.

Pour certains problèmes il n’existe que des algorithmes partiellementcorrects !

6 / 34



Une première écriture formelle

Soit un problème instancié par une donnée D et dont la réponse estfournie par un résultat R.

Une spécification peut être donnée sous la forme de :I une propriété P(D) de la donnée (précondition) ;I une propriété Q(D,R) de la donnée et du résultat (postcondition).

Un programme satisfait cette spécification si :

Pour toute donnée D qui vérifie la propriété P,l’exécution du programme donne un résultat R qui vérifie Q.

Le programme est alors dit correct par rapport à cette spécification.

7 / 34



Division euclidienne

Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par br := aq := 0while r ≥ b

r := r − bq := q + 1

return q, r

8 / 34





r := r − bq := q + 1

return q, r

Données acceptables

I b 6= 0 sinon le problème n’a pas de sens (et la boucle non plus)I b > 0 ( ?)I a > 0 ( ?)

8 / 34





r := r − bq := q + 1

return q, r


I b 6= 0 sinon le problème n’a pas de sens (et la boucle non plus)

I b > 0 ( ?)I a > 0 ( ?)

8 / 34





r := r − bq := q + 1

return q, r


I b 6= 0 sinon le problème n’a pas de sens (et la boucle non plus)I b > 0 ( ?)

I a > 0 ( ?)

8 / 34





r := r − bq := q + 1

return q, r


I b 6= 0 sinon le problème n’a pas de sens (et la boucle non plus)I b > 0 ( ?)I a > 0 ( ?)

8 / 34





r := r − bq := q + 1

return q, r

Résultat attendu

I a = q × b + rI 0 ≤ r < bI a et b inchangés

8 / 34





r := r − bq := q + 1

return q, r

Résultat attenduI a = q × b + r

I 0 ≤ r < bI a et b inchangés

8 / 34





r := r − bq := q + 1

return q, r

Résultat attenduI a = q × b + rI 0 ≤ r < b

I a et b inchangés

8 / 34





r := r − bq := q + 1

return q, r

Résultat attenduI a = q × b + rI 0 ≤ r < bI a et b inchangés

8 / 34


Annotations de programmes

Plan




9 / 34



Notion d’invariant

Idée de la démonstration d’un algorithmeDe proche en proche, établir que la postcondition est vraie à chaque foisque la précondition est vraie.

(Interlude : tour de cartes)

I Affectation, séquence, condition :pas de vrai problème si la spécification est correctement écrite.

I Problème : la boucle(peut recevoir ses données d’une itération précédente)

InvariantUn invariant est une propriété P des variables en début de boucle telleque

si P est vérifiée à une itération, alors elle l’est à l’itération suivante.

10 / 34



Méthodologie

1. Choisir et exprimer un invariant judicieux

Pas de méthode systématique2. Démontrer qu’il est vérifié avant d’entrer dans la boucle

Utiliser les préconditions

3. Démontrer que s’il est vérifié au début d’une itération quelconque,il l’est aussi au début de l’itération suivante.

Utiliser le corps de la boucleOn note x’ la valeur de x en fin de boucle

4. Instancier l’invariant en sortie de boucle et en déduire unepostcondition.

Utiliser (la négation de) la condition du while

11 / 34



Méthodologie


Pas de méthode systématique

2. Démontrer qu’il est vérifié avant d’entrer dans la boucle

Utiliser les préconditions3. Démontrer que s’il est vérifié au début d’une itération quelconque,

il l’est aussi au début de l’itération suivante.




11 / 34



Méthodologie


Pas de méthode systématique







11 / 34



Méthodologie

1. Choisir et exprimer un invariant judicieuxPas de méthode systématique







11 / 34



Méthodologie

1. Choisir et exprimer un invariant judicieuxPas de méthode systématique

2. Démontrer qu’il est vérifié avant d’entrer dans la boucleUtiliser les préconditions





11 / 34



Annotation de la division euclidienne

Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par b

Précondition : a ≥ 0 et b > 0

r := aq := 0while r ≥ b

{invariant : a = b× q + r}

r := r − bq := q + 1

ßb× q′ + r′ = b× (q + 1) + (r− b) = b× q + b− b + r = b× q + r

et par hypothèse de l’invariant b× q + r = a

™

return q, r

Postconditions : a = b× q + r0 ≤ r < b

←− (reste à démontrer)

a et b inchangés


12 / 34




Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par b

Précondition : a ≥ 0 et b > 0

r := aq := 0while r ≥ b


r := r − bq := q + 1



™

return q, rPostconditions : a = b× q + r

0 ≤ r < b


a et b inchangés


12 / 34




Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par bPrécondition : a ≥ 0 et b > 0r := aq := 0while r ≥ b


r := r − bq := q + 1



™


0 ≤ r < b


a et b inchangés


12 / 34




Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par bPrécondition : a ≥ 0 et b > 0r := aq := 0while r ≥ b {invariant : a = b× q + r}

r := r − bq := q + 1



™


0 ≤ r < b


a et b inchangés


12 / 34





r := r − bq := q + 1ß

b× q′ + r′ = b× (q + 1) + (r− b) = b× q + b− b + r = b× q + r


™return q, rPostconditions : a = b× q + r

0 ≤ r < b


a et b inchangés


12 / 34





r := r − bq := q + 1ß

b× q′ + r′ = b× (q + 1) + (r− b) = b× q + b− b + r = b× q + ret par hypothèse de l’invariant b× q + r = a


0 ≤ r < b


a et b inchangés


12 / 34





r := r − bq := q + 1ß

b× q′ + r′ = b× (q + 1) + (r− b) = b× q + b− b + r = b× q + ret par hypothèse de l’invariant b× q + r = a


0 ≤ r < b ←− (reste à démontrer)a et b inchangés ←− (reste à démontrer)

12 / 34



Exercice

Quel(s) programme(s) calcule(nt) la factorielle de n dans la variable F ?Ai := 0F := 1while i



Programme A

i := 0F := 1while i



Programme A

i := 0F := 1 {F = 1 = 0! = i! }while i



Programme B!

i := 0F := 1while i < n

i := i + 1F := F * i

Invariant

F = i!

15 / 34



Programme B!

i := 0F := 1 {F = 1 = 0! = i!}while i < n

i := i + 1F := F * i

Invariant

F = i!

15 / 34



Programme B!

i := 0F := 1 {F = 1 = 0! = i!}while i < n

{F = i!}i := i + 1F := F * i

Invariant

F = i!

15 / 34



Programme B!

i := 0F := 1 {F = 1 = 0! = i!}while i < n

{F = i!}i := i + 1F := F * i {F ′ = F ∗ i ′ = i! ∗ (i + 1) = (i + 1)! donc F ′ = i ′!}

Invariant

F = i!

15 / 34



Programme B!

i := 0F := 1 {F = 1 = 0! = i!}while i < n

{F = i!}i := i + 1F := F * i {F ′ = F ∗ i ′ = i! ∗ (i + 1) = (i + 1)! donc F ′ = i ′!}

Invariant

F = i!

En sortie de boucle {i = n d’où F = n!}

15 / 34



Programme C !

i := 1F := 1while i



Programme C !

i := 1F := 1 {F = 1 = 0! = (1− 1)! = (i − 1)!}while i



Programme D

i := 0F := 1while i < n

F := F * ii := i + 1

Invariant

F = (i − 1)! correctement propagé par la bouclemais faux à l’entrée de la boucle : NON

En réalité on a toujours F = 0 après la 1è itération.

17 / 34



Programme D

i := 0F := 1while i < n

F := F * ii := i + 1

InvariantF = (i − 1)!

correctement propagé par la bouclemais faux à l’entrée de la boucle : NON


17 / 34



Programme D

i := 0F := 1while i < n

F := F * ii := i + 1

InvariantF = (i − 1)! correctement propagé par la boucle

mais faux à l’entrée de la boucle : NON


17 / 34

Algorithmique et Analyse d’AlgorithmesTerminaison d’un algorithme

Plan




18 / 34


Correction partielle ou totale

Correction partiellePour toute donnée D qui vérifie la précondition P,

si le programme se termine,alors son exécution donne un résultat R qui vérifie la postcondition Q.

Correction totalePour toute donnée D qui vérifie la précondition P,

l’exécution du programme se termineet donne un résultat R qui vérifie la postcondition Q.

SI correction partielle ET terminaison ALORS correction totale

19 / 34


Variant de boucle

Variant de boucleUn variant de boucle est une expression :I entièreI positiveI qui décroît strictement à chaque itération

Variants usuelsI i pour une boucle du type for i = n downto 1I n − i pour une boucle du type for i = 1 to nI j − i pour deux variables i croissante et j décroissanteI . . .I mais pas de technique « systématique »

20 / 34


Variant de la division euclidienne

Division par soustractionsDIV(a, b)Données : Deux entiers a et bRésultat : Le quotient q et le reste r de la division euclidienne de a par bPrécondition : a ≥ 0 et b > 0r := aq := 0while r ≥ b

r := r − bq := q + 1

return q, r

r est clairement un variant de boucleI il est entierI il décroît strictement à chaque itération (car b > 0)I il est toujours positif (car b > 0 et condition du while)

21 / 34


Les difficultés

Précondition et postconditionI généralement faciles à écrire si le problème est correctement spécifiéI éventuellement nécessaire de renforcer la précondition si la preuve

n’aboutit pasI attention aux postconditions trop faibles (exemple du tri)

InvariantsI incluent souvent une généralisation de la postconditionI demandent une compréhension fine de l’algorithmeI les trouver peut même précéder l’écriture de l’algorithme

VariantsI souvent immédiats, mais des cas particuliers très difficilesI nécessitent parfois de s’appuyer sur les autres assertions

22 / 34

Algorithmique et Analyse d’AlgorithmesDrapeau Hollandais

Le problème et l’algorithme

Plan




23 / 34



Le drapeau hollandais (1976)E.W. Dijkstra (1930-2002)I un des fondateurs de la science informatiqueI algorithme de recherche de plus court cheminI pile de récursivité pour ALGOL-60I Turing Award 1972

Tableau de n éléments, chacun coloré en bleu, blanc ou rouge.Objectif : réorganiser le tableau pour que :I les éléments bleus soient sur la partie gaucheI les éléments blancs au centreI les rouges en fin de tableau

1 2 3 4 5 6 7 81 2 3 4 5 6 7 8

EBB EA C F C AF H GG H DD

Contrainte : utiliser un minimum de mémoire supplémentaire (en place)

24 / 34



Le drapeau hollandais (1976)E.W. Dijkstra (1930-2002)I un des fondateurs de la science informatiqueI algorithme de recherche de plus court cheminI pile de récursivité pour ALGOL-60I Turing Award 1972

Tableau de n éléments, chacun coloré en bleu, blanc ou rouge.Objectif : réorganiser le tableau pour que :I les éléments bleus soient sur la partie gaucheI les éléments blancs au centreI les rouges en fin de tableau

1 2 3 4 5 6 7 81 2 3 4 5 6 7 8

EBB EA C F C AF H GG H DD

Contrainte : utiliser un minimum de mémoire supplémentaire (en place)24 / 34



Les trois casTrois indices mémorisant où placer le prochain élément de chaque couleur

I Cas où E est bleu

1 2 5 6 7 843 1 2 3 4 5 6 7 8

Blanc BlancBleu Rouge Bleu Rouge

C D E F G H B A C D E F G H B A

I Cas où E est blanc

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8


C E F G H B A C D G F E H B AD

I Cas où E est rouge

876543211 2 3 4 5 6 7 8

BlancBlanc Bleu RougeRougeBleu

2

1

C D E F G H A C D G F B EH AB

25 / 34



Les trois casTrois indices mémorisant où placer le prochain élément de chaque couleurI Cas où E est bleu

1 2 5 6 7 843 1 2 3 4 5 6 7 8


C D E F G H B A C D E F G H B A

I Cas où E est blanc

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8


C E F G H B A C D G F E H B AD

I Cas où E est rouge

876543211 2 3 4 5 6 7 8

BlancBlanc Bleu RougeRougeBleu

2

1

C D E F G H A C D G F B EH AB

25 / 34



L’algorithmeDRAPEAU(T)

Données : Un tableau T de N éléments colorés (bleu, blanc ou rouge)Résultat : T contient les mêmes éléments rangés par couleur croissanteibleu = 1iblanc = N // ik est l’indice de la place duirouge = N // prochain élément de couleur kwhile ibleu ≤ iblanc

switch Couleur (T [ibleu]) docase bleu do

ibleu = ibleu + 1 // l’élément est en placecase blanc do

Échange (ibleu, iblanc) // on le place en bonne positioniblanc = iblanc − 1

case rouge doÉchange (ibleu, iblanc) // permutation circulaireÉchange (iblanc , irouge) // pour libérer une caseiblanc = iblanc − 1 ; irouge = irouge − 1

26 / 34


Analyse de l’algorithme

Plan




27 / 34



Complexité

I Nombre d’appels à la fonction Couleur = nombre d’itérations = N

CoûtCouleur(N) = N

On évalue la couleur de chaque élément une et une seule fois.

I Nombre d’appels à la fonction Échange = somme du nombred’échanges réalisés à chaque itération (0, 1 ou 2) :

0 ≤ CoûtÉchange(N) ≤ 2N.

I Cas favorable = tableau rempli d’éléments bleusI Cas défavorable = tableau rempli d’éléments rouges

La complexité de l’algorithme en nombre d’échanges est donc au pire enO(N) et au mieux en O(1).Et en moyenne ? Ça dépend de la distribution des données !

28 / 34



Complexité


CoûtCouleur(N) = N

On évalue la couleur de chaque élément une et une seule fois.I Nombre d’appels à la fonction Échange = somme du nombre

d’échanges réalisés à chaque itération (0, 1 ou 2) :




28 / 34



Complexité


CoûtCouleur(N) = N





La complexité de l’algorithme en nombre d’échanges est donc au pire enO(N) et au mieux en O(1).

Et en moyenne ? Ça dépend de la distribution des données !

28 / 34



Complexité


CoûtCouleur(N) = N





La complexité de l’algorithme en nombre d’échanges est donc au pire enO(N) et au mieux en O(1).Et en moyenne ?

Ça dépend de la distribution des données !

28 / 34



Complexité


CoûtCouleur(N) = N






28 / 34



Éléments de démonstration

ibleu = 1 ; iblanc = N ; irouge = Nwhile ibleu ≤ iblanc


ibleu = ibleu + 1case blanc do

Échange (ibleu, iblanc)iblanc = iblanc − 1

case rouge doÉchange (ibleu, irouge)Échange (ibleu, iblanc)iblanc = iblanc − 1 ; irouge = irouge − 1

Terminaison :

iblanc − ibleu est un variant acceptable

I À chaque itération ibleu augmente (cas 1) ou iblanc diminue (cas 2 et3).

I La condition du while assure que ibleu ≤ iblanc .

29 / 34









Terminaison :

iblanc − ibleu est un variant acceptable


I La condition du while assure que ibleu ≤ iblanc . 29 / 34









Terminaison : iblanc − ibleu est un variant acceptable


I La condition du while assure que ibleu ≤ iblanc . 29 / 34








Invariant de boucle

I T contient une permutation des éléments du tableau initial.I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de iblanc + 1 à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge.

30 / 34








Invariant de boucleI T contient une permutation des éléments du tableau initial.

I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de iblanc + 1 à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge.

30 / 34








Invariant de boucleI T contient une permutation des éléments du tableau initial.I Les éléments de 1 à ibleu − 1 sont de couleur bleu.

I Les éléments de iblanc + 1 à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge.

30 / 34








Invariant de boucleI T contient une permutation des éléments du tableau initial.I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de iblanc + 1 à irouge sont de couleur blanc.

I Les éléments de irouge + 1 à N sont de couleur rouge.

30 / 34








Invariant de boucleI T contient une permutation des éléments du tableau initial.I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de iblanc + 1 à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge. 30 / 34



Démonstration

Préservation des éléments du tableauGarantie par l’utilisation exclusive de la procédure Échange.

(mais cette propriété doit faire partie de la spécification de Échange !)

Rangement des couleurs

I À l’entrée dans la boucle cette propriété ne concerne aucun élément.(donc elle est vraie !)

I Au cours d’une itération :cas 1 : un élément bleu est placé, les autres sont inchangéscas 2 : un élément blanc est placé, les autres sont inchangéscas 3 : un élément rouge est placé, les éléments blanc sont

décalés, les autres sont inchangésI En sortie de boucle iblanc = ibleu − 1 donc :

I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de ibleu à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge.

31 / 34



Démonstration






décalés, les autres sont inchangés

I En sortie de boucle iblanc = ibleu − 1 donc :I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de ibleu à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge.

31 / 34



Démonstration






décalés, les autres sont inchangésI En sortie de boucle iblanc = ibleu − 1 donc :

I Les éléments de 1 à ibleu − 1 sont de couleur bleu.I Les éléments de ibleu à irouge sont de couleur blanc.I Les éléments de irouge + 1 à N sont de couleur rouge. 31 / 34



Variantes

Même problème avec :I 2 couleurs seulement

(c’est Partition pour le tri rapide)I plus de 3 couleurs (cf TD2)

Tri rapide avec plusieurs pivots :I Remplacer Partition par le « drapeau » appropriéI Autant d’appels récursifs que de sous-tableaux formésI Mais au final pas de gain (voire une perte) d’efficacité

32 / 34



Variantes

Même problème avec :I 2 couleurs seulement (c’est Partition pour le tri rapide)

I plus de 3 couleurs (cf TD2)


32 / 34



Variantes

Même problème avec :I 2 couleurs seulement (c’est Partition pour le tri rapide)I plus de 3 couleurs

(cf TD2)


32 / 34



Variantes

Même problème avec :I 2 couleurs seulement (c’est Partition pour le tri rapide)I plus de 3 couleurs (cf TD2)


32 / 34



Variantes


Tri rapide avec plusieurs pivots :

I Remplacer Partition par le « drapeau » appropriéI Autant d’appels récursifs que de sous-tableaux formésI Mais au final pas de gain (voire une perte) d’efficacité

32 / 34



Variantes


Tri rapide avec plusieurs pivots :I Remplacer Partition par le « drapeau » approprié

I Autant d’appels récursifs que de sous-tableaux formésI Mais au final pas de gain (voire une perte) d’efficacité

32 / 34



Variantes


Tri rapide avec plusieurs pivots :I Remplacer Partition par le « drapeau » appropriéI Autant d’appels récursifs que de sous-tableaux formés

I Mais au final pas de gain (voire une perte) d’efficacité

32 / 34



Variantes



32 / 34



En résumé

Aujourd’hui

I Un algorithme est démontré correct par rapport à unespécification

I Un invariant est une propriété préservée par une boucle, utile pourdémontrer la correction de l’algorithme

I Un variant est une quantité qui décroît à chaque itération d’uneboucle et assure sa terminaison

I Drapeau hollandais

La prochaine fois

I Logique de HoareI Annotation de programmes

33 / 34



Test ou preuve ?

“Testing shows the presence, not the absence of bugs”E. W. Dijkstra

Le test :I valide une implantation plutôt qu’un algorithmeI permet rapidement d’éliminer des « bugs »I peut être utilisé en cours de développementI fait apparaître les limites du modèle

La preuve :I fournit une garantie incontestable sur le fond de l’algorithmeI mais n’élimine pas (complètement) les erreurs de programmationI nécessite des outils formels pour une utilisation à grande échelle

34 / 34



Test ou preuve ?

“Testing shows the presence, not the absence of bugs”E. W. Dijkstra

Le test :I valide une implantation plutôt qu’un algorithmeI permet rapidement d’éliminer des « bugs »I peut être utilisé en cours de développementI fait apparaître les limites du modèle

La preuve :I fournit une garantie incontestable sur le fond de l’algorithmeI mais n’élimine pas (complètement) les erreurs de programmationI nécessite des outils formels pour une utilisation à grande échelle

34 / 34

Preuve de correction d'un algorithmeTerminaison d'un algorithmeDrapeau Hollandais

Algorithmique et Analyse d'Algorithmes - L3 Info Cours 3 ......AlgorithmiqueetAnalysed’Algorithmes...

Documents

Transcript of Algorithmique et Analyse d'Algorithmes - L3 Info Cours 3 ......AlgorithmiqueetAnalysed’Algorithmes...