IGL502/IGL752 – Techniques de

vérification et de validation

notes de cours

Michael Blondin

30 novembre 2023
 Avant-propos

La rédaction de ce document a été entamée à la session d’hiver 2019 comme

notes complémentaires du cours « IGL502/IGL752 – Techniques de vérification
et de validation » de l’Université de Sherbrooke, dans le but d’offrir des notes
gratuites, libres, en français, et taillées sur mesure pour chaque cohorte. En
particulier, la structure et le contenu se basent sur le plan cadre établi par le
Département d’informatique. Ainsi, ce document évoluera au gré des sessions.
Ces notes sont une synthèse et non un livre: certains passages peuvent être
« expéditifs » par rapport aux explications, exemples et discussions qui sur-
gissent en classe ou dans les capsules vidéos. Ainsi, ces notes devraient d’abord
être considérées comme un complément, par ex. pour réduire, voire éliminer,
la prise de notes; comme références pour réaliser les devoirs; comme matériel
de révision, etc.
Les six premiers chapitres s’inspirent fortement de présentations classiques
sur LTL et CTL, en grande partie de [BK08]. Le chapitre 7 suit la présentation
de [And98]. Le chapitre 8 puise sa théorie dans [BEM97, EHRS00]. Le cha-
pitre 10 s’inspire d’un diaporama de Mickael Randour (Université de Mons)
basé sur [BK08]. De façon générale, les neufs premiers chapitres sont influen-
cés par ma participation à l’enseignement des cours Model Checking et Petri nets
offerts par le groupe de Javier Esparza (Université technique de Munich).
Si vous trouvez des coquilles ou des erreurs dans le document, ou si vous
avez des suggestions, n’hésitez pas à me les indiquer sur GitHub  (en ajoutant
un « issue ») ou par courriel à [Link]@[Link]. Je remercie
notamment Mathieu Fournier (A21), François Ladouceur (A20), Maxime Rou-
thier (A20) pour l’identification de nombreuses coquilles.

cb
Cette œuvre est mise à disposition selon les termes de la licence
Creative Commons Attribution 4.0 International.
 Légende

Observation.

Les passages compris dans une région comme celle-ci correspondent à

des observations jugées intéressantes mais qui dérogent légèrement du
contenu principal.

Remarque.

Les passages compris dans une région comme celle-ci correspondent à

des remarques jugées intéressantes mais qui dérogent légèrement du
contenu principal.

Les passages compris dans une région colorée sans bordure comme celle-ci
correspondent à du contenu qui ne sera pas nécessairement présenté en classe,
mais qui peut aider à une compréhension plus approfondie.

Les exercices marqués par « ⋆ » sont considérés plus avancés que les autres.
Les exercices marqués par « ⋆⋆ » sont difficiles ou dépassent le cadre du cours.

L’icône «  » dans la marge fournit un lien vers des fichiers associés au passage.
L’icône « ? » dans la marge fournit un lien vers la solution de l’exercice

iii
 Table des matières

1 Systèmes de transition 1
1.1 Prédécesseurs et successeurs . . . . . . . . . . . . . . . . . . . . 3
1.2 Chemins et exécutions . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Structures de Kripke . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Explosion combinatoire . . . . . . . . . . . . . . . . . . . . . . . 6
1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Logique temporelle linéaire (LTL) 9

2.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Sucre syntaxique . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Équivalences . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.1 Distributivité . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.2 Dualité . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.3 Idempotence . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.4 Absorption . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5 Propriétés d’un système . . . . . . . . . . . . . . . . . . . . . . 14
2.6 Types de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6.1 Invariants . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6.2 Sûreté . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.6.3 Vivacité . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.7 Équité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.8 Spin et Promela . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.9 Étude de cas: protocole de Needham-Schroeder . . . . . . . . . 22
2.10 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3 Langages ω-réguliers 27
3.1 Expressions ω-régulières . . . . . . . . . . . . . . . . . . . . . . 27
3.1.1 Expressions régulières . . . . . . . . . . . . . . . . . . . 27
3.1.2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

iv
TABLE DES MATIÈRES v

3.1.3 Sémantique . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2 Automates de Büchi . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.1 Langage d’un automate . . . . . . . . . . . . . . . . . . 30
3.2.2 Déterminisme et expressivité . . . . . . . . . . . . . . . 32
3.3 Intersection d’automates de Büchi . . . . . . . . . . . . . . . . . 32
3.3.1 Construction à partir d’un exemple . . . . . . . . . . . . 33
3.3.2 Construction générale . . . . . . . . . . . . . . . . . . . 35
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 Vérification algorithmique de formules LTL 39

4.1 LTL vers automates de Büchi . . . . . . . . . . . . . . . . . . . . 39
4.2 Structures de Kripke vers automates de Büchi . . . . . . . . . . 41
4.3 Vérification d’une spécification . . . . . . . . . . . . . . . . . . . 42
4.3.1 Lassos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.3.2 Détection de lasso par parcours en profondeur . . . . . . 44
4.3.3 Détection de lasso par les composantes fortement connexes 47
4.4 Sommaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

5 Logique temporelle arborescente (CTL) 54

5.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.2 Sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.3 Propriétés d’un système . . . . . . . . . . . . . . . . . . . . . . 57
5.4 Équivalences . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.4.1 Distributivité . . . . . . . . . . . . . . . . . . . . . . . . 58
5.4.2 Dualité . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5.4.3 Idempotence . . . . . . . . . . . . . . . . . . . . . . . . 59
5.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6 Vérification algorithmique de formules CTL 61

6.1 Forme normale existentielle . . . . . . . . . . . . . . . . . . . . 62
6.2 Calcul des états . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
6.2.1 Logique propositionnelle et opérateur temporel X . . . . 63
6.2.2 Opérateur temporel G . . . . . . . . . . . . . . . . . . . 63
6.2.3 Opérateur temporel U . . . . . . . . . . . . . . . . . . . 65
6.2.4 Algorithme complet . . . . . . . . . . . . . . . . . . . . 67
6.2.5 Optimisations . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2.6 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

7 Vérification symbolique: diagrammes de décision binaire 74

7.1 Représentation de BDD . . . . . . . . . . . . . . . . . . . . . . . 77
7.2 Construction de BDD . . . . . . . . . . . . . . . . . . . . . . . . 78
7.3 Manipulation de BDD . . . . . . . . . . . . . . . . . . . . . . . . 78
7.3.1 Opérations logiques binaires . . . . . . . . . . . . . . . . 78
7.3.2 Restriction et quantification existentielle . . . . . . . . . 80
TABLE DES MATIÈRES vi

7.4 Vérification CTL à l’aide de BDD . . . . . . . . . . . . . . . . . . 80

7.5 Complexité calculatoire . . . . . . . . . . . . . . . . . . . . . . 83
7.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

8 Systèmes à pile 85
8.1 Systèmes à pile . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
8.2 Calcul des prédécesseurs . . . . . . . . . . . . . . . . . . . . . . 87
8.3 Vérification à l’aide de système à pile . . . . . . . . . . . . . . . 91
8.4 Autre exemple: analyse de code intermédiaire . . . . . . . . . . 92
8.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

9 Systèmes à compteurs 97
9.1 Réseaux de Petri . . . . . . . . . . . . . . . . . . . . . . . . . . 97
9.2 Modélisation de systèmes concurrents . . . . . . . . . . . . . . 99
9.3 Vérification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
9.3.1 Graphes de couverture . . . . . . . . . . . . . . . . . . . 101
9.3.2 Algorithme arrière . . . . . . . . . . . . . . . . . . . . . 103
9.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

10 Systèmes probabilistes 112

10.1 Chaînes de Markov . . . . . . . . . . . . . . . . . . . . . . . . . 112
10.2 Probabilités d’accessibilité . . . . . . . . . . . . . . . . . . . . . 115
10.3 Probabilités de comportements limites . . . . . . . . . . . . . . 117
10.4 CTL probabiliste . . . . . . . . . . . . . . . . . . . . . . . . . . 118
10.4.1 Syntaxe et sémantique . . . . . . . . . . . . . . . . . . . 118
10.4.2 Vérification . . . . . . . . . . . . . . . . . . . . . . . . . 119
10.5 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
10.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

Solutions des exercices 126

Fiches récapitulatives 166

Bibliographie 171

Index 174
 1
Systèmes de transition

Notre but est d’automatiser la vérification de systèmes, c.-à-d. de vérifier ri-

goureusement qu’un système donné satisfait une certaine spécification. Afin
d’accomplir cette tâche, nous devons modéliser les systèmes formellement. Les
« systèmes de transition » permettent une telle modélisation. Il s’agit de graphes
dirigés dont les sommets représentent symboliquement l’état interne d’un sys-
tème, et dont les arcs indiquent la façon dont les états peuvent évoluer. Les
états dans lesquels un tel système peut débuter sont dits « initiaux », par ex. la
première ligne de code d’un programme avec ses variables initialisées.
Formellement, un système de transition est un triplet T = (S, − →, I) tel que
— S est un ensemble, dont les éléments se nomment états,
— − → ⊆ S × S est la relation de transition,
— I ⊆ S est l’ensemble des états initiaux.
Nous disons qu’un tel système T est fini si son ensemble d’états S est fini.
Voyons quelques exemples.

Exemple.

Considérons le système de transition fini T1 suivant:

S := {s0 , s1 , s2 },
I := {s0 },
−
→ := {(s0 , s0 ), (s0 , s1 ), (s0 , s2 ), (s1 , s2 ), (s2 , s2 )}.
Le système T1 peut être représenté graphiquement ainsi:

s0 s1 s2

1
CHAPITRE 1. SYSTÈMES DE TRANSITION 2

Exemple.

Considérons les deux processus suivants qui sont exécutés de façon concur-
rente et qui partagent une variable booléenne tour ∈ {0, 1}:
P0 (): P1 ():
boucler: boucler:
a: attendre(tour == 0) a: attendre(tour == 1)
b: tour = 1 b: tour = 0

Le système de transition T2 naturellement associé à ce système est illustré

ci-dessous. Ici, un état de la forme (x, y, z) indique que P0 est à la ligne x,
que P1 est à la ligne y, et que tour = z. Les composantes et les transitions
associées à P0 (resp. P1 ) apparaissent en cyan (resp. magenta). Les états
non accessibles à partir des états initiaux sont plus pâles.

a, b, 0 a, a, 0 b, b, 1

b, b, 0 b, a, 0 b, a, 1

a, a, 1 a, b, 1

Remarque.

La plupart du temps, nous allons omettre les états d’un système de tran-
sition qui ne sont pas accessibles à partir d’un état initial; comme ceux
plus pâles à l’exemple précédent. Toutefois, notons que déterminer si un
état est accessible ou non possède un coût algorithmique.
CHAPITRE 1. SYSTÈMES DE TRANSITION 3

Exemple.

Considérons le programme partiel suivant constitué de trois fonctions,

dont le point d’entrée est la fonction main, et où « ? » dénote une valeur
booléenne choisie de façon non déterministe:
main(): foo(): bar():
m0 : foo() f0 : si ?: bar() b0 : foo()
m1 : return f1 : return b1 : si ?: return
b2 : bar()

Le système de transition T3 associé à la pile d’appel de ce programme,

avec main comme point d’entrée, est illustré ci-dessous.

f0
b0 b1
f0 f1 f1
m0 m1 m1 m1

f1
m1 m1

Ce système est infini puisque, par exemple, cette exécution infinie génère
une pile de profondeur arbitrairement grande:

main() foo() bar() foo() bar() · · · .

1.1 Prédécesseurs et successeurs

Soit T = (S, −→, I) un système de transition. Nous écrivons s −→ t pour dénoter
(s, t) ∈ −
→. Si s −
→ t, nous disons que s est un prédécesseur immédiat de t, et que
t est un successeur immédiat de s. L’ensemble des successeurs et prédécesseurs
immédiats d’un état s ∈ S sont respectivement dénotés:

Post(s) := {t ∈ S : s −
→ t},
Pre(s) := {t ∈ S : t −
→ s}.

Nous disons qu’un état s ∈ S est terminal si Post(s) = ∅.

CHAPITRE 1. SYSTÈMES DE TRANSITION 4

∗
Nous écrivons s −→ t lorsque l’état t est accessible à partir de l’état s en zéro,
∗
une ou plusieurs transitions. En termes plus techniques, − → est la fermeture
∗
réflexive et transitive de −
→. En particulier, notons que s − → s pour tout s ∈ S.
∗
Si s −
→ t, nous disons que s est un prédécesseur de t, et que t est un suc-
cesseur de s. L’ensemble des successeurs et prédécesseurs d’un état s ∈ S sont
respectivement dénotés:
∗
Post∗ (s) := {t ∈ S : s −
→ t},
∗
Pre∗ (s) := {t ∈ S : t −
→ s}.

En particulier, notons que s ∈ Post∗ (s) et s ∈ Pre∗ (s) pour tout s ∈ S.

Exemple.

Reconsidérons le système de transition T1 . Nous avons:

Pre(s0 ) = {s0 } Pre(s1 ) = {s0 } Pre(s2 ) = {s0 , s1 , s2 },

Post(s0 ) = {s0 , s1 , s2 } Post(s1 ) = {s2 } Post(s2 ) = {s2 },
∗ ∗
Pre (s0 ) = {s0 } Pre (s1 ) = {s0 , s1 } Pre∗ (s2 ) = {s0 , s1 , s2 },
∗ ∗
Post (s0 ) = {s0 , s1 , s2 } Post (s1 ) = {s1 , s2 } Post∗ (s2 ) = {s2 }.

Remarque.

Post∗ (s) est aussi connu sous le nom d’ensemble d’accessibilité de s.

1.2 Chemins et exécutions

Soit T = (S, − →, I) un système de transition. Un chemin fini est une séquence
finie d’états s0 s1 · · · sn telle que s0 −
→ s1 −
→ ··· −
→ sn . Similairement, un chemin
infini est une séquence infinie d’états s0 s1 · · · telle que s0 − → s1 −→ · · · . Un
chemin est un chemin fini ou infini. Nous disons qu’un chemin est initial si s0 ∈
I; et qu’il est maximal s’il est infini, ou s’il est fini et que son dernier état sn
est terminal, c.-à-d. si Post(sn ) = ∅. Une exécution de T est un chemin initial
et maximal. Autrement dit, une exécution est une séquence qui débute dans un
état initial et qui ne peut pas être étendue.

Exemple.

Reconsidérons le système de transition T1 du tout premier exemple. La

séquence ρ := s0 s0 s1 s2 est un chemin fini de T1 et la séquence ρ′ :=
s0 s1 s2 s2 s2 · · · est un chemin infini de T1 .
Le chemin ρ′ est une exécution puisqu’il est initial et infini. Le chemin
CHAPITRE 1. SYSTÈMES DE TRANSITION 5

ρ n’est pas initial puisque s1 n’est pas initial. De plus, ρ n’est pas maximal
puisque Post(s2 ) ̸= ∅. En fait, T1 ne possède aucun état terminal.

1.3 Structures de Kripke

Les systèmes de transition permettent de décrire les comportements d’un sys-
tème. Nous étendons ce formalisme aux « structures de Kripke » qui ajoutent de
l’information afin de raisonner sur des propriétés de ces comportements.
Une structure de Kripke est un quintuplet T = (S, −
→, I, AP, L) tel que
— (S, −
→, I) est un système de transition,
— AP est un ensemble, dont les éléments sont appelés propositions atomiques,
— L : S → 2AP est une fonction dite d’étiquetage.
Rappelons que 2AP dénote l’ensemble des sous-ensembles de AP, aussi connu
sous le nom d’ensemble des parties de AP, et parfois dénoté P(AP).
Les propositions atomiques d’une structure de Kripke correspondent à des
propriétés d’un système jugées intéressantes pour son analyse. La fonction L
associe à chaque état un sous-ensemble de AP. Les propriétés décrites par le
sous-ensemble L(s) sont considérées satisfaites dans l’état s, et celles de AP \
L(s) sont considérés non satisfaites dans l’état s. Par exemple, si AP = {p, q, r}
et L(s) = {p, q}, alors p et q sont vraies en s, et r est fausse en s.

Exemple.

Considérons la structure de Kripke T4 suivante, où AP = {d, r}:

{d} {r} ∅ ∅ {d, r}

s0 s1 s2 s3 s4

Supposons que les propositions atomiques d et r correspondent respec-

tivement à l’occurrence d’une demande et d’une réponse dans le contexte
d’une communication entre deux machines. On peut se demander si:
1. dans chaque exécution, toute demande est éventuellement suivie
d’une réponse?
2. il existe une exécution où une demande a lieu au même moment
qu’une réponse?
3. chaque exécution possède un nombre infini de demandes?
CHAPITRE 1. SYSTÈMES DE TRANSITION 6

La première propriété est ambiguë car il n’est pas clair si « suivie d’une
réponse » permet l’occurrence d’une réponse en même temps qu’une de-
mande.
Si cela est permis, alors la propriété est satisfaite par T4 puisque lors-
qu’une demande est faite en s0 , elle est forcément suivie d’une réponse
en s1 , et lorsqu’une demande est faite en s4 , elle est suivie au même mo-
ment d’une réponse. Si cela n’est pas permis, alors la propriété n’est pas
satisfaite puisque la deuxième demande de l’exécution suivante n’est pas
suivie d’une demande:

ρ := s0 s1 s4 s3 s2 s3 s2 · · · .

La seconde propriété est satisfaite, par exemple, par ρ. La troisième

propriété n’est pas satisfaite puisque ρ ne possède que deux demandes.

Dans les chapitres subséquents, nous verrons comment de telles propriétés

peuvent être formalisées en logique temporelle, plutôt qu’en français, afin d’évi-
ter toute ambiguïté et d’automatiser leur vérification.

1.4 Explosion combinatoire

En général, la taille d’une structure de Kripke croît rapidement en fonction du
système concret sous-jacent. Par exemple, un système de transition modélisant
un programme avec n variables booléennes peut posséder jusqu’à 2n états. Ce
phénomème est connu sous le nom d’explosion combinatoire, ou « state space
explosion » en anglais. Il existe plusieurs mesures pour contrer cette explosion.
Tout d’abord, les outils de vérification génèrent normalement les systèmes de
transitions à la volée plutôt qu’exhaustivement. De plus, d’autres techniques
peuvent être utilisées lors de la modélisation ou de la vérification:
— abstraction: ignorer les données jugées non importantes pour réduire la
taille du système de transition (de façon manuelle ou automatique);
— vérification symbolique: utiliser des structures de données pouvant repré-
senter plusieurs états symboliquement et manipuler directement ces struc-
tures;
— approximations: calculer un sous-ensemble ou sur-ensemble des états ac-
cessibles de façon symbolique afin de démontrer la présence ou l’absence
d’erreurs.
Nous verrons certaines de ces approches plus tard.
CHAPITRE 1. SYSTÈMES DE TRANSITION 7

1.5 Exercices
1.1) Considérons la structure de Kripke T suivante: ?
{p, q} {p} ∅ ∅ {p, q}
s0 s1 s2 s3 s4

s5 s6

{q} {p}

a) Décrivez Post(s), Pre(s), Post∗ (s) et Pre∗ (s) pour chaque état s.
b) Donnez la plus courte exécution de T .
c) Donnez une exécution de T qui satisfait toujours p.
d) Donnez une exécution de T qui satisfait p infiniment souvent et qui
ne satisfait pas q infiniment souvent.

1.2) Un système de transition étiqueté est un système de transition dont chaque ?

transition possède une étiquette tirée d’un ensemble fini E.
a) Modélisez une variable booléenne x par un système de transition
étiqueté avec E := {x ← vrai, x ← faux, x = vrai, x = faux}.
b) Modélisez le programme ci-dessous par un système de transition éti-
queté avec E := {x ← vrai, x = vrai, x = faux, crit, noncrit}.

boucler
1 tant que x ̸= faux
rien faire
2 /* section critique */
3 x ← vrai
4 /* section non critique */

c) Soient T1 = (S1 , −
→1 , I1 , E1 ) et T2 = (S2 , −
→2 , I2 , E2 ) des systèmes de
transition étiquetés. Le produit asynchrone T1 ∥ T2 est le système de
transition étiqueté obtenu en composant T1 et T2 avec une synchroni-
sation faite uniquement sur leurs étiquettes communes. Construisez
le produit asynchrone des deux systèmes modélisés précédemment.
Plus formellement, T1 ∥ T2 := (S, −
→, I, E) où S := S1 × S2 , I :=
I1 × I2 , E := E1 ∪ E2 , et
→ (s′1 , s′2 ) ⇐⇒ (e ∈ E1 ∩ E2 ∧ s1 −
→ s′1 ∧ s2 −
→ s′2 ) ∨
e déf e e
(s1 , s2 ) −
→ s′1 ∧ s2 = s′2 ) ∨
e
(e ∈ E1 ∩ E2 ∧ s1 −
(e ∈ E1 ∩ E2 ∧ s1 = s′1 ∧ s2 −
→ s′2 ).
e
CHAPITRE 1. SYSTÈMES DE TRANSITION 8

d) En général, quels sont les comportements de T1 ∥ T2 lorsque T1 et T2

partagent le même ensemble d’étiquettes? Et lorsqu’ils n’ont aucune
étiquette en commun?

1.3) Modélisez l’algorithme d’exclusion mutuelle de Lamport à la manière de ?

l’exercice 1.2):

Processus 0 Processus 1
répéter répéter
nc0 : b0 ← 1 nc1 : b1 ← 1
t0 : tant que b1 = 1: rien t1 : si b0 = 1 alors
c0 : b0 ← 0 q1 : b1 ← 0
q1′ : tant que b0 = 1: rien
aller à nc1
c1 : b1 ← 0

(tiré d’un livre en co-rédaction avec J. Esparza)

1.4) Considérons un état s d’un système de transition fini T . Décrivez la com- ?

posante fortement connexe de s en utilisant les ensembles Post(s), Pre(s),
Post∗ (s) et/ou Pre∗ (s).

1.5) Soit un chemin infini s0 − → s1 − → · · · d’un système de transition fini ?

T . Expliquez pourquoi il existe forcément un indice i ∈ N tel que les
états si , si+1 , . . . appartiennent tous à une même composante fortement
connexe de T .

1.6) Donnez une famille de programmes booléens où le nème programme pos- ?

sède O(n) lignes et O(n) variables booléennes, mais le système de tran-
sition sous-jacent contient Θ(2n ) états accessibles. Autrement dit, donnez
un exemple d’explosion combinatoire.
(tiré d’un livre en co-rédaction avec J. Esparza)
 2

Logique temporelle linéaire (LTL)

La correction d’un système dépend de propriétés satisfaites par ses exécutions.

Afin de vérifier formellement que de telles propriétés sont satisfaites, nous de-
vons les modéliser formellement plutôt qu’en français, d’une part pour éviter
toute ambiguïté, et d’autre part afin d’avoir un objet manipulable par un algo-
rithme. La logique est l’outil idéal pour accomplir cette tâche. La logique pro-
positionnelle n’est pas suffisante pour modéliser des propriétés intéressantes de
systèmes puisqu’elle ne permet pas de raisonner sur les comportements; elle
ne possède aucune notion de temps. Par exemple, la logique propositionnelle
ne permet pas de décrire « chaque fois qu’un processus désire entrer dans sa
section critique, il y entre éventuellement ». Afin de pallier ce problème, nous
introduisons une logique temporelle; une logique qui étend la logique propo-
sitionnelle avec des opérateurs permettant de raisonner sur le temps. De telles
logiques temporelles sont classiques dans le domaine de la vérification (et dans
une moindre mesure en intelligence artificielle symbolique.) Dans ce chapitre,
nous nous concentrons sur la logique temporelle linéaire.

2.1 Syntaxe
Soit AP un ensemble de propositions atomiques. La syntaxe de la logique tem-
porelle linéaire (LTL) sur AP est définie par la grammaire suivante:

φ ::= vrai | p | φ ∧ φ | ¬φ | Xφ | φ U φ

où p ∈ AP. Autrement dit, l’ensemble des formules LTL sur AP est défini récur-
sivement par ces règles:
— vrai est une formule LTL;
— Si p ∈ AP, alors p est une formule LTL;
— Si φ1 et φ2 sont des formules LTL, alors φ1 ∧ φ2 est une formule LTL;
— Si φ est une formule LTL, alors ¬φ est une formule LTL;

9
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 10

— Si φ est une formule LTL, alors Xφ est une formule LTL;

— Si φ1 et φ2 sont des formules LTL, alors φ1 U φ2 est une formule LTL.

Remarque.

Nous utilisons le symbole X plutôt que le symbole utlisé dans d’autres

ouvrages comme [BK08]. Les opérateurs X et U se nomment respective-
ment next (« suivant ») et until (« jusqu’à »).

2.2 Sucre syntaxique

Avant d’expliquer la sémantique, c.-à-d. le sens associé aux formules LTL, nous
introduisons d’autres opérateurs qui rendent la lecture et l’écriture de formules
plus agréable. Ceux-ci sont définis en fonction des opérateurs déjà introduits:
faux := ¬vrai
φ1 ∨ φ2 := ¬(¬φ1 ∧ ¬φ2 )
φ1 → φ2 := ¬φ1 ∨ φ2
φ1 ↔ φ2 := (φ1 → φ2 ) ∧ (φ2 → φ1 )
φ1 ⊕ φ2 := (φ1 ∧ ¬φ2 ) ∨ (¬φ1 ∧ φ2 )
Fφ := vrai U φ
Gφ := ¬F¬φ
Les opérateurs ¬, ∧, ∨, →, ↔, ⊕ sont dits logiques, et les opérateurs X, F, G, U
sont dits temporels (ou parfois des modalités).

Remarque.

Nous utilisons les symboles F et G plutôt que les symboles ♢ et □ utli-

sés dans d’autres ouvrages comme [BK08]. Ces opérateurs se nomment
respectivement finally (« finalement ») et globally (« globalement »).

2.3 Sémantique
Nous associons un sens formel aux formules LTL. Celles-ci raisonnent sur des sé-
quences infinies qui représenteront les exécutions d’un système. Formellement,
un mot infini sur un alphabet fini Σ est une fonction σ : N → Σ que nous consi-
dérons comme une séquence infinie σ(0)σ(1)σ(2) · · · . Nous écrivons Σω pour
dénoter l’ensemble des mots infinis sur Σ. Pour tous mots finis u ∈ Σ∗ et v ∈ Σ+ ,
nous dénotons par uv ω le mot infini uvvv · · · , donc u suivi de v répété infiniment
souvent. Pour tous σ ∈ Σω et i ∈ N, nous définissons σ[i..] := σ(i)σ(i + 1) · · · .
Autrement dit, σ[i..] est le suffixe infini de σ obtenu en débutant à l’indice i.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 11

Exemple.

Les mots infinis aω , abω et (ab)ω sur alphabet Σ = {a, b} correspondent

respectivement: à la lettre a répétée pour toujours; à la lettre a suivie
de la lettre b répétée pour toujours; et à une alternation infinie entre les
lettres a et b. Par exemple, le mot abω est formellement la fonction σ telle
que σ(0) = a et σ(i) = b pour tout i > 0.

Dans le but de raisonner sur les exécutions de structures de Kripke, nous uti-
liserons l’alphabet Σ = 2AP . Ainsi, une lettre est ici un ensemble de propositions
atomiques et non une unique proposition (cela peut paraître contre-intuitif!)

Exemple.

Le mot infini ∅{p}{p, q}ω sur alphabet 2{p,q} correspond à une exécution
où ni p, ni q ne sont vraies au premier moment; où seulement p est vraie
au second moment; et où p et q sont vraies pour toujours par la suite.

Nous utiliserons la notation σ |= φ afin d’indiquer que « le mot σ satisfait la

formule φ ». Pour tout mot infini σ ∈ (2AP )ω , nous définissons cette notion ainsi:

σ |= vrai
déf
σ |= p ⇐⇒ p ∈ σ(0)
déf
σ |= φ1 ∧ φ2 ⇐⇒ σ |= φ1 ∧ σ |= φ2
déf
σ |= ¬φ ⇐⇒ σ ̸|= φ
déf
σ |= Xφ ⇐⇒ σ[1..] |= φ
déf
σ |= φ1 U φ2 ⇐⇒ ∃j ≥ 0 : (σ[j..] |= φ2 ) ∧ (∀0 ≤ i < j : σ[i..] |= φ1 ).

En mots, ces règles spécifient respectivement que:

— tout mot satisfait trivialement la formule « vrai »;
— un mot satisfait une proposition atomique si elle apparaît dans l’ensemble
à la première position du mot;
— un mot satisfait la conjonction de formules si elle satisfait ces formules;
— un mot satisfait la négation d’une formule si elle ne la satisfait pas;
— un mot satisfait Xφ s’il satisfait φ lorsqu’on retranche l’ensemble à la pre-
mière position du mot;
— un mot satisfait φ1 U φ2 si l’un de ses suffixes satisfait φ2 et que les suffixes
précédents satisfont tous φ1 .
La figure 2.1 illustre la sémantique de différentes formules LTL.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 12

p arbitraire arbitraire arbitraire arbitraire arbitraire arbitraire

p:

arbitraire p arbitraire arbitraire arbitraire arbitraire arbitraire

Xp:

p p p q arbitraire arbitraire arbitraire

p U q:

arbitraire arbitraire arbitraire arbitraire p arbitraire arbitraire

Fp:

p p p p p p p
Gp:

Figure 2.1 – Illustration de la sémantique de la logique temporelle linéaire.

Chaque ligne représente un mot w infini où les cercles sont les positions de w
et l’étiquette au-dessus du ième cercle indique les propositions de w(i).

Exemple.

Soient AP = {p, q} et le mot infini σ ∈ (2AP )ω tel que

σ := {p} ∅ {q} {p, q} ({p}{q})ω .

Nous avons:

σ |= p, σ ̸|= q,
σ ̸|= Xp, σ ̸|= Xq,
σ |= ¬Xp, σ |= ¬Xq,
σ ̸|= p U q, σ |= q U p,
σ |= GFp, σ ̸|= FGp,
σ |= G(q → Fp), σ |= FG(p ⊕ q).

Les opérateurs temporels F et G sont particulièrement utiles. Intuitivement,

F spécifie qu’une propriété est éventuellement satisfaite au moins une fois, et G
spécifie qu’une propriété est toujours satisfaite. Il est possible de démontrer for-
mellement que leur sémantique correspond bien à celle illustrée à la figure 2.1:
Proposition 1. Soit AP un ensemble de propositions atomiques. Pour tout σ ∈
(2AP )ω et pour toute formule LTL φ sur AP, nous avons:
(a) σ |= Fφ ⇐⇒ ∃j ≥ 0 : σ[j..] |= φ, et
(b) σ |= Gφ ⇐⇒ ∀j ≥ 0 : σ[j..] |= φ.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 13

Démonstration.
(a)
σ |= Fφ ⇐⇒ σ |= vrai U φ (par déf. de F)
⇐⇒ ∃j ≥ 0 : (σ[j..] |= φ) ∧ (∀0 ≤ i < j : σ[i..] |= vrai) (par déf. de U)
⇐⇒ ∃j ≥ 0 : σ[j..] |= φ (par déf. de vrai).
(b)
σ |= Gφ ⇐⇒ σ |= ¬F¬φ (par déf. de G)
⇐⇒ ¬(σ |= F¬φ) (par déf. de ¬)
⇐⇒ ¬(∃j ≥ 0 : σ[j..] |= ¬φ) (par (a))
⇐⇒ ¬(∃j ≥ 0 : ¬(σ[j..] |= φ)) (par déf. de ¬)
⇐⇒ ∀j ≥ 0 : ¬(¬(σ[j..] |= φ)) (loi de De Morgan)
⇐⇒ ∀j ≥ 0 : σ[j..] |= φ (double négation).

2.4 Équivalences
L’ensemble des mots qui satisfont une formule LTL φ sur AP se dénote par:
{ ω
}
JφK := σ ∈ (2AP ) : σ |= φ .

Certains concepts de la logique propositionnelle s’étendent naturellement à la

logique temporelle linéaire. Soient φ et φ′ deux formules LTL. Nous disons que:
— φ est une tautologie si JφK = (2AP )ω ;
— φ n’est pas satisfaisable si JφK = ∅;
— φ et φ′ sont équivalentes si JφK = Jφ′ K.
Nous écrivons φ ≡ φ′ pour dénoter que deux formules sont équivalentes. Notons
que toute tautologie est équivalente à la formule vrai, et que toute formule non
satisfaisable est équivalente à la formule faux.
Nous répertorions quelques équivalences entre formules LTL qui peuvent
simplifier la spécification ou l’analyse de propriétés.

2.4.1 Distributivité
Les opérateurs temporels se distribuent ainsi sur les opérateurs logiques:
X(φ1 ∨ φ2 ) ≡ Xφ1 ∨ Xφ2 ,
X(φ1 ∧ φ2 ) ≡ Xφ1 ∧ Xφ2 ,
F(φ1 ∨ φ2 ) ≡ Fφ1 ∨ Fφ2 ,
G(φ1 ∧ φ2 ) ≡ Gφ1 ∧ Gφ2 ,
(φ1 ∧ φ2 ) U ψ, ≡ (φ1 U ψ) ∧ (φ2 U ψ),
ψ U (φ1 ∨ φ2 ), ≡ (ψ U φ1 ) ∨ (ψ U φ2 ).
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 14

Remarque.

En général, la formule F(φ1 ∧ φ2 ) n’est pas équivalente à Fφ1 ∧ Fφ2 . Par

exemple, pour AP = {p, q} et σ := ({p}{q})ω , nous avons:

σ ̸|= F(p ∧ q),

σ |= Fp ∧ Fq.

Similairement, G ne se distribue par sur la disjonction:

σ |= G(p ∨ q),
σ ̸|= Gp ∨ Gq.

2.4.2 Dualité
La négation interagit de cette façon avec les opérateurs temporels:

¬Xφ ≡ X¬φ,
¬Fφ ≡ G¬φ,
¬Gφ ≡ F¬φ.

2.4.3 Idempotence
Les opérateurs temporels satisfont ces règles d’idempotence:

FFφ ≡ Fφ,
GGφ ≡ Gφ,
φ1 U (φ1 U φ2 ) ≡ φ1 U φ2 .

2.4.4 Absorption
Les opérateurs temporels satisfont ces règles d’absorption:

FGFφ ≡ GFφ,
GFGφ ≡ FGφ.

Ainsi, il n’existe que quatre combinaisons des opérateurs F et G: {F, G, FG, GF}.
Ceux-ci spécifient respectivement « éventuellement », « toujours », » éventuelle-
ment toujours » et « infiniment souvent ».

2.5 Propriétés d’un système

Voyons maintenant comment établir la connexion entre système et spécification,
c.-à-d. entre structures de Kripke et formules LTL. Considérons une structure de
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 15

Kripke T = (S, −
→, I, AP, L). La trace d’une exécution infinie s0 s1 · · · de T est
définie par
trace(s0 s1 · · · ) := L(s0 )L(s1 ) · · · .
Autrement dit, la trace d’une exécution est obtenue en remplaçant chaque état
par son étiquette qui indique les propositions atomiques qu’il satisfait.
L’ensemble des traces de T est dénoté

Traces(T ) := {trace(w) : w est une exécution infinie de T } .

Nous disons que T satisfait une propriété LTL φ sur AP si:

Traces(T ) ⊆ JφK.

En mots: T satisfait φ si la trace de chacune de ses exécutions infinies satisfait φ.

Exemple.

Considérons la structure de Kripke T illustrée à la figure 2.2. Nous avons:

T |= p, T |= GFp,
T ̸|= Gp, T ̸|= (¬q) U q.

{p} {p, q}

s0 s2
∅
s1

Figure 2.2 – Une structure de Kripke avec AP = {p, q}.

Notons qu’il est possible qu’une propriété et sa négation ne soient pas satis-
faites par un système. Par exemple, pour la structure de Kripke de la figure 2.2,
nous avons T ̸|= p ∧ q et T ̸|= ¬(p ∧ q) puisque toute exécution qui débute en s0
ne satisfait pas p ∧ q et toute exécution qui débute en s2 ne satisfait pas ¬(p ∧ q).
En particulier, il faut donc tenir compte de tous les états initiaux.

Exemple.

Considérons le circuit logique C ci-dessous qui émet un bit à chaque trois

cycles (inspiré de l’exemple 5.11 de [BK08]). Ce circuit est constitué des
registres r1 et r2 , et de la sortie s.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 16

⊕ r1 ¬

∧ s

¬ r2 ¬

Cherchons à spécifier que la sortie de C vaut 1 à chaque cycle divisible

par trois: 1, 0, 0, 1, 0, 0, . . .. Soit AP = {s} où la proposition atomique s
indique que la sortie du circuit vaut 1. Nous spécifions d’abord que la
sortie de C doit valoir 1 au moins une fois par cycle de taille trois:

φ≥1 := G(s ∨ Xs ∨ XXs).

Nous spécifions ensuite que la sortie vaut 1 au plus une fois par cycle de
taille trois:
φ≤1 := G(s → (X¬s ∧ XX¬s)).
La formule ψ = s ∧ φ≥1 ∧ φ≤1 spécifie que la sortie de C évolue bien de la
façon suivante: 1, 0, 0, 1, 0, 0, . . .. Notons que C satisfait φ si et seulement
si ses registres sont initialisés à r1 = 0 et r2 = 0.

