Notes Theorie Des Langages

Eléments de Théorie des langages
Notes de cours de SHS 18
Alexis Nasr
Table des matières
1 Introduction 5
1.1 Le paysage syntaxique . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Opérations sur les langages . . . . . . . . . . . . . . . . . . . 6
1.2 Grammaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.1 Hiérarchie des grammaires . . . . . . . . . . . . . . . . . . . 9
1.2.2 Type d’un langage . . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Reconnaisseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Langages réguliers 15
2.1 Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1 Manipulation d’expressions régulières . . . . . . . . . . . . . 16
2.2 Expressions régulières ⇔ grammaires régulières . . . . . . . . . . . 17
2.2.1 Expressions régulières ⇒ grammaires régulières . . . . . . . 18
2.2.2 Grammaires régulières ⇒ expressions régulières . . . . . . . 19
2.3 Automates finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1 Automate complet . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.2 Représentation graphique d’un automate fini . . . . . . . . . 22
2.3.3 Représentation tabulaire d’un automate fini . . . . . . . . . 23
2.3.4 Automates non déterministes . . . . . . . . . . . . . . . . . 23
2.3.5 Propriétés de fermeture . . . . . . . . . . . . . . . . . . . . . 27
2.3.6 Minimalisation . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.4 Expressions régulières ⇔ automates finis . . . . . . . . . . . . . . . 33
2.4.1 Expression régulière ⇒ automate . . . . . . . . . . . . . . . 33
2.4.2 Automate ⇒ expression régulière . . . . . . . . . . . . . . . 35
3 Langages hors contexte 39

3.1 Grammaires hors-contexte . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.1 Sens de dérivation . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.2 Arbre de dérivation . . . . . . . . . . . . . . . . . . . . . . . 40
3.1.3 Ambiguı̈té . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.2 Transformation de grammaires . . . . . . . . . . . . . . . . . . . . . 41
3.2.1 Forme normale de Chomsky . . . . . . . . . . . . . . . . . . 42
3.2.2 Grammaires non récursives à gauche . . . . . . . . . . . . . 44
3.2.3 Factorisation à gauche . . . . . . . . . . . . . . . . . . . . . 46
3.3 Automate à pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.1 Représentation graphique d’un automate à pile . . . . . . . 48
3.3.2 Reconnaissance d’un mot par un automate non déterministe 49
3.4 Automate à pile ⇔ Grammaires hors-contexte . . . . . . . . . . . . 50
3
3.4.1 Grammaires hors-contexte ⇒ Automate à pile . . . . . . . . 50
3.5 Analyse syntaxique . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.1 Transducteurs à pile . . . . . . . . . . . . . . . . . . . . . . 52
3.5.2 Analyseurs gauches . . . . . . . . . . . . . . . . . . . . . . . 53
3.6 Analyse descendante . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.6.1 Analyseur récursif . . . . . . . . . . . . . . . . . . . . . . . . 55
3.6.2 Analyseur prédictif non récursif . . . . . . . . . . . . . . . . 57
Chapitre 1
Introduction
L’objet de ce chapitre est d’introduire les trois notions fondamentales de ce cours

que sont les langages, les grammaires et les reconnaisseurs.
1.1 Le paysage syntaxique

L’univers de la théorie des langages est peuplé de symboles appartenant à des al-
phabets, de mots et de langages.
Les symboles sont des éléments indivisibles qui vont servir de briques de base pour
construire des mots. On peux citer comme exemple de symboles les 26 lettres de
l’alphabet romain a, b, c...z, les chiffres décimaux 0, 1, ...9.
Un alphabet est un ensemble fini de symboles . L’ensemble des 26 lettres de l’al-

phabet romain (que l’on notera R) et l’ensemble (noté B) des deux symboles 0 et
1, sont deux exemples d’alphabets. On désigne conventionnellement un alphabet
par la lettre grecque Σ.
Une suite de symboles, appartenant à un alphabet Σ, mis bout à bout est appelé
un mot (ou une chaı̂ne) sur Σ. 01001100, par exemple est un mot construit sur
l’alphabet B. Le nombre de symboles entrant dans la composition d’un mot α est
appelé la longueur de α, que l’on note à l’aide de deux barres verticales : |α|. La
longueur du mot 01001100, par exemple (notée |01001100|) vaut huit 1 .
Il est utile de pouvoir désigner un mot particulier, dont la longueur vaut zéro,
que l’on appellera le mot vide. Ce mot est conventionnellement représenté par le
symbole ε2 .
La concaténation de deux mots α et β, notée α · β ou simplement αβ est le mot

