Vous êtes sur la page 1sur 8

Automates

Notions de base
Notes de cours, IR1, 2009
Sylvain Lombardy

1 Alphabets, mots, langages


Un alphabet A est un ensemble fini de symboles appelés lettres.
Un mot est une suite finie de lettres.
On note A∗ l’ensemble des mots que l’on peut former avec des lettres de l’alphabet A.
Un langage sur un alphabet A est un ensemble (fini ou infini) de mots de A∗ .
Exemples :
1. L’alphabet A1 permettant d’écrire les mots usuels comporte environ soixante-dix lettres (mi-
nuscules, majuscules, lettres accentuées). L’ensemble des mots du français est un langage sur A1 .
Le mot carichon appartient à A∗1 mais n’est pas un mot français.
2. Les séquences d’ADN se représentent sur un alphabet A2 = {G, A, T, C}. Une séquence d’ADN
est un mot de A∗2 , mais un mot de A∗2 n’est pas forcément une séquence correcte.
3. On peut prendre comme alphabet A3 l’ensemble des mots du français (plusieurs centaines de
milliers de mots). Un “mot” est alors une suite finie d’éléments de cet alphabet, c’est donc ce
qu’on appelle habituellement une phrase. Les phrases correctes sont un langage sur A3 .

2 Automates non déterministes


Définition Un automate (non-déterministe) A sur un alphabet A est défini par les éléments
suivants :
– un ensemble fini d’états noté Q ;
– un ensemble fini E de transitions, chaque transition étant définie par un état de départ p, un
état d’arrivée q et une étiquette a appartenant à A ; on note une telle transition (p, a, q).
– un sous-ensemble de Q appelé ensemble d’états initiaux noté I ;
– un sous-ensemble de Q appelé ensemble d’états terminaux noté T .
Un tel automate est noté A = hQ, A, E, I, T i. Ainsi, quand on définit un automate, on donne
successivement son ensemble d’états, l’alphabet sur lequel il est défini, son ensemble de transitions,
son ensemble d’états initiaux et son ensemble d’états terminaux.

Représentation graphique Un automate est représenté comme un graphe orienté étiqueté :


les états sont des ronds (à l’intérieur desquels on écrit le nom de l’état), les transitions sont
représentées par des flèches qui partent de l’état de départ et pointent sur l’état d’arrivée, on
indique au milieu de la flèche la lettre qui en est l’étiquette. Un état initial est signalé par une
petite flèche qui pointe sur l’état, un état terminal par une petite flèche qui en part (et qui pointe
dans le vide).
Exemple :
a, c, g, t a, c, g, t
g t a
p q r s

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

Si A = hQ, A, E, {i}, T i est un automate déterministe complet, on peut définir la fonction de


transition δ, qui, étant donné un état p et une lettre a , donne le successeur de p par a, c’est-
à-dire l’unique état q tel que (p, a, q) est une transition de A : δ(p, a) = q. On peut alors noter
A = (Q, A, δ, i, T ).

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.

Déterminisation Il existe un algorithme qui permet de transformer n’importe quel automate


en automate déterministe équivalent.
Soit A = hQ, A, E, I, T i un automate non déterministe. On calcul D le déterminisé de A.
Chaque état de D correspond à un ensemble d’états de A. On veut construire D de sorte que
lorsqu’on lit un mot w à partir de l’état initial, on arrive dans un état qui correspond à l’ensemble
des états de A dans lesquels on peut arriver à partir d’un état initial de A en lisant w.

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.

Suppression des ε-transitions On peut toujours calculer un automate équivalent sans ε-


transition.
Pour cela, il faut d’abord calculer, pour chaque état, les ε-succeseurs de chaque état p, c’est-à-
dire l’ensemble des états q tels qu’il existe un chemin formé uniquement de ε-transitions partant
de p arrivant en q. On note cet ensemble Succε (p).
L’algorithme est ensuite le suivant :
–pour tout état p
pour tout état q dans Succε (p)
si q est final, rendre p final
pour toute transition (q, a, r) partant de q
créer la transition (p, a, r) (sauf si elle existe).
–Supprimer les ε-transitions.
Exemple :
a b a

p ε q ε r

On calcule les ε-successeurs de chaque état :

Succε (p) = {q, r}, Succε (q) = {r}, Succε (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.

5 Opérations sur les langages


On considère un automate A = hQ, A, E, I, T i qui reconnaı̂t un langage L et un automate
A′ = hQ′ , A, E ′ , I ′ , T ′ i (sur le même alphabet) qui reconnaı̂t un langage L′ .
On va voir quelles opérations sur les langages L et L′ peuvent être représentées par des auto-
mates.

Complémentation On cherche à construire un automate A qui reconnaisse le langage L des


mots qui ne sont pas dans L.
On calcul D l’automate déterminisé complet à partir de A. Un mot w est dans L si et seulement
si lorsqu’on le lit dans D, on arrive à un état terminal. Donc il est dans L si et seulement si lorsqu’on
le lit dans D, on arrive à un état non terminal. Le langage L est donc reconnu par l’automate D,
obtenu à partir de D en échangeant états terminaux et non terminaux.
Exemple :
a b
p a q b r

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.

Intersection de langages On veut calculer un automate qui reconnaisse le langage L ∩ L′ ,


c’est-à-dire le langage des mots qui sont reconnus à la fois par A et A′ . On construit pour cela le

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.

Union de langages On veut calculer un automate qui reconnaisse le langage L ∪ L′ , c’est-à-dire


le langage des mots qui sont reconnus par A ou par A′ (ou par les deux).
La solution consiste tout simplement à placer les deux automates côte à côte. On obtient alors
l’automate U = hQ ∪ Q′ , A, E ∪ E ′ , I ∪ I ′ , T ∪ T ′ i.

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, ε

On peut ensuite supprimer les ε-transitions :


a, b
a, b
s a u
t i
b, a

6 Automate des positions


Pour calculer l’automate des positions d’une expression, on commence par numéroter chaque
occurence de lettre.
Exemple : E = (a ∪ ba)∗ (ε ∪ b) devient Ē = (a1 ∪ b2 a3 )∗ (ε ∪ b4 ).
On dira que cette expression a 4 positions : {1, 2, 3, 4} et que la lettre en position 3, par exemple,
est un a.
On calcule sur l’expression les fonctions Null, First, Last et Follow.
Null est une fonction à valeur booléenne qui indique si le langage représenté par une expression
contient le mot vide ; elle est inductivement définie par :

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ù

E = {(i, a, p) | p ∈ First(E) et la lettre en position p est a}


∪ {(p, a, q) | q ∈ Follow(E, p) et la lettre en position q est a}
(
{i} ∪ Last(E) si Null(E) = True
T =
Last(E) si Null(E) = False