Les outils

On distingue trois grandes familles d’outils permettant de mod´eliser des syst`emes. Elles se diff´erencient par le mod`ele math´ematique utilis´e : alg´ e-brique, logique, fonctionnel. Dans cette section, nous pr´esenterons des outils repr´esentatifs de chacune de ces cat´egories sans toutefois viser `a l’exhaus-tivit´e. Nous introduirons aussi les outils d’annotation de programmes, plus particuli`erement destin´es `a la v´erification de logiciels.

Le modèle algébrique

Nous regroupons dans le mod`ele alg´ebrique, des outils bas´es sur des th´eories math´ematiques telles que la th´eorie des ensembles ou la th´eorie des cat´egories (le syst`eme Specware [72, 73] par exemple).

Les machines à états abstraits Le mod`ele des machines `a ´etats abstraits ou Abstract State Machine (ASM) [61] est constitu´e d’une notion d’´etat et d’ensemble de r`egles de transitions sur ces ´etats. L’utilisation d’une transi-tion sur un ´etat est conditionn´e par la v´erification de ses conditions de garde et conduit `a un nouvel ´etat. Il est possible dans ce formalisme de sp´ecifier un syst`eme non-d´eterministe par la donn´ee de plusieurs r`egles de transition sur un mˆeme ´etat. Le niveau d’expressivit´e des ASM se compare aux ma-chines de T¨uring [123]. Enfin, l’utilisation de r`egles de transitions permet

`

a ce mod`ele de fournir tr`es facilement, si les ´etats et les transitions sont d´ecidables, une sp´ecification ex´ecutable. De nombreux outils [66], principa-lement acad´emiques, sont issus des ASM. Citons par exemple le langage de programmation ASMGofer [109] bas´e sur les ASM et qui ´etend le langage de programmation fonctionnelle Gofer (similaire `a Haskell).

De mani`ere parall`ele aux ASM, l’outil VDM [24], voit le processus de conception dirig´e par des raffinements successifs de machines abstraites jus-qu’`a aboutir `a une machine proche de l’impl´ementation. Enrichie avec la th´eorie des ensembles de Zermelo-Fraenkel et la logique des pr´edicats du premier ordre, ce formalisme a donn´e lieu aux syst`emes Z [113] ou B [1], uti-lis´es par les industriels pour d’importantes r´ealisations (dont la plus connue concerne la ligne de m´etro METEOR [19]). Dans le syst`eme B, chaque ´etape de raffinement depuis la sp´ecification engendre des obligations de preuve.

Beaucoup de ces obligations sont d´emontr´ees automatiquement mais le reste est `a la charge de l’utilisateur qui dispose d’un assistant de preuve int´egr´e.

Les automates Un mod`ele math´ematique proche des ASM est fourni par les automates o`u l’on retrouve les notions d’´etat et de transitions sur ces ´etats.

Les automates permettent de mod´eliser des syst`emes concurrents, communi-cants, non-d´eterministes et fournissent une sp´ecification ex´ecutable. Contrai-rement aux ASM, les ´etats doivent ˆetre connus `a l’avance et ˆetre en nombre fini. Il s’agit l`a de la principale limitation des automates, et cela p´enalise

´egalement la v´erification puisque les propri´et´es sont prouv´ees par explora-tion de tous les ´etats. Pour ces raisons, ils sont beaucoup plus adapt´es `a la v´erification de protocoles (pour lesquels le nombre d’´etats est limit´e), qu’`a la sp´ecification et `a la v´erification de logiciels.

Le modèle logique

Les mod`eles logiques centrent la mod´elisation sur les notion de pr´ edi-cats, de r`egles et de r´eduction sur ces r`egles. La programmation logique consid`ere les formules logiques comme des programmes et la construction de leur preuve comme l’ex´ecution de ces programmes. Prolog [116] est un des ces outils de programmation logiques. Il s’agit d’un v´erificateur de mod`ele bas´e sur les clauses de Horn pour lar´esolution, automatique, des preuves.

