Csex LANG200812 S3fi b-1

I.U.T.
Lille A — Département Informatique

Mathématiques — théorie des langages
version du 5 décembre 2008
e cours présente quelques notions générales sur les langages formels. La théorie des langages formels est
C apparue dans les années 1950 comme un outil novateur de la linguistique, science de l’étude des langues. Le
linguiste américain Noam CHOMSKY, en particulier, proposa une description générative pour chaque phrase,
à l’aide de règles de réécriture, du type :
hphrasei −→ hsujeti hverbei hobjeti.

hsujeti −→ hgroupe nominali
hobjeti −→ hgroupe nominali
hverbei −→ apprécie | aime | adore
hgroupe nominali −→ l’étudiant | l’étudiante | les mathématiques
Ainsi, avec cette grammaire, la phrase ≪ l’étudiant adore les mathématiques ≫ correspond à l’arbre d’analyse
syntaxique suivant :
hphrasei
hsujeti hverbei hobjeti
hgroupe nominali adore hgroupe nominali
l’étudiant les mathématiques
À l’aide de cette grammaire, nous avons pu mettre en évidence la ≪ structure ≫ de la phrase étudiée...
Cette analyse – que nous pratiquons inconsciemmment lorsque nous écoutons un discours (ou lisons un texte)
en langue naturelle – est proche de celle qui doit être faite lors de l’interprétation d’un programme écrit dans
un langage informatique ≪ de haut niveau ≫ (C, C++, JAVA, Cobol...) : un tel programme n’est rien d’autre
qu’un fichier texte, c’est-à-dire une suite de caractères dans laquelle on doit mettre à jour une structure, afin
de la traduire en une séquence d’instructions en pseudocode ou directement en langage-machine, directement
exécutable par la machine.
C’est à partir de cette analogie entre langues naturelles et langages informatiques que s’est développée
la théorie des langages en tant que partie de l’informatique et de l’algorithmique : on citera les concepts de
grammaire, de dérivation, d’automate fini, d’automate à pile, tous à la base des méthodes modernes d’analyse
syntaxique et donc de la conception des compilateurs...
Théorie des langages 2
Table des matières

1 Définitions générales 3
1.1 Alphabet, lettres et mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Concaténation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Langages, opérations sur les langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Automates finis 5
2.1 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Des AF déterministes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Un AF non déterministe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.3 Un AFnd avec des transitions instantanées . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Transformation d’un AF en AFdc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Simplifications d’AFdc, automate minimal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 La classe des langages reconnaissables par un AF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.6 Un exemple de langage non reconnaissable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Grammaires 15
3.1 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Définitions générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3 La classification de Chomsky . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.4 Grammaires algébriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.5 Langages réguliers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
A Preuve des équivalences : régulier – reconnaissable – type 3 19

A.1 Passage d’un AF à une grammaire régulière. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
A.2 Passage d’une grammaire régulière à un AF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
A.3 Passage d’une expression régulière à une grammaire régulière. . . . . . . . . . . . . . . . . . . . . 22
A.4 Passage d’une grammaire régulière à une expression régulière. . . . . . . . . . . . . . . . . . . . . 23
B Syntaxes des expressions régulières en Tcl 24

B.1 REGULAR EXPRESSION SYNTAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
B.2 AMBIGUITY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
C Expressions régulières en environnement unix 25
D Une calculatrice en Lex et Yacc 26

D.1 Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
D.2 Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
D.3 calc.l – Le programme Lex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
D.4 calc.y – Le programme Yacc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
D.5 Compilations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1 Définitions générales
1.1 Alphabet, lettres et mots
Définition 1
Un alphabet est un ensemble fini dont les éléments sont appelés lettres.
Quelques exemples : {0, 1, 2, 4, 5, 6, 7, 8, 9} est l’alphabet des chiffres en base dix, {0, 1} est l’alphabet des chiffres
en base deux, {a, b, c, . . . y, z} est l’alphabet latin, etc.
Définition 2
Un mot est une suite finie de lettres, le nombre de lettres d’un mot est la longueur de ce mot. Par
convention, on notera ε le mot vide, dont la longueur est évidemment nulle. L’ensemble des mots
que l’on peut construire sur l’alphabet Σ sera noté Σ∗ .
Par exemple, bonjour, ε, z, zzzzzzzzzzzz sont des mots sur l’alphabet {a, b, c, . . . y, z}, de longueur respective
7, 0, 1, 12.
1.2 Concaténation
La seule opération ≪ naturelle ≫ entre mots est la concaténation, en voici quelques exemples avec des mots
∗
appartenant à {a, b, c, . . . y, z} : bon · jour = bonjour, jour · bon = jourbon, (bon)2 = bon · bon = bonbon,
bon = bo · n · n = bonn, bon · ε = bon, turlututu = tu · rlu · (tu)2 , zzzzzzzzzzzz = z 12 .
2
Définition 3
Soient α = (αi )1≤i≤m et β = (βi )1≤i≤n deux mots appartenant à Σ∗ . Alors α · β = γ où :

αi pour 1≤i≤m
γi =
β−m+i pour m + 1≤i≤m + n
En particulier, α · ε = ε · α = α et ε · ε = ε
Pour tout mot α : α0 = ε. Pour tout mot α et pour tout entier naturel k : αk+1 = αk · α.
Une conséquence immédiate est :
Propriété 1
La longueur du concaténé de plusieurs mots est la somme des longueurs de ces mots. De même, la
longueur de αk est k fois la longueur de α.
1.3 Langages, opérations sur les langages

Un langage est tout simplement un ensemble de mots, plus précisément :
Définition 4
Un langage sur l’alphabet Σ est une partie de Σ∗ .
En dehors des opérations ensemblistes habituelles – union, intersection, complémentation – on peut définir entre
langages deux nouvelles opérations, déduites de l’opération de concaténation entre mots.
Donnons d’abord quelques exemples de langages sur l’alphabet Σ = {a, b, c, . . . y, z}, ainsi que d’opérations
sur ces langages : Σ, Σ∗ , ∅, {ε} , {a, ba}, {a, c, d},
{a, ba} ∩ {a, c, d} = {a} ,

{a, ba} ∪ {a, c, d} = {a, ba, c, d} ,
{a, ba} \ {a, c, d} = {ba} ,
{a, c, d} \ {a, ba} = {c, d} ,
{a, ba} · {a, c, d} = {aa, ac, ad, baa, bac, bad} ,
{a, c, d} · {a, ba} = {aa, aba, ca, cba, da, dba} ,
2
{a, c, d} = {a, c, d} · {a, c, d} = {aa, ac, ad, ca, cc, cd, da, dc, dd} ,
{a, c, d}3 = {a, c, d}2 · {a, c, d}
= {aa, ac, ad, ca, cc, cd, da, dc, dd} · {a, c, d}
= {aaa, aca, ada, caa, cca, cda, daa, dca, dda,
aac, acc, adc, cac, ccc, cdc, dac, dcc, ddc, aad, acd, add, cad, ccd, cdd, dad, dcd, ddd}.
Définition 5
Soient L, L′ deux langages sur l’alphabet Σ. Alors L · L′ est le langage sur l’alphabet Σ défini par :
L · L′ = {m · m′ : m ∈ L et m′ ∈ L′ }
De plus, on pose 1 pour tout langage S

L : L0 = {ε}, puis,Sinductivement, pour tout entier naturel k :
k+1
L = L · L. On pose enfin : L = k∈N Lk et L+ = k∈N∗ Lk .
k ∗
On remarquera que, pour tout langage L, L1 =SL. D’autre part, pour tout alphabet Σ, Σk est l’ensemble des
mots de longueur k construits sur Σ, et Σ∗ = k∈N Σk est bien l’ensemble de tous les mots construits sur Σ,
comme indiqué dans la définition 2.
Signalons enfin quelques conventions d’écriture qui concernent les opérations portant sur un langage {α}
réduit à un seul mot : {α} · L sera noté plus simplement αL, de même {α}∗ sera noté plus simplement α∗ . Voici
quelques exemples – toujours avec l’alphabet Σ = {a, b, c, . . . y, z} – montrant la puissance de ces définitions...
et aussi qu’il faut les manier avec précaution :
– aΣ∗ (que l’on devrait noter {a} · Σ∗ ) est le langage des mots sur Σ commençant par la lettre a,
– Σ∗ aΣ∗ aΣ∗ est le langage des mots sur Σ contenant au moins deux fois la lettre a,
∗ ∗ ∗
– en notant Σ′ = Σ \ {a} l’alphabet privé de la lettre a, Σ′ aΣ′ aΣ′ est le langage des mots sur Σ contenant
exactement deux fois la lettre a,
– a∗ = {ε, a, aa, aaa . . .} est le langage des mots ne contenant que la lettre a,
– attention : ab∗ = {a, ab, abb, abbb . . .} mais (ab)∗ = {ε, ab, abab, ababab . . .}.
1.4 Expressions régulières

Nous terminons par une définition inductive que nous utiliserons dans la partie 3.5, page 19 consacrée aux
différentes caractérisations des langages réguliers :
Définition 6
La classe des langages réguliers est la classe la plus petite qui contienne les langages finis 2 et qui
soit stable par les opérations de réunion, concaténation, ≪ étoile ≫. Autrement dit, les seuls langages
réguliers sont les langages qu’il est possible de fabriquer à l’aide des deux règles suivantes :
– Tout langage fini est régulier,
– Si L et L′ sont réguliers, alors L ∪ L′ , L · L′ et L∗ sont réguliers.
Voici quelques exemples de langages réguliers : ∅, Σ, Σ \ {a} (ces langages sont réguliers car finis), le langage
des mots sur Σ contenant au plus une fois la lettre a : en effet, ce langage peut être obtenu par les opérations
de réunion, concaténation, ≪ étoile ≫ à partir de langages eux-mêmes réguliers, puisque finis :
(Σ \ {a})∗ ∪ (Σ \ {a})∗ a(Σ \ {a})∗ .
On verra plus loin quelques cas de langages non réguliers, par exemple :
k k
a b : k ∈ N = {ε, ab, aabb, aaabbb, . . . } .
1. Attention à l’erreur courante qui consiste à croire que Lk serait égal à mk : m ∈ L : ce n’est qu’exceptionnellement le cas !
˘ ¯
2. c’est-à-dire les ensembles finis de mots.
Remarquons tout de suite que, pour prouver que ce dernier langage n’est pas régulier, il ne suffit pas seulement
de dire que, dans la définition nque nous venons de lui donner, il n’est pas ≪ fabriqué ≫ à l’aide d’une expression
régulière : il faut en fait justifier qu’il n’existe aucune expression régulière qui le représente.
Nous allons faire le lien avec les expressions régulières telles que les utilisent les informaticiens (en particulier
dans les langages proches de C ou de unix... On en trouvera une description informelle en annexe C, page 25).
et une description un peu plus précise en annexe B, page 24). En transcrivant dans un formalisation plus
≪ mathématique ≫, on obtient :
Définition 7
Soit Σ un alphabet fini. Une expression régulière est une expression qui peut être obtenue par
application de une ou plusieurs des règles suivantes :
– ∅ est une expression régulière qui désigne la langage ∅ (langage vide).
– ε est une expression régulière qui désigne la langage {ε} (langage réduit au mot vide, à ne pas
confondre avec le précédent. . .).
– Si x est une lettre de Σ, alors x est expression régulière qui désigne la langage {x}.
– Si r et s sont des expressions régulières qui désignent respectivement les langages L(r) et L(s),
alors r | s, r · s et r∗ sont des expressions régulières qui désignent respectivement les langages
L(r) ∪ L(s), L(r) · L(s) et L(r)∗ .
Ainsi, on pourra écrire

[b-z]* | [b-z]*a[b-z]*
au lieu de
(Σ \ {a})∗ ∪ (Σ \ {a})∗ a(Σ \ {a})∗ .
2 Automates finis
Un automate est une méthode permettant de tester si un mot donné appartient, ou n’appartient pas, à un
langage donné.
Avant de donner les définitions générales, nous étudierons quelques exemples simples, de façon à faciliter
la compréhension de ces définitions. Nous verrons d’abord un exemple de la structure la plus simple : celle
d’automate fini déterministe complet. Nous verrons ensuite un exemple d’automate fini déterministe non complet.
Nous passerons ensuite à un exemple de la classe plus générale des automates finis. Le lecteur s’attachera à bien
comprendre comment ≪ fonctionne ≫ un automate fini.
Après avoir donné les définitions générales, nous montrerons que tout automate fini est ≪ équivalent ≫ à un
automate fini déterministe et complet.
Nous donnerons alors des résultats concernant la classe des langages reconnaissables par des automates finis
(stabilité par réunion, concaténation, étoile).
Nous terminerons par un algorithme de simplification d’automate.
2.1 Quelques exemples

2.1.1 Des AF déterministes
L’automate A1 (voir figure 1) est un automate sur l’alphabet {a, b, c}, c’est un automate fini car son ensemble
d’états {1, 2, 3, 4} est fini. Parmi ces états, 1 est un état de départ, 1 et 3 sont des états acceptants.
a
1 2 b
a|c c 3
b|c
4 a|b
a|b|c
Figure 1 – A1 (automate fini déterministe complet)

Chaque flèche est une transition, par exemple, si l’automate est dans l’état 1 et qu’il reçoit la lettre a, il
passe dans l’état 2 = 1 · a. Remarquons que lorsque plusieurs transitions ont même état de départ et même état
d’arrivée, on les représente par une seule flèche portant plusieurs étiquettes, ainsi 2 · a = 2 · c = 4.
Comment ≪ fonctionne ≫ un tel automate ? Le mot abcb est reconnu par l’automate car
1 · abcb = (1 · a) · bcb = 2 · bcb = 3 · cb = 2 · b = 3
et car 3 est un état acceptant. De même, le mot vide est reconnu par A1 car l’état de départ est un des états
acceptants. Par contre, le mot aabc n’est pas reconnu car
1 · aabc = 2 · abc = 4 · bc = 4 · c = 4
et car 4 n’est pas acceptant.