2.6 Types de propriétés

Nous discutons brièvement des types de propriétés pouvant être modélisées en
LTL et plus généralement à l’aide de mots infinis.

2.6.1 Invariants
Un invariant est une propriété qui doit être satisfaite à tout moment d’une exé-
cution. En LTL, un invariant s’écrit sous la forme « Gφ », où φ est une formule
propositionnelle. Par exemple, l’exclusion mutuelle de deux processus est un in-
variant qui s’écrit sous la forme G¬(c1 ∧ c2 ). Une telle propriété peut être dé-
montrée ou infirmée à l’aide d’un parcours de graphe sur la structure de Kripke.
De plus, un témoin de l’invalidité d’un invariant peut être identifié algorithmi-
quement, par exemple à l’aide d’un parcours en profondeur où l’on utilise une
pile afin de stocker un chemin qui mène à un état qui enfreint la propriété (par
ex. voir [BK08, algo. 4, p. 110]). Ainsi, on peut automatiser la vérification d’un
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 17

invariant pour une structure de Kripke donnée, et retourner une « explication »

du bogue le cas échéant.

2.6.2 Sûreté
Informellement, une propriété de sûreté est une propriété qui indique que « rien
de mauvais ne se produit ». Une propriété de sûreté qui n’est pas satisfaite peut
être réfutée par un préfixe fini d’une trace. Par exemple, reconsidérons la struc-
ture de Kripke T illustrée à la figure 2.2 et la propriété φ = G(p∨q). La structure
T ne satisfait pas φ tel que démontré par la « trace finie »: {p, q}{p}∅. En effet,
ni p, ni q sont vraies à la troisième position, donc la suite n’a pas d’importance.
En particulier, les invariants sont des propriétés de sûreté.
Formellement, nous disons qu’une propriété φ sur AP est une propriété de
sûreté si tout mot infini σ ̸∈ JφK satisfait:

∃i ∈ N, ∀σ ′ ∈ (2AP )ω , σ[0..i]σ ′ ̸∈ JφK.

En mots, cela signifie que si un mot infini σ enfreint φ, alors il doit posséder un
préfixe fini qui enfreint φ peu importe la façon dont on l’étend. Intuitivement,
ce préfixe σ[0..i] est celui qui « témoigne » de l’erreur.

2.6.3 Vivacité
Informellement, une propriété de vivacité est une propriété dont les bons com-
portements se manifestent « vers l’infini ». Contrairement aux propriétés de sû-
reté, une propriété de vivacité ne peut pas être réfutée à l’aide d’un préfixe fini.
Voici quelques exemples de propriétés de vivacité:
(a) GFp: p est satisfaite infiniment souvent;
(b) FGp: p est éventuellement toujours satisfaite (propriété de persistance);
(c) G(p → Fq): lorsque p est satisfaite, q est éventuellement satisfaite.
Afin d’illustrer la vivacité, considérons la propriété (a). Si elle est enfreinte
par un système T , on ne peut pas s’en convaincre à l’aide d’un préfixe fini w. Par
exemple, considérons w = ∅∅{q}∅. Bien que w ne contienne aucune occurrence
de p, il est possible qu’après quatre transitions, T visite infiniment souvent p. En
fait, ici on ne peut même pas se convaincre que T satisfait la propriété à l’aide
d’un préfixe fini. Par exemple, bien que w′ := {p}{p, q}{p} visite p plusieurs
fois, il y a peut-être moyen de compléter w′ dans T sans plus jamais visiter p.
Formellement, nous disons qu’une propriété φ sur AP est une propriété de
vivacité si pour tout mot fini w ∈ (2AP )∗ , il existe un mot infini σ ∈ (2AP )ω tel
que wσ ∈ JφK. Plus informellement, cela signifie que toute « trace finie » w peut
être étendue de telle sorte à satisfaire φ.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 18

2.7 Équité
Certaines propriétés d’un système concurrent peuvent parfois être trivialement
enfreintes en raison d’exécutions inéquitables qui priorisent systématiquement
certains processus. Par exemple, considérons un système constitué de n proces-
sus P1 , P2 , . . . , Pn . Pour tout 1 ≤ i ≤ n, définissons les propositions atomiques:
pi := Pi peut exécuter une instruction,
qi := Pi exécute une instruction.
Considérons la trace σ := {p1 , q1 , p2 }ω . Cette trace correspond à une exécution
où seules les instructions du processus P1 sont exécutées, bien que les instruc-
tions du processus P2 soient exécutables. En particulier, nous avons:
σ |= FG(p2 ∧ ¬q2 ).
Autrement dit, à partir d’un certain point, le processus P2 est toujours exécu-
table, mais n’est jamais exécuté. En pratique, cela pourrait correspondre à un
ordonnanceur qui ignore complètement un processus pour aucune raison va-
lable. Normalement, ce type de comportement n’est pas réaliste et il faut donc
faire l’hypothèse d’une certaine notion d’« équité » entre les processus. Nous
survolons deux telles notions d’équité.

Équité faible. Posons φi := FG(pi ∧ ¬qi ) pour tout 1 ≤ i ≤ n. Nous disons

qu’une trace σ ∈ (2AP )ω d’un système à n processus est faiblement équitable ssi:
∧
n
σ |= ¬φi .
i=1

Autrement dit, σ est faiblement équitable ssi pour chaque processus Pi , ce n’est
pas le cas qu’éventuellement celui-ci est toujours exécutable et jamais exécuté.
Il est possible de spécifier que toutes les traces faiblement équitables d’un
système doivent satisfaire une propriété ψ, et d’ignorer les traces non équitables
avec cette formule: ( n )
∧
¬φi → ψ.
i=1
Ainsi, la vérification d’une propriété ψ, sous hypothèse que les exécutions sont
faiblement équitables, ne requiert pas de machinerie supplémentaire. En effet,
la formule résultante est également une formule LTL.
Notons que:
¬φi = ¬FG(pi ∧ ¬qi ) (par définition de φi )
≡ ¬(FGpi ∧ FG¬qi ) (par distributivité de FG, voir exercice 2.9))
≡ ¬FGpi ∨ ¬FG¬qi (par la loi de De Morgan)
≡ ¬FGpi ∨ GFqi (par dualité)
≡ FGpi → GFqi (par défininition de →).
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 19

Ainsi, de façon équivalente, qui est celle utilisée dans d’autres ouvrages comme
le manuel de référence [BK08], une trace σ est faiblement équitable ssi:
∧
n
σ |= (FGpi → GFqi ).
i=1

Équité forte. Considérons la trace ({p1 , q1 , p2 }{p1 , q1 })ω . Cette trace est fai-
blement équitable (vérifiez-le!) Toutefois, bien que le processus P2 soit exécu-
table infiniment souvent, il n’est jamais exécuté. La notion d’équité faible peut
être raffinée afin d’éliminer ce type de traces. Posons φ′i := (GFpi ∧ FG¬qi ) pour
tout 1 ≤ i ≤ n. Nous disons qu’une trace σ est fortement équitable ssi
∧
n
σ |= ¬φ′i .
i=1

Autrement dit, une trace n’est pas fortement équitable ssi un processus est exé-
cutable infiniment souvent, mais n’est exécuté qu’un nombre fini de fois.
Comme dans le cas de l’équité faible, la vérification d’une propriété ψ, sous
hypothèse que les exécutions sont fortement équitables, ne ∧requiert pas de ma-
chinerie supplémentaire; il suffit de considérer la formule ( i=1 ¬φ′i ) → ψ.
n

Notons que:

¬φ′i = ¬(GFpi ∧ FG¬qi ) (par définition de φ′i )

≡ ¬GFpi ∨ ¬FG¬qi (par la loi de De Morgan)
≡ GFpi → ¬FG¬qi (par définition de →)
≡ GFpi → GFqi (par dualité).

Ainsi, de façon équivalente, qui est celle utilisée par d’autres ouvrages comme
le manuel de référence [BK08], une trace σ est fortement équitable ssi:
∧
n
σ |= (GFpi → GFqi ).
i=1

Remarque.

L’unique propriété linéaire qui est à la fois de sûreté et de vivacité est

la propriété triviale vrai. Toute autre propriété linéaire est de sûreté, de
vivacité, ou l’intersection d’une propriété de sûreté et de vivacité.

2.8 Spin et Promela

Spin est un outil qui permet de vérifier automatiquement des systèmes concur-
rents finis décrits dans le langage Promela et dont les propriétés sont spécifiées
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 20

par des assertions ou des formules LTL (avec ou sans équité). Le développe-
ment de cet outil a débuté en 1980 dans le « groupe Unix » de Bell Labs. Spin
est maintenu à jour et distribué sous licence libre. Le langage Promela supporte
des types booléens et entiers, les tableaux, les structures, les canaux de commu-
nication (finis ou de type rendez-vous), les processus (avec identités), les blocs
atomiques, différents types de flôt de contrôles (boucle, sélection, saut, etc.) Sa
syntaxe s’apparente à celle de C, à l’exception notable de l’ajout du non déter-
minisme qui permet de modéliser des comportements imprévisibles. À l’interne,
Spin convertit le code Promela vers une structure de Kripke.
Par exemple, reconsidérons l’algorithme d’exclusion mutuelle de Lamport à
deux processus tel qu’introduit au début du cours:

Processus A Processus B

1. tant que vrai: 1. tant que vrai:

2. x = vrai 2. y = vrai
3. tant que y: rien faire 3. si x alors:
4. # section critique 4. y = faux
5. x = faux 5. tant que x: rien faire
6. aller à 2
7. # section critique
8. y = faux

Cet algorithme se modélise ainsi dans le langage Promela: 

bool x = false;
bool y = false;

init
{
atomic
{
run A()
run B()
}
}

proctype A()
{
do
:: true ->
enter:
x = true
wait:
do
:: y -> skip
:: else -> break
od
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 21

critical:
skip
leave:
x = false
od
}

proctype B()
{
do
:: true ->
enter:
y = true
wait:
if
:: x ->
y = false

do
:: x -> skip
:: else -> break
od

goto enter

:: else -> goto critical

fi
critical:
skip
leave:
y = false
od
}

Ces propriétés LTL pertinentes à l’analyse de l’algorithme:

φ1 := ¬(F(« A est dans sa section critique » ∧ « B est dans sa section critique »))
φ2 := G(« B désire entrer dans sa section critique » →
F « B est dans sa section critique »)

se spécifient respectivement ainsi:

ltl p1 { !(<> (A@critical && B@critical)) }
ltl p2 { [] (B@enter -> <> B@critical) }

Spin peut vérifier que la propriété φ1 est satisfaite. Cependant, φ2 ne l’est

pas, même sous équité forte, puisque dans cette exécution infinie le processus
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 22

B atteint sa ligne 2 infiniment souvent sans jamais atteindre sa ligne 7:

A
(A1 , B1 , x = faux, y = faux) −→ (A2 , B1 , x = faux, y = faux)
A
−→ (A3 , B1 , x = vrai, y = faux)
B
→ (A3 , B2 , x = vrai, y = faux)
−
B
−
→ (A3 , B3 , x = vrai, y = vrai)
B
−
→ (A3 , B4 , x = vrai, y = vrai)
B
−
→ (A3 , B5 , x = vrai, y = faux)
A
−→ (A4 , B5 , x = vrai, y = faux)
A
−→ (A5 , B5 , x = vrai, y = faux)
A
−→ (A1 , B5 , x = faux, y = faux)
B
−
→ (A1 , B6 , x = faux, y = faux)
B
−
→ (A1 , B2 , x = faux, y = faux)
A
−→ (A2 , B2 , x = faux, y = faux)
A
−→ (A3 , B2 , x = vrai, y = faux)
B
−
→ ···

2.9 Étude de cas: protocole de Needham-Schroeder

Considérons le scénario où deux entités, Alice et Bob, désirent établir un secret
commun sur un réseau non sûr, avec un accès à la cryptographie à clé publique.
Plus en détails, Alice et Bob possèdent respectivement un secret NA et NB (par
ex. des entiers) et veulent s’échanger ces secrets sans qu’une autre entité l’ap-
prenne. Chaque entité peut chiffrer un message m avec la clé publique de l’entité
X, que nous dénotons ⟨m⟩X , et uniquement X peut déchiffrer ⟨m⟩X .
Le protocole de Needham-Schroeder 1 tente d’accomplir cette tâche ainsi:
1. Alice envoie ⟨A, NA ⟩B , c.-à-d. son identité et son secret, à Bob;
2. Bob déchiffre le message, apprend l’identité d’Alice et envoie ⟨NA , NB ⟩A ;
3. Alice déchiffre le message, se convainc qu’elle interagit bien avec Bob puis-
qu’il a pu lui renvoyer son secret, et elle apprend ainsi le secret de Bob;
Alice envoie ⟨NB ⟩B à Bob, ce qui le convainc qu’il interagit bien avec Alice.
Schématiquement, le protocole devrait donc se comporter ainsi:

1. Il s’agit ici de la variante décrite dans [Mer01]

CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 23

1. ⟨A, NA ⟩B

2. ⟨NA , NB ⟩A
♂ ♂
Alice 3. ⟨NB ⟩B Bob

Cependant, nous supposons qu’une entité adversariale, Eve, peut intercepter

et envoyer des messages sur le réseau. Ainsi, le protocole est de la forme:
1. Alice envoie ⟨A, NA ⟩X ;
2. Bob reçoit ⟨Y, M ⟩B et envoie ⟨M, NB ⟩Y ;
3. Alice reçoit ⟨K, L⟩A et envoie ⟨L⟩X .

Le protocole doit donc résister aux attaques cryptographiques. Plus précisément,

les propriétés suivantes doivent être satisfaites lorsqu’Alice et Bob ne détectent
aucune incongruité:
— Seul X peut apprendre NA (donc si X = B, alors Eve n’apprend pas NA );
— Seul Y peut apprendre NB (donc si Y = A, alors Eve n’apprend pas NB ).
Une attaque a été identifiée 18 ans après la parution du protocole par l’in-
formaticien Gavin Lowe à l’aide d’un outil de vérification algorithmique. Voici
un schéma de l’attaque, où Eve se fait passer à la fois pour Alice et Bob:

1. ⟨A, NA ⟩E 2. ⟨A, NA ⟩B

4. ⟨NA , NB ⟩A 3. ⟨NA , NB ⟩A
♂ 5. ⟨NB ⟩E
♂ 6. ⟨NB ⟩B
♂
Alice Eve Bob

L’attaque peut être identifiée automatiquement, par exemple, en modélisant

le protocole dans le langage Promela, en spécifiant les propriétés en LTL, et en
les analysant à l’aide de l’outil Spin. Par exemple, voici la modélisation et la
spécification fournies par le chercheur Stephan Merz dans [Mer01], où certaines 
simplifications sont faites, par ex. Eve ne peut stocker qu’un message intercepté.
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 24

2.10 Exercices
2.1) Soit AP = {vert, jaune, rouge} l’ensemble où chaque proposition atomique ?
indique si un feu de circulation est allumé ou non. Dites en français ce que
spécifient ces formules LTL:
a) F(vert ∧ ¬jaune ∧ ¬rouge)
b) G(rouge → ¬X vert)
c) G(rouge → (rouge U X(jaune ∧ X(jaune U vert))))
(tiré en partie de [BK08, ex. 5.4])

2.2) Pour chaque formule de l’exercice précédent, donnez un mot infini de ?

votre choix qui satisfait la formule et un qui ne la satisfait pas.

2.3) Soit AP = {vert, jaune, rouge} l’ensemble où chaque proposition atomique ?

indique si un feu de circulation est allumé ou non. Spécifiez ces propriétés
en LTL:
a) Il y a toujours exactement un feu allumé.
b) Le feu rouge est allumé infiniment souvent.
c) On ne peut pas passer du vert au rouge sans passer par le jaune.

2.4) Soit AP = {d, r} l’ensemble où d indique qu’une demande est faite à un ?

serveur et r indique qu’une réponse est envoyée par le serveur. Spécifiez
ces propriétés en LTL:
a) Toute demande est éventuellement suivie d’une réponse.
b) Il y a éventuellement toujours des demandes.
c) Au moins une demande a lieu en même temps qu’une réponse.
d) Il y a un nombre infini de réponses.

2.5) Montrez ces équivalences: ?

a) F(φ1 ∨ φ2 ) ≡ (Fφ1 ) ∨ (Fφ2 )
b) G(φ1 ∧ φ2 ) ≡ (Gφ1 ) ∧ (Gφ2 )
c) FGFφ ≡ GFφ
d) GFGφ ≡ FGφ

2.6) On pourrait être tenté de croire que φ U ψ signifie ?

« φ est satisfaite tant que ψ ne l’est pas ». (*)

Cependant, cela n’est pas le cas comme U force ψ à être éventuellement

satisfaite. Définissez un nouvel opérateur binaire W, en fonction des opé-
rateurs existants, qui se comporte comme (*).
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 25

2.7) Définissez un nouvel opérateur temporel R, en fonction des opérateurs ?

existants, tel que φ R ψ spécifie « la validité de φ permet de relâcher celle
de ψ » Schématiquement, cela correspond à:

ψ ∧ ¬φ ψ ∧ ¬φ ψ ∧ ¬φ ψ∧φ arbitraire arbitraire

φ R ψ: ou

ψ ∧ ¬φ ψ ∧ ¬φ ψ ∧ ¬φ ψ ∧ ¬φ ψ ∧ ¬φ ψ ∧ ¬φ

2.8) Lesquelles de ces équivalences sont vraies? Pensez à une justification. ?

?
a) (φ ∨ ψ) U ψ ≡ φ U ψ.
?
b) φ U (φ ∨ ψ) ≡ φ U ψ.
?
c) ¬(φ U ψ) ≡ (¬φ) U (¬ψ)
?
d) X(φ U ψ) ≡ (Xφ) U (Xψ)

2.9) Convainquez-vous de la règle de distributivité FG(φ1 ∧φ2 ) ≡ FGφ1 ∧FGφ2 , ?

préférablement avec une démonstration.

2.10) Posons φ := GFp → FG(q ∨ r) et ψ := (r U Xp) U (q ∧ ¬XXs). Dites si ces ?

mots infinis sur AP := {p, q, r, s} satisfont respectivement φ et ψ:

a) ∅ω d) {r}∅{p, q, s}ω
b) {p, q, r, s}ω e) {r}∅({p, q}{r, s})ω
c) {p, q}ω f) {r}∅{p}{q, r}({p, s}∅)ω

(tiré d’exercices enseignés à l’Université technique de Munich)

2.11) ⋆⋆ Considérons n processus qui communiquent à l’aide d’un canal par- ?

tagé c de taille m. Chaque processus peut envoyer ou consommer des mes-
sages. Un ajout lorsque c est plein ou un retrait lorsque c est vide bloque
un processus jusqu’à ce qu’il devienne possible de compléter l’opération.
(a) Modélisez le système suivant, avec n = 2 et m = 1, en Promela:
processus(i):
tant que vrai
c!i
c?i
/* section critique */
/* section non critique */
CHAPITRE 2. LOGIQUE TEMPORELLE LINÉAIRE (LTL) 26

(b) Vérifiez la propriété d’exclusion mutuelle à l’aide de Spin (avec as-

sertions ou avec LTL).
(c) Décrivez deux processus qui utilisent un canal afin de satisfaire la
propriété d’exclusion mutuelle pour n = 2. Modélisez votre système
à l’aide de Promela et vérifiez-le à l’aide de Spin.
(d) Vérifiez également si les deux processus entrent toujours éventuelle-
ment dans leurs sections critiques: sans équité, avec équité faible, et
avec équité forte.
(adapté d’un exercice enseigné à l’Université technique de Munich)

2.12) Considérons la structure de Kripke T : ?

{p} {r} {q, r}

s0 s1 s2

s3 s4 s5

{p, q, r} {q} ∅

Dites si T |= φ pour chacune des formules φ suivantes:

a) G(p → Fq) f) GFp

b) G(q → Fp) g) p U (Xq)
c) p U q h) p U (¬p U p)
d) F(p U q) i) G(r → ¬(p ⊕ q))
e) GFq j) (Xr) U (G(q ∨ ¬r))

2.13) Dites si p U (q U r) ≡ (p U q) U r. Justifiez. ?

 3
Langages ω-réguliers

Dans les deux premiers chapitres, nous avons vu comment modéliser différents
systèmes à l’aide de structures de Kripke, et comment spécifier leurs propriétés
en logique temporelle linéaire. Une question demeure: comment vérifier systé-
matiquement qu’une structure de Kripke satisfait une propriété LTL? Autrement
dit, comment faire le pont afin de tester algorithmiquement si Traces(T ) ⊆ JφK?
Dans cette optique, observons que Traces(T ) et JφK sont tous deux des sous-
ensembles de Σω où Σ := 2AP , donc des langages de mots infinis sur l’alphabet
Σ. Nous chercherons donc à représenter ces langages symboliquement par des
automates. Ceux-ci serviront de structures de données pouvant être manipulées
algorithmiquement.
Il est bien connu que les langages reconnus par les automates finis (déter-
ministes ou non) correspondent précisément aux langages décrits par les ex-
pressions régulières. Ces formalismes opèrent sur des mots finis. Dans notre
contexte, nous devons plutôt raisonner sur des mots infinis. Nous introduisons
donc les expressions ω-régulières, puis les automates de Büchi, qui étendent
naturellement ces formalismes au cas infini.

3.1 Expressions ω-régulières

3.1.1 Expressions régulières
Soit Σ un alphabet fini, donc un ensemble fini de symboles appelés lettres. Rap-
pelons que les expressions régulières, sur un alphabet Σ, sont décrites par cette
grammaire, où a ∈ Σ, et ε dénote le mot vide:

r ::= r∗ | (r · r) | (r + r) | a | ε

27
CHAPITRE 3. LANGAGES ω-RÉGULIERS 28

Le langage L(r) ⊆ Σ∗ d’une expression régulière r est défini récursivement par:

∪
L(r∗ ) := {w1 w2 · · · wn : w1 , w2 , . . . , wn ∈ L(r)},
n∈N

L(r · r′ ) := {uv : u ∈ L(r), v ∈ L(r′ )},

L(r + r′ ) := L(r) ∪ L(r′ ),

L(a) := {a},
L(ε) := {ε}.

3.1.2 Syntaxe
La syntaxe des expressions ω-régulières sur alphabet Σ est définie par cette gram-
maire, où a ∈ Σ:

s ::= rω | (r · s) | (s + s)
r ::= r∗ | (r · r) | (r + r) | a | ε

Cette syntaxe est restreinte par l’interdiction d’utiliser l’opérateur rω lorsque

le langage de r est vide ou contient le mot vide ε. Ainsi, par exemple, (a + ε)ω
et ∅ω ne sont pas des expressions ω-régulières valides. En mots, l’ensemble des
expressions ω-régulières sur alphabet Σ est donc défini récursivement par:
— Si r est une expression régulière telle que ε ̸∈ L(r) et L(r) ̸= ∅, alors rω
est une expression ω-régulière;
— Si r est une expression régulière et s est une expression ω-régulière, alors
(r · s) est une expression ω-régulière;
— Si s et s′ sont des expressions ω-régulières, alors (s+s′ ) est une expression
ω-régulière.

Exemple.

Ces quatre expressions sur Σ := {a, b} sont toutes ω-régulières:

(a + b)ω a(a + b)ω
(ab)ω b∗ (aa∗ bb∗ )ω
CHAPITRE 3. LANGAGES ω-RÉGULIERS 29

3.1.3 Sémantique
Nous associons un langage L(s) ⊆ Σω à chaque expression ω-régulière s, défini
récursivement par:
L(rω ) := {w0 w1 · · · : wi ∈ L(r) pour tout i ∈ N},
L(r · s) := {wσ : w ∈ L(r), σ ∈ L(s)},
L(s + s′ ) := L(s) ∪ L(s′ ).
Ainsi, l’opérateur rω est une variante de l’opérateur r∗ où plutôt que de conca-
téner des mots de L(r) un nombre fini de fois, on en concatène une infinité.
Nous disons qu’un langage est ω-régulier s’il peut être décrit par une expres-
sion ω-régulière.

Exemples.

Soit Σ := {a, b}. Les expressions ω-régulières suivantes sur alphabet Σ

décrivent respectivement ces langages ω-réguliers:

(a + b)ω : ensemble de tous les mots (infinis),

a(a + b)ω : ensemble des mots qui débutent par la lettre a,
(ab)ω : ensemble contenant l’unique mot abababab · · · ,
b∗ (aa∗ bb∗ )ω : ensemble des mots avec une infinité de a et de b,
(a + b)∗ bω : ensemble des mots avec un nombre fini de a,
(a(a + b))ω : ensemble des mots avec un a à chaque position paire.

3.2 Automates de Büchi

Les expressions ω-régulières sont pratiques afin de décrire des langages, mais
moins adaptées à la manipulation algorithmique. Nous introduisons donc le mo-
dèle équivalent des automates de Büchi. Un automate fini classique accepte un
mot fini w s’il atteint un état acceptant en complétant la lecture de w. Cette
notion ne fait pas de sens dans le contexte d’un mot infini puisqu’il n’y a pas
de fin au mot. Un automate de Büchi accepte donc plutôt un mot infini σ si sa
lecture visite infiniment souvent un état acceptant. Formellement, un automate
de Büchi est un quintuplet A = (Q, Σ, δ, Q0 , F ) où
— Q est un ensemble fini dont les éléments sont appelés états,
— Σ est un alphabet fini,
— δ : Q × Σ → 2Q est la fonction de transition,
— Q0 ⊆ Q est un ensemble d’états dits initiaux,
— F ⊆ Q est un ensemble d’états dits acceptants.
CHAPITRE 3. LANGAGES ω-RÉGULIERS 30

Exemple.

Considérons les automates de Büchi A et B illustrés à la figure 3.1.

L’automate A débute dans l’état initial p, lit la lettre a, puis boucle
pour toujours sur l’état acceptant q sur une lettre arbitraire. Ainsi, cet
automate accepte le langage a(a + b)ω des mots qui débutent par a.
L’automate B débute dans l’état initial p. Il lit la lettre a en se dépla-
çant ou bien dans l’état acceptant q ou r. Dans le premier cas, seule la
lettre a peut être lue, alors que dans le second, seule la lettre b peut être
lue. Ainsi, cet automate accepte le langage des mots qui débutent par a
suivie d’une même lettre répétée indéfiniment, c.-à-d. a(aω + bω ).

A: B: q a
a

a
p q a, b p

a
r b

Figure 3.1 – Exemples d’automates de Büchi. L’automate A accepte le langage

a(a + b)ω et l’automate B accepte le langage a(aω + bω ).

3.2.1 Langage d’un automate

a
Nous écrivons p − → q pour dénoter que q ∈ δ(p, a), et ainsi indiquer que l’au-
tomate possède une transition de p vers q étiquetée par la lettre a. Nous disons
qu’un mot infini σ ∈ Σω est accepté par un automate de Büchi A s’il existe une
suite (infinie) d’états q0 , q1 , . . . ∈ Q telle que
σ(0) σ(1)
— q0 −−−→ q1 −−−→ · · · ,
— q0 ∈ Q0 , et
— qi ∈ F pour une infinité de i ∈ N.
Autrement dit, un mot infini σ est accepté par A s’il est possible de lire ses lettres
à partir d’un état initial via une suite de transitions qui visite infiniment souvent
des états acceptants. En général, il peut exister plusieurs manières de lire un
même mot, il suffit donc que l’une d’elles satisfasse ces critères.
Le langage d’un automate de Büchi A, dénoté L(A), est l’ensemble des mots
infinis qu’il accepte:
L(A) := {σ ∈ Σω : σ est accepté par A}.
CHAPITRE 3. LANGAGES ω-RÉGULIERS 31

Exemple.

Reconsidérons les automates de Büchi A et B illustrés à la figure 3.1.

Pour l’automate A, nous avons:
a a b
p−
→ q, q−
→ q, q−
→ q.
a b a b
Cet automate accepte abab · · · car p −
→q−
→q−
→q−
→ ···.
Pour l’automate B, nous avons:
a a a b
p−
→ q, p−
→ r, q−
→ q, r−
→ r.

L’automate n’accepte pas le mot abaaa · · · car la seule manière de lire ab

consiste à se déplacer dans l’état r où il est impossible de lire d’autres a.
Tel que mentionné plus tôt, nous avons

L(A) = L(a(a + b)ω ), et

L(B) = L(a(aω + bω )).

Exemples.

Identifions des automates de Büchi qui acceptent ces langages ω-réguliers

(pensez-y d’abord):

langage expression ω-régulière

mots avec un nombre fini de c (a + b + c)∗ (a + b)ω
mots avec un nombre infini de a, un
(a + b + c)∗ (aa∗ bb∗ )ω
nombre infini de b et un nombre fini de c
mots avec un nombre infini de a et un
((b + c)∗ a(a + c)∗ b)ω
nombre infini de b
mots avec au moins un c et un nombre
(b∗ ab∗ a)∗ b∗ c(a + b + c)ω
pair de a avant le premier c

Ces langages sont acceptés respectivement par ces automates:

CHAPITRE 3. LANGAGES ω-RÉGULIERS 32

A: B:
a, b, c a, b a, b, c a, b
a
a, b a, b

C: D: b b
a
b, c
b, c
a
a
a c
b
a, c a, b, c

3.2.2 Déterminisme et expressivité

Nous disons qu’un automate de Büchi est déterministe si |Q0 | = 1, et |δ(q, a)| ≤ 1
pour tout état q ∈ Q et toute lettre a ∈ Σ. Autrement dit, un automate de Büchi
est déterministe s’il ne possède qu’un seul état initial, et aucun état ayant deux
transitions sortantes étiquetées par la même lettre. Par exemple, l’automate A
de la figure 3.1 est déterministe, mais l’automate B est non déterministe puisque
a a
p−→ q et p −→ r.
Contrairement aux automates classiques sur les mots finis, le déterminisme
est strictement plus faible que le non déterminisme dans le contexte des mots
infinis. Par exemple, il n’existe aucun automate de Büchi déterministe qui ac-
cepte le langage (a + b)∗ aω , c’est-à-dire le langage des mots qui possèdent un
nombre fini de b.
Mentionnons également que les automates de Büchi (non déterministes) et
les expressions ω-régulières capturent précisément la même classe de langages
(voir par ex. [BK08, théorème 4.32]):
Proposition 2 ([McN66]). L’ensemble des langages acceptés par les automates de
Büchi correspond précisément aux langages ω-réguliers.

3.3 Intersection d’automates de Büchi

Soient A et B deux automates de Büchi sur un alphabet commun. Si l’on voit
chacun de ces automates comme une structure de données qui stocke symbo-
liquement un langage, il est intéressant d’implémenter une opération qui per-
CHAPITRE 3. LANGAGES ω-RÉGULIERS 33

met de les combiner afin d’obtenir une représentation de leurs mots communs.
Pour y arriver, il suffit de construire un automate qui accepte l’intersection de
leurs langages. Nous montrons donc comment construire un automate de Bü-
chi, nommé A∩B, tel que L(A∩B) = L(A)∩L(B). Autrement dit, cet automate
acceptera précisément les mots acceptés par A et B.

3.3.1 Construction à partir d’un exemple

Avant de présenter la construction générale de A ∩ B, considérons le cas parti-
culier des automates A et B illustrés à la figure 3.2. Le langage de l’automate
A est l’ensemble des mots qui possèdent une infinité de a et qui ne contiennent
pas d’occurrence de bab. Le langage de l’automate B est l’ensemble des mots
possédant une infinité de b. Ainsi, l’intersection de ces deux langages est l’en-
semble des mots avec une infinité de a, une infinité de b, et qui ne contiennent
pas bab.

A: B:
a b a b
a b
p q r s
a a

Figure 3.2 – Deux automates de Büchi A et B pour lesquels nous désirons

construire l’intersection.

Nous construisons d’abord un automate C qui simule les automates A et B

simultanément « en parallèle ». Cela peut être réalisé en opérant sur le produit
cartésien des états de A et B. Les états initiaux de C correspondent aux paires
où le premier état est initial dans A et où le second état est initial dans B. Les
transitions indiquent l’évolution respective des états de A et B. L’automate C
obtenu de cette manière est illustré à la figure 3.3.
L’automate C peut lire exactement les mots pouvant être lus dans A et B.
On pourrait donc être tenté de conclure que leur intersection est vide car il est
impossible d’atteindre les états acceptants de A et B simultanément, c’est-à-
dire la paire (p, s). Ce n’est pourtant pas le cas puisque, par exemple, A et B
acceptent tous deux le mot infini (aab)ω . L’automate C ne donne donc pas assez
d’information pour décider quels mots doivent être acceptés ou refusés.
Afin de pallier ce problème, nous ajoutons une troisième composante aux
états de C qui indique lequel de A et B est le prochain à devoir franchir un état
acceptant. L’automate A ∩ B obtenu de cette façon est illustré à la figure 3.4.
L’idée derrière l’automate A ∩ B est la suivante. Lorsque l’automate est dans
l’état (x, y, A) et que x est un état acceptant de A, l’automate passe à la copie
de droite. Similairement, lorsque l’automate est dans l’état (x, y, B) et que y
est un état acceptant de B, l’automate passe à la copie de gauche. Cela permet
CHAPITRE 3. LANGAGES ω-RÉGULIERS 34

a
a
p, r q, r
a

b
a
q, s b

Figure 3.3 – Produit des automates A et B de la figure 3.2.

a
a
a
a
a
p, r, A q, r, A p, r, B q, r, B
a

b b

q, s, A q, s, B
b

Figure 3.4 – Intersection des automates A et B de la figure 3.2.

d’alterner indéfiniment entre les états acceptants de A et B, tout en simulant les

deux automates en parallèle. Les états acceptants de A ∩ B sont ceux de A dans
la copie de gauche. Nous pourrions également choisir ceux de B dans la copie
de droite; l’important est de s’assurer que A ∩ B alterne indéfiniment entre les
deux copies.
CHAPITRE 3. LANGAGES ω-RÉGULIERS 35

3.3.2 Construction générale

Présentons maintenant la construction dans sa généralité. Soient les automates
de Büchi A et B tels que

A = (QA , Σ, δA , Q0,A , FA ), et
B = (QB , Σ, δB , Q0,B , FB ).

L’automate A ∩ B := (Q, Σ, δ, Q0 , F ) est défini de la façon suivante.

Ses états, états initiaux et états acceptants sont définis respectivement par:

Q := QA × QB × {A, B},
Q0 := Q0,A × Q0,B × {A},
F := FA × QB × {A}.
a
La fonction de transition δ est définie par la règle suivante. Si qA −
→ rA dans
a
A, et qB −
→ rB dans B, alors nous ajoutons à A ∩ B la transition:


B si I = A et qA ∈ FA ,
a ′ ′
(qA , qB , I) −
→ (rA , rB , I ) où I := A si I = B et qB ∈ FB ,


I sinon.

Exemple.

Voyons un autre exemple de la construction de l’intersection. Considé-

rons ces automates de Büchi A et B:
A: B:
b b a, b c
a c
p q s t
a a, b

a, b, c r

L’automate A accepte les mots qui contiennent au moins un c et un

nombre pair de a avant la première occurrence de c. L’automate B ac-
cepte les mots qui contiennent une infinité d’occurrences de c.
L’automate A ∩ B obtenu selon notre construction est comme suit:
CHAPITRE 3. LANGAGES ω-RÉGULIERS 36

b b

a
p, s, A q, s, A
a

a, b
r, t, A r, s, B a, b

c
c c a, b

a, b
r, t, B r, s, A
c

Cet automate accepte les mots qui contiennent une infinité de c et un

nombre pair de a avant la première occurrence de c.
CHAPITRE 3. LANGAGES ω-RÉGULIERS 37

3.4 Exercices
3.1) Donnez une expression ω-régulière et un automate de Büchi pour chacun ?
de ces langages:
a) L ⊆ {a, b}ω tel que σ ∈ L ssi le nombre de a entre deux b est pair;
b) Comme en (a) mais sur alphabet {a, b, c};
c) L ⊆ {a, b, c}ω tel que σ ∈ L ssi σ ne contient aucun b qui suit immé-
diatement un a.

3.2) Ces expressions décrivent-elles le même langage? ?

a) (b∗ a∗ ab)ω et (a∗ ab + b∗ ba)ω ;
b) a(b∗ a + b)ω et (ab∗ a + ab)ω .

3.3) Expliquez comment transformer une expression ω-régulière arbitraire en

un automate de Büchi. Pensez à la construction des opérateurs ω, · et +.

3.4) ⋆ Expliquez comment transformer un automate de Büchi non détermi-

niste arbitraire en une expression ω-régulière. Pensez d’abord à un auto-
mate avec un seul état initial et un seul état final.

3.5) Comment peut-on construire l’union de deux automates de Büchi? ?

3.6) Étant donné un automate fini déterministe classique A , il suffit d’inverser ?
les états acceptants et non acceptants afin d’obtenir un automate qui ac-
cepte L(A). Est-ce aussi le cas pour les automates de Büchi déterministes?

3.7) Construisez l’intersection A ∩ B de ces deux automates de Büchi: ?

A: B:
b c a

a a, c
a
p q r s t
b b

3.8) Considérons un automate de Büchi qui possède plusieurs états initiaux. ?

