Cours d'algorithmique 9 - Intranet 1 12 décembre 2006 Cours dAlgorithmique Logique de Hoare...

Cours d'algorithmique 9 - IntranetCours d'algorithmique 9 - Intranet 1112 décembre 200612 décembre 2006

Cours d’AlgorithmiqueCours d’Algorithmique

Logique de Hoare (début) :Logique de Hoare (début) :

Principes etPrincipes et

constructions élémentaires.constructions élémentaires.

12 décembre 200612 décembre 2006 Cours d'algorithmique 9 - IntranetCours d'algorithmique 9 - Intranet 22

• Trier et chercher, recherche textuelleTrier et chercher, recherche textuelle• Listes et arbresListes et arbres• Le back-trackLe back-track• Arbres équilibrésArbres équilibrés• Récursivité et induction sur la structureRécursivité et induction sur la structure• Divide and conquer, algorithmes gloutonsDivide and conquer, algorithmes gloutons• Minimax, alpha-betaMinimax, alpha-beta• DérécursionDérécursion• Divers problèmes particuliersDivers problèmes particuliers• Logique de HoareLogique de Hoare• Programmation dynamiqueProgrammation dynamique• Complexité et calculabilitéComplexité et calculabilité

Les grandes lignes du coursLes grandes lignes du cours


Logique de HoareLogique de Hoare----------------------------------------------------------------------------------------------------------------------------------

• Logique de Hoare !Logique de Hoare !

• Plus faibles pré-conditions de Dijkstra !Plus faibles pré-conditions de Dijkstra !





• Objectif :Objectif :

– Raisonnement formel sur la correction d’un Raisonnement formel sur la correction d’un programme !programme !





• Objectif :Objectif :

– Raisonnement formel sur la correction d’un programme !Raisonnement formel sur la correction d’un programme !

• Cadre :Cadre :

– Spécifications formelles.Spécifications formelles.

– Génie logiciel.Génie logiciel.



• Indispensable dans certains cas (lois européennes) !Indispensable dans certains cas (lois européennes) !

• Transport, nucléaire, … !Transport, nucléaire, … !



• Indispensable dans certains cas (lois européennes) !Indispensable dans certains cas (lois européennes) !

• Transport, nucléaire, … !Transport, nucléaire, … !

• Il faut :Il faut :

– fournir une preuve formelle de la correction du fournir une preuve formelle de la correction du programme !programme !

• On peut :On peut :

– utiliser des outils comme « Atelier B » !utiliser des outils comme « Atelier B » !



• Analyse de programmes :Analyse de programmes :

ProgrammeProgramme




ProgrammeProgramme

Que fait-il ?Que fait-il ?




ProgrammeProgramme

• Construction d’un programme :Construction d’un programme :

Ce qu’il doit faire ! (cahier des charges)Ce qu’il doit faire ! (cahier des charges)





ProgrammeProgramme

• Construction d’un programme :Construction d’un programme :

Ce qu’il doit faire ! (cahier des charges)Ce qu’il doit faire ! (cahier des charges)


ProgrammeProgramme



• Une Une spécification formellespécification formelle est un est un

cahier de charges formel (des définitions cahier de charges formel (des définitions précises).précises).




cahier de charges formel (des définitions cahier de charges formel (des définitions précises).précises).

• Elle donneElle donne

– les les pré-conditions, notées PRE, pré-conditions, notées PRE, qui sont les conditions qui sont les conditions

vérifiées par vérifiées par les arguments en entréeles arguments en entrée,,




cahier de charges formel (des définitions précises).cahier de charges formel (des définitions précises).

• Elle donneElle donne

– les les pré-conditions, notées PRE, pré-conditions, notées PRE, qui sont les conditions qui sont les conditions

vérifiées par vérifiées par les arguments en entréeles arguments en entrée,,

– les les post-conditions, notées POST, post-conditions, notées POST, qui sont les conditions qui sont les conditions

vérifiées par vérifiées par les résultats en sortieles résultats en sortie..



• Un exemple :Un exemple :

– PRE : ENTREE , DIV PRE : ENTREE , DIV N N

– POST: POST: QUO , RESTE QUO , RESTE N N