Notons alors L(A1) le langage reconnu par A1, outre le mot vide, L(A1) contient ab, abcb, abcbcb, abcbcbcbcb...
autrement dit :
L(A1) = {ε} ∪ {ab(cb)n : n ∈ N} = {ε} ∪ ab(cb)∗ .
Remarquons enfin que cet automate fini est déterministe complet, car, d’une part, il a un et un seul état de
départ, et, d’autre part, il y a, pour chaque couple (état, lettre), une et une seule transition partant de cet état
et étiquetée avec cette lettre.
Intéressons nous à l’état 4 de notre automate : cet état est non-acceptant, et, ≪ lorsqu’on y est parvenu, on
ne peut plus en sortir ≫, c’est-à-dire que, pour toute lettre x de l’alphabet, on a : 4 · x = 4. Un tel état est dit
rebut, poubelle ou trou noir.
On s’autorise souvent à ≪ oublier ≫ les états-rebuts, ainsi notre premier automate A1 devient A1bis (voir
figure 2). Ce nouvel automate fini est déterministe, mais non complet. En pratique, comment lit-on, par exemple,
le mot aabc ?
1 · aabc = 2 · abc = blocage
Tout se passe comme si on sous-entendait un état de blocage, non acceptant, tel que pour toute lettre x, on ait :
blocage · x = blocage. En d’autre termes, cet état blocage n’est autre que l’état-rebut que l’on avait sous-entendu !
a b
1 2 3
c
Figure 2 – A1bis (automate fini déterministe non complet)
2.1.2 Un AF non déterministe

Cependant, il est parfois difficile de trouver un automate fini déterministe reconnaissant un langage donné. 3
Par exemple, sur l’alphabet {a, b, c}, il est facile de construire un automate fini déterministe (voir figure 3)
∗
reconnaissant le langage des mots commençant par ba, c’est-à-dire ba {a, b, c} : 4
b a
1 2 3
a|b|c
Figure 3 – A2
Le problème est par contre plus difficile pour le langage {a, b, c}∗ ba {a, b, c}∗ c’est-à-dire 5 le langage des
mots contenant ba. On est conduit à proposer l’automate fini suivant :
On remarquera que cet automate n’est pas déterministe, il y a en effet deux transitions marquées b au
départ de 1. Il importe de bien comprendre comment un tel automate lit un mot, par exemple cbbab. A cause
du caractère non déterministe, il y a plusieurs lectures possibles :
c b b a b
– 1 −→ 1 −→ 1 −→ 1 −→ 1 −→ 1
3. L’expérience montre que cette difficulté est liée au fait que les automates lisent les mots ≪ par la gauche ≫.
4. On devrait plutôt noter {ba} · {a, b, c}∗ .

5. On devrait noter {a, b, c}∗ · {ba} · {a, b, c}∗ .
b a
1 2 3
a|b|c a|b|c
Figure 4 – A3 (automate fini non déterministe)
c b b a b
– 1 −→ 1 −→ 1 −→ 1 −→ 1 −→ 2
c b b
– 1 −→ 1 −→ 2 −→ blocage
c b b a b
– 1 −→ 1 −→ 1 −→ 2 −→ 3 −→ 3
Il faut comprendre que le mot cbbab est reconnu parce qu’il est associé à au moins un chemin dans l’automate,
partant d’un état de départ et arrivant à un état acceptant ; autrement dit, il suffit d’une ≪ bonne ≫ lecture
d’un mot pour que celui-ci soit reconnu, le fait qu’il existe d’autres lectures du même mot ne gêne en rien.
Comment être alors certain de n’oublier aucune lecture d’un mot ? On part de {1}, ensemble des états de
départ de l’automate. Si F est un ensemble d’états, et si x est une lettre, on notera F · x l’ensemble des états
auxquels on peut arriver par une transition étiquetée x et partant de l’un des états de F .
{1} · cbbab = {1} · bbab = {1, 2} · bab = {1, 2} · ab = {1, 3} · b = {1, 2, 3}
Ceci signifie que les états auxquels on peut arriver depuis l’un des états de départ en lisant le mot cbbab sont
1, 2 et 3. L’un au moins de ces états est acceptant, d’où le fait que le mot cbbab est accepté. Etudions un autre
exemple :
{1} · cbcb = {1} · bcb = {1, 2} · cb = {1} · b = {1, 2}
Comme ni 1, ni 2 ne sont acceptants, le mot cbcb n’est pas accepté.
On verra plus loin que le fait de travailler avec des sous-ensembles de l’ensemble des états permet de trans-
former un automate fini non déterministe en automate fini déterministe complet.
2.1.3 Un AFnd avec des transitions instantanées

Enfin, voici un dernier exemple. . . Nous voulons construire un automate fini qui reconnaisse le langage
ab∗ c∗ b∗ | b∗ .
En introduisant des ≪ transitions instantanées ≫ et en gardant à l’esprit que les mots reconnus sont ceux
qui correspondent à un chemin depuis l’un des états de départ (ici : 1) à un des des états acceptants (ici ; 4 ou
5), on propose : Comme on le voit, cet automate est non déterministe (par exemple, il y a deux lectures du mot
ε ε
2 3 4
a
1 c
ε b b
Figure 5 – A4 (AFnd avec transitions instantanées)
vide : 1 · ε = {1, 5}, le mot vide est accepté car l’un au moins des états de fin de lecture est acceptant).
2.2 Définitions
Définition 8 (Automate fini)

Un automate fini est un quintuplet (Σ, E, D, A, Θ), où :
– Σ est un alphabet, 6
– E est un ensemble fini dont les éléments sont appelés états,
6. c’est-à-dire un ensemble fini d’éléments appelés lettres.
– D est une partie de E dont les éléments sont appelés états de départ,
– A est une partie de E dont les éléments sont appelés états d’acceptation,
– Θ est une partie de E × (Σ ∪ {ε}) × E dont les éléments sont appelés transitions. 7
Revenons sur les automates dont les représentations sagittales ont été données plus haut. Ainsi (voir figure 1,)
A1 = ({a, b, c} , {1, 2, 3, 4} , {1} , {1, 3} , Θ1), où :
Θ1 = {(1, a, 2), (1, b, 4), (1, c, 4), (2, a, 4), (2, b, 3), (2, c, 4),
(3, a, 4), (3, b, 4), (3, c, 2), (4, a, 4), (4, b, 4), (4, c, 4)}
On préfère souvent résumer cette définition par une table des transitions :
a b c
− 1 + 2 4 4
2 4 3 4
3 + 4 4 2
4 4 4 4
De même (voir figure 2), A1bis = ({a, b, c} , {1, 2, 3} , {1} , {1, 3} , Θ1bis ), où la table de transition est :
a b c
− 1 + 2
2 3
3 + 2
Voici enfin les tables de transition associées aux automates A2 et A3, respectivement : (voir figures 3 et 4) :
a b c a b c
− 1 2 − 1 1 1|2 1
2 3 2 3
3 + 3 3 3 3 + 3 3 3
Comme A3 comporte plusieurs transitions depuis l’état 1 pour la lettre b, cet automate est non déterministe.
Voyons enfin la table de transitions de A4 (voir figure 5 page 7). Il s’agit, rappelons le, d’un automate non
déterministe car comportant des transitions instantanées :
ε a b c
− 1 5 2
2 3 2
3 4 3
4 + 4
5 + 5
Nous pouvons donner précisément la définition des automates finis déterministes :
Définition 9 (Automate fini déterministe)

Un automate fini déterministe est un automate fini (Σ, E, D, A, Θ) tel que :
– D est de cardinal au plus 1, 8
– il n’y a aucune transition instantanée,
– Pour tout état e ∈ E et toute lettre x ∈ Σ, il y a au plus un état f ∈ E tel que le triplet (e, x, f )
soit élément de l’ensemble Θ des transitions 9 .
Définition 10 (Automate fini déterministe complet)

Un automate fini déterministe complet est un automate fini (Σ, E, D, A, Θ) tel que :
– D est de cardinal 1, 10
7. Une transition est donc un triplet du type (état, lettre ou mot vide, état) qui est représenté par une flèche dans la représentation
sagittale, lorsque l’étiquette est le mot vide, on parle de transition instan,tanée.
8. Autrement dit : il y a au plus un seul état de départ.
9. Autrement dit : dans la représentation sagittale, il n’y a jamais plusieurs flèches partant d’un même état et portant la même
étiquette, ou encore : dans la table de transition, chaque case contient au plus un état, ou encore : la table de transition définit une
fonction de E × Σ dans E.
10. Autrement dit : il y a un seul état de départ.
– il n’y a aucune transition instantanée,

– Pour tout état e ∈ E et toute lettre x ∈ Σ, il y a exactement un état f ∈ E tel que le triplet
(e, x, f ) soit élément de l’ensemble Θ des transitions 11 .
Parmi les automates finis proposés ci-dessus, tous ont un seul état de départ, A1 est déterministe complet, A1,
A1bis et A2 sont détermistes, A3 et A4 ne sont pas déterministes. Définissons maintenant ce qu’est la lecture
d’un mot par un automate :
Définition 11 (Lecture par un automate fini)

Soit A = (Σ, E, D, A, Θ) un automate fini.
– Un chemin de longueur n dans l’automate A est une suite de n transitions
(e1 , x1 , f1 ), (e2 , x2 , f2 ), . . . (en , xn , fn )
correctement enchaı̂nées, c’est-à-dire telles que : ∀i, 1 ≤ i < n : fi = ei+1 . L’état de départ de ce
chemin est e1 , l’état d’arrivée, est fn , le mot x1 x2 · · · xn en est la trace.
– Un mot de Σ∗ est reconnu par A s’il est la trace d’au moins un chemin dans A partant d’un état
de départ et arrivant dans un état d’acceptation.
– Le langage reconnu par A est l’ensemble des mots reconnus par A.
– Pour toute partie F de l’ensemble d’états E, et pour tout mot α de Σ∗ , on notera F · α l’ensemble
des états d’arrivée associés aux chemins dans A de trace α dont l’état de départ est dans F . 12
– Avec ces définitions, le langage reconnu par A = (Σ, E, D, A, Θ) est :
L(A) = {α ∈ Σ∗ : D · α ∩ A 6= ∅}
2.3 Transformation d’un AF en AFdc.

D’après les définitions précédentes, on peut affirmer :
Théorème 2 (Transformation d’un AF en AFdc)

Soit A = (Σ, E, D, A, Θ) un automate fini.
e = (Σ, E,
On pose : A e {D · ε} , A,
e Θ),
e où :
– Ee = {F ⊆ E : ∃α ∈ Σ∗ : D · α = F }
n o
– Ae= F ∈E e : F ∩ A 6= ∅
n o
e = (F, x, F · x) : F ∈ E
– Θ e, x∈Σ
Alors Ae est un automate fini déterministe complet qui reconnaı̂t le même langage que A.
Revenons sur notre automate A3 (voir figure 4), et appliquons lui cet algorithme (il est utile de rappeler la
table de transition de A3 ; on remarquera que cet automate est, certes, non déterministe, mais qu’il n’ a aucune
transition instantanée) :
a b c
− 1 1 1|2 1
2 3
3 + 3 3 3
− {1} {1} {1, 2} {1}
{1, 2} {1, 3} {1, 2} {1}
{1, 3} + {1, 3} {1, 2, 3} {1, 3}
{1, 2, 3} + {1, 3} {1, 2, 3} {1, 3}
Donnons quelques explications :

f est {1}, ensemble des états de départ de A3,
– L’état de départ de A3
– on calcule {1} · a, {1} · b, {1} · c,
11. Autrement dit : dans la représentation sagittale, il y a, à partir de chaque état, une flèche pour chaque lettre de l’alphabet,
ou encore : dans la table de transition, chaque case contient exactement un état, ou encore : la table de transition définit une
application de E × Σ dans E.
12. Dans le cas où A est déterministe complet, on notera e · x = f au lieu de {e} · x = {f }.
f apparaı̂t,
– on crée une nouvelle ligne dès qu’un nouvel état de A3
– lorsque tous les états apparus sont traités, 13 on a obtenu à la fois tous les états et toutes les transitions
f
de A3,
f ceux qui sont acceptants, c’est-à-dire qui contiennent l’un
– il reste alors à distinguer parmi les états de A3
des états acceptants de A3, à savoir 3 : ce sont {1, 2, 3} et {1, 3},
– on peut alors faire la représentation de A3,f
b b
a
{1} {1, 2} {1, 3} {1, 2, 3}
c a|c
a|c b a|c b
f
Figure 6 – A3 (Version déterministe de A3)
– on constate alors que lorsque l’automate est parvenu dans l’un ou l’autre des états acceptants, il ne pourra
plus que passer de l’un à l’autre de ces états, aussi peut-on simplifier l’automate fini proposé :
b a
I II III
c
a|c b
fa | b | c
Figure 7 – A3bis (Version simplifiée de A3)
Voyons maintenant comment l’automate non déterministe (car comportant des transitions instantanées) A4 (cf.
figure 5 page 7) peut être transformé en AFdc. Rappelons en la table de transitions :
ε a b c
− 1 5 2
2 3 2
3 4 3
4 + 4
5 + 5
On commence par construire un AFnd équivalent sans transitions instantanées. Pour cela, on détermine la liste
e · ε des états atteignables par 0, 1 ou plusieurs transitions instantanées depuis chaque état e :
1 · ε : {1, 5} , 2 · ε : {2, 3, 4} , 3 · ε : {3, 4} , 4 · ε : {4} , 5 · ε : {5}
On obtient alors un AFnd équivalent sans transitions instantanées :

– en remplaçant l’ensemble des états de départ D par l’ensemble D · ε des états atteignables en 0, 1 ou
plusieurs transitions instantanées depuis l’un des états de départ, ici : {1} · ε = {1, 5},
– en ajoutant, pour chaque transition non instantanée (e, x, f ) et pour chaque état g atteignable depuis f
par 1 ou plusieurs transitions instantanées, une transition (e, x, g),
– enfin, en supprimant toutes les transitions instantanées.
On obtient dans cet exemple (on remarquera que, par une paresse peu excusable, on a noté 234 pour {2, 3, 4} :
cette convention de notation est tout à fait acceptable, à condition de bien comprendre que 234 = 23334 = 432. . .,
ce qui peut étonner à la première lecture !) :
a b c
− 1 234 ∅ ∅
2 ∅ 234 ∅
3 ∅ ∅ 34
4 + ∅ 4 ∅
− 5 + ∅ 5 ∅
13. On est assuré que le procédé se terminera, puisqu’il y aura, pire, autant d’états que de parties dans {1, 2, 3}, soit 23 = 8 états.
Il reste à appliquer la méthode ≪ classique ≫ de subset construction :