Un approche assez similaire au mod`ele logique est donn´ee par les sys-t`emes de r´e´ecriture tels qu’Elan [25] ou Spike [26]. Les axiomes et r`egles de la logique sont remplac´es par un syst`eme de r`egles de r´e´ecriture du premier ordre.

Ces syst`emes logiques ne sont n´eanmoins pas adapt´es `a la formalisation de logiciels car l’´ecriture de fonctions, mˆeme simples, n’y est pas intuitive.

Le modèle fonctionnel

Le mod`ele de sp´ecification fonctionnel se rapproche des langages de pro-grammation fonctionnels comme Ocaml [82] ou Scheme [53]. Le syst`eme mod´elis´e est exprim´e par une s´erie de d´efinitions de fonctions, ´ eventuelle-ment r´ecursives, sans effets de bord. Les fonctions sont repr´esent´ees dans des formalismes d´eriv´es du λ-calcul [7, 38] et sont consid´er´ees comme des objets du calcul. Le syst`eme de preuves ACL2 [74] utilise leλ-calcul pour langage de sp´ecification combin´e `a une logique calculatoire pour les preuves.

Le λ-calcul peut ˆetre enrichi avec des types pour les variables et fonctions [8] et offre alors un mod`ele de sp´ecification tr`es robuste. Ceλ-calcul typ´e est la base des syst`emes de preuves comme PVS, Isabelle/HOL ouCoq.

PVS [110], d´evelopp´e au SRI, est le plus automatis´e (et aussi le plus utilis´e) des assistants de preuves. Il repose sur une logique d’ordre sup´erieur classique et un calcul des s´equents pour les d´emonstrations. Les sp´ecifications

sont dirig´ees pour les preuves aux d´epends de la qualit´e du code g´en´er´e.

Isabelle/HOL [98] est un assistant de preuves, d´evelopp´e par les univer-sit´es de Cambridge et de Munich, bas´e sur un langage de programmation fonctionnel typ´e et une logique d’ordre sup´erieur. Il offre une assez grande automatisation de la construction de preuves et permet d’extraire des sp´ e-cifications un programme ex´ecutable.

Le langage formel de Coq [89] repose sur le Calcul des Constructions Inductives d´evelopp´e `a l’INRIA par Thierry Coquand, G´erard Huet et Christine Paulin. Il s’agit d’un λ-calcul d’ordre sup´erieur bas´e sur l’iso-morphisme de Curry-Howard [8].Coq permet de manier des types d´ epen-dants, des constructions inductives et co-inductives et offre ainsi une tr`es forte expressivit´e. Un th´eor`eme est d´efini par la donn´ee d’un type et sa preuve par un λ-terme de ce type. Les preuves sont alors objets du calcul lui-mˆeme. Pour aider `a la construction de ce terme de preuve, Coqdispose detactiques qui sont des pas ´el´ementaires de preuves. L’automatisation reste malheureusement assez faible. En revanche, la logique constructive deCoq facilite l’extraction de programmes `a partir des preuves. Enfin, notons que le cœur de Coq, son v´erificateur de type, a ´et´e prouv´e correct de mani`ere formelle dansCoqlui-mˆeme [9].

L’annotation de programmes

Pour en finir avec les outils permettant la sp´ecification et la v´ erifica-tion de syst`emes, mentionnons ceux proposant l’annotation de programmes.

Dans ce cadre, le code source d’un programme est annot´e par un ´enonc´e logique d´ecrivant son comportement : les assertions en entr´ee (les pr´ econdi-tions), les invariants en cours d’ex´ecution et les contraintes en sortie (les postconditions). Il s’agit du mod`ele de la logique de Hoare. Les annota-tions sont traduites avec le programme par l’outil vers un syst`eme de preuve existant ou d´edi´e pour ˆetre v´erifi´ees. Pour le seul langageJavaet avec le lan-gage d’annotation JML [71], plusieurs outils existent, comme le LOOP Tool [86, 124] construit autour de PVS ou d’Isabelle, Jive [93] et Bandera [6, 64]

autour de PVS, JACK [31] autour de l’atelier B, ou encore Krakatoa [88]

autour deCoq. Compaq propose l’outil Esc/Java [106] avec un v´erificateur int´egr´e et un langage d’annotation sp´ecifique.

L’avantage de cette approche est que l’impl´ementation elle-mˆeme du pro-gramme, et non pas une sp´ecification, sert `a la v´erification. D’autre part, le langage d’annotation est suffisamment simple pour ˆetre accessible et utilis´e par des personnes non-expertes en m´ethodes formelles, mˆeme si la v´ erifica-tion pourra requ´erir une exp´erience plus large.