telles ENTREE = QUO * DIV + RESTEtelles ENTREE = QUO * DIV + RESTE et RESTE < DIV .et RESTE < DIV .

II

II







– C’est la spécification de la division euclidienne !C’est la spécification de la division euclidienne !

II

II







– C’est la spécification de la division euclidienne !C’est la spécification de la division euclidienne !

– Nous savons ce qu’il faut faire !Nous savons ce qu’il faut faire !

– Nous ne savons pas encore comment faire ?Nous ne savons pas encore comment faire ?

II

II



• Ensuite, nous construisons un Ensuite, nous construisons un programmeprogramme tel que tel que

{ PRE } { PRE } programme programme { POST }{ POST }





• Ceci signifie queCeci signifie que

– si les si les pré-conditionspré-conditions sont vérifiées par sont vérifiées par les argumentsles arguments,,

– alors les alors les post-conditions post-conditions seront vérifiées par seront vérifiées par les les résultatsrésultats..







– alors les alors les post-conditions post-conditions seront vérifiées par seront vérifiées par les les résultatsrésultats..

• Ce lien est fait à l’aide de la logique de Hoare !Ce lien est fait à l’aide de la logique de Hoare !







– alors les alors les post-conditions post-conditions seront vérifiées par seront vérifiées par les résultatsles résultats..

• Ce lien est fait à l’aide de la logique de Hoare !Ce lien est fait à l’aide de la logique de Hoare !

• Et si les pré-conditions ne sont pas vérifiées ? ? ? ? ?Et si les pré-conditions ne sont pas vérifiées ? ? ? ? ?



• Si la pré-condition n’est pas vérifiée, le programme Si la pré-condition n’est pas vérifiée, le programme peutpeut




– provoquer une erreur (segmentation fault, … ),provoquer une erreur (segmentation fault, … ),





– boucler,boucler,






– répondre n’importe quoi,répondre n’importe quoi,







– répondre correctement, malgré tout !répondre correctement, malgré tout !



• Si la pré-condition n’est pas vérifiée, le programme peutSi la pré-condition n’est pas vérifiée, le programme peut





• Sage précaution :Sage précaution :

– Testons la validité des arguments et générons des messages Testons la validité des arguments et générons des messages d’erreur s’il le faut !d’erreur s’il le faut !

– Ce sont les « assert » !Ce sont les « assert » !



• DansDans


nous avons en faitnous avons en fait

PRE => POSTPRE => POST (l’implication logique) ! (l’implication logique) !



• DansDans




• Rappels :Rappels :

A => B « Tous les A sont B » !A => B « Tous les A sont B » !



• DansDans






AA

BBA A : : ceux qui vérifient A.ceux qui vérifient A.

B B : : ceux qui vérifient B.ceux qui vérifient B.



• DansDans






AA

BB « A » est une condition« A » est une conditionplus forte que « B ».plus forte que « B ».



• DansDans






AA

BB « A » est une condition« A » est une conditionplus forte que « B ».plus forte que « B ».

« B » est une condition« B » est une conditionplus faible que « A ».plus faible que « A ».



• SoitSoit { PRE } { PRE } programme programme { POST }{ POST } ! !

• Soit Soit PRE’ => PRE PRE’ => PRE !!

• Soit Soit POST => POST’ POST => POST’ !!






• Donc :Donc :

PRE’ => { PRE } PRE’ => { PRE } programme programme { POST } => { POST } => POST’POST’






• Donc :Donc :

PRE’ => { PRE } PRE’ => { PRE } programme programme { POST } => { POST } => POST’POST’

etet { PRE’ } { PRE’ } programme programme { POST’ }{ POST’ }






• Donc :Donc :

PRE’ => { PRE } PRE’ => { PRE } programme programme { POST } => POST’{ POST } => POST’ etet { PRE’ } { PRE’ } programme programme { POST’ }{ POST’ }

Pré-condition plus forte ! Post-condition plus faible !Pré-condition plus forte ! Post-condition plus faible !






• Donc :Donc :

PRE’ => { PRE } PRE’ => { PRE } programme programme { POST } => POST’{ POST } => POST’ etet { PRE’ } { PRE’ } programme programme { POST’ }{ POST’ }

