Mots, langages et Automates

Bruno Mery (Doctorant, LaBRI bureau 123, [email protected])
Université de Bordeaux, année 2007-2008
Informatique Théorique 1
INF154T Groupe CSB5A2
Travaux Dirigés
Mots, langages et Automates
1
Mots et expressions rationelles
Rappels
– Notation : on notera conventionellement a, b, c . . . (éventuellement
avec un ou plusieurs indices i) les lettres d’un alphabet, généralement
noté A.
– De même, on notera u, v, w . . . (éventuellement indicés) les mots d’un
alphabet A, c’est-à-dire composés d’un nombre fini (éventuellement
nul) de lettres de A, et on note u = a1 . . . an pour définir un mot, |u| = n
pour définir sa longueur, |u|ai = k pour dire que le mot u comporte
k fois la lettre ai , u ∈ A∗ pour déterminer que u est un mot fini de
l’alphabet A.
– On note ε le mot vide, ou mot de longueur nulle, qui est l’élément neutre
pour la concaténation (εu = uε = u, ∀u).
– Pour un ensemble A donné, l’adjonction d’une astérisque en exposant se prononce ”A étoile de Kleene”, et on a par définition A∗ =
S
∗
i
0≤i<+∞ A (un élément de A est donc bien un k-uple avec k ∈ N
d’éléments de A, et donc une séquence d’éléments de A).
– Un langage de mots sur l’alphabet A est un élément L ∈ P(A∗ ) – autrement dit, un ensemble de mots sur cet alphabet.
– Une expression rationnelle e décrivant un langage sur l’alphabet A est
définie inductivement comme suit :
– soit e est réduite à une lettre, auquel cas elle représente le mot composé de cette lettre (e = a ∈ A),
1
– soit e est la concaténation de deux expressions e0 et e00 , et elle
représente les mots qui sont la concaténation de deux expressions
(e.g. e = ab, (a, b) ∈ A2 : le mot ab de longueur 2),
– soit e est l’union de deux expressions e0 et e00 , auquel cas elle
représente l’ensemble des mots représentés par e0 ou e00 (e.g. e =
u + v : le mot u et le mot v),
– soit e est l’étoile de Kleene d’une expression e0 , auquel cas elle
représente l’ensemble des mots représentés par e0 autant de fois
que souhaité (y compris aucune). Par exemple, a∗ est l’ensemble
{ε, a, aa, aaa, . . .}.
– Exemples :
– a(a + b)∗ b est l’ensemble des mots de {a, b}∗ commençant par a et
finissant par b.
– ((a + b)(a + b))∗ est l’ensemble des mots de {a, b}∗ de longueur
paire.
– A∗ uA∗ est l’ensemble des mots de A∗ ayant u pour facteur.
Exercice 1 Soit A = {a, b, c}. Donner des expressions rationelles pour chacun des langages suivants :
1. L’ensemble des mots de A∗ qui comptent au moins une fois la lettre a
2. L’ensemble des mots de A∗ qui ne commencent pas par la lettre a.
3. L’ensemble des mots de A∗ contenant au moins un a et un b, tels que
la première occurrence de a précède la première occurrence de b.
Corrigé 1
1. A∗ aA∗
2. (b + c)A∗
3. c∗ a(a + c)∗ bA∗
2
2
Automates déterministes
Rappels
– Les Automates sont une classe de formalismes permettant de
modéliser divers phénomènes, dont certains langages.
– Ici, on parlera d’automates d’états finis (c’est-à-dire représentables avec
un nombre fini d’états), définis par rapport à un alphabet A.
– Un automate A est défini par une collection d’états Q = {q0 , q1 . . .}, et
un ensemble de transitions sur ces états T = {t0 ,t1 , . . .}.
– On distingue, dans Q, des états que l’on qualifie d’initiaux, et des états
que l’on qualifie de terminaux (rien ne s’oppose à ce qu’un état initial
soit aussi terminal.
– Une transition t associe un état q (dit ”de départ”) à un état q0 (dit
”d’arrivée”), et est étiquetée par une lettre a ∈ A.
– Un automate A est dit déterministe quand, pour tout état q, il n’y a au
plus qu’une transition émanant de cet état et étiquetée par une même
lettre a ∈ A. Dans un automate déterministe, il n’y a qu’un et un seul
état initial.
– Un automate déterministe est complet quand, pour tout état q, il y a
exactement une transition étiquetée par chacune des lettres de A.
– Un mot u de A∗ est reconnu par l’automate fini déterministe A s’il
existe un chemin reliant un état initial à un état terminal, dont les
étiquettes des transitions sont constituées par les lettres du mot u
(dans le même ordre).
– Le langage reconnu par l’automate A est l’ensemble des mots reconnus par A .
– Un langage L est reconnaissable s’il existe un automate fini déterministe
qui le reconnaisse.
– Ces formalités mises à part, un automate est surtout représenté par
un graphe, dans lequel les états sont des nœuds et les transitions, des
arcs. On signale les états initiaux par une double flèche entrante, les
terminaux par une double flèche sortante, et on peu optionellement
étiqueter les états.
3
Exercice 2 Donner une expression rationelle représentant les langages reconnus par chacun des automates suivants :
F IG . 1 – Un automate
F IG . 2 – Un autre automate
Corrigé 2
1. Fig. 1 : (ab)∗ (b + aa + ε)
2. Fig. 2 : (ab) + (aba + b)a(aa)∗
Exercice 3 Donner, pour chaque langage sur A = {a, b, c} donné par les
expressions rationelles suivantes, un automate fini déterministe qui le reconnaisse :
1. (a + b)∗ ca∗
2. A∗ (b + c)
3. A∗ aA∗ bA∗
Corrigé 3 Voir figure 3. Penser au déterminisme des automates obtenus. . .
4
F IG . 3 – Les automates de l’exercice 3
Exercice 4 Donner des automates finis déterministes sur {a, b} reconnaissant les langages. . .
1. l’ensemble des mots de longueur paire,
2. l’ensemble des mots se terminant par a,
3. l’ensemble des mots contenant au plus une occurrence de la lettre a,
4. l’ensemble des mots contenant au moins deux occurrences de leur
dernière lettre,
5. l’ensemble des mots ayant pour préfixe aba,
6. l’ensemble des mots ayant pour suffixe aba,
7. l’ensemble des mots ayant pour facteur aba,
8. l’ensemble des mots comportant un nombre pair de a et un nombre
impair de b.
Corrigé 4 Les automates des 1, 2 et 3 sont donnés en Fig. 4. Le 4 (le plus
long et délicat, sans dessin. . . ) peut être décrit comme suit : un état initial,
un état ”a”, un état ”b”, un état ”ab”, un état ”bb” (final), un état ”aa”
(final), un état ”abb” (final), un état ”aab” (final), un état ”aabb” (final).
Transitions : a de initial vers ”a”, b de initial vers ”b”, a de ”a” vers ”aa”, b
5
de ”a” vers ”ab”, a de ”b” vers ”ab”, b de ”b” vers ”bb”, boucle a sur ”aa”,
transition b de ”aa” vers ”aab”, a de ”ab” vers ”aab”, b de ”ab” vers ”abb”,
a de ”bb” vers ”abb”, boucle b sur ”bb”, boucle a sur ”aab”, transition b
de ”aab” vers ”aabb”, boucle b sur ”abb”, transition a de ”abb” à ”aabb”,
boucles a et b sur ”aabb” (ouf). Les automates 5, 6, 7 sont donnés Fig. 5
(le corps est similaire, les conditions préfixe-suffixe-facteur influent sur les
retours autorisés). Enfin, l’automate 8 est donné Fig. 6 : il suffit de conserver
en mémoire simultanément le nombre de a modulo 2 et le nombre de b
modulo 2.
F IG . 4 – Premiers automates de l’exercice 4
6
F IG . 5 – Exercice 4 : préfixe, suffixe, facteur
F IG . 6 – Exercice 4 : pair / impair
7
3
Quelques algorithmes sur les automates
Rappels
– Compléter un automate déterministe :
– Pour compléter un automate déterministe, s’il n’est pas déjà complet, il suffit de rajouter un état (non final, non initial) ”puits”, ne
comportant aucune transition sortante mis à part une boucle pour
chaque lettre de l’alphabet concerné, et vers lequel on envoie toutes
les transitions ”manquantes”.
– Intersection de langages reconnaissables :
– Soient L1 , L2 des langages sur A∗ reconnus respectivement par les
automates finis déterministes complets A1 et A2 . Alors L1 ∩ L2 est
reconnaissable, par l’automate produit A1 × A2 .
– A1 × A2 est construit comme suit : les états sont des couples d’états
(q, r) où les q sont des états de A1 et r, des états de A2 . Les états
initiaux sont les couples d’états respectivement initiaux dans les
deux automates, de même pour les états finaux.
– Il y a une transition de (q, r) à (q0 , r0 ) par la lettre ai dans l’automate
produit si, et seulement si, il y a une transition de q à q0 et de r à r0
par la même lettre ai dans les automates de départ.
– Des simplifications sont possibles (notamment dans le cas des états
”puits”).
– Automates non déterministes avec ε-transitions :
– Un automate non déterministe est analogue d’un automate déterministe,
à la différence près qu’un état peut posséder plusieurs transitions
sortantes étiquetées par une même lettre, et peut avoir plusieurs
états initiaux. Il peut également utiliser des transitions étiquetées
par ε, qui doivent se comprendre comme ”on peut passer d’un état
à un autre sans consommer de lettre”.
– Théorème de Kleene : les langages qui sont reconnus par des automates à états finis non déterministes avec ε-transitions sont aussi
reconnus par des automates à états finis déterministes complets,
et représentables par des expressions rationnelles (les réciproques
sont vraies). On appelle cette classe de langage langages rationnels
(ou parfois langages réguliers).
– Déterminisation d’un automate :
– Le processus de déterminisation d’un automate fini non-déterministe
consiste à construire, pas à pas, l’ensemble des états et l’ensemble
des transitions de l’ (d’un) automate fini déterministe équivalent.
– Le principe est le suivant : pour chaque état de l’automate non
8
déterministe, on repère la classe d’états accessible par un ensemble
de transitions étiquetées par la même lettre, qui formera un état
dans l’automate déterministe ; on identifie ensuite les transitions
nécessaires à la reproduction du comportement de l’automate de
départ.
– Plus précisément, soit une classe d’états représentant Q0 l’ensemble
des états initiaux qinit1 , qinit2 , . . . : ce sera l’état initial du nouvel
automate. Soit ensuite la classe Q0:a qui regroupe l’ensemble des
états accessibles depuis les états initiaux par toutes les transitions
étiquetées par a. C’est un état du nouvel automate, et on a une transition (unique) partant de Q0 , dirigée sur Q0:a , étiquetée par a. On
répète pour toutes les lettres de l’alphabet concerné.
– Par la suite, on ré-itère ce procédé pour tous les nouvelles classes
d’états que l’on définit, jusqu’à obtenir un ensemble de classes,
et de transitions entre ces classes, qui soit stable. On distingue et
confond les classes suivant leur comportement face à la réception
des lettres. . . Les états finaux sont les classes dont un membre était
final dans l’automate de départ.
– On peut prouver par induction que cette procédure termine en
O(2n ), pour un automate non déterministe de n états.
– Union de langages reconnaissables :
– Soit deux langages reconnaissables par deux automates finis
déterministes A1 et A2 .
– Alors l’union des deux langages est reconnue par l’automate fini
non déterministe A1+2 , construit en prenant l’union des deux automates, avec pour états initiaux les états initiaux de chacun des automates de départ, et un unique état final, nouveau, accessible depuis
chacun des anciens états finaux par des ε-transitions (construction
triviale).
– Alors cette même union des langages est aussi reconnaissable par
un automate fini déterministe, formé par la déterminisation de
A1+2 .
9
Exercice 5 Complèter les automates suivants (sur A = {a, b, c}). À quelles
expressions rationnelles correspondent-ils ?
(Voyez les figures 7, 8 et 9.)
F IG . 7 – Automate 1/3, exercice 5
F IG . 8 – Automate 2/3, exercice 5
10
F IG . 9 – Automate 3/3, exercice 5
Corrigé 5 Dessins sur commande (peu fondamentaux). Il s’agit simplement de rajouter un état puits, avec une boucle a, b, c et aucune autre transition sortante, et d’y faire arriver les quelques transitions manquantes. En
1 : a et c depuis l’état du bas et celui du haut, a, b, c pour le central ; en
2 : c de tous les états et a, b, c de l’état final ; en 3 : a, c de l’état en bas à
gauche, b, c de l’état en haut à droite. Des expressions représentant ces langages sont : pour 1, (a + b + c)b, pour 2 : (a(ba)∗ a + b(ab)∗ b)b∗ a, pour 3 :
((aa + bb)∗ cc∗ (a + b))∗ (aa + bb)∗ cc∗ . La complétation1 est instantanée et peu
utile en pratique, sauf pour la résolution de l’exercice suivant.
Exercice 6 Soit A un automate fini déterministe complet. Pour le manipuler, on dispose des primitives initial(A), renvoyant l’état q0 initial, final(q) qui renvoit vrai quand l’état q est final, apply(q, a) qui,
en appliquant la transition étiquetée par la lettre a à l’état q, renvoie l’état
d’arrivée. Considérons un mot u donné sous la forme d’un tableau u[0],
u[1]... de longueur n.
Donner alors un algorithme recon(A, u, n) qui renvoie vrai si le
mot u de longueur n est reconnu par l’automate A , faux sinon.
Quelle est sa complexité (selon n) en temps ? en espace ?
1 Si
quelqu’un dispose d’un synonyme correct pour rendre complet qui ne fasse pas
référence au complément, je suis preneur.
11
Corrigé 6 Avec une définition récursive :
recon(A, u, n) = apply_w(initial(A), u, n)
apply_w(q, u, n) =
if n=0 final(q)
else apply_w(apply(q, u[0]), &u[1], n-1)
(Où &u[1] est le mot u pris à partir de la deuxième lettre.) La complexité
est de O(n) en temps, O(1) en espace, quel que soit l’automate (qui, lui,
occupe une complexité de Kolmogorov de O(|Q| + |T |)). On peut faire les
démonstrations par induction si nécessaire.
Exercice 7 Le miroir d’un mot u est le mot composé des mêmes lettres,
écrites en ordre inverse de celles de u. En supposant que le langage L est
reconnaissable par un automate fini déterministe complet A et que ce dernier dispose d’un unique état final, donner (l’idée d’) une méthode pour
construire un automate reconnaissant l’ensemble des miroirs des mots de L
(le langage miroir de L). Dans le cas général, le langage miroir d’un langage
reconnaissable est-il reconnaissable ?
Corrigé 7 Idée de procédure : on échange l’état final et l’état initial, puis
on inverse les directions des transitions constructives (i.e., toutes sauf celles
menant à un état ”puits”). Il y a des précisions à apporter pour que cette
construction soit déterministe (des problèmes avec les transitions entrantes
étiquetées par la même lettre). . . L’important est que, dans le cas général,
cela marche aussi, mais peut donner des automates non déterministes (en
particulier à plusieurs états initiaux) : il suffit alors de déterminiser le
résultat.
Exercice 8 Pour chacune des paires d’automates suivantes (sur A = {a, b}),
construire un automate fini déterministe reconnaissant l’intersection des
langages définis au départ. Donner ensuite une expression rationelle correspondant à cet automate.
(Voyez les figures 10, 11 et 12.)
12
F IG . 10 – Automate 1/3, exercice 8
F IG . 11 – Automate 2/3, exercice 8
13
F IG . 12 – Automate 3/3, exercice 8
Corrigé 8 Procédure graphique. L’idée est d’appliquer directement l’algorithme donné dans les rappels, en envoyant les transitions surnuméraires
sur un unique état puits (qu’on peut éventuellement supprimer à la fin) ;
on a des automates qui disposent de paires des états des automates initiaux (penser à numéroter les automates avant. . . ). Expressions rationelles
correspondant : 1 : aaba, 2 : a + ab + ba (les mots comportant exactement
un a et au plus un b), 3 : beaucoup trop complexe dans ce cadre (mots de
longueur paire comportant obligatoirement le facteur aaa et plus aucun a
après ce facteur). Automates représentés en Fig. 13, 14 et 15.
14
F IG . 13 – Automate 1, Exercice 8
F IG . 14 – Automate 2, Exercice 8
15
F IG . 15 – Automate 3, Exercice 8
16
Exercice 9 Pour chacun des automates non déterministes suivants (sur
A = {a, b}), appliquer la procédure de déterminisation2 : (Voyez les figures
16, 17 et 18.)
F IG . 16 – Automate 1/3, exercice 9
2 Telle
quelle, sans optimisations. Il est fortement conseillé d’étiqueter les états avant de
commencer !
17
F IG . 17 – Automate 2/3, exercice 9
18
F IG . 18 – Automate 3/3, exercice 9
19
Corrigé 9 L’idée est d’appliquer mécaniquement l’algorithme de déterminisation,
pour s’y familiariser. Je donne le tableau de construction des états et transitions à chaque fois. . . (en supposant les états d’origine numérotés) :
1 : Mise en bouche, on pourrait remarquer que A∗ aA∗ aA∗ est rigoureusement équivalente à b∗ ab∗ aA∗ .
0
(0, 1)
(0, 1, 2)
a
(0, 1)
(0, 1, 2)
(0, 1, 2)
b
0
(0, 1)
(0, 1, 2)
Voir Fig. 19.
F IG . 19 – Automate 1, Exercice 9
2 : Moins immédiat mais assez rapide.
0
(0, 1)
(2, 3)
(0, 3)
(0, 1, 3)
a
(0, 1)
(0, 1)
(0, 3)
(0, 1, 3)
(0, 1, 3)
20
b
(2, 3)
(2, 3)
F IG . 20 – Automate 2, Exercice 9
Voir Fig. 20.
3 : Volontairement abscons. On a ici des ε-transitions fondamentalement inutiles (on traite cela en posant que tout ensemble d’états comprenant 4 ou 5 contient aussi 6), deux états de départ, et il est plus facile de
visualiser quoi que ce soit sur l’automate de départ que celui d’arrivée
(qui n’est pas du tout minimal). Le langage est ((aa + bb)A∗ ab(a + b))∗ (aa +
bb)A∗ ab.
(0, 1)
2
3
(4, 6)
(5, 6)
(6, 7)
6
(6, 8)
(6, 7, 0, 1)
(6, 0, 1)
(6, 7, 2)
(6, 8, 3)
(6, 3)
(6, 7, 4)
(6, 1, 5)
a
2
(4, 6)
(6, 7)
(6, 7)
(6, 7)
(6, 7)
(6, 7, 0, 1)
(6, 7, 2)
(6, 7, 2)
(6, 7, 4)
(6, 7, 0, 1)
(6, 7)
(6, 7)
(6, 7)
b
3
(5, 6)
6
6
(6, 8)
6
(6, 0, 1)
(6, 8, 3)
(6, 3)
(6, 8)
(6, 1, 5)
(6, 5)
(6, 8)
(6, 3)
(Note : les classes d’états sont des ensembles, donc (6, 5) et (5, 6) représentent
la même classe.) Voir Fig. 21.
21
F IG . 21 – Automate à ne pas dessiner souvent. . .
22
Exercice 10 Pour chaque expression rationnelle (sur A = {a, b}), construire
un automate déterministe correspondant, éventuellement en construisant
d’abord un automate non déterministe.
1. ba + (a + bb)a∗ b
2. (bb + a)∗ (aa + b)∗
3. (aa)∗ + (aaa)∗
4. (aa + bb + (ab + ba)(aa + bb)∗ (ab + ba))∗
Corrigé 10 Dans certains cas, il est plus rapide de faire l’union de plusieurs automates et de déterminiser le résultat. C’est le cas pour le premier (qui est assez simple). . . Pour le troisième, il suffit de conserver en
mémoire simultanément la longueur du mot modulo 2 et 3 (ce qui nécessite
6 états), et il est beaucoup plus rapide de concevoir directement un automate déterministe pour le dernier cas (l’union des sous-parties ne posant
pas de problèmes).
Le deuxième automate est le plus long à réaliser. On peut explorer
toutes les possibilités par un automate non déterministe (en donnant des
transitions avec a si on suppose qu’on se trouve dans la première partie, a
si on se suppose dans la deuxième, etc.), et déterminiser le résultat : c’est
long. On peut aussi déterminer les motifs qui ne sont pas dans le langage
(bab, baaa, . . . ), faire un automate et donner le complémentaire. Ou encore
avoir la bonne intuition directement.
Exemples de corrections en Fig. 22, 23, 24, 25.
23
F IG . 22 – Automate 1, Exercice 10
F IG . 23 – Automate 2, Exercice 10
24
F IG . 24 – Automate 3, Exercice 10
F IG . 25 – Automate 4, Exercice 10
25
4
Interlude : exemples concrets
Les automates finis, déterministes ou non, sont certes un moyen
de représenter graphiquement une certaine classe de langages. Plus
concrètement, il s’agit également d’une forme de machines d’états finis, servant à modéliser de nombreuses situations pour formaliser une intelligence
artificielle élémentaire (cas d’un ennemi de jeu vidéo des années 90, Fig. 26),
ou pour mettre sur le papier un protocole de communication (cas d’un protocole élémentaire d’un serveur, Fig. 27). En général, on utilisera des formalismes plus spécialisés (transducteurs, réseaux de Pétri, ou formalismes
dédiés comme UML. . . ), mais les automates sont un bon point de départ –
à ceci près qu’il n’y a généralement pas d’état final à proprement parler, les
mécanismes devant théoriquement fonctionner en boucle sauf interruption
manuelle. Plus prosaı̈quement, on utilise aussi souvent les automates pour
reconnaı̂tre certains motifs comme :
– une adresse email valide (pour un formulaire en ligne),
– une somme supérieure ou égal à un certain prix, exprimée en pièces
de différentes valeurs (pour un distributeur),
– un score correct de match de rugby (pour un tableau de scores),
– etc.
F IG . 26 – Routine gérant un personnage de jeu – les états donnent le comportement du personnage, les lettres sont les actions possibles du joueur.
26
F IG . 27 – Boucle principale, schématisée, d’un serveur. Les états sont les
actions en cours, les lettres sont les commandes reçues.
Exercice 11 Donner un pseudo-automate modélisant le processus (très
simplifié) d’attribution d’un marché public : lorsqu’un besoin se fait sentir, un projet est déposé, sur lequel l’autorité compétente reçoit un certain
nombre de candidatures, fait connaı̂tre son choix à une certaine date, et
charge le lauréat de la réalisation concrète.
Corrigé 11 Simple suggestion : états ”attente” (l’autorité est à l’écoute des
besoins) avec boucle, transition ”besoin” (un besoin a été signalé) vers un
état ”projet” (un appel à projets est lancé, avec les contraintes de réalisation
et une limite de temps), qui dispose d’une boucle ”dépôt de candidatures”
et d’une transition ”date limite” (on atteint le temps limite) vers un état
”réalisation” (le projet retenu est réalisé, s’il y en a un), qui dispose d’une
transition ”fin” vers l’état ”attente”.
Exercice 12 Donner un automate validant le format des adresses postales
simples (numéro voie, code postal ville) sur l’alphabet A = Aa ∪ An ∪ {, }, Aa
étant l’ensemble des lettres classiques (y compris majuscules, accents. . . et
les caractères point et espace), An , l’ensemble des chiffres.
27
Corrigé 12 Il suffit d’implémenter l’expression rationnelle A∗n A∗a , (A, )∗ A∗n A∗a
(la partie entre parenthèses est destinée aux options du type ”résidence,
escalier, appartement, boı̂te postale. . . ” et est optionnelle).
28
5
Minimisation d’un automate déterministe
Rappels
– Un théorème du cours (revu plus loin) précise, entre autres, que, pour
tout automate fini reconnaissant le langage L, il existe un automate
fini déterministe complet reconnaissant le même langage L tel que le
nombre d’états soit minimal. On appel cet automate l’automate minimal
reconnaissant L ; il est unique à isomorphisme près3 .
– La construction de l’automate minimal d’un langage peut se faire à
partir d’un automate fini déterministe complet existant, selon une
méthode qui analogue à l’algorithme de déterminisation.
– Cette méthode consiste à dégager des classes d’états équivalents du
point de vue de la reconnaissance du langage, c’est-à-dire dont la fusion ne changera pas la production de l’automate.
– On procède par raffinements successifs :
– au départ, on distingue deux classes d’états : les états terminaux et
les autres.
– Ensuite, à chaque étape, on choisit une lettre a de l’alphabet et une
classe K = {q, . . .}. On partitionne K suivant la classe cible par a.
(Par exemple, supposons qu’à la première étape nous ayons 0, 1, 2
comme états non terminaux, 3, 4 comme états terminaux, et que a
envoie 0 sur 1, 1 sur 1 et 2 sur 3 dans l’automate de départ ; alors, à
la deuxième étape, on distinguera les classes {0, 1}, {2} et {3, 4}.)
– On itère le procédé pour chaque lettre et chaque classe, jusqu’à
ce que ces dernières soient stables. L’automate est alors minimisé,
l’état initial est celui qui comporte l’état initial de départ, les états
terminaux sont ceux qui comportent un des états terminaux de
départ.
Exercice 13 Minimiser à la volée les automates suivants (sur A={a, b})
(Fig. 28, 29, 30) :
3 C’est-à-dire
que les états peuvent avoir différentes étiquettes, être placés
différemment. . . mais qu’il s’agira toujours du même automate du point de vue de sa
matrice de transitions.
29
F IG . 28 – Automate à minimiser 1/3
F IG . 29 – Automate à minimiser 2/3
30
F IG . 30 – Automate à minimiser 3/3
Corrigé 13 On aura reconnu, sous d’habiles déguisements, le langage
AA∗, le langage des mots de longueur paire, et le langage des mots ayant
aaa pour suffixe. Dans les deux premiers cas, la minimisation est directe (il
n’y a que deux états correspondant aux terminaux et non-terminaux), dans
le dernier, il y a quelques étapes (pour un total de 5 états, dont un puits).
31
6
Propriétés des langages rationnels
Rappels
– La classe des langages rationelle est close par les opérations suivantes : complément, étoile de Kleene, concaténation, union, intersection, différence, miroir, image par un homomorphisme. Autrement
dit, si on construit un langage à partir de langages rationnels et de
ces opérations, il sera aussi rationnel ; par contraposée, si un langage
non rationnel est réalisé à partir d’une de ces opérations, alors un des
langages de départ n’était pas rationnel non plus.
– Lemme d’Arden : il existe une méthode pour résoudre certaines
équations sur les langages rationnels. Notamment pour X = A · X ∪ B,
avec A, B deux langages rationnels, la solution est unique : X = A∗ · B.
– Lemme de pompage (ou lemme de l’étoile, pumping lemma. . . ) : soit L
un langage rationnel. Alors il existe un entier N pour lequel, pour tout
mot u ∈ L tel que u ≥ N, u puisse s’écrire xvy (où x, v, y sont respectivement préfixe, facteur et suffixe de u), avec v 6= ε, et tel que xv ∗ y ∈ L.
Autrement dit, à partir d’une certaine longueur, un motif se répète (ce
qui est normal : un automate à états finis ne peut produire des mots
de longueur arbitraire qu’avec des boucles ou retour en arrière). Ce
lemme permet, par contraposée, de prouver qu’un langage n’est pas
rationnel, en prouvant qu’un tel nombre ne peut exister.
– Résidus (ou résiduels) d’un langage : le résidu d’un langage L pour un
mot u donné est le langage formé de l’ensemble des v tels que uv ∈ L.
On le note u−1 L, ou parfois L(u). L’ensemble des résidus de L pour
l’alphabet A est l’ensemble des u−1 L pour u ∈ A∗ .
– Théorème de Myhill-Nerode : un langage L est reconnaissable si et seulement s’il n’a qu’un nombre fini de résidus distincts.
– Le théorème de Myhill-Nerode permet de justifier la minimisation
des automates. Le nombre d’états de l’automate minimal d’un langage L est le nombre de ses résidus distincts.
– Ce théorème a deux applications : utiliser les résidus pour calculer
directement l’automate minimal d’un langage à partir d’une description ou d’une expression rationnelle (voir le cours d’Anne Dicky), et
surtout prouver, par contraposée, qu’un langage n’est pas rationnel
(il suffit de donner un ensemble infini de résidus distincts).
32
Exercice 14 (Difficile sans le cours.) Prouver que les langages suivants ne
sont pas rationnels :
1. {ww, w ∈ L, L rationnel et infini}
2. {an bn cn , n ∈ N}
3. {u ∈ {a, b, c}∗ /|u|a = |u|b = |u|c }
4. {a p , p premier}
Corrigé 14 (On peut utiliser le cours d’Anne Dicky pour avoir des idées
plus précises sur la démarche à suivre.)
1. (Presque immédiat.) Myhill-Nerode : soit u un mot de L. Alors u−1 L =
{u}. L étant un langage infini, il y a une infinité de résidus distincts
pour le langage, il n’est pas rationnel (et il en sera de même pour tous
les langages à copie).
2. (Inspiré de {an bn }.) Myhill-Nerode : examinons les résidus du langage pour abc, aabbc, . . . an bn c : ils forment la suite {ε}, {c}, {cc}, . . . , {cn }
qui sont deux à deux distincts. Il existe donc un nombre infini de
résidus distincts pour le langage (et il en sera de même pour tous les
langages à compteurs).
3. (Proche du cours.) Clôture : si le langage était rationnel, alors son
intersection avec a∗ b∗ c∗ , {an bn cn } le serait aussi, ce qui est faux (vu
plus haut).
4. (Cours.) Lemme de pompage : Supposons a p décomposable en xvy
avec v 6= ε et xv∗ y ⊆ L. Alors, pour p suffisamment grand, ∃q = |x| +
|y|/, ∀n ≥ 0, q+n(p−q) = |xvn y|premier. Ainsi on aurait q+(1+ p)(p−q)
un nombre premier, or cette expression est décomposable en p(1+ p−
q) : contradiction, a p n’est pas décomposable de cette manière, donc
n’est pas rationnel.
33
7
Automates et langages : exercices bonus
Exercice 15 Simplifier (factoriser) les expressions rationelles suivantes :
1. ((a + aab)∗ + (a + aaa)∗ )∗
2. (ab + ba)(abb + bab)
3. a∗ + (aba + baa + aab + abb + aaa + bba + bab + bbb)
Corrigé 15
1. (a(ab + ε)∗
2. (ab + ba)2 b
3. a∗ + A3
Exercice 16 Pour chacun des langages L définis par les expressions rationnelles suivantes, donner un automate reconnaissant A∗ − L (pour A =
{a, b}) :
1. a
2. (aba)∗
3. (ab + ba + a∗ bbb)∗
Corrigé 16 Pas de dessins cette fois ci. La construction est simple : soit un
automate fini déterministe complet : tout mot de A∗ donne un calcul dans
cet automate qui s’achève sur un état donné. Si cet état est terminal, le mot
appartient au langage reconnu par l’automate, sinon, non. Pour avoir les
mots du langage complémentaire, il suffit donc d’inverser les rôles : les
anciens terminaux de l’automates sont non terminaux, les anciens non terminaux sont terminaux. La construction est donc : construire un automate
déterministe pour L, le complèter, inverser états terminaux et non terminaux pour obtenir un automate reconnaissant A∗ − L (trivial en 1, facile en
2, plus long en 3).
Exercice 17 Les langages suivants sont-ils rationnels ? Justifier.
1. a∗ b∗
2. {an , n ≥ 0}
3. {an bam , n, m ≥ 0}
4. {an ban , n ≥ 0}
34
5. Le langage des mots comportant un nombre pair de a et un nombre
impair de b.
6. Le langage des mots pour lesquels a et b n’ont pas la même parité.
7. Le langage des mots n’ayant pas le même nombre de a que de b.
Corrigé 17
1. Oui (il s’agit d’une expression rationnelle).
2. Oui (c’est a∗ ).
3. Oui (c’est a∗ ba∗ ).
4. Non (Myhill-Nerode avec (an b) comme motif : on exhibe {an−1 } en
tant que résidu paramétré par n non borné).
5. Oui (on peut construire un automate à quatre états : 00, 01, 10, 11, initial en 00, final en 01, etc.).
6. Oui (même automate avec 01 et 10 comme terminaux).
7. Non. Intermédiaire : prouver par Myhill-Nerode que le langage
{an bm , n 6= m} n’est pas rationnel (résidu pour an : {b∗ } − {bn }, puis
clôture par intersection avec a∗ b∗ .
35