obtenu en juxtaposant les symboles de β à la suite de ceux de α. Si α = abra et
1
On pourra remarquer que l’expression a avec a ∈ Σ dénote deux objets différents, le symbole
a et le mot de longueur 1 composé du symbole a. Cette ambiguı̈té n’est pas gênante et nous
garderons donc cette même expression pour dénoter les deux objets.
2
Attention, même si personne ne nous en empêche, c’est une très mauvaise idée d’utiliser ε
comme symbole appartenant à un alphabet, car on ne peut plus distinguer le mot de longueur 1
composé du symbole ε du mot vide !
5
β = cadabra, αβ = abracadabra. Le mot mn représente la concaténation de m
avec lui même n fois :
n
z }| {
m . . . m = mn
Etant donné trois mots α, β et γ définis sur un alphabet Σ, on dit que α est un
préfixe du mot αβ β un suffixe du mot αβ et β une sous-chaı̂ne de αβγ. ε est un
préfixe, un suffixe et une sous-chaı̂ne de tout mot. Si α 6= β et α est un préfixe (ou
suffixe) de β, alors on dit que α est un préfixe (ou suffixe) propre de β.
L’ensemble de tous les mots que l’on peut construire sur un alphabet Σ, ε inclu,
est noté3 Σ∗ . On a donc en particulier :
B ∗ = {ε, 0, 1, 10, 00, 01, 10, 11, 001...}

Un langage sur un alphabet Σ est un ensemble de mots construits sur Σ. Tout
langage défini sur Σ est donc une partie de Σ∗ .
Deux langages sont définis indépendamment de tout alphabet. Il s’agit du langage

vide (noté ∅) et du langage composé uniquement du mot vide ({ε}). Σ peut être
vu comme le langage composé des symboles de Σ.
1.1.1 Opérations sur les langages

Les langages étant des ensembles, on peut leur appliquer les opérations définies
sur ces derniers :
– L’union de deux langages L1 et L2 , est le langage, noté L1 ∪ L2 constitué des

mots appartenant à L1 ou à L2 .
L1 ∪ L2 = {x|x ∈ L1 ou x ∈ L2 }
– L’intersection de L1 et L2 , est le langage, noté L1 ∩ L2 constitué des mots

appartenant à L1 et à L2 .
L1 ∩ L2 = {x|x ∈ L1 et x ∈ L2 }
– La différence de L1 et L2 est le langage, noté L1 − L2 , constitué des mots ap-
partenant à L1 et n’appartenant pas à L2 .
L1 − L2 = {x|x ∈ L1 et x ∈
/ L2 }
– La différence de Σ∗ et de L, noté L̄ est appelé le complément du langage L :
L̄ = {x ∈ Σ∗ |x ∈
/ L}
On définit de plus l’opération de concaténation de deux langages : la concaténation
de deux langages L1 et L2 est le langage noté L1 L2 composé des mots xy tels que
x ∈ L1 et y ∈ L2 .
3
La définition de l’opérateur ∗ est donnée plus loin.
L1 L2 = {xy|x ∈ L1 ety ∈ L2 }
on note Ln la concaténation de L avec lui même n fois :
n
z }| {
L . . . L = Ln
On définit enfin la fermeture de Kleene du langage L, notée L∗ de la façon suivante :
[
L∗ = Lk
k≥0
1.2 Grammaires
Un langage étant défini comme un ensemble de mots, une première façon de décrire
un langage est d’énumérer tous les mots qui le constituent. Cette méthode se heurte
à une difficulté fondamentale qui est qu’elle ne permet pas de décrire les langages
composés d’un nombre infini de mots. De plus, même si le langage que l’on désire
décrire est fini, ce mode de description ne permet pas de mettre en évidence ce qui
est commun dans la structure des mots de ce langages. C’est la raison pour laquelle
on introduit la notion de grammaire comme méthode de définition d’un langage.
Une grammaire est un système mathématique qui permet de générer tous les mots
d’un langage, c’est la raison pour laquelle elles sont aussi appelées des grammaires
génératives . Etant donné une grammaire G, on notera L(G) le langage généré par
G. De plus, une grammaire permet d’attribuer aux mots appartenant au langage
qu’elle définit, une structure, appelée structure syntaxique des mots.
Une grammaire générative utilise deux alphabets. Un alphabet non terminal, que
l’on notera N, composé de symboles non terminaux et un alphabet terminal , noté
Σ, composé de de symboles terminaux . L’alphabet terminal est l’alphabet sur le-
quel sont construits les mots du langage défini par la grammaire. Les symboles
non terminaux sont utilisés dans le processus de génération.
Le cœur d’une grammaire est constitué de règles de production appelées aussi règles
de réécriture qui décrivent la façon de générer les mots du langage. Une règle de
production est en fait un couple de mots (α, β) composés de symboles terminaux
et non terminaux (α, β ∈ (V ∪ N)∗ ). Ce couple est noté conventionnellement à
l’aide d’une flèche : α → β. α est appelée la partie gauche de la règle α → β et
β sa partie droite. α n’est pas un mot quelconque, il doit contenir au moins un
symbole non terminal.
Pour alléger les notations, nous représenterons par :
α → β1 |β2 | . . . |βn
les n règles :
α → β1 , α → β2 , . . . , α → βn
Ce qu’une règle α → β dit c’est que α peut se réécrire β. Si l’on dispose d’un
mot x que l’on a réussi à générer et que α est une sous-chaı̂ne de x, alors on peut
générer un nouveau mot en remplaçant α par β. Ce mécanisme est décrit plus
précisément ci-après.
Plus formellement, une grammaire est un quadruplet hN, Σ, P, Si où :
– N est un ensemble de symboles non terminaux, appelé l’alphabet non terminal.
– Σ est un ensemble de symboles terminaux, appelé l’alphabet terminal, tel que

N et Σ soient disjoints.
4
– P est un sous ensemble fini de :
(N ∪ Σ)∗ N(N ∪ Σ)∗ × (N ∪ Σ)∗
un élément (α, β) de P , que l’on note α → β est appelé une règle de production
ou règle de réécriture.
– S est un élément de N appelé l’axiome de la grammaire.
Une grammaire G = hN, Σ, P, Si définit un langage de manière récursive. Pour

décire le processus de génération, nous allons commencer par définir un type de
mot particulier appelé proto-phrase d’une grammaire. Les proto-phrases de G sont
des mots construits sur l’alphabet Σ ∪ N, on les définit récursivement de la façon
suivante :
– S est une proto-phrase de G
– si αβγ est une proto-phrase de G et β → δ ∈ P alors αδγ est une proto-phrase

de G.
Une proto-phrase de G ne contenant aucun symbole non terminal est appelé un

mot généré par G. Le langage généré par G, noté L(G) est l’ensemble des mots
générés par G.
L’opération qui est au cœur du processus de génération et qui consiste à générer

une proto-phrase αδγ à partir d’une proto-phrase αβγ et d’une règle de production
r de la forme β → δ est appelée l’opération de dérivation. Elle se note à l’aide d’une
double flèche :
αβγ ⇒ αδγ
k
On notera α ⇒ β pour indiquer que β se dérive de α en k étapes.
+ ∗
On définit aussi les deux notations ⇒ et ⇒ de la façon suivante :
4
(N ∪ Σ)∗ N (N ∪ Σ)∗ est le langage issu de la concaténation des trois langages (N ∪ Σ)∗ , N
et (N ∪ Σ)∗ . Ce dernier est la fermeture de Kleene du langage (N ∪ Σ) qui est lui même l’union
des deux langages M et Σ.
+ k
– α ⇒ β ≡ α ⇒ β avec k > 0
∗ k
– α ⇒ β ≡ α ⇒ β avec k ≥ 0
En utilisant ces notations, l’ensemble des mots générés par la grammaire G (en
d’autres termes le langage L(G)) est défini de la façon suivante :
∗
L(G) = {m ∈ Σ∗ |S ⇒ m}
Deux grammaires G et G′ sont équivalentes si les langages L(G) et L(G′ ) sont
identiques.
1.2.1 Hiérarchie des grammaires

Les grammaires peuvent être classées en fonction de la forme de leurs règles de
production. On définit cinq types de règles de production :
– règles régulières à gauche :

Une règle est régulière à gauche si et seulement si elle est de la forme A → xB
ou A → x avec A, B ∈ N et x ∈ Σ∗ .
– règles régulières à droite :

Une règle est régulière à gauche si et seulement si elle est de la forme A → Bx
ou A → x avec A, B ∈ N et x ∈ Σ∗ .
– règles hors-contexte :
Une règle A → α est un règle hors-contexte si et seulement si : A ∈ N et
α ∈ (N ∪ Σ)∗
– règles contextuelles :
Une règle α → β est une règle contextuelle si et seulement si : α = gAd et
β = gBd avec g, d, B ∈ (N ∪ Σ)∗ et A ∈ N le nom “contextuelle” provient du
fait que A se réecrit B uniquement dans le contexte g d.
– règles sans restrictions Une règle α → β est une règle sans restriction si et seule-
ment si : |α| ≥ 1
Il est important de remarquer que les types de règles définis ci-dessus définissent
une hiérarchie dans le sens où une règle régulière est un cas particulier de règle hors-
contexte qui est elle même un cas particulier de règle indépendante du contexte
et, pour finir, cette dernière est un cas particulier de règle non contrainte.
Cette classification des règles de production permet de définir un classement des

grammaires selon le type de leurs règles. Etant donné une grammaire G = hN, Σ, P, Si,
on dira que G est :
– régulière (ou grammaire de type 3) si elle est régulière à droite ou régulière à

gauche. Une grammaire est régulière à gauche si toutes ses règles sont régulières à
gauche et une grammaire est régulière à droite si toutes ses règles sont régulières
à droite. Une grammaire qui aurait des règles régulières à gauche et des règles
régulières à droite n’est pas une grammaire régulière.
– hors contexte (ou grammaire de type 2) si toutes ses règles de production sont
hors contexte.
– dépendante du contexte (ou grammaire de type 1) si toutes ses règles de produc-

tion sont dépendantes du contexte.
– sans restrictions (ou grammaire de type 0) si toutes ses règles de production

sont sans restrictions.
Les types de grammaires définis ci-dessus forment aussi une hiérarchie appelée
hiérarchie de Chomsky, représentée dans la figure 1.1.
grammaires sans restrictions
grammaires contextuelles
grammaires hors-contexte
grammaires régulières
Fig. 1.1 – hierarchie de Chomsky
1.2.2 Type d’un langage

La classification des grammaires ci-dessus va permettre de classer les langages se-
lon le type de grammaires nécessaire à leur génération. Un langage pouvant être
généré par une grammaire de type x et pas par une grammaire d’un type supérieur
dans la hiérarchie, sera appelé un langage de type x.
Il existe des langages “fondamentaux” pour les types de langages les plus utilisés,
ce sont des langages qui illustrent une propriété importante de leur classe :
– langages réguliers (de type 3)
le langage an , avec n ≥ 0 (les mots de longueur quelconque composés uniquement
de a), il peut être généré par la grammaire suivante : h{S}, {a}, {S → aS|ε}, Si.
– langages hors contextes (de type 2)

an bn , avec n ≥ 0 (le langage des mots composés d’un certain nombre de a
suivi du même nombre de b), qui peut être généré par la grammaire suivante :
h{S}, {a, b}, {S → aSb|ε}, Si.
langage mirroir, le langage des mots de la forme mm avec m ∈ Σ∗ : h{S}, {a, b}, {S →
aSa|bSb|aa|bb}, Si.
– langages contextuels (de type 1)

an bn cn h{S, S1 , S2 }, {a, b, c}, {S → aS1 c, S1 → b|SS2 , cS2 → S2 c, bS2 → bb}, Si.
1.3 Reconnaisseurs
Les reconnaisseurs constituent une autre manière de décrire des langages. Un re-
connaisseur est en fait la description d’une machine abstraite qui prend en entrée
un mot et dit si ce mot appartient ou pas au langage décrit par la machine.
Un reconnaisseur est composé de quatre parties :

1. une bande de lecture, qui est une succession de cases, chaque case pouvant
contenir un seul symbole d’un alphabet d’entrée. C’est dans les cases de cette
bande de lecture qu’est écrit le mot à reconnaı̂tre.
2. une tête de lecture, qui peut lire une case à un instant donné. La case sur
laquelle se trouve la tête de lecture à un moment donné s’appelle la case
courante. La tête peut être déplacée par le reconnaisseur pour se positionner
sur la case immédiatement à gauche ou à droite de la case courante.
3. une mémoire, qui peut prendre des formes différentes. La mémoire permet
de stocker des éléments d’un alphabet de mémoire.
4. une unité de contrôle, qui constitue le cœur d’un reconnaisseur. Elle peut
être vue comme un progamme qui dicte au reconnaisseur son comportement.
Elle est représentée par un ensemble fini d’états ainsi que par une fonction de
transition qui décrit le passage d’un état à un autre en fonction du contenu
de la case courante de la bande de lecture et du contenu de la mémoire.
L’unité de contrôle décide aussi de la direction dans laquelle déplacer la tête
de lecture et choisit quels symboles stocker dans la mémoire. Parmi les états
d’un reconnaisseur, on distingue des états initiaux, qui sont les états dans
lesquels doit se trouver le reconnaisseur avant de commencer à reconnaı̂tre
un mot et des états d’acceptation qui sont les états dans lequel doit se trouver
le reconnaisseur après avoir reconnu un mot.
Les différents éléments d’un reconnaisseur sont représentés graphiquement dans la

figure 1.2.
L’état d’un reconnaisseur à un moment donné est décrit par sa configuration qui
se compose de trois informations :
1. L’état de l’unité de contrôle
BANDE DE LECTURE
TETE DE LECTURE
UNITE DE CONTROLE
MEMOIRE
AUXILIAIRE
Fig. 1.2 – Eléments d’un reconnaisseur
2. Le contenu de la bande de lecture et la position de la tête de lecture

3. Le contenu de la mémoire
Un reconnaisseur fonctionne en effectuant une séquence de mouvements. Un mou-
vement est le passage d’une configuration du reconnaisseur à une autre. Le passage
de la configuration C1 à la configuration C2 est représenté de la façon suivante :
k ∗
C1 ⊢ C2 . Une suite de k mouvements est notée ⊢. On définit les deux notations ⊢
+
et ⊢ pour k ≥ 0 et k > 0.
Lors d’un mouvement, le reconnaisseur lit le symbole se trouvant dans la case cou-
rante, stocke de l’information dans sa mémoire et change d’état.
Un reconnaisseur est dit déterministe si pour chaque configuration, il existe au

plus un mouvement possible sinon, il est dit non déterministe.
La configuration initiale d’un reconnaisseur est une configuration pour laquelle

l’unité de contrôle est dans un état initial, la tête de lecture se trouve sur la case
se trouvant la plus à gauche de la bande de lecture et la mémoire contient un
symbole initial donné.
Une configuration d’acceptation est une configuration pour laquelle l’unité de contrôle
se trouve dans un état d’acceptation, la tête de lecture se trouve sur la case la plus
à droite et la mémoire se trouve dans un état d’acceptation.
On dit qu’un reconnaisseur accepte un mot m si, ayant m sur sa bande de lecture, le
reconnaisseur peut effectuer une séquence de mouvements l’amenant de la configu-
ration initiale à une configuration finale. Si le reconnaisseur est non déterministe,
il peut exister plusieurs séquences de mouvements vérifiant ces conditions.
Le langage reconnu par un reconnaisseur est l’ensemble des mots qu’il accepte.
Pour toute classe de grammaire dans la hiérarchie de Chomsky, il existe une classe
de reconnaisseurs qui définit la même classe de langages. En particulier, les auto-
mates finis dont il sera question au chapitre 2 définissent les langages réguliers et les
automates à pile, que l’on verra au chapitre 3 définissent les langages hors-contexte.
Chapitre 2
Langages réguliers
2.1 Expressions régulières

Etant donné un alphabet Σ, on appelle ensemble régulier sur Σ un langage sur Σ
défini de la façon suivante :
1. ∅ (l’ensemble vide) est un ensemble régulier sur Σ.
2. {ε} est un ensemble régulier sur Σ.
3. {a} est un ensemble régulier sur Σ pour tout a ∈ Σ.
4. Si P et Q sont des ensembles réguliers sur Σ, alors les ensembles suivants
sont des ensembles réguliers :
(a) P ∪ Q
(b) P Q
(c) P ∗
5. rien d’autre n’est un ensemble régulier.
On dit que la famille des ensembles réguliers est fermée pour les opérations de
concaténation, union et étoile1 . De façon générale, on dit qu’une famille d’objets
est fermée pour une opération si l’applicaton de cette opération à des objets de la
famille produit un objet qui appartient à cette famille.
Nous allons maintenant introduire une notation pratique pour dénoter des en-
sembles réguliers sur Σ, que l’on appelle expression régulière sur Σ :
1. ∅ est une expression régulière dénotant l’ensemble régulier ∅.
2. ε est une expression régulière dénotant l’ensemble régulier {ε}.
3. a (tel que a ∈ Σ) est une expression régulière dénotant l’ensemble régulier
{a}.
4. Si p et q sont des expressions régulières dénotant respectivement les ensembles
réguliers P et Q alors :
(a) (p + q) est une expression régulière dénotant l’ensemble régulier P ∪ Q
(b) (pq) est une expression régulière dénotant l’ensemble régulier P Q
1
On pourra remarquer que tout langage fini est un ensemble régulier.
15
(c) (p)∗ est une expression régulière dénotant l’ensemble régulier P ∗
5. rien d’autre n’est une expression régulière.
Cette définition des expressions régulières peut sembler circulaire car on définit
les expressions régulières en fonction d’elle-mêmes, en particulier dans les cas 4, 5
et 6. Elle ne l’est en fait pas car on définit des expressions régulières en fonction
d’expressions régulières plus courtes : p et q sont plus courtes que p + q et pq et
p est plus courte que p∗ . On peut ainsi décomposer une expression régulière en
expressions régulières plus simples jusqu’à aboutir aux expressions élémentaires
des cas 1, 2 et 3.
L’expression régulière (0 + (1(0)∗ )) définie sur l’alphabet {0, 1} dénote l’ensemble

{0} ∪ ({1}({0})∗), qui est l’ensemble formé du mot 0 et des mots composés d’un
un 1 suivi d’un nombre quelconque de 0 : {0, 1, 10, 100, . . .}. E étant une ex-
pression régulière, on notera L(E) le langage dénoté par E : L(0 + (1(0)∗ )) =
{0, 1, 10, 100, . . .}.
Quelques exemples d’expressions régulières sur Σ = {0, 1} :
0∗ 10∗ = {m ∈ Σ∗ | m a exactemement un 1}
(0 + 1)∗ 1(0 + 1)∗ = {m ∈ Σ∗ | m a au moins un 1}
(0 + 1)∗ 001(0 + 1)∗ = {m ∈ Σ∗ | m contient la sous-chaı̂ne 001}
((0 + 1)(0 + 1))∗ = {m ∈ Σ∗ | |m| est pair}
Il est clair d’après la définition des expressions régulières que l’on peut construire
une expression régulière dénotant un ensemble régulier quelconque. De même, on
peut construire l’ensemble régulier dénoté par toute expression régulière. Malheu-
reusement, pour tout ensemble régulier, il existe une infinité d’expression régulières
le dénotant.
2.1.1 Manipulation d’expressions régulières

Les opérations d’union, de concaténation et l’étoile de Kleene sont appelées des
opérations régulières . On peut faire le parallèle entre les expressions arithmétiques
qui sont construites à l’aide d’opérateurs arithmétiques et les expressions régulières,
construites à l’aide d’opérateurs réguliers. Dans un cas ces expressions dénotent
des nombres et dans l’autre, elles dénotent des ensembles. Afin d’alléger l’écriture
des expressions régulières en évitant certaines parenthèses, nous respecterons les
priorités suivantes : l’étoile est prioritaire sur la concaténation qui est prioritaire
sur l’union :
priorité(∗) > priorité(·) > priorité(+)

L’expression 0 + 10∗ est donc équivalente à (0 + (1(0)∗ )). On dira que deux expres-
sions régulières sont équivalentes (=) si elles dénotent le même ensemble.
Voici quelques lois qui permettent de simplifier des expressions régulières.
α + (β + γ) = (α + β) + γ (2.1)
α+β = β+α (2.2)
α+∅ = α (2.3)
α+α = α (2.4)
α(βγ) = (αβ)γ (2.5)
εα = αε = α (2.6)
α(β + γ) = αβ + αγ (2.7)
(α + β)γ = αγ + βγ (2.8)
∅α = α∅ = α (2.9)
ε + αα∗ = α∗ (2.10)
ε + α∗ α = α∗ (2.11)
Ces différentes lois peuvent être prouvées en remplaçant chaque expression régulière
par la définition de l’ensemble qu’elle dénote et en raisonnant sur ces ensembles.
Voici quelques équivalence utiles que l’on peut dériver à partir ces lois :
a∗ a∗ = a∗
a∗∗ = a∗
(a∗ b)∗ a∗ = (a + b)∗
a(ba)∗ = (ab)∗ a
a∗ = (aa)∗ + a(aa)∗
Il est aussi possible de définir des équations régulières dont les variables et les
coefficients sont des ensembles réguliers. On peut par exemple écrire l’équation :
X = αX + β
où α et β sont des expressions régulières. On peut vérifier que X = α∗ β est une
solution de cette équation :
αX + β = αα∗ β + β = (αα∗ + ε)β = α∗ β

On peut de la même façon définir des systèmes d’équations régulières.
2.2 Expressions régulières ⇔ grammaires régulières

La raison pour laquelle nous avons défini les ensembles réguliers dans ce chapitre
est qu’il existe une relation tout à fait privilégiée entre les langages réguliers et les
ensembles réguliers qui est donnée par le théorème suivant :
P ⊂ Σ∗ est un ensemble régulier si et seulement si P est un langage régulier.
Les expressions régulières sur Σ permettent donc de dénoter exactement les lan-
gages qui peuvent être générés par une grammaire régulière. Nous disposons ainsi
de deux moyens équivalents pour décrire les langages réguliers : les grammaires
régulières et les expressions régulières. Nous allons démontrer ce théorème en
décrivant d’une part comment construire une grammaire régulière à partir d’une
expression régulière et inversement comment construire une expression régulière
dénotant le même langage qu’un grammaire régulière.
2.2.1 Expressions régulières ⇒ grammaires régulières

La définition des ensembles réguliers (2.1) distinguait six cas. Les trois premiers
affirmaient que ∅, ε et a ∈ Σ étaient des ensembles réguliers et les trois derniers af-
firmaient que les ensembles réguliers étaient fermés pour les opérations régulières.
Nous allons montrer, dans les trois premiers cas, que ∅, ε et a ∈ Σ peuvent être
générés par des grammaires régulières et nous montrerons ensuite que les lan-
gages réguliers sont fermés pour les opérations régulières. On montre que la classe
des langages réguliers est fermée pour une opération donnée si étant donné deux
grammaires régulières G1 et G2 , on peut construire la grammaire G qui génère le
langage produit par l’application de cette opération aux deux langages L(G1 ) et
L(G2 ). Dans la suite, les deux grammaire G1 et G2 sont définies respectivement
par hN1 , Σ, P1 , S1 i et hN2 , Σ, P2 , S2 i.
1. R = ∅. R dénote le langage ∅ qui est aussi le langage généré par la grammaire
régulière suivante :
G = h{S}, Σ, ∅, Si
2. R = ε. R dénote le langage {ε} qui est aussi le langage généré par la gram-
maire régulière suivante :
G = h{S}, Σ, {S → ε}, Si
3. R = a avec a ∈ Σ. R dénote le langage {a} qui est aussi le langage généré

par la grammaire régulière suivante :
G = h{S}, Σ, {S → a}, Si
4. Si L1 et L2 sont des langages réguliers, générés par les grammaires G1 et G2

alors L1 ∪ L2 est décrit par la grammaire :
G = hN1 ∪ N2 ∪ {S}, Σ, P1 ∪ P2 ∪ {S → S1 |S2 }, Si
où S est un nouveau symbole non terminal tel que S ∈

/ N1 et S ∈
/ N2 .
Il faut encore montrer que L(G) = L(G1 ) ∪ L(G2 ) !

5. Si L1 et L2 sont des langages réguliers, générés par les grammaires G1 et G2
alors L1 L2 est généré par la grammaire :
G = hN1 ∪ N2 , Σ, P, S1 i
où P est défini de la façon suivante :
– Si A → xB ∈ P1 alors A → xB ∈ P
– Si A → x ∈ P1 alors A → xS2 ∈ P
– Si p ∈ P2 alors p ∈ P
Il faut encore montrer que L(G) = L(G1 )L(G2 ) !
6. Si L1 est un langage régulier, généré par la grammaire G1 alors L∗1 est généré
par la grammaire :
G = hN1 ∪ {S}, Σ, P, Si
où S est un nouveau symbole non terminal tel que S ∈
/ N1 . P est défini de
la façon suivante :
– Si A → xB ∈ P1 alors A → xB ∈ P
– Si A → x ∈ P1 alors A → xS ∈ P
– S → S1 |ε ∈ P
Il faut encore montrer que L(G) = L(G1 )∗ !
Exemple : Construisons une grammaire équivalente à l’expression régulière R =
(a + b)∗ aba. Pour cela, on commence par décomposer R en sous expressions plus
simples jusqu’à aboutir aux expressions élémentaires a et b , pour lesquelles on
construit des grammaires suivantes2 :
a : {S1 → a}
b : {S2 → b}
On combine ensuite ces grammaires selon les règles 4, 5, et 6 pour construire les
grammaires correspondant aux expressions plus complexes :
a+b : {S3 → S1 |S2 , S1 → a , S2 → b}

(a + b)∗ : {S4 → S3 |ε , S3 → S1 |S2 , S1 → aS4 , S2 → bS4 }
aba : {S5 → aS6 , S6 → bS7 , S7 → a}
∗
(a + b) aba : {S4 → S3 |S5 , S3 → S1 |S2 , S1 → aS4 , S2 → bS4 , S5 → aS6 , S6 → bS7 , S7 → a}
2.2.2 Grammaires régulières ⇒ expressions régulières

Soit la grammaire G = hN, Σ, P, Si avec N = {A1 , . . . , An }. On peut construire le
système d’équations ayant les éléments de N comme inconnues.
L’équation correspondant à Ai est : Ai = αi0 + αi1 A1 + . . . + αin An avec :

2
Pour alléger les notations, nous n’écrirons que les productions des grammaires, en respectant
la convention suivante : la partie gauche de la première production est l’axiome de la grammaire.
– αi0 = a1 + . . . + ak où Ai → a1 | . . . |ak sont toutes les productions ayant Ai
comme partie gauche et un terminal comme partie droite. Si k = 0 alors αi0 = ∅.
– αij = a1 + . . . + am (pour j > 0) où Ai → a1 Aj | . . . |am Aj sont toutes les produc-

tions ayant Ai comme partie gauche et une partie droite se terminant par Aj .
Si m = 0 alors αij = ∅.
L’expression régulière correspondant à L(G) est la valeur de la variable S dans la

solution de ce système d’équations.
Exemple : Ecrivons le système d’équations régulières correspondant à la gram-

maire de l’expression (a + b)∗ aba construite ci-dessus.
S4 = S3 + S5 (2.12) S5 = aS6 (2.16)

S3 = S1 + S2 (2.13) S6 = bS7 (2.17)
S1 = aS4 (2.14) S7 = a (2.18)
S2 = bS4 (2.15)
Des équations 2.16, 2.17 et 2.18, on peut déduire l’équation :
S5 = aba (2.19)
Des équations 2.13, 2.14 et 2.15, on peut déduire :
S3 = aS4 + bS4 (2.20)

En remplaçant 2.19 et 2.20 dans 2.12, on obtient l’équation à une inconnue sui-
vante :
S4 = aS4 + bS4 + aba (2.21)

que l’on peut écrire sous la forme :
S4 = (a + b)S4 + aba (2.22)

dont une solution est :
S4 = (a + b)∗ aba (2.23)
2.3 Automates finis

Les automates finis (on dira indiféremment automate fini ou automate dans la
suite de ce chapitre) constituent un type de reconnaisseurs. Comme nous l’avons
vu en 1.3, un reconnaisseur est composé d’une bande d’entrée, d’une tête de lecture,
d’une mémoire et d’une unité de contrôle. Les automates finis comptent parmi les
reconnaisseurs les plus simples, du fait que leur mémoire est nulle. De plus, la tête
de lecture ne se déplace que d’une case vers la droite à chaque mouvement du
reconnaisseur.
Un automate fini est donc défini par un ensemble d’états, qui sont les différents
états possibles de son unité de contrôle, et par une fonction de transition qui as-
socie un état e à un couple (q, a) formé d’un état et d’un symbole. On dit que
l’automate passe de l’état q à l’état e en lisant le symbole a ou encore que l’au-
tomate transite vers e sur a. Parmi les états de l’unité de contrôle, un état est
distingué comme étant l’état initial et un sous ensemble des états définit les états
d’acceptation de l’automate.
Plus formellement, un automate fini A est un quintuplet hQ, Σ, δ, q0 , F i où :

– Q est l’ensemble des états
– Σ est l’alphabet d’entrée
– δ est la fonction de transition3 :
δ :Q×Σ→ Q
– q0 est l’état initial

– F ⊆ Q est l’ensemble des états d’acceptation
Exemple :
A2n = h{A, B}, {0, 1}, δ, A, {B}i

avec : δ(A, 1) = A, δ(A, 0) = B, δ(B, 0) = B, δ(B, 1) = A. L(A2n ) est l’ensemble
des nombres pairs en représentation binaire.
Une configuration d’un automate fini est un couple (q, m) ∈ Q × Σ∗ . Etant donné
un automate fini et un mot m ∈ Σ∗ , une configuration de la forme (q0 , m) est
appelée configuration initiale et toute configuration de la forme (q, ε) avec q ∈ F
est une configuration d’acceptation.
Un mouvement de l’automate consiste à lire le symbole se trouvant sous sa tête

de lecture, à changer d’état (si cela est possible) et à déplacer sa tête de lecture
d’une case vers la droite, ce que l’on représente de la façon suivante :
(q, aw) ⊢ (q ′ , w) si δ(q, a) = q ′
Un état q de A est dit accessible s’il est possible d’y accéder depuis l’état initial
ou, plus précisément, s’il existe un mot m ∈ Σ∗ permettant d’effectuer une suite
de mouvements menant de l’état initial à q :
∗
q accessible ⇔ ∃m ∈ Σ∗ (q0 , m) ⊢ (q, ε)
il est dit co-accessible s’il est possible d’accéder à un état d’acceptation depuis cet
état, ou encore, s’il existe un mot m ∈ Σ∗ permettant d’effectuer une suite de
mouvements menant de q à un état d’acceptation :
∗
q co-accessible ⇔ ∃m ∈ Σ∗ (q, m) ⊢ (e, ε) avec e ∈ F
3
La fonction δ n’est pas forcément définie pour tous les couples de Q × Σ. Lorsqu’elle n’est
pas définie pour un couple (q, a), on note δ(q, a) = ∅.
Un mot m est reconnu par l’automate s’il existe une suite de mouvements menant
de la configuration (q0 , m) à (q, ε) avec q ∈ F . Le langage reconnu par un automate
A, noté L(A), est l’ensemble des mots reconnus par ce dernier4 :
∗
L(A) = {m ∈ Σ∗ |(q0 , m) ⊢ (q, ε) avec q ∈ F }
Il est très facile de déterminer si un automate fini déterministe accepte un mot m

étant donné qu’il existe au plus une séquence de mouvements pouvant mener de
(q0 , m) à (q, ε) avec q ∈ F .
Exemple : l’unique séquence de mouvements de A2n correspondant à l’acceptation

du mot 0100 est la suivante :
(A, 0100) ⊢ (B, 100) ⊢ (A, 00) ⊢ (B, 0) ⊢ (B, ε)
On dira qu’un langage L sur Σ est reconnaissable s’il existe au moins un automate
fini A ayant Σ comme alphabet d’entrée tel que L = L(A).
2.3.1 Automate complet

Un automate A = hQ, Σ, δ, q0 , F i est complet si A peut transiter depuis chaque
état vers un autre état sur tous les symboles de Σ, ce qui revient à dire que pour
tout état q et tout symbole a, il existe un état e ∈ Q tel que δ(q, a) = e.
Si un automate n’est pas complet, on peut le compléter en lui ajoutant un nouvel

état, qui n’est pas un état d’acceptation, appelé état puits (noté conventionnelle-
ment par le symbole ∅), dans lequel aboutiront toutes les transitions qui “man-
quaient”.
2.3.2 Représentation graphique d’un automate fini

Les automates finis sont souvent représentés sous la forme d’un graphe dont les
sommets sont les états de l’automate et les arcs (étiquetées par les symboles de Σ)
correspondent à la fonction de transition δ : il existe un arc étiqueté par a entre les
sommets i et j si et seulement si δ(a, i) = j. Les états initiaux sont désignés par
une flèche entrante et les états d’acceptation par un double cercle, comme dans la
figure 2.1.
Un mot m est reconnu par un automate s’il existe un chemin dans le graphe, par-
tant de l’état initial et aboutissant à un état d’acceptation tel que la concaténation
des symboles étiquetant les arcs du chemin est égale à m. Le mot 0100 est donc
reconnu par l’automate car il correspond au chemin ABABB.
Un état q est accessible s’il existe un chemin menant de l’état de départ à q ; il est
co-accessible s’il existe un chemin menant de q à un état d’acceptation.
4
On remarquera qu’un état non accessible ou non co-accessible est inutile du point de vue du
langage reconnu par l’automate.
1 0
A B
Fig. 2.1 – Représentation graphique d’un automate
2.3.3 Représentation tabulaire d’un automate fini

On peut aussi représenter l’automate A = hQ, Σ, δ, q0 , F i sous forme d’un tableau
T indicé par Q et Σ tel que q ′ ∈ T [q, a] si et seulement si δ(q, a) = q ′ . On distingue
l’état initial et les états d’acceptation par des flèches dirigées respectivement vers
la droite et vers la gauche, comme l’illustre la figure 2.3.3.
0 1
→ A B A
← B B A
Fig. 2.2 – Représentation tabulaire d’un automate
Dans la suite de ce document, nous utiliserons indifféremment la représentation

formelle, la représentation graphique ou la représentation tabulaire.
2.3.4 Automates non déterministes

Les automates finis, tels que nous les avons définis en 2.3 possèdent une propriété
que nous avons déjà rencontré en 1.3 qui est le déterminisme : pour toute configu-
ration d’un automate fini, il existe au plus un mouvement possible. Un automate
est non déterministe s’il existe des configurations pour lesquelles plus d’un mou-
vement est possible.
La définition formelle d’un automate fini non déterministe se distingue de celle d’un
automate déterministe par la fonction de transition. Dans le cas d’un automate
déterministe, la fonction de transition associe un état à un couple composé d’un
état et d’un symbole (δ : Q×Σ → Q) alors que pour un automate non déterministe,
cette fonction associe un ensemble d’états à un couple composé d’un état et d’un
symbole ou d’un état et du mot vide. L’automate peut donc d’une part transiter à
partir d’un état q et sur un symbole a vers plusieurs états et d’autre part change
d’état sans lire de symbole dans le mot à reconnaı̂tre. La fonction de transistion
est par conséquent définie de la façon suivante :
δ : Q × Σε → ℘(Q)
où Σε = Σ ∪ {ε} et ℘(Q) est l’ensemble des parties de Q. Une transition associant
un ensemble d’état au couple (q, ε) est appelée une transition-ε.
Le déterminisme se traduit dans la représentation graphique d’un automate fini
par le fait qu’il ne peut y avoir plus d’un arc possédant la même étiquette émanant
d’un même état. Lorsque l’automate est non déterministe, une telle configuration
peut exister, comme dans la figure 2.3. De plus, un arc peut être étiqueté par le
mot vide ε. Un tel arc peut être traversé sans qu’un symbole du mot d’entrée
soit lu. Dans la représentation tabulaire, le non déterminisme est illustré par la
présence de plusieurs états dans une case du tableau et d’une colonne réservées
aux transitions-ε.
1,0
0
A B
Fig. 2.3 – Représentation graphique d’un automate non déterministe
Reconnaissance d’un mot par un automate non déterministe
La reconnaissance d’un mot par un automate non déterministe est un peu plus
délicate que dans le cas déterministe. Il est possible, du fait du non-déterminisme
de l’automate qu’à un moment donné de la reconnaissance, alors que l’automate se
trouve dans une configuration donnée, il existe plusieurs états vers lesquels tran-
siter. Il faut alors dédoubler le processus de lecture de façon à poursuivre tous
les chemins possibles en parallèle. Chaque “copie” du processus va poursuivre un
chemin. Si un processus est confronté à un nouveau choix alors il se dédouble à
nouveau, et ainsi de suite. Si un processus se trouve dans une configuration telle
qu’il ne peut effectuer aucune transition, alors il meurt. Finalement, si un de ces
processus atteint un état d’acceptation après avoir lu le dernier symbole du mot à
reconnaı̂tre alors tous les processus s’arrêtent et le mot est reconnu par l’automate.
Illustrons cela grâce à l’automate N défini ci-dessous et qui reconnait le langage

des mots construits sur {a, b} de longueur supérieure ou égale à 2 et dont l’avant-
dernier symbole est un a.
N = h{0, 1, 2}, {a, b}, δn, 0, {2}i avec :
δn (0, a) = {0, 1}, δn (1, a) = {2}, δn (0, b) = {0} et δn (1, b) = {2}.
La reconnaissance du mot ababab par cet automate est représentée dans la fi-
gure 2.4.
Partant de la configuration (0, ababab), l’automate effectue en parallèle deux mou-
vements qui le mènent vers les configurations (0, babab) et (1, babab). Cette dernière
permet un mouvement vers (2, abab) qui elle ne permet aucun mouvement, ce pro-
cessus s’arrête donc. La configuration (0, babab) mène à (0, abab) de laquelle deux
mouvements vers (1, bab) et (0, bab) sont possibles . . .
(0, ababab)
HH
HH
H
(0, babab) (1, babab)
(0, abab) (2, abab)

H
H
H
(1, bab) (0, bab)
(2, ab) (0, ab)

HH
(1, b) (0, b)
(2, ε) (0, ε)
Fig. 2.4 – Reconnaissance non déterministe
Déterminisation d’un automate

Les automates finis déterministes et non déterministes reconnaissent la même
classe de langages. Ce résultat est à la fois surprenant et pratique. Il est sur-
prenant car les automates non déterministes semblent plus puissants que les au-
tomates déterministes. Il est pratique car il est souvent plus simple de décrire un
langage à l’aide d’un automate non déterministe.
Nous allons démontrer ce résultat en décrivant une méthode permettant de trans-

former un automate non déterministe en un automate déterministe reconnaissant
le même langage5 .
Soit N = hQN , Σ, δN , qN , FN i un automate non déterministe reconnaissant un

langage L. On construit un automate détermisite D = hQD , Σ, δD , qD , FD i qui re-
connaı̂t le même langage. L’idée générale de la construction consiste a créer des
états qui correspondent à des ensembles d’états de N. Ainsi, lorsque N peut tran-
siter d’un état e vers les états q1 , . . . , qi sur un symbole a, un nouvel état q1,...,i
correspondant à cet ensemble est créé et les différentes transitions sont remplacées
par une transition de e vers q1,...,i sur a.
Tout ceci est décrit plus formellement ci-dessous. Nous procèderons en deux étapes.
Lors d’une première étape, nous éliminerons de N les éventuelles transitions-ε et
dans une seconde étape, nous réduirons les transitions d’un même état sur un
même symbole.
Elimination des transitions-ε
Etant donné un automate N = hQN , Σ, δN , qN , FN i, on lui associe un automate

N ′ = hQN ′ , Σ, δN ′ , qN ′ , FN ′ i sans transitions-ε en procédant comme suit :
– Tant qu’il existe au moins une transition-ε, on applique la procédure suivante :
5
Il n’est pas nécessaire de montrer l’inverse car la définition des automates non déterministes
englobe celle des automates déterministes.
ε q
x
r k
ε q’
x
q
r k
q’
x
Fig. 2.5 – Elimination de transitions-ε

δ(a,R)
a
R
a
a
a
Fig. 2.6 – Calcul de la fonction de transition d’un automate non déterministe
– On choisit un état k dans lequel aboutit au moins une transition-ε

– pour tout q ∈ QN − {k} tel que δ(q, ε) = k, et pour tous r ∈ Q et x ∈ Σε tels
que δ(k, x) = r, on ajoute une transition δ(q, x) = r.
– on supprime les transitions δ(q, ε) = k (cette étape et la précédente sont
représentées dans la figure 2.3.4)
– si k ∈ F , on ajoute q à F
– si k n’est plus accessible, on le supprime.
Réduction des transitions
Etant donné un automate N ′ sans transitions-ε, on lui associe un automate déterministe

D = hQD , Σ, δD , qD , FD i défini comme suit :
1. QD = ℘(QN ′ ) Les états de D sont des ensembles d’états de N ′ .
2. Pour R ∈ QD et a ∈ Σ, on calcule δD (R, a) de la façon suivante :
δD (R, a) = {q ∈ Q|q ∈ δN ′ (r, a) avec r ∈ R}
Si R est un état de D alors c’est aussi un ensemble d’états de N ′ . Lorsque

D lit un symbole a en R, il transite vers un état correspondant à tous les
états que l’on peut atteindre à partir d’un état r de R par une transition
en a. Mais δN ′ (r, a) peut être lui-même un ensemble d’états (car N ′ est
non déterministe), il faut donc prendre l’union de tous ces ensembles (voir
figure 2). Ce que l’on peut écrire de la façon suivante :
[
δD (R, a) = δN ′ (r, a)
r∈R
3. qD = {qN ′ }. L’état initial de D est l’ensemble constitué de l’état initial de N ′ .
4. FD = {R ∈ QD |R contient un état d’acceptation de N ′ }. Les états d’accep-

tation de D sont les ensembles qui contiennent au moins un état d’acceptation
de N ′ .
Dans la pratique, lorsque l’on veut construire un automate déterministe D à partir

d’un automate non déterministe sans transitions-ε N ′ , on ne commence pas par
créer tous les états de D, car ils peuvent être nombreux : |℘(Q)| = 2|Q| !
On construit plutôt les états de D au fur et à mesure de leur création en partant

de l’état initial. Illustrons cela sur l’automate N ′ (de la partie 2.4) représenté
ci-dessous sous une forme tabulaire :
a b
→ 0 {0, 1} 0
1 2 2
← 2 ∅ ∅
On part de l’état initial 0 dont on calcule les transitions :
a b
→ 0 01 0
un nouvel état 01 a été crée, dont on calcule les transition. Ce calcul mène à la
création des deux nouveaux états 01 et 012 qui ne donneront pas naissance à de
nouveaux états, ce qui nous donne l’automate déterministe suivant :
a b
→ 0 01 0
01 012 02
← 02 01 0
← 012 012 02
2.3.5 Propriétés de fermeture

Nous allons montrer que la classe des langages reconnaissables (les langages pou-
vant être reconnus par des automates finis) est fermée pour un certain nombre
d’opérations. On montre que la classe des langages reconnaissables est fermée pour
une opération donnée si étant donné deux automates A1 et A2 on peut construire
l’automate A qui reconnaı̂t le langage produit par l’application de cette opération
aux deux langages L(A1 ) et L(A2 ). Nous allons décrire dans les cinq sections sui-
vantes comment construire les automates reconnaissant successivement l’union, la
concaténation, l’étoile, la complémentation et l’intersection de deux langages re-
connaissables. Dans la suite, les trois automates A, A1 et A2 sont définis par les
quintuplets suivants : hQ, Σ, δ, q0 , F i, hQ1 , Σ1 , δ1 , q1 , F1 i et hQ2 , Σ2 , δ2 , q2 , F2 i
Union
On construit l’automate A tel que L(A) = L(A1 ) ∪ L(A2 ). L’idée est de créér un
nouvel état initial duquel on peut acceder aux états initiaux de A1 et de A2 par
des transitions-ε. Ainsi si un mot m est reconnu par A1 ou par A2 , il est reconnu
par A car sans lire un symbole de m, on peut accéder à l’état initial de A1 et
de A2 . Cette construction est représentée graphiquement dans la figure 2.7. On
remarquera que A est non déterministe.
A1UA2
A1
A2
ε
Fig. 2.7 – Union de deux automates
Plus formellement, A est défini de la façon suivante :
1. Q = {q0 } ∪ Q1 ∪ Q2 . L’ensemble des états de A est constitué des états de A1 ,

des états de A2 et d’un nouvel état initial q0 .
2. l’état q0 est l’état initial de A.
3. F = F1 ∪ F2 . L’ensemble des états d’acceptation A est constitué des états
d’acceptation de A1 et des états d’acceptation de A2 .
4. La fonction de transition δ est définie de la façon suivante pour tout q ∈ Q
et tout a ∈ Σε :


 δ1 (q, a) si q ∈ Q1

 δ2 (q, a) si q ∈ Q2
δ(q, a) =


 {q1 , q2 } si q = q0 et a = ε

∅ si q 6 ε
= q0 et a =
Concaténation
On construit l’automate A tel que L(A) = L(A1 )L(A2 ). L’idée est d’ajouter aux
états d’acceptation de A1 des transitions-ε vers l’état initial de A2 . Ainsi un mot
est reconnu par A s’il peut être décomposé en un mot reconnu par A1 suivi d’un
mot reconnu par A2 . Là aussi, A est non déterministe. Cette construction est
représentée graphiquement dans la figure 2.8.
Plus formellement :
1. Q = Q1 ∪ Q2 . L’ensemble des états de A est constitué des états de A1 et des

états de A2 .
A1 A2
A1A2
Fig. 2.8 – Concaténation de deux automates
2. q0 = q1 . L’état initial q0 est le même que celui de A1 .

3. F = F2 . L’ensemble des états d’acceptation celui de A2 .


 δ1 (q, a) si q ∈ Q1 et q ∈/ F1

 δ1 (q, a) si q ∈ F1 et a 6= ε
δ(q, a) =


 δ1 (q, a) ∪ {q2 } si q ∈ F1 et a = ε

δ2 (q, a) si q ∈ Q2
Etoile
On construit l’automate A tel que L(A) = L(A1 )∗ . Les mots acceptés par A
peuvent être décomposés en plusieurs mots dont chacun peut être reconnu par
A1 . L’idée est d’ajouter aux états d’acceptation de A1 des transitions-ε vers l’état
initial de A1 . Ainsi, lors de la reconnaissance d’un mot m par A, lorsqu’un préfixe
de m appartenant à L(A1 ) a été reconnu et que l’on se trouve par conséquent
dans un état d’acceptation de A1 , la transition-ε peut être empruntée pour re-
connaı̂tre une nouvelle occurrence d’un mot de L(A1 ). De plus A doit accepter le
mot vide, pour cela on crée un nouvel état initial qui est aussi un état d’accepta-
tion et qui possède une transition-ε vers l’état initial de A1 6 . Cette construction
est représentée graphiquement dans la figure 2.9.
A A∗
ε
Fig. 2.9 – Etoile d’un automate
Formellement :
1. Q = {q0 } ∪ Q1 . L’ensemble des états de A1 plus un nouvel état initial q0 .

6
On pourrait croire qu’il suffit de faire de l’état initial de A1 un état d’acceptation, ce n’est
en fait pas le cas, car cette méthode, bien qu’elle permette la reconnaissance de ε par A, risque
de permettre aussi la reconnaissance d’autres mots indésirables (s’il existe des transitions vers
l’état initial), ce qui n’est pas le cas dans la construction proposée.
2. q0 = q1 . L’état q0 est l’état initial de A∗1 .
3. F = {q0 } ∪ F1 . L’ensemble des états d’acceptation A est constitué des états
d’acceptation de A1 et du nouvel état initial.




δ1 (q, a) si q ∈ Q1 et q ∈/ F1



 δ1 (q, a) si q ∈ F1 et a 6= ε
δ(q, a) = δ1 (q, a) ∪ {q1 } si q ∈ F1 et a = ε




 {q1 } si q = q0 et a = ε

 ∅ si q = q0 et a 6= ε
Complémentation
On construit l’automate A tel que L(A) = Σ∗ − L(A1 ). L’idée est de partir d’un
automate déterministe complet et d’échanger les états d’acceptation en états de
non acceptation. Ainsi un mot qui était reconnu par A1 ne sera pas reconnu par
le nouvel automate et un mot qui n’était pas reconnu par A1 le sera.
Il est indispensable que A1 soit déterministe et complet. En effet, puisque l’on

échange les états d’acceptation et les états de non-acceptation, il ne faut pas que
dans A1 , un même mot soit étiquette à la fois d’un chemin menant à un état d’ac-
ceptation et d’un chemin menant à un état de non-acceptation, car ce serait aussi
le cas dans A et ce mot appartiendrait à la fois à L et à L̄, ce qui est impossible.
Formellement : A = hQ, Σ, δ, q0 , Q − F i
Intersection
La fermeture des langages reconnaissables pour l’intersection peut être déduite de
la fermeture pour l’union et la complémentation grâce aux lois de de Morgan :
L3 = L1 ∩ L2 ⇔ L3 = L1 ∪ L2
Pour construire A tel que L(A) = L(A1 ) ∩ L(A2 ), il suffit donc de déterminiser et
compléter A1 et A2 , de construire leurs complémentaires puis de construire l’union
des complémentaire que l’on déterminisera et complètera avant d’en construire le
complémentaire. C’est un peu long !
On peut aussi définir directement A en construisant des états qui sont en fait des
couples d’états (q1 , q2 ) avec q1 ∈ A1 et q2 ∈ A2 . Un tel état indique que l’on par-
cours “en même temps” A1 et A2 . On établit une transition entre (q1 , q2 ) et (q1′ , q2′ )
sur a s’il existe une transition sur a entre q1 et q1′ et entre q2 et q2′ .
Plus formellement :
A = hQ1 × Q2 , Σ, δ, (q1 , q2 ), F1 × F2 i avec :

1. δ((e1 , e2 ), a) = (δ1 (e1 , a), δ2 (e2 , a))∀a ∈ Σ, ∀(e1 , e2 ) ∈ Q1 × Q2
En pratique, la construction de A en suivant ce principe peut être fastidieuse,
car ce dernier possède un grand nombre d’états : |Q1 | × |Q2 |. En général, un
nombre important de ces états sont “inutiles” car ils sont non accessibles ou non
co-accessible. Il vaut donc mieux éviter de les créer. Pour cela, on part de deux
automates déterministes complets A1 et A2 :
– on commence par créer l’état de départ (q1 , q2 )
– pour chaque symbole a ∈ Σ, et chaque état (e1 , e2 ), il y aura une transition :
– δ ′ ((e1 , e2 ), a) = (e′1 , e′2 ) si δ1 (e1 , a) = e′1 et δ2 (e2 , a) = e′2
– δ ′ ((e1 , e2 ), a) = ∅ sinon
On recommence ce travail depuis chacun des nouveaux états (e′1 , e′2 ) ainsi créés
et on s’arrête quand plus aucun nouvel état est créé. Les états d’acceptation
sont tous les états (e1 , e2 ) tels que e1 ∈ F1 et e2 ∈ F2 .
L’automate ainsi réalisé est déterministe complet.
Exemple
2.3.6 Minimalisation
Un automate fini déterministe est minimal si tout autre automate fini déterministe
reconnaissant le même langage comporte au moins autant d’états.
L’automate minimal qui reconnaı̂t un langage donné est unique, à la numérotation

des états près.
L’unicité de l’automate minimal est une propriété importante car elle permet de
vérifier que deux automates reconnaissent le même langage. En effet, si l’on dispose
de deux automates déterministe, il suffit de construire les automates minimaux leur
correspondant. Si ces derniers sont égaux (au nom des états près) alors les deux
automates initiaux reconnaissent bien le même langage.
Avant de décrire la méthode de construction d’un automate minimal, on définit la

notion de séparation de deux états :
Soit A = hQ, Σ, δ, q0 , F i un automate fini déterministe complet. Deux états s, t ∈ Q

sont séparés par le mot u ∈ Σ∗ si le chemin étiqueté par ce mot en partant de l’un
des deux états aboutit à un état d’acceptation tandis que le chemin étiqueté par
ce mot et partant de l’autre état aboutit dans un état qui n’est pas un état d’ac-
ceptation :
∗ ∗
– ou bien (s, u) ⊢ (q, ε) avec q ∈ F et (t, u) ⊢ (q, ε) avec q ∈
/F
∗ ∗
– ou bien (t, u) ⊢ (q, ε) avec q ∈ F et (s, u) ⊢ (q, ε) avec q ∈
/F
Remarques :
– Deux états sont séparés par ε si et seulement si l’un des deux états appartient
à F et l’autre à Q − F .
– les états non co-accessibles (comme l’état puits) sont toujours séparés des autres
états.
Le principe de construction de l’automate minimal (Algorithme de Moore) revient
à regrouper au sein d’un même état les états qui ne sont séparés par aucun mot ;
deux état de l’automate initial seront donc dans des états différents de l’automate
minimal s’il existe un mot qui les sépare. Ceci revient à réaliser une partition de
l’ensemble des états de l’automate initial.
La construction se fait de manière itérative, en partant d’une partition initiale qui

est affinée au fur et à mesure. La partition initiale consiste en deux parties : les
états d’acceptation et les états de non acceptation (ces deux parties sont séparées
par ε). L’étape fondamentale consiste à prendre une partie G et un symbole a
et à étudier les transitions des états de G sur a. Si ces transitions conduisent à
des états appartenant à des parties différentes dans la partition courante, alors on
doit diviser G de façon que les transitions sur a depuis chaque partie mènent à
des états appartenant à la même partie de la partition courante. Ce processus est
répété jusqu’à ce que plus aucune partie n’ait besoin d’être divisée.
Entrée : A = hQ, Σ, δ, q0 , F i un automate déterministe complet

Sortie : Un automate minimal A′ = hQ′ , Σ, δ ′ , q0′ , F ′ i qui reconnaı̂t le même langage
que A.
Méthode :
1. Construire une partition initale Π de Q composée de deux parties : les états

d’acceptation F et les états de non acceptation Q − F .
2. Construire une nouvelle partition Πn à partir de Π de la façon suivante :
pour chaque partie P de Π :
– partitionner P en sous-groupes de manière que deux états e et t apparte-

nant à P appartiennent dans le même sous-groupe si et seulement si, pour
tout symbole a ∈ Σ, les états e et t ont des transitions sur a vers des états
de la même partie de Π : (au pire, un état formera un sous-groupe par
lui-même) remplacer P dans Π par tous les sous-groupes ainsi formés.
3. Si Πn = Π, aller à l’étape 4, sinon répéter l’étape 2 avec Π ← Πn .

4. Choisir un état dans chaque partie de la partition Π comme représentant de
ce groupe.
– Ces états constituent Q′ , les états de l’automate minimal.
– La fonction de transition δ ′ est construite de la façon suivante : Pour chaque
état q de Q′ , si δ(q, a) = e alors δ ′ (q, a) = e′ où e′ est le représentant de la
partie de e.
– q0′ est le représentant de la partie de q0 .
– F ′ est l’ensemble composé des représentants des parties des éléments de
F.
5. Si A′ possède des états puits, les supprimer, supprimer aussi tous les états
non accessibles.
Illustrons cela sur l’automate déterministe suivant qui reconnaı̂t le langage L((a +
b)∗ abb) :
a b
→ A B C
B B D
C B C
D B E
← E B C
La partition initiale Π consiste en deux groupes (E), l’état d’acceptation et (A, B, C, D),
les états de non-acceptation. Pour construire Πn , on considère d’abord le groupe
(E). Ce groupe étant composé d’un seul état, il ne peut être décomposé et (E)
est placé dans Πn . On considère ensuite le groupe (A, B, C, D). Sur le symbole
a, chacun de ses états a une transition vers B, ils ne sont donc pas séparés par
a. Par contre, sur le symbole b, A, B et C ont une transition vers des membres
de (A, B, C, D) tandis que D a une transition vers E, ainsi, dans Πn (A, B, C, D)
doit être séparé en deux groupes : (A, B, C) et (D) ; Πn est donc (A, B, C)(D)(E).
A la seconde itération, (A, B, C) n’est toujours pas séparé par a par contre il est
séparé par b en (A, C) et (B). La nouvelle partition est donc (A, C)(B)(D)(E).
Une nouvelle itération ne parviendra pas à diviser (A, C), (A, C)(B)(D)(E) est
donc la partition finale. Si l’on choisit A comme représentant de (A, C), on obtient
le tableau suivant :
a b
→ A B A
B B D
D B E
← E B A
2.4 Expressions régulières ⇔ automates finis

Les langages reconnaissable ont été définis indépendamment des langages réguliers,
pour pouvoir dire que les automates finis constituent des reconnaisseurs pour les
langages réguliers, il nous manque un élément, qui est donné par le Théorème de
Kleene :
P ⊂ Σ∗ est un ensemble régulier si et seulement si il est défini par un automate

fini.
On a dit par ailleurs (section 2.1) que les ensembles réguliers pouvaient être décrits
par des grammaires régulières, il en résulte par conséquent que les automates finis
constituent des reconnaisseurs pour langages réguliers.
Nous allons prouver le théorème de Kleene en proposant une méthode pour constuire
un automate fini à partir d’une expression régulière ainsi qu’une méthode permet-
tant de construire une expression régulière à partir d’un automate fini.
2.4.1 Expression régulière ⇒ automate

Pour construire un automate correspondant à une expression régulière, nous allons
procéder comme nous l’avons fait pour en ?? construire une grammaire régulière
à partir d’une expression régulière. Pour chacun de ces six cas, de la définition des
expressions régulières, en 2.1, nous allons construire un automate reconnaissant le
même langage.
1. E = ∅. E dénote le langage ∅ qui est aussi le langage reconnu par l’automate
suivant : A = h{q}, Σ, δ, q, ∅i avec δ(r, b) = ∅, ∀r, ∀b.
2. E = ε. E dénote le langage {ε} qui est aussi le langage reconnu par l’auto-
mate suivant :A = h{q1 }, Σ, δ, q1 , {q1 }i avec δ(r, b) = ∅, ∀r, ∀b.
3. E = a avec a ∈ Σ. E dénote le langage {a} qui est aussi le langage re-

connu par l’automate suivant : A = h{q1 , q2 }, Σ, δ, q1 , {q2 }i avec δ(q1 , a) = q2 ,
δ(r, b) = ∅ pour r 6= q1 ou b 6= a.
4. E = E1 + E2
5. E = E1 E2
6. E = E1∗
Les trois derniers cas ont été traités en 2.3.5.
La construction de l’automate correspondant (a + b)∗ aba est représentée dans la fi-

gure 2.10. On commence par décomposer l’expression régulière en sous-expressions
régulières élémentaires que l’on combine ensuite.
a: a b: b
a
ε
a+b :
ε b
ε
a
ε
(a+b)* : ε
ε b
aba : a ε b ε a
ε
a
ε
ε
(a+b)*aba :
ε b ε
ε
ε ε
ε b ε a
a
Fig. 2.10 – Construction de l’automate correspondant à (a + b)∗ aba

2.4.2 Automate ⇒ expression régulière
La construction d’une expression régulière à partir d’un automate est un peu plus
délicate, nous allons la diviser en deux étapes, lors d’une première étape, l’automate
est transformé en un automate d’un autre type, appelé automate fini généralisé (ou
tout simplement automate généralisé). Cet automate est transformé en expression
régulière lors d’une seconde étape.
Un automate généralisé n’est rien d’autre qu’un automate fini dont les transitions
sont étiquetées par des expressions régulières et non pas simplement des symboles
ou le mot vide. L’automate généralisé lit le mot à reconnaı̂tre par blocs de symboles.
Les automates généralisés que nous allons manipuler vérifient trois contraintes
supplémentaires :
– L’état initial possède des transitions vers tous les autres états, mais aucun état
n’a de transition vers l’état initial.
– Il n’y a qu’un état d’acceptation qui ne possède aucune transition vers d’autres
états, mais tous les autres états possèdent une transition vers l’état d’accepta-
tion. De plus, l’état d’acceptation est distinct de l’état initial.
– A l’exception de l’état d’acceptation et de l’état initial, tous les états possèdent
une transition et une seule vers tous les autres états.
Un exemple d’automate généralisé est représenté dans la figure 2.11
aa
ab*
a* ab+ba
(aa)*
b*
b
ab
Fig. 2.11 – Un automate généralisé
Il est facile de construire un automate généralisé à partir d’un automate, il suffit

pour cela d’ajouter un nouvel état initial possèdant une transition-ε vers l’ancien
état initial et un nouvel état d’acceptation vers lequel il existe une transition-ε
partant des anciens états d’acceptation. S’il existe plusieurs transitions entre deux
états, elles sont remplacées par une transition unique étiquetée par l’union des
étiquettes des différentes transitions. Finalement, des transitions étiquetées ∅ sont
ajoutées entre les états qui ne sont reliés par aucune transition. Cet ajout ne mo-
difie pas le langage reconnu par l’automate car une transition étiquetée ∅ ne peut
jamais être franchie. L’automate généralisé correspondant à l’automate de la fi-
gure 2.1 est représenté dans la figure 2.12.
Il reste maintenant à construire une expression réguilère à partir d’un automate

généralisé. Cette construction s’effectue de manière itérative en diminuant d’un,
à chaque itération, le nombre d’états de l’automate généralisé. A l’issue de cette
étape, on obtient un automate généralisé comportant deux états (l’état initial
1 0
0
ε ε
I A B F
Fig. 2.12 – Transformation d’un automate en automate généralisé
et l’état d’acceptation) et une transition entre les deux. L’expression régulière

étiquetant cette transition dénote le langage de l’automate initial.
Il nous reste à décrire l’étape de réduction de l’automate généralisé qui consiste

donc à transformer un automate généralisé G comportant k états (avec k > 2)
en un automate G′ comportant k − 1 états. Le principe consiste à choisir un
état de G, que nous appellerons qe à l’éliminer et à “réarranger” le reste des
transitions de façon à ce que G et G′ reconnaissent le même langage. Le principe
du réarrangement est le suivant : s’il existe dans G une transition de l’état q1
vers l’état qe étiquetée R1 et une transition de qe vers lui-même étiqueté R2 et
finalement une transition de qe vers q2 étiquetée R3 , alors on crée une nouvelle
transition, allant de q1 vers q2 étiquetée avec l’expression régulière suivante :
R1 R2∗ R3 + R4
où R4 est l’étiquette de la transition qui existait dans G entre q1 et q2 . Cette
élimination d’état est représentée dans la figure 2.13.
R2
R1 R3
q1 q2 q3
R4
R1 R*
2 3R 4+ R
q1 q3
Fig. 2.13 – Elimination d’un état d’un automate généralisé
L’application de cette méthode à l’automate de la figure 2.12 est représentée dans

la figure 2.14. Dans un premier temps l’état A est éliminé et dans un second
temps l’état B. L’expression régulière résultante est 1∗ 0(0 + 11∗ 0)∗ que l’on peut
transformer en 1∗ 0((ε + 11∗ )0)∗ puis en 1∗ 0(1∗ 0)∗ qui est équivalente à l’expression
régulière (1 + 0)∗ 0.
0+11*0
1*0 ε
I A F
1*0(0+11*0)*
I F
Fig. 2.14 – Elimination des états A et B

Chapitre 3
Langages hors contexte
3.1 Grammaires hors-contexte

Les grammaires hors contexte sont très utilisées pour décrire la syntaxe des lan-
gages, et en particulier des langages de programmation. En plus de définir un
langage, une grammaire hors contexte G permet d’attribuer une strucuture syn-
taxique. aux mots de L(G).
Soit la grammaire G1 des expressions arithmétiques :
G1 = h{E, T, F }, {a, +, −, ∗(, )}, P, Ei avec P = {E → T +E | T , T → F ∗T | F , F → (E) | a}
3.1.1 Sens de dérivation

Les proto-phrases générées lors d’une dérivation utilisant des règles hors-contexte,
peuvent comporter plus d’un symbole non terminal1 , comme le montre la dérivation
suivante du mot a + a ∗ a par la grammaire G1 2 .
E ⇒ T +E ⇒ T +T ⇒ F +T ⇒ F +F ∗T ⇒ F +a∗T ⇒ F +a∗F ⇒ a+a∗F ⇒ a+a∗a

Selon le symbole non terminal que l’on décide de réécrire à un moment donné
de la dérivation, des dérivations différentes sont obtenues. Des dérivations qui ne
diffèrent que par l’odre dans lequel est appliqué les règles de réécriture sont dites
équivalentes. Parmi toutes les dérivations équivalentes d’un même mot par une
grammaire, nous allons en distinguer deux appelées dérivation droite et dérivation
gauche. Dans une dérivation droite (respectivement gauche), à chaque étape de la
dérivation, c’est le non terminal le plus à droite (respectivement le plus à gauche)
de la proto-phrase qui est réécrit. La dérivation gauche du mot a + a ∗ a par G1
est représentée ci-dessous :
E ⇒ T +E ⇒ F +E ⇒ a+E ⇒ a+T ⇒ a+F ∗T ⇒ a+a∗T ⇒ a+a∗F ⇒ a+a∗a

Et voici la dérivation droite :
E ⇒ T +E ⇒ T +T ⇒ T +F ∗T ⇒ T +F ∗F ⇒ T +F ∗a ⇒ T +a∗a ⇒ F +a∗a ⇒ a+a∗a

1
On pourra remarque que ce n’était pas le cas pour les grammaires régulières.
2
Le symbole qui est réécrit dans chaque proto-phrase a été souligné.
39
3.1.2 Arbre de dérivation
Etant donné une grammaire hors-contexte G, nous avons vu ci-dessus qu’il est pos-
sible d’avoir plusieurs dérivations équivalentes d’un mot m qui ne se distinguent
que par l’ordre dans lequel ont été appliquées les règles de réécriture. On peut
représenter toutes ces dérivations sous la forme d’un arbre de dérivation, défini
ci-dessous.
Etant donné une grammaire G = hN, Σ, P, Si, un arbre de dérivation pour G

est un arbre ordonné et étiqueté dont les étiquettes appartiennent à l’ensemble
N ∪ Σ ∪ {ε}. Si un nœud de l’arbre est étiqueté par le non terminal A et ses fils
sont étiquetés X1 , X2 , ..., Xn alors la règle A → X1 , X2 , ..., Xn appartient à P .
Un arbre de dérivation indique les règles qui ont été utilisées dans une dérivation,
mais pas l’ordre dans lequel elles ont été utilisées.
L’arbre syntaxique correspondant au mot a + a ∗ a est représenté ci-dessous.

E
HH
HH
T + E
F T
HH
a F * T
a F
a
On pourra remarquer qu’à un arbre de dérivation correspondent une seule dérivation
droite et une seule dérivation gauche. Dans le cas de l’arbre ci-dessus, ces deux
dérivations sont représentées en 3.1.1.
3.1.3 Ambiguı̈té
Si une grammaire G permet d’attribuer plus d’un arbre de dérivation à un mot
m ∈ L(G), elle est dite ambiguë. La grammaire
G2 = h{E}, {a}, {E → E + E | E ∗ E | a}, Ei

par exemple, est ambiguë, elle permet d’attribuer au mot a + a ∗ a les deux arbres
ci-dessous :
E E
HH
HH H
HH H
E + E E * E
HH H
H
a E * E E + E a
a a a a
On pourra remarquer que les langages générés par G1 et G2 sont identiques3 .
Cependant, certains langages hors-contextes ne peuvent être générés que par des
grammaires ambiguës. Ces langages sont dits intrinsèquement ambigus.
L’ambiguı̈té est une propriété gênante pour certaines grammaires, telles que les
grammaires des langages de programmation car elles permettent de donner plu-
sieurs interprétations différentes d’un même programme.
3.2 Transformation de grammaires

Contrairement aux règles régulières qui sont très contraintes, les règles hors-contexte
peuvent, elles, prendre un très grand nombre de formes. Certains algorithmes
prenant en entrée des grammaires hors-contexte imposent que ces derinères se
présentent sous une forme particulière. Nous décrirons ci-dessous trois types im-
portants de formes que sont la forme normale de Chomsky, les grammaires non
récursives à gauche et les grammaires factorisées à gauche ainsi que des méthodes
permettant de transformer une grammaire quelconque en une grammaire équivalente
conforme à chacune de ces différentes formes. Avant cela, nous décrirons quelques
caractéristiques que peuvent vérifier des grammaires hors-contexte.
– le symbole non terminal X d’une grammaire G = hN, Σ, P, Si est dit inutile si

l’on ne peut dériver un mot sur Σ à partir de X :
+
X ∈ N inutile ⇔ {m ∈ Σ∗ | X ⇒ m} = ∅
Toute grammaire comportant des symboles inutiles peut être transformée en une
grammaire équivalente ne comportant pas de symboles inutiles.
– le symbole non terminal X d’une grammaire G = hN, Σ, P, Si est dit inaccessible

s’il n’apparaı̂t dans aucune proto-phrase de la grammaire.
+
X ∈ N inaccessible ⇔ {m = αXβ , α, β ∈ (Σ ∪ N)∗ | S ⇒ m} = ∅
Toute grammaire comportant des symboles inaccessibles peut être transformée

en une grammaire équivalente ne comportant pas de symboles inaccessibles.
– Une règle-ε est une règle de la forme A → ε. Une grammaire G = hN, Σ, P, Si

est dite sans règles-ε si :
1. P ne possède pas de règle-ε, ou
2. P possède une seule règle-ε : S → ε et S n’apparaı̂t dans la partie droite
d’aucune règle de P .
– Une règle de la forme A → B est dite règle simple . Toute grammaire compor-
tant des règles simples peut être transformée en une grammaire équivalente ne
3
On dit que G1 et G2 on le même pouvoir génératif faible (elles génèrent les mêmes langages)
mais des pouvoirs génératifs fort différents (elles n’associent pas la même structure aux mots du
langage).
comportant pas de telles règles.
+
– Une grammaire G est sans cycle si n’existe pas de dérivation de la forme A ⇒
A , ∀A ∈ N
– Une grammaire G est propre si elle est sans cycle, sans règles-ε et ne possède
pas de symboles inutiles. Tout langage hors contexte peut être généré par une
grammaire propre.
3.2.1 Forme normale de Chomsky

Une grammaire hors-contexte est en forme normale de Chomsky si toutes ses règles
sont de la forme :
A → BC ou A → a
avec A, B ∈ N et a ∈ Σ. De plus, on autorise la règle S → ε si S est l’axiome de
la grammaire et s’il n’apparaı̂t jamais dans la partie droite d’une règle.
Tout langage hors-contexte peut être généré par une grammaire hors-contexte en
forme normale de Chomsky.
Pour prouver ce résultat, il suffit de montrer que l’on peut constuire pour toute
grammaire hors-contexte une grammaire équivalente en forme normale de Chom-
sky. Il n’est pas nécessaire de montrer l’inverse puisque toute grammaire en forme
normale de Chomsky est une grammaire hors-contexte.
Conversion en forme normale de Chomsky

La conversion d’une grammaire s’effectue en plusieurs étapes. A chaque étape,
des règles qui ne sont pas en forme normale sont remplacées par d’autres règles
qui le sont. On commence par remplacer l’axiome S par un nouveau symbole non
terminal, puis on élimine les règles de la forme A → ε puis les règles de la forme
A → B. Dans les deux cas, les autres règles de la grammaire sont transformées
de façon à ne pas modifier le langage généré. Pour finir, les règles restantes sont
transformées. Tout cela est décrit plus précisément ci-dessous.
Entrée : Une grammaire hors contexte G = hN, Σ, P, Si
Sortie : Une grammaire équivalente à G en forme normale de Chomsky
Méthode :
1. Création d’un nouvel axiome. On crée un nouveau symbole S0 et on ajoute la

règle S0 → S. Cette modification garantit que l’axiome n’apparaı̂t pas dans
une partie droite de règle.
2. Elimination des règles-ε. On élimine une règle de la forme A → ε ∈ P , pour
A 6= S0 puis, pour toute occurrence de A dans une règle de P , on ajoute une
nouvelle règle dans laquelle cette occurrence de A a été éliminée. La règle
X → αAβAγ, par exemple, provoquera l’ajout des trois règles suivantes :
X → αβAγ, X → αAβγ et X → αβγ. Si X → A ∈ P alors on ajoute
X → ε à moins que cette dernière n’ait déjà été éliminée. On recommence
cette étape tant que P possède des règles-ε.
3. Elimination des règles A → B. On élimine une règle de la forme A → B.
Pour toute règle de la forme B → α, on ajoute une règle A → α à moins
qu’il ne s’agisse d’une règle déjà éliminée. On recommence cette étape tant
que P possède des règles de la forme A → B.
4. Transformation des règles restantes. Toute règle de la forme A → α1 α2 . . . αk
avec k ≥ 3 et αi ∈ Σ∪N, est remplacée par les règles A → α1 A1 , A1 → α2 A2 ,
. . ., Ak−2 → αk−1αk où A1 . . . Ak sont de nouveaux non terminaux. Si k ≥ 2,
on remplace tout symbole terminal αi des règles précédentes par un nouveau
symbole non terminal Ui et on ajoute la règle Ui → αi
Exemple :
1. Création d’un nouvel axiome.

S0 → S
S → ASA|aB
S → ASA|aB
A → B|S
A → B|S
B → b|ε
B → b|ε
2. Elimination des règles-ε.

S0 → S S0 → S
S → ASA|aB|a S → ASA|aB|a|SA|AS|S
A → B|S|ε A → B|S
B→b B→b
3. Elimination des règles A → B.
Elimination de S → S à gauche et de S0 → S à droite :
S0 → S S0 → ASA|aB|a|SA|AS
S → ASA|aB|a|SA|AS S → ASA|aB|a|SA|AS
A → B|S A → B|S
B→b B→b
Elimination de A → B à gauche et de A → S à droite :
S0 → ASA|aB|a|SA|AS S0 → ASA|aB|a|SA|AS
S → ASA|aB|a|SA|AS S → ASA|aB|a|SA|AS
A → S|b A → b|ASA|aB|a|SA|AS
B→b B→b
4. Transformation des règles restantes.
S0 → AA1 |UB|a|SA|AS
S → AA1 |UB|a|SA|AS
A → b|AA1 |UB|a|SA|AS
A1 → SA
U →A
B→b
3.2.2 Grammaires non récursives à gauche
Un symbole non terminal A d’une grammaire G = hN, Σ, P, Si est dit récursif si
∗
A ⇒ αAβ avec α, β ∈ (N ∪ Σ)∗ . Si α = ε, A est dit récursif à gauche . Si β = ε, A
est dit récursif à droite . Une grammaire comportant au moins un symbole réursif
à gauche (resp. droite) est dite grammaire récursive à gauche (resp droite).
On distingue deux cas de récursivité gauche, la récursivité gauche directe et la

récursivité gauche indirecte. Dans le permier cas, la récursivité à gauche apparaı̂t à
l’issue d’une seule dérivation. Par exemple lors de l’application de la règle A → AB
au symbole A :A ⇒ AB. Dans le second cas, la récursivité à gauche apparaı̂t après
plusieurs dérivations. Par exemple lors de l’application sucessive des deux règles
A → BC et B → AE à A : A ⇒ BC ⇒ AEC.
Certains algorithmes d’analyse, et en particulier les algorithmes d’analyse des-

cendante décrits en 3.5, ne fonctionnent qu’avec des grammaires non récursive à
gauche. Cette condition est en fait peu contraignante car :
Tout langage hors-contexte peut être généré par une grammaire hors-contexte
non récursive à gauche.
Comme nous l’avons fait pour la forme normale de Chomsky, nous allons mon-
trer ce résultat, en présentant une méthode de transformation d’une grammaire
hors-contexte quelconque en une grammaire équivalente non récursive à gauche.
Nous procèderons en deux étapes, lors d’une première étape nous montrerons com-
ment éliminer la récursivité gauche directe puis dans une seconde étape comment
éliminer la récursivité gauche indirecte.
Elimination de la récursivité à gauche directe

Soit G = hN, Σ, P, Si une grammaire hors contexte, et soit
A → Aα1 | Aα2 | . . . | Aαm | β1 | β2 | . . . | βn

toutes les règle de P ayant A pour partie gauche.
G génère le même langage que la grammaire G′ définie de la façon suivante :
G′ = hN ∪ {A′ }, Σ, P ′ , Si
où P ′ est égale à P avec les règles ayant A pour partie gauche remplacées par :
A → β1 | β2 | . . . | βn | β1 A′ | β2 A′ | . . . | βn A′
A′ → α1 | α2 | . . . | αm | α1 A′ | α2 A′ | . . . | αm A′
Exemple : Cette transformation appliquée aux règles suivantes :
E → E + T | T , T → T ∗ F | F , F → (E) | a
produit les règles :
E → T | T E ′ , E ′ → +T | + T E ′ , T → F | F T ′ , T ′ → ∗F | ∗ F T ′, F → (E) | a
Cette méthode permet d’éliminer la récursivité à gauche directe, mais ne garantit

pas la non récursivité à gauche indirecte. Pour cela, on recourt à la méthode sui-
vante.
Elimination de la récursivité à gauche

Le principe consiste à éliminer la récursivité à gauche de façon incrémentale,
en considérant des ensembles de règles de plus en plus important, jusqu’à avoir
traité toute les règles. Pour cela on ordonne les non terminaux de la grammaire :
A1 , . . . , An et on commence par éliminer la récursivité directe des règles de la forme
A1 → α. Puis on traite les règles de la forme A2 → β et ainsi de suite, jusqu’à
avoir transformé toute la grammaire. L’algorithme est décrit ci-dessous :
Entrée : une grammaire propre G = hN, Σ, P, Si

Sortie : une grammaire G′ non récursive à gauche
Méthode :
– Numéroter les non terminaux de G : N = {A1 , . . . , An }
– éliminer les récursivités à gauche directes des règles ayant A1 pour partie gauche.
– Pour i = 2 à n faire
– pour j = 1 à i − 1 faire
1. remplacer chaque règle de la forme Ai → Aj γ par les règles Ai →
δ1 γ | . . . | δk γ, où Aj → δ1 | . . . | δk sont toutes les règles ayant Aj
pour partie gauche.
2. éliminer les récursivités à gauche directes des règles ayant Ai pour partie
gauche.
La raison pour laquelle l’algorithme ci-dessus produit l’effet voulu est qu’après la
(i − 1)ème itération de la boucle la plus externe (en i), chaque règle de la forme
Aj → Al α, où j < i doit être telle que l > j. Il en résulte qu’à l’itération suivante
dans la boucle interne (en j), les remplacements successifs de Aj dans les règles de
la forme Ai → Aj α va avoir pour conséquence que les règles de la forme Ai → Al α
seront telles que l ≥ i et l’élimination de la récursivité directe sur Ai va faire que
l > i.
Exemple :
A → BC | a, B → CA | Ab, C → AB | CC | a
Posons A1 = A, A2 = B et A3 = C.
On commence par éliminer la récursivité directe sur A puis on remplace dans B →

CA | Ab A par BC | a puis on élimine la récursivité directe sur B. On remplace alors
dans C → AB | CC | a A par BC | a, ce qui donne C → BCB | aB | CC | a. Puis
on remplace B par CA | ab | CAB ′ | abB ′ et on termine en éliminant la récursivité
directe sur C. Ces différentes étapes sont détaillées ci-dessous :
i=1 pas de changements

i = 2 j = 1 B → CA | BCb | ab
i=2 B → CA | ab | CAB ′ | abB ′
B ′ → CbB ′ | Cb
i = 3 j = 1 C → BCB | aB | CC | a
i = 3 j = 2 C → CACB | abCB | CAB ′ CB | abB ′ B | aB | CC | a
i=3 C → abCB | abB ′ CB | aB | a | abCBC ′ | abB ′ BC ′ | aBC ′ | aC ′
C ′ → ACBC ′ | AB ′ CBC ′ | CC ′ | ACB | AB ′ B | C
3.2.3 Factorisation à gauche

Une grammaire G est dite factorisée à gauche si les parties droites de deux règles
ayant la même partie gauche n’ont pas de prefixe commun propre : (A → αβ1 | αβ2
avec α 6= ε).
Entrée : une grammaire G
Sortie : une grammaire équivalente factorisée à gauche
Méthode : Pour chaque symbole non terminal A, trouver le plus long préfixe α 6= ε
commun à deux règles ou plus ayant A pour partie gauche. Remplacer toutes les
règles ayant A pour partie gauche :
A → αβ1 | αβ2 | . . . | αβn | γ

où γ représente toutes les parties droites qui ne commencent pas par α, par :
A → αA′ | γ
A′ → β1 | β2 | . . . | βn
Exemple : G = h{E, S}, {i, t, e, a, b}, {S → iEtS | iEtSeS | a, E → b}, Si
Factorisée à gauche, cette grammaire devient :
G = h{E, S, E ′ }, {i, t, e, a, b}, {S → iEtSS ′ | a, S ′ → eS | ε, E → b}, Si
3.3 Automate à pile

Un automate à pile possède les différents éléments d’un reconnaisseur, sa particu-
larité est son mode de stockage : une pile dans laquelle sont stockés des symboles
d’un alphabet particulier appelé alphabet de pile. De plus, à l’instar d’un auto-
mate à états finis, la tête de lecture d’un automate à pile ne peut se déplacer que
d’une case à chaque mouvement du reconnaisseur, de la gauche vers la droite. Ces
différents éléments sont représentés dans la figure 3.1.
Un automate à pile peut stocker des symboles dans sa pile, pour les relire en-
suite. L’automate ne peut lire que le symbole se trouvant au sommet de la pile
(dépiler) et ne peut ajouter un symbole (empiler) qu’en sommet de pile. C’est
la présence de la pile qui permet à l’automate de reconnaı̂tre certains langages
non-réguliers. Un automate à pile peut reconnaı̂tre le langage an bn par exemple,
TETE DE LECTURE
BANDE DE LECTURE
UNITE DE CONTROLE PILE
Fig. 3.1 – Eléments d’un automate à pile
car il peut “mémoriser” le nombre de a qu’il a lu (en les mettant dans la pile),
et par conséquent vérifier que le mot à reconnaı̂tre comporte le même nombre de b.
Les automates à pile peuvent être non déterministes. Contrairement aux langages
réguliers, certains langages hors-contexte ne peuvent être reconnus que par des
automates non déterministes.
Un automate à pile effectue un mouvement en fonction de son état courant, du

symbole se trouvant sous la tête de lecture et du symbole se trouvant au sommet
de la pile. Le mouvement consiste à déplacer la tête de lecture, à changer d’état,
à dépiler un symbole de la pile et à empiler un ou plusieurs symboles.
Plus formellement, un automate à pile est un septuplet hQ, Σ, Γ, δ, q0 , Z0 , F i

– Γ est l’alphabet de symboles de pile
– δ est la fonction de transition
δ : Q × (Σ ∪ {ε}) × Γ → ℘(Q × Γ∗ )
– q0 ∈ Q est l’état initial

– Z0 ∈ Γ est le symbole de fond de pile, qui se trouve initialement dans la pile
(voir 3.3.2)
Une configuration d’un automate à pile est défini par un triplet (q, m, α) ∈ Q ×
Σ∗ × Γ∗ où :
– q représente l’état courant de l’unité de contrôle
– m est la partie du mot à reconnaı̂tre non encore lue. Le premier symbole de m
(le plus à gauche) est celui qui se trouve sous la tête de lecture. Si m = ε alors
tout le mot a été lu.
– α représente le contenu de la pile. Le symbole le plus à gauche est le sommet de
la pile. Si α = ε alors la pile est vide.
La fonction de transition d’un automate à pile permet de décrire le passage d’une
configuration de l’automate à une autre. On écrit :
(q, aw, Zα) ⊢ (q ′ , w, γα)

si δ(q, a, Z) contient le couple (q ′ , γ).
Lors de ce mouvement :
– l’automate est passé de l’état q à l’état q ′ ,
– le symbole a a été lu,
– la tête de lecture s’est déplacée d’une case vers la droite,
– le symbole Z a été dépilé et le mot γ empilé.
Remarques :
– Si γ = ε, on dit que la pile a été dépilée.
– Si a = ε, aucun symbole n’a été lu sur la bande de lecture et la tête de lecture

n’a pas été déplacée. Par contre, l’état de l’automate peut avoir changé, ainsi
que le contenu de la pile.
3.3.1 Représentation graphique d’un automate à pile

On peut représenter un automate à pile sous la forme d’un graphe, comme dans
le cas des automates finis. La différence entre les deux représentations concerne
la gestion de la pile : les opérations d’empilement et de dépilement. Elles sont
indiquées en étiquetant les transitions d’étiquettes de la forme a, b → c. Une telle
étiquette sur un arc allant de qi à qj signifie que l’automate franchit cet arc en lisant
a et en remplaçant b par c sur le sommet de la pile. Ce qui dans la représentation
formelle correspond à : δ(qi , a, b) = {(qj , c)}.
– si a = ε, l’automate peut franchir cet arc sans lire de symbole.
– si b = ε, l’automate peut franchir cet arc indépendamment du symbole se trou-
vant en sommet de pile.
– si c = ε, l’automate peut franchir cet arc sans rien empiler.
Exemple 1 : A1 = h{q0 , q1 , q2 }, {a, b}, {Z, a}, δ, q0, Z, {q2}i avec :
δ(q0 , a, Z) = {(q1 , aZ)}

δ(q1 , a, a) = {(q1 , aa)}
δ(q1 , b, a) = {(q2 , ε)}
δ(q2 , b, a) = {(q2 , ε)}
A1 (voir figure 3.2) est un automate déterministe qui reconnaı̂t le langage an bn . A1

commence par lire une séquence de a tout en les empilant dans la pile puis dépile
un a pour tout b lu.
a, a −> aa b, a −> ε
q0 q1 q2
a, Z −>aZ b, a −> ε
Fig. 3.2 – Automate à pile reconnaissant le langage an bn

Exemple 2 : A2 = h{B, C, D, E, F }, {a, b, c}, {$, a}, δ, B, $, {D, F }i avec :
δ(B, a, ε) = {(B, a)} δ(C, b, a) = {(C, ε)}

δ(B, ε, ε) = {(C, a), (E, ε)} δ(C, ε, $) = {(D, $)}
δ(D, c, $) = {(D, $)}
δ(E, b, ε) = {(E, ε)}

δ(E, ε, ε) = {(F, ε)}
δ(F, c, a) = {(F, ε)}
A2 (voir figure 3.3) est un automate non-déterministe qui reconnaı̂t le langage

L = {ai bj ck | i, j, k ≥ 0 et i = j ou i = k} A1 commence par lire une séquence de a
tout en les empilant pour pouvoir ensuite comparer leur nombre avec le nombre de
b ou le nombre de c. Cette deuxième étape est un peu délicate et c’est là qu’entre
en jeu le non-déterminisme. Chaque branche de l’automate correspond à une des
alternatives i = j ou i = k. Dans la branche supérieure, A2 vérifie que le nombre
de b est égal au nombre de a tandis que dans la branche inférieure, il vérifie que
le nombre de b est égal au nombre de a.
b , a ε
C D c ,$ $
ε, ε ε ε, ε ε
ε, ε ε ε, ε ε
B E F c , a ε
a ,ε a b ,ε ε
Fig. 3.3 – Automate à pile reconnaissant le langage ai bj ck avec i = j ou i = k
3.3.2 Reconnaissance d’un mot par un automate non déterministe

Une configuration initiale d’un automate à pile A = hQ, Σ, Γ, δ, q0 , Z0 , F i est une
configuration de la forme (q0 , m, Z0) avec m ∈ Σ∗ . En d’autres termes, A se trouve
dans l’état initial, la tête de lecture se trouve sur le premier symbole du mot à
reconnaı̂tre et la pile ne contient que le symbole de fond de pile.
Une configuration d’acceptation est une configuration de la forme (q, ε, Z0) avec
q ∈ F . En d’autres termes, A se trouve dans un état d’acceptation, le mot à re-
connaı̂tre a été lu en entier et la pile ne contient que le symbole de fond de pile.
Un mot m ∈ Σ∗ est accepté par A s’il existe une séquence de mouvements de l’au-
tomate menant d’une configuration initiale (q0 , m, Z0 ) à une configuration d’accep-
tation (q, ε, Z0) avec q ∈ F . Le langage reconnu par A, noté L(A) est l’ensemble
des mots reconnus par A :
∗
L(A) = {m ∈ Σ∗ | (q0 , m, Z0 ) ⊢ (q, ε, Z0)}
L’automate A1 reconnaı̂t le mot aabb en effectuant les mouvements suivants :
(q0 , aabb, Z) ⊢ (q1 , abb, aZ) ⊢ (q1 , bb, aaZ) ⊢ (q2 , b, aZ) ⊢ (q2 , ε, Z)
Lorsque l’automate est non-déterministe, certaines configurations autorisent plus
d’un mouvement, comme l’illustre ci-dessous les différentes séquences de mouve-
ments de l’automate A2 lors de la reconnaissance du mot aabcc.
(B, aabcc, $)
(B, abcc, a$)
(B, bcc, aa$)

H
HH
H
(C, bcc, aa$) (E, bcc, aa$)
(C, cc, a$) (E, cc, aa$)
(D, cc, a$) (F, c, a$)
(F, ε, $)
3.4 Automate à pile ⇔ Grammaires hors-contexte

Les automates à pile constituent des reconnaisseurs pour langages hors contexte.
Pour pouvoir affirmer cela, il faut démontrer que tout langage reconnu par un
automate à pile peut être généré par une grammaire hors contexte et que, inver-
sement, tout langage généré par une grammaire hors contexte peut être reconnu
par un automate à pile. Nous montrerons ici uniquement comment construire un
automate à pile à partir d’une grammaire.
P ⊂ Σ∗ est un langage hors-contexte si et seulement si P est reconnu par un

automate à pile.
3.4.1 Grammaires hors-contexte ⇒ Automate à pile

Soit G = hN, Σ, P, Si une grammaire hors-contexte, on construit un automate à
+
pile A qui accepte un mot m s’il existe une dérivation pour m dans G (S ⇒ m).
A est conçu de telle sorte à déterminer une dérivation conduisant de S à m.
L’idée clef est d’écrire dans la pile de A les proto-phrases qui constituent la
dérivation recherchée. Pour cela, on commence par empiler l’axiome S, puis on
le remplace par la partie droite d’une règle de P de la forme S→ α de telle sorte
que le premier symbole x de α se trouve en sommet de pile.
– Si x est un terminal alors on le compare avec le caractère se trouvant sous la
tête de lecture. S’ils sont égaux alors on dépile.
– Si x est un non terminal alors on le remplace par la partie droite d’une règle de
P de la forme x → β.
Les différents états de la pile de l’automate correspondant à la grammaire G1 lors
de la reconnaissance du mot a + a ∗ a sont représentés dans la figure 3.4. On re-
marquera que la dérivation qui est construite lors de la reconnaissance est une
dérivation gauche car à chaque étape, c’est le symbole se trouvant en sommet de
pile qui est traité. Ce symbole correspond au symbole le plus à gauche dans la
proto-phrase correspondante.
T F a F a
+ + + + * * *
E E E E E E T T T T T a ε
Fig. 3.4 – Différents états de la pile lors de la reconnaissance du mot a + a ∗ a
On voit bien ici le rôle que joue le non déterminisme de A. Lorsqu’un non termi-
nal S doit être remplacé au sommet de la pile, il peut l’être par la partie droite
de n’importe quelle règle de la forme S → β. On ne sait pas à l’avance quelle
règle choisir. C’est là la difficulté principale de cette tâche. Elle est résolue dans
les automates à pile par la notion de non déterminisme qui permet de poursuivre
plusieurs hypothèses en parallèle. On peut aussi remarquer que si G est récursive
à gauche, P risque de ne jamais s’arrêter lors de la reconnaissance d’un mot.
L’automate à pile A correspondant à la grammaire G = hN, Σ, P, Si non récursive

à gauche est défini de la façon suivante :
A = h{q0 , q1 , q2 }, Σ, N ∪ Σ ∪ {Z0 }, δ, q0 , Z0 , {q2 }i
– A possède trois états : {q0 , q1 , q2 }.

– l’alphabet d’entrée est l’alphabet terminal de G.
– l’alphabet de pile est constitué des symboles non terminaux de G de l’alphabet
terminal Σet du symbole de fond de pile Z0 .
– la fonction de transition δ est définie de la façon suivante :
– δ(q0 , ε, Z0) = {(q1 , SZ0)} On empile l’axiome.
– δ(q1 , ε, Ni) = {(q1 , mi ) | avec Ni → mi ∈ P }
Si un symbole non terminal Ni occupe le sommet de la pile, on le remplace
par la partie droite mi d’une règle Ni → mi .
– δ(q1 , a, a) = {(q1 , ε) | avec a ∈ Σ}
Si le même symbole terminal occupe le sommet de la pile et la case courante
de la bande d’entrée, on dépile.
– δ(q1 , ε, Z0) = {(q2 , Z0 )}
Si le mot en entrée a été reconnu et que la pile ne contient que le symbole de
fond de pile, on passe à l’état d’acceptation.
– q0 est l’état initial.
– Z0 est le symbole de fond de pile.
– q2 est l’unique état d’acceptation.
Cet automate est représenté sous sa forme graphique dans la figure 3.5.
ε, Ni −> m pour toute règle Ni −> m de P

a, a −> ε pour tout terminal a de Σ
q0 q1 q2
ε, ε −> S ε, Z0 −> Z0
Fig. 3.5 – Automate correspondant à la grammaire G = hN, Σ, P, Si
Exemple :
L’automate à pile A1 correspondant à la grammaire G1 est défini de la façon
suivante :
A1 = h{q0 , q1 , q2 }, {a, +, ∗, (, )}, {E, T, F, Z0}, δ, q0 , Z0 , {q2 }i

avec :
δ(q0 , ε, Z0) = {(q1 , EZ0 , ε)} δ(q1 , +, +) = {(q1 , ε)}

δ(q1 , ε, E) = {(q1 , E + T ), (q1 , T )} δ(q1 , ∗, ∗) = {(q1 , ε)}
δ(q1 , ε, T ) = {(q1 , T ∗ F ), (q1 , F )} δ(q1 , (, () = {(q1 , ε)}
δ(q1 , ε, F ) = {(q1 , (E)), (q1 , a)} δ(q1 , a, a) = {(q1 , ε)}
δ(q1 , ε, Z0) = {(q2 , Z0 )}
3.5 Analyse syntaxique

Etant donné une grammaire hors-contexte G, on dit qu’un mot m ∈ L(G) a été
analysé lorsque l’on connaı̂t un (ou tous ses) arbres de dérivations. Un analyseur
syntaxique pour une grammaire G est donc une machine qui prend en entrée un
mot m et produit un (ou tous) les arbres de dérivations de m.
3.5.1 Transducteurs à pile

Nous allons définir un autre type d’automate, appelé transducteur à pile qui sont
très proches des automates à pile définis ci-dessus. La différence entre ces deux
types de machines réside dans le fait qu’un transducteur possède en plus d’une
bande d’entrée une bande de sortie sur laquelle il peut écrire grâce à une tête
d’écriture. A chaque mouvement du transducteur, un mot sur un alphabet de sor-
tie peut être écrit sur la bande de sortie. Les différents éléments d’un transducteur
à pile sont représentés dans la figure 3.6.
Formellement, un transducteur à pile est un 8-uplet hQ, Σ, Γ, ∆, δ, q0 , Z0 , F i défini

de la façon suivante :
TETE DE LECTURE
BANDE D’ENTREE
UNITE DE CONTROLE
PILE
BANDE DE SORTIE
TETE D’ECRITURE
Fig. 3.6 – Eléments d’un transducteur à pile
– Γ est l’alphabet de symboles de pile

– ∆ est l’alphabet de sortie
– δ est la fonction de transition
δ : Q × (Σ ∪ {ε}) × Γ → ℘(Q × Γ∗ × ∆∗ )
– q0 ∈ Q est l’état initial

– Z0 ∈ Γ est le symbole de fond de pile
Une configuration d’un transducteur à pile est un quadruplet (q, m, α, y) où :
– q représente l’état courant de l’unité de contrôle
– m est la partie du mot à reconnaı̂tre non encore lue. Le premier symbole de m
(le plus à gauche) est celui qui se trouve sous la tête de lecture.
– α représente le contenu de la pile. Le symbole le plus à gauche est le sommet de
la pile.
– y est la séquence de symboles de sortie produite.
3.5.2 Analyseurs gauches

Un analyseur gauche pour une grammaire G est un transducteur à pile qui pro-
duit en sortie une dérivation gauche du mot présent sur sa bande d’entrée. Cette
dérivation est représentée par une suite de chiffres, chaque chiffre correspondant à
une règle de G, ces dernières ayant été préalablement numérotées.
Soit la grammaire des expressions arithmétique G1 = h{E, T, F }, {a}, P, Ei dont

on a numéroté les règles :
1 E →T +E 2E→T
3 T →F ∗T 4T →F
5 F → (E) 6F →a
La dérivation gauche du mot a+a∗a se présente maintenant sous la forme suivante :
1 4 6 2 3 6 4 6
E ⇒ T +E ⇒ F +E ⇒ a+E ⇒ a+T ⇒ a+F ∗T ⇒ a+a∗T ⇒ a+a∗F ⇒ a+a∗a
que l’on représentera par le mot 14623646
Soit une grammaire hors-contexte G dont les règles ont été numérotées de 1 à p.
On appelle un analyseur gauche de G, un transducteur à pile non déterministe TGg
qui produit pour une entrée w, une dérivation gauche de w.
Un tel transducteur peut être construit immédiatement à partir d’une grammaire

hors-contexte G en suivant le principe de la section 3.4.1. La seule différence étant
que, pour le transducteur, la fonction de transition indique le numéro de la règle
correspondant à la transition.
Exemple : L’analyseur gauche T1g correspondant à la grammaire G1 est défini de

la façon suivante :
T1g = h{q0 , q1 , q2 }, {a, +, ∗, (, )}, {E, T, F, Z0, +, ∗, a, (, )}, {1, 2, 3, 4, 5, 6}, δ, q0, Z0 , {q2 }i
avec :
δ(q0 , ε, Z0) = {(q1 , EZ0 , ε)} δ(q1 , +, +) = {(q1 , ε, ε)}
δ(q1 , ε, E) = {(q1 , T + E, 1), (q1 , T, 2)} δ(q1 , ∗, ∗) = {(q1 , ε, ε)}
δ(q1 , ε, T ) = {(q1 , F ∗ T, 3), (q1 , F, 4)} δ(q1 , (, () = {(q1 , ε, ε)}
δ(q1 , ε, F ) = {(q1 , (E), 5), (q1 , a, 6)} δ(q1 , ), )) = {(q1 , ε, ε)}
δ(q1 , a, a) = {(q1 , ε, ε)} δ(q1 , ε, Z0 ) = {(q2 , Z0 , ε)}
T1g analyse le mot a + a ∗ a en effectuant la séquence de mouvements suivante :
(q0 , a + a ∗ a, Z0 , ε) ⊢ (q1 , a + a ∗ a, EZ0 , ε)
⊢ (q1 , a + a ∗ a, T + EZ0 , 1)
⊢ (q1 , a + a ∗ a, F + EZ0 , 14)
⊢ (q1 , a + a ∗ a, a + EZ0 , 146)
⊢ (q1 , +a ∗ a, +EZ0 , 146)
⊢ (q1 , a ∗ a, EZ0 , 146)
⊢ (q1 , a ∗ a, T Z0 , 1462)
⊢ (q1 , a ∗ a, F ∗ T Z0 , 14623)
⊢ (q1 , a ∗ a, a ∗ T Z0 , 146236)
⊢ (q1 , ∗a, ∗T Z0, 146236)
⊢ (q1 , a, T Z0 , 146236)
⊢ (q1 , a, F Z0 , 1462364)
⊢ (q1 , a, aZ0 , 14623646)
⊢ (q1 , ε, Z0, 14623646)
⊢ (q2 , ε, Z0, 14623646)
3.6 Analyse descendante

Etant donné une grammaire G il est possible de construire un analyseur gauche TGg
et d’effectuer l’analyse d’un mot m en simulant le fonctionnement de TGg sur l’entrée
m. Ce type d’analyse est dit descendant car il consiste à construire un arbre de
dérivation de m à partir de sa racine (l’axiome). La difficulté de ce type d’analyse
provient du fait que TGg est en général non déterministe, il faut par conséquent
gérer ce non-déterminisme, comme le décrit la section 3.6.1. Dans certains cas TGg
peut être rendu déterministe, comme nous le verrons dans la section 3.6.2.
3.6.1 Analyseur récursif

Soit un analyseur gauche non-déterministe TGg , et un mot m. L’ensemble des
séquences différentes de mouvements que TGg peut décrire sur l’entrée m étant
fini4 , une façon un peu brutale de simuler de façon déterministe TGg consiste à
les construire toutes, dans un certain ordre. C’est l’idée sous-jacente à l’analyse
récursive.
Remarques :
– Si l’on ne s’intéresse qu’à une dérivation de m alors on peut s’arrêter après
avoir construit la première séquence de mouvements menant de la configuration
initiale à une configuration d’acceptation.
– Si on s’intéresse à toutes les dérivations de m, il faudra alors construire toutes
les séquences de mouvements.
– Si m n’est pas reconnu par TGg alors toutes les séquences de dérivations devront
être construites.
Considérons la grammaire G = h{S}, {a, b, c}, P, Si avec les production suivantes :
1 S → aSbS 2 S → aS 3 S → c
et l’analyseur gauche TGg de G défini de la façon suivante :
TGg = h{q0 , q1 , q2 }, {a, b, c}, {S, Z0}, {1, 2, 3}, δ, q0, Z0 , {q2 }i
δ(q0 , ε, Z0 ) = {(q1 , SZ0 , ε)}

δ(q1 , a, S) = {(q1 , SbS, 1), (q1 , S, 2)}
δ(q1 , c, S) = {(q1 , ε, 3)}
δ(q1 , b, b) = {(q1 , ε, ε)}
δ(q1 , ε, Z0 ) = {(q2 , Z0 , ε)}
Les différents mouvements que TGg peut décrire sur le mot aacbc à partir de la
configuration initiale (q0 , aacbc, Z0 , ε) sont représentés par l’arbre ci-dessous où
chaque nœud est étiqueté par une configuration et un identificateur (de la forme
Ci ) lui correspondant :
4
On suppose que toute séquence de mouvements que TGg peut décrire sur l’entrée m est de
taille finie.
C−1 (q0 , aacbc, Z0 , ε)
C0 (q1 , aacbc, SZ0 , ε)

HH
HH
HH
H
HH
HH
HH
C1 (q1 , acbc, SbSZ0 , 1) C2 (q1 , acbc, SZ0 , 2)
H H
HH HH
HH
HH

HH
HH
C3 (q1 , cbc, SbSbSZ0 , 11) C4 (q1 , cbc, SbSZ0 , 12) C11 (q1 , cbc, SbSZ0 , 21) C15 (q1 , cbc, SZ0 , 22)
C5 (q1 , bc, bSbSZ0 , 113) C8 (q1 , bc, bSZ0 , 123) C12 (q1 , bc, bSZ0 , 213) C16 (q1 , bc, Z0 , 223)
C6 (q1 , c, SbSZ0 , 113) C9 (q1 , c, SZ0, 123) C13 (q1 , c, SZ0 , 213)
C7 (q1 , ε, bSZ0 , 113) C10 (q1 , ε, Z0, 1233) C14 (q1 , ε, Z0, 2134)
A partir de C−1 un seul mouvement est possible, menant en C0 . A partir de C0

deux mouvements sont possibles, vers C1 et C2 , correspondant respectivement au
choix de la règle 1 ou 2 pour réecrire S. En C1 , le sommet de la pile est encore oc-
cupé par S, et donc deux possibilités s’offrent pour réecrire ce dernier, aboutissant
aux deux configurations C3 et C4 . A partir de chacune de ces deux configurations,
un seul chemin mène respectivement à C7 et C10 . A partir de C2 deux mouvements
sont possibles, menant en C11 et C15 d’où on peut rejoindre les deux configurations
C14 et C16 .
Une manière de construire toutes les analyses du mot aacbc consiste à déterminer
toutes les configurations d’acceptation atteignables à partir de C0 en effectuant
un parcours de l’arbre des configurations. Pour cela, on détermine l’ordre dans le-
quel seront visités les fils d’un nœud. Choisissons par exemple de visiter d’abord le
fils correspondant à l’application de la règle 1 puis celui qui correspond à la règle 2.
La première branche parcourue est donc : C0 , C1 , C3 , C5 , C6 , C7 , elle ne constitue

pas une analyse de aacbc car C7 n’est pas un état d’acceptation. Pour déterminer
s’il existe une autre analyse possible on remonte dans l’arbre jusqu’à aboutir à
un nœud dont un fils n’a pas été parcouru. Pour cela, on exécute “à l’envers”
les mouvements qui ont mené l’analyseur en C7 jusqu’à revenir à la configuration
C1 , à partir de laquelle on atteint en quatre mouvements l’état C10 qui est un
état d’acceptation, correspondant à l’analyse gauche : 1233. Si l’objectif est de
déterminer toutes les analyses gauches du mot (dans le cas où la grammaire est
ambiguë) alors on continue le parcours de l’arbre, ce qui permettra de déterminer
une seconde analyse gauche : 2133 représentée par l’état C14 .
Performances :
– Espace : O(|m|)
– Temps : O(c|m| )
3.6.2 Analyseur prédictif non récursif
Nous allons voir dans cette section une méthode d’analyse descendante linéaire en
temps. Cette méthode ne peut être appliquée qu’à un sous-ensemble des gram-
maires hors-contexte appelées grammaires LL(k). La particularité de ces gram-
maires est que les analyseurs gauches qui leurs sont associés peuvent être rendus
déterministes si on s’autorise à regarder les k symboles suivant le caractère courant
dans le mot à analyser. Ce type d’analyse est dit prédictif . Dans la suite de cette
section, nous nous intéresserons uniquement au cas où k = 1 donc aux grammaires
et analyseurs LL(1).
Analyseurs LL(1)
Soit G = hN, Σ, P, Si une grammaire hors-contexte non ambiguë et m = a1 . . . an
un mot de L(G). On sait qu’il existe une unique dérivation gauche du mot m
composée des proto-phrases α1 . . . αk avec α1 = S et αk = m. L’idée de l’analyse
LL(1) est de construire cette suite de proto-phrases en ne lisant m qu’une fois, de
gauche à droite. Le principe est le suivant : si αi = a1 . . . aj Aβ alors αi+1 doit pou-
voir être déterminée de façon unique en fonction du symbole non terminal A et du
symbole aj+1. Une grammaire possédant cette propriété est dite grammaire LL(1).
Une grammaire LL(1) peut être analysée à l’aide d’un analyseur LL. Ce dernier
ressemble à un analyseur gauche, il possède en particulier une bande d’entrée, un
bande de sortie, une pile et une table d’analyse, comme l’illustre la figure 3.7.
BANDE D’ENTREE
TETE DE LECTURE
TABLE D’ANALYSE
PILE
BANDE DE SORTIE
TETE D’ECRITURE
Fig. 3.7 – Eléments d’un analyseur LL
Une configuration d’un analyseur LL est un triplet (au, Xα, π) où :

1. au représente la partie du mot d’entrée non encore lue, a est le symbole
terminal se trouvant sous la tête de lecture.
2. Xα représente le contenu de la pile (avec X au sommet de cette dernière)
3. π représente le mot produit sur la bande de sortie.
Si m ∈ Σ∗ est le mot à analyser, la configuration initiale de l’analyseur est :
(m$, S$, ε) $ étant le symbole de fond de pile qui sert aussi à marquer la fin de
la chaı̂ne à analyser. Une configuration d’acceptation se présente sous la forme :
($, $, π) π étant l’analyse gauche de m.
L’analyseur LL effectue une analyse en décrivant une séquence de mouvements

qui ressemblent aux mouvements d’un transducteur à pile. Le mouvement à effec-
tuer à partir d’une configuration (au, Xα, π) dépend de a et de X. Trois cas sont
possibles :
1. Si X = a = $, l’analyseur s’arrête et annonce le succès de l’analyse.
2. Si X = a 6= $, l’analyseur enlève X de la pile et avance la tête de lecture :
(au, aα, π) ⊢ (u, α, π)

3. Si X est un symbole non terminal, l’analyseur consulte l’entrée M(X, a) de
la table d’analyse M. Deux cas sont possibles :
(a) M(X, a) = i où i est le numéro d’une règle ayant X pour partie gauche
(X → β). Dans ce cas, X est dépilé, β est empilé et i est écrit sur la
bande de sortie.
(au, Xα, π) ⊢ (au, βα, πi)

(b) M(X, a) = erreur, l’analyse s’arrête et annonce l’échec de l’analyse.
Exemple : Soit la grammaire G = h{E, E ′ , T, T ′, F }, {a, +, ∗, (, ), a}, P, Ei non

récursive à gauche où P est composé des règles suivantes :
1 E → T E′ 2 E ′ → +T E ′
3 E′ → ε 4 T → FT′
5 T ′ → ∗F T ′ 6 T′ → ε
7 F → (E) 8 F →a
Soit la table d’analyse LL correspondant à G :
a ( ) + ∗ $
E 1 1 erreur erreur erreur erreur
E′ erreur erreur 3 2 erreur 3
T 4 4 erreur erreur erreur erreur
T′ erreur erreur 6 6 5 6
F 8 7 erreur erreur erreur erreur
L’analyse du mot (a ∗ a) correspond aux mouvements suivants :
((a ∗ a), E$, ε) ⊢ ((a ∗ a), T E ′ $, 1)

⊢ ((a ∗ a), F T ′ E ′ $, 14)
⊢ ((a ∗ a), (E)T ′ E ′ $, 147)
⊢ (a ∗ a), E)T ′ E ′ $, 147)
⊢ (a ∗ a), T E ′ )T ′ E ′ $, 1471)
⊢ (a ∗ a), F T ′ E ′ )T ′ E ′ $, 14714)
⊢ (a ∗ a), aT ′ E ′ )T ′ E ′ $, 147148)
⊢ (∗a), T ′ E ′ )T ′ E ′ $, 147148)
⊢ (∗a), ∗F T ′E ′ )T ′ E ′ $, 1471485)
⊢ (a), F T ′ E ′ )T ′ E ′ $, 1471485)
⊢ (a), aT ′ E ′ )T ′ E ′ $, 14714858)
⊢ (), T ′ E ′ )T ′ E ′ $, 14714858)
⊢ (), E ′ )T ′ E ′ $, 147148586)
⊢ (), )T ′ E ′ $, 1471485863)
⊢ (ε, T ′ E ′ $, 1471485863)
⊢ (ε, E ′ $, 14714858636)
⊢ (ε, $, 147148586363)
Construction d’une table LL(1) à partir d’une grammaire

