Notes de cours du Master ISIC

Notes de cours du Master ISIC
commentaires et corrections bienvenus
Sarah Zennou
CEA/Saclay, [email protected]
1
Introduction
Ces notes de cours constituent une très brève introduction au domaine de la vérification par
modèle des systèmes concurrents, également dits distribués ou réactifs. Pour une présentation
plus approfondie, l’ouvrage collectif [SBB+ 99] constitue un point d’entrée très didactique.
Cette technique de vérification a été mise au point dans les années 1980, fait l’objet de
recherches actives durant les années 1990 et atteint une matûrité suffisante dans les années
2000 pour être utilisée industriellement dans la vérification de circuits, de protocoles réseau,
etc.
Le model-checking est une méthode formelle qui permet de répondre à la question : est-ce
qu’un système satisfait une certaine propriété ? Répondre à cette question se fait en trois
temps :
Choisir un modèle La première étape consiste à décrire les aspects les plus significatifs du
système par un modèle mathématique. Les principaux modèles sont les modèles asynchrones
(adaptés aux systèmes concurrents), les modèles synchrones (adaptés aux circuits logiques),
les modèles asynchrones avec contraintes temporelles (adaptés aux systèmes dits temps-réel),
etc.
Dans ce cours, nous ne parlerons que des modèles asynchrones dont le modèle est appelé
de façon générique système de transitions.
Spécifier la propriété sur le modèle Une fois le système modélisé, il s’agit de spécifier la
propriété à vérifier par une formule de logique temporelle, c’est-à-dire une logique propositionnelle enrichie d’opérateurs modaux qui permettent de parler de suites d’exécutions du système.
La logique qui nous intéresse ici est LTL (Linear Temporal Logic) qui permet d’exprimer des
propriétés sur les différents états du système. D’autres logiques comme CTL (Branching Temporal Logic) par exemple permettent également d’exprimer des propriétés sur des ensembles
de suites d’exécution du système.
Décider si le modèle satisfait la propriété Ces deux modèles sont finalement donnés
comme entrée d’un outil, le model-checker, qui va décider si oui ou non le modèle satisfait la
formule.
Evidemment, l’algorithme de décision sous-jacent n’existe pas pour tout modèle ni pour
tout type de propriété. Il faut que le problème admette un modèle fini 1 (nombre de processus du système, nombre d’états représenté de chaque processus, domaine de valeur des
variables, etc.) et il faut également se restreindre à certaines classes de propriétés. Pour une
1
certaines techniques de model-checking peuvent nénamoins être appliquées sur des sous-classes de
modèles infinis
représentation du système par système de transitions fini et une spécification de la propriété
par une formule de LTL, un tel algorithme de décision existe (cf [VW86]).
Dans le cas où le modèle ne satisfait pas la formule logique, le model-checker est également
capable de fournir un contre-exemple.
Le model-checker le plus répandu est SPIN [Hol03]. On peut citer également nuSMV
[CCaR99] qui utilise une représentation plus symbolique que SPIN des états du système.
Le reste de ces notes est dédié à la description de ces différentes phases.
2
Modèles
Pour modéliser un système concurrent de n processus, il faut préalablement modéliser chaque
processus par un système de transitions puis composer ces systèmes pour obtenir un produit
synchronisé.
2.1
Systèmes de transitions étiquetées et produit synchonisé
Le système de transitions d’un processus est un ensemble d’états qui représentent ceux du
processus dont un certain état est dit initial et de transitions qui modélisent le passage d’un
état à un autre sous l’effet d’une action.
Definition 1 (Système de transitions étiquetées). Soit Σ un ensemble appelé alphabet
d’actions. Un système de transitions étiquetées sur Σ est un triplet T = (S, s0 , →) tel que S
est un ensemble d’états ; s0 ∈ S est l’état initial ; →⊆ S × Σ × S est la relation de transition
a
où (s, a, s0 ) ∈→ est en général noté s → s0 .
En pratique, T est donné explicitement par une algèbre de processus où les transitions sont
les réductions ; par un processus Promela (comme dans SPIN) où les états sont composés
des points de contrôle des processus, des valeurs des variables et des états des canaux de
communication ; par un réseau de Petri où un état est un marquage du réseau, etc.
Une exécution du système est représentée par une suite de transitions successives depuis
l’état initial2 :
Definition 2 (Trace d’exécution et langage). Une trace d’exécution d’un système de
transitions (S, s0 , →) est une suite σ = s0 s1 . . . où (si , ai , si+1 ) ∈→. L’ensemble des traces
d’exécution est noté tr(T ) et l’ensemble des suites d’étiquettes a0 a1 . . . de traces d’exéuction
est le langage de T , noté L(T ).
La composition des systèmes de transitions est aussi un système de transition dit produit
synchronisé : un état est un tuple composé d’un état de chaque système ; les transitions sont
locales à un processus ou impliquent plusieurs participants. Elles font changer l’état de chaque
participant de façon simultanée, laissant les autres inchangés.
Definition 3 (Produit synchronisé de systèmes de transition). Soient n systèmes de
transitions Ti = (Si , si0 , →i ) étiquetées sur Σi , i = 1, ..n.
Le produit synchonisé T1 × . . . × Tn est le système de transitions T = (S, s0 , →) étiquetées
sur Σ tel que
(1) Σ = Σ1 ∪ . . . ∪ Σn ;
(2) S = S1 × . . . × Sn avec s0 = (s10 , . . . , sn0 ) ;
a
(3) (s1 , . . . , sn ) → (s01 , . . . , s0n ) tel que si = s0i si a 6∈ Σi et (si , a, s0i ) ∈→i sinon.
2
il est parfois fait la distinction entre exécutions finies et infinies. Dans ce contexte, nous considèrerons uniquement des exécutions infinies. Les exécutions finies pouvant être prolongées par
une suite infinie d’actions factices.
Exemple de synchronisation par échanges de messages On veut modéliser un système de n
processus qui interagissent par échanges de messages. Chaque processus n’est supposé lire que
dans un seul canal.
Soient N = {1, . . . , n} l’ensemble des noms des processus, V l’ensemble des valeurs transmissibles entre les processus. Σ l’alphabet des actions est formellement défini par
Σ = {τ } ∪ {i!v | i ∈ N, v ∈ V } ∪ {?v | v ∈ V }
Les actions modélisées par τ , i!v et ?v représentent respectivement un calcul interne, l’envoi
d’une valeur v et la reception d’une valeur v. On note M sg = {i!v | i ∈ N, v ∈ V } l’ensemble
des messages et M(M sg) le multi-ensemble sur M sg.
A chaque processus de nom i est associé un système de transitions étiquetées (Si , s0i , →i )
où Si est un ensemble de couple (pi , Mi ) avec pi un état discret et Mi ∈ M(M sg) le multiensemble des messages que i a reçus entre l’état initial et l’état pi mais n’a pas encore lu.
L’ensemble S = {< (p1, M1 ), . . . , (pn , Mn ) > | (pi , Mi ) ∈ Si }.
A l’état initial, on suppose qu’aucun message n’a été envoyé, c’est-à-dire que l’état initial
est < (p01 , ∅), . . . (p0n , ∅) >.
La relation de transition dite aussi relation de réduction est définie comme suit (le cas (!)
est symétrique pour j < i):
τ
(τ )
(pi ,Mi )→i (p0i ,Mi )
<(p1 ,M1 ),...,(pi ,Mi ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(p0i ,Mi ),...,(pn ,Mn )>
(!)
(pi ,Mi )→i (p0i ,Mi )
<(p1 ,M1 ),...,(pi ,Mi ),...,(pj ,Mj ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(p0i ,Mi ),...,(pj ,Mj ∪{v}),...(pn ,Mn )>
(?)
(pi ,Mi ∪{v})→i (p0i ,Mi )
<(p1 ,M1 ),...(pi ,Mi ∪{v}),...(pn ,Mn )>→<(p1 ,M1 )...(p0i ,Mi )...,(pn ,Mn )>
j!v
?v
Une exécution est une suite infinie d’états, c’est-à-dire que pour les états qui ne peuvent
plus être réduits, on suppose boucler sur cet état.
Ce modèle est asynchone puisque les envois et les réceptions de messages ne sont pas
simultanés.
La définition de la relation de réduction suppose que les canaux de communication entre les
processus ont une taille non bornée et que les messages peuvent être réordonnés de n’importe
quelle façon. Une variante de ce modèle consiste à considérer que les canaux ont une taille
bornée et que les messages sont reçus dans l’ordre de leur émission. Lorsque les canaux ont
une taille nulle, on parle de communication par rendez-vous.
Pour modéliser des canaux bornés, considérons size : N → ω la fonction qui à un nom de
processus associe la taille de son canal de lecture. Chaque état < (p1 , M1 ), . . . , (pn , Mn ) > est
donc tel que chaque Mi est un mot de M sg ≤ω et satisfait la contrainte |Mi | ≤ size(i). L’état
initial est le même que dans le cas non borné.
La relation de réduction devient (τrdv admet une règle symétrique que nous omettons) :
τ
(τ )
(pi ,Mi )→i (p0i ,Mi )
<(p1 ,M1 ),...,(pi ,Mi ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(p0i ,Mi ),...,(pn ,Mn )>
(!)
(pi ,Mi )→i (p0i ,Mi ) |Mj |≤size(j)
<(p1 ,M1 ),...,(pi ,Mi ),...,(pj ,Mj ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(p0i ,Mi ),...,(pj ,Mj .v),...,(pn ,Mn )>
(?)
(pi ,v.Mi )→i (p0i ,Mi )
<(p1 ,M1 ),...,(pi ,Mi ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(p0i ,Mi ),...,(pn ,Mn )>
(τrdv )
(pi ,Mi )→i (p0i ,Mi ) (pj ,Mj )→i (p0j ,Mj ) size(j)=0 i6=j
<(p1 ,M1 ),...,(pi ,Mi ),...,(pn ,Mn )>→<(p1 ,M1 ),...,(pi ,Mi ),...,(pn ,Mn )>
j!v
?v
j!v
?v
Dans un modèle synchrone (par exemple dans un circuit commandé par une horloge globale),
les calculs se font par cycle. A chaque début de cycle, un processus envoie un certain nombre
de messages et reçoit ensuite tous les messages qui lui sont envoyés au cours de ce cycle (pas
d’action interne).
Nous modifions le modèle asynchrone pour prendre en comptes ces contraintes. Les états
des processus sont maintenant uniquement constitués d’un état discret pi et Σ = Σ1 ∪
ldots ∪ Σn un ensemble de couples (m, u) où m est un ensemble de messages envoyés (dans
M({i!v | i ∈ N, v ∈ V })) et u l’ensemble des valeurs de reçues (u ∈ M(V )).
La seule règle de réduction (on suppose les canaux non bornés) est donc
(τsynch )
3
(mi ,ui )
pi −→ p0 i ui ={v |i!v∈m1 ∪...∪mn } pour i=1,..,n
(p1 ,...,pn )→(p1 ,...,pn )
Spécifier les propriétés avec LTL
Une propriété est un sous-ensemble de suites infinies d’états du système de transitions. Ces
propriétés peuvent se diviser en deux grandes catégories : les propriétés de sûreté et celles de
vivacité. Elles s’expriment formellement via une formule logique, comme celles de la logique
LTL, dont l’interprétation est l’ensemble des exécutions qui la satisfont.
Nous rappelons préalablement quelques notations usuelles. Pour un ensemble A, A∗ désigne
l’ensemble des suites finies d’éléments de A et Aω l’ensemble de ses suites infinies. L’ensemble
A≤ω désigne A∗ ∪ Aω . Enfin, pour une suite finie ou infinie w, le ieme élément de w est w(i);
w≤i est le préfixe w(1) ≤ w(i) et w≥i le suffixe w(i)w(i + 1)...
3.1
Propriétés de sûreté et de vivacité
Informellement, une propriété de sûreté exprime qu’une “mauvaise situation” ne va jamais
se produire dans l’exécution. Par exemple, deux processus ne peuvent être au même moment
en section critique, le système n’a pas de deadlock, etc. Une propriété de vivacité, quant à
elle, exprime qu’une “bonne situation” va se produire pendant l’exécution. Par exemple, que
chaque processus va finir par pouvoir entrer en section critique.
Dans ce qui suit, S est un ensemble d’états.
Definition 4 (Propriété de sûreté). L’ensemble P ⊆ S ω est une propriété de sûreté si
pour toute suite infinie d’états σ, σ ∈ P ou il existe un ordinal k tel que pour toute suite
σ 0 ∈ S ω on a σ ≤k σ 0 6∈ P .
Definition 5 (Assertion). Une assertion A est un prédicat unaire sur l’ensemble des états,
i.e. A ⊆ S
Definition 6 (Invariant). Soit A une assertion. L’opérateur unaire Always est défini par
Always A = {σ ∈ S | ∀k σ(k) ∈ A}
On dit que l’assertion A est un invariant du système de transitions T si tr(T ) ⊆ Always A.
L’ensemble Always A est un exemple de propriété de sûreté.
Pour prouver qu’une assertion A est un invariant du système, on prouve que l’état initial
est dans A et on montre que si un état s est dans A alors pour toute transition s → s0 on a
s0 ∈ A.
Informellement, une propriété de vivacité caractérise le fait qu’il est toujours possible de
poursuivre une exécution finie pour que la propriété soit satisfaite.
Definition 7 (Propriété de vivacité). L’ensemble P ⊆ S ω est une propriété de vivacité
si pour toute suite finie d’états σ il existe une suite infinie d’états σ 0 telle que σσ 0 ∈ P .
Definition 8 (Accessibilité). Soit A une assertion. On définit l’opérateur unaire
Eventually A = {σ | ∃k σ(k) ∈ A}
On peut remarquer que si A 6= ∅ alors Eventually A est une propriété de vivacité. On dit
qu’une assertion A va inéluctablement être satisfaite dans T si tr(T ) ⊆ Eventually A.
Pour prouver cette inclusion, on doit trouver (W, <) un ensemble bien fondé et f : S → W
une fonction telle que pour tout état s soit s ∈ A soit il existe une transition s → s0 telle que
f (s0 ) < f (s).
3.2
Structure de Kripke et logique LTL
La logique LTL s’evalue sur les états des exécutions du système de transitions. Pour cela,
le système de transitions est enrichi d’une fonction L qui à chaque état associe la liste des
propositions qu’il sastisfait. Ce modèle enrichi est appelé structure de Kripke.
Definition 9 (Structure de Kripke étiquetée). Soit Σ un alphabet et P un ensemble de
propositions. Une structure de Kripke étiquetée sur Σ est un quadruplet K = (S, s0 , →, L)
où (S, s0 , →) est un système de transitions étiquetées sur Σ et L : S → 2P est la fonction qui
à un état associe les propositions qui sont vraies à cet état.
L’exécution d’une structure de Kripke est l’exécution du système de transitions sousjacent.
Definition 10 (Syntaxe de LTL). Une formule p de LTL est définie par
p ::= a | p ∧ p | ¬p | X p | p U p
où a est une proposition de P , X p est lu next p et p U q est lu p until q.
Definition 11 (Sémantique de LTL). A chaque formule p est associée une propriété JpK ⊆
S ω telle que
JaK
= {σ | a ∈ L(σ(0))}
Jp1 ∧ p2 K = Jp1 K ∩ Jp2 K
J¬pK
= S ω \JpK
JX pK
= {σ | σ ≥1 ∈ JpK}
Jp U qK = {σ | ∃j ∈ ω.σ ≥j ∈ Jq K et ∀k < j σ ≥k ∈ JpK}
A partir de ces opérateurs, de nouveaux peuvent être définis :
F p = true U p (finally/eventually p)
Gp = ¬F ¬p (always/globally p)
Leur sémantique:
JF pK = {σ | ∃j ∈ ωσ ≥j ∈ JpK}
JGpK = {σ | ∀j ∈ ωσ ≥j ∈ JpK}
F permet d’exprimer des propriétés d’accessibilité et G des invariants, cf respectivement
les définitions 8 et 6.
4
Le model-checking pour LTL
Soit φ la formule LTL que l’on souhaite vérifier sur la structure de Kripke K. Vérifier si
K satisfait φ se réduit au problème de savoir si tr(K) ⊆ JφK ou de façon équivalente si
tr(K) ∩ J¬φK = ∅. Si la réponse est négative, toute trace de cette intersection est un contreexemple.
Pour tester la vacuité de cette intersection, on construit un système de transitions A¬φ
appelé automate de Büchi dont l’ensemble des exécutions tr(A¬φ ) est exactement J¬φK. Savoir
si T satisfait φ est donc équivalent au problème de savoir si tr(K) ∩ tr(A¬φ ) = ∅, ce qui est
équivalent au problème de savoir si
?
tr(K × A¬φ ) = ∅
Deux questions se posent donc : comment traduire φ en un automate de Büchi et comment
décider la vacuité de l’ensemble des traces d’un système de transitions.
4.1
Automates de Büchi
Definition 12 (Automate de Büchi). Un automate M fini sur un alphabet Σ est un
quadruplet (Q, q0 , ∆, F ) où (Q, q0 , ∆) est un système de transitions sur Σ avec Q fini et
F ⊆ Q est l’ensemble des états d’acceptation.
Une trace d’exécution σ du sytème de transitions est dite acceptée si elle admet un nombre
infini d’états dans F : σ(i) ∈ F :
∃q ∈ F ]{i |σ(i) = q} = ω
Un automate de Büchi est un automate fini M avec une condition d’acceptance comme
décrite ci-dessus.
L’automate de Büchi qui reconnaı̂t une formule LTL φ dont l’ensemble des propositions
est noté P est tel que :
– l’alphabet est l’ensemble des parties de P , c’est-à-dire que chaque transition est étiqueté
par l’ensemble des propositions de P qui doivent être satisfaites pour qu’une transition
se fasse
– ses états sont des ensembles de sous-formules de φ.
– sa taille de cet automate est exponentielle dans la taille de la formule, i.e. en O(2|φ| ).
La construction exacte de cet automate suit un algorithme assez délicat que nous ne
présenterons pas ici. Le lecteur intéressé pourra se référer à [Var96]. Nous donnons néanmoins
quelques exemples de construction pour des formules simples où les états d’acceptation sont
représentés par deux cercles concentriques.
p:
p
q0
q1
Xp :
q0
p
q1
q2
p
p
Gp :
q0
Fp :
q0
p
q1
pU q :
q0
q
q1
Le produit synchronisé entre la structure de Kripke et l’automate de Büchi est légèrement
différent que celui donné à la définition 3. Dans ce cas, chaque transition s → s0 de la structure
p1 ,...,pk
doit être synchronisée avec chaque transition q → q 0 de l’automate mais n’est dans le
produit synchronisé que si p1 , . . . pk ∈ L(s), pour modéliser l’hypothèse que le système est
dans un état qui satisfait la contrainte de la transition de l’automate.
Definition 13 (Automate produit). Soient P un ensemble de propositions ; K = (S, s0 , →
, L) une structure de Kripke sur Σ et A = (Q, q0 , ∆, F ) un automate de Büchi sur l’alphabet
P(P ).
L’automate produit K × φ est l’automate de Büchi A = (Q0 , q00 , ∆0 , L0 , F 0 ) tel que Q0 =
S × Q; q0 = (s0 , q0 ) ; F 0 = {(s, q) | q ∈ F }; ((s, q), (a, u), (s0 , q 0 )) ∈ ∆0 ssi (s, t, s0 ) ∈→ et
(q1 , u, q2 ) ∈ ∆ et u ⊆ L(s).
Pour illustrer cette définition, considérons l’exemple ci-dessous (extrait du livre [SBB+ 99])
de structure de Kripke (à gauche) et la formule que nous souhaitons vérifier (dont l’automate
de Büchi de la négation est à droite) est G(p1 → X F p2 ). La formule φ énonce que tout
occurrence de p sera suivie d’une occurrence de p2 . Sa négation signifie donc qu’il existe une
occurrence de p1 après laquelle on ne rencontrera plus jamais p2 .
¬p1
¬p2
t1
¬p1
¬p2
p1 , p2
p1 , ¬p2
u0 : ¬p , p
1
2
¬p1 , ¬p2
t4
p1
p2
t5
q0
t3
t2
u2 :
p1 , ¬p2
¬p1 , ¬p2
q1
u1 :
p1 , ¬p2
p1 , p2
A¬φ avec φ : G(p1 → X F p2 )
¬p1
¬p2
Le produit synchonisé est alors donné à la figure ci-dessous où seules les transitions possibles sont représentées :
(t4 , u1 )
¬p1
¬p2
t1
¬p1
¬p2
t4
t3
t2
¬p1
¬p2
4.2
p1
p2
t5
¬p1
¬p2
(t1 , u2 )
(t3 , u2 )
¬p1
¬p2
p1
p2
(t3 , u2 )
(t2 , u2 )
¬p1
¬p2
Algorithmes de décision
Rappelons que le problème de model-checking se réduit à la question de savoir si le produit
synchonisé K × A¬φ admet ou non une trace acceptée. Une hypothèse importante est que K
doit être fini en terme de nombre d’états et de transitions.
Si on considère ce produit synchronisé comme un graphe dont les noeuds sont les états et
les arcs sont ses transitions, cela revient à savoir s’il existe un cycle dans ce graphe qui soit
accessible depuis l’état initial et qui contient un état acceptant.
Deux algorithmes peuvent être utilisés :
– uitliser l’algorithme de Tarjan [Edu01] pour calculer l’ensemble des composantes fortement connexes accessibles depuis l’état initial. On cherche ensuite parmi ces composantes
fortement connexes si l’une d’elle contient un état acceptant. Cette méthode est peu
utilisée car elle est incompatible avec certaines techniques d’optimisation ;
– utiliser l’algorithme Nested DFS (inmplémenté dans SPIN par exemple [HPY]). Il s’agit
d’un parcours en profondeur du graphe depuis l’état initial pour trouver dans un premier
temps tous les etats accessible. Si aucun état acceptant n’est trouvé à cette étape, c’est
que la propriété est satisfaite.
Sinon, un parcours en profondeur du graphe depuis chaque état acceptant s accessible est
fait de façon à détecter s’il sont accessible depuis eux-mêmes c’est-à-dire dans une boucle.
Ces algorithmes terminent puisque par hypothèse le produit synchronisé est fini.
5
Le phénomène d’explosion combinatoire
Par construction, la taille du produit synchronisé est exponentielle dans le nombre de ses
composants, ce qui limite en pratique l’utilisation du model-checking comme technique de
vérification : le produit à construire est souvent trop grand pour pouvoir être stocké.
Pour pallier à cet inconvénient, des techniques de construction et d’exploration partielle
du produit synchronisé ont été mises au point pour combattre ce phénomène d’explosion
combinatoire : Le model-checking “à la volée” construit uniquement les parties utiles du
système tandis que les techniques d’ordre partiel [GW92,Pel93,NHZL01] exploitent la nature
concurrente des systèmes pour n’explorer que certaines exécutions.
Parallellement, ont été développées des méthodes de model-checking symbolique pour
représenter des ensembles d’états plutôt que chaque les états explicitement ; les transitions
sont alors réexprimées sur ces états symboliques. Les diagrammes de décision binaire sont un
exemple d’une telle technique.
5.1
les diagrammes de décision binaires
Les BDD (Binary Decision Diagram) sont une structure de données qui permet de représenter
de façon concise des fonctions booléennes. L’utilisation de cette structure pour représenter
des automates est duûe à Bryant [Bry92]. Ce codage est particulièrement efficace pour des
circuits logiques même de très grande taille (plus de 1020 états). L’efficacité du codage dépend
beaucoup de la régularité de la fonction à coder.
Les BDDs offrent plusieurs avantages :
– des opérations de base efficaces et peu coûteuses (quadratiques dans le nombre de variables
de la formule) ;
– une implantation simple d’une structure de données pour les représenter ainsi que des
algorithmes pour les manipuler ;
– l’existence d’une forme canonique compacte pour les comparer aisément.
Construction d’un BDD pour la fonction f (x1 , x2 , x3 ) = x1 =⇒ (x2 ∨ x3 ) Dans un premier
temps, on se fixe un ordre x1 < x2 < x3 sur les variables et on construit l’arbre de choix qui
a 2n+1 − 1 noeuds où n = 3 est le nombre de variables de la fonction à coder :
x1
T
F
x2
x2
T
F
x3
T
x3
F
x3
x3
T
F
T
F
T
F
T
F
T
T
T
F
T
T
T
T
Puis, on réduit ensuite cet arbre pour obtenir le BDD par application jusquà saturation
des règles suivantes :
– regrouper les sous-arbres identiques (l’arbre devient un graphe acyclique dirigé)
– supprimer les noeuds internes correspondant à des faux choix, ie les fils gauche et droit
sont identiques
Lorsque plus aucune réduction n’est possible, le BDD obtenu est appelé ROBDD (Reduced
Ordered BDD) :
x1
T
F
x2
F
T
x3
T
F
F
T
Proposition 14. Pour un ordre fixé des variables d’une fonction, le ROBDD est unique.
L’ordre des variables a grande influence sur la taille du ROBDD. Des heuristiques ont été
développées pour tenter d’optimiser ces choix. On peut par exemple priviliégier les variables
qui n’apparaissent que sous une forme positive ou négative, etc.
Opérations sur les BDD L’égalité de deux BDD se fait par comparaison deux à deux des
noeuds depuis la racine jusqu’aux feuilles. Pour complémenter un BDD, il suffit d’echanger
le rôle des feuilles T et F. L’intersection de deux BDD B1 et B2 est un BDD B = B1 × B2
où un noeud interne (n1 , n2 ) représentant n1 ∧ n2 est tel que n1 est un noeud de B1 et n2 est
un noeud de B2 . La taille est bornée par |B1 × B2 | ≤ |B1 | × |B2 |
L’union suit le même principe que l’intersection avec (n1 , n2 ) qui représente n1 ∨ n2 .
Représentation d’un système de transitions fini par un BDD Soit (S, s0 , →) un système de
transitions fini. Chaque état de S est codé par un vecteur de bits de taille log|S|. Chaque
transition s → s0 est codée par la concaténation du codage de s et de celui de s0 . Ce codage
est utilisé dans l’outil SMV qui utilise la logique CTL.
6
Compléments
D’autres modèles et méthodes ont été développés :
– des représentations prenant mieux en compte la nature distribuée d’un système pour
éviter de costruire le produit synchronisé : les Message Sequence Charts
– des modèles prenant en compte le temps ainsi que des logiques adequats: les automates
temporisés [AD94] sont les modèles les plus répandus. C’est celui implanté dans le modelchecker UPPAAL [BDL04] par exemple
– des techniques de model-checking pour des systèmes infinis : pushdown systems et regular
model-checking
– des modèles probabilistes
– etc.
References
[AD94]
R. Alur and D. Dill, A theory of timed automata, Theoretical Computer Science 126 (1994),
no. 2, 183–235.
[BDL04] G. Behrmann, A. David, and K. Larsen, A tutorial on uppaal, SFM-RT, Lecture Notes in
Computer Science, no. 3185, Springer–Verlag, 2004, pp. 200–236.
[Bry92] Randal E. Bryant, Symbolic Boolean manipulation with ordered binary-decision diagrams,
ACM Computing Surveys 24 (1992), no. 3, 293–318.
[CCaR99] A. Cimatti, E. Clarke, and F. Giunchiglia and. Roveri, Nusmv: a new symbolic model
verifier, 1999, pp. 495–499.
[Edu01] McGraw-Hill Higher Education (ed.), Introduction to algorithms, 2001.
[GW92] P. Godefroid and P. Wolper, Using partial orders for the efficient verification of deadlock
freedom and safety properties, CAV ’91: Proceedings of the 3rd International Workshop on
Computer Aided Verification, Springer-Verlag, 1992, pp. 332–342.
[Hol03] G. Holzmann, The spin model-checker, Addison-Wesley, 2003.
[HPY]
G. Holzmann, D. Peled, and M. Yannakakis, On nested depth first search, Second SPIN
Workshop (American Mathematical Society, ed.), Lecture Notes Computer Science, pp. 23–
32.
[NHZL01] P. Niebert, M. Huhn, S. Zennou, and D. Lugiez, Local first search - a new paradigm for
partial order reductions, CONCUR ’01: Proceedings of the 12th International Conference
on Concurrency Theory, Springer-Verlag, 2001, pp. 396–410.
[Pel93]
D. Peled, All from one, one for all: On model checking using representatives, Computer
Aided Verification: Proc. of the 5th International Conference CAV’93, Springer, 1993,
pp. 409–423.
[SBB+ 99] P. Schnoebelen, B. Bérard, M. Bidoit, F. Laroussinie, and A. Petit, Vérification de logiciels
: techniques et outils du model-checking, Vuibert, 1999.
[Var96] M. Vardi, An automata-theoretic approach to linear temporal logic, Banff Higher Order
Workshop, 1996, pp. 238–266.
[VW86] M. Vardi and P. Wolper, An automata-theoretic approach to automatic program verification,
1986, pp. 332–344.