Pré-condition plus forte ! Post-condition plus faible !Pré-condition plus forte ! Post-condition plus faible !

• Pour un Pour un ensemble plus restreint d’argumentsensemble plus restreint d’arguments,,

le programme répond le programme répond de manière plus vaguede manière plus vague ! !



• Graphiquement :Graphiquement :

{ PRE } { PRE } programme programme { POST } { POST }





programmeprogramme

PREPRE POSTPOST





programmeprogramme

PREPRE POSTPOSTxx yy





programmeprogramme

PREPRE POSTPOST

PRE’ => PREPRE’ => PRE

PRE’PRE’





programmeprogramme

PREPRE POSTPOST


PRE’PRE’

POST => POST’POST => POST’





{ PRE’ }{ PRE’ } programme programme { POST’ }{ POST’ }

programmeprogramme

PREPRE POSTPOST


PRE’PRE’




• Le lien entre le « cahier des charges » et le Le lien entre le « cahier des charges » et le « programme » :« programme » :




Cahier des chargesCahier des charges




programmeprogramme




• Le lien entre le « cahier des charges » et le « programme » :Le lien entre le « cahier des charges » et le « programme » :

• Le programme accepte toutes les données, voire plus !Le programme accepte toutes les données, voire plus !

programmeprogramme






• Le programme répond précisément, même plus qu’exigé !Le programme répond précisément, même plus qu’exigé !

programmeprogramme






• Le programme répond précisément, même plus qu’exigé !Le programme répond précisément, même plus qu’exigé !

• Le cahier des charges est l’exigence minimale ! ! !Le cahier des charges est l’exigence minimale ! ! !

programmeprogramme




• Que ferons-nous ?Que ferons-nous ?




– Soient les prédicats « P » et « Q » !Soient les prédicats « P » et « Q » !

– Soit le programme « Soit le programme « » ! » !






• Nous pouvons dire siNous pouvons dire si { P } { P } { Q } { Q } est vraie ou est vraie ou non !non !






• Nous pouvons dire siNous pouvons dire si { P } { P } { Q } { Q } est vraie ou est vraie ou non !non !

• Plus intéressant :Plus intéressant :






• Nous pouvons dire siNous pouvons dire si { P } { P } { Q } { Q } est vraie ou non !est vraie ou non !


– Soit la post-condition « Q » !Soit la post-condition « Q » !











Nous avons un programmeNous avons un programmeet une définition de ce queet une définition de ce que

le programme devrait faire !le programme devrait faire !










• Nous pouvons calculer la plus faible conditionNous pouvons calculer la plus faible condition F F telle quetelle que { F } { F } { Q } { Q } soit vraie !soit vraie !

Nous avons un programmeNous avons un programmeet une définition de ce queet une définition de ce que

le programme devrait faire !le programme devrait faire !



• La démarche complète :La démarche complète :

– Soit la post-condition « Q » ! Soit le programme Soit la post-condition « Q » ! Soit le programme « « » ! » !




– Soit la post-condition « Q » ! Soit le programme Soit la post-condition « Q » ! Soit le programme « « » ! » !

QQ




– Soit la post-condition « Q » ! Soit le programme « Soit la post-condition « Q » ! Soit le programme « » ! » !

• Calculons la plus faible condition Calculons la plus faible condition FF telle que telle que { F } { F } { Q } { Q } !!

QQ






FF QQ






• Nous comparons avec le cahier des charges ! ! !Nous comparons avec le cahier des charges ! ! !

FF QQ








FFPREPRE

QQ = POST = POST







• Et nous vérifions que PRE => Et nous vérifions que PRE => F !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!F !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


QQ = POST = POSTFFPREPRE



C O N C R E T E M E N T . . C O N C R E T E M E N T . . ..



• Les programmes :Les programmes :

– skipskip

– x <x <-- e e

–

– if C thenif C then else else

– while C dowhile C do

22

11

11

22




– skip le programme qui ne fait skip le programme qui ne fait rien !rien !

– x <x <-- e e

–



22

11

11

22





– x <x <-- e l’affectation ! e l’affectation !

–



22

11

11

22






– la séquence la séquence d’instructions !d’instructions !



22

11

11

22







– if C thenif C then else else la conditionnelle !la conditionnelle !


