Théorie Des Langages Et Compilation - Leila Ben Ayed

Théorie des langages et
Compilation
Prof. Leila Ben Ayed
Ecole Nationale des Sciences de l’Informatique

ENSI - Université la Manouba - Tunis
Théorie des Langages et
Compilation
Objectif. Ce cours présente la théorie des langages en traitant trois aspects :
L’aspect reconnaissance par les automates finis, les automates à pile et les
machines de turing, L’aspect génération par les grammaires régulières, non
contextuelles et contextuelles, et L’aspect représentation par propriétés
mesurables, définitions récursives et expressions régulières. L’objectif est
d’introduire des connaissances en théorie des langages et des automates afin
de pouvoir les étendre à la description des langages de programmation et leur
analyse syntaxique en vue de leur compilation.
Un mini compilateur fera l’objet d’un projet de ce module.
Références. A. Aho, R. Sethi et J. Ullman, Compilateurs Principes,
Techniques et Outils, InterEditions, Paris, 1991.
- P. Walper, Introduction à la Calculabilité, Dunod, Paris, 2001.
-G. Dowek et J. Lévy, Introduction à la théorie des langages de programmation,
Éditions de l'École polytechnique, Paris, 2006.
Théorie des langages et
Compilation
Langages
Processus Réguliers Hors contexte Dépendants du
contexte
Représentation ExpressionsPropriété Propriété
régulières mesurable mesurable + Compilation
+ Définition
Définition Récursive Analyse lexicale
Récursive Analyse
Reconnaissance Automates Automates à Machines de syntaxique
finis Pile Turing
Analyse
Génération Grammaires Grammaires Grammaires sémantique
régulières Non contextuelles
contextuelles
Théorie des langages
I. Mots et langages
II. Les automates finis et les langages réguliers
III. Les grammaires
IV. Les grammaires non contextuelles
V. Les automates à piles
VI. Les machines de Turing
VII. Décidabilité
C pour TLC (Compilation)

Mini projet TLC
I. Mots et langages
Plan
I.1. Vocabulaire et Mot

I.2. Langage
I.3. Opérations sur les langages
I.4. Propriétés des langages
I.5. Définition des langages
I.6. Le lemme d’Arden
Leila Ben Ayed Théorie des Langages et Compilation 5
I.1. Vocabulaire et mot Exercices
Définition 1. Alphabet: Un alphabet (ou vocabulaire) est un
ensemble fini, non vide de symboles. On le note
généralement X.
Définition 2. Fermeture: Soit X, un alphabet. On note par

X*, l’ensemble de toutes les séquences finies de symboles
de X.
Rq le symbole * est une fonction qui, appliquée à un

ensemble non vide X, donne un autre ensemble infini X*.
On dit que X* est la fermeture de X.

I.1. Vocabulaire et mot
Définition 3. Chaine vide: Une chaine vide est une chaine

qui ne contient aucun symbole du vocabulaire ( appelée
aussi mot vide). Une chaine vide est un élément de X*. On
la note : 
Définition 4. Longueur d’une chaine: La longueur d’une

chaine finie  est le nombre de symboles qu’elle contient.
On la note ||.

Définition 5. Mot : Un mot  est une application d’un
segment initial de longueur n vers le vocabulaire:
 : [n]  X
Où i est l’image de i dans X; i est le rang de i dans ;

si i = a et a X alors i est une occurrence de a dans le
mot .
Exercice :
Donner les i associés aux mots sivants :
1) abba sur le vocabulaire {a, b}
2) (x1*(x2+x1)) sur le vocabulaire {x1, x2, +, *, (, )}
Corrigé:
1) Si le vocabulaire X = {a, b} alors dans le mot abba,
1 = a
2 = b
3 = b
4 = a
2) Si le vocabulaire est X = {x1, x2, +, *, (, )} alors dans le mot (x1*(x2+x1))
1 = ( 2 = x1 3 = *
4 = ( 5 = x2 6 = +
7 = x1 8 = ) 9 = )
Longueur d’un mot : La longueur d’un mot  est le
nombre de symboles qu’il contient , on le note |
|.
Exercice :
Quelle est la longueur des mots abba et  sur le
Vocabulaire {a,b}
Corrigé:
Le mot abba est de longueur 4, |abba| = 4
Le mot  est de longueur 0, | | = 0

Nombre d’occurrences d’un symbole dans un mot :
Le nombre d’occurrences d’un symbole x dans un mot
 est le nombre de fois où ce symbole apparaît dans
ce mot . On le note ||x.
|| = xX ||x
Exercice :
Quel est le nombre d’occurrences de b dans les mots
abba et 
Corrigé :
|abba|b=2
| |b=0
I.2. Langage
Définition 6. Langage :
On définit un langage sur un alphabet X comme un sous
ensemble de X*
Exemple:
• Si le vocabulaire est X = {0, 1, 2, 3, …9}
L = { représentations décimales des nombres entiers
naturels}
L = |N
• Si le vocabulaire est X = {x1, x2, +, *, (, )} x1++ X*
L = {expressions arithmétiques parenthésées}
manipulant x1, x2, + et * (x1+ x2)
I.2. Langage
• Si X est la vocabulaire du langage de programmation C

X = {main, (, ), #, Include, <, >, ., ;, id, nb, …….}
L= {programmes C corrects syntaxiquement}
(main) element de X*
main(){}
• Si X est le vocabulaire de la logique des propositions

X ={p, (, ), , , } où p désigne une proposition
L = {formules bien formées de la logique des
propositions} V p ->p
I.2. Langage
• Si X est le vocabulaire de la logique des propositions
X ={p, (, ), , , } où p désigne une proposition
L = {formules bien formées de la logique des
propositions}
L’ensemble des mots de L est défini récursivement comme

suit :
1) P est un mot
2) Si F et G sont deux mots alors F-> G, F/\G le sont aussi
3) Si F est un mot alors (F) et !F le sont aussi
(P V P) ->p S => p
F -> G S =>
F1 V F2 p
(p V p) -> p
Concaténation de deux mots:
Si u et v deux mots / |u| = n et |v| = m alors:
u.v =  / i = ui  i  [n] et
n+j = vj  j  [m]
Le mot vide  est un élément neutre de la
concaténation
u.  = .u = u

Soient A et B deux langages alors on a les opérations suivantes:
Intersection AB = {/ A et B}
Union A+B = {/ A ou B}
Complémentation A-B = {/ A et B}
Concaténation
A.B = {/ u A et v B et  = u.v}
Propriétés
Soient A, B, C des langages, on a A.(B+C) = A.B + A.C
(A+B).C = A.C+B.C
A  B  AC  BC
CA  CB

Notation:
ak = aaaaaaaaa…… a2 = aa
<----------------->
k fois
a0 = 
a* = {ai / i  0} = {a0, a1, a2, ….ai, …}
a+ = {ai / i >0} = {a1, a2, …., ai, …}

L’opération * A* =  Ai avec A0 = {}
i0 A1 = A
Ai+1 = A.Ai i0
L’opération + A+ =  Ai
i1
Exercice :
Calculer A* pour chacun des ensembles A suivants:
1) A = {a}
2) A = {X* / || = 2k+1 / k  0}
Corrigé :
1) Si A = {a} alors A* = {a}* = a*
Car A* = A0 + A1 + A2 +… Ai +…
A0 = {} = {a0}
A1 = AA0 = {a} {} = {a} = {a1}
A2 = AA1 = {a}{a} = {aa} = {a2}
Ai = {ai}
Ai+1 = A Ai = {a}{ai} = {ai+1}
….
A* = {, a, aa, aaa, …} = {a0, a1, a2, a3, …} = a*

2) Si A = {X* / || = 2k+1 / k  0}
A* = X*
Car A* = A0 + A1 + A2 +… Ai +…
A0 = {}
A1 = AA0 = A{} = {X* / || = 2k+1 / k  0}
A2 = AA1 = {X* / || = 2k+1/ k0} {X* / ||= 2k+1/ k  0}
= {X* / || = 2k+2/ k0}
= {X* / || = 2k / k>0}
A0 + A2 = {} + {X* / || = 2k / k>0} = {X* / || = 2k/ k0}
A0 + A1 + A2 = X*
Donc A* = X*

Exercice :
Calculer A. et A.{}
Montrer qu’on a A.(B+C) = A.B + A.C mais pas A.(BC) = A.B  A.C
Corrigé:
1- A. = .A = 
2- A.{} = {}.A= A
5- On n’a pas A.(BC) = A.B  A.C
Contre exemple : A = {, x}, B = {xyzt}, C = {yzt}

Contre exemple : A = {, x}, B = {xy}, C = {y}
Car A.(BC)  A.B  A.C
En effet (BC) =  donc A. (BC) = 
Par contre A.B = {xy, xxy} et A.C = {y, xy} donc A.B  A.C = {xy}
6- On n’a pas A+ = A* - {} par contre on A* =A+ + {}
Pour A = {, a}
A+ = A1 + A2 + … = {, a} + {, a, aa} + …
A* = A0 + A1 + A2 + … = {ai / i  0}
A* - {} = {ai / i > 0}  A+ car A  {}
A+ = A* - {} est vraie lorsque A ne contient pas 

I.5. Définition de langages (propriété
mesurable ou définition récursive)
•Définition par propriété mesurable
–L est l’ensemble des mots sur {a, b} de longueur paire

L = {  {a, b}*/ || = 2k, K  0}
–L est l’ensemble des mots sur {a, b} ayant un nombre impaire de b

L = {  {a, b}*/ ||b = 2k+1, K  0}
–L est l’ensemble des mots sur {a, b} où tous les a précèdent les b et sont de
même nombre
L = { anbn, n  0}

I.5. Définition de langages (propriétés
mesurables ou récursive)
• Définition récursive
– L est l’ensemble des mots sur {a, b} où tous les a précèdent les b et
sont de même nombre
La définition par propriété mesurable est la suivante :
L = { anbn, n  0}
La définition récursive du même langage est :
L = {   {a, b}*/  =  ou  = a1b et 1  L}

– L est l’ensemble des mots palindromes sur le
vocabulaire {a, b}, de longueur paire.
L = {   {a, b}*/  = aa ou  = bb ou  = a1a ou

 = b1b et 1  L}

vocabulaire {a, b}, de longueur impaire.
L = {   {a, b}*/  = a ou  = b ou  = a1a ou

 = b1b et 1  L}

vocabulaire {a, b}.
L = {   {a, b}*/  = a ou  = b ou  = aa ou  = bb
ou  = a1a ou  = b1b et 1  L}

I.6. Le lemme d’Arden
Pour deux langages A et B d’un vocabulaire X*,

Les équations L= AL+B et L = LA+B admettent
respectivement comme solution minimale A*B
et BA*. Cette solution est unique si A.

II. Les automates finis et les
langages réguliers
Plan
II.1. Les automates finis déterministes
II.2. Langage accepté par un automate fini
II.3. Rendre déterministe un automate fini non déterministe
II.4. Les langages réguliers LR
II.5. Minimisation d’un automate fini déterministe
II.6. Expressions régulières et automates finis
II.7. Limites des automates finis
Définition7. Automate fini
Un automate fini consiste en un quintuple de la
forme (Q, X, , q0, F) avec
Q est un ensemble fini d’états
X est un alphabet
 est une fonction de transition
: Q x X  (Q) (l’ensemble de tous les sous ensembles de Q)
q0 est l’état initial
F est l’ensemble des états finaux F  Q
Exemple d’un automate fini
Presser Cet automate reconnaît les

séquences de presser qui
OFF ON nous mènent toujours à
l’état final souhaité ON
Presser (lampe allumée)
En partant d’un état où la
lampe est éteinte (OFF)
Q = {OFF, ON}
X = {presser}
q0 = OFF (OFF, presser) = {ON}
F = {ON} (ON, presser) = {OFF}

Presser
OFF ON
Presser
La séquence:
presser presser presser est acceptée
Par ce que
•en partant de l’état off, avec un presser on passe à l’état ON
•En lisant le deuxième presser à partir de l’état ON, on revient à l’état OFF
•Le dernier presser lu nous mène de l’état OFF à l’état ON
Donc à la fin de la lecture des trois presser, trois transitions sont effectuées et la
dernière nous mène à l’état ON donc la séquence est acceptée.
presser
Presser
presser presser
presser presser presser
presser
OFF
OFF ON
ON
Le mot est lu et l’état est final
Presser
presser donc le mot est accepté
La séquence:
presser presser presser est acceptée
Par ce que
•Le dernier presser lu nous mène de l’état OFF à l’état ON
Donc à la fin de la lecture des trois presser, trois transitions sont effectuées et la
dernière nous mène à l’état ON donc la séquence est acceptée.
Presser
OFF ON
Presser
La séquence:
presser presser n’est pas acceptée par l’automate
Par ce que

A Presser
OFF ON
Presser
Le langage accepté par cet automate est l’ensemble des séquences de presser qui,
partant de l’état initial OFF, après la lecture de tous les symboles de la séquence,
on se trouve à l’état ON.
Ce langage (le langage accepté par l’automate A, L(A)) est l’ensemble des
séquences de presser de longueur impaire.
L(A) = {  {presser}*/ | | = 2k + 1, k  0}

Exemple d’un automate fini qui accepte
{  {a}*/ || = 2k, k  0} (aa)*
A a
P I
L’état initial devient un état final puisque le mot  est accepté (pour k = 0).
En étant à l’état initial de l’automate, on peut ne rien lire (c-a-d lire 0 symboles
donc lire ) et on est déjà à un état final.

Exercices :
1) Construire un automate fini qui accepte le langage suivant:
{  {a}*/ || = 2k, k > 0}
A aa(aa)*
a a
q0 q1 q2
Le plus petit mot accepté est aa (On atteint l’état final après la lecture de aa).
Après il faudra continuer à avoir un nombre paire de a. Donc quand on se trouve à
l’état d’acceptation ou l’état final, il faudra continuer à lire des séquences de 2a
pour revenir à l’état final.

{  {a}*/ || = 2k, k > 0} (autre solution)

A
a a a
q0 q1 q2 q3
a

{a,b}*/ ||a = 3k+2, k  0}
b b b b*ab*ab*(ab*ab*ab*)*
A
a a
q0
q0 q1
q1 q2
pour revenir à l’état final. Les b on peut les lire à n’importe quel état et on reste
au même état puisqu’ils n’engendrent pas une transitions contrairement à un a lu
qui nous fait passer de q0 à q1 ou de q1 à q2 ou de q2 à q0 par ce qu’il faut les
comptabiliser.

{  {a}*/ || = 3k+1, k  0}
a(aaa)*
A
a a a
q0 q1 q2 q3
a
Le plus petit mot accepté est a (On atteint l’état final après la lecture de a). Après il
faudra continuer à avoir un nombre multiple de 3a. Donc quand on se trouve à

{  {a}*/ || = 3k+1, k  0} (autre solution)

a(aaa)*
A
a a
q0 q1 q2
Le plus petit mot accepté est a (On atteint l’état final après la lecture de a). Après il
faudra continuer à avoir un nombre multiple de 3a. Donc quand on se trouve à

{  {a, b, c}*/ ||a = 3k+1, k  0}
b, c b, c b, c
A
a a
q0 q1 q2
(b+c)*a(b+c)*(a(b+c)*a(b+c)*a(b+c)*)*

5) Construire un automate fini qui accepte l’ensemble des mots

sur {a, b, c} ayant aba comme facteur (ou sous chaine)
b, c a a, b, c
a b a
q0 q1 q2 q3
c
b, c

6) Construire un automate fini qui accepte l’ensemble des
représentations décimales des nombres entiers ayant le chiffre 1
dans les dizaines (Exemple: 12316, 13, 210)
0,1,2,3,4,5,6,7,8,9
1 0,1,2,3,4,5,6,7,8,9
q0 q1 q2
c*1c
(0+1+2+…+9)*1(0+1+2+…9)

7) Construire un automate fini qui accepte l’ensemble des
représentations décimales des nombres entiers différents de
Zéro
0,1,2,3,4,5,6,7,8,9
0
1,2,3,4,5,6,7,8,9
q0 q1
0*(1+2+…9)(0+1+2+…+9)*

Définition 8. Automate fini complet
Un automate fini est dit complet sur un vocabulaire X ssi pour
chaque état q et chaque symbole s, il existe au moins une transition
qui quitte q avec le symbole s.
Définition 9. Automate fini non ambigu
Un automate fini est dit non ambigu sur un vocabulaire X ssi pour
chaque état q et chaque symbole s, il existe au plus une transition
qui quitte q avec le symbole s.
Définition 10. Automate fini déterministe
Un automate fini est dit déterministe sur un vocabulaire X ssi il est
complet et non ambigu (pour chaque état q et chaque symbole s, il
existe une et une seule transition qui quitte q avec le symbole s).

a,b a,b a
a a
q0 q1 q0 q1
b
Non complet sur {a, b} car
Ambigu sur {a, b} car
(q0, b) = 
(q0, a) = {q0, q1}
L(A) = a(a+b)*
L(A) = ((a+b)*a+)+
b a
a
q0 q1 L(A) = (b*a+)+
b
Automate fini déterministe sur {a, b} car il est complet et non ambigu:
(q0, a) = {q1} (q0, b) = {q0} (q1, a) = {q1} (q1, b) = {q0}
Définition 11. Configuration
Une configuration est un couple
(q, )
où q est l’état courant et  est le reste du mot à lire.
Pour l’automate suivant, des configurations possibles sont:
b b b
A
a a
q0
q0 q1
q1 q2
a
(q0, aa) (q1, a) (q2, )
(q0, bba) (q0, ba) (q0, a) (q1, )
Définition 12. Configuration successeur

Une configuration (p, y) est successeur d’une
configuration (q, x) qu’on note:
(q, x) |-- (p, y) q a p
ssi a
x
y
 a / x = a y et (q, a) = {p}

Pour l’automate suivant, des configurations possibles sont:
b b b
A
a a
q0
q0 q1
q1 q2
(q0, aa) |-- (q1, a) |-- (q2, )

(q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Définition 13. Configuration kème successeur
Une configuration (p, y) est kème successeur d’une
configuration (q, x) qu’on note:
k
(q, x) |-- (p, y) ssi (q, x) |-- (q1, x1) |-- (q2, x2) |--…(qk, xk) = (p, y)
* k
(q, x) |-- (p, y) ssi  k  0 / (q, x) |-- (p, y)

Pour l’automate suivant, nous avons :
b b b
A
a a
q0
q0 q1
q1 q2
* k
(q0, aa) |-- (q2, ) puisque:  k  0 / (q0, aa) |-- (q2, )

(q0, aa) |-- (q1, a) |-- (q2, ) (k = 2)
3
(q0, bba) |-- (q1, )

En effet, (q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Définition 14. Langage reconnu par un automate

fini
Soit A = (Q, X, , q0, F) un automate fini. Le
langage accepté (ou reconnu par A) est noté
L(A) /
L(A) = {/ (q0, ) |-- (qf, ) , qf  F}

 est accepté par A ssi   L(A)
Exercice : Soit l’automate fini A suivant :
b b b
A
a a
q0
q0 q1
q1 q2
Montrer que aa  L(A) et que bba  L(A)
Corrigé:
*
aa  L(A) par ce que : (q0, aa) |-- (q2, ) puisque:

(q0, aa) |-- (q1, a) |-- (q2, ) (k = 2)
k
bba  L(A) par ce que :  k / (q0, bba) |-- (q2, )

En effet, (q0, bba) |-- (q0, ba) |-- (q0, a) |-- (q1, )
Exercice: Considérons l’automate A suivant :
1) Quel est le langage reconnu par A
b b b
A
a a
q0
q0 q1
q1 q2
2) Est-ce que le mot  est accepté par A