a b c
− 1 234
2 234
3 34
4 + 4
− 5 + 5
− 15 + 234 5 ∅
234 + ∅ 234 34
5 + ∅ 5 ∅
∅ ∅ ∅ ∅
34 + ∅ 4 34
4 + ∅ 4 ∅
On obtient un AFdc A4′ équivalent à l’AFnd A4, dont voici une représentation sagittale :
b c b
a
c b
234 34 4
b
15
b
a a
5 a|c a|c
c
∅
a|b|c
Figure 8 – A4′ (AFdc équivalent à A4)
2.4 Simplifications d’AFdc, automate minimal.

Un algorithme – connu sous le nom d’algorithme de Nérode, et dont nous allons exposer une présentation
en séance de TD, aboutit à ≪ simplifier ≫ un AFdc obtenu par subset construction 14 c’est-à-dire à en regrouper
les états ≪ inutilement séparés ≫. Nous énoncerons ensuite le théorème de Nérode qui affirme que l’AFdc
obtenu est non seulement minimal – au sens où il n’existe aucun AFdc qui reconnaisse le même langage tout
en comportant moins d’états – mais aussi que cet AFdc est en quelque sorte canoniquement lié à son langage
reconnu – c’est-à-dire qu’en minimisant deux AFdc sans états inaccessibles qui reconnaissent le même langage
L, on obtiendra deux AFdc qui non seulement comportent le même nombre d’états mais qui, de plus, sont
identiques. . . à la dénomination des états près.
étape 0 : il est plus simple de renommer les états, par exemple par un parcours en largeur d’abord depuis
l’état de départ : ceci assure surtout qu’il n’y a pas d’état inaccessible ; cette étape préalable est ≪ natu-
rellement ≫ réalisée lors de la construction d’un AFdc par subset construction ;
étape 1 : nous recherchons les peper (paires d’états peut-être regroupables), c’est-à-dire les paires constituées
de deux états tous deux acceptants ou de deux états tous deux refusants 15 ;
étape 2 : nous calculons les transitions associées à ces peper que nous répartissons en deux catégories :
– d’une part, celles qui aboutissent à des paires (marquées • dans l’exemple ci-dessous) qui ne sont pas
parmi la liste actuelle des peper perdent leur statut de peper
par contre, les peper (marquées ◦ dans l’exemple ci-dessous) dont les transitions associées aboutissent à des
peper ou à des singletons gardent au moins provisoirement (voir étape suivante) leur statut de peper ;
étape 2bis : nous recommençons l’étape précédente tant que la liste de peper devient plus courte 16 . . .
14. L’algorithme de Nérode s’applique à tout AFdc sans état inaccessible : la construction des états lors de la subset construction
s’effectuant dans un parcours en largeur d’abord, l’automate obtenu est déterministe complet et sans état inaccessible.
a(a−1) r(r−1)
15. S’il y a a états acceptants et r états refusants, alors nous obtenons une liste de 2
+ 2
peper, d’après le ≪ théorème
des coupes de Champagne ≫...
16. cette liste peut devenir vide, ce qui prouve alors que l’AFdc dont on était parti était déjà minimal.
étape 3 : . . . et enfin lorsque la liste des peper ne varie plus, chacune des peper restantes acquiert le statut
envié de persah (paire d’états regroupable sans aucune hésitation) ;
étape 3bis : il reste enfin à recopier la table de transition en tenant compte des regroupements (collapsing)
déterminés pat les persah. . .
Voici un exemple complet, où l’on demande de rechercher l’AFdc minimal du langage reconnu par l’automate
non déterministe suivant :
a b c
− 1 145
2 12 25 23
3 +
4 45 4 4
5 5 6 4
6 6 6 36
Par subset construction puis par renumérotation en largeur d’abord, on obtient :
a b c a b c
− 1 145 ∅ ∅ − 1 2 3 3
145 145 46 4 2 2 4 5
∅ ∅ ∅ ∅ 3 3 3 3
46 456 46 346 4 6 4 7
4 45 4 4 5 8 5 5
456 456 46 346 6 6 4 7
346 + 456 46 346 7 + 6 4 7
45 45 46 4 8 8 4 5
Ces 7 états refusants et ce seul état acceptant permettent de construire 21 peper, mais cette longue liste passe à
11 peper, puis 5, puis 3 et se stabilise enfin à 2 peper qui sont de fait les deux seules paires d’états regroupables. . .
a b c a b c
12 2◦ 34 ◦ 35 ◦ 12 2◦ 34 • 35 ◦
13 23 ◦ 3◦ 3◦ 13 23 ◦ 3◦ 3◦
14 26 ◦ 34 ◦ 37 • 15 28 ◦ 35 ◦ 35 ◦
15 28 ◦ 35 ◦ 35 ◦ 18 28 ◦ 34 • 35 ◦
16 26 ◦ 34 ◦ 37 • 23 23 ◦ 34 • 35 ◦
18 28 ◦ 34 ◦ 35 ◦ 25 28 ◦ 45 • 5◦
23 23 ◦ 34 ◦ 35 ◦ 28 28 ◦ 4◦ 5◦
24 26 ◦ 4◦ 57 • 35 38 ◦ 35 ◦ 35 ◦
25 28 ◦ 45 ◦ 5◦ 38 38 ◦ 34 • 35 ◦
26 26 ◦ 4◦ 57 • 46 6◦ 4◦ 7◦
28 28 ◦ 4◦ 5◦ 58 8◦ 45 • 5◦
34 36 ◦ 34 ◦ 37 • 13 23 • 3◦ 3◦
35 38 ◦ 35 ◦ 35 ◦ 15 28 ◦ 35 ◦ 35 ◦
36 36 ◦ 34 ◦ 37 • 28 28 ◦ 4◦ 5◦
38 38 ◦ 34 ◦ 35 ◦ 35 38 • 35 ◦ 35 ◦
45 68 ◦ 45 ◦ 57 • 46 6◦ 4◦ 7◦
46 6◦ 4◦ 7◦ 15 28 ◦ 35 • 35 ◦
48 68 ◦ 4◦ 57 • 28 28 ◦ 4◦ 5◦
56 68 ◦ 45 ◦ 57 • 46 6◦ 4◦ 7◦
58 8◦ 45 ◦ 5◦ 28 28 ◦ 4◦ 5◦
68 68 ◦ 4◦ 57 • 46 6◦ 4◦ 7◦
Il nous reste à replier 8 sur 2 et 6 sur 4, ce qui donne finalement l’AFdc minimal suivant (nous laissons en regard
l’AFdc précédemment obtenu par subset construction afin de faciliter la comparaison) :
a b c
− 1 2 3 3 a b c
2 2 4 5 − 1 2 3 3
3 3 3 3 2 2 4 5
4 6 4 7 3 3 3 3
5 8 5 5 4 4 4 7
6 6 4 7 5 2 5 5
7 + 6 4 7 7 + 4 4 7
8 8 4 5
Nous avons rassemblé des représentations des trois AF de cet exemple : voir figure 9, page 14.
Nous admettrons le :
Théorème 3 (Nérode)
Soit A un automate fini déterministe complet sans état inaccessible, soit L = L(A) le langage reconnu
par cet automate et soit A e l’automate obtenu à partir de A par l’algorithme de Nérode .
Alors :
– Ae est un un automate fini déterministe complet sans état inaccessible ;
– Ae et A sont équivalents, c’est-à-dire qu’ils reconnaissent le même langage L ;
– tout automate qui reconnaı̂t ce langage L a un nombre d’états supérieur ou égal à celui de A e;
– tout automate qui reconnaı̂t ce langage L et qui a le même nombre d’états que A e est, à la
e
dénomination de ses états près, identique à A.
Ceci justifie que l’automate A e est désigné comme l’AFdc minimal du langage L. Une conséquence
du théorème précédent est que, si deux automates qui reconnaissent le même langage L (langage
régulier, puisque reconnaissable : cf. théorème 7) peuvent être fort différents, on obtiendra après
subset construction et minimisation le même AFdc minimal, qui peut donc être considéré comme
un représentant canonique du langage (régulier !) L.
2.5 La classe des langages reconnaissables par un AF.
Définition 12
Un langage est reconnaissable s’il est possible de construire un automate fini qui le reconnaisse.
Nous verrons plus loin qu’il y a identité entre langages réguliers et langages reconnaissables. La preuve de ce
résultat est un exercice de manipulation d’automates, nous reviendrons sur ce point après l’étude des grammaires,
et plus précisément des grammaires régulières.
2.6 Un exemple de langage non reconnaissable.

On démontre le :
Théorème 4
le langage ak bk : k ∈ N N’EST PAS reconnaissable.
preuve D’après le théorème 2, si ce langage était reconnaissable, on pourrait trouver un automate fini déter-
ministe complet A = (Σ, E, {d} , A, Θ) qui le reconnaı̂trait. 17
L’idée est alors la suivante : après avoir lu le mot ak , cet AFdc devrait être dans un ≪ état ≫ qui serait : Si
je lis maintenant un b, alors je dois attendre exactement k lettres b pour passer dans un état acceptant, toute
autre lecture doit me laisser dans un état non acceptant. La description de cet ≪ état ≫ demande que la valeur k
soit ≪ mise en mémoire ≫ : à deux valeurs différentes de k correspondent deux ≪ états ≫ différents. Autrement
dit, un tel automate devrait avoir au moins autant d’états qu’il y a de valeurs possibles pour k... c’est-à-dire
une infinité !
17. Le langage reconnu par A serait donc exactement ak bk : k ∈ N , c’est-à-dire que les mots reconnus seraient les ak bk et
˘ ¯
seulement ceux-là.
Rappelons par ailleurs que, pour tout état e de l’AFdc A, et pour tout mot α, on note e · α l’état auquel parvient l’automate après
lecture du mot α en partant de l’état e.
a|b|c
4
a a a a|b|c
a
c
a b c
1 5 6 3
c
a b
a|b|c
c
a
3467
b c
1452
a b
b
11 464 c a
b|c c a
b
a b
∅3 45 458 4566
c
a|b|c b|c a a
c
a
7
a|b c
a 2 b
a|b
1 4
b|c a c
3 5
a|b|c b|c
Figure 9 – Recherche de l’AFdc minimal équivalent à un AFnd donné

De façon plus précise, soit k un entier supérieur ou égal au nombre d’états de A. Parmi les k + 1 états :
d, d · a, d · a2 , · · · d · ak , deux au moins sont égaux, il existe donc deux entiers distincts p et q tels que, après
lecture des mots (pourtant distincts) ap et aq , on parvienne au même état : d · ap = d · aq . Comme ap bp est
reconnu, l’état d · ap bp est acceptant, l’égalité précédente implique que d · aq bp = d · aq bp est aussi acceptant, le
mot aq bp est donc aussi reconnu, ceci bien que p 6= q : il y a contradiction.
3 Grammaires
Alors que les automates servent à reconnaı̂tre si un mot donné est, ou n’est pas, dans un langage donné, les
grammaires, elles, servent à fabriquer des mots d’un langage donné.
3.1 Quelques exemples

Soit G1 la grammaire suivante, extraite du manuel de l’utilisateur du langage Pascal. Elle décrit 18 ce qu’est
un identificateur, c’est-à-dire un mot commençant par une lettre, et suivi d’un nombre quelconque de lettres ou
de chiffres :
– les symboles terminaux sont a,b,c,d,...z,0,1,...9,
– les symboles non terminaux (ou variables) sont :
hidentificateuri, hlettrei, hchiffrei, hsuite de lettres ou chiffresi
– le symbole non terminal initial est hidentificateuri,
– les règles de production sont : 19
hidentificateuri ::= hlettreihsuite de lettres ou chiffresi
hsuite de lettres ou chiffresi
::= hvidei|
hlettreihsuite de lettres ou chiffresi|
hchiffreihsuite de lettres ou chiffresi
hlettrei ::= a|b|c...y|z
hchiffrei ::= 0|1|2...8|9
Montrons comment est produit le mot iutlille1 :
hidentificateuri =⇒ hlettreihsuite de lettres ou chiffresi,
=⇒ ihsuite de lettres ou chiffresi,
=⇒ ihlettreihsuite de lettres ou chiffresi,
=⇒ iuhsuite de lettres ou chiffresi,
=⇒ ...
=⇒ iutlillehsuite de lettres ou chiffresi,
=⇒ iutlillehchiffreihsuite de lettres ou chiffresi,
=⇒ iutlille1hsuite de lettres ou chiffresi,
=⇒ iutlille1hvidei c’est-à-dire iutlille1.
Nous venons de donner un premier exemple de dérivation.
18. certes avec quelques simplifications...
19. Contrairement aux exemples suivants, cette grammaire est présentée sous ≪ BNF ≫, c’est-à-dire ≪ Backus-Naur Form ≫.
≪ ::= ≫ signifie ≪ peut être remplacé par ≫, ≪ | ≫ signifie ≪ ou ≫
Passons à une série d’exemples. 20