La construction d’une table d’analyse LL(1) pour une grammaire G = hN, Σ, P, Si
est facilitée par les deux fonctions premier et suivant. Ces deux fonctions pe-
mettent, quand c’est possible de remplir les entrées de la table d’analyse LL(1) de
G.
PREMIER et SUIVANT
Si α est une proto-phrase de G, premier(α) est l’ensemble des terminaux qui
commencent les chaı̂nes se dérivant de α. :
∗
premier(α) = {a ∈ Σ | α ⇒ au}
∗
Si α ⇒ ε alors ε appartient aussi à premier(α).
Pour calculer premier(X) avec X ∈ N ∪Σ, on applique les règles suivantes jusqu’à
ce qu’aucun terminal ni ε ne puisse être ajouté aux ensembles premier.
1. Si X ∈ Σ, premier(X) = {X}.
2. Si X → ε ∈ P , on ajoute ε à premier(X).
3. Si X ∈ N et X → Y1 . . . Yk ∈ P , mettre a dans premier(X) s’il existe
i tel que a est dans premier(Yi) et que ε est dans tous les premier(Y1 )
. . .premier(Yi−1 ). Si ε ∈ premier(Yj )∀j , 1 ≤ j ≤ k, on ajoute ε à
premier(X).
On calcule premier(X1 . . . Xn ) de la façon suivante :
1. Ajouter à premier(X1 . . . Xn ) tous les symboles de premier(X1 ) différents
de ε.
2. Si ε ∈ premier(X1 ), ajouter également les symboles de premier(X2 ) différents
de ε. Si ε ∈ premier(X2 ), ajouter également les symboles de premier(X3 )
différents de ε, etc.
3. Finalement, si ε appartient à premier(Xj ) pour tous les j = 1, 2, . . . n, on
ajoute ε à premier(X1 . . . Xn ).
Si A ∈ N, suivant(A) est l’ensemble des symboles a ∈ Σ qui peuvent apparaı̂tre
immédiatement à droite de A dans une proto-phrase :
∗
suivant(A) = {a ∈ Σ | S ⇒ αAaβ}
Si A peut être le symbole le plus à droite d’une proto-phrase alors $ est dans
suivant(A).
Pour calculer suivant(A) pour tous symbole non terminal A, on applique les
règles suivantes jusqu’à ce qu’aucun symbole non terminal ne puisse être ajouté
aux ensembles suivant :
1. Mettre $ dans suivant(S).
2. si A → αBβ, le contenu de premier(β), excepté ε, est ajouté à suivant(B).
3. s’il existe une règle A → αB ou une règle A → αBβ telle que ε ∈ premier(β)
∗
(c’est à dire β ⇒ ε), les éléments de suivant(A) sont ajoutés à suivant(B).
Exemple
Soit la grammaire G = h{E, E ′ , T, T ′ , F }, {a, +, ∗, (, ), a}, P, Ei non récursive à
gauche où P est composé des règles suivantes :
1 E → T E′ 2 E ′ → +T E ′
3 E′ → ε 4 T → FT′
5 T ′ → ∗F T ′ 6 T′ → ε
7 F → (E) 8 F →a
Alors :
premier(E) = premier(T ) = premier(F ) = {(, a}
premier(E ′ ) = {+, ε}
premier(T ′ ) = {∗, ε}
suivant(E) = suivant(E ′ ) = {), $}
suivant(T ) = suivant(T ′ ) = {+, ), $}
suivant(F ) = {+, ∗, ), $}
Construction de la table LL(1)

