Académique Documents
Professionnel Documents
Culture Documents
Notions de base
Notes de cours, IR1, 2009
Sylvain Lombardy
L’automate ci-dessus est l’automate A = hQ, A, E, I, T i, avec Q = {p, q, r, s}, A = {a, c, g, t},
E = {(p, a, p), (p, c, p), (p, g, p), (p, t, p), (p, g, q), (q, t, r), (r, a, s), (s, a, s), (s, c, s), (s, g, s), (s, t, s)},
I = {p, q} et T = {s}. On remarque que si plusieurs transitions ont les mêmes états de départ et
d’arrivée, on ne dessine qu’une flèche en indiquant les différents étiquettes.
1
Chemins et langage acceptés Un chemin dans l’automate est une suite de transitions consé-
cutives, c’est-à-dire une suite (p1 , a1 , q1 ), (p2 , a2 , q2 ), ..., (pn , an , qn ) telle que qi = pi+1 . L’état de
départ du chemin est l’état de départ de la première transition, l’état d’arrivée du chemin est celui
de la dernière transition. L’étiquette d’un chemin est le mot a1 a2 ...an obtenu en concaténant les
étiquettes des transitions du chemin.
Un chemin est réussi s’il commence dans un état initial et s’il arrive dans un état terminal. Un
tel chemin est parfois appelé calcul.
Un mot est accepté par l’automate s’il existe un chemin réussi dont il est l’étiquette. Le langage
reconnu par l’automate est l’ensemble des mots acceptés par l’automate.
Deux automates sont équivalents s’ils reconnaissent le même langage.
Exemple : Le mot cgtag est accepté par l’automate ci-dessus car il est l’étiquette du chemin
réussi suivant :
c g t a g
→ p −→ p −→ q −→ r −→ s −→ s →
Si on regarde attentivement l’automate, on constate que tous les chemins réussis partent des états
p ou q et arrivent en s. Les chemins réussis partant de p sont exactement ceux qui sont étiquetés
par un mot qui contient gta (on dit que gta est un facteur du mot) ; ceux qui partent de q sont
étiquetés par des mots qui commencent par ta (on dit que ta est un préfixe du mot). Le langage
reconnu par cet automate est donc l’ensemble des mots sur {a, c, g, t} qui soit contiennent le facteur
gta, soit commencent par le préfixe ta.
Décider si un mot est accepté par un automate L’algorithme qui permet de décider ceci
consiste à lire le mot lettre par lettre et à calculer tous les états que l’on peut atteindre à partir
d’un état initial en ayant lu ces lettres.
Formellement, soit w = w1 w2 ...wk un mot (wi est la i-ème lettre du mot) et A = hQ, A, E, I, T i
un automate. On veut décider si w est accepté par A. Xi est l’ensemble des états que l’on peut
atteindre en ayant lu w1 w2 ...wi .
Calcul de Xk :
– X0 = I ;
– pour i de 1 à k
Xi = ∅
pour tout p dans Xi−1
pour tout q tel que (p, wi , q) est dans E
Xi = Xi ∪ {q}
Le mot w est accepté si et seulement si Xk ∩ T 6= ∅ :
– pour tout p dans Xk
si p est dans T
retourne VRAI (w est accepté)
retourne FAUX
La complexité de cet algorithme est O(kn2 ), où k est la longueur du mot et n est le nombre
d’états de l’automate. En effet, Xi peut contenir n états et il peut y avoir n transitions partant
de p étiquetées par wi .
États utiles, automates émondé Un état p d’un automate A est utile s’il existe un chemin
réussi passant par p. Si un état n’est pas utile, on peut le supprimer sans modifier le langage
reconnu.
Un automate est émondé si tous ses états sont utiles. On peut émonder un automate en
supprimant tous ses états inutiles.
3 Automates déterministes
Un automate est déterministe s’il n’a qu’un seul état initial et si, pour tout état p, toute lettre a,
il y a au plus une transition partant de p étiquetée par a.
2
Exemple : L’automate présenté précédemment n’est pas déterministe pour deux raisons :
d’une part il possède deux états initiaux p et q et d’autre part, il y a deux transition étiquetées
par g qui partent de p, l’une restant en p, l’autre arrivant en q. Cet automate est équivalent à
l’automate déterministe ci-dessous :
a, c, t
c, t a, c, g, t
j g a
t l m
a, c k g
g
Dans un automate déterministe, si on veut lire un mot donné, à aucun moment on n’a de choix
à faire. On doit commencer dans l’unique état initial, et lorsqu’on lit une lettre, il n’y a qu’une
seule transition que l’on peut emprunter.
Automate complet et fonction de transition Un automate déterministe est complet si, pour
tout état p, toute lettre a, il y a exactement une transition partant de p étiquetée par a.
Exemple : L’automate déterministe suivant, sur l’alphabet {a, b} n’est pas complet :
a a
p b q
En effet, l’état q ne comporte pas de transition sortante étiquetée par b. En ajoutant un état
inutile (puits), on peut toujours rendre un automate déterministe complet :
a a a, b
p b q b
puits
Décider si un mot est accepté par un automate Cet algorithme, comme le précédent
consiste à lire le mot à accepter lettre par lettre. Soit w = w1 w2 ...wk un mot et A = (Q, A, δ, i, T ).
On veut décider si w est accepté par A.
– p0 = i
– pour i de 1 à k
pi = δ(pi−1 , wi )
– si pk est terminal alors retourner VRAI sinon retourner FAUX
Cet algorithme est linéaire dans la longueur k du mot : O(k). On le voit, il est beaucoup plus
rapide de décider si un mot est accepté par un automate si celui-ci est déterministe.
3
Formellement, l’état initial de D est (correspond à) l’ensemble I. Si X est un état initial, pour
chaque lettre a, il y a une transition de X à Y étiquetée par a, où Y = {q | ∃p ∈ X, (p, a, q) ∈ E}.
L’état X est terminal si X ∩ T 6= ∅.
En pratique, on construit le déterminisé de façon incrémentale. Au départ, il n’y a que l’état
initial et on ajoute les états au fur et à mesure qu’on en a besoin.
Exemple : Le déterminisé du premier automate est :
a, c, t a, c, t
c, t a, c, t
p g a p, s g
t p, r t p, r, s
a, c p, q g a, c p, q, s g
g
4 Automates avec ε-transitions
Il est parfois commode d’autoriser dans les automates des transitions particulières appelées
ε-transitions. Ces transitions n’ont pas d’étiquette, ou, pour être plus exact, leur étiquette est
le mot vide. Ainsi, l’étiquette d’un chemin comportant des ǫ-transition est le mot formé par les
lettres qui étiquettent les transitions du chemin qui ne sont pas des ε-transitions.
Exemple :
a b
p q ε r s
a b
Le chemin réussi
a ε b b
→ p −→ q −→ r −→ s −→ r →
est étiqueté par le mot abb. Cet automate reconnaı̂t les mots formés d’un bloc de a de longueur
impaire puis d’un bloc de b de longueur paire.
p ε q ε r
4
On obtient l’automate non déterministe suivant :
a b a
p b q a r
a
Attention, pour appliquer la plupart des algorithmes (déterminisation, intersection,. . . ) il faut
d’abord supprimer les ε-transitions s’il y en a.
L’automate ci-dessus reconnaı̂t les mots formés d’un bloc non vide de a suivi d’un bloc non
vide de b. On calcule le déterminisé complet :
a b
p a b r
b p, q
a
puits
a, b
On échange états terminaux et non terminaux :
a b
p a b r
p, q
b
a
puits
a, b
Cet automate reconnaı̂t le complémentaire du langage de départ. On voit qu’il est crucial
d’utiliser un automate complet.
5
produit des deux automates dans lequel chaque chemin correspond à une paire formée d’un chemin
de chacun des deux automates étiquetés par le même mot.
Soit P = hR, A, F, J, U i l’automate défini par :
– les états de P sont des pairs d’états formées d’un état de A et d’un état de A′ ;
– l’ensemble J des états initiaux est formé des paires (p, p′ ), où p est initial dans A et p′ est initial
dans A′ ;
– pour tout état (p, p′ ), pour toute lettre a, s’il y a une transition (p, a, q) dans A et une transition
(p′ , a, q ′ ) dans A′ , il y a un état (q, q ′ ) dans P et une transition de (p, p′ ) à (q, q ′ ) étiquetée par a ;
– un état (p, p′ ) est terminal si et seulement si les états p et p′ sont terminaux.
Exemple : Soit A et A′ les deux automates suivants :
b
a a, b
p q b r s a u
t
a b
Pour calculer le produit, on place les automates en ligne, le premier verticalement, le second
horizontalement.
a, b
s a u
t
b
p p, s p, t p, u
a
a a
a a
q q, t q, u
b
b b
b b
r r, t r, u
b
On peut remarquer que le produit de deux automates déterministes est un automate déterministe.
Produit de concaténation Le produit des deux langages L et L′ est le langage L.L′ des mots
w formés d’un mot u de L et d’un mot v de L′ .
Le plus simple pour calculer un automate qui reconnaisse L.L′ est d’utiliser les ε-transitions.
L’automate C = hQ ∪ Q′ , A, E ∪ E ′ ∪ T × I ′ , I, T ′ i est formé de la juxtaposition des automates A
et A′ ; on place une ε-transition entre chaque état terminal de A et chaque état initial de A′ , puis
seuls les états initiaux de A restent initiaux, seuls les états terminaux de A′ restent terminaux.
Étoile de Kleene – Itération Pour tout langage L, on peut définir Ln , la n-ième puissance
de L, qui consiste à faire n fois le produit de concaténation de L par lui-même. Ln est donc le
lanage des mots qui peuvent être découpés en n parties appartenant chacune au langage L. Par
convention (et afin d’en faire un élément neutre pour la multiplication), L0 est le langage qui
contient uniquement le mot vide (c’est-à-dire le mot de longueur nulle).
6
L’étoile de L notée L∗ est l’union (infinie) de toutes les puissances de L ; c’est le langage des
mots qui peuvent être découpées en plusieurs parties appartenant chacune au langage L.
Si l’automate A reconnaı̂t le langage L, on obtient un automate (avec ε-transitions) reconnais-
sant L∗ en reliant chaque état terminal de A à chaque état terminal de A par une ε-transition et
en ajoutant un état initial et final.
Exemple : Considérons l’automate ci-dessous :
a, b
s a u
t
b
Pour construire un automate avec ε-transitions qui reconnaisse l’étoile du langage, on relie
l’état terminal aux états initiaux :
ε
a, b
s a u
t i
b, ε
Null(∅) = False
Null(ε) = True
Null(ap ) = False
Null(E ∪ F ) = Null(E)orNull(F )
Null(EF ) = Null(E)andNull(F )
Null(E ∗ ) = True
First est une fonction qui retourne un ensemble de positions. Elle indique où sont situées les
lettres qui peuvent apparaı̂tre comme première lettre d’un mot décrit par l’expression.
7
First(∅) = First(ε) = ∅
First(ap ) = {p}
First(E ∪ F ) = First(E) ∪ First(F )
(
First(E) ∪ First(F ) si Null(E) = True
First(EF ) =
First(E) si Null(E) = False
First(E ∗ ) = First(E)
Last est une fonction qui retourne un ensemble de positions. Elle indique où sont situées les
lettres qui peuvent apparaı̂tre comme dernière lettre d’un mot décrit par l’expression.
Last(∅) = Last(ε) = ∅
Last(ap ) = {p}
Last(E ∪ F ) = Last(E) ∪ Last(F )
(
Last(E) ∪ Last(F ) si Null(F ) = True
Last(EF ) =
Last(F ) si Null(F ) = False
Last(E ∗ ) = Last(E)
Last est une fonction qui a en argument une expression et une position et qui retourne un
ensemble de positions. Elle indique où sont situées les lettres qui peuvent suivre celle dont la
position est donnée en argument dans un mot décrit par l’expression.
Follow(∅, p) = Follow(ε, p) = ∅
Follow(aq , p) = ∅
Follow(E, p) si p est une position de E
Follow(E ∪ F, p) = Follow(F, p) si p est une position de F
∅ sinon
Follow(E, p) si p est une position de E et p 6∈ Last(E)
Follow(E, p) ∪ First(F ) si p ∈ Last(E)
Follow(EF, p) =
Follow(F, p) si p est une position de F
∅ sinon
(
Follow(E, p) ∪ First(E) si p est une position de E
Follow(E ∗ , p) =
∅ sinon
Pour l’expression Ē = (a1 ∪ b2 a3 )∗ (ε ∪ b4 ), on obtient Null(E) = True, First(E) = {1, 2, 4},
Last(E) = {1, 3, 4}, et
p 1 2 3 4
Follow(E, p) {1, 2, 4} {3} {1, 2, 4} ∅
Définition 1 Soit E une expression rationnelle et [1; n] l’ensemble des positions de cette expres-
sions. L’automate des positions de E est A = h{i} ∪ [1; n], A, E, {i}, T i, où