22

11

11

22








– while C dowhile C do la boucle ! la boucle !

22

11

11

22




– skip le programme qui ne fait rien !skip le programme qui ne fait rien !


– la séquence d’instructions !la séquence d’instructions !



• Les conditions « C » ne font pas d’affectation !Les conditions « C » ne font pas d’affectation !

22

11

11

22




– skip le programme qui ne fait rien !skip le programme qui ne fait rien !


– la séquence d’instructions !la séquence d’instructions !



• Les conditions « C » ne font pas d’affectation !Les conditions « C » ne font pas d’affectation !

• Toutes les autres constructions peuvent s’exprimer à l’aide de Toutes les autres constructions peuvent s’exprimer à l’aide de celles ci-dessus !celles ci-dessus !

22

11

11

22



• Nous utilisons des règles logiques de la forme :Nous utilisons des règles logiques de la forme :

HYP . . . HYPHYP . . . HYP1 n1 n

CONCLCONCL




• Celles-ci sont utilisées enCelles-ci sont utilisées en

– MODUS PONENS : Si nous avons les hypothèses nous MODUS PONENS : Si nous avons les hypothèses nous pouvons déduire la conclusion !pouvons déduire la conclusion !


CONCLCONCL




• Celles-ci sont utilisées enCelles-ci sont utilisées en

– MODUS PONENS : Si nous avons les hypothèses nous pouvons MODUS PONENS : Si nous avons les hypothèses nous pouvons déduire la conclusion !déduire la conclusion !

– MODUS TOLLENS : Pour avoir la conclusion, il suffit d’avoir les MODUS TOLLENS : Pour avoir la conclusion, il suffit d’avoir les hypothèses !hypothèses !


CONCLCONCL



• Trois règles qui sont toujours vraies :Trois règles qui sont toujours vraies :

• PRE-STRENGTH :PRE-STRENGTH :

• POST-WEAK :POST-WEAK :

• CONJUNCTION :CONJUNCTION :







P => Q P => Q { Q } { Q } { R } { R }







P => Q P => Q { Q } { Q } { R } { R }

{ { PP } } { R } { R }







P => Q { Q } P => Q { Q } { R } { R }

{ P } { P } { R } { R }

Q => R Q => R { P } { P } { Q } { Q }







P => Q { Q } P => Q { Q } { R } { R }

{ P } { P } { R } { R }

Q => R Q => R { P } { P } { Q } { Q }

{ P } { P } { { R R }}







P => Q { Q } P => Q { Q } { R } { R }

{ P } { P } { R } { R }

Q => R { P } Q => R { P } { Q } { Q }

{ P } { P } { R } { R }

{ P } { P } { Q } { Q }1 11 1 { P } { P } { Q } { Q }

2 2 2 2







P => Q { Q } P => Q { Q } { R } { R }

{ P } { P } { R } { R }

Q => R { P } Q => R { P } { Q } { Q }

{ P } { P } { R } { R }

{ P } { P } { Q } { Q }1 11 1 { P } { P } { Q } { Q }

2 2 2 2

{ P , { P , PP } } { Q , { Q , QQ } }1 11 12 2 2 2







P => Q { Q } P => Q { Q } { R } { R }

{ P } { P } { R } { R }

Q => R { P } Q => R { P } { Q } { Q }

{ P } { P } { R } { R }

{ P } { P } { Q } { Q }1 11 1 { P } { P } { Q } { Q }

2 2 2 2

{ P , { P , PP } } { Q , { Q , QQ } }1 11 12 2 2 2

ConjonctionConjonction



• Règle pour le programme Règle pour le programme skipskip : :



• Règle pour le programme Règle pour le programme skipskip : :

{ P } skip { P }{ P } skip { P }



• Règle pour le programme Règle pour le programme ; ; : :1 21 2



• Règle pour le programme Règle pour le programme ; ; : :

{ P } { P } { Q } { Q } { Q } { Q } { R } { R }11 22

{ P } { P } ;; { R } { R }11 22

1 21 2



• Règle pour le programme Règle pour le programme ; ; : :