Entrée : G = hN, Σ, P, Si Une grammaire dont les règles sont numérotées.
Sortie : M Une table d’analyse LL(1) pour G.
Méthode :
1. pour chaque regle i ∈ P de la forme A → α, procéder aux étapes 2 et 3.
2. Pour chaque symbole terminal a ∈ premier(α), ajouter i à M(A, a).
3. Si ε ∈ premier(α), ajouter i à M(A, b) pour chaque symbole terminal b ∈
suivant(A). Si ε ∈ premier(α) et $ ∈ suivant(A), ajouter i à M(A, $).
4. Mettre erreur dans toutes les entrées restées vides.
Si G n’est pas LL(1), en particulier si elle est récursive à gauche, non factorisée à
gauche ou ambiguë, M peut avoir des entrées qui sont définies de façons multiples.
On peut montrer qu’une grammaire G est LL(1) si et seulement si, pour toute
règle disctincte A → α et A → β de G, les conditions suivantes s’appliquent :
1. Pour aucun symbole terminal a, α et β ne se dérivent toutes les deux en des
mots commençant par a.
2. Une des deux proto-phrases α et β peut se dériver en ε.
∗
3. Si β ⇒ ε, α ne se dérive pas en un mot commençant par un élément de
suivant(A).
Index
Alphabet, 5 de Chomsky, 40
de pile, 44
non terminal, 7 Grammaire, 7
terminal, 7 LL(k), 55
Analyse ambiguë, 38
descendante, 53 dépendante du contexte, 10
prédictive, 55 factorisée à gauche, 44
Analyseur générative, 7
gauche, 52 hors contexte, 10
syntaxique, 50 récursive à gauche, 42
Arbre de dérivation, 38 régulière, 9
Automate sans cycles, 40
à pile, 48 sans restrictions, 10
complet, 22 Grammaires
déterministe, 23 équivalentes, 9
généralisé, 34 Hiérarchie de Chomsky, 10
minimal, 31
Axiome, 8 Langage
généré par une grammaire, 8
Chaı̂ne, 5 reconnaissable, 22
Concaténation de deux langages, 7 reconnu par un reconnaisseur, 12
Configuration
d’un automate à pile, 45 Mot, 5
Configuration d’un reconnaisseur, 11 Mouvement d’un reconnaisseur, 12
Dérivation, 8 Opérations régulières, 16