terminaux non-terminaux axiome règles
G2 : {a, b} {S} S S −→ aSb | ε
G3 : {a, b} {S, A, B} S S −→ AB
A −→ aA | ε
B −→ bB | ε
G4 : {a, b} {S} S S −→ aS | ε | bB
B −→ bB | ε
G5 : {a, b} {S, X, Y } S S −→ abc | aXbc
Xb −→ bX
Xc −→ Y bcc
bY −→ Y b
aY −→ aaX | aa
G6 : {a, b, c, d, +, −, ×, /} {S} S S −→ SS+ | SS− | SS× | SS/
S −→ a | b | c | d
3.2 Définitions générales
Définition 13 (Grammaire)
Une grammaire (ou grammaire de type 0) est un quadruplet (ΣT , ΣN T , S, Π) tel que :
– ΣT est un alphabet dont les lettres sont appelées symboles terminaux,
– ΣN T est un alphabet disjoint de ΣT dont les lettres sont appelées symboles non terminaux,
– S est un élément distingué de ΣN T appelé symbole initial ou axiome,
– Π est un ensemble fini de règles de réécriture ou règles de production, chacune de ces règles est
un couple du type : 21
(γ, δ) ∈ ((ΣT ∪ ΣN T )∗ \ Σ∗T ) × (ΣT ∪ ΣN T )∗
Reste à définir comment on peut dériver un mot dans une grammaire :
Définition 14 (Dérivation dans une grammaire)

Soit une grammaire G = (ΣT , ΣN T , S, Π), soient α et β deux mots de (ΣT ∪ ΣN T )∗ .
1
– On dit que β dérive de α en 1 coup (et on note α =⇒ β ou α =⇒ β), lorsque l’on peut trouver
des mots α′ , α”, γ et δ tels que :
α = α′ γα” et β = α′ δα” et (γ, δ) ∈ Π
,
0
– on dit que β dérive de α en 0 coup (et on note α =⇒ β), lorsque α = β,
– la dérivation en n coups est définie inductivement :
n+1 n 1
(α =⇒ β) ⇐⇒ (∃ω : α =⇒ ω et ω =⇒ β)
∗ n
– on dit que β dérive de α (et on note α =⇒ β), lorsque ∃n ∈ N : α =⇒ β,
∗
– autrement dit, =⇒ est la fermeture reflexo-transitive de =⇒,
– le langage engendré par G est l’ensemble de tous les mots qui dérivent de l’axiome S et qui ne
contiennent aucun symbole non terminal :
n o
∗
L(G) = α : α ∈ Σ∗T et S =⇒ α .
20. Les symboles terminaux seront notés en minuscule, les non terminaux en majuscule, le symbole initial étant S (comme
≪ start ≫). Reste donc à donner la liste des règles de production... ≪ −→ ≫ signifie ≪ peut être remplacé par ≫, ≪ | ≫ signifie
≪ ou ≫. Le lecteur pourra s’entraı̂ner à fabriquer des mots à l’aide de ces grammaires. À titre d’indication, on peut montrer que les
langages engendrés sont L(G2) = {an bn : n ∈ N}, L(G3) = L(G4) = {am bn : m, n ∈ N} = a∗ b∗ , L(G5) = {an bn cn : n ∈ N \ {0}}.
Quant à G6, elle permet de fabriquer les expressions algébriques sur les constantes a, b, c et d en notation polonaise inverse (notation
de Lukasiewicz), les symboles terminaux étant : a, b, c, d, +, −, × et /.
21. la règle (γ, δ) est notée γ −→ δ. La partie gauche γ et la partie droite δ sont des mots constitués de symboles terminaux ou
non, la partie gauche devant contenir au moins un non terminal.
3.3 La classification de Chomsky

Il est souvent utile de reconnaı̂tre si plusieurs grammaires produisent ou non le même langage, on ne sait hélas
pas résoudre cette question en général. On connaı̂t cependant de nombreux résultats sur des classes plus simples
de grammaires. Nous définissons ci-dessous les deux classes les plus simples 22 et, surtout, les plus couramment
utilisées en informatique, de la classification de Chomsky :
Définition 15 (Classification (simplifiée) de Chomsky)

Soit G = (ΣT , ΣN T , S, Π) une grammaire.
– On dit que G est de type 2, ou est non contextuelle ou est ALGEBRIQUE, lorsque toute règle de
production est du type A −→ α avec A ∈ ΣN T , α ∈ (ΣT ∪ ΣN T )∗ : le membre gauche de chaque
règle se réduit à une seule variable, le membre droit est quelconque.
– On dit que G est de type 3 ou est REGULIERE, lorsque toute règle de production 23 est soit du
modèle A −→ αB, soit du modèle A −→ α, avec A, B ∈ ΣN T , α ∈ Σ∗T : le membre gauche de
chaque règle se réduit à une seule variable, le membre droit comporte au plus une variable, si c’est
le cas, cette variable doit être à la fin du membre droit.
– Un langage est dit de type i s’il est possible de trouver une grammaire de type i qui l’engendre.
3.4 Grammaires algébriques

Dans la pratique, les grammaires utilisées couramment en informatique sont algébriques, aussi ne trouvera-
t-on dans ce cours qu’un exemple de grammaire non algébrique (il s’agit de G5, page 15).
On admet le :
Théorème 5
Tout langage de type i est aussi de type j, pour tout j tel que j ≤ i.
Ceci implique, par exemple, que tout langage de type 3 est aussi un langage de types 2, 1 et 0.
Il faut remarquer que, s’il est facile de déterminer quels types possède une grammaire donnée, la notion de
types de langage est moins facile d’emploi.
Ainsi, la grammaire
({a, b} ; {S, A, B} ; S; {S −→ AB; A −→ aA | ε; B −→ bB | ε})
est de type 2 (car la partie gauche de chaque règle est réduite à un seul non-terminal) mais pas 3 (car la règle
S −→ AB contient plusieurs non-terminaux dans sa partie droite). On en déduit que le langage engendré par
cette grammaire – dont on voit aisément qu’il s’agit de a∗ b∗ – est au moins de type 2... De fait, le théorème 7
montre que, parce qu’il est décrit par une expression régulière, ce langage peut aussi être produit par une
grammaire de type 3. On peut par exemple proposer :
({a, b} ; {S, B} ; S; {S −→ aS | B; B −→ bB | ε}).
Le langage a∗ b∗ est donc non seulement de type 2, mais aussi de type 3...
Inversement, le langage ak bk : k ∈ N n’est pas reconnaissable par un automate fini (cf. thèorème 4) et ne
peut (thèorème 7) donc être produit par une grammaire de type 3. Par contre, ce même langage est clairement
produit par la grammaire de type 2 :
({a, b} ; {S} ; S; {S −→ aSb | ε})

k k
et finalement a b : k ∈ N est de type 2 mais pas 3.
22. À titre d’information, voici l’énonce complet de la définition : Soit G = (ΣT , ΣNT , S, Π) une grammaire.
– Une grammaire quelconque est dite de type 0, ou non restreinte, ou à structure de phrase.
– On dit que G est de type 1, ou est contextuelle, ou context sensitive, lorsque toute règle de production est du type δ −→ γ
avec δ = δ′ Aδ”, γ = δ′ αδ” et A ∈ ΣNT , δ′ , δ”, α ∈ (ΣT ∪ ΣNT )∗ , α 6= ε, à l’exception toutefois de la règle S −→ ε qui peut
appartenir à Π, à condition que, dans ce cas, S n’apparaisse jamais dans la partie droite d’une règle de Π.
– On dit que G est de type 2, ou est non contextuelle, ou est une C-grammaire, ou est context free, ou est ALGEBRIQUE,
lorsque toute règle de production est du type A −→ α avec A ∈ ΣNT , α ∈ (ΣT ∪ ΣNT )∗ .
– On dit que G est de type 3, ou est une K-grammaire, ou est linéaire à droite, ou est REGULIERE, lorsque toute règle de
production est soit du modèle A −→ αB, soit du modèle A −→ α, avec A, B ∈ ΣNT , α ∈ Σ∗T .
– Un langage est dit de type i s’il est possible de trouver une grammaire de type i qui l’engendre.
23. Pour le premier modèle, rien n’empêche que A = B. Les règles du deuxième modèle sont appelées règles terminales.
Donnons maintenant, en nous appuyant sur des exemples, quelques définitions utiles dans le cadre des
grammaires algébriques. Nous définissons les grammaires :
G = ( {a, b, c, d, +, ×} , {S, X} , S, {S −→ S + X | S × X | X , X −→ a | b | c | d} )
G’ = ( {a, b, c, d, +, ×} , {S} , S, {S −→ S + S | S × S | a | b | c | d} )
et étudions d’abord comment produire dans la première grammaire G le mot a + b × c + d. On peut proposer
plusieurs dérivations de ce mot :
(q) S =⇒ S + X =⇒ S × X + X =⇒ S × c + X =⇒ S + X × c + X =⇒ S + b × c + X
=⇒ X + b × c + X =⇒ a + b × c + X =⇒ a + b × c + d
(g) S =⇒ S + X =⇒ S × X + X =⇒ S + X × X + X =⇒ X + X × X + X =⇒ a + X × X + X
=⇒ a + b × X + X =⇒ a + b × c + X =⇒ a + b × c + d
(d) S =⇒ S + X =⇒ S + d =⇒ S × X + d =⇒ S × c + d =⇒ S + X × c + d
=⇒ S + b × c + d =⇒ X + b × c + d =⇒ a + b × c + d
Mais il importe de comprendre que ces dérivations ne diffèrent que par l’ordre d’execution. Cette équivalence se
traduit bien dans le fait que ces dérivations sont toutes associées au même arbre d’analyse syntaxique :
S + X
S × X d
S + X c
X b
a
On dira que la dérivation (g) (respectivement (d) ) ci-dessus est la dérivation la plus à gauche (respectivement
la plus à droite) associée à cet arbre, car on a pris comme règle, lorsqu’on avait le choix entre plusieurs non-
terminaux, de réduire celui qui était le plus à gauche (respectivement la plus à droite).
Finalement, il faut bien comprendre que c’est l’arbre syntaxique (et non pas les diverses dérivations qui
lui sont associées) qui nous permet de ≪ lire ≫ la structure du mot a + b × c + d, qui est donc ici compris
comme ((a + b) × c) + d. Le lecteur se convaincra aisément que chaque mot produit par G admet un seul
arbre de dérivation (on dira que cette grammaire est non ambigüe) correspondant à une évaluation des signes
d’opération dans le sens de lecture 24 . Le lecteur trouvera en annexe une grammaire (écrite en langage yacc)
qui implémente les parenthésages et qui, surtout, permet, en l’absence de parenthèses, de ≪ forcer ≫ le respect
des priorités habituellement utilisées en mathématiques, par exemple, a + b × c + d devrait être évalué comme
(a + (b × c)) + d.
Pour terminer, on remarquera que la grammaire G’ ci-dessus produit le même langage 25 que G, mais que
certains mots admettent plusieurs arbres de dérivation – autrement dit, la grammaire G’ est ambigüe, ce qui
est évidemment un défaut impordonnable aux yeux d’un programmeur... Par exemple, les arbres de dérivations
suivants correspondent aux ≪ interprétations ≫ ((a + b) × c) + d et (a + b) × (c + d) du mot a + b × c + d :
S S
S + S S × S
S × S d S + S S + S
S + S c a b c d
a b
Nous terminerons en énonçant un théorème utile dans les preuves mettant en œuvre des dérivations dans
des grammaires algébriques :
24. Attention, ce sont les signes d’opération qui sont situés au plus près des feuilles qui sont évalués en premier, le ≪ + ≫ de la
première production S =⇒ S + X sera donc évalué en dernier !
25. À savoir ({a, b, c, d} · {+, ×})∗ · {a, b, c, d}.
Théorème 6
Soit G = (ΣT , ΣN T , S, Π) une grammaire ALGEBRIQUE.
Soient α1 , α2 , β ∈ (ΣT ∪ ΣN T )∗ , et soit k ∈ N. Alors :

 k1

 α1 =⇒ β1
 k2
k α2 =⇒ β2
(α1 α2 =⇒ β) ⇐⇒ ∃β1 , β2 ∈ (ΣT ∪ ΣN T )∗ , ∃k1 , k2 ∈ N :

 k + k2 = k

 1
β = β1 · β 2
3.5 Langages réguliers

On démontre le :
Théorème 7
Il y a identité entre :
– les langages réguliers (ie définis par une expression régulière),
– les langages reconnaissables, (ie reconnus par au moins un automate fini),
– les langages de type 3 (ie produits par au moins une grammaire de type 3).
La preuve de ce théorème est relativement difficile à rédiger dans le cas général, en particulier à cause du fait
que les notations deviennent très ≪ lourdes ≫... À notre niveau, nous nous contenterons donc de suggérer les
méthodes générales sur quelques exemples proposés dans les feuilles d’exercices. Voici quelques savoir-faire liés
à ce théorème que vous devriez savoir manier, au moins dans des cas simples :
– passage de expression régulière à grammaire régulière,
– passage de expression régulière à automate fini,
– passage de automate fini à automate fini déterministe complet,
– reconnaissance du fait qu’un langage N’EST PAS régulier (exemple-type : {an bn : n ∈ N}).
Une preuve générale de ce résultat sera donnée en annexe.
A Preuve des équivalences : régulier – reconnaissable – type 3

On désire donc prouver que, pour un langage L, il est équivalent d’affirmer que :
– L est régulier (c’est-à-dire que L peut être décrit par une expression régulière),
– L est reconnaissable (c’est-à-dire qu’il existe un automate fini qui reconnait L),
– L est de type 3 (c’est-à-dire qu’il existe une grammaire de type 3 qui engendre L).
A.1 Passage d’un AF à une grammaire régulière.

Soit donc un automate fini 26 A = (Σ, E, D, A, Θ) : comment obtenir une grammaire de type 3 qui engendre
le langage reconnu par cet automate ?
Rappelons que le langage L(A) des mots reconnus par cet automate est l’ensemble des étiquettes de chemins
dans A menant de l’un des états de départ à l’un des états acceptants, ainsi, le mot a1 a2 . . . an (où a1 , a2 ...
an appartiennent à Σ) est reconnu s’il existe dans Θ n transitions (e0 , a1 , e1 ), (e1 , a2 , e2 )... (en−1 , an , en ) telles
que :
a1 a2 an
D ∋ e0 −→ e1 −→ . . . en−1 −→ en ∈ A.
Soit alors S un nouveau symbole (n’appartenant pas à l’alphabet Σ ni à l’ensemble des états E), on définit une
grammaire G = (Σ, E ∪ {S} , S, Π) comme suit :
– l’alphabet terminal est l’alphabet Σ de l’automate A,
– l’alphabet non terminal est l’ensemble des états E de l’automate A auquel on ajoute le nouveau symbole
S,
– le symbole initial est S,
26. L’automate considéré n’a nul besoin d’être déterministe ni a fortiori complet.
– l’ensemble π des règles est constitué comme suit :