• A cause de PRE-STRENGTH et POST-WEAK, nous n’avons pas A cause de PRE-STRENGTH et POST-WEAK, nous n’avons pas besoin d’une règle de la forme :besoin d’une règle de la forme :

{ P } { P } { Q } { Q } { Q } { Q } { R } { R }11 22

{ P } { P } ;; { R } { R }11 22

{ P } { P } { L } { L } { Q } { Q } { R } { R }11 22

{ P } { P } ;; { R } { R }11 22

L => QL => Q

1 21 2



{ P } { P } { L } { L } { Q } { Q } { R } { R }11 22L => QL => Q



{ P } { P } { L } { L } { Q } { Q } { R } { R }11 22L => QL => Q

11

PPLL


22


{ P } { P } { L } { L } { Q } { Q } { R } { R }11 22L => QL => Q

QQ

RR11

PPLL



• Règle pour le programme Règle pour le programme x <x <-- e e : :




{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }




ou ou P[ x <P[ x <-- e ] e ] est laest la

substitution de « e » à toutes les occurrencessubstitution de « e » à toutes les occurrences libres de « x » dans « P ».libres de « x » dans « P ».

{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }






Une occurrence de « x » dans « P » est libre si elle n’est pas sous la portée d’un Une occurrence de « x » dans « P » est libre si elle n’est pas sous la portée d’un quantification universel ou existentiel.quantification universel ou existentiel.

{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }






( x > 3 et ( x > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) ) [ x <[ x <-- 9 ] 9 ]

{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }






( x > 3 et ( x > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) ) [ x <[ x <-- 9 ] 9 ]= = ( ( xx > 3 et > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) ) [ x <[ x <-- 9 ] 9 ]

{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }






( x > 3 et ( x > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) ) [ x <[ x <-- 9 ] 9 ]= = ( ( xx > 3 et > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) ) [ x <[ x <-- 9 ] 9 ]= = ( ( 99 > 3 et > 3 et x . ( x >= 17 ) ) x . ( x >= 17 ) )

{ P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P }



• Interprétation de Interprétation de { P[ x <{ P[ x <--e ] } e ] } x <x <-- e e { P } { P } : :




– Si « x » n’est pas libre dans « P » :Si « x » n’est pas libre dans « P » :

• la post-condition ne s’intéresse pas à « x »,la post-condition ne s’intéresse pas à « x »,

• la pré-condition la pré-condition P[ x <P[ x <--e ] = P e ] = P non plus d’ailleurs,non plus d’ailleurs,

• l’affectation l’affectation x <x <-- e e n’est pas fausse, mais inutile !n’est pas fausse, mais inutile !




– Si « x » est libre dans « P » :Si « x » est libre dans « P » :

• la post-condition dépend bien de « x »,la post-condition dépend bien de « x »,

• la pré-condition la pré-condition P[ x <P[ x <--e ] e ] est la formule ou nous avons des « est la formule ou nous avons des « ee » à la place des » à la place des «« x x », »,

• l’affectation l’affectation x <x <-- e e donne la valeur « donne la valeur « ee » à « » à « xx » et nous pouvons donc dans » et nous pouvons donc dans P[ x <P[ x <--e ] e ] remplacer « remplacer « ee » par « » par « x x »,»,

• c’est-à-dire considérer la post-condition c’est-à-dire considérer la post-condition P P ..



• Illustration :Illustration :

{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( xx * y mod ( 1 + * y mod ( 1 + x x ) )) )[ [ x x <<-- ( 11 + 34 ) ( 11 + 34 ) ] ] } } x <x <-- … … { ??? }{ ??? }




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }


{ { ( ( xx * y mod ( 1 + * y mod ( 1 + x x ) )) )[ [ x x <<-- ( 11 + 34 ) ( 11 + 34 ) ] ] } } x <x <-- ( 11 + 34 )( 11 + 34 ) { ??? }{ ??? }




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }



PP




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }



{ { ( ( xx * y mod ( 1 + * y mod ( 1 + x x ) )) )[ [ x x <<-- ( 11 + 34 ) ( 11 + 34 ) ] ] } } x <x <-- ( 11 + 34 )( 11 + 34 ) { P }{ P }

PP




{ { ( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) )( ( 11 + 34 ) * y mod ( 1 + ( 11 + 34 ) ) ) } } x <x <-- … … { ??? }{ ??? }