Corrigé:
1) L(A) = {  {a, b}*/ ||a = 3k+2, k  0} + {  {a, b}*/ ||a = 3k, k  0}
2)  L(A) par ce que : q0  F
(q0, ) est une configuration initiale et finale.
(Lemme d’Arden)
Soit A un automate fini sur un vocabulaire X
Avec x  X
A
x
qi qj
On dénote par Li, le langage reconnu par l’automate A en considérant que qi

est l’état initial. Ainsi, L0 est le langage reconnu par A
j  Lj   i  Li / i = x j en conséquence Li = xLj
Si qi est un état final alors Li = x Lj + {} par ce que si qi est un état initial
et final alors le langage Li contient le mot 

(Lemme d’arden)
Exercice : Soit A un automate fini sur un vocabulaire X= {a,b}, Chercher le
langage L0 reconnu par l’automate A
A
a a
q0 q1 q2
a
Corrigé :
L0 = {a} L1 (1) L1 = {a} L2 (2)
L2 = {a} L0 + {} (3)
(1) + (2)  L0 = {a}{a}L2 = {aa}L2 (4)
(4) + (3)  L0 = {aa} L2 = {aa}({a}L0 + {})  L0 = {aaa}L0 + {aa}
 L0 = {aaa}*{aa} = (aaa)*aa
D’après le lemme d’Arden

(Lemme d’arden)
Exercice :
1) Construire un automate qui accepte le langage a*b*
2) Vérifier que l’automate construit reconnaît le langage a*b*
Corrigé :
1) a b
A
b
q0 q1
2) Calculons L0
L0 = {a} L0 + {b}L1 + {} (1)
L1 = {b} L1 + [] (2)
(2)  L1 = {b}*{} d’après le lemme d’Arden  L1 = b* (3)
(1) + (3)  L0 = {a}L0 + {b} b* + {}
 L0 = {a}L0 + b+ + {}
 L0 = {a}L0 + b* car b++{} = b*
 L0 = {a}*b* = a*b*d’après le lemme d’Arden
L(A) = L0 = a*b* donc l’automate A reconnaît le langage a*b*
(Lemme d’arden)
Exercice :
1) Construire une automate qui accepte le langage (a+b)*
2) Vérifier que l’automate construit reconnaît le langage (a+b)* (L0 est le langage accepté par
l’automate puisque c’est le langage où q0 est l’état initial)
Corrigé:
1)
a,b
A
q0
2) L0 = {a} L0 + {b}L0 + {} (1)

(1) L0 = {a,b} L0 + {}
 L0 = {a,b}*{} d’après le lemme d’Arden
 L0 = {a,b}* = (a+b)*

II.3. Rendre déterministe un automate fini
non déterministe
II.3.1. Automate fini non complet
Si l’automate fini est non déterministe par ce qu’il est non complet, alors pour le rendre
déterministe, il suffit d’ajouter un état puit et ajouter toutes les transitions manquantes
vers cet état.
a,b a,b
a a
q0 q1 q0 q1
Non complet sur {a, b} car b

(q0, b) = 
p
L(A) = a(a+b)* a,b
Complet sur {a, b}

non déterministe
II.3.2. Automate fini ambigu
Si l’automate fini est non déterministe par ce qu’il est ambigu
alors on doit construire un automate en groupant les états visités
par un même symbole à partir d’un état, ces états groupés
forment les nouveaux états de l’automate déterministe. La
construction de l’automate déterministe suit les étapes suivantes:
Etape 1. Définir les nouveaux groupes d’états
Etape 2. Renommer les nouveaux groupes et définir les états
finaux. Un nouvel état (Groupe d’état) est un état final ssi il
contient un ancien état final
Etape 3. Construire l’automate déterministe

non déterministe
Exemple1
Etape 1. Définir les nouveaux groupes d’états
a a,b
a b
a,b
q0 q1
{q0} {q0, q1} {q1}
{q0, q1} {q0, q1} {q1}

L(A) = a*(a+b)+ {q1} {q1} {q1}

non déterministe
Exemple1
Etape 2. Renommer les états et définir les états finaux
a a,b
a b
a,b
q0 q1
{q0} A {q0, q1} B {q1} C
{q0, q1} B {q0, q1} B {q1} C
{q1} C {q1} C {q1} C

non déterministe
Exemple1
a
a b
a
A B
{q0} A {q0, q1} B {q1} C
a,b
b b {q0, q1} B {q0, q1} B {q1} C
C
{q1} C {q1} C {q1} C

non déterministe
Exercice : Soit l’automate A suivant, construire un automate fini déterministe
qui reconnaît le même langage
a a,b
a
q0 q1
Corrigé :
Etape1. Définir les nouveaux groupes d’états
a b
L(A) = a+(a+b)* {q0} {q0, q1} 
{q0, q1} {q0, q1} {q1}
{q1} {q1} {q1}

non déterministe
Etape 2. Renommer les états et définir les états finaux
a a,b
a b
a
q0 q1
{q0} A {q0, q1} B  P
{q0, q1} B {q0, q1} B {q1} C
{q1} C {q1} C {q1} C

non déterministe
a
a b
a
A B {q0} A {q0, q1} B
a,b  P
b a,b b {q0, q1} B {q0, q1} B {q1} C

C {q1} C {q1} C {q1} C
P

II.4. Les langages réguliers
II.4.1. Définition
Un langage L est dit régulier s’il existe un automate fini A
qui l’accepte (L(A) = L)

Le lemme de pompage
Soit L un langage régulier reconnu par
un automate à n états.
Pour tout mot z de L, z est de longueur
≥ n, il existe une factorisation z = uvw,
où |uv| ≤ n, v ≠  et,
pour tout i ≥ 0, on a uviw  L.

Exemple d’application : montrer que certains
langages ne sont pas réguliers.
L = {0n1n : n ≥ 0} n'est pas régulier.
Si L est reconnu par un automate à n états, la
factorisation de 0n1n conduit à une
contradiction.
L = {écritures binaires de p, où p est premier}
n'est pas régulier.

II.4.2. Propriétés des langages réguliers
(LR) X
-  est un langage régulier (Il existe un automate fini qui
l’accepte) q0
- Si L1 et L2 sont des langages réguliers alors
L1+L2 (Union), L1.L2 (Concaténation) et L1L2
(Intersection) sont des langages réguliers
- Si L est un langage régulier alors
L* (Fermeture transitive), L+ (Fermeture transitive
réflexive), (Complément X-L) et L (Image miroir) sont des
langages réguliers

II.4.2. Propriétés des langages réguliers (LR)

- Si L1 et L2 sont des langages réguliers alors L1+L2 (Union) est un langage régulier.
On peut toujours construire un automate fini qui accepte L1 + L2 à partir des
automates finis qui acceptent respectivement L1 et L2²²
Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1
A2 = (Q2, X2, 2, q02, F2)/ L(A2) = L2
On construit A = (Q, X, , q0, F)/ L(A) = L1+L2
Q = Q1Q2{q0}
X = X1  X2
d= 12{(q0, x, q)/ (q01, x, q) 1 ou (q02, x, q) 2}
F = F1 F2  {q0} si q01  F1 ou q02  F2
F1  F2 sinon

Exercice: Soient les automates A1 et A2, construire un automate A qui reconnaît L(A1) + L(A2)
(l’union des deux langages reconnus par A1 et A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2
a a,b
Corrigé:
a
q01 q1
A
a a
q0
b
b
a,b
a,b q02 q2

- Si L1 et L2 sont des langages réguliers alors L1.L2 (concaténation) est un langage régulier.
On peut toujours construire un automate fini qui accepte L1.L2 à partir des automates finis
qui acceptent respectivement L1 et L2
Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1

A2 = (Q2, X2, 2, q02, F2)/ L(A2) = L2
On construit A = (Q, X, , q0, F)/ L(A) = L1.L2
Q = Q1Q2
X = X1  X2
q0 = q01
d= 12{(p, x, q)/ (q02, x, q) 2 et p  F1}
F = F1 F2 si q02  F2
F2 sinon

Exercice: Soient les automates A1 et A2 suivants, construire un automate A qui accepte L(A1) .
L(A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2
Corrigé:
a a,b
b
a b a,b
A q01 q1 q02 q2
b a,b
a,b

Exercice: Soient les automates A1 et A2 suivants, construire un automate A qui accepte L(A1) .
L(A2)
a b
a,b
a a,b
A1 q01 q1 A2 q02 q2
a a,b
b
a b a,b
A q01 q1 q02 q2
b a,b
a,b

- Si L est un langage régulier alors L* est un langage régulier
On peut toujours construire un automate fini qui accepte L* à partir de l’automate fini qui
accepte L
Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1

On construit A = (Q, X, , q0, F)/ L(A) = L*
Q = Q1{q0}
X = X1
d= 1{(q0, x, q)/ (q01, x, q) 1}  {(qf, x, q)/
(q01, x, q)  1 et qfF1}
F = F1 {q0}

Exercice: Soit l’automate A1 suivant. Construire un automate A qui accepte (L(A1))*
a a L(A1) = a*ba*
L(A) = (L(A1))* = (a*ba*)*
b Par ce que on a :
A1 q01 q1
(q01, a q01) et (q01, b, q1)
dans 1 qu’on ajoute :
(q0, a, q01) et (q0, b, q1) à 
_____
Corrigé: Par ce que on a :
a a,b (q01, a, q01) et (q01, b, q1)
A
b dans 1 qu’on ajoute :
a q01 q1 (q1, a, q01) et (q1, b, q1) à 
q0
b
a

- Si L est un langage régulier alors L+ est un langage régulier
On peut toujours construire un automate fini qui accepte L + à partir de l’automate fini qui accepte
L
Soit A1 = (Q1, X1, 1, q01, F1) / L(A1) = L1

On construit A = (Q, X, , q0, F)/ L(A) = L1+
Q = Q1{q0}
X = X1
d= 1{(q0, x, q)/ (q01, x, q) 1}  {(qf, x, q)/
(q01, x, q)  1 et qfF1}
F = F1

Exercice: Soit l’automate A1 suivant. Construire un automate A qui accepte (L(A1)) +
a a L(A1) = a*ba*
L(A) = (L(A1))+ = (a*ba*)+
b Par ce que on a :
A1 q01 q1
(q01, a q01) et (q01, b, q1)
dans 1 qu’on ajoute :
(q0, a, q01) et (q0, b, q1) à 
_____
Corrigé: Par ce que on a :
a a,b (q01, a, q01) et (q01, b, q1)
A
b dans 1 qu’on ajoute :
a q01 q1 (q1, a, q01) et (q1, b, q1) à 
q0
b
a

II.5. Minimisation d’un automate fini
déterministe
Soit A un automate fini déterministe A = (Q, X, , q0, F)
Pour obtenir un automate A minimal en nombre d’états, suivre les étapes suivantes:
1) Construire une partition initiale 0 composée de deux groupes: Groupe des états
finaux G1 et Groupe des états non finaux G2
2) Répéter Jusqu’à  i+1 =  i / i0
- Pour obtenir  i+1, Partitionner chaque groupe de i en mettant ensemble des
états p et q si pour chaque symbole s du vocabulaire, p et q transitent vers des
états d’un même groupe d’états.
- Construire les nouveaux groupes
3) Associer à chaque groupe un nom
4) Construire les transitions des groupes en utilisant les transitions des états des
groupes.
5) Un groupe qui contient un état final est un état final dans l’automate minimal

II.5. Minimisation d’un automate fini
déterministe
Exercice : Soit l’automate A suivant. Construire un automate minimal qui accepte le
même langage (Minimiser le nombre d’états de l’automate A)
A
a a a
q0 q1 q2 q3
a
Corrigé:G1 G2
0 (q0, q2, q3) (q1)
G1 G2 G3
P1 (q0, q3) (q2) (q1) (q2, a, q0) est
P2 (q0, q3) (q2) (q1) dans A minimal
q0 q2 q1 car (q2, a, q3) était
On obtient le dans A et que le
A minimal a a group d’états (q0,
q0 q1 q2
q3) est renommé
a q0

Une expression régulière (e.r) est définie récursivement comme suit:
-  est une e.r
- Un symbole a de X est une e.r
- Si E est une e.r alors E+, E*, (E) sont des e.r
- Si E1 et E2 sont des e.r alors E1.E2 et E1+E2 sont des e.r
Lemme
{langages réguliers} = {langages représentés par une expression
régulière}
Rq. Un langage est dit régulier s’il existe un automate fini qui l’accepte ou une
expression régulière qui le représente

Exemples:
a*b*
(a+b)*c+
(0+1+2+…9)+représentations décimales des entiers
(a+b+…z+A+B+…Z)(a+b+…z+A+B+…Z+0+1+…9)*
les identificateurs alphanumériques qui
commencent par un caractère
alphabétique

Exemples:
(a+b)*aa mots sur {a, b} ayant aa comme facteur droit
(a+b+c)*abc(a+b+c)* mots sur {a,b,c} ayant abc comme facteur
0*(1+2+…9)(0+1+…9)* représentations décimales des entiers non nuls
(0+1+2+…9)*1(0+1+2+…9) représentation décimale des entiers

naturels ayant 1 dans les dizaines
(0+1+2+…9)*10 représentation décimale des entiers
naturels ayant 1 dans les dizaines et 0 dans les unités

II.7. Limites des automates finis
Exercice : Prouver que le langage L suivant n’est pas un langage régulier:
L = {aibi, i  0}
C-a-d, il n’existe pas un automate fini qui l’accepte
Corrigé:
Supposons qu’il existe un automate fini A à n états qui accepte L (L(A) = L) (1)
Alors A accepte en particulier anbn,
Considérons la séquence de configurations aceptables pour anbn
(q0, anbn) |-- (q1, an-1bn) |--…..(q2n-1, b) |-- (q2n, ) où q2n  F
Cette séquence contient 2n+1 états
Donc un état au moins doit apparaître plus qu’une fois dans les n premiers mouvements. Soit q cet état, si = sj
= q pour certaines valeurs de i et j telles que 0  i  j  n
Ceci entraine
+ + +
(q0, anbn) |-- (q, an-ibn) |--…..(q, an-jbn) |-- (q2n, )
+ +
(q0, an-j+ibn) |-- (q, an-jbn) |--…..(q2n, )
C-a-d an-j+i bn L(A)
C-a-d L  L(A) (absurde) avec l’hypothèse (1)

III. Les grammaires
Plan
III.1. Définition d’une grammaire
III.2. Langage généré par une grammaire
III.3. Grammaire régulière
III.4. Langages réguliers et grammaires
régulières
III.5. Les formes normales de grammaires
Une grammaire est un quadruplet:

G = (V, T, S, R)
Où
V est un alphabet non terminal
T est un ensemble de terminaux
S est l’axiome de la grammaire (Symbole de départ) (S
 V)
R est l’ensemble des règles de production

Exemple: Une grammaire Le mot aabbcc est généré
avec les règles suivantes: par la grammaire:
S  abNSc
S S  abNSc
bNa  abN  abNabNScc
bNb  bbN  abNabNcc
bNc  bc  aabNbNcc
 aabNbcc
Génère {anbncn, n  0}  aabbNcc
 aabbcc

Exercice : Soit le langage L suivant :
L = {anbn, n  0}
1) Construire une grammaire G qui génère L
2) Vérifier que les mots ab et aabb sont générés par la
grammaire G
Corrigé:
1) G = (V, T, S, R)
Où V = {S} T = {a, b} R = {S  , S  aSb }
2) Le mot ab est généré par la Le mot aabb est généré par la

grammaire G en effet: grammaire G en effet:
S  aSb  ab = ab S  aSb  aaSbb  aabb =
Leila Ben Ayed
aabb
Théorie des Langages et Compilation 90
L = {anbn, n  0} = {e, ab, aabb, aaabbb, ……….}
L = {w / w = e ou w = a w1 b, w1 L}
L1 = {aibj, i, j > 0} a+b+
S S S S -> aSb
S -> e
e a S b a S b
e a S b
aeb = ab
e
e
aeb
aaebb
L = a* ={ai, i>=0}
S -> aS
S S S S -> e
e a S
e
ae = a

L = { formules logiques sur le vocabulaire
{p, ->, (, ), V, /\, !} } ! Repr not
S -> p
S -> S V S
S -> S /\ S
S -> (S)
S -> ! S
S -> S -> S
L = { w / w = p ou w = w1 V w2 ou w = w1 /\w2 ou w = (w1)
ou w = ! W1 ou w = w1 ->w2, w1  L et w2  L}

Exercice:
1) Construire une grammaire G qui génère le langage a+
2) Vérifier que les mots aa et a sont générés par la grammaire
Corrigé :
1) Une grammaire qui génère {an, n > 0} = a+
G = (V, T, A, R) Où V = {A}, T = {a}
R = { A  a, A  aA }
2) Le mot aa est généré par la grammaire G en effet:
A  aA  aa
Le mot a est généré par la grammaire G en effet:
Aa

Exercice:
1) Construire une grammaire G qui génère {an, n  0} = a*
2) Vérifier que les mots aa et  sont générés par G.

Corrigé:
1) G = (V, T, A, R) Où
V = {A} T = {a, b} R = { A  , A  aA }
2) Le mot aa est généré par la grammaire G en effet:
A  aA  aaA  aa = aa
Le mot  est généré par la grammaire G en effet:
A

Exercice :
1) Construire une grammaire G qui génère les représentations
décimales des entiers naturels :
(0+1+…9)+ = {0, 1, 2, …9}+
2) Vérifier que le mot 0129 est généré par la grammaire G
Corrigé:
1) G = (V, T, S, R)
Où V = {C}
T = {0, 1, …, 9}
R = { C  0|1|2|…|9| 0C|1C|…9C}
2) Le mot 0129 en effet:
C  0C  01C  012C  0129
L est l’ensemble des représentations décimales des entiers

naturels non nuls
1) Donner une expression régulière qui représente le langage L

2) Donner une grammaire G qui génère L
3) Vérifier que le mot 0129 est généré par la grammaire G
4) Construire un automate fini qui accepte le langage L