Est-il possible d’obtenir un automate équivalent avec un seul état initial?

3.9) Qu’en est-il des états acceptants? Autrement dit, est-ce toujours possible ?
d’obtenir un automate de Büchi équivalent avec un seul état acceptant?

3.10) ⋆ Montrez qu’il n’existe pas d’automate de Büchi déterministe qui accepte ?
le langage des mots avec un nombre fini de b sur alphabet Σ := {a, b};
autrement dit, le langage décrit par (a + b)∗ aω .
CHAPITRE 3. LANGAGES ω-RÉGULIERS 38

3.11) Étant donné un automate de Büchi A = (Q, Σ, δ, Q0 , F ), considérons l’au- ?

tomate de Büchi A′ = (Q, Σ, δ ′ , Q0 , F ) obtenu à partir de A en réétique-
tant ses transitions ainsi:

(p, a, q) ∈ δ ′ ⇐⇒ (p, a, q) ∈
/ δ.

Est-ce nécessairement le cas que L(A) = L(A′ )?

(basé sur des interventions de Noé Canva et Alex Sansfaçon-Buchanan (A21))
 4
Vérification algorithmique de formules LTL

Dans ce chapitre, nous survolons l’automatisation de la vérification de spécifi-

cations LTL d’une structure de Kripke. Celle-ci s’appuiera sur la construction et
la manipulation d’automates de Büchi.

4.1 LTL vers automates de Büchi

Soit AP un ensemble de propositions atomiques. Posons Σ := 2AP . Pour toute
formule LTL φ sur AP, l’ensemble JφK est un sous-ensemble de Σω et ainsi un
langage de mots infinis sur alphabet Σ. Nous pouvons donc chercher à convertir
une formule LTL vers un automate de Büchi.

Exemple.

Pour AP = {p, q}, nous avons:

∗
JFpK = (∅ + {q}) ({p} + {p, q}) Σω ,
| {z } | {z }
pas de p occurrence de p

ω
JGpK = ({p} + {p, q}) ,
| {z }
occurrence de p

∗
JGFpK = ((∅ + {q}) ({p} + {p, q}))ω ,
| {z } | {z }
pas de p occurrence de p

∗
Jp U qK = ({p} + {p, q}) ({q} + {p, q}) Σω .
| {z } | {z }
occurrence de p occurrence de q

Ainsi, ces formules peuvent être représentées par ces automates:

39
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 40

Fp: Gp:

∅, {q} Σ {p}, {p, q}

{p}, {p, q}

GFp: p U q:

∅, {q} {p}, {p, q} {p} Σ

{p}, {p, q}
{p, q}, {q}

∅, {q}

Remarquons que le langage associé à une formule LTL s’exprime récursive-

ment en fonction de la répétition, la concaténation, l’union, l’intersection et la
complémentation:
Jφ ∧ ψK = JφK ∩ JψK JXφK = ΣJφK
Jφ ∨ ψK = JφK ∪ JψK JFφK = Σ∗ JφK

J¬φK = JφK JGφK = Σ∗ JφK

∪
JvraiK = Σω JpK = AΣω
{p}⊆A⊆AP
  
∪ ∩
Jφ U ψK =  Σi JφK ∩ Σj JψK .
j∈N 0≤i<j

Nous pourrions ainsi chercher à construire un automate de Büchi récursive-

ment. Cependant, au moins deux problèmes surgissent. Premièrement, la com-
plémentation d’un automate de Büchi est loin d’être simple et s’appuie sur des
constructions plutôt complexes. Il est connu que:
Proposition 3. Pour tout automate de Büchi A de n états, il existe un automate
de Büchi B tel que L(B) = L(A) et B possède 2O(n log n) états. De plus, cette borne
peut être atteinte pour certaines familles d’automates.
Deuxièmement, l’identité ci-dessus pour l’opérateur temporel U utilise une
union infinie, ce qui correspond, à priori, à composer une infinité d’automates.
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 41

Ces enjeux peuvent être surmontés en construisant directement un automate

de Büchi 1 dont les états représentent essentiellement des ensembles de sous-
formules à vérifier simultanément à la volée. Il existe plusieurs telles construc-
tions, assez complexes, qui offrent certains compromis en théorie et en pratique.
Par exemple, la description de [BK08, Thm. 5.41] mène à ce résultat classique:

Théorème 1. Pour toute formule LTL φ sur AP, il est possible de construire un
automate de Büchi Aφ de 2O(|φ|) états tel que L(Aφ ) = JφK. De plus, certaines
familles de formules requièrent un nombre exponentiel d’états.

En pratique, cette taille exponentielle ne se manifeste pas systématiquement.

Il existe aussi plusieurs approches pour chercher à produire des automates avec
peu d’états ou à réduire la taille d’automates déjà construits. Par exemple, des
outils modernes comme Spot [DLF+ 16] et Owl [KMS18] sont entièrement dé-
diés à ces tâches. Une présentation de ces techniques dépasse le cadre du cours.

4.2 Structures de Kripke vers automates de Büchi

Afin de comparer une formule LTL à une structure de Kripke T , on peut trans-
former T en un automate de Büchi. Cette conversion s’avère bien plus simple
puisqu’une structure de Kripke s’apparente déjà grandement à un automate.
Voyons comment procéder.
Soit T = (S, − →, I, AP, L) une structure de Kripke. Nous associons à T un
automate de Büchi AT tel que L(AT ) = Traces(T ). L’automate AT est obtenu
à partir de T en rendant tous ses états acceptants et en étiquetant chaque tran-
sition s −
→ t par l’étiquette L(s). Plus précisément, l’automate AT est défini par
AT := (S, 2AP , δ, I, S) où δ est défini par:

δ(q, a) := {r ∈ Q : q −
→ r et L(q) = a} pour tous q ∈ Q, a ∈ 2AP .

Exemple.

T: AT :
{p} {p, q} {p}
s0 s2 s0 s2

{p, q}
{p}
{∅} {p} ∅

s1 s1

1. En fait, il s’agirait normalement d’un automate de Büchi généralisé.

CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 42

Nous avons comme conséquence quasi immédiate de la définition que:

Proposition 4. L(AT ) = Traces(T ) pour toute structure de Kripke T .

Démonstration. Soit E l’ensemble des exécutions infinies de T . Nous avons:

σ ∈ Traces(T ) ⇐⇒ ∃s0 s1 · · · ∈ E : σ = trace(s0 s1 · · · )

⇐⇒ ∃s0 s1 · · · ∈ E : σ = L(s0 )L(s1 ) · · ·
⇐⇒ ∃s0 , s1 , . . . ∈ S : s0 −
→ s1 −
→ · · · et σ = L(s0 )L(s1 ) · · ·
σ(0) σ(1)
⇐⇒ ∃s0 , s1 , . . . ∈ S : s0 −−−→ s1 −−−→ · · · dans AT
⇐⇒ σ ∈ L(AT ) (*)

où (*) découle du fait que tous les états de AT sont acceptants.

Observation.
Bien que tous les états de l’automate AT soient acceptants, cela ne si-
gnifie pas qu’il accepte forcément tous les mots. En effet, les transitions
sortantes d’un état sont toutes étiquetées par la même lettre. En particu-
lier, nous avons ∅ω ̸∈ L(AT ) dans l’exemple précédent.

4.3 Vérification d’une spécification

Afin de vérifier qu’une structure de Kripke T satisfait une formule LTL φ, il suffit
de:
1. Construire l’automate de Büchi A¬φ ,
2. Construire l’automate de Büchi AT , et
3. Tester si L(AT ) ∩ L(A¬φ ) = ∅.
En effet, la validité de cette procédure découle de ces équivalences:

T |= φ ⇐⇒ Traces(T ) ⊆ JφK
⇐⇒ Traces(T ) ∩ JφK =∅
⇐⇒ Traces(T ) ∩ J¬φK =∅
⇐⇒ L(AT ) ∩ L(A¬φ ) = ∅.

Rappelons que nous avons vu, à la section 3.3, un algorithme qui peut pro-
duire un automate B tel L(B) = L(AT )∩L(A¬φ ). Ainsi, la vérification de T |= φ
se réduit au problème qui consiste à déterminer si L(B) = ∅. Voyons comment
résoudre ce problème algorithmiquement.
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 43

4.3.1 Lassos
Nous présentons d’abord une condition suffisante et nécessaire afin de détermi-
ner si le langage d’un automate de Büchi est vide. Soit B = (Q, Σ, δ, Q0 , F ) un
automate de Büchi. Un lasso de B est une séquence de la forme
u v
q0 −−−→ r −−−→ r,

où q0 ∈ Q0 , r ∈ F , u ∈ Σ∗ et v ∈ Σ+ . La figure 4.1 illustre un tel lasso.

L’existence d’un lasso caractérise le vide d’un automate de Büchi:
Proposition 5. Soit B un automate de Büchi. Nous avons L(B) ̸= ∅ si et seulement
si B possède un lasso.

Démonstration. ⇐) Supposons que B possède un lasso. Par définition, il existe

u v
q0 ∈ Q0 , r ∈ F , u ∈ Σ∗ et v ∈ Σ+ tels que q0 −
→r−
→ r. Notons que
u v v v
q0 −
→r−
→r−
→r−
→ ··· .

Ainsi, uv ω ∈ L(B), ce qui implique que L(B) est non vide.

⇒) Supposons que L(B) ̸= ∅. Il existe un mot infini v0 v1 · · · ∈ Σω et des états
q0 , q1 , . . . ∈ Q tels que q0 ∈ Q0 , qi ∈ F pour une infinité d’indices i, et
v v v
q0 −→
0
q1 −→
1
q2 −→
2
··· .

Puisque F est fini, il existe forcément deux indices i < j tels que qi = qj ∈ F .
Nous obtenons donc le lasso suivant:
v0 v1 ···vi−1 vi vi+1 ···vj−1
q0 −−−−−−−→ qi −−−−−−−−→ qi .

vn

u1 um
q0 r

v1 v2

Figure 4.1 – Schéma d’un lasso où |u| = m ≥ 0 et |v| = n > 0.

CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 44

4.3.2 Détection de lasso par parcours en profondeur

Afin de détecter un lasso dans un automate de Büchi, il suffit de:
1. calculer l’ensemble R des états accessibles à partir des états initiaux;
2. pour tout état acceptant f ∈ R, chercher un chemin non vide de f vers f .
Une telle procédure est décrite à l’algorithme 1, où l’instruction « terminer avec
x » court-circuite l’exécution et retourne la valeur x.

Algorithme 1 : Détection naïve de lasso par parcours en profondeur.

Entrées : Automate de Büchi B = (Q, Σ, δ, Q0 , F )
Sorties : L(B) = ∅?
// Calculer l'ensemble R des états accessibles
R←∅
dfs(q ):
ajouter q à R
pour r : q −
→r
si r ̸∈ R alors dfs(r)
pour q ∈ Q0
si q ̸∈ R alors
dfs(q )
// Chercher un état acceptant de R qui peut s'atteindre
pour f ∈ R ∩ F
Sf ← ∅
cycle(q ):
ajouter q à Sf
pour r : q −
→r
si r = f alors terminer avec « non vide »
sinon si r ∈
/ Sf alors cycle(r)
cycle(f )
terminer avec « vide »

Soient n et m, respectivement, le nombre d’états et de transitions de l’auto-

mate. Puisque dans le pire cas R contient tous les états (donc n états), et que
la complexité d’une recherche est de O(n + m), l’algorithme 1 fonctionne en
temps O(n(n + m)) = O(n2 + nm) dans le pire cas.
En pratique, les structures de Kripke possèdent une quantité massive d’états.
Une complexité quadratique n’est donc pas raisonnable. Il existe des algorithmes
de complexité linéaire pour détecter des lassos. Une approche consiste à:
1. Effectuer un parcours en profondeur à partir des états initiaux Q0 et nu-
méroter le moment où l’exploration de chaque état débute et termine;
2. Ordonner les états acceptants découverts selon la terminaison de leur ex-
ploration; en d’autres mots, obtenir un post-ordre;
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 45

3. Réexplorer l’automate, cette fois à partir de chaque état fi ∈ F , en post-

ordre, et chercher à atteindre fi pour identifier un cycle.
Cette procédure, décrite à l’algorithme 2, n’a pas à reconsidérer un état plus
d’une fois au second parcours. En effet, on peut démontrer que s’il y a un cycle
de fi vers fi qui traverse un état marqué précédemment par fk , où k < i, alors
ce cycle aurait été détecté plus tôt lors de l’exploration de fk (car F est en
post-ordre). Cela mène donc à une complexité de O(n + m).

Algorithme 2 : Détection linéaire de lasso par parcours post-ordre.

Entrées : Automate de Büchi B = (Q, Σ, δ, Q0 , F )
Sorties : L(B) = ∅?
// Premier parcours de B
parcourir B en profondeur à partir de Q0
en obtenir [f1 , f2 , . . . , fk ] les états acceptants découverts, en post-ordre
// Second parcours pour identifier un cycle acceptant
S←∅ // états marqués
cycle(q, c):
ajouter q à S
pour r : q −
→r
si r = c alors terminer avec « non vide »
sinon si r ̸∈ S alors cycle(r, c)
pour i ∈ [1..k]
si fi ̸∈ S alors
cycle(fi , fi ) // ∃ chemin non vide de fi vers fi ?
terminer avec « vide »

Exemple.

Exécutons l’algorithme 2 sur l’automate de Büchi illustré ci-dessous. Consi-

dérons le premier parcours en profondeur. Les deux nombres encadrés
en couleur à gauche et droite d’un état qi indiquent respectivement le
moment où l’exploration a débuté en qi et terminé en qi .

1 14 2 13 3 12 6 7
b
a
q0 q1 q2 q6 b
a
a b a a a

a, b b
q3 q4 q5

10 11 4 9 5 8
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 46

Suite à cette première fouille, les états acceptants sont ordonnés par
[q5 , q3 , q0 ] car leur exploration a respectivement terminé aux moments
[8, 11, 14]. La deuxième exploration à partir de q5 visite [q5 , q6 ] et ainsi
aucun cycle n’est identifié. La seconde exploration à partir de q3 visite
[q4 , q5 , q2 , q1 , q3 ] et ainsi un cycle de q3 vers lui-même est découvert. Par
conséquent, l’algorithme identifie un lasso de la forme
∗ +
q0 −
→ q3 −
→ q3 .

Remarquons que les lettres sur les transitions ne jouent aucun rôle. De
plus, d’autres ordres d’exploration sont possibles selon l’ordre dans le-
quel les successeurs immédiats d’un état sont considérés.

Un désavantage de l’algorithme 2 est qu’il doit explorer l’automate en en-

tier avant d’effectuer la seconde fouille. Cela s’évite en imbriquant la seconde
exploration dans la première. Cette approche établie par [CVWY90] est décrite
à l’algorithme 3, telle que présentée dans [EB23] 2 . Cet algorithme requiert peu
de mémoire: il suffit de stocker deux bits par état dans une table de hachage
pour indiquer s’il appartient aux ensembles S1 ou S2 . De plus, la procédure peut
être adaptée pour retourner explicitement un lasso lorsqu’elle en détecte un.

Algorithme 3 : Détection linéaire de lasso par parcours imbriqués.

Entrées : Automate de Büchi B = (Q, Σ, δ, Q0 , F )
Sorties : L(B) = ∅?
S1 ← ∅; S2 ← ∅
dfs1(q ): // Chercher un état acceptant
ajouter q à S1
pour r : q −
→r
si r ̸∈ S1 alors dfs1(r)
si q ∈ F alors c ← q; dfs2(q )
dfs2(q ): // Chercher un cycle vers c
ajouter q à S2
pour r : q −
→r
si r = c alors terminer avec « non vide »
sinon si r ̸∈ S2 alors dfs2(r)
pour q0 ∈ Q0
si q0 ∈
/ S1 alors dfs1(q0 )
terminer avec « vide »

2. Voir [EB23, chapitre 12], par exemple, pour une preuve formelle que cet algorithme fonc-
tionne, ainsi qu’une présentation d’autres algorithmes de détection de lasso.
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 47

4.3.3 Détection de lasso par les composantes fortement connexes

L’algorithme précédent peut être amélioré afin d’éviter de lancer des secondes
fouilles. Nous décrivons brièvement une telle approche, basée sur les compo-
santes fortement connexes.

Algorithme 4 : Détection linéaire de lasso basée sur les composantes

fortement connexes.
Entrées : Automate de Büchi B = (Q, Σ, δ, Q0 , F )
Sorties : L(B) = ∅?
n ←0 // Rang actuel
r ← [q →
7 ∞ : q ∈ Q] // Rang des sommets
a ← [q →7 faux : q ∈ Q] // Sommets actifs
C ← [] // Sommet découverts
S ←∅ // Composantes fortement connexes actuelles
scc(p):
n ← n + 1; r[p] ← n; a[p] ← vrai
empiler (p, {p}) à C; ajouter p à S
pour q : p −
→q
si q ∈
/ S alors scc(q )
sinon si a[q] alors
X′ ← [ ]
répéter
dépiler (x, X) de C
si x ∈ F alors terminer avec « non vide »
X′ ← X′ ∪ X
jusqu’à r[x] ≤ r[q]
empiler (x, X ′ ) à C
si p est la racine du dessus de C alors
dépiler (p, X) de C
pour x ∈ X a[x] ← faux
pour q0 ∈ Q0
si q0 ̸∈ S alors scc(q0 )
terminer avec « vide »

Nous associons à chaque état un rang numérique afin de répertorier l’ordre

dans lequel les états sont découverts. Lorsqu’un état q est découvert, nous consi-
dérons qu’il devient actif. Une transition est active si elle a été découverte et l’état
qui a mené à sa découverte est actif. Le graphe actif est le sous-graphe de l’au-
tomate constitué des états actifs et des transitions actives. À tout moment, nous
stockons dans une pile C les composantes fortement connexes du graphe actif.
Nous associons à chaque composante fortement connexe X une racine x qui
est l’état de rang minimal de X (donc le premier découvert parmi X). Ainsi, C
contient des paires de la forme (x, X) où x ∈ Q et {x} ⊆ X ⊆ Q. Un état q re-
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 48

devient inactif lorsque tous les sommets de sa composante ont été entièrement
traités (ce qui est équivalent à dire que la racine a été entièrement traitée).
La procédure, décrite à algorithme 4, procède ainsi:
— On lance l’exploration à partir d’un état initial q0 ∈ Q0 ;
— Si un nouvel état inactif q est découvert, alors q devient actif et la racine
de sa propre composante;
— Si un état actif q est redécouvert à partir d’un état p, alors p, q et tous les
sommets de rang supérieur à q sur le dessus de la pile font partie de la
même composante fortement connexe; on procède donc à leur fusion;
— Lors d’une fusion, si on rencontre une racine acceptante x, alors un lasso a
été identifé; en effet, cela signifie qu’à partir de q0 ∈ Q0 on peut atteindre
p ∈ Q et que la composante fortement connexe de p contient au moins
une transition et un état acceptant x ∈ F .

Exemple.

Exécutons l’algorithme 4 sur l’automate de Büchi illustré ci-dessous.

b
a
q0 q1 q2 q6 b
a
a b a a a

a, b b
q3 q4 q5

Voici une trace possible:

graphe actif C
b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 }); (q2 , {q2 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 , q2 })]
a, b b
q3 q4 q5
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 49

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 , q2 }); (q4 , {q4 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b

a b
a
a a a
[(q0 , {q0 }); (q1 , {q1 , q2 }); (q4 , {q4 });
q3
a, b
q4
b
q5
(q5 , {q5 })]

b
a
q0 q1 q2 q6 b

a b
a
a a a
[(q0 , {q0 }); (q1 , {q1 , q2 }); (q4 , {q4 });
q3
a, b
q4
b
q5
(q5 , {q5 }); (q6 , {q6 })]

b
a
q0 q1 q2 q6 b

a b
a
a a a
[(q0 , {q0 }); (q1 , {q1 , q2 }); (q4 , {q4 });
q3
a, b
q4
b
q5
(q5 , {q5 })]

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 , q2 }); (q4 , {q4 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 , q2 , q4 })]
a, b b
q3 q4 q5

b
a
q0 q1 q2 q6 b
a
a b a a a
[(q0 , {q0 }); (q1 , {q1 , q2 , q4 }); (q3 , {q3 })]
a, b b
q3 q4 q5

b
q0
a
q1
a
q2 q6 b [(q0 , {q0 }); (q1 , {q1 , q2 , q3 , q4 })]
a b a a a

a, b b
q3 q4 q5
lasso détecté via q3

4.4 Sommaire
L’approche algorithmique complète est schématisée à la figure 4.2.
Remarquons que la construction de T , AT et AT ∩ Aφ , ainsi que le test du
vide peuvent être être effectués simultanément à la volée. En effet, imaginons
qu’un modèle soit fourni dans un langage de description comme Promela. Un
outil de vérification comme Spin peut tester si L(AT ∩Aφ ) = ∅ en exécutant, par
exemple, l’algorithme 4 qui génère les états de AT ∩ Aφ au besoin, où les états
internes de AT sont eux-mêmes obtenus à la volée à partir du code Promela.
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 50

Système Propriété

Modèle Formule LTL φ

Structure de Kripke T

Automate de Büchi AT Automate de Büchi A¬φ

Calculer AT ∩ A¬φ

L(AT ∩ A¬φ ) = ∅?
oui non

Pas d’erreur Erreur (décrite par un lasso)

Figure 4.2 – Sommaire de l’approche de vérification algorithmique.

Cela permet d’identifier des erreurs sans avoir à construire la structure et les
automates en entier. Dans le cas où aucune erreur n’est identifiée, on explore
tout l’espace. Cependant, il existe des techniques plus sophistiquées comme la
réduction par ordre partiel qui permet de réduire le nombre d’états.

Remarque.

Si vous connaissez la théorie de la complexité, sachez que le problème

de décision qui consiste à déterminer si une structure de Kripke satisfait
une formule LTL est PSPACE-complet.
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 51

4.5 Exercices
4.1) Donnez une expression ω-régulière et un automate de Büchi pour ces for- ?
mules LTL sur AP = {p, q}:

a) Xp e) p ∨ q
b) FGp
f) G(p → Fq)
c) G(p U q)
d) p U (Xq) g) G[(X¬p) → (F(p ∧ q))]

4.2) Considérons cet automate de Büchi A: ?

q2

c a

a b
q0 q1 q3

a
b q6 b a

c
a b
q5 q4 q7 q8
b

a) Testez si L(A) = ∅ à l’aide des algorithmes présentés. Choisissez les

successeurs immédiats d’un état selon l’ordre alphabétique.
b) Expliquez pourquoi l’algorithme 3 n’identifie pas de lasso qui em-
prunte q2 , et ce peu importe l’ordre dans lequel les parcours en pro-
fondeur effectuent leurs choix de successeurs lors des explorations.

Remarque.

Cela montre que l’algorithme 3 n’identifie pas nécessairement

une « erreur minimale » car le plus petit lasso est
a b a
q0 −
→ q1 −
→ q2 −
→ q1 .

(tiré d’un exercice enseigné à l’Université technique de Munich)

4.3) Plusieurs conversions de formules LTL vers automates de Büchi passent ?

par un modèle intermédiaire: les automates de Büchi généralisés. Un tel
CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 52

automate est un quintuplet A = (Q, Σ, δ, Q0 , F ) où les quatre premières

composantes sont comme pour les automates de Büchi, mais où F ⊆ 2Q
est un ensemble d’états acceptants. Un mot σ ∈ Σω appartient au langage
L(A) si, et seulement si, il est possible de lire σ dans A en visitant chaque
ensemble de F infiniment souvent.
a) Quel langage est accepté par l’automate de Büchi A = ({p, q, r},
{a, b}, δ, {p}, {{q}, {r}}) ci-dessous?

a q a
p
b r b

b) Donnez un automate de Büchi généralisé déterministe qui accepte:

{σ ∈ Σω : chaque lettre de Σ apparaît infiniment souvent dans σ.}

c) Montrez que les automates de Büchi généralisés sont aussi expressifs

que les automates de Büchi. Autrement dit, montrez que l’on peut
accepter les mêmes langages en passant d’un modèle à l’autre.
d) Appliquez votre transformation de (c) à l’automate obtenu en (b).

4.4) Soit AP := {p}. Complétez l’automate de Büchi ci-dessous en lui ajoutant ?

des transitions de façon à ce que l’ensemble des mots infinis de 2AP lisibles
à partir de chaque état q soit précisément celui des mots infinis qui satis-
font les deux formules inscrites dans q. Choisissez ensuite les états initiaux
qui font en sorte que l’automate résultat accepte le langage JXpK.

p, Xp p, ¬Xp

¬p, Xp ¬p, ¬Xp

(adapté de [BK08, Fig. 5.21].)

4.5) ⋆ Montrez qu’aucun automate de Büchi déterministe n’accepte JFGpK. ?

CHAPITRE 4. VÉRIFICATION ALGORITHMIQUE DE FORMULES LTL 53

4.6) ⋆⋆ (Requiert des connaissances en théorie du calcul) Un chemin hamilto-

nien d’un graphe est un chemin qui visite tous ses sommets exactement
une fois. Montrez que le problème, qui consiste à déterminer si un graphe
dirigé possède un chemin hamiltonien, se réduit en temps polynomial au
problème de vérification de formules LTL.
(tiré de [BK08])

Observation.
Cela montre que le problème de vérification est NP-difficile.
 5
Logique temporelle arborescente (CTL)

La logique temporelle linéaire étudiée jusqu’ici ne permet pas de raisonner sur

les différents choix possibles d’un système. Par exemple, considérons la structure
de Kripke T illustrée à la gauche de la figure 5.1. On ne peut spécifier en LTL
une propriété comme: « il est toujours possible de revenir à l’état initial de T ».
Cette limitation est due à la conception linéaire du temps inhérente à LTL. La
logique temporelle arborescente (CTL) adopte une autre conception: le temps
arborescent. Cette modélisation considère tous les chemins possibles d’un sys-
tème sous une arborescence infinie. Par exemple, l’arborescence associée à T
est illustrée à la droite de la figure 5.1. Les formules CTL permettent de décrire
des propriétés qui dépendent des choix de cette arborescence. Nous étudierons
cette logique dans ce chapitre.

{p} {p, q} {p}

s0 s2 s0

{p} ∅ {p, q}
∅
s0 s1 s2
s1
{p} ∅ {p, q} {p, q} {p}

s0 s1 s2 s2 s0

Figure 5.1 – Une structure de Kripke T (à gauche), et son arbre de calcul (à

droite), c.-à-d. le « déroulement » des chemins de T sous forme d’arborescence.

54
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 55

Exemple.

La structure de Kripke T illustrée à la figure 5.1 ne satisfait pas la formule

F(p∧q) sous LTL. Toutefois il est toujours possible d’éventuellement satis-
faire p ∧ q car chaque état de l’arbre de calcul de T peut atteindre s2 en
zéro ou une étape. Nous dénoterons cette propriété CTL par ∀G∃F(p∧q).

5.1 Syntaxe
Soit AP un ensemble de propositions atomiques. La syntaxe de la logique tem-
porelle arborescente (CTL) sur AP est définie à partir de cette grammaire:

Φ ::= vrai | p | (Φ ∧ Φ) | ¬Φ | ∃φ | ∀φ
φ ::= XΦ | (Φ U Φ)

où p ∈ AP. Nous disons qu’une telle formule Φ est une formule d’état et qu’une
telle formule φ est une formule de chemin. Une formule CTL est une formule
d’état. Ainsi, les formules de chemin ne sont qu’un concept intermédiaire pour
définir les formules CTL.
Comme pour LTL, les opérateurs logiques ∨, →, ↔ et ⊕ se définissent natu-
rellement à partir de ∧ et ¬. Nous introduisons des opérateurs supplémentaires
qui seront utiles afin de modéliser des propriétés:

∃FΦ := ∃(vrai U Φ)
∀FΦ := ∀(vrai U Φ)
∃GΦ := ¬∀F¬Φ
∀GΦ := ¬∃F¬Φ

Informellement, ces quatre formules pourraient se lire ainsi:

— ∃FΦ: « Φ peut être satisfaite »,
— ∀FΦ: « Φ est inévitablement satisfaite »,
— ∃GΦ: « Φ est possiblement toujours satisfaite »,
— ∀GΦ: « Φ est invariablement satisfaite ».

Exemple.

Les formules ∀X∃F(p ∨ q) et ∃F∀G(∃(p U ¬(q ∧ r))) sont syntaxiquement

valides, alors que ∃FGp, ∃(p U q)∀Gp et ∀¬(p U q) ne le sont pas.
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 56

Remarque.

Nous utilisons les symboles X, F et G plutôt que les symboles , ♢ et □

utlisés dans d’autres ouvrages comme [BK08].

5.2 Sémantique
Contrairement à LTL, la sémantique d’une formule CTL dépend d’un système,
et donc pas seulement de AP. Soit T = (S, − →, I, AP, L) une structure de Kripke.
Nous associons un sens formel aux formules CTL en fonction de T . Les formules
d’état sont interprétées sur les états S et les formules de chemin sur les chemins
infinis de T .
Pour tout état s ∈ S, nous disons que:

s |= vrai,
déf
s |= p ⇐⇒ p ∈ L(s),
déf
s |= ¬Φ ⇐⇒ ¬(s |= Φ),
déf
s |= Φ1 ∧ Φ2 ⇐⇒ (s |= Φ1 ) ∧ (s |= Φ2 ),
déf
s |= ∃φ ⇐⇒ σ |= φ pour un certain chemin infini de T débutant en s,
déf
s |= ∀φ ⇐⇒ σ |= φ pour tout chemin infini de T débutant en s.

Pour tout chemin infini σ de T , nous disons que:

déf
σ |= XΦ ⇐⇒ σ(1) |= Φ,
déf
σ |= Φ1 U Φ2 ⇐⇒ ∃j ≥ 0 : [(∀0 ≤ i < j : σ(i) |= Φ1 ) ∧ (σ(j) |= Φ2 )] .

Remarque.

Contrairement à LTL, l’opérateur U ne raisonne pas sur des suffixes infi-

nis σ[0..], σ[1..], . . . , σ[j..], mais bien sur des états σ(0), σ(1), . . . , σ(j).

En particulier, pour tout état s et toute formule d’état Φ, nous avons:

s |= ∃FΦ ⇐⇒ ∃ chemin σ débutant en s tel que ∃j ≥ 0 : σ(j) |= Φ,

s |= ∀FΦ ⇐⇒ ∀ chemin σ débutant en s tel que ∃j ≥ 0 : σ(j) |= Φ,
s |= ∃GΦ ⇐⇒ ∃ chemin σ débutant en s tel que ∀j ≥ 0 : σ(j) |= Φ,
s |= ∀GΦ ⇐⇒ ∀ chemin σ débutant en s tel que ∀j ≥ 0 : σ(j) |= Φ.

L’intuition derrière la sémantique des formules CTL est illustrée à la figure 5.2.
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 57

∃Fp: ∃Gp: ∃(p U q):

∀Fp: ∀Gp: ∀(p U q):

Figure 5.2 – Illustration de la sémantique de CTL. Chaque arborescence cor-

respond à l’arbre de calcul d’une structure de Kripke. Les états pleins (en noir)
satisfont p et les états hachurés (en magenta) satisfont q.

Exemple.

Soit T la structure de Kripke illustrée à la figure 5.1. Nous avons:

s0 |= ∃Fq, s0 ̸|= ∀Fq,

s0 |= ∃Gp, s0 ̸|= ∀Gp,
s0 |= ∃(p U q), s0 ̸|= ∀(p U q),
s0 |= ∀G ∃F(p ∧ q), s0 ̸|= ∃G ∀F(p ∧ q).

5.3 Propriétés d’un système

Soient T = (S, −→, I, AP, L) une structure de Kripke et Φ une formule CTL sur
propositions atomiques AP. L’ensemble des états de T qui satisfont Φ est dénoté:
JΦK := {s ∈ S : s |= Φ}.
Nous disons que T satisfait Φ, dénoté T |= Φ ssi I ⊆ JΦK. Autrement dit:
déf
T |= Φ ⇐⇒ ∀s0 ∈ I s0 |= Φ.
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 58

Exemple.

Considérons cette structure de Kripke et ces formules tirées de [BK08,

ex. 6.7].
{p} {p, q} {p}

s0 s1 s3

{q}

s2

Nous avons:

T |= ∃Xp T ̸|= ∀Gp

T ̸|= ∀Xp T |= ∃F∃Gp
T |= ∃Gp T |= ∀(p U q)

5.4 Équivalences
Nous disons que deux formules CTL Φ1 et Φ2 sont équivalentes, dénoté Φ1 ≡
Φ2 , si JΦ1 K = JΦ2 K pour toute structure de Kripke. Ainsi, deux formules sont
équivalentes si elles ne peuvent pas être distinguées par une structure de Kripke.
Nous répertorions quelques équivalences entre formules CTL qui peuvent
simplifier la spécification ou l’analyse de propriétés.

5.4.1 Distributivité
Les opérateurs temporels quantifiés se distribuent de cette façon sur les opéra-
teurs logiques:

∃F(Φ1 ∨ Φ2 ) ≡ (∃FΦ1 ) ∨ (∃FΦ2 ),

∀G(Φ1 ∧ Φ2 ) ≡ (∀GΦ1 ) ∧ (∀GΦ2 ).

Démontrons l’une de ces équivalences:

Proposition 6. ∃F(Φ1 ∨ Φ2 ) ≡ (∃FΦ1 ) ∨ (∃FΦ2 )

Démonstration. Soient T = (S, −→, I, AP, L) une structure de Kripke, s ∈ S un

état de T , et X l’ensemble des chemins infinis de T qui débutent en s. Nous
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 59

avons:

s |= ∃F(Φ1 ∨ Φ2 ) ⇐⇒ s |= ∃(vrai U (Φ1 ∨ Φ2 ))

⇐⇒ ∃σ ∈ X : σ |= (vrai U (Φ1 ∨ Φ2 ))
⇐⇒ ∃σ ∈ X : ∃j ≥ 0 : σ(j) |= (Φ1 ∨ Φ2 )
⇐⇒ ∃σ ∈ X : ∃j ≥ 0 : (σ(j) |= Φ1 ) ∨ (σ(j) |= Φ2 )
⇐⇒ ∃σ ∈ X : ∃j ≥ 0 : (σ(j) |= Φ1 ) ∨
∃σ ∈ X : ∃j ≥ 0 : (σ(j) |= Φ2 )
⇐⇒ ∃σ ∈ X : σ |= (vrai U Φ1 ) ∨
∃σ ∈ X : σ |= (vrai U Φ2 )
⇐⇒ s |= ∃FΦ1 ∨ s |= ∃FΦ2
⇐⇒ s |= ∃FΦ1 ∨ ∃FΦ2 .

Remarque.

Notons qu’en général l’inverse n’est pas vrai:

∀F(Φ1 ∨ Φ2 ) ̸≡ (∀FΦ1 ) ∨ (∀FΦ2 ),

∃G(Φ1 ∧ Φ2 ) ̸≡ (∃GΦ1 ) ∧ (∃GΦ2 ).

5.4.2 Dualité
La négation interagit de cette façon avec les opérateurs temporels quantifiés:

¬∃XΦ ≡ ∀X¬Φ,
¬∀XΦ ≡ ∃X¬Φ,
¬∃GΦ ≡ ∀F¬Φ,
¬∀GΦ ≡ ∃F¬Φ.

5.4.3 Idempotence
Les opérateurs temporels quantifiés satisfont ces règles d’idempotence:

∀G ∀GΦ ≡ ∀GΦ,
∀F ∀FΦ ≡ ∀FΦ,
∃G ∃GΦ ≡ ∃GΦ,
∃F ∃FΦ ≡ ∃FΦ.
CHAPITRE 5. LOGIQUE TEMPORELLE ARBORESCENTE (CTL) 60

5.5 Exercices
5.1) Considérons la structure de Kripke illustrée à l’exemple de la section 5.3. ?
Satisfait-elle ces formules?
a) ∃(p U (¬p ∧ ∃(¬p U q)));
b) ∃(p U (¬p ∧ ∀(¬p U q)));
c) ∀(p U (¬p ∧ ∃(¬p U q)));
d) ∀(p U (¬p ∧ ∀(¬p U q))).

5.2) Montrez que ces formules CTL ne sont généralement pas équivalentes: ?
a) ∀F(Φ1 ∨ Φ2 ) ̸≡ (∀FΦ1 ) ∨ (∀FΦ2 ),
b) ∃G(Φ1 ∧ Φ2 ) ̸≡ (∃GΦ1 ) ∧ (∃GΦ2 ),
c) ¬∃(Φ1 U Φ2 ) ̸≡ ∀((¬Φ1 ) U (¬Φ2 )).

5.3) Répondez à l’exemple 6.6 de [BK08] (sera probablement fait en classe).

5.4) Nous disons qu’une formule LTL φ et une formule CTL Φ sont équivalentes, ?
dénoté φ ≡ Φ, lorsque T |= φ ⇐⇒ T |= Φ pour toute structure de Kripke
T . Montrez que ces formules ne sont pas équivalentes:
a) φ := FGp et Φ := ∀F∀Gp
b) φ := FXp et Φ := ∀F∀Xp

5.5) Montrez maintenant que GFp ≡ ∀G∀Fp. ?

