option informatique

Chapitre 4
Automates

1. Automates finis déterministes

1.1 Introduction
De manière informelle, un automate est une machine abstraite qui peut prendre un nombre fini d’états, qui
reçoit en entrée un mot écrit sur un alphabet Σ, et qui change d’état à la lecture des lettres de ce dernier.
Certains états sont désignés au préalable comme des états acceptants ; à la fin de la lecture du mot passé en
entrée l’automate aura changé d’état ; on dira que le mot est accepté si l’état final est un état acceptant, et rejeté
dans le cas contraire.
Considérons à titre d’exemple l’automate fini suivant : les états sont représentés par les nœuds du graphe et les
transitions par les arêtes. Ces dernières sont étiquetées par une lettre de l’alphabet Σ = {a, b} et représentent le
changement d’état lié à la lecture du mot en entrée.
a b
b
q0 a q1 q2
a

L’état initial (ici q0 ) est désigné par une flèche entrante ; les états acceptants (ici q2 ) sont représentés par une
flèche sortante 1 .
On se convaincra aisément que pour qu’un mot soit lu et aboutisse à un état acceptant il faut et il suffit qu’il
débute par un a et se termine par un b ; on dira que cet automate reconnait le langage des mots de aΣ∗ b.
On peut observer qu’un mot débutant par la lettre b ne peut être lu par cet automate, faute d’une transition
partant de q0 et étiquetée par b. On dira que le couple (q0 , b) est un blocage de l’automate. Un automate sans
blocage est dit complet ; il est toujours possible de rendre un automate complet en ajoutant un état inutile qu’on
appelle un puit (voir figure 1).

a b
b
q0 a q1 q2
a
b
q3

a, b

Figure 1 – Un automate complet qui reconnait le langage aΣ∗ b ; l’état q3 est un puit.

Le second exemple que nous allons donner est un peu plus complexe. L’alphabet utilisé est l’alphabet binaire
Σ = {0, 1} et le mot lu par l’automate ci-dessous correspond à l’écriture binaire d’un entier n :
0 1
1 0
q0 q1 q2

1 0
1. Certains auteurs représentent les états acceptants avec un double cercle.

[Link]
4.2 option informatique

Nous allons montrer que cet automate reconnait les entiers n qui sont divisibles par 3. Plus précisément, nous
allons montrer par récurrence sur n que l’état final atteint par la lecture de l’entier n est q0 si n ≡ 0 mod 3, q1 si
n ≡ 1 mod 3 et q2 si n ≡ 2 mod 3.
– C’est vrai si n = 0 ;
– si n > 1, supposons le résultat acquis jusqu’au rang n − 1, et posons n = 2p + r avec r ∈ {0, 1}.
Par hypothèse de récurrence appliquée à p, avant la lecture de r l’automate se trouve dans l’état qi avec
p ≡ i mod 3.
– Si i = 0 alors n ≡ r mod 3 et si r = 0 l’automate reste à l’état q0 , si r = 1 l’automate passe à l’état q1 ;
– si i = 1 alors n ≡ 2 + r mod 3 et si r = 0 l’automate passe à l’état q2 , si r = 1 l’automate passe à l’état q0 ;
– si i = 2 alors n ≡ 1 + r mod 3 et si r = 0 l’automate passe à l’état q1 , si r = 1 l’automate reste à l’état q2 .
Dans les trois cas le résultat est acquis au rang n.

1.2 Définition formelle d’un automate

Définition. — Un automate fini 2 déterministe (DFA, pour deterministic finite automaton) est défini par un
quintuplet A = (Σ, Q, q0 , F, δ) où :
– Σ est un alphabet (fini) ;
– Q est un ensemble fini dont les éléments sont appelés les états de A ;
– q0 ∈ Q est l’état initial ;
– F ⊂ Q est l’ensemble des états acceptants (ou finaux) ;
– δ est une application d’une partie de Q × Σ dans Q, appelée fonction de transition.
Lorsque δ est définie sur Q × Σ tout entier, l’automate A est dit complet.

Le qualificatif de déterministe sera justifié lors de l’introduction des automates non-déterministes plus loin dans
ce chapitre.
Comme nous l’avons vu en introduction, il est d’usage de représenter un automate par un graphe dont les
nœuds sont les états et les arêtes les couples (qi , qj ) ∈ Q2 étiquetés par a ∈ Σ tel que δ(qi , a) = qj .

b a, b
– Σ = {a, b} ; δ a b a a
q0 q1 q0
– Q = {q0 , q1 , q2 } ; q0 q1 q2
q1 q2 q0
– F = {q0 , q1 } ; q2 q2 q2 b

Figure 2 – Un automate fini déterministe complet et sa représentation graphique.

a
Une transition δ(qi , a) = qj sera représentée par qi −→ qj . Un chemin dans l’automate A est une suite finie
a1 a2 an
de transitions consécutives q0 −→ q1 −→ · · · −→ qn débutant par l’état initial q0 . Le mot a1 a2 · · · an est appelé
l’étiquette du chemin.

Définition. — Un chemin est dit acceptant lorsque l’état d’arrivée de celui-ci est un état acceptant ; un mot de Σ∗
est reconnu par l’automate A lorsqu’il est l’étiquette d’un chemin acceptant. Le langage L(A) reconnu par l’automate
A est l’ensemble des mots reconnus par A.

Par exemple, le langage reconnu par l’automate représenté figure 2 est le langage des mots sur {a, b} qui ne
comportent pas deux a consécutifs. Notons qu’il s’agit d’un langage rationnel dénoté par (b + ab)∗ (ε + a).
En effet, Notons Li l’ensemble des étiquettes des chemins débutant par l’état qi et finissant par un état acceptant.
On dispose des relations :
L0 = ε + bL0 + aL1 , L1 = ε + bL0 et L2 = ∅.
On en déduit que L0 = ε + bL0 + a(ε + bL0 ) = (b + ab)L0 + (ε + a) et d’après le lemme d’Arden 3 , L0 = (b + ab)∗ (ε + a).
2. Plus exactement à états finis.
3. Voir l’exercice 11 du chapitre 3.
Automates 4.3

