MC-ENSTA

Document Sample
MC-ENSTA Powered By Docstoc
					Introduction au Model Checking
            ENSTA

              e
             S´bastien Bardin
                             u e
   CEA,LIST, Laboratoire de Sˆret´ logicielle
      ıte
    Boˆ 65, Gif-sur-Yvette, F-91191 France
          sebastien.bardin@cea.fr


              24 octobre 2008
              e
Table des mati`res

1 Introduction                                                                                                                                                                                    3
          e      e
  1.1 Syst`mes r´actifs . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   3
            ee
  1.2 Propri´t´s temporelles      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   3
  1.3 Model checking . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   4
  1.4 Historique . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   4
  1.5 En pratique . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   5
                       e
  1.6 Lectures conseill´es . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   7


I   Bases du model checking                                                                                                                                                                       8
      e                    e       e
2 Mod´lisation des syst`mes r´actifs                                                                                                                                                               9
                            ae
  2.1 Syntaxe : machines ` ´tats . . . . . . . . . . . . . . . . . .                                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    9
       e                 e
  2.2 S´mantique : syst`mes de transitions . . . . . . . . . . . .                                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    9
  2.3 Structure de Kripke . . . . . . . . . . . . . . . . . . . . .                                               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   11
  2.4 Discussion sur la terminologie . . . . . . . . . . . . . . . .                                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   13
                  e            ee                  e
  2.5 Espace des ´tats, propri´t´s d’accessibilit´ et d’invariance                                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   13
          e
  2.6 Syst`mes concurrents . . . . . . . . . . . . . . . . . . . . .                                              .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   15
             e      e      e
  2.7 Hypoth`ses d’´quit´ . . . . . . . . . . . . . . . . . . . . .                                               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   16
            ee       u e
  2.8 Propri´t´s de sˆ ret´. . . . . . . . . . . . . . . . . . . . . .                                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   17
                               e
  2.9 Quelques points de mod´lisation . . . . . . . . . . . . . .                                                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   18

3 Logiques temporelles                                                                                                                                                                            20
                            ee
  3.1 Panorama de propri´t´s temporelles .                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   20
  3.2 Intuitions sur les logiques temporelles                         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   21
                  e
  3.3 Logique lin´aire LTL . . . . . . . . . .                        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   25
  3.4 Logique branchante CTL∗ . . . . . . .                           .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   27
  3.5 Logique branchante CTL . . . . . . .                            .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   28
  3.6 Comparaison des trois logiques . . . .                          .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   29

4 Model checking, algorithmes de base                                                                                                                                                             32
        e
  4.1 Pr´lude : composantes fortement connexes                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32
  4.2 Model checking de CTL par labelling . . .                               .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   33
  4.3 Model checking de fair CTL par labelling                                .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   35
  4.4 Model checking de LTL par automates . .                                 .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   37

 ee
R´f´rences                                                                                                                                                                                        39




                                                                                  1
A Rappels de logique                                                                                                                                                     41
       e
  A.1 D´finitions . . . . . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   41
           e                  e
  A.2 Probl`mes classiques li´s aux logiques . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   41
  A.3 Quelques logiques . . . . . . . . . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   42
  A.4 Exemple : logique classique propositionnelle       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   42

                            e
B Notions de calculabilit´ et complexit´       e                                                                44
                   e
  B.1 Calculabilit´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
                 e
  B.2 Complexit´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

              e
C Divers probl`mes algorithmiques                                                                        46
  C.1 Composantes fortement connexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

D Sujets de partiel                                                                                      48
                  e
  D.1 ENSTA, ann´e 2006-2007 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
                             e
  D.2 ENSTA, rattrapages, ann´e 2006-2007 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49




                                                         2
Chapitre 1

Introduction

1.1            e     e
           Syst`mes r´actifs
                                                                                                e
    Habituellement un programme, que nous dirons standard, (1) termine ; (2) retourne un r´sultat et (3)
                    e                                         o
manipule des donn´es complexes mais sa structure de contrˆle est assez simple. Pour ces programmes stan-
                 ee a                                                               e              e
dards, les propri´t´s ` prouver sont toujours du style “quand la fonction est appell´e et que la pr´condition
     e e                                                        e e
est v´rifi´e, alors la fonction termine et la postcondition est v´rifi´e”.
Exemple typique de programme standard : compilateur, algorithme de tri.
                     e        a              e           e                           e      e
    Ici nous nous int´ressons ` une classe tr`s particuli`re de programmes : les syst`mes r´actifs. Quelques
       ee                            e                                    e
propri´t´s remarquables de ces syst`mes : (1) ils ne terminent pas forc´ment ; (2) ils ne calculent pas un
 e                o                                                       e           e
r´sultat mais plutˆt maintiennent une interaction ; (3) les types de donn´es manipul´s sont souvent simples
                  o                    e                                          e