5.6) Dites si cette structure de Kripke satisfait les formules CTL ci-dessous: ?

{p} {p, q}

s0 s1

s2 s3

{q} ∅

a) ∀F∃Gp
b) ∀G∃X∀F(p ∧ q)
c) ∃[(¬(p ∧ q)) U (∀Xp)]
 6
Vérification algorithmique de formules CTL

Dans ce chapitre, nous présentons une approche afin d’automatiser la vérifica-

tion de formules CTL. Celle-ci s’appuie sur des manipulations d’ensembles et de
calculs de points fixes. D’un point de vue calculatoire, la vérification sera plus
simple que pour LTL: elle est polynomiale plutôt qu’exponentielle.
L’approche générale consiste à déterminer si T |= Φ, où T = (S, −
→, I, AP, L)
est une structure de Kripke et Φ une formule CTL, en calculant JΦ′ K récursive-
ment pour chaque sous-formule Φ′ de Φ, jusqu’à l’obtention de JΦK. Le calcul de
ce dernier permet finalement de tester I ⊆ JΦK. Par exemple, pour la formule
Φ = ∃Xp∧∃(q U ∃G¬r), nous calculerons récursivement les ensembles suivants:

1. JpK, 5. J∃G¬rK,
2. JqK, 6. J∃XpK,
3. JrK, 7. J∃(q U (∃G¬r))K,
4. J¬rK, 8. JΦK.

Autrement dit, nous procéderons par induction structurelle sur l’arbre syn-
taxique de Φ, c.-à-d. en calculant l’ensemble d’états de chacun de ces sommets
récursivement (du bas vers le haut):

Φ = ∃Xp ∧ ∃(q U ∃G¬r)

∃Xp ∃(q U ∃G¬r)

p q ∃G¬r

¬r

61
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 62

6.1 Forme normale existentielle

Nous décrivons d’abord une certaine forme normale qui facilite le calcul récursif
des ensembles d’états. Afin d’effectuer la vérification T |= Φ, nous supposerons
que Φ est d’abord mise dans cette forme normale.
Une formule CTL est dite en forme normale existentielle si elle s’exprime avec
la grammaire suivante:

Φ ::= vrai | p | Φ ∧ Φ | ¬Φ | ∃XΦ | ∃GΦ | ∃(Φ U Φ)

La sémantique d’une telle formule demeure la même que celle introduite au

chapitre précédent; il ne s’agit que d’une restriction syntaxique.
Toute formule CTL peut être mise en forme normale en appliquant récursi-
vement ces équivalences:

∃FΦ ≡ ∃(vrai U Φ)
∀XΦ ≡ ¬∃X¬Φ
∀FΦ ≡ ¬∃G¬Φ
∀GΦ ≡ ¬∃(vrai U ¬Φ)
∀(Φ1 U Φ2 ) ≡ (¬∃G¬Φ2 ) ∧ (¬∃(¬Φ2 U (¬Φ1 ∧ ¬Φ2 )))

Exemple.

Considérons la formule Φ = ∀F∃[(¬(p∧∀Gq)) U (∀Xp)]. La mise en forme

normale existentielle de Φ mène à:

Φ = ∀F∃[(¬(p ∧ ∀Gq)) U (∀Xp)]

≡ ∀F∃[(¬(p ∧ ∀Gq)) U (¬∃X¬p)]
≡ ∀F∃[(¬(p ∧ ¬∃[vrai U ¬q])) U (¬∃X¬p)]
≡ ¬∃G¬∃[(¬(p ∧ ¬∃[vrai U ¬q])) U (¬∃X¬p)].

6.2 Calcul des états

Cherchons à calculer JΦK ⊆ S, où Φ est une formule CTL et S est l’ensemble des
états de la structure de Kripke sous considération.
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 63

6.2.1 Logique propositionnelle et opérateur temporel X

Les règles suivantes découlent directement de la sémantique de la logique:

JvraiK = S,

JpK = {s ∈ S : p ∈ L(s)},
JΦ1 ∧ Φ2 K = JΦ1 K ∩ JΦ2 K,
J¬ΦK = S \ JΦK.

Remarquons que s0 |= ∃XΦ ssi il existe un chemin infini s0 s1 · · · tel que

s1 |= Φ. Ainsi, s0 |= ∃XΦ ssi s0 possède au moins un successeur s1 qui satisfait
Φ (en supposant que tous les chemins soient infinis). Ainsi, nous avons la règle:

J∃XΦK = {s ∈ S : Post(s) ∩ JΦK ̸= ∅}.

6.2.2 Opérateur temporel G

Les formules de la forme « ∃GΦ » et « ∃(Φ1 U Φ2 ) » sont plus complexes car elles
ne dépendent pas de critères locaux. Considérons d’abord la première forme.
Posons T := J∃GΦK. Nous avons s0 ∈ T ssi il existe un chemin infini s0 s1 · · · tel
que si |= Φ pour tout i ∈ N. Ainsi, si s0 ∈ T , alors il existe s1 ∈ Post(s0 ) tel que
s1 ∈ T , puis un état s2 ∈ Post(s1 ) tel que s2 ∈ T et ainsi de suite. Ainsi, tous les
états de T doivent satisfaire la propriété Post(s) ∩ T ̸= ∅. Plus formellement:
Proposition 7. L’ensemble J∃GΦK est le plus grand ensemble T ⊆ S tel que T ⊆
JΦK et s ∈ T =⇒ Post(s) ∩ T ̸= ∅.

Démonstration. Montrons d’abord que T est bien défini, c.-à-d. qu’il existe bien
un plus grand ensemble. Pour ce faire, il suffit de démontrer que les ensembles
qui satisfont la propriété sont clos sous union. Soient T1 , T2 ⊆ JΦK tels que

s ∈ T1 =⇒ Post(s) ∩ T1 ̸= ∅,
s ∈ T2 =⇒ Post(s) ∩ T2 ̸= ∅.

Posons T ′ := T1 ∪ T2 . Soit s ∈ T ′ . Nous avons s ∈ Ti pour un certain i ∈ {1, 2}.

Ainsi, Post(s) ∩ Ti ̸= ∅ et par conséquent Post(s) ∩ T ′ ̸= ∅.
Montrons maintenant que J∃GΦK = T .
J∃GΦK ⊆ T . Soit s0 ∈ J∃GΦK. Par définition, il existe un chemin infini s0 s1 · · ·
tel que si |= Φ pour tout i ∈ N. Posons S ′ := {si : i ∈ N}. Si S ′ ⊆ T , alors nous
avons terminé puisqu’en particulier s0 ∈ T . Afin d’obtenir une contradiction,
supposons que S ′ ̸⊆ T . Posons T ′ := T ∪ S ′ . Remarquons que, par définition de
T et S ′ , l’ensemble T ′ satisfait:

T ′ ⊆ JΦK et s ∈ T ′ =⇒ Post(s) ∩ T ′ ̸= ∅.

Cela contredit la maximalité de T puisque T ′ ⊃ T . Ainsi, S ′ ⊆ T .

CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 64

T ⊆ J∃GΦK. Soit s0 ∈ T . Par définition de T , nous avons s0 |= Φ et il existe

s1 ∈ Post(s0 ) tel que s1 ∈ T . Par le même raisonnement, nous avons s1 |= Φ et il
existe s2 ∈ Post(s1 ) tel que s2 ∈ T . En continuant ce processus, nous obtenons
un chemin infini s0 s1 s2 · · · tel que si ∈ T pour tout i ∈ N, ce qui implique
s0 ∈ J∃GΦK car T ⊆ JΦK.

L’algorithme 5 calcule l’ensemble J∃GΦK en exploitant la caractérisation de

plus grand point fixe de la proposition 7.

Algorithme 5 : Calcule J∃GΦK à partir de JΦK.

Entrées : ensemble JΦK
Sorties : ensemble J∃GΦK
T ← JΦK // États pouvant satisfaire ∃GΦ
// Raffiner T
tant que ∃s ∈ T : Post(s) ∩ T = ∅
retirer s de T
retourner T

Exemple.

Exécutons l’algorithme 5 sur la formule Φ = ∃Gp et la structure de Kripke

ci-dessous. Nous marquons les sommets qui appartiennent à T au début
de chaque itération:
∅ {p} {p, q} {q}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {p, q} {p} ∅

∅ {p} {p, q} {q}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {p, q} {p} ∅

CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 65

∅ {p} {p, q} {q}

s0 s2 s4 s6

s1 s3 s5 s7

{p} {p, q} {p} ∅

Ainsi, JΦK = {s1 , s2 , s3 }. Le système ne satisfait donc pas Φ car s0 ̸∈ JΦK.

6.2.3 Opérateur temporel U

Considérons maintenant les formules de la forme « Φ = ∃(Φ1 U Φ2 ) ». Posons
T := JΦK. Par définition, s0 ∈ T ssi il existe un chemin infini σ tel que

∃j ∈ N : ∀0 ≤ i < j : σ(i) |= Φ1 et σ(j) |= Φ2 .

Ainsi, s0 ∈ T ssi il y a un chemin infini s0 s1 · · · sj tel que sj ∈ JΦ2 K et si ∈ JΦ1 K

pour tout 0 ≤ i < j. Il suffit donc d’identifier d’abord les états de JΦ2 K, puis tous
leurs prédécesseurs (immédiats ou non) qui peuvent les atteindre sans quitter
JΦ1 K. Plus formellement:
Proposition 8. L’ensemble J∃(Φ1 U Φ2 )K est le plus petit ensemble T ⊆ S tel que
JΦ2 K ⊆ T et (s ∈ JΦ1 K ∧ Post(s) ∩ T ̸= ∅) =⇒ s ∈ T .

L’algorithme 6 calcule l’ensemble J∃(Φ1 U Φ2 )K en exploitant la caractérisa-

tion de plus petit point fixe de la proposition 8.

Algorithme 6 : Calcule J∃(Φ1 U Φ2 )K à partir de JΦ1 K et JΦ2 K.

Entrées : ensembles JΦ1 K et JΦ2 K
Sorties : ensemble J∃(Φ1 U Φ2 )K
T ← JΦ2 K // États qui satisfont immédiatement ∃(Φ1 U Φ2 )
C ← JΦ1 K \ T // États pouvant aussi satisfaire ∃(Φ1 U Φ2 )
// Élargir T à partir de C
tant que ∃s ∈ C : Post(s) ∩ T ̸= ∅
ajouter s à T
retirer s de C
retourner T
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 66

Exemple.

Exécutons l’algorithme 6 sur la formule Φ = ∃(p U q) et la structure

de Kripke ci-dessous. Nous marquons les sommets qui font partie de T
(plein) et C (rayé) au début de chaque itération:
{p} ∅ {p, q} {p}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {q} {p} ∅

{p} ∅ {p, q} {p}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {q} {p} ∅

{p} ∅ {p, q} {p}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {q} {p} ∅

{p} ∅ {p, q} {p}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {q} {p} ∅

{p} ∅ {p, q} {p}
s0 s2 s4 s6

s1 s3 s5 s7

{p} {q} {p} ∅

Ainsi, JΦK = {s0 , s1 , s3 , s4 , s5 }. Le système satisfait donc Φ car s0 ∈ JΦK.

CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 67

6.2.4 Algorithme complet

L’algorithme 7 regroupe toutes les caractérisations décrites précédemment afin
de vérifier automatiquement si une structure de Kripke satisfait une certaine
spécification CTL. Comme une implémentation naïve de chaque étape prend un
temps quadratique, et que le nombre de sous-formules est linéaire par rapport
à la taille de la formule initiale, l’algorithme fonctionne en temps cubique dans
le pire cas.

Algorithme 7 : Algorithme de vérification.

Entrées : structure de Kripke T = (S, −
→, I, AP, L) et formule CTL Φ
Sorties : T |= Φ?
états(Φ):
si Φ = vrai alors retourner S
sinon si Φ = p ∈ AP alors retourner {s ∈ S : p ∈ L(s)}
sinon si Φ = Φ1 ∧ Φ2 alors retourner états(Φ1 ) ∩ états(Φ2 )
sinon si Φ = ¬Φ′ alors retourner S \ états(Φ′ )
sinon si Φ = ∃XΦ′ alors
T ← états(Φ′ )
retourner {s ∈ S : Post(s) ∩ T ̸= ∅}
sinon si Φ = ∃GΦ′ alors
T ′ ← états(Φ′ )
retourner T obtenu par l’algorithme 5 sur entrée T ′
sinon si Φ = ∃(Φ1 U Φ2 ) alors
T1 ← états(Φ1 )
T2 ← états(Φ2 )
retourner T obtenu par l’algorithme 6 sur entrée (T1 , T2 )
normaliser Φ
T ← états(Φ)
retourner I ⊆ T

6.2.5 Optimisations
Il est possible d’adapter l’algorithme 7 afin d’opérer directement sur une formule
CTL générale, plutôt que de la mettre en forme normale existentielle. De plus,
chaque étape s’implémente en temps linéaire plutôt que quadratique. Ainsi, la
vérification d’une formule CTL Φ requiert un temps de O((|S| + |− →|) · |Φ|) dans
le pire cas. En particulier, pour une formule de taille constante, la vérification
s’effectue en temps linéaire.
Nous présentons deux telles optimisations afin d’illustrer les idées générales.
Voyons d’abord comment calculer J∃GΦK en temps linéaire à partir de JΦK. Soit
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 68

GΦ le graphe induit par la structure de Kripke restreinte à ses états qui appar-
tiennent à JΦK. Remarquons que

s |= ∃GΦ ⇐⇒ s ∈ GΦ et s peut atteindre une composante

fortement connexe non triviale de GΦ , (6.1)

où « non triviale » signifie que la composante contient au moins une transition.

Ainsi, on peut calculer J∃GΦK en identifiant les composantes fortement connexes
de GΦ (ordonnées topologiquement). Cette opération se réalise en temps li-
néaire, par ex. à l’aide de l’algorithme de Tarjan ou de Kosaraju.

Exemple.

Considérons la structure de Kripke ci-dessous (gauche) et la formule

Φ = ∃Gq. Le sous-graphe Gq illustré ci-dessous (droite) est constitué
des composantes fortement connexes {s0 , s2 } et {s1 }:
{p, q} {p, q}
s0 s2 s0 s2

s1 s3 s1

{q} {p}

Par l’équivalence (6.1), JΦK = {s0 , s1 , s2 }. En effet, la composante {s0 , s2 }

est non triviale, et la composante triviale {s1 } peut atteindre une com-
posante non triviale. La structure satisfait donc Φ.

Montrons que l’équivalence décrite est correcte:

Proposition 9. L’équivalence (6.1) est valide.

Démonstration. ⇒) Soit s0 ∈ J∃GΦK. Il existe un chemin infini s0 s1 · · · tel que

si |= Φ pour tout i ∈ N. Tous les états de ce chemin appartiennent au sous-
graphe GΦ . De plus, comme le nombre d’états est fini et que le chemin est infini,
il existe des indices i < j tels que si = sj . Par conséquent,
∗ +
s0 −
→ si −
→ si ,

ce qui signifie que s0 peut atteindre la composante fortement connexe de si , qui

n’est pas triviale puisqu’elle possède au moins une transition (car i < j).
⇐) Soit s0 ∈ GΦ un état qui peut atteindre une composante fortement
connexe non triviale de GΦ . Soit s0 s1 · · · si un tel chemin fini. Comme la com-
posante de si est non triviale, si peut s’atteindre via un chemin non vide. Autre-
ment dit, il existe un chemin non vide si si+1 · · · sj où sj = si . Ainsi, le chemin
infini s0 s1 · · · si−1 (si si+1 · · · sj )ω montre que s0 |= ∃GΦ.
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 69

Voyons maintenant comment gérer une formule de la forme ∀GΦ sans passer
par la forme normale existentielle. Rappelons que s |= ∀GΦ ssi tous les chemins
qui débutent dans l’état s satisfont Φ. Ainsi, on peut initialement considérer tous
les états de JΦK, puis itérativement raffiner l’ensemble en retirant les états qui
possèdent au moins un successeur qui n’en fait pas partie. Cette procédure est
décrite à l’algorithme 8.

Algorithme 8 : Calcule J∀GΦK à partir de JΦK.

Entrées : ensemble JΦK
Sorties : ensemble J∀GΦK
T ← JΦK // États pouvant satisfaire ∀GΦ
// Raffiner T
tant que ∃s ∈ T : Post(s) ̸⊆ T
retirer s de T
retourner T

Exemple.

Exécutons l’algorithme 8 sur la formule Φ = ∀Gq et la structure de Kripke

ci-dessous. Nous marquons les sommets qui appartiennent à T au début
de chaque itération:
{p, q} {p, q} {q}
s0 s2 s4

s1 s3 s5

{q} {p} {q}

{p, q} {p, q} {q}
s0 s2 s4

s1 s3 s5

{q} {p} {q}

CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 70

{p, q} {p, q} {q}

s0 s2 s4

s1 s3 s5

{q} {p} {q}

Ainsi, JΦK = {s2 , s4 , s5 }. Le système ne satisfait donc pas Φ car s0 ̸∈ JΦK.

6.2.6 Outils
Il existe un certain nombre d’outils de vérifications pour CTL. En particulier, le
logiciel de vérification NuSMV, développé conjointement à l’Université Carnegie-
Mellon, de Gênes et de Trente, permet de vérifier des spécifications CTL (et LTL)
de systèmes finis dans un langage de description de haut niveau. NuSMV est un
descendant de SMV, un outil de vérification historique qui a notamment per-
mis de vérifier formellement des composantes matérielles de grande taille et
d’identifier des bogues dans le standard IEEE Future+.
Voici un exemple de modélisation d’une structure de Kripke et de la propriété
∀X(p ∧ ∃(p U q)):

MODULE main
VAR
etat : {s0, s1, s2, s3};
ASSIGN
init(etat) := s0;
next(etat) :=
case
etat = s0 : {s1, s2};
etat = s1 : s3;
etat = s2 : {s0, s1, s2};
etat = s3 : s2;
esac;
DEFINE
p := etat = s0 | etat = s1 | etat = s2;
q := etat = s1;

SPEC
AX (p & E [p U q])

Cet exemple utilise le langage de NuSMV afin de représenter une structure

de Kripke abstraite. En pratique, il est plus utile d’utiliser le langage de haut
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 71

niveau afin de décrire des structures plus complexes, qui sont ensuite converties
en structures de Kripke à l’interne (comme pour Spin et Promela).

Remarque.

Il existe d’autres applications à CTL. Par exemple, jusqu’à récemment un

module de l’analyseur statique Infer de Facebook permettait de raisonner
sur les arbres de syntaxe abstraite de différents langages de programma-
tion à l’aide d’une variante de CTL.
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 72

6.3 Exercices
6.1) Calculer algorithmiquement les états de la structure de Kripke ci-dessous ?
qui satisfont ces propriétés:
a) Φ1 := ∃F(p ↔ r ∧ p ⊕ q)
b) Φ2 := ∃Gq
c) ∀X(¬Φ1 ∨ ¬Φ2 )

{r} ∅
s6 s7

{p, q, r} {p}
s0 s3
s4 s5

{q} {p, r}

s2 s1

{q, r} {p, q}

(adapté de [BK08, ex. 6.26])

6.2) Expliquez pourquoi la mise en forme normale existentielle peut mener à ?

une explosion exponentielle de la taille d’une formule.

6.3) Décrivez des algorithmes afin de vérifier directement des formules de la ?

forme ∃FΦ, ∀FΦ, ∀XΦ et ∀(Φ1 U Φ2 ).

6.4) Vérifiez les propriétés de la structure Kripke décrite par [Link] et 

confirmez votre résultat avec NuSMV.

6.5) Spécifiez les propriétés de la pile modélisée par pile_sans_solutions.smv 

et vérifiez-les avec NuSMV. ?
6.6) ⋆ Démontrez la proposition 8.

6.7) Comme pour LTL, certaines spécifications ne font du sens en pratique que ?
sous hypothèse d’une notion d’équité. Contrairement à LTL, il est générale-
ment impossible de spécifier directement l’équité en CTL. Une vérification
qui tient compte de l’équité requiert donc de nouveaux algorithmes.
Soient S1 , . . . , Sn ⊆ S des ensembles d’états. Nous disons qu’un chemin
infini s0 s1 · · · est équitable s’il visite chaque ensemble Si infiniment sou-
vent. De plus, nous disons que:
CHAPITRE 6. VÉRIFICATION ALGORITHMIQUE DE FORMULES CTL 73

— s |= ∃équit GΦ ssi il existe un chemin infini équitable qui débute en s

et qui satisfait GΦ.
— s |= ∃équit (Φ1 U Φ2 ) ssi il existe un chemin infini équitable qui débute
en s et qui satisfait Φ1 U Φ2 .
a) Donnez un algorithme qui calcule J∃équit GΦK étant donné JΦK. Pensez
d’abord au cas où n = 1, puis généralisez votre approche à n > 1.
b) Exprimez ∃équit (Φ1 U Φ2 ) à l’aide de ∃U et ∃équit G. Déduisez-en un
algorithme qui calcule J∃équit (Φ1 U Φ2 )K.

6.8) Expliquez comment identifier algorithmiquement, en temps linéaire, tous

les sommets d’un graphe qui peuvent atteindre une composante fortement
connexe non triviale.
 7
Vérification symbolique : diagrammes de décision
binaire

Au chapitre 6, nous avons vu qu’il est possible de vérifier qu’un système T satis-
fait une spécification CTL Φ en temps polynomial, plus précisément O((#états+
#transitions)·|Φ|). Toutefois, les algorithmes de vérification manipulent des en-
sembles d’états souvent gigantesques dû à l’explosion combinatoire causée par
le passage d’un modèle de haut niveau vers une structure de Kripke. Ainsi, une
représentation « énumérative », où tous les éléments d’un ensemble sont explici-
tement stockés, s’avère peu efficace en pratique. Dans ce chapitre, nous voyons
une structure de données qui représente des ensembles d’états de façon symbo-
lique. Une telle représentation permet de réduire la quantité de données tout
en offrant généralement de bonnes propriétés algorithmiques. Elle est utilisée
à l’interne, par exemple, par l’outil de vérification NuSMV. Ce chapitre se base
fortement sur l’excellente présentation de [And98]. En particulier, nous suivons
donc sa terminologie anglophone afin d’en faciliter sa lecture.

x1

x2 x2

x3 x3 x3 x3

1 1 0 0 1 1 0 1

Figure 7.1 – Arbre de décision de l’expression booléenne (x1 ∨¬x2 )∧(¬x2 ∨x3 ).
Une arête tiretée (resp. pleine) sortant d’un sommet xi indique la décision où la
variable xi prend la valeur faux (resp. vrai). Les sommets 0 et 1 correspondent
respectivement aux valeurs booléennes faux et vrai.

74
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 75
À titre d’exemple, considérons une structure de Kripke dont l’ensemble des
états est S = {s0 , s1 , . . . , s7 }, et telle que JpK = {s0 , s1 , s4 , s5 , s7 }. Chaque état
de S peut être représenté par la représentation binaire de son indice. Ainsi,
JpK = {000, 001, 100, 101, 111}
= {x1 x2 x3 ∈ {0, 1}3 : (x1 ∨ ¬x2 ) ∧ (¬x2 ∨ x3 )}.
L’ensemble JpK se représente donc symboliquement par l’expression (x1 ∨¬x2 )∧
(¬x2 ∨ x3 ), ou alternativement par l’arbre de décision illustré à la figure 7.1.
Ces deux représentations ne sont pas pratiques parce que d’une part les ex-
pressions booléennes souffrent d’une complexité calculatoire élevée, et d’autre
part de tels arbres de décision sont de taille 2n où n est le nombre de variables.
Cependant, un arbre de décision contient généralement une grande quantité de
redondance. Par exemple, l’arbre de la figure 7.1 possède plusieurs occurrences
des sommets 0 et 1, deux sous-arbres isomorphes étiquetés par x3 , en plus de
choix inutiles: par ex. lorsque x1 = x2 = faux, le résultat est vrai indépendam-
ment de la valeur de x3 .

x1

x2 x2

x3

0 1

Figure 7.2 – Diagramme de décision binaire de l’expression (x1 ∨¬x2 )∧(¬x2 ∨

x3 ) obtenu à partir de l’arbre de décision de la figure 7.1.

En éliminant cette redonance de l’arbre de décision, nous obtenons un graphe

dirigé acyclique équivalent tel qu’illustré à la figure 7.2. Ce graphe résultant est
un diagramme de décision binaire. Plus formellement:
Définition 1. Un diagramme de décision binaire (réduit et ordonné), abrégé par
le terme anglophone BDD, est un graphe dirigé acyclique B tel que:
— B possède des variables ordonnées x1 < x2 < · · · < xn ;
— B contient deux sommets spéciaux, nommés 0 et 1, qui ne possèdent pas
de succeseurs;
— chaque autre sommet u de B est associé à une variable var(u), et possède
deux successeurs lo(u) et hi(u);
— chaque chemin de B respecte l’ordre des variables, autrement dit:
u−
→ v =⇒ var(u) < var(v);
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 76
— chaque sommet est unique, autrement dit:

(var(u) = var(v) ∧ lo(u) = lo(v) ∧ hi(u) = hi(v)) =⇒ u = v;

— les sommets ne sont pas redondants, autrement dit: lo(u) ̸= hi(u).

Chaque sommet u d’un BDD à n variables représente naturellement une ex-
pression booléenne fu : {0, 1}n → {0, 1}, où la valeur de fu (x1 , . . . , xn ) est ob-
tenue en suivant le chemin associé aux variables de u vers le sommet 0 ou 1.
Ainsi, un BDD représente plusieurs expressions booléennes à la fois.

5
x1
4 3
x2 x2
2
x3

0 1

Figure 7.3 – Exemple d’un BDD sur trois variables x1 < x2 < x3 .

Exemple.

Pour le BDD illustré à la figure 7.3, nous avons:

f0 = faux ≡ ∅,
f1 = vrai ≡ {000, 001, 010, 011, 100, 101, 110, 111},
f2 = x3 ≡ {001, 011, 101, 111},
f3 = ¬x2 ∨ x3 ≡ {000, 001, 100, 101, 011, 111},
f4 = ¬x2 ≡ {000, 001, 100, 101},
f5 = (x1 ∨ ¬x2 ) ∧ (¬x2 ∨ x3 ) ≡ {000, 001, 100, 101, 111}.

Il est possible de démontrer que les BDDs offrent une représentation cano-
nique des fonctions booléennes. Autrement dit, chaque fonction booléenne est
représentée par un unique BDD (pour un ordre fixe des variables). Ainsi:
Lemme 1. Soit t une fonction booléenne sur les variables ordonnées x1 < x2 <
· · · < xn . Il existe un unique sommet de BDD tel que fu = t.
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 77
Remarque.

Certains ouvrages utilisent plutôt le terme multi-BDD pour référer au fait

qu’il n’y a pas de sommet de départ particulier et que chaque sommet
calcule sa propre fonction booléenne.

7.1 Représentation de BDD

Chaque sommet d’un BDD est uniquement déterminé par sa variable et ses deux
successeurs. Ainsi, un BDD peut être stocké sous forme de tableau associatif où
chaque entrée indique cette information.
Par exemple, le BDD de la figure 7.3 se représente par ce tableau:

u var(u) lo(u) hi(u)

5 x1 4 3
4 x2 1 0
3 x2 1 2
2 x3 0 1
1 x∞ — —
0 x∞ — —

Notons que les sommets spéciaux 0 et 1 ne possèdent pas de variable. Nous

pouvons tout de même considérer qu’ils sont étiquetés par une variable artifi-
cielle x∞ plus grande que toutes les autres variables. En pratique, il n’est pas
nécessaire de représenter ces deux entrées explicitement car elles seront tou-
jours les mêmes.

Algorithme 9 : Création d’un sommet de BDD.

Entrées : indice i ∈ [1..n] et sommets ℓ et h
Sorties : sommet u t.q. ¬xi mène à ℓ et xi mène à h
make(i, ℓ, h):
si ℓ = h alors retourner ℓ // Ne pas créer de redondance
sinon si le BDD contient déjà un sommet (xi , ℓ, h) alors
retourner u où u est le sommet associé à (xi , ℓ, h)
sinon
u ← prochain identifiant numérique
ajouter u : (xi , ℓ, h) au BDD
retourner u
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 78
L’ajout d’un nouveau sommet u tel que var(u) = xi , lo(u) = ℓ et hi(u) = h
s’effectue à l’aide de l’algorithme 9. Nous supposons qu’il est possible d’obte-
nir (var(u), lo(u), hi(u)) à partir de u en temps constant, et inversement qu’il
est possible de déterminer l’identifiant d’un sommet étiqueté par (xi , ℓ, h) en
temps constant. En pratique, cette hypothèse se traduit par l’usage de tables de
hachage (bien qu’elles fournissent techniquement un temps constant amorti).

7.2 Construction de BDD

Voyons maintenant comment construire un BDD à partir d’une expression boo-
léenne. Soient t une expression booléenne, b ∈ {0, 1} et xi une variable. Nous
dénotons par t[b/xi ] l’expression booléenne obtenue en remplaçant chaque oc-
currence de xi par b dans l’expression t. Par exemple, (x1 ∨ x2 )[0/x1 ] = x2 et
(x1 ∧ x2 )[0/x1 ] = faux.

Algorithme 10 : Conversion d’une expression booléenne vers un BDD.

Entrées : une expression booléenne t
Sorties : sommet u tel que fu = t
build(t):
build'(t, i):
si t = faux alors retourner 0
sinon si t = vrai alors retourner 1
sinon
v0 ← build'(t[0/xi ], i + 1)
v1 ← build'(t[1/xi ], i + 1)
retourner make(xi , v0 , v1 )
retourner build'(t, 1)

Étant donné une expression booléenne t, l’unique sommet représentant t se

calcule à l’aide de l’algorithme 10. La figure 7.4 montre les sommets obtenus lors
de l’appel de build(x1 ∨¬x2 ) (plein) suivi de l’appel de build(¬x2 ∨x3 ) (rayé).
Les sommets 3 et 5 représentent respectivement les expressions booléennes x1 ∨
¬x2 et ¬x2 ∨x3 . Notons que des appels subséquents à build pourraient réutiliser
certains sommets existants.

7.3 Manipulation de BDD

7.3.1 Opérations logiques binaires
À partir de sommets u1 et u2 , on peut construire un sommet qui représente la
fonction fu1 ⃝ fu2 où ⃝ est une opération logique binaire telle que ∧, ∨ ou ⊕.
Un algorithme qui accomplit cette tâche est décrit à l’algorithme 11. Informelle-
ment, cet algorithme calcule u1 ⃝ u2 en calculant récursivement lo(u1 ) ⃝ lo(u2 )
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 79
⃝
3 ⃝
5
(x1 ∨ ¬x2 , 1) (¬x2 ∨ x3 , 1)
⃝
2 ⃝
1 ⃝
5 ⃝
5
(¬x2 , 2) (vrai, 2) (¬x2 ∨ x3 , 2) (¬x2 ∨ x3 , 2)
⃝
1 ⃝
0 ⃝
1 ⃝
4
(vrai, 3) (faux, 3) (vrai, 3) (x3 , 3)
⃝
0 ⃝
1
⃝
3
(faux, 4) (vrai, 4)
x1
⃝
2 ⃝
5
x2 x2

⃝
4
x3

0 1

Figure 7.4 – Haut gauche: arbre d’appel de build(x1 ∨ ¬x2 ); haut droite: arbre
d’appel de build(¬x2 ∨ x3 ); où x1 < x2 < x3 , et chaque nombre encerclé
indique la valeur retournée par l’appel. Bas: BDD résultant des deux appels.

et hi(u1 ) ⃝ hi(u2 ). Comme deux chemins ne font pas nécessairement des re-
quêtes simultanément aux mêmes variables, certains appels doivent « mettre
un côté en attente » pour que l’autre côté « le ratrappe ».

Algorithme 11 : Calcul d’une opération binaire ⃝.

Entrées : sommets u1 et u2
Sorties : sommet u qui représente fu := fu1 ⃝ fu2
apply⃝(u1 , u2 ):
v1 , ℓ1 , h1 ← var(u1 ), lo(u1 ), hi(u1 )
v2 , ℓ2 , h2 ← var(u2 ), lo(u2 ), hi(u2 )
si u1 ∈ {0, 1} et u2 ∈ {0, 1} alors
retourner u1 ⃝ u2
sinon si v1 < v2 alors // Creuser à gauche
retourner make(v1 , apply⃝(ℓ1 , u2 ), apply⃝(h1 , u2 ))
sinon si v1 > v2 alors // Creuser à droite
retourner make(v2 , apply⃝(u1 , ℓ2 ), apply⃝(u1 , h2 ))
sinon // Creuser des deux côtés
retourner make(v1 , apply⃝(ℓ1 , ℓ2 ), apply⃝(h1 , h2 ))
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 80
Par exemple, supposons que nous désirons obtenir un sommet représentant
la fonction f3 ∧ f5 , où 3 et 5 sont les sommets du BDD de la figure 7.4. Un appel
à apply∧(3, 5) génère le sommet 6, tel que f6 = f3 ∧ f5 , illustré à la figure 7.5.

⃝
6
⃝
6 x1
(3, 5)
⃝
3

⃝
2 ⃝
5 x1
⃝
2 ⃝
5
(2, 5) (1, 5)
x2 x2
⃝
1 ⃝
0 ⃝
1 ⃝
4
⃝
4
(1, 1) (0, 4) (1, 1) (1, 4) x3

⃝
0 ⃝
0 ⃝
0 ⃝
1
(0, 0) (0, 1) (1, 0) (1, 1) 0 1

Figure 7.5 – Gauche: arbre d’appel de apply∧(3, 5) sur le BDD de la figure 7.4;
droite: BDD résultant où f6 = f3 ∧ f5 .

7.3.2 Restriction et quantification existentielle

L’algorithme 12 calcule un sommet u′ tel que fu′ = fu [b/xi ]. Cet algorithme
s’avère utile pour quantifier des variables existentiellement. En effet, pour toute
expression booléenne t, la formule ∃xi ∈ {0, 1} : t(x1 , x2 , . . . , xn ) est équiva-
lente à t[0/xi ] ∨ t[1/xi ]. Ainsi, comme illustré à l’algorithme 13, deux appels à
restrict et un appel à apply implémentent la quantification existentielle.

7.4 Vérification CTL à l’aide de BDD

Les opérations décrites jusqu’ici permettent de représenter et de manipuler des
ensembles d’états satisfaisant des propositions atomiques comme Jp ∧ qK. Ce-
pendant, les opérateurs temporels quantifiés comme ∃X nécessitent également
de raisonner à propos des transitions d’une structure de Kripke.
Considérons la structure de Kripke T illustrée à la figure 7.6. Ses états sont
représentés par s0 = 00, s1 = 01, s2 = 10 et s3 = 11. La relation de transition
−
→ peut donc être représentée sur les variables x1 < x2 < x3 < x4 par:

{0001, 0011, 0101, 0110, 1000, 1100}.

Par exemple, 0110 dénote la transition s1 −

→ s2 .
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 81

Algorithme 12 : Algorithme de restriction d’une variable.

Entrées : un sommet u, un indice i ∈ [1..n] et une valeur b ∈ {0, 1}
Sorties : un sommet u′ qui représente fu′ := fu [b/xi ]
restrict(u, i, b):
restrict'(u):
v ← var(u)
si v > xi alors // Rien faire, xi n'apparaît pas sous u
retourner u
sinon si v < xi alors // Creuser jusqu'à xi
retourner make(v, restrict'(lo(u)), restrict'(hi(u)))
sinon si b = 0 alors // Élaguer branche pleine
retourner restrict'(lo(u))
sinon // Élaguer branche tiretée
retourner restrict'(hi(u))
retourner restrict'(u)

Algorithme 13 : Algorithme de quantification existentielle.

Entrées : un sommet u et un indice i ∈ [1..n]
Sorties : un sommet u′ qui représente fu′ := ∃xi : fu
exists(u, i):
retourner apply∨(restrict(u, i, 0), restrict(u, i, 1))

{q} {p, q}

s0 s1

s3 s2

∅ {q}

Figure 7.6 – Une structure de Kripke.

∪ Cherchons à déterminer ∪ si T |= ∃Xp. Soit M ⊆ S. Définissons Post(M ) :=

s∈M Post(s) et Pre(M ) := s∈M Pre(s). Observons que:

Post(M ) = {t : ∃s (s, t) ∈ (−
→ ∩ (M × S))},
Pre(M ) = {s : ∃t (s, t) ∈ (−
→ ∩ (S × M ))}.
Notons que J∃XpK = Pre(JpK). Ainsi, nous devons calculer l’ensemble:
{s : ∃t (s, t) ∈ (−
→ ∩ (S × JpK))}.
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 82
La représentation ensembliste de −→ ainsi que l’ensemble S × JpK = {0001,
0101, 1001, 1101} sont représentés respectivement par les sommets 8 (rayé) et
3 (plein) du BDD de la figure 7.7. Ces sommets s’obtiennent avec deux appels à
build. L’ensemble −→ ∩ (S ×JpK) est représenté par le sommet 9 de la figure 7.7.
Ce sommet est obtenu par un appel à apply∧(3, 8).

⃝
8
x1

⃝
6
x2
⃝
9
x1
⃝
3 ⃝
5 ⃝
7
x3 x3 x3
⃝
10
x1
⃝
2 ⃝
4
x4 x4
⃝
11
x1

Figure 7.7 – BDD partiel obtenu lors de la vérification de T |= ∃Xp. Les arêtes
vers le sommet 0 sont omises par souci de lisibilité.

Nous devons maintenant calculer le résultat de la quantification existen-

tielle « ∃t ». Puisque t se situe du côté droit de la paire (s, t), cela correspond à
une quantification existentielle de x3 et x4 . Autrement dit, nous devons calculer
∃x4 (∃x3 f9 ). Ce calcul se fait en deux étapes à l’aide de exists(exists(9, 3), 4).
Ces appels retournent le nouveau sommet 11 illustré à la figure 7.7.
Le sommet 11 représente donc l’ensemble Pre(JpK) sur les variables x1 et x2 .
Rappelons le critère afin de satisfaire ∃Xp:

T |= ∃Xp ⇐⇒ I ⊆ PreJpK

⇐⇒ I ∩ PreJpK = ∅.

Afin de compléter la vérification, il demeure donc de:

— calculer un sommet u représentant l’ensemble I;
— calculer un sommet v représentant ¬f11 ;
— calculer un sommet w représentant fu ∧ fv ;
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 83
— tester si fw ≡ faux.
Par le lemme 1, le test fw ≡ faux correspond à vérifier si w = 0. Le calcul de
¬f11 s’effectue quant à lui par un algorithme récursif simple laissé en exercice.
Alternativement, nous pouvons procéder sans implémentation de la néga-
tion. En effet, tester une inclusion A ⊆ B correspond à tester si la fonction boo-
léenne fA → fB est une tautotologie, où fA et fB sont les fonctions booléennes
qui correspondent aux ensembles A et B. L’implication peut être calculée par
l’algorithme 11 (apply), et le test de tautotologie correspond à vérifier si le
sommet obtenu est 1.

7.5 Complexité calculatoire

Pour tout sommet u d’un BDD, nous dénotons par |u| le nombre de sommets
accessibles à partir de u. Tel que détaillé dans [And98], toutes les opérations, à
l’exception de build, s’implémentent de façon polynomiale:

Opération Complexité dans le pire cas

make(i, ℓ, h) O(1)
build(t) O(2n )
apply⃝(u1 , u2 ) O(|u1 | · |u2 |)
restrict(u, i, b) O(|u|)
exists(u, i) O(|u|2 )
fu ≡ vrai? O(1)
fu ≡ faux? O(1)

Notons que cette complexité polynomiale nécessite un usage de la mémoïsa-

tion, typique à la programmation dynamique, afin d’éviter de recalculer des
valeurs déjà calculées (mènerait sinon à des complexités exponentielles). Par
exemple, si dans un certain sous-appel récursif à apply∧ (u1 , u2 ) on doit iden-
tifier apply∧ (a, b) et qu’on a déjà calculé sa valeur ailleurs dans la récursion,
alors on ne la recalcule pas; on la récupère plutôt d’un tableau associatif.
CHAPITRE 7. VÉRIFICATION SYMBOLIQUE: DIAGRAMMES DE DÉCISION
BINAIRE 84
7.6 Exercices
7.1) Montrez que l’ordre des variables d’une expression booléenne φ peut avoir ?
un impact sur le nombre de sommets du BDD obtenu pour φ.

7.2) Montrez maintenant que l’ordre des variables peut avoir un impact expo- ?
nentiel sur le nombre de sommets.