Corrigé: 3) Le mot 0129 en effet:
1) 0*(1+…+9)(0+1+…+9)* A  0A
2) G = (V, T, S, R)  01B
Où  012B
V = {A, B}  0129B
T = {0, 1, …, 9}  0129
R = {A  0A|1B|2B|…|9B,
B  0B|1B|…9B|} 4)
0,1,2,3,4,5,6,7,8,9
0
1,2,3,4,5,6,7,8,9
A B

Définition:
Soit G = (V, T, S, R) une grammaire. Si T  X où X est un
alphabet alors on dit que G est une grammaire sur X.
Définition:
L(G) = {  T* /  est dérivé de S}
On dit que L(G) est le langage généré par G.

Exercice : Construire une grammaire G qui génère le langage L

suivant:
L = {anbmcn, m, n  |N}
Corrigé:
La grammaire G est définie comme suit :
G = (V, T, S, R)
V = {S, B}, T = {a, b, c}, R = {S  aSc, S  B, B  |bB}
G Génère le langage L(G) = {anbmcn, m, n  |N}

III.3. Grammaires régulières
Définition: (Grammaires régulières)
Une grammaire régulière est une grammaire avec les
restrictions suivantes:
• Le coté gauche de chaque production consiste en un seul
symbole non terminal.
• Le coté droit est :
• Soit un symbole terminal suivi d’un symbole non
terminal
• Soit un seul symbole terminal
• Soit 

III.3. Grammaires régulières
Exemple :
C  bD, C  a, B  
Est une grammaire régulière mais pas :
bD  A, A  acb, BA  Dec
Remarque:
Il est possible d’éliminer les règles de la forme : N  a en les
remplaçant par N  aX
X 
Où X est le nouveau symbole n’apparaissant pas dans la
grammaire initiale.

régulières
Théorème
Pour chaque alphabet X,
{Langages réguliers sur X}
=
{L(G) / G est une grammaire régulière sur X}
=
{L(M) / M est un automate fini sur X}
Rq. Un langage est dit régulier s’il existe un automate fini qui
l’accepte ou bien une grammaire régulière qui le génère ou
bien une expression régulière qui le représente.
régulières
Preuve:
• Conversion grammaire / automate
Soit G = (V, T, S, R) une grammaire régulière.
1) On peut transformer la grammaire G en une grammaire
G’ = (V’, T, S, R’)
Qui génère le même langage sur G, mais n’ayant pas de règle dont le coté droit
consiste en un seul symbole terminal (remplacer N  a par
N  aX, X  }.
2) On définit un automate fini M = (Q, X, , q0, F)
Q = V’
X=T
 = { (p, x, q} / p  xq  R’}
q0 = S
F = {q / (q )  R’}

régulières
Exercice 1 : Soit la grammaire régulière G ayant les règles de
production suivantes, construire un automate A / L(G) = L(A)
G = (V, T, A, R)/ V = {A, B}, T = {a, b}, R = {A  bB | aA|, B  bB |}
Corrigé Exercice 1:
A  bB
a b
A  aA
b
A
A B
B  bB
B

régulières
• Conversion automate/grammaire
Soit M = (Q, X, , q0, F) un automate fini,
On définit une grammaire G / L(G) = L(M) comme suit:
G = (V, T, S, R)/
V=Q
T=X
S = q0
R = {p  xq / (p, x, q)  }  {q  / q  F}

régulières
Exercice : Soit l’automate fini A suivant :
A = (Q, X, , q0, F) / Q = {A, B}, X = {a, b},  = {(A, a, A), (A, b, B), (B, b, B)}, q0 = A,
F = {A, B}
Construire une grammaire régulière G / L(G) = L(A)
Corrigé Exercice 2:
G = (V, T, A, R)/ V = {A, B}, T = {a, b}, R = {A  bB | aA|, A  bB |}
A  bB
a b A  aA
b
A B A
B  bB
B

III.5. Les formes normales des grammaires
III.5.1. Forme standard binaire (CHOMSKY)

C’est la forme des règles de production suivantes :
A  BC ; A  a
où
A, B, C  V et a  X  {}

Exercice 1 : Soit la grammaire G suivante. Construire une grammaire G’ sous
forme de CHOMSKY qui génère L(G) (le langage généré par G)
G = ({S, A, B}, {a, b}, S, R)
R = { S  bA, S  aB,
A  a, B  b,
A  aS, B  bS,
A  bAA, B  aBB }
Corrigé Exercice 1: La forme standard binaire associée aux règles de production de la

grammaire G est :
R’= { S  C1A, A  C1C3, B  C2C4,
C1  b, C3  AA, C4  BB,
A  a, S  C2B,
A  C2S, B  b,
C2  a, B  C1S, }
La mise en forme standard binaire de la grammaire G donne la grammaire G’
G’ = ({S, A, B, C1, C2, C3, C4}, {a, b}, S, R’)
III.5.2. Forme standard de GREIBACK

C’est la forme des règles de production suivantes :
A  av
où
a  X, A  V, v  V*

Exercice 2: Soit la grammaire G suivante. Construire une

grammaire G’ sous forme GREIBACK qui génère L(G)
G = ({A1, A2, A3}, {a, b}, A1, R)
R = { A1  A2A3,
A3  A4A3,
A2  aA3,
A4  b,
A3  b }
Corrigé Exercice 2: La forme standard de GREIBACK associée est :
R’= { A1  aA3A3
A3  b A3
A3  b }
La mise en forme standard de GREIBACK de la grammaire G donne la grammaire G’
G’ = ({A1, A3}, {a, b}, A1, R’)

IV. Les grammaires non contextuelles
Plan
IV.1. Définition d’une grammaire non
contextuelle
IV.2. Dérivation
IV.3. Langage généré par une grammaire
IV.4. Langage hors contexte
IV.5. Dérivation, arbre et ambiguïté
IV.6. Propriétés des langages non
contextuels
IV.1. Définition d’une grammaire non
contextuelle (GNC)
Une grammaire non contextuelle G est un quadruplet:
G = (V, T, S, R)
Où
V est un alphabet non terminal
T est un ensemble de terminaux
R est l’ensemble des règles de production de la forme
A  U / A V et U  (V  T)*
S est l’axiome de la grammaire (Symbole de départ) (S
 V)

IV.2. Dérivation
• U  V dénote la dérivation de V à partir de U
• U  V ssi il existe des chaines x, y, t  (V T)* et A  V
telles que : U = x Ay, V = x t y et A  t
G
Exemple
G = ({S}, {a, b}, S, {S  aSb |})
S  aSb ici U = S x =  et y = 
V = aSb A = S et t = aSb
aSb  aaSbb ici U = aSb x = a et y = b
V = aaSbb A = S et t = aSb
k
UV  U  U1  U2 … Uk = V

IV.3. Langage généré par une grammaire
*
• La relation  est la fermeture réflexive et transitive de 
G G
* k
S  k1/S
*
Par exemple S  aabb Puisque S aSb  aaSbb  aabb
Le langage généré par une grammaire G est L(G)

*
L(G) = { X* / S  }
*
aabb  L(G) par ce que S  aabb
IV.4. Langage hors contexte ou indépendant
du contexte
Un langage L est dit non-contextuel

ssi
Il existe une grammaire non-contextuelle G
telle que
L(G) = L
Si LR est l’ensemble des langages réguliers et LIC est l’ensemble des

langages indépendants du contexte, alors on a
LR  LIC

du contexte
Exemple : G génère la chaine (x1*x2+x1)*(x1+x2) par la
G = (V, X, E, R) dérivation suivante
V = {T, F, E} E  T (2)  T*F (3)  F*F (4)
X = {x1, x2, +, *, (, )}  (E)*F (5)  (E+T)*F (1)
R={ EE+T (1)  (T+T)*F (2)  (T*F+T)*F (3)
ET (2)  (F*F +T)*F (4)  (x1*F+T)*F (6)
T  T *F (3)  (x1*x2+T)*F (7)  (x1*x2+F)*F (4)
TF (4)  (x1*x2+x1)*F (6)  (x1*x2+x1)*(E) (5)
F  (E) (5)  (x1*x2+x1)*(E+ T) (1)
F  x1 (6)  (x1*x2+x1)*(T+ T) (2)
F  x2 (7)  (x1*x2+x1)*(F+ T) (4)
}  (x1*x2+x1)*(x1+ T) (6)
 (x1*x2+x1)*(x1+ F) (4)
 (x1*x2+x1)*(x1+ x2) (7)
L(G) est (ou bien G génère) l’ensemble des expressions arithmétiques
parenthèsées utilisant x1, x2 et les opérateurs arithmétiques + et *.
du contexte
Exercice :
1) Construire une grammaire G qui génère des expressions booléennes sur les
nombres entiers, les opérateurs arithmétiques {+, *}, les opérateurs booléens {et,
ou, non} et les opérateurs relationnels {>, <, = }
2) Vérifier que le mot (nb + nb) > nb est généré par la grammaire
Corrigé :
G = (V, X, Eb, R)
V = {Ea, Eb, Er}
X = {nb, +, *, (, ) , >, <, = , et, ou, non} où nb représente un nombre entier.
R={ Ea  Ea + Ea | Ea * Ea | nb | (Ea)
Er  Ea > Ea | Ea < Ea | Ea= Ea
Eb  Er | non Eb | Eb et Eb | Eb ou Eb | (Eb)
}

Exemple d’un langage indépendant du
contexte (LIC)
Lemme1
Tout langage L hors-contexte tel que  L
peut être engendré par une grammaire
hors-contexte sous forme normale de
GREIBACK

A chaque dérivation, on associe un arbre dont:
-La racine est étiquetée par le symbole de départ de la grammaire
-A un nœud étiqueté A, on associe les fils X1X2… Xn si la règle A X1X2…Xn a été
appliquée.
-Exemple
S  AB
Aa
Bb
Pour le mot ab, on a deux dérivations possibles :
1) S  AB  aB  ab
2) S  AB  Ab  ab

1) S  AB  aB  ab
2) S  AB  Ab  ab
Ces deux dérivations ne diffèrent que par l’ordre d’application des règles. En
conséquence, on fait correspondre le même arbre.
A B
a b

Dérivation la plus à gauche (lpg)
*
Pour un arbre donné correspondant à la dérivation : A  
Où   X*, il existe une dérivation unique ayant la propriété suivante :
A = 0  1  2 ……  n = 
et
 i = 0, …, n-1 : i = ui Ai yi
i+1 = ui Zi yi
(Ai  Zi)  R ; ui  X*
On l’appelle la dérivation la plus à gauche

Dérivation la plus à gauche (Exemple)
Soit G = ({S, A}, {a, b}, S, R) R = {S  aAb, S  a, S  abSbS, A  bS}
Soit  = ababa
Au mot , correspond la dérivation la plus à gauche suivante :
S  abSbS  ababS  ababa S
L’arbre correspondant est le suivant:

a b S b S
La dérivation S  abSbS  abSba  ababa
N’est pas une dérivation la plus àgauche a a

Lemme 2
Pour tout mot d’un langage L(G), il
existe une dérivation la plus à gauche

Exemple
Soit G = ({S, A}, {a, b}, S, R) R = {S  aAb, S  a, S  abSbS, A  bS}
Le mot  = abababab  L(G)
Une dérivation possible est qui n’est pas la plus à gauche:
S  abSbS (3)
 abSbaAb (1)
 abSbabSb (4)
 abSbabab (2)
L’arbre de dérivation est : S  abababab (2)
a b S b S
a a A b
b S
a
Exercice :
Soit une grammaire avec les règles de production suivantes :
R = {S  aAb, S  a, S  abSbS, A  bS, S  abSb}
1) Donner une dérvation la plus à gauche du mot abababab
2) Construire un arbre associé à cette dérivation
3) Construire deux dérivations les plus à gauche pour le mot abab
Corrigé:
1) La dérivation la plus à gauche : 2)
S  abSbS (3) S
 ababS (2)
 ababaAb (1) a b S b S
 abababSb (4)
 abababab (2) a
a A b
b S
a
R = {S  aAb, S  a, S  abSbS, A  bS, S  abSb}
3) S  aAb  abSb  abab S  abSb  abab
S S
a A b a b S b
b S a

Ambiguïté
Une grammaire G est dite ambiguë s’il existe un mot de L(G) qui a au moins 2
dérivations lpg à partir de S (donc deux arbres différents sont associés à ce mot).
Sinon G est non – ambiguë.
Exercice : Montrer que la grammaire G

suivante est ambigüe:
G = ({S, A}, {a, b}, b, R)
R = { S  aAb, S  a, S  abSb, A  bS}
Corrigé:
en effet, pour le mot abab il y a deux
dérivations lpg
S  aAb  abSb  abab
S  abSb  abab

IV.6. Propriétés des langages non contextuels
(LNC)
Soit LNC, l’ensemble des langages non contextuels:

-Si L1  LNC et L2  LNC alors
- L1  L2  LNC
- L1.L2  LNC
-Si L  LNC alors L*  LNC, L+  LNC et L  LNC
-On n’a pas la propriété pour L1L2 et pour L

(LNC)
L1  L2  LNC
En effet, on peut construire une grammaire non contextuelle
qui génère L1  L2 à partir des grammaires non contextuelles
qui génèrent L1 et L2
Soit G1 = (V1, T1, S1, R1) / L(G1) = L1 et
G2 = (V2, T2, S2, R2)/ L(G2) = L2
On peut construire G = (V, T, S, R) / L(G) = L(G1) L(G2)
- V= V1V2  {S} où S n’apparaît ni dans V1 ni dans V2 et
V1 et V2 sont disjoints si non on doit renommer les non
terminaux
- T = T1 T2
- R = R1  R2  {S  S1, S  S2}
(LNC)
Exercice : Soient les langages L1 et L2 générés respectivement par G1 et
G2.
L1 = {anbn / n0}
L2 = {a2nbn / n  0}
G1 = ({S1}, {a, b}, S1, {S1 | aS1b})
G2 = ({S2}, {a, b}, S2, {S2 | aaS2b})
1) Construire une grammaire G / L(G) = L1  L2
2) Vérifier que le mot aab est généré par la grammaire G
Corrigé :
1) G = ({S1, S2, S}, {a, b}, S, {SS1, SS2, S1, S1aS1b, S2,
S2aaS2b})
2) Le mot aab est généré par G en effet S * aab
S  S2  aaS2b  aab donc aab  L(G)

(LNC)
L1 .L2  LNC
qui génère L1.L2 à partir des grammaires non contextuelles
qui génèrent L1 et L2
Soit G1 = (V1, T1, S1, R1) / L(G1) = L1 et
G2 = (V2, T2, S2, R2)/ L(G2) = L2
On peut construire G = (V, T, S, R) / L(G) = L(G1).L(G2)
- V= V1V2  {S} où S n’apparaît ni dans V1 ni dans V2 et
V1 et V2 sont disjoints si non on doit renommer les non
terminaux
- T = T1 T2
- R = R1  R2  {S  S1 S2}
(LNC)
Exercice: Construire une grammaire qui génère L1.L2
L1 = l+
L2 = (l+c)+ où l  {a, b, c, …z, A, B, C, …Z}= L et
c  {0, 1, 2, 3, …, 9}= C
G1 = ({S1}, L, S1, R1)
G2 = ({S2}, L C, S2, R2)
R1 = { S1 a, S1 b,…. S1 z , R2 = { S2 a, S2 b,…. S2 z ,
S1 A, S1 B, … S1 Z, S2 A, S2 B, … S2 Z,
S1 aS1, S1 bS1,…. S1 zS1, S1 S2 0, S2 1,…. S2 9,
AS1, S1 BS1, … S1 ZS1} S2 aS2, S2 bS2,…. S1 zS2, S2
AS2, S2 BS2, … S2 ZS2,
S2 0S2, S2 1S2, … S2 9S2}
Corrigé: G / L(G) = L1.L2 = l+(l+c)+

G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})
(LNC)
Exercice :
1) Construire une grammaire G qui génère L1. L2
2) Vérifier que le mot temp1 est généré par G L1 = l+
L2 = (l+c)* où l  {a, b, c, …z, A, B, C, …Z}= L et
c  {0, 1, 2, 3, …, 9}= C
G1 = ({S1}, L, S1, R1)
= a,
R1 = { G2S1 S1 b,….
({S2}, L R2)z ,
C, S2, S1 R2 = { S2 
S1 A, S1 B, … S1 Z, S2 aS2, S2 bS2,…. S1 zS2, S2
S1 aS1, S1 bS1,…. S1 zS1, S1 AS2, S2 BS2, … S2 ZS2,
AS1, S1 BS1, … S1 ZS1} S2 0S2, S2 1S2, … S2 9S2}
Corrigé :
1) G / L(G) = L1.L2 = l+(l+c)*
G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})
(LNC)
G / L(G) = L1.L2 = l+(l+c)*

G = ({S1,S2,S}, LC, S, R1R2  {SS1S2})
2) Vérifier que le mot temp1 est généré par G

Mq S * temp1
S  S1S2  tS1S2 teS1S2 temS1S2 tempS2 temp1S2
temp1

(LNC)
-Si L  LNC alors L*  LNC
qui génère L* à partir d’une grammaire non contextuelles qui
génère L
Soit G1 = (V1, T1, S1, R1) / L(G1) = L
On peut construire G = (V, T, S, R) / L(G) = (L(G1))*
- V= V1 {S} où S n’apparaît pas dans V1
- T = T1
- R = R1  {S  , S  S1 S}

(LNC)
Exercice : Soit la grammaire G1 suivante qui génère le
langage L = {a, b}
G1 = ({S1}, {a, b}, S1, {S1a |b})
1) Construire une grammaire G / L(G) = L*
2) Vérifier que le mot aab est généré par la grammaire G
Corrigé :
1) G = ({S1, S}, {a, b}, S, {S  , S  S1 S, S1a,
S1b})
2) Vérifier que le mot aab est généré par G. Mq S * aab
S  S1S  S1S1S  S1S1S1S  aS1S1S  aaS1S  aabS  aab

(LNC)
-On n’a pas Si L1  LNC et L2  LNC alors L1 L2  LNC
Contre exemple:
L1 = {aibick/ i 0, k0}  LNC
G1 = ({S, S1, S2}, {a, b, c}, S, {SS1 S2, S1  |aS1b,
S2  |cS2})
L2 = {akbici/ i 0, k0}  LNC
G2 = ({A, B, C}, {a, b, c}, C, {CAB, A  |aA,
B  |bBc})
L1  L2 = {aibici/ i 0}  LIC car il n’existe aucune
grammaire non
contextuelle qui le génère
V. Les automates à Piles
Plan
V.1. Présentation
V.2. Définition d’un automate à pile
V.3. Description d’un automate à pile
V.4. Exemple d’automate à Pile
V.5. Fonctionnement d’un automate à pile
V.6. Langages acceptés par des automates à pile
V.7. Construction d’un automate à pile à partir d’une
grammaire non contextuelle