(groupe α) : pour chaque 27 état de départ d ∈ D, on crée la règle S −→ d,
(groupe β) : pour chaque état d’acceptation a ∈ A, on crée la règle a −→ ε,
(groupe γ) : pour chaque transition (e, x, f ) ∈ Θ, on crée la règle e −→ xf .
On voit alors que la lecture dans l’automate A du mot a1 a2 . . . an citée plus haut correspond à la dérivation
suivante dans la grammaire G :
S =⇒ e0 =⇒ a1 e1 =⇒ a1 a2 e2 . . . =⇒ a1 a2 . . . an−1 en−1 =⇒ a1 a2 . . . an−1 an en =⇒ a1 a2 . . . an−1 an
il est d’autre part clair que la production d’un mot quelconque de L(G) de longueur n s’obtient en ≪ mettant
bout à bout ≫ d’abord une transition du groupe α, puis n transitions du groupe γ, et enfin une transition du
groupe β... il y a donc bien identité entre le langage L(A) reconnu par l’automate A et le langage L(G) engendré
par la grammaire G.
Remarquons enfin que G est évidemment du type 3, (grammaire régulière) : nous venons de prouver que
tout langage reconnaissable par un automate est le langage d’une grammaire de type 3.
A.2 Passage d’une grammaire régulière à un AF.

Soit donc une grammaire G = (ΣT , ΣN T , S, Π) de type 3 (ce qui signifie que toute règle de Π est soit du type
A −→ αB : A, B ∈ ΣN T , α ∈ Σ∗T , soit du type A −→ α : A ∈ ΣN T , α ∈ Σ∗T ), comment construire un automate
qui reconnaı̂t le langage engendré par cette grammaire ?
On a vu dans ce qui précède qu’un automate ≪ traduit ≫ une grammaire dont les règles relèvent de l’un ou
l’autre des groupes que nous avons désignés ci-dessus ≪ α ≫, ≪ β ≫ et ≪ γ ≫ : il s’agit donc d’un cas particulier
de grammaire de type 3 –c’est-à-dire régulière – que nous appellerons ici grammaire d’AF.
La question que nous nous posons est donc la suivante : étant donnée la grammaire G = (ΣT , ΣN T , S, Π) de
type 3, peut-on en déduire une grammaire d’AF équivalente à G, c’est-à-direqui produit exactement le même
langage que G ? Si nous y parvenons, il nous sera alors facile de construire un automate fini qui reconnaı̂tra
exactement le langage produit à la fois par la grammaire d’AF et par la grammaire G.
Pour parvenir à cette fin, nous allons appliquer une série de transformations à la grammaire G, toutes les
grammaires ainsi créées seront des grammaires régulières équivalentes à G, et la dernière sera une grammaire
d’AF équivalente à G.
• Première transformation : Remarquons d’abord que l’on peut, sans perte de généralité, que l’axiome S
n’apparaı̂t dans aucun membre droit, sinon, il suffit d’introduire un nouveau symbole Ŝ, puis de remplacer
G par la grammaire régulière :
n o n o
(ΣT , ΣN T ∪ Ŝ , Ŝ, Ŝ −→ S ∪ Π)
de cette manière, on est assuré que l’axiome de notre grammaire ne peut apparaı̂tre dans un mot in-
termédiaire d’une dérivation : ce point sera utile lorsque nous supprimerons les ε-règles.
• Deuxième transformation : Parmi l’ensemble Π des règles de production de G, il nous faut chercher celles
qui ne relèvent d’aucun des groupes α, β et γ, puis les modifier en une ou plusieurs règles de l’un ou l’autre
de ces groupes, sans, bien entendu, modifier le langage engendré...
– une règle du type
A −→ α : A ∈ ΣN T , α ∈ Σ+
T avec α = a1 a2 . . . an : a1 , a2 . . . an ∈ ΣT
sera remplacée, en introduisant de nouveaux symboles non-terminaux X1 , X2 . . . Xn , par les n règles :
A −→ a1 X1 , X1 −→ a2 X2 , . . . , Xn−1 −→ an Xn , Xn −→ ε
qui appartiennent au groupe β pour la dernière et au groupe γ pour les autres,

– une règle du type
A −→ αB : A, B ∈ ΣN T , α ∈ Σ+
T, avec α = a1 a2 ...an : a1 , a2 ...an ∈ ΣT et n ≥ 2
sera remplacée, en introduisant de nouveaux non-terminaux X1 , X2 , . . . , Xn−1 , par les n règles :
A −→ a1 X1 , X1 −→ a2 X2 , . . . , Xn−1 −→ an B
qui appartiennent toutes au groupe γ.

27. Lorsqu’il y a un seul état de départ d, il est en fait inutile d’introduire le nouveau symbole S : il suffit de prendre d comme
symbole initial.
• Troisième transformation : Après ces premières séries de transformations, les seules règles qui pourraient
encore être non conformes au ≪ standard ≫ des grammaires d’AF seraient les 28
X −→ Y : X ∈ ΣN T \ {S} , Y ∈ ΣN T ,
(où le non-terminal de gauche X n’est pas l’axiome S, auquel cas la règle S −→ Y relèverait du groupe α
des grammaires d’AF) et nous nous plaçons donc désormais dans la situation où G = (ΣT , ΣN T , S, Π) est
une grammaire de type 3 comportant des ε-règles que nous voulons remplacer par des règles d’AF.
Nous utiliserons pour cela les relations 29 ≺ et ≍ dans l’ensemble ΣN T des non-terminaux :
+
∀X, Y ∈ ΣN T : ((X ≺ Y ) ⇔ (X =⇒ Y ))
et
∗ ∗
∀X, Y ∈ ΣN T : ((X ≍ Y ) ⇔ ((X =⇒ Y ) et (X =⇒ Y ))).
De façon générale, on va choisir, parmi chaque classe de non-terminaux interchangeables, l’un d’entre eux,
puis remplacer dans chaque règle chaque non-terminal par le représentant choisi dans sa ≪ classe d’inter-
changeabilité ≫, puis on supprimera toute ε-règle faisant intervenir deux non-terminaux interchangeables.
Après ces transformations, on obtient une nouvelle grammaire dont on se convainc aisément qu’elle
équivaut à la précédente et où la relation ≪ être remplaçable par ≫ (notée ≺) est sans circuit.
• Dernière transformation : Nous allons, pour chaque règle X −→ αY de cette nouvelle grammaire où
apparaı̂t dans le membre gauche un non-terminal Y tel que Y ≺ Z, ajouter la nouvelle règle X −→ αZ,
autrement dit, la règle X −→ αY est remplacée par les règles X −→ αY | αZ, on termine en supprimant
toutes les ε-règles restantes (sauf celles dont le membre gauche est l’axiome S), on obtient une nouvelle
grammaire dont on se convainc aisément qu’elle équivaut à la précédente et qui ne contient plus aucune
ε-règle... c’est-à-dire une grammaire d’AF !
Prenons l’exemple 30 G1 suivant :
S −→ aA | bB | cC, A −→ aA, E −→ eF, C −→ ε, D −→ ε, F −→ ε,

A −→ B, B −→ D, D −→ A, D −→ E, C −→ B.
On voit d’une part que l’axiome S n’apparaı̂t dans le membre droit d’aucune règle, et d’autre part que aucune
règle ne fait intervenir plusieurs symboles terminaux, ce qui rend inutiles les première et deuxième transforma-
tions décrites ci-dessus.
La seule difficulté provient des 5 ε-règles :
A −→ B, B −→ D, D −→ A, D −→ E, C −→ B,
on voit que A, B et D sont interchangeables, on décide donc (troisième transformation) de remplacer chaque
occurence de B et de D par A (tout en laissant les autres non-terminaux inchangés, puiqu’ils ne sont interchan-
geables qu’avec eux-mêmes), et l’on obtient une nouvelle grammaire G2 équivalente à G1, mais où la relation
≺ est sans circuit.
En particulier, les seules ε-règles de G2 sont : A −→ E, C −→ A, la relation ≺ se résume donc maintenant
à :
C ≺ A, A ≺ E, et, par transitivité : C ≺ E
28. Ce type de règles - dont l’exécution ne produit aucun terminal - est appelé ≪ ε-règle ≫.
29. On lira ≪ X est remplaçable par Y ≫ pour ≪ X ≺ Y ≫ et ≪ X est interchangeable avec Y ≫ pour ≪ X ≍ Y ≫.
On remarquera que ≺ est la fermeture transitive de la relation =⇒ restreinte à ΣNT ...
30. Pour alléger l’écriture, on ne donne que les règles de production, comme à l’habitude, les non-terminaux sont en majuscule
et les terminaux en minuscule, l’axiome est S.
d’où (quatrième transformation) une grammaire d’AF G3 équivalente aux deux précédentes :
G1 : G2 : G3 :
S −→ aA | bA S −→ aA | bA S −→ aA | aE | bA | bE
S −→ cC S −→ cC S −→ cC | cA | cE
A −→ aA A −→ aA A −→ aA | aE
E −→ eF E −→ eF E −→ eF
C −→ ε C −→ ε C −→ ε
A −→ ε A −→ ε A −→ ε
F −→ ε F −→ ε F −→ ε
A −→ B, B −→ D, D −→ A
D −→ E A −→ E
C −→ B C −→ A
Pour suggérer comment l’on montre l’équivalence de ces trois grammaires, envisageons la dérivation de G1
S =⇒ cC =⇒ cB =⇒ cD =⇒ cA =⇒ caA =⇒ caaA
=⇒ caaB =⇒ caaD =⇒ caaE =⇒ caaeF =⇒ caaeε = caae
obtenue en ≪ exécutant ≫ les productions suivantes de G1 : S −→ cC, C −→ B, B −→ D, D −→ A, A −→ aA,
A −→ aA, A −→ B, B −→ D, D −→ E, E −→ eF , F −→ ε.
Dans G2, cette dérivation devient :
S =⇒ cC =⇒ cA =⇒ caA =⇒ caaA =⇒ caaE =⇒ caaeF =⇒ caaeε = caae
en ≪ exécutant ≫ les productions suivantes de G2 :
S −→ cC, C −→ A, A −→ aA, A −→ aA, A −→ E, E −→ eF, F −→ ε.
Enfin, on obtient dans G3 la dérivation :
S =⇒ cA =⇒ caA =⇒ caaE =⇒ caaeF =⇒ caaeε = caae
en ≪ exécutant ≫ les productions suivantes de G3 :
S −→ cA, A −→ aA, A −→ aE, E −→ eF, F −→ ε.
Finalement, on remarquera que la grammaire G3 produit le langage reconnu par l’automate (non déterministe)
∗
A5 représenté ci-dessous (et qu’une expression régulière de ce langage est {c, ae, be, ce}∪{a, b, c}·{a} ∪{a, b, c}·
∗ ∗ ∗
{a} · {e}, soit, plus simplement{a, b, c} · {a} ∪ {a, b, c} · {a} · {e}) :
C
c
a
a|b|c
S A
a
a|b|c e
E F
Figure 10 – A5 (automate fini non déterministe équivalent aux grammaires G1, G2 et G3)
Résumons : nous venons de montrer que tout langage produit par une grammaire de type 3 est un langage
reconnaissable par un automate fini.
A.3 Passage d’une expression régulière à une grammaire régulière.

Soit donc un langage régulier, montrons qu’il est possible de proposer une grammaire régulière qui produit
par ce langage.
Nous avons donné une définition récursive de la classe des langages réguliers :
– tout langage fini est régulier,

– la réunion de deux langages réguliers est un langage régulier,
– la concaténation de deux langages réguliers est un langage régulier,
– l’étoile d’un langage régulier est un langage régulier,
– les seuls langages réguliers sont ceux que l’on peut obtenir par application des règles précédentes.
Il nous reste donc à proposer une construction récursive d’une grammaire pour un langage régulier quelconque...
– Soit L = {α1 , . . . , αn } un langage fini sur l’alphabet Σ, notons alors S un nouveau symbole, alors la
grammaire
(Σ, {S} , S, {S −→ α1 | · · · | αn })
est une grammaire régulière qui produit le langage L.
– Soit maintenant G une grammaire régulière, en introduisant un nouveau non-terminal Z, en remplaçant
chaque règle terminale X −→ α de G par la règle X −→ αZ, puis en ajoutant la règle Z −→ ε, on obtient
une grammaire régulière équivalente à G et dont la seule règle terminale est Z −→ ε.
– Soient maintenant G′ = (Σ′T , Σ′N T , S ′ , Π′ ) et G” = (ΣT ”, ΣN T ”, S”, Π”) deux grammaires régulières, on
peut supposer que la seule règle terminale de G′ est Z −→ ε ; quitte à renommer certains symboles, on
peut aussi supposer que les alphabets {S}, Σ′N T , ΣN T ” etΣ′T ∪ ΣT ” sont deux à deux disjoints.
On pourra alors vérifier que :
– la grammaire
(Σ′T ∪ ΣT ”, {S} ∪ Σ′N T ∪ ΣN T ”, S, {S −→ S ′ | S”} ∪ Π′ ∪ Π”)
est une grammaire régulière qui produit le langage L(G′ ) ∪ L(G”),
– la grammaire
(Σ′T ∪ ΣT ”, Σ′N T ∪ ΣN T ”, S ′ , (Π′ \ {Z −→ ε}) ∪ {Z −→ S”} ∪ Π”)
est une grammaire régulière qui produit le langage L(G′ ) · L(G”),
– la grammaire
(Σ′T , Σ′N T , S ′ , {S ′ −→ ε} ∪ Π′ ∪ {Z −→ S ′ })
est une grammaire régulière qui produit le langage (L(G′ ))∗ .
La définition récursive des langages réguliers nous permet donc de conclure que tout langage régulier peut être
produit par une grammaire de type 3.
A.4 Passage d’une grammaire régulière à une expression régulière.