7.3) Construisez un sommet de BDD qui représente... ?

a) f := (x1 ∧ x3 ) ∨ x2 ;
b) g := x1 ⊕ x2 ;
c) f ∧ g;
d) ∃x3 : f .

7.4) Expliquez comment implémenter ces opérations pour des sommets u et v: ?

a) tester si fu ↔ fv ;
b) calculer {x ∈ {0, 1}n : fu (x1 , . . . , xn ) = vrai};
c) calculer x ∈ {0, 1}n tel que fu (x1 , . . . , xn ) = vrai;
d) calculer |{x ∈ {0, 1}n : fu (x1 , . . . , xn ) = vrai}|.

7.5) Expliquez comment gérer d’autres quantificateurs et opérateurs tempo- ?

rels, par ex. ∀X et ∃G, à l’aide de BDD.

7.6) ⋆⋆ (Requiert des connaissances en théorie du calcul) Si la complexité de ?

build était polynomiale (pas le cas), alors on aurait P = NP. Pourquoi?

7.7) Considérons cette structure de Kripke T sur AP = {p, q, r}: ?

{p, r} {r}

s0 s2

s1 s3

{p, q} {q, r}

a) Donnez des expressions booléennes φp , φq et φr qui représentent

respectivement les ensembles JpK, JqK et JrK.
b) Construisez des BDD pour φp , φq et φr à l’aide de la procédure build.
c) Construisez un BDD pour φp ∧ φq à l’aide de apply∧ .
d) Donnez un BDD pour − →.
e) Donnez un BDD pour JFpK.
 8
Systèmes à pile

Dans ce chapitre, nous voyons comment vérifier des systèmes qui font des ap-
pels récursifs ou possèdent une forme de pile. Il n’est pas possible de modéliser
de tels systèmes par une structure de Kripke finie puisqu’une pile peut générale-
ment avoir une taille arbitraire. Néanmoins, il s’avère possible de les représenter
symboliquement à l’aide d’une variante des automates à pile.
Par exemple, considérons le programme suivant constitué de deux fonctions
et d’une variable booléenne globale x:
bool x ∈ {faux,vrai}

foo(): bar():
f0 : x = ¬x: b0 : si x: foo()
f1 : si x: foo() b1 : retourner
sinon: bar()
f2 : retourner

Il n’est pas immédiatement clair si la pile d’appel peut devenir infinie ou non à
partir d’un appel initial à foo. Ainsi, sans en avoir la certitude, nous ne pouvons
pas utiliser les méthodes de vérification présentées jusqu’ici. Le programme peut
plutôt être modélisé à l’aide de ce diagramme:

f0 −
→ f1
f1 −
→ b0 f 2 f1 −
→ f0 f2
f2 −
→ ε f2 −
→ ε
x0 x1
b0 −
→ b1 b0 −
→ f 0 b1
b1 −
→ ε b1 −
→ ε
f0 −
→ f1

Les états x0 et x1 indiquent que x = faux et x = vrai respectivement. Les transi-

tions représentent le flot du programme. Par exemple, la transition « f1 − → b0 f2 »
indique qu’à partir de la ligne étiquetée par f1 , on se déplace à celle étiquetée

85
CHAPITRE 8. SYSTÈMES À PILE 86

par b0 , et on effectue un retour vers f2 (plus tard). Le mot vide ε indique que
l’exécution locale se complète et que rien n’est mis sur la pile d’appel, par ex.
« b1 −
→ ε » représente un retour de la fonction bar.
Ce type de modélisation s’étend également aux variables locales. Par exemple,
considérons ce programme:

bool g ∈ {faux,vrai}

main(l): foo():
m0 : si l: foo() f0 : g = ¬g
m1 : assert(g == l) f1 : si ¬g:
m2 : retourner foo()
f2 : foo()
f3 : retourner

Lorsque le programme se situe à une instruction de la fonction main, l’état

du programme est entièrement déterminé par l’étiquette de l’instruction cou-
rante ainsi que la valeur du paramètre l; autrement dit, par une paire de la
forme (mi , ℓj ). De plus, nous pouvons introduire un symbole « ⊥ » afin d’indi-
quer que l’assertion est enfreinte. Nous obtenons ainsi cette modélisation, où
chaque paire (mi , ℓj ) est vue comme un unique symbole:

(m0 , ℓ0 ) −
→ (m1 , ℓ0 ) (m0 , ℓ0 ) −
→ (m1 , ℓ0 )
(m0 , ℓ1 ) −
→ f0 (m1 , ℓ1 ) (m0 , ℓ1 ) −
→ f0 (m1 , ℓ1 )
(m1 , ℓ0 ) −
→ (m2 , ℓ0 ) f0 −
→ f1 (m1 , ℓ0 ) −
→ ⊥
(m1 , ℓ1 ) −
→ ⊥ (m1 , ℓ1 ) −
→ (m2 , ℓ1 )
(m2 , ℓ0 ) −
→ ε g0 g1 (m2 , ℓ0 ) −
→ ε
(m2 , ℓ1 ) −
→ ε (m2 , ℓ1 ) −
→ ε
f1 −
→ f0 f2 f0 −
→ f1 f1 −
→ f3
f2 −
→ f0 f3 f2 −
→ f0 f3
f3 −
→ ε f3 −
→ ε

8.1 Systèmes à pile

Il est naturel de chercher à vérifier des propriétés de systèmes tels que ceux
présentés ci-dessus. Par exemple: est-ce que toutes les exécutions du deuxième
programme satisfont l’assertion à la ligne m1 ? Afin d’effectuer une telle vérifi-
cation, nous introduisons les systèmes à pile; un formalisme qui représente les
modélisations que nous avons données pour les programmes ci-dessus.
Définition 2. Un système à pile est un triplet P = (P, Γ, ∆) où
— P est un ensemble fini dont les éléments sont appelés états;
— Γ est l’alphabet fini de la pile;
CHAPITRE 8. SYSTÈMES À PILE 87

— ∆ ⊆ (P × Γ) × (P × Γ∗ ) est un ensemble fini de transitions.

Une configuration de P est une paire ⟨p, w⟩ ∈ P × Γ∗ où w décrit le contenu
d’une pile. Par exemple, ⟨p, abc⟩ représente la configuration où P est dans l’état
p et le contenu de sa pile est:
a
b
c
a−→u
Une transition ((p, a), (q, u)) ∈ ∆, que nous dénotons p −−−→ q, indique que
dans l’état p, si la lettre a est au sommet de la pile, alors on peut dépiler a,
se déplacer à l’état q, et empiler u (qui peut être le mot vide). Dans ce cas,
nous écrivons ⟨p, av⟩ − → ⟨q, uv⟩, où v décrit le contenu du reste de la pile. Plus
généralement, nous écrivons

→ ⟨p′ , w′ ⟩
i
⟨p, w⟩ −

s’il est possible de passer de la configuration ⟨p, w⟩ à la configuration ⟨p′ , w′ ⟩ en

i transitions.
Soit C un ensemble de configurations. Nous définissons l’ensemble des pré-
decesseurs et des successeurs de C respectivement par
∪ ∪
Pre∗ (C) := Prei (C), Post∗ (C) := Posti (C),
i≥0 i≥0

où

Prei (C) := {⟨p, w⟩ : il existe ⟨p′ , w′ ⟩ ∈ C telle que ⟨p, w⟩ −

→ ⟨p′ , w′ ⟩},
i

Posti (C) := {⟨p′ , w′ ⟩ : il existe ⟨p, w⟩ ∈ C telle que ⟨p, w⟩ −

→ ⟨p′ , w′ ⟩}.
i

8.2 Calcul des prédécesseurs

L’ensemble Pre∗ (C) permet de déterminer certaines propriétés d’un système à
pile. Par exemple, posons C := {⟨gi , ⊥w⟩ : i ∈ {0, 1}, w ∈ Γ∗ }. L’ensemble C
représente les configurations qui enfreignent l’assertion du programme précé-
dent. Ainsi, à partir du point d’entrée main, le programme contient un bogue
ssi Pre∗ (C) ∩ {⟨gi , (m0 , ℓj )⟩ : i, j ∈ {0, 1}} ̸= ∅. Nous décrivons une procédure
qui calcule Pre∗ (C). Puisque C et Pre∗ (C) peuvent être infinis, nous devons
représenter ces ensembles symboliquement. Pour ce faire, nous utilisons les P-
automates définis comme suit:

Définition 3. Soit P = (P, Γ, ∆) un système à pile. Un P-automate A est un au-

tomate fini tel que A = (Q, Γ, δ, P, F ), où les composantes sont respectivement
les états, alphabet, transitions, états initiaux et états finaux de A.
CHAPITRE 8. SYSTÈMES À PILE 88

Autrement dit, un P-automate A est un automate fini classique dont les états
initiaux sont ceux de P et dont l’alphabet est celui de la pile de P. Le langage
accepté par A représente le contenu possible de la pile de P. Afin d’éviter toute
ambiguïté, nous ajoutons parfois un indice à « − → » afin de mettre l’emphase sur
le système dont nous faisons référence, par ex. − →A pour A.
Formellement, nous disons que le P-automate A accepte une configuration
⟨p, w⟩ ∈ P × Γ∗ ssi p ∈ P et il existe q ∈ F tel que
w
p−
→A q.

L’ensemble des configurations acceptées par A est dénoté par Conf(A). Par
exemple, le haut de la figure 8.1 illustre un système à pile P (gauche) et un
P-automate A (droite) où Conf(A) = {⟨p, aa⟩}.

P: A:
a a
p b−
→ε p s t

a−
→ ba

c−
→b q q

b−
→ ca

r r

b
B: a
a a
p s t

b
c q b

Figure 8.1 – Exemple de P-automate B tel que Conf(B) = Pre∗ (A) calculé à
partir d’un système à pile P et d’un P-automate A.

Une représentation des prédécesseurs de Conf(A) se calcule algorithmiquement:

Théorème 2 ([EHRS00, BEM97]). Soient P un système à pile et A un P-automate.
Il est possible de construire, en temps polynomial, un P-automate B tel que Conf(B) =
Pre∗ (Conf(A)).
Le P-automate B de la proposition 2 se calcule comme suit. Par souci tech-
nique, nous supposons, sans perte de généralité, qu’aucune transition n’entre
CHAPITRE 8. SYSTÈMES À PILE 89

dans un état initial de A. Nous initialisons B := A, puis nous enrichissons B en

lui ajoutant des transititions avec cette règle:

a−
→w w
Si p −−−−→P p′ et p′ −
→B q, alors (p, a, q) peut être ajoutée à B.

Expliquons le raisonnement derrière cette règle. Soit y ∈ Γ∗ un mot qui

mène de q vers un état final qf . Nous avons
y
p′ −
w
→B q −
→B qf
a−→w
et ainsi ⟨p′ , wy⟩ ∈ Conf(B). Puisque p −−−−→P p′ , nous avons ⟨p, ay⟩ − → ⟨p′ , wy⟩
et ainsi ⟨p, ay⟩ ∈ Pre(Conf(B)). Comme nous cherchons à obtenir tous les pré-
décesseurs, nous désirons enrichir B en ajoutant ⟨p, ay⟩ à Conf(B). L’ajout de la
transition (p, a, q) accomplit exactement cette tâche (pour tous les y possibles).
Ainsi, la règle est appliquée jusqu’à saturation de B, c.-à-d. jusqu’à ce que la
règle ne soit plus applicable et qu’on obtienne tous les prédécesseurs. Une telle
procédure est décrite sous forme de pseudocode à l’algorithme 14.

Algorithme 14 : Calcul de prédécesseurs.

Entrées : Un système à pile P = (P, Γ, ∆) et un P-automate
A = (Q, Γ, δ, P, F )
Sorties : Un P-automate B tel que Conf(B) = Pre∗ (Conf(A))
B←A
changement ← vrai
tant que changement
changement ← faux
pour ((p, a), (p′ , w)) ∈ ∆
pour q ∈ Q
w
si p′ −
→ q dans B alors
ajouter (p, a, q) à B
changement ← vrai
retourner B

Exemple.

Appliquons l’algorithme 14 au système à pile P et au P-automate A illus-

trés au haut de la figure 8.1. Cinq transitions sont ajoutées à A:
CHAPITRE 8. SYSTÈMES À PILE 90

Règle Nouvelle transition

b→ε
p −−−→ p
⃝
1 ε (p, b, p)
p − → p

c−
→b
r −−−→ p
⃝
2 b (r, c, p)
p −
→ p

b−
→ca
q −−−−→ r
⃝
3 ca (q, b, s)
r −→ s

a−
→ba
p −−−−→ q
⃝
4 ba (p, a, t)
q −→ t

b−
→ca
b −−−−→ r
⃝
5 ca (q, b, t)
r −→ t

Nous donnons un aperçu du bon fonctionnement de l’algorithme, les détails

techniques sont décrits en annexe à l’exercice 8.8).

Esquisse de preuve du théorème 2. Soit B0 := A et soit Bi le P-automate obtenu

à partir de Bi−1 après avoir ajouté tout triplet (p, a, q) permis par la règle. Par
définition, nous avons Conf(Bi+1 ) ⊇ Conf(Bi ) pour tout i ∈ N. Comme nous
ajoutons des transitions, mais jamais d’état, nous avons forcément

Conf(Bk ) = Conf(Bk+1 ) = Conf(Bk+2 ) = · · · (8.1)

où k := |P |2 · |Γ|, c.-à-d. le nombre maximal de transitions.

De plus, par définition de la règle, il est possible de montrer que

Pre∗ (Conf(A)) ⊇ Conf(Bi ) ⊇ Prei (Conf(A)) pour tout i ∈ N. (8.2)

En particulier, Pre∗ (Conf(A)) ⊇ Conf(Bk ). De plus,

∞
∪
∗
Pre (Conf(A)) = Prei (Conf(A)) (par déf. de Pre∗ )
i=0
∪∞
⊆ Conf(Bi ) (par (8.2))
i=0
= Conf(Bk ) (par (8.1)).

Nous concluons donc que Conf(Bk ) = Pre∗ (Conf(A)).

CHAPITRE 8. SYSTÈMES À PILE 91

8.3 Vérification à l’aide de système à pile

Afin d’illustrer la vérification d’un programme récursif dont le domaine des va-
riables est fini, considérons ce programme:
bool x, y ∈ {faux,vrai}

main(): foo():
m0 : y = ¬y: f0 : x = ¬y
m1 : si y: f1 : si x: foo()
foo()
sinon:
main()
m2 : assert(x ̸= y)

Celui-ci se modélise par le système à pile P illustré à la figure 8.2.

Afin de déterminer si l’assertion n’est jamais enfreinte, il suffit de:
— construire un P-automate A qui accepte l’ensemble des configurations où
les variables prennent une valeur arbitraire et le dessus de la pile corres-
pond à ⊥ (voir la figure 8.3);
— calculer un P-automate B qui accepte Pre∗ (Conf(A)) à l’aide de l’algo-
rithme 14;
— vérifier s’il existe une configuration initiale, c.-à-d. de la forme ⟨(xi , yi ), m0 ⟩,
acceptée par B, auquel cas il y a un bogue (et sinon aucun).

m0 −
→ m1 m1 −
→ f0 m2
m1 −
→ m0 m2
m2 −
→ ε
m2 −
→ ⊥ x0 , y 0 x0 , y 1
f0 −
→ f1
f1 −
→ ε m0 −
→ m1
f1 −
→ ε

f0 −
→ f1 f0 −
→ f1

m1 −
→ m0 m2 m0 −
→ m1 m1 −
→ f0 m2
m2 −
→ ε x1 , y 0 x1 , y 1 m2 −
→ ⊥
f0 −
→ f1
m0 −
→ m1 f1 −
→ f0
f1 −
→ f0

Figure 8.2 – Système à pile qui modélise un programme récursif.

Mentionnons qu’il existe également un algorithme un peu plus complexe qui

calcule une représentation symbolique des successeurs des configurations d’un
P-automate. Celui-ci enrichit également un P-automate B initialisé à A mais
en lui ajoutant possiblement de nouveaux états, ce qui complique son analyse.
CHAPITRE 8. SYSTÈMES À PILE 92

x0 , y 0 Γ x1 , y 0

⊥ ⊥
⊥ ⊥

x0 , y 1 x1 , y 1

Figure 8.3 – Un P-automate A qui représente les configurations de P où l’as-

sertion est enfreinte, c.-à-d. {⟨(xi , yj ), ⊥w⟩ : i, j ∈ {0, 1}, w ∈ Γ∗ }.

Théorème 3 ([EHRS00]). Soient P un système à pile et A un P-automate. Il est

possible de construire, en temps polynomial, un P-automate B tel que Conf(B) =
Post∗ (Conf(A)).
De plus, il existe un algorithme de complexité polynomiale [EHRS00] qui
vérifie si un système à pile satisfait une formule LTL dont la négation est spécifiée
par un automate de Büchi et dont les propositions atomiques raisonnent sur les
lettres au dessus de la pile. La vérification CTL est également possible, mais en
temps exponentiel dans le pire cas.

8.4 Autre exemple: analyse de code intermédiaire

Afin d’illustrer une application supplémentaire, utilisons les systèmes à pile afin
de raisonner sur le typage d’un programme dérit sous forme de code intermé-
diaire (« bytecode ») Java comme celui-ci (tiré de [Fé19, p. 65]):
sconst_0 // mettre 0 de type « short » sur la pile
sconst_0 // mettre 0 de type « short » sur la pile
/* dépiler deux nombres de type « short »,
les multiplier et mettre le résultat
smul de type « short » sur la pile */
aconst_null // empiler la référence nulle
goto -2 // brancher deux instructions en arrière

Si l’on ignore les erreurs de typage, la pile de ce programme évoluerait de

cette façon, où « ? » indique une valeur non définie:

0 0 0 null ? null

−
→ 0 −
→ −
→ 0 −
→ −
→ ? −
→ ···
.. .. ..
. .. . .. . ..
. . .
CHAPITRE 8. SYSTÈMES À PILE 93

À la seconde exécution de l’instruction smul, le programme tente de multiplier

l’entier 0 par la référence nulle, ce qui ne devrait pas être permis.
Nous pourrions modéliser ce programme à l’aide d’un système à pile, mais
la représentation des entiers de type « short » (16 bits) ajouterait 216 lettres
à l’alphabet Γ. De façon générale, il faudrait aussi représenter la valeur des
registres (pas utilisés dans ce programme) dans les états du système à pile.
Ce genre d’erreur de typage se détecte à l’aide d’une modélisation moins fine
où les valeurs correspondent aux types. Posons Γ := {s, a, . . .} où s représente
le type « short » et a représente le type « reference ». Le typage du programme
précédent se modélise par le système à pile P de la figure 8.4.

τ−
→ τ où τ ∈ Γ

τ−
→ sτ τ−
→ sτ τ−
→ aτ
où τ ∈ Γ où τ ∈ Γ s−
→ε s−
→s où τ ∈ Γ
p0 p1 p2 p3 p4 p5
sconst_0 sconst_0 smul aconst_null goto -2

Figure 8.4 – Modélisation du typage d’un programme en code intermédiaire.

L’instruction smul cause une erreur (au sens du typage) si l’on peut atteindre
une configuration de cet ensemble:

Err := {⟨pi , τ w⟩ : i ∈ {2, 3}, τ ∈ Γ \ {s}, w ∈ Γ∗ } ∪ {⟨pi , ε⟩ : i ∈ {2, 3}}.

Le P-automate A illustré à la figure 8.5 accepte l’ensemble Err. Nous pourrions

donc utiliser l’algorithme 14 pour effectuer la vérification automatiquement.

p0 p1 p2 p3 p4 p5

τ ∈ Γ \ {s}
τ ∈ Γ \ {s}
Γ

Figure 8.5 – Un P-automate A tel que Conf(A) = Err.

CHAPITRE 8. SYSTÈMES À PILE 94

Remarque.

La définition de système à pile force une transition à dépiler. Les algo-

rithmes s’adaptent pour gérer le dépilement d’aucune lettre (mot vide)
ou de plusieurs lettres. Cela simplifierait la modélisation de la figure 8.4.
CHAPITRE 8. SYSTÈMES À PILE 95

8.5 Exercices
8.1) Reconsidérons ce programme non déterministe du chapitre 1: ?

main(): foo(): bar():

m0 : foo() f0 : si ?: bar() b0 : foo()
m1 : retourner f1 : retourner b1 : si ?: retourner
b2 : bar()

a) Modélisez le programme à l’aide d’un système à pile.

b) Expliquez comment nous pourrions déterminer si le programme peut
terminer à partir du point d’entrée main.

8.2) Soit A un P-automate. Comment peut-on déterminer si Pre∗ (Conf(A)) ?

(ou Post∗ (Conf(A))) est infini?

8.3) Nous pouvons associer une structure de Kripke infinie à un système à pile: ?
les états sont les configurations et les transitions dictent l’évolution entre
les configurations. Considérons une variante où la fonction d’étiquetage
L est de la forme L : (P × Γ) → 2AP , plutôt que de (P × Γ∗ ) → 2AP . En
mots, cela signifie qu’une proposition atomique attachée à une configura-
tion ⟨q, aw⟩ ne peut raisonner que sur son état q et la lettre a au dessus de
sa pile. Donnez une formule LTL, et la façon dont vous assignez les pro-
positions atomiques, pour ces propriétés du programme de la section 8.3:
a) une trace exécute foo infiniment souvent;
b) le programme termine;
c) chaque fois que foo est exécutée, main l’est éventuellement aussi;
d) à partir d’un certain point, x = y.

8.4) Expliquez pourquoi nous pouvons supposer qu’aucune transition ne mène ?

vers un état initial d’un P-automate.

8.5) Calculez Pre∗ (Conf(A)) avec l’algorithme 14 où A est le P-automate de la ?

figure 8.5 par rapport au système à pile P de la figure 8.4. Supposez que
Γ = {a, i, s}.

8.6) Notre modélisation à la section 8.4 suppose que seuls deux entiers de ?
type « short » (16 bits) peuvent être additionnés par l’instruction smul.
Supposons qu’elle supporte aussi des entiers de type « byte » (8 bits) qui
sont convertis à l’interne sur 16 bits. Adaptez P et A pour en tenir compte.

8.7) Donnez un système à pile pour ces programmes (tirés de [Fé19, p. 65]):
— sconst_0; goto 3; goto -2; sconst_0; smul
CHAPITRE 8. SYSTÈMES À PILE 96

— aconst_null; pop; goto -2

8.8) ⋆⋆ (Cet « exercice » est ardu et sert d’abord à présenter une preuve, omise
dans le chapitre, aux lectrices et lecteurs intéressé·e·s; tentez d’abord l’inclu-
sion de droite qui est la plus simple) ?
Complétez cette partie de l’esquisse de preuve du théorème 2:

Pre∗ (A) ⊇ Conf(Bi ) ⊇ Prei (Conf(A)) pour tout i ∈ N.

 9
Systèmes à compteurs

Au chapitre 8, nous avons introduit une forme d’infinité à nos systèmes: une
pile. En général, l’ajout d’une seconde pile à un système rend la vérification al-
gorithmique impossible car cela mène à un formalisme Turing-complet. 1 Pour
le cas particulier d’un alphabet muni d’une seule lettre, une pile correspond à
un compteur non négatif: empiler consiste à incrémenter et dépiler consiste à
décrémenter. Contrairement aux piles, l’ajout de plusieurs compteurs ne mène
pas immédiatement à un formalisme Turing-complet. Les compteurs sont éga-
lement pratiques afin de, par ex., dénombrer le nombre de ressources actuelles
d’un système. Nous poursuivons ainsi notre excursion dans le domaine des sys-
tèmes infinis en considérant les réseaux de Petri, un formalisme qui peut être
vu comme une extension des graphes (ou des automates) avec des compteurs.
Les réseaux de Petri permettent de modéliser des systèmes variés allant des
programmes concurrents aux systèmes biologiques, chimiques ou d’affaires.

9.1 Réseaux de Petri

Définition 4. Un réseau de Petri est un triplet N = (P, T, F ) où

— P est un ensemble fini (places);

— T est un ensemble fini disjoint de P (transitions);
— F : ((P × T ) ∪ (T × P )) → N (fonction de flot).

1. Rappelons que par le théorème de Rice, il est impossible de vérifier une propriété sémantique
d’une machine de Turing. En particulier, il n’existe aucun algorithme qui résout le problème d’arrêt
qui consiste à déterminer si un programme termine sur une entrée donnée.

97
CHAPITRE 9. SYSTÈMES À COMPTEURS 98

Exemple.

Le réseau de Petri suivant est illustré à la figure 9.1:

P = {p, q}, T = {s, t},

F (p, s) = 1, F (p, t) = 0,
F (q, s) = 0, F (q, t) = 3,

F (s, p) = 0, F (t, p) = 4,
F (s, q) = 2, F (t, q) = 1.

s
2
p q

4 3
t

Figure 9.1 – Un exemple de réseau de Petri marqué par (1, 1). Les places
et les transitions sont représentées respectivement par des cercles et des
carrés. Les arcs représentent la fonction de flot.

Un marquage est un vecteur m ∈ NP qui associe un nombre de jetons m(p)

à chaque place p. Une transition t ∈ T est déclenchable dans m si m(p) ≥ F (p, t)
pour toute place p ∈ P . Si t est déclenchable, alors

→ m′ où m′ (p) := m(p) − F (p, t) + F (t, p) pour tout p ∈ P.

t
m−
t ∗
Nous écrivons m −→ m′ s’il existe t ∈ T telle que m −
→ m′ , et m − → m′ si
′
m = m ou s’il existe une séquence de marquages et de transitions tels que:

mk = m′ .
t t t
m = m0 −→
1
m1 −→
2
· · · −→
k

Exemple.
∗
Dans le réseau de la figure 9.1, nous avons (1, 1) −
→ (3, 3) puisque
s t s
(1, 1) −
→ (0, 3) −
→ (4, 1) −
→ (3, 3).
CHAPITRE 9. SYSTÈMES À COMPTEURS 99

L’ensemble des successeurs et prédécesseurs d’un marquage m sont respecti-

vement définis par:
∗
Post∗ (m) = {m′ ∈ NP : m −
→ m′ },
∗
Pre∗ (m) = {m′ ∈ NP : m′ −
→ m}.

Nous écrivons m ≥ m′ si m(p) ≥ m′ (p) pour toute place p ∈ P . Par exemple,

(1, 2, 3) ≥ (1, 1, 0), mais (1, 2, 3) ̸≥ (0, 1, 4).

9.2 Modélisation de systèmes concurrents

Considérons le programme suivant, constitué d’une variable booléenne globale
x, qui peut exécuter un nombre arbitraire de processus:

x = faux
tant que ?:
lancer proc()
proc():
p0 : si ¬x: x = vrai sinon: goto p0
p1 : tant que ¬x: pass
p2 : // code

Ce programme ne peut pas être modélisé à l’aide d’une structure de Kripke

finie puisque le nombre de processus n’est pas borné. Nous pouvons cependant
le modéliser à l’aide d’un réseau de Petri tel qu’illustré à la figure 9.2.

p0 p1 p2

¬x x

Figure 9.2 – Réseau de Petri qui modélise l’exécution du processus proc. La

place tout à gauche permet de lancer un nombre arbitraire de processus et de
décider de cesser d’en lancer.

Supposons qu’on cherche à déterminer si plusieurs processus peuvent at-

teindre la ligne p2 . Cela est équivalent à déterminer s’il existe un marquage m′
tel que: ( ) ( )
1 0 0 0 * 0 0 0 2
−−−−−→ m′ et m′ ≥ .
1 0 0 0
CHAPITRE 9. SYSTÈMES À COMPTEURS 100

Considérons un programme similaire, aussi constitué d’une variable boo-

léenne globale x, et qui peut aussi exécuter un nombre arbitraire de processus:
x = faux
tant que ?:
lancer proc2()
proc2():
p0 : si ¬x: x = vrai sinon: goto p0
p1 : tant que ¬x: pass
p2 : x = ¬x

Ce programme est modélisé par un réseau de Petri à la figure 9.3. Supposons

qu’on cherche à déterminer si le programme peut se terminer avec x = vrai.
Cela est équivalent à déterminer si:
( ) ( )
1 0 0 0 * 0 0 0 0
−−−−−→ .
1 0 0 1

p0 p1 p2

¬x x

Figure 9.3 – Réseau de Petri qui modélise l’exécution du processus proc2.

9.3 Vérification
Nous formalisons les problèmes de vérification sous-jacents aux deux exemples:
Problème d’accessibilité
Entrée: réseau de Petri N = (P, T, F ) et marquages m, m′ ∈ NP
∗
Question: → m′ ?
m−

Problème de couverture
Entrée: réseau de Petri N = (P, T, F ) et marquages m, m′ ∈ NP
∗
Question: existe-t-il m′′ ∈ NP tel que m −
→ m′′ et m′′ ≥ m′ ?
CHAPITRE 9. SYSTÈMES À COMPTEURS 101

Ces deux problèmes sont décidables; autrement dit, ils sont tous deux so-
lubles à l’aide d’un algorithme.

Remarque.

Bien que ces deux problèmes soient décidables, leur complexité est co-
lossale: non récursive primitive [ST77, May81, Kos82, Lam92, Ler12,
CLL+ 19, Ler21, CO21] et EXPSPACE-complet [Lip76, Rac78], respecti-
vement. Cela n’empêche toutefois pas de les résoudre en pratique.

Nous mettons l’emphase sur le problème de couverture et présentons deux

algorithmes permettant de résoudre ce problème.
Nous disons que m′ est couvrable à partir de m s’il existe un marquage
∗
m′′ ∈ NP tel que m −→ m′′ et m′′ ≥ m′ . Nous disons que m peut couvrir m′ si
m′ est couvrable à partir de m.

9.3.1 Graphes de couverture

Considérons le réseau de Petri illustré à la figure 9.4. Cherchons à déterminer si
m = (1, 1) peut couvrir un marquage m′ . Nous pourrions tenter de construire
Post∗ (1, 1) sous forme de graphe d’accessibilité tel qu’illustré du côté gauche de
la figure 9.5. Cependant, ce graphe est infini et il serait à priori impossible de
déterminer lorsqu’il faut arrêter de construire le graphe.

p0 p1
s

3
t

Figure 9.4 – Autre exemple de réseau de Petri.

Afin de pallier ce problème, nous introduisons la notion de graphe de cou-

verture. Nous étendons N avec un élément maximal ω. Plus formellement, nous
définissons l’ensemble Nω := N ∪ {ω} où

n+ω =ω pour tout n ∈ Nω ,

ω−n=ω pour tout n ∈ N,
ω>n pour tout n ∈ N.

Un marquage étendu est un vecteur m ∈ NP ω . Le concept de déclenchement de

transitions est étendu naturellement à ces marquages.
Reconsidérons le graphe d’accessibilité à la gauche de la figure 9.5. Lorsque
st
nous atteignons le marquage (1, 2), nous observons que (1, 1) −→ (1, 2) et (1, 2) ≥
CHAPITRE 9. SYSTÈMES À COMPTEURS 102

(1, 1) (1, 1)
s t s t

(0, 3) (2, 0) (0, 3) (2, 0)

t t

(1, 2) (1, ω)
s t s t

(0, 4) (2, 1) (0, ω) (ω, ω) s, t

s t t

(1, 3) (3, 0)

Figure 9.5 – Graphe d’accessibilité (gauche) et graphe de couverture (droite)

du réseau de Petri de la figure 9.4 à partir du marquage (1, 1).

(1, 1). En itérant la séquence st, nous pouvons donc faire croître arbitrairement
la deuxième place. Nous remplaçons donc ce marquage par le marquage étendu
(1, ω), que nous appelons son accélération. Le symbole « ω » n’indique pas que
toutes les valeurs sont atteignables, mais bien que la place peut contenir autant
de jetons que désiré. Ainsi, en inspectant les ancêtres d’un marquage lors de
son ajout, nous obtenons un graphe fini qui capture la forme des marquages
couvrables, comme celui du côté droite de la figure 9.5.
La procédure de calcul d’un graphe de couverture est décrite à l’algorithme 15.
La proposition suivante explique comment déterminer si un marquage m′
est couvrable à l’aide d’un graphe de couverture:
Proposition 10. Soit N = (P, T, F ) un réseau de Petri, et soient deux marquages
m, m′ ∈ NP . Soit G un graphe de couverture calculé par cover(N , m). Le mar-
quage m′ est couvrable à partir de m si et seulement si G possède un marquage
m′′ tel que m′′ ≥ m′ .

Notons que l’algorithme termine bel et bien sur toute entrée et qu’ainsi un
graphe de couverture est nécessairement fini:

Proposition 11. L’algorithme 15 termine sur toute entrée.

Démonstration. Afin d’obtenir une contradiction, supposons qu’il existe une

entrée sur laquelle l’algorithme ne termine pas. L’algorithme calcule donc un
graphe infini G. Observons que chaque sommet de G possède au plus |T | suc-
cesseurs immédiats; donc un nombre fini de successeurs immédiats. Par le
lemme de König, G contient donc un chemin simple infini m0 − → m1 − → ···.
CHAPITRE 9. SYSTÈMES À COMPTEURS 103

Algorithme 15 : Algorithme de calcul de graphe de couverture.

Entrées : Réseau de Petri N = (P, T, F ) et m ∈ NP
Sorties : Graphe de couverture à partir de m
cover(N , m):
V ←∅ // Sommets
E←∅ // Arcs
W ← {m} // À traiter
tant que W ̸= ∅
m′ ← retirer de W
ajouter m′ à V
pour t ∈ T déclenchable en m′
t
m′′ ← marquage tel que m′ −→ m′′
′′
accel(m )
si m′′ ̸∈ V alors // Déjà traité?
ajouter m′′ à W
ajouter (m′ , m′′ ) à E
retourner (V, E)
accel(x):
pour tout ancêtre x′ de x dans le graphe (V, E)
si x′ ≤ x alors
pour p ∈ P
si x′ (p) < x(p) alors
x(p) ← ω