{ { ( ( ( 11 + 34 )( 11 + 34 ) * y mod ( 1 + * y mod ( 1 + ( 11 + 34 ) ( 11 + 34 ) ) )) ) } } x <x <-- … … { ??? }{ ??? }



{ { ( ( xx * y mod ( 1 + * y mod ( 1 + x x ) )) )[ [ x x <<-- ( 11 + 34 ) ( 11 + 34 ) ] ] } } x <x <-- ( 11 + 34 )( 11 + 34 ) { P }{ P }

{ { PP[ [ x x <<-- ( 11 + 34 ) ( 11 + 34 ) ] ] } } x <x <-- ( 11 + 34 )( 11 + 34 ) { P }{ P }

PP



• Premier exemple :Premier exemple :

m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m




• Post-condition :Post-condition :

m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ y <R = Q[ y <-- m ] m ]





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ y <R = Q[ y <-- m ] = { x = a , m = b } m ] = { x = a , m = b }





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ x <S = R[ x <-- y ] y ]





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ x <S = R[ x <-- y ] = { y = a , m = b } y ] = { y = a , m = b }





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ m <P = S[ m <-- x ] x ]





m <- x ;m <- x ;

x <- y ;x <- y ;

y <- my <- m

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ m <P = S[ m <-- x ] = { y = a , x = b } x ] = { y = a , x = b }



• Deuxième exemple :Deuxième exemple :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- x x -- y ] y ]




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- x x -- y ] = { x – y = a , y = b } y ] = { x – y = a , y = b }




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- x x -- y ] = { x – y = a , y = b } = { x = a + b , y = b } y ] = { x – y = a , y = b } = { x = a + b , y = b }

Des maths !Des maths !




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x -- y ] y ]




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x -- y ] = { x = a + b , x y ] = { x = a + b , x -- y = b } y = b }




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x -- y ] = { x = a + b , x y ] = { x = a + b , x -- y = b } = { x = a + b , y = a } y = b } = { x = a + b , y = a }





• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x + y ] x + y ]




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x + y ] = { x + y = a + b , y = a } x + y ] = { x + y = a + b , y = a }




• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x + y ] = { x + y = a + b , y = a } = { x = b , y = a } x + y ] = { x + y = a + b , y = a } = { x = b , y = a }





• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }







• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b }Q = { x = a , y = b }




DépassementDépassementde capacité ? ? ?de capacité ? ? ?



• Deuxième exemple, avec vérification de la capacité :Deuxième exemple, avec vérification de la capacité :

• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y

Q = { x = a , y = b Q = { x = a , y = b , a , a DD , b , b DD }}



• Deuxième exemple, avec vérification de la capacité :Deuxième exemple, avec vérification de la capacité :

• POST :POST :

x <- x + y ;x <- x + y ;

y <- x - y ;y <- x - y ;

x <- x - yx <- x - y


R = Q[ x <R = Q[ x <-- x x -- y ] = { x = a + b , y = b y ] = { x = a + b , y = b , a , a DD , b , b DD , a + b , a + b DD }}

S = R[ y <S = R[ y <-- x x -- y ] = { x = a + b , y = a y ] = { x = a + b , y = a , a , a DD , b , b DD , a + b , a + b DD }}

P = S[ x <P = S[ x <-- x + y ] = { x = b , y = a x + y ] = { x = b , y = a , a , a DD , b , b DD , a + b , a + b DD }}



• Troisième exemple :Troisième exemple :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- y y -- x ] x ]




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- y y -- x ] = { y – x = a , y = b } x ] = { y – x = a , y = b }




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }

R = Q[ x <R = Q[ x <-- y y -- x ] = { y – x = a , y = b } = { x = b x ] = { y – x = a , y = b } = { x = b -- a , y = b } a , y = b }





• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x ++ y ] y ]




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x ++ y ] = { x = b – a , x y ] = { x = b – a , x ++ y = b } y = b }




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }


S = R[ y <S = R[ y <-- x x ++ y ] = { x = b – a , x y ] = { x = b – a , x ++ y = b } = { x = b – a , y = a } y = b } = { x = b – a , y = a }





• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x x -- y ] y ]




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x x -- y ] = { x y ] = { x -- y = b – a , y = a } y = b – a , y = a }




• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }



P = S[ x <P = S[ x <-- x x -- y ] = { x y ] = { x -- y = b – a , y = a } = { x = b , y = a } y = b – a , y = a } = { x = b , y = a }





• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }







• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x

Q = { x = a , y = b }Q = { x = a , y = b }




DépassementDépassementde capacité ? ? ?de capacité ? ? ?



• Troisième exemple, avec vérification de la capacité :Troisième exemple, avec vérification de la capacité :

• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x




• Troisième exemple, avec vérification de la capacité :Troisième exemple, avec vérification de la capacité :

• POST :POST :

x <- x - y ;x <- x - y ;

y <- x + y ;y <- x + y ;

x <- y - xx <- y - x


R = Q[ x <R = Q[ x <-- y y -- x ] = { x = b x ] = { x = b -- a , y = b a , y = b , a , a DD , b , b DD , b , b -- a a DD }}

S = R[ y <S = R[ y <-- x x ++ y ] = { x = b – a , y = a y ] = { x = b – a , y = a , a , a DD , b , b DD , b , b -- a a DD }}

P = S[ x <P = S[ x <-- x x -- y ] = { x = b , y = a y ] = { x = b , y = a , a , a DD , b , b DD , b , b -- a a DD }}



• Règle pour le programme Règle pour le programme if C then if C then else else : :

2211




{ P ,{ P , C } C } { Q } { Q }

{ P } if C then { P } if C then else else { Q } { Q }

2211

1 21 2

22{ P , C } { P , C } { Q } { Q }11




• Mais, dans la pratique, nous n’aurons pas « P » :Mais, dans la pratique, nous n’aurons pas « P » :

{ P ,{ P , T } T } { Q } { Q }

{ P } if C then { P } if C then else else { Q } { Q }

2211

1 21 2

22{ P , T } { P , T } { Q } { Q }11

{ ??? ,{ ??? , C } C } { Q } { Q }

{ ??? } if C then { ??? } if C then else else { Q } { Q }1 21 2

22{ ??? , C } { ??? , C } { Q } { Q }11



• Nous allons déduire les pré-conditions Nous allons déduire les pré-conditions FF et et FF à partir de à partir de et et et de et de Q Q :: 2211

11 22



• Nous allons déduire les pré-conditions Nous allons déduire les pré-conditions FF et et FF à partir de à partir de et et et de et de Q Q ::

{ F }{ F } { Q } { Q }

2211

22{ F }{ F } { Q } { Q }1111 22

11 22




• Ensuite, il s’agira de trouver Ensuite, il s’agira de trouver PP tel que : tel que :

{ F }{ F } { Q } { Q }

2211

22{ F }{ F } { Q } { Q }11

P ,P , C => C => FF22P , C =>P , C => FF11

11 22

11 22



• Nous allons déduire les pré-conditions Nous allons déduire les pré-conditions FF et et FF à partir de à partir de et et et et de de Q Q ::


• Mais, comment faire ? ? ? ? ?Mais, comment faire ? ? ? ? ?

{ F }{ F } { Q } { Q }

2211

22{ F }{ F } { Q } { Q }11

P ,P , C => C => FF22P , C =>P , C => FF11

11 22

11 22





• Mais, comment faire ? ? ? ? ?Mais, comment faire ? ? ? ? ?

• Si vous avez de la chance, vous trouverez !Si vous avez de la chance, vous trouverez !• Sinon, il faudra trouver une autre approche !Sinon, il faudra trouver une autre approche !

{ F }{ F } { Q } { Q }

2211

22{ F }{ F } { Q } { Q }11

P ,P , C => C => FF22P , C =>P , C => FF11

11 22

11 22



• Si nous ne trouvons pas Si nous ne trouvons pas PP nous pouvons toujours nous pouvons toujours faire une discussion par cas et partir de :faire une discussion par cas et partir de :


{ ??? } { ??? } { Q } { Q }11



• Si nous ne trouvons pas Si nous ne trouvons pas PP nous pouvons toujours nous pouvons toujours faire une discussion par cas et partir de :faire une discussion par cas et partir de :