Pour terminer notre preuve de l’équivalence annoncée dans le théorème 7, il nous resterait à justifier qu’il
est possible de proposer une expression régulière pour tout langage engendré par une grammaire de type 3.
Remarquons d’abord que dans la cas (certes simplissime !) où il n’y a qu’un seul non terminal, alors la
grammaire étudiée est du type 31
G = (ΣT , {S} , S, {S −→ α1 S | · · · | αa S} ∪ {S −→ β1 | · · · | βb })
les mots α1 , . . . , αa , β1 , . . . , βb étant terminaux.

On montre alors aisément que L(G) est le langage régulier :
∗
{α1 , . . . , αa } · {β1 , . . . , βb } .
Dans un deuxième temps, supposons que nous sachions déterminer une expression régulière d’un langage
produit par une grammaire régulière, pourvu que cette grammaire ait au plus n non-terminaux, et envisageons
une grammaire régulière
G = (ΣT , ΣN T , S, Π)
ayant n + 1 non-terminaux.
Quitte à renommer les n + 1 éléments de ΣN T , on peut supposer que ΣN T = {S, X1 , X2 , . . . , Xn }, puis que :
Π = Π′ ∪ {S −→ β1 | · · · | βb , S −→ α0,1 S | · · · | α0,a0 S,
S −→ α1,1 X1 | · · · | α1,a1 X1 , . . . , S −→ αk,1 Xk | · · · | αk,ak Xk }
on a supposé, dans les notations ci-dessus, que Π′ contient toutes les règles ne comportant pas l’axiome S à
gauche, et que les variables intervenant dans les règles de Π \ Π′ sont S, X1 ... Xk .
31. En séparant les règles terminales des règles non terminales...
Étudions alors les grammaires
Gi = (ΣT ∪ {S} , {X1 , X2 , . . . , Xn } , Xi , Π′ )
où 1 ≤ i ≤ n : chacune de ces grammaires a exactement n non-terminaux, il est donc possible (d’après notre
hypothèse de récurrence) de donner une expression régulière (sur l’alphabet ΣT ∪ {S}) de son langage L(Gi ).
On remarquera que cette expression contient éventuellement le symbole S qui a, dans Gi , le statut de
terminal... Cependant, le fait que S n’apparaı̂t que complètement à droite dans les règles de Π – et donc dans
celles de Π′ – nous permet de supposer une écriture de L(Gi ) sous une forme
L(Gi ) = Li ∪ L′i · {S}
où Li et L′i sont des expressions régulières sur l’alphabet ΣT .

Notons maintenant :
B = {β1 , . . . , βb }
A = {α0,1 , . . . , α0,a0 }
A1 = {α1,1 , . . . , α1,a1 }
..
.
Ak = {αk,1 , . . . , αk,ak } ,
(ces ensembles sont réguliers car finis).

On a, en quelque sorte, réécrit les règles de G sous la forme suivante, où les ≪ coefficients ≫ B, A, Ai , Li et
L′i sont des expressions régulières (sur l’alphabet ΣT , bien sûr) :
∗
S =⇒ B | AS | A1 X1 | . . . | Ak Xk
∗
X1 =⇒ L1 | L′1 S
..
.
∗
Xk =⇒ Lk | L′k S
∗
Xk+1 =⇒ Lk+1 | L′k+1 S
..
.
∗
Xn =⇒ Ln | L′n S
d’où l’on déduit que le langage L(G) admet l’expression régulière suivante :
L(G) = (A ∪ A1 · L′1 ∪ · · · ∪ Ak · L′k )∗ · (B ∪ A1 · L1 ∪ · · · ∪ Ak · Lk )
ceci achève la preuve par récurrence du fait que le langage produit par une grammaire régulière quelconque
admet une expression régulière.
De façon plus générale, nous venons d’achever la preuve de l’équivalence annoncée dans le théorème 7, à
savoir que les trois ≪ procédés ≫ : automates finis, grammaires de type 3 et expressions régulières ont la même
≪ puissance ≫, c’est-à-dire qu’ils engendrent une seule et même classe de langages.
B Syntaxes des expressions régulières en Tcl

B.1 REGULAR EXPRESSION SYNTAX
A regular expression is zero or more branches, separated by |. It matches anything that matches one of the
branches.
A branch is zero or more pieces, concatenated. It matches a match for the first, followed by a match for the
second, etc.
A piece is an atom possibly followed by *, +, or ?. An atom followed by * matches a sequence of 0 or more
matches of the atom. An atom followed by + matches a sequence of 1 or more matches of the atom. An atom
followed by ? matches a match of the atom, or the null string.
An atom is a regular expression in parentheses (matching a match for the regular expression), a range (see
below), . (matching any single character), ^ (matching the null string at the beginning of the input string),
$ (matching the null string at the end of the input string), a \ followed by a single character (matching that
character), or a single character with no other significance (matching that character).
A range is a sequence of characters enclosed in []. It normally matches any single character from the
sequence. If the sequence begins with ^, it matches any single character not from the rest of the sequence. If
two characters in the sequence are separated by -, this is shorthand for the full list of ASCII characters between
them (e.g. [0-9] matches any decimal digit). To include a literal ] in the sequence, make it the first character
(following a possible ^). To include a literal -, make it the first or last character.
B.2 AMBIGUITY
If a regular expression could match two different parts of the input string, it will match the one which begins
earliest. If both begin in the same place but match different lengths, or match the same length in different ways,
life gets messier, as follows.
In general, the possibilities in a list of branches are considered in left-to-right order, the possibilities for ‘*’,
‘+’, and ‘ ?’ are considered longest-first, nested constructs are considered from the outermost in, and concate-
nated constructs are considered leftmost-first. The match that will be chosen is the one that uses the earliest
possibility in the first choice that has to be made. If there is more than one choice, the next will be made in the
same manner (earliest possibility) subject to the decision on the first choice. And so forth.
For example, (ab|a)b*c could match abc in one of two ways. The first choice is between ab and a ; since
ab is earlier, and does lead to a successful overall match, it is chosen. Since the b is already spoken for, the b*
must match its last possibility-the empty string-since it must respect the earlier choice.
In the particular case where no |s are present and there is only one *, +, or ?, the net effect is that the
longest possible match will be chosen. So ab*, presented with xabbbby, will match abbbb. Note that if ab* is
tried against xabyabbbz, it will match ab just after x, due to the begins-earliest rule. (In effect, the decision on
where to start the match is the first choice to be made, hence subsequent choices must respect it even if this
leads them to less-preferred alternatives.)
In addition\w matches an alphanumeric character (including_) an\W a nonalphanumeric. Word boundaries
may be matched b\b and non-boundaries b\B. A whitespace character is matched by \s, a non-whitespace b\S.
A numeric character is matched b\d, non-numeric b\D. You may use \w, \s and \d within character classes.
The class of character recognized by \w (and hence not recognized by \W), can be augmented via the
addAlphaChars command.
C Expressions régulières en environnement unix

Nous allons tenter de décrire rapidement l’implémentation en environnement unix des expressions régulières.
Signalons tout d’abord que les caractères suivants :
. + * [ ] - ^ $ { } ? ... \ / ( )
sont des métacaractères : pour obtenir , par exemple, qu’un point soit interprété littéralement, il faut écrire \..
Décrivons quelques uns de ces métacaractères :
. n’importe quel caractère, sauf le saut de ligne \n
[...] (classe de caractères) Par exemple, [0123456789] signifie tout mot composé de un seul chiffre décimal,
on peut écrire plus rapidement [0-9]. ainsi [A-Za-z] signifie tout mot composé de une seule lettre.
[^...] (complémentaire d’une classe de caractères) Par exemple, [^0123456789] ou [^0-9] signifie tout mot
composé de un caractère, à condition que celui-ci ne soit pas un chiffre décimal.
\ caractère d’échappement pour les métacaractères (cf. ci-dessus).
* signifie zéro, une ou plusieurs occurences de l’expression régulière précédente, ainsi [0-9]* accepte-t-elle 14,
7, 1789, le mot vide mais pas 1.789.
+ signifie une ou plusieurs occurences de l’expression régulière précédente, ainsi [0-9]+ accepte-t-elle 14, 7,
1789, mais pas le mot vide ni 1.789.
? signifie zéro ou une occurence de l’expression régulière précédente, ainsi [0-9]? accepte-t-elle 7 ou le mot vide,
mais pas 14 ni 1.789.
(...) permet de regrouper plusieurs expressions régulières en une seule, ainsi abc? accepte-elle les seuls mots
ab et abc, tandis que a(bc)? accepte les seuls mots a et abc.
| permet de réaliser une disjonction (ou) entre deux expressions, ainsi [0-9]+|[0-9]*\,[0-9]+ accepte-t-elle
d’une part les suites de un ou plusieurs chiffres, d’autre part les suites de zéro, un ou plusieurs chiffres
suivies d’une virgule suivies d’une suite de un ou plusieurs chiffres.
À titre d’exemple, le lecteur vérifiera que l’expression régulière suivante (dans laquelle on a ajouté des espaces
pour faciliter la lecture) :
[-+]? ( ([0-9]+ )| ([0-9]*\,[0-9]+ ) ([eE][-+]?[0-9]+)? )
décrit la notation dite scientifique des nombres décimaux, la partie ≪ exponentielle ≫ étant optionnelle.
Voici une situation courante en programmation : vous avez écrit un programme en C++, mais en faisant
les commentaires à la mode C++ (depuis \\ jusqu’à la fin de la ligne) que vous décidez de transformer en
commentaires à la mode C (entre \* et *\). Il suffit pour cela, à l’aide d’un langage de macrocommandes tel
que perl ou tcl de remplacer dans tout le fichier les //(.*) par des /* \1 */, sachant que \1 signifie ≪ le
contenu du couple de parenthèses dans la chaı̂ne de caractères repérée par //(.*) ≫.
D Une calculatrice en Lex et Yacc

D.1 Situation
Dans le cadre d’un projet de synthèse réalisé en mars – avril 1996, il était demandé à des étudiants 32 de
réaliser une ébauche de compilateur Pascal. Nous présentons ici une (toute petite) partie de leur travail.
Il s’agissait de construire un programme (en langage C) qui accepte en entrée une expression algébrique entre
nombre décimaux, et qui renvoie un message d’erreur si cette expression est syntaxiquement incorrecte, et qui
renvoie la valeur de cette expression sinon, cette valeur étant calculée en respectant les priorités habituelles
en mathématiques ou dans les langages de programmation courants – comme Pascal. Ainsi, l’expression 1 +
17, 89 + ∗10 devait être signalée comme incorrecte, par contre 14 ∗ −7 + 17, 89/100 ∗ (−3 + 13) devait être évaluée
comme −19, 211...
D.2 Réalisation
Ce projet a été réalisé sous environnement AIX (version ibm de unix système V) à l’aide des outils Lex et
Yacc.
Le travail se décompose en trois étapes :
– on écrit en Lex un analyseur lexical qui décompose le fichier d’entrée – c’est-à-dire ici l’expression
arithmétique à évaluer – en éléments (tokens), on remarquera l’usage d’expressions régulières. Ici, le seul
token utilisé est NOMBRE, mais dans un ≪ vrai ≫ compilateur, on utiliserait des tokens IDENTIFICATEUR,
INSTRUCTION...
– cette décomposition en tokens étant réalisée, on donne en Yacc les règles de grammaire ainsi que les
instructions à exécuter losque l’une de ces règles est utilisée
– il reste à compiler ces deux programmes pour obtenir un programme C qui une fois qu’il sera lui-même
compilé, fera le travail demandé !
D.3 calc.l – Le programme Lex

%{
/********************************************************
* Analyseur Lexical de la calculatrice *
********************************************************/
#include "y.tab.h"
%}
%%
(([0-9]+)|([0-9]*\,[0-9]+)) { yylval.dval = atof(yytext);
return NOMBRE; } ;/* entiers ou flottants */
[ \t] ; /* ignore les espaces */
\n return 0; /* fin de fichier logique */
. return yytext[0]; /* on renvoie le reste */
%%
32. Ces étudiants – Sylvie Ansart, Nicolas Bredeche, Cédric Caron, Cédric Lesperres, Alexandre Mazel, Stéphane Petit
et Philippe Regnauld – ont travaillé sous la direction de Mikal Ziane et de Max Chlebowski. Nous tenons à remercier les dits
étudiants d’avoir bien voulu réaliser ces petits programmes afin de donner une illustration de ce cours de théorie des langages.
D.4 calc.y – Le programme Yacc

%{
/* Analyseur syntaxique de la calculatrice implicite */
#include <stdio.h>
%}
%union { double dval;} /* ?? union pour utiliser un float */
%token <dval> NOMBRE /* le token NOMBRE est dval (float)*/
%nonassoc UNAIRE /* gestion des signes unaires -/+ */
%type <dval> expression /* les expressions composantes */

%type <dval> terme /* les termes des expressions */
%type <dval> facteur
%%
expression:
expression ’+’ terme { $$ = $1 + $3;}
| expression ’-’ terme { $$ = $1 - $3;}
| terme
;
terme:
terme ’*’ facteur { $$ = $1 * $3; }
| terme ’/’ facteur {
if ($3 == 0)
{ yyerror("division par zero");
return(1);
}
else $$ = $1 / $3; }
| facteur
;
facteur:
’(’ expression ’)’ {$$ = $2;}
| ’-’ facteur { $$ = -$2; }
| ’+’ facteur { $$ = $2; }
| NOMBRE
;
%%
main()
{
int res;
do
{ res = yyparse(); }
while(!res);
}
D.5 Compilations
Il reste à compiler ces fichiers, ce qui se fait en plusieurs étapes :
>lex calc.l
>yacc -d calc.y
>cc -c lex.yy.c y.tab.c
>cc -o ako lex.yy.o y.tab.o -ly -ll
ce qui peut se lire comme suit :