Pour tout i ∈ N, définissons

Jmi K := {p ∈ P : mi (p) = ω}.

Comme le chemin est infini et que P est fini, il existe des indices i0 < i1 < · · ·
tels que Jmi0 K = Jmi1 K = · · · . Ainsi, par le lemme de Dickson, il existe j, k ∈ N
tels que j < k et mij ≤ mik . Notons que mij ̸= mik , puisqu’autrement le
chemin ne serait pas simple. Ainsi, mij (p) < mik (p) pour au moins une place
p ∈ P . Si mik (p) = ω, alors Jmij K ̸= Jmik K, ce qui est une contradiction. Nous
avons donc mik (p) ∈ N. Cela implique que mik aurait dû être accéléré par son
ancêtre mij , ce qui n’est pas le cas puisque Jmij K = Jmik K.

9.3.2 Algorithme arrière

Nous étudions un autre algorithme qui permet de résoudre le problème de cou-
verture: l’algorithme arrière. Plutôt que d’identifier les marquages couvrables,
cet algorithme identifie plutôt les marquages qui peuvent couvrir un marquage
CHAPITRE 9. SYSTÈMES À COMPTEURS 104

donné. L’algorithme arrière repose notamment sur la représentation et la ma-

nipulation d’ensembles dits clos par le haut.
Soit un marquage m ∈ NP . La clôture par le haut de m est l’ensemble de
marquages ↑m := {m′ ∈ NP : m′ ≥ m}. La clôture par le haut d’un ensemble
X ⊆ NP est l’ensemble: ∪
↑X := ↑m.
m∈X

Nous disons que X ⊆ N est clos par le haut si ↑X = X. Une base d’un ensemble
P

clos par le haut X est un ensemble B tel que ↑B = X. Une base B est minimale
si ce n’est pas le cas qu’il existe x, y ∈ B tels que x ≥ y et x ̸= y. Autrement dit,
B est minimale si tous ses éléments sont incomparables. La figure 9.6 donne un
exemple d’ensemble clos par le haut et de base minimale.

Figure 9.6 – Illustration d’un ensemble clos par le haut (cercles). Sa base mi-
nimale {(1, 2), (3, 1)} est représentée par des carrés.

Observons que l’ensemble des marquages qui peuvent couvrir un certain

marquage est clos par le haut:
Proposition 12. Soit m′ ∈ NP . L’ensemble des marquages qui peuvent couvrir
m′ est égal à ↑Pre∗ (↑m′ ).

Démonstration. ⊆) Soit m un marquage qui peut couvrir m′ . Par définition de

∗
couverture, il existe un marquage m′′ tel que m −
→ m′′ et m′′ ≥ m′ . Ainsi,

m ∈ Pre∗ (m′′ ) (par définition de Pre∗ )

⊆ Pre∗ (↑m′ ) (car m′′ ∈ ↑m′ )
⊆ ↑Pre∗ (↑m′ ) (par l’identité X ⊆ ↑X).

⊇) Soit m ∈ ↑Pre∗ (↑m′ ). Il existe des marquages k et m′′ tels que

m
≤

∗
k → m′′
−
≤

m′
CHAPITRE 9. SYSTÈMES À COMPTEURS 105

∗
Ainsi, par monotonicité, il existe un marquage m′′′ tel que m −
→ m′′′ et m′′′ ≥
′′ ′
m ≥ m . Informellement, la « monotonicité » signifie qu’un plus grand bud-
get de jetons permet de déclencher (au moins) autant de transitions. Nous
concluons donc que m peut couvrir m′ .
L’algorithme arrière cherche à calculer une représentation de ↑Pre∗ (↑m′ ).
Par exemple, considérons le réseau de Petri illustré à la figure 9.7 avec m′ =
(0, 2). L’algorithme arrière débute avec l’ensemble ↑m′ , puis calcule itérative-
ment les prédécesseurs immédiats de chacun de ses marquages jusqu’à ce que
l’ensemble se stabilise:

Itér. Prédecesseurs sous t1 Prédecesseurs sous t2 Ensemble actuel

0 — —

3 ensemble inchangé

Puisque les ensembles clos par le haut sont infinis, cette procédure n’est pas,
à priori, effective. Pour qu’elle le soit, nous devons être en mesure de:
— représenter les ensembles clos par le haut symboliquement;
— calculer les prédécesseurs immédiats de tous les marquages d’un ensemble
clos par le haut.
Le premier point est rendu possible par cette observation:
Proposition 13. Tout ensemble X ⊆ NP clos par le haut a une base finie.
CHAPITRE 9. SYSTÈMES À COMPTEURS 106

p1 p2
t2

4 5
2
t1

Figure 9.7 – Un réseau de Petri.

Ainsi, nous manipulons des bases finies comme représentants d’ensembles

clos par le haut. En particulier, il est possible de tester l’appartenance à un en-
semble clos par le haut représenté par une base B puisque:

m ∈ ↑B ⇐⇒ il existe k ∈ B tel que m ≥ k.

Pour le second point, nous calculons pour chaque élément de la base et pour
chaque transition, le plus petit marquage pouvant le couvrir sous cette transi-
tion. Formellement, soit t ∈ T une transition et m ∈ NP un marquage. Le plus
petit marquage pouvant couvrir m en déclechant t est le marquage mt tel que

mt (p) := max(F (p, t), m(p) + F (p, t) − F (t, p)) pour tout p ∈ P.
| {z } | {z }
« budget nécessaire » « déclenchement arrière »

L’algorithme complet est décrit à l’algorithme 16. Reconsidérons le réseau

de Petri illustré à la figure 9.7 avec m′ = (0, 2). Nous exécutons cette fois l’al-
gorithme arrière en manipulant directement une base:

Itér. Base B Prédécesseurs

0 {(0, 2)} (0, 2)t1 = (4, 4) (0, 2)t2 = (2, 1)
1 {(0, 2), (2, 1)} (2, 1)t1 = (4, 3) (2, 1)t2 = (3, 0)
2 {(0, 2), (2, 1), (3, 0)} (3, 0)t1 = (4, 2) (3, 0)t2 = (4, 0)
3 {(0, 2), (2, 1), (3, 0)} base inchangée
CHAPITRE 9. SYSTÈMES À COMPTEURS 107

Algorithme 16 : Algorithme arrière.

Entrées : Réseau de Petri N = (P, T, F ) et m′ ∈ NP
Sorties : Une base minimale de ↑Pre∗ (↑m′ )
arriere(N , m′ ):
B ′ ← {m′ }
faire
B ← B′ // Base actuelle
pour m ∈ B
pour t ∈ T
ajouter mt à B ′
minimiser(B ′ ) // Retirer les marquages redondants
tant que B ′ ̸= B
retourner B
minimiser(X ):
pour x ∈ X
pour y ∈ X
si x ≤ y ∧ x ̸= y alors retirer y de X
CHAPITRE 9. SYSTÈMES À COMPTEURS 108

9.4 Exercices
9.1) Calculez un graphe de couverture de ce réseau de Petri à partir de (1, 0, 0, 0): ?

t1 p3

p1 t3 p4

t2 p2

t4

9.2) Exécutez l’algorithme arrière sur ce réseau de Petri à partir de (0, 1, 1): ?
p2
t1 t3

p1 t2 p3

9.3) Montrez que l’ordre dans lequel on construit un graphe de couverture peut ?
avoir une incidence sur sa taille. Considérez ce réseau de Petri:

t1

p1 p2
t3

t2
CHAPITRE 9. SYSTÈMES À COMPTEURS 109

Remarque.

L’ancienne version de l’exercice débutait par le marquage (1, 1),

mais on obtient un contre-exemple plus simple à partir de (0, 0).

t
→ m′ et k ≥ m
9.4) Montrez la propriété de monotonicité, c.-à-d. que m − ?
′ ′ t ′
implique l’existence de k ≥ m tel que k −
→k.

9.5) Considérons une variable entière x de n bits qui peut être incrémentée.
a) Modélisez x à l’aide de 8 places pour n = 3, puis généralisez.
b) Modélisez x à l’aide de 6 places pour n = 3, puis généralisez.
c) Modélisez le test « x == 0 ».
d) En supposant que x est signée et représentée sous complément à
deux, modélisez le test « x > 0 ».

9.6) Considérons cette (sous) interface Java: ?

[Link]
new AffineTransformation()
Shape [Link](AffineTransformation)
String [Link]()
double [Link]()
double [Link]()
void [Link](double, double, double)
void [Link]()
Area [Link](AffineTransformation)

a) Modélisez l’interface au niveau des types, c.-à-d. en assignant une

place par type et une transition par méthode.
b) Dans cette modélisation, quel est le marquage m associé à cette nou-
velle méthode qu’on voudrait implémenter:
Area rotate(Area object, Point2D point, double angle)

c) Donnez une séquence de transitions qui mène à m.

(adapté de [BHO20] basé sur [FMW+ 17])

9.7) Dans le jeu de société Century: La route des épices, chaque personne pos- ?
sède des unités de quatre types d’épices ordonnés comme suit:

curcuma safran cardamome cannelle

Une carte marchand permet soit d’obtenir, d’échanger ou d’améliorer des

épices. Par exemple, considérons ces sept cartes:
CHAPITRE 9. SYSTÈMES À COMPTEURS 110

La première carte du bas procure deux unités de curcuma. La deuxième

carte du bas permet d’échanger trois unités de curcuma contre une unité
de cardamome et une unité de safran. La carte au centre tout à droite
permet d’améliorer (au plus) deux unités (de n’importe quel type), par
ex. transformer deux unités de curcuma vers deux unités de safran, ou
bien une unité de curcuma vers une unité de cardamome.
Les épices permettent d’acheter des cartes points comme celles-ci:

17 13 16

Considérons un sous-ensemble des règles où, à chaque tour, on peut:

— jouer une carte marchand puis la mettre de côté;
— reprendre toutes ses cartes marchands;
— acheter une carte points.

a) Expliquez comment déterminer algorithmiquement

i. s’il est possible d’acheter toutes les carte points;
CHAPITRE 9. SYSTÈMES À COMPTEURS 111

ii. le nombre de tours minimal afin d’acheter toutes les cartes points.
b) Répondez à nouveau, en supposant maintenant qu’il est interdit de
posséder plus de dix unités d’épices (ce qui est le cas dans le jeu).
c) ⋆ Déterminez une séquence minimale pour les cartes ci-dessus, en
supposant qu’on débute avec trois unités de curcuma.
 10
Systèmes probabilistes

Le non-déterminisme utilisé jusqu’ici s’avère pratique afin de modéliser des com-

portements à priori incertains. Toutefois, il ne permet ni de distinguer entre
comportements fortement et faiblement probables, ni d’évaluer la probabilité
qu’une propriété soit satisfaite. Parfois, une distribution de probabilité (ou une
estimation) est connue. Ainsi, il devient intéressant de distinguer, par ex., entre
« la spécification peut être enfreinte » et « la spécification peut être enfreinte,
mais avec faible probabilité ». Nous introduisons un formalisme qui remplace le
non-déterminisme des structures de Kripke par des probabilités, et qui permet
l’automatisation de la vérification de telles questions.

10.1 Chaînes de Markov

Définition 5. Une chaîne de Markov 1 est un tuple M = (S, P, init, AP, L) où
— (S, − → := {(s, s′ ) : P(s, s′ ) > 0},
→, I) est un système de transition où −
— P : S × S → Q[0,1] est∑ une matrice qui associe des probabilités aux transi-
tions, et qui satisfait s′ ∈S P(s, s′ ) = 1 pour tout état s ∈ S,
— init : S → Q[0,1] est un vecteur
∑qui indique la probabilité init(s) de débuter
dans l’état s, et qui satisfait s∈S init(s) = 1,
— AP est un ensemble de propositions atomiques,
— L : S → 2AP est une fonction d’étiquetage.

Nous supposons pour le reste du chapitre qu’une chaîne de Markov est finie.
Les notions de chemins, d’exécutions, de successeurs et de prédécesseurs s’ap-
pliquent directement à une chaîne de Markov: nous considérons le système de
transition qu’il induit en ignorant la valeur précise des probabilités. Pour facili-
ter la présentation, nous supposerons qu’une chaîne de Markov ne possède pas
d’état terminal (c.-à-d. sans successeur immédiat).

1. Plus précisément, une chaîne de Markov à temps discret.

112
CHAPITRE 10. SYSTÈMES PROBABILISTES 113

Exemple.

Considérons la figure 10.1 qui illustre une chaîne de Markov, sans pro-
positions atomiques. Celle-ci modélise un système de communication
simple qui tente d’envoyer un message à répétition sur un canal non
fiable.

1 départ

1 1
1/10

succès envoyer échec

9/10
1

Figure 10.1 – Chaîne de Markov, sans propositions atomiques, qui mo-

délise un système de communication (tirée de [BK08]).

En ordonnant les états S = {départ, envoyer, succès, échec}, nous avons:

   
0 1 0 0 1
0 0 9/10 1/10 0
P= 1 0
 et init =   .
0 0  0
0 1 0 0 0

Afin de raisonner sur les propriétés d’une chaîne de Markov M, nous devons
lui associer un espace de probabilité. À cette fin, nous associons à chaque chemin
fini ρ = s0 s1 · · · sn de M, ce cylindre et cette valeur:

cyl(ρ) := {ρ′ : ρ′ est un chemin infini qui débute par ρ},

∏
P(s0 · · · sn ) := P(si , si+1 ).
0≤i<n

L’espace de probabilité de M est défini comme suit:

— son univers est l’ensemble des exécutions infinies de M;
— ses événements est l’ensemble qui contient le cylindre de chaque chemin
fini de M, et qui est clos par complémentation et par union dénombrable;
— sa mesure de probabilité P satisfait P(cyl(s0 · · · sn )) := init(s0 )·P(s0 · · · s1 ).
Afin de spécifier des ensembles de chemins infinis plus aisément, nous utili-
sons la notation LTL, où un état est vu comme une proposition atomique et un
CHAPITRE 10. SYSTÈMES PROBABILISTES 114

ensemble A = {s1 , . . . , sk } comme l’expression s1 ∨ · · · ∨ sk . Par exemple, FA

est l’ensemble des chemins infinis qui passent au moins une fois par un état de
A, et GA est l’ensemble des chemins infinis qui ne visitent que des états de A.
La probabilité de ces ensembles existe car ils sont des événements, par la pro-
position ci-dessous. En particulier, nous écrirons P(s |= φ) pour dénoter P(φ)
où s serait l’unique état initial de M. Par exemple, P(s |= Fs′ ) est la probabilité
d’atteindre l’état s′ à partir de l’état s. De façon générale, nous avons donc
∑
P(φ) = init(s) · P(s |= φ).
s∈S

Proposition 14. Les ensembles engendrés par la notation LTL sont mesurables.

Démonstration. Nous montrons seulement le cas de FA. Nous devons montrer

que cet ensemble est un événement en l’exprimant par rapport à des cylindres.
Un chemin infini visite A au moins une fois ssi il possède un préfixe fini (possi-
blement vide) dans S \ A suivi d’un état de A et de n’importe quoi. Ainsi:
∪ ∪
FA = cyl(ρ · s).
ρ∈(S\A)∗ s∈A

En particulier, la probabilité de l’événement FA est:

∪
P(FA) = P( cyl(s0 · · · sn ))
s0 ···sn ∈(S\A)∗ A
∑
= P(cyl(s0 · · · sn )) (car les cylindres sont disjoints)
∗
s0 ···sn ∈(S\A) A
∑
= init(s0 ) · P(s0 · · · sn ) (par déf. de P).
s0 ···sn ∈(S\A)∗ A

Exemple.

Reconsidérons la chaîne de Markov M de la figure 10.1. Calculons la

probabilité que M atteigne l’état de succès. Remarquons que l’unique
CHAPITRE 10. SYSTÈMES PROBABILISTES 115

état initial est l’état de départ. Ainsi, nous avons:

∞
∑
P(F succès) = P(départ envoyer (échec envoyer)i succès)
i=0
∞
∑
= 1 · (1/10)i · (9/10)
i=0
∞
∑
= (9/10) · (1/10)i
i=0
= (9/10) · (1/(1 − 1/10)) (10.1)
= 1,

où (10.1) découle du fait qu’il s’agit d’une série géométrique.

10.2 Probabilités d’accessibilité

Cherchons à exprimer la probabilité qu’un certain état s atteigne un ensemble
d’états B. Si s ∈ B, alors celle-ci est de 1. Si s ne peut pas atteindre un état de
B, alors la probabilité est de 0. Autrement dit:

∗

0 si Post (s) ∩ B = ∅,
P(s |= FB) = 1 si s ∈ B,


? sinon.

Dans le cas général indiqué par « ? », un état s atteint l’ensemble B en plus d’une
étape, ou en exactement une étape. Ainsi:
∑ ∑
P(s |= FB) = P(s, s′ ) · P(s′ |= FB) + P(s, s′ ).
s′ ∈S\B s′ ∈B

La première somme se simplifie légèrement. En effet, il est inutile de considérer

les états s′ qui ne peuvent pas atteindre B car leur probabilité est de zéro.
Réécrivons le tout de façon plus concise. Posons:
S0 := {s ∈ S : Post∗ (s) ∩ B = ∅},
S1 := B,
S? := S \ (S0 ∪ S1 ).
∑
Soit A la matrice P restreinte à S? , et soit b le vecteur tel que b(s) = s′ ∈S1 P(s, s′ ).
Le vecteur x : S? → Q[0,1] tel que x(s) = P(s |= FB) est une solution de:
x = A · x + b, qui s’écrit aussi (I − A) · x = b.
En fait, on peut démontrer que ce système possède une unique solution.
CHAPITRE 10. SYSTÈMES PROBABILISTES 116

Exemple.

Reconsidérons l’événement « F succès » de la chaîne de Markov M illus-

trée à la figure 10.1. Nous avons S0 = ∅, S1 = {succès} et S? = {départ,
envoyer, échec}. Nous obtenons ce système:
     
1 0 0 0 1 0 0
0 1 0 − 0 0 1/10 · x = 9/10 .
0 0 1 0 1 0 0

L’unique solution du système est (1, 1, 1).

Ce calcul de probabilités se généralise à un événement de la forme A U B:

Théorème 4 ([BK08, Thm. 10.15]). Soit M = (S, P, init, AP, L) une chaîne de
Markov. Soient A, B ⊆ S. Posons
S0 := J¬∃(A U B)K,
S1 := B,
S? := S \ (S0 ∪ S1 ).
∑
Soient A la matrice P restreinte à S? , et b le vecteur sur S? où b(s) := s′ ∈S1 P(s, s′ ).
Le vecteur x : S? → Q[0,1] tel que x(s) = P(s |= (A U B)) est l’unique solution de:
x = A · x + b,
ou, de façon équivalente: x = limn→∞ f n (0) où f (y) := A · y + b. De plus, f n (0)
est le vecteur de probabilités du cas où B doit être atteint en au plus n étapes.
Notons que la seconde formulation du théorème (en terme de limite) permet
d’approximer la solution numériquement en calculant itérativement les vecteurs
0, f (0), f (f (0)), . . . jusqu’à une marge d’erreur jugée acceptable.

Exemple.

Considérons l’événement {envoyer, échec} U {départ, succès} de la chaîne

de Markov M de la figure 10.1. Nous avons S0 = ∅, S1 = {départ, succès}
et S? = {envoyer, échec}. Nous obtenons ce système:
[( ) ( )] ( )
1 0 0 1/10 9/10
− ·x= .
0 1 1 0 0

L’unique solution du système est (1, 1). Alternativement, en évaluant f à

répétition, nous convergeons vers (1, 1):
( ) ( ) ( ) ( )
0 0,9 0,99 0,999
; ; ; ;...
0 0,0 0,90 0,990
CHAPITRE 10. SYSTÈMES PROBABILISTES 117

10.3 Probabilités de comportements limites

Les exemples précédents mènent tous à des probabilités de 1, ce qui n’est pas
une coïncidence. Cela découle du fait que le graphe induit par la chaîne de Mar-
kov est fortement connexe 2 . Nous disons qu’une composante fortement connexe
(CFC) est terminale si elle ne peut pas en atteindre d’autre. En général, toute
exécution infinie ρ atteint une composante fortement connexe terminale C avec
probabilité 1. De plus, tous les états de C sont visités par ρ avec probabilité 1.
Plus formellement, nous dénotons par inf(ρ) l’ensemble des états visités infini-
ment souvent par ρ. Nous avons:
Proposition 15. Soient un état s et E := {ρ : inf(ρ) est une CFC terminale}.
Nous avons P(s |= E) = 1.
Ainsi, peu importe le point de départ de la chaîne de Markov de la figure 10.1,
l’état « succès » est visité infiniment souvent avec probabilité 1, ce qui explique
le résultat des exemples.
De plus, la proposition 15 permet d’évaluer certaines « propriétés limites »
en termes d’accessibilité. Par exemple, P(s |= GFA) = P(s |= FA′ ) où

A′ := {s ∈ S : s appartient à une CFC terminale C t.q. C ∩ A ̸= ∅}.

Similairement, P(s |= FGA) = P(s |= FA′ ) où

A′ := {s ∈ S : s appartient à une CFC terminale C t.q. C ⊆ A}.

Comme on peut identifier les composantes fortement connexes terminales d’un

graphe en temps linéaire, ces probabilités se calculent en temps polynomial.

Exemple.

Considérons la chaîne de Markov suivante. Cherchons à évaluer P(FGp).

{p} {p} {q} {p, q} 1 {p}

1/2 1 1/2
3/4 s0 s2 s3 s4 s5 1/4

1/2 1/4 1/2

1/2 1
s1 s6 s7 3/4
1/4
{q} ∅ 1/4 {p}

Figure 10.2 – Exemple de chaîne de Markov sur AP = {p, q}.

2. Une telle chaîne est dite ergodique ou irréductible dans le jargon mathématique.
CHAPITRE 10. SYSTÈMES PROBABILISTES 118

Posons A := JpK = {s0 , s2 , s4 , s5 , s7 }. Nous avons:

P(FGp) = P(FGA)
= P(FA′ ) (où A′ := {s4 , s5 })
= 3/4 · P(s0 |= FA′ ) + 1/4 · P(s5 |= FA′ ) (selon init)
= 3/4 · P(s0 |= FA′ ) + 1/4 (car s5 ∈ A′ )
= 3/4 · x(s0 ) + 1/4 (où (I − A) · x = b).

Il nous reste à déterminer A et b afin d’identifier x. Nous avons S0 =

{s6 , s7 }, S1 = {s4 , s5 } et S? = {s0 , s1 , s2 , s3 }. Ainsi:
   
0 1/2 1/2 0 0
1/4 0 1/2 0   0 
A :=   0
 et b :=   .
0 0 1  0 
0 0 0 0 1/2

En résolvant (I − A) · x = b, nous obtenons x = (3/7, 5/14, 1/2, 1/2). En

particulier, x(s0 ) = 3/7 et ainsi P(FGp) = (3/4) · (3/7) + (1/4) = 4/7.

10.4 CTL probabiliste

10.4.1 Syntaxe et sémantique
Nous introduisons une variante probabiliste de CTL qui permet de vérifier plu-
sieurs propriétés. La syntaxe de la logique temporelle arborescente probabiliste
(PCTL) sur propositions atomiques AP est définie à partir de cette grammaire:

Φ ::= vrai | p | (Φ ∧ Φ) | ¬Φ | PI (φ) (formule d’état)

≤n
φ ::= XΦ | (Φ U Φ) | (Φ U Φ) (formule de chemin)

où p ∈ AP, n ∈ N et I dénote un intervalle de Q[0,1] .

La syntaxe diffère de celle de CTL en deux points. Premièrement, les quan-
tificateurs de chemins ∃ et ∀ sont remplacés par l’opérateur PI qui affirme
que la probabilité de l’événement JφK appartient à l’intervalle I, Par exemple,
P[1/2,1] (Fp), que nous abrégons par P≥1/2 (Fp), spécifie que la probabilité d’at-
teindre un état qui satisfait p est d’au moins 1/2. Deuxièmement, le nouvel
opérateur temporel U≤n borne le moment maximal auquel son terme de droite
doit devenir vrai.
CHAPITRE 10. SYSTÈMES PROBABILISTES 119

Formellement, la sémantique est définie comme suit. Pour tout état s ∈ S:

s |= vrai,
déf
s |= p ⇐⇒ p ∈ L(s),
déf
s |= ¬Φ ⇐⇒ ¬(s |= Φ),
déf
s |= Φ1 ∧ Φ2 ⇐⇒ (s |= Φ1 ) ∧ (s |= Φ2 ),
déf
s |= PI (φ) ⇐⇒ P(s |= φ) ∈ I.

Pour tout chemin infini σ de la chaîne de Markov:

déf
σ |= XΦ ⇐⇒ σ(1) |= Φ,
déf
σ |= Φ1 U Φ2 ⇐⇒ ∃j ≥ 0 : [(∀i ∈ [0..j − 1] : σ(i) |= Φ1 ) ∧ (σ(j) |= Φ2 )] ,
≤n déf
σ |= Φ1 U Φ2 ⇐⇒ ∃j ∈ [0..n] : [(∀i ∈ [0..j − 1] : σ(i) |= Φ1 ) ∧ (σ(j) |= Φ2 )] .

Notons que la sémantique de l’opérateur PI est bien définie car toute formule
de chemin donne lieu à un événement:
Proposition 16. Pour toute formule de chemin φ et tout état s, P(s |= φ) est bien
définie, c.-à-d. que cet ensemble est mesurable:

{σ est un chemin infini : σ débute en s et σ |= φ}.

Nous introduisons les opérateurs temporels F et G à la manière de CTL en

tenant compte des probabilités. Le dual d’un intervalle de probabilités I = [p, q]
est l’intervalle dual(I) := {1 − i : i ∈ I}. Par exemple, dual([p, 1]) = [0, 1 − p] et
dual([0, q)) = (1 − q, 1]. Nous définissons:

FΦ := vrai U Φ, F≤n Φ := vrai U≤n Φ,

PI (GΦ) := Pdual(I) (F¬Φ), PI (G≤n Φ) := Pdual(I) (F≤n ¬Φ).

Exemple.

La formule PCTL suivante spécifie que, presque sûrement, un message

est reçu avec succès, et qu’une tentative d’envoi mène à un succès en au
plus trois envois avec probabilité au moins 99/100:

P=1 (F succès) ∧ P=1 (G(envoyer → P≥0,99 (F≤3 succès))).

10.4.2 Vérification
Le problème de vérification PCTL consiste à déterminer si un état s satisfait une
formule d’état Φ. Cela se détermine en temps O(poly(|M|) · |Φ| · m), où m est le
plus grand exposant qui apparaît sur un opérateur U≤n (ou 1 s’il n’y en a pas).
CHAPITRE 10. SYSTÈMES PROBABILISTES 120

Nous savons déjà vérifier la portion propositionnelle de PCTL: nous calcu-

lons récursivement l’ensemble des états qui satisfont les sous-formules à l’aide
d’opérations sur les ensembles. Il demeure donc d’identifier des algorithmes
pour obtenir les états qui satisfont une formule de la forme PI (φ).

Opérateur X. Nous avons JPI (XΦ)K = {s ∈ S : P(s |= XΦ) ∈ I}. De plus:

∑
P(s |= XΦ) = P(s, s′ ). (10.2)
s′ ∈JΦK

Ainsi, JPI (XΦ)K s’obtient en évaluant chaque probabilité avec (10.2) et en conser-
vant les états dont la valeur appartenant à I.

Opérateur U. Nous avons

JPI (Φ1 U Φ2 )K = {s ∈ S : P(s |= JΦ1 K U JΦ2 K) ∈ I}.

Nous savons comment calculer P(s |= JΦ1 K U JΦ2 K) par le théorème 4. Ainsi,
comme pour l’opérateur X, il suffit d’évaluer les probabilités et de préserver les
états dont la valeur appartient à l’intervalle I.

Opérateur U≤n . Nous avons

JPI (Φ1 U Φ2 )K = {s ∈ S : P(s |= JΦ1 K U≤n JΦ2 K) ∈ I}.

Pour évaluer les probabilités, nous exploitons le théorème 4 et évaluons f n (0).

Exemple.

Reconsidérons la chaîne de Markov M de la figure 10.1 et cette formule:

Φ := P=1 (F succès) ∧ P=1 (G(envoyer → P≥0,99 (F≤3 succès))) .
| {z } | {z }
Φ1 Φ2

Par la proposition 15, JΦ1 K = S car M est fortement connexe. Évaluons

P(s |= F≤3 succès) pour chaque état s à l’aide du théorème 4. Nous avons
S0 = ∅, S1 = {succès} et S? = {départ, envoyer, échec},
   
0 1 0 0
A = 0 0 1/10 et b = 9/10 .
0 1 0 0
En évaluant f 3 (0), où f (y) = A · y + b, nous obtenons le vecteur
x = (9/10, 99/100, 9/10).
Ainsi,
JP≥0,99 (F≤3 succès)K = {s ∈ S : x(s) ≥ 99/100} = {envoyer, succès}.
CHAPITRE 10. SYSTÈMES PROBABILISTES 121

Nous obtenons donc

JΦ2 K = JP=1 (G(envoyer → P≥0,99 (F≤3 succès)))K

= JP=0 (F¬(envoyer → P≥0,99 (F≤3 succès)))K
= JP=0 (F(envoyer ∧ ¬P≥0,99 (F≤3 succès)))K
= {s ∈ S : P(s |= F({envoyer} ∩ {envoyer, succès})) = 0}
= {s ∈ S : P(s |= F({envoyer} ∩ {départ, échec})) = 0}
= {s ∈ S : P(s |= F ∅) = 0}
= S.

Ainsi JΦK = JΦ1 K ∩ JΦ2 K = S et, en particulier, l’état initial satisfait Φ.

10.5 Outils
La vérification formelle de chaînes de Markov (et de processus de décision mar-
koviens) est supportée par des outils comme PRISM [KNP11] et Storm [HJK+ 20].
Par exemple, la chaîne de Markov de la figure 10.1 se modélise avec PRISM: 
dtmc

const double p = 0.9;

module systeme
// 0 = départ, 1 = envoyer, 2 = succès, 3 = échec
etat : [0..3] init 0;

[] (etat = 0) -> (etat' = 1);

[] (etat = 1) -> p : (etat' = 2) + (1 - p) : (etat' = 3);
[] (etat = 2) -> (etat' = 0);
[] (etat = 3) -> (etat' = 1);
endmodule

// Propositions atomiques
label "envoyer" = (etat = 1);
label "succes" = (etat = 2);

PRISM vérifie automatiquement les propriétés de l’exemple précédent:

P>=1 [ F "succes" ]
P>=1 [ G "envoyer" => P>=0.99 [ F<=3 "succes" ] ]

Il sait également calculer des probabilités. Par exemple, la requête suivante

calcule P(départ |= F≤3 succès) = 0,9:
CHAPITRE 10. SYSTÈMES PROBABILISTES 122

P=? [ F<=3 "succes" ]

PRISM peut aussi performer des analyses quantitatives. Par exemple, nous
pouvons calculer l’espérance du nombre d’envois effectués avant un succès, en
ajoutant ce bloc de code:

// Incrémente le nombre d'envois chaque fois que «envoyer» est atteint

rewards "nombre_envois"
(etat = 1) : 1;
(etat = 0 | etat = 2 | etat = 3) : 0;
endrewards

puis en effectuant cette requête qui retourne (une approximation de) 10/9:

R{"nombre_envois"}=? [ F "succes" ]
CHAPITRE 10. SYSTÈMES PROBABILISTES 123

10.6 Exercices
10.1) Soit M la chaîne de Markov de la figure 10.2. ?
a) Calculez P(s0 |= Fs2 ) à l’aide d’une somme exhaustive des chemins.
b) Calculez P(GFp).
c) Calculez P(p U q).
d) Calculez P(G(p ∨ q)).
e) Calculez P(XX¬q).

10.2) Cette fonction de Knuth et Yao cherche à simuler un dé à six faces à l’aide ?
d’une pièce non biaisée:
from random import randint

def lancer_de():
x = randint(0, 1)

while True:
y = randint(0, 1)
z = randint(0, 1)

if not(x == y == z):
break

return 4*x + 2*y + z

a) Spécifiez en PCTL que la fonction « lancer_de » simule bien un dé,

en raisonnant sur sa modélisation ci-dessous.
b) Vérifiez que l’état initial satisfait votre formule.

---

1/2 1/2

1/2 0-- 1-- 1/2

1/2 1/2 1/2 1/2

00- 01- 10- 11-

1/2 1/2 1/2 1/2

1/2 1/2

001 010 011 100 101 110

1 1 1 1 1 1
CHAPITRE 10. SYSTÈMES PROBABILISTES 124

(adapté de [BK08])

10.3) Nous disons qu’une formule CTL Φ et qu’une formule PCTL Φ′ sont équi- ?
valentes lorsque JΦK = JΦ′ K pour toute structure de Kripke. Montrez que
ces formules ne sont pas équivalentes à l’aide de contre-exemples:
a) Φ := ∀Fp et Φ′ := P=1 (Fp)
b) Φ := ∃Gp et Φ′ := P>0 (Gp)

10.4) Exprimez (10.2) en terme de matrice et de vecteur.

10.5) ⋆ Montrez que les ensembles XA, GA et A U B sont mesurables.

10.6) ⋆ Dites pourquoi l’ensemble A := {ρ : inf(ρ) est une CFC terminale} dé-
fini à la proposition 15 est un événement.

10.7) Considérons la modélisation ci-dessous du protocole IPv4 zeroconf para- ?

métré par n = 3, a = 1/4 et b = 1/10. Les propositions atomiques pIP , p?
et p⊥ indiquent respectivement que l’hôte s’est fait attribuer une adresse
IP; que l’hôte est en attente d’une réponse à une requête; et que l’hôte
crée une collision sur le réseau. Spécifiez ces propriétés en PCTL:
a) Une adresse IP est attribuée presque sûrement.
b) Avec probabilité au moins 1/2, au plus deux requêtes sont effectuées
avant qu’une adresse IP soit attribuée.
c) L’hôte crée une collision presque jamais.
d) Il y a une infinité de requêtes avec probabilité non nulle.
e) Presque sûrement, une adresse IP attribuée demeure attribuée.

∅ {p? } {p? } {p? } {p? } {pIP , p⊥ }

b a a a 1
1 s0 s1 s2 s3 s4 s5 1
1−a
1−b
1−a
{p? } t
1−a

{pIP } u 1

(adapté de [BK08])

10.8) Considérons une variante distribuée du jeu roche-papier-ciseaux consti- ?

tuée de n agents. Chaque agent débute dans un état parmi {, , }. À
CHAPITRE 10. SYSTÈMES PROBABILISTES 125

chaque moment, une paire d’agents est choisie uniformément au hasard

et l’état des deux agents est mis à jour selon ces règles:

,  → , 
,  → , 
,  → , 
q, q → q, q pour q ∈ {, , }.

Si tous les agents se stabilisent dans le même état, alors le jeu se termine.
Calculez la probabilité que le jeu se termine dans un certain état lorsque
a) il y a initialement trois agents distincts;
b) il y a initialement deux , un  et un .
 Solutions des exercices

Cette section présente des solutions à certains des exercices du document. Dans
certains cas, il ne s’agit que d’ébauches de solutions.

126
SOLUTIONS DES EXERCICES 127

Chapitre 1
1.1)
a) Par ex. pour s = s2 :

Post(s2 ) = {s1 , s2 , s3 },
Pre(s2 ) = {s1 , s2 },
Post∗ (s2 ) = {s1 , s2 , . . . , s6 },
Pre∗ (s2 ) = {s0 , s1 , s2 }.

b) s0 −
→ s1 −
→ s2 −
→ s3 −
→ s4 .
c) Par ex. s0 −
→ s0 −
→ s0 −
→ ···.
d) Par ex. s0 −
→ s1 −
→ s2 −
→ s1 −
→ · · · ou s0 −
→ s5 −
→ s6 −
→ s6 −
→ ···

1.2)
a)

x = vrai x = faux

x ← faux
xv xf

x ← vrai

x ← vrai x ← faux

b)

x = vrai

x = faux crit x ← vrai

1 2 3 4

noncrit

c)
SOLUTIONS DES EXERCICES 128

noncrit
x = vrai

crit x ← vrai
1, xv 2, xv 3, xv 4, xv

x ← vrai

x = faux crit
1, xf 2, xf 3, xf 4, xf

noncrit

d) Si les étiquettes sont les mêmes, alors on obtient une composition

complètement synchrone où les systèmes doivent évoluer en même
temps. Si elles sont disjointes, alors on obtient une composition où
les deux systèmes évoluent indépendamment.

1.3) Nous obtenons ces systèmes de transition étiquetés:

b1 = 1

b0 ← 1 b1 = 0
nc0 t0 c0 b0 ← 0 b0 ← 1
b0 = 0 b0 = 1
b0 ← 1
b0 ← 0
0 1
b0 ← 0
b1 ← 0
b0 = 1 q1′ q1

b1 ← 0 b1 ← 1
b1 = 0 b1 = 1
b0 = 0 b0 = 1
b1 ← 1

b1 ← 1 b0 = 0 0 1
nc1 t1 c1
b1 ← 0

b1 ← 0

Le produit asynchrone correspond à:

