Cours Automate

Université de Franche-Comté
UFR des sciences et techniques

Master d’informatique
25 030 Besançon Cedex
1. Qu'est-ce qu'un automate ?............................................................................................................................1
2. Définitions d'un automate, d’un système de transition et d’une structure de Kripke ....................................3
3. Exécutions d'un automate..............................................................................................................................4
4. A quoi servent les automates ? ......................................................................................................................5
5. Résumé, Conclusion et Perpectives...............................................................................................................8
1. Pourquoi des produits d'automates ? ...........................................................................................................11
2. Produit libre (ou cartésien) ..........................................................................................................................12
3. Produit synchronisé .....................................................................................................................................15
4. Produit synchrone........................................................................................................................................16
5. Produit Asynchrone.....................................................................................................................................17
6. Résumé, Conclusion....................................................................................................................................17
1. Introduction ................................................................................................................................................19
2. La Logique Temporelle Linéaire Propositionnelle (PLTL) ........................................................................19
Automates de Büchi ........................................................................................................................................21
4. Exemples de propriétés LTL et de codage en Automates de Büchi............................................................24
5. Outils de codage des propriétés PLTL en automates de Büchi ...................................................................26
Définition du Produit Synchronisé ..................................................................................................................27
7. Utilisation pour la vérification ...................................................................................................................28
1. Exemples d'automates avec variables..........................................................................................................31
2. Pourquoi des automates avec variables ? ....................................................................................................32
3. Automate avec variables, automate déplié, variables de contrôle et variables de données.........................33
4. Automate avec variables et abstraction sur les variables de contrôle..........................................................35
5. Résumé, conclusion.....................................................................................................................................36
1. Pourquoi et comment faire communiquer des automates ?.........................................................................39
2. Automates communicants par échange de messages ..................................................................................41
3. Automates communicants par variables partagées......................................................................................43
1. Motivations..................................................................................................................................................45
2. Description des Automates Temporisés (AT) .............................................................................................47
Réseaux d’A.T.................................................................................................................................................51
4. Evaluation algorithmique des automates temporisés .................................................................................53
5. Résumé, Conclusion et Perspectives ..........................................................................................................74
-1-
Modélisation et Evaluation de Systèmes Informatiques,
partie Automates finis et applications
cours de Master Recherche Informatique
2ème année
Jacques Julliand
Année 2007
-2-
Table des matières
TABLE DES FIGURES 2
TABLES DES DEFINITIONS 5
INTRODUCTION AUX AUTOMATES 1

1. Qu'est-ce qu'un automate ?............................................................................................................................1
1.1. Définitions ............................................................................................................................................1
1.2. Exemples...............................................................................................................................................1
1.3. Bilan......................................................................................................................................................2
2. Définitions d'un automate, d’un système de transition et d’une structure de Kripke ....................................3
3. Exécutions d'un automate..............................................................................................................................4
4. A quoi servent les automates ? ......................................................................................................................6
4.1. Idée 1 : Etre un modèle formel d'un système pour résoudre des problèmes ........................................6
4.2. Idée 2 : traiter des problèmes sur des ensembles infinis .......................................................................8
5. Résumé, Conclusion et Perpectives...............................................................................................................8
PRODUITS D'AUTOMATES 11
1. Pourquoi des produits d'automates ? ...........................................................................................................11
2. Produit libre (ou cartésien) ..........................................................................................................................12
2.1. Exemples introductifs .........................................................................................................................12
2.2. Définitions ..........................................................................................................................................12
3. Produit synchronisé .....................................................................................................................................15
3.1. Exemple introductif ............................................................................................................................15
3.2. Définitions ..........................................................................................................................................15
4. Produit synchrone........................................................................................................................................16
5. Produit Asynchrone.....................................................................................................................................17
AUTOMATES DE BÜCHI ET PROPRIETES PLTL 19

1. Introduction ................................................................................................................................................19
2. La Logique Temporelle Linéaire Propositionnelle (PLTL) ........................................................................19
2.2 Logique Temporelle Linéaire ..............................................................................................................20
Automates de Büchi ........................................................................................................................................21
4. Exemples de propriétés LTL et de codage en Automates de Büchi............................................................24
4.1. Exemple 1 : Violation de propriété de la forme (p ⇒ Oq)............................................................24
4.2. Exemple 2 : Vérification de propriété de la forme (p⇒◊q)...........................................................25
5. Outils de codage des propriétés PLTL en automates de Büchi ...................................................................26
Définition du Produit Synchronisé ..................................................................................................................27
6.1. Transformation d'une SKE en Automate .........................................................................................27
6.2 Produit synchronisé..............................................................................................................................27
7. Utilisation pour la vérification ...................................................................................................................28
AUTOMATES AVEC VARIABLES DE DONNEES ET ABSTRACTION 31

1. Exemples d'automates avec variables..........................................................................................................31
2. Pourquoi des automates avec variables ? ....................................................................................................32
3. Automate avec variables, automate déplié, variables de contrôle et variables de données.........................33
4. Automate avec variables et abstraction sur les variables de contrôle..........................................................35
AUTOMATES COMMUNICANTS 39
1. Pourquoi et comment faire communiquer des automates ?.........................................................................39
1.1. Pourquoi ? ...........................................................................................................................................39
-1-
1.2. Comment ?..........................................................................................................................................40
2. Automates communicants par échange de messages ..................................................................................41
2.1. Synchronisation par rendez-vous ........................................................................................................41
2.2. Echange d'informations par rendez-vous ............................................................................................42
2.3. Echange d'information par file FIFO ..................................................................................................42
3. Automates communicants par variables partagées......................................................................................43
AUTOMATES TEMPORISES 45
1. Motivations..................................................................................................................................................45
2. Description des Automates Temporisés (AT) .............................................................................................47
2.2. Configuration et exécution..................................................................................................................48
Réseaux d’A.T.................................................................................................................................................51
3.1. Exemple - Modélisation d’un passage à niveau.................................................................................51
3.2. Exécution d’un réseau d’AT avec Invariants......................................................................................51
4. Evaluation algorithmique des automates temporisés .................................................................................53
4.1 Equivalence des valuations d'horloge et Régions ............................................................................53
4.2 Automate des Régions pour l’analyse d’accessibilité......................................................................56
4.3 Définition de l'automate des régions pour faire du model checking TCTL (voir [ACD 93])..........58
4.4 Automates des zones............................................................................................................................59
4.5 Model-Checking MITL....................................................................................................................67
5. Résumé, Conclusion et Perspectives ..........................................................................................................74
RÉFÉRENCES 75
INDEX 75
Table des figures

Figure 1 : automate modélisant un robot de transport de pièces. .................................................................................1
Figure 2 automate modélisant un digicode...................................................................................................................2
Figure 3 : automate modélisant une montre digitale ....................................................................................................2
Figure 4 : arbre des exécutions .....................................................................................................................................5
Figure 5 : automate modélisant le jeu de Nim à 5 quilles ............................................................................................7
Figure 6 : chemin d'exécution gagnant pour le joueur A du leu de Nim à 5 quilles....................................................7
Figure 7 : Réseau de Pétri modélisant l'exclusion mutuelle .........................................................................................9
Figure 8 : automates des composants modélisant l'exclusion mutuelle........................................................................9
Figure 9 : automate modélisant le réseau de Pétri de la Figure 7 ...............................................................................10
Figure 10 : Automate Minute .....................................................................................................................................11
Figure 11 : Automate Heure .......................................................................................................................................11
Figure 12 : Automate compteur modulo n..................................................................................................................11
Figure 13 : Automate de l'évacuateur .........................................................................................................................12
Figure 14 : Automate du dispositif d'arrivée ..............................................................................................................12
Figure 15 : Produit libre de l'évacuateur et du dispositif d'arrivée .............................................................................13
Figure 16 Produit libre de deux compteurs modulo 3(Minute) et 2(Heure)...............................................................13
Figure 17 : Horloge avec heures modulo 2 et minutes modulo 3 ...............................................................................14
Figure 18 : Horloge ....................................................................................................................................................16
Figure 19 : Produit synchrone de l'évacuateur et du dispositif d'arrivée ....................................................................17
Figure 20 : Automate de Büchi A¬P.........................................................................................................................17
Figure 21 : Produit synchrone de l'Evacuateur et de AP ...........................................................................................18
Figure 22 : Produit asynchrone de l'évacuateur et du dispositif de transport .............................................................18
Figure 23: Le digicode décoré par des propositions atomiques .................................................................................20
Figure 24: Le digicode décoré par les valeurs des variables ......................................................................................20
Figure 25 : Exemple d’automate de Büchi .................................................................................................................22
Figure 26 : Automate reconnaissant la propriété (Dt=occupé ⇒ ◊(Dt=libre)) ........................................................22
Figure 27 : Automate de Büchi reconnaissant la propriété (p ⇒ ◊¬p)....................................................................23
-2-
Figure 28 Automate de Büchi de la propriété (Dt=occupé ⇒ (Dt=occupé ∧ De=occupé)) ..................................23
Figure 29 : Automate de Büchi vérifiant la propriété (p⇒Oq) ...............................................................................24
Figure 30 : Automate de Büchi vérifiant la propriété (De=libre ⇒ O(De=libre)) .................................................25
Figure 31: Produit synchronisé du robot avec la propriété (De=libre ⇒ ODe=libre).............................................25
Figure 32 : Automate de Büchi vérifiant la propriété ◊ (De=occupé).......................................................................26
Figure 33: Produit synchronisé du robot avec la propriété (De=occupé).........................................................26
Figure 34 : Automate associé à la SKE de la Figure 1 d’après la définition 3.8 ........................................................28
Figure 35 : Produit synchronisé des automates des Figure 34 et Figure 30. ..............................................................29
Figure 36. : digicode avec transitions gardées...........................................................................................................31
Figure 37. : Automate de montre avec variables ........................................................................................................32
Figure 38. : Automate du Robot avec variables .........................................................................................................32
Figure 39. : Digicole avec comptage des erreurs........................................................................................................33
Figure 40. : digicode abstrait ......................................................................................................................................35
Figure 41: Dépliage et Approximation de SKE avec variable de données.................................................................37
Figure 42. : Automates Evacuateur et Pince...............................................................................................................39
Figure 43 : Automates communicants CEvacuateur et CPince ..................................................................................40
Figure 44 : Automates communicants par échange de messages EvacuateurG, EvacuateurD et PinceV..................40
Figure 45 : Automate déplié obtenu par la mise en parallèle des 3 automates de la Figure 44..................................41
Figure 46 : Automates synchronisés par rendez-vous correspondant au dépliement des automates avec variables de
la Figure 44.........................................................................................................................................................42
Figure 47 : communication par File FIFO..................................................................................................................42
Figure 48 : Automate File infinie ...............................................................................................................................43
Figure 49 : Automates communicants par variables partagées ..................................................................................43
Figure 50 : Un automate temporisé ............................................................................................................................45
Figure 51 : Modélisation du temps .............................................................................................................................46
Figure 52 : Automate sous-jacent à l'AT de la Figure 50 ...........................................................................................47
Figure 53 : Dépliage de l'AT de la Figure 50 sur des intervalles de temps ................................................................49
Figure 54 : Un passage à niveau.................................................................................................................................50
Figure 55 : Modélisation temporisée d’un passage à niveau ......................................................................................50
Figure 56 : Produit synchronisé de la barrière et d’un train .......................................................................................52
Figure 57 : Vérification des automates temporisés.....................................................................................................53
Figure 58 : Ensemble des régions pour une horloge x avec Cx = 5 ............................................................................54
Figure 59 : Ensemble des régions pour 2 horloges Ht et Hb avec CHt=5 et CHb=2 ....................................................55
Figure 60 : Régions pour Cx=1 et Cy=1 ......................................................................................................................55
Figure 61 : Tableau des régions successeurs de la Figure 60 .....................................................................................56
Figure 62 : Automate des régions pour l’analyse d’accessibilité associé au train......................................................57
Figure 63 : Automate des régions atteignables du train .............................................................................................58
Figure 64 : Autre automate temporisé du train...........................................................................................................59
Figure 65 : Automate des régions du train Figure 64 pour faire du model-checking.................................................60
Figure 66 : Zone convexe et non convexe..................................................................................................................61
Figure 67 : Opérations sur les zones...........................................................................................................................62
Figure 68 : Automate temporisé A0 ............................................................................................................................63
Figure 69 : Automate de régions R(A0)......................................................................................................................63
Figure 70 : Automate des zones Z(A0) .......................................................................................................................64
Figure 71 : Ensemble des zones de Z (A0) .................................................................................................................64
Figure 72 : ABT de la propriété ¬M1.........................................................................................................................68
Figure 73 : Exemple de langage dont le complémentaire n’est pas ω-régulier ..........................................................69
Figure 74 : AT étiqueté par des ensembles de propositions .......................................................................................70
Figure 75 : Produit synchronisé des automates des Figure 73 et Figure 74. ..............................................................71
Figure 76 : Automate des régions associé à l’AT de la ..............................................................................................72
Figure 77 : Régions pour Cx=2 et CHt=1.....................................................................................................................73
Figure 78 : Automates des régions de l’AT de la .......................................................................................................74
-3-
Tables des Définitions
Définition 1 - Système de transitions étiquetées (STE) :..............................................................................................3
Définition 2 - Structure de Kripke Etiquetée (SKE) :...................................................................................................3
Définition 3 - Exécution finie :.....................................................................................................................................4
Définition 4 - Exécution infinie :..................................................................................................................................4
Définition 5 - chemin d’exécution complet :................................................................................................................4
Définition 6 - Automate étiqueté :................................................................................................................................5
Définition 7 - Produit cartésien (libre) d'automates : .................................................................................................14
Définition 8 : Produit synchronisé..............................................................................................................................15
Définition 9 - Produit synchrone : ..............................................................................................................................16
Définition 10 – Produit asynchrone :..........................................................................................................................17
Définition 11 - PLTL :................................................................................................................................................21
Définition 12 – Sémantique de la PLTL :...................................................................................................................21
Définition 13 – Automate de Büchi :..........................................................................................................................21
Définition 14 - satisfaction d'une proposition d'état par un ensemble de propositions atomiques : ...........................23
Définition 15 - reconnaissance d'une exécution infinie par un automate de Büchi :..................................................23
Définition 16 – Transformation d’une SKE en AB ....................................................................................................27
Définition 17 – Produit synchronisé d’automates de Büchi : .....................................................................................27
Définition 18 - SKE avec variables : ..........................................................................................................................33
Définition 19 - Dépliage d’une SKE avec variables :.................................................................................................34
Définition 20 - Abstraction d’une SKE : ....................................................................................................................35
Définition 21 - contrainte d'horloge : .........................................................................................................................47
Définition 22 – Automate Temporisé :.......................................................................................................................47
Définition 23 - exécution d’un AT : ...........................................................................................................................49
Définition 24 - AT avec Invariant : ............................................................................................................................52
Définition 25 - produit synchronisé de 2 AT communicants : ...................................................................................52
Définition 26 - sémantique d'un AT : .........................................................................................................................53
Définition 27 - relation d'équivalence sur les valuations d'horloge :..........................................................................54
Définition 28 - fonction succ :....................................................................................................................................55
Définition 29 - automate des régions :........................................................................................................................56
Définition 30 - notion de région de fin :.....................................................................................................................58
Définition 31 - région bornée : ...................................................................................................................................58
Définition 32 - graphe des régions : ...........................................................................................................................58
Définition 33 – Automate des zones : ........................................................................................................................62
Définition 34 - formules MITL :: ...............................................................................................................................67
Définition 35 - satisfaction d’une formule MITL :: ...................................................................................................67
Définition 36 - Automate de Büchi Temporisé (ABT) :.............................................................................................68
Définition 37 - exécution d’un ABT : ........................................................................................................................68
Définition 38 - produit synchronisé de deux AT :......................................................................................................69
Définition 39 - automate des régions associé à un AT ::............................................................................................70
Définition 40 - cycle progressif : :.............................................................................................................................72
Théorème 1 – Préservation des propriétés de sûreté : ................................................................................................36
-4-
Tables des exercices et des exemples
Exercice 1 : ...................................................................................................................................................................2
Exercice 2 : .................................................................................................................................................................15
Exercice 3 : .................................................................................................................................................................35
Exemple 1 – Systèmes de Transition Etiquetés :..........................................................................................................3

Exemple 2 – SKE Robot : ............................................................................................................................................3
Exemple 3 – SKE Digicode..........................................................................................................................................4
Exemple 4 – exécution finie : .......................................................................................................................................4
Exemple 5 – exécution infinie :....................................................................................................................................4
Exemple 6 - problèmes résolus par modélisation par des automates : .........................................................................5
Exemple 7 - Jeu de 5 quilles :.......................................................................................................................................7
Exemple 8 – produit libre d’automates : ....................................................................................................................12
Exemple 9 – produit libre d’automates : ....................................................................................................................12
Exemple 10 - SKE ......................................................................................................................................................13
Exemple 11 – produit libre .........................................................................................................................................14
Exemple 12 – produit synchronisé .............................................................................................................................15
Exemple 13 – produit synchrone ................................................................................................................................16
Exemple 14 – produit asynchrone ..............................................................................................................................18
Exemple 15 – propriététs en logique temporelle linéaire : .........................................................................................21
Exemple 16 – automate de Büchi ...............................................................................................................................22
Exemple 17 – transformation d’une SKE en AB .......................................................................................................27
Exemple 18 – produit synchronisé d’AB ...................................................................................................................28
Exemple 19 – automate avec variables.......................................................................................................................31
Exemple 20 – automate avec variables, montre .........................................................................................................31
Exemple 21 – automate avec variables, robot ............................................................................................................31
Exemple 22 – SKE avec variables..............................................................................................................................34
Exemple 23 – automate temporisé..............................................................................................................................47
Exemple 24 - exécution de l’AT de la Figure 50 .......................................................................................................50
Exemple 25 – automate des régions ...........................................................................................................................56
Exemple 26 – automate temporisé..............................................................................................................................62
Exemple 27 - propriété en MITL :..............................................................................................................................68
Exemple 28 – Automate de Büchi temporisé .............................................................................................................68
-5-
INTRODUCTION AUX AUTOMATES
1. Qu'est-ce qu'un automate ?
1.1. Définitions
Grand Larousse en 5 volumes :
- Machine qui, par le moyen de dispositifs mécaniques, pneumatiques, hydrauliques, électriques ou
électroniques, est capable d'actes imitant ceux des corps animés (poupée à mouvements saccadés
accompagnant la mélodie de boite à musique).
- Automates de Vaucanson (joueur de flûte, canard).
- Personne qui agit comme une machine, d'une manière inconsciente ou sous l'impulsion d'une force
extérieure.
- Machine et mécanismes automatiques, utilisés par exemple pour la peinture et le soudage dans
l'industrie automobile (robot), dans la banque pour distribuer les billets.
- Automate programmable, système de commande automatique de machines permettant de choisir
entre plusieurs séquences d'actions préétablies (cœur des machines outils).
Pour ce cours les automates sont autre chose : ce sont des modèles élémentaires de machine ou de
calcul.
init
s0
De Dt
Chargt
s1
Evac
De Dt
DéChargt
s2
Evac
De Dt
Chargt
s3
De Dt
Figure 1 : automate modélisant un robot de transport de pièces.
1.2. Exemples
1. Imaginons un robot de transport de pièces (voir Figure 1) constitué d'une pince qui charge des
pièces et les décharge sur un évacuateur qui les évacue. Une modélisation élémentaire (très abstraite) des
fonctionnements de cette machine est la suivante :
Il est défini par un automate représenté par un graphe (voir Figure 1) où :
- les ronds représentent les états de la machine ; le schéma intérieur est une interprétation (appelé
aussi décor) des états modélisant le système physique,
-1-
Cours n°1 Introduction aux Automates - Master Informatique
- les flèches entre les ronds sont des transitions de changement d'états provoqué par l'événement dont
le nom e étiquette la flèche,
le cas particulier d'un rond qui a une flèche entrante venant d'aucun état désigne un état initial de la
machine,
le cas particulier d’un rond qui n’a pas de flèche sortante est un état terminal de la machine (état de
blocage).
2. Prenons un exemple un peu plus élaboré, celui d'un digicode (voir Figure 2) comme ceux
permettant l'ouverture de porte.
- la porte s'ouvre dès qu'on a tapé la bonne séquence de caractères,
- pour simplifier, supposons 3 touches A, B, C et que la porte s'ouvre dès que l'on a tapé la suite
ABB.
Ce digicode peut être modélisé par l'automate suivant à 4 états et 9 transitions
B, C A
A B B
s0 s1 s2 s3
ε A AB ABB
C A
C
Figure 2 automate modélisant un digicode

Celui-ci autorise de se tromper et ouvre la porte dès que la fin de la séquence de touches est ABB.
Exercice 1 :
Le modifier pour modéliser la mise en état de blocage dès que 3 frappes erronées ont été effectuées.♦
3. L'automate modélisant une montre à affichage digital (voir Figure 3) n'est pas représentable ayant
24 × 60 = 1 440 états ou 24 × 60 × 60 = 86 400 états.
... 3:58 3:59 4:00 ...