droite, 37 priorités, 16
gauche, 37 Partie droite d’une règle, 7
Déterminisme, 12, 23 Partie gauche d’une règle, 7
Prefixe, 6
Ensemble régulier, 15
Proto-phrase, 8
Etat
accessible, 21 Règle
co-accessible, 21 simple, 40
d’acceptation d’un automate, 21 Règle-ε, 39
d’un reconnaisseur, 11 Règles
initial d’un automate, 21 de production, 7
puits, 22 de réécriture, 7
Expression régulière, 15 Reconnaisseur, 11
Fermeture de Kleene, 7 Structure syntaxique, 37
Forme normale Suffixe, 6
62
Symbole, 5
inaccessible, 39
inutile, 39
non terminal, 7
récursif, 42
à droite, 42
à gauche, 42
terminal, 7
Transducteur à pile, 50
Transition-ε, 23
Type
d’un langage, 10

Notes Theorie Des Langages

Transféré par

Droits d'auteur :

Formats disponibles

Notes Theorie Des Langages

Transféré par

Informations du document

Description originale:

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

Notes Theorie Des Langages

Transféré par

Droits d'auteur :

Formats disponibles

Eléments de Théorie des langages

Notes de cours de SHS 18

3 Langages hors contexte 39

L’objet de ce chapitre est d’introduire les trois notions fondamentales de ce cours