– par la première ligne, on compile dans lex le fichier calc.l et on obtient le fichier lex.yy.c décrivant notre
analyseur lexical en langage C (un utilisateur patient qui lirait ce fichier y verrait les tables de transition
des automates fabriqués par lex pour reconnaı̂tre les expressions régulières données dans calc.l),
– par la deuxième ligne, on compile dans yacc le fichier calc.y, on obtient les fichiers y.tab.c et y.tab.h
correspondants (en langage C, toujours)
– par les deux dernières lignes, on compile les différents fichiers en les liant à la librairie lex.
On obtient enfin un executable ako qu’il suffit d’invoquer pour faire ses petits calculs... Cette façon de
procéder peut paraı̂tre lourde, mais le code (c’est-à-dire les deux fichiers calc.l et calc.y ci-dessus) est en fait
extrêmement court, ce qui limite beaucoup le temps de mise au point.
exercices de théorie des langages 1
I.U.T. de Lille - Département Informatique

Mathématiques
Exercices de théorie des langages
version du 5 décembre 2008
Exercice 1 - Quelques opérations simples entre langages.

Soient les langages Σ = {a, b, c}, L1 = {cab, ba} et L2 = {aa, ba, ε}.
Décrire chacun des langages suivants :
L1 ∩ L2, L1 ∪ L2, L1 \ L2, L2 \ L1, L1 · L2, L2 · L1,

2 2 ∗ + ∗
L1 , L2 , L2 , L2 , Σ .
Exercice 2 - Exercice simple.

1 - Donner des exemples de langages finis.
2 - Soit L un langage... c’est-à-dire un ensemble de mots. On rappelle la définition inductive suivante :
L0 = {ε} et pour n ≥ 0, Ln+1 = LLn .
Soit Σ un alphabet, autrement dit, Σ est un langage dont chaque mot est de longueur 1. Montrer par récurrence
que Σn est l’ensemble des mots de longueur n construits sur Σ. Rappeler comment Σ∗ et Σ+ peuvent être
écrits comme réunion de certains Σn .
3 - 3.1 - Soit le langage L = {a}.
Quel est le nombre
S S de mots du langage L10 ? du langage Li ? Quel est le nombre de mots du S langage
i
1≤i≤10 L où désigne l’union des langages ? De même, déterminer le nombre de mots de 0≤i≤n Li ,
S
puis le nombre de mots de 1≤i≤n Li .
3.2 - Répondre aux mêmes questions pour L = {ε, a}.
3.3 - Idem pour L = {a, aa}.
3.4 - Idem pour L = {b, aa}.
Exercice 3 - Intersection, concaténation.

Soit l’alphabet Σ = {a, b} et soient les langages :
L1 = {an bp : n, p ∈ N} L2 = {an bn : n ∈ N}
et
L3 = {an : n ∈ N} = a∗ L4 = {bn : n ∈ N} = b∗
On rappelle que, par convention, on pose a0 = b0 = ε.
1 - Donner des mots de chacun des langages.
2 - Déterminer l’intersection L1 ∩ L2.
3 - Déterminer les mots de L1 qui ne sont pas dans L3 puis ceux de L2 qui ne sont pas dans L4 (en d’autres
termes, déterminer L1 \ L3 et L2 \ L4).
4 - Pourquoi peut-on écrire que L1 = L3 · L4, c’est-à-dire que {an bp : n, p ∈ N} = a∗ b∗ ?
Peut-on aussi écrire que L2 – c’est-à-dire {an bn : n ∈ N} égale aussi a∗ b∗ ?
Exercice 4 - Exemples de langages.

1 - Décrire le langage dont les mots sont les éléments de N (plus précisément, on demande de donner une
expression régulière du langage des écritures en base dix d’entiers naturels).
2 - Décrire le langage dont les mots sont les éléments de Z.
3 - Soit B = {1, 2, 3, 4, 5, 6, 7, 8, 9} et A = {0} ∪ B deux alphabets.
3.1 - Quel est le langage B · A∗ · {0} ∪ {0} ?
3.2 - Écrire le langage des multiples entiers naturels de 5, puis celui des entiers naturels strictement
inférieurs à 1000.
Exercice 5 - Quelques expressions régulières.

Soit l’alphabet Σ = {a, b}. Montrer les résultats suivants :
1 - Σ ∗ = Σ∗ Σ ∗ ,
2 - Σ∗ = Σ∗ {ab} Σ∗ ∪ b∗ a∗ ,
3 - Σ∗ = (a∗ ∪ {b})∗ ,
4 - Σ∗ = (a∗ ∪ b∗ )∗ ,
5 - Σ∗ = (a∗ b∗ )∗ ,
6 - (ab)∗ a = a(ba)∗ ,
7 - ε∗ = {ε} (que vaut ∅∗ ?),
8 - b∗ ∪ ab∗ = {ε, a} b∗ ,
9 - (a∗ )∗ = a∗ ,
∗
10 - ({aa} ∪ (ab)∗ )∗ 6= {a, ab} ,
11 - Σ∗ 6= a∗ b∗ .
Exercice 6 - Quelques expressions régulières.

Soit l’alphabet Σ = {a, b, c}. Pour chacun des langages suivants, proposer une expression régulière :
1 - Langage des mots sur Σ commençant par a,
2 - Langage des mots sur Σ commençant et se terminant par a,
3 - Langage des mots sur Σ commençant et se terminant par la même lettre,
4 - Langage des mots sur Σ commençant et se terminant par des lettres distinctes,
5 - Langage des mots sur Σ contenant au moins un a,
6 - Langage des mots sur Σ contenant exactement un a,
7 - Langage des mots sur Σ ne contenant aucun a,
8 - Langage des mots sur Σ contenant un nombre pair de a,
9 - Langage des mots sur Σ contenant un nombre impair de a,
Exercice 7 - Concaténation.
1 - Soit Σ un alphabet, ¡¡·¿¿ l’opération de concaténation définie sur Σ∗ , et (Σ∗ , ·) le monoı̈de libre (Un
monoı̈de est un ensemble muni d’une loi interne et associative, un monoı̈de libre est un monoı̈de admettant
un élément neutre) des mots sur Σ.
1.1 - Rappeler pourquoi (Σ∗ , ·) est un monoı̈de libre.
1.2 - Montrer que (N, +) est un monoı̈de libre.
1.3 - Montrer que l’application ¡¡longueur¿¿ est un homomorphisme de monoı̈de libre. Cette application
est définie par :
|. . .| : Σ∗ → N, m 7→ |m|
où |m| désigne la longueur du mot m, c’est-à-dire le nombre de lettres de m.
2 - À quelle condition sur Σ l’opération de concaténation est- elle commutative dans Σ∗ ?
3 - Montrer que la proposition suivante est fausse : (quels que soient L1, L2, L3 trois langages construits sur
Σ, on a : L1 · L2 = L1 · L3 ⇒ L2 = L3).
4 - Montrer en revanche que la proposition suivante est vraie : (quels que soient m1, m2, m3 trois mots de
Σ∗ , on a : m1 · m2 = m1 · m3 ⇒ m2 = m3).
Exercice 8 - Équations entre langages.