V.1. Présentation
L’automate fini permet de représenter une grammaire régulière. Par suite, il permet de
reconnaître des mots d’un langage régulier (associé à une grammaire régulière).
À une règle (A  x B) d’une grammaire régulière, on peut associer une transition
(A, x, B)
A x B
Partant d’une grammaire non contextuelle ayant une règle de production de la forme
(A  x B y), l’automate doit se souvenir qu’il doit lire la chaine y après avoir lu la sous
chaine dérivant de B. Pour cette raison, on ajoute une pile à l’automate fini où on
empile ce que nous avons à lire (x) et après avoir dérivé la sous chaine dérivant de B,
on doit lire y et dépiler le y de la pile.
On parle d’automate à pile

V.2. Définition d’un automate à pile
Un automate à pile A est un septuplet
A = < X, Q, q0, F, , Z0, >
Où
X est un alphabet
Q est un ensemble d’états
q0  Q est l’état initial
F  Q est l’ensemble des états finaux
 est le vocabulaire de la pile
Z0 est le symbole initial de la pile (symbole de fond de pile)
d est une fonction de transition
d : Q x (X  {}) x   { parties finies de Q x *}

V.3. Description d’un automate à pile
Z0 Pile
Tête de lecture/écriture
q Unité de contrôle
Tête de lecture
U V Ruban d’entrée
L’unité de contrôle, se trouve à un état q munie de deux têtes (L/E sur pile
et L sur ruban d’entrée). Le ruban d’entrée sert de support à un mot de X *.
La lecture se fait de gauche à droite. La pile est un ruban infini du côté droit
où sont lus et écrits les symboles de la pile (*). La case lue est toujours
celle qui contient le symbole le plus à droite.
V.4. Exemple d’un automate à pile qui
accepte {ancbn / n 0}
(a, Z0, Z0a)
(a, a, aa) •Commencer par empiler tous les a
q0 •On doit lire un c
• Le c peut être précédé d’un a
comme il peut être le seule
symbole dans le mot
(c, a, a) • Dans les deux cas, il ne doit pas
(c, Z0 , Z0) être empilé et il faut changer
d’état pour séparer la lecture
des a de la lecture des b.
•si on lit un b alors il doit être
q1 (b, a, ) précédé d’un a. On le dépile et on
(, Z0, ) continue à accepter uniquement des
b et dépiler les a correspondants.
•A la fin, il faut arriver à vider la pile

Exemple d’un automate à pile qui accepte
{ancbn / n 0} suite
Acceptation du mot aacbb
aacbb aacbb aacbb aacbb aacbb aacbb aacbb

q0 q0 q0 q1 q1 q1 q1
Z0 Z0a Z0aa Z0aa Z0a Z0
Le mot aacbb est lu et la pile est vide alors il est accepté
Rejet du mot acbb

Le mot acbb n’est pas
acbb acbb acbb acbb accepté par ce que le mot
n’est pas entièrement lu.
q0 q0 q1 q1
La transition de q1 avec b,
Z0 n’est pas définie.
Z0 Z0a Z0a Z0

Exemple d’un automate à pile qui accepte
{ancbn / n 0} suite
Le mot c est accepté
C C C
q0 q1 q1
Z0 Z0
Le mot c est lu et la pile est vide alors il est accepté
Rejet du mot aacb
aacb aacb aacb aacb aacb

q0 q0 q0 q1 q1
Z0 Z0a Z0aa Z0aa Z0a
Le mot aacb n’est pas accepté par ce que on n’arrive pas à vider la pile
a- Configuration
Une configuration d’un automate à pile est le contenu des deux rubans, d’un état
et de la lettre à lire
 = (U, q, aV, Z)

Où Le contenu du ruban d’entrée est : UaV
Le contenu de la pile est : Z avec  *
Z   : sommet de pile
La configuration initiale est : (, q0, , Z0)

U =  par ce que rien n’a été lu donc  lu
aV =  puisqu’il reste tout le mot à lire
L’état initial est q0
Le symbole sommet de pile est le symbole fond de pile Z0 puisque la pile est
vide
Leila Ben Ayed initialement Théorie des Langages et Compilation 147
b- Configuration successeur de  = (U, q, aV, Z)
 est une configuration successeur de  qu’on note  |--  si
Si (qi, i)  δ(q, a, Z) alors  = (Ua, qi, V,  i)

(qi, i)  δ(q, , Z) alors  = (U, qi, aV,  i)
Autrement dit, le symbole a peut ou non être lu ( transition, sans consommer un

symbole), l’unité de contrôle passe de l’état q à l’état qi. Le symbole au sommet Z
est remplacé par i
c- Configuration k successeur
k
 |--    |-- 1 |-- 2 |-- … k / k = 
* k
 |--   k0  |-- 
+ k
Leila 
|--Ayed
Ben k>0  |--  Théorie des Langages et Compilation 148
V.5. Langages acceptés par un automate à
pile
Deux critères d’acceptation sont définis pour un automate à pile
- Le critère pile vide (mot accepté = mot lu + pile vide)
- Le critère état final (mot accepté = mot lu + état final)
Pour un automate à pile A= <X, Q, q0, F, , Z0,  >,

L(A) désigne le langage accepté avec le critère pile vide
c-a-d un mot  est accepté par A ssi en partant d’une pile contenant Z0 comme
symbole de fond de pile, après la lecture du mot, on arrive à vider la pile.
N(A), le langage accepté avec le critère état final
c-a-d un mot  est accepté par A ssi en partant d’une pile contenant Z0 comme
symbole de fond de pile, après la lecture du mot, on arrive à un état final ; pas de
soucis sur le contenu de la pile.

pile
Pour un automate à pile A, deux langages sont acceptés L(A) et N(A) qui peuvent être
vides (cas de N(A) lorsqu’il n’ya pas d’état final N(A) =  si F = )
*
L(A) = {  X* / (, q0,  , Z0) |-- ( , q, , )}
*
N(A) = {  X* / (, q0,  , Z0) |-- (, qF, , )/ qF  F}
On n’a pas toujours L(A) = N(A) mais on a :

$ A’ / L(A) = N(A’) et
 A’’/ L(A’’) = N(A)

pile
Pour un automate à pile A sans état final,N(A) = 
(a, Z0, Z0a)
A (a, a, aa) Pour l’automate A suivant :
q0 L(A) = {anbn / n 1}
N(A) = {aibj / i j>0}
a2b2  L(A) en effet

(b, a, )
(, q0, aabb, Z0) |-- (a, q0, abb, Z0 a)
|-- (aa, q0, bb, Z0 aa) |-- (aab, q1, b, Z0 a)
|-- (aabb, q1, , Z0 )|-- (aabb, q1,  ,  )
(b, a, )
q1
(, Z0, )
a2b  N(A) en effet
( , q0, aab , Z0) |-- (a, q0, ab, Z0 a)
|-- (aa, q0, b, Z0 aa) |-- (aab, q1,  , Z0 a)

V.6. Construction d’un automate à pile à partir
d’une grammaire non contextuelle (GNC)
Définition. Un langage est dit non contextuel ou indépendant du contexte ou hors
contexte s’il existe un automate à pile qui l’accepte
Construction d’un automate à pile à partir d’une

grammaire non contextuelle
Soit G = (V, T, S, R) une GNC, il existe un automate
à pile A / N(A) = L(G)
A = < X, Q, q0, F, , Z0, >
Où
X=T
Q = {q0, q1}
F = {q1}
G= X  {Z0}
 / (q0, , Z0) = (q1, S)
(q1, , A) = (q1, )  A  ~  R
(q1, a, a) = (q1, )  a  X

 / (q0, , Z0) = (q1, S)
(q1, , A) = (q1, )  A  ~  R
(q1, a, a) = (q1, )  a  X
Exercice : Soit la grammaire G suivante.

G = ({S} , {a, b}, S, R)
R = {S  aSb, S  }
1) Construire un automate à pile qui accepte L(G) q0
avec le critère état final
2) Vérifier que le mot aabb est accepté par
l’automate
Corrigé : (, Z0, S)
1)  / (q0, , Z0) = (q1, S)
(q1, , S) = (q1, bSa)
(q1, , S) = (q1, )
(q1, a, a) = (q1, ) q1
(q1, b, b) = (q1, ) (, S, bSa) (, S, )
(a, a, ) (b, b, )

q0
1)  / (q0, , Z0) = (q1, S)
(q1, , S) = (q1, bSa)
(q1, , S) = (q1, )
(q1, a, a) = (q1, ) (, Z0, S)
(q1, b, b) = (q1, )
q1
(, S, bSa) (, S, )
(a, a, ) (b, b, )

2) Vérifier que le mot  = aabb est accepté par

l’automate q0
(, q0, aabb, Z0) |-- (, q1, aabb, S)
|-- (, q1, aabb, bSa)
|-- (a, q1, abb, bS)
|-- (a, q1, abb, bbSa) (, Z0, S)
|-- (aa, q1, bb, bbS)
|-- (aa, q1, bb, bb)
|-- (aab, q1, b, b)
|-- (aabb, q1, , ) q1
(, S, bSa) (, S, )
(a, a, ) (b, b, )

Exercices
Exercice 1 : Construire un automate à pile qui accepte {ancbn / n1}
(a, Z0, Z0a)

•Commencer par empiler tous les a
(a, a, aa) •On doit lire un c
q1 • Le c doit être précédé d’un a. Le
c ne doit pas être empilé et il
faut changer d’état pour séparer
la lecture des a de la lecture des
(c, a, a)
b.
•si on lit un b alors il doit être
précédé d’un a. On le dépile et on
continue à accepter uniquement des
b et dépiler les a correspondants.
q2 (b, a, )
•A la fin, il faut arriver à vider la pile
(, Z0, )

Exercices
Exercice 1 : Construire un automate à pile qui accepte {xnyzn+1 / n0}
(x, Z0, Z0x)

(x, x, xx) (, q0, xyzz, Z0) |-- (x, q0, yzz, Z0x)
q0 |-- (xy, q1, zz, Z0x)
|-- (xyz, q1, z, Z0)
|-- (xyzz, q1, , )
(y, x, x),
(y, Z0, Z0) Donc le mot xyzz est accepté par
l’automate
q1 (z, x, ) (, q0, yz, Z0) |-- (y, q1, z, Z0)

(z, Z0 , ) |-- (yz, q1, , )
Donc le mot yz est accepté par
l’automate

Exercices
Exercice 2 :
1) Construire un automate à pile qui accepte {anbn / n0} avec le critère pile vide
2) Vérifier que le mot aabb est accepté par l’automate
•Commencer par empiler tous les a

1) (, Z0, ) •si on lit un b alors il doit être
(a, Z0, Z0a) précédé d’un a. On le dépile et on
q0 (a, a, aa) change d’état pour accepter
uniquement un b et dépiler un a
correspondant.
•A la fin il faut arriver à vider la pile
(b, a, )
l’automate
(, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
q1 (b, a, ) |-- (aab, q1, b, Z0a)
(, Z0, ) |-- (aabb, q1, , Z0)
|-- (aabb, q1, , )
Exercices
Exercice 3 :
1) Construire un automate à pile qui accepte {anbn / n0} avec le critère état final
2) Vérifier que le mot aabb est accepté par l’autmoate
a, Z0, Z0a)
1) (a, a, aa)
Un mot est accepté si après la lecture du
q0
mot, on atteint un état final
2) Vérifier que le mot  = aabb est accepté

(b, a, ) par l’automate
(, Z0, Z0) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
|-- (aabb, q1, , Z0)
q1
|-- (aabb, q2, , Z0)
(b, a, )
(, Z0, Z0)

q2
Exercices
Exercice 4 :
1) Construire un automate à pile qui accepte {anbm / m>n} avec le critère état final
2) Vérifier que le mot abb est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa)
q0
2) Vérifier que le mot  = abb est accepté
par l’automate
(, q0, abb, Z0) |-- (a, q0, abb, Z0a)
(b, a, ) |-- (ab, q1, b, Z0)
(b, Z0, Z0)
|-- (abb, q2, , Z0)
q1
(b, a, )
(b, Z0, Z0)
q2
Leila Ben Ayed
(b, Z0, Z0Théorie
) des Langages et Compilation 160
Exercices
Exercice 5 :
1) Construire un automate à pile qui accepte {anbm / m>n} avec le critère pile vide
2) Vérifier que le mot abb est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa)
q0
2) Vérifier que le mot  = abb est accepté
par l’automate
(, q0, abb, Z0) |-- (a, q0, bb, Z0a)
(b, a, )
(b, Z0, Z0) |-- (ab, q1, b, Z0)
|-- (abb, q2, , Z0)
|-- (abb, q2, , )
q1 (b, a, )
(b, Z0, Z0)

q2 (b, Z0, Z0)
Leila Ben Ayed ) des Langages
(, Z0,Théorie et Compilation 161
Exercices
Exercice 6 :
1) Construire un automate à pile qui accepte {anbm / n>m} avec le critère état final
2) Vérifier que le mot aab est accepté par l’automate
(a, Z0, Z0a)

q0 •Il n’est pas nécessaire de vider la pile
(a, a, aa) Il suffit d’atteindre un état final (avoir
un a au moins dans la pile
(b, a, ) Vérifier que le mot  = aab est accepté

(, a, a) par l’automate
(, q0, aab, Z0) |-- (a, q0, ab, Z0a)
|-- (aa, q0, b, Z0aa)
|-- (aab, q1, , Z0a)
q1 |-- (aab, q2, , Z0a)
(b, a, )
(, a, a)
q2

Exercices
Exercice 7 :
1) Construire un automate à pile qui accepte {anbm / n>m} avec le critère pile vide
2) Vérifier que le mot aab est accepté par l’automate
3) Calculer L(A ) et N(A)
1) (a, Z0, Z0a)

q0 •Il est nécessaire de vider la pile
(a, a, aa) Même si il ya des états finaux
2) Vérifier que le mot  = aab est accepté
par l’automate (aabL(A))
(b, a, )
(, a,  ) (, q0, aab, Z0) |-- (a, q0, ab, Z0a)
|-- (aa, q0, b, Z0aa)
|-- (aab, q1, , Z0a)
|-- (aab, q2, , Z0)
q1 |-- (aab, q2, , )
(b, a, )
(, a,  ) 3) L(A) = {anbm / n>m}
N(A) =  car F = 
q2 (, a,  )
(, Z0,  )
Exercices
Exercice 8 : Soit l’automate à pile suivant :
1) Quel est le langage accepté par l’automate suivant
2) Vérifier que le mot aaab est accepté avec le critère état final et le critère pile vide
(a, Z0, Z0a)
(a, a, aa) 1) On obtient : L(A) = N(A) = {anbm/n>m}
q0
2) Vérifier que le mot  = aaab  L(A)
(, q0, aaab, Z0) |-- (a, q0, aab, Z0a)
|-- (aa, q0, ab, Z0aa)
(b, a, ) |-- (aaa, q0, b, Z0aaa)
(, a,  )
|-- (aaab, q1, , Z0aa)
|-- (aaab, q2, , Z0a)
|-- (aaab, q2, , Z0)
q1 |-- (aab, q2, , )
Vérifier que le mot  = aaab  N(A)
(b, a, )
(, q0, aaab, Z0) |-- (a, q0, aab, Z0a)
(, a,  ) |-- (aa, q0, ab, Z0aa)
q2 |-- (aaa, q0, b, Z0aaa)
(, a,  ) |-- (aaab, q1, , Z0aa)
Leila Ben Ayed (, Z0,  ) Théorie des Langages et Compilation|-- (aaab, q2, , Z0a) 164
Exercices
Exercice 9 :
1) Construire un automate fini qui accepte {anbm / nm} avec le critère état final
3) Déduire le langage accepté avec le critère pile vide
(a, Z0, Z0a)
1) •Il n’est pas nécessaire de vider la pile
q0 (a, a, aa)
l’automate
(, a, a) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
(b, a, )
(, Z0, Z0) |-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
|-- (aabb, q1, , Z0)
|-- (aabb, q2, , Z0)
q1
(b, a, ) 3)
(, a, a) N(A) = {anbm / nm}
(, Z , Z ) Le langage accepté avec le critère pile vide
q2 0 0
L(A) =  car on n’arrive pas à vider la pile
Exercices
Exercice 10 :
1) Construire un automate fini qui accepte {anbm / nm} avec le critère pile vide
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire de vider la pile
q0 (, Z0,  )

(b, a, ) l’automate
(, a,  ) (, q0, aabb, Z0) |-- (a, q0, abb, Z0a)
|-- (aa, q0, bb, Z0aa)
|-- (aab, q1, b, Z0a)
q1 |-- (aabb, q1, , Z0)
(b, a, ) |-- (aabb, q2, , )
(, a,  )
q2 (, Z0,  )
(, a,  )
(, Z0,  )
Exercices
Exercice 11 :
1) Construire un automate à pile qui accepte {anbmct/ t = n+ m} avec le critère pile
vide
2) Vérifier que le mot abcc est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire de vider la pile
q0 (, Z0,  )
n=m=0
(b, Z0, Z0b) 2) Vérifier que le mot  = abcc est accepté par
(b, a, ab) l’automate
(c, a,  ) (, q0, abcc, Z0) |-- (a, q0, bcc, Z0a)
q1
(b, b, bb) |-- (ab, q1, cc, Z0ab)
|-- (abc, q2, c, Z0a)
(c, b, ) |-- (abcc, q2, , Z0)
n=0 |-- (abcc, q2, , )
q2
(c, b,  )
(c, a,  )
m=0 (, Z0,  )
Exercices
Exercice 11 :
1) Construire un automate à pile qui accepte {anbmct/ t = n+ m} avec le critère état
final
2) Vérifier que le mot abcc est accepté par l’automate
(a, Z0, Z0a)
1) (a, a, aa) •Il est nécessaire d’atteindre un état
q0 final
(b, Z0, Z0b)

(b, a, ab)
(c, a,  ) (, Z0,  )
q1
(b, b, bb) n=m=0
(c, b, )
n=0
q2
(c, b,  ) (, Z0,  )
(c, a,  )
m=0
Exercices
Exercice
1) Construire un automate fini qui accepte {anb2nck/ k >0} avec le critère pile vide
(a, Z0, Z0aa)

(a, a, aaa) •Il est nécessaire de vider la pile
q0
(b, a,  ) 2) Vérifier que le mot  = abbcc est accepté

par l’automate
(c, Z0, Z0 ) (, q0, abbcc, Z0) |-- (a, q0, bbcc, Z0aa)
q1
(b, a,  ) |-- (ab, q1, bcc, Z0a)
|-- (abb, q1, cc, Z0)
(c, Z0, Z0) |-- (abbc, q2, c, Z0)
|-- (abbcc, q2, , Z0)
q2 |-- (abbcc, q2, , )
(c, Z0, Z0)
(, Z0,  )
n=0
Exercices
Exercice
1) Construire un automate fini qui accepte {anb2nck/ k >0} avec le critère état final
(a, Z0, Z0aa)