Remarque. Le théorème de Kleene qui sera prouvé plus loin établit l’équivalence entre les expressions
rationnelles et les automates finis dans le sens où ces deux notions définissent les mêmes langages. Ce résultat
est remarquable car il relie deux notions de natures différentes, combinatoire pour les expressions rationnelles
et opérationnelles pour les automates.

1.3 Émondage
Nous avons mis en évidence la fonction principale d’un automate : reconnaitre des mots en parcourant
un par un ses caractères. Dans le cas d’un automate complet, la complexité de l’algorithme qui en résulte
est proportionnelle à la longueur du mot puisqu’aucune transition n’est bloquante. Or ceci peut s’avérer
particulièrement inefficace : dans l’exemple de l’automate présenté figure 2, une fois arrivé dans l’état q2 il est
impossible de le quitter et il n’est donc pas nécessaire de poursuivre la lecture du mot (on dit que q2 est un
puit). Puisqu’il ne s’agit pas d’un état acceptant, il peut être supprimé sans modifier le langage reconnu par
l’automate. On dira que l’automate représenté figure 3 est un automate équivalent à celui de la figure 2 car il
reconnait le même langage, et le couple (q1 , a) sera appelé un blocage car δ(q1 , a) n’est pas défini.

b
– Σ = {a, b} ; δ a b a
– Q = {q0 , q1 } ; q0 q1 q0 q0 q1
– F = {q0 , q1 } ; q1 − q0
b

Figure 3 – Un automate incomplet équivalent à celui de la figure 2.

L’état q2 de l’automate présenté figure 2 a pu être supprimé car il n’existe pas de chemin menant de q2 à un état
acceptant. Plus généralement, on dit d’un état q qu’il est :
– accessible lorsqu’il existe un chemin menant de l’état initial q0 à q ;
– co-accessible lorsqu’il existe un chemin menant de q à un état acceptant.
Un état accessible et co-accessible est dit utile ; sachant que le chemin décrit par un mot reconnu ne passe que
par des états utiles, on ne change pas le langage reconnu en supprimant tous les états qui ne le sont pas ainsi
que les transitions impliquant ces états. L’automate obtenu, qui ne possède plus que des états utiles, est dit
émondé.

a b a b
b b
q0 a q1 q2 q0 a q1 q2
a a
b
b
q3 q4 q3 n’est pas co-accessible
a
q4 n’est pas accessible

a, b

Figure 4 – Un automate complet et son émondage. Tous deux reconnaissent le langage dénoté par a(a + b)∗ b.

1.4 Mise en œuvre pratique

Pour modéliser un automate en Caml il est pratique d’utiliser le type char pour représenter l’alphabet Σ, le
type int pour l’ensemble des états et d’utiliser un dictionnaire pour énumérer la liste des transitions possibles.
Pour simplifier, la liste des transitions possibles sera représentée par le type (int * char) * int list et on utilisera la
fonction assoc pour associer au couple (q, a) l’état δ(q, a) 4 .

4. la fonction assoc est de type ’a −> (’a * ’b) list −> ’b ; appliquée à un élément a et une liste ` cette fonction renvoie la première valeur b
telle que (a, b) ∈ ` et déclenche l’exception Not_found s’il n’en existe pas.

[Link]
4.4 option informatique

Ceci conduit à définir le type :

type dfa = {Start: int ;
Accept: int list ;
Delta: ((int * char) * int) list} ;;

Par exemple, l’automate émondé représenté figure 4 sera défini par :

let a = {Start = 0; Accept = [2]; Delta = [ (0, ‘a‘), 1; (1, ‘a‘), 1; (1, ‘b‘), 2;
(2, ‘a‘), 1; (2, ‘b‘), 2 ]} ;;

La fonction suivante détermine l’état final de l’automate après parcours du chemin étiqueté par un mot passé
en paramètre (et déclenche l’exception Not_found en cas de blocage) :

let chemin a m =
let rec aux q = function
| k when k = string_length m −> q
| k −> aux (assoc (q, m.[k]) [Link]) (k+1)
in aux [Link] 0 ;;

Enfin, la fonction qui suit détermine si un mot est reconnu ou pas :

let reconnu a m =
try mem (chemin a m) [Link]
with Not_found −> false ;;

2. Automates non-déterministes
Dans cette section nous allons généraliser la notion d’automate fini en utilisant plusieurs états initiaux et en
autorisant deux transitions sortantes d’un même état q à porter la même étiquette. Nous constaterons que cette
généralisation n’augmente pas l’expressivité du modèle : les langages reconnus sont les mêmes que pour les
automates déterministes ; cependant le nombre d’états d’un automate non-déterministe peut être notablement
inférieur à l’automate déterministe équivalent.

2.1 Définition
Définition. — Un automate fini non-déterministe (NFA, nondeterministic finite automaton) est défini par un
quintuplet A = (Σ, Q, I, F, δ) où :
– Σ est un alphabet (fini) ;
– Q est un ensemble fini dont les éléments sont appelés les états de A ;
– I ⊂ Q est l’ensemble des états initiaux ;
– F ⊂ Q est l’ensemble des états acceptants (ou finaux) ;
– δ est une application d’une partie de Q × Σ dans P (Q), appelée fonction de transition.

On notera que la notion de blocage n’a plus vraiment de sens puisque δ(q, a) peut prendre la valeur ∅.
a
Une transition est un triplet (qi , a, qj ) tel que qj ∈ δ(qi , a) ; celle-ci est représentée par qi −→ qj . Un chemin est une
a1 a2 an
suite finie de transitions consécutives q0 −→ q1 −→ · · · −→ qn .

Définition. — Un mot de Σ∗ est reconnu par l’automate A s’il étiquette un chemin menant d’un état initial à un
état acceptant. Le langage des mots reconnus par l’automate A est noté L(A).

Autrement dit, pour qu’un mot m soit reconnu il suffit qu’il existe au moins un chemin étiqueté par m menant
d’un état initial à un état acceptant, ce qui nécessite de tester tous les chemins partant d’un état initial et
étiquetés par m avant de pouvoir affirmer que ce dernier n’est pas reconnaissable.
Automates 4.5

a, b

q0 a q1 b q2

Figure 5 – Un automate non-déterministe qui reconnait le langage dénoté par a(a + b)∗ b.