• pour chercher pour chercher F F : :


{ ??? } { ??? } { Q } { Q }11

11


{ F }{ F } { Q } { Q }1111



• Si nous ne trouvons pas Si nous ne trouvons pas PP nous pouvons toujours faire une discussion par cas et partir nous pouvons toujours faire une discussion par cas et partir de :de :

• pour chercher pour chercher F F : :

• et déduire une pré-condition au cas ou le test est vrai :et déduire une pré-condition au cas ou le test est vrai :


{ ??? } { ??? } { Q } { Q }11

11


{ F }{ F } { Q } { Q }1111

{ F , C }{ F , C } if C then if C then else else { Q } { Q }1 21 2

{ F }{ F } { Q } { Q }1111

11



• Nous obtenons deux cas :Nous obtenons deux cas :


{ F }{ F } { Q } { Q }1111

11

Test vrai !Test vrai !





{ F }{ F } { Q } { Q }1111

11


{ F , { F , C }C } if C then if C then else else { Q } { Q }1 21 2

{ F }{ F } { Q } { Q }2222

22

Test faux !Test faux !




• que nous fusionnons ensuite :que nous fusionnons ensuite :


{ F }{ F } { Q } { Q }1111

11


{ F , { F , C }C } if C then if C then else else { Q } { Q }1 21 2

{ F }{ F } { Q } { Q }2222

22

Test faux !Test faux !

{ F , C } ou { F , { F , C } ou { F , C }C } if C then if C then else else { Q } { Q }1 21 2

{ F }{ F } { Q } { Q }2222

2211

{ F }{ F } { Q } { Q }1111



• Un premier exemple :Un premier exemple :

if ( a < 0 )if ( a < 0 )thenthen

x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3




• POST : POST :


x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3

Q = { x = a + 8Q = { x = a + 8 }}




• POST : POST :


x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}




• POST : POST :


x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

F = { x = a + 11 }F = { x = a + 11 }22




• POST : POST :


x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

F = { x = a + 11 }F = { x = a + 11 }22

F = { x = a + 1 }F = { x = a + 1 }11




• POST : POST :


x <- x + 7x <- x + 7

elseelse

x = x – 3x = x – 3

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

Q = { x = a + 8Q = { x = a + 8 }}

F = { x = a + 11 }F = { x = a + 11 }22

F = { x = a + 1 }F = { x = a + 1 }11

{ x = a + 1 , a < 0 } { x = a + 1 , a < 0 } ouou { x = a + 11 , a >= 0 }{ x = a + 11 , a >= 0 }



• Un second exemple :Un second exemple :


x <- -ax <- -a

elseelse

x = ax = a




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

F = { a >= 0 }F = { a >= 0 }22




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

F = { a >= 0 }F = { a >= 0 }22

F = { a < 0 }F = { a < 0 }11




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

F = { a >= 0 }F = { a >= 0 }22

F = { a < 0 }F = { a < 0 }11

{ a < 0 } { a < 0 } ouou { a >= 0 }{ a >= 0 }




• POST : POST :


x <- -ax <- -a

elseelse

x = ax = a

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

Q = { x = | a |Q = { x = | a | }}

F = { a >= 0 }F = { a >= 0 }22

F = { a < 0 }F = { a < 0 }11

{ a < 0 } { a < 0 } ouou { a >= 0 } { a >= 0 } = = { VRAI }{ VRAI }


SynthèseSynthèse----------------------------------------------------------------------------------------------------------------------------------

Logique de Hoare (début) :Logique de Hoare (début) :

Principes etPrincipes et

constructions élémentaires.constructions élémentaires.


m E r C i e Tm E r C i e Tb O n N e J o U r N é b O n N e J o U r N é

E ! ! !E ! ! !

n ‘ O u B l I e Z p A s D en ‘ O u B l I e Z p A s D ep R é P a R e R v O sp R é P a R e R v O s

T D ! ! !T D ! ! !

Cours d'algorithmique 9 - Intranet 1 12 décembre 2006 Cours dAlgorithmique Logique de Hoare...

Documents

Transcript of Cours d'algorithmique 9 - Intranet 1 12 décembre 2006 Cours dAlgorithmique Logique de Hoare...