(a, a, aaa) •Il est nécessaire de vider la pile
q0
(b, a,  ) 2) Vérifier que le mot  = abbcc est accepté

par l’automate
(c, Z0, Z0 ) (, q0, abbcc, Z0) |-- (a, q0, bbcc, Z0aa)
q1
(b, a,  ) |-- (ab, q1, bcc, Z0a)
|-- (abb, q1, cc, Z0)
(c, Z0, Z0) |-- (abbc, q2, c, Z0)
|-- (abbcc, q2, , Z0)
q2
(c, Z0, Z0)
n=0
Exercices
Exercice 12 :
Construire un automate à pile qui accepte les mots palindrômes sur le vocabulaire
{a,b,c} avec le critère pile vide
(a, Z0, Z0a) (b, Z0, Z0b) (c, Z0, Z0c)

(a, a, aa) (b, b, bb) (c, c, cc) L’automates accepte
q0 (a, b, ba) (b, a, ab) (c, a, ac) les mots palindromes
(a, c, ca) (b, c, cb) (c, b, bc) de longueur impaire
et les mots de
longueur paire
(a, a, ) (a, a, a) (b, b, b) (c, c, c) Avec le critère pile
(b, b, ) (a, b, b) (b, a, a) (c, a, a) vide.
(c, c, ) (a, c, c) (b, c, c) (c, b, b) -------
(a, Z0, ), (b, Z0, ), (c, Z0, ) Un mot palindrome
est identique à son
q1 (a, a, ) image miroire comme
(b, b, ) ‘abbcbcbba’
(c, c, ) Ou bien ‘abba’
(, Z0,  ) Cas des mots a, b ou c
VI. Les machines de Turing
Plan
VI.1. Description d’une machine de Turing

VI.2. Fonctionnement d’une machine de Turing
VI.3. Utilisation d’une machine de Turing
VI.4. Variantes de machines de Turing
VI.5. Relation avec les calculateurs et fonction T-
Calculable
VI.6. Machine de Turing et langages
VI.7. Combinaison de machines de Turing

Une machine de Turing (m.t) est composée d’un ruban infini décomposé en carrés,
d’une tête de lecture/ecriture sur ce ruban et une unité de contrôle par un nombre fini
d’états. Le calcul d'une machine de Turing est formé d'une suite d'étapes de calcul qui
sont effectuées par la machine. A chaque étape, la m.t, lisant un carré du ruban, peut
changer d’état, changer le contenu du carré lu et se déplacer sur le ruban à droite ou à
gauche d’une case ou bien rester sur place. Les étapes de calcul possibles sont décrites
par les transitions de la machine.
Z0 Ruban infini
Tête de lecture/écriture
q Unité de contrôle

Définition
Nous donnons la définition précise d'une machine de Turing. De manière formelle, une
machine de Turing M est un Quadruplet (Q, X, , q0, ) où
Q est l'ensemble des états de contrôle.

X ensemble fini des symboles lus et écrits sur la bande contenant # . Il contient
l’alphabet d’entrée et l’alphabet de sortie sur la bande.
δ la fonction de transition de la machine
δ : Q x X  Q x X x {1, 0, -}
est un ensemble fini de transitions de la forme (qi, sj, qij, sij, dij) où qi et qij sont des
états, sj et sij sont des symboles de bande et dij est un élément de {Droite, Gauche
et Arrêt}. Une transition (qi, sj, qij, sij, dij) est aussi notée : qi, sj → qij, sij, dij.
q0 est l'état initial. C'est un état particulier de Q dans lequel se trouve la machine au
début d'un calcul.
# est le symbole blanc qui, au départ, remplit toutes les positions de la bande autres
que celles contenant la donnée initiale.
qF est l’état final. qF  Q
VI.2. Fonctionnement d’une machine de
Turing
d fonction de transition de la machine :
d : Q x X  Q x X x {1, 0, -}
droite gauche arrêt
Dans un état qi, lisant un symbole sj, la machine va dans l’état qij, remplace le
symbole lu par sij et effectue un déplacement dij. Les instructions pour une
machine de Turing sont représentées par des quintuples: (qi, sj, qij, sij, dij)
sj  sij, dij
qi qj