1.1 Le paysage syntaxique

Un alphabet est un ensemble fini de symboles . L’ensemble des 26 lettres de l’al-

La concaténation de deux mots α et β, notée α · β ou simplement αβ est le mot

B ∗ = {ε, 0, 1, 10, 00, 01, 10, 11, 001...}

Deux langages sont définis indépendamment de tout alphabet. Il s’agit du langage

1.1.1 Opérations sur les langages

– L’union de deux langages L1 et L2 , est le langage, noté L1 ∪ L2 constitué des

– L’intersection de L1 et L2 , est le langage, noté L1 ∩ L2 constitué des mots

Pour alléger les notations, nous représenterons par :

Plus formellement, une grammaire est un quadruplet hN, Σ, P, Si où :

– N est un ensemble de symboles non terminaux, appelé l’alphabet non terminal.

– Σ est un ensemble de symboles terminaux, appelé l’alphabet terminal, tel que

(N ∪ Σ)∗ N(N ∪ Σ)∗ × (N ∪ Σ)∗

– S est un élément de N appelé l’axiome de la grammaire.

Une grammaire G = hN, Σ, P, Si définit un langage de manière récursive. Pour

– S est une proto-phrase de G

– si αβγ est une proto-phrase de G et β → δ ∈ P alors αδγ est une proto-phrase