2.2 Déterminisation
La propriété essentielle que nous allons établir est que tout automate non-déterministe est équivalent (dans
le sens où il reconnait le même langage) à un automate déterministe. La preuve que nous allons établir est
couramment appelée construction par sous-ensembles.
Considérons donc un automate non-déterministe A = (Σ, Q, I, F, δ) et posons :
n  o [
A0 = (Σ, P (Q), I, F0 , δ0 ) avec F0 = P ∈ P (Q)  P ∩ F , ∅ et ∀(P, a) ∈ P (Q) × Σ, δ0 (P, a) = δ(q, a).
q∈P

Si A est un automate non-déterministe à n états, l’automate A0 est un automate déterministe à 2n états. Pour
bien comprendre cette construction, calculons A0 lorsque A est l’automate représenté figure 5. A0 possède 23 = 8
états : ∅, {q0 }, {q1 }, {q2 }, {q0 , q1 }, {q1 , q2 }, {q0 , q2 }, {q0 , q1 , q2 } ; son état initial est {q0 } et ses états acceptants tous
ceux qui contiennent q2 , à savoir {q2 }, {q1 , q2 }, {q0 , q1 , q2 }. Enfin, le tableau des transitions de A0 est le suivant :

δ0 a b δ0 a b
∅ ∅ ∅ {q0 , q1 } {q1 } {q1 , q2 }
{q0 } {q1 } ∅ {q1 , q2 } {q1 } {q1 , q2 }
{q1 } {q1 } {q1 , q2 } {q0 , q2 } {q1 } ∅
{q2 } ∅ ∅ {q0 , q1 , q2 } {q1 } {q1 , q2 }

Pour éviter d’avoir à représenter un automate trop volumineux on ne représente que les états accessibles :
pour ce faire on commence par remplir le tableau des transitions avec l’état initial et on n’ajoute que les états
qui apparaissent comme résultats des transitions précédentes. On ne représente pas non plus l’état ∅ qui ne
peut être co-accessible (en revanche d’autres états non co-accessibles peuvent subsister). Dans le cas qui nous
intéresse cela conduit au tableau simplifié suivant :

δ0 a b
{q0 } {q1 } −
{q1 } {q1 } {q1 , q2 }
{q1 , q2 } {q1 } {q1 , q2 }

En posant q00 = {q0 }, q10 = {q1 } et q20 = {q1 , q2 } l’automate déterminisé (et partiellement émondé) est donc :

a b
b
a
q00 q10 q20
a

Théorème. — Les automates A et A0 reconnaissent le même langage.

Preuve. On montre par récurrence sur |u| que pour tout mot u ∈ Σ∗ , il existe dans A un chemin étiqueté par u
menant à un état q si et seulement s’il existe dans A0 un chemin étiqueté par u menant à un état P contenant q.
– Dans A tout chemin étiqueté par ε mène à un élément de I ; dans A0 tout chemin étiqueté par ε mène à
l’état I. Le résultat énoncé est donc vrai pour le mot ε.
– Si u , ε, supposons le résultat acquis pour tout mot de longueur strictement inférieure, et posons
u = a1 a2 · · · an .
a1 a2 an
Considérons un chemin q0 −→ q1 −→ · · · −→ qn dans A. Par hypothèse de récurrence il existe dans A0 un
a1 a2 an−1
chemin I −→ P1 −→ · · · −→ Pn−1 tel que qn−1 ∈ Pn−1 . Or qn ∈ δ(qn−1 , an ) donc qn ∈ δ0 (Pn−1 , an ). En posant
a1 a2 an
Pn = δ0 (Pn−1 , an ) on établit un chemin I −→ P1 −→ · · · −→ Pn tel que qn ∈ Pn .

[Link]
4.6 option informatique

a1 a2 an
Réciproquement, considérons un chemin I −→ P1 −→ · · · −→ Pn dans A, et considérons un élément qn ∈ Pn .
Il existe donc un état qn−1 ∈ Pn−1 tel que qn ∈ δ(qn−1 , an ). Or par hypothèse de récurrence il existe un
a1 a2 an−1 a1 a2 an
chemin q0 −→ q1 −→ · · · −→ qn−1 dans A, ce qui prouve l’existence d’un chemin q0 −→ q1 −→ · · · −→ qn .
n  o
Sachant que F0 = P ∈ P (Q)  P ∩ F , ∅ ceci prouve qu’un mot est reconnu par A si et seulement s’il est reconnu
par A0 .

Remarque. Le résultat précédent prouve que les automates non-déterministes ne sont pas plus « riches » que
les automates déterministes puisqu’ils reconnaissent exactement les mêmes langages. En outre ils ne sont pas
très efficaces pour le traitement effectif des données : pour un mot donné, il faut explorer tous les chemins
étiquetés par celui-ci, à partir de tous les états initiaux, avant de pouvoir affirmer que ce mot n’est pas reconnu
alors que pour un automate déterministe il y a au plus un chemin étiqueté pour un mot donné.
Cependant ils sont parfois plus simples à construire à partir d’une caractérisation donnée d’un langage et seront
pour cette raison précieux dans certaines preuves à venir. En outre, ils fournissent des automates ayant souvent
un nombre plus réduit d’états. La démarche que nous suivrons plus loin consistera à trouver un automate
non-déterministe reconnaissant un langage donné, à le déterminiser puis à émonder ce dernier avec pour
objectif d’obtenir un automate déterministe ayant un nombre le plus réduit possible d’états.
Il faut cependant noter qu’il sera parfois tout bonnement impossible d’obtenir un automate déterministe ayant
un nombre d’états du même ordre de grandeur que pour l’automate non déterministe équivalent. Considérons
en effet le langage dénoté par (a + b)∗ a(a + b)n−1 . Il est facile d’obtenir un automate non-déterministe à n + 1 états
qui le reconnait :

a, b

a a, b a, b a, b
q0 q1 q2 ··· qn

En revanche nous allons montrer que tout automate déterministe qui reconnait L possède au moins 2n états.

Preuve. Considérons un tel automate A et notons q0 son état initial. À tout mot u de n lettres on peut associer
l’état q(u) auquel aboutit le chemin étiqueté par u. On définit ainsi une application q : {a, b}n → Q et nous allons
montrer que cette application est injective.
Pour cela on considère deux mots distincts u et v tels que q(u) = q(v) ainsi que le plus long suffixe w commun à u
et à v. Sans perte de généralité on peut poser u = u 0 aw et v = v 0 bw. Le mot w est de longueur inférieure ou égale
à n − 1 ; complétons-le pour former un mot ww0 de longueur n − 1. Dans ces conditions le mot uw0 = u 0 aww0
est reconnu par A mais pas vw0 = v 0 bww0 . Cependant puisque A est déterministe et q(u) = q(v) les chemins
étiquetés par uw0 et vw0 doivent mener au même état (ou être tous deux bloquants) ce qui est absurde.
q est donc bien injectif et A possède au moins 2n états.

2.3 Recherche d’un mot dans un texte

Nous allons maintenant illustrer l’intérêt que peut présenter la formalisation d’un problème par des automates
en abordant le problème de la recherche d’un mot dans un texte.

Si u ∈ Σ∗ est un mot donné, on souhaite obtenir un automate qui caractérise la présence de u dans un texte,
autrement dit qui reconnait le langage Σ∗ uΣ∗ . Ce problème est aisément résolu à l’aide d’un automate non-
déterministe : si u = a1 a2 · · · an il suffit de considérer l’automate :

Σ Σ

a1 a2 a3 an
q0 q1 q2 ··· qn

Cependant, si on veut effectivement utiliser ce formalisme pour traiter un texte, il est préférable de disposer d’un
automate déterministe ; on calcule donc l’automate déterminisé de l’automate ci-dessus. La figure 6 présente
l’automate non-déterministe associé à la recherche du mot aba sur l’alphabet {a, b} ainsi que sa déterminisation.
Automates 4.7

a, b a, b

q0 a q1 b q2 a q3

b a

a b
q00 q10 q20
δ0 a b
{q0 } {q0 , q1 } {q0 }
{q0 , q1 } {q0 , q1 } {q0 , q2 } b a
{q0 , q2 } {q0 , q1 , q3 } {q0 }
{q0 , q1 , q3 } {q0 , q1 , q3 } {q0 , q2 , q3 } b b
{q0 , q2 , q3 } {q0 , q1 , q3 } {q0 , q3 } q50 q40 q30
{q0 , q3 } {q0 , q1 , q3 } {q0 , q3 } a

b a
a

Figure 6 – L’automate non-déterministe qui reconnait le langage Σ∗ abaΣ∗ et sa déterminisation.

L’automate déterministe obtenu est émondé et possède 6 états mais il n’est pas optimal : à l’évidence les états q40
et q50 ne sont pas nécessaires et il peut être réduit à l’automate à quatre états suivant :

b a a, b

a b a
q00 q10 q20 q30

• Algorithme KMP 5
Il existe un moyen d’obtenir mécaniquement un automate déterministe ayant un nombre plus réduit d’états en
considérant l’ensemble P(u) des préfixes du mot u et si v est un mot en notant s(v) le plus long suffixe de v qui
soit dans P(u).
Nous allons considérer l’automate déterministe A = (Σ, P(u), {ε}, {u}, δ) où la fonction de transition est définie
par :
∀p ∈ P(u), ∀x ∈ Σ, δ(p, x) = s(px)
La figure 7 représente l’automate ainsi construit à partir du mot u = aba.

a
b a
δ a b
a
ε a ε
a a ab a b
ε a ab aba
ab aba ε
aba a ab b
b

Figure 7 – Un automate déterministe qui reconnait le langage Σ∗ aba.

Théorème. — L’automate A reconnait le langage Σ∗ u.

5. D’après le nom de leurs inventeurs, Knuth, Morris et Pratt.

[Link]
4.8 option informatique

Preuve. Si p ∈ P(u) et v ∈ Σ∗ nous allons montrer par récurrence sur |v| que le chemin qui part de l’état p et qui
est étiqueté par v mène à l’état s(pv).
– Si v = ε on a s(p) = p puisque p ∈ P(u).
– Si v n’est pas le mot vide, supposons le résultat acquis pour tout mot de longueur inférieure et notons
v = v 0 a. Par hypothèse de récurrence le chemin qui part de p étiqueté par v 0 mène à l’état s(pv 0 ). Celui
étiqueté par v mène donc à l’état δ(s(pv 0 ), a) = s(s(pv 0 )a). Il s’agit donc de prouver que s(s(pv 0 )a) = s(pv).
Posons w = s(s(pv 0 )a) et w0 = s(pv 0 ). w est suffixe de w0 a et w0 suffixe de pv 0 donc w est suffixe de pv 0 a = pv.
De plus w ∈ P(u) donc w est suffixe de s(pv) (plus long suffixe de pv qui soit dans P(u)).
Si s(pv) = ε alors w = ε. Si s(pv) , ε on peut poser s(pv) = xa puisque v = v 0 a. Alors x ∈ P(u) et x est suffixe
de pv 0 donc x est suffixe de s(pv 0 ) = w0 et xa suffixe de w0 a. Puisque xa ∈ P(u) alors xa est suffixe de
s(w0 a) = w. Dans les deux cas nous avons prouvé que s(pv) est suffixe de w donc en définitive w = s(pv).
Ainsi le chemin qui part de l’état ε et étiqueté par un mot v mène à l’état s(v), et s(v) = u ⇐⇒ v ∈ Σ∗ u.

Corollaire. — Pour obtenir un automate qui reconnait le langage Σ∗ uΣ∗ il suffit de considérer l’automate A et de
transformer l’état u en puit.

b a a, b

a b a
ε a ab aba

Figure 8 – Un automate déterministe qui reconnait le langage Σ∗ abaΣ∗ .

3. Automates finis et langages rationnels

Il est maintenant temps d’aborder le théorème essentiel de ce chapitre, qui affirme l’équivalence entre langages
rationnels et langages reconnaissables par un automate. Il s’agit du :

Théorème (Kleene). — Un langage L sur un alphabet Σ est rationnel si et seulement s’il existe un automate fini A
tel que L(A) = L.

Dans un premier temps nous montrerons que tout langage rationnel est reconnaissable en décrivant un algo-
rithme construisant explicitement un automate (l’automate de Glushkov) associé à une expression rationnelle.
Moins utile en pratique, la réciproque, à savoir la détermination d’une expression rationnelle à partir d’un
automate, nous servira essentiellement à justifier l’équivalence dans le théorème de Kleene. Enfin, quelques
propriétés des langages reconnaissables (en particulier de clôture) seront établies pour être étendues aux
langages rationnels.

3.1 L’algorithme de Berry-Sethi

Définition. — Un automate déterministe A = (Σ, Q, q0 , F, δ) est dit local lorsque pour toute lettre x il existe un état
q ∈ Q tel que pour tout q0 ∈ Q, δ(q0 , x) est un blocage ou δ(q0 , x) = q.
Il est dit standard lorsqu’il n’existe pas de lettre x et d’état q tel que δ(q, x) = q0 .

Autrement dit, un automate est local lorsque pour chaque lettre x toutes les transitions étiquetées par x arrivent
dans un même état, et il est standard lorsqu’il n’existe pas de transition aboutissant à l’état initial.

Théorème. — Si L est un langage local, le langage L \ {ε} est reconnaissable par un automate local standard.

Preuve. Notons P = P(L), S = S(L), F = F(L) 6 et considérons l’automate A = (Σ, Σ ∪ {ε}, ε, S, δ) avec :
∀x ∈ P, δ(ε, x) = x et ∀xy ∈ F, δ(x, y) = y.
6. Ces notations sont celles du chapitre précédent.
Automates 4.9

Par construction, le mot u = a1 a2 · · · an est reconnu par A si et seulement si a1 ∈ P, ai ai+1 ∈ F pour i ∈ ~1, n − 1 et
an ∈ S.

Remarque. Si le langage local L contient le mot vide il suffit d’ajouter l’état ε à l’ensemble des états acceptant
pour obtenir un automate qui reconnait L.

Corollaire. — Tout langage dénoté par une expression rationnelle linéaire est reconnaissable.

À titre l’exemple, considérons l’expression rationnelle linéaire (a+b)∗ c. Nous avons vu dans le chapitre précédent
les algorithmes de calcul des ensembles P, S et F ; appliqués à cette expression on obtient P = {a, b, c}, S = {c} et
F = {aa, ab, ba, bb, ac, bc}. L’automate local reconnaissant le langage dénoté par cette expression est donc :

b
a b
b
a c
ε a b c
a

• Construction de l’automate de Glushkov

Considérons maintenant une expression rationnelle quelconque e. Nous avons vu au chapitre précédent que
si le langage dénoté par e est non vide il existe une expression rationnelle équivalente e0 ne contenant pas le
symbole ∅. Nous avons aussi démontré l’existence d’une expression rationnelle e00 ne contant pas le symbole ε
telle que e00 soit équivalente à ε, e00 ou ε + e00 . Il est facile de construire un automate reconnaissant le langage
dénoté par ε + e00 à partir d’un automate reconnaissant le langage dénoté par e00 : il suffit d’ajouter q0 aux états
acceptants. On suppose donc désormais que e est une expression rationnelle ne comportant ni le symbole ∅, ni
le symbole ε.

Linéarisation d’une expression rationnelle par marquage

Notons n le nombre de lettres (non nécessairement distinctes) de e et ordonnons ces dernières par ordre croissant
d’apparition dans e. Remplaçons dans e chaque lettre par le caractère ck où k désigne son rang d’apparition. On
obtient une nouvelle expression rationnelle sur l’alphabet Σ0 = {c1 , c2 , . . . , cn }, expression qui est linéaire.
Par exemple, à l’expression e = (a + b)(a∗ + ba∗ + b∗ )∗ va être associée l’expression rationnelle linéaire e0 =
(c1 + c2 )(c3∗ + c4 c5∗ + c6∗ )∗ .
Pour retrouver l’expression rationnelle initiale à partir de l’expression linéarisée il suffit de connaître la fonction
de marquage µ : {c1 , c2 , . . . , cn } → Σ précisant par quel caractère de Σ doit être remplacé le caractère ck .
Dans le cas de l’exemple ci-dessus on a µ(c1 ) = µ(c3 ) = µ(c5 ) = a et µ(c2 ) = µ(c4 ) = µ(c6 ) = b.

Théorème. — Tout langage dénoté par une expression rationnelle sans symbole ∅ ni ε est reconnaissable par un
automate fini.

Preuve. Soit e une expression rationnelle sans ∅ ni ε, et A = ({c1 , . . . , cn }, Q, q0 , F, δ) l’automate standard local
associé à la linéarisation de e. On remplace dans A toutes les transitions étiquetées par le caractère ci par
une transition étiquetée par µ(ci ) ; autrement dit on considère l’automate A0 = (Σ, Q, q0 , S, δ0 ) obtenu en posant
δ(qi , c) = δ(qi µ(c)). Alors A0 est un automate standard (en général non déterministe) qui reconnait le langage
dénoté par e.

Remarque. Compte tenu de la remarque faite au préalable, ceci prouve le sens direct du théorème de Kleene.
La procédure que nous venons de décrire :
– linéarisation de l’expression ;
– calcul des ensembles P, S et F définissant le langage local associé ;
– construction de l’automate local ;
– suppression des marques utilisées pour la linéarisation

[Link]
4.10 option informatique

porte le nom d’ algorithme de Berry-Sethi et l’automate obtenu s’appelle l’automate de Glushkov de l’expression
rationnelle. Ce dernier est en général non déterministe et possède |e| + 1 états ; il peut être rendu déterministe
par déterminisation.
Exemple. Considérons l’expression rationnelle e = (ab+b)∗ ba. Sa linéarisation est e0 = (c1 c2 +c3 )∗ c4 c5 . On calcule
P = {c1 , c3 , c4 }, S = {c5 } et F = {c1 c2 , c2 c1 , c2 c3 , c2 c4 , c3 c1 , c3 c3 , c3 c4 , c4 c5 } donc l’automate local standard associé à e0
est :
c2

c1 c2

c1
c1
c1
c3
c3
c0 c3 c3
c4
c4
c4

c4 c5
c5

Il reste à supprimer le marquage pour obtenir l’automate de Glushkov associé à e :

b
c1 c2

a
a
a
b

c0 b c3 b
b
b
b

c4 c5
a

On peut finalement le déterminiser :

b
q1 q3

a
δ0 a b a
a
{c0 } {c1 } {c3 , c4 }
{c1 } − {c2 }
{c3 , c4 } {c1 , c5 } {c3 } q0 q5 b
{c2 } {c1 } {c3 , c4 }
b
{c1 , c5 } − {c2 }
{c3 } {c1 } {c3 , c4 } b b
b

q2 q4
a
Automates 4.11

3.2 Des automates aux expressions rationnelles

Pour montrer que tout langage reconnu peut être dénoté par une expression rationnelle nous allons généraliser
la définition des automates en s’autorisant l’étiquetage d’une transition par une expression rationnelle. Plus
précisément :

Définition. — On appelle automate généralisé un automate A = (Rat(Σ), Q, I, F, δ) dont les états et les transitions
sont en nombres finis et dont les transitions sont étiquetées par des expressions rationnelles.

e1 e2 en
Avec un automate généralisé, un mot u est reconnu s’il existe un chemin q0 −→ q1 −→ · · · −→ qn menant d’un
état initial à un état acceptant tel que u appartienne au langage dénoté par e1 e2 · · · en .
Remarque. La possibilité d’étiqueter une transition par ε permet de supposer qu’un automate généralisé ne
possède qu’un seul état initial et un seul état acceptant : si tel n’est pas le cas, il suffit d’ajouter à Q deux états i et
f ainsi que les transitions : δ(i, ε) = q pour tout q ∈ I et δ(q, ε) = f pour tout q ∈ F. L’automate (Σ, Q∪{i, f }, {i}, {f }, δ)
est alors équivalent à A. Remarquons en outre qu’avec cette construction il n’existe pas de transition vers i ni de
transition à partir de f .
Notons aussi qu’on peut supposer qu’entre deux états il n’existe qu’au plus une transition. En effet, deux
transitions δ(qi , e1 ) = qj et δ(qi , e2 ) = qj peuvent être remplacées par une seule : δ(qi , e1 + e2 ) = qj .

e1
e1 + e2
qi qj ⇐⇒ qi qj

e2

Le résultat suivant montre que le pouvoir expressif des automates n’est pas augmenté par cette généralisation :

Théorème. — Tout langage reconnu par un automate généralisé est rationnel.

Preuve. Considérons un automate généralisé A possédant un unique état initial i, un unique état final f et au
plus une transition par couple d’états, et raisonnons par récurrence sur le nombre d’états |Q|.
– Si |Q| = 2 l’automate A est de la forme suivante :

e
i f

et le langage reconnu par A est dénoté par e donc est rationnel.

– Si |Q| > 2, supposons le résultat acquis au rang précédent et considérons un état q ∈ Q \ {i, f }. Pour chaque
couple d’états (qi , qj ) tel que qi , q et qj , q on effectue la transformation suivante :

e4

q
e1 e2

e3 + e1 e4∗ e2
qi qj ⇐⇒ qi qj
e3

(avec le cas échéant e1 , e2 , e3 , e4 égal à ∅ si la transition correspondante n’existe pas).

Ceci permet d’éliminer totalement l’état q et donc d’obtenir un automate généralisé équivalent ayant un
état de moins, à qui on peut appliquer l’hypothèse de récurrence pour conclure.

Algorithme de Brzozowski et McCluskey

Appelé aussi algorithme d’élimination des états, il consiste à appliquer la démarche décrite dans la preuve
ci-dessus pour éliminer un par un les différents états d’un automate jusqu’à ne plus obtenir qu’un automate
généralisé à deux états qui fournira une expression rationnelle dénotant le langage reconnu par l’automate
initial.

[Link]
4.12 option informatique

Exemple. Considérons l’automate suivant :

a

q1
a b

q0 b q3
a
a
b
q2

On commence par ajouter un état initial et un état final :

a

q1
a b

ε q0 b q3 ε
i f
a
a
b
q2

On élimine l’état q2 :
a

q1
a b

ε q0 b + a2 q3 ε
i f

ba
On élimine l’état q1 :

ε q0 b + a2 + aa∗ b q3 ε
i f

ba
On élimine l’état q0 :

b + a2 + aa∗ b q3 ε
i f

ba
On élimine enfin l’état q3 :

(b + a2 + aa∗ b)(ba)∗
i f

Nous avons montré que l’automate reconnait le langage dénoté par (b + a2 + aa∗ b)(ba)∗ . Évidemment, l’expression
obtenue dépend de l’ordre dans lequel les éliminations ont été réalisées.
Automates 4.13

3.3 Propriétés des langages reconnaissables

Nous allons maintenant nous attacher à prouver des propriétés de stabilité des langages reconnus par un
automate : stabilité par complémentation et par intersection.

Théorème. — Les langages reconnaissables sont clos par complémentation.

Preuve. Soit L un langage reconnu par un automate déterministe complet A = (Σ, Q, q0 , F, δ), et L = Σ∗ \ L. Posons
A0 = (Σ, Q, q0 , Q \ F, δ) ; alors l’automate A0 reconnait L.
Remarque. Il est important que l’automate A soit complet car un blocage de A serait aussi un blocage de A0 .

Théorème. — Les langages reconnaissables sont clos par intersection.

Preuve. Soient L1 et L2 deux langages reconnus respectivement par les automates déterministes complets
A1 = (Σ, Q1 , q1,0 , F1 , δ1 ) et A2 = (Σ, Q2 , q2,0 , F2 , δ2 ). On pose Q = Q1 ×Q2 , q0 = (q1,0 , q2,0 ), F = F1 ×F2 et δ((q1 , q2 ), a) =
(δ1 (q1 , a), δ(q2 , a)). Alors A = (Σ, Q, q0 , F, δ) reconnait le langage L1 ∩ L2 .
En effet, considérons u ∈ Σ∗ et (q1 , q2 ) l’état auquel aboutit le chemin étiqueté par u (il ne peut y avoir de blocage
car les automates sont complets).
– Si u < L1 alors q1 < F1 donc (q1 , q2 ) < S ;
– si u < L2 alors q2 < F2 donc (q1 , q2 ) < S ;
– si u ∈ L1 ∩ L2 alors q1 ∈ F1 et q2 ∈ F2 donc (q1 , q2 ) ∈ F.

Sachant que le théorème de Kleene à prouvé l’équivalence entre langages rationnels et langages reconnaissables,
une conséquence importante de ces deux derniers résultats est que :
Les langages rationnels sont clos par complémentation et par intersection.
On notera que ce résultat n’est pas du tout évident si on s’en tient à la définition des expressions rationnelles
donnée dans le chapitre précédent.
À l’inverse les propriétés de stabilité par union, concaténation et passage à l’étoile de Kleene des langages
rationnels permettent d’en déduire que les langages reconnaissables sont clos par union, concaténation et
passage à l’étoile (cela dit, il n’est pas très compliqué de prouver ces propriétés en construisant les automates
associés à ces constructions ensemblistes).
Terminons cette section avec un dernier résultat de clôture :

Théorème. — Les langages reconnaissables sont clos par passage au miroir.

Preuve. Considérons un automate non déterministe A = (Σ, Q, I, F, δ) et définissons l’automate A0 = (Σ, Q, F, I, δ0 )

avec :
δ0 (q, x) = q0 ⇐⇒ δ(q0 , x) = q
(concrètement on inverse le sens des arcs de A).
Alors le langage reconnu par A0 est l’image miroir du langage reconnu par A.
Une conséquence du théorème de Kleene est que les langages rationnels sont eux aussi stables par passage au
langage miroir.

3.4 Lemme de l’étoile 7

On dispose désormais de deux manières de prouver qu’un langage est rationnel : en exhibant une expression
rationnelle qui le dénote ou un automate qui le reconnait. En revanche, pour montrer qu’un langage n’est pas
rationnel il peut être utile de disposer du résultat suivant :

Lemme (de l’étoile). — Si L est un langage rationnel il existe un entier k tel que tout mot m ∈ L de longueur
supérieure ou égale à k se factorise sous la forme m = uvw avec :

(i) |v| > 1 (ii) |uv| 6 k (iii) ∀n ∈ N, uv n w ∈ L.

7. Attention, ce résultat n’est pas explicitement au programme.

[Link]
4.14 option informatique

Remarque. Ce résultat est aussi connu sous le nom de lemme de pompage, dans le sens où le facteur v du mot m
peut être « pompé » un nombre quelconque de fois et produire ainsi des mots de L.
Rappelons que tout langage fini est rationnel et notons que pour ces derniers ce résultat est évident dès lors
qu’on considère un entier k strictement supérieur au plus long des mots de L. En revanche, lorsque L est de
cardinal infini il possède nécessairement des mots de longueur arbitrairement grande. Pour ces langages ce
résultat affirme que passé une certaine taille les mots de L sont toujours construits par répétition d’un facteur v
s’insérant au sein d’un mot uw de L.
Preuve. Considérons un automate fini déterministe A = (Σ, Q, q0 , F, δ) et k = |Q|. Soit m un mot de L tel que
a1 a2 ap
|m| > k. Le chemin q0 −→ q1 −→ q2 · · · −→ qp reconnaissant m implique p + 1 états donc passe nécessairement
deux fois par le même état qi = qj avec 0 6 i < j 6 k :
a1 ai aj ap
q0 −→ · · · −→ qi · · · · · · −→ qj −→ · · · −→ qp

Posons u = a1 · · · ai , v = ai+1 · · · aj et w = aj+1 · · · ap . Alors pour tout n ∈ N le chemin étiqueté par uv n w conduit à
l’état acceptant qp donc uv n w ∈ L.
Ce résultat est le principal utilisé pour prouver qu’un langage n’est pas rationnel mais attention, il n’exprime pas
une équivalence : il existe des langages non rationnels qui vérifient les conclusions du lemme de l’étoile.
Il existe plusieurs variantes du lemme de l’étoile ; dans la première version un facteur arbitraire est itéré ; la
version suivante itère un facteur qui se trouve dans une zone prédéterminée du mot, ce qui permet plus de
souplesse dans l’application de ce résultat :

Lemme (de l’étoile). — Si L est un langage rationnel il existe un entier k tel que tout mot m = uvw tel que |v| > k se
factorise sous la forme m = u(v1 v2 v3 )w avec :

(i) |v2 | > 1 (ii) |v1 v2 | 6 k (iii) ∀n ∈ N, u(v1 v2n v3 )w ∈ L.

Preuve. On applique la méthode décrite dans la preuve précédente uniquement après avoir parcouru le chemin
étiqueté par u.
n  o
Exemple. Le langage L = an bn  n ∈ N n’est pas rationnel. Supposons en effet les conclusions du lemme de
l’étoile vérifiées et posons u = ak , v = bk et w = ε. D’après le lemme précédent v se factorise en v = bk1 bk2 bk3 avec
k2 > 1 et on doit avoir : ∀n ∈ N, ak bk+nk2 ∈ L, ce qui est absurde.
n  o
Exemple. Si Σ possède au moins deux lettres le langage L = m2  m ∈ Σ∗ des carrés parfaits n’est pas rationnel.
Supposons en effet les conclusions du lemme de l’étoile vérifiées et posons m = abk . Le mot m2 se factorise
en m2 = uvw avec u = a, v = bk et w = abk . D’après le lemme ci-dessus il existe j > 1 tel que pour tout n ∈ N,
abk+nj abk ∈ L, ce qui est absurde.

4. Exercices
4.1 Automates finis déterministes

Exercice 1
Dans chacun des cas déterminer un automate reconnaissant sur l’alphabet {a, b} les langages
suivants :
1. L est le langage des mots contenant au moins une fois la lettre a ;
2. L est le langage des mots contenant au plus une fois la lettre a ;
3. L est le langage des mots contenant un nombre pair de fois la lettre a ;
4. L est le langage des mots admettant aba pour facteur ;
5. L est le langage des mots admettant aba pour sous-mot.

Exercice 2
Dessiner un automate fini déterministe sur l’alphabet {0, 1} qui reconnait les représentations
binaires des entiers divisibles par 5.
Dessiner un automate fini déterministe sur l’alphabet {0, 1} qui reconnait les représentations binaires des entiers
divisibles par 5, lorsque ceux-ci sont lus à partir du bit de poids le plus faible.
Automates 4.15


Exercice 3
Sur l’alphabet Σ = {a, b} déterminer un automate qui reconnait le langage des mots comptant au
moins deux occurrences de leur dernier caractère.

∗
Exercice 4
On considère l’alphabet Σ = {0, 1} et le langage L = 1(0 + 1) des mots qui commencent par 1.
Chaque mot u de L peut être considéré comme l’écriture binaire d’un entier n > 0. On note alors succ(u)
l’écriture binaire de n + 1.
n  o
1. On note L0 = u ∈ L  | succ(u)| = |u| . Définir un automate fini déterministe qui reconnait le langage L0 .

On considère le nmorphisme
 o h qui double chaque lettre d’un mot, c’est-à-dire celui défini par h(0) = 00 et
h(1) = 11, et E = h(u)  u ∈ L .
2. Définir un automate fini déterministe qui reconnait le langage E.
Pour tout mot u ∈ L0 on note s(u) le mot n qui  entrelace
o u et succ(u) : si u = a1 a2 · · · an et succ(u) = b1 b2 · · · bn alors
s(u) = a1 b1 a2 b2 · · · an bn . On pose S = s(u)  u ∈ L0 .
3. Trouver deux langages L1 et L2 tels que S = EL1 L2 et en déduire un automate fini déterministe qui
reconnait le langage S.


Exercice 5
Rédiger une fonction Caml qui calcule un automate émondé équivalent à un automate passé en
paramètre.

4.2 Automates non déterministes


Exercice 6
Déterminiser les automates suivants : a

q1
a, b a, b a

b a, b b
q0 q1 q2 q0 b
b

b
q2


Exercice 7
Un barman aveugle joue au jeu suivant avec un client : il a devant lui un plateau sur lequel sont
disposés quatre verres formant un carré. Chacun de ces verres peut être retourné ou non, sans que le barman ne
le sache. Le but de ce dernier est de s’arranger pour que tous les verres soient tournés dans le même sens. Pour
ce faire, il peut à chaque tour choisir l’une des trois actions suivantes :
– tourner l’un des verres ;
– tourner deux verres voisins ;
– tourner deux verres opposés ;
mais pour corser la difficulté, le client peut tourner le plateau d’un nombre quelconque de quart de tours entre
chacune des actions du barman. Le jeu s’arrête dès qu’une des deux positions gagnantes est atteinte.
1. Montrer qu’on peut restreindre à quatre le nombre de configurations différentes, puis représenter les
actions possibles du jeu par un automate non déterministe.
2. Déterminiser cet automate et en déduire une stratégie gagnante pour le barman.

[Link]
4.16 option informatique


Exercice 8
On considère l’automate non déterministe A défini par la figure suivante :
b a b
q4 q1 q2 q5

b b b
a
a, b b

b
q0 q3

b
a

Le transposé de A, note T (A), est l’automate dans lequel toutes les flèches de A ont été inversées (y compris les
états initiaux et acceptants).
Le déterminisé de A, noté D(A) est l’automate déterministe obtenu par l’algorithme de déterminisation du
cours.
Construisez A0 = D(T (A)) puis A00 = D(T (A0 )) et justifier que A et A00 reconnaissent le même langage.
Remarque. Cette méthode, appelée minimisation de Brzozowski, permet d’obtenir un automate déterministe
équivalent à A et de taille minimale.

Exercice 9
Donner un automate non déterministe reconnaissant les mots possédant le facteur abba, et le
déterminiser. Appliquer ensuite l’algorithme KMP pour obtenir un automate déterministe reconnaissant ce
même langage.

4.3 Théorème de Kleene


Exercice 10
Appliquer l’algorithme de Berry-Sethi pour déterminer l’automate de Glushkov associé à
l’expression rationnelle (a + c)∗ (abb + ε).

Exercice 11
Construire un automate reconnaissant le langage des mots m sur Σ = {a, b} tels que |m|a soit un
multiple de 3, et en déduire une expression rationnelle dénotant ce langage.

∗
Exercice 12
On considère le langage L sur l’alphabet Σ = {a, b} dénoté par l’expression (ab+abb+aa) . Trouver
un automate à quatre états qui reconnait L, puis construire un automate qui reconnait le complémentaire L.

Exercice 13
L’exercice 4 montre qu’il est possible de décider si le langage reconnu par un automate est vide :
il suffit de l’émonder puis de vérifier si les états acceptants font partie des états utiles. En déduire qu’il est
possible de décider si deux expressions rationnelles dénotent le même langage.

Exercice 14
On note pref(L) l’ensemble des préfixes des mots de L, suff(L) l’ensemble des suffixes, fact(L)
l’ensemble des facteurs. Montrer que si L est rationnel il en est de même de ces trois langages.
 √ n  o
Exercice 15
On rappelle que si L est un langage sur un alphabet Σ alors L = u ∈ Σ∗  u 2 ∈ L .
√
Montrer que si L est rationnel il en est de même de L.

Exercice 16
On rappelle que le quotient gauche de deux langages K et L est défini par :
n  o
K−1 L = v ∈ Σ∗  ∃u ∈ K tel que uv ∈ L .

Montrer que si L est un langage rationnel il en est de même de K−1 L (on notera qu’on ne fait pas d’hypothèses
particulières sur K).
Automates 4.17

4.4 Lemme de l’étoile


Exercice 17
Montrer que les langages suivants ne sont pas rationnels :
n  o n  o n  o
L1 = ai bj  i < j L2 = u ∈ {a, b}∗  |u|a = |u|b L3 = ap  p est premier


Exercice 18
Montrer que le langage de Dick n’est pas rationnel. Caml est-il un langage rationnel ?

8 ∗
Exercice 19
Soit Σ un alphabet ayant au moins deux lettres, et L l’ensemble des palindromes de Σ . Montrer
que L n’est pas un langage rationnel.

Exercice 20
On note L l’ensemble des mots sur l’alphabet Σ = {0, 1} qui correspondent à l’écriture binaire
d’un nombre premier. On rappelle qu’un nombre de Mersenne est un nombre premier de la forme Mn = 2n − 1.
On conjecture que ceux-ci sont en nombre infini, mais ceci n’a pas encore été prouvé.
Montrer que si cette conjecture est vraie alors L n’est pas un langage rationnel.

8. Un palindrome est un mot égal à son image miroir.

[Link]