alors que le contrˆle est complexe (ex´cution de plusieurs composants en parall`le). Enfin bien souvent ils
interagissent avec un environnement par le biais de capteurs (prise d’information) et d’actionneurs (action).
                            e   e             e          e                        e            e
Exemples typiques de syst`mes r´actifs : syst`mes embarqu´s pour les transports/l’´nergie, syst`mes d’ex-
ploitation, protocoles de communication, etc.


1.2              e e
           Propri´t´s temporelles
               ee                                      e      e               e  e
    Les propri´t´s que l’on veut prouver sur ces syst`mes r´actifs sont tr`s diff´rentes de celles que l’on veut
                                                                                   ee
prouver sur des programmes standards. On veut typiquement prouver des propri´t´s sur l’entrelacement des
e e                               e
´v`nements tout au long de l’ex´cution (infinie) du programme, par exemple
                                                     ae        e e                          e
    – si un processus demande infiniment souvent ` ˆtre ex´cut´, alors l’OS finira par l’ex´cuter ;
                                           e                  a e
    – il est toujours possible lors de l’ex´cution de revenir ` l’´tat initial ;
                                       e     e                  e
    – chaque fois qu’une panne est d´tect´e, une alarme est ´mise ;
                                     eee                          ee e
    – chaque fois qu’une alarme a ´t´ ´mise, une panne avait ´t´ d´tect´e.   e
        e                                                           ee a e                          e
    Sch´matiquement, pour les programmes standards, les propri´t´s ` v´rifier impliquent des pr´dicats tr`s   e
riches sur les donn´es manipul´es1 mais les aspects temporel sont tr`s restreints, tandis que pour les syst`mes
                    e          e                                      e                                    e
r´actifs l’aspect temporel est tr`s ´labor´ mais les pr´dicats sur les donn´es sont souvent basiques2 .
 e                               e e      e            e                   e
                            ee                                                    ` ¸
    Pour exprimer ces propri´t´s temporelles on utilise des logiques temporelles. A ca deux avantages. (1)
                      e         e                                        e                        e
Ces logiques peuvent ˆtre utilis´ avantageusement lors de la phase de sp´cification, puisqu’elles d´crivent
                                      e                                          e
les comportements temporels de mani`re non ambigue. (2) Un algorithme qui v´rifie toutes les propri´t´see
  1 Par                          ıt e      e
          exemple : le tableau doˆ ˆtre tri´.
  2 Par   exemple : x = 0




                                                      3
                                                               e e                        e ea           e
exprimables dans une certaine logique est bien plus souple et g´n´rique qu’un algorithme d´di´ ` un probl`me
particulier.
   Il existe de nombreuses logiques temporelles. Nous verrons principalement CTL, LTL et CTL∗ .


1.3      Model checking
  e                                                                  e                               ee
D´finition 1.3.1. Le model checking est un ensemble de techniques de v´rification automatique de propri´t´s
                        e     e
temporelles sur des syst`mes r´actifs.
        e                                                               e
     Sch´matiquement, un algorithme de model checking prend en entr´e une abstraction du comportement
        e     e              e                                                                        e
du syst`me r´actif (un syst`me de transitions) et une formule d’une certaine logique temporelle, et r´pond
                                                                      e                            e
si l’abstraction satisfait ou non la formule. On dit alors que le syst`me de transitions est un mod`le de la
formule, d’ou le terme anglais de model checking.

                                                        e              e
    Le gros avantage du model checking est qu’il est (id´alement) compl`tement automatique, et que ha-
                                            e                ee           e e                        ee
bituellement un contre-exemple est retourn´ quand la propri´t´ n’est pas v´rifi´e. Ce dernier point a ´t´
 e
d´terminant pour une adoption industrielle.

                     e                                                                                e
    La limitation th´orique principale des techniques standards de model checking est que le syst`me de
                e                e                                                            a
transition doit ˆtre fini : grossi`rement, le programme ne doit manipuler que des variables ` domaine fini.
                                                                     e                                   e
C’est souvent le cas en pratique, mais pas toujours. Soit que le syst`me est infini par nature (ex : syst`mes
  e                                                                                    a
d´pendants du temps et donc variables dans R), ou que les bornes sont impossibles ` estimer (ex : bornes
                                                                       e      e                e
des canaux de communication de l’internet), ou bien encore que le syst`me d´pend de param`tres (m´moiree
                                                                                                     e
disponible, nombre de clients) et qu’il doit fonctionner pour n’importequ’elles valeurs de ces param`tres.

                                                                                         e
   En pratique la limitation majeure du model checking est la taille gigantesque des syst`mes de transitions
           e    e                                           e             e
due au ph´nom`ne d’explosion combinatoire du nombre d’´tats du syst`me. Par exemple on compte d´j`       ea
10255 ´tats pour un programme manipulant 10 variables cod´es sur 8 bits3 . Le ph´nom`ne d’explosion com-
      e                                                      e                    e    e
                                                       e
binatoire a deux sources distinctes : la taille du syst`me de transitions augmente exponentiellement d’une
                                                                                                       e
part avec le nombre de variables (et leur taille), d’autre part avec le nombre de composants du syst`mes
             u        e                      e
dans le cas o` le syst`me est concurrent (tr`s courant).

                      e           ee e         e             e
    Des techniques sp´cifiques ont ´t´ d´velopp´es pour limit´e chacune de ces sources potentielles d’explo-
sion, par exemple le model checking symbolique pour le nombre de variables et les ordres partiels pour les
entrelacements de composants. Ceci et l’augmentation des ressources de calcul permet aujourd’hui l’utilisa-
tion industrielle du model checking pour certains types d’application.

    La recherche en model checking continue et se partage actuellement en trois grandes tendances : continuer
      e              e
d’am´liorer l’efficacit´ pratique des techniques de model checking fini pour combattre l’explosion combina-
        e                        a         e                                       e
toire, ´tendre le model checking ` des syst`mes plus complexes (infinis, temporis´s, probabilistes) et enfin
  e                                   a
id´alement adapter le model checking ` des logiciels quelconques.


1.4      Historique
        `                 e                         e            e      e              e
1970. A la fin des ann´es 70, les techniques de v´rification d´velopp´es durant la d´cennie (types, logique
                                 e e            e                e    e
de Hoare, analyse statique) se r´v`lent inadapt´es pour les syst`mes r´actifs. En 1977, Pnueli est le premier a
propos´ d’utiliser les logiques temporelles4 pour sp´cifier le comportement de syst`mes r´actifs. Puis en 1981
      e                                             e                              e     e
    `
  3 A titre de comparaison un petit programme a vite une centaine de variables cod´es sur 32 bits, le nombre de particules
                                                                                       e
dans l’univers est de l’ordre de 1080 et le nombre de secondes depuis le Big-Bang est de l’ordre de 1017 .
  4 D´velopp´es jusque l` par des philosophes et des logiciens.
      e       e           a



                                                            4
                      ´                                           e             e
Clarke et Emerson aux Etats-Unis et Quielle et Sifakis en France d´veloppent ind´pendamment les premiers
                                                e
algorithmes de model checking. La logique utilis´e est CTL.

                         e            e                                        e          e            e
1980. Durant les ann´es 80, les r´sulats sont principalement d’ordre th´orique : r´sulats de d´cision et
                     e                      e                   e
bornes de complexit´, comparaisons de diff´rentes logiques, d´couverte des techniques de model checking par
automates (automata-theoretic model checking, par Vardi et Wolper). Du point de vue pratique, quelques
                            e e                                          e     e
preuves de concept sont r´alis´es sur des exemples jouets, mais le ph´nom`ne d’explosion combinatoire (et
           e                 e                         e                              e
les capacit´s de calcul de l’´poque) rendent les cas d’´tudes industriels hors de port´e. Un certain scepticisme
 e                          e       e
r`gne dans la communaut´ de la v´rification automatique.

                 e            e       e                                                   e      e
1990 Les ann´es 90 voient ´merg´es deux techniques majeures pour combattre le ph´nom`ne d’explosion
                     e             e
combinatoire et am´liorer consid´rablement les performances des model-checkers. Les techniques d’ordres
                                             e       e                                                  e
partiels (Peled, Godefroid) permettent d’all´ger la v´rification en ne construisant qu’une partie du syst`me de
                                                                                                        e
transitions. Les techniques de model checking symbolique par BDD (McMillan) permettent elles de repr´senter
         e     e                    e
de mani`re tr`s compacte le syst`me de transitions. Ces deux techniques rendent possibles les premi`res   e
´tudes de cas de taille industrielle, avec des syst`mes de transition allant jusqu’` 1020 ´tats.
e                                                  e                               a      e

                                                                           e                      e
1995-20 ? ? Les recherches sur le model checking fini continuent, pour am´liorer encore l’efficacit´. Citons
par exemple la model checking modulaire, le raffinement automatique d’abstractions et le bounded model
                   e                                 a                                                e
checking. En parall`le de nombreux travaux visent ` aller plus loin que le model checking fini : syst`mes
            e            e       e                                  e           e
infinis, syst`mes temporis´s, syst`mes probabilistes, etc. Enfin, au d´but des ann´es 2000, les techniques de
                             ae          e                   e
model checking commencent ` ˆtre adapt´es dans le but de v´rifier des programmes classiques. On assiste `  a
  e
l’´mergence du software model checking (Ball, Godefroid, Henzinger).

                  e                                                             a
Influence acad´mique. Avec le software model checking, on commence ` assister au mariage maintes
            e                                                       e e                         e
fois annonc´ du model checking, de l’analyse statique, de la g´n´ration de tests et de la d´monstration
                                             e      e
automatique. De ce fait, les techniques d´velopp´es pour le model checking se diffusent dans d’autres do-
maines, notamment les logiques temporelles (design by contract, run-time verification, model-based testing),
                      e e                       e
les ordres partiels (g´n´ration de tests de syst`mes concurrents), et le raffinement automatique d’abstractions
par contre-exemple (analyse statique).


1.5     En pratique
                                                      e     ea          e
Champs d’application. Le model checking est r´serv´ ` des syst`mes finis, ou pour lesquels on peut
facilement trouver une abstraction finie. Les deux champs d’applications classiques sont la validation des
             e                                                                                  e
composants ´lectroniques et la validation des protocoles de communication. Les composants ´lectroniques
                                                          e                          e
sont typiquement de nature finie (ils manipulent des bool´ens), mais l’explosion des ´tats est due au nombre
gigantesque de portes logiques dans un composant. Le model checking symbolique est utile dans ce cas. Pour
                                           `                                e
les protocoles, il faut souvent se ramener a une abstraction finie. Le probl`me principal est l’explosion due
a                                             e
` l’entrelacement des comportements des diff´rents agents du protocole. Les ordres partiels sont utiles dans
ce cas.
                                                                 e             e                    ea
     Dans un futur proche, les champs d’applications devraient s’´tendre consid´rablement. On peut d´j` citer
                                                                                  e
les Web services, cas particuliers de protocoles de communication dont l’impact ´conomique s’annonce tr`s  e
                                                                   e
important du fait de leur place centrale dans la programmation r´partie. De plus le model checking devrait
         a
profiter ` plein du nouveau paradigme Model Driven Development (MDD), qui insiste sur les phases de
   e                              e               e
sp´cification et l’utilisation syst´matique de mod`les.

                e        e                               e                                         e
Outils et succ`s acad´miques. Plusieurs outils acad´miques de bon niveau existent, et plusieurs ´tudes
                           eae e     e                                                         e      ea
de cas industrielles ont d´j` ´t´ men´es. Les deux outils les plus connus sont sans doute SMV d´velopp´ `
                                                                        e       e
CMU et implantant le model checking symbolique par BDD, et SPIN d´velopp´ au Bell Labs et implantant


                                                       5
                                          e              e e                         e
les ordres partiels. Parmi les nombreuses ´tudes de cas r´alis´es, on peut noter la v´rification du protocole
                               e            e                              e      e     e
de bus FutureBus+ IEEE. C’´tait la premi`re fois qu’un protocole IEEE ´tait d´bugg´ par des techniques
      e                                                        e
compl`tement automatiques. D’autres exemples sont mentionn´s dans [3] et [1, 2].

Process du model checking.              En pratique, le model checking est un process en trois phases :
  1. Mod´liser le syst`me (syst`me de transitions M) et les sp´cifications (logique temporelle ϕ).
        e             e        e                              e
  2. V´rifier si M satisfait ϕ ou non. Si non, retourner un contre-exemple.
      e
                   e
  3. Analyser les r´sultats obtenus :
         (a) Si oui, le mod`le M est sˆ r. Fin. Attention : le syst`me r´el est-il sˆ r pour autant ?5
                           e          u                            e    e           u
                                                          e    e
         (b) Si non, rejouer le contre-exemple sur le syst`me r´el.
                i. Si c’est un vrai bug, avertir le concepteur et attendre qu’il corrige. Fin.
                                               e                   a                      e     a
               ii. Si le bug vient de notre mod´lisation, repartir ` (1) en raffinant le mod`le grˆce au faux bug.
´                                           e                     e
Evidemment, c’est un peu plus compliqu´ que le discours “v´rification totalement automatique” :-) Je ne
                                                e e                                             e
vous cacherai pas que les parties 1 et 3 sont tr`s d´licates. Pourtant elles ne seront pas abord´es du tout ici, ni
                                        a
d’ailleurs dans la plupart des ouvrages ` part [1]. Nous nous concentrerons sur la partie 2, qui est effectivement
                 e                  e
la partie compl`tement automatis´e du model checking. Remarquons que des travaux de recherche en cours
permettent d’automatiser en partie l’aspect raffinement.

                                e
Place dans le cycle de d´veloppement. Le model checking prend place au niveau des phases de
                     e                           e                      e                           o
conception du syst`me, avant l’implantation r´elle. Cela permet de d´couvrir les bugs au plus tˆt, et plus
              e            o             u
un bug est d´couvert tˆt, moins il coˆ te cher. Cependant, pour appliquer le model checking on a besoin
          e                           e               e                                    e
d’un mod`le formel (et fini) du syst`me et de ses sp´cifications. Aussi, si le process de d´veloppement choisi
     e                              e          e                        e                       ıne       u
n’int`gre pas cela, il faudra que l’´quipe de v´rification refasse un mod`le formel, ce qui entraˆ un surcoˆ t.
`                                                                            e        ea
A l’inverse, par exemple chez les fondeurs de processeurs, les process int`grent d´j` tout une batterie de
     e            a      e                                      e
mod`les formels ` diff´rents niveaux d’abstraction et des sp´cifications rigoureuses. Dans ce cas, le model
checking s’int`gre tr`s bien au process6 .
              e        e

                                           e                                        e        e
Par rapport aux autres techniques de v´rification. Voici une comparaison, forc´ment tr`s subjective,
          e       e           e              e          a          a       e
entre diff´rentes m´thodes de v´rification. N’h´sitez pas ` demander ` des sp´cialistes des autres domaines
leur avis :-)

                                  phase du       prise              e
                                                              assist´              u
                                                                              surcoˆ t       debug     validation
                                    cycle       en main      par ordi.
           preuve                conception        --            -            preuves           -         ++
           model checking        conception        +            +               e
                                                                           mod´lisation        ++          +
                                                                                e
                                                                          concr´tisation
           tests autom.          conception         +             +             e
                                                                           mod´lisation            +       -
                 e
           (mod`le)                                                             e
                                                                          concr´tisation
           analyse statique         code           ++             ++              e
                                                                           faux n´gatifs           -       +
                                                                               stub
           tests autom.             code           ++             ++           stubs               +       -
           (code)
           test autom.              code           ++             +         assertions         ++          -
           (code+assert)                                                      stubs
           tests standard           code           ++             -           stubs                -       --
                                                                           jeu de tests
  5 Cela    e                e
           d´pend de la mod´lisation.
  6 L`
     a                             e e                          a           e
         encore, on voit tout l’int´rˆt que le model checking a ` tirer du d´veloppement du MDD.



                                                              6
                                                                   e          e
Utilisation industrielle. Le model checking a fait une perc´e remarqu´e dans l’industrie des composants
e                                     e
´lectroniques depuis quelques ann´es [6], soit en interne soit dans des suites de CAO. On peut citer par
exemple pour les produits commerciaux : Siemens, Bull, IBM, Lucent Technologies, Cadence ; et pour les
                                                                                    e     e
outils internes : IBM, Intel, Motorola. En 2003, un langage industriel standardis´ de sp´cifications temporelles
       e         ee
nomm´ PSL a ´t´ mis au point par un consortium regroupant entre autre Intel et IBM.
                                                          e                       e          a
    Les industriels des domaines critiques (transport, ´nergie) commencent ´galement ` regarder ces outils
                                                                  a                          e
(Airbus, Bosch) dans une approche MDD, mais je ne sais pas ` quel point ils sont utilis´s en interne. Enfin,
                                     e      e
remarquez que Microsoft investit ´norm´ment d’argent en ce moment dans le software model checking.
                  e                            a                                e              e
    Les outils cit´s plus haut sont quasiment ` la point de la technologie acad´mique : ils int`grent des logiques
  e                                                                                   a
tr`s expressives et certains utilisent des algorithmes de model checking optimaux ` base d’automates d’arbres
                                                                                                        e
alternants. Il est d’ailleurs assez amusant de noter qu’un standard industriel comme PSL est bas´ sur des
                         e       e a
logiques temporelles d´velopp´es ` la base par des philosophes [9].

           e      a                                     a
De la th´orie ` la pratique. Il faut bien avoir ` l’esprit que si l’ambition initiale du model checking
e                                          e
´tait de prouver la correction d’un syst`me, l’utilisation qui en est actuellement faite (au moins chez les
                    o                                                         e
fondeurs) est plutˆt celle d’un “super testeur automatique”, capable de v´rifier tous les comportements et
entrelacements du syst`me pour des chemins de taille fix´e, par exemple ≤ 50 cycles d’horloge. Des techniques
                       e                                   e
  e                                                     e a                       e
sp´cifiques, dites bounded model checking, sont adapt´es ` ce besoin. Cette “d´rive” de la validation vers le
                                                  e
test a au moins deux raisons : prouver la validit´ d’un processeur entier demanderait des puissances de calcul
                                      e               e                 ıtre                           e
colossales, ensuite prouver la validit´ sur un mod`le peut vite paraˆ suspect : qui dit que le mod`le est
                                                                                e              a
valide ? que le model checker est valide ? ... Alors que si vous trouvez une ex´cution amenant ` un bug, vous
avez une preuve tangible du bug.
                                                                             It has been an exciting twenty
                                                                             years, which has seen the research
                                                                             focus evolve [. . .] from a dream of
                                                                             automatic program verification to
                                                                             a reality of computer-aided design
                                                                             debugging.
                                                                                           Thomas A. Henzinger

1.6                      e
        Lectures conseill´es
                     e                                   e            ee             e
    Je me suis inspir´ des articles, cours et livres list´s dans les r´f´rences. Je d´cris rapidement ici ceux que
         e                        a
j’estime ˆtre de bons auxiliaires ` ce cours.

                            e                                                    e e
Livres. L’ouvrage [2] pr´sente les fondements du model checking, et est r´dig´ par trois des chercheurs les
                                                               a        e                                e
plus actifs du domaine. Le contenu de ce document aborde ` peu pr`s les six premiers chapitres. N’h´sitez pas
a                                                  c                    e                   e e              e
` aller voir les onze autres. Le livre [1] (en fran¸ais) est plus orient´ pratique que le pr´c´dent. La deuxi`me
                   e a                                                                                 e
partie est consacr´e ` l’utilisation des logiques temporelles du point de vue utilsateur, et la troisi`me partie
  e                                                          e
d´crit les model checkers (outil de model checking) acad´miques les plus connus.

                                                      e            e e       e
Notes de cours. Les notes de cours [4, 5] sont tr`s claires et tr`s d´taill´es. Le contenu est beaucoup plus
   e                                                                 e
th´orique qu’ici. [5] donne les preuves de correction et de complexit´ des algorithmes de model checking pour
CTL, LTL et CTL∗ . Quand ` [4], il traite du model checking par automate de LTL et surtout de CTL∗ , avec
                              a
                                                                       e
les constructions optimales par automates d’arbres alternants. Du tr`s haut niveau.

                                                e
Articles. Les trois articles [7, 8, 9] sont des ´tats de l’art sur certains points particuliers : comparaison
des logiques LTL et CTL [7], model checking par automates [8] et enfin histoire du model checking (orient´   e
                   e
automates quand mˆme), de la logique aux utilisations industrielles [9]. Enfin l’article [3] est un survey sur
              e                                                    e                e
l’emploi des m´thodes formelles dans l’industrie. Il est un peu dat´ (1996) mais tr`s instructif.


                                                        7
          e
     Premi`re partie

Bases du model checking




            8
Chapitre 2

   e                 e     e
Mod´lisation des syst`mes r´actifs

                   e        a                       e                          e      e
    Nous nous int´ressons ` une classe particuli`re de programmes : les syst`mes r´actifs. Le plus souvent
         e                                                            e                  ee
ces syst`mes interagissent avec leur environnement et sont distribu´s. Quelques propri´t´s remarquables de
         e
ces syst`mes :
                                e
    – ils ne terminent pas forc´ment ;
                               e                  o
    – ils ne calculent pas un r´sultat mais plutˆt maintiennent une interaction ;
                            e              o                      e          e
    – ils sont souvent dirig´s par le contrˆle : les types de donn´es manipul´s sont assez simples.
                                                             e
Quelques exemples typiques : protocole de communication, syst`me d’exploitation.
Contre-exemple typique : un compilateur.
                      e              e     e                                                   `e
    Le model-checking ´tudie des syst`mes r´actifs abstraits sous forme syntaxique de machines a ´tats. La
 e                        ae               e             e                                ae
s´mantique d’une machine ` ´tats est donn´e par un syst`me de transitions. Ces machines ` ´tats peuvent
e                                                   a e                             a
ˆtre plus ou moins complexes, allant des machines ` ´tats finis (= automates finis) ` de vrai programmes
                                                                 e                              e
(= machines de Turing). Cependant, plus le formalisme d’entr´e est puissant, moins on peut d´cider de
      ee
propri´t´s automatiquement.


2.1                        ae
        Syntaxe : machines ` ´tats
           e                               ae                                                        e
   Nous d´finissons d’abord les machines ` ´tats, qui seront notre formalisme syntaxique pour les syst`mes
e    e                     e
´tudi´s et le format d’entr´e potentiel d’un model-checker.
 e                          ae                     ae                                    u
D´finition 2.1.1 (Machine ` ´tats). Une machine ` ´tats est un quadruplet P = C, V, A, T o`
                              e             o
   – C est l’ensemble fini des ´tats de contrˆles,
   – V est l’ensemble fini des variables,
                                    a
   – A est un ensemble d’actions, c-`-d des formules logiques sur les variables V ,
   – T ⊆ C × A × C est un ensemble fini de transitions.

                              e                  ae         e                                       a    e
    La figure 2.1 ci-dessous pr´sente une machine ` ´tats mod´lisant le fonctionnement d’une machine ` caf´.
                                e                               e              o
Formellement, la machine est d´finie par P = C, V, A, T avec les ´tats de contrˆle C ={ idle,serving,serve},
les variables V = {x,paid}, les actions A sont d´finies par des op´rations arithm´tiques (tests, addition,
                                                  e                 e               e
        a e                                e
remise ` z´ro) et il y a 5 transition nomm´es money, cancel, choice, served, back. Par exemple, choice
     e
est d´finie par le triplet (idle,‘‘x ?=2,x :=0,paid :=true’’,serving).


2.2      e               e
        S´mantique : syst`mes de transitions
                                 ae                                                                       e
   Pour l’instant, notre machine ` ´tats P n’est que syntaxique. Pour simplifier les notations, nous consid`rerons
               e      e                                                              a
toujours associ´ une s´mantique aux variables et aux actions de la machine, c’est ` dire que :


                                                      9
                             x?<2, money, x:=x+1




                                                        x?=2, choice, x:=0, paid:=true
                                        idle                                                  serving



                   x?>0, cancel, x:=0




                                    back, paid:=false              served                served




                                              ae          e                    a    e
                           Fig. 2.1 – Machine ` ´tats repr´sentant une machine ` caf´.

        `
      – A chaque variable vi ∈ V est associ´ un domaine de d´finition Di . On notera D = D1 × . . . × D|V | .
                                              e                   e
        Une valuation de V est l’assignation ` chaque vi ∈ V d’une valeur di ∈ Di .
                                               a
      – Une configuration, ou ´tat, de la machine ` ´tat est un couple (q, d) ∈ C × D form´ d’un ´tat de
                                e                     a e                                        e      e
             o
        contrˆle q et d’une valuation des variables d.
        `
      – A chaque action a ∈ A est associ´e une relation binaire a ⊆ D × D. Informellement, (d, d′ ) ∈ a
                                           e
        signifie que si on effectue l’action a sur la valuation d, on obtient une nouvelle valuation d′ .
   Par exemple, pour la machine ` caf´, Dx = N et Dpaid = B. Le domaine D vaut donc N × B, soit des
                                    a     e
                                                        e
couples de valeurs pour les variables (x,paid). La s´mantique des actions est standard. Par exemple pour
                         a               e               a                          e      e
money, l’action ajoute 1 ` x si x est inf´rieurer strict ` 2, et laisse paid inchang´. On d´finit alors

             x? < 2, x := x + 1 = {((x, p), (x′ , p′ )) ∈ (N × B) × (N × B)|x < 2 ∧ x′ = x + 1 ∧ p′ = p}
    Intuitivement (x, p) repr´sente la valeur des variables avant l’action, et (x′ , p′ ) la valeur apr`s l’action. Si
                             e                                                                         e
x < 2, alors on l’incr´mente de 1 et donc x apr`s l’action vaut x avant l’action +1 (x′ = x + 1), tandis que
                      e                           e
p est inchang´ (p′ = p). Si x ≥ 2 l’action ne peut pas avoir lieu, cela se retrouve dans la d´finition donn´e.
              e                                                                                     e              e
Il n’y a pas de valeurs pour lesquelles x ≥ 2.
                                    ae                    e            e
      Le comportement d’une machine ` ´tats est alors donn´ par un syst`me de transitions.
                                                                                               − u
D´finition 2.2.1 (Syst`me de transitions). Un syst`me de transitions S est un triplet S = Q, T, → o`
 e                     e                           e
                          e
   – Q est l’ensemble des ´tats ou configurations,
   – T est l’ensemble des transitions,
                                                            t
   – − ⊆ S × T × S est la relation de transition. On note q − q ′ plutˆt que (q, t, q ′ ) ∈− .
     →                                                      →         o                    →
   Intuitivement, q ∈ Q repr´sente une configuration possible du syst`me r´actif ` un moment donn´, et
                              e                                          e     e       a                   e
  t  ′
q − q indique que si le syst`me est dans l’´tat q, alors en prenant la transition t il arrivera dans l’´tat q ′ .
  →                         e              e                                                           e

                     a e             e                                e
Passage machine ` ´tats - syst`me de transitions. La s´mantique d’une machine ` ´tats not´e         a e          e
P = C, V, A, T est donn´e par le syst`me de transitions S = C × D, T, → o`
                          e            e                                      − u
         e            e                                                             ae
   – les ´tats du syst`me de transitions sont les configurations de la machine ` ´tats.
                                                       t   ′ ′                   ′
   – la relation de transition − est d´finie par (c, d) − (c , d ) si t = (c, a, c ) avec a ∈ A et (d, d′ ) ∈ a .
                               →      e                →
  e                                     ae                       e                        e
D´finition 2.2.2. On parlera de machine ` ´tats finis quand le syst`me de transitions associ´ est fini. C’est
                                                                                      e
le cas notamment quand les domaines de variables sont finis. Par exemple variables bool´ennes, compteurs
                      e
modulo, compteurs born´s, etc.


                                                                10
                                           money                            money
                         idle,0,false                     idle,1,false                    idle,2,false



                                                 cancel

                       back                                                                 choice
                                                            cancel



                                        served,0,true                    serving,0,true
                                                            served




                                                  e                                a    e
                     Fig. 2.2 – Une partie du syst`me de transitions de la machine ` caf´.


Ex´cution du syst`me. Une ex´cution1 σ d’un syst`me S est une s´quence infinie (q1 , t1 ) . . . (qn , tn ) . . .
   e                 e                 e                   e               e
                                                    ti
                                                    →
d’´l´ments de Q × T telle que pour tout i, qi − qi+1 . Intuitivement, les qi se suivent par la relation de
  ee
transition. Le langage L(S) est l’ensemble des ex´cutions de S. Dans le cas des automates finis, et si on
                                                       e
projette les ex´cutions sur les ti , on retrouve la notion de mot2 et de langage de l’automate.
               e
                     a  e        e         e
Pour la machine ` caf´, des d´buts d’ex´cutions sont par exemple :
              money       money      choice        served         back        money
               − →(i,1,f)− −
    – (i,0,f)− −                      −−           −−             − →(i,0,f)− −
                           − →(i,2,f)− − →(sg,0,t) − − →(sd,0,t)− −            − → . . . (utilisateur normal)
               money         cancel       money        cancel         money
                −→           −−             −→         −−              −→
    – (i,0,f) − − (i,1,f) − − → (i,0,f) − − (i,1,f) − − → (i,0,f) − − (i,1,f) . . .                          e
                                                                                             (utilisateur ind´cis)
                e
Si on ne s’int´resse qu’aux transitions cela donne :
    – money, money, choice,served,back,money . . .                                           (utilisateur normal)
    – money, cancel,money, cancel,money . . .                                                                e
                                                                                             (utilisateur ind´cis)
                                 e                     e         e
    On pourrait aussi ne s’int´resser qu’aux suites d’´tats visit´es. D’ailleurs c’est ce qu’on fera.
                                e                            `e                                       `
Exercice 1. Pourriez-vous mod´liser sous forme de machine a ´tats : les automates finis, les automates a
                                              e      e
pile, les machines de Turing, un programme imp´ratif ´crit en C ?
                    e                                  `    e e      e `
Exercice 2. Le syst`me de transitions de la machine a caf´ pr´sent´ a la figure 2.2 n’est que partiel.
                e                           e                                         e
Pourquoi ? Compl´tez le pour obtenir le syst`me de transitions complet, et donnez sa d´finition formelle
          →
S = Q, T, − .


2.3        Structure de Kripke
                              e e           e                           e
  La structure de Kripke est d´riv´e du syst`me de transitions, et modifi´e avec les informations utiles au
model checking.

           e                             ee              e                                          e
    Pour r´ellement prouver des propri´t´s sur nos syst`mes, on va enrichir un petit peu nos syst`mes de
                                     ee                    e                         e           e     e
transitions, en ajoutant des propri´t´s atomiques sur les ´tats. Intuitivement, un ´tat s sera ´tiquett´ par
une propri´t´ p si p est vraie dans s. On va aussi ajouter un ´tat particulier s0 ∈ Q, consid´r´ comme l’´tat
            ee                                                e                              e e         e
               e                       e                       a
initial du syst`me. Ainsi toutes les ex´cutions commenceront ` partir de s0 .

          e                  e                       e
    En mˆme temps, on va ´galement enlever les ´tiquettes des arcs (les actions), car on fait le choix de ne
s’int´resser qu’` des propri´t´s sur les suites d’´tats visit´s3 .
     e          a           ee                    e          e
                                                                                      →
D´finition 2.3.1 (Structure de Kripke). Un structure de Kripke M est d´finie par M = Q, − , P, l, s0 o`
 e                                                                   e                              u
  1 On dit aussi un chemin.
  2 Bien                    o     e    e
         qu’ici on soit plutˆt int´ress´ par les mots infinis.
  3 On retrouve facilement des propri´t´s sur les actions en ajoutant a P des atomes comme : “l’action a vient d’avoir lieu“
                                        e e                           `


                                                              11
   –                          e
       Q est l’ensemble des ´tats ou configurations,
   –   →
       − ⊆ Q × Q est la relation de transition,
   –   P est un ensemble de propositions atomiques,
   –   l : Q → 2P est la fonction d’´tiquettage des ´tats,
                                    e               e
   –   s0 ∈ Q est l’´tat initial.
                    e
                →                                    →
   Si on note − M la relation de transition sur M et − S la relation de transition sur S, on a le lien suivant :
                                          t
q − M q ′ ssi il existe t ∈ T telle que q − S q ′ .
  →                                       →

    La notion d’ex´cution est modifi´e en cons´quence, en ne conservant que les ´tats. On notera L(M, s)
                   e               e          e                                 e
l’ensemble des ex´cutions de M partant de l’´tat s, et le langage de M sera d´fini par L(M) = L(M, s0 ).
                 e                          e                                e

                                                  a   e             e    e
Exemple. On reprend l’exemple de la machine ` caf´. On consid`re l’´tat initial correspondant `    a
                                            ee                                          e             o
    (idle,c=0,paid=false) et les propri´t´s atomiques m : paid = true, et s vrai si l’´tat de contrˆle est
                                                           e                                          e    e
dans served. On obtient alors la structure de Kripke compl`te suivante. Notez que cette fois on a repr´sent´
                                                e      a                                                e
toute la structure, et non une partie. On peut v´rifier ` partir de la structure de Kripke que si un caf´ est
                              ee     e
servi (s), c’est qu’il a bien ´t´ pay´ (m).

                              not m, not s                    not m, not s                 not m, not s




                                                   m, s                         m, not s




                                                                                a    e
                                Fig. 2.3 – La structure de Kripke de la machine ` caf´.


D´pliage. Le d´pliage (unfolding) d’une structure de Kripke4 est un arbre infini dont la racine est l’´tat
  e                 e                                                                                          e
initial de la structure, et chaque nœud de l’arbre a pour successeur ses successeurs par la relation de transition.
        e                                                                                              e
La diff´rence avec la structure de Kripke est qu’on n’identifie plus les nœuds correspondants aux mˆmes ´tats. e
     e                                                  e
Le d´pliage permet de visualiser plus facilement les ex´cutions possibles de la structure. Par exemple, la figure
       e           e                                                            a    e
2.4 pr´sente le d´pliage (partiel) de la structure de Kripke de la machine ` caf´. Les noms des transitions
     ee         e
ont ´t´ ajout´s pour simplifier la lecture.
                                               e              o                           e           e
Exercice 3 (Exemple de l’ascenceur.). Le syst`me de contrˆle d’un ascenceur (pour 3 ´tages) est d´fini par :
            o                 e        e                    e
  – le contrˆleur garde en m´moire l’´tage courant et l’´tage cible.
                           e                                                        o
  – en mode actif, quand l’´tage cible est atteint, les portes s’ouvrent et le contrˆleur passe en mode attente.
                            e                    e e          e                       o           e
  – en mode actif, quand l’´tage cible est plus ´lev´ que l’´tage courant, le contrˆleur fait s’´lever l’ascen-
    ceur.
                              e                        e e         e                        o
  – en mode actif, quand l’´tage cible est moins ´lev´ que l’´tage courant, le contrˆleur fait descendre
    l’ascenceur.
                                                                                                    e
  – en mode attente, il se peut que quelqu’un entre dans l’ascenceur et choisisse un nouvel ´tage cible.
    L’ascenceur ferme alors les portes et redevient actif.
  4 On                                 e                                   e
         peut faire pareil avec un syst`me de transitions si on choisit un ´tat initial.




                                                                 12
                                                  not m, not s


                                                  money



                                                  not m, not s

                                        cancel                      money


                              not m, not s                            not m, not s


                            money                          cancel              choice



                         not m, not s             not m, not s              m, not s




                            e                                                         a    e
                Fig. 2.4 – D´pliage (partiel) de la structure de Kripke de la machine ` caf´.


                                         ` e        e               o                    e
Questions : 1. Proposez une machine a ´tats mod´lisant le contrˆle de l’ascenceur (d´finition formelle et
             e                           e
dessin). 2. D´finissez et dessinez le syst`me de transitions correspondant. 3. Dessinez la structure de Kripke
                                                                e
correspondante si on prend comme propositions atomiques A : ˆtre actif et OPEN : portes ouvertes. 4. Est-ce
que les portes peuvent s’ouvrir quand l’ascenceur est actif ?


2.4     Discussion sur la terminologie
                   e e                         e                            a
    Les termes pr´c´dents ne sont pas fix´s et varient d’un ouvrage ` l’autre. La notion de syst`me de   e
                                                       a
transitions vient de l’informatique et est un peu lˆche, tandis que celle de structure de Kripke vient des
                                                            e`
logiques modales. Cependant un terme est parfois utilis´ a la place de l’autre. On peut aussi mettre ou non
    e                        e
un ´tat initial ou diverses ´tiquettes, sur les configurations ou sur les transitions. On pourrait ainsi appeler
                                      e                   e      e            e            e
nos structures de Kripke des “syst`mes de transition ´tiquet´s et initialis´s”. On peut ´galement fusionner
                                      e                                                    e
nos structures de Kripke et nos syst`mes de transitions en une unique structure (avec le d´tail des transitions,
          ee     e           e
les propri´t´s d’´tat et les ´tats initiaux), ce qui est plus proche d’une implantation effective.

                                                          e
   Pour conclure, dans les autres chapitres nous ne consid`rerons plus que des structures de Kripke car c’est
 e                                                                          a
r´ellement ce qui sert dans le model checking. Cependant il faut garder ` l’esprit que cette structure de
                          e                    e                                      ae
Kripke provient d’un syst`me de transitions d´fini syntaxiquement par une machine ` ´tats.


2.5                e            e e                e
        Espace des ´tats, propri´t´s d’accessibilit´ et d’invariance
                   e                       e             e                               a
    L’espace des ´tats est l’ensemble des ´tats d’un syst`me de transitions accessibles ` partir d’une configu-
                                              e                                e
ration initiale en suivant les chemins du syst`me de transitions. L’espace des ´tats a une structure plus simple
            e
que le syst`me de transitions explicite puisqu’on ne garde que les configurations en oubliant la structure de
                  e                                e                            ee
graphe, et en mˆme temps il est suffisant pour v´rifier deux types de propri´t´s simples mais importantes :
              e
l’accessibilit´ et l’invariance.
                                              −
    Soit un syst`me de transitions S = Q, T, → , et q ∈ Q une configuration arbitraire. La relation d’acces-
                e
                                                                                     t
                                                                                     →
sibilit´ en un coup, not´e post, est d´finie par post = {(q1 , q2 ) ∈ Q × Q|∃t ∈ T.q1 − q2 }. On d´finit ensuite
       e                e             e                                                          e
                    i         0              n+1                   n
r´cursivement post par post = I, et post
 e                                                = post • post . Enfin on d´finit la relation d’accessibilit´
                                                                               e                             e
post∗ par post∗ = i∈N posti . Les ´tats accessibles en un coup ` partir de q sont donn´s par post(q), c’est `
                                    e                              a                    e                    a


                                                      13
dire les q ′ tels que (q, q ′ ) ∈ post. Les ´tats accessibles ` partir de q sont donn´s par post∗ (q). On ´tend ces
                                            e                 a                      e                    e
d´finitions naturellement ` des ensembles X ⊆ Q, avec par exemple post(X) = x∈X post(x).
 e                              a
                                                                      −
D´finition 2.5.1 (Invariant). Soit un syst`me de transitions S = Q, T, → . On appelle invariant de S tout
  e                                      e
I ⊆ Q tel que post(I) ⊆ I.
D´finition 2.5.2 (Point fixe). Soit un ensemble K et τ : 2K → 2K . On dit que X ⊆ K est un point fixe de
  e
τ si τ (X) = X.
                                                     →
Exercice 4. Soit un syst`me de transitions S = Q, T, − et q0 ∈ Q une configuration initiale. On note Post
                         e
la fonction d´finie par Post(X) = post(X) ∪ X, et Postq0 la fonction d´finie par Postq0 (X) = post(X) ∪ {q0 }.
             e                                                       e
Montrez que :
  1. l’ensemble d’accessibilit´ post∗ (q0 ) est le plus petit invariant de S contenant q0 ;
                              e
  2. l’ensemble d’accessibilit´ post∗ (q0 ) est le plus petit point fixe de Post contenant q0 ;
                              e
  3. l’ensemble d’accessibilit´ post∗ (q0 ) est le plus petit point fixe de Postq0 ;
                              e
                                              k
  4. il existe k ∈ N tel que post∗ (q0 ) =    0   posti (q0 ) ;
  5. il existe k ∈ N tel que post∗ (q0 ) = Posti (q0 ) ;
  6. il existe k ∈ N tel que post∗ (q0 ) = Posti 0 (∅).
                                               q

    L’exercice ci-dessus donne un moyen tr`s simple de calculer post∗ (q0 ) dans le cas fini sous l’hypoth`se, tr`s
                                          e                                                              e      e
raisonnable, que les ensembles post(X) sont simples ` calculer. Il suffit d’it´rer l’op´ration X := post(X) ∪ X
                                                     a                        e        e
en partant de X := {q0 }.

        e e                   e                                ee
Propri´t´s d’accessibilit´ et d’invariance. Les propri´t´s les plus simples qu’on puisse vouloir v´rifier   e
                          e                          e              u
sont celles d’accessibilit´, du type “il existe un ´tat accessible o` x vaut 0”, et celles d’invariance, du type
                e                           e                                         ee               e
“dans tous les ´tats accessibles x est diff´rent de 0”. On dira que dans une propri´t´ d’accessibilit´ on teste
                              e              e                                       ee
si un ensemble de mauvais ´tats A peut ˆtre atteint, tandis que dans une propri´t´ d’invariance on teste si
    e                                                    e
les ´tats accessibles restent dans un bon ensemble d’´tat I.
    Ces propri´t´s sont simples ` v´rifier une fois que post∗ (q0 ) a ´t´ calcul´ :
               ee                 a e                                 ee       e
    – accessibilit´ : A accessible ssi post∗ (q0 ) ∩ A = ∅.
                  e
    – invariance : I est v´rifi´ ssi post∗ (q0 ) ⊆ I.
                            e e
                 e                                                    e            e                   o     a
    On peut am´liorer le calcul en faisant les tests ensemblistes apr`s chaque it´ration de post plutˆt qu’` la
                                                                                        e
fin. On y gagne respectivement si l’ensemble est accessible ou si l’invariant est viol´. Sinon il faut de toute
mani`re calculer post∗ (q0 ) en entier pour conclure.
      e
                                               e
Exercice 5. Quel est le lien entre accessibilit´ et invariance ?

                  e               e           e                                          e
Co-accessibilit´. On peut d´finir symm´triquement la relation de co-accessibilit´ en un coup pre par
pre = post−1 , et on d´finit prei , pre∗ , pre(q), pre(X), pre∗ (q) et pre∗ (X). Un algorithme de calcul it´ratif
                        e                                                                                 e
de pre∗ (q) est possible. La diff´rence principale est que pre(q) n’est pas toujours ´vident ` calculer, mˆme si
                                e                                                   e       a            e
                                                  e    e
dans le cas fini on peut toujours s’en sortir en ´num´rant.
Exercice 6. Comment v´rifier une propri´t´ d’accessibilit´ en passant par le calcul de pre∗ ? Et pour l’in-
                     e                ee                e
variance ?

                                       ee                e                                       e
Remarques diverses. Les propri´t´s d’accessibilit´ et d’invariance sont simples mais extrˆmement impor-
                                               e                           e       o
tantes en pratique. On remarque que leur v´rification a une complexit´ polynˆmiale dans le nombre d’´tats     e
        e                                                                                a e
du syst`me de transitions, donc souvent exponentielle dans la taille de la machine ` ´tats initiale si on a
des variables pouvant prendre beaucoup de valeurs. C’est toute l’histoire du model checking fini : se battre
                           e
contre cette explosion d’´tats.
                              e                                               e
   Les avantages et inconv´nients des calculs en avant (post) et en arri`re (pre) ont fait couler beaucoup
                                        e                                                       e            e
d’encre, mais il n’y a pas de solution d´finitive. Le calcul en avant ne prend en compte que les ´tats du syst`me,

                                                              14
                                                              a            `                            e
mais cherche un peu au hasard sans s’occuper de l’objectif ` atteindre. A l’inverse le calcul en arri`re est
                                                      e
contraint par l’objectif, mais rique de s’encombrer d’´tats qui n’appartiennent pas au comportement normal
       e                   u              ea                                  e                            e
du syst`me. Dans le cas o` on dispose d´j` d’un invariant I, il est souvent tr`s efficace de calculer en arri`re
            a
en coupant ` chaque fois avec l’ensemble I.
   Enfin remarquez que les algorithmes de calcul de post∗ (q0 ) et pre∗ (q0 ) pr´sent´s ici ne fonctionnent pas
                                                                               e    e
            e
sur des syst`mes infinis.


2.6          e
         Syst`mes concurrents
                   e      e                             e                                  e
    Comme les syst`mes r´actifs sont souvent distribu´s, il sera plus simple de les mod´liser comme des
                            ae                        e                 e
ensembles finis de machines ` ´tats concurrentes (s’ex´cutant en parall`le). Il y a de nombreux travaux sur
    e                                                                               e
la s´mantique de la concurrence. Voici quelques distinctions classiques sur les syst`mes concurrents.

              e                    e                           e
Modes d’ex´cution. Un syst`me synchrone est rythm´ par une horloge global, et tous ces composants
          a     e                a                                                                  e
avancent ` la mˆme vitesse, c-`-d une action par tick d’horloge. Donc une transition du syst`me globale est
    e                      e
le d´clechement simultan´ d’une transition de chaque composant. Formellement, si on note Ti les transitions
de la machine Pi et T les transitions de la machine compos´e P1 × . . . × Pn , alors T = T1 × . . . × Tn . Les
                                                                  e
processeurs sont typiquement synchrones.
                            e
    Au contraire, un syst`me asynchrone n’a pas d’horloge globale, et une transition du syst`me globalee
est soit (s´mantique 1) une transition d’un seul des composants et T = ∪i Ti (dans ce cas il n’y jamais
           e
                         e            e
deux actions simultan´es) ; soit (s´mantique 2) un ensemble d’au plus une transition par composant et
T = (T1 + ε) × . . . × (Tn + ε) o` ε d´signe l’action qui ne fait rien (ici les actions simultan´es sont possibles).
                                 u    e                                                         e
Les protocoles de communication sont typiquement asynchrones.

Modes de communication. Les composants peuvent interagir en modifiant des variables communes ou
en s’envoyant des messages.
                          e          e                                      e
     Dans le cas de la m´moire partag´e, chaque machine a ses variables priv´es et il existe un pool de variables
                      e                          e           e                    e                         e
communes / partag´es. L’avantage est l’efficacit´, la difficult´ principale est l’acc`s concurrent aux donn´ees :
un composant rique de modifier une valeur qu’un autre composant voulait stocker.
                                                                                       a
     Dans le cas des envois de messages, un composants peuvent envoyer un message ` un autre composant via
                                                      e                                               e
un canal de communication FIFO. Il peut y avoir diff´rents canaux de communication, ils peuvent ˆtre priv´s     e
                                 e                                                          e
ou communs, en lecture ou en ´criture, avoir des bornes sur le nombre de messages pr´sents simultan´ment   e
             e
ou encore ˆtre plus ou moins fiables, par exemple si la perte de messages est possible. Normalement l’envoi
                        e                            e                                                e
d’un message et sa r´ception ne sont pas synchronis´s : le composant qui envoie continue sont ex´cution, et
     e                    e
le r´cepteur lira peut ˆtre le message plus tard.
           e              e
     Un m´canismes tr`s classique d’envoi de message permet de synchroniser deux composants : le rendez-
                                                   e                                     e
vous (ou handshaking). Dans le rendez-vous, un ´metteur envoie sur un canal priv´ un message et attend
         e                                           e                                     e
que le r´cepteur lui retourne un acquittement de r´ception sur un autre canal priv´. Vu de loin, tout se
                                e                    e                e
passe comme si l’envoi et la r´ception du message ´taient simultan´s. Ainsi quand l’envoyeur reprend son
   e               a                                       e              e
ex´cution, il sait ` quel point de programme se trouve le r´cepteur, et r´ciproquement.
                                e                           a
     Enfin dans le broadcast un ´metteur diffuse un message ` tous les autres participants, et souvent n’attend
pas d’acquittement.

                  e
Exemples de syst`mes concurrents.
                                               e
  – threads JAVA : asynchrone, variables partag´es.
  – processus UNIX : asynchrone, envoi de messages.
                e                                                            e
  – composants ´lectroniques dans un processeur : synchrone, variables partag´es.
  – agents d’un protocole de communication internet : asynchrone, envoi de messages.
  – calculateur massivement parall`le GALS5 : synchrone + asynchrone, variables partag´es et messages.
                                  e                                                   e
  5 Globally   Asynchronous Locally Synchronous.



                                                        15
                                                             ee                         e
Machines concurrentes en pratique. Voici quelques ´l´ments classiques de mod´lisation de syst`mes          e
                                                    ae
concurrents. On se donne un ensemble de machine ` ´tats.
                              e                                                                        e
   – Le produit synchronis´ (surtout le choix des transitions possibles) se fait selon le mode d’ex´cution
     choisi.
                            e        e                                                e
   – Les variables partag´es s’int`grent facilement en identifiant les variables de mˆme nom des diff´rentse
                                                      e    e
     composants, ou en rajoutant des contraintes d’´galit´ entre variables.
                                         e
   – On peut rajouter des contraintes sp´cifiques de synchronisation, dites vecteurs de synchronisation, c’est
     a                                                        e                e
     ` dire que certains groupes de transitions ne peuvent ˆtre que simultan´es. Cela permet de mod´liser e
                                               e e                           a                       e e
     des rendez-vous et des situations plus g´n´rales, dues par exemples ` des parties non mod´lis´es du
          e            ee e                e
     syst`me (propri´t´s ´lectroniques, m´caniques, etc.)
   – Parfois seuls les rendez-vous sont disponibles : dans ce cas les synchronisations se font toujours entre
                          e          e     e                             e       e        e
     deux transitions, l’´metteur ´tiquett´ !m envoie le message m au r´cepteur ´tiquett´ ?m. Les deux tran-
                          e                          e           e
     sitions ne peuvent ˆtre franchies que simultan´ment, mod´lisant l’envoie du message avec attente (et
      e                     e     e            e
     r´ception) de l’accus´ de r´ception. La r´ception et l’envoi sont bloquants.
             e
   – Des op´rations de broadcast sont plus rarement disponibles.
                        ee          e                                               e
   – Enfin on peut pr´f´rer mod´liser l’envoi de messages en utilisant un type sp´cifique de variables par-
         e
     tag´es : les files de communication. Dans ce cas, ?m signie lire le message m en queue de file et !m signie
                                e                          e                a                       e
     mettre le message m en tˆte de file. Les files peuvent ˆtre parfaites ou ` pertes, de taille born´e ou non.
              e                     e                                  e
     La mod´lisation est plus fid`le que les rendez-vous, mais le syst`me obtenu est plus complexe.

Entrelacement et explosion combinatoire. En g´n´ral, le comportement de la machine P1 × P2 est
                                                           e e
                                                                                             e   e
beaucoup plus complexe que le comportement de P1 ou P2 . C’est ce qu’on appelle le ph´nom`ne d’explosion
combinatoire : le syst`me de transitions de P1 × P2 (dans le cas fini) a une taille beaucoup plus grande que
                       e
|S1 | + |S2 |, dˆ aux entrelacements de transitions possibles. Typiquement pour deux syst`mes asynchrones
                u                                                                              e
(1) sans variable partag´e ni synchronisation, |S| = |S1 | × |S2 | en nombre d’´tats, et le nombre de transitions
                          e                                                    e
                                  e
augmente plus, surtout avec la s´mantique asynchrone (2).
Exercice 7. Soit les machines concurrentes suivantes.
                                           1                       3
                                                                              5




                                            2                       4



                                    e
Quelles sont les transitions du syst`me concurrent dans les cas suivants :
      e
  1. s´mantique synchrone ;
      e
  2. s´mantique asynchrone (1) ;
      e
  3. s´mantique asynchrone (2) ;
      e
  4. s´mantique synchrone + synchronisation entre 1 et 4 ;
      e
  5. s´mantique asynchrone (1) + synchronisation entre 1 et 4 ;
      e
  6. s´mantique asynchrone (2) + synchronisation entre 1 et 4 ;
Quel est le lien entre vecteur de synchronisations et rendez-vous ?


2.7           e      e    e
        Hypoth`ses d’´quit´
                                  e     a          e                                              e
    Le processus d’abstraction inh´rent ` toute mod´lisation peut introduire des comportements irr´alistes,
                                    e
soit impossibles dans la machine r´elle soit hautement improbables. De tels comportements peuvent ˆtre e
                                            e                                          e
par exemple : rien ne se passe dans le syst`me, un canal de communication perd syst´matiquement tous
                                                                                 e e
les messages, un composant n’a jamais la main, etc. Ces comportements sont tr`s gˆnants en pratique car

                                                       16
                                          e                              e             e     a
ils risquent de fausser l’analyse du mod`le, par exemple si les seules ex´cutions qui m`nent ` une erreur
     e    e          e
s’av`rent ˆtre des ex´cutions aberrantes.
               e      e      e                         e
    Les hypoth`ses d’´quit´ permettent justement d’´carter ces chemins aberrants en se restreignant aux
         e                 a                                  e              e    e                      e    a
chemins ´quitables, c’est ` dire ceux le long desquels le syst`me progresse r´guli`rement, selon des crit`res `
  e                 e      e    e     e
d´finir. Une hypoth`se d’´quit´ peut ˆtre par exemple que tout composant obtient la main infiniment souvent
               e                          e                          e      e    e
le long de l’ex´cution. Il y a deux mani`res de rajouter des hypoth`ses d’´quit´ : en modifiant la formule `   a
  e                                    e
v´rifier ou en modifiant (un peu) la s´mantique du mod`le.   e

´     e                                         e                  ee         e
Equit´ dans les formules. Comme on veut v´rifier une propri´t´s exprim´e par une formule de logique
ϕ, on va alors v´rifier plutˆt une formule ψ → ϕ o` ψ d´crit nos contraintes d’´quit´. Cette solution est tr`s
                e          o                     u    e                       e    e                       e
                  e                                                                  a e
souple mais elle n´cessite des logiques suffisament expressives, et donc plus difficiles ` v´rifier automatique-
ment.

´       e                e                       ee                              e
Equit´ dans le mod`le. On peut aussi pr´f´rer modifier directement la s´mantique des syst`mes de e
                                                                                      e       e e
transitions en ne conservant que les chemins passant infiniment souvent par certains ´tats sp´cifi´s par
                                                    e    e
l’utilisateur. On peut ainsi simuler des formules d’´quit´ suffisantes en pratique.
    Techniquement, on ajoute au syst`me de transitions un ensemble fini F d’ensembles d’´tats Fi ⊆ Q
                                        e                                                 e
       e               e     e        e                    e             e
appel´s contraintes d’´quit´. Une ex´cution fair du syst`me est une ex´cution passant infiniment souvent
par chaque Fi . Du coup L(M) et LF (M) sont diff´rents, et certaines configurations qui ´taient accessibles
                                                     e                                 e
                   e              e
peuvent ne plus l’ˆtre avec une s´mantique f air.
Exercice 8 (**). Comment calculer post∗ et pre∗ dans le cas d’un syst`me de transitions avec hypoth`ses
                                      F       F                      e                             e
  e    e           e
d’´quit´ sur le mod`le ?

´      e                              a e                                             e       e
Equit´ et produit de machines ` ´tats. On pourrait penser que les hypoth`ses d’´quit´ ne doivent   e
e         e
ˆtre ajout´es qu’exceptionnellement. Il n’en est rien, c’est au contraire quasi-obligatoire si on passe par des
          ae                                        ea              e                       e
machines ` ´tats finis concurrentes. Remarquons d´j` que le mod`le sous-jacent des syst`mes de transitions
                                           e e                    u        e
assure implicitement que ne sont consid´r´s que les chemins o` le syst`me fait quelquechose s’il le peut.
       e                                  e e e e e       e
Cela r`gle “gratuitement” un des cas d´g´n´r´s ´voqu´s plus haut. Malheureusement si on consid`re des   e
                                     e                                e                              a
machines concurrentes, cette hypoth`se implicite s’applique au syst`me de transitions total et pas ` chacune
                                   e         e                        e
des machines. Ainsi, sans hypoth`se suppl´mentaire, il se peut tr`s bien qu’une des machines monopolise
          e
toute l’ex´cution tandis que les autres la regardent.


2.8           e e      u e
        Propri´t´s de sˆ ret´.
                                                       e                                        e
   On peut aller avec de simples calculs d’ensembles d’´tats un peu plus loin que l’accessibilit´ et l’invariance.
  e                          e                             ee       u e
D´finition 2.8.1. On d´finit informellement les propri´t´s de sˆ ret´ comme celles stipulant que “quelque-
                                              e
chose de mauvais n’arrive jamais”. Une d´finition semi-formelle pratique est que quand une propri´t´ de   ee
 u              e                                          a            e                               ee
sˆ rete est viol´e, il existe un contre-exemple fini. C’est ` dire une ex´cution finie qui viole la propri´t´.
                                                             u e                           e
   Ainsi par exemple l’invariance est un cas particulier de sˆret´, mais pas l’accessibilit´. Il y a d’autres
      ee       u e                                e    `                             e
propri´t´s de sˆ ret´, par exemple “je ne peux acc´der a mon compte sans avoir donn´ le bon password.”
                                                           ee     u ea               e                 a
    En principe on peut ramener n’importequ’elle propri´t´ de sˆ ret´ ` du calcul d’´tats accessibles, ` condi-
                          e        e                                                                 e
tion de modifier le syst`me de d´part. L’avantage est d’utiliser des techniques simples et homog`nes, l’in-
     e                                e            e      e
conv´nient est que le nouveau syst`me modifi´ peut ˆtre beaucoup plus large que l’ancien. Il y a deux
     e
mani`res de faire : l’ajout de variables d’historique ou la synchronisation avec un automate observeur. Nous
                            e
allons illustrer les deux m´thodes sur des exemples.




                                                       17
                                                           e               ee                     e
Variables d’historique. Admettons que l’on veuille v´rifier la propri´t´ ϕ : “Lors d’une ex´cution, l’´tat   e
         o                       e         e           o
de contrˆle p est toujours visit´ avant l’´tat de contrˆle q”. On rajoute une nouvelle variable h qui vaut 0
                      a                            e     a     e         e               ee            a e
dans q0 , et est mise ` 1 par les transitions qui m`nent ` p. D`s lors, v´rifier la propri´t´ ϕ revient ` v´rifier
dans notre syst`me modifi´ la propri´t´ d’invariance I : “tous les ´tats accessibles v´rifient q → (h = 1) ”.
                 e         e           ee                           e                  e
                                              e               ee       u e
   Les variables d’historique permettent de v´rifier des propri´t´s de sˆ ret´ en se souvenant de certains faits
    e              e                     e                             e
pass´s lors de l’ex´cution. Il y a deux d´savantages : le nouveau syst`me de transitions est plus large, par
                                                                 e
exemple au pire deux fois plus large si on rajoute juste un bool´en, et surtout il faut un nouveau syst`me e
       e                    ee                 e           a                             a                 e
modifi´ pour chaque propri´t´ ce qui peut s’av´rer difficile ` maintenir. On peut pallier ` ce dernier probl`me
par le biais d’automates observeurs.

                                 e
Automates observeurs. L’id´e est de mettre toutes les variables d’historique dans une machine ` ´tats ae
` part (automate observeur) qui sera synchronis´e avec le syst`me initial. On ne gagne pas en expressivit´
a                                                e             e                                           e
                                                                                               e         e
(on pourrait coder l’automate observeur par des variables d’historique) mais on gagne en clart´ : le syst`me
                                                          e e` e
ne change pas et il y a un automate observeur par propri´t´ a v´rifier.
                                                                                       a
   Pour l’exemple ci-dessus, l’automate observeur aurait une variable h initialement ` 0 et des transitions
           a              e                              e                  a e              o
mettant h ` 1, synchronis´es avec les transitions du syst`me initial menant ` l’´tat de contrˆle p.
                                  e                                                         e
Exercice 9. On se donne un syst`me de transitions S dont certaines transitions sont distingu´es et corres-
         `       e
pondent a des op´rations d’aquisition de verrou (lock), de rendu de verrou (unlock), de lecture (read) et
  e                                      ee
d’´criture (write). On se donne la propri´t´ ϕ suivante :
                                                                      e e e
     Si on ne regarde que les lock et unlock : unlock est toujours pr´c´d´ directement de lock et lock
                                                                                                   e e e
est toujours suivi directement de unlock, ET une suite arbitraire de read,write est toujours pr´c´d´e
                              e
directement d’un lock et ferm´e directement par un unlock.
    Questions :
                                ee      u e                    a        e
  1. Est-ce que ϕ est une propri´t´ de sˆret´ ? Sinon modifiez l` en cons´quence.
     ´                                     e                                                         ee`
  2. Ecrivez un automate observeur pour v´rifer ϕ (ou sa modification) et expliquez la nouvelle propri´t´ a
      e
     v´rifier.

                               ee                 e                                      ` a
Remarque. Pour des propri´t´s plus compliqu´es, par exemple “un jour j’arriverai a L`-bas”, on ne peut
                 a                 e                       e
plus se ramener ` de l’accessibilit´. Intuitivement, la diff´rence est que les contre-exemples sont maintenant
                                                                  e                                   e
infinis, puisque ce n’est pas parceque je ne suis pas encore arriv´ que je n’arriverai jamais. On peut ´tendre
     e                                                                                            a
la m´thode en synchronisant cette fois avec des automates de mots infinis. Cette technique est ` la base du
                           e    e
model checking de LTL pr´sent´ plus loin.


2.9                            e
         Quelques points de mod´lisation
                                          e                        e                         ` e
    Cette section regroupe quelques consid´rations sur certains m´canismes des machines a ´tats et leur
      e            e                            `                                                  e
utilit´ pour la mod´lisation. Cependant, gardez a l’esprit que ce cours n’est pas un cours de mod´lisation.
                e                e                                 e
Nous ne consid´rons que des mod`les assez simples, et nous nous int´ressons surtout aux structures de Kripke
 e e
d´riv´es.

        e                                                       e        e
Non d´terminisme. La relation de transition n’est pas forc´ment d´terministe. Formellement, cela signifie
                                                                                                               t
que dans nos syst`mes de transitions, il peut y avoir une transition t et trois ´tats q, q ′ , q ′′ tels que q − q ′
                     e                                                            e                            →
      t
et q − q ′′ . Ainsi, partant de la configuration q et effectuant la transition t, on peut aller arbitrairement `
     →                                                                                                            a
q ou ` q ′ . Il y a deux utilisations principales : d’une part mod´liser des choix de l’environnement dans les
      a                                                           e
    e                                                 ee              e
syst`mes ouverts, d’autre part abstraire certains ´l´ments du syst`me initial trop complexes ou remplacer
                                e
un des composants par sa sp´cification.




                                                        18
                                           e                                e
Actions observables. On peut consid´rer que seules certaines actions/´tats de la machine sont observables
                      e                                    e      e       e                 e
par un utilisateur ext´rieur, ou encore que le label observ´ peut ˆtre diff´rent de l’action/´tat. Dans ce cas, on
                                           e              e e                                               e
peut avoir deux labels : un label d’action/´tat comme pr´c´demment, et un label observable. Les actions/´tats
                             e       e
non observables sont alors ´tiquett´es ε. On retrouve un peu la notion d’ε-transitions des automates finis.

                                                                             e
Types classiques de variables. Les types de variables suivants sont tr`s classiques pour les machines `    a
e              e                              e
´tat : les bool´ens, les piles (appels de proc´dure), les files FIFO (canaux de communication), les compteurs
                                               e
(ressources) et les horloges (aspects temps-r´el).

            e    e                           ae                        e                       ea    e
Modularit´, hi´rarchie. Les machines ` ´tats sont un formalisme tr`s simple et bien adapt´ ` la v´rification.
                           e               e          e            e
Malheureusement il est tr`s laborieux d’´crire des sp´cifications r´alistes par ce biais, car les constructions
                                   e
offertes sont de trop bas niveau mˆme avec la synchronisation de composants. Les concepteurs aiment utiliser
                       e       e                                                     e                 e
des constructeurs plus ´labor´s comme par exemple des modules (un composant est d´fini une fois et r´utilis´  e
a                                e                                           e
` plusieurs endroits) et de la hi´rarchie (des composants simples sont associ´s en composants complexes via
    e       e                                                                   e
diff´rents m´canismes). Certains model checkers proposent des langages d’entr´e avec de tels constructions,
par exemple AltaRica (Uni. Bordeaux) ou SMV.
              e                                 e                      u                  e
    Pour la v´rification de ces formalismes ´tendus, on peut bien sˆ r calculer le syst`me de transitions
puis se ramener aux techniques usuelles. Une meilleur solution est d’essayer d’adapter les techniques de
  e                 e                                                               e e
v´rification au mod`le de haut niveau, pour profiter du niveau d’abstration plus ´lev´. Cependant il n’y a
                     e        e
malheureusement gu`re de r´sultats en ce sens actuellement.

     e                          e                                                     e               e
Syst`mes ouverts. Les syst`mes ouverts interagissent avec un environnement ext´rieur. Le syst`me re¸oit     c
                                                                           e
des informations par des capteurs (ex : mesurer la profondeur d’un r´servoir), et peut parfois agir sur
                                                                                            e
l’environnement via des actionneurs (ex : ouvrir ou fermer les vannes du barrage). On doit v´rifier la correction
        e
du syst`me pour toute suite d’actions de l’environnement. Selon les cas, l’environnement peut soit ˆtre     e
     e e                             ae                   e                                      e
mod´lis´ comme une autre machine ` ´tats (souvent ind´terministe) concurrente de notre syst`me, ou alors
  e                                                                                                     a e
d´crit par des formules de logiques restreignant son comportement. Ce dernier cas est plus complexe ` g´rer.




                                                       19
Chapitre 3

Logiques temporelles

                                                                                    e        e
    Ce chapitre introduit les logiques temporelles, qui seront le formalisme employ´ pour sp´cifier les com-
                                   e     e              o e
portements attendus de nos syst`mes r´actifs. D’un cˆt´, ces logiques surpassent les autres moyens usuels
      e
de sp´cification du comportement, que ce soit le langage naturel (trop ambigu) ou des formalismes ` basea
                                                                                                    a
de diagrammes (peu expressifs et souvent ambigus). De l’autre, elles sont plus concises et faciles ` lire que
                    e                e e
des langages de sp´cification plus g´n´ralistes (comme la logique du premier ordre). Enfin, et surtout, leur
 e                e              e                                         e
v´rification peut ˆtre automatis´e, contrairement aux exemples mentionn´s ci-dessus.
        e
    Apr`s avoir introduit intuitivement la notion de logique temporelle et les principaux concepts, on va
pr´senter formellement les trois logiques temporelle LTL, CTL∗ et CTL. LTL est une logique lin´aire, c-`-d
  e                                                                                               e       a
           e            e                e                                                      e
qu’on s’int´resse aux ex´cutions du syst`me sans prendre en compte les entrelacements des diff´rents futurs
possibles. CTL∗ est la logique la plus expressive que nous verrons. C’est une logique branchante. Enfin CTL
est aussi une logique branchante, moins expressive que CTL∗ , mais le model-checking est beaucoup plus
facile.


3.1                       e e
        Panorama de propri´t´s temporelles
                          e                ee                          e                          eae e
    Voici une liste de cat´gories de propri´t´s temporelles utiles en v´rification. Certaines ont d´j` ´t´ men-
     e                   e e
tionn´es au chapitre pr´c´dent.

            e                               e
Accessibilit´. Une certaine situation peut ˆtre atteinte.
  – le compteur x peut prendre la valeur 0 ;
                                     e
  – le point final du programme peut ˆtre atteint.

                       e            e
Invariance. Tous les ´tats du syst`me satisfont une bonne propri´t´. ee
                                          e                                e
   – pas de division par 0, respect des pr´conditions de fonction, pas de d´bordement de tableaux ;
                                                                   e
   – (exclusion mutuelle) deux processus ne sont jamais simultan´ment en section critique.

 u e
Sˆ ret´. Quelquechose de mauvais n’arrive jamais.
                                                  e
   – chaque fois que j’utilise unlock, j’ai utilis´ lock avant ;
                           e a                                e                        e
   – chaque fois que j’acc`de ` mon compte, j’ai bien rentr´ le bon mot de passe au pr´alable ;
                                        e                                 e
   – (correction partielle) quand la pr´condition du programme est respect´e et que le programme termine
                                        e
      alors la postcondition est respect´e.

       e       e
Vivacit´/progr`s . Quelquechose de bon finira par arriver.
                                  e
   – quand une impression est lanc´e, elle finira par s’achever ;
                                e               e      c
   – quand un message est envoy´, il finira par ˆtre re¸u ;



                                                     20
                                     e                                 e
   – (correction totale) quand la pr´condition du programme est respect´e, alors le programme termine et
                                 e
     la postcondition est respect´e.

´    e                      e e
Equit´. Quelquechose se r´p`tera infiniment souvent.
     e    e                                                       e
  – (´quit´ faible) si un processus demande continuellement son ex´cution, il finira par l’avoir.
     e    e                                                         e
  – (´quit´ forte) si un processus demande infiniment souvent son ex´cution, il finira par l’avoir.

                                  e
Absence de blocage. Le syst`me ne se bloque pas.
                                                   e
  – (non blocage total ) il existe au moins une ex´cution infinie de la machine ;
                                          e
  – (non blocage partiel ) il n’y a pas d’´tat bloquant.

´                                                       e                          e
Equivalence comportementale. Est-ce que deux syst`mes se comportent de la mˆme mani`re ?     e
                               e                                   e
   Cela permet par exemple de r´aliser rapidement un premier syst`me, de le valider puis de remplacer un
                       e                         e            a
composant par un autre ´quivalent et plus optimis´ sans avoir ` tout revalider.
                                                    e                 u e               e                 u e
Exercice 10. Quels sont les liens entre accessibilit´, invariance et sˆret´ ? La vivacit´ est-elle de la sˆret´ ?
           e                   e    e
Justifiez. Mˆme question pour l’´quit´ et l’absence de blocage.


3.2     Intuitions sur les logiques temporelles
                                                        e
Logique temporelle versus logique temporis´e. Les logiques que nous verrons dans ce chapitre sont
                          e            e                 e e               e
dites temporelles. Elles d´crivent le s´quencement d’´v`nements observ´s et peuvent exprimer par exemple la
         e                                            e
causalit´ : “chaque fois que j’observe q, j’ai observ´ p avant”. Ces logiques ne manipulent jamais explicitement
                       e                          e e                e
le temps comme dur´e absolue : entre deux ´v`nements observ´s (observations), il peut a priori se passer
                            e
une seconde ou une journ´e. On ne pourra pas exprimer par exemple que “quand je vois p, je vois ensuite
                                e
q exactement 3 secondes apr`s”. On pourra juste dire : “quand je vois p, je vois ensuite q exactement 3
                  e
observations apr`s”.
                                           e
    Il existe des logiques dites temporis´es manipulant explicitement le temps. Le model checking de telles
                                         e       e            u                                 e
logiques demande des techniques plus ´labor´es et plus coˆ teuses, bien que partageant les mˆmes bases. Ces
                                  e
techniques ne seront pas abord´es dans ce cours.

   Dans la suite nous parlerons parfois d’instants, mais il faudra comprendre observations.

                                                      e               ee
Pourquoi des logiques ? On pourrait imaginer d´crire les propri´t´s temporelles soit directement dans les
langues naturelles, soit au moyen d’un formalisme graphique. Malheureusement, les langues naturelles sont
                                                                                          ee
trop ambigues pour les besoins de l’informatisation et pas assez concises : des propri´t´s un peu complexes
demanderaient des dizaines de mots, voir de phrases. Les formalismes graphiques (ex : Message Sequence
              e              ee                     e                      a
Charts, utilis´s dans les T´l´coms) sont plus int´ressants car faciles ` comprendre et concis. Cependant
                                                        ee           e       e             e
souvent, soit ils ne peuvent pas exprimer des propri´t´s un peu ´labor´es, soit leur s´mantique n’est pas
suffisament claire.
                                        e                         a                      e            e
    Les logiques sont des langages de sp´cification formels, c’est ` dire qu’ils ont une d´finition math´matique
  e                                        e
pr´cise. Les avantages reconnus pour le g´nie logiciel sont :
                              e           ee                      e       e
    – exprimer sans ambiguit´ les propri´t´s attendues du syst`me (sp´cification, documentation),
                                        e                                 e       e
    – permettre la simulation, voir la v´rification automatique du syst`me (v´rification).

                                                                           e
Pourquoi des logiques temporelles ? On pourrait imaginer de mod´liser le temps en logique classique
du premier ordre : une variable t ∈ N indique l’instant o` a lieu une observation et on temporise les pr´dicats
                                                         u                                              e
                e                                                              a
en les faisant d´pendre de t. Dans cette optique P (t) signifie que P est vrai ` l’instant t. Par exemple pour
la propri´t´ “Chaque panne est suivie d’une alarme”, on ´crirait : ∀t, panne(t) → (∃t′ ≥ t, alarme(t′ )). Ce
          ee                                                 e
                  e                                                         e            e
formalisme est tr`s expressif, malheureusement il est peu concis et pas tr`s lisible, mˆme pour des experts.
                       e                              e                                          e
De plus son expressivit´ implique qu’on ne peut esp´rer prouver automatiquement de telles sp´cifications.

                                                       21
    On va donc se tourner vers des logiques moins expressives (pas de quantification arbitraire), mais plus
       e a                a a                              e         e
adapt´es ` nos besoins grˆce ` l’ajout de deux types d’op´rateurs li´s au temps : les connecteurs temporels
et les quantificateurs de chemins.
                                                  e                  e             e
    On parle de logiques temporelles au pluriel, d´finies selon les op´rateurs ajout´s.

                                       e e
Connecteurs temporels et propri´t´s de chemin. Les connecteurs temporels permettent de parler
du s´quencement des ´tats/ ´v`nements observ´s le long d’une ex´cution 1 . On introduit les connecteurs
     e                 e      e e                 e                   e
                                                                                                 ee
suivants : X (next), F (future), G (globally) et U (until). Dans la suite, les pi sont des propri´t´s atomiques
    e           e
des ´tats observ´s.
                                                   e                           e
    – X (next) : Xp signifie que p est vrai dans l’´tat suivant le long de l’ex´cution.


                             Xp              p


                                                              e
                                                 Fig. 3.1 – Op´rateur X

                                                                       e           e
   – F (future) : Fp signifie que p est vrai plus tard au moins dans un ´tat de l’ex´cution.


                             Fp                                                           p


                                                              e
                                                 Fig. 3.2 – Op´rateur F

                                                             e
   – G (globally) : Gp signifie que p est vrai dans toute l’ex´cution.


                           Gp,p              p              p              p             p


                                                              e
                                                 Fig. 3.3 – Op´rateur G

                                                           a    e     u
   – U (until) : pUq signifie que p est toujours vrai jusqu’` un ´tat o` q est vrai.
                            ee
   On exprime des propri´t´s complexes le long d’un chemin en imbriquant les connecteurs. Voici quelques
                    ee
exemples de propri´t´s de chemin.
                 e
   – accessibilit´ (le long du chemin) : F(x = 0)
   – invariance (le long du chemin) : G¬(x = 0)
   – vivacit´ (le long du chemin) : G(p → Fq)
            e
   – correction totale (le long du chemin) : (init ∧ precondition) → F(end ∧ postcondition)
Exercice 11. Quelques petits exercices sur les connecteurs temporels :
                                                   e
   – Fp est-il vrai si p vrai tout de suite dans l’´tat courant ?
                                      e
   – Gp est-il vrai si p faux dans l’´tat courant et vrai partout ailleurs ?
                                                e
   – pUq est-il vrai si p faux et q vrai dans l’´tat courant ?
   – pUq est-il vrai si q est toujours faux, et p toujours vrai ?
                   e              e        u
   – Faites un sch´ma d’une ex´cution o` p est vrai infiniment souvent. Comparez avec vos camarades.
       e
Qu’en d´duisez-vous sur les langages naturels et graphiques ?

                                             e e         e                  e
Quantificateurs de chemins et propri´t´s des ´tats (d’un syst`me). Jusqu’` maintenant on a a
       e e             e               e                                                       ee
consid´r´ une seule ex´cution du syst`me, et les connecteurs permettent de parler de propri´t´s le long de
         e                           e                               e
cette ex´cution. C’est une vision lin´aire du temps : le futur est fix´. Cependant, on peut aussi voir le temps
  1 Ce                                                  e e                  e                   e
         n’est donc pas suffisant pour exprimer des propri´t´s sur tout un syst`me, mais c’est un d´but.



                                                                22
                           pUq,p                 p               p              q
                                                                                p


                                                               e
                                                  Fig. 3.4 – Op´rateur U


                                     a        e            e
comme une structure branchante : ` chaque ´tat du syst`me, plusieurs futurs sont possibles, selon l’action
qui sera effectu´e2 . Les quantificateurs de chemins permettent de quantifier des propri´t´s sur les ex´cutions
               e                                                                      ee            e
                  a             e                       ee     e               e
futures possibles ` partir d’un ´tat. On parle de propri´t´s d’´tats (d’un syst`me).
                                                e                     e
   – l’expression Aϕ signifie que toutes les ex´cutions partant de l’´tat courant satisfont ϕ.
                                                             e                   e
   – l’expression Eϕ signifie qu’il existe (au moins) une ex´cution partant de l’´tat courant qui satisfait ϕ.
                                                        a                      a
   On peut alors associer un quantificateur de chemin ` une formule de chemin bˆtie sur X, F, G, U. On
verra quand on ´tudiera la logique CTL∗ qu’on peut mˆme combiner de mani`re plus complexe. Voici quatre
                e                                     e                 e
                     e
cas de base (s est l’´tat courant) :
   – EFp : il existe un chemin partant de s qui atteint p.


                                                              EFp




                                             p


                                                        Fig. 3.5 – EF

   – AFp : tous les chemins partant de s finissent par atteindre p.


                                                              AFp


                                       p



                                                                           p

                                                                                    p      p


                                                        Fig. 3.6 – AF

   – EGp : il existe un chemin partant de s tel que p est vrai tout au long du chemin (et aussi dans s).
   – AGp : p est toujours vrai en partant de s (et aussi vrai dans s).
             ee               e                   e                            ee     e           e
   Les propri´t´s qui nous int´ressent sur un syst`me S sont en fait les propri´t´s d’´tats sur l’´tat initial
       e
du syst`me.

  2 La                          e
         structure de Kripke mod´lise ces entrelacements de futurs possibles.


                                                               23
                                                         EGp,p


                                   p


                                               p

                                         p


                                                   Fig. 3.7 – EG

                                                         AGp,p


                                   p                                         p


                        p                      p                     p               p

                   p          p         p            p           p       p       p        p


                                                   Fig. 3.8 – AG

                           e                                                ee
Exercice 12. Dessinez des d´pliages sur lesquels vous illustrerez les propri´t´s EX, AX, EU, AU.
                                ee
Exercice 13. Exprimer les propri´t´s suivantes :
  1.            e
       Tous les ´tats satisfont p.
  2.                                         u
       On peut atteindre p par un chemin o` q est toujours vrai.
  3.                 e                          ` e
       Quelquesoit l’´tat, on finit par revenir a l’´tat initial init.
  4.                 e                     ` e
       Quelquesoit l’´tat, on peut revenir a l’´tat initial init.
  5.   Absence de deadlock (partiel).

     e                                                           e e
Diff´rents types de logiques temporelles. Comme pr´c´demment dit, il existe plusieurs logiques tem-
                     e                          e                           e                          e
porelles selon les op´rateurs du temps employ´s. Distinguer selon les op´rateurs permis est la mani`re la plus
                                                                     ee
simple de distinguer deux logiques temporelles. Voici d’autres ´l´ments de distinction.
        e                                         e              e            e              e      e
    Lin´aire vs. branchant. Dans les logiques lin´aires on s’int´resse aux ex´cutions du syst`me ind´pendamment
                                                                         e                     a             e
les unes des autres, sans prendre en compte les entrelacements des diff´rents futurs possibles ` un point donn´
        e                               e      a                      e          o      a                 e
de l’ex´cution. Autrement dit, on s’int´resse ` un ensemble d’ex´cutions plutˆt qu’` un arbre des ex´cutions
                                                                                          e
possibles. La quantification sur les chemins est donc quasi-absente des logiques lin´aires. Au contraire les
logiques branchantes permettent de quantifier sur les futurs possibles.
                e                                                                      e
    Expressivit´. Intuitivement, est-ce que deux logiques peuvent exprimer la mˆme chose, ou est-ce que
                                                                                                        e
l’une sait dire plus de choses que l’autre, ou est-ce qu’elles sont incomparables ? L’expressivit´ est une
          e                                                    e
notion s´mantique, pas syntaxique, car des formules diff´rentes peuvent parfois signifier la mˆme chose.e
Typiquement, la logique classique du premier ordre est plus expressive que les logiques temporelles usuelles.
                                                                   e                  e
    Concision. Quand deux logiques peuvent exprimer la mˆme chose, il est int´ressant de savoir laquelle
le fait avec les phrases les plus courtes. C’est la concision. Ainsi par exemple, une logique temporelle est
toujours plus concise que la logique classique du premier ordre.

                                                          24
                  e                                 a                                                    e
    Pouvoir de s´paration. Capaciter d’une logique ` distinguer deux structures de Kripke. Une logique s´pare
M1 et M2 si il existe une formule ϕ de la logique en question telle que M1 |= ϕ et M2 |= ϕ.
                       e                   e     e
    Avec ou sans pass´. Nous n’avons pr´sent´ ici que des connecteurs du futurs. On pourrait aussi d´finir e
des connecteurs du pass´3 , par exemple pour dire que quand j’observe q, c’est que j’ai observ´ p avant. On ne
                         e                                                                    e
                                                             e                              e
le fera pas ici. Retenez que ca n’augmente pas l’expressivit´ (on peut se ramener aux op´rateurs du futur),
                                                  a                                         e
mais le pouvoir de concision. Retenez aussi qu’` l’heure actuelle on ne sait pas comment v´rifier efficacement
          ee                 e            a                                    e
ces propri´t´s : on est oblig´ de revenir ` la traduction (exponentielle) en op´rateurs du futur.
               e                                       ee
    Complexit´ du model checking. C’est une propri´t´ fondamentale pour l’informatique, qui indique si le
                       e                                                o
model checking peut ˆtre fait efficacement (par un algorithme polynˆmial) ou pas. Malheureusement, plus
                                          e
une logique est expressive, plus le probl`me du model checking est difficile. Attention : entre deux logiques
                e              e                  e
L1 et L2 de mˆme expressivit´, si la complexit´ de L1 est meilleure mais que sa concision est moins bonne,
                   e                a e
L1 n’est pas forc´ment plus facile ` v´rifier en pratique.
    Dans la suite on va pr´senter trois logiques temporelles diff´rentes : LTL, CTL et CTL∗ . LTL est une
                            e                                     e
           e        a              e            e               e
logique lin´aire, c-`-d qu’on s’int´resse aux ex´cutions du syst`me sans prendre en compte les entrelacements
       e                         a                 e
des diff´rents futurs possibles ` un point de l’ex´cution. La quantification sur les chemins y est donc quasi-
absente. CTL∗ est la logique la plus expressive que nous verrons, il n’y a pas de limitation ` l’utilisation des
                                                                                             a
connecteurs temporels et quantificateurs de chemins. C’est une logique branchante. Enfin CTL est aussi une
                            u
logique branchante, mais o` l’emploi des connecteurs temporels est restreint. La logique est moins expressive
que CTL∗ mais le model checking est bien plus facile.
                             e e                                                  `
Exercice 14. Quel est l’int´rˆt d’utiliser des logiques temporelles par rapport a (a) langage naturel, (b)
                                                                                                      e
formalisme graphique, (c) logique classique du premier ordre. Vous discuterez les points suivants : pr´cision
                                  e           e      e
du langage, concision, expressivit´, simplicit´ d’acc`s.
   Comparez maintenant entre logique classique du premier ordre et logique classique du premier ordre
        e        e
augment´e des op´rateurs temporels.


3.3                   e
           Logique lin´aire LTL
                            e                                  e                      e
    LTL est une logique lin´aire. Le seul quantificateur autoris´ est A, seulement en d´but de formule. Dans
                                                ee
la suite on se donne un ensemble fini de propri´t´s atomiques AP.
                          e                                    e
     On va tout d’abord d´finir LTL sur un chemin, puis on d´finira LTL sur une structure de Kripke.
  e
D´finition 3.3.1 (LTL sur un chemin). La logique temporelle LTL (Linear Temporal Logic) sur un chemin
     e
est d´finie par la grammaire suivante :
        ϕ : := p ∈ AP — ¬ϕ — ϕ ∨ ϕ — ϕ ∧ ϕ — Xϕ — Fϕ — Gϕ — ϕUϕ

                                 e                                                              e
   Le domaine d’interpr´tation est un ensemble de chemins σ. Un chemin est une s´quence infinie σ =
s0 s1 s2 . . . sn . . . d’´tats s ∈ Q. On note σ i le chemin extrait de σ ` partir de la i-`me position. Par exemple
                          e                                               a                e
σ 2 = s2 s3 . . . sn . . .. On note σ(k) le k-i`me ´tat de σ. On se donne une fonction l : Q → 2AP indiquant
                                                e      e
quelles propri´t´s p ∈ AP sont vraies dans un ´tat s ∈ Q.
                    ee                                  e

  On d´finit ensuite r´cursivement la relation de satisfaction σ |= ϕ par :
      e               e
   . σ |= p iff p ∈ l(σ(0))                     e
                               (p vrai dans l’´tat courant),
   . σ |= ¬ϕ iff σ |= ϕ,
   . σ |= ϕ1 ∨ ϕ2 iff σ |= ϕ1 ou σ |= ϕ2 ,
   . σ |= ϕ1 ∧ ϕ2 iff σ |= ϕ1 et σ |= ϕ2 ,
   . σ |= Xϕ iff σ 1 |= ϕ,
   . σ |= Fϕ iff il existe k ≥ 0 tel que σ k |= ϕ,
   . σ |= Gϕ iff pour tout k ≥ 0 on a σ k |= ϕ,
  3 Qui                   e          e ee                         u e
          permettent une d´finition tr`s ´l´gante de la notion de sˆret´.



                                                               25
   . σ |= ϕ1 Uϕ2 iff il existe k ≥ 0 tel que σ k |= ϕ2 et pour tout 0 ≤ j < k, σ j |= ϕ1 .
Exercice 15. On va voir que certains connecteurs sont redondants.
  – Exprimer Gp avec les connecteurs ¬, F et p.
                   a
  – Exprimer Fp grˆce au connecteur U.
  – Peut-on exprimer X en fonction des autres connecteurs ?
  – Peut-on exprimer U en fonction des autres connecteurs ?
  – Comparez alors LTL, LTL-F, LTL-U et LTL-X.
  – Donner une grammaire minimale pour LTL.
                                             e
Exercice 16 (Autres connecteurs.). On va d´finir quelques connecteurs additionels utiles.
  1. D´finir la relation |= pour les connecteurs additionnels suivants :
       e
                                                      a                                        e          `
  – pWq (weak until) : signifie que p est vrai jusqu’` ce que q soit vrai, mais q n’est pas forc´ment vrai a
     un moment. Dans ce cas, p reste vrai tout le long du chemin.
  – F∞ p (infiniment souvent) : p est infiniment vrai au long de l’ex´cution.
                                                                      e
  – G∞ p (presque toujours) : a partir d’un moment donn´, p est toujours vrai.
                               `                           e
                                           a
  – p U≤k q (bounded until) : p vrai jusqu’` ce que q soit vrai, et q vrai dans au plus k observations.
                                       a                        e     u
  – pRq (release) : q est vraie jusqu’` (et inclus) le premier ´tat o` p est vraie, sachant que p n’est pas
         e
     forc´ment vraie un jour.
  2. On va maintenant faire le lien entre ces connecteurs et les anciens.
  – Exprimer F∞ et G∞ par des connecteurs de LTL.
  – Que pensez-vous de LTL-U+W ?
  – Que pensez-vous de LTL et LTL+U≤k (pour toute valeur de k) ? Quel lien entre U≤k et U ?
                                                  e
  – Exprimer G et U en fonction de R. Qu’en d´duire sur LTL+R, LTL et LTL+R-U ?
                                                   ee
Exercice 17. Exprimer en langage naturel les propri´t´s de chemin suivantes.
  – G(emission → Freception)
  – F∞ ok → G(emission → Freception)
                          e                                        `           ee       u e
Exercice 18. Parmi les op´rateurs suivants, lesquels correspondent a des propri´t´s de sˆret´ ?
  X, F, G, U, W, U≤k , R, F∞ , G∞ .
Exercice 19 (*). Montrez que U n’est pas associatif.
               e               e               e           e               e
Exercice 20 (Op´rateurs du pass´ (**)). On va d´finir des op´rateurs du pass´.
                 e                                e                                      e               e
  1. Modifier la d´finition de la logique et de la s´mantique pour prendre en compte les op´rateurs du pass´
     X−1 ,F−1 , G−1 et U−1 .
                        e               e      e          `
  2. Montrer que LTL+(op´rateurs du pass´) est ´quivalent a LTL.
  3. Comparez la concision des deux logiques.
                    e e                         e                               e e
Exercice 21 (Th´or`me de Kamp (*)). Ce r´sultat est le sens (facile) du th´or`me de Kamp, qui ´tablit e
              e                                                                     `
que LTL a mˆme pouvoir d’expression que la logique monadique du premier ordre a un successeur.
    On se donne un ensemble AP de pr´dicats atomiques P : N → B et un ensemble Var de variables. On
                                            e
       e                                          `                 e
consid`re la logique monadique du premier ordre a un successeur, d´finie par :
    . t : := 0|v ∈ Var|t + 1
    . atome : := t ≥ t|t = t|P (t), P ∈ AP
    . f : := f ∨ f |f ∧ f |¬f |∃v, f |atome
                       ee                     e                                 ee
La logique est interpr´t´e sur N. En consid´rant que P (t) signifie que la propri´t´ P est vrai au temps t (=
        `      e     e                                          e
P vrai a la t-i`me ´tape du chemin), donner une traduction (r´cursive) des formules LTL ϕ en formules ϕ
                                  e
de logique monadique ayant mˆme signification.




                                                      26
                  e                                e          e
 Jusqu’ici on a d´fini LTL sur un unique chemin. On ´tend les d´finitions pour une structure de Kripke
        →
M = Q, − , P, l, s0 comme suit.
  e
D´finition 3.3.2 (LTL sur une structure de Kripke ). Les formules LTL sur une structure de Kripke sont
                  u
de la forme Af o` f est une formule LTL de chemin. La formule est satisfaite si tous les chemins de la
structure de Kripke satisfont f . Cela donne la grammaire suivante :
        ϕs : := Aϕp
        ϕp : := p ∈ AP — ¬ϕp — ϕp ∨ ϕp — ϕp ∧ ϕp — Xϕp — Fϕp — Gϕp — ϕp Uϕp

                                      e
Satisfaction. Le domaine d’interpr´tation est maintenant un couple (M, s) associant une structure de
Kripke et un ´tat. On d´finit alors r´cursivement la relation de satisfaction M, s |= ϕ par :
             e         e            e
   . M, s |= Aϕp ssi tous les chemins σ partant de s v´rifient σ |= ϕp ,
                                                        e
   . σ |= ϕp est d´fini comme pr´c´demment.
                   e             e e

  On vient de d´finir la relation M, s |= ϕ. Ce n’est pas exactement ce qu’on veut, puisqu’on s’int´resse
               e                                                                                  e
uniquement ` des structures de Kripke, pas ` des couples. On d´finit alors M |= ϕ par M, s0 |= ϕ.
           a                               a                  e
Exercice 22.
  1. Soit ϕ = Af une formule de LTL. ¬ϕ est-il exprimable en LTL ? On dit que LTL n’est pas clos par
      e        ´                                                           e
     n´gation. Etait-ce le cas pour LTL sur les chemins ? Quelle est la diff´rence ?
  2. Peut-on avoir a la fois M |= Af et M |= A¬f ? Si oui, donner un exemple, sinon prouvez le.
                   `
                                           `                      o          e         ´
  3. Quel connecteur faudrait-il rajouter a LTL pour obtenir la clˆture par n´gation ? Ecrivez la nouvelle
                                                e
     grammaire et le relation de satisfaisabilit´ correspondante.
Exercice 23. Montrer que si on ajoute R aux connecteurs de bases, on peut restreindre l’emploi de la
 e                  ee                          ee       e                                    e
n´gation aux propri´t´s atomiques. Cette propri´t´ est tr`s importante, car la gestion de la n´gation non
               e    u
atomique est tr`s coˆteuse dans les algorithmes de model checking.
              ´
Exercice 24 (Equivalence comportementale (*).). Que peut-on dire de deux structures de Kripke M1 et
M2 telles que L(M1 ) = L(M2 ) ? Que peut-on dire de deux structures de Kripke M1 et M2 telles que
L(M1 ) ⊆ L(M2 ) ?
                                       `
Exercice 25 (Stuttering equivalence.). a faire.
                                        e                                  e         e                e
Exercice 26 (**). Montrer que le probl`me du model checking de LTL se ram`ne au probl`me de la validit´
                                                                                          −
de LTL. Plus pr´cis´ment, on se donne une formule LTL ϕ et une structure de Kripke M = Q, →, P, l, s0 .
               e e
On va construire une formule ϕ′′ telle que M, s0 |= ϕ ssi ϕ′′ est valide.
  1. Commencez par construire une formule ϕ′ telle que σ |= ϕ′ ssi σ ∈ L(M).
  2. Concluez en construisant la formule ϕ′′ cherch´e a partir de ϕ′ et ϕ.
                                                   e `


3.4     Logique branchante CTL∗
   La logique CTL∗ est la plus expressive que nous verrons. Par rapport ` LTL, elle ne restreint pas l’emploi
                                                                        a
des quantificateurs de chemin.
D´finition 3.4.1 (logique CTL∗ ). On distingue dans CTL∗ des formules d’´tat (ϕs ), interpr´t´es sur les
  e                                                                             e                ee
e                                                                        ee
´tats de la structure de Kripke, et des formules de chemin (ϕp ), interpr´t´es sur les chemins de la structure
de Kripke. Les formules CTL∗ sont alors d´finies par la grammaire suivante :
                                            e
        ϕs : := p ∈ AP — ¬ϕs — ϕs ∨ ϕs — ϕs ∧ ϕs — Aϕp — Eϕp
        ϕp : := ϕs — ¬ϕp — ϕp ∨ ϕp — ϕp ∧ ϕp — Xϕp — Fϕp — Gϕp — ϕp Uϕp




                                                     27
                                       e
Satisfaction. Le domaine d’interpr´tation est encore un couple (M, s) associant une structure de Kripke
et un ´tat. On d´finit alors M, s |= ϕ par :
       e          e
    formules d’´tat, relation |=s
                e
     . M, s |=s p ∈ AP iff p ∈ l(s)                     e
                                        (p vrai dans l’´tat courant),
     . M, s |=s ¬ϕ iff M, s |=s ϕ,
     . M, s |=s ϕ1 ∨ ϕ2 iff M, s |=s ϕ1 ou M, s |=s ϕ2 ,
     . M, s |=s ϕ1 ∧ ϕ2 iff M, s |=s ϕ1 et M, s |=s ϕ2 ,
     . M, s |=s Af ssi tous les chemins σ partant de s v´rifient M, σ |=p f ,
                                                          e
     . M, s |=s Ef ssi il existe un chemins σ partant de s v´rifiant M, σ |=p f ,
                                                              e
    formules de chemin, relation |=p
     . M, σ |=p f iff M, σ(0) |=s f                     e
                                         (f formule d’´tat),
     . M, σ |=p ¬ϕ iff M, σ |=p ϕ,
     . M, σ |=p ϕ1 ∨ ϕ2 iff M, σ |=p ϕ1 ou M, σ |=p ϕ2 ,
     . M, σ |=p ϕ1 ∧ ϕ2 iff M, σ |=p ϕ1 et M, σ |=p ϕ2 ,
     . M, σ |=p Xϕ iff M, σ 1 |=p ϕ,
     . M, σ |=p Fϕ iff il existe k ≥ 0 tel que M, σ k |=p ϕ,
     . M, σ |=p Gϕ iff pour tout k ≥ 0 on a M, σ k |=p ϕ,
     . M, σ |=p ϕ1 Uϕ2 iff il existe k ≥ 0 tel que M, σ k |=p ϕ2 et pour tout 0 ≤ j < k, M, σ j |=p ϕ1 .

  L` encore on d´finit M |= ϕ en partant de l’´tat initial, avec M |= ϕ si M, s0 |=s ϕ.
   a            e                            e
                                       ee
Exercice 27. Exprimer toutes les propri´t´s de la section 3.1 en tenant compte des quantificateurs de
chemin.
Exercice 28.
  1.   Est-ce que CTL∗ est clos par n´gation ?
                                     e
  2.   Montrer que ∨, ¬, X, U et E suffisent a exprimer les autres connecteurs.
                                              `
                                       ∗
  3.                                                                                     e          e
       Restreignez la grammaire de CT L (les ϕp ou les ϕs ) pour retrouver LTL (avec la mˆme interpr´tation).
  4.   Montrez que si on ajoute R, on peut restreindre ¬ aux propositions atomiques.
Exercice 29. On d´finit la logique ACTL∗ comme la restriction de CTL∗ dans laquelle le seul quantificateur
                   e
                     e
permis est A, et la n´gation ne peut intervenir qu’au niveau des propositions atomiques. Ainsi, AG¬p est
une formule de ACTL∗ , mais pas EF p ni A¬Gp. On ajoute R aux connecteurs de base.
   1. Comparez ACTL∗ et ACTL∗ -R.
   2. Montrer que LTL ⊆ ACTL∗ . (au sens s´mantique)
                                            e
   3. Est-ce que AF AGp ≡ AF Gp ?
   4. Que d´duire sur LTL et ACTL∗ ?
            e
Remarque : ACTL∗ est le fragment de CTL∗ bien adapt´ a la v´rification modulaire.
                                                       e`     e
                                           `
Exercice 30 (Bisimulation et simulation.). a faire.
Exercice 31 (ACTL∗ et assume-guarantee). a faire.
                                         `
                                       `
Exercice 32 (Stuttering bisimulation). a faire.


3.5      Logique branchante CTL
   On d´finit maintenant la logique CTL (Computation tree logic), qui est une restriction de CTL∗ dans
         e
                                                        e                  e e e
laquelle les connecteurs temporels X, F, G et U doivent ˆtre directement pr´c´d´s d’un quantificateur de
chemin A ou E. Par exemple, AF AGp est une formule CTL, mais pas AF Gp.
   Une formule CTL s’obtient donc ` partir de ¬, ∨, ∧ et des huit op´rateurs suivants :
                                  a                                 e

                                                      28
   –   AX et EX,
   –   AF et EF,
   –   AG et EG,
   –   AU et EU.
    CTL est un fragment tr`s important de CTL∗ , car il est raisonnablement expressif et il existe des algo-
                          e
rithmes de model-checking polynˆmiaux. Comme dans le cas de CTL∗ , on peut d´finir la restriction ACTL
                                o                                              e
          e
bien adapt´e au calcul modulaire.
Exercice 33. Montrer que p, ∨, ¬, EX, EG et EU suffisent a exprimer les autres connecteurs. Montrer
                                                       `
ensuite que p, ∧, ¬, EX, AU et EU suffisent aussi.
Exercice 34. Ce n’est pas parcequ’une formule n’est pas syntaxiquement dans CTL qu’il n’y a pas de formule
CTL ´quivalente. Tranformez les formules suivantes en formules CTL : E(p ∧ Fq), AGFp.
     e
  Peut-on exprimer les notions suivantes en CTL : AW, EW, AU≤k , EU≤k ?
  Peut-on exprimer les notions suivantes en CTL : AG∞ , EG∞ ?
   ´
  Equit´ : peut-on exprimer AF∞ ϕ en CTL ? et EF∞ ϕ ?
       e
Exercice 35 (CTL et CTL+). a faire
                     e    e                        e                              e    e
Exercice 36 (CTL et ´quit´ (*)). On peut essayer d’´tendre CTL pour lui ajouter l’´quit´. Il y a plusieurs
    e
mani`res de faire.
  – fair CTL : on fait du CTL mais sur des structures fair, comme d´finies au chapitre pr´c´dent4 .
                                                                   e                      e e
  – ECTL : on ajoute AF∞ et EF∞
  Questions :
  1. Quel lien entre CTL et ECTL ?
                                       e                  e
  2. Quel genre de formules permet de v´rifier fair CTL ? D´duire le lien entre CTL et fair CTL, puis le
     lien entre ECTL et fair CTL.
Exercice 37 (CTL et bisimulation). a faire
Exercice 38 (ACTL et assume-guarantee). a faire


3.6        Comparaison des trois logiques
                                     e                  e          e
    La figure 3.9 donne quelques r´sultats de complexit´ sur les diff´rentes logiques, et la figure 3.10 indique
les relations d’inclusion entre les logiques LTL, CTL, CTL∗ et ACTL∗ .

                                          CTL                     LTL                CTL∗
               MC                       P-complet             PSPACE-complet     PSPACE-complet
               MC concurrent         PSPACE-complet           PSPACE-complet     PSPACE-complet
               MC open              EXPTIME-complet           PSPACE-complet   2-EXPTIME-complet
                              e
               satisfaisabilit´     EXPTIME-complet           PSPACE-complet   2-EXPTIME-complet

MC : est-ce que M |= ϕ ?
MC concurrent : est-ce que M1 , . . . , Mn |= ϕ ?
MC open : est-ce que M, E |= ϕ pour tout E tel que E |= ψ, o` ψ est la contrainte d’environnement ?
                                                            u
Satisfaisabilit´ : est-ce qu’il existe M tel que M |= ϕ ?
               e


                                                           e                    e
                                      Fig. 3.9 – Quelques r´sultats de complexit´

  4 Ce   que je note fair CTL est parfois aussi appel´ CTLF
                                                     e


                                                              29
                                                     CTL*




                                                  ACTL*




                                                   LTL        CTL




                                     e
                       Fig. 3.10 – Hi´rarchie des logiques temporelles vues en cours.


                                                                    ı
Exercice 39. Quand une logique est incluse dans une autre, dˆtes pourquoi. Quand deux logiques sont
distinctes, trouvez une formule expressible dans l’une et pas dans l’autre.
Exercice 40 (Questions pratiques).
                                                                    e    e
(1) Quelles logiques ci-dessus sont capables d’exprimer la notion d’´quit´ ?
(2) Comment v´rifieriez-vous les propri´t´s suivantes si vous aviez un model checker pour CTL, LTL, CTL∗ ?
                e                      ee
                  e
    – accessibilit´,
    – invariance,
       u e
    – sˆret´,
             e
    – vivacit´,
    – absence de deadlock,
      e    e
    – ´quit´,
      e                   e
    – ´quivalence de mod`le.
                         e
Exercice 41 (Pouvoir de s´paration.). a faire.

                                                       e                       e
Comparaisons des logiques. Les logiques lin´aires comme LTL s’av`rent plus naturelles en pratique
          e                                               e
pour sp´cifier les comportements attendus du syst`me ou de l’environnement. De plus elles permettent
                                           e    e                             e                          e
d’exprimer des notions utiles comme l’´quit´, les contre-exemples retourn´s sont simples (trace d’ex´cution)
                            e a        e            a     e
et ces logiques sont adapt´es ` la v´rification ` l’ex´cution. Par contre LTL manque parfois d’expressivit´      e
                                  ` e
(ex : “on peut toujours revenir a l’´tat initial”).
    `                                             e                                                e
    A l’inverse les logiques branchantes s’av`rent parfois contre-intuitives (environnement, ´quivalence de
     e                                   e                  a       e                 e              e
mod`le), les contre-exemples retourn´s sont difficiles ` interpr´ter (arbres d’ex´cution) et la v´rification `     a
    e                                                e
l’ex´cution n’a pas de sens. CTL a cependant l’´norme avantage d’avoir des algorithmes de model checking
       o
polynˆmiaux, alors que ceux de LTL sont PSPACE donc exponentiels en pratique. CTL peut aussi exprimer
                 ee                                  e    e
certaines propri´t´s utiles absentes de LTL et l’´quit´ peut s’obtenir avec des algorithmes ad hoc.
    La logique CTL∗ est tr`s expressive et le model checking a la mˆme complexit´ que pour LTL. On pourrait
                            e                                         e              e
donc se dire autant utiliser CTL∗ , quitte ` se restreindre ` des formules “humainement compr´hensibles”.
                                              a                 a                                     e
                                                e                                e
Cependant, d’une part le gain d’expressivit´ n’est plus gratuit si on consid`re un environnement, d’autres
                                                         e                                       e   e a
part ce n’est pas certain que ce gain d’expressivit´ soit utile, puisqu’on peut ajouter l’´quit´ ` CTL au
niveau des algorithmes, et qu’on peut toujours utiliser un model checker de LTL et un autre de CTL pour
                     ee
les quelques propri´t´s manquantes.
                                                                        e                          e
    Une voie raisonnable d’utilisation des model-checkers semble ˆtre d’utiliser CTL pour v´rifier les pro-
   ee                      u e                      e          e                 e           e
pri´t´s les plus simples (sˆ ret´) sur tout le mod`le et d’en ´prouver la validit´ ; puis apr`s que quelques bugs
                ee       e                  e            e      e
grossiers aient ´t´ trouv´s et que le mod`le soit valid´, utilis´ un model checker LTL sur une partie seulement
         e
du syst`me (bounded model checking).

                                                         30
                                             ee e        e
Autres logiques. D’autres logiques ont ´t´ d´velopp´es. Nous en mentionnons seulement trois. Le µ-
                               e                                                     e
calcul est le formalisme de sp´cification le plus puissant, mais il est difficile d’acc`s et peu concis. Les
      ee        e  e                              e                           e
propri´t´s w-r´guli`res sont assez intuitives (bas´es sur des automates) et tr`s expressives. Il existe des
                           e                                            e
versions branchantes ou lin´aires. Les algorithmes de model checking bas´s sur les automates travaillent en
g´n´ral non pas sur LTL ou CTL∗ mais sur des propri´t´s w-r´guli`res lin´aires ou branchantes. Enfin les
 e e                                                    ee     e   e      e
                                                           e
Hierarchical Message Sequence Charts (HMSC) sont des sp´cifications provenant d’UML (Unified Modeling
                       e                               ee                        e
Language) et emprunt´es au monde des protocoles de t´l´communications. Ces sp´cifications sont simples `   a
             a       e
comprendre ` premi`re vue (graphiques), mais leurs liens avec les autres logiques temporelles ne sont pas
encore claires.




                                                    31
Chapitre 4

Model checking, algorithmes de base

           e                                                                                       e
   Nous pr´sentons dans ce chapitre des algorithmes de model checking pour CTL et LTL. On pr´sentera
                                                           `       e                         e
deux algorithmes pour CTL, d’abord l’algorithme standard a base d’´tiquetage (labelling) des ´tats puis une
                 e    e               e                               a
extension pour l’´quit´. Ensuite on pr´sentera un algorithme pour LTL ` base d’automates.


4.1       e
        Pr´lude : composantes fortement connexes
                                   e
    On commence par un probl`me algorithmique sous-jacent au model checking de CTL et de LTL : la
                                                                                               e
recherche de composantes fortement connexes d’un graphe. Formellement un graphe orient´ G est une paire
G = Q, T o` Q est un ensembles d’´tats (ou nœuds) et T ⊆ Q × Q un ensemble de transitions. Comme
              u                           e
d’habitude, (q, q ′ ) ∈ T signifie qu’on peut aller de q ` q ′ en prenant une transition du graphe. On dit que q ′
                                                        a
                                        ∗
est atteignable ` partir de q, not´ q − q ′ si il existe un chemin (une suite de transitions) de q ` q ′ .
                a                   e →                                                            a

  e                                                    e
D´finition 4.1.1. Soit G = Q, T un graphe orient´. On appelle composante connexe de G tout sous
ensemble non vide C ⊆ Q tel que pour tout ci , cj ∈ C, cj est atteignable ` partir de ci en restant dans C.
                                                                          a
    Une composante fortement connexe est une composante connexe maximale : si on lui rajoute un nouveau
nœud, elle n’est plus connexe. Un composante fortement connexe non triviale a soit au moins deux nœuds,
soit un seul nœud avec une transition sur lui-mˆme, c-`-d (q, q) ∈ T . Autrement dit une composante fortement
                                               e      a
                                                 e     a     e
connexe non triviale a au moins un arc. On s’int´resse ` la d´composition en composantes fortement connexes
                                e                  e                        ea
non triviales d’un graphe orient´.Un exemple de d´composition est donn´ ` la figure 4.1.




                                        e
                 Fig. 4.1 – Exemple de d´composition en composantes fortement connexes


                                                                                  ee
    Le lien avec CTL et LTL est le suivant : intuitivement, pour qu’une propri´t´ du type ϕ = EGp soit
vraie, comme on s’int´resse ` des chemins infinis et que la structre de Kripke M est finie, la seule mani`re
                      e       a                                                                          e
         e                                                                   e      e
qu’a un ´tat s0 de satisfaire ϕ est de pouvoir atteindre par un chemin fini d’´tats v´rifiant p une composante
                                      e                            e         a
fortement connexe C dont tous les ´tats satisfont p. Le chemin v´rifiant ϕ ` partir de s0 est donc la forme



                                                       32
                   u                                    e
s0 s1 . . . sn σC o` s0 s1 . . . sn est un chemin fini d’´tats satisfaisant p et σC est un chemin infini restant dans
      u            e
C (o` tous les ´tats satisfont p).
                               e                           e
    La section C.1 en annexe pr´sente deux algorithmes de d´couverte des composantes fortement connexes :
                                                                                       e
l’algorithme de Kosaraju et l’algorithme de Tarjan. Ce dernier est le plus rapide en th´orie, mais il est un
      e      a
peu d´licat ` bien implanter.
                      e
   Dans la suite on ´crira “composante fortement connexe” en lieu et place de “composante fortement
connexe non triviale”.


4.2      Model checking de CTL par labelling
                                                          ee e         e
    C’est le premier algorithme de model checking a avoir ´t´ d´velopp´. Son avantage majeur est de tourner
              e                       e
en temps lin´aire en chacune des entr´es (la structure de Kripke et la formule). L’algorithme repose sur le
                                                                                           e
fait que toute formule CTL peut s’exprimer par un nombre restreint de formules sur les ´tats. Cela nous
                                  e                                 o          e
permet de raisonner en termes d’´tats (satisfaisant la formule) plutˆt que d’ex´cutions.

                                                                            →
Principe. L’algorithme prend en entr´e la structure de Kripke M = Q, − , P, l, s0 et une formule CTL
                                       e
ϕ. Il est ` base de marquage : pour chaque sous-formule ϕ′ de ϕ, en commen¸ant par la plus interne, on va
          a                                                                  c
marquer les ´tats s de M qui v´rifient ϕ′ . On proc`de ensuite r´cursivement en r´utilisant les marquages des
             e                 e                  e            e                e
sous-formules plus internes pour une sous-formule plus externe. Finalement, M satisfait ϕ ssi l’´tat initial
                                                                                                  e
              e
s0 est marqu´ par ϕ.

    Par exemple pour la formule ¬EXp, on proc`de ent trois phases : (1) on marque les ´tats Qp v´rifiant p,
                                                e                                     e         e
cette information est donn´e par la fonction l de M ; (2) on marque les ´tats QEXp v´rifiant EXp, ce sont
                           e                                            e           e
                             →
ceux dont un successeur par − est dans Qp . (3) on marque les ´tats Qϕ v´rifiant ¬EXp, ce sont ceux qui
                                                               e           e
ne sont pas dans QXp .

                                 a
   Pour limiter le nombre de cas ` traiter dans l’algorithme et dans les preuves, on va se restreindre aux
connecteurs p, ∧, ¬, EX, EU et AU. Avant d’appliquer l’algorithme, on passera donc d’abord par une phase
de traduction de la formule ϕ.

         e                                                 e                  e     e     e
   Le sch´ma global de l’algorithme est le suivant. La proc´dure marking est d´taill´e apr`s.

Algorithme mc-ctl
                  →
input : ϕ, M = Q, − , P, l, s0
 1: ϕ′ := normalize(ϕ) ;
 2: Do marking(ϕ′ ,M) ;
 3: RETURN s0 .ϕ′
                                                                 e
                         Algorithme 1: Model Checking de CTL par ´tiquetage


Th´or`me 4.2.1 (Correction). L’algorithme mc-ctl termine et retourne vrai ssi M |= ϕ.
  e e
           e                 a             e                                   e
   On s’int´resse maintenant ` la complexit´ de l’algorithme. Pour cela on va d´finir la taille d’une structure
                                                                                              →
de Kripke |M| comme la somme de son nombre d’´tats |Q| et son nombre de transitions | − |, et la taille
                                                    e
d’une formule |ϕ| comme son nombre de connecteurs. On a alors le r´sultat suivant.
                                                                     e
   e e                        e                    e
Th´or`me 4.2.2 (Complexit´). L’algorithme 1 est lin´aire en la taille de la formule et la taille de la
structure de Kripke, soit O(|M| · |ϕ|).
                            e                                                                    ea
Exercice 42. On a ici utilis´ un nombre restreint de connecteurs, et la formule initiale ϕ0 est d´j` trans-
form´e en une formule ϕ′ n’utilisant que ces connecteurs.
    e


                                                        33
Algorithme marking
                                     →
input : formule ϕ normalis´e, M = Q, − , P, l, s0
                          e
 1:
 2:   Case 1 : ϕ = p
 3:   for all s ∈ Q do
 4:     if p ∈ l(s) then s.ϕ := true
 5:     else s.ϕ := false
 6:   end for
 7:
 8:   Case 2 : ϕ = ¬ϕ′
 9:   do marking(ϕ′ ,M) ;
10:   for all s ∈ Q do s.ϕ := not(s.ϕ′ ) end for
11:
12:   Case 3 : ϕ = ϕ′ ∧ ϕ′′
13:   do marking(ϕ′ ,M) ; marking(ϕ′′ ,M) ;
14:   for all s ∈ Q do s.ϕ := and(s.ϕ′ ,s.ϕ′′ ) end for
15:
16:   Case 4 : ϕ = EXϕ′
17:   do marking(ϕ′ ,M) ;
18:   for all s ∈ Q do s.ϕ := false end for
19:   for all (s, s′ ) ∈− do
                        →
20:     if s’.ϕ′ =true then s.ϕ := true
21:   end for
22:
23:   Case 5 : ϕ = Eϕ′ Uϕ′′
24:   do marking(ϕ′ ,M) ; marking(ϕ′′ ,M) ;
25:   for all s ∈ Q do
26:     s.ϕ := false ;
27:     s.seenbefore := false
28:   end for
29:   L := ∅
30:   for all s ∈ Q do if s.ϕ′′ =true then L :=L + {s} end for
31:   while L = ∅ do
32:     choose s ∈ L ; L := L - {s} ;
33:     s.ϕ := true ;
34:                      →
        For all (s’,s) ∈− do // s’ predecessor of s
35:        if s’.seenbefore = false then
36:           s’.seenbefore := true ;
37:           if s’.ϕ′ = true then L := L + {s’} ;
38:        end if
39:     end for
40:   end while
41:
42:   Case 6 : ϕ = Aϕ′ Uϕ′′
43:   Do markingAU(ϕ,M) ;
                                                            e
                    Algorithme 2: Model Checking de CTL par ´tiquetage, cas simples




                                                          34
Algorithme markingAU
                   →
entr´e : ϕ, M = Q, − , P, l, s0
    e
 1:
 2:   Case 6 : ϕ = Aϕ′ Uϕ′′
 3:   fo marking(ϕ′ ,M) ; marking(ϕ′′ ,M) ;
 4:   L := ∅ ;
 5:   for all s ∈ Q do
 6:      s.nb := degree(s) ; s.ϕ := false ;
 7:      if s.ϕ′′ = true then L := L + {s} ;
 8:   end for
 9:   while L = ∅ do
10:      choose s ∈ L ; L := L - {s} ;
11:      s.ϕ := true ;
12:                      →
         for all (s’,s) ∈− do // s’ predecessor of s
13:         s’.nb := s’.nb - 1 ;
14:         if (s’.nb = 0) and (s’.ϕ′ = true) and (s’.ϕ = false) do
15:            L := L + {s’} ;
16:         end if
17:      end for
18:   end while
19:
                                                             e
                     Algorithme 3: Model Checking de CTL par ´tiquetage, cas Aϕ1 Uϕ2


                                                                    e
      – Rappelez pourquoi on peut se permettre de restreindre les op´rateurs.
                                       e                    e
      – Quel est l’avantage de cette m´thode ? Quel est le d´savantage ?
                                     e
      – Y a-t-il un saut de complexit´ ?
                                                                e
Exercice 43 (*). Faire les preuves de correction et de complexit´.
                         e       e
   On a vu qu’il pouvait ˆtre int´ressant d’implanter d’autres connecteurs directement dans l’algorithme.
                                                    a
Par exemple pour EG on peut utiliser l’algorithme 4 ` base de recherche de composantes fortement connexes.
Exercice 44 (*). Modifier l’algorithme pour g´rer tous les cas suivants : ¬p, ∧, AX, AG, AF, EF, AR,
                                            e
ER, AW, EW, AU≤k , EU≤k . Adaptez les preuves de correction et de complexit´.   e

                                      `
Exercice 45 (Model checking de ECTL). a faire


4.3       Model checking de fair CTL par labelling
                        e                                                        e    e
    On a vu que CTL n’´tait pas assez expressive pour exprimer les contraintes d’´quit´s. Cela pose un gros
      e                                     e                ee
probl`me pratique, car souvent on ne veut v´rifier une propri´t´ que sur des chemins fair, sans tenir compte
                          e e
des chemins aberrants jug´s tr`s peu probables en pratique. Par exemple, pour un protocole de communica-
                           e                 u                       e
tion, on ne veut pas consid´rer les chemins o` les messages sont syst´matiquement perdus.

   En LTL ou CTL∗ ce type de propri´t´ s’exprimerait naturellement en utilisant une implication, par
                                         ee
                                ee                                         e     e
exemple ϕ =A(fairness→propri´t´ ). En CTL, on ne peut pas exprimer l’´quit´, mais on peut ruser en mo-
                                           e
difiant l’algorithme marking de telle mani`re qu’il ne prenne en compte que les chemins passant infiniment
                     e       e e
souvent par certains ´tats sp´cifi´s par l’utilisateur. Ainsi, on n’agit pas au niveau de la formule mais on
            o     e                 e                                          e    e             e
change plutˆt la s´mantique du mod`le. On peut ainsi simuler des formules d’´quit´ du type “tels ´tats sont
                       e
infiniment souvent visit´s”, qui suffisent habituellement en pratique. On obtient alors un algorithme fair-
marking, qui prend en entr´e M, ϕ et un ensemble F d’ensembles d’´tats Fi ⊆ Q appel´ contraintes d’´quit´.
                           e                                         e                 e             e    e



                                                         35
Algorithme marking-eg
entr´e : ϕ = EGϕ′ , M = Q, − , P, l, s0
    e                      →
 1:
 2:   Q’ := {s | ϕ′ ∈ l(s) } ;
 3:   SCC := { C | C non trivial SCC of Q’ } ;
 4:   L := C∈SCC { s | s ∈ C } ;
 5:   for all s ∈ L do s.ϕ := true end for
 6:   while L = ∅ do
 7:     choose s ∈ L ; L := L - {s} ;
 8:                     →
        for all (s’,s) ∈− such that s’ ∈ Q’ do
 9:        if (s’.ϕ = false) then
10:           s’.ϕ := true ;
11:           L := L + {s’} ;
12:        end if
13:     end for
14:   end while
15:
                                                              e
                      Algorithme 4: Model Checking de CTL par ´tiquetage, cas EGϕ


    Dans la suite, on distingue une nouvelle relation de satisfaisabilit´ M |=F ϕ signifiant “si on se restreint
                                                                        e
aux chemins fair, M satisfait ϕ”. Formellement, |=F est d´fini comme |=, sauf pour les propositions de base
                                                            e
p, et les quantificateurs A, E. Ainsi,
    – M, s |=F p ssi il existe un chemin fair partant de s et p ∈ l(s) ;
    – M, s |=F Ef ssi il existe un chemin fair σ partant de s et M, σ |=F f ;
    – M, s |=F Ap ssi tous les chemins fair σ partant de s v´rifient M, σ |=F f .
                                                               e

Fair SCC. Soit une structure de Kripke M et une contrainte d’´quit´ sur les ´tats F = {F1 , . . . , Fn }. On
                                                              e   e         e
dira qu’une composante fortement connexe C de M est fair (par rapport ` F ) si pour chaque Fi , il y a au
                                                                      a
          e           a      a
moins un ´tat commun ` C et ` Fi .

                e
Algorithme. L’id´e de l’algorithme fair-marking est la suivante :
      . on d´finit d’abord une proc´dure fair-marking-eg qui marque les ´tats s tels que M, s |=F EGf ,
            e                      e                                        e
        en supposant que les ´tats sont d´j` marqu´s pour M, s |=F f . Cette proc´dure est tr`s proche de
                             e           ea        e                                e        e
                                 e                   e                    o
        marking-eg, la seule diff´rence est de consid´rer les fair SCC plutˆt que les SCC.
                                                      e       a
      . on utilise fair-marking-eg pour marquer les ´tats s ` partir desquels partent des chemins fair. Pour
                                                                                e
        cela on ajoute une nouvelle proposition atomique fair valant EGtrue en s´mantique fair, et on utilise
        fair-marking-eg.
                        e
      . finalement, on r´utilise les anciens algorithmes de marquages pour les autres connecteurs, en remar-
        quant que M, s |=F p ssi M, s |= p ∧ fair, M, s |=F EXϕ ssi M, s |= EX(ϕ ∧ fair) et M, s |=F Eϕ1 Uϕ2
        ssi M, s |= ϕ1 EU(ϕ2 ∧ fair).

  e e                                       e
Th´or`me 4.3.1 (Correction et complexit´). L’algorithme fair-marking termine et retourne vrai ssi
M, s |=F ϕ. L’algorithme est en O(|M| · |ϕ| · |F |).
Exercice 46. Terminer la preuve de correction. Notamment expliquez pourquoi on peut utiliser fair-
                    e                    e                                      e                  e
marking-eg pour ´tiqueter EGtrue en s´mantique fair (point 2), et prouver les ´quivalences donn´es pour
passer de |=F a |=. Exprimer pour tous les connecteurs CTL la relation M, s |=F ϕ en fonction de |= et fair.
              `
   Enfin essayer de r´exprimer l’algorithme g´n´ral plus simplement, en ramenant M, s |=F ϕ a M′ , s |= ϕ,
                      e                       e e                                            `
o` M′ est une autre structure de Kripke et ϕ est la mˆme formule, sans fair.
 u                                                    e



                                                      36
Algorithme fair-marking-eg
entr´e : ϕ = EGϕ′ , M = Q, − , P, l, s0 , F = {F1 , . . . , Fn }
    e                      →
 1:
 2:   Q’ := {s | ϕ′ ∈ l(s) } ;
 3:   SCC := { C | C non trivial fair SCC of Q’ } ;
 4:   L := C∈SCC { s | s ∈ C } ;
 5:   for all s ∈ L do s.ϕ := true end for
 6:   while L = ∅ do
 7:     choose s ∈ L ; L := L - {s} ;
 8:                     →
        for all (s’,s) ∈− such that s’ ∈ Q’ do
 9:        if (s’.ϕ = false) then
10:           s’.ϕ := true ;
11:           L := L + {s’} ;
12:        end if
13:     end for
14:   end while
15:
                                                                e
                   Algorithme 5: Fair Model Checking de CTL par ´tiquetage, cas EGϕ


4.4       Model checking de LTL par automates
                                                                          −
Automates, mots et langages. Un automate A = Σ, Q, →, q0 , F est un quintuplet constitu´ d’un                  e
                                                    →
ensemble d’´tats Q reli´s par des transitions − ⊆ Q × Σ × Q ´tiquet´es par les lettres d’un alphabet fini Σ.
             e              e                                          e       e
             e                       e                      e                                   e
Parmis les ´tats on distingue l’´tat initial q0 et les ´tats finaux F . Un mot w accept´ par A est une suite
fini de lettre v1 . . . vn telle qu’il soit possible d’aller de l’´tat initial q0 ` un ´tat final f ∈ F en prenant une
                                                                 e               a     e
           e        e                           e       e                            a
transition ´tiquet´e par v1 , puis une autre ´tiquet´e par v2 , puis etc. jusqu’` atteindre f . L’ensemble des mots
accept´s par un automate A est not´ L(A). Les langages ainsi d´finissables s’appellent langages r´guliers.
       e                                   e                                e                                e
                                      e ee                                         e
Les automates offrent une mani`re ´l´gante de manipuler les langages r´guliers. Ainsi on peut facilement `          a
partir de deux automates A1 et A2 calculer un automate qui reconnait L(A1 ) ∩ L(A2 ) ou tester si L(A) = ∅,
ou bien encore tester si L(A1 ) = L(A2 ).
                                       e     ea                          ıt
   Par exemple, l’automate repr´sent´ ` la figure 4.2 reconnaˆ le langage des mots terminant par a. Les
e                         e     e                              e
´tats finaux sont repr´sent´s par des doubles cercles, l’´tat initial est flˆch´.  e e

                                                     a                 b



                                                               b
                                                    S1                S2

                                                              a



                                         Fig. 4.2: Exemple d’automate.

Exercice 47. Donnez des algorithmes pour : tester l’appartenance, tester le vide, construire l’union / l’in-
                     e                                                    e
tersection / le compl´ment du langage d’un automate. Discutez la complexit´.

                               e       e                             e
Liens intuitifs avec les syst`mes r´actifs. On peut voir un syst`me de transitions comme un automate
              e                                                               e
dont tous les ´tats sont acceptants. Les structures de Kripke, en mettant les ´tiquettes sur les transitions et
                 e                                a
non plus sur les ´tats, peuvent aussi se ramener ` des automates. Dans ce cas, le langage de l’automate est
                          e                                             e                ee
presque l’ensemble des ex´cutions, soit exactement ce sur quoi on veut v´rifier des propri´t´s temporelles. On
peut imaginer alors par exemple qu’une question comme “est-ce que M1 et M2 ont mˆmes comportements ?”
                                                                                      e

                                                         37
se ram`ne ` tester L(A1 ) = L(A2 ). Il y a quand mˆme une diff´rence : on a ici des ex´cutions finies, alors
      e a                                         e            e                       e
                    e    e            e                                                 e        e
que nous sommes int´ress´s par des ex´cutions (mots) infinies. Pour pallier cette difficult´ on va d´finir alors
des automates de mots infinis.

                     u           e
Automates de B¨ chi. On ´tend les automates pour travailler sur des mots infinis. Un automate de
                                    →
B¨ chi est un automate B = Σ, Q, − , q0 , F , mais la condition d’acceptation est modifi´e. L’ensemble F est
  u                                                                                    e
                  e                 e                                           e
maintenant appel´ l’ensembles des ´tats acceptants. Un mot infini σ est accept´ si il part de q0 , respecte la
relation de transition et passe infiniment souvent par un ´tat acceptant f ∈ F .
                                                          e

                              e                                                             u
   Par exemple, si on consid`re maintenant l’automate de la figure 4.2 comme un automate de B¨ chi, le
                                                   e
langage reconnu est celui des mots ayant une infinit´ de a.
             ´
Exercice 48. Ecrire des automates de B¨chi sur l’alphabet {a, b} reconnaissant les langages suivants : aw ,
                                      u
 ∗       w
b a(a, b) .
                                                                                          u
Exercice 49. Comment tester l’appartenance d’un mot au langage d’un automate de B¨chi ? Comment
                                 u                                                                 u
tester le vide d’un automate de B¨chi ? Comment calculer l’union et l’intersection d’automates de B¨chi ?
                           e                                     u
Remarque 4.4.1. Deux diff´rences notables entre automates de B¨ chi et automates finis : (1) les automates
      e                                                               e                          e
non d´terministes sont strictement plus expressifs que les automates d´terministes ; (2) la compl´mentation
est une op´ration extrˆmement coˆ teuse, en th´orie1 comme en pratique. Il est courant de ne pas pouvoir
          e           e           u            e
      e                                      e
compl´menter un automate d’une centaine d’´tats.

Model checking de LTL. Le model checking de LTL par automates suit les points suivants :
 1. transformer une formule de chemin ϕp en automate de B¨ chi B¬ϕp ;
                                                            u
 2. transformer M en automate de B¨ chi BM ;
                                      u
 3. calculer l’automate B⊗ reconnaissant L(BM ) ∩ L(B¬ϕp ) ;
 4. tester si le langage reconnu par B⊗ est vide ou non. On a L(B⊗ ) = ∅ ssi M |= Aϕp .

Intuitivement, L(BM ) va repr´senter toutes les ex´cutions (infinies) de M et L(B¬ϕp ) va repr´senter toutes
                               e                  e                                            e
les ex´cutions ne satisfaisant pas ϕp . Ainsi L(BM ) ∩ L(B¬ϕp ) est vide ssi tous les chemins de M satisfont
       e
ϕp , ssi M |= Aϕp .
    Pour la construction de B¬ϕp , on proc`dera r´cursivement. Bien entendu, ∧, ∨, ¬ se traduiront par l’inter-
                                          e      e
                            e
section, l’union et le compl´ment sur les automates et on fait des constructions ad hoc pour les connecteurs
temporels. Par exemple la figure 4.3 pr´sente un automate de B¨ chi pour F∞ p.
                                        e                        u

                                                     not p                       p



                                                                     p


                                                                   not p



                                       Fig. 4.3: Automate de B¨ chi pour F∞ p.
                                                              u


Exercice 50. Transformez les propri´t´s de chemin suivantes en automates de B¨chi sur alphabet {p, q, ¬p, ¬q} :
                                    ee                                       u
p, ¬p, Xp, Fp, Gp, pUq, pWq, F∞ p, G∞ p, pU≤3 q.
                                                                                                   2
  1 Pendant longtemps le meilleur algorithme ´taient double exponentielle, maintenant on est a O(2n ), mais avec des constantes
                                             e                                               `
                               e      `
importantes et un algorithme tr`s fin a implanter.


                                                              38
                     e                            u          e    u                        e
Exercice 51. La compl´mentation des automates de B¨chi est tr`s coˆteuse. Proposer une mani`re de s’en
passer.
Exercice 52 (Model checking de CTL∗ (**)). Montrez comment adapter l’algorithme de model checking de
           e                        e
LTL pour r´soudre des formules lin´aires du type Eϕ, avec ϕ une formule de chemin (on parlera de E-LTL
et A-LTL). Montrez ensuite comment modifier l’algorithme de model checking de E-LTL et A-LTL pour
                 e      e                        o                  e                                      e
marquer tous les ´tats v´rifiant une formule, plutˆt que savoir si l’´tat initial satisfait la formule. En d´duire
                                               ´
un algorithme de model checking pour CTL∗ . Evaluer sa complexit´.   e

                                e                                   e
Remarques sur la complexit´. On peut montrer que le probl`me du model checking de LTL est
                                      e
PSPACE-complet. L’algorithme propos´ ici est exponentiel : exponentiel pour la transformation de la for-
mule, polynˆmial pour le produit et polynˆmial pour le test du vide. La complexit´ est en O(|M| × 2|ϕ| ).
           o                             o                                       e
Quelques remarques :
  1. Mˆme si la complexit´ peut paraˆ ´lev´e, on remarque qu’elle est lin´aire en la taille de M et que
       e                    e           ıtre e e                         e
     |ϕ| est souvent petit. Ce r´sultat n’est donc pas r´dhibitoire.
                                e                       e
                                                                       e e                         e
  2. Ensuite cet algorithme n’est pas optimal du point de vue complexit´, mˆme s’il a l’avantage d’ˆtre simple
     a                                              e                                           e      e
     ` comprendre. On peut atteindre la complexit´ optimale en utilisant des automates plus ´labor´s, dits
     alternants avec b´gaiement2 .
                       e
                                        ee       u e                                                e
  3. On peut faire mieux pour les propri´t´s de sˆ ret´ en utilisant des automates finis, voir ci-apr`s.
                                                        e
  4. En pratique le model checking par automate se prˆte bien a certaines optimisations, par exemple la
     construction ` la vol´e de M (plutˆt que tout construire d’abord) ou la r´duction par ordres partiels.
                  a       e            o                                      e
     ¸                             e          e     e e
     Ca ne change pas la complexit´ du probl`me g´n´ral mais change parfois radicalement les choses en
     pratique.

   e                    e e
Sp´cifier des propri´t´s temporelles par des automates. On a vu que nos formules LTL avaient une
                                          u                             u                       a
correspondance avec les automates de B¨ chi. En fait les automates de B¨ chi sont un formalisme ` la fois plus
                                        e            e                                                   e
expressif que LTL et plus facile d’acc`s pour les ing´nieurs. Plusieurs model checkers pour logique lin´aire
                            e               ee                                  u
proposent donc aussi de d´finir des propri´t´s directement par automate de B¨ chi, et appliquent le mˆme   e
                                            e                         e                 e
algorithme que pour LTL. L’approche est s´duisante mais a un gros d´faut : on est oblig´ cette fois de passer
              e                                        e           e      e
par la compl´mentation de l’automate et la complexit´ augmente ´norm´ment. On peut aussi imaginer que
                                                     e      e
l’utilisateur fournisse directement l’automate compl´ment´ (laborieux et pas toujours plus efficace) ou se
restreigne aux automates de B¨ chi d´terministes faciles ` compl´menter mais moins expressifs (pas de G∞
                                u      e                  a      e
par exemple).

  u e
Sˆ ret´ et lien avec les automates observeurs. On peut voir le model checking de LTL comme une
    e                                                u                                      u
am´lioration du principe des automates observeurs, o` on synchronise avec un automate de B¨ chi et on teste
              e                                                      e                ee              e
l’accessibilit´ d’une composante fortement connexe. Cela permet de v´rifier des propri´t´s de vivacit´ mais
       a                                                                                  ee         u e
oblige ` manipuler des objets plus complexes. En fait on peut montrer que pour les propri´t´s de sˆ ret´ on
                                                                                                    e
peut souvent se ramener automatiquement au cas d’un automate fini, ce qui peut permettre d’am´liorer la
  e                    e                                                           ee       u e
v´rification. Le probl`me reste alors de pouvoir identifier syntaxiquement ces propri´t´s de sˆ ret´.

Automates et logiques branchantes. On peut utiliser des automates pour le model checking de CTL
et CTL∗ . On utilise alors des automates d’arbres infinis, et l` encore des automates alternants permettent
                                                              a
             e                              e                                a
des complexit´s optimales. On peut aussi d´finir des logiques branchantes ` base des automates d’arbres.
Cependant ces travaux sont plutˆt d’int´rˆt th´orique car CTL∗ est d´j` suffisament expressive et de toute
                                 o      e e   e                        ea
     e            e                                                         e
mani`re peu utilis´e en pratique tandis que CTL a des algorithmes optimis´s beaucoup plus efficaces.



  2 Le    e
         r´sultat est meilleur, mais reste exponentiel en pratique


                                                                39
 ee
R´f´rences

         e                                                                                      e
[1] B. B´rard, M. Bidoit, A. Finkel, F. Laroussinie, A. Petit, L. Petrucci and P. Schnoebelen. V´rification
    de logiciels. Techniques et outils du model-checking. Vuibert, 1999.
[2] E. M. Clarke, O. Grumberg and D. A. Peled. Model Checking. MIT press, 1999.
[3] E. M. Clarke and J. Wing. Formal Methods : State of the Art and Future Directions. ACM, 1996.
[4] H. Comon. Automates et logiques temporelles. Cours Ens Cachan. www.lsv.ens-cachan.fr/∼comon
[5] S. Demri. Temporal logics. Cours Mpri, Paris 7. www.lsv.ens-cachan.fr/∼demri
[6] R. P. Kurshan. Formal Verification In a Commercial Setting. In ACM IEEE DA’97. ACM, 1997.
[7] M. Y. Vardi. Branching vs linear time : Final showdown. In TACAS’2001. LNCS 2031. Springer, 2001.
[8] M. Y. Vardi. Automata-theoretic model checking revisited. In VMCAI’2007. LNCS 4349. Springer, 2007.
[9] M. Y. Vardi. From Church and Prior to PSL. In 25MC. 2006.




                                                   40
Annexe A

Rappels de logique

A.1       e
         D´finitions
                            e
   Une logique est la donn´e de
                                        e
   – (aspect syntaxique) un langage (r´cursif) L de formules ϕ.
   – (aspect s´mantique) un domaine S d’interpr´tations I
                e                                   e
   – (relie les deux) une relation de satisfaction |=⊆ S × L

 e
D´finition A.1.1. On dit que
   – I est un mod`le de ϕ si I |= ϕ. Dans ce cas on dit que I satisfait ϕ.
                   e
                                                 e
   – ϕ est satisfaisable si il existe une interpr´tation qui la satisfait.
   – ϕ est valide si toute interpr´tation la satisfait. On note alors |= ϕ.
                                    e
                                              e
   – ϕ est contradictoire si aucune interpr´tation ne la satisfait.
        e                              e          e                                    e
    La s´mantique d’une formule ϕ, not´e ϕ , peut ˆtre vue comme l’ensemble des interpr´tations qui la
satisfont. C’est ` dire que ϕ = {I ∈ S|I |= ϕ}.
                 a
 e
D´finition A.1.2. On dit que :
   – Un ensemble A ⊆ S est L-d´finissable si il existe une formule ϕ de L telle que A = ϕ .
                                e
                            e                                 e                       e
   – Pour une logique donn´e L, l’ensemble des ensembles L-d´finissables donne une id´e du pouvoir d’ex-
                            e                e
     pression de L (cf probl`me d’expressivit´ si dessous).


A.2           e                 e
         Probl`mes classiques li´s aux logiques
             e             a
        Probl`mes relatifs ` une formule de la logique :
  1. (MC) Model checking. Entr´e : I, ϕ. R´ponse : est-ce que I |= ϕ ?
                              e           e
  2. Validit´. Entr´e : ϕ. R´ponse : est-ce que |= ϕ ?
            e      e        e
                             e        e
  3. (SAT) Satisfaction. Entr´e : ϕ. R´ponse : est-ce que ϕ est satisfaisable ?
  4. Synth`se. Entr´e : ϕ. R´ponse : donner, si il existe, I tel que I |= ϕ.
          e        e        e
             e             a                   e
       Probl`mes relatifs ` la logique elle-mˆme :
                   e  ´           e                                  e              e
  1. Expressivit´. Etant donn´ deux logiques, est-ce qu’elles d´finissent les mˆmes ensembles ?
                   ´          e                                                              e
  2. Concision. Etant donn´ deux logiques, est-ce que les formules pour exprimer les mˆmes ensembles ont
       e
     mˆme taille ?
                                  ´
  3. Pouvoir de s´paration. Etant donn´ une logique L et deux interpr´tations I1 et I2, est-ce que L
                     e                        e                                 e
     peut les distinguer, c’est ` dire est-ce qu’il existe ϕ ∈ L telle que I1 |= ϕ et I2 |= ϕ ?
                                a


                                                     41
A.3         Quelques logiques
                                ee e                      e a
   De nombreuses logiques ont ´t´ d´finies, chacune adapt´e ` exprimer un point de vue particulier. Ce travail
prend surtout en compte le pouvoir d’expression et la concision. De plus, dans le cadre du raisonnement
                                                     ee       e                   e         e              e
automatique, de nombreuses sous-classes ont ensuite ´t´ explor´es pour gagner en d´cidabilit´ et complexit´.
                               e                            e
   – logiques classiques de pr´dicats (fondements des math´matiques)
                                         e
   – logique classique propositionnelle (´lectronique)
   – logiques intuitionistes (fondements de la programmation)
   – logiques lin´aires1 (prise en compte des ressources)
                 e
   – logiques monadiques (diverses types de raisonnements en IA, par exemple croyances & savoirs)


A.4         Exemple : logique classique propositionnelle
             e
   On consid`re le cas le plus simple : la logique des propositions. On se donne un ensemble fini A1 , . . . , An
                                                                            e
de propositions atomiques. Le langage des formules propositionnelles est d´fini par la grammaire :
     atome : := Ai — ⊤ — ⊥
     formule : := formule ∨ formule — formule ∧ formule — ¬ formule — atome
   Le domaine d’interpr´tation S est l’ensemble des valuations bool´ennes des Ai . Une interpr´tation I est
                        e                                          e                          e
donc une fonction qui assigne une valeur dans {0, 1} ` chaque Ai .
                                                     a
   La satisfaction I |= ϕ est d´finie inductivement par :
                                e
     I |= ⊤ pour tout I,
     I |= ⊥ pour tout I,
     I |= Ai si I(Ai ) = 1,
     I |= f1 ∧ f2 si I |= f1 ou I |= f2 ,
     I |= f1 ∨ f2 si I |= f1 et I |= f2 ,
     I |= ¬f si I |= f .
Exercice 53 (Logique des propositions).
  1. Dites pour chaque interpr´tation I si elle est un mod`le de la formule A ∨ (¬B) :
                                e                            e
     I1 : (A, B) −→ (0, 0), I2 : (A, B) −→ (1, 1), I3 : (A, B) −→ (1, 0).
  2. Que dire des formules suivantes (satisfaisable, valide, contradictoire) : A ∧ ¬A, A ∨ ¬A, A ∨ B
  3. Ajouter a la logique les connecteurs →, ↔ et xor.
             `
  4. Exprimer ces connecteurs en fonction des anciens.
  5. Exprimer ∨, ⊤, ⊥ en fonction de ∧, ¬.
  6. Montrer que tous les connecteurs peuvent s’obtenir a partir de ¬p ∧ ¬q.
                                                        `
Exercice 54. Quel lien y a-t-il entre satisfaisabilit´ de f et validit´ de ¬f ?
                                                     e                e
Exercice 55. On d´finit la relation ≡ sur les formules logiques par ϕ1 ≡ ϕ2 ssi ϕ1 et ϕ2 ont les mˆmes
                  e                                                                              e
mod`les. Donnez une d´finition formelle de “ont les mˆmes mod`les”. Quel est le lien entre ϕ1 ≡ ϕ2 et
   e                 e                               e         e
ϕ1 ↔ ϕ2 ?
Exercice 56 (**). Soit F un ensemble fini de formules de logique classique propositionnelle sur des propo-
                                    `
sitions atomiques p1 , . . . , pn . A partir de quelle valeur de |F | est-on sˆr d’avoir au moins deux ϕ1 , ϕ2 ∈ F
                                                                              u
telles que ϕ1 ≡ ϕ2 ?
Exercice 57 (Forme normale (*)). Montrer que toute formule ϕ peut se mettre sous une forme                i   j   ¯
                                                                                                                  pi ,
o` pi vaut soit pi soit ¬pi .
 u ¯
  1 Rien   `
           a voir avec LTL



                                                       42
Exercice 58 (QBF (*)). On appelle QBF ( Quantified boolean Formulas) la logique des propositions a    `
laquelle on ajoute les quantificateurs ∃ et ∀. On pourra ainsi ´crire des formules comme : ∃x, x ∧ y.
                                                              e
  1. D´finissez |= pour ces nouveaux op´rateurs.
      e                               e
  2. Montrer que toute formule ϕ de QBF peut se traduire en une formule ϕ de logique des propositions.
  3. Quel lien y a-t-il entre |ϕ| et |ϕ| ?




                                                  43
Annexe B

                       e             e
Notions de calculabilit´ et complexit´

B.1                     e
            Calculabilit´
              e                                 e     a                      e
Calculabilit´. Ce domaine de recherche s’int´resse ` distinguer les probl`mes solubles par ordinateur (avec
des ressources arbitrairement grandes, mais finies1 ) de ceux qui ne le sont pas. On mod´lise un probl`me par
                                                                                        e             e
                              e                    e                       a     e
un langage (des couples entr´es-solution). On ram`ne alors le but initial ` la d´finition de langages reconnus
                      e                       e           e              e
par un certain mod`le de machine. Ce mod`le se doit d’ˆtre le plus pr`s possible de la notion de “fonction
                                    e                                              e
humainement calculable”, sinon d`s qu’un formalisme plus puissant serait trouv´, il faudrait tout refaire. Le
                                                                                               e
formalisme choisit est celui des machines de Turing. Ce sont globalement des automates ´tendus par un
                        e                   e                               e        e             e
ruban infini et des op´rations de lecture / ´criture. On se limite aux probl`mes de d´cisions. On d´finit entre
                                          e
autre les trois classes suivantes de probl`mes / langages :
            e      e
   – probl`me d´cidable : soluble par un programme.
            e        e                                                 e
   – probl`me ind´cidable : il ne peut exister de programme qui le r´soud.
            e            e                                     e
   – probl`me semi-d´cidable : il existe un programme qui r´pond toujours 1 quand il faut, mais qui peut
            e                                         e
      soit r´pondre 0 soit ne pas terminer quand la r´ponse est “faux”.

                     e        e
Exemples de probl`mes d´cidables. La plupart des questions raisonnables sur les automates finis sont
  e                                                e
d´cidables, par exemple savoir si un mot est accept´ ou si le langage reconnu est vide. Les questions relatives
a                                                                                      e
` des logiques simples, typiquement la logique des propositions, sont souvent aussi d´cidables.

                       e          e                                    a          e        e
Exemples de probl`mes ind´cidables. On arrive rapidement ` des probl`mes ind´cidables quand on
            a                                                       e           e                e
commence ` utiliser les machines de Turing (comme outil de d´cision) pour r´soudre des probl`mes sur les
                                      e                           e
machines de Turing (comme objet d’´tude). En fait “Tout probl`me non trivial sur les machines de Turing est
   e             e e                                              e
ind´cidable” (th´orˆme de Rice). Par exemple on ne peut pas d´cider si une machine de Turing termine, peut
atteindre un certain point de son programme ou fait ce qu’elle devrait faire. Ce dernier point est important
                        e                                              e
car il implique que la v´rification automatique de vrais programmes, ´crits dans de vrais langages et tournant
sur de vrais ordinateurs, est impossible.
                        e                           e       a
    Pour regagner en d´cision, il faut en fait s’int´resser ` des formalismes moins puissants.

    e                        e               e                    e                       e
Th`se de Church. La th`se de Church d´clare qu’aucun syst`me de calcul automatis´ ne peut avoir une
               e       `                                                               e
puissance sup´rieure a celle des machines de Turing, du point de vue de la calculabilit´.
                                                                                              e
    Cela signifie que nos ordinateurs actuels, tout comme les ordinateurs qui seront invent´s dans 1000 ans
                       ee      e                                                                       e
ou ceux qui auraient ´t´ utilis´s a long time ago in a galaxy far, far away ont fondamentalement les mˆmes
          e                e                                                                   e         e
possibilit´s et limites th´oriques que les machines de Turing. Ainsi si on accepte cette th`se, le caract`re
    e                    e                e                                                 e
ind´cidable d’un probl`me n’est plus sp´cifique aux machines de Turing mais est intrins`que au probl`me  e
      e
lui-mˆme.
  1 C’est      e                         e     e       e
            coh´rent puisqu’on ne peut gu`re pr´voir l’´volution future des moyens de calcul.


                                                               44
                                                       e                                  e
    Deux remarques importantes : quand on dit “la mˆme puissance” c’est en terme de d´cision. La conjecture
                                                               e                       e                 e   a
ne dit rien sur la vitesse de calcul, et donc sur la possibilit´ pratique de mener la r´solution du probl`me `
                                                 e e         e
bien. Ensuite c’est une conjecture et pas un th´or`me. Mˆme si on a de fortes raisons d’y croire, rien ne dit
qu’elle ne sera jamais remise en cause.
    Les preuves de la conjecture reposent principalement sur le fait que d’une part toutes les extensions
     e                                                                 e
tent´es sur les machines de Turing (probabiliste, quantique, non d´terministe) n’ont au final pas ajout´ de e
                                                                   e
pouvoir d’expression, et d’autre part que toutes les autres mod´lisations de la notion de fonction calculable
            a                       e
ont abouti ` des formalismes de mˆme pouvoir que celui des machines de Turing, bien que partant parfois de
            e     e                                                                         e
concepts tr`s diff´rents. On peut citer par exemple le λ-calcul de Church, les fonctions r´cursives de Kleene
                     e e
et les grammaires g´n´ratives de Chomsky.
                                                   e
    Remarquons enfin que la conjecture dite th`se forte de Church-Turing (ils n’en sont pas auteurs) qui
                      e                        e                  a                 o         e
stipule que tout syst`me de calcul automatis´ est aussi rapide ` un facteur polynˆmial pr`s qu’une machine
                                      a
de Turing pourrait bien s’effondrer ` cause des ordinateurs quantiques (quantum computing) et biologiques
                                                                                  e e       e
(DNA computing). Cependant la conjecture n’est pas encore formellement r´fut´e, mˆme si on la pense
maintenant assez improbable.


B.2                  e
            Complexit´
                   e           a                          e       e
    La complexit´ s’interesse ` distinguer parmi les probl`mes d´cidables ceux qui le sont en temps et en
m´moire raisonnables, de ceux qui ne le sont pas2 . On classe ainsi les probl`mes d´cidables selon leur classe
  e                                                                          e     e
              e        a                                                            e               e
de complexit´, c’est ` dire selon le minimum de ressources qu’un algorithme qui r´soud ces probl`mes doit
 e               e
d´penser. On d´finit par exemple les classes suivantes :
                e                            o
    – P : probl`mes solubles en temps polynˆmial.
                    e                           o                               e
    – N P : probl`mes solubles en temps polynˆmial sur une machine non d´terministe. En pratique ils
                 e
      peuvent n´cessiter un temps exponentiel.
    – P N P : probl`mes solubles avec un nombre d’appels polynˆmial a une machine ind´terminste. En pra-
                     e                                          o      `                 e
                         e
      tique ils peuvent n´cessiter un temps exponentiel.
                         e                             o                                  e
    – P SP ACE : probl`mes solubles en espace polynˆmial. En pratique ils peuvent n´cessiter un temps
      exponentiel.
                                                             e
    – N P SP ACE : comme P SP ACE pour machines non d´terministes.
    – EXP T IM E, N EXP T IM E, EXP SP ACE, N EXP SP ACE, 2 − EXP T IM E ,. . .
                       e    e
    Les classes sont pr´sent´es en ordre d’inclusion croissant. Il est acquis que P SP ACE = N P SP ACE,
EXP SP ACE = N EXP SP ACE, etc. Peu d’inclusions strictes sont connues. On est certain des inclusions
strictes entre P , EXP T IM E, 2−EXP T IM E, etc. Idem pour P SP ACE, EXP SP ACE, 2−EXP SP ACE,
                                         e
etc. On sait aussi que P SP ACE est diff´rent de EXP T IM E.
   Par contre on ne sait par exemple si P = P SP ACE ou si P = N P .
                       e          e                                     e        e           e        e
   Pour donner une id´e de la hi´rarchie, typiquement, si on a un syst`me d’in´quations lin´aires : v´rifier
une solution est dans P , trouver une solution est dans N P et trouver une solution minimale est dans P N P .




  2 Des                  e        e                          e e
          milliards d’ann´e pour r´pondre 42 n’est pas consid´r´ comme raisonnable.


                                                             45
Annexe C

            e
Divers probl`mes algorithmiques

C.1        Composantes fortement connexes
                                   e                              u                         e
    Formellement un graphe orient´ G est une paire G = Q, T o` Q est un ensembles d’´tats (ou nœuds)
et T ⊆ Q × Q un ensemble de transitions. Comme d’habitude, (q, q ′ ) ∈ T signifie qu’on peut aller de q ` q ′a
                                                                                          ∗
en prenant une transition du graphe. On dit que q ′ est atteignable ` partir de q, not´ q − q ′ si il existe un
                                                                    a                 e →
chemin (une suite de transitions) de q ` q ′ .
                                       a
  e                                                    e
D´finition C.1.1. Soit G = Q, T un graphe orient´. On appelle composante connexe de G tout sous
ensemble non vide C ⊆ Q tel que pour tout ci , cj ∈ C, cj est atteignable ` partir de ci en restant dans C.
                                                                          a
    Une composante fortement connexe est une composante connexe maximale : si on lui rajoute un nouveau
nœud, elle n’est plus connexe. Un composante fortement connexe non triviale a soit au moins deux nœuds,
soit un seul nœud avec une transition sur lui-mˆme, c-`-d (q, q) ∈ T . On s’int´resse ` la d´composition en
                                               e      a                        e      a     e
                                                                 e                  e
composantes fortement connexes non triviales d’un graphe orient´.Un exemple de d´composition est donn´    e
a
` la figure C.1.




                                          e
                    Fig. C.1: Exemple de d´composition en composantes fortement connexes


Algorithme de Kosaraju (1978). Intuitivement l’algorithme est en trois passes. (1) On fait une recherche
en profondeur d’abord1 dans le graphe G, et on marque chaque nœud dans l’ordre o` il est trait´ (les feuilles
                                                                                        u            e
ont les plus bas indices, la racine a le plus haut). (2) On inverse G en Gr , en inversant le sens des transitions.
                                                                                                        e
(3) On part du nœud d’indice le plus haut, et on fait une DFS dans Gr . Tous les nœuds rencontr´s forment
          e                                                                  ee          e
la premi`re composante fortement connexe. Si tous les nœuds n’ont pas ´t´ rencontr´s, on recommence avec
l’indice le plus haut restant.
                                                                                   e
Exercice 59. Prouvez la correction de l’agorithme de Kosaraju. Pour cela, vous proc´derez en deux phases.
                                              e                               e               e
D’abord (1) montrez que si x, y sont dans la mˆme SCC alors ils sont dans le mˆme arbre calcul´ par la DFS
sur Gr . Puis (2) montrez le sens inverse.
  1 DFS   pour depth first search.


                                                        46
Algorithme kosaraju
input : graph G = Q, T , initial state s0
 1: depth := 0 ;
 2: L := Q ;
 3: SCC := ∅ ; // set of SCCs
 4: marking dfs(s0) ;
 5: L := Q ;
 6: while L = ∅ do
 7:   choose s ∈ L with highest s.depth ;
 8:   CurrentSCC := ∅ ;
 9:   drawing scc(s) ;
10:   SCC := SCC + {CurrentSCC}
11: end while
12: RETURN(SCC) ;
13:
14:   procedure marking dfs(s) // DFS transversal and marking
15:     L := L - {s} ;
16:     forall (s, s’) in T do
17:        if (s’ ∈ L) do marking dfs(s’) ; end if
18:     end for
19:     s.depth := depth ; depth := depth + 1
20:   end proc
21:
22:   procedure drawing scc(s) // DFS on Gr to recover current SCC
23:     CurrentSCC := CurrentSCC + {s} ;
24:     L := L - {s} ;
25:     forall (s’, s) in T do
26:       if (s’ ∈ L) do drawing scc(s’) ; end if
27:     end for
28:   end proc
                                     e
                      Algorithme 6: D´composition en SCC, algorithme de Kosaraju




                                                   47
Annexe D

Sujets de partiel

D.1                e
         ENSTA, ann´e 2006-2007
Exercice 60.
  1. Qu’est-ce que le model checking ?(2 lignes max)
  2. Citer deux domaines d’application du model checking.
                           e                   e    e
  3. Quelles sont les carat´ristiques d’un syst`me r´actif ? (5 lignes max)
                                        ` e          e
  4. Quels sont les liens entre machine a ´tats, syst`mes de transitions et structure de Kripke ? (5 lignes
     max)
  5. Qu’est-ce qui distingue les logiques temporelles de la logique classique ? (2 lignes max)
  6. Qu’est-ce qu’un connecteur temporel ? Quels sont les connecteurs temporels vus en cours ?
  7. Qu’est-ce qu’un quantificateur de chemin ? Quels sont les quantificateurs de chemin vus en cours ?
                      e                                                     e
  8. Quelle est la diff´rence entre une logique branchante et une logique lin´aire ?
  9. Quelles sont les diff´rences (au niveau d´finitions) entre CTL∗ , LTL et CTL ?
                         e                    e
 10. A` quelles grandes classes de propri´t´s temporelles (accessibilit´, invariance, etc.) appartiennent ces
                                         ee                            e
     formules : AGp, EFp, A((¬pUq) ∨ G¬p), A(GFp → GFq), AG(p → Fq).
 11. Exprimer ∨, F, G en fonction de ¬, ∧, U.
                   e e                                                               e
 12. Quel est l’int´rˆt de restreindre ainsi le nombre de connecteurs ? Quel est le d´savantage ?
 13. Quelles logiques parmi LTL, CTL et CTL∗ peuvent exprimer l’´quit´ ?
                                                                e    e
 14. Faites un sch´ma indiquant les relations d’inclusion entre LTL, CTL, CTL∗ et ACTL∗ (vue en TD).
                   e
                                                                ee e                          e
     Quand deux logiques sont incomparables, donnez une propri´t´ d´finissable dans la premi`re et pas dans
     la seconde, et vice versa. Quand une logique est incluse dans une autre, dites pourquoi.
                e                                 ee
 15. Comment v´rifieriez-vous les types de propri´t´s suivants si vous aviez un model checker pour (1) CTL,
     (2) LTL, (3) CTL∗ ? (a) accessibilit´, (b) invariance, (c) ´quit´.
                                         e                      e    e


Exercice 61.
                                                    e    e                             e
  1. Quels sont les algorithmes de model checking pr´sent´s dans le cours ? Donnez l’id´e de chacun des
     algorithmes. (15 lignes max en tout)
                                           e
  2. Pour l’algorithme de marquage de CTL, ´crivez les cas AXϕ et AGϕ, sans passer par une traduction
                     e
     dans d’autres op´rateurs.
                                u        e                  ee
  3. Dessinez les automates de B¨chi repr´sentant les propri´t´s GFp et FGp.


                                                     48
                                     e                                      e            e
Exercice 62. Montrer que le probl`me du model checking de LTL se ram`ne au probl`me de la validit´ de    e
                                                                                              →
LTL. Plus pr´cis´ment, on se donne une formule LTL ϕ et une structure de Kripke M = Q, − , P, l, s0 . On
              e e
va construire une formule ϕ′′ telle que M, s0 |= ϕ ssi ϕ′′ est valide. Pour cela on va construire une formule
ϕ′ telle que σ |= ϕ′ ssi σ ∈ L(M). On commence par rajouter une variable propositionnelle psi pour chaque
´tat si de M.
e
                                                                       ee              e e
  1. Construisez les formules suivantes : PROPsi qui indique les propri´t´s atomiques v´rifi´es par si et
     NEXTsi qui mime la relation de transition de M.
  2. Servez-vous des r´sultats pr´c´dents pour construire ϕ′ .
                      e          e e
  3. Concluez en construisant la formule ϕ′′ cherch´e a partir de ϕ′ et ϕ.
                                                   e `


D.2                             e
         ENSTA, rattrapages, ann´e 2006-2007
Exercice 63 (Questions de Cours).
  1. Qu’est-ce que le model checking ?
  2. Qu’est-ce qu’une logique temporelle ?
       e               e                                                              o
  3. D´tailler les entr´es-sorties d’un algorithme de model checking et expliquer le rˆle de chacune des
         e
     entr´es.
                              e
  4. Que signifient logique lin´aire et logique branchante ?
                  e                                                      e
  5. Donner une d´finition de la logique CTL, par exemple en citant les op´rateurs permis ou en donnant
     la grammaire des formules CTL.
Exercice 64. Pour l’algorithme de model checking pour CTL :
                    e
  1. Donner les entr´es-sorties.
  2. Expliquer le principe de l’algorithme.
     Vous pourrez par exemple illustrer le fonctionnement sur un petit exemple ou vous appuyer sur du
     pseudo-code de haut niveau.
                                  e
  3. Donner un programme pour g´rer les cas EXϕ et AXϕ.
                                                             e                         o
     Vous pourrez utiliser du pseudo-code, par exemple des op´rations ensemblistes plutˆt que des manipu-
                                  e
     lations de structures de donn´es.
                                      e                   e
Exercice 65. Expliquer la notion de s´mantique fair utilis´e dans l’algorithme de model checking de fair
CTL. Quelles formules peut-on alors exprimer dans fair CTL ?
Exercice 66. Soit deux structures de Kripke M1 , M2 ayant mˆme langage L(M1 ) = L(M2 ), et ϕ une
                                                           e
formule LTL. Que peut-on dire si M1 |= ϕ ? Que se passe-t-il maintenant si L(M1 ) ⊆ L(M2 ) ? Ces
 e
r´sultats sont-ils valides pour ϕ dans CTL ?
Exercice 67 (Questions de Cours).
  1. Qu’est-ce qu’une logique temporelle ?
  2. Pourquoi utilise-t-on des logiques temporelles ? Quels sont les avantages par rapport au langage naturel
        `
     et a la logique classique ?
  3. D´finissez LTL, CTL∗ , CTL.
      e
Exercice 68. Model checking de LTL
      e                                   u                        e
  1. D´finition formelle des automates de B¨chi et du langage associ´
                              u
  2. Lien LTL - automates de B¨chi
  3. Illustrer ce lien pour les formules FGp et GFp.
        e
  4. Sch´ma de l’algorithme de model checking de LTL

                                                     49
             `                          u
Exercice 69. A propos des automates de B¨chi :
                                                                            u
  1. Comment tester si un mot infini appartient au langage d’un automate de B¨chi ?
                                                    u
  2. Comment tester si le langage d’un automate de B¨chi est vide ?

Exercice 70 (Questions de Cours).
                    e                                       ee                                     e
  1. Donner une d´finition de chacune des classes de propri´t´s temporelles suivantes : accessibilit´, inva-
                    e e     e e
     riance, vivacit´, ´quit´, ´quivalence comportementale.
                                            e
  2. Quels sont les liens entre accessibilit´ et invariance ?
                     e                                           e e
  3. Qu’est-ce que l’´quivalence comportementale ? Quel est l’int´rˆt ?
Exercice 71.
  1. Donner la d´finition formelle de la relation |= pour un chemin infini σ.
                e
                        `
  2. Montrer que U suffit a exprimer F et G.
  3. Transformer les formules suivantes (si possible) en formules CTL
     – E(p ∨ Fq)
     – AGFp
  4. Montrer que AFGp = AFAGp.




                                                      50

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:34
posted:5/17/2012
language:French
pages:51
fanzhongqing fanzhongqing http://
About