Turing
Exemple1: Machine M1 d’effacement des symboles non blancs
M1 = ({q0}, {a,#}, δ, q0) avec δ :

δ(q0,a)=(q0,#, 1);
δ(q0,#)=(q0,#, -);
– Cette machine permet d’effacer la bande contenant une suite de ‘a’ et les
remplacer par des ‘#’
Exemple2: Machine M2 de déplacement de la tête à gauche jusqu’au blanc ‘#’
M2 = ({q0}, {a,#}, δ, q0) avec δ :

δ(q0,a)=(q0, a, 0); et δ(q0,#)=(q0,#, -)

Turing
(q1, a) = (q2, b, 0) Lire a Ecrire b
Se déplacer à gauche
a  b, 0
q1 q2
(q1, a) = (q2, b, 1) Lire a Ecrire b

Se déplacer à droite
a  b, 1
q1 q2

Turing
Configuration i ………. b b b a c a ………...
q1 Etat Courant
(q1, a) = (q2, b, 1)
q1
a  b, 1 q2
………. b b b b c a ………...
Configuration i+1
q2 Etat Courant
Turing
Configuration i ………. b b b a c a ………...
q1 Etat Courant
(q1, a) = (q2, b, 0)
q1
a  b, 0 q2
………. b b b b c a ………...
Configuration i+1
q2 Etat Courant
Turing
Si la machine s’arrête dans un
Un mot accepté état final et le mot est
entièrement lu
Si la machine s’arrête dans un état

Un mot rejeté non-final ou
la machine entre dans une boucle
infinie
La machine halt si il n’existe aucune

Transition possible à exécuter

Turing
Exemple : Une machine de Turing qui accepte a*
a  a, 1
q1
  , - q2

Turing
a  a, 1
Rejet   , -
q1 q2
Le mot aba est rejeté

Configuration 1    a b a   
q1
Configuration 2 finale    a b a   
Pas de transition possible
Arrêt + rejet du mot aba
q1
Turing
a  a, 1
Acceptation q1
  , - q2
Le mot aaa est accepté

Configuration 1    a a a   
q1
Configuration 4 finale    a a a   
Arrêt + acceptation du mot aaa
q1
Turing
Boucle infinie
b  b, 0
a  a, 1 q1
q1
  , - q2
b  b, 0 q1
a  a, 1
q1
  , - q2
q1
Turing
Boucle infinie
q1
b  b, 0    a b a   
Configuration 2
a  a, 1
  , - q1
q1 q2    a b a   
Configuration 3
q1
et ca reboucle q1
A cause de la boucle infinie, l’état final n’est jamais atteint, la
machine ne s’arrête jamais et le mot en entrée n’est pas accepté
Succession de Configurations
1 2
………. # x a y b # # ………... ………. # x a y b # # ………...
q2 q0
3 4
………. # x x y b # # ………... ………. # x x y b # # ………...
q1 q1
x, x, d a, x, d y, y, d
q 2 Ben Ayed
Leila q0 q1 Théorie des Langages
q1et Compilation ….. 186
1 2
………. # x a y b # # ………... ………. # x a y b # # ………...
q2 q0
3 4
………. # x x y b # # ………... ………. # x x y b # # ………...
q1 q1
q2 xayb |-- x q0 ayb |-- xx q1 yb |-- xxy q1 b
q2 xayb |-- x q0 ayb |-- xx q1 yb |-- xxy q1 b
*
Peut etre noté comme suit: q2 xayb |-- xxy q1 b
Configuration initiale : q0 w
Mot en entrée
w
# a a b b # #
q0
Pour une machine de Turing M
Le langage L(M) accepté par M est défini comme suit :
L(M) = {w / q0 w |-- w*1 qf w2}
Etat initial Etat final

VI.3. Utilisation d’une machine de Turing
Une machine de Turing est utilisée pour :

- accepter
- calculer
Une machine qui accepte : Pour un mot donné en entrée, la machine répond par oui si
ce mot est accepté et par non dans le cas contraire.
Une machine accepte un mot w s'il existe au moins un calcul acceptant avec w comme
entrée, c'est-à-dire qui commence avec la configuration q0w. Un seul calcul acceptant
suffit pour que la machine accepte même si d'autres calculs bloquent ou n'atteignent
jamais une configuration acceptante.
Une machine qui calcule : Pour un mot donné en entrée, la machine retourne un ou
plusieurs mots de sortie. Quand la machine ne donne qu’un seul mot de sortie, elle
calcule une fonction qui associe le mot de sortie au mot d'entrée.
On met donc le mot d'entrée sur la bande, la machine effectue un calcul jusqu'à ce
qu'elle atteigne un état final et le contenu de la bande constitue alors un des mots de
sortie. Si la machine est déterministe alors il existe un seul mot de sortie.

Exemple de compteur de parité
Une procédure de reconnaissance par une machine de Turing peut être
spécifiée par une liste finie d’instructions.
Un calcul particulier est effectué par la liste d’instructions, l’état initial q0, le
contenu du ruban au départ et la position initiale de la tête de lecture/écriture
sur le ruban.
Exemple : Un compteur de parité des 1

Le ruban contient une séquence de 1 et 0 qui se termine par un délimiteur
droit #. L’état final est atteint et la case sur la quelle pointe la tête de L/E est 0
ou 1 selon que le nombre de 1 est pair ou impair
Les instructions sont les suivantes :
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 0, 1) (q1, 1, q0, 0, 1)
(q0, , qF, 0, -) (q1,  , qF, 1, -)
Illustration d’un calcul:
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 1, 1) (q1, 1, q0, 1, 1)
(q0, B, q2, 0, -) (q1, B, q2, 1, -) 0 0, 1
1  1,1 0 0, 1
q0 q1
1 0 1 1 0  Le nombre de 1 est
impair
1 1, 1
 0, -   1, -
1 0 1 1 0 #1
qF
(q0, 1, q1, 1, 1) (q0, 1, q1, 1, 1)
(q1, 0, q1, 0, 1) (q1, 0, q1, 0, 1)
(q1, 1, q0, 1, 1) (q1, , qF, 1 , -)
Illustration d’un calcul:
(q0, 0, q0, 0, 1) (q1, #, qF, 1, -)
(q0, 1, q1, 1, 1) (q1, 0, q1, 0, 1)
(q0,
(q0, #,
, qF,
qF, 0,
0, -)
-) (q1, 1,
(q1, 1, q0,
q0, 1,
1, 1)
1) 0  0, 1
(1,1,
1 1, 1)1 (0,0,
0 0, 1)1
q0
q0 q1
q1
1 0 1  Le nombre de 1 est
pair
(1,1,
1 1, 1)1
  0, -   1, -
1 0 1 0#
q2
qF

Si, en plus du calcul de la parité, on demande de remplacer les 1 par 0, nous
obtenons les instructions suivantes:
(q0, 0, q0, 0, 1) (q1, 0, q1, 0, 1)
(q0, 1, q1, 0, 1) (q1, 1, q0, 0, 1) 0  0, 1
(q0, , qF, 0, -) (q1, , qF, 1, -)
1  0, 1 0  0, 1
q0 q1
1 0 1 1 0  Le nombre de 1 est
impair
1 0, 1
0 0 1
1 0 10 0 1B # 0, - #  1, -
qF
(q0, 1, q1, 0, 1) (q0, 1, q1, 0, 1)
(q1, 0, q1, 0, 1) (q1, 0, q1, 0, 1)
(q1, 1, q0, 0, 1) (q1, , qF, 1, -)
Exercice
Exercice : Vérification des parenthèses

On dispose au départ d’une chaine qui contient des parenthèses. La chaine est
délimitée à droite et à gauche par le symbole #. A l’arrêt de la machine, le symbole
sous la tête de lecture/écriture est 0 si les parenthèses sont bien équilibrées et 1 dans
le cas contraire.
Donner les instructions pour une machine de Turing qui permet de répondre par 0 ou 1
si les parenthèses sont équilibrées ou non.

Exemple de vérification de parenthèses
Corrigé:
On démarre sur la première parenthèse. Le calcul consiste à aller chercher vers la
droite la première parenthèse fermante, l’effacer et revenir vers la gauche pour
chercher la première parenthèse ouvrante à partir de là, l’effacer puis recommencer la
recherche (fermante, ouvrante).
Nous avons besoin donc de deux états: un qui sert à se déplacer à droite (q0) pour
chercher une fermante et un qui sert à se déplacer à gauche (q1) pour chercher une
ouvrante.
Enfin, il se peut que l’on ne rencontre plus de parenthèses fermantes, auquel cas il
faut revenir au point de départ de la chaine en vérifiant qu’il n’ y a plus d’ouvrante non
plus. Un état q2 effectue cette vérification en reculant.
Nous utilisons le symbole x pour remplacer les parenthèses rencontrées pour ne pas
les reprendre une deuxième fois.

Exercice
X = {(, ), x, #}
(q0, ), q1, x, 0) (q2, (, qF, 1, -)
(q0, (, q0, (, 1) (q1, (, q0, x, 1) (q2, #, qF, 0, -)
(q0, #, q2, #, 0) (q1, #, qF, 1, -) (q2, x, q2, x, 0)
(q0, x, q0, x, 1) (q1, x, q1, x, 0) qF est l’état final
)  x, 0
( (, 1 q0 q1 x x, 0
x x, 1 (x, 1
# 1, -
# #, 0
(1, -
q2 #  0, - qF
x x, 0

Exercice
Une machine de Turing qui accepte {anbn, n 0}
X = {a, b, x, #}
(q0, a, q1, x, 1) (q1, a, q1, a, 1) (q2, x, q2, x, 0) (qv, x, qv, x, 1)
(q0, #, qF, #,-) (q1, b, q2, x, 0) (q2, a, q1, x, 1) (qv, #, qF, #, -)
(q1, x, q1, x, 1) (q2, #, qv, #, 1)
x x, 1
a  x, 1
Le mot aabb est accepté q0 q1 a a, 1
# #, -
1 0 1 1 0 
b x, 0
qF a x, 1
# #, -
qv q2 x x, 0
##, 1
xx, 1
Exercice
Le mot aba n’est pas accepté
# a a b b  # x x x b 
x x, 1
a  x, 1
q0 q1 a a, 1
q0 q1
# #, -
# x a b b  # x x x b  b x, 0
qF
q0 b 1, - a x, 1
q1 q1 b 1, -
# #, -
# x a b b  # x x x x  qv q2 x x, 0
##, 1
q1 q2
xx, 1
# x a x b  # x x x x 
q2 q2

Exercice
Le mot aabb est accepté
# x x x x  # x x x x 
x x, 1
a  x, 1
q0 q1 a a, 1
q2 qv
# #, -
# x x x x  # x x x x  b x, 0
qF a x, 1
q2 qv
# #, -
# x x x x  # x x x x  qv q2 x x, 0
##, 1
qv qF
xx, 1
# x x x x 
qv

Exercice
Le mot aba n’est pas accepté
# a b a #  # x x a # 
x x, 1
a  x, 1
q0 q1 a a, 1
q0 qv
# #, -
# x b a #  # x x a #  b x, 0
qF a x, 1
q1 qv
# #, -
# x x a #  # x x a #  qv q2 x x, 0
##, 1
q2 qv
# x x a #  Arrêt de la machine car (qv, a)
n’est pas définie. Le mot n’est
q2 pas lu donc le mot aba n’est pas
accepté
Exercice
Le mot aabb est accepté
# x x x x  # x x x x 
x x, 1
a  x, 1
q0 q1 a a, 1
q2 qv
# #, -
# x x x x  # x x x x  b x, 0
qF a x, 1
q2 qv
# #, -
# x x x x  # x x x x  qv q2 x x, 0
##, 1
qv qF
xx, 1
# x x x x 
qv

Exercice
Une machine de Turing qui accepte {anbncn, n 0}
X = {a, b, x, #}
(q0, a, q1, x,1) (q1, a, q1, a, 1) (q2, c, q3, x, 0) (q3, b, q3, b, 0)
(q0, #, qF, #,-) (q1, b, q2, x, 1) (q2, x, q2, x, 1) (q3, a, q1, x, 1)
(q1, x, q1, x, 1) (q2, b, q2, b, 1) (q3, #, qv, #, 1)
(q3, x, q3, x, 0)
(qv, x, qv, x, 1)
x x, 1
(qv, #, qF, #, -) a  x, 1
q0 q1 a a, 1
# #, -
b x, 1
qF a x, 1
c x, 0 q2 x x, 1
# #, - b b, 1
qv q3
##, 1
c x, 0
xx, 1 a x, 1
x x, 0
VI.4. Variantes de MT
Machines de Turing avec :
• Option d’arrêt, Bande semi-infinie, Off-Line
• Multibande, Multidimension, Non déterministe
Les différentes variantes forment différentes classes de machines

de Turing
Pour chaque machine M1 de la première classe,
Il existe une machine M2 de la deuxième classe tel que
L(M1) = L(M2)

Machine de Turing à bande Semi-infinie
Machine standard
......... .........
Machine à bande semi infinie

.........
Machine de Turing Standart simule la machine de Turing à bande

semi-infinie
Machine de Turing à bande Semi-infinie
Machine standard
......... # a b c d e # # .........
Point de référence
Machine de Turing à bande semi-infinie
Partie droite ## d e # # # .........

Partie gauche ## c b a  # #

Machine de Turing déterministe
Une machine de Turing déterministe est une machine qui fait un seul calcul
à chaque exécution. Pour un état donné et un symbole donné, l'action effectuée par la
machine est unique.
Une machine de Turing non-déterministe est une machine de Turing où à
chaque étape de son calcul, elle peut effectuer un choix non-déterministe: elle a le
choix entre plusieurs actions, et elle en effectue une.
Si l'un des choix l'amène à accepter l'entrée alors on dit que la machine accepte
l'entrée.
Un mot  = a1a2…an  X* est accepté par une machine non déterministe
S’il existe au moins un calcul :
a1, b1, d1 a 2, b 2, d 2 a n, bn, dn

q0 q1 q2 ….. q n-1 qn
q0 a1a2…an|-- a1 q1 a2…an |--…….|-- a1a2…an-1 qn-1 an |-- a1…an qn

VI.5. Relation avec les calculateurs
et fonction T-calculable
Une machine de turing est un modèle pour un ordinateur avec un temps de

calcul très grand et un bon espace de calcul. Il est possible de simuler un
ordinateur sur une machine de turing.
Fonction T- calculable
Une fonction f(x) est dite Turing calculable (T-calculable) si ses valeurs peuvent
être calculées par une machine de turing dont le ruban contient une
représentation standard de l’argument x. Quand la machine (le calculateur)
s’arrête, la valeur de f(x) apparaît dans une représentation sur le ruban. Une
représentation standard possible est une représentation en Base 1 (symbole
utilisé est 1).

Exercice
Exercice : Montrer que la fonction ADD(m, n) est T-Calculable pour les entiers
m et n.
Corrigé: Le B est un séparateur
La réponse est la suivante:
B 1 1 B 1 1 B
m n
B 1 1 B
m+n

La fonction ADD(m, n) = m+n est calculable
Machine de Turing :
Chaîne en entrée : BmBnB
Chaîne en sortie : Bm+nB

(1, 1, 1)
(1, 1, 1)
(B, B, 1) (B, B, 1)
On avance jusqu’au 2ème

(B, B, 0)
délimiteur droit B, le
décaler d’une case vers
(1, 1, 0) la gauche et ensuite
(1, B, 0) remplacer le premier
délimiteur B rencontré
(B, B, 0) par 1.
(B, 1, 0)
(1, 1, 0)
(B, B, -)

Exercice: Montrer que la fonction Mul(m, n) = m x n est T-calculable et donner
l’algorithme de calcul associé
Corrigé:
On utilise une machine de turing à trois rubans
3 B B B
m*n Tant qu’il y a 1 dans le

ruban1, on copie le contenu
du ruban2 dans le ruban3
B 1 1 B
2
m
B 1 1 B
1
n
Nous utilisons P1, P2 et P3 pour désigner les têtes de L/E respectivement sur
les rubans 1, 2 et 3.
Tant que P1 pointe sur 1 faire

Tant que P2 pointe sur 1 faire
écrire à la position P3 un 1
avancer P2
avancer P3
Fin tant que
Reculer P2
tant que P2 pointe sur 1 Faire
Reculer P2
Fin Tant que
Avancer P2
Avancer P1
Fin Tant que
Une fonction f, définie sur D, est calculable si il existe une
machine de Turing T tel que à partir d’une configuration initiale
avec une entrée W, on peut atteindre une configuration où f (W),
en sortie, est calculée.
Configuration initiale Configuration finale

# W # # f #
(W)
q0 Etat initial qf Etat final
WD
1 si x>y Entrée : x0y

f(x, y) = 0 sinon Sortie : 1 ou 0
Pseudo code pour une MT

Repeter
égaler un 1 de x avec un 1 de y
Jusqu’à tous les x ou y sont égalées
Si un 1 de x n’est pas égalé
Alors effacer la bande, ecrire 1
Sinon effacer la bande, ecrire 0

La thèse de Church
Thèse de Church
Si il existe un algorithme qui calcule f(x)
Alors il existe une machine de Turing qui
exécute l’algorithme qui calcule f(x)

VI.6. Machine de Turing et Langages
L’ensemble L de tous les mots sur {a, b}:
L = {a,b}* = {, a, b, ab, aa, ba, bb, aaa, aab, …}

Infini et dénombrable
L’ensemble des parties de L :
P(L) = {{}, {a}, {a,b}, {aa, ab, aab}, …}

L1 L2 L3 L4 
Non dénombrable
Langages: non dénombrable
L1 L2 L3  Lk 
M1 M2 M3 ?
Machines de Turing : dénombrable
Il existe plus de langages que les machines

de Turing

Il exite plusieurs langages non acceptés

Par des Machines de Turing
Ce sont
(Les langages qui ne peuvent pas être
décrits par des algorithmes)
Les langages récursifs : Un langage est récursif s’il existe une

machine engendrant L dans l’ordre des mots de longueur
croissante.
Les langages récursivement énumérables : Un langage L est
récursivement énumérable s’il existe une MdT M engendrant L.

VI.7. Combinaison de Machines de Turing
On peut combiner des machines simples (de base – sous

programmes) pour obtenir une machine composée
Machines de base
Machine d’écriture de symbole
Ecriture d’un symbole correspondant
sans déplacer la tête et indépendant
du contenu de la bande
Machine de déplacement de la tête
Une machine pour déplacer la tête de
la bande à droite ou à gauche

Machines de base (Abréviation)
R# : qui trouve le premier blanc a droite
L # : qui trouve le premier blanc à gauche
R # : qui trouve le premier non blanc à droite
L # : qui trouve le premier non blanc à gauche
NB. Le symbole “#” représente un blanc et le symbole “”

représente un symbole quelconque du ruban
Machines de base (Construction graphique)
R # R  #
R#
L # L  #
L#
Exemple
Une machine qui scanne la bande jusqu’à ce qu’elle trouve un
non blanc. Elle revient a gauche et copie le symbole qu’elle
trouve dans la case juste avant. La
X={a,b,c,#}
a Lb
 # L b
R
R c Lc
#
L : action reculer suivie de #
remplacer symbole courant par   représente a,b ou c
Exemple: Copie d’un mot
#w# résultat #w#w#
Un algorithme possible:
Chercher le premier blanc a gauche
T: avancer à droite d’une case
Si la case contient   # alors
ecrire #
chercher le deuxieme # à D de la Tête
ecrire 
chercher le deuxieme # à G de la tête
ecrire  (le remettre)
aller à T
Sinon
avancer à droite jusqu’au premier #

Exemple : Copie d’un mot
#w# résultat #w#w#
La machine C correspondante est la suivante:
L# #
R #R2# L2# 
#
C
R#
Exemple : Copie d’un mot
#w# résultat #w#w#
Exemple d’exécution :
#abc# > #abc > #abc > ##bc > ##bc## >
##bc#a > ##bc#a > #abc#a >#a#c#a >
#a#c#a# > #a#c#ab….
#ab##ab …>
#abc#abc …>
#abc#abc#

Exemple : Copie d’un mot - C
#w# q0 résultat #w#w# h
Exemple d’exécution :
#abc# > #abc > #abc > ##bc > ##bc## >
##bc#a > ##bc#a > #abc#a >#a#c#a >
#a#c#a# > #a#c#ab….
#ab##ab …>
#abc#abc …>
#abc#abc#

Exemple : Décalage à gauche (Shift Left) - SL
#w# q0 résultat w# h
w ne contient pas de blanc
SL
L# #
R L R
L#
Application : F(w)=ww la machine est CSL(copie suivi de Shift Left)
Exemple : Décalage à droite (Shift Right) - SR
#w# q0 résultat w# h
w ne contient pas de blanc
SR
L# #
R L R
L#
Application : F(w)=ww la machine est CSL(copie suivi de Shift Left)
Exercice
L = {w  Xo : |w|a = |w|b = |w|c}
X={a,b,c,#}
L = {w  Xo : |w|a = |w|b = |w|c}

Donner la machine de Turing qui accepte L

VII. Décidabilité
Plan
VII.1. Problèmes décidables

VII.2. Définitions
VII.3. Décidabilité et Calculabilité
VII.4. Exemples

VII. Décidabilité
Décidabilité
Intuitivement, P est décidable s’il existe un algorithme qui
pour chaque x répond par “OUI” ou par “NON” à la
question :
“Est-ce que P(x) est vrai ?”.

VII.1. Problème Décidable
PROBLÈMES DE DÉCISION
Définition : c’est un problème pour lequel il existe, en un temps fini, deux
réponses possibles oui ou non
Problèmes décidables : Un problème P est décidable s’il existe une Machine

de Turing Reconnaisseur qui, pour une donnée quelconque de P, s’arrête
toujours soit dans un état reconnaisseur (arret + symbole correspondant à la
réponse) qui signifie si la réponse à P pour cette instance est oui, soit dans
un état de rejet (arret + symbole de rejet) si la réponse est non.

Problèmes semi-décidables : Un problème P est semi-décidable s’il existe

un Machine de Turing Reconnaisseur qui, pour une donnée quelconque de P,
lorsque la réponse est oui s’arrête dans un état accepteur, et lorsque la
réponse est non peut soit s’arrêter dans l’état de rejet comme elle peut ne
pas s’arrêter.
Les langages récursivement énumérables : Un langage L est récursivement

énumérable ssi il est semi-décidable.

• Un problème P est décidable si :

il existe A tel que A résout P
(A est un algorithme)
• Problème de décision est formulé comme suit :
Etant donnés :
- un ensemble U de toutes les données possibles (un univers)
- un ensemble B de toutes les données pour lesquelles P est résolu (B ⊆ U),
pour chaque élément x ∈ U, répondre
- par “OUI” si x ∈ B et
- par “NON” si x  B

Exemple de problème P
• Exemple . Est-ce qu’une formule F du premier ordre donnée telle
que par exemple
∀x(H(x) → ∃yH(y))
est valide ?
• Il n’existe pas d’algorithme qui donne la bonne réponse pour une
formule du premier ordre quelconque
• Skolémiser la négation de la formule, la mettre en forme clausale
et appliquer la résolution peut ne pas terminer.
– U = { toutes les formules de la logique des prédicats }
– B = { toutes les formules valides }.
• Le problème de la validité s’écrit comme :
– “F ∈ B ?”, ou comme “B(F) ?”

VII.2. Décidabilité - Définitions
Pour un problème P = (U,B) donné:
Le problème P est décidable

⇔
Il existe un algorithme pour P (une procédure qui s’arrete et
répond “OUI” si l’entée x ∈ B et répond “NON” si
l’entrée x  B)

VII.2. Décidabilité - Définitions
Le problème P est indécidable
⇔
Il n’existe pas d’algorithme pour P.
Le problème P est semi-décidable

⇔
Il existe un semi-algorithme pour P (une procédure telle
que :
- si l’entrée x ∈ B elle répond “OUI” ;
- si l’entrée x  B dit “NON” ou
- ne donne pas de réponse.
VII.3. Décidabilité et Calculabilité
Le problème de décision (U,B) est le suivant :

pour x ∈ U décider si x ∈ B
Afin de décider si une entrée x ∈ B, nous allons
utiliser la fonction caractéristique de l’ensemble B
CB(x) : U → {0,1}
CB(x) = 1 si x ∈ B,
0 sinon.
Le problème (U,B) est décidable si et seulement si

CB est calculable.
Exemples de Problèmes Décidables ou
indécidables
• P : un mot est reconnu par un automate fini non
déterministe ?
On peut construire un algorithme pour décider si en
partant de l’état initial, il existe une séquence de
configurations qui permet d’atteindre un état final où le
mot est entièrement lu; si il n’existe aucune séquence de
configurations qui nous amène à la reconnaissance alors
le mot n’est pas accepté. le problème P est décidable

indécidables
• P : un entier naturel est pair?
On peut construire un algorithme pour décider si un entier
naturel est pair ou non on fait la division par deux, si le
reste est zéro, le nombre est pair, si le reste est un, il ne
l'est pas), donc l'ensemble des entiers naturels pairs est
décidable
• P : un mot est reconnu par un automate fini déterministe ?
partant de l’état initial, on peut atteindre un état final où le
mot est entièrement lu, le problème P est décidable

indécidables
• P : un mot est reconnu par un automate fini non
déterministe ?
partant de l’état initial, on peut atteindre un état final où
le mot est entièrement lu.
Si il existe une séquence de transitions (chemin) qui nous
mène à l’état final après la lecture du mot alors le mot est
accepté sinon, si aucun chemin ne mène à l’acceptation,
alors le mot est rejeté.
La suite est dans le cours de Complexité en II2.

Additif C associé à TLC
Techniques de compilation
Leila Jemni Ben Ayed
Ecole Nationale des Sciences de l’Informatique

L’objectif de ce cours est d’étendre les connaissances en théorie des
langages et des automates à la description des langages de
programmation et leur analyse syntaxique en vue de leur compilation. Ce
cours décrit les concepts fondamentaux des langages de programmation
en commençant, dans une première partie, par donner la syntaxe et la
sémantique, en insistant davantage sur la syntaxe. La traduction en code
intermédiaire et l’environnement d’exécution font l’objet de la deuxième
partie.
Additif C associé à TLC
Techniques de compilation
I. Introduction à la compilation
II. Compilateur en une seule passe
III. Analyse syntaxique
IV. Analyse sémantique
V. Traduction en code pour
machine abstraite à pile
I. Introduction à la Compilation
Plan
I.1. Compilateurs
I.2. Les Grammaires non contextuelles
I.3. Phases de Compilation
I.4. Qualité d’un Compilateur
I.5. Outils pour la construction de Compilateurs

I.1. Compilateurs
– Évolution des langages:
• Langage machine
• Langage assembleur
• Langages évolués : C, PASCAL, ADA (Algorithmiques)
PROLOG (Logiques)
• Langages de 4ème génération
– Un compilateur est un programme qui lit un
programme écrit dans un premier langage(langage
source) et le traduit en un programme équivalent
écrit dans un autre langage (le langage cible).
I.1. Compilateurs
– Au cours de ce processus de traduction, un rôle du
compilateur est de signaler à son utilisateur la
présence d’erreurs dans le programme source.
PSource Compilateur PAssembleur
Messages
d’erreur

I.2. Exemples de grammaires non
contextuelles
1) Une grammaire qui génère l’ensemble des expressions arithmétiques utilisant les opérateurs + et * et les chiffres
{0,1,...9}
R = { Exp  Exp + Exp G = ({Exp}, {+, *, (, ), 0, 1, …9}, Exp, R}

Exp  Exp * Exp
Exp  (Exp)
Exp  0
Exp  1
Exp  2
Exp  3
Exp  4
Exp  5
Exp  6
Exp  7
Exp  8
Exp  9 }

contextuelles
2) Une grammaire qui génère l’ensemble des expressions booléennes utilisant les opérateurs
arithmétiques (oparith), les opérateurs relationnels (oprel) et les opérateurs booléens (non, et et ou)
sur les identificateurs (id) et les nombres entiers (nb)
R = { Expb  Expr
Expb  non(Expb) G = (V, T, Expb, R)
Expb  Expb et Expb V = {Expb, Expr, Expa}
Expb  Expb ou Expb T = {id, nb, oprel, oparith, non, et, ou, (, )}
Expr  Expa oprel Expa où oprel  {<, >, <=, >=, <>, =}
Expr  (Expr)oparith  {+, *, /, -}
Expa  Expa oparith Expa
Expa  (Expa)
Expa  id
Expa  nb
}

contextuelles
3) Une grammaire qui génère une séquence non vide de déclarations suivie de Début, suivie d’une séquence non
vide d’instructions suivie de Fin . Chaque instruction peut être une instruction d’affectation (se termine par ;) ou
une instruction conditionnelle avec ou sans sinon (qui se termine par FinSi). Les types utilisés sont entier et réel.
La séquence générée commence par program suivi d’un nom.
R = { P  Program id S_DCL Début S_INST Fin G = (V, T, P, R)

S_DCL  DCL | DCL S_DCL V = {P, S_DCL, DCL, S_INST, INST, Expb, Expr, Expa}
DCL  Var L_id : TYPE; T = {Program, Début, Fin, Var, :, id, :=, ;, Si, Sinon, Fin Si, (, ),
L_id  id | id, L_id oparith, oprel, non, et, ou, entier, réel, nb}
TYPE  entier | réel
S_INST  INST | INST S_INST
INST  id := Expa;
INST  Si Expb alors S_INST Fin Si
INST  Si Expb alors S_INST Sinon S_INST Fin Si
Expb  Expr | non(Expb) | Expb et Expb | Expb ou Expb
Expr  Expa oprel Expa
Expr  (Expr)
Expa  Exp oparith Exp
Expa  (Expa)
Expa  id
Expa  nb
}

contextuelles
Vérifier que la grammaire précédente génère le
programme suivant :
Program test
Var a, b : entier;
Début
a:= 10;
Si a>= 10 alors a:= 20; Fin Si
Fin

contextuelles
Le programme est transformé en une séquence de
terminaux.
Program id
Var id, id : entier;
Début
id:= nb;
Si id oprel nb alors id:= nb; Fin Si
Fin

contextuelles
P
Program id S_DCL Début S_INST Fin
Var L_id : TYPE ; INST S_INST
id , L_id entier id := Expa ; INST

En parcourant les feuilles
id nb Si Expb alors S_INST Fin Si
de l’arbre de gauche à
droite, on trouve le Expr INST
programme à analyser
Donc ce programme est Expa oprel Expa id := Expa ;
syntaxiquement correct
Leila Ben Ayed Théorie des Langages et Compilation id nb nb 253
I.3. Phases de Compilation
On distingue deux parties:
– Analyse
• Partitionne le programme source en ses constituants et en
crée une représentation intermédiaire.
– Synthèse
• Construit le programme cible à partir de la représentation
intermédiaire.
• L’analyse utilise les constituants d’une
grammaire non contextuelle qui génère des
programmes du langage utilisé.
I.3. Phases de compilation
PSource
Analyse lexicale
Gestion de la Analyse Syntaxique

table de
symboles Analyse sémantique
Gestion des
erreurs
Génération de code
intermédiaire
Table des Optimisation de code

identificateurs,
mots réservés Génération de code
et constantes machine
PCible
Psource Analyse
Les compilateurs
comportent ces deux
parties.
Génération de
Partie frontale code
Si on change de intermédiaire
machine, on peut ne
modifier que la partie
terminale
PLI
Partie terminale Générateur de code
machine
PASS

Type d’un id
Interface avec l’analyseur lexical Valeur d’un nb
Opérateur PPQ pour oprel
Passer unité
Lire caractère
lexicale et ses
Entrée Analyseur attributs Analyseur
lexical syntaxique
Rendre
caractère
• Pour l’AS, l’AL retourne l’UL

• Pour l’Asem, il retourne le type, la portée, …
• Pour le traducteur, il retourne la valeur du nombre, l’opérateur utilisé, …
• Si C est une variable caractère et le prog source est dans l’entrée standard alors
l’instruction C = getchar(); affecte le prochain caractère d’entrée à C et l’instruction
ungetc(C, stdin); rend à l’entrée standard stdin la valeur de C.
Implantation des interactions avec l’analyseur lexical
Retourne une
Utilise getchar();
unité lexicale
pour lire un
caractère AnalLex() à l’appelant
analyseur
Rendre caractère lexical Positionne la
En utilisant ungetc(C, stdin) variable globale à la
ValLex valeur de l’unité
lexicale

Analyse du programme source :
A chaque langage de programmation est associée une
grammaire non contextuelle.
L’analyse comprend quatre phases :
– Phase1: analyse linéaire (ou lexicale) au cours de laquelle
le flot de caractères formant le programme source est lu
de gauche à droite et groupé en unités lexicales qui sont
une suite de caractères ayant une signification collective.
Ces unités lexicales sont les terminaux de la grammaire.

– L’Al retourne une UL pour l’AS
– Pour l’Asem, si l’UL est id alors il retourne une entrée dans
la table des identificateurs pour l’identificateur trouvé.
– Pour le traducteur, si l’UL est nb, alors il retourne sa valeur
• si l’UL est oprel alors il retourne l’opérateur en question
• Si l’UL est oparith alors il retourne l’opérateur en
question
– Quand l’analyseur lexical rencontre un identificateur non
mot clé, il le cherche dans la table des id. S’il existe alors il
retourné l’entrée associée sinon il lui crêt une entrée et
retourne le numéro d’entrée.

par exemple si on dispose de la grammaire avec les règles
suivantes:
P  id opaff Exp
Exp  id | nb | (Exp) | Exp oparith Exp
Les unités lexicales associées au mot :
position := initiale + vitesse * 60
Sont:
1) l’identificateur position 2) Le symbole d’affectation opaff
3) L’identificateur initiale 4) Le signe d’addition oparith
5) L’identificateur vitesse
6) Le signe de multiplication oparith 7) Le nombre nb

Le lexème est la suite de caractères du fichier source qui forme l’unité
lexicale. Le tableau suivant présente les lexèmes et les unités lexicales
associées au mot position := initiale + vitesse * 60
lexème Unité lexicale
Résultat position Id
de l’AL
:= Opaff
initiale Id
+ Oparith
vitesse Id
* Oparith
60 nb
id opaff id oparith id oparith nb Pour l’AS

1 := 2 + 3 * 60
suivantes:
DCL  Var L_ID : TYPE;
| Var L_ID : TYPE; DCL
|
L_ID  id | id, L_ID
Les unité lexicales associées au mot (retournées par l’AL à l’AS):
Var a, b: entier; var c: réel;
Sont les suivantes :
Var id , id : entier ; Var id : réel ;

suivantes: Table des id de variables
DCL  Var L_ID : TYPE; N° Lexème Type
| Var L_ID : TYPE; DCL 1 a entier
| 2 b entier
L_ID  id | id, L_ID 3 c réel
Si l’AL retourne un résultat à l’AS et l’Asem alors le résultat de
l’AL pour le mot Var a, b: entier; var c: réel; sera :
Var Id , Id : entier ; Var Id : réel ;
0 1 0 2 0 0 0 0 3 0 0 0

Soit le mot a := c + 34; l’AL retourne Résultat de l’AL
Pour l’AS : id := id oparith nb; Id := Id oparith nb ;
Pour l’Asem : 1 := 3 oparith nb; 1 0 3 + 34 0
c-a-d entier := réel oparith entier

Pour le traducteur : @a := @c + 34;
Table des id de variables
N° Lexème Type Adresse
1 a entier @a
2 b entier @b
3 c réel @c

suivantes: Table des id de variables
P  DCL L_I N° Lexème Type
DCL  Var L_ID : TYPE; 1 a entier
| Var L_ID : TYPE; DCL 2 b entier
| 3 c réel
L_ID  id | id, L_ID
L_I  id := nb; | id := id; | id := nb; L_I | id := id; L_I
Si l’AL retourne un résultat à l’AS, l’Asem et le traducteur alors le résultat de
l’AL pour le mot Var a, b: entier; var c: réel; b := 10; sera :
Var Id , Id : entier ; Var Id : réel ; id := nb ;

0 1 0 2 0 0 0 0 3 0 0 0 2 0 10 0
Var a, b: entier; var c: réel; b := 10;
N° Lexème Type
1 a entier
2 b entier
3 c réel
Var Id , Id : entier ; Var Id : réel ; id := nb ;

0 1 0 2 0 0 0 0 3 0 0 0 2 0 10 0

– Phase2: analyse hiérarchique (ou syntaxique) au cours de
laquelle les unités lexicales sont regroupées
hiérarchiquement en structure grammaticale.
L’analyse syntaxique consiste à vérifier que la suite d’unités
lexicales est générée par la grammaire du langage.
Ceci revient à construire un arbre d’analyse (ou syntaxique)
dont les feuilles concordent avec la suite d’unités lexicales
en les parcourant de gauche à droite.

– Phase3: analyse sémantique au cours de laquelle on opère
certain contrôle pour s’assurer que l’assemblage des
constituants du programme a un sens. Une des opérations
principales d’un Asem est le contrôle de type des
opérandes d’une opération, le contrôle de la portée des
identificateurs au moment de l’appel d’un sous
programme, ….
– Dans le contrôle de type, l’analyseur sémantique peut
insérer des opérations de conversion pour les expr d’entier
vers réel.

– Phase3: analyse sémantique
Nous distinguons deux types d’erreurs sémantiques:
• sémantique statique, contrôlée au moment de la compilation telle
que :
– Variable non déclarée
– l’incompatibilité de type,
– la portée d’une variable…
• Sémantique dynamique, contrôlée au moment de l’exécution telle
que :
– la division par zéro
– les boucles infinies
– le débordement mémoire

– Phase4: traduction en code intermédiaire au cours de
laquelle la séquence d’instructions du programme est
traduite en une séquence d’instructions dans un langage
intermédiaire. Par exemple : le langage pour machine à
pile, le langage C, …

– La table des symboles contient des informations sur les
différents symboles et les attributs associés. Par exemple
les mots clés (ou réservés) et les identificateurs de
variables en spécifiant l’unité lexicale id et leurs attributs:
type, adresse, etc…
– A chaque fois qu’une unité lexicale id est trouvée par l’AL,
le lexème associé est inséré dans la table des symboles s’il
n’a pas été déjà inséré et l’AL retourne id et un pointeur
vers une entrée de la table des symboles.

Exemple
On veut illustrer les phases de compilation sur l’exemple suivant :
Position := Initiale + Vitesse * 60;
La grammaire est la suivante :
P  id := Exp;
Exp  id | nb | (Exp) | Exp + Exp | Exp * Exp
Une Contrainte sémantique doit être vérifiée :
L’opérateur de multiplication doit être appliqué à deux
opérandes de même type (entier, entier) ou (réel, réel)
Pour notre exemple, Vitesse est un réel et 60 est un nombre
entier, il faut alors convertir 60 d’entier vers réel (60.0)

• Analyse lexicale
id1 := id2 + id3 * nb;
• Analyse syntaxique
P
id := Exp ;
Exp + Exp
id Exp * Exp
id nb
• Analyse sémantique
Comme vitesse est un réel, un compilateur peut convertir le nombre
entier nb en réel pour pouvoir utiliser l’opérateur de multiplication
Var position, Initiale,
P : réel;
Vitesse
Analyseur
id := Exp
Sémantique

Exp + Exp
N° Lexème Type
1 Position Réel
2 Initiale Réel id Exp * Exp
entier vers réel
3 Vitesse Réel
60 60.0
id
• Génération de code intermédiaire
Temp1 := Entier vers réel(60);
Temp2 := Temp1*id3;
Temp3 := id2 + Temp2;
id1 := Temp3;
• Optimisation de code Analyse syntaxique
Temp1 := id3*60.0;
id1 := id2 + Temp1;
• Génération de code intermédiaire (Machine VON NEUMAN)
Machin à registres
MOVF id3, R2
MULF #60.0, R2
MOVF id2, R1
ADDF R2, R1
MOVF R1, id1
I.4. Qualité d’un compilateur
–Fournir le maximum d’erreurs en

une seule compilation
–Rapidité

I.5. Outils pour la construction de
compilateurs
– Assembleur
– Ecriture en langage évolué
– Constructeurs automatiques de compilateurs : LEX et YACC
Générateur automatique
d’analyseur syntaxique
Grammaire non
Analyseur Syntaxique
contextuelle du Yacc Écrit en C ou en LPascal
langage
Générateur automatique
d’analyseur lexical
Description
des unités Lex Analyseur lexical
lexicales du Écrit en C ou en LPascal
langage

II. Analyse lexicale
Plan
II.1. Présentation générale

II.2. Automates finis et expressions régulières
II.3. Spécification des unités lexicales
II.4. Reconnaissance des unités lexicales
II.5. Conception d’un générateur d’un analyseur
lexical
• L’analyseur lexical constitue la première phase d’un compilateur. Sa tâche
principale est de lire les caractères d’entrée et de produire comme
résultat une suite d’unités lexicales que l’analyseur syntaxique va utiliser.
Passer unité
lexicale et ses
attributs
Lire caractère
Programme Analyseur Analyseur
Source
lexical Obtenir syntaxique
Rendre prochaine
caractère unité lexicale
Table des
symboles
• Rq. L’AL est un sous programme de l’AS. A la réception de
« prochaine unité », l’AL lit les caractères d’entrée jusqu’à ce qu’il puisse identifier la
prochaine unité lexicale.
Unité lexicale : produite la même pour un ensemble de chaines de caractères
Modèle d’une unité lexicale : règle qui décrit une unité lexicale (Expression régulière)
Lexème : une suite de caractères du PS qui concorde avec le modèle d’une unité lexicale.
Unité Lexicale Lexèmes Description formelle des
modèles
const const const
if if If
oprel < <= = <> > >= (<+<=+=+<>+>+>=)
id Pi compte D2 lettre(lettre+chiffre)*
nb 3 6.780 6.0 Chiffre+ + chiffre+.chiffre+

II.2. Automates finis et expressions
régulières
• Un analyseur lexical est basé sur les systèmes de transition (ou bien les
automates finis)
Un diagramme de transition pour la reconnaissance de >=
Début > =
0 1 2 return(oprel, PGE)
autre
3 *
return(oprel, PGQ)

régulières

Début > =
autre
3 *
return(oprel, PGQ)
Ce diagramme fonctionne comme suit:
Son état de départ est l’état 0. Dans l’état 0, on lit le prochain caractère de l’entrée. On suit l’arc
> depuis l’état 0 vers l’état 1 si le caractère d’entrée est >. Sinon, on n’a réussi à reconnaître ni >
ni >=. En atteignant l’état 1, on lit le prochain caractère d’entrée. L’arc étiqueté = entre l’état 1
et l’état 2 doit être suivi si le caractère d’entrée est = et le diagramme reconnaît >= (PGE).
Autrement, l’arc étiqueté autre conduit à l’état 3. Le diagramme reconnaît ainsi > (PGQ) et
recule d’un caractère dans l’entrée. On utilise une * pour signaler les états dans lesquels ce
recul dans l’entrée doit être fait.
régulières
Un diagramme de transition pour la reconnaissance
des opérateurs de relation
Début < = return(oprel, PPE)
0 1 2
>
autre 3 return(oprel, DIF)
= *
4 return(oprel, PPQ)
5 return(oprel, EGA)
>
return(oprel, PGE)
= 7
6
autre *
Leila Ben Ayed Théorie des Langages et Compilation 8 return(oprel, PGQ)
284
régulières
Un diagramme de transition pour la reconnaissance des
identificateurs et des mots clés
lettre, chiffre
*
Début lettre autre
0 1 2
return(UnilexId(), RangerId())
L’action spécifiée par le symbole * permet de reculer d’une position sur le fichier
source après la consommation d’un symbole autre qu’une lettre ou un chiffre.

régulières
Les fonctions RangerId() et UnilexId()
- La fonction RangerId() a accès au tampon où l’unité lexicale identificateur a été localisée. On
examine la table des symboles et si on trouve le lexème avec l’identificateur mot clé, RangerId()
rend 0. Si on trouve le lexème comme variable du programme, RangerId() rend un pointeur vers
une entrée dans la table des symboles. Si on ne trouve pas le lexème dans la table des symboles,
il y est placé en tant que variable et un pointeur vers cette nouvelle entrée est retourné.
- La fonction UnilexId() recherche le lexème dans la table des symboles. Si le lexème est un mot
clé, l’unité lexicale correspondante est retournée; autrement, l’unité lexicale id est retournée.
NB.
1) Le diagramme de transition ne change pas si on doit reconnaître de nouveaux mots clés; on
initiale simplement la table des symboles avec les nouvelles chaines et les nouvelles unités
lexicales.
2) En pratique, la table des symboles peut être répartie sur deux tables: table des mots clés et
table des identificateurs de variables.

Expressions régulières
Les expressions régulières sont une notation importante pour spécifier des
modèles d’unités lexicales.
Exemples:
Soit L l’ensemble {A, B, …, Z, a, b, …z} et C l’ensemble {0, 1, …9}
1. L+C ou(L  C) est l’ensemble des lettres et des chiffres
2. LC est l’ensemble des chaines formées d’une lettre suivie d’un chiffre
3. L4 est l’ensemble des chaines de quatre lettres
4. L* est l’ensemble de toutes les lettres, y compris , la chaine vide.
5. L(L+C)* est l’ensemble de toutes les chaines de lettres et de chiffres
commençant par une lettre.
6. C+ est l’ensemble de toutes les chaines d’au moins un chiffre
(représentations décimales des entiers naturels)
Définitions régulières
Soit  un alphabet de symboles de base, une définition régulière est une suite de
définitions de la forme :
d1  r1
d2  r2
…
d n  rn
Où chaque di est un nom distinct et chaque ri est une expression régulière sur les
symboles de  {d1, d2, …, di-1}
Exemples:
Lettre  A|B|…|Z|a|b|…|z
chiffre  0|1|…|9
id  Lettre(Lettre + Chiffre)*

Nous utilisons les diagrammes de transition pour reconnaître des unités lexicales
Exemple:
Considérons le fragment de la grammaire suivant:
Instr  si expr alors instr
| si expr alors instr sinon instr
| id opaff id pv
| id opaff nb pv
expr  terme oprel terme
| terme
terme  id
| nb
Où si, alors, sinon, oprel, id et nb engendrent les ensembles de chaines données par les définitions
régulières suivantes:
si  si nb  chiffre+
alors  alors opaff  :=
sinon  sinon pv  ;
oprel  < | <= | = | <> | > | >=
id  lettre(lettre|chiffre)*

Le mot en entrée dans le fichier source est le suivant :

N° lexème type
si a1 >= b alors a1 Mots clés
1 a1 …
si
:= 10; 2 b …
alors
3 … …
L’analyseur lexical retourne la séquence suivante d’unités

lexicales avec leurs attributs:
si id oprel id alors id opaff nb pv
0 1 PGE 2 0 1 := 10 ;

Rq. On suppose que les lexèmes sont séparés par un espace

consistant d’une suite non vide de blancs, tabulations et fins
de lignes. Notre analyseur lexical doit éliminer ces espaces
en comparant une chaine avec la définition régulière
suivante :
Délim  blanc | tabulation | fin de ligne
bl  délim+
Si l’analyseur lexical trouve une correspondance avec bl, il ne
retourne pas l’unité lexicale à l’analyseur syntaxique. Il
continue pour rechercher l’unité lexicale qui suit le blanc et
le retourne à l’analyseur syntaxique.

Système de transition associé à un analyseur lexical
l, c
autre *
bl, tab, \n 1 2
l return(UnilexId(), RangerId())
c
Début
c autre 4 *
0 3 return(nb, val)
6
< return(oprel, PPE)
=
Echec()
5 > 7
return(oprel, DIF)
= autre
autre EOF *return(oprel, PPQ)
8
9
> return(oprel, EGA)
return(oprel, PGE)
14 = 11
13
10
return(EOF, 0) autre *
12 return(oprel, PGQ)
Système de transition associé à un analyseur lexical
l, c
Init(Val)
autre *
bl, tab, \n 1 2
l return(UnilexId(), RangerId())
cAdd(Val, c)
Début Add(Val, c)
c autre 4 *
0 3 return(nb, conv(val))
6
< return(oprel, PPE)
=
Erreur()
5 > 7
return(oprel, DIF)
= autre
autre EOF *return(oprel, PPQ)
8
9
> return(oprel, EGA)
return(oprel, PGE)
14 = 11
13
10
return(EOF, 0) autre *
12 return(oprel, PGQ)
Code C d’un analyseur lexical
Unilex AnalLex() /* Unilex est une chaine si Alalex retourne uniquement l’unité lexicale*/
{ /* Unilex est un entier si Analex retourne l’unité lexicale et chaque unité est définie comme une
constante*/ case 1: car = carsuiv();
While(1) if(isletter(car) || isdigit(car))
/* Unilex est un enregistrement si Analex ajouter(car, chaine);;
else etat = 2;
retourne l’unité lexicale et un attribut*/
break;
{ case 2: Reculer(1); RangerId(); return(UniLexId()); /*
Switch(etat) cas où l’analyseur lexical retourne uniquement
{ */l’unité lexicale sinon, il faut utiliser un
case 0: Init(Chaine); car = carsuivant(); enregistrement (symbole)*/
if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’) ………….
{ etat = 0; debutlex ++; }
else if( car == ‘<‘) etat = 5; case 3: car = carsuiv();
else if (car == ‘=‘) etat = 9; if(isdigit(car)) ajouter(car, chaine);
else if (car == ‘>’) etat = 10;
else if (isletter(car)) Ajouter(car, chaine); else etat = 4;
etat = 1; break;
case 4 : Reculer(1); Return(NB); case 6: Return(Oprel);
else if(isdigit(car)) Ajouter(car, chaine);
……………
etat = 3; case 13: Return(EOF);
Leila Ben Ayed
else if(car == EOF) etat = 13;Théorie des Langages }et Compilation 294
else Erreur();
Code C d’un analyseur lexical (cas du retour d’un enregistrement dans une
variable globale symbole à deux champs (UL, Att))
Unilex AnalLex() /* Unilex est une chaine si Alalex retourne uniquement l’unité lexicale*/
{ /* Unilex est un entier si Analex retourne l’unité lexicale et chaque unité est définie comme une
constante*/ case 1: car = carsuiv();
While(1) if(isletter(car) || isdigit(car))
/* Unilex est un enregistrement si Analex ajouter(car, chaine);;
retourne l’unité lexicale et un attribut*/ else etat = 2;
{ break;
case 2: Reculer(1); symbole.att = RangerId();
Switch(etat)
symbole.UL = UniLexId(); Return(Symbole);
{ ………….
case 0: Init(Chaine)car = carsuivant();
if(car == ‘ ‘ || car == ‘\t’ || car = ‘\n’) case 3: car = carsuiv();
{ etat = 0; debutlex ++; } if(isdigit(car)) ajouter(car, chaine);
else if( car == ‘<‘) etat = 5;
else etat = 4;
else if (car == ‘=‘) etat = 9;
break;
else if (car == ‘>’) etat = 10; case 4 : Reculer(1); symbole.UL=NB; symbole.Att =
else if (isletter(car)) etat = 1; toupper(chaine)); Return(symbole);
else if(isdigit(car)) etat = 3; case 6: symbole.UL = Oprel; symbole.att = PPE;
else if(car == EOF) etat = 13; Return(symbole); ……………
else Erreur(); case 13: symbole.UL = EOF; symbole.att = 0;
Return(symbole);}
Leila Ben Ayed Théorie des Langages On
et Compilation
peut retourner des numériques. 295
Code C d’un analyseur lexical qui élimine les espaces et collecte les nombres
#include <stdio.h>
#include <ctype.h>
Int NumLigne = 1;
Int Vallex = RIEN;
Int AnalLex() While (isdigit(T))

{ {
int T;
While(1);
ValLex = ValLex*10+T-’0’;
{ T = getchar();
T = getchar(); }
if (T == ‘ ‘ || T == ‘\t’) ;
ungetc(T, stdin); return NB;
else
if (T == ‘\n’) }
NumLigne ++; Else
else ValLex = RIEN;
if(isdigit(T))
{
Return T;
Vallex = T-’0’;; }
T = getchar(); }

II. Compilateur en une seule passe
Plan

II.2. Définition de la syntaxe
II.3. Traduction dirigée par la syntaxe
II.4. Un traducteur pour les expressions
II.5. Analyse lexicale

Un compilateur en une seule passe est un compilateur qui fait le parcours
du fichier source une seule fois.
L’analyseur lexical fournit un résultat aussi bien à l’analyseur syntaxique,
sémantique qu’au traducteur en code intermédiaire.
Il fournit ainsi:
- Les unités lexicales à l’analyseur syntaxique
- Les types des identificateurs à l’analyseur sémantique et
- Les attributs des unités au traducteur en langage intermédiaire
- Si l’unité est un nombre alors l’attribut est la valeur de ce nombre
- Si l’unité est un opérateur arithmétique alors l’attribut est l’opérateur en
question (+, -, /, *)
- Si l’unité est oprel alors l’attribut est l’opérateur en question
(PPQ, PPE, PGQ, PGE, EGA, DIF)

• Consiste en une grammaire non contextuelle

– C’est une grammaire (V, T, S, R) où
• V est l’ensemble des symboles non terminaux
• T est l’ensemble des terminaux
• S est le symbole de départ où l’axiome de la grammaire
• R est l’ensemble des règles de production de la forme A  u où u  (V + T)*
• Un programme est syntaxiquement correct s’il peut être généré par la

grammaire associée au langage de programmation
• Si le langage est l’ensemble des instructions d’affectation, alors un élément

de l’ensemble est une instruction d’affectation
Une grammaire possible est la suivante:

Soit la grammaire non contextuelle G = (V, T, INST, R) où

V = {INST, EXP}
T = {id, :=, +, -, *, /, (, ), ;}
R = { INST  id := EXP;
EXP  id | nb | EXP + EXP | EXP * EXP | EXP – EXP | EXP / EXP
| (EXP) }
INST est l’axiome de la grammaire. Un mot est généré par la grammaire si en partant
de l’axiome (le symbole de départ) et en appliquant successivement des règles de
production, nous obtenons le mot (formé par une séquence de terminaux)
Par exemple le mot suivant est généré par la grammaire:

Id := id + (id*nb);

Parce que on a:
INST  id := EXP;
 id := EXP + EXP ;
 id := id + EXP ;
 id := id + (EXP) ;
 id := id + (EXP * EXP) ;
 id := id + (id * EXP) ;
 id := id + (id * nb) ;

Si le langage est formé par l’ensemble des séquences non vides d’instructions où
chaque instruction est une instruction d’affectation
alors une grammaire possible est la suivante :
LISTE_INST  INST | INST LISTE_INST

INST  id := EXP;
EXP  id | nb | EXP + EXP | EXP * EXP | EXP – EXP | EXP / EXP | (EXP)
LISTE_INST est l’axiome de la grammaire. Un mot est généré par la grammaire si en

partant de l’axiome (le symbole de départ) et en appliquant successivement des
règles de production, nous obtenons le mot (formé par une séquence de terminaux)
Par exemple le mot suivant est généré par la grammaire:

Id := id + (id*nb); id := nb;

Parce que on a:
LISTE_INST  INST LISTE_INST
 id := EXP; LISTE_INST
 id := EXP + EXP ; LISTE_INST
 id := id + EXP ; LISTE_INST
 id := id + (EXP) ; LISTE_INST
 id := id + (EXP * EXP) ; LISTE_INST
 id := id + (id * EXP) ; LISTE_INST
 id := id + (id * nb) ; LISTE_INST
 id := id + (id * nb) ; INST
 id := id + (id * nb) ; id := EXP;
 id := id + (id * nb) ; id := nb;

• La traduction dirigée par la syntaxe est la combinaison d’un

analyseur syntaxique et d’un générateur de code intermédiaire
UL Traducteur Programme
Programme Analyseur dirigé par la
source lexical syntaxe
en LI
Données
Producteur Consommateur
• L’analyseur lexical (AL) joue le rôle de producteur et le traducteur dirigé par la syntaxe (TDS) joue le rôle de
consommateur
• L’AL produit une unité lexicale avec ses attributs et le TDS consomme cette unité et demande l’unité suivante (fait appel à
symbole_suivant())

• 2 méthodes différentes existent pour la

traduction dirigée par la syntaxe:
– Définition dirigée par la syntaxe
• Formalisme basé sur une grammaire + des règles
sémantiques
– Schéma de traduction
• Des production + des fragments de programmes

II.3.1. Définition dirigée par la syntaxe (DDS)
• Elle utilise une grammaire non contextuelle pour spécifier la

structure syntaxique du texte d’entrée.
• A chaque symbole non terminal de la grammaire, on associe un
ensemble d’attributs et à chaque production, on associe un
ensemble de règles sémantiques pour calculer la valeur des
attributs associés aux symboles apparaissant dans cette
production
• Une DDS est formée par les règles de la grammaire + des règles
sémantiques pour calculer les attributs.

II.3.2. Schéma de traduction
• C’est une grammaire non contextuelle étendue par des
fragments de programmes qui sont des actions de
traduction.
• Elles sont introduites à l’intérieure de la partie droite
des règles de production entre {}
• Au moment de la construction de l’arbre d’analyse, des
feuilles additionnelles sont associées à ces actions.
• En les parcourant de gauche à droite, nous obtenons le
résultat de la traduction.
II.4.1. Traduction des expressions infixées en notation
post-fixée
• La notation postfixée pour une expression arithmétique E est définie récursivement
comme suit :
– Si E est une variable ou une constante alors la forme post fixée de E est E elle-
même
– Si E est de la forme E1 op E2 alors la forme postfixée de E est E1’E2’op où E1’ et E2’
sont respectivement les formes postfixée de E1 et E2.
– Si E est de la forme (E1) alors la forme post fixée de E est la forme postfixée de E1.
• Pour cet exemple, dans une DDS, on associe un attribut t à chaque non terminal
dont la valeur est une chaine qui représente la notation postfixée de l’expression
engendrée par ce non terminal dans un arbre syntaxique.

II.4.2. DDS pour la traduction des expressions infixées
en notation post-fixées
Règles de production Règles sémantiques
Exp  Exp1 + Exp2 {Exp.t := Exp1.t ||Exp2.t||
+}
Exp  Exp1 * Exp2 {Exp.t := Exp1.t ||Exp2.t||
*}
Exp  (Exp1) {Exp.t := Exp1.t}
Exp  0 {Exp.t := 0}
Exp  1 {Exp.t := 1}
Exp  2 {Exp.t := 2}
…. .…
Exp  9 {Exp.t := 9}
L’AS
Expdu mot (5+9)*2
Donne :
Exp * Exp
( Exp ) 2
Lorsque la règle de
production Exp  5
Exp + Exp est appliquée,
l’attribut t est calculé
par l’application de
la règle sémantique
et Exp.t prend la
5 9 valeur 5
(5+9)*2
Exp.t:=59+2*
Est traduite par
5 9 + 2 * Exp.t:= 59+ * Exp.t:=2
( Exp.t:=5 9 + ) 2
Lorsque la règle de
production Exp  5
Exp.t := 5 + Exp.t :=9 est appliquée,
l’attribut t est calculé
par l’application de
la règle sémantique
et Exp.t prend la
5 9 valeur 5
II.4.3. Schéma de traduction des expression
Exp  Exp1 + Exp2{Imprimer(+)}
Exp  Exp1 * Exp2{Imprimer(*)}
Exp  (Exp1)
Exp  0 {Imprimer(0)}
Leila Ben Ayed Exp  8 Théorie
{Imprimer(8)}
des Langages et Compilation 312
(5+9)*2
Exp
Est traduite par
5 Exp
9 + 2 ** Exp I(*)
( Exp ) 2 I(2)
En exécutant les
Exp + Exp I(+) Instructions
d’impression de
gauche à droite :
I(5)I(9)I(+)I(2)I(*)
5 Nous obtenons
I(5) 9 I(9) La forme post fixée :
59+2*
II.5. Analyse lexicale
• L’analyse lexicale consiste en la conversion du flot de caractères d’entrée en un flot
d’unités lexicales qui devient l’entrée pour les phases suivantes d’analyse (syntaxique,
sémantique et traduction en code intermédiaire) ou bien pour le traducteur dirigé par
la syntaxe dans le cas d’un compilateur en une seule passe. Un analyseur lexical est
basé sur les systèmes de transition (ou bien les automates finis)
Début > =
autre
3 *
return(oprel, PGQ)

III. Analyse Syntaxique
Plan
III.1. Présentation Générale

III.2. Analyse syntaxique par descente récursive
III.3. Analyse syntaxique prédictive récursive
III.4. Analyse syntaxique prédictive non récursive
III.5. Récupération sur erreur
III.6. Analyse syntaxique par décalage réduction
III.1. Présentation générale
L’analyse syntaxique consiste à vérifier que la séquence d’unités
lexicales retournées par l’analyseur lexical est générée par la grammaire
du langage.
Ceci revient à construire un arbre syntaxique dont les feuilles
concordent avec la séquence d’unités lexicales en les parcourant de
gauche à droite.
Nous distinguons:
• Analyse syntaxique descendante

• Analyse syntaxique ascendante
III.1. Présentation générale
Analyse syntaxique descendante :
• Elle s’effectue par la construction descendante d’un arbre syntaxique en
partant de la racine étiquetée par l’axiome de la grammaire et en
réalisant de manière répétitive les étapes suivantes:
• Étape 1: au nœud n étiqueté par le non terminal A, choisir une

production ayant A à gauche et construire les fils de n avec les
symboles en partie droite de la production.
• Étape 2: déterminer le prochain nœud où un sous arbre doit être

construit.
III.2. Analyse syntaxique descendante
récursive
Exemple: Le langage est formé par un ensemble de Types générés par la
grammaire non contextuelle suivante:
Type  array[Type_simple] of Type
| Type_simple
| ^Type
Type_simple  integer
|char
|nb 2points nb
Les étapes de construction descendante de l’arbre syntaxique pour le
mot:
array[nb 2points nb] of integer
sont les suivantes:

récursive
(a) Type
(b) Type
array [ Type_simple ] of Type
(c) Type
nb 2points nb

récursive
(d) Type
nb 2points nb Type_simple
(e) Type
nb 2points nb Type_simple
integer

récursive
• C’est une méthode d’analyse dans laquelle on

exécute des procédures récursives.
• Une procédure est associée à chaque non
terminal.

récursive
Exemple: Le langage est formé par un ensemble de
Types générés par la grammaire non contextuelle
suivante:
Type  array[Type_simple] of Type
| Type_simple
| ^Type
Type_simple  integer
|char
|nb 2points nb
récursive
Procedure accepter(T) Procedure Type_simple()
Si Symbole = T alors Si symbole = integer alors
symbole := symbole_suivant();
AnalLex(); accepter(integer);
Sinon erreur(); Sinon Si symbole = char alors
Fin Si accepter(char);
Procedure Type() Sinon Si symbole = nb alors
Si symbole = array alors accepter(nb);
accepter(array); accepter([); Type_simple(); accepter(2points);
accepter(]); accepter(nb);
accepter(of); Type(); Sinon erreur();
Sinon si symbole  {integer, char, nb} alors Fin Si Fin Si Fin Si
type_simple(); Fin
Symbole_suivant est une fonction
Sinon si symbole = ^ alors accepter(^); qui retourne le nouveau symbole
Type();
trouvé par l’analyseur lexical et
sinon erreur (); l’enregistre dans une variable
Fin Si FinSi FinSi globale symbole
Fin

III.3. Analyse syntaxique Prédictive
descendante récursive
• C’est une méthode d’analyse syntaxique par descente récursive
où un symbole de prévision permet de décider d’une manière
unique quelle règle peut être appliquée.
• La grammaire doit être non récursive à gauche et non ambiguë.
• Pour se faire, il faut éliminer la récursivité à gauche puis
enlever l’ambigüité.
• Ensuite, on associe une procédure à chaque non terminal.
Rq. Le pseudo-code précédent est associé à un analyseur

syntaxique prédictif récursif car la grammaire qui génère les
types est non ambiguë et non récursive à gauche

III.3.1. Elimination de la récursivité à gauche
• Une grammaire est dite récursive à gauche si

elle admet une règle de la forme : A  A 
• Une grammaire récursive à gauche avec les
règles de production
– A  A1|A2|…An |1|2 |… |m
Est transformée en une grammaire non récursive à
gauche ayant les règles de production :
– A  1 A’| 2A’|… mA’
– A’  1 A’|2A’|…nA’ |
III.3.1. Elimination de la récursivité à gauche
Exemple
• La grammaire suivante est récursive à gauche
Exp  Exp op Exp | (Exp) | id | nb
Elle est transformée en une grammaire non
récursive à gauche avec les règles suivantes:
Exp  (Exp) E’ | id E’ | nb E’
E’  op Exp E’ | 

III.3.2. Elimination de l’ambiguité
Une grammaire est dite ambiguë si elle admet des règles de la forme :
A   1 | 2
• Une grammaire ambiguë avec les règles de production
– A   1|2|…n |1|2 |… |m
Est transformée en une grammaire non ambiguë ayant les règles de production :
– A   A’|1 | 2 |…| n
A’  1|2|…n
• La grammaire suivante est ambigue
I  If (Expb) Then I | If (Expb) Then I else I
Elle est transformée en une grammaire non ambiguë avec les règles
suivantes:
I  If (Expb) Then I S
S   | else I

III.3.3. Exemple
Exemple: le langage est formé par une séquence non vide d’instructions d’affectation
L_I  I | I L_I
I  id := Exp;
Exp  id |nb| (Exp) | Exp op Exp
1) En éliminant la récursivité à gauche, on obtient:
L_I  I | I L_I
I  id := Exp;
Exp  id E’|nb E’| (Exp) E’
E’  op Exp E’ | 
2) En éliminant l’ambiguité, on obtient :
L_I  I S
S   | L_I
I  id := Exp;
Exp  id E’|nb E’| (Exp) E’
E’  op Exp E’ | 

III.3.3. Exemple
Un pseudo-code d’un analyseur syntaxique prédictif et récursif associé:
L_I  I S Procédure S()

Si symbole = id alors L_I();
S   | L_I Fin
I  id := Exp; Procédure I();
Exp  id E’|nb E’| (Exp) E’ Si symbole = id alors
accepter(id); accepter(:=);
E’  op Exp E’ |  Exp(); accepter(;);
Sinon erreur();
Fin Si
Fin
Procédure accepter(T) Procédure Exp();
Si symbole = T alors Symbole := symbole_ Si symbole = id alors accepter(id); E’();
suivant(); Sinon Si symbole = nb alors accepter(nb); E’();
Sinon erreur(); Sinon si symbole = ( alors accepter((); Exp(); accepter()); E’();
Sinon erreur();
FinSi
Fin Si Fin Si Fin Si
Fin Fin
Procédure L_I() Procédure E’()
I(); S(); Si symbole = op alors accepter(op); Exp(); E’();
Fin
Fin

Théorie Des Langages Et Compilation - Leila Ben Ayed

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Théorie Des Langages Et Compilation - Leila Ben Ayed

Transféré par

Droits d'auteur :

Formats disponibles

Théorie des langages et

Prof. Leila Ben Ayed

Ecole Nationale des Sciences de l’Informatique

C pour TLC (Compilation)

I.1. Vocabulaire et Mot

Définition 2. Fermeture: Soit X, un alphabet. On note par

Rq le symbole * est une fonction qui, appliquée à un

Leila Ben Ayed Théorie des Langages et Compilation 6

Définition 3. Chaine vide: Une chaine vide est une chaine

Définition 4. Longueur d’une chaine: La longueur d’une

Leila Ben Ayed Théorie des Langages et Compilation 7

Où i est l’image de i dans X; i est le rang de i dans ;

Leila Ben Ayed Théorie des Langages et Compilation 10

• Si X est la vocabulaire du langage de programmation C

• Si X est le vocabulaire de la logique des propositions

L’ensemble des mots de L est défini récursivement comme

Leila Ben Ayed Théorie des Langages et Compilation 15

Leila Ben Ayed Théorie des Langages et Compilation 16

Leila Ben Ayed Théorie des Langages et Compilation 17

Ai+1 = A.Ai i0

Leila Ben Ayed Théorie des Langages et Compilation 19

Leila Ben Ayed Théorie des Langages et Compilation 20

Contre exemple : A = {, x}, B = {xyzt}, C = {yzt}

Leila Ben Ayed Théorie des Langages et Compilation 21

Leila Ben Ayed Théorie des Langages et Compilation 22

–L est l’ensemble des mots sur {a, b} de longueur paire

–L est l’ensemble des mots sur {a, b} ayant un nombre impaire de b

Leila Ben Ayed Théorie des Langages et Compilation 23

La définition récursive du même langage est :

L = {   {a, b}*/  =  ou  = a1b et 1  L}

Leila Ben Ayed Théorie des Langages et Compilation 24

L = {   {a, b}*/  = aa ou  = bb ou  = a1a ou

Leila Ben Ayed Théorie des Langages et Compilation 25

L = {   {a, b}*/  = a ou  = b ou  = a1a ou

Leila Ben Ayed Théorie des Langages et Compilation 26

Leila Ben Ayed Théorie des Langages et Compilation 27

Pour deux langages A et B d’un vocabulaire X*,

Leila Ben Ayed Théorie des Langages et Compilation 28

Presser Cet automate reconnaît les

Leila Ben Ayed Théorie des Langages et Compilation 31

Leila Ben Ayed Théorie des Langages et Compilation 34

Leila Ben Ayed Théorie des Langages et Compilation 35

Leila Ben Ayed Théorie des Langages et Compilation 36

Leila Ben Ayed Théorie des Langages et Compilation 37

{  {a}*/ || = 2k, k > 0} (autre solution)

Leila Ben Ayed Théorie des Langages et Compilation 38

Leila Ben Ayed Théorie des Langages et Compilation 39

Leila Ben Ayed Théorie des Langages et Compilation 40

{  {a}*/ || = 3k+1, k  0} (autre solution)

Leila Ben Ayed Théorie des Langages et Compilation 41

Leila Ben Ayed Théorie des Langages et Compilation 42

5) Construire un automate fini qui accepte l’ensemble des mots

Leila Ben Ayed Théorie des Langages et Compilation 43

Leila Ben Ayed Théorie des Langages et Compilation 44

Leila Ben Ayed Théorie des Langages et Compilation 45

Leila Ben Ayed Théorie des Langages et Compilation 46

Pour l’automate suivant, des configurations possibles sont:

Définition 12. Configuration successeur

(q, x) |-- (p, y) q a p

Leila Ben Ayed Théorie des Langages et Compilation 49

Pour l’automate suivant, des configurations possibles sont:

(q0, aa) |-- (q1, a) |-- (q2, )

(q, x) |-- (p, y) ssi  k  0 / (q, x) |-- (p, y)