Soit Σ un alphabet et soient B, C, D et L des langages sur Σ.
1 - Montrer que B · (C ∪ D) = (B · C) ∪ (B · D).
2 - Montrer que B · (C ∩ D) ⊆ (B · C) ∩ (B · D).
3 - Soit B = {a, b}∗ . Si C = {ε, a} et si D = {ε, b}, est-il exact que BC = BD ? A-t-on (BC = BD) ⇒ (C =
D) ?
4 - Que peut-on dire de {ε}·L ? De ({ε}∪L)∗ ? De (L∗ )∗ ? Et de {ε} ∪(L ·L∗ ? Est-il vrai que L+ = L∗ \ {ε} ?
Exercice 9 - Quelques AFdc sur l’alphabet Σ = {a, l, m, n}.

On considère les automates finis représentés par :
l|m|n l|m|n l|m|n
1 2 1 2 1 2
a a a
a l|m|n a l|m|n a l|m|n
Aut1 3 Aut2 3 Aut3 3
a|l|m|n a|l|m|n a|l|m|n

l|m|n l|m|n l|m|n
1 2 1 2 1 2
a a a
a l|m|n a l|m|n a l|m|n
Aut4 3 Aut5 3 Aut6 3
a|l|m|n a|l|m|n a|l|m|n
1 - On considère Aut1.
1.1 - Comment sont lus les mots : lama, maman, laamll, ε ? Quels sont ceux qui sont acceptés ?
1.2 - Mêmes questions pour Aut1bis :
l|m|n
1 2
a
(attention, il s’agit cette fois d’un AF déterministe mais non complet).

2 - Quel est le langage reconnu par Aut1 et par Aut1bis ? Essayez de justifier votre réponse...
3 - Pour chacun des 5 automates Aut2 à Aut6, donner une expression (si possible régulière) du langage qu’il
reconnaı̂t.
4 - Proposer un automate qui reconnaı̂t le même langage que Aut3, mais qui soit plus simple.
Même question pour Aut4.
Exercice 10 - Constructions d’automates sur Σ = {a, b, c}. Proposer des automates (AFdc, puis, si c’est
plus simple, AFd) reconnaissant chacun des langages suivants :
Σ∗ , {ε}, Σ, Σ2 , langage des mots de longueur au plus 2, langage des mots de longueur 2 ou plus, ∅, langage
des mots commençant par a, langage des mots sans voyelle, langage des mots ne contenant pas deux lettres
différentes, langage des mots ne contenant pas deux fois la même lettre.
Pour chacun de ces langages, proposer une expression régulière.
Exercice 11 - Un AFnd.
Soit Σ = {a, b, c}, on désire construire un AF, le plus simple possible, qui reconnaisse le langage des mots sur
Σ qui contiennent le mot bac et se terminent par a.
1 - Donner une expression régulière de ce langage.
2 - Dessiner un AF, le plus simple possible, qui reconnaisse ce langage.
3 - Indiquer comment votre AF lit chacun des mots suivants (plus précisément, on demande d’indiquer toutes
les lectures de chaque mot) :
abaca, abacb, abacbaca, bcaa, bcab, ε.
4 - Donner la ¡¡définition mathématique¿¿ complète de votre AF.

5 - Par le procédé décrit en cours, transformer votre AF en un AFDC qui reconnaı̂t le même langage.
6 - Indiquer comment votre AFDC lit chacun des mots proposés à la question 11.3.
Exercice 12 - Un autre AFnd.

Reprendre les questions de l’exercice 11 pour le langage sur Σ = {a, b, c} des mots qui contiennent le mot bac
ou se terminent par a.
Exercice 13 - Des automates finis simples.

Soit Σ = {a, b} un alphabet et soient les langages suivants : L1 = {an : n ≥ 0}, L2 = {bn : n ≥ 0} , L3 = L1L2.
1 - Déterminer un automate fini dont le langage soit L1.
2 - Le langage L3 est-il le langage d’un automate fini ? Si le réponse est oui, construire un tel automate.
3 - Construire une grammaire dont le langage soit L3.
Exercice 14 - Des automates finis simples.

Soit Σ = {a, b, c} un alphabet. Déterminer un automate fini associé aux langages suivants construits sur Σ :
1 - le langage L1 des mots contenant au moins la suite de 3 lettres abc,
2 - le langage L2 des mots contenant exactement 4 b,
3 - le langage L3 des mots commençant par (a ou c), et se terminant par b.
Exercice 15 - Transformations d’AFnd en AFdc.

1 - Soit l’automate ({a, b} , {0, 1, 2} , {0} , {2} , Θ) où Θ est donnée par sa table de transition :
a b
− 0 0|1 1
1 2
2 + 0|1|2 1
Pourquoi cet AF n’est-il pas déterministe complet ? Construire un AFdc qui reconnaisse le même langage.
2 - Mêmes questions pour l’automate ({a, b} , {0, 1, 2} , {0, 1, 2} , {2} , Θ).
3 - Mêmes questions pour l’automate ({a, b} , {0, 1, 2} , ∅, {2} , Θ).
4 - Mêmes questions pour l’automate ({a, b} , {0, 1, 2} , {0} , {0, 1, 2} , Θ).
Exercice 16 - Transformations d’AFnd en AFdc.

Pour chacun des deux automates représentés ci-dessous, construire un AFdc qui reconnaisse la même langage :
a
a
4 5 b
2 5
a a
b b a c
b b 1 4 7
b a c b
1 2 3 c
3 6
a|b a a
Exercice 17 - Palindromes ¡¡Esope reste ici et se repose¿¿

Soit Σ un alphabet et L un langage sur Σ. On définit sur Σ∗ l’opération unaire d’¡¡image miroir¿¿ notée . . .µ :
∀m ∈ Σ∗ :
((m = a1 a2 . . . an−1 an et ∀i ∈ {1, 2 . . . n} : ai ∈ Σ) ⇒ mµ = an an−1 . . . a2 a1 ) .
On pose aussi εµ = ε, le mot mµ est donc appelé ¡¡image miroir¿¿ du mot m. Un mot de Σ∗ tel que mµ = m
est appelé palindrome (Par exemple la suite de symboles ¡¡Esope reste ici et se repose¿¿ est un palindrome, si
du moins on ne tient pas compte des espaces).
On définit le langage miroir de L par
Lµ = {n ∈ Σ∗ : ∃m ∈ L, n = mµ } = {mµ : m ∈ L} .
Parmi les propriétés suivantes, indiquer celles qui sont vraies :
1 - Quel que soit le mot m ∈ L : mmµ = (mmµ )µ ,

2 - quel que soit le langage L construit sur l’alphabet Σ : L = (Lµ )µ ,
3 - quel que soit x appartenant au langage L ∩ Lµ , on a x = xµ ,
4 - quels que soient les deux langages L1 et L2 construits sur Σ, (L1L2)µ = (L2µ )(L1µ ),
5 - quel que soit le langage L construit sur Σ, quel que soit n de N : (Ln )µ = (Lµ )n ,
6 - quels que soient m ∈ L et n ∈ L, on a : (nmn = (nmn)µ ) ⇒ (m = mµ ).
Exercice 18 - Langage impair.

On considère dans tout l’exercice l’alphabet Σ = {a, b}. On note impair l’ensemble des mots comportant un
nombre impair d’occurrences de la lettre a. Soient A1, A2 les automates finis donnés par les schémas suivants :
a a a
1 2 1 2 3
a a
A1 A2
b b b b b
1 - Soit W le langage b∗ ab∗ . Construire un automate fini A3 tel que L(A3) = W .

2 - Construire 5 mots de L(A1). Combien ces mots comportent-ils d’occurrences de la lettre a ? Démontrer
que L(A1) est inclus dans impair.
3 - Démontrer, par récurrence sur le nombre d’occurrences de la lettre a, que impair est inclus dans L(A1).
Déduire des questions précédentes que : impair = L(A1).
4 - Comparer les mots de L(A2) avec les mots de L(A1). En déduire un caractérisation de L(A2).
5 - Soit la grammaire G = (ΣT , ΣN T , S, Π) suivante : ΣN T = {S, F }, ΣT = {a, b}, P i est l’ensemble des
règles sont :
S −→ bS | aF
F −→ bF | aS | ε.
Construire 5 mots de L(G). A-t-on L(G) = L(A1) ou L(G) = L(A2) ? Présenter la démontration de votre
réponse.
6 - Comparer L(A3) avec L(A1) et L(A2).
Exercice 19 - Automates finis simples.

Déterminer les langages de :
a, b
1 2 1
a|b a|b
a|b a|b a|b

1 2 1 2 3
a|b a|b
Exercice 20 - Automates finis. On traitera les deux questions indépendamment l’une de l’autre...
1 - Soit A l’automate fini ci-dessous :
2
a a
1 a b 4
b b
3
a|b
∗ ∗
Démontrer que : L(A) = {a, b} {aa, bb} {a, b} .
∗ ∗
2 - Déterminer un AF dont le langage soit {a, b} {aa, bb} {a, b} . L’automate fini sera déterministe com-
plet, bien sûr, mais rien n’interdit de passer d’abord par un automate fini non déterministe, de le rendre
déterministe, et enfin de simplifier l’AFdc obtenu.
Exercice 21 - Automate fini simple.

Déterminer le langage de chacun des automates suivants :
b a a
1 2 3 4
b
1 2
b b a
a 5 a|b
a b
a|b

Soit l’automate :
b
1 2
b
a a a a
b
4 3
b
Caractériser son langage.

Construire un automate fini dont le langage soit Σ∗ aaΣ∗ , où Σ = {a, b}.
Exercice 24 - Des langages finis.

Soit l’alphabet Σ = {a, b, c}, on pose Σ̂ = {a, b}, puis L1 = Σ̂3 cΣ̂Σ et L2 = Σ̂3 cΣ.
1 - Montrer que L1 ⊆ L2.
2 - A-t-on L2 ⊆ L1 ?
3 - Construire un automate fini A1 dont le langage soit L1.
4 - Construire une grammaire G1 dont le langage soit L1.
5 - Construire une grammaire G2 et un un automate fini A2 dont le langage soit L2.
Exercice 25 - Deux grammaires simples.

Soient G1 et G2 les deux grammaires suivantes :
G1 = ({a, b, c} , {S} , S, {S −→ aSb | c})

et :
G2 = ({a, b, c, d, e} , {S, X} , S, {S −→ aSb | X | c, X −→ eXd | ε})
1 - Donner tous les mots de longueur inférieure ou égale à 5 dérivés par la grammaire G1.
2 - Donner tous les mots de longueur inférieure ou égale à 5 dérivés par la grammaire G2.
3 - Démontrer que L(G1) = {an cbn : n ∈ N}.
4 - Quel est le langage L(G2) ?
5 - Montrer que L(G1) ⊆ L(G2).
Exercice 26 - Types de grammaire, types de langage.

Soit la grammaire G = (ΣT , ΣN T , S, Π) où :
ΣT = {a, b, c}, ΣN T = {S, X}, Π = {S −→ XabX, X −→ aX | bX | cX | ε}.
1 - Construire l’arbre de dérivation du mot (ab)2 (cb)2 .
2 - Le mot a4 cb est-il dérivable dans G ? Pourquoi ?
3- 3.1 - Déterminer le langage L(G).
3.2 - Ce langage est-il produit par un automate fini ? Pourquoi ?
3.3 - Déterminer un grammaire dont le langage L(G), et dont les règles sont du type suivant : X −→ m
ou X −→ mY avec m ∈ Σ∗T et X, Y ∈ ΣN T (En d’autres termes, on cherche une grammaire de type 3 – ou
grammaire régulière – équivalente à G...).
3.4 - Quels sont les types de grammaires envisagées dans cet exercice ? Quel est le type du langage
considéré ?
4 - Déterminer un automate fini A tel que L(A) = L(G).
Exercice 27 - Quatre grammaires.

Soient les quatre grammaires :
G1 = ({a, b} , {S, X, Y } , S, {S −→ XabaY, X −→ bX | b, Y −→ aY | bY | ε}),

G2 = ({a, b} , {S} , S, {S −→ aS | bS | a | b}),
G3 = ({a, b} , {S, X, Y } , S, {S −→ X | Y, X −→ ε, Y −→ aY | bY | a | b}),
G4 = ({a} , {S} , S, {S −→ aS | ε})
et soient les quatre langages :

∗
E1 = a∗ , E2 = {a, b} , E3 = E2 \ {ε} , E4 = b∗ (ba)2 E2.
1 - Attribuer à chaque grammaire son langage.

2 - Les expressions proposées pour les langages sont-elles régulières ? Si non, proposer des expressions régu-
lières pour ces langages.
3 - Les grammaires proposées sont-elles régulières ? Si non, proposer des grammaires régulières qui engendrent
les mêmes langages.
Exercice 28 - Un langage simple.

Soit Σ = {a, b}. Soit L le langage des mots sur Σ dont la première et la dernière lettre sont distinctes.
1 - Construire un automate fini engendrant ce langage.
2 - Construire une grammaire engendrant ce langage.
3 - Donner une expresion régulière de ce langage.
Exercice 29 - Un langage non régulier.

Démontrer qu’il n’existe pas d’automate fini dont le langage est L = {an bn : n ∈ N }.
En quoi cela justifie-t-il qu’il n’existe aucune expression régulière pour ce langage ? Justifier que, en revanche,
L est algébrique.
Exercice 30 - Grammaires algébriques.

Donner le langage engendré par chacune des grammaires suivantes :
G1 = ({a, b, c} , {A, X} , X, {X −→ Ac | c, A −→ aAb | ab}),

G2 = ({a, b, c} , {A, B, C} , A, {A −→ aB | CB −→ aAb, C −→ cC | c}),
G3 = ({a, b} , {S, X} , S, {S −→ XaaXX −→ aX | bX | ε}),
G4 = ({a, b, c} , {S, B, C} , S, {S −→ aB | C | ε, B −→ aSb, C −→ cC | c}).
Exercice 31 - Grammaires algébriques.

Étudier les langages dont les règles de réécriture sont les suivantes (comme habituellement, les terminaux sont
en minuscule et les non terminaux sont en majuscule, le symbole initial est toujours S).
G1 : G3 :
S −→ SX S −→ aS | bX
SX −→ BS X −→ bX | c
BS −→ ab G4 :
B −→ a S −→ aaS | a | b
X −→ c G5 :
G2 : S −→ aX
S −→ aaS | aa X −→ bS | a
Exercice 32 - Exercice simple sur les grammaires.

Déterminer des grammaires G1 et G2 telles que L(G1) = {ap bq : p ∈ N \ {0} , q ∈ N \ {0, 1, 2}} et L(G2) =
{ap bq : p ∈ N \ {0} , q ∈ N \ {0}}.
Exercice 33 - Équivalence de grammaires, ambiguı̈té.

Soit la grammaire G = (ΣT , ΣN T , S, Π), où ΣT = {x, y}, ΣN T = {S} et où Π = {S −→ xSy | xS | ε}.
1 - Déterminer L(G).
2 - Montrer que le mot x2 y peut être obtenu de deux façons distinctes. On dit que G est ambiguë.
3 - Soit alors la grammaire G1 = (ΣT , Σ′N T , S, Π′ ), où Σ′N T = {S, T } et où
Π′ = {S −→ xSy | xT | ε, T −→ xT | ε} .
Montrer que L(G1) = L(G).

4 - Montrer qu’à tout mot de L(G1) correspond une dérivation unique dans la grammaire G1. On aura donc
construit une grammaire non ambiguë G1 équivalente à la grammaire ambiguë G.
Exercice 34 - Deux grammaires pour un même langage.

1 - Soient les deux grammaires suivantes :
G1 = ({a, b} , {S} , S, {S −→ ab | ba | SS | aSb | bSa})

G2 = ({a, b} , {S, A, B} , S,
{S −→ aB | bA, A −→ a | aS | bAA, B −→ b | bS | aBB}).
Quelle est la longueur des mots les plus courts de L(G1) ? et de L(G2) ?
2 - Déterminer L(G1).
3 - Montrer que L(G1) = L(G2).
Exercice 35 - Réduction de grammaires.

Soit la grammaire G1 = (ΣT , ΣN T , S, Π), où ΣT = {a, b, c}, ΣN T = {S, A, B, C} et Π est la liste de règles :
S −→ aB | bc A −→ BAc | bSC | a
B −→ aSB | bBC C −→ SBc | aBC | ac.
1 - Simplifier G1 en supprimant le plus possible de règles inutiles, sans changer le langage. La nouvelle
grammaire obtenue sera notée G2.
2 - Déterminer L(G2).
3 - Déterminer une grammaire G3 très simple qui engendre L(G2).
4 - Déterminer un automate fini produisant L(G1).
Exercice 36 - Langages miroirs.

Soit la grammaire G = (ΣT , ΣN T , S, Π), où : ΣT = {a, b, c}, ΣN T = {S, B, C}, les règles sont :
S −→ aB | C , B −→ aAb , C −→ cC | c .
1 - Déterminer L(G).
2 - De quel type est ce langage ?
3 - Déterminer une grammaire G′ dont le langage L(G′ ) soit le langage miroir de L(G).
4 - De façon plus générale, si l’on connait G et L(G), comment construire une grammaire G′ dont le langage
L(G′ ) soit le langage miroir de L(G) ?

Csex LANG200812 S3fi b-1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Csex LANG200812 S3fi b-1

Transféré par

Droits d'auteur :

Formats disponibles

I.U.T.

Lille A — Département Informatique

hphrasei −→ hsujeti hverbei hobjeti.

Table des matières

A Preuve des équivalences : régulier – reconnaissable – type 3 19

B Syntaxes des expressions régulières en Tcl 24

C Expressions régulières en environnement unix 25

D Une calculatrice en Lex et Yacc 26

Une conséquence immédiate est :

1.3 Langages, opérations sur les langages

{a, ba} ∩ {a, c, d} = {a} ,

De plus, on pose 1 pour tout langage S

1.4 Expressions régulières

(Σ \ {a})∗ ∪ (Σ \ {a})∗ a(Σ \ {a})∗ .

Ainsi, on pourra écrire

2.1 Quelques exemples

Figure 1 – A1 (automate fini déterministe complet)

1 · abcb = (1 · a) · bcb = 2 · bcb = 3 · cb = 2 · b = 3

et car 4 n’est pas acceptant.

Figure 2 – A1bis (automate fini déterministe non complet)

2.1.2 Un AF non déterministe

4. On devrait plutôt noter {ba} · {a, b, c}∗ .

Figure 4 – A3 (automate fini non déterministe)

{1} · cbbab = {1} · bbab = {1, 2} · bab = {1, 2} · ab = {1, 3} · b = {1, 2, 3}

2.1.3 Un AFnd avec des transitions instantanées

Figure 5 – A4 (AFnd avec transitions instantanées)

Définition 8 (Automate fini)

Nous pouvons donner précisément la définition des automates finis déterministes :

Définition 9 (Automate fini déterministe)

Définition 10 (Automate fini déterministe complet)

– il n’y a aucune transition instantanée,

Définition 11 (Lecture par un automate fini)

(e1 , x1 , f1 ), (e2 , x2 , f2 ), . . . (en , xn , fn )

2.3 Transformation d’un AF en AFdc.

Théorème 2 (Transformation d’un AF en AFdc)

Donnons quelques explications :

1 · ε : {1, 5} , 2 · ε : {2, 3, 4} , 3 · ε : {3, 4} , 4 · ε : {4} , 5 · ε : {5}

On obtient alors un AFnd équivalent sans transitions instantanées :

Il reste à appliquer la méthode ≪ classique ≫ de subset construction :

Figure 8 – A4′ (AFdc équivalent à A4)

2.4 Simplifications d’AFdc, automate minimal.

2.5 La classe des langages reconnaissables par un AF.

2.6 Un exemple de langage non reconnaissable.

Figure 9 – Recherche de l’AFdc minimal équivalent à un AFnd donné

3.1 Quelques exemples

Passons à une série d’exemples. 20

3.2 Définitions générales

(γ, δ) ∈ ((ΣT ∪ ΣN T )∗ \ Σ∗T ) × (ΣT ∪ ΣN T )∗

Reste à définir comment on peut dériver un mot dans une grammaire :

Définition 14 (Dérivation dans une grammaire)

α = α′ γα” et β = α′ δα” et (γ, δ) ∈ Π

3.3 La classification de Chomsky

Définition 15 (Classification (simplifiée) de Chomsky)

3.4 Grammaires algébriques

({a, b} ; {S, A, B} ; S; {S −→ AB; A −→ aA | ε; B −→ bB | ε})

({a, b} ; {S, B} ; S; {S −→ aS | B; B −→ bB | ε}).

({a, b} ; {S} ; S; {S −→ aSb | ε})

3.5 Langages réguliers

A Preuve des équivalences : régulier – reconnaissable – type 3

A.1 Passage d’un AF à une grammaire régulière.

– l’ensemble π des règles est constitué comme suit :

S =⇒ e0 =⇒ a1 e1 =⇒ a1 a2 e2 . . . =⇒ a1 a2 . . . an−1 en−1 =⇒ a1 a2 . . . an−1 an en =⇒ a1 a2 . . . an−1 an

A.2 Passage d’une grammaire régulière à un AF.