SOLUTIONS DES EXERCICES 129

0, 0, nc0 , q1′

b0 = 0 b0 ← 0

b0 ← 0 b1 ← 0
1, 0, c0 , nc1 1, 1, c0 , q1 1, 0, c0 , q1′ b0 ← 1

b1 = 0 b1 ← 1 b0 ← 0
b0 = 1
b0 = 1
b0 ← 0 b0 ← 1 b1 ← 0
1, 0, t0 , nc1 1, 1, c0 , t1 0, 1, nc0 , q1

b0 ← 1
b1 = 0
b1 ← 1

b0 = 1 b1 ← 0
0, 0, nc0 , nc1 1, 1, t0 , t1 1, 1, t0 , q1 1, 0, t0 , q1′

b0 ← 1 b1 = 1 b1 = 1 b1 = 1
b1 ← 1

0, 1, nc0 , t1 1, 1, t0 , c1
b1 ← 0
b1 ← 0 b1 = 1
b0 = 0 b0 ← 1

0, 1, nc0 , c1

1.4) Post∗ (s) ∩ Pre∗ (s)

1.5) Supposons que ce ne soit pas le cas. Puisque T est fini et que le chemin est
infini, il existe une composante fortement connexe C ⊆ S visitée infini-
ment souvent. En particulier, il existe donc un état si ∈ C visité infiniment
souvent. Par hypothèse, {si , si+1 . . .} ̸⊆ C. Ainsi, il existe un indice j > i
tel que sj ̸∈ C. Puisque si est visité infiniment souvent, il existe un indice
k > j tel que sk = si .
∗ ∗
Ainsi, si −
→ sj −→ si , ce qui implique la contradiction sj ∈ C.

1.6)
pour i ∈ [1..n]
xi ← 0

boucler
pour i ∈ [1..n]
xi ← 1 − xi
si xi = 1 alors quitter bloc si
SOLUTIONS DES EXERCICES 130

Chapitre 2
2.1)
a) À un certain point, seul le feu vert est allumé.
b) On ne peut pas immédiatement passer du rouge au vert.
c) Lorsque le feu rouge est allumé, c’est aussi éventuellement le cas du
jaune, puis du vert.

2.2) Il existe bien des solutions (une infinité), en voici des exemples:
a) — satisfait: ∅{vert}∅ω
— ne satisfait pas: ({vert, jaune}{rouge})ω
b) — satisfait: ({rouge}{rouge}{vert})ω
— ne satisfait pas: {rouge}({rouge}{vert})ω
c) — satisfait: {rouge}{jaune}{vert}∅ω
— ne satisfait pas: {rouge}{jaune, vert}∅ω

2.3)
a)

G((rouge ∧ ¬jaune ∧ ¬vert) ∨

(¬rouge ∧ jaune ∧ ¬vert) ∨
(¬rouge ∧ ¬jaune ∧ vert))

b) GF rouge
c) ¬F ((rouge ∧ ¬vert) ∧ X ((¬jaune) U (¬rouge ∧ vert)))

2.4)
a) G(d → Fr) ou G(d → XFr) (selon l’interpétation de « suivie »)
b) FG d
c) F(d ∧ r)
d) GF r

2.5)
a)

σ |= F(φ1 ∨ φ2 )
⇐⇒ ∃j ≥ 0 : σ[j..] |= (φ1 ∨ φ2 ) (par déf. de F)
⇐⇒ ∃j ≥ 0 : (σ[j..] |= φ1 ) ∨ (σ[j..] |= φ2 ) (par déf. de ∨)
⇐⇒ (∃j ≥ 0 : σ[j..] |= φ1 ) ∨ (∃j ≥ 0 : σ[j..] |= φ2 ) (par distributivité)
⇐⇒ (σ |= Fφ1 ) ∨ (σ |= Fφ2 ) (par déf. de F)
SOLUTIONS DES EXERCICES 131

b)

G(φ1 ∧ φ2 ) ≡ ¬F¬(φ1 ∧ φ2 ) (par déf. de G)

≡ ¬F(¬φ1 ∨ ¬φ2 ) (loi de De Morgan)
≡ ¬((F¬φ1 ) ∨ (F¬φ2 )) (par exercice préc.)
≡ (¬F¬φ1 ) ∧ (¬F¬φ2 ) (loi de De Morgan)
≡ (G¬¬φ1 ) ∧ (G¬¬φ2 ) (par dualité)
≡ (Gφ1 ) ∧ (Gφ2 ) (double négation)

2.6) φ W ψ := (φ U ψ) ∨ (Gφ)

2.7) φ R ψ := (ψ U (ψ ∧ φ)) ∨ Gψ, ou alternativement φ R ψ := ψ W (ψ ∧ φ)

2.8)
a) Oui, nous avons bien (φ ∨ ψ) U ψ ≡ φ U ψ. La formule de droite im-
plique celle de gauche puisqu’elle est syntaxiquement plus restrictive.
De plus, celle de gauche implique celle de droite car en choisissant
la première position qui satisfait ψ, toutes les positions précédentes
satisfont forcément φ.
Plus formellement, soit σ |= (φ ∨ ψ) U ψ. Il existe j ∈ N tel que

(∀0 ≤ i < j : σ[i..] |= φ ∨ ψ) ∧ σ[j..] |= ψ. (*)

Considérons l’indice j minimal qui satisfait (*). Par minimalité, au-

cun suffixe avant la position j ne satisfait ψ. Ainsi, nous avons:

(∀0 ≤ i < j : σ[i..] |= φ) ∧ σ[j..] |= ψ,

ce qui implie σ |= φ U ψ.
b) Non, par exemple, pour σ := {p}ω :

σ |= p U (p ∨ q),
σ ̸|= p U q.

c) Non, par exemple, pour σ := {p}∅ω :

σ |= ¬(p U q),
σ ̸|= (¬p) U (¬q).

d) Oui. Schématiquement, nous avons:

ψ ψ φ

Xψ Xψ Xφ
SOLUTIONS DES EXERCICES 132

Plus formellement:

σ |= X(φ U ψ) ⇐⇒ σ[1..] |= φ U ψ
⇐⇒ ∃j(∀0 ≤ i < j : (σ[1..])[i..] |= φ) ∧ (σ[1..])[j..] |= ψ
⇐⇒ ∃j(∀0 ≤ i < j : (σ[i..])[1..] |= φ) ∧ (σ[j..])[1..] |= ψ
⇐⇒ ∃j(∀0 ≤ i < j : σ[i..] |= Xφ) ∧ (σ[j..]) |= Xψ
⇐⇒ σ |= (Xφ) U (Xψ).

2.9) Si σ |= FG(φ1 ∧φ2 ), alors il existe un point à partir duquel tous les suffixes
de σ satisfont φ1 ∧ φ2 , et par conséquent σ |= FGφ1 et σ |= FGφ2 .
L’autre direction est moins évidente. Supposons que σ |= FGφ1 et σ |=
FGφ2 . Cela signifie qu’il existe un point i à partir duquel tous les suffixes
de σ satisfont φ1 , et un autre point j à partir duquel tous les suffixes de σ
satisfont φ2 . Par conséquent, à partir du point max(i, j), tous les suffixes
de σ satisfont à la fois φ1 et φ2 .

2.10)

GFp → FG(q ∨ r) (r U Xp) U (q ∧ ¬XXs)

∅ω
oui non
{p, q, r, s} ω
oui non
{p, q} ω
oui oui
{r}∅{p, q, s}ω oui non
{r}∅({p, q}{r, s})ω
oui oui
{r}∅{p}{q, r}({p, s}∅) ω
non non

2.11)
(a–b)

chan c = [1] of { bit };
byte crit = 0;

init
{
atomic
{
run process(0)
run process(1)
}
}

proctype process(bit i)
{
SOLUTIONS DES EXERCICES 133

request:
c ! i

wait:
c ? i

critical:
atomic
{
crit++
assert(crit == 1)
}

noncritical:
atomic
{
crit--
goto request
}
}

#define crit0 process[0]@critical

#define crit1 process[1]@critical

ltl mutex { [](!crit0 || !crit1) }

(c–d)
processus(i):
tant que vrai
/* section non critique */
c?1
/* section critique */
c!1

chan c = [1] of { bit };

init
{
atomic
{
c ! 1
run process(0)
run process(1)
}
}

proctype process(bit i)
{
noncritical:
skip
SOLUTIONS DES EXERCICES 134

wait:
c ? 1

critical:
skip

leave:
atomic
{
c ! 1
goto noncritical
}
}

#define crit0 (process[0]@critical)

#define wait0 (process[0]@wait)
#define pid0 (process[0]:_pid)

#define crit1 (process[1]@critical)

#define wait1 (process[1]@wait)
#define pid1 (process[1]:_pid)

#define phi0 (<>[](enabled(pid0)) && !(_last == pid0))

#define phi1 (<>[](enabled(pid1)) && !(_last == pid1))
#define weak (!phi0 && !phi1)

#define phi0_ ([]<>(enabled(pid0)) && <>[](_last != pid0))

#define phi1_ ([]<>(enabled(pid1)) && <>[](_last != pid1))
#define strong (!phi0_ && !phi1_)

#define ev_enter ([](wait0 -> <> crit0) && [](wait1 -> <> crit1))

ltl mutex { [](!crit0 || !crit1) }

ltl enter_unfair { ev_enter }
ltl enter_weak { weak -> ev_enter}
ltl enter_strong { strong -> ev_enter}

2.12)

a) Oui. f) Non.
b) Non. g) Oui.
c) Non. h) Oui.
d) Oui. i) Oui.
e) Oui. j) Non.

2.13) Non. Posons σ := {q}{p}{q, r}∅ω . Nous avons σ ̸|= p U (q U r) et σ |=

(p U q) U r.
SOLUTIONS DES EXERCICES 135

Chapitre 3
3.1)
sans b un seul b plusieurs b infinité de b
z}|{ z }| { z }| { z }| {
a) aω + a∗ baω + a∗ (b(aa)∗ )∗ aω + a∗ (b(aa)∗ )ω ou a∗ (b + aa)ω

a b
a
b

a
b)
sans b un seul b
z }| { z }| {
(a + c)ω + (a + c)∗ b(a + c)ω +
(a + c)∗ (b(c + ac∗ ac∗ ))∗ (a + c)ω + (a + c)∗ (b(c + ac∗ ac∗ ))ω
| {z } | {z }
plusieurs b infinité de b

a, c b, c c
a
b

c) (b + c + ac)ω + (b + c + ac)∗ (a + c)ω

b, c a, c
a

c
3.2) a) Oui, les deux décrivent {σ ∈ {a, b} : σ contient une infinité de a et b}
ω

b) Non, la première expression reconnaît bω et pas l’autre.

Remarque.

Si vous connaissez la théorie de la complexité, sachez que le pro-

blème qui consiste à déterminer si deux expressions ω-régulières
décrivent le même langage est EXPSPACE-complet.

3.5) En les mettant simplement l’un à côté de l’autre, puisque plusieurs états
initiaux sont permis.
SOLUTIONS DES EXERCICES 136

3.6) Non, par exemple l’automate ci-dessous accepte aω . En inversant son état
acceptant et son état non acceptant, l’automate accepte le même langage.

3.7)

p, s, A q, s, A q, s, B

a b a
c c

a
q, t, A r, t, A q, t, B r, t, B
a

3.8) Oui, il suffit d’ajouter un nouvel état ∪ q0 , d’en faire l’unique état initial, et
d’ajouter les transitions δ(q0 , a) := q∈Q0 δ(q, a).

3.9) Non, par exemple cela est impossible pour le langage aω + bω .

3.10) ⋆ Afin d’obtenir une contradiction, supposons qu’il existe un automate de

Büchi déterministe A = (Q, Σ, δ, {q0 }, F ) qui accepte (a + b)∗ aω . Posons
n := |Q|. Puisque A accepte baω , il existe i1 ∈ N et un état acceptant
q1 ∈ F tel que
bai1
q0 −−−→ q1 .
Remarquons que A accepte également le mot infini ai1 baω . Comme l’au-
tomate est déterministe, il existe i2 ∈ N et un état acceptant q2 ∈ F tel
que
bai1 bai2
q0 −−−→ q1 −−−→ .
En répétant cet argument n + 1 fois, nous obtenons i1 , . . . , in+1 ∈ N et
q1 , . . . , qn+1 ∈ F tels que
bai1 bai2 bain+1
q0 −−−→ q1 −−−→ · · · −−−−→ qn+1 .
SOLUTIONS DES EXERCICES 137

Par le principe des pigeonniers (ou des tiroirs), il existe 1 ≤ j < k ≤ n + 1

tel que qj = qk . Nous obtenons donc

bai1 ···baij baij+1 ···baik

q0 −−−−−−→ qj −−−−−−−−→ qj .

Puisque qj est acceptant, A accepte un mot qui contient une infinité de b,

ce qui est une contradiction.

3.11) Non. Par exemple, dans le cas suivant, L(A) = {a, b}ω = L(A′ ):

a b b a
b a

a b
SOLUTIONS DES EXERCICES 138

Chapitre 4
4.1) Posons Σ := 2AP .
a) ∅({p} + {p, q})ω

Σ {p}, {p, q}
Σ

b) Σ∗ ({p} + {p, q})ω

Σ {p}, {p, q}

{p}, {p, q}

c) ({p}∗ ({q} + {p, q}))ω

{p} {q}, {p, q}

{q}, {p, q}

{p}

d) ({p} + {p, q})∗ Σ({q} + {p, q})Σω

{p}, {p, q} Σ

Σ {q}, {p, q}

e) ({p} + {q} + {p, q})Σω

{p}, {q}, {p, q}

f) (∅ + {q} + {p, q} + [{p}Σ∗ ({q} + {p, q})])ω

SOLUTIONS DES EXERCICES 139

∅, {q}, {p, q} ∅, {p}

{p}

{q}, {p, q}

∗
g) [(∅ + {p} + {q})∗ {p, q}] + [(∅ + {p} + {q})∗ {p, q}] Σ{p}ω
ω

∅, {p}, {q}

{p, q} {p} ∅, {p}, {q}

∅, {p}, {q}
{p}

{p, q}

{p, q}

4.2)
a) Nous considérons l’algorithme 2 (détection linéaire par parcours post-
ordre). Après un premier parcours en profondeur, nous obtenons cet
étiquetage des états:

15 16

q2

c a
1 18 2 17 3 14

a b
q0 q1 q3
11 12
a
b q6 b a

c
a b
q5 q4 q7 q8
b
9 10 4 13 5 8 6 7

Ainsi, les états acceptants découverts sont [q7 , q6 , q1 ] en post-ordre.

La deuxième exploration à partir de q7 visite [q7 , q8 ] et ainsi aucun
SOLUTIONS DES EXERCICES 140

cycle n’est identifié. La seconde exploration à partir de q6 visite [q1 , q3 ,

q4 , q7 , q5 , q1 , q6 ] et ainsi un cycle de q6 vers lui-même est découvert.
Par conséquent, l’algorithme identifie un lasso de la forme
∗ +
q0 −
→ q6 −
→ q6 .

Plus précisément, il s’agit de q0 −

→ q1 −
→ q3 −
→ q4 −
→ q6 .
b) Peu importe l’ordre du premier parcours en profondeur, l’état ac-
ceptant q1 sera entièrement traité après q6 . Ainsi, q6 se situe avant
q1 dans tout post-ordre. Ainsi, il n’y aura jamais de seconde fouille
lancée à partir de q1 car un lasso autour de q6 sera d’abord trouvé.

4.3)
a) ∅
b) Voici la construction pour Σ = {a, b, c} qui se généralise à un alpha-
bet arbitraire:

a b

b
p q
a
c b
a c
r

c
SOLUTIONS DES EXERCICES 141

4.4)

{p}

{p}
p, Xp p, ¬Xp

∅
∅ {p}
{p}

¬p, Xp ¬p, ¬Xp

∅

4.5) On peut utiliser la même idée que pour l’exercice 3.10). Afin d’obtenir une
contradiction, supposons qu’il existe un automate de Büchi déterministe
A = (Q, Σ, δ, {q0 }, F ) tel que L(A) = JFGpK. Remarquons que ∅{p}ω ∈
L(A). Il existe donc n1 ∈ N tel que ∅{p}n1 atteint un état acceptant q1 ∈ F
à partir de q0 . Le mot ∅{p}n1 ∅{p}ω est aussi accepté par A. Ainsi, il existe
n2 ∈ N tel que ∅{p}n1 ∅{p}n2 atteint un état acceptant q2 ∈ F à partir
de q0 . Puisque l’automate est déterministe, le préfixe commun à ces deux
mots traverse les mêmes états. Ainsi, nous avons:
∅{p}n1 ∅{p}n2
q0 −−−−→ q1 −−−−→ q2 .

En répétant ce processus infiniment, nous obtenons des tailles n1 , n2 , . . . ∈

N et des états q1 , q2 , . . . ∈ F tels que
∅{p}n1 ∅{p}n2 ∅{p}n3
q0 −−−−→ q1 −−−−→ q2 −−−−→ · · ·
∏
Par conséquent, le mot σ := i≥1 ∅{p}ni est accepté par A puisqu’il visite
F infiniment souvent. Cela contradit σ ̸|= FGp.
SOLUTIONS DES EXERCICES 142

Chapitre 5
5.1)
a) Oui, en prenant une trace de la forme {p}{q} · · · .
b) Oui. De s0 à s2 on obtient {p}{q} qui satisfait ∃p U ¬p. L’état s2 sa-
tisfait q, donc toute trace à partir de s2 satisfait trivialement ¬p U q.
c) Non, la trace ({p}{p, q})ω ne satisfait pas p U ¬p, donc ce n’est pas
nécessaire d’explorer le côté droit de la conjonction.
d) Non, cette propriété est plus forte que la précédente.

5.2) a) Cette structure de Kripke satisfait ∀F(p ∨ q), mais pas (∀Fp) ∨ (∀Fq):

{q} ∅ {p}

s2 s0 s1

b) Cette structure de Kripke satisfait (∃Gp) ∧ (∃Gq), mais pas ∃G(p ∧ q):

{q} {p, q} {p}

s2 s0 s1

c) Cette structure satisfait ∀((¬p) U (¬q)), mais pas ¬∃(p U q):

{p} {q}

s0 s1

5.4)
a) Cette structure de Kripke satisfait FGp mais pas ∀F∀Gp:

{p} {q} {p}

s0 s1 s2
SOLUTIONS DES EXERCICES 143

b) La structure de Kripke ci-dessus satisfait FXp mais pas ∀F∀Xp.

5.5) Soit T une structure de Kripke.

⇒) Supposons que T |= ∀G∀Fp. Soit s0 s1 · · · une exécution infinie de T .
Nous devons montrer que trace(s0 s1 · · · ) |= GFp, ou, autrement dit, que
pour tout j ∈ N, il existe i ≥ j tel que p ∈ L(si ). Soit j ∈ N. Puisque s0 |=
∀G∀Fp, en particulier s0 s1 · · · |= G∀Fp. Ainsi, sj |= ∀Fp. En particulier,
cela implique que sj sj+1 · · · |= Fp. Il existe donc i ≥ j tel que p ∈ L(si ).
⇐) Supposons que T |= GFp. Soit s0 un état initial de T . Nous devons
montrer que s0 |= ∀G∀Fp, ou, autrement dit, que sj |= ∀Fp pour toute
exécution s0 s1 · · · et tout j ≥ 0. Soit s0 s1 · · · une exécution et soit j ≥ 0.
Considérons σ := sj sj+1 · · · . Nous devons montrer que trace(σ) |= Fp.
Par hypothèse, trace(s0 s1 · · · ) |= GFp. Ainsi, p est satisfaite infiniment
souvent sur cette trace. En particulier, il existe donc i ≥ j tel que p ∈ L(si ).
Par conséquent, trace(σ) |= Fp.

5.6)
a) Oui.
b) Non.
c) Oui.
SOLUTIONS DES EXERCICES 144

Chapitre 6
6.1) Afin d’illustrer les étapes de calcul, ces solutions utilisent des ensembles
d’états comme propositions atomiques (par abus de notation):
a) ∃F{s4 , s5 } ≡ {s4 , s5 , s6 , s7 }
b) ∃G{s0 , s1 , s2 , s4 } ≡ {s0 , s2 , s4 }
c)

∀X(¬Φ1 ∨ ¬Φ2 ) ≡ ¬∃X(Φ1 ∧ Φ2 )

≡ ¬∃X({s4 , s5 , s6 , s7 } ∧ {s0 , s2 , s4 })
≡ ¬∃X{s4 }
≡ ¬{s6 }
≡ S \ {s6 }.

6.2) La réécriture de ∀(Φ1 U Φ2 ) copie trois fois Φ2 . Donc, si on compose des

occurrences de ∀ U à droite, la réécriture explosera exponentiellement.
Par exemple, posons Φ0 := q et Φn := ∀(p U Φn−1 ). La formule Φn possède
n quantificateurs. Soit f (n) le nombre de quantificateurs dans la forme
normale existentielle de Φn . Par définition, nous avons:
{
0 si n = 0,
f (n) =
3 · f (n − 1) + 2 sinon.

Ainsi:

f (n) = 3 · f (n − 1) + 2
= 3[3 · f (n − 2) + 2] + 2
= 32 · f (n − 2) + 8
= 32 · [3 · f (n − 3) + 2] + 8
= 33 · f (n − 3) + 26
= 33 · f (n − 3) + (33 − 1)
..
.
= 3i · f (n − i) + (3i − 1)
..
.
= 3n · f (n − n) + (3n − 1)
= 3n − 1.

Par conséquent, le nombre de quantificateurs de la forme normale appar-

tient à Θ(3n ).
SOLUTIONS DES EXERCICES 145

Remarquons aussi que l’arbre syntaxique de Φn a 2n + 1 sommets. Soit

g(n) le nombre de sommets de l’arbre syntaxique de Φn après sa mise en
forme normale. Nous avons:
{
1 si n = 0,
g(n) =
(7 + 2 · g(n − 1)) + (3 + g(n − 1)) = 10 + 3 · g(n − 1) sinon.

En résolvant cette récurrence linéaire non homogène, on conclut qu’après

la mise en forme normale, l’arbre syntaxique possède g(n) = 6 · 3n − 5 ∈
Θ(3n ) sommets.

6.3) On obtient des algorithmes en utilisant ces caractérisations:

∗
— J∃FΦK = {s ∈ S : ∃s′ ∈ JΦK t.q. s −
→ s′ }
— J∀FΦK est le plus petit ensemble T ⊆ S tel que JΦK ⊆ S et (Post(s) ⊆
T =⇒ s ∈ T )
— J∀XΦK = {s ∈ S : Post(s) ⊆ JΦK}
— J∀(Φ1 U Φ2 )K est le plus petit ensemble T ⊆ S tel que JΦ2 K ⊆ T et
(s ∈ JΦ1 K ∧ Post(s) ⊆ T ) =⇒ s ∈ T .

6.5) Voir pile_avec_solutions.smv. 

6.7) a) On calcule d’abord le sous-graphe induit par Φ. Ensuite, on identi-
fie ses composantes fortement connexes. Un état satisfait ∃équit GΦ
ssi
∧ il peut atteindre une composante fortement connexe C telle que
1≤i≤n (C ∩ Si ̸= ∅).
b) ∃équit (Φ1 U Φ2 ) ≡ ∃(Φ1 U (Φ2 ∧ ∃équit G vrai))
SOLUTIONS DES EXERCICES 146

Chapitre 7
7.1) Par exemple, le BDD ci-dessous calcule (x1 ∨ ¬x2 ) ∧ (¬x2 ∨ x3 ) sous l’ordre
x3 < x1 < x2 . Ce BDD possède trois sommets internes, alors que celui de
la figure 7.2 en possède quatre.

x3

x1 x2

7.2) Posons φn := (x1 ↔ y1 ) ∧ · · · ∧ (xn ↔ yn ). Sous l’ordre x1 < y1 < · · · <

xn < yn , φn a un BDD de 3n sommets internes, alors que sous l’ordre
x1 < · · · < xn < y1 < · · · < yn , φn a un BDD de taille Ω(2n ).

7.3) a) En exécutant build, nous obtenons:

⃝
5
⃝
5 x1
(x1 ∧ x3 ) ∨ x2 , 1) ⃝
2 ⃝
4
⃝
2 ⃝
4 x2 x2
(x2 , 2) (x3 ∨ x2 , 2)
⃝
0 ⃝
1 ⃝
3 ⃝
1
x3 ⃝
3
(faux, 3) (vrai, 3) (x3 , 3) (vrai, 3)

⃝
0 ⃝
1
(faux, 4) (vrai, 4) 0 1

b) En exécutant build, nous obtenons:

SOLUTIONS DES EXERCICES 147

⃝
7 ⃝
5
x1 x1
⃝
2 ⃝
4

⃝ ⃝
6 x2 x2 x2
7
(x1 ⊕ x2 , 1)
⃝
2 ⃝
6 x3 ⃝
3
(x2 , 2) (¬x2 , 2)
⃝
0 ⃝
1 ⃝
1 ⃝
0
(faux, 3) (vrai, 3) (vrai, 3) (faux, 3) 0 1

c) En exécutant apply∧ (5, 7), nous obtenons:

⃝
7 ⃝ ⃝
9
5
x1 x1 x1
⃝
2 ⃝
4

⃝
6 x2 x2 x2 ⃝
8 x2
⃝
9
(5, 7) x3 ⃝
3
⃝
2 ⃝
8
(2, 2) (4, 6)
⃝
0 ⃝1 ⃝
3 ⃝0 0 1
(0, 0) (1, 1) (3, 1) (1, 0)
⃝0 ⃝
1
(0, 1) (1, 1)

d) Le résultat pourrait être obtenu à l’aide de exists(5, 3). Procédons

manuellement. Comme f = (x1 ∨ ¬x2 ) ∧ (¬x2 ∨ x3 ), nous avons:

∃x3 : f = [(x1 ∨ ¬x2 ) ∧ (¬x2 ∨ 0)] ∨ [(x1 ∨ ¬x2 ) ∧ (¬x2 ∨ 1)]

= [(x1 ∨ ¬x2 ) ∧ ¬x2 ] ∨ [x1 ∨ ¬x2 ]
= ¬x2 ∨ [x1 ∨ ¬x2 ]
= x1 ∨ ¬x2 .

Cette fonction se représente par un sommet u tel que T [u] = (x1 , v, 1)

et T [v] = (x2 , 0, 1). Un tel sommet v = 6 existe déjà. Aucun sommet
tel que T [u] = (x1 , 1, 6) n’existe. Il faut donc en ajouter un nouveau
nommé 10. Nous obtenons donc:
SOLUTIONS DES EXERCICES 148

⃝
10 ⃝
7 ⃝ ⃝
9
5
x1 x1 x1 x1
⃝
2 ⃝
4

⃝
6 x2 x2 x2 ⃝
8 x2

x3 ⃝
3

0 1

7.4) a) Par le lemme 1, il suffit de tester si u = v.

b) Dans les trois algorithmes ci-dessous, les termes de la forme 0k et 1k
dénotent la répétition de bits (par ex. 03 = 000), et les termes de la
forme 2k dénotent l’exponentiation (par ex. 23 = 8).

Entrées : sommet u
Sorties : {x ∈ {0, 1}n : fu (x1 , . . . , xn ) = vrai}
sol(u):
sol'(u, i):
si u = 0 alors retourner ∅
sinon si u = 1 alors retourner {0, 1}n−i+1
sinon
ℓ ← var(u) − i
X0 ← sol'(lo(u), var(u) + 1)
X1 ← sol'(hi(u), var(u) + 1)
retourner {abc : a ∈ {0, 1}ℓ , b ∈ {0, 1}, c ∈ Xb }
retourner sol'(u, 1)
SOLUTIONS DES EXERCICES 149

c)

Entrées : sommet u
Sorties : x ∈ {0, 1}n tel que fu (x1 , . . . , xn ) = vrai
sat(u):
sat'(u, i):
si u = 0 alors retourner ⊥
sinon si u = 1 alors retourner 1n−i+1
sinon
ℓ ← var(u) − i
X1 ← sat'(hi(u), var(u) + 1)
si X1 ̸= ∅ alors
b ←1
c ← un élément de X1
sinon
X0 ← sat'(lo(u), var(u) + 1)
b ←0
c ← un élément de X0
retourner 1ℓ bc
retourner sat'(u, 1)

d)

Entrées : sommet u
Sorties : |{x ∈ {0, 1}n : fu (x1 , . . . , xn ) = vrai}|
count(u):
count'(u, i):
si u = 0 alors retourner 0
sinon si u = 1 alors retourner 2n−i+1
sinon
ℓ ← var(u) − i
c0 ← count'(lo(u), var(u) + 1)
c1 ← count'(hi(u), var(u) + 1)
retourner 2ℓ · (c0 + c1 )
retourner count'(u, 1)

7.5) Nous expliquons le cas de ∃G. Soit f : S → S la fonction telle que f (T ) :=

Pre(T ) ∩ T . Nous avons
J∃GK = f (· · · f (f (JΦK)))
où f est appliquée jusqu’à l’atteinte d’un point fixe. Il suffit donc d’appli-
quer f symboliquement à répétition jusqu’à stabilisation. L’application de
SOLUTIONS DES EXERCICES 150

f s’appuie sur le calcul de prédécesseurs (via −

→ et exists) et de l’inter-
section (via apply∧ ).

7.6) ⋆⋆ Supposons que la complexité de build soit polynomiale. Soit φ une

expression booléenne. Afin de tester si φ est satisfaisable, nous construi-
sons un BDD B pour φ enraciné en u. Comme build s’exécute en temps
polynomial, B est forcément de taille polynomiale. Par le lemme 1, φ est
satisfaisable ssi u ̸= 0, ce qui se teste en temps constant. Ainsi, le problème
SAT est soluble en temps polynomial, ce qui montre que P = NP.

7.7) a) φp := ¬x1 , φq := x2 et φr := x1 ∨ ¬x2 .

b)

⃝
5 ⃝
2
x1 x1

⃝
4 x2 x2 ⃝
3

c) Après l’exécution de apply∧(2, 3), nous obtenons:

⃝
5 ⃝
2 ⃝
6
x1 x1 x1

⃝
4 x2 x2 ⃝
3

d) Nous omettons les sommets déjà présents car ils ne sont pas utilisés:
SOLUTIONS DES EXERCICES 151

⃝
12

x1
⃝
10

x2

⃝
11

x3 x3 ⃝
9

⃝
8
x4 x4 ⃝
7

e) Nous devons calculer JpK ∪ Pre(JpK) ∪ Pre(Pre(JpK)) ∪ · · · . Le sommet

2 représente JpK. Calculons une représentation de cet ensemble:
Pre(JpK) = {s : ∃t (s, t) ∈ (−
→ ∩ (S × JpK))}.
Le sommet 2 représente JpK sur les variables x1 x2 , alors que nous
avons besoin d’une représentation sur les variables x3 x4 . Ainsi, nous
ajoutons le sommet 13 ci-dessous. Puis, on calcule apply∧ (12, 13) =
17, exists(17, x4 ) = 18, et finalement exists(18, x3 ) = 2:

⃝
13 ⃝
2 ⃝
12 ⃝
18 ⃝
17

x3 x1 x1 x1 x1
⃝
10

x2 x2 ⃝
16

⃝
11 ⃝
14 ⃝
15

x3 x3 ⃝
9 x3 x3

⃝
8
x4 x4 ⃝
7

Comme le sommet 2 représente JpK, cela signifie que Pre(JpK) = JpK.

Il s’agit d’un point fixe et ainsi le sommet 2 représente JFpK.
SOLUTIONS DES EXERCICES 152

Chapitre 8
8.1)
a) Comme il n’y a pas de variables, le système n’a qu’un état p que nous
n’avons pas à illustrer. Les règles sont comme suit:

m0 −
→ f0 m1
m1 −
→ ε
f0 −
→ b0 f 1 | f 1
f1 −
→ ε
b0 −
→ f 0 b1
b1 −
→ ε | b2
b2 −
→ b0

b) On construit un P-automate A tel que Conf(A) = {⟨p, ε⟩} (voir ci-

dessous), on construit B tel que Conf(B) = Pre∗ (Conf(A)), puis on
vérifie si ⟨p, m0 ⟩ ∈ Conf(B).

Remarquons que cette vérification fonctionne même si le point d’en-

trée est appelé avec une pile non vide. En effet,
∗ ∗
⟨p, m0 ⟩ −
→ ⟨p, ε⟩ ⇐⇒ ⟨p, m0 w⟩ −
→ ⟨p, w⟩.

Alternativement, on peut construire A′ tel que Conf(A′ ) = {⟨p, m0 ⟩}

(voir ci-dessous), construire B ′ tel que Conf(B ′ ) = Post∗ (Conf(A)),
puis vérifier si ⟨p, ε⟩ ∈ Conf(B ′ ).

m0
p q

8.2) On construit un P-automate B pour cet ensemble, puis on détermine si

Conf(B) est infini. Pour effectuer ce test, on peut (a) retirer les états non
accessibles de B, (b) retirer les états de B qui ne peuvent pas atteindre un
état final, et (c) tester si l’automate résultant possède un cycle. Ces trois
étapes s’implémentent en temps linéaire par rapport à la taille de B.

8.3) Étiquetons chaque configuration dans l’état (xi , yj ) avec la lettre a sur
le dessus de la pile par la proposition atomique p(xi ,yj ),a . Posons φa :=
∨
i,j∈{0,1} p(xi ,yj ),a .

a) GFφf0
b) Fφε (en supposant que les configurations terminales bouclent sur
elles-mêmes afin que les exécutions soient infinies)
SOLUTIONS DES EXERCICES 153

c) G(φf0 → Fφm0 )
∨
d) FG a∈Γ (p(x0 ,y0 ),a ∧ p(x1 ,y1 ),a )

8.4) Pour chaque état initial p0 qui possède des transitions entrantes, il suffit
de copier p0 par un état p′0 , de rediriger les transitions qui entrent dans p0
vers p′0 , et de copier les transitions sortantes de p0 à p′0 . Le nombre d’états
et transitions ajoutés est linéaire.

8.5) Rappelons d’abord P:

a−
→a
i−
→i
s−
→s

a−
→ sa a−
→ sa a−
→ aa
i−
→ si i−
→ si i−
→ ai
s−
→ ss s−
→ ss s−
→ε s−
→s s−
→ as
p0 p1 p2 p3 p4 p5
sconst_0 sconst_0 smul aconst_null goto -2

Nous obtenons:

s
p0 p1 p2 p3 p4 p5
s
s
a, i
a, i
a, i a, i, s
a, i, s
a, i
a, i, s

Le programme mène donc à une erreur, peu importe le type initialement

sur la pile, car p0 mène directement à l’état final en lisant une lettre. Ce
serait aussi le cas si la pile était vide, mais nous ne l’avons pas modélisé.

8.6) On ajoute simplement une nouvelle règle entre p2 et p3 , et p3 et p4 :

SOLUTIONS DES EXERCICES 154

τ−
→ τ où τ ∈ Γ

τ−
→ sτ τ−
→ sτ s−
→ε s−
→s τ−
→ aτ
où τ ∈ Γ où τ ∈ Γ b−
→ε b−
→s où τ ∈ Γ
p0 p1 p2 p3 p4 p5
sconst_0 sconst_0 smul aconst_null goto -2

8.8) ⋆⋆
Proposition 17. Conf(Bi ) ⊇ Prei (Conf(A)) pour tout i ∈ N.

Démonstration. Nous procédons par induction sur i ∈ N. La validité du

cas de base découle de

Conf(B0 ) = Conf(A) = Pre0 (Conf(A)).

Soient i > 0 et ⟨p, w⟩ ∈ Prei (Conf(A)). Par définition, nous avons

a−
→u
p −−−→P p′ où w = av, w′ = uv, v ∈ Γ∗ et ⟨p′ , w′ ⟩ ∈ Prei−1 (Conf(A)).

Par hypothèse d’induction, ⟨p′ , w′ ⟩ ∈ Conf(Bi−1 ). Ainsi,

p′ −
→Bi−1 p′′ −
→Bi−1 pf où p′ ∈ P , p′′ ∈ Q et pf ∈ F .
u v

Par les applications de la règle d’ajout qui mène de Bi−1 à Bi , ce dernier

possède la transition (p, a, p′′ ). Comme Bi contient toutes les transitions
de Bi−1 , nous obtenons

→Bi p′′ −
a v
p− →Bi pf ,

ce qui implique ⟨p, w⟩ = ⟨p, av⟩ ∈ Conf(Bi ).

Proposition 18. Pre∗ (Conf(A)) ⊇ Conf(Bi ) pour tout i ∈ N.

Démonstration. Nous montrons une propriété plus forte:

w w′ ∗
→Bi q, alors ∃ p′ −→A q et ⟨p, w⟩ −
Si p ∈ P et p − →P ⟨p′ , w′ ⟩.
Procédons par double induction sur i ∈ N, puis |w|. Le cas où i = 0 découle
immédiatement de B0 = A, et le cas où w = ε est trivialement vrai.
w
Supposons que i > 0 et |w| > 0. Si p −→Bi−1 q, alors nous avons terminé
par hypothèse d’induction. Sinon, w = uav, où a ∈ Γ, u, v ∈ Γ∗ ,

→Bi r′ −
u a v
p−
→Bi−1 r − →Bi q,

et Bi−1 ne contient pas la transition (r, a, r′ ). Autrement dit, cette transi-

tion provient de la règle d’ajout. En particulier, cela implique que r ∈ P .
Par hypothèses d’induction, nous avons:
SOLUTIONS DES EXERCICES 155

w′′ ∗
— ∃ p′′ −−→A r et ⟨p, u⟩ −
→P ⟨p′′ , w′′ ⟩, et
w′ ∗
— ∃ p′ −→A q et ⟨r, av⟩ −
→P ⟨p′ , w′ ⟩.
Comme r ∈ P et aucune transition n’entre dans un état initial de A, nous
avons forcément w′′ = ε et nous pouvons donc simplifier par:
∗
— ⟨p, u⟩ −
→P ⟨r, ε⟩, et
w′ ∗
→P ⟨p′ , w′ ⟩.
— p′ −→A q et ⟨r, av⟩ −
Par conséquent:
∗ ∗
⟨p, w⟩ = ⟨p, uav⟩ − →P ⟨p′ , w′ ⟩.
→P ⟨r, av⟩ −

w′ ∗
Ainsi, p′ −→A q et ⟨p, w⟩ −
→P ⟨p′ , w′ ⟩ comme désiré.
SOLUTIONS DES EXERCICES 156

Chapitre 9
9.1)

t2 1, 0, 0, 0 t3

0, 1, 0, 0 0, 0, 1, 1
t1
t2 1, 0, 0, ω t3

0, 1, 0, ω t4 t1 0, 0, 1, ω

9.2)

Itér. Base B Prédecesseurs

(0, 1, 1)t1 = (0, 1, 1)
0 {(0, 1, 1)} (0, 1, 1)t2 = (1, 2, 0)
(0, 1, 1)t3 = (0, 0, 2)
(1, 2, 0)t1 = (0, 2, 0) (0, 0, 2)t1 = (0, 1, 2)
1 {(0, 1, 1), (1, 2, 0), (0, 0, 2)} (1, 2, 0)t2 = (2, 3, 0) (0, 0, 2)t2 = (1, 1, 1)
(1, 2, 0)t3 = (1, 1, 1) (0, 0, 2)t3 = (0, 0, 3)
(0, 2, 0)t1 = (0, 2, 0)
2 {(0, 1, 1), (0, 2, 0), (0, 0, 2)} (0, 2, 0)t2 = (1, 3, 0)
(0, 2, 0)t3 = (0, 1, 1)
3 {(0, 1, 1), (0, 2, 0), (0, 0, 2)} base inchangée

9.3) Un déclenchement en profondeur de t2 , t3 et t1 mène à cinq sommets. Un

déclenchement de t2 , t1 et t3 mène à quatre sommets.

9.4) Comme k ≥ m, il existe d ∈ NP tel que k = m + d. Nous avons k(p) ≥

m(p) ≥ F (p, t) pour toute place p, ainsi t est déclenchable en k. Posons
k′ := m′ + d. Nous avons:

→ (m′ + d) = k′ ≥ m′ .
t
k = (m + d) −

9.6) Voir l’annexe A de [BHO20].

9.7) Les actions se modélisent à l’aide d’un réseau de Petri. Une carte d’amé-
lioration se modélise comme suit:
SOLUTIONS DES EXERCICES 157

2 2 2 2 2 2

Une carte d’échange se modélise comme suit:


3

Afin de modéliser le fait qu’une carte marchand est mise de côté lorsqu’elle
est jouée, il suffit d’ajouter deux places pour chaque carte: une qui indique
qu’elle est libre, et l’autre qui indique qu’elle est de côté. Chaque transition
est enrichie comme suit:

libre de côté

L’obtention d’une carte points se modélise comme suit:

SOLUTIONS DES EXERCICES 158

2
17
2
17
disponible 2

score

L’action qui consiste à reprendre les cartes se modélise comme suit:

libre de côté libre de côté

Afin de vérifier si les cartes points peuvent être obtenues, on détermine

si les places étiquetées « disponible » peuvent être vidées. Si c’est le cas,
on ajoute une nouvelle place initialisée avec k jetons; on modifie chaque
transition associée à une action afin qu’elle décrémente cette place; et on
vérifie à nouveau. Cela vérifie s’il est possible d’y arriver en au plus k tours.
On peut ainsi identifier la valeur k minimale.
Afin de borner à dix unités d’épices, on ajoute une nouvelle place p qui
contient un budget de jetons. Chaque transition ajoute ou retire du budget
de telle sorte à ce que p et les quatre places d’épices contiennent toujours
exactement 10 jetons.
⋆ Voici une séquence qui mène à l’obtention de toutes les cartes points
en 24 tours. Il est impossible de faire mieux. Afin d’obtenir ce résultat, la
vérification a été effectuée à l’aide de l’outil LoLA. 
SOLUTIONS DES EXERCICES 159




13
REPRENDRE
(3, 0, 1, 0) (0, 1, 2, 0) (2, 1, 2, 0) (1, 2, 1, 1) (2, 3, 2, 0) (0, 1, 0, 0) (0, 1, 0, 0)


 

 

(2, 1, 0, 0) (2, 0, 0, 1) (2, 0, 1, 1) (3, 1, 2, 0) (0, 2, 3, 0) (0, 4, 2, 0) (1, 1, 3, 1)




16
REPRENDRE REPRENDRE
(1, 1, 3, 1) (0, 2, 2, 2) (1, 3, 3, 1) (0, 0, 2, 0) (2, 0, 2, 0) (2, 0, 3, 0) (2, 0, 3, 0)

17

(2, 0, 1, 2) (2, 0, 2, 2) (0, 0, 0, 0)

SOLUTIONS DES EXERCICES 160

Chapitre 10
10.1)
a) Nous avons:
P(s0 |= Fs2 )
∞
∑ ∞
∑
= ((1/2) · (1/4))i · (1/2) + (1/2) · ((1/4) · (1/2))i · (1/2)
i=0 i=0
∞
∑ ∞
∑
= (1/2) · (1/8)i + (1/4) · (1/8)i
i=0 i=0
= (1/2) · (1/(1 − 1/8)) + (1/4) · (1/(1 − 1/8))
= (3/4) · (8/7)
= 6/7.

b) Posons A := JpK = {s0 , s2 , s4 , s5 , s7 } et A′ := {s4 , s5 , s6 , s7 }. Nous

avons:
P(GFp) = P(GFA)
= P(FA′ )
= (3/4) · P(s0 |= FA′ ) + (1/4) · P(s5 |= FA′ )
= (3/4) · P(s0 |= FA′ ) + (1/4)
= (3/4) · x(s0 ) + (1/4).
Il nous reste à déterminer A et b afin d’identifier x. Nous avons S0 =
∅, S1 = {s4 , s5 , s6 , s7 } et S? = {s0 , s1 , s2 , s3 }. Ainsi:
   
0 1/2 1/2 0 0
1/4 0 1/2 0  1/4
A :=   0
 et b :=   .
0 0 1  0 
0 0 0 0 1
En résolvant (I − A) · x = b, nous obtenons x = (1, 1, 1, 1). En parti-
culier, x(s0 ) = 1 et ainsi P(GFp) = (3/4) · 1 + (1/4) = 1.

Alternativement, nous pouvons (bien plus) simplement invoquer le

fait que A′ correspond à l’ensemble de toutes les CFC terminales.
Ainsi, P(si |= FA′ ) = 1 pour tout état si .
c) Nous avons S0 = {s6 , s7 }, S1 = {s1 , s3 , s4 } et S? = {s0 , s2 , s5 }. Ainsi,
   
0 1/2 0 1/2
A = 0 0 0 et b =  1  .
0 0 0 1
En résolvant (I − A) · x = b, nous obtenons x = (1, 1, 1). Ainsi,
P(p U q) = init(s0 ) · 1 + init(s5 ) · 1 = 1.
SOLUTIONS DES EXERCICES 161

d) Remarquons que l’événement G(p∨q) correspond à ¬F(¬p∧¬q). Cal-

culons P(F(¬p∧¬q)). Nous devons déterminer A et b afin d’identifier
x. Nous avons S0 = {s4 , s5 }, S1 = {s6 } et S? = {s0 , s1 , s2 , s3 , s7 }.
Ainsi:
   
0 1/2 1/2 0 0 0
1/4 0 1/2 0 0 1/4
   
A    0 .
:=  0 0 0 1 0  et b :=  
 0 0 0 0 0 1/2
0 0 0 0 0 1/4

En résolvant (I−A)·x = b, nous obtenons x = (4/7, 9/14, 1/2, 1/2, 1/4).

Ainsi:

P(G(p ∨ q)) = init(s0 ) · P(s0 |= G(p ∨ q)) + init(s5 ) · P(s5 |= G(p ∨ q))
= init(s0 ) · (1 − P(s0 |= F(¬p ∧ ¬q))) +
init(s5 ) · (1 − P(s5 |= F(¬p ∧ ¬q)))
= (3/4) · (1 − 4/7) + (1/4) · (1 − 0)
= 4/7
= 0,571428.

e) La notation XX(p ∨ ¬q) réfère aux chemins infinis dont le troisième

état satisfait p ∨ ¬q. Plus formellement, cela dénote cet événement:
∪
cyl(x0 x1 x2 ).
x0 ,x1 ,x2 ∈S
p∈L(x2 )∨q ∈L(x
/ 2

Nous devons donc calculer cette probabilité:

∑
P(XX(p ∨ ¬q) = init(x0 ) · P(cyl(x0 x1 x2 )).
x0 ,x1 ,x2 ∈S
p∈L(x2 )∨q ∈L(x
/ 2)

Les seuls cylindres pertinents sont ceux qui débutent par s0 s1 s0 ,

s0 s1 s2 , s0 s1 s6 et s5 s4 s5 . Nous obtenons donc:

P(XX(p ∨ ¬q)
= init(s0 ) · (1/2 · 1/4 + 1/2 · 1/2 + 1/2 · 1/4) + init(s5 ) · (1/2 · 1/4)
= 3/4 · (1/2 · 1/4 + 1/2 · 1/2 + 1/2 · 1/4) + 1/4 · (1/2 · 1/4)
= 13/32
= 0,40625.

10.2)
∧
a) 1≤k≤6 P=1/6 (F pk ), où AP := {pk : 1 ≤ k ≤ 6} et la proposition pi
est associée au ième état du bas (à partir de la gauche).
SOLUTIONS DES EXERCICES 162

b) Nous vérifions seulement P=1/6 (F p1 ); les autres formules sont iden-

tiques ou plus simples. Nous avons S1 = {001}, S? = {---, 0--, 00-}
et S0 = S \ (S1 ∪ S? ). Ainsi:
   
0 1/2 0 0
A = 0 0 1/2 et b =  0  .
0 1/2 0 1/2

En résolvant (I − A) · x = b, nous obtenons x = (1/6, 1/3, 2/3).

En particulier, x(---) = 1/6 et ainsi P(Fp1 ) = init(---) · (1/6) =
1 · (1/6) = 1/6 comme désiré.

Alternativement, nous obtenons le même résultat avec:

∞
∑
P(Fp1 ) = (1/2) · (1/2) · ((1/2) · (1/2))i · (1/2)
i=0
∞
∑
= (1/8) · (1/4)i
i=0
= (1/8) · (1/(1 − 1/4))
= (1/8) · (4/3)
= 1/6.

10.3)
a)

∅ {p}

s0 s1

b)

{p} ∅
s0 s1

10.7)
a) P=1 (F pIP )
b) P≥1/2 ((¬pIP ) U≤2 pIP )
SOLUTIONS DES EXERCICES 163

c) P=0 (F p⊥ )
d) P>0 (G P>0 (F p? ))
e) P=1 (G(pIP → P=1 (G pIP )))

10.8)
a) Nous obtenons cette chaîne de Markov:

1/3 1/3 1

2/3 2/3
  

1/3
1/3 1/3 1

1/3 2/3 2/3

   

1/3 1/3 1
1/3
2/3 2/3
  

Ainsi, comme on boucle dans une composante fortement connexe

terminale avec probabilité 1, nous obtenons:

état gagnant probabilité

 roche 1/3
 papier 1/3
 ciseaux 1/3

b) Nous obtenons cette chaîne de Markov:

SOLUTIONS DES EXERCICES 164

1/3
 

1/3 1/6
1/3 1/6 1/6 1/2

1/3 1/2 2/3 1/2

    

1/3 1/6
1/6 1/2 1/2 1/3 1/2 1

1/3 1/2 2/3 1/2

    

1/3 1/2 1
1/6
2/3 1/2 1/2
  

1/3 1/2 1

Nous avons:
 3 i
∞
∑ ∞
∑
 
P( |= F ) =  (1/6)j · (1/3) 
i=1 j=0

∞ (
∑ )i
3
= (6/5 · 1/3)
i=1
∞
∑ i
= (8/125)
i=1
∞
∑ i
= (8/125) − 1
i=0
= (125/117) − 1
= 8/117.
SOLUTIONS DES EXERCICES 165

Ainsi, nous avons:

P( |= FG )
= P( |= F )
∞ (
∑ )i
3
= P( |= F ) + (6/5 · 1/3) · 6/5 · 1/6
i=0
∑∞
= P( |= F ) + (8/125)i · 6/5 · 1/6
i=0
= P( |= F ) + 125/117 · 6/5 · 1/6
= P( |= F ) + 25/117
= 8/117 + 25/117
= 33/117.

Par une analyse similaire, nous obtenons:

P( |= FG ) = 125/117 · 6/5 · 1/3 · (1 + 6/5 · 1/6)

= 50/117 · (1 + 6/5 · 1/6)
= 50/117 · 6/5
= 60/117.

Par conséquent:

P( |= FG )
= 1 − (P( |= FG ) + P( |= FG ))
= 1 − (33/117 + 60/117)
= 24/117.

En conclusion, nous obtenons ces probabilités:

état gagnant probabilité

 roche 33/117 ≈ 0,282051
 papier 60/117 ≈ 0,512820
 ciseaux 24/117 ≈ 0,205128

Ces probabilités peuvent aussi être obtenues empiriquement avec PRISM. 

 Fiches récapitulatives

Les fiches des pages suivantes résument le contenu de chacun des chapitres.
Elles peuvent être imprimées recto-verso, ou bien au recto seulement afin d’être
découpées et pliées en deux. À l’ordinateur, il est possible de cliquer sur la plu-
part des puces « ▶ » pour accéder à la section du contenu correspondant.

166
1. Systèmes de transition
Systèmes de transition Chemins et exécutions
▶ Modélise formellement un système concret ▶ Chemin fini: s0 −
→ s1 −
→ s2 −
→ s1
▶ États: ensemble S (sommets) ▶ Chemin infini: s1 −
→ s2 −
→ s1 −
→ s2 −
→ ···
▶ Relation de transition: −
→ ⊆ S × S (arcs) ▶ Ch. maximal: ne peut être étendu, par ex. s0 −
→ s1 −
→ s2 −
→ s3
▶ États initiaux: I ⊆ S (où S peut débuter) ▶ Exécution: chemin maximal qui débute par un état initial
Structures de Kripke
s0 s1 s2 s3 ▶ Décrit les propriétés des états d’un système
▶ Système de transition (S, −
→, I)
Prédécesseurs et successeurs ▶ Propositions atomiques AP
▶ Successeurs immédiats: Post(s1 ) = {s2 } ▶ Fonction d’étiquetage L : S → 2AP
▶ Prédécesseurs immédiats: Pre(s1 ) = {s0 , s2 } ▶ Exemple: si AP = {p, q, r} et L(s1 ) = {p, q}, alors s1 satisfait
p et q, mais pas r
▶ Successeurs: Post∗ (s1 ) = {s1 , s2 , s3 }
Explosion combinatoire
▶ Prédécesseurs: Pre∗ (s1 ) = {s0 , s1 , s2 }
▶ Nombre d’états peut croître rapidement, par ex. O(2n )
▶ États terminaux: s3 car Post(s3 ) = ∅
▶ Existe techniques pour surmonter ce problème

2. Logique temporelle linéaire (LTL)

Logique Équivalences
▶ Intérêt: spécifier formellement des propriétés ▶ Distributivité: X, G, U (gauche) sur ∧; X, F, U (droite) sur ∨
▶ Syntaxe: vrai | p | φ ∧ φ | φ ∨ φ | ¬φ | Xφ | φ U φ | Fφ | Gφ ▶ Dualité: X dual de lui-même, F dual de G
▶ Interprétation: sur des traces, c.-à-d. mots infinis de (2AP )ω ▶ Autre: seules combinaisons de F et G: {F, G, FG, GF}
▶ Sémantique: Types de propriétés
p arbitraire arbitraire arbitraire arbitraire arbitraire arbitraire ▶ Invariant: propriété toujours vraie: Gφ
p:
▶ Sûreté: réfutable avec préfixe fini
arbitraire p arbitraire arbitraire arbitraire arbitraire arbitraire ▶ Vivacité: comportements vers l’infini
Xp:
Vérification
p p p q arbitraire arbitraire arbitraire
p U q: ▶ Trace: états d’une exécution infinie 7→ leurs étiquettes
▶ Satisfaisabilité: T |= φ ⇐⇒ Traces(T ) ⊆ JφK
arbitraire arbitraire arbitraire arbitraire p arbitraire arbitraire
Fp: ▶ Équité: omettre traces triviales où un processus est ignoré
▶ En pratique: Spin (avec Promela), par ex. algorithme de Lam-
p p p p p p p
Gp: port, protocole de Needham-Schroeder

3. Langages ω-réguliers
Expressions ω-régulières ▶ Exemple: mots tels que #a = ∞, #b = ∞ et #c ̸= ∞:
▶ Décrivent: les langages ω-réguliers de mots infinis a, b, c a, b
▶ Syntaxe: a
a, b
s ::= rω | (r · s) | (s + s)
r ::= r∗ | (r · r) | (r + r) | a | ε b

▶ Exemples: Intersection d’automates de Büchi

a(a + b)ω : mots qui débutent par a, ▶ 1ère idée: simuler A et B en parallèle via produit; pas suffisant
(ab)ω : l’unique mot abababab · · · ▶ Solution: faire deux copies, alterner aux états acceptants
a
b∗ (aa∗ bb∗ )ω : mots avec une infinité de a et de b ▶ Exemple: A ∩ B:
a
A:
(a + b)∗ bω : mots avec un nombre fini de a a b
a a
p, r, A q, r, A p, r, B q, r, B
a a
p q
Automates de Büchi a a b b

▶ Définition: automates usuels; plusieurs états initiaux B: a b q, s, A

a
q, s, B
b
▶ Langage: mots qui visitent états acceptants ∞ souvent b
r s
▶ Expressivité: ≡ expressions ω-rég.; déterminisme ̸= non dét. a a
b
4. Vérification algorithmique de formules LTL
Test du vide
LTL vers automates
▶ Vérification: T |= φ ⇐⇒ L(AT ) ∩ L(A¬φ ) = ∅
▶ Alphabet: Σ := 2AP ∗ +
▶ Lassos: L(B) ̸= ∅ ⇐⇒ ∃q0 −
→q−
→ q où q0 ∈ Q0 , q ∈ F
▶ Conversion: φ → Aφ (pire cas: 2O(|φ|) états)
▶ Détection: double parcours en profondeur (temps linéaire)
▶ Exemples:
1 14 2 13 3 12 6 7

GFp: ∅, {q} {p}, {p, q} p U q: {p} Σ q0

a
q1
b
q2 q6 b
{p}, {p, q} a
a a a a
{p, q}, {q} b
a, b b
q3 q4 q5

∅, {q} 10 11 4 9 5 8

▶ Mieux: identifier les composantes fort. conn. (temps linéaire)

Structures de Kripke vers automates ▶ Sommaire:
Formule LTL φ
▶ Conversion: étiquettes ≡ lettres + tout acceptant Modèle

Structure de Kripke T
▶ Exemple: {p, q}
Automate de Büchi AT Automate de Büchi A¬φ
T: {p} AT :
{p}
Calculer AT ∩ A¬φ
s0 s1 {p, q} s0 s1
oui non
L(AT ∩ A¬φ ) = ∅? Erreur (lasso)
{p, q} Pas d’erreur

5. Logique temporelle arborescente (CTL)

Logique Propriétés d’un système
▶ Intérêt: raisonne sur le temps avec un futur indéterminé ▶ Satisfiabilité dépend des états: JΦK := {s ∈ S : s |= Φ}
▶ Syntaxe: vrai | p | Φ ∧ Φ | Φ ∨ Φ | ¬Φ | QT Φ | Q(Φ U Φ) ▶ Spécification: T |= Φ ⇐⇒ I ⊆ JΦK
où Q ∈ {∃, ∀}, T ∈ {X, F, G} ▶ Expressivité: incomparable à LTL
▶ Interprétation: sur l’arbre de calcul d’une structure de Kripke
▶ Sémantique: LTL CTL

∃Xp: ∃Fp: ∃Gp: ∃(p U q):

Équivalences
▶ Distributivité:
∃F(Φ1 ∨ Φ2 ) ≡ (∃FΦ1 ) ∨ (∃FΦ2 )
∀G(Φ1 ∧ Φ2 ) ≡ (∀GΦ1 ) ∧ (∀GΦ2 )
∀Xp: ∀Fp: ∀Gp: ∀(p U q):
▶ Attention: pas équiv. si on change les quantificateurs
▶ Dualité: effet d’une négation: ∃ ↔ ∀, X ↔ X et F ↔ G
▶ Idempotence: QT QT Φ ≡ QT Φ où Q ∈ {∃, ∀}, T ∈ {F, G}

6. Vérification algorithmique de formules CTL

Algorithme Opérateurs temporels existentiels
▶ Approche: calculer JΦ′ K pour chaque sous-formule Φ′ de Φ ▶ Calcul de J∃XΦK: {s ∈ S : Post(s) ∩ JΦK ̸= ∅}
▶ Vérification: tester I ⊆ JΦK
▶ Calcul de J∃GΦK: T ⊆ JΦK max. t.q. ∀s ∈ T : Post(s) ∩ T ̸= ∅
▶ Forme normale existentielle plus simple, mais pas nécessaire
▶ Complexité: O((|S| + |−
→|) · |Φ|) avec bonne implémentation ▶ Calcul de ∃(Φ1 U Φ2 ): T ⊇ JΦ2 K min. t.q.

▶ En pratique: NuSMV + langage de description de haut niveau s ∈ JΦ1 K ∧ Post(s) ∩ T ̸= ∅) =⇒ s ∈ T

Logique propositionnelle s s s

▶ Règles récursives:
JvraiK = S,
Optimisations
JpK = {s ∈ S : p ∈ L(s)}, ▶ Autres opérateurs: ∀ et F s’implémentent directement; néces-
saire pour obtenir un algorithme polynomial
JΦ1 ∧ Φ2 K = JΦ1 K ∩ JΦ2 K,
▶ Points fixes: temps linéaire si calculs directs sans raffinements
J¬ΦK = S \ JΦK. itératifs; par ex. calcul de composantes fortement connexes
 7. Vérification symbolique : diagrammes de décision binaire

Diagramme de décision binaire Manipulation

▶ But: représenter des fonctions booléennes de façon compacte ▶ Représentation: tableau associatif sommet ↔ (xi , lo, hi)
▶ Utilité: manipuler efficacement de grands ensembles d’états ▶ Ajout d’un sommet: temps constant avec make(xi , lo, hi)
▶ Propriétés: ▶ Construction: par substitutions récursives avec build(φ)
▶ graphe dirigé acyclique ▶ Op. bool.: application récursive « synchronisée » avec apply⃝
▶ sommets étiquetés par variables ordonnées sauf 0 et 1 ▶ Quantif.: existsxi ∈ {0, 1} : t obtenu via t[0/xi ] ∨ t[1/xi ] ⃝
8
x1

▶ les chemins respectent l’ordre des variables ▶ Complexité: polynomiale sauf pour build ⃝
6
x2
▶ sommets uniques et non redondants (lo(u) ̸= hi(u)) ⃝
9

Vérification x1
⃝
3 ⃝ ⃝
5 7

▶ Canonicité: pas deux BDDs pour la même fonction booléenne ▶ État: représenté par identifiant binaire ⃝
10
x3 x3 x3

x1
⃝
▶ Transition: paire d’identifiants binaires
2 ⃝
4
x1 ⃝
x4 x4
x1 11

x2 x2 ▶ Ensemble: représenté par sommet de BDD x1

x2 x2
▶ Logique prop.: manipulation de BDD
1
x3 x3 x3 x3
→ x3
▶ Opérateurs temporels: via calculs de Post ou Pre sur BDD
1 1 0 0 1 1 0 1 0 1 ▶ Satisfiabilité: I ⊆ JΦK ⇔ I∩JΦK = ∅ ⇔ apply∧ (uI , uJΦK ) = 0

8. Systèmes avec récursion

Contexte Calcul de prédécesseurs/successeurs
∪ ∪
▶ Espace d’états: pile d’appel ou d’éléments (+ valeurs locales) ▶ Déf.: Pre∗ (C) := i≥0 Prei (C) et Post∗ (C) := i≥0 Posti (C)
▶ Défi: gérer un nombre infini ou arbitraire d’états ▶ Représentation: symbolique de C avec un P-automate A
▶ Approche: construction et analyse de systèmes à pile ▶ Idée: (états initiaux = états de P)+mots sur alphabet de pile
w
▶ Décrit: Conf(A) := {⟨p, w⟩ : p −
→A }
Systèmes à pile ∗
▶ Algorithme: permet de calculer Pre (Conf(A)) par saturation
a−
→u
▶ Définition: états P , alphabet Γ, transitions {p −−−→ q, . . .} ▶ Approche: init. B := A puis enrichir avec cette règle:
▶ But: décrire un ensemble de piles (et non accepter des mots) p a−
→w ′
p a
7→ p q
▶ Configuration: ⟨p, w⟩ ∈ P × Γ∗ 7→ p + pile w1
p′
w q
...
Vérification
▶ Exemple de modélisation: wn ▶ Approche: système 7→ sys. à pile, spécification 7→ P-automate,
vérification: par Pre∗ /Post∗ /automate de Büchi (LTL)
bool x ∈ {faux,vrai} f1 −
→ b0 f2 f0 −
→ f1 f1 −
→ f0 f2
foo(): bar():
f2 −
→ ε
x0 x1
f2 −
→ ε ▶ Applications: raisonnement sur piles, par ex. « bytecode »
b0 −
→ b1 b0 −
→ f0 b1 τ−
→τ
f0 : x = ¬x: b0 : si x: foo()
b1 −
→ ε f0 −
→ f1 b1 −
→ ε
f1 : si x: foo() b1 : retourner
sinon: bar() τ−
→ sτ τ−
→ sτ s−
→ε s−
→s τ−
→ aτ
f2 : retourner p0 p1 p2 p3 p4 p5
sconst_0 sconst_0 smul aconst_null goto -2

9. Systèmes infinis
Réseaux de Petri Graphes de couverture
▶ Déf.: places et transitions reliées par arcs pondérés ▶ Idée: construire Post∗ (m) mais accélérer avec ω si x < x′
▶ Marquage: nombre de jetons par place ▶ Test: m′ couvrable ssi le graphe contient un m′′ ≥ m′
▶ Déclenchement: si assez de jetons pour chaque arc entrant, ▶ Exemple: (1, 1)
s t
les retirer, et en ajouter de nouveaux selon les arcs sortants p0 p1
∗ s (0, 3) (2, 0)
▶ Successeurs: Post∗ (m) = {m′ ∈ NP : m −
→ m′ } t
3
∗
▶ Prédecesseurs: Pre∗ (m′ ) = {m ∈ NP : m −
→ m′ } t
s
(1, ω)
t
p1 p2 p1 p2
▶ Exemple: t t (0, ω) (ω, ω) s, t
t
2 2 Algorithme arrière
Modélisation ▶ Idée: construire ↑Pre∗ (↑m′ ) en déclenchant vers l’arrière
▶ Processus: comptés par les places ▶ Représentation: d’ensemble clos par le haut par base finie
▶ Exemple: si ¬x: x = vrai tant que ¬x:
▶ Test: m peut couvrir m′ ssi découvert
sinon: goto p0 pass // code
Accessibilité
▶ Problème: tester si m′ ∈ Post∗ (m)

¬x x
▶ Décidable mais plus compliqué
10. Systèmes probabilistes
Chaîne de Markov Accessibilité
▶ But: remplacer non-déterminisme par probabilités ▶ Accessibilité: événement de la forme A U B
▶ Déf.: struct. de Kripke avec proba. sur transitions / états init. ▶ Partition: S0 := J¬∃(A U B)K, S1 := B , S? := S \ (S0 ∪ S1 )
| {z } | {z } | {z }
▶ Représentation: probabilités = matrice P et vecteur init prob. nulle prob. = 1 prob. à déterminer

▶ Exemple: ▶ Approche: A := P sur S? ; b(s) := proba. d’aller de s vers S1 ;

1 départ
x(s) = P(s |= A U B) est la solution de (I − A) · x = b
1 1 ▶ Approx.: A U≤n B obtenu par f n (0) où f (y) := A · y + b
1/10
Comportements limites
succès envoyer échec
9/10 ▶ CFC terminales: une est atteinte et parcourue avec proba. 1
1 ▶ FG et GF: se calculent via accessibilité et CFC terminales

▶ Événements: exéc. inf. décrites par préfixes finis (cylindres) CTL probabiliste (PCTL)

▶ Probabilité: somme du produit des transitions de cylindres ▶ Syntaxe: comme CTL, mais ∃ / ∀ deviennent PI , et ajout U≤n
∑∞ ▶ PI (φ): proba. de φ dans intervalle I?
▶ Exemple: P(F succès) = i=0 1 · ((1/10) · 1)i · (9/10) = 1
▶ Outils: PRISM/Storm (PCTL, analyse quantitative, etc.) ▶ U≤n : côté droit satisfait en ≤ n étapes?
▶ Vérification: calcul récursif + éval. proba. d’accessibilité
 Bibliographie

[And98] Henrik Reif Andersen : An introduction to binary decision dia-

grams, 1998.
[BEM97] Ahmed Bouajjani, Javier Esparza et Oded Maler : Reacha-
bility analysis of pushdown automata: Application to model-
checking. In Proc. 8th International Conference on Concurrency
Theory (CONCUR), pages 135–150, 1997.
[BHO20] Michael Blondin, Christoph Haase et Philip Offtermatt : Direc-
ted reachability for infinite-state systems. CoRR, 2020.
[BK08] Christel Baier et Joost-Pieter Katoen : Principles of model checking.
MIT Press, 2008.
[CLL+ 19] Wojciech Czerwiński, Sławomir Lasota, Ranko Lazić, Jérôme Le-
roux et Filip Mazowiecki : The reachability problem for Petri nets
is not elementary. In Proc. 51st Annual ACM SIGACT Symposium on
Theory of Computing (STOC), pages 24–33, 2019.
[CO21] Wojciech Czerwinski et Lukasz Orlikowski : Reachability in vec-
tor addition systems is Ackermann-complete. In Proc. 62nd Annual
IEEE Symposium on Foundations of Computer Science (FOCS), 2021.
à paraître.
[CVWY90] Costas Courcoubetis, Moshe Y. Vardi, Pierre Wolper et Mihalis
Yannakakis : Memory efficient algorithms for the verification of
temporal properties. In Proc. 2nd International Workshop on Com-
puter Aided Verification (CAV), volume 531, pages 233–242, 1990.
[DLF+ 16] Alexandre Duret-Lutz, Alexandre Lewkowicz, Amaury Fau-
chille, Thibaud Michaud, Etienne Renault et Laurent Xu : Spot
2.0 – A framework for LTL and ω-automata manipulation. In Proc.
14th International Symposium on Automated Technology for Verifi-
cation and Analysis (ATVA), pages 122–129. Springer, 2016. Outil
disponible à [Link]

171
BIBLIOGRAPHIE 172

[EB23] Javier Esparza et Michael Blondin : Automata theory: An algo-

rithmic approach. MIT Press, 2023.
[EHRS00] Javier Esparza, David Hansel, Peter Rossmanith et Stefan
Schwoon : Efficient algorithms for model checking pushdown sys-
tems. In Proc. 12th International Conference on Computer Aided Ve-
rification (CAV), pages 232–247, 2000.
[FMW+ 17] Yu Feng, Ruben Martins, Yuepeng Wang, Isil Dillig et Tho-
mas W. Reps : Component-based synthesis for complex APIs. In
Proc. 44th ACM SIGPLAN Symposium on Principles of Programming
Languages (POPL), pages 599–612, 2017.
[Fé19] Vincent Fély : Génération de tests de vulnérabilité pour des pro-
grammes java card itératifs. Mémoire de maîtrise, 2019.
[HJK+ 20] Christian Hensel, Sebastian Junges, Joost-Pieter Katoen, Tim
Quatmann et Matthias Volk : The probabilistic model checker
storm. CoRR, abs/2002.07080, 2020.
[KMS18] Jan Kretínský, Tobias Meggendorfer et Salomon Sickert :
Owl: A library for ω-words, automata, and LTL. In Proc. 16th Inter-
national Symposium on Automated Technology for Verification and
Analysis (ATVA), pages 543–550. Springer, 2018. Outil disponible
à [Link]
[KNP11] M. Kwiatkowska, G. Norman et D. Parker : PRISM 4.0: Verifica-
tion of probabilistic real-time systems. In Proc. 23rd International
Conference on Computer Aided Verification (CAV), pages 585–591,
2011.
[Kos82] S. Rao Kosaraju : Decidability of reachability in vector addition
systems (preliminary version). In Proc. 14th Symposium on Theory
of Computing (STOC), pages 267–281, 1982.
[Lam92] Jean-Luc Lambert : A structure to decide reachability in Petri nets.
Theoretical Computer Science, 99(1):79–104, 1992.
[Ler12] Jérôme Leroux : Vector addition systems reachability problem
(A simpler solution). In Turing-100 – The Alan Turing Centenary,
pages 214–228, 2012.
[Ler21] Jérôme Leroux : The reachability problem for Petri nets is not
primitive recursive. In Proc. 62nd Annual IEEE Symposium on Foun-
dations of Computer Science (FOCS), 2021. à paraître.
[Lip76] Richard J. Lipton : The reachability problem requires exponential
space. Rapport technique 63, Department of Computer Science,
Yale University, 1976.
[May81] Ernst W. Mayr : An algorithm for the general Petri net reachability
problem. In Proc. 13th Symposium on Theory of Computing (STOC),
pages 238–246, 1981.
BIBLIOGRAPHIE 173

[McN66] Robert McNaughton : Testing and generating infinite sequences

by a finite automaton. Information and Control, 9(5):521–530,
1966.
[Mer01] Stephan Merz : Model checking: A tutorial overview. In Modeling
and Verification of Parallel Processes, pages 3–38. 2001.
[Rac78] Charles Rackoff : The covering and boundedness problems for
vector addition systems. Theoretical Computer Science, 6:223–231,
1978.
[ST77] George S. Sacerdote et Richard L. Tenney : The decidability of
the reachability problem for vector addition systems (preliminary
version). In Proc. 9th Symposium on Theory of Computing (STOC),
pages 61–76, 1977.
 Index

F, 10 déterminisme, 32
G, 10
U, 9 équité, 18
X, 9 équité faible, 18
équité forte, 19
absorption, 14 explosion combinatoire, 6
accessibilité, 100 expression
Algorithme ω-régulière, 27, 28
de Lamport, 20 régulière, 27
algorithme arrière, 103 expressivité, 32
automate, 86 exécution, 4
automate de Büchi, 29
Finally, 10
base, 103 fonction d’étiquetage, 5
BDD, 74 forme normale
bytecode, 92 existentielle, 62

chemin, 4 Globally, 10
initial, 4 graphe de couverture, 101
maximal, 4
clôture par le haut, 103 idempotence, 14, 59
code intermédiaire, 92 Infer, 70
composante fortement connexe, 67 intersection, 32
couverture, 100 invariant, 16
cryptographie, 22
Java, 92
CTL, 54, 92
langage, 30
diagramme de décision binaire, 74
ω-régulier, 29
distributivité, 13, 58
régulier, 27
dualité, 14, 59
lasso, 43
déclenchement, 97
logique temporelle arborescente, 54

174
INDEX 175

syntaxe, 55 tautologie, 13
sémantique, 56 trace, 14
équivalence, 58 transition, 1, 30
logique temporelle linéaire, 9 types de propriétés, 16
syntaxe, 9
sémantique, 10 Until, 9
équivalence, 13
LTL, 9, 92 vivacité, 17
vérification, 42, 61
marquage, 97 vérification symbolique, 74, 80
mot
infini, 10 équité, 72
état, 1
Next, 9 terminal, 3
non déterminisme, 32
NuSMV, 70

persistance, 17
Petri, 97
point fixe, 65
problème d’accessibilité, 100
problème de couverture, 100
Promela, 19
proposition atomique, 5
propriétés
invariant, 16
persistance, 17
sûreté, 17
vivacité, 17
protocole
de Needham-Schroeder, 22
prédécesseur, 3, 87

récursion, 85
réseau de Petri, 97

SMV, 70
Spin, 19
structure de Kripke, 5
successeur, 3
successeurs, 91
sucre syntaxique, 10
système
à pile, 86
système de transition, 1
système infini, 97
sûreté, 17