Figure 3 : automate modélisant une montre digitale
1.3. Bilan
En ce sens les automates permettent de modéliser des machines ou des calculs, de manière générale
des systèmes à événements discrets par :
- un ensemble d'états du système,
- un état initial,
- des transitions atomiques entre états (aucun état intermédiaire n'est observé, donc il ne peut rien se
passer d'autre pendant la transition).
Ils ne permettent pas de modéliser des phénomènes continus, comme c'est souvent le cas en
automatique. Voir d'autres modélisations : équations aux dérivées partielles,...
Ils permettent de modéliser des systèmes à événements discrets, comme c'est le cas en informatique et
en productique.
Le passage du continu au discret s'effectue s’il est possible d'ignorer l'évolution continue des états
pour observer le système à la lumière d'un stroboscope.
-2-
2. Définitions d'un automate, d’un système de transition et d’une structure de Kripke

Le terme d’automate est un terme générique que nous utilisons pour désigner de nombreuses variantes
du même concept appelées systèmes de transitions, structures de Kripke, systèmes de transitions
étiquetées, structures de Kripke étiquetée et automates. Le vocable d’automate est plus particulièrement
utilisé en théorie des langages pour un système de transitions étiquetées muni d’un ensemble d’états
terminaux ou d’acceptation.
On suppose donné un ensemble E de noms d'événements,
Définition 1 - Système de transitions étiquetées (STE) :
def
Un STE est un quadruplet A = <S, S0, E, R> où :
- S est un ensemble d'états,
- S0 est l'ensemble des états initiaux S0 ⊆ S,
- E est un ensemble fini d’étiquettes (noms d’action ou d’événements),
- R est un ensemble de transitions étiquetées R ⊆ S×E×S.♦
Remarque : E est l'ensemble des étiquettes des transitions
Exemple 1 – Systèmes de Transition Etiquetés :
def
1 Robot Soit E = {C, D, E}
def
- S = {s0, s1, s2, s3}, S0 = {s0},
def
- R = {s0 →C s,s → D s,s → E s,s →C s,s →E s}
1 1 2 2 0 2 3 3 1
2 Digicode Soit E = {A, B, C}

def
- S = {s0, s1, s2, s3}, S0 = {s0},
def
- R = {s0 →B s,s → C s,s → A s,s → C s,s →A s,s →B s,s →B s,s →C s,s →B s}
0 0 0 0 1 1 0 1 1 1 1 2 0 2 0 2 3
def def
3 Montre S = {s0, s1, ..., s1439}, S0 = {s0}
def
- R = {s0→ s1, s1 → s2, ..., s1438 →s1439, s1439 → s0}.
Remarques :
. Les transitions de l'automate de la montre ne sont pas étiquetées. C'est un triplet <S, S0, R> où R ⊆
S×S. On appellera cette structure système de transitions (ST).
a s'
. Les transitions étiquetées sont notées (s, a, s') ou s →
. Les états de ces automates ne sont pas décorés par une modélisation du système physique. Par
exemple il n'est pas possible de savoir que dans l'état s0 du robot la pince est vide et l'évacuateur
aussi. Pour modéliser ceci on enrichit la définition des STE en décorant les états. Cette structure est
alors appelée Structure de Kripke.
Définition 2 - Structure de Kripke Etiquetée (SKE) :
On suppose donné un ensemble π de propositions atomiques et un ensemble E d'étiquettes, une
structure de Kripke K est un système de transition étiquetées où les états sont décorés par des ensembles
de propositions de π, K= <S, S0, E, R, λ> où :
- S est un ensemble d'états,
- S0 est un ensemble d'états initiaux S0 ⊆ S,
- E est un ensemble fini d’étiquettes (noms d’action ou d’événements),
- R est un ensemble de transitions, R ⊆ S×E×S,
- λ est une application totale injective de S dans 2π, l'ensemble des parties de π.♦
Exemple 2 – SKE Robot :
-3-
def
Soit π = {De=libre, De=occupé, Dt=libre, Dt=occupé},
def
- λ = {s0 å {De=libre, Dt=libre}, s1 å {De=libre, Dt=occupé}, s2å {De=occupé, Dt=libre}, s3 å
{De=occupé, Dt=occupé}}.
Exemple 3 – SKE Digicode
def
Soit π = {code=‘’, code='A', code='AB', code='ABB'},
def
λ = (s0 å {code=’’}, s1 å {code='A'}, s2 å {code='AB'}, s3 å {code='ABB'}.
Remarques
En général, les structures de Kripke sont munies d’une relation de transition totale de telle sorte
qu’elles ne décrivent que des comportements infinis. Une relation R est totale ssi ∀s.(s ∈ S ⇒ ∃(s’, e).(s
→e s’ ∈ R)). Par exemple, le robot a une relation de transition totale. Par contre le digicode de la Figure 2
n’a pas de relation R totale puisqu’il se bloque dans l’état s3.
3. Exécutions d'un automate

Définition 3 - Exécution finie :
On appelle chemin d'exécution fini d'un automate une séquence d'états s0, s1, ..., sn telle que :
- s0 ∈ S0,
- ∀i.(0≤i<n ⇒ ∃a.(a ∈ E ∧ s → a s ∈ R).♦
i i+1
Exemple 4 – exécution finie :

- s0 s1 s2 s3 est une séquence finie du Robot et du Digicode
- s0 s1 s2 s0 s1 s2 s3 s1 est une séquence finie du robot
Définition 4 - Exécution infinie :
On appelle chemin d'exécution infini d'un automate une séquence d'états s0 s1 ... si ... telle que
- s0 ∈ S0
- ∀i.(0≤i ⇒ ∃a.(a ∈ E ∧ s → a s ∈ R).♦
i i+1
Exemple 5 – exécution infinie :

- s0 (s1 s2 s3)ω, où xω représente la répétition infinie de x, est une exécution infinie du robot.
Remarque
On appellera indifféremment un chemin d'exécution chemin ou exécution.
Définition 5 - chemin d’exécution complet :
On appelle chemin d'exécution complet d'un automate soit un chemin infini, soit un chemin fini
terminé par un état qui n'a pas de successeur : s0 ... sn est une exécution complète si il n'existe pas de
a s ∈ R.♦
transition s → n j
-4-
L'ensemble des exécutions complètes est représentable sous forme d'arbre

s0
s0 s1
s0 s1 s0 s1 s2
.
s1 .
. s0 s1 s2 s3
s0
. s0 s1
s1
s0 .
.
s1
.
.
.
.
:
Figure 4 : arbre des exécutions
On peut remarquer que l'ensemble d'exécution est infini et qu'il est représenté par un automate fini
(nombre d'états fini).
L'un des intérêts des automates est d'être une représentation finie d'un ensemble infini de
comportements d'un système. On pourra résoudre algorithmiquement des problèmes sur un univers infini.
On appelle trace d’une exécution complète la séquence des étiquettes des transitions.
Un automate est un système de transition étiqueté ou non muni d’une condition d’acceptation des
exécutions qui a pour but de limiter l’ensemble des exécutions complètes acceptées à celles :
- soit qui se terminent par un état d’acceptation, appelé état terminal ; ceci permet l’acceptation d’un
ensemble de séquences d’exécution (ou de traces) finies (cas des langages réguliers),
- soit qui contiennent une infinité d’états d’acceptation ; ceci permet l’acceptation d’un ensemble de
séquences d’exécutions infinies (cas des langages ω-réguliers, voir chapitre AUTOMATES DE
BÜCHI ET PROPRIETES PLTL),
- soit d’autres variantes (automates de Street, de Rabin, etc [HTCS 90]).
Définition 6 - Automate étiqueté :
Un automate étiqueté est un STE muni d’une condition d’acceptation, A=<S, S0, E, R, F> où F (⊆ S)
est un sous-ensemble des états de S.♦
Une exécution finie doit se terminer par un état sn de F pour être acceptée. Une exécution infinie doit
contenir une infinité d’états de F pour être acceptée. Cette condition se formalise ainsi. Soit σ une
def
exécution, soit Inf(σ) = {s | il existe une infinité d’états si de σ tel que s=si}. Une exécution σ est acceptée
ssi Inf(σ)∩F ≠ φ.
Notons que l’absence de condition d’acceptation signifie implicitement que toutes les exécutions sont
acceptées, ce qui revient à la condition d’acceptation F=S.
4. A quoi servent les automates ?
4.1. Idée 1 : Etre un modèle formel d'un système pour résoudre des problèmes
Exemple 6 - problèmes résolus par modélisation par des automates :
-5-
1. Est-ce que le Robot peut se bloquer ?

2 Est-ce que la pince du Robot peut décharger sur un évacuateur occupé par une pièce ?
3 Est-ce que l'état d'ouverture s3 de la porte commandée par le digicode est toujours atteignable ?
4 Est-ce que le jeu de Nim est tel que le premier joueur a une stratégie gagnante ?
Solution
Reformulation du problème sur l'automate (ou sur le graphe).
1. Existe-t-il un état qui est cible d'une transition et qui n'est pas source d'une autre ?
def C s,s →
R = {s0 → D s,s →E s,s →C s,s →E s}
1 1 2 2 0 2 3 3 1
La réponse est non : liste des états cibles : s1 s2 s0 s3

D s
; ils sont source des transitions suivantes : s1 → C s
s2→ C s
s0 → E s
s3 →
2 3 1 1
D s telle que le décor de s (λ(s )) contient la

2. Existe-t-il une transition de déchargement si → j i i
proposition atomique De=occupé ?
D s est la seule transition et λ(s ) = {De=libre, Dt=occupé}
Non car s1 →
def
2 1
3. Est-ce qu'il existe un chemin fini partant de n’importe quel état et se terminant par s3 ? Pour
résoudre ce problème, faisons un marquage du graphe en marquant de proche en proche les états qui
permettent d’atteindre s3, puis ceux qui permettent d’atteindre ceux qui atteignent s3 jusqu’à ce que
l’ensemble ne change plus. Si l’ensemble obtenu contient tous les états, alors s3 est atteignable à partir de
tout état.
def
Soit : Q = {s3},
B s existe, Q =
- on marque les états qui ont une transition vers s ; s est marqué car la transition , s →
3 2 2 3
{s2, s3},
def
- on marque les états qui ont une transition vers s2 : Q = {s1, s2, s3},
def
- on marque les états qui ont une transition vers s1 : Q = {s0, s1, s2, s3}.
def
Comme Q = S, s3 est atteignable à partir de tous les états.
4. Est-ce que le jeu de Nim est tel que le premier joueur a une stratégie gagnante ?
Jeu de Nim : Jeu à 2 joueurs
-6-
5,A
4,B 3-1,B 2-2,B 3,B 2-1,B
3,A 2-1,A 2,A 1-1,A 1-1-1,A
2,B 1-1,B
1,B
1,A
0,B 0,A
Figure 5 : automate modélisant le jeu de Nim à 5 quilles

Exemple 7 - Jeu de 5 quilles :
Règles
- le joueur a le droit de faire tomber 1 ou 2 quilles voisines,
- le joueur qui fait tomber la dernière a gagné.
Résolution du problème
- construire l'automate représentant toutes les parties (voir Figure 5),
- voir s’il existe des chemins d'exécution ou les choix du joueur A lui permettent de faire tomber la
dernière quille quel que soit les choix du joueur B.
Légende
- x-y est une configuration des quilles en 2 paquets de x et y quilles consécutives séparés par un
espace,
- A et B sont le n° du joueur qui doit jouer.
Les exécutions gagnantes pour A (voir Figure 6) sont celles qui atteignent l'état décoré par (0, B)
quel que soit ce que joue B.
A B A
2-1,A 1-1,B 1,A 0,B
B
A
5,A 2-2,B
B A
2,A 0,B
Figure 6 : chemin d'exécution gagnant pour le joueur A du leu de Nim à 5 quilles

Il existe deux exécutions gagnantes pour A, c'est-à-dire des séquences de choix de A qui conduisent à
l'état décoré par (0, B) quel que soit les choix de B.
Les autres stratégies ne sont pas gagnantes car :
-7-
- 5,A 4,B permet à B de faire le choix
4,B 1-1,A et A perd
- 5,A 3-1,B idem
- 5,A 3,B idem
- 5,A 2-1,B idem
Remarque :
Notons que l'automate du jeu de Nim décrit un ensemble fini de comportements par opposition aux
automates du Robot et du Digicode.
4.2. Idée 2 : traiter des problèmes sur des ensembles infinis

Etre un modèle à représentation finie pour traiter des problèmes sur des ensembles infinis de
comportements du système.
Exemple :
Le problème d'atteignabilité de l'état s3 par le Digicode ne peut pas être résolu en énumérant toutes les
exécutions possibles.
5. Résumé, Conclusion et Perpectives

1. Un automate modélise un système à événements discrets.
2. Un automate peut être une représentation finie d'un ensemble de comportements infini d'un système.
3. Un automate permet de formuler certains problèmes et de les résoudre algorithmiquement.
4. Le terme d'automate est générique pour ST, STE, SK, SKE et automate,
5. Il existe de nombreuses variantes de la notion d'automate (terme générique) :
- on appelle système de transitions étiquetées (STE) ou non (ST) un quadruplet <S, S0, E, R(S × E ×
S)> ou un triplet <S, S0, R(S × S)>,
- on appelle automate un quintuplet <S, S0, E, R, SA> où SA est un ensemble d'états terminaux (ou
d'acceptation),
- on appelle structure de Kripke étiquetée (SKE) ou non un quintuplet <S, S0, E, R, λ> ou un
quadruplet <S, S0, R, λ> où λ est une application de S dans 2π qui décore les états par un ensemble
de propositions qui modélisent les valeurs des variables d'états d'un système.
Exemples :
- les problèmes 1 et 3 n'ont besoin ni d'étiquette, ni de décor (Un ST suffit),
- le problème 2 utilise les étiquettes et le décor (Une SKE est nécessaire),
- le problème 4 utilise le décor (Une SK suffit).
-8-
Nous présentons la théorie des automates pour résoudre des problèmes :

- de théorie des langages,
- de vérification de systèmes (ex. : pb 1, 2, 3).
Il existe tout un ensemble de notions d'automates particuliers comme les automates :
- déterministes (montre, robot, digicode),
- non déterministes (robot à 2 plateaux),
- accessibles, émondés, complets, normalisés, miroir, etc.
A attend R B attend R
B obtient R
A utilise
B utilise
R B calcule
R
B libère R
A a libéré R B a libéré R
Figure 7 : Réseau de Pétri modélisant l'exclusion mutuelle

Les automates sont une modélisation générale permettant de représenter la sémantique de nombreux
formalismes : Réseaux de Pétri, StateCharts, Systèmes d'événements B, processus communicants,...
Par exemple le Réseau de Pétri qui modélise l'exclusion mutuelle de 2 processus pour l'utilisation
d'une ressource R (voir Figure 7) est modélisé par le produit synchronisé (voir chapitre 2) des 3 automates
de la Figure 8. L'automate PR représente la place centrale du réseau de Pétri. L'état 4 correspond à la
place marquée, l'état 5 à la place non marquée. Les automates PA et PB sont identiques. L'état 1 est l'état
où le jeton est dans la place du bas, l'état 2, la place du haut et l'état 3 la place milieu.
1 1
CA (calcul) 4 CB
_ _
(A libère R) L 2 L R 2 L
R (A obtient R) R
5
3 3
PA PR PB
Figure 8 : automates des composants modélisant l'exclusion mutuelle
Ce produit synchronisé (voir section Produit synchronisé page 18) est défini par (PA || PR || PB)\Sync
- -
où Sync={CA, CB, (R, R), (L, L)} est représenté dans la
Figure 9.
Dans la Figure 9, n, p, k représentent l'état de PA, de PR et de PB respectivement :
-9-
- l'état initial est le produit des états du Réseau de Pétri marqué,

- chaque transition (de la forme O→|→O) du Réseau de Pétri est codé par une transition (de la forme
O→O) de l'automate où 1 seul composant évolue,
chacune des transitions du Réseau de Pétri qui a plusieurs places en entrée ou en sortie est codée par
-
une transition synchronisée sur les automates (X, X) pour spécifier que les 2 composants A et R ou B et R
évoluent simultanément.
C 1,4,1 C
A B
- 2,4,1 1,4,2
-
(L,L)
C (L,L)
B C -
A
(R,R)
-
(R,R) - 2,4,2
- -
(L,L)
(R,R) (L,L)
-
3,5,1 1,5,3
(R,R)
2,5,3 3,5,2
Figure 9 : automate modélisant le réseau de Pétri de la Figure 7
- 10 -
Cours n°2 - Produits d'Automates - Master Informatique
PRODUITS D'AUTOMATES
1. Pourquoi des produits d'automates ?

. 2 raisons principales :
1 Pour décrire un système composé physiquement de sous-systèmes
exemples :
. robot de transport de pièces (pince, évacuateur, dispositif d'arrivée),
. protocole T=1 (carte, lecteur de carte),
. gestionnaire d'imprimante (n utilisateurs, allocateur d'imprimante,...),
. ascenseur (cabine, utilisateurs, portes, boutons,...),
. système à 2 compteurs (horloge).
2 C'est une facilité de description : la décomposition permet la réduction de la taille de l'automate.
exemple : une montre peut être décrite par la composition de 2 automates :
- l'un qui compte les minutes (voir Figure 10),
- l'autre qui compte les heures (voir Figure 11).
_
h
m m m m m m
0 1 2 3 ..... 58 59
Figure 10 : Automate Minute

_
j
h h h h
0 1 2 3 ..... 22 23
Figure 11 : Automate Heure

raz
i i i i
0 1 2 ..... n-2 n-1
Figure 12 : Automate compteur modulo n

Leur composition donne un automate à 1440 états (24×60) plus difficile à décrire.
. Plusieurs sortes de produits d'automates :
- produit libre (produit cartésien) pour des systèmes indépendants,
- produit synchronisé pour des systèmes dépendants
- moyens de description de produits synchronisés :
- synchronisation par envoi de messages
- synchronisation par variables partagées (en lieu avec automates avec variables)
- 11 -
- produit synchrone (cas particulier de produit synchronisé où seules les étiquettes couple de deux
étiquettes sont autorisées) pour des systèmes totalement dépendants,
- produit asynchrone pour des systèmes indépendants où l'on interdit l'évolution simultanée des sous-
systèmes (cas particulier du produit synchronisé où l'on restreint les étiquettes des transitions à
l'union des étiquettes des sous-systèmes).
2. Produit libre (ou cartésien)
2.1. Exemples introductifs

Pour modéliser la composition (parallèle) de processus indépendants on effectue le produit libre des
automates modélisant chaque processus.
Exemple 8 – produit libre d’automates :
Etant donné les dispositifs d'évacuation et d'arrivée des pièces du robot de transport de pièces, leur
comportement en parallèle est modélisé par la composition libre des 2 automates des Figure 13 et Figure
14.
s _ s
1 2
D
De De
E
Figure 13 : Automate de l'évacuateur

A_P
s s
3 4
Da _
Da
C
Figure 14 : Automate du dispositif d'arrivée

Les comportements du système composé sont modélisés par l'automate de la Figure 15.
Exemple 9 – produit libre d’automates :
Le produit cartésien des 2 compteurs d'horloge de minutes et d'heures décrit un automate à 1440 états.
La Figure 16 représente cet automate pour le cas où heure = 0 ou 1 et minute = 0, 1 ou 2.
Cet automate n'est pas celui d'une horloge qui est représentée Figure 17 car une horloge passe de l'état
décoré par n : 59 à n+1 : 0 en synchronisant les transitions h et h (voir produit synchronisé) .
2.2. Définitions
La définition d'une Structure de Kripke étiquetée est donnée dans la Définition 2, page 6.
- 12 -
(s , s )
1 3
__ __
_
De Da
E _ C
A_P
D
(E, A_P)
_
_
(D, A_P) _ _
_ (E,C)
(C, D)
_ A_P D
E
C
Figure 15 : Produit libre de l'évacuateur et du dispositif d'arrivée

_ _
(j, h)
_
h
0:0 m 0:1 m
0:2
(h,m) (h,m)
_
h
j j h h
_ _ j
(j,m) (j,m)
m m
1:0 1:1 1:2
_
h
_
(h, h)
Figure 16 Produit libre de deux compteurs modulo 3(Minute) et 2(Heure)
Remarques
- on ne s'intéresse pas aux états finaux car on n'est pas sur des problèmes de reconnaissance de mots
finis,
- on s'intéresse aux valeurs des variables d'état du système dans chaque état. C'est le décor formalisé
par l'application λ,
v s.
- une transition est notée, soit (s , v, s ), soit s →
1 2 1 2
Exemple 10 - SKE
1 L'évacuateur de la Figure 13 est une SKE où :
def def
- S = {s0, s1}, S0 = {s1}, E = { Dechargt , Evac},
def
- R = {(s1, Dechargt , s2), (s2, Evac, s1)},
def
- λ = {s1 å {De=libre}, s2 å {De=occupé}}.
- 13 -
_ _
(j, h)
0:0 m 0:1 m
0:2
_
(h, h)
m m
1:0 1:1 1:2
Figure 17 : Horloge avec heures modulo 2 et minutes modulo 3

2 Le dispositif d'arrivée de la Figure 14 est une SKE où :
def
- S = {s3, s4},
def
- S0 = {s3}, E = {Arrivée_Pièce, Chargt },
def
- R = {(s3, Arrivée_Pièce, s4), (s4, Chargt , s3)},
def
- λ = {s3 å {Da=libre}, s4 å {Da=occupé}}.
Définition 7 - Produit cartésien (libre) d'automates :
def def
Le produit cartésien de 2 SKE K1 = <S1, S01, E1, R1, λ1> et K2 = < S2, S02, E2, R2, λ2>, noté K1||K2, est
def
une SKE K = <S1× S2, S01×S02, E1 ∪ E2 ∪ E1×E2, R, λ> où
v (s' , s' ) ssi :
- R est l'ensemble de transitions défini par (s , s ) → 1 2 1 2
* soit s1 →v s' ∈ R et s' =s

1 1 2 2
v
* soit s2 → s'2 ∈ R2 et s'2=s2
v1 s' ∈ R et s →
* soit v = (v1, v2) et s1 → v
1 1 2 2 s'2 ∈ R2
- λ est l'application de S1×S2 dans 2APV1∪V2 définie par (s1, s2) åλ1(s1)∪λ2(s2) ∈ λ.♦
Exemple 11 – produit libre
L'automate produit cartésien de l'évacuateur (voir Figure 13) et du dispositif d'arrivée (voir Figure 14)
Evacuateur||Darrivée représenté Figure 15 est le suivant :
def
- S= {(s1, s3), (s1, s4), (s2, s3), (s2, s4)}
def
- S0 = {(s1, s3)}
def
- E= { Déchargt , Evac, Arrivée_Pièce, Ch arg t , (Evac, Chargt ), (Evac, Déchargt ),
(Arrivée_Pièce, Chargt ), (Arrivée_Pièce, Déchargt )}
→ → →
def
- R = {(s1, s3) DéChargt (s2, s3), (s1, s3) Arrivée_Pièce (s1, s4), (s1, s3) ( DéChargt , Arrivée_Pièce) (s2, s4),
→ → → →
(s2, s3) Evac (s1, s3), (s2, s3) Arrivée_Pièce (s2, s4), (s2, s3)(Evac, Arrivée_Pièce) (s1, s4), (s1, s4) Chargt (s1,
- 14 -
→ → → →
s3), (s1, s4), DéChargt (s2, s4), (s1, s4) ( Chargt , DéChargt ) (s2, s3), (s2, s4) Chargt (s2, s3), (s2, s4) Evac
(s1, s ), (s , s ) →( Chargt , Evac) (s , s )}

4 2 4 1 3
def
- λ = {(s1, s3) å {De=libre, Da=libre}, (s1, s4) å {De=libre, Da=occupé}, (s2, s3) å {De=occupé,
Da=libre}, (s2, s4) å {De=occupé, Da=occupé}}
Quand les systèmes sont dépendants il est parfois suffisant de restreindre l'ensemble des étiquettes de
transitions pour exprimer la synchronisation entre les sous systèmes.
Remarque : Le produit libre de 2 SKE s'adapte au produit libre de deux STE ou de deux automates
<S1, S01, E1, R1, SA1> et <S2, S02, E2, R2, SA2> en remplaçant λ par l'ensemble d'états d'acceptation (ou
terminaux) SA = SA1×SA2.
3. Produit synchronisé
3.1. Exemple introductif

Pour modéliser une véritable horloge, il faut interdire que les transitions h et
h (ainsi que j et h ) soient exécutables indépendamment et il faut interdire que les transitions h et m
soient exécutables simultanément pour obtenir l'automate de la Figure 18 :
Parmi l'ensemble d'étiquettes de transitions {m, h , h, j , (h, m), ( j , m), (h, h ), ( j , h )} seules
sont autorisées {m, (h, h ), ( j , h )}. On appelle cet ensemble l'ensemble de synchronisation.
3.2. Définitions
Définition 8 : Produit synchronisé
def
Le produit synchronisé de 2 SKE K1 et K2, noté K1||K2\Sync, est une SKE K = <S1×S2, S01×S02, Sync,
R, λ> où :
- Sync est l'ensemble des étiquettes de transitions autorisées Sync ⊆ E1 ∪ E2 ∪ (E1×E2)
- R est l'ensemble de transitions défini pour le produit libre restreint aux transitions étiquetées dans
Sync,
- λ est l'application définie dans le produit libre.♦
Exemple 12 – produit synchronisé
Le modèle d'horloge est l'automate Heure||Minute\{m, (h, h )}.
Exercice 2 :
Définir la SKE de la spécification abstraite du robot par un produit synchronisé de deux SKE, la pince
et l'évacuateur.♦
- 15 -
0:0
m
0:1
m
0:2
m
... m
0:59
_
(h, h)
1:59
m
1:58
m
1:57
... m
1:0
_ _ _
(j, h) (h, h)
2:0
...
...
23:59
m
...
Figure 18 : Horloge
4. Produit synchrone
Définition 9 - Produit synchrone :
def
Le produit synchrone est un cas particulier de produit synchronisé K = <S1×S2, S01×S02, E1×E2, R, λ>
où les seules étiquettes autorisées sont les couples d'étiquettes.♦
Ainsi le produit synchrone oblige les 2 sous-systèmes à évoluer simultanément à chaque fois.
Exemple 13 – produit synchrone
Le produit synchrone de l'évacuateur et du dispositif d'arrivée serait la SKE représentée dans la Figure
19.
On notera que le graphe n'est pas connexe Les états (s1, s4) et (s2, s3) ne sont pas atteignables à partir
de l'état initial. Donc les transitions (Evac, Arrivée_Pièce) et ( Chargt , Déchargt ) ne sont pas
déclenchables à partir de l'état initial.
Une autre forme de produit synchrone (voir la définition chapitre 3) est utilisée pour vérifier si une
SKE KS viole une propriété P de PLTL. Celle-ci est codée par un automate de Büchi A¬P. Si l'automate
produit synchrone de KS et A¬P n'est formé que des chemins qui contiennent une infinité d'état
d'acceptation c'est que la propriété P est violée.
Exemple
def
Pour vérifier que l'Evacuateur n’évacue pas obligatoirement la pièce qu'il supporte (P = ◊(De=occupé
def
∧ (De=occupé))=, donc ¬P = (De=occupé ⇒ ◊(De=libre)), on effectue le produit synchrone (voir
Figure 21) de l'automate de l'évacuateur (voir Figure 13) avec celui qui code la négation de cette propriété
représenté Figure 20.
Le produit synchrone est représenté dans la Figure 21.
L'automate de la Figure 21 ne contient que des chemins formés d'une infinité d'états d'acceptation.
Ceci signifie que l'intersection des exécutions du système et de la propriété n'est pas vide, c'est à dire qu'il
existe des exécutions du système qui satisfont la propriété. Autrement dit ce produit synchrone ne permet
pas de conclure que toutes les exécutions du système satisfont la propriété (De=occupé ⇒ ◊(De=libre)).
- 16 -
Par contre, il permet de conclure que certaines exécutions du système ne satisfont pas la négation de la
propriété, c'est à dire que le système viole la négation de la propriété, exprimée ainsi en PLTL :
◊(De=occupé ∧ (De=occupé)).
s1 , s3
(D, C)
s1 , s4 (E, D)
s2 , s4
(D, D)
(E, C)
s2 , s3
Figure 19 : Produit synchrone de l'évacuateur et du dispositif d'arrivée

true
De=occupé
a1 a2 De=libre
/
De=libre
Figure 20 : Automate de Büchi A¬P
5. Produit Asynchrone
Définition 10 – Produit asynchrone :
def
Le produit asynchrone est un cas particulier de produit synchronisé K = <S1×S2, S01× S02, E1 ∪ E2, R,
λ> où les seules étiquettes autorisées sont celles des actions individuelles de K1 et K2.. Ainsi on oblige les
2 sous-systèmes à évoluer séparément à chaque fois.♦
6. Résumé, Conclusion
- Les notions de produit d'automates permettent de simplifier la modélisation d'un système en
décrivant séparément les automates de ses sous-systèmes.
Le produit libre est le concept de base.
Le produit synchronisé est une restriction du produit libre qui restreint l’ensemble des étiquettes des
transitions.
- 17 -
- Le produit synchronisé modélise la composition parallèle de sous-systèmes qui se coordonnent (se

synchronisent) d’une certaine manière définie par l’ensemble Sync.
- Le produit asynchrone modélise la composition parallèle de sous-systèmes indépendants.
- Le produit synchrone modélise la composition parallèle de sous-systèmes qui évoluent
obligatoirement simultanément.
- Le produit synchronisé de SK et d'automate de Büchi permet de décider si la propriété modélisée
par l'automate de Büchi est satisfaite ou non par la SK.
S ,a
1 1
________
(D echargt, true)
(E vac, true)
S ,a
2 1
________ (E vac, D e=o ccupé)

(D echargt, D e=libre)
S ,a
1 2
Figure 21 : Produit synchrone de l'Evacuateur et de AP

Exemple 14 – produit asynchrone
Le produit asynchrone de l'évacuateur et du dispositif de transport est la SKE représentée dans la
Figure 22.
s 1 , s3
s1 , s4 D
E D s2 , s4
D
E
C
D
s2 , s3
Figure 22 : Produit asynchrone de l'évacuateur et du dispositif de transport
- 18 -
Cours n°3 - Automates de Büchi et propriétés PLTL - Master Informatique
AUTOMATES DE BÜCHI ET PROPRIETES PLTL
1. Introduction
Certaines propriétés des systèmes ne peuvent pas s'exprimer en logique classique mais nécessitent une
logique temporelle.
Exemples :
- P1 : la pince du robot de transport de pièces ne doit pas décharger sur un évacuateur déjà occupé
par une pièce (cf. cours n° 1).
- P2 : si la pince tient une pièce, elle doit obligatoirement la décharger.
La Logique Temporelle Linéaire Propositionnelle (PLTL) permet d'exprimer ces propriétés. Une
formule de PLTL définit un ensemble de chemins d'exécution autorisés pour un système. Cet ensemble
est un langage régulier sur des séquences infinies ; ensemble fini de séquences infinies. Ces langages sont
reconnus par des automates, appelés automates de Büchi, variantes des automates reconnaissant les
langages réguliers pour reconnaître des séquences infinies (langages ω-réguliers).
Utilisation pour vérifier une propriété PLTL sur un système :
- Vérifier que l'ensemble des chemins du système (Automate AS) est inclus dans l'ensemble des
chemins autorisés par la propriété (Automate AP qui est un automate de Büchi).
- Vérifier P sur S : AS ⊆ AP ? ou AS ∩ A¬P = φ?
C'est une opération de produit synchronisé sur les automates (les langages) (voir cours n° 2).
2. La Logique Temporelle Linéaire Propositionnelle (PLTL)

On rappelle que les notions de SKE et d'exécution qui permettent l'interprétation des formules de
logique temporelle sur les chemins de ces automates sont données dans les Définition 2, Définition 3 et
Définition 4.
La modélisation du digicode Figure 23 est une représentation graphique de la SKE suivante :
def
- S = {s0, s1, s2, s3}, S0={s0},
def
- E = {A, B, C}
def
- R = {(s0, A, s1), (s0, B, s0), (s0, C, s0), (s1, A, s1), (s1, B, s2), (s1, C, s0), (s2, A, s1), (s2, B, s3), (s2, C,
s0), (s3, A, s1), (s3, B, s0), (s3, C, s0)}
def
- λ = {(s0 å {P6, P8}, s1 å {P6, P9}, s2 å {P6, P10}, s3å {P7, P11}.
X s.
Une transition (si, X, sj) se note également si → j
Notons que la Figure 23 représente toute l'information du quintuplet <S, S0 E, R, λ>. L'étiquetage des
états par les propositions atomiques suivantes est indiqué :
def
P6 = EtatPorte=fermée,
def
P7 = EtatPorte=ouverte,
def
P8 = CodeTapé=ε,
def
P9 = CodeTapé=A,
def
P10 = CodeTapé=AB,
def
P11 = CodeTapé=ABB.
- 19 -
B, C A A
A B B
s0 s1 s2 s3
P6, P8 P6, P9 P6, P10 P7, P11
C A
C
B, C
Figure 23: Le digicode décoré par des propositions atomiques

Une autre représentation graphique est donnée Figure 24. Elle consiste à étiqueter les états par les
valeurs des variables EtatPorte et CodeTapé, permettant ainsi d'évaluer les propositions atomiques.
B, C A A
A B B
s0 s1 s2 s3
fermée, ⊥ fermée, A fermée, ouverte,
ΑΒ ΑΒΒ
C A
C
B, C
Figure 24: Le digicode décoré par les valeurs des variables
Exécution finie (chemin fini)

def
La définition d’une exécution (ou chemin) finie d'une SKE K = <S, S0, E, R, λ> est donnée dans la
Définition 3.
Selon les besoins de la vérification on peut trouver une définition duale d'une exécution comme une
def vi s ).
séquence de transitions σ = t , t , t ,…, t telle que ∀i.(0≤i<n ⇒ t = s →
0 1 2 n i i i+1
v0 s →
On note alors une exécution sous la forme suivante : s0 → v1 s →v2 s → …
1 2 3
A s →
Par exemple s0 → B s →B s est une exécution finie de l'automate Figure 24.
1 2 3
Exécution infinie (chemin infini)

def
La définition d’une exécution infinie d'une SKE K = <S, S0, E, R, λ> est donnée dans la Définition 4.
2.2 Logique Temporelle Linéaire
Définitions et Notations :
- Soit SPV l’ensemble de propositions d'état sur V ; soit p, p1, p2 ∈ SPV, SPV est défini
récursivement par la grammaire suivante :
p, p1, p2 ::= pa | x=y | ¬p | p1 ∨ p2 où pa ∈ APV, x et y ∈ V ;
Par exemple, Dt=libre ∧ De=libre et ¬(De=libre) sont des propositions d'état qui
combinent des propositions atomiques avec les opérateurs propositionnels suivants ¬, ∨, ∧, ⇒, …
- Soit P, P1, P2 des formules temporelles quelconques.
Syntaxe de la PLTL
- 20 -
Définition 11 - PLTL :
Soit P, P1 et P2 des formules temporelles. Les formules temporelles sont définies syntaxiquement
ainsi :
- pa est une formule temporelle,
- ¬P, P, ◊P et OP sont des formules temporelles,
- P1∧P2, P1∨P2, P1⇒P2, P1 U P2, P1 W P2 sont des formules temporelles.♦
Exemple 15 – propriététs en logique temporelle linéaire :
P1 : ((Dt=occupé ∧ O(Dt=libre)) ⇒ De=libre),
P2 : (Dt=occupé ⇒ Dt=libre),
P3 : (Dt=occupé ⇒ (Dt=libre U De=libre)).
Sémantique
Ces formules s'interprètent sur des chemins des automates vus comme des séquences d'états σ = s0, s1,
s2, .... En PLTL, implicitement chaque formule doit être vraie sur tous les chemins de l'automate pour
quelle soit satisfaite sur l'automate. Intuitivement ces formules se lisent ainsi :
- Toujours P notée P est vraie sur un chemin σ ssi P est vraie sur tous les états du chemin σ,
- Fatalement P ou Inévitablement P notée ◊P est vraie sur un chemin σ ssi P est vraie au moins sur
un état du chemin σ,
- A l'état suivant P notée OP est vraie sur un chemin σ à un état donné si ssi elle est vraie à l'état
si+1,
- P1 jusqu'à P2 notée P1 U P2 est vraie sur un chemin σ ssi P1 est vraie sur tous les états jusqu'à un
état où P2 est vraie,
- P1 à moins que P2 notée P1 W P2 est vraie sur un chemin σ ssi P1 est vraie sur tous les états
jusqu'à un état où P2 est vraie ou P1 est vraie sur tous les états de σ,
Formellement leur définition sont les suivantes :
Définition 12 – Sémantique de la PLTL :
def
Soit σ un chemin infini de l'automate : σ = s0, s1, s2, .s3 …sj …. On note "(σ, j) |= P" le prédicat "P est
satisfait sur le chemin σ sur l'état sj".
. (σ, j) |= pa ⇔ pa ∈ λ(sj) -- pa est vraie si elle décore l’état sj
. (σ, j) |= ¬P ⇔ il n'est pas vrai que (σ, k) |= P
. (σ, j) |= P1 ∨ P2 ⇔ (σ, k) |= P1 ou (σ, k) |= P2
. (σ, j) |= P ⇔k.(j≤k ⇒ (σ, k) |= P)
. (σ, j) |= OP ⇔ (σ, j+1) |= P
. (σ, j) |= P ⇔ ∃k.(j≤k ∧ (σ, k) |= P)
. (σ, j) |= P1 U P2 ⇔ ∃k.(j≤k ∧ (σ, k) |= P2 ∧ ∀i.(j≤i<k ⇒ (σ, i) |= P1))
. (σ, j) |= P1 W P2 ⇔ ((σ, j) |= P1 U P2) ou ((σ, j) |= P1).♦
Nous ne donnons pas la définition des autres opérateurs car ils se redéfinissent tous à partir de ¬, ∨, O
et U.
Automates de Büchi
Définition 13 – Automate de Büchi :
On suppose donné un ensemble SPV de propositions d'états. Un automate de Büchi est un quintuplet
def
AB = <SB, sb0, SPV, RB, SBA> où :
- 21 -
- SB est un ensemble fini d'états,

- sb0 est un état initial,
- RB ⊆ SB × SPV × QB est un ensemble fini de transitions étiquetées par des propositions d’état,
- SBA ⊆ SB est un ensemble d'états d'acceptation.♦
Par exemple, l'automate de la Figure 25 est un automate de Büchi défini ainsi :
def
- SPV = {p ∧ q, ¬p, q, p ∧ ¬q, ¬q} où p et q sont des propositions atomiques
def
- SB = {e0, e1}
def
- sb0 = e0
- RB = {e p→
def ∧q e , e ¬ →q e , e ¬
→p e , e p∧¬ →q e , e →
q e}
0 0 0 0 0 1 1 1 1 0
def
- SBA = {e0}
p∧q q
p∧¬q
e0 e1
¬p ¬q
Figure 25 : Exemple d’automate de Büchi
Ces automates permettent de coder des mots infinis de langages réguliers appelés langages ω-
réguliers. Les propriétés PLTL définissent l'ensemble des chemins infinis qui satisfont la propriété. Par
exemple la propriété (p⇒◊q) est satisfaite par l'ensemble infini de chemins infinis dont les séquences
suivantes sont des exemples de préfixes :
- ¬p ¬p p ¬p ¬p q ¬p p p ¬p p ¬p q ¬p…
- ¬p ¬p ¬p ¬p ¬p ¬p …
Cet ensemble se code par l'automate de la Figure 27 dans le cas où q=¬p. Les mots du langage sont
les séquences infinies d'étiquettes des transitions reconnues par les exécutions de l'automate qui
contiennent une infinité d'états d'acceptation.
Exemple 16 – automate de Büchi
Dt=o
Dt=l
Dt = o
sb0 sb1
Dt=l
Figure 26 : Automate reconnaissant la propriété (Dt=occupé ⇒ ◊(Dt=libre))

L'automate de la Figure 26 reconnaît P2 ( (Dt=occupé ⇒ ◊(Dt=libre))) qui est le langage suivant : soit
def
p = (Dt=o).
{¬p ¬p ¬p ...,
¬p ... ¬p p ... ¬p ¬p ... ,
¬p ... ¬p p ... ¬p ... ¬p p ... ¬p ... , ... }
- 22 -
Le langage est défini par l'expression ω-régulière suivante : (p*.¬p)ω reconnue par l'automate dans la
Figure 27.
¬p p
p
sb0 sb1
¬p
Figure 27 : Automate de Büchi reconnaissant la propriété (p ⇒ ◊¬p)

Le langage reconnu par un automate de Büchi ne contient que les séquences infinies reconnues par les
exécutions contenant une infinité d'états d'acceptation.
Définition 14 - satisfaction d'une proposition d'état par un ensemble de propositions atomiques :
Un ensemble de propositions atomiques AP ∈ 2APV satisfait une proposition d'état p, notée AP |=p si
et seulement si :
AP |= pa ssi pa ∈ AP,
AP |= x=y ssi ∃pa. ∃pa’.∃d.(pa ∈ AP ∧ pa’ ∈ AP ∧ pa=(x=d) ∧ pa’=(y=d))
- AP |= ¬p ssi il n'est pas vrai que AP |= p,
- AP |= p ∨ q ssi AP |= p ou AP |= q.♦
Définition 15 - reconnaissance d'une exécution infinie par un automate de Büchi :
def
Une exécution infinie σ = s0 ... si ... d'une SKE est reconnue par une séquence
def
χ = sb0 ... sbi ... d'un automate de Büchi ssi :
1. ∀i.(i≥0 ⇒ λ(si) |= pi ) où pi tel que sbi →pi sb ∈ RB,
i+1
2. χ contient une infinité d'états d'acceptation.♦
Exemples
def def
- σ = (s0 s1 s2)ω de la Figure 1 est reconnue par la séquence χ = (sb0 sb0 sb1)ω de la Figure 26 qui
contient une infinité de fois l'état d'acceptation sb0.
- la propriété suivante (Dt=occupé ⇒ (Dt=occupé ∧ De=occupé)) est codée par
l'automate de Büchi de la Figure 28 :
true Dt=l ∨ De=l
Dt=o
sb0 sb1
Dt=o ∧ De=o
Figure 28 Automate de Büchi de la propriété (Dt=occupé ⇒ (Dt=occupé ∧ De=occupé))

def def
La séquence σ = (s0 s1 s2)ω de la Figure 1 n'est pas reconnue par la séquence χ = (sb0 sb0 sb1)ω car
celle-ci ne contient pas d'infinité d'état d'acceptation malgré qu'elle satisfasse la condition 1 de
reconnaissance (voir Définition 15).
- 23 -
4. Exemples de propriétés LTL et de codage en Automates de Büchi
4.1. Exemple 1 : Violation de propriété de la forme (p ⇒ Oq)

La propriété suivante : (De=libre ⇒ O(De=occupé)) est violée par le robot Figure 1.
4.1.1. Calcul de sa négation

¬ (p ⇒ Op)
≡ ◊¬ (p ⇒ Oq) car ¬ p = ◊¬p
≡ ◊¬ (¬p ∨ Oq) car a ⇒ b = ¬a∨b
≡ ◊(p ∧¬Oq) car ¬¬p = p et ¬ (a ∨ b) = ¬a ∧ ¬b
≡ ◊(p ∧ O¬q) car ¬Oq = O¬q
donc la négation de la propriété est :
(De=libre ⇒ O(De=libre))
Ce qui signifie intuitivement que tous les comportements conduisent inévitablement à 2 états
successifs tels que De=libre, ce qui est vérifié par le graphe d’accessibilité du système Figure 1 où les 2
premiers états satisfont cette condition. La propriété est donc violée. Montrons que nous obtenons ce
résultat par la méthode de construction du produit synchronisé des automates.
4.1.2. Codage en automate de Büchi

L'automate de Büchi de la Figure 29 associé à la propriété (p⇒Oq) reconnaît les mots suivants :
true*.p.q.trueω .
sb0 p q sb2
sb1 true
true
Figure 29 : Automate de Büchi vérifiant la propriété (p⇒Oq)
4.1.3. Produit synchronisé des deux automates

La Figure 31 représente le produit synchronisé des automates des Figure 30 et du robot à 4 états.
Notations utilisées Figure 31.
- les états sont des couples (si, sbj) décorés par des couples de valeurs de <Dt, De>
- l dénote libre,
- o dénote occupé.
De=libre De=libre
sb0 sb1 sb2
true
true
Figure 30 : Automate de Büchi vérifiant la propriété (De=libre ⇒ O(De=libre))

Le graphe Figure 31 contient un cycle sur les états d'acceptation (s2, sb2), (s3, sb2) et (s1, sb2) qui
indique que la propriété suivante :
(De=libre ⇒ O(De=occupé)) est violée.
- 24 -
De cette manière on a montré que certaines exécutions satisfont la négation de la propriété:

(De=libre ⇒ O(De=libre)).
4.2. Exemple 2 : Vérification de propriété de la forme (p⇒◊q)

Vérifions que la propriété suivante du robot n° 1 : (De=occupé ⇒ ◊(De=libre)) est
satisfaite.
4.2.1. Calcul de sa négation

¬ (p ⇒ ◊q)
≡ ◊¬ (p ⇒ ◊q) -- car ¬ p ≡ ◊¬p
≡ ◊¬(¬p ∨ ◊q)
≡ ◊(p ∧ ¬◊q) -- car ¬◊p ≡ ¬p
≡ ◊(p ∧ ¬q)
donc la négation de cette propriété est la suivante :
◊(De=occupé ∧ (De=occupé))
qui est équivalente à : ◊ (De=occupé).
init s0 , sb0
<l, l>
Evac, true Chargt,
Chargt, true De = l
s1, sb0 s1 , sb1

<o, l> <o, l>
Evac, DéChargt, DéChargt,
true DéChargt, De=l De=l
true
s2 , sb0 s2 , sb1 s2 , sb2
<l, o> <l, o> <l, o>
Chargt, Evac, true

true
DéChargt,
s3 , sb0 s3 , sb2 true
<o, o> s0 , sb2 <o, o>
<l, l>
Evac,
true
Chargt, true
s1 , sb2
<o, l>
Figure 31: Produit synchronisé du robot avec la propriété (De=libre ⇒ ODe=libre)
4.2.2. Automate de Büchi codant la propriété

Les mots acceptés sont : true* (De=occupé)ω.
L'automate de Büchi associé est décrit Figure 32.
- 25 -
De=occupé
sb0 sb1
De=occupé
true
Figure 32 : Automate de Büchi vérifiant la propriété ◊ (De=occupé)
4.2.3. Produit synchronisé des automates

Le produit synchronisé des automates représentés Figure 32 et Figure 1 est dessiné Figure 33.
Le graphe de la Figure 33 ne contient pas de cycle sur des états d’acceptation, la propriété n'est donc
pas violée. Par contre, l'exemple montre que des chemins finis contiennent des états d'acceptation. La
propriété n'est pas violée pour autant car il n'existe pas de prolongement qui la viole. Cet exemple illustre
la nécessité du cycle pour décider de la violation sur un chemin infini.
init
s0, sb0
<l, l>
Evac, true
Chargt, true
s1, sb0
<o, l>
DéChargt,
true
s2, sb0
<l, o> Chargt, De=o
Evac, Chargt,
De=o true s3, sb1
s3, sb0
s2, sb1 <o, o> <o, o>
<l, l>
Evac,
De=o
Evac, s1, sb1

true <o, l>
Figure 33: Produit synchronisé du robot avec la propriété (De=occupé)
5. Outils de codage des propriétés PLTL en automates de Büchi

- Algorithme de Vardi et Wolper en 86 :
. "An Automata-theoretic approach to automatic program verification", Symp. on Logic in Computer
Science, juin 86.
- 26 -
. "using asynchronous Büchi automata for efficient verification of concurrent systems". Symp. on
Protocol Specification Testing & verification, Pologne, pp. 90-100, juin 95.
Implantation de cet algorithme dans SPIN et [G.J. HOLZMANN], http://www.lics.bell-
labs.com:8080/cgi-bin/dok.exe.
P. Gastin, D. Oddoux, "Fast LTL to Büchi automata translation", Computer Aided Verification 2001,
p. 53-65.
- Kousha ETESSAMI : outil shareware : http//cm.bell-labs.com/who/kousha/, papiers :
http//www1.bell-labs.com/project/TMP/
Définition du Produit Synchronisé

Les exemples des Figure 31 et Figure 33 sont des produits synchronisés entre un automate de Büchi
A¬P reconnaissant une propriété ¬P et une structure de Kripke étiquetée K. Ces produits synchronisés se
définissent à partir de la notion de produit synchronisé présentée dans le chapitre 2 par la formule
suivante : A(KS) || A¬P \Sync(2APV, SPV) où A(KS) est un automate obtenu à partir de KS en étiquetant les
transitions de A(KS) avec le décor des états de KS.
6.1. Transformation d'une SKE en Automate

Soit V un ensemble de variables de domaines finis et APV l'ensemble de ses propositions atomiques.
Définition 16 – Transformation d’une SKE en AB
def
Soit K = <S, S0, E, R, λ> une structure de Kripke étiquetée sur V, i.e. λ : S → 2APV. A K on associe
un automate A(K)=<Q, Q0, 2APV, T, QA> où :
def
- Q = S ∪ {i} est l'ensemble d'états,
def
- Q0 = {i} est l'ensemble d'états initial, avec i ∉ S,
- T ⊆ Q × 2APV × Q est la relation de transition définie ainsi :
def
T = {(i, λ(s0), s0) | pour tout s0 ∈ S0} ∪ {(s, λ(s'), s') | pour toute transition (s, a, s') ∈ R},
def
- QA = Q, tous les états sont des états d'acceptation.♦
Exemple 17 – transformation d’une SKE en AB
A la structure de Kripke de la Figure 1 est associée l'automate de la Figure 34.
6.2 Produit synchronisé

Définition 17 – Produit synchronisé d’automates de Büchi :
def
Soit AB = <SB, sb0, SPV, TB, SBA> un automate de Büchi reconnaissant une propriété PLTL ¬P.
Soit K une structure de Kripke modélisant un système S sur l'ensemble de variables V. Soit A(K)
l'automate <Q, Q0, 2APV, T, Q> obtenu en appliquant la définition 3.8. Le produit synchronisé qui calcule
LS ∩ L¬P est défini ainsi : A(K) || AB \ {(AP, p) | AP ∈ 2APV et p ∈ SPV et AP |= p}.♦
- 27 -
i
{De=l, Dt=l}
s0
{De=l, Dt=o}
s1 {De=l, Dt=l}
{De=o,
Dt=l}
{De=l, Dt=o}
s2
{De=o, Dt=o}
s3
Figure 34 : Automate associé à la SKE de la Figure 1 d’après la Définition 16

Ce produit synchronisé est une restriction du produit synchrone au sens où l'ensemble de
synchronisation {(AP, p) | AP ∈ 2APV et p ∈ SPV et AP |= p} est inclus dans 2APV × SPV. C'est pour cette
raison que ce produit est souvent appelé produit synchrone dans la littérature. Les états d'acceptation sont
les éléments (si, sbj) tels que si ∈ Q et sbj ∈ SBA.
Exemple 18 – produit synchronisé d’AB
Le produit synchronisé de l'automate de Büchi de la Figure 30 (¬P ≡ ◊(De=l ∧ O(De=l)) avec
l'automate du robot représenté dans la Figure 34 est représenté dans la Figure 35.
L'automate de la Figure 35 contient deux cycles incluant des états d'acceptation. Ce sont les mêmes
cycles que ceux de la Figure 31. Ils indiquent que les exécutions suivantes violent la propriété (De=l
⇒ O(De=o)) :
- Chargt, DéChargt, (Chargt, Evac, DéChargt)ω,
- Chargt, DéChargt, (Evac, Chargt, DéChargt)ω.
7. Utilisation pour la vérification

Soit une propriété PLTL P à vérifier sur une structure de Kripke étiquetée KS modélisant un système S
défini sur V. Le principe de la vérification est le suivant :
1 codage de ¬P en un automate de Büchi A¬P
2 calcul de A(KS) selon la Définition 16
3 Calcul de LS ∩ L¬P = A(KS) || A¬P \{(AP, p) | AP ∈ 2APV et p ∈ SPV et AP |= p}.
4 si LS ∩ L¬P = alors KS satisfait P
Sinon KS ne satisfait pas P
et les chemins de LS ∩ L¬P sont des exécutions erronées (violant P, satisfaisant P).
- 28 -
8. Résumé, Conclusion
- Les AB permettent de reconnaître des langages ω-réguliers (séquences infinies),
- Les propriétés PLTL définissent un langage ω-régulier reconnaissable par un AB,
- Toutes les propriétés PLTL sont codables en AB,
Un algorithme de vérification de propriétés PLTL utilise ce codage.
- Le produit synchronisé d'automate et d'automate de Büchi permet de décider si la propriété
modélisée par l'automate de Büchi est satisfaite ou non par l'automate.
i, sbo {De=l, Dt=l}, De=l
{De=l, Dt=l}, true
so, sbo so, sb1

{De=l, Dt=l}, true
{De=l, Dt=o}, De=l

{De=l, Dt=o}, true {De=l, Dt=o}, De=l
{De=l, Dt=l}, De=l
s1, sb2
s1, sbo s1, sb1
{De=o, Dt=l}, true

{De=o, Dt=l}, true
{De=l, Dt=o}, true {De=l, Dt=o}, true
s2 ,sbo s2, sb2
{De=o, Dt=o}, true {De=o, Dt=o}, true

{De=l, Dt=o}, true
{De=l, Dt=l}, true
s3, sb2
s3, sbo {De=l, Dt=o}, De=l so, sb2
Figure 35 : Produit synchronisé des automates des Figure 34 et Figure 30.
- 29 -
Cours n°4 - Automates avec variables de données et abstraction - Master Informatique
AUTOMATES AVEC VARIABLES DE DONNEES ET ABSTRACTION
1. Exemples d'automates avec variables

Un automate avec variables est un automate dont les transitions agissent de deux manières :
→
- par transformation d'état : ss t sc
- par modification de valeur de variables externes : ss →→→→→→

select g then
t a end sc
Exemple 19 – automate avec variables

Cas du digicode où le nombre d'erreur de frappe maximum est de 3. Celui-ci est modélisé par la
variable cpt. Par exemple, le code étant ABB, la frappe de AACABB permet d'ouvrir la porte. Par contre
la frappe de ABCABCB conduit à un état d'erreur où la porte est bloquée.
L'automate avec variable est représenté Figure 36.
B, C ; select cpt<3 A ; select cpt<3 then

then cpt := cpt+1 end cpt := cpt+1 end
A, cpt := 0
A B B
cpt := 0
s1 s2 s3
s0
C ; select cpt<3
then cpt := cpt+1 end A ; select cpt<3 then
cpt := cpt+1 end
A, C ; select cpt=3
then cpt := cpt+1 end
s4
B, C ; cpt := 1
Figure 36. : digicode avec transitions gardées

Exemple 20 – automate avec variables, montre
Cas de la montre où H et M sont des variables (voir Figure 37).
Exemple 21 – automate avec variables, robot
Cas du robot de transport de pièces où De est une variable (voir Figure 38).
On remarque qu'une transition n'est plus une simple étiquette, mais une étiquette éventuellement
accompagnée d'une action gardée Select g then A end. La transition est déclenchable si g est vraie. Son
déclenchement effectue le changement d'état et applique l'action A sur les variables externes.
- 31 -
m ; select M<59 then M := M+1 end
h ; select M = 59∧ H < 23 then H, M := H+1, 0 end

H, M := 0, 0 s0
j ; select M = 59 ∧ H=23 then H, M := 0, 0 end
Figure 37. : Automate de montre avec variables
C
De:=libre s0 s1 E ; select De=occupé
then De:=libre end
Dt Dt
D ; select De=libre
then De:=occupé end
E ; select De=occupé
then De:=libre end
Figure 38. : Automate du Robot avec variables
2. Pourquoi des automates avec variables ?

1. Faciliter la modélisation en réduisant le nombre d'état.
2. Diminuer le nombre d'état (abstraire) pour faciliter la vérification quand elle reste possible.
Raison 1.
. Par exemple l'automate à 4 états du Robot est devenu un automate à 2 états en faisant passer De du
statut de variable de contrôle au statut de variable de données.
. L'automate à 1440 états de la montre est devenu un automate à 1 état en faisant passer H et M en
variable de données.
. L'automate du digicole déplié, en faisant passer la variable de données cpt du statut de variable de
données au statut de variable de contrôle passe de 5 à 17 états (voir Figure 39).
Raison 2.
. Par exemple sur l'automate du digicole, Figure 36, il est possible de démontrer que l'état s3 est
toujours atteignable à moins qu'on soit dans l'état s4 (état d'erreur). Il est donc inutile de raisonner
sur l'automate déplié qui est beaucoup plus grand.
Ceci est possible sans raisonner sur les actions gardées des transitions car, sur l'exemple, il n'y a
A s,s →
pas d'action gardée sur les transitions s → B s,s → B s.
0 1 1 2 2 3
Mais ceci n'est pas toujours le cas. Par exemple sur l'automate du robot Figure 38, il n'est pas possible
de démontrer que si Dt est occupé, alors fatalement Dt déchargera (Dt=occupé ⇒ ◊(Dt=libre)) sans
démontrer que la transition s1 E , select De=occupé
→ then De:=libre end s1 en peut pas s'appliquer indéfiniment. Par
contre cette propriété se démontre sans difficulté sur l'automate déplié à 4 états (voir Figure 1).
- 32 -
A B B
s0 s1 s2 s3
cpt=0 cpt=0 cpt=0 cpt=0
C A A,C
B,C
B B
s0 A s1 s2 s3
C A A,C
B,C
B B
s0 A s1 s2 s3
C A A,C
B,C
B B s3
s0 A s1 s2
A,C
A,C
B,C
s0
cpt=4
Figure 39. : Digicole avec comptage des erreurs
3. Automate avec variables, automate déplié, variables de contrôle et variables de données

def
Soit E un alphabet d'événements. Soit X = {x1, x2, …, xn} un ensemble de variables typées sur des
def
domaines finis Dxi. Soit APX = {xi=di | xi ∈ X et di ∈ Dxi} un ensemble de propositions atomiques sur X.
L'ensemble des propositions booléennes sur X, SPX, définissant l'ensemble des gardes g, g' ∈ SPX est
défini par la grammaire suivante :
g, g' ::= apx | true | ¬g | g ∨ g'. où apx ∈ APX.
Le langage des expressions sur X est de la forme suivante :
Exp ::= d | x | Exp+n | Exp-n où d ∈ Dx, x ∈ X et n ∈ Nat.
Son évaluation est définie ainsi où {x1=d1, …, xn=dn} représente l'environnement qui définit les
valeurs de chaque variable de X:
. Eval(d, {x1=d1, …, xn=dn}) = d,
. Eval(xi, {x1=d1, …, xn=dn}) = di,
. Eval(e+n, {x1=d1, …, xn=dn}) = Eval(e, {x1=d1, …, xn=dn})+n,
. Eval(e-n, {x1=d1, …, xn=dn}) = Eval(e, {x1=d1, …, xn=dn})-n.
Le langage des actions gardées est l'ensemble des formules de la forme Select g then x, y, …, z := ex,
ey, …, ez end où g ∈ SPX et x, y, …, z ∈ X et := ex, ey, …, ez ∈ Exp.
Définition 18 - SKE avec variables :
Une SKE avec variables <S, S0, E, R, λ, X, Init> est une SKE <S, S0, E, R, λ> à laquelle on a ajouté
un ensemble de variables X et une action initiale Init qui fixe la valeur des variables dans l'état initial et
où la relation de transition R est un sous-ensemble de S × (E × A) × S.♦
- 33 -
Une SKE avec variables a des transitions étiquetées par un couple (nom d'événement; action gardée).
Exemple 22 – SKE avec variables
La SKE avec variables représentée Figure 38 est la suivante :
def
- S = {s0, s1}, E={C, D},
- R = { s0 E, select De=occupé
→ then De:=libre end s0, s0 C,→
skip
def
s1,
s1 E, select De=occupé
→ then De:=libre end s1, s1 D, select De=libre→then De:=occupé end s0}
def
- λ = {s0 å {Dt=libre}, s1 å {Dt=occupé}}
def def
- X = {De}, Init = Select true then De:=libre end
On notera que la valeur de De a disparu du décor par la fonction λ. On dit que De est une variable de
donnée alors que Dt est une variable de contrôle. La valeur des variables de contrôle est exprimée sur par
l'état par la fonction λ alors que la valeur des variables de données est définie par les actions sur les
transitions.
Définition 19 - Dépliage d’une SKE avec variables :
La SKE dépliée d'une SKE avec variables <S, S0, E, R, λ, X, Init> où X={x1, …, xn} est la SKE <Sd,
S0d, E, Rd, λd> définie ainsi :
def
- Sd = S × Dx1 × … × Dxn ; chaque état est dupliqué pour chaque n-uplet de valeurs possibles des
variables de données
def
- S0d = S0 × {(d1, …, dn)} où {(d1, …, dn) est le n-uplet de valeurs défini par l'action Init (= Select
true then x1, …, xn := d1, …, dn end)
e (s', d' , …, d' ) ∈ R ssi :
- R ⊆ S × E × S est telle que (s, d , …, d ) →
d d d 1 n 1 n d
. s (e, select→g then A) s' ∈ R,

. et {x1=d1, …, xn=dn} |= g,
. et soit A = x, y, …, z := ex, ey, …, ez,
d'i = di si xi ∉ {x, y, …, z},
d'i = Eval(eu, {x1=d1, …, xn=dn}) si xi ∈ {x, y, …, z} et xi=u ; Eval(eu, {x1=d1, …, xn=dn})
évalue l'expression eu dans le contexte où {x1=d1, …, xn=dn}.
- λd : Sd → 2APV ∪ APX telle que λd((s, d1, …, dn)) = λ(s) ∪ {x1=d1, …, xn=dn}.♦
Exemple :
L'automate déplié du robot représenté Figure 38 est celui de la Figure 1. Sa définition est la suivante :
def def
V = {Dt}, X={De}, DDe = {libre, occupé},
def def
S0d = (s0, libre)} car Init = Select true then De := libre,
def
- Rd = {(s0, occupé) → E {(s , libre), (s , libre) →
C {(s , libre),
0 0 1
(s0, occupé) →C {(s , occupé), {(s , occupé) → E {(s , libre), {(s , libre) →
D {(s , occupé)},
1 1 1 1 0
def
λd = {(s0, occupé) å
 {Dt=libre, De=occupé}, (s0, libre) å {Dt=libre, De=libre},
(s1, libre) å {Dt=occupé, De=libre}, (s1, occupé) å {Dt= occupé, De=occupé}}
Le dépliement s'effectue ainsi :
- dupliquer chaque état pour chaque valeur des variables de données,
- déplier les transitions entre occurrences d'état si la garde est vraie,
- éventuellement, supprimer les états qui ne sont pas atteignables.
Exercice 3 :
- 34 -
Effectuer cette opération sur l'automate de la Figure 36 et vérifier que vous obtenez l'automate de la
Figure 39.♦
B,C A
A
A B B
s0 s1 s2 s3
C A
C
A,C
B,C A,C
s4
B,C
Figure 40. : digicode abstrait
4. Automate avec variables et abstraction sur les variables de contrôle

Quand le nombre d'état est trop grand pour effectuer automatiquement une vérification et si certaines
variables de contrôle sont inutiles pour vérifier la propriété d'intérêt alors on peut abstraire l'automate en
le pliant en un automate avec variables puis oublier les variables pour vérifier la propriété. Par exemple la
Figure 40 représente une telle abstraction pour l'exemple du digicode.
L'opération de pliage est définie dans la Définition 20 à partir de la relation d'équivalence ≡ sur S×S
définie ainsi : s ≡ s' ssi λ(s)\{x=d | x ∈ X et d ∈ Dx} = λ(s')\{x=d | x ∈ X et d ∈ Dx}.
Définition 20 - Abstraction d’une SKE :
def
Le pliage d'une SKE <S, S0, E, R, λ> sur l'ensemble de variables X ⊆ V où X = {x1, …, xn} est la
SKE <Sp, S0p, E, Rp, λp> définie ainsi :
def
Sp = S\≡ ; Sp est formé d'un état par classe d'équivalence (son représentant),
def
S0p = S0\≡ ; S0p est formé d'un état par classe d'équivalence de S0,
e s' ∈ R ssi :
Rp ⊆ Sp × E × Sp est telle que s → p
. e s' ∈ R) où
∃s1.∃s'1.(s1 ∈ S ∧ s'1 ∈ S ∧ s1 ∈ Cl(s) ∧ s'1 ∈ Cl(s') ∧ s1 → 1
Cl(s)={s2 | s2 ∈ S et s2≡s}.
- λp : Sp → 2APV\X telle que λ p(s) = λ (s)\{x=d | x ∈ X et d ∈ Dx}.♦
Le pliage sur X réalise une fusion des états de S qui sont décorés par le même ensemble de
propositions atomiques sur X. Les transitions entre 2 états de la même classe d'équivalence deviennent
des boucles sur cet état. Les transitions entre 2 états de 2 classes d'équivalence différentes reste une
transition entre les 2 représentants de leur classe.
- 35 -
Sur l'exemple du digicode plié, nous pouvons démontrer la propriété de sûreté suivante : A partir de
l'état s0 si l'utilisateur tape ABB, il atteint l'état s3. Cette propriété vraie sur l'automate de la Figure 40 est
également vraie sur l'automate déplié de la Figure 39.
Pour démontrer une propriété sur un système ayant un trop grand nombre d'état, on la démontre sur
une abstraction qui est obtenue à partir d'un pliage avec un automate avec variable.
Quelles sont les propriétés qu'on peut démontrer ainsi ?
Théorème 1 – Préservation des propriétés de sûreté :
Soit V un ensemble de variables. Soit X un sous-ensemble de V. Soit K une SKE. Soit Kp le pliage de
K sur X. Soit P une propriété de sûreté, alors Kp |= P ⇒ K |= P.♦
Preuve
Un automate plié a plus d'exécutions que l'automate de départ. Si quelque chose de mauvais n'arrive
pas sur un ensemble d'exécutions, il n'arrivera pas sur un sous-ensemble de celui-ci.♦
Par contre une propriété de sûreté violée sur le système abstrait pourrait être satisfaite par le système
déplié.
Une propriété de vivacité telle que, il existe un comportement où l'on reste fatalement dans les états s0,
s1 et s2 est satisfaite par l'abstraction Figure 40 et pas par l'automate déplié Figure 39.
L'abstraction sur un ensemble de variables de contrôle C consiste à retirer du décor des états toutes les
propositions sur les variables de C, fusionner les états dont le décor sur les variables de contrôle restant
est identique et conserver les transitions entre ces états en transformant les transitions entre états
fusionnés en boucle.
Par exemple pour passer de l'automate Figure 39 à celui de la Figure 40, on abstrait la variable de
contrôle cpt :
- on a fusionné les états qui ont la même valeur pour la fraction de séquence correcte tapée par
l'utilisateur,
- on a conservé toutes les transitions entre ces états ; les transitions entre 2 états regroupés
deviennent des boucles sur l'état fusionné.
5. Résumé, conclusion
. L'ensemble d'états d'un automate est défini à partir de toutes les valeurs possibles des variables de
contrôle du système modélisé,
. Considérer certaines variables comme des variables de données engendre une modélisation par un
automate avec variables,
. Un automate avec variables de données a des transitions étiquetées par une action gardée de
modification des variables de données,
. C'est un moyen de réduire l'ensemble d'états considéré,
. Ce pliage est intéressant quand il permet de vérifier des propriétés sur un espace d'état plus petit,
. Ce pliage permet de vérifier uniquement des propriétés de sûreté (quelque chose de mauvais ne se
produit jamais), mais pas des propriétés de vivacité (quelque chose de bon arrive inévitablement),
. Le dépliage d'un automate avec variable engendre un automate.
. Dans ce chapitre, on a défini les fonctions de Dépliage et d'Approximation selon le schéma de la
Figure 41:
L'approximation est définie ainsi :
def def
S = S, S = S , R ⊆ S×E×S telle que : s → a s' ∈R si s a, Select g→then A end s' ∈R et λ def
=λ
p 0p 0 p p p
SKE sur V avec

variables -de
36 -
Abstraction sur X
<S, S0, E, R, λ, X, Init> sur V
Dépliage Approximation
<Sp, S0p, E, Rp, λp>

Figure 41: Dépliage et Approximation de SKE avec variable de données
- 37 -
Cours n°5 - Automates communicants - Master Informatique
AUTOMATES COMMUNICANTS
1. Pourquoi et comment faire communiquer des automates ?
1.1. Pourquoi ?
La raison essentielle pour utiliser le concept d'automate communicant est la facilité d'expressivité d'un
produit synchronisé d'automates.
Premièrement, qui dit automates communicants, dit décomposition du modèle en plusieurs automates
pour simplifier la conception.
Deuxièmement qui dit décomposition dit recomposition par produit synchronisé.
Les automates communicants sont un moyen d'expression implicite d'un produit synchronisé.
Exemple
Pour décrire le système du robot de transport de pièces le plus abstrait en deux composants, on peut :
- soit utiliser le produit synchronisé comme l'indique la Figure 42,
- soit utiliser les automates communicants comme l'indique la Figure 43.
s0 s2
De Dt
Evac DépotPièce Déchargt Chargt
s1 s3
De Dt
Figure 42. : Automates Evacuateur et Pince
Le robot de la Figure 1 est obtenu en effectuant le produit synchronisé des deux automates de la
Figure 42 ainsi :
Robot||Evacuateur||Pince \ {Evac, Chargt, (DépotPièce, DéChargt)}.
Celui-ci est décrit implicitement par la mise en parallèle des deux automates communicants de la
Figure 43 : Robot||Cevacuateur||CPince.
Les automates communicants utilisent des transitions spéciales d'envoi et de réception de messages
notées ainsi :
- !t : l'envoi du message t aux autres automates,
- ?t : réception du message t.
- 39 -
s0 s2
De Dt
Evac ?Déchargt !Déchargt Chargt
s1 s3
De Dt
Figure 43 : Automates communicants CEvacuateur et CPince
Le produit synchronisé d'automates communicants est implicitement défini ainsi :
- toute transition !t est synchronisée avec une transition ?t quand les deux existent,
- toutes les autres transitions sont asynchrones.
Var TPG ∈ {T1, T2, AP} Var TPD ∈ {T1, T3, AP} Var TP ∈ {T1, T2, T3, AP}
/*type de pièce gauche ; AP : aucune pièce */
TPD:=AP TP:=AP
TPG:=AP
?D(P) ; Chargt ;
EvacG ; ?D(P) ;
select P ∈{T1, T2} EvacD ; !D(TP) ; Any P Where
TPG:=AP select P ∈{T1, T3}
then TPG:=P TPD:=AP TP:=AP P ∈{T1, T2, T3}
then TPG:=P
end then TP:=P
end
end
Figure 44 : Automates communicants par échange de messages EvacuateurG, EvacuateurD et

PinceV
1.2. Comment ?
La communication s'effectue de deux manières :
1. par échanges de messages :
. de contrôle pur (cas du robot Figure 43.),
. et de données (voir exemple ci-dessous).
2. par variables partagées (cas des automates avec variables de données).
. exemple de communication de messages de contrôle pur (voir le cas du robot Figure 43),
. exemple de communication de messages de contrôle et de données (voir le cas du robot Figure
44.).
- 40 -
L'exemple du robot avec 2 évacuateurs et trois types de pièces peut être décrit par des automates
communicants avec variables de données comme l'indiquent les Figure 44 et Figure 45.
Les règles de déchargement sont les suivantes :
- les pièces de type T1 peuvent être déchargées à droite ou à gauche,
- les pièces de type T2 à gauche seulement,
- les pièces de type T3 à droite seulement.
C C C
EG
ED
T1 T2 T3
ED EG ED
(!D, ?D) (!D, ?D) (!D, ?D)
T1 T1 T2 T3
C C C C C
ED
T1 T1 T2 T1 T3 T1 ED
(!D, ?D) (!D, ?D) (!D, ?D)
Figure 45 : Automate déplié obtenu par la mise en parallèle des 3 automates de la Figure 44.
La Figure 44 décrit des automates avec variables dont les transitions :
- d'émission de la forme : ! t(x) ; select P(x) then A(x) end
- et de réception de la forme : ? t(y) ; select P'(y) then A'(y) end
se synchronisent ssi P(x) ∧ P'(x) est satisfait.
Lorsque cette transition synchrone est déclenchée la valeur de x est reçue par la variable y et fait l'objet
de l'action A'(x)||A(x).
La mise en parallèle des trois automates de la Figure 44 donne le système décrit par l'automate déplié
de la Figure 45. Celui-ci pourrait être obtenu par un produit synchronisé de trois automates sans variables
et sans échange de données.
On peut voir, malgré la modestie de cet exemple, la puissance d'expression des automates
communicants avec variables par rapport aux automates bruts. La composition parallèle de 3 automates à
2 états donne un automate déplié à 38 états.
2. Automates communicants par échange de messages
2.1. Synchronisation par rendez-vous
- 41 -
Dans le cas de l'exemple de la Figure 43 les automates se synchronisent sur les transitions (!t, ?t).
Dans ce cas le produit de 2 automates communicants A1 et A2 est un produit synchronisé où Sync est
composé :
- de tous les couples (!t, ?t) pour toute transition !t ∈ Ai et ?t ∈ Aj, i ≠ j
- de toutes les transitions t de A1 et A2 qui ne sont pas des émissions ou des réceptions,
- de toutes les émissions !t pour lesquelles il n'existe pas de réception associée ?t et réciproquement.
2.2. Echange d'informations par rendez-vous

Dans le cas de l'exemple de la Figure 44 les automates communicants se synchronisent sur l'envoi et la
réception de messages et échangent des données lors de cette synchronisation.
Une transition (!t(x) ; select P(x) then A(x) end, ?t(y) ; select P'(y) then A'(y) end) est déclenchable ssi
P(x) ∧ [y :=x] P'(y). L'effet de son déclenchement est [y := x] A'(y)||A(x).
La présentation formelle de la construction de l'automate global dans le cas d'échange de messages par
rendez-vous est une combinaison assez naturelle du dépliage des automates avec variables et du produit
synchronisé pour la synchronisation par rendez-vous. Nous faisons cette présentation Figure 46.
EG ?DT1 ?DT2 EG ED ?DT1 ?DT3 ED ?DT1 C

?DT3 C
C ?DT2
T1 T2 T1 T3 T1 T2 T3
Figure 46 : Automates synchronisés par rendez-vous correspondant au dépliement des automates

avec variables de la Figure 44
2.3. Echange d'information par file FIFO
!Emettre(x) ?Recevoir(y)
Automate Automate
Emetteur file FIFO Récepteur
Figure 47 : communication par File FIFO

Quelquefois, quand c'est possible, les données sont échangées de manière asynchrone en introduisant
une file FIFO entre 2 automates communicants comme l'indique la Figure 47.
Une file FIFO est elle-même un automate communicant gérant une variable de type file d'attente
comme le décrit l'automate Figure 48.
- 42 -
var F : file d’élément

F := φ
!Recevoir(e)
?Emettre(e) ; select F = φ
ajouter e à la then retirer e du
fin de F début de F
end
Figure 48 : Automate File infinie

Les files peuvent être de taille finie (automate à nombre d'état fini) ou infinie (automate à nombre
d'état infini).
3. Automates communicants par variables partagées

On peut également exprimer la communication de données par variables partagées. Par exemple le
robot avec type de pièces de la Figure 44 décrit par transmission de messages est décrit Figure 49 par le
partage des variables TP, TPG et TPD.
Var TPG ∈ {T1, T2, AP}
Var TPD ∈ {T1, T3, AP}
Var TP ∈ {T1, T2, T3, AP}
TPD:=AP TP:=AP
TPG:=AP
?D ; Chargt ;
EvacG ; ?D ;
select TP ∈{T1, T2} EvacD ; !D ; Any P Where
TPG:=AP select TP ∈{T1, T3}
then TPG:=TP TPD:=AP TP:=AP P ∈{T1, T2, T3}
then TPG:=TP
end then TP:=P
end
end
Figure 49 : Automates communicants par variables partagées

Dans cet exemple les automates Evacuateur utilisent la variable TP.
Il y a peu de différence entre les deux descriptions des Figure 49 et Figure 44. Du point de vue
théorique les communications par variables partagées et par transmission de messages se ramènent à un
produit synchronisé d'automates.
4. Résumé, conclusion
- Les automates communicants sont une facilité d'expression (expression implicite) d'un produit
synchronisé.
- Si les automates communicants sont des automates standards, la communication exprime
uniquement de la synchronisation par rendez-vous.
- 43 -
- Si les automates communicants sont des automates avec variables, la communication exprime
également des échanges de données.
- Les échanges de données par rendez-vous peuvent être généralisés à des échanges à travers des
files FIFO.
- Les échanges de données peuvent aussi être exprimés par du partage de variables.
- 44 -
Cours n°6 - Automates temporisés - Master Informatique
AUTOMATES TEMPORISES
1. Motivations
Les automates classiques permettent de modéliser l’ordonnancement des actions d’un réseau
d’automates. Par exemple « déclencher l’action blocage après toute détection de code erroné entré sur le
digicode ». Ces ordonnancements ne contiennent pas d’informations quantitatives sur les délais séparant
deux actions. Ainsi il n’est pas possible de modéliser le déclenchement d’une alarme moins de 5 secondes
après la détection d’un problème. Pourtant de telles contraintes, qualifiées de temps réelles, sont souvent
essentielles dans la modélisation des systèmes.
En pratique, cette limitation est contournable en modélisant une horloge globale contrôlant les actions
du réseau d’automates. On ajoute alors aux automates usuels des transitions spéciales représentant des
« tic d’horloge » qui marquent l’écoulement du temps. Le délai séparant 2 actions correspond alors au
nombre de transitions « tic » effectuées entre ces 2 actions. Par exemple l’automate de la Figure 51
modélise un système qui déclenche une alarme lorsque le délai séparant deux actions a successives est
inférieur à 5 secondes.
L’unité de temps est de une seconde. Chaque transition « tic » incrémente le temps global de une
seconde. Les transitions étiquetées par a ne prennent pas de temps, c’est-à-dire que le modèle est fondé
sur cette hypothèse implicite. Le fonctionnement est le suivant :
- une action a déclenche un chronomètre dans l’état (vérif, 0),
- si l’action a suivante arrive avant que le chronomètre ait compté 5 secondes, l’alarme se déclenche,
- sinon elle réinitialise le chronomètre à zéro.
Le type de modélisation de la Figure 51 n’est guère satisfaisant. D’une part, elle impose d’ajouter un
codage extrêmement lourd pour mesurer les délais, ce qui entraîne une perte de lisibilité du modèle et
accroît les risques d’erreurs de modélisation. On peut s’en rendre compte en observant le modèle
beaucoup plus simple de la Figure 50 où le chronomètre est modélisé par une variable h. D’autre part, le
modèle avec temps explicite ne permet pas de distinguer de façon claire les deux types de transitions, les
tics et les actions du système. Ainsi, remplacer un délai séparant deux actions « inférieur à 5 secondes »
par « inférieur à 0,3 seconde » ou « inférieur à 100 secondes » oblige à changer la structure des
automates, changer l’unité de temps et changer des transitions.
var h : chronomètre
5≤h, a, h:=0
_, a, h:=0 h<5, a, _
init verif alarme
Figure 50 : Un automate temporisé

Dans le modèle de la Figure 50, le changement du délai de 5 à 0.3 s’effectue en changeant les
conditions h≥5 et h<5 respectivement par h≥0.3 et h<0.3. On remarque alors que le temps, considéré
- 45 -
Cours n°6 Automates temporisés – Master Informatique
représenté par un entier dans la Figure 51, est un nombre réel. Par ailleurs on notera que les transitions
« tic » restent implicites dans ce modèle.
init, a verif a alarme

0 0 0
tic a tic tic
init, verif a alarme

a 1
1 1
tic tic
tic
a
init, verif a
alarme
2 2 2
tic tic tic
a alarme
init, verif
3 tic 3 3
tic a tic tic
a alarme
init, verif
4 4 4
tic a
tic tic
init, verif alarme

5 5 5
tic a tic tic
init, verif alarme

6 6 6
tic tic
tic
... ... ...
init, verif alarme
n n 7
tic tic tic
... ... ...
Figure 51 : Modélisation du temps
Les automates temporisés ont été proposés par Alur et Dill [AD 94] en 1994 pour répondre à ce
besoin. La Figure 50 est une représentation graphique d'un automate temporisé d'Alur et Dill.
- 46 -
2. Description des Automates Temporisés (AT)

Un AT se compose de deux éléments fondamentaux :
- une SKE finie usuelle <S, S0, E, R, λ> qui décrit les états de contrôle du système et les transitions
supposées instantanées,
def
- un ensemble fini de variables H = {h1,…,hn} (appelées chronomètres ou horloges), utilisées pour
spécifier des contraintes quantitatives de temps qui peuvent être associées aux transitions de
l’automate fini.
Par exemple, la Figure 50 représente un A.T. dont l’automate fini est représenté Figure 52 et
l’ensemble de chronomètres est l’ensemble {h}.
a
a a
init verif alarme
Figure 52 : Automate sous-jacent à l'AT de la Figure 50

Le temps sur lequel les A.T. permettent de raisonner ne s’écoule qu’entre les actions de l’automate fini
sous-jacent. Le temps passe quand rien ne se passe. En général, les exécutions des automates temporisés
sont définies avec l’hypothèse Non Zeno qui a pour effet d’interdire de faire une infinité d’actions en un
laps de temps fini.
Définition 21 - contrainte d'horloge :
Soit H un ensemble fini de chronomètres. Une contrainte de chronomètre (ou d’horloge) est une
formule du langage suivant appelé C(H) :
ϕ ::= h~c | c~h | ϕ ∧ ϕ
où h, h’ ∈ H, c ∈ Q (nombres rationnels) et ~ ∈ {<, ≤}.♦
Remarque : Le langage des contraintes d'horloges est défini ainsi pour le limiter à la définition de
zones convexes dans l'espaces des horloges. h≤c, h<c, c<h et c≤h sont des convexes. L'intersection de
deux convexes ϕ1 et ϕ2 est un convexe, donc ϕ1 ∧ ϕ2 définit un convexe. Les contraintes h=c exprimables
avec ce langage, ne seront pas autorisées dans les propriétés MITL pour des questions de décidabilité du
model checking MITL ((voir section 4.5). Les propriétés de la notion de convexe sont utiles pour
permettre l'abstraction finie de la sémantique infinie des automates temporisés (voir Automates des
zones).
Définition 22 – Automate Temporisé :
def
Soit A un alphabet d’actions. Soit H un ensemble de chronomètres. Un A.T. est un tuple AT = <A, H,
S, S0, R> où
- S est un ensemble fini d’états,
- S0 ⊆ S est l’ensemble des états initiaux,
- R ⊆ S × C(H) × A × 2H × S est l’ensemble de transitions étiquetées ; 2H est l’ensemble des
chronomètres remis à zéro.♦
Exemple 23 – automate temporisé
L’A.T. de la Figure 50 est décrit ainsi :
def
- A = {a}
def
- H = {h}
- 47 -
def
- S = {init, verif, alarme}
def
- S0 = {init}
def a ,{h} ≤ h , a ,{h} <5, a ,Φ
R = {init true
, → verif, verif 5  → verif, verif h → alarme}.
On notera que dans la notation graphique (voir Figure 50), les ensembles de chronomètres remis à zéro
sont notés explicitement par des affectations (exemple : h := 0) qui représente l’ensemble des horloges
remises à zéro (exemple : {h}).
Remarque
L'AT pourrait être muni d'une application λ pour devenir une SKE temporisée si son utilisation le
nécessite comme c'est le cas du model-checking.
2.1. Chronomètres et transitions
Les chronomètres sont des variables à valeurs réelles positives (ℜ+). Ils progressent tous à la même
vitesse de manière synchrone.
L’étiquette d’une transition est définie par trois éléments :
- une condition d’activation de la transition (∈ C(H)),
- un nom d’action (étiquette usuelle appartenant à A),
- une action de remise à zéro de certains chronomètres (définie par l’ensemble des chronomètres
remis à zéro).
Note : la condition true est représentée par _, l’action représentée par _ ne modifie aucun chronomètre.
On remarque que dans l’exemple présenté section 3, le modèle contient deux chronomètres, celui du
train, noté Ht, et celui de la barrière, noté Hb, qui sont synchronisés, c’est-à-dire qui progressent
simultanément de la même durée.
A cause de l’interprétation des chronomètres dans ℜ+, le nombre d’état d’un AT est infini. Cependant,
il peut se déplier en un automate fini où les états sont un couple état de contrôle, intervalle de temps. La
Figure 53 représente un dépliement de l’AT de la Figure 50 où le chronomètre h est représenté par des
intervalles de temps. Ceci permet d’obtenir un automate à nombre d’état fini.
Les intervalles de temps ont été définis ainsi :
- [0..0] est l’intervalle avant tout écoulement du temps,
- ]0..5[ est l’intervalle pendant lequel une alarme est déclenchée par l’action a,
- [5..∞] est l’intervalle pendant lequel l’action a s’exécute sans déclencher l’alarme.
Avec cet automate, on simule l’écoulement du temps par un choix aléatoire d’une valeur des
chronomètres dans un intervalle des états cible de chaque action «tic». On a déplié l'AT en un automate à
nombre fini d'états en discrétisant le temps à partir des propriétés de l'application. Sur l'exemple, l'alarme
est déclenchable dans l'intervalle [0..5[ et ne l'est plus dans l'intervalle [5..∞]. L'instant 0 est distingué
pour représenter l'état initial.
2.2. Configuration et exécution

Une configuration du système définit son état global. Elle est constituée :
- du nom de son état de contrôle,
- d’une valeur de chaque chronomètre.
On note (s, v) une configuration où :
- s∈S
- v ∈ H → ℜ+ (fonction totale, chaque chronomètre a une valeur). On désigne par v(h) la valeur du
chronomètre h.
- 48 -
Par exemple les couples (init, 10.2), (vérif, 3.5), (vérif, 5.6) et (alarme, 4.2) sont respectivement des
configurations de l’AT de la Figure 50, avec respectivement h = 10.2, h = 3.5, h = 5.6 et h = 4.2.
Un système peut changer de configuration de 2 manières :
init, tic a verif, a alarme,

init,
0,∞
[ ]
[0..0] [0..0] [0..0]
tic tic
tic tic
verif, a alarme,
a
]0..5[ ]0..5[
tic
verif, alarme,
[5..∞] [5..∞]
Figure 53 : Dépliage de l'AT de la Figure 50 sur des intervalles de temps
Par écoulement du temps : (s, v) tic

→ (s, v’)
a (s’, v’)
Par activation de l’une des actions a ∈ A de l’automate : (s, v) →
L’écoulement du temps ne change pas l’état de contrôle. Les actions changent l’état de contrôle et
peuvent remettre à zéro des chronomètres.
En l’absence de remise à zéro de chronomètres, une action est définie par le changement de
a (s’, v).
configurations (s, v) →
Définition de la satisfaction d'une contrainte d'horloge :
Le prédicat "une valuation d'horloges v satisfait une contrainte ϕ", noté v|=ϕ est défini ainsi :
- v |=h~c ssi v(h)~c est vrai
- v |=c~h ssi c~v(h) est vrai
- v |= ϕ1 ∧ ϕ2 ssi v |= ϕ1 et v |= ϕ2♦
Définition 23 - exécution d’un AT :
def
Une exécution d’un AT = <A, H, S, S0, R> est une séquence infinie de configurations (s0, v0), (s1, v1),
(s2, v2), … (si, vi),… telle que pour tout i ∈[0..∞] :
- soit si+1 = si et il existe un délai d ∈ ℜ tel que : vi+1(h) = vi(h) + d pour tout h ∈ H,
- soit il existe une action a ∈A telle que :
. t = si c → si+1 ∈R
,a , H '
. les valeurs des chronomètres dans vi satisfont la condition c : vi |= c
- 49 -
. les valeurs des chronomètres dans vi+1 sont identiques à celles de vi sauf celle qui appartiennent
à H’ qui sont remis à zéro notée vi+1 := [H']vi.♦
Autrement dit chaque configuration (si, vi) est reliée à la configuration (si+1, vi+1) soit par une transition
d’écoulement du temps, soit par une action de changement d’état de contrôle du système.
Exemple 24 - exécution de l’AT de la Figure 50
Exécution 1 : (init, 0), (verif, 0), (alarme, 0), (alarme, 4.2),…
Exécution 2 : (init, 0), (init, 15.1), (verif, 0), (verif, 5.5), (verif, 0), (verif, 10.3), (verif, 0),…
Exécution 3 : (init, 0), (init, 17.2), (verif, 0), (verif, 4.2), (alarme, 4.2), (alarme, 4.4),…
Arrivée Sortie
voie
loin avant sur loin
Figure 54 : Un passage à niveau

_, ?Sortie, _ _, ?Arrivée, _
_, ?Arrivée, Hb := 0se-baisse
_, !Arrivée, Ht := 0 levée Hb<45
avant _, ?Arrivée,
loin Ht<180 30<Hb ∧ 30<Hb ∧
Hb := 0
Hb<45, _, ?sortie, Hb<45,
30<Ht ∧ 60<Ht ∧ Ht<180, Hb := 0 Baisser, _
Lever, _
Ht<120, Sur,
sur
!Sortie, Ht := 0 se-lève_, ?sortie, Hb := 0
Ht<120
_ Hb<45 baissée
_, ?sortie, _ _, ?Arrivée, _
Train Barrière
Figure 55 : Modélisation temporisée d’un passage à niveau
L’exécution 2 est réalisée par les transitions suivantes de l’automate :
(init, 0) tic → (init, 15.1) true

, → (verif, 0) tic
a ,{h}
→ (verif, 0) tic
≤ h , a , h:= 0
→ (verif, 5.5) 5 → (verif,
5≤ h , a , h:= 0
10.3)  → (verif, 0)…
Dans la littérature, on adopte quelques fois la notation suivante où les transitions tic sont remplacées
par le délai écoulé depuis le début de l’exécution qui figure sous la flèche :
(init, 0) true,a,
→h:=0 (verif, 0) ) 5≤h,20.6
15.1 →a, h:=0
(verif, 0) ) 5≤h,30.9
→a, h:=0
(verif, 0) 5≤h,34.6
→a, h:=0
(alarme, 3.7)…
Dans la littérature [Sch 99], on appelle également trajectoire une exécution. Formellement une
trajectoire est une application de ℜ+ dans l’ensemble des parties de l’ensemble des configurations.Par
exemple dans l’exécution 1 appelée ρ :
def
- ρ(0) = {(init, 0), (verif, 0), (alarme, 0)},
def
- ρ(20.2) = {(alarme, 20.2)}.
- 50 -
Réseaux d’A.T.
Comme dans le cas des automates non temporisés, il est utile de pouvoir construire un modèle
temporisé de façon composée en combinant plusieurs AT mis en parallèle et synchronisés entre eux.
3.1. Exemple - Modélisation d’un passage à niveau

La Figure 54 décrit un passage à niveau simplifié composé d’une voie à sens unique, d’une barrière et
de deux capteurs Arrivée et Sortie signalant respectivement à la barrière l’arrivée d’un train avant la
barrière et son éloignement après la barrière.
La position du train sur la voie est soit :
- loin : hors du champ de considération de la barrière,
- avant : entre la position du capteur d’arrivée et l’entrée de la position protégée par la barrière,
- sur : sur la position protégée de la barrière.
On fait l’hypothèse que la distance de sécurité entre 2 trains ne rend pas possible d’avoir 2 trains au
même instant dans la portion de voie composée de la séquence des deux sections avant et sur.
Si l’on connaît la vitesse du train, ainsi que la vitesse d’ouverture et de fermeture de la barrière, il est
possible de modéliser ce système par les deux automates temporisés de la Figure 55. Pour simplifier, on
suppose que l’unité de temps est la seconde. Le train met entre 60 et 180 secondes pour parcourir la
portion avant, 30 à 120 secondes pour parcourir la portion sur. La barrière met 30 à 45 secondes pour se
lever ou se baisser.
Les actions communicantes !a et ?a sont synchronisées, les autres sont libres. L’ensemble de
synchronisation du système est le suivant :
def
Sync = {(!Arrivée, ?Arrivée), ( !Sortie, ?Sortie), Sur, Lever, Baisser}
La barrière peut être dans quatre états : levée, baissée, en train de se lever (se-lève) et en train de se
baisser (se-baisse). Elle doit être en mesure de répondre aux signaux externes (Arrivée et Sortie)
déclenchés par le train dans tous les états.
Cette modélisation autorise des exécutions avec blocage des actions de changement d’état de contrôle
qui ne sont pas très réalistes. Par exemple si le train reste plus de 180 secondes dans l’état avant, il y reste
indéfiniment car l’action Sur n’est plus déclenchable.
Son exécution serait la suivante :
tic
(loin, 0) → (loin, 10.5) !Arrivée tic
→ (avant, 0) → tic
(avant, 200) → tic
(avant, 220) → …
Pour interdire que ces exécutions soient prises en compte, on peut ajouter des invariants dans les états
comme sur la Figure 55.
Avec ce type d’AT avec invariant, les transitions d’écoulement du temps doivent respecter les
tic
invariants. Par exemple la transition suivante (avant, 0) → (avant, 200) n’est plus valide car Ht ne
respecte pas l’invariant Ht <180 dans l’état cible.
3.2. Exécution d’un réseau d’AT avec Invariants

Une configuration d’un réseau d’Automates Temporisés est un n+1-uplet (s1, s2, …, sn, v) qui respecte
les invariants des états s1, s2, …, sn et où si est l’état de l’automate Ai et v est l’évaluation des
chronomètres. Par exemple (avant, se-baisse, {Ht å10, Hb å 10}) est la configuration où le train est dans
l’état avant, la barrière dans l’état se-baisse et les chronomètres Hb et Ht ont laissé écouler 10 secondes.
Cet état vérifie les invariants respectifs des états avant et se-baisse Ht<180 et Hb<45.
Une exécution est une suite de configurations qui respecte les invariants.
Remarques :
- 51 -
- les chronomètres sont tous synchronisés sur le même temps global,

- ils peuvent être partagés entre plusieurs automates du réseau, comme les seules opérations sont des
remises à zéro, il n’y a pas de conflit d’actions concurrentes.
Le produit synchronisé des 2 AT de la Figure 55 donne l’AT de la Figure 56. On peut constater sur cet
automate que lorsque le train est dans la position sur, la barrière est baissée en respectant les contraintes
de temps.
avant,
_, Arrivée, Ht:=0 || Hb := 0 se_baisse
loin,
levée Ht<180 ∧
Hb<45
30<Hb ∧
30<Hb ∧ Hb<45,
Hb<45, Baisser, _
Lever, _
_, Arrivée,
Ht := 0 || avant,
Hb := 0 baissée
Ht<180
60<Ht ∧
Ht <180,
Sur, Ht := 0
loin, 30<Ht ∧Ht <120, Sortie, Hb := 0 sur,

se_lève baissée
Hb<45 Ht<180
Figure 56 : Produit synchronisé de la barrière et d’un train
Définition 24 - AT avec Invariant :
def
Un A.T. avec invariant est un tuple ATI = <A, H, S, S0, R, I> où I est une application de S dans C(H).
Cette fois une exécution notée (s0, v0) →
t1 (s1, v1) →
t2 (s2, v2) →
t3 doit satisfaire les invariants : v0+t1 |=
I(s0) et vi-1+ti-ti-1 |= I(si-1).♦
Définition 25 - produit synchronisé de 2 AT communicants :
def def
Soit deux AT avec invariant communicants AT1 = <A1, H1, S1, S01, R1, I1> et AT2 = <A2, H2, S2, S02,
R2, I2>. Leur produit synchronisé AT= <A, H, S, S0, R, I> est défini ainsi :
def
- AT = AT1 || AT2 \ {_a| _ ∈ { !, ?, vide} et (!a ∈ A1 et ?a ∈ A2 ) ou (!a ∈ A2 et ?a ∈ A1)}
∪ {( !a, ?a)| !a ∈ E1 et ?a ∈ E2},
def
- H = H1 ∪ H2
def
- S = S1 × S2
def
- S = S01 × S02
- R = (s1, s2) c,a,
→H' (s’1, s’2) telle que :
def
- soit s’2 = s2 et s1 c,a,

→H' s’1 ∈ R1
- soit s’1 = s1 et s2 c,a,
→H' s’2 ∈ R2
- soit s1 c1, →
!a, H1
s’1 ∈ R1 et s2 c2, →
?a, H2
s’2 ∈ R2 et c=c1∧c2 et H’=H1∪H2 et a=( !a, ?a)
- 52 -
- soit s1 c1, →
?a, H1
s’1 ∈ R1 et s2 c2, →
!a, H2
s’2 ∈ R2 et c=c1∧c2 et H’=H1∪H2 et a=( !a, ?a)
- I telle que I(s1, s2) = I(s1) ∧ I(s2).♦
4. Evaluation algorithmique des automates temporisés

La sémantique d'un automate temporisé est l'automate qu'on obtient en le dépliant sur les horloges.
Comme les horloges sont interprétées dans le domaine des réels positifs qui est un domaine dense et
continu, l'automate déplié est un automate infini (AI) sur lequel il n'est pas possible de faire d'évaluation
algorithmique.
Mais les restrictions sur les contraintes d'horloges qui définissent les gardes des transitions et les
invariants d'état permettent de définir un nombre fini de classes d'équivalence de valuation d'horloge
(appelée régions ou zones) qui permet de déplier un automate temporisé par un automate fini appelé
automate des régions (AR). Un théorème établit que AR et AI sont “bisimilaires” (voir Figure 57). Cette
propriété permet d'effectuer des évaluations algorithmiques sur AR qui sont correctes sur AI. Par exemple
la vérification algorithmique d’atteignabilité d’état ou de vérification (model checking) de propriétés
TCTL [ACD 93] sur des automates temporisés, effectuée sur l'AR, est correcte grâce à ce résultat. Nous
verrons que l’automate des régions est défini différemment selon l’analyse qui est effectuée.
Nous présentons en section 4.1. la sémantique d'un AT par un AI et la relation d'équivalence des
valuations d'horloges. Section 4.2 nous définissons l'automate des régions pour effectuer des analyses
d’accessibilité. Enfin, section 4.3., nous présentons l’AR pour effectuer du model checking TCTL.
Sémantique
A Infini Bisimulation A Région Vérification Ppté TCTL
Figure 57 : Vérification des automates temporisés
4.1 Equivalence des valuations d'horloge et Régions

Soit v une valuation des horloges de l'ensemble H. Elle est définie par une application de H dans R+.
Définition 26 - sémantique d'un AT :
def
La sémantique (le modèle) d'un AT = <A, H, S, S0, RT, I> est un automate à nombre d'état infini
def
S(AT) = <A, Q, Q0, T> où
def
- Q = {(s,v) | s∈S et v∈H → R+}
def
- Q0 = {(s, v) | s∈ S0 et ∀h.(h∈H ⇒ v(h)=0)}
- (s, v) → a (s', v') ∈T si :
a, λ
. s g,→ s’∈RT et
. ∃d.∀e.(0≤e≤d ⇒ (v+e) |= I(s)) ∧ v+d |= g ∧ v'= [λ := 0](v+d)).♦
La relation de transition T est obtenue en combinant les transitions d'écoulement du temps ((s, v) succ
→
a
(s, v+d)) et les transitions d'actions ((s, v+d) → (s', v')). d est une durée quelconque qui s'écoule quand le
système est dans l'état s. Toutes les durées inférieures ou égales doivent respecter l'invariant I(s). (i.e.
∀e.(0≤e≤d ⇒ (v+e)╞ I(s)).
- 53 -
L'action a doit être déclenchable à l'instant v+d, c'est-à-dire que sa garde doit être satisfaite (v+d ╞ g)
et la valuation après l'action a qui est instantanée est v+d dans laquelle on remet à zéro les horloges
conformément à la transition de AT ([λ:=0]v+d).
Notations :
- soit H un ensemble d'horloges,
- soit Ch la plus grande constante sur h dans I et les gardes de l'AT,
- t ∈R+, fr(t) est la partie fractionnaire et pe(t) sa partie entière, t = pe(t)+fr(t).
Définition 27 - relation d'équivalence sur les valuations d'horloge :
v ≅ v' ssi les trois conditions suivantes sont satisfaites :
- ∀x.(x∈H ⇒ ((v(x)≥Cx ∧ v'(x)≥Cx) ∨ (pe(v(x)) = pe(v'(x)))),
- ∀x.∀y.((x∈H ∧ y∈H ∧ v(x)≤Cx ∧ v(y)≤Cy) ⇒ (fr(v(x))≤fr(v(y)) ⇔ (fr(v'(x)≤fr (v'(y))),
- ∀x.((x∈H ∧ v(x)≤Cx) ⇒ (fr(v(x))=0 ⇔ fr(v'(x))=0)).♦
Pour un ensemble d'une seule horloge x, l'ensemble des régions est défini ainsi :
def
R = {x = c | c∈{0,1,…, Cx}} ∪ {c–1<x<c | c∈{1,2,…, Cx }} ∪ {x>Cx}.
Par exemple pour Cx = 5, l'ensemble des régions est représenté sur la Figure 58.
x
0 1 2 3 4 5
Figure 58 : Ensemble des régions pour une horloge x avec Cx = 5
Il est composé de six points 0, 1,…, 5, de cinq segments ouverts ]0..1[, ]1..2[, …, ]4..5[ et du segment
ouvert de fin ]5.. ∞[. Le nombre de région est 2Cx+2 (= 12 sur l'exemple).
Pour un ensemble de 2 horloges x, y l'ensemble des régions peut être représenté dans un espace à deux
dimensions comme le montre la Figure 60. On observe sur cette figure plusieurs sortes de régions : des
points (ro), des segments horizontaux (r1) ou verticaux (r4), des segments de diagonale (r6), des triangles
(r5, r7) et des portions de plan rectangulaire ouvertes (r9, r15). Ces régions sont définies par une contrainte
d'horloge. Par exemple, le premier triangle en bas à gauche est défini par 0 <x ∧ x<y ∧ y <1.
Pour n horloges, le nombre de régions explose. Il est borné par |H|! × 2|H| × Π (2cx+2). Dans le cas de
la Figure 59 on obtient : 2!×22×(2×5+2)×(2×2+2) = 2 × 4 × 12 × 6 = 576. En réalité, il y a (4×12) +
(2×22) = 92 régions.
La décomposition en régions permet de discrétiser l'espace temps en garantissant que tous les points
d'une région ont pour premier successeur, en dehors de la région, un point qui est dans la même région.
La relation successeur est représentée sur la Figure 59 par la flèche diagonale "succ" qui montre que la
région successeur du triangle est le segment vertical, car le temps s'écoule à la même vitesse sur Ht et Hb.
Comme les contraintes d'horloges de l'AT ne contiennent que des constantes entières, on est sûr que la
valeur de vérité d'une contrainte est la même sur tous les points d'une région, donc que les régions sont
bien des classes d'équivalence du point de vue de l'interprétation des contraintes.
Les régions sont des convexes qui ont donc 2 propriétés nécessaires pour que l'abstraction de
l'automate infini par l'automate des régions soit en bi-simulation avec l’automate infini :
- toute région a une région successeur immédiate unique,
- la valeur de la vérité de toute contrainte est identique sur toute la région.
Comme toutes les constantes ne sont pas utilisées dans les contraintes, il est possible de conserver ces
propriétés sur des regroupements de régions contiguës appelées zones. Cette optimisation est réalisée par
- 54 -
les algorithmes de model-checking TCTL par exemple [ACH 92]. Elle n'est pas décrite dans ce
document.
Hb
r0 (Ht=0) ∧ (Hb=0)
2 ri (Ht=0) ∧ (1<Hb<2)
rj (2<Ht<3) ∧ (2<Hb)
1
Ht
0
1 2 3 4 5 succ
Figure 59 : Ensemble des régions pour 2 horloges Ht et Hb avec CHt=5 et CHb=2
Définition 28 - fonction succ :
Soit r et r' deux régions (classe d'équivalence de R+H). La région r' est la suivante de r, notée succ(r)
= r' ssi :
∀v.(v∈r ⇒ ∃t.(t∈R+ ∧ v+t∈r' ∧ ∀t'.(t'<t ⇒ v+t'∈(r ∪ r'))).♦
Seule la région ouverte sur l'infini (ex : Cx>5 dans la Figure 58 ou CHt>5 ∧ CHb>2 dans la Figure 59)
n'a pas de successeur. Donc la fonction successeur peut être composée de telle sorte que toute région a
une chaîne de successeurs dont le dernier élément est la région ouverte. Par exemple sur la Figure 60, si
on numérote les régions de gauche à droite et de bas en haut, on obtient les chaînes de successeurs
exhibées dans la Figure 61.
y
14 15 16 17
10 11 12 13
4 5 6
x
7 8 9
0 1 2 3
Figure 60 : Régions pour Cx=1 et Cy=1

Dans la Figure 61 chaque colonne indique le successeur de la colonne précédente. succi(r) est le ième
successeur de r. Les nombres en gras indiquent le début d’une chaîne de successeurs.
Régions succ(r) succ2(r) succ3(r) succ4(r) succ5(r)
r=succ0(r
)
0 6 12 17
1 7 8 9 13 17
2 9 13 17
- 55 -
3 9 13 17
4 5 11 15 16 17
10 15 16 17
14 15 16 17
Figure 61 : Tableau des régions successeurs de la Figure 60
4.2 Automate des Régions pour l’analyse d’accessibilité

On dira qu'une région r satisfait une contrainte d'horloge g, noté r|= g ssi ∀v.(v∈r ⇒ v|=g).
Définition 29 - automate des régions :
def
Soit R l'ensemble des régions de région initiale r0 issu de l'automate temporisé AT = <A, H, S, S0, RT,
def def def
I>. L'automate des régions bisimilaires à S(AT) est AR = <A, SR = S×R, SR0 = S0×{r0}, T> où la
a (s', r') ∈T si :
relation de transition T est définie ainsi : (s, r) →
a, λ s'∈R
- ∃(g, λ) tq s g,→
- ∃i tq
. r' = [λ := 0]succi(r)
. succi(r)╞g
. ∀ j.(0≤j≤i ⇒ succi(r)╞I(s)).♦
Exemple 25 – automate des régions
La Figure 62 représente, à gauche, l'automate des régions de l'automate temporisé qui est représenté à
droite pour une seule horloge Ht avec CHt=2, donc 6 régions dont la chaîne des successeurs est la suivante
:
[0], ]0..1[, [1], ]1..2[, [2], ]2..∞[.
Par exemple, la transition (avant, Ht<2) 1<Ht<2,→ts, Ht:=0 (sur, Ht <1) donne lieu aux 4 transitions
étiquetées par ts dans le graphe des régions.
loin loin loin loin loin loin

[0] ]0..1[ [1] ]1..2[ [2] ]2.. [
app
avant avant avant avant

[0] ]0..1[ [1] ]1..2[
ts
exit loin true, app, Ht:=0 avant
true Ht<2
sur sur
[0] ]0..1[
0<Ht<1, exit, _ 1<Ht<2, ts, Ht:=0
sur
Ht<1
- 56 -
Figure 62 : Automate des régions pour l’analyse d’accessibilité associé au train

ts (sur, [0]) existe dans AT car :
Par définition, la transition (avant, [0]) →
- la transition avant 1<Ht<2,→ts, Ht:=0 sur existe dans AT
- il existe i = 3 tq
. ]1..2[ = succ3([0]) et [0] = [Ht := 0](]1..2[)
. ]1..2[ |= 1<Ht<2
. pour j = 0, 1, 2, 3 : [0] |= Ht<2, ]0..1[|=Ht<2, [1] |= Ht<2, ]1..2[ |= Ht<2.
ts (sur,
Pour les mêmes raisons, les 3 autres transitions existent, par contre la transition (avant, [2]) →
[0]) n'existe pas car la région [2] ne satisfait ni l'invariant, ni la garde.
Finalement, l'automate des régions atteignables est représenté dans la Figure 63.
Cette première définition de l'automate des régions permet de vérifier des propriétés d'accessibilité
(est-ce qu'un état q' est atteignable à partir d'un état q ?).
Pour ces propriétés, les délais sont sans importance, c'est pourquoi l'écoulement du temps a été
supprimé de cet automate. Par contre, pour vérifier des propriétés plus générales, faisant intervenir des
délais, il est nécessaire de conserver l'écoulement du temps dans l'automate. C'est ce qui est fait avec les
τ (s', r') dans la Définition 32.
transitions (s, r) →
loin loin
[0] ]0..1[
app loin true, app, Ht:=0 avant

true Ht<2
avant
[0]
0<Ht<1, exit, _ 1<Ht<2, ts, Ht:=0
ts sur
exit
Ht<1
sur
[0]
Figure 63 : Automate des régions atteignables du train
4.3 Définition de l'automate des régions pour faire du model checking TCTL (voir [ACD 93])
def
Pour évaluer une formule temporisée (ex : φ = E◊<1 ϕ qui signifie, il existe un chemin sur lequel
inévitablement en moins d’une unité de temps, on atteint un état satisfaisant ϕ) et garder la trace du temps
écoulé en traversant une séquence d’états, nous introduisons une nouvelle horloge x∉H. Soit H* =
H∪{x} le nouvel ensemble d’horloges. Soit C(φ) la plus grande constante apparaissant dans φ. On étend
la relation d’équivalence sur H → R+ à H* → R+. On note [v]* la classe d’équivalence v par cette relation
d’équivalence.
- 57 -
Pour déterminer la valeur de vérité d’une formule E◊<c ϕ dans une région v, nous essayons de trouver
une région v’ où ϕ est satisfaite et un chemin de la région v, augmentée avec x=0, vers une région
augmentée de v’ et qui satisfait x<c. La nouvelle horloge x n’est jamais remise à zéro le long de ce
chemin et elle est augmentée des mêmes durées que les autres horloges.
Soit R*, l’ensemble des régions obtenu à partir des horloges d’un automate temporisé auquel on a
ajouté une nouvelle horloge pour évaluer la formule φ.
Définition 30 - notion de région de fin :
On appelle région de fin la région satisfaisant la condition suivante : ∀x.(x∈X* ⇒ x>Cx).
La région de fin est la région ouverte à l’infini sur toutes les horloges. Elle n’a pas de région
successeur. Par exemple la région r17 dans la Figure 60.♦
Définition 31 - région bornée :
On appelle région bornée les régions où au moins l’une des horloges peut prendre une seule valeur,
c’est à dire telle que : ∀v.(v∈r ∧ ∀t.(t∈ R+ ⇒ ¬(v≅v+t))).♦
Par exemple, les régions 0, 1, 2, 3, 4, 8, 10, 11, 12, 13, 14 et 16 sont des régions bornées dans la
Figure 60.
Le graphe des régions d’un automate temporisé est alors défini dans la Définition 32.
Définition 32 - graphe des régions :
def
Soit un automate temporisé AT = <A, H, S, S0, RT, I> et un ensemble de régions R qui définit les
def def def
classes d’équivalence des horloges de AT. L’automate des régions AR = <A∪{τ}, SR= S×R, SR0 =
S0×{ro}, T> où T ( T ⊆ SR×A∪{τ}×SR) est la relation de transition qui contient deux sortes de
transitions :
τ (s, succ(r)) si :
- les transitions d’écoulement du temps (s, r) →
. r n’est pas la région de fin,
. r |= I(s) et succ(r) |= I(s),
a (s’, [λ :=0]r') si :
- les transitions d’actions (s, r) →
. s g,→ a,λ s’ ∈ RT
. r n’est pas une région bornée
. soit r’=r, soit r’=succ(r)
. r’|=g et r’|=I(s) et [λ:=0]r'|=I(s').♦
L’automate des régions permet au temps de s’écouler sans changer d’état de contrôle et sous réserve
de rester dans les contraintes de l’invariant, c’est à dire qu’il existe un successeur qui satisfasse
l’invariant. Les transitions d’actions ne sont pas déclenchables sur les régions bornées afin de modéliser
que, malgré qu’elles soient instantanées, elles ne peuvent s’exécuter indéfiniment sans laisser passer du
temps (contrainte Non Zéno, voir [AL 91]).
- 58 -
L true, app, Ht:=0 A
true 1≤Ht<2
0<Ht≤1, exit, _ 1≤Ht<2, ts, Ht:=0

S
Ht≤1
Figure 64 : Autre automate temporisé du train

Par exemple, à l’automate temporisé du train représenté dans la Figure 64 est associé l’automate des
régions de la Figure 65.
Sur la Figure 65, par exemple, il n’y a pas de transition étiquetée par τ entre les états (A, ]1..2[) et
(A,[2]) car l’état (A, [2]) ne satisfait plus l’invariant de l’état A et aucun des états (A, r) avec r=succi([2])
ne le satisfait. Sur la figure, par exemple il n’y a pas de transition étiquetée par app entre l’état (L, [0]) et
l’état (A, [0]) car la région [0] est une région bornée. Il n’y a pas de transition étiquetée par ts entre l’état
(A, ]0..1[) et l’état (S, [0]) car la région ]0..1[ ne satisfait pas la garde 1<Ht<2. Il y a une transition de
l’état (S, ]0..1[) vers l’état (L, [1]) car [1]=succ(]0..1[), [1] satisfait la garde 0<Ht≤1 et [1] satisfait
l’invariant Ht≤1.
4.4 Automates des zones
4.4.1 Motivations
L'automate des régions peut être optimisé, en pratique, par la construction d’un automate des zones,
une zone étant en première approximation un regroupement de régions contiguës formant un espace
convexe.
La convexité des zones est une propriété nécessaire pour que l’automate des zones simule l’automate
infini. En effet comme le montre la Figure 66a, à partir de n’importe quel point (s, v) d’une zone convexe
z, tous ses successeurs temporels (s′′, v′′) compris entre (s, v) et (s’, v’) qui est le premier point hors de z,
sont dans z. Ce n’est plus vrai si la zone n’est pas convexe. Alors la transition (s, z) → a (s″, z) ne
a (s″, v″) comme on peut le voir sur la Figure 66b.
simulerait pas la transition (s, v) →
4.4.2 Définitions des convexes et opérations

Le langage d’horloge pour définir les zones est celui de la section 2, appelé C(H), étendu par les deux
formules suivantes h-h′∼c et c∼h-h′ qui permettent de définir des zones limitées par des diagonales. Par
exemple dans la Figure 66b, x-y≤1 définit la zone à gauche de la diagonale qui passe par les points (1,0)
et (3,2). Une zone est donc une conjonction de contraintes élémentaires, chacune définissant un convexe.
Une zone est donc une intersection de convexes. Une intersection de convexe est un convexe. C’est pour
avoir cette propriété que C(H) est défini et étendu de la sorte : par exemple la zone z dans la Figure 66a
est définie ainsi : y≥0 ∧ y<1 ∧ x-y≥0 ∧ x-y≤1.
Une zone a les propriétés suivantes :
1. chaque région est une zone,
- 59 -
2. pour une région r et une zone z, soit r ⊆ z soit r ∩ z = φ,

3. l’intersection de 2 zones est une zone,
4. les gardes et les invariants sont des zones (convexes),
étant données deux zones z1 et z2, si z1 ∪ z2 est convexe, alors c’est une zone. Donc l’ensemble des
zones coïncide avec l’ensemble d’unions convexes de régions.
exit exit
L τ L τ L τ L τ L τ L
[0] ]0..1[ [1] ]1..2[ [2] ]2.. [
app
A τ A τ A τ A
[0] ]0..1[ [1] ]1..2[
ts
S τ S τ S
[0] ]0..1[ [1]
Figure 65 : Automate des régions du train Figure 64 pour faire du model-checking

La construction de l’automate des zones utilise les trois opérations suivantes pour lesquelles
l’ensemble des zones est clos sous ces opérations :
- pour 2 zones z1 et z2, l’intersection dénotée z1 ∧ z2 (ou z1 ∩ z2) est une zone (voir exemple Figure
67),
- pour une zone z, soit z⇑ l’ensemble des valuations d’horloge ν+δ pour ν∈z et δ∈R+. Donc z⇑ est
l’ensemble des valuations d’horloges obtenues en laissant le temps s’écouler à partir de n’importe
quelle valuation de z. z⇑ est une zone (convexe). Par exemple Figure 67, la zone z3 est égale à la
zone (z1∧ z2)⇑.
- pour une remise à zéro H de la zone z, soit [H :=0]z l’ensemble des valuations [H :=0]ν pour ν ∈ z
est une zone (convexe). Par exemple z4 Figure 67 est la projection de (z1∧z2)⇑ pour y := 0 :[y :=0](
z1∧z2)⇑.
- 60 -
y
y
z’ (s’, v’)
(s", v")
z’ (s’, v’) z
z (s, v)
(s", v")
(s, v)
x
(a) (b)
Figure 66 : Zone convexe et non convexe
Les états de l’automate des zones sont des couples (s, z) où s est un nom d’état de l’automate
temporisé et z est une zone d’horloge. Etant donné un état (s, z) et une transition e = (s, g, a, H, s′) d'un
AT. On note Succ(z, e) = z' la zone qui peut être atteinte à partir de z par la transition e. z’ est l’ensemble
des valuations v’ telles que pour un v ∈ z, l’état (s′, ν′) peut être atteint à partir de l’état (s, ν) en laissant
le temps s’écouler et en exécutant la transition e. Succ(z, e) est défini ainsi :
y
z2
z3
z1
z4
z1 ∩z2
x
Figure 67 : Opérations sur les zones

Succ (z, e)= [H :=0](((z∧Ι(s))⇑) ∧ Ι(s)∧g).
Succ(z, e) est obtenu ainsi :
- prendre l’intersection de la zone z et de l’invariant de l’état s,
- laisser le temps s’écouler,
- prendre l’intersection avec l’invariant de s,
- 61 -
- prendre l’intersection avec la garde de e,

- projeter la zone obtenue selon les remises à zéro de e.
Proposition : Succ(z, e) est une zone convexe.
Preuve : A chaque étape on obtient une zone convexe car z, I(s) et g sont convexes, z l'est par
définition, I(s) et g le sont à cause des restrictions sur C(H). Les trois opérations (∧, ⇑ et [H]z) préservant
la convexité, Succ(z, e) est convexe. Par exemple dans la Figure 67 avec z= z1 et Ι(s)= z2, z∧Ι(s) est le
carré hachuré, puis (z∧I(s))⇑ est la zone z3 formée de ce carré et de la partie ouverte prolongée par les 2
diagonales. L’intersection avec I(s) donne la zone formée du carré z2 moins les 2 triangles gauche et
droite. La projection sur x par y := 0 donne le segment 1≤x≤3.
4.4.3 Définition de l’automate des zones

Définition 33 – Automate des zones :
def def
A partir d’un AT. AT= <A, H, S, S0, R, I>, on construit un automate des zones Z(A) = <A, S×Z,
s0×z0, T> où
- Z est l’ensemble des zones,
- z0 est la zone initiale où toutes les horloges sont à zéro.
- T est une relation de transition T ⊆ (S×Z)×A×(S×Z) définie ainsi : pour chaque transition e = (s, g,
a (s', Succ(z, e)) appartenant à T.♦
a, H, s') ∈ R et pour chaque zone z, il y a une transition (s, z) →
Exemple 26 – automate temporisé
(issu de l’article d’Alur [A 98] «Timed Automata»).
s2
y=1, b x<1, c
y>0 ∧ x<1, c
x>0, a, y:=0
s0 s1 s3 x>1, d
y<1, a, y:=0
Figure 68 : Automate temporisé A0

A l’AT de la Figure 68 est associé l’automate des régions de la Figure 69 et l’automate des zones de la
Figure 70. L’ensemble des zones de l’automate de la Figure 70 est représenté dans la Figure 71. On
constate, sur cet exemple, que l’automate des zones est de plus petite taille que l’automate des régions.
- 62 -
s0, r0
a a a
b
b
b
s1, r1 s1, r2 s1, r3 s2, r13
c a a a
d d d
d d d
s3, r7 s3, r9 s3, r13 s3, r17
d d
d
Figure 69 : Automate de régions R(A0)
L’automate des zones est formé ainsi :
- son état initial est (s0, z0),
def
- à partir de la transition t0 = s0 x>0,→
a, y:=0 a
s1 et de z0 on obtient la transition (s0, z0) → (s1, z1) car
Succ(z0, t0) = [y:=0] ((z0∧true)⇑∧ true ∧ x>0)
= [y:=0] ((x-y=0) ∧ true ∧ x>0)
= [y:=0] ((x=y) ∧ x>0) = (y=0 ∧ x>0).
def
- A partir de la transition t1 = s1 y=1,
→ bs2 et de z1 on obtient la transition (s1, z1) →
b
(s2, z5).
def
- A partir de la transition t2 = s2 x<1,
→ cs3 et de z5 on n’obtient pas de transition car Succ(z5, t2)=false
car l’intersection de la garde x<1 avec z5⇑ est vide.
def∧ x<1, c
- A partir de la transition t3 = s1 y>0 → c
s3, on obtient la transition (s1, z1) → (s3, z2).
def
- A partir de la transition t4 = s3 y<1,→
a, y:=0 a
s1 on obtient la transition (s3, z2) → (s1, z1) car Succ(z2, t4)
def def
= [y:=0] z2⇑∧y<1 = y=0 ∧ 0<x ∧ x<2 ⊂ z1.
- A partir de la transition t5 def
= s3 x>1,
→ ds3 on obtient la transition (s3, z2) →
d
(s3, z3).
d
- A partir de la transition t5, on obtient la transition (s3, z3) → (s3, z3).
a def
- A partir de la transition t4 on obtient la transition (s3, z3) → (s1, z4) car Succ(z3, t4) = [y:=0]
def
z3⇑∧y<1 = y=0 ∧ 1<x ∧ x<2 ⊂ z4.
b def
- A partir de la transition t1 on obtient la transition (s1, z4) → (s2, z5) car Succ(z4, t1) = z4⇑∧y=1 def
=
y=1 ∧ x-y>1 ⊂ z5.
b
s0, z0 s2, z5 s1 , z4
b
a a
d
c d
s1, z1 a s3-, 63
z2 - s3 , z3
Figure 70 : Automate des zones Z(A0)
z3 z0≡ x=0 ∧ y=0

z1≡ x>0 ∧ y=0
z2≡ x<1 ∧ y>0 ∧ x-y>0
z3≡ x>1 ∧ x-y<1 ∧ x-y>0
approximée en x>1∧ y>0
z5 z4≡ x>1 ∧ y=0
z5≡ y=1 ∧ y-x<0
1
z2
z0 z1 z4
Figure 71 : Ensemble des zones de Z (A0)
4.4.4. Algorithme de construction de l’automate des zones

def
Données AT = <A, H, S, s0, R, I>
def
Résultat Z(AT) = <A, S×Z, s0×z0, T>
Variables
s : état ; z, z’ : zone ;
SZ : ensemble de couples S×Z ; (* états de Z(AT) *)
T : ensemble de triplets (S×Z)×A×(S×Z) ; (* relation de transition de Z(AT) *)
P : ensemble de couples de S×Z ; (* état à partir desquels, il faut calculer les transitions *)
Début
(* z0 tq ∀x.(x∈H ⇒ z0(x)=0) *)
1 SZ := {(s0, z0)};
2 T := φ ;
3 P := SZ ;
tantque P≠φ faire
4 (s, z) := choose(P) ; retirer (s, z) de P ;
pourtoute transition t = s g,→
a, H
s’ ∈ R faire
5 z’ := Succ (z, t) ;
si z’≠zone vide alors
- 64 -
si il existe (s’, z") ∈ SZ tq z’ ⊂ z" alors

a
6 T := T ∪ {(s, z) → (s’, z")}
a
7 sinon T := T ∪ {(s, z) → (s’, z’)}
8 SZ := SZ ∪ {(s’, z’)} ;
9 P := P ∪ {(s’, z’)} ;
finsi
finsi
fait
fait
Fin
Remarque : L’opération Succ élargi la zone obtenue si celle-ci n’est pas exactement une union de
régions. Par exemple la zone z3 dans la Figure 71 n’est pas une union de régions car elle contient des
def def def def
parties des régions r9 = x>1 ∧ y>0 ∧ y<1, r17 = y>1 ∧ x>1 et r13 = y=1 ∧ x>1. La zone z3 = x>1 ∧ x-y>0
def
x-y<1 est élargie en z3 = x>1 ∧ y>0 qui est l’union de r9, r13, et r17.
La conséquence de cette approximation est que l’automate des zones n’est plus post-stable. En
l’absence de cette propriété, l’atteignabilité d’un état n’est plus décidable sur cet automate sans des
vérifications supplémentaires.
Application à l’exemple de la Figure 68 :
1 SZ := {(s0, z0)} ; 2 T := φ ; 3 P := {(s0, z0)} ;
4 s, z := s0, z0 ; P := φ ;
5 z’ := z1 ;
a
7 T := {(s0, z0) ) → (s1 z1)} ; 8 SZ := {(s0, z0), (s1, z1)} ;
9 P := {(s1 z1)} ;
4 s, z := s1 z1 ; P := φ ;
5 z’ := z5 ;
b
7 T := T ∪ {(s1, z1) ) → (s2, z5)} ; 8 SZ := SZ ∪ {(s2, z5)} ;
9 P := {(s2 z5)} ;
5 z’ := z2 ;
c
7 T := T ∪ {(s1, z1) ) → (s3, z2)} ; 8 SZ := SZ ∪ {(s3, z1)} ;
9 P := {(s2 z5), {(s3, z1)} ; etc.
Cet algorithme suppose de représenter la notion de zone et de réaliser les cinq opérations sur les
zones : intersection (z1 ∧ z2), écoulement du temps (z⇑), remise à zéro ([H]z), test d’égalité de zones
(z’=zone vide) et inclusion (z1 ⊆ z2). Les zones sont représentées par des matrices de différences de
bornes (DBM). L’opération d’inclusion se définit à partir de l’intersection et du test d’égalité ainsi : z1 ⊆
def
z2 = (z1 ∩ z2 = z1).
4.4.5 Représentation des zones par des DBM

Une zone peut-être représentée par une matrice [Dil 89]. Pour un AT avec k horloges x1, …, xk, la
représentation d’une zone est une matrice D de dimension k+1. Par exemple, la zone triangulaire z2 de la
Figure 71, y>0 ∧ x<1 ∧ x-y>0 peut être représentée par la matrice D suivante avec x=x1 et y=x2.
0 1 2
0 ∞ ∞ (0, <)
1 (1, <) ∞ ∞
2 ∞ (0, <) ∞
- 65 -
Où :
- Di0 est la borne supérieure de l’horloge xi,
- D0i est la borne inférieure de l’horloge xi,
- Dij est la borne supérieure de la différence xi – xj,
- ∞ dénote l’absence de borne,
- < et ≤ dénotent si la borne est stricte ou non.
def def
Par exemple D21 = (0, <) représente la différence y-x<0 ; D01 = ∞ représente le fait que x n’a pas de
borne inférieure. La représentation d’une zone par une DBM n’est pas unique. Dans notre exemple, il y a
plusieurs contraintes qui sont des conséquences des contraintes données et qui ne sont pas représentées
dans D. Par exemple x>0 est une conséquence de y>0 et x-y>0. Ainsi l’entrée D01 peut être égale à (0, <)
sans changer les valuations d’horloge satisfaisant D. La matrice D’ suivante est équivalente à D :
0 1 2
0 (0, ≤) (0, <) (0, <)
1 (1, <) (0, ≤) (1, <)
2 (1, <) (0, <) (0, ≤)
La borne supérieure de la différence entre x et y, D12 est strictement inférieure à 1 car x<1 et y>0. Des
matrices comme D’ sont canoniques. Le domaine des bornes de D est Z×{<, ≤}∪{∞}. Les matrices
canoniques sont obtenues en observant que la somme des bornes supérieures sur les différences
d’horloges xi-xj et xj-xl est la borne supérieure de xi-x1.
L’addition est définie ainsi : (i, j)+(i’, j’) = (i+i’, j∧j’) où < est représenté par 0 et ≤ par 1.
La comparaison est définie ainsi : (i, j)<∞ et (i, j)<(i’, j’) ssi i<i’ ou i=i’ et j<j’.
Une DBM est satisfiable si elle représente une zone non vide. Elle est non satisfiable si et seulement
s’il existe une séquence 0≤i1, i2, …, ij≤k d’indices tels que Di1i2+Di2i3+ … + Diji1<(0, ≤).
La DBM D est canonique ssi pour tous les indices 0≤i, j, l≤k, Dil≤Dij+Djl. Chaque DBM satisfiable a
une DBM équivalente canonique.
Réalisation des opérations : Soit 2 DBM canoniques D et D’ :
- Egalité : D et D’ sont équivalentes si Dij=D’ij pour tout i et j compris entre 0 et k,
- Intersection, D"=D∩D’ telle que D"ij=min(Dij, D’ij). D" n’est pas en forme canonique. Il est donc
nécessaire de vérifier si elle est satisfiable et dans ce cas la remettre en forme canonique.
- Ecoulement du temps : D⇑ telle que Di0⇑=∞ pour 1≤i≤k, Dij⇑=Dij pour 1≤j≤k et 0≤i≤k. Puis D⇑
doit être mise en forme canonique. Les bornes supérieures de chaque horloge (Di0) sont affectées à
l’infini pour laisser le temps s’écouler.
- Projection : [H :=0]D telle que : Di0 = D0i = (0, ≤) pour tout xi ∈ H, Dij = (0, ≤) pour tout couple xi,
xj ∈ H×H, Dij = D0j et Dji = Dj0 pour tout couple xi ∈ H et xj ∉ H. La matrice résultat doit être mise
sous forme canonique.
Théoriquement, le nombre de zones est exponentiel sur le nombre de régions. Cependant, en pratique,
l’automate des zones a moins de sommets atteignables et ainsi améliore les performances des algorithmes
d’exploration pour résoudre les problèmes d’atteignabilité. En pratique, on constate que le nombre de
zones atteignables est peu sensible aux valeurs des plus grandes constantes alors que le nombre de régions
croît avec ces valeurs de constantes.
4.5 Model-Checking MITL
- 66 -
La MITL (Metric Interval Temporal Logic) est une logique temporelle temporisée linéaire (extension
temporisée de la PLTL). Les formules de cette logique définissent des ensembles de comportements
temporisés qui sont des ω-langages réguliers temporisés. Ceux-ci sont reconnus par des automates de
Büchi temporisés. Cette modélisation permet de définir un algorithme de vérification de propriétés MITL
basé sur le produit d’automates temporisés similaire à celui de vérification de propriétés PLTL basé sur le
produit d’automates tel qu’il est défini dans la section 6 du chapitre 3.
Dans la section 4.4.1 nous présentons tout d’abord la syntaxe et la sémantique de la logique
temporisée MITL. Dans la section 4.4.2, nous définissons la notion d’automate de Bűchi temporisé. Dans
la section 4.4.3, nous définissons le produit synchronisé d’automates temporisés utilisé pour effectuer le
model checking MITL. Ensuite, dans la section 4.4.4, nous définissons l’automate des régions associé à
un automate temporisé produit pour effectuer la recherche de cycle de l’algorithme de model checking
MITL. Enfin dans la section 4.4.5 nous présentons l’algorithme de model checking MITL illustré par des
exemples dans les sections 4.4.6 et 4.4.7.
4.5.1 Syntaxe et sémantique de la MITL

Les formules de la MITL sont construites à partir des propositions atomiques de APv sur un ensemble
de variables d’états V. L’opérateur Until est indicé par un intervalle qui est de l’une des formes
suivantes :
[a, b], [a, b[, [a,∞[, ]a, b[, ]a, ∞[ où a≤b pour a, b ∈ ℝ+ (ens. des réels positifs).
Ces intervalles ne doivent pas être singuliers (réduit à un seul point), c'est-à-dire de la forme [a, a],
afin que la vérification soit décidable.
Définition 34 - formules MITL ::
Les formules de la MITL sont définies inductivement par la grammaire suivante :
φ::= pa | ¬φ | φ ∨ φ | φ UI φ où pa ∈ APv et I est un intervalle non singulier.♦
Les formules de la MITL sont interprétées sur des séquences d'états temporisés τ=(σ, σi) où σ est une
séquence d'états σ=s0 s1 s2….. et σi est une séquence d'intervalles σi=I0 I1 I2 …… telle que :
- I0 est fermé à gauche sur 0, I0= [0.. ? (initialisation),
- pour tout i, les intervalles Ii et Ii+1 sont adjacents (adjacence),
- tout instant t ∈ ℝ+ appartient à un intervalle Ii (progression du temps).
τ= (σ, σi) est souvent noté (s0, I0) → (s1, I1) → (s2, I2) →…→(si, Ii)… On note τt le suffixe de la
séquence d'états temporisés τ à l'instant t. Soit t ∈ Ii, τt = (si si+1 si+2,…, Ii-t Ii+1-t Ii+2-t …). Par exemple, τ =
(s0, [0, 0.5]) → (s0, ]0.5, 1.5[) → (s0, [1.5, ∞[) est une séquence d’états temporisés finie.
Définition 35 - satisfaction d’une formule MITL ::
La relation de satisfaction τ= (σ, σi) satisfait φ, notée τ ⊧ φ est définie inductivement ainsi :
- τ ⊧ pa ssi pa ∈ λ(s0)
- τ ⊧ ¬φ ssi τ ⊭ φ
- τ ⊧ φ1 ∨ φ2 ssi τ ⊧ φ1 ou τ ⊧ φ2
- τ ⊧ φ1 UI φ2 ssi ∃t. (t ∈ I ∧ τt ⊧ φ2 ∧ ∀ t'.( t' ∈ ]0, t[ ⇒ τt' ⊧ φ1).♦
La définition de τ ⊧ φ1 UI φ2 signifie qu'il existe un instant t dans l'intervalle I qui satisfait φ2 et que à
tout instant t' précédent, φ1 est satisfaite.
Les opérateurs unaires ◊I– et I– peuvent se redéfinir aussi à partir de l'opérateur UI:
- ◊I φ ≡ true UI φ
- I φ ≡ ¬ ◊I ¬φ.
- 67 -
L'opérateur Next n'existe pas en MITL.

Exemple 27 - propriété en MITL :
M1 def
= [0, ∝[ (Et=avant ⇒ ◊[1, 10] (Et=loin)).
Qui signifie qu'à tout moment si un train atteint l'état avant alors il aura atteint l'état loin en au moins
une unité de temps et au plus dix unités de temps.
On notera O≤C pour O[0, C] avec O ∈ [◊, , UI]. On notera O pour O[0, ∝[.
4.5.2 Automates de Büchi temporisés (ABT)

Un automate de Büchi temporisé est un automate temporisé muni d'un critère d'acceptation modélisé
par un sous-ensemble d'états appelés ensemble d'acceptation.
Définition 36 - Automate de Büchi Temporisé (ABT) :
Un ABT est un couple (AT, F) avec AT=<A, H, S, S0, R>, F ⊆ S et A=SPV.♦
Définition 37 - exécution d’un ABT :
Une exécution τ=(σ, σi) d'un ABT sur un mot temporisé est acceptante ssi (Inf(σ) ∩ F)≠φ. Autrement
dit une exécution d'un ABT doit contenir une infinité d'états d'acceptation.♦
Exemple 28 – Automate de Büchi temporisé
L'automate représenté dans la Figure 72 est un ABT qui reconnaît les comportements qui violent la
propriété M1 def
= (Et=avant ⇒ ◊[1, 10] (Et=loin)).
u1=(true, Et≠avant, {}) u3=(x≤10, Et≠loin, {}) u5=(true, true, {})
u2=(true, Et=avant, {x}) u4=(x>10, true, {})

b0 b1 b2
Figure 72 : ABT de la propriété ¬M1.

La négation de M1 est la propriété suivante :
¬M1def
= ◊[0, ∝[ (Et=avant ∧ [0, 10] (Et≠loin)).
Les comportements qui vérifient ¬M1 sont reconnus par l'ABT de la Figure 72 qui est défini ainsi :
- A = {Et≠avant, Et≠loin, Et=avant, true}, l'alphabet d'étiquetage des transitions est l'ensemble des
propositions d'états sur V appartenant à SPv qui définit les conditions booléennes sur lesquelles
portent les opérateurs temporels de la MITL,
- H ={x}; l'ensemble des horloges est formé d'un chronomètre x qui est déclenché quand la condition
Et=avant se produit et permet de vérifier que pendant 10 unités de temps, la condition Et≠loin est
satisfaite,
def
- S = {b0, b1, b2},
def
- S0 = { b0},
def ≠ avant, {}
- R = {b0 true, Et → b0, ...} ; R ⊆ S × C(H) × SPV × 2H × S,
def
- F = {b2}.
Cet automate spécifie que pour reconnaître la propriété ¬M2 il faut que la condition Et=avant se
produise et que pendant les 10 unités de temps suivantes Et soit différent de loin.
Cet automate de Büchi est déterministe. On notera que la classe des langages ω-réguliers temporisés
n'est pas close pour la négation, c'est-à-dire que le langage complémentaire de celui qui est reconnu par
un ABT non déterministe n'est pas forcément ω-régulier. Par exemple le complémentaire de l'automate de
- 68 -
la Figure 73 nécessite un nombre infini d'horloges, ce n'est donc pas un ABT. Le langage n'est donc pas
ω-régulier.
(true, a, {}) (true, a, {}) (true, a, {})
(true, a, {x}) (x=1, a, {})

b0 b1 b2
Figure 73 : Exemple de langage dont le complémentaire n’est pas ω-régulier

L'automate de la Figure 73 [AD95] vérifie qu'un des événements a est suivi d'un événement a
exactement une unité de temps après. Le complémentaire consisterait à vérifier qu'aucun événement a est
suivi d'un événement a exactement une unité de temps après. Pour vérifier ceci, il faut associer un
chronomètre à chaque occurrence d’événement a et comme il peut y en avoir une infinité dans l'intervalle
[0..1], il faudrait une infinité de chronomètres. Ce n'est donc pas un langage ω-régulier.
Par contre le complémentaire du langage reconnu par un ABT déterministe est un ABT.
4.5.3 Produit synchronisé d'une SKT et d'un ABT

Celui-ci est défini de manière tout à fait similaire au cas non temporisé présenté section 6 du chapitre
2.
La structure de Kripke temporisée étiquetée par des noms d'actions est transformée par la Définition
def
16 en automate étiqueté par des ensembles de propositions atomiques. A la SKT = <A, H, S, S0, R, λ> est
def APv
associé A(SKT) = <2 , H, Q, Q0, T, QA> avec :
def
- Q = S ∪ {i}, ensemble d'états,
def
- Q0 = {i}, ens. d'états initiaux,
- T ⊆ Q × 2APv × Q, relation de transition,
def
T = {(i, λ(s0), s0) | s0 ∈ S0} ∪ {(s, λ(s'), s') | (s, a, s') ∈ R}
def
- QA = Q.
Par exemple, à l'automate du train de la Figure 64 est associé l'automate de la Figure 74.
Le produit synchronisé est défini comme dans la Définition 17 section 5.2 chapitre 2.
Définition 38 - produit synchronisé de deux AT :
Soit ABT¬φ un automate de Büchi temporisé <SPV, X, S, S0, R, F> reconnaissant une propriété MITL
¬φ. Soit KT une structure de Kripke temporisée modélisant un système S sur l'ensemble de variables V.
Soit A(KT) l'automate <2APv, H, Q, Q0, T, Q> obtenu par transformation de KT. Le produit synchronisé
qui reconnaît le langage LS ∩ L¬φ est défini ainsi :
def
P = A(KT)  ABT¬φ \ {AP, p) | AP ∈ 2APv et p ∈ SPV et AP ⊧ p}. L'automate temporisé P = <2APv,
X ∪ H, S × Q, S0 × Q0, RT, FA> avec :
def
- RT = { (s, q) g1 ∧ g2, (AP→
⊧ p), λ ∪ λ (s’, q’) | AP ⊧ p et
1 2
g , p, λ
s 1→ 1 s' ∈ R et
AP, λ
q g2, → 2 q' ∈ T
def
FA = {(s, q) | s ∈ F et q ∈ Q}.♦
- 69 -
t1=(true, {Et=loin}, {}) t2=(true, {Et=avant}, {Ht})

i 1 2
t4=(1< Ht≤2, {Et=loin}, {})

t3=(1 ≤ Ht≤5, {Et=sur}, {Ht})
Figure 74 : AT étiqueté par des ensembles de propositions

Par exemple, le produit de l'automate de la Figure 74 avec celui de la Figure 73 est représenté dans la
Figure 75.
4.5.4 Automates des régions pour le model-checking MITL

Pour effectuer la vérification d'une propriété φ, le model checking consiste à vérifier que l'automate
des régions du produit synchronisé de A(KT) avec ABT¬φ ne contient pas de cycle d'acceptation.
L'automate des régions est construit comme pour l'analyse d'accessibilité (voir section 4.2).
La définition suivante est équivalente à la définition section 4.2.
Définition 39 - automate des régions associé à un AT ::
def
Soit R l'ensemble des régions pour un ensemble d'horloges H. Soit r0 la région initiale. Soit AT = <A,
H, S, S0, T, F> un automate temporisé muni d'une condition d'acceptation F. L'automate des régions
def
associé est AR = <A, S×R, S0×{r0}, TR, FR> défini ainsi :
- (s, r) →a (s', r') ∈ TR ssi
a, λ
∃ (v, v', t).(v ∈ r ∧ v’ ∈ r' ∧ t ∈ ℝ+ ∧ s g,→ s' ∈ T ∧ v+t ⊧ g ∧ v'= [λ:=0](v+t)
- (s, r) ∈ FR ssi s ∈ F.♦
- 70 -
t 1||u1 =(true,
i, b 0 {Et=loin}|=Et≠ 1, b 0 2, b 0 3, b 0
avant, {})
t4||u3
t1||u2 =(true, {Et=avant}|=
Et=avant, {Ht, x}) t 3||u3 =(x≤10
∧2<Ht<5,
[Et=sur}|=tru
e, {Ht})
i, b 1 1, b 1 2, b 1 3, b 1
t 4||u4 =(x>10 ∧ 2<Ht<5

{Et=sur}|=true, {Ht})
t 2||u5 =(true, t3||u5 =(true,

{Et=avant}|= {Et=sur}|=
i, b 2 1, b2 true, {Ht}) 2, b2 true, {Ht}) 3, b2
t 4||u5 =(true ∧ 1<Ht<2, {Et=loin}|=true, {})
t 4||u4 =(x>10 ∧ 1<Ht<2, {Et=sur}|=true, {Ht})
Figure 75 : Produit synchronisé des automates des Figure 73 et Figure 74.

Pour vérifier si un système S spécifié par une structure de Kripke temporisée KT vérifie une propriété
MITL φ, il faut procéder ainsi :
- Calculer l'ABT de ¬φ , ABT¬φ
- Calculer A(KT) pour l'étiqueter par des ensembles de propositions
- Calculer le produit synchronisé P= A(KT)ABT¬φ \ {AP, p) |AP ⊧ p},
- Construire l'automate des régions AR(P) selon la Définition 29 section 4.2
- Détecter les cycles contenant au moins un état d'acceptation de FA et vérifiant la condition de
progressiveness,
- Conclure que si un tel état existe, il représente un comportement qui viole φ.
Remarques sur la Figure 75 :
- La transition t3||u4 ne sera pas activable car x>10 ∧ 2<Ht<5 dans un contexte x=Ht n'est satisfiable;
- Idem pour la transition t4||u4 avec x>10 ∧ 1<Ht<2 dans un contexte x<5, Ht=0. Donc le cycle
d’acceptation ne sera pas atteignable. La propriété M1 est satisfaite.
4.5.5 Algorithme de model checking MITL

Par contre si la condition de la propriété avait été x≤6, alors la propriété serait violée par le système de
la Figure 74. Ceci peut se voir sur la Figure 75 où le cycle (1, b2) → (2, b2) → (3, b2) → (1, b2) serait
accessible car la transition t4||u4 serait déclenchable : sa garde serait x>6 ∧ 1<Ht<2 et serait satisfaite
dans le contexte x<5, Ht=0. Dans l'intervalle x>6 et x<7, la propriété serait violée.
- 71 -
i, b 0, r 0
t1 ||u 1
1, b 0, r 6 1, b 0, r 12 1, b 0, r 17
t1 ||u 2
2, b 1, r 0
t3 ||u 3
3, b 2, r 14
t4 ||u 4
t2 ||u 5 t3 ||u 5
1, b 2, r 14 2, b 2, r 14 3, b 2, r 14
1, b 2, r 15
t2 ||u 5
1, b 2, r 16
1, b 2, r 17
t4 ||u 5
Figure 76 : Automate des régions associé à l’AT de la

Figure 75.
Définition 40 - cycle progressif : :
Un cycle d'un automate des régions vérifie la condition de progressiveness s’il existe un état q du
cycle tel que :
- soit toutes les horloges sont remises à zéro,
- soit toutes les horloges x vérifient x>Cx.♦
4.5.6 Exemple de propriété non satisfaite

L'automate de la Figure 75 a un trop grand nombre de régions pour être faisable car Cx=10 et CHt=5.
On construit un exemple avec Cx=1 et CHt=2 (28 régions, voir Figure 77) en vérifiant que le train (Figure
74 avec la contrainte 0<Ht<1 sur les 2 transitions t3 et t4 ) ne satisfait pas la propriété φ1def
= (Et=avant ⇒
◊[1,10](Et=loin)) (Figure 72 avec les contraintes x≤1 et x>1 à la place de x≤10 et x>10).
- 72 -
r24 r25 r26 r27
2 r20 r21 r22 r23
r15
r14 r18 r19

r16
r17
1 r10 r11 r12 r13
r5
r4 r6 r8 r9
r7
Ht
r0 r1 r2 r3
0 1
Figure 77 : Régions pour Cx=2 et CHt=1.
L'automate des régions obtenu à partir de la
Figure 75 modifiée par les changements de contraintes d'horloges énoncés ci-dessus est représenté
dans la Figure 76. Cet automate contient le cycle d'acceptation suivant :
(2, b2, r14) →(3, b2, r14) →(1, b2, r17) →(2, b2, r14)
qui vérifie la condition de progressiveness puisqu'il contient un état dont la région est r17 (Cx>1 et
CHt>1). La propriété φ1 est donc violée par ce cycle. Par contre, les autres cycles d’acceptation ne
satisfont pas la condition de progressiveness.
4.5.7 Exemple de propriété satisfaite

les mêmes contraintes d'horloges que dans la section 4.4.6, la propriété φ2 def
= (Et=avant ⇒ ◊[0, 2]
(Et=Loin)) (Voir Figure 72 avec les contraintes x≤2 et x>2) est satisfaite. On peut le constater sur la
Figure 78 construite à partir de l'ensemble des 28 régions représentées dans la
Figure 77 avec CHt=1 et Cx=2.
L’état (3, b1, r4) n’a pas de successeur car sur la
- 73 -
Figure 77 on voit que dans la chaîne des successeurs de r4 (r4 → r5 → r11 → r17 → r18 → r19 → r23 →
r27), aucune de ces régions ne satisfait la contrainte x>2 ∧ 0<Ht<1. L’automate de la Figure 78 ne contient
pas de cycle, donc la propriété φ2 est satisfaite.
i, b 0, r 0
t1 ||u 1
1, b 0, r 6 1, b 0, r 12 1, b 0, r 19 1, b 0, r 23 1, b 0, r 27
t1 ||u 2
2, b 1, r 0
t3 ||u 3
x>2 ∧ 0<Ht<1
3, b 1, r 4 Stop
non satisfiable
:
Figure 78 : Automates des régions de l’AT de la
Figure 75 avec x>2 ∧ 0<Ht<1.
5. Résumé, Conclusion et Perspectives

- Les AT permettent de modéliser des informations quantitatives sur l’écoulement du temps dans les
automates.
- Ils permettent donc de définir des modèles permettant de vérifier des contraintes temporisées,
appelées également contraintes temps réelles.
- Un AT se compose d’un automate fini classique et d’un ensemble de chronomètres.
- Un AT est une représentation finie d’un automate classique qui aurait un nombre infini d’états.
- La représentation finie des AT permet leur analyse algorithmique (exemple : Model checking de
propriétés de logique temporelle temporisée).
- Une exécution est composée de deux sortes de transitions, d’une part des transitions implicites
d’écoulement du temps qui incrémentent tous les chronomètres d’une durée d (respectant les
invariants d’états) et d’autre part des transitions explicites de changement d’état de contrôle qui
remettent éventuellement certains chronomètres à zéro.
Le temps est modélisé par des nombres réels.
Les transitions de changement d’état de contrôle ne prennent pas de temps.
Des invariants associés aux états spécifient la nécessité d’activer les transitions.
- Chaque composant d’un système peut être décrit par un AT. Le système est alors décrit par un
réseau d’AT dont la sémantique est un produit synchronisé.
- 74 -
Références
[ACD 93] R. Alur, C. Courcoubetis, D. Dill, «Model checking in Dense Real-time», Information
and computation, 104 (1) : 2-34, 1993.
[ACH 92] R. Alur, C. Courcoubetis, N. Halbwachs, D. Dill, "Minimization of timed transitions
systems", Third Conference on Concurrency Theory, LNCS 630, P. 340-354, 1992.
[AD 94] R. Alur et D. Dill, «Model-Checking in Dense Real-time», Information and Computation,
104(1) : 2-34, 1993.
[AD 95] R. Alur, D. Dill, “Automata- Theoretic Verification of Real-Time Systems”, In Formal Methods
For Real Time Computing, Trends in Software Series, John Wiley & Sons Publishers, pp. 55-
82, 1995.
[A 98] R. Alur , «Timed Automata», NATO ASI summer school on Verification of Digital and Hybrid
Systems, 1998.
[AL 91] M. Abadi, L. Lamport, "An old-fashion recipe for real time", In Real Time : Theory in Practice,
LNCS 600, p. 1-27, 1991.
[Bel 98] P. Bellot, J. Sakarovitch, «Logique et automates», Ellipses, 1998.
[Dil 89] D. L. Dill, “Timing assumptions and verification of finite-state concurrent systems”, LNCS n°
407, p. 197-212. Automatic Verification Methods for Finite State Systems, 1989.
[Per 95] D. Perrin, «Les débuts de la théorie des automates», TSI, vol 14, n°4, p. 409-433, 1995.
[CGP 01]E.M. Clarke, O. Grumberg et D.A. Peled, «Model Checking», MIT Press, Cambridge,
Massachusetts, 2001.
[Sch 99] P. Schnoebelen, «Vérification de logiciels ; Techniques et outils du model-checking», Vuibert,
1999.
[Séé 99] P. Seebold, «Théorie des automates - Méthodes et exercices corrigés», Vuibert, 1999.
[Tho 90] W. Thomas, «Automata on infinite words», Handbook of theoretical computer science, vol B,
Elsevier, MIT Press, 1990.
[Var 86] M.-Y. Vardi, «An automata theoretic approach to Linear Temporal Logic».
[HTCS 90] «Formal models and semantics», Vol. B, edited by Jan Van Leeuwen, Elsevier; MIT
Press, 1990.
Index
automate, 8 automate
compteur modulo n, 14 digicode, 24
dispositif d’arrivée, 15 automate
étiqueté, 8 produit synchronisé, 32
évacuateur, 15 automate
exécution complète, 8 produit synchronisé, 34
exécution finie, 7 automate
exécution infinie, 7 avec variables, 35
exemple, 4, 5, 14 automate
trace, 8 abstraction, 39
automate automate
exemple, 13 communicant, 43
automate automate avec variables
digicode, 24 dépliage, 38
- 75 -
exemple, 35, 36, 37 jeu 5 quilles, 10

automate communicant logique temporelle
exemple, 44 exemple, 25, 29
file, 46 linéaire, 23, 25
rendez-vous, 46 sémantique, 25
variable partagée, 47 MITL, 71
automate de Büchi, 20, 23, 26 model-checking, 75
automate de Büchi MITL
exemple, 27 syntaxe, 71
exemple, 27 sémantique, 72
exemple, 27 propriété, 72
automate de Büchi Model-checking MITL, 76
exemple, 29 montre, 5, 6
automate de Büchi PLTL, 23, 25
exemple, 29 produit asynchrone d’automates, 21
automate de Büchi produit d’automates, 14
produit synchronisé, 30 asynchrone, 21
automate de Büchi exemple, 16
exemple, 30 libre, 15, 17
automate de Büchi synchrone, 19
produit synchronisé, 31 synchronisé, 18
automate de Büchi produit libre d’automates, 17
outil, 31 compteurs, 16
Automate de Büchi Temporisé, 72 produit synchrone d’automates, 19
Automate de Büchi Temporisé robot, 20
exemple, 73 produit synchronisé, 32
Automate de Büchi Temporisé Produit synchronisé, 73, 74
exemple, 73 produit synchronisé d’automates, 18
Automate des régions, 75 compteurs, 17
automate temporisé, 49 horloge, 19
Automate Temporisé progressivness, 76
produit synchronisé, 76 robot, 4, 6
Automates des zones, 63 structure de Kripke
Büchi digicode, 7
automate temporisé, 72 étiquetée, 7
condition d’acceptation, 8 robot, 7
cycle progressif, 76 structure de Kripke, 7
digicode, 5, 6 exemple, 4
exécution complète, 8 structure de Kripke
exécution finie, 7 digicode, 24
exécution infinie, 7 système de transition
exemple étiqueté, 6
jeu 5 quilles, 10 système de transition, 6
exemple système de transition
digicode, 5, 6 exemple, 6
montre, 5, 6 système de transition
robot, 4, 6 exemple, 6
exemple trace, 8
comptage minute, 14 transformation SKE en automate, 32
exemple Zone
comptage heure, 14 opérations, 66
exemple Zone convexe, 65
compteur modulo n, 14
- 76 -

Cours Automate

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Automate

Transféré par

Droits d'auteur :

Formats disponibles

Université de Franche-Comté

UFR des sciences et techniques

cours de Master Recherche Informatique

TABLE DES FIGURES 2

TABLES DES DEFINITIONS 5

INTRODUCTION AUX AUTOMATES 1

AUTOMATES DE BÜCHI ET PROPRIETES PLTL 19

AUTOMATES AVEC VARIABLES DE DONNEES ET ABSTRACTION 31

Table des figures

Théorème 1 – Préservation des propriétés de sûreté : ................................................................................................36

Exemple 1 – Systèmes de Transition Etiquetés :..........................................................................................................3

1. Qu'est-ce qu'un automate ?

Figure 1 : automate modélisant un robot de transport de pièces.

Figure 2 automate modélisant un digicode

... 3:58 3:59 4:00 ...

2. Définitions d'un automate, d’un système de transition et d’une structure de Kripke

2 Digicode Soit E = {A, B, C}

3. Exécutions d'un automate

Exemple 4 – exécution finie :

Exemple 5 – exécution infinie :

L'ensemble des exécutions complètes est représentable sous forme d'arbre

4. A quoi servent les automates ?

1. Est-ce que le Robot peut se bloquer ?

La réponse est non : liste des états cibles : s1 s2 s0 s3

D s telle que le décor de s (λ(s )) contient la

4,B 3-1,B 2-2,B 3,B 2-1,B

3,A 2-1,A 2,A 1-1,A 1-1-1,A

Figure 5 : automate modélisant le jeu de Nim à 5 quilles

Figure 6 : chemin d'exécution gagnant pour le joueur A du leu de Nim à 5 quilles

- 5,A 4,B permet à B de faire le choix

4,B 1-1,A et A perd

- 5,A 3-1,B idem

- 5,A 3,B idem

- 5,A 2-1,B idem

4.2. Idée 2 : traiter des problèmes sur des ensembles infinis

5. Résumé, Conclusion et Perpectives

Nous présentons la théorie des automates pour résoudre des problèmes :

Figure 7 : Réseau de Pétri modélisant l'exclusion mutuelle

- l'état initial est le produit des états du Réseau de Pétri marqué,

Figure 9 : automate modélisant le réseau de Pétri de la Figure 7

1. Pourquoi des produits d'automates ?

Figure 10 : Automate Minute

Figure 11 : Automate Heure

Figure 12 : Automate compteur modulo n

2. Produit libre (ou cartésien)

2.1. Exemples introductifs

Figure 13 : Automate de l'évacuateur

Figure 14 : Automate du dispositif d'arrivée

Figure 15 : Produit libre de l'évacuateur et du dispositif d'arrivée

Figure 16 Produit libre de deux compteurs modulo 3(Minute) et 2(Heure)

Figure 17 : Horloge avec heures modulo 2 et minutes modulo 3

* soit s1 →v s' ∈ R et s' =s

(s1, s ), (s , s ) →( Chargt , Evac) (s , s )}

3.1. Exemple introductif

Le modèle d'horloge est l'automate Heure||Minute\{m, (h, h )}.

Figure 19 : Produit synchrone de l'évacuateur et du dispositif d'arrivée

Figure 20 : Automate de Büchi A¬P

- Le produit synchronisé modélise la composition parallèle de sous-systèmes qui se coordonnent (se

________ (E vac, D e=o ccupé)

Figure 21 : Produit synchrone de l'Evacuateur et de AP

Figure 22 : Produit asynchrone de l'évacuateur et du dispositif de transport

AUTOMATES DE BÜCHI ET PROPRIETES PLTL

2. La Logique Temporelle Linéaire Propositionnelle (PLTL)

Figure 23: Le digicode décoré par des propositions atomiques