Une proto-phrase de G ne contenant aucun symbole non terminal est appelé un

L’opération qui est au cœur du processus de génération et qui consiste à générer

1.2.1 Hiérarchie des grammaires

– règles régulières à gauche :

– règles régulières à droite :

Cette classification des règles de production permet de définir un classement des

– régulière (ou grammaire de type 3) si elle est régulière à droite ou régulière à

– dépendante du contexte (ou grammaire de type 1) si toutes ses règles de produc-

– sans restrictions (ou grammaire de type 0) si toutes ses règles de production

grammaires sans restrictions

Fig. 1.1 – hierarchie de Chomsky

1.2.2 Type d’un langage

– langages hors contextes (de type 2)

– langages contextuels (de type 1)

Un reconnaisseur est composé de quatre parties :

Les différents éléments d’un reconnaisseur sont représentés graphiquement dans la

Fig. 1.2 – Eléments d’un reconnaisseur

2. Le contenu de la bande de lecture et la position de la tête de lecture

Un reconnaisseur est dit déterministe si pour chaque configuration, il existe au

La configuration initiale d’un reconnaisseur est une configuration pour laquelle

2.1 Expressions régulières

L’expression régulière (0 + (1(0)∗ )) définie sur l’alphabet {0, 1} dénote l’ensemble

Quelques exemples d’expressions régulières sur Σ = {0, 1} :

2.1.1 Manipulation d’expressions régulières

priorité(∗) > priorité(·) > priorité(+)

αX + β = αα∗ β + β = (αα∗ + ε)β = α∗ β

2.2 Expressions régulières ⇔ grammaires régulières

2.2.1 Expressions régulières ⇒ grammaires régulières

3. R = a avec a ∈ Σ. R dénote le langage {a} qui est aussi le langage généré

4. Si L1 et L2 sont des langages réguliers, générés par les grammaires G1 et G2

G = hN1 ∪ N2 ∪ {S}, Σ, P1 ∪ P2 ∪ {S → S1 |S2 }, Si

où S est un nouveau symbole non terminal tel que S ∈

Il faut encore montrer que L(G) = L(G1 ) ∪ L(G2 ) !

a+b : {S3 → S1 |S2 , S1 → a , S2 → b}

2.2.2 Grammaires régulières ⇒ expressions régulières

L’équation correspondant à Ai est : Ai = αi0 + αi1 A1 + . . . + αin An avec :

– αij = a1 + . . . + am (pour j > 0) où Ai → a1 Aj | . . . |am Aj sont toutes les produc-

L’expression régulière correspondant à L(G) est la valeur de la variable S dans la