THEORIE DES LANGAGES ET COMPILATION (Cours2) V5

Langages et expressions rationnels
Boutaina Hdioud
hdioud.boutaina@hotmail.fr
Plan
o Langages réguliers
o Expressions régulières
Langage
Langage
Un langage sur un alphabet X est une partie de X*. C’est donc un ensemble de mots.
L’ensemble des codes source C, des nombres binaires sont des langages.
Exemple :
Soit X = {a, b} un alphabet.
• ∅ désigne le langage vide
• On désigne également par {ε} le langage composé uniquement de la chaîne vide.
• {a, ba, bba} est un langage
• {w ∈ X*|w = an , n ∈ ℕ} est un langage
Langage
Opérations sur les langages

Soient 𝐿, 𝐿1 𝑒𝑡 𝐿2 des langages sur l’alphabet X.
• Union ∶ Tous les éléments de deux ensembles

𝐿1, 𝐿2 ⊆ 𝑿∗ , 𝐿1 ∪ 𝐿2 = {𝒘 ∈ 𝑿∗ |𝒘 ∈ 𝐿1 𝒐𝒖 𝒘 ∈ 𝐿2}
• Associative
• Commutative
• Elément neutre : ensemble vide ∅
• Notée + dans la théorie des langages

Langage

• Exemple: Union
• 𝑿= 𝒂, 𝒃, 𝒄 , 𝑳𝟏 = 𝒂, 𝒃 , 𝑳𝟐 = { 𝒂, 𝒄 }
• 𝑳𝟑 = 𝑳𝟏 ∪ 𝑳𝟐
Langage

• Intersection:‚ Éléments communs de deux ensembles
L1, L2 ⊆ 𝑿∗ , L1 ∩ L2 = {𝒘 ∈ 𝑿∗ |𝒘 ∈ L1 𝒆𝒕 𝒘 ∈ L2}
• Associative
• Commutative
• Elément neutre : 𝑿∗
• Elément absorbant : ∅
Langage

• Exemple: Intersection
• 𝑿= 𝒂, 𝒃, 𝒄 , 𝑳𝟏 = 𝒂, 𝒃 , 𝑳𝟐 = { 𝒂, 𝒄 }
• 𝑳𝟑 = 𝑳𝟏 ∩ 𝑳𝟐
Langage

• D𝐢𝐟𝐟é𝐫𝐞𝐧𝐜𝐞: tous les éléments du premier ensemble sauf ceux du second
L1, L2 ⊆ 𝑿∗ , L1 ∖ L2 = {𝒘 ∈ 𝑿∗ |𝒘 ∈ L1 𝒆𝒕 𝒘 ∉ L2}
• Non-associative,
• Non-commutative,
• Elément neutre ∅,
• Elément absorbant 𝑿∗
Langage

• Exemple: Différence
• 𝑿= 𝒂, 𝒃, 𝒄 , 𝑳𝟏 = 𝒂𝒃, 𝒂𝒄, 𝒄𝒅 , 𝑳𝟐 = { 𝒂𝒄 }
• 𝑳𝟑 = 𝐿 1 ∖ 𝐿 2
Langage

• Complémentaire : mots de 𝑿∗ qui ne sont pas dans L1
L1 ⊆ 𝑿∗ , Lഥ1= 𝑿∗ ∖ L1 = {w ∈ 𝑿∗ |w ∉ L1}
Langage

• Egalité de langages: Deux langages 𝐿1 𝐿2 ⊆ 𝑿∗ sont égaux, noté 𝐿1 = 𝐿2 , si et seulement si 𝐿1
⊆ 𝐿2 et 𝐿2 ⊆ 𝐿1 .
Langage

• Concaténation: 𝐿1 𝐿2 est le langage contenant tous les mots formés d’un mot de 𝐿1 suivi d’un
mot de 𝐿2 :
𝐿1 . 𝐿2 = {w|w = 𝑤1 𝑤2 , 𝑤1 ∈ 𝐿1 𝒆𝒕 𝑤2 ∈ 𝐿2 }
• Associative,
• non commutative,
• élément neutre ε,
• élément absorbant ∅
Langage

• Exemple: Concaténations
• 𝑿= 𝒂, 𝒃, 𝒄 , 𝑳𝟏 = 𝒂𝒃, 𝒂𝒄, 𝒄𝒅 , 𝑳𝟐 = { 𝒂𝒄 }
• 𝑳𝟑 = 𝐿 1 𝐿 2
Langage

• Exemple: Concaténations
Soit un alphabet X = {a, b}, un langage 𝐿1 = {𝜀, a, ab} et un langage 𝐿2 = {b, ba}.
• 𝐿1 ◦𝐿2 = 𝐿1 . 𝐿2 = 𝐿1 𝐿2 = {b, ba, ab, aba, abb, abba}
• 𝐿2 ◦ 𝐿1 = 𝐿2 . 𝐿1 = 𝐿2 𝐿1 = {b, ba, bab, ba, baa, baab} = {b, bab, ba, baa, baab}
⇒ 𝐿1 𝐿2 ≠𝐿2 𝐿1
Langage

• P𝐮𝐢𝐬𝐬𝐚𝐧𝐜𝐞:
𝐿𝑖 = { α ∈ L* t. q. |α| = i }
EXEMPLE: soit L = {a, ab, ba, ac},

𝐿2 = {𝑎𝑎, 𝑎𝑎𝑏, 𝑎𝑏𝑎, 𝑎𝑎𝑐, 𝑎𝑏𝑎𝑏, 𝑎𝑏𝑏𝑎, 𝑎𝑏𝑎𝑐, 𝑏𝑎𝑎, 𝑏𝑎𝑎𝑏, 𝑏𝑎𝑏𝑎, 𝑏𝑎𝑎𝑐, 𝑎𝑐𝑎, 𝑎𝑐𝑎𝑏, 𝑎𝑐𝑏𝑎, 𝑎𝑐𝑎𝑐}.
Remarque :
• 𝐿0 = {ε} ,
• 𝐿𝑖 = LL...L, la concaténation de i fois L
• 𝐿𝑖 = 𝐿𝑖−1 .L
Langage

• Théorème
Le produit de langages est distributif par rapport à l’union.
∀𝐿1 , 𝐿2 , 𝐿3 ⊆ 𝑿∗ 𝐿1 .(𝐿2 ∪ 𝐿3 ) = (𝐿1 . 𝐿2 ) ∪ (𝐿1 . 𝐿3 )
(𝐿2 ∪ 𝐿3 ). 𝐿1 = (𝐿2 . 𝐿1 ) ∪ (𝐿3 . 𝐿1 )
• Ce théorème reste vrai pour des unions infinies
∀𝐿1 , 𝐿𝑖 ⊆ 𝑿∗ 𝐿1 .(⋃∞
𝑖=1 𝐿𝑖 ) =⋃𝑖=1 (𝐿1 𝐿𝑖 )
∞
. (⋃∞
𝑖=1 𝐿𝑖 ). 𝐿1 =⋃𝑖=1 (𝐿𝑖 𝐿1 )
∞
• Attention ! : Le produit de langages n’est pas distributif par rapport à l’intersection.
∀𝐿1 , 𝐿2 , 𝐿3 ⊆ 𝑿∗ , 𝐿1 .(𝐿2 ∩ 𝐿3 ) ⊆ (𝐿1 . 𝐿3 ) ∩ (𝐿1 . 𝐿3 )
• 𝐿𝑛+𝑚 = 𝐿𝑛 𝐿𝑚 et (𝐿𝑚 )𝑛 = 𝐿𝑚𝑛

Langage

• Fermeture de Kleene: La clôture de Kleene du langage 𝐿, notée 𝐿∗ est l’ensemble des chaînes
qui peuvent être formées en prenant un nombre quelconque (éventuellement 0) de chaînes de
𝐿 et en les concaténant.
• 𝐿∗ =⋃∞
𝑖=0 𝐿
𝑖
• 𝐿∗ = {ε} ∪ L ∪ 𝐿2 … ∪ 𝐿𝑛 ∪ …
Ce langage contient un nombre infini de mots, qui sont les répétitions indéfinies de mots de L.
Langage

• 𝐅𝐞𝐫𝐦𝐞𝐭𝐮𝐫𝐞 𝐩𝐨𝐬𝐢𝐭𝐢𝐯𝐞
Soit L ⊆ X ∗ . On note 𝐿+ =⋃∞ 𝑖

𝑖=1 𝐿 la fermeture positive du langage L.
Langage

• 𝐓𝐡é𝐨𝐫è𝐦𝐞
Soit 𝐿 ⊆ X ∗ . On note 𝐿+ =𝐿𝐿∗ =𝐿∗ 𝐿
• (𝐿∗ )∗ = 𝐿∗
Langage

• 𝐎𝐩é𝐫𝐚𝐭𝐢𝐨𝐧 𝐦𝐢𝐫𝐨𝐢𝐫
Soit 𝐿 ⊆ X ∗ . 𝑂𝑛 𝑑é𝑓𝑖𝑛𝑖𝑡 𝑙’𝑜𝑝é𝑟𝑎𝑡𝑖𝑜𝑛 𝑚𝑖𝑟𝑜𝑖𝑟 𝑐𝑜𝑚𝑚𝑒 é𝑡𝑎𝑛𝑡 ∶
𝐿𝑅 = 𝑤
෥ 𝑤 ∈ 𝐿}
• Théorème
Soit 𝐿1 ,𝐿2 ⊆ X ∗ . On a (𝐿1 .𝐿2 )𝑅 = 𝐿2 𝑅 𝐿1 𝑅
• 𝐿෫1 ∪𝐿2 =𝐿1 ∪ 𝐿2

෪ ෪
• 𝐿෨ = 𝐿
• (𝐿෩∗ ) = (𝐿)
෪∗
Langage
Les opérations de réunion, de concaténation et de fermeture sont dites opérations régulières, car
elles servent a écrire ce qu’on appelle des expressions régulières :
• La réunion exprime le choix.
• La concaténation exprime la séquence.
• La fermeture de Kleene exprime la répétition ´ .
• La fermeture de Kleene positive exprime la répétition non nulle.

Langage
Exemple:
Soit le langage L des mots sur l’alphabet 𝐴 = {𝑎, 𝑏, 𝑐} qui commencent par 𝑎 ou 𝑏, suivis de 0 ou
plusieurs occurrences de 𝑐𝑐 et se termine par au moins un 𝑏.
Il est clair que 𝐿 = 𝐿1 𝐿2 𝐿3 , où 𝐿1 = 𝑎, 𝑏 , 𝐿2 = {𝑐𝑐}∗ 𝑒𝑡 𝐿3 = {𝑏}+ .
Finalement, 𝐿 = 𝑎, 𝑏 ({𝑐𝑐}∗ ) {𝑏}+ , qui sera simplifié (a|b) (𝑐𝑐)∗ 𝑏+

Expressions régulières
Langages réguliers
Un langage L sur un alphabet Σ est dit régulier si et seulement s’il existe une expression régulière
qui le dénote, c’est- à -dire telle que L = L(r).
Langages réguliers
L’ensemble 𝐿 des langages réguliers sur un alphabet Σ est le plus petit ensemble (qui contient le
moins d ’éléments) des langages satisfaisant les conditions :
1. ∅ ∈ L et {𝜀} ∈ 𝐿 sont régulières
2. ∀a ∈ Σ, {a} ∈ L le langage {a} est régulier
3. Si 𝐿1 , 𝐿2 ∈ L, alors 𝐿1 ∪ 𝐿2 ∈ L, 𝐿1 𝐿2 ∈ L et 𝐿1 ∗ ∈ L
Les expressions régulières sont une façon déclarative de décrire la formation des chaînes d’un langage.
Si 𝐸 est une expression régulière on notera 𝐿(𝐸) le langage engendré par 𝐸.

Les expressions régulières sur un alphabet Σ sont les règles formées par les règles suivantes :
1. ∅ et 𝜀 sont des expressions régulières
2. ∀ a ∈ Σ, a est une expression régulière
3. Si 𝛼 𝑒𝑡 𝛽 sont des expressions régulières alors
(α + β)
(α.β) ቑ sont des expressions régulières
(α)∗
Langage représenté par une expression régulière

Soit r une expression régulière. 𝐿(𝑟) est le langage représenté par r.
𝐿(∅) = ∅, L(𝜀) = {𝜀}
∀a ∈ Σ, L(a) = {a}
L(α ,β) = L(α) ∪ L(β) = L(α) + L(β)
L(α.β) = L(α).L(β)
L((𝛼)∗ ) = (𝐿(𝛼)) ∗
Théorème
Un langage est régulier si et seulement si il peut être dénoté par une expression régulière.
Le langage 𝐿(𝑀) engendré par l’automate 𝑀 suivant est un langage régulier.
𝐿(𝑀) = (𝑎 + 𝑏)∗ 𝑎(𝑎 + 𝑏)∗

Egalité d’expressions régulières

Deux expressions régulières sont égales si elles représentent le même langage.
Exemple
• 𝑟 ∗ = 𝑟 ∗ + 𝜀 car 𝜀 ∈ 𝑟 ∗
Propriétés des expressions régulières • (r.s).t = r.(s.t) = r.s.t
Soient r, s et t trois expressions régulières sur le même • r.(s + t) = rs + rt

alphabet Σ. • 𝑟 ∗ = (𝑟 ∗ ) ∗ = 𝑟 ∗ 𝑟 ∗ = (𝜀 +r) ∗ = 𝑟 ∗ (r+ 𝜀) = (r+ 𝜀) 𝑟 ∗ =
𝜀 +r𝑟 ∗ = 𝜀 +𝑟 ∗ r
• r+s=s+r
• (r +s) ∗ = (𝑟 ∗ 𝑠 ∗ )∗ = (𝑟 ∗ s) ∗ 𝑟 ∗ = (𝑠 ∗ r) ∗ 𝑠 ∗ = 𝑟 ∗ (s𝑟 ∗ )∗
• r+∅=∅+r=r
• r(sr) ∗ = (rs) ∗ r
• r+r=r
• (𝑟 ∗ s) ∗ = 𝜀 +(r +s) ∗ s
• (r + s) + t = r + (s + t) = r + s + t
• (𝑟𝑠 ∗ )∗ = 𝜀 +r(r +s) ∗
• r. 𝜀 = 𝜀 .r = r
• r𝑟 ∗ = 𝑟 ∗ r = 𝑟 +
• r.∅ = ∅.r = ∅
• ∅+ε = ε +∅ =ε
• ∅∗ = ε
Règles de précédence
• Lorsqu’on combine plusieurs symboles de construction dans une expression régulière, comme par exemple dans 𝑎|𝑎𝑏 ∗ ,
il n’est pas clair comment les sous expressions régulières sont regroupées. On peut alors utiliser les parenthèses (...)
pour fixer un regroupement de symboles, par exemple (𝑎|(𝑎𝑏))∗ . Pour simplifier l’écriture des expressions régulières, on
adopte les règles de priorité suivantes :
1. l’operateur de fermeture ‘*’ a la plus haute priorité.
2. l’operateur de concaténation à la deuxième plus haute priorité.
3. l’operateur de réunion ‘ | ‘a la plus faible priorité.
Selon ces conventions, l’expression régulière 𝑎|𝑎𝑏 ∗ est équivalente à (𝑎|(𝑎(𝑏 ∗ )))
Exemples:
Considérons l’alphabet Σ = {0, 1}
• Expression1 : 0*
Cette expression régulière décrit toutes les chaînes composées uniquement du symbole 0 ainsi que la chaînes vide 𝜀.
• Expression2 : 110*1
Cette expression régulière décrit les chaînes contenant deux fois le symbole 1 suivis d’un nombre quelconque de
symboles 0, éventuellement nul, et du symbole 1.
• 0*110*1 est la concaténation des expressions 1 et 2. Elle décrit les chaînes commençant par un nombre quelconque de
0 suivis de deux 1, suivi d’un nombre quelconque de 0 et d’un 1.
• 0* | 110*1 est l’expression régulière décrivant les chaînes générées soit par l’expression 1, soit par l’expression 2.
Remarque
• On utilise parfois la notation 𝑒 + pour 𝑒𝑒 ∗
L 𝑒 + =∪𝑖=1 (𝐿(𝑒))𝑖
• Pour des raisons de lisibilité, il est possible de nommer certaines E.R. et d'utiliser ces noms dans d'autres E.R.
• DEC → (0|1|...|9) + (ε|. (0|1|...|9) + )
• Chiffre →(0|1|...|9)
• DEC → 𝐶ℎ𝑖𝑓𝑓𝑟𝑒 + (ε |. 𝐶ℎ𝑖𝑓𝑓𝑟𝑒 + )

Autres constructions obtenues à partir des précédentes

• [a,b,c] pour (a|b|c) et [a1-a2] pour tout caractère entre a1 et a2 (alphabet supposé ordonné)
• M+ pour MM*
• [^abc] désigne le complémentaire de {a,b,c} dans Σ
• . pour Σ (n’importe quel caractère )
• a? est une abréviation de a|ε

Récapitulation
• Le rôle d'un analyseur lexical est la reconnaissance des unités lexicales.
• Une unité lexicale peut (la plupart du temps) être exprimée sous forme d'expression régulière.
• Dans la théorie des langages, on définit des automates qui sont des machines théoriques
permettant la reconnaissance de mots.
• Ces machines ne marchent que pour certains types de langages.
Théorème
Tout langage régulier est reconnu par un automate fini.

Les automates
Les automates sont des objets mathématiques, très utilisés en informatique, qui permettent de modéliser un grand
nombre de systèmes (informatiques). De façon très informelle, un automate est un ensemble “d’états du système”,
reliés entre eux par des “transitions” qui sont marquées par des symboles. Étant donné un “mot” fourni en entrée,
l’automate lit les symboles du mot un par un et va d’état en état selon les transitions. Le mot lu est soit accepté par
l’automate soit rejeté.
• Les automates finis ont des applications importantes :
 Description de machines physiques (circuits électroniques, distributeur d’objets, etc.)
 Définition de protocoles de communication dans des réseaux
 Description de systèmes de commandes (comme le système de commandes d’un ascenseur), etc.
• Les automates finis peuvent être utilisés pour calculer des fonctions, ou pour reconnaître des langages.
Les automates finis
Les expressions régulières constituent un formalisme algébrique pour spécifier les langages
réguliers. Le formalisme graphique permet de résoudre la question de la reconnaissance de ces
langages.
Définition : Un reconnaisseur pour un langage 𝐿 sur un alphabet Σ est un programme qui prend
∗
en entrée une chaîne w ∈ Σ et répond ”oui” si w ∈ L et ”non” si w ∉ L.
Les automates finis constituent un outil formel très intéressant de la théorie des langages. Nous
allons voir comment transformer une expression régulière en un reconnaisseur en construisant un
automate fini.
Il y a deux grandes catégories d’automates finis : les AFD (automates finis déterministes) et les
AFND (automates finis non-déterministes ).
Automate fini déterministe

Un automate fini déterministe est un quintuplet 𝑀 = 𝑄, Σ, 𝛿, 𝑞0 , 𝐹 où,
 Q est un ensemble fini d’états
 Σ est un ensemble fini de symboles (un alphabet)
 δ : Q × Σ → Q est une fonction de transitions
 q0 ∈ Q est l’état initial
 F ⊆ Q est l’ensemble (fini) des états finaux
 Une paire (q,w), où q ∈ Q est un état, et w ∈ Σ∗ est un mot de l’alphabet Σ est appelé une configuration.
Notations
• Etat initial
• Etat final (2 notations possible)
• Transition entre l’ état p et q : 𝛿(𝑝, 𝑎) = 𝑞

Diagrammes de transition
 Ce sont des automates finis déterministes
 On se déplace de position en position dans le diagramme au fur et à mesure de la lecture des caractères.
 Les positions dans l’automate sont appelées états.
 Les états sont reliés par des arcs qui ont des étiquettes indiquant les caractères lus.
 Les automates sont déterministes (aucun symbole ne peut apparaître comme étiquette de deux arcs quittant un nœud )
 Un état appelé départ est l’état initial

Exemple d’automate fini déterministe:
– 𝚺 = {𝒂, 𝒃}
– 𝑸 = 𝟏, 𝟐, 𝟑
– 𝒒𝟎 = 𝟏
–𝑭 = 𝟑
– 𝜹(𝟏, 𝒂) = 𝟐 𝒆𝒕 𝜹(𝟐, 𝒃) = 𝟑.
Résumé
Un AFD dans le sens abstrait, est une ”machine” qui possède un nombre fini d’ états et un nombre fini de
transitions entre ces états. Une transition entre deux états est étiqueté par un symbole de l’alphabet d’entrée . En
théorie des langages, un AFD peut être utilisé pour décider si un mot w appartient a un langage donné 𝐿. Pour
faire ceci, nous partons de l’état initial q0 de l’automate. A chaque étape, on lit un symbole de w a partir de
l’entrée, puis on suit une transition étiquetée par ce symbole et on change l’état courant. Il y a deux cas qui
peuvent se présenter :
 Tous les symboles de l’entrée ont été lus. Nous testons alors si le dernier état est un état final. Si oui, le mot
𝑤 ∈ 𝐿, sinon w ∉ L.
 On se bloque sur un symbole particulier car il n’y a pas de transition avec ce symbole. Dans ce cas, w ∉ L.
Langage reconnu par un AFD
Le langage reconnu (ou accepté) par un automate AFD est l’ensemble des mots qui correspondent à un
calcul de l’automate partant d’un état initial et s’arrêtant dans un état final.
Le langage accepté par un automate M, noté L(M), est défini par:

𝐿(𝑀) ∶ {𝑤 ∈ Σ ∗ |(𝑞0 , 𝑤) ⊢∗𝑀 (𝑞, 𝜀) 𝑎𝑣𝑒𝑐 𝑞 ∈ 𝐹}.
Reconnaissance d’un mot par un automate
La reconnaissance d’un mot w par un automate M (appelée aussi exécution d’un automate M sur
un mot w) est la suite des configurations :
(𝑞0 , 𝑤) ⊢ (𝑞1 , 𝑤1 ) ⊢ (𝑞2 , 𝑤2 ) ⊢ ………… ⊢ (𝑞𝑛 , 𝜀)
Mot accepté par un automate
Un mot w est accepté par un automate si et seulement si:
(𝑞0 , 𝑤) ⊢∗𝑀 (𝑞, 𝜀) et 𝑞 ∈ 𝐹

Exemple d’un AFD reconnaissant le langage 𝒂∗ 𝒃 𝒂∗ :

L’ expression régulière 𝒂∗ 𝒃 𝒂∗ dénote le langage 𝐿 sur l’alphabet {𝑎, 𝑏} des mots ayant exactement une seule occurrence de b. Ce
langage est reconnu par l’AFD suivant :
La fonction de transition 𝛿 d’un AFD peut être représentée à l’aide d’un tableau bidimensionnel appelé matrice de transition
• Le mot baa appartient au langage 𝒂∗ 𝒃 𝒂∗ ,
• Le mot aa n’appartient pas au langage 𝒂∗ 𝒃 𝒂∗ (0 ∉ F, alors le mot aa ∉ 𝒂∗ 𝒃 𝒂∗ ).
• Le mot bba n’appartient pas au langage 𝒂∗ 𝒃 𝒂∗ ( le mot bba ∉ 𝒂∗ 𝒃 𝒂∗ )

Configuration dérivable en une étape
La configuration 𝑞 ′ , 𝑤 ′ est dérivable en une étape de 𝑞, 𝑤 par M (noté (q, w) ⊢𝑀 (𝑞 ′ , 𝑤 ′ )) si :
– 𝑤 = 𝜎𝑤 ′ (𝜎 ∈ Σ, 𝜎 est le premier caractère de w et 𝑤 ′ est égal à w privé de 𝜎 ).
– 𝑞 ′ =𝛿(𝑞, 𝜎) (𝑞 ′ est le prochain état déterminé par la fonction de transition pour 𝑞 et 𝜎).
Configuration dérivable (en plusieurs étapes)
la configuration 𝑞 ′ , 𝑤 ′ est dérivable de la configuration 𝑞, 𝑤 par M (noté (q, w) ⊢∗𝑀 (𝑞 ′ , 𝑤 ′ ) , si ∃k ≥ 0 et k

configurations (𝑞𝑖 , 𝑤𝑖 ), 0 ≤ 𝑖 ≤ 𝑘 telles que:
(𝑞0 , 𝑤0 ) = 𝑞, 𝑤
(𝑞𝑘 , 𝑤𝑘 ) = (𝑞 ′ , 𝑤 ′ )
(𝑞𝑖 , 𝑤𝑖 ) ⊢ (𝑞𝑖+1 , 𝑤𝑖+1 )
Automates complets
Automate complet
Un automate est complet si pour tout état 𝑞 ∈ 𝑄, il existe une transition pour chaque lettre de
l’alphabet Σ.
∀𝑞 ∈ 𝑄, ∀𝑥 ∈ Σ, 𝛿(𝑞, 𝑥) 𝑒𝑠𝑡 𝑑é𝑓𝑖𝑛𝑖
Automates complets
Exemple: Soit Σ = {a, b}
• L’automate M1 est-il complet ?
• L’automate M2 est-il complet ?

Automates complets
Proposition
Pour tout AFD 𝑀=⟨𝑄, Σ,𝛿, 𝑞0 , 𝐹 ⟩, il existe un AFD complet 𝑀′ = 𝑄 ′ , Σ′ , 𝛿 ′ , 𝑞0 ′ , 𝐹 ′ reconnaissant le

même langage.
Automates complets
Etat puits
Pour un automate complet, on appelle état puits, un état 𝑞 ∈ 𝑄 pour lequel toutes les transitions sont
de la forme 𝛿(𝑞, 𝑥) = 𝑞.
Automates complets
Etat poubelle
Un état poubelle est un état puits non final.
Exemple:
Pour Σ = {𝑎, 𝑏}
Automates complets
Technique de complétion
Pour rendre un automate complet :
• Ajouter un état puits P ;
• Ajouter pour chaque état q, et chaque lettre x, une transition (q, x, P) s’il n’existe pas déjà une transition
partant de q par la lettre x.
• Pour chaque lettre x, ajouter la transition (P, x, P).
Remarque :
La complétion ne change ni le langage reconnu, ni le déterminisme éventuel de l’automate.

Automates complets
Exemple:
a,b
b
a,b
Attention : P n’est pas un état d’acceptation !
Remarque : un automate peut être non déterministe mais complet.

Automates complets
Clôture par complément des langages reconnus par AFD
Propriété. Si L est un langage reconnu par AFD, alors son complémentaire Σ ∗ \L l’est aussi.
Exemple : 𝐿 = {𝑎𝑖 𝑏 𝑗 , 𝑖, 𝑗 ∈ 𝑁}, Σ ∗ \L = {𝑤 ∈ Σ ∗ , 𝑏𝑎 𝑒𝑠𝑡 𝑓𝑎𝑐𝑡𝑒𝑢𝑟 𝑑𝑒 𝑤}
On complète l’automate:
Puis on intervertit les états finals :
Construction : Si 𝐴 = (𝑄, 𝛿, 𝑖, 𝐹) est un AFD complet qui reconnaît L, alors 𝐴 = (𝑄, 𝛿, 𝑖, 𝑄\F) reconnaît Σ ∗ \L .
Langage généré par un automate
Un automate peut être vu comme un mécanisme décrivant, ou générant, un langage
Langage généré à partir d’un état par un automate
Le langage généré à partir d’un état 𝑞 par un automate M, noté L(q) est l’ensemble des mots acceptés à partir de
cet état.
. L(q) = Lq = 𝑤 ∈ Σ ∗ (𝑞, 𝑤 ⊢∗ 𝑞 ′ , 𝜀 𝑒𝑡 𝑞 ′ ∈ 𝐹}.
Le langage généré par un automate M est défini par:
L(M) = L(q0)
Système d’équations définissant un langage
Le langage généré à partir d’un état q par un automate M est défini par une équation de la forme :
L(q) = Lq =(σ𝑥∈𝛴 𝑥. 𝐿(𝛿 𝑞, 𝑥 )) + 𝑑(L(q))

∅ 𝑠𝑖 𝜀 ∉ 𝐴
𝑜ù 𝑑(𝐴) = ቊ
𝜀 𝑠𝑖 𝜀 ∈ 𝐴
Exemple : Pour M2
𝐿 𝑞0 = 𝑎𝐿 𝑞0 + 𝑏𝐿 𝑞1 + ∅ = 𝑎𝐿0 + 𝑏𝐿1
൞ 𝐿 𝑞1 = 𝑎𝐿 𝑞0 + 𝑏𝐿 𝑞2 + ∅ = 𝑎𝐿0 + 𝑏𝐿2
𝐿 𝑞2 = 𝑎𝐿 𝑞2 + 𝑏𝐿 𝑞2 + 𝜖 = 𝑎𝐿2 + 𝑏𝐿2 + 𝜖
Automates non déterministe
Non-déterministe
En informatique, non-déterministe est souvent associé à ”plusieurs choix possibles” par opposition déterministe où
l’opération ou l’action à effectuer est unique.
Non-déterministe dans les automates
Plusieurs sources de non-déterministe dans les automates :
• Absence de transition,
• Plusieurs transitions pour une même lettre.
• Plusieurs états initiaux
• des transitions sur des mots vides : 𝜀-transitions

Absence de transition
S’il n’y a plus de transition possible et que le mot est encore en cours de lecture alors le mot est refusé.
Exemple : Lecture de bbba
Plusieurs transitions
Exemple: Lecture de aabaabab et de aaaaaba
Le mot est accepté lorsqu’il existe au moins une lecture menant à un état acceptant.
Plusieurs états initiaux
Le mot est accepté lorsqu’il existe une lecture à partir de l’un des états initiaux menant à un état acceptant.
Définition AFN
Un Automate Fini Non-déterministe est un quintuplet (𝑄, Σ, 𝑇, 𝐼, 𝐴) où :
• Σ est l’alphabet de l’automate,
• 𝑄 un ensemble fini appelé ensemble des états de l’automate,
• 𝑇 est une application de 𝑄 × Σ dans 𝑃(𝑄), appelée la fonction de transition,
• 𝐼 est un sous-ensemble de 𝑄, appelé l’ensemble des états initiaux,
• 𝐴 est un sous-ensemble de 𝑄, appelé l’ensemble des états acceptants.

Exemple
Déterminisation d’un AFN
La déterminisation d’un AFN
Un AFD est un cas particulier d’AFN, avec 𝐶𝑎𝑟𝑑(𝛿(𝑞, 𝑎)) ≤ 1 pour tous 𝑞 ∈ 𝑄, 𝑎 ∈ Σ.
Donc tout langage reconnu par un AFD est reconnu par un AFN.
Plus surprenant, on a la réciproque.
Théorème (Rabin-Scott)
Tout langage reconnu par un AFN peut être reconnu par un AFD.
La déterminisation
Le principe de la construction est de prendre comme états de l’AFD les ensembles d’états de
l’AFN. L’unique état initial de l’AFD est l’ensemble I des états initiaux de l’AFN.
Algorithme de déterminisation d’un AFN
Construction pour la déterminisation d’un AFN :
Si 𝐴 = (𝑄, 𝛿, 𝐼, 𝐹) est un AFN qui reconnaît 𝐿, alors
Adet = (P(Q), δdet, I, 𝐹 det) est un AFD qui reconnaît le même langage L, avec :
• Fdet = {X ∈ P(Q), X ∩ F ≠ ∅},
• δdet(𝑋, 𝑎) = ∪q∈X δ(q, a).
Pratiquement, on ne construit que les états accessibles à partir de I:
On part de l’état initial I, puis on calcule toutes les transitions qui partent de I, puis on recommence avec les
nouveaux états obtenus, etc.
Exemple:
état initial : 𝑰 = {𝟏}
transition par a : {1, 2}
transition par b : {1}
état {1, 2}
transition par b : {1, 3}
état {1, 3}
transition par b : {1}

Clôture par union
S’il y a équivalence des langages reconnus par AFD et AFN, quel est l’intérêt des AFN ?
-> Ils peuvent faciliter certaines constructions

Construction d’un AFN par l’union de deux langages réguliers :
Si 𝐴 = (Σ, 𝑄, 𝐼, 𝐹, 𝛿) et 𝐴′ =(Σ, 𝑄′ ,𝐼 ′ ,𝐹 ′ ,𝛿 ′ ) sont deux AFND , alors 𝐴′′ = (Σ, 𝑄 ∪ 𝑄′ , 𝐼 ∪ 𝐼 ′ , 𝐹 ∪ 𝐹 ′ , 𝛿∪𝛿 ′ ) est un
AFND reconnaissant l’union des langages reconnus par 𝐴 et 𝐴′ .
Pourquoi l’automate union A’’ n’est pas un AFD ?
-> Il n’a pas un seul état initial

Clôture par complémentation
Propriété.
Si 𝐿 est un langage reconnu par AFN, alors son complémentaire Σ ∗ \L l’est aussi.
Par déterminisation, on peut construire un AFD reconnaissant le même langage L, puis appliquer la propriété de clôture
vue précédemment.
Clôture par intersection
Propriété.
Si 𝐿1 , 𝐿2 sont des langages reconnus par AFN, alors 𝐿1 ∩ 𝐿2 l’est aussi.
Exemple :𝐿1 = 𝑤 ∈ Σ ∗ , 𝑤 𝑎 𝑎𝑢 𝑚𝑜𝑖𝑛𝑠 𝑢𝑛 𝑏 , 𝐿2 = 𝑤 ∈ Σ ∗ , 𝑤 𝑎 𝑢𝑛 𝑛𝑜𝑚𝑏𝑟𝑒 𝑝𝑎𝑖𝑟 𝑑𝑒 𝑎
Construction par produit d’automates :
Si 𝐴𝑖 = (𝑄𝑖 , δ𝑖 , 𝐼𝑖 , 𝐹𝑖 ) reconnaît 𝐿𝑖 pour i = 1, 2, alors
A = (𝑄1 × 𝑄2 , δ𝑖 , 𝐼1 × 𝐼2 , 𝐹1 × 𝐹2 ) reconnaît L1 ∩ L2. avec
δ((r, s), a) = (δ1 (r, a), δ2 (s, a))
Remarque :
Si les automates sont des AFD, alors l’automate produit obtenu
Par l’intersection est aussi un AFD.

Clôture par concaténation et étoile
Propriété.
Si 𝐿1 , 𝐿2 sont des langages reconnus par AFN, alors 𝐿1 𝐿2 l’est aussi.
Pour cette propriété, il est très commode d’utiliser des ε–transitions : on rajoute des ε–transitions de tous les états initiaux
de l’AFN pour 𝐿1 , vers tous les états finals de l’AFN pour 𝐿2 .
Propriété.
Si L est un langage reconnu par AFN, alors L* l’est aussi.
De même, on rajoute des ε–transitions de tous les états finals de l’AFN pour L, vers tous ses états initiaux.
Théorème de clôture pour les langages reconnus par AFN ou AFD
Théorème. Si L, L' sont des langages reconnus par AFN, alors il en est de même :
• du complémentaire Σ* \L,
• de l’intersection L ∩ L',
• de l’union L ∪ L',
• de la concaténation LL',
• de l’étoile L*.
Les langages reconnus par AFD étant les mêmes que les langages reconnus par AFN, ces propriétés de clôture sont
vraies aussi pour les langages reconnus par AFD.
𝜺-transistions
Une 𝜀-transistion est une transition par lecture du mot vide.
Pendant la lecture d’un mot, il est possible de choisir d’effectuer la transition 𝜀 sans lire aucune lettre.
Un automate fini non-déterministe avec 𝜺 −transitions
Un automate fini non-déterministe avec 𝜀-transitions est défini par :
• Σ est l’alphabet de l’automate,
• 𝑄 un ensemble fini appelé ensemble des états de l’automate,
• 𝑇 est une application de 𝑄 × {Σ ∪ {𝜀}} dans 𝑃(𝑄), appelée la fonction de transition
• 𝐼 est un sous-ensemble de 𝑄, appelé l’ensemble des états initiaux
• 𝐴 est un sous-ensemble de 𝑄, appelé l’ensemble des états acceptants.
Exemple:
Langage reconnu : 𝐿 = {𝑎𝑐𝑏𝑐, 𝑎𝑐𝑐, 𝑎𝑏𝑐, 𝑎𝑐}

ε-fermeture
On appel ε-fermeture de l’ ensemble d’états 𝑸 = {𝒒𝟎 , 𝒒𝟏 , … … 𝒒𝒏 } l’ensemble des états accessibles depuis un
état 𝒒𝒏 de 𝑸 par une ou plusieurs transition spontanée. Formellement :
Définition.
Soit q un état de Q. On appelle ε-fermeture (en anglais closure) de q l’ensemble
ε−closure(q) = {𝑝 ∈ 𝑄| 𝑞, 𝜀 ⊢∗𝑀 𝑝, 𝜀 }. Par construction, q ∈ ε−closure(q).

Transformation en AFN sans ε-transition
Proposition
Tout langage reconnu par un AFN avec ε–transitions peut être reconnu par un AFN (sans ε–transitions) ayant le même nombre d’états.
Preuve constructive : il existe un algorithme qui étant donné un AFN avec ε-transitions construit un AFN sans ε-transitions équivalent et avec le
même nombre d ’états.
Première étape : Ajoût de ε–transitions par fermeture transitive.
Pour chaque état q, on définit Cloture(q) l’ensemble des états accessibles à partir de q par des ε-transitions. On ajoute à l’automate initial une ε-
transition de q vers p pour tout p dans Cloture(q).
Deuxième étape : Construction de l’AFN sans ε-transitions par fermeture
On ajoute à l’automate de départ :
• dans l’ensemble des états initiaux : les états p extrémités d’une ε-transition dont l’origine est un état initial;
• dans l’ensemble des états finaux : les états p origines d’une ε-transition dont l’extrémité est un état final;
𝑎 𝑎 ε
• dans l’ensemble des transitions : les transitions 𝑝 → 𝑟 pour chaque séquence p → q → r .
On supprime ensuite les ε-transitions.

Transformation en AFN sans ε-transition
Exemple 1
• Fermeture transitive des ε-transitions
• Ajoût de nouvelles transitions et suppression des ε-transitions
• L’AFN obtenu reconnaît bien le même langage : L = {acbc, acc, abc, ac}
Algorithme de détermination d’un AFNε
(Conversion d’un AFNε en un AFD équivalent)
Principe : considérer des ensembles d’états successeurs de 𝐶𝜀({𝑞0}).
• Partir de l’état initial E0 = Cε({𝑞0})
• Pour toute transition a, construire Ei l’ensemble des états obtenus à partir de Ei-1 (à l’étape
précédente) par : 𝐸 i = Cε(δε(Ei-1, a))
• Recommencer 2. pour chaque nouvel ensemble obtenu.
• Tous les ensembles Ei contenant au moins un état final deviennent terminaux
• Renuméroter les ensembles Ei par de simples états
Algorithme de détermination d’un AFNε
Exemple:
Transformation d’une expression régulière en un automate
L’algorithme de Thompson donne un moyen pour convertir automatiquement une expression régulière r dénotant un
langage L en un AFND ayant certaines propriétés et qui accepte le même langage L.
AFND normalisé
L’algorithme de Thompson construit un AFND normalisé. Ce dernier est un cas spécial d’un AFND :
1. Il possède un seul état initial q0.
2. Il possède un seul état final qf ≠q0.
3. Aucune transition ne pointe sur l’état initial.
4. Aucune transition ne sorte de l’état final.
5. Tout état, est soit l’origine d’exactement une transition étiquetée par un symbole de l’alphabet, soit l’origine
d’au plus deux transitions, étiquetées par le mot vide ε.
L’algorithme de Thompson
L’algorithme est récursif : on décompose l’expression régulière en sous-expressions élémentaires

avec les opérations régulières, puis on applique récursivement le procédé suivant :
• Cas de base : automates pour ε, ∅ et a (a ∈ Σ)
• Induction : automate pour α + β

L’algorithme de Thompson
• Induction : automate pour α .β
• Induction : automate pour 𝛼 ∗

Exemple : (𝒂 + 𝒃)∗ abb
Avec 𝐴 = {0,1,2,4,7} 𝐵 = {1,2,3,4,6,7,8} 𝐶 = {1,2,4,5,6,7} 𝐷 = {1,2,4,5,6,7,9} 𝐸 = {1,2,4,5,6,7,10}

Algorithme de Glushkov
L’algorithme de Glushkov permet de trouver un automate non déterministe, mais avec un nombre d’états réduit plus réduit que l’algorithme
de thompson.
Etant donné une expression rationnelle e, on désire construire un automate reconnaissant le langage L(e) décrit par cette expression, en
mettant en œuvre l’algorithme de Glushkov.
• On associe à chaque occurence d’une lettre de l’expression rationnelle e un entier appelé sa position.
On obtient ainsi une expression rationnelle e’ sur l’alphabet ℕ\ {0} (linéarisation de l’expression e). On note αi la lettre en position i.
Exemple: (𝑎𝑏 + 𝑐)∗ 𝑎𝑏 est linéarisée en (12 + 3)∗ 45 . On a α1 = α4 = a, α2 = α5 = b et α3 = c.
• On définit un état pour chaque position i de l’expression, et on ajoute un état initial 0.
• On place une transition de i vers j étiquetée par αj si et seulement si la “lettre” j peut suivre la lettre i dans un mot du langage L(e′).
• On place une transition de 0 vers i si et seulement si la “lettre” i peut être la première lettre d’un mot du langage L(e′).
• L’état i (i > 0) est final si et seulement si i peut être la dernière “lettre” d’un mot du langage L(e′).
• L’état 0 est final si et seulement si le mot vide appartient à L(e′).
L’automate ainsi construit reconnaît le langage L(e) associé à l’expression initiale

Algorithme de Glushkov
L’automate de Glushkov de l’expression donnée en exemple possède 6 états. L’état 0 est initial, l’état 5 est seul état final. Sa table de
transition est la suivante :
De l’automate à l’expression rationnelle
Systèmes d’équations
Soit 𝐴 = (Σ, 𝑄, 𝑞0 , 𝐹, 𝛿) un automate. On définit les langages :

∀𝑞 ∈ 𝑄, 𝐿𝑞 = {𝑤 ∈ Σ ∗ , 𝛿 ∗ (𝑞, 𝑤) ∈ 𝐹}
cad. l’ensemble des mots qui sont acceptés « à partir de l’état q ».
On a alors le système d’équations (linéaires gauches)
Lq =(෍ 𝑎. 𝐿(𝛿 𝑞, 𝑎 )) ∀𝑞 ∈ 𝑄|𝐹

𝑎∈𝛴
Lq =(෍ 𝑎. 𝐿(𝛿 𝑞, 𝑎 )) + 𝜀 ∀𝑞 ∈ 𝐹
𝑎∈𝛴
De l’automate à l’expression rationnelle
Résolution: Lemme d’Arden
On peut résoudre un tel système grâce au résultat suivant :
Théoreme (Lemme d’Arden)
Une équation de la forme 𝐿 = 𝐴. 𝐿 + 𝐵 où 𝐴 ne contient pas le mot vide admet comme unique
solution l’expression rationnelle L = 𝐴∗ .B
Analyse syntaxique
Grammaires
Analyse syntaxique
Le rôle principal de l’analyse syntaxique est de vérifier si l’écriture du programme source conforme avec la
syntaxe du langage à compilé. Cette dernière est spécifiée à l’aide d’une grammaire hors contexte. Il existe
plusieurs méthodes d’analyse appartenant à l’une des deux catégories qui sont l’analyse descendante et
l’analyse ascendante. Dans l’analyse descendante nous essayons de dériver à partir de l’axiome de la
grammaire le programme source. D’une façon opposée, l’analyse ascendante établit des réductions sur les
chaines à analyser pour aboutir à l’axiome de la grammaire
Grammaires
Une grammaire permet une représentation finie d'un langage (éventuellement infini). Noam Chomsky a inventé la notion
de grammaire formelle.
Grammaire hors contexte (context-free)

Une grammaire hors contexte (ou grammaire algébrique, ou grammaire non contextuelle) est donnée par un quadruplet
𝐺 = (𝑇, 𝑁, 𝑆, 𝑅) où :
• 𝑇 est le vocabulaire terminal, c’est-à-dire l’alphabet sur lequel est défini le langage (les lexèmes produits par l’analyse lexicale).
• N est le vocabulaire non terminal, c’est-à-dire l’ensemble des symboles qui n’apparaissent pas dans les mots générés, mais qui sont
utilisés au cours de la génération. Un symbole non terminal désigne une “catégorie syntaxique”.
• R est un ensemble de règles dites de réécriture ou de production de la forme :
𝑢1 → 𝑢2, avec 𝑢1 ∈ 𝑁 𝑒𝑡 𝑢2 ∈ (𝑁 ∪ 𝑇)∗
• S ∈ N est le symbole de départ ou axiome. C’est à partir de ce symbole non terminal que l’on commencera la génération de mots
au moyen des règles de la grammaire.
Analyse syntaxique
Grammaire: Exemple1
– le vocabulaire est défini par l’ensemble : T = { le, la, fille, jouet, regarde }
– les catégories syntaxiques sont :
• la phrase, notée PH
• le groupe nominal, noté GN
• le verbe, noté V
• le déterminant, noté D
• le nom, noté N
– les règles permettant de combiner des éléments du vocabulaire et des catégories syntaxiques pour construire des catégories syntaxiques
sont les suivantes :
• PH → GN V GN N → fille
• GN → D N N → jouet
• D → le V → regarde
• D → la
où le symbole → est une abréviation de “peut être composé de”.
– la catégorie syntaxique de départ est la phrase PH.
La phrase “la fille regarde le jouet” est une phrase correcte pour la grammaire envisagée, comme le montre l’analyse suivante :
PH ⇒ GN V GN ⇒ D N V GN ⇒ la N V GN ⇒ la fille V GN ⇒ la fille regarde GN ⇒ la fille regarde D N ⇒ la fille regarde le N ⇒ la fille regarde
le jouet
où le symbole ⇒ est une abréviation de “se dérive en”.
Analyse syntaxique
Grammaire: Exemple2
On peut utiliser la grammaire GA suivante pour définir des expressions arithmétique :
• T = {int,(,), +, −, ×, /} ;
• N= {E} ;
• S=E;
𝐸 → 𝐸 + 𝐸
𝐸 → 𝐸 − 𝐸
𝐸 → 𝐸 × 𝐸
• R= 𝐸 → 𝐸/𝐸
𝐸 → (𝐸)
𝐸 → 𝑖𝑛𝑡
Grammaires
Dérivation : Extension des règles de production
Soient G = (T, N, S, P) une grammaire et αAβ une chaîne telle que :
• α ∈ (𝑁 ∪ 𝑇)∗
• β ∈ (𝑁 ∪ 𝑇)∗
• A∈N
• et A → γ une production de G
alors :
• αAβ se dérive selon G en αγβ
et on écrit :
• αAβ ⇒ αγβ ou plus simplement αAβ ⇒ αγβ

𝐺
Il est possible d’étendre la relation ⇒ en ∗ ⇒ pour représenter 0, 1 ou plusieurs pas de dérivation. Pour tout α ∈ (𝑁 ∪ 𝑇)∗ on écrit
∗
• α⇒α.
∗
• Si α ⇒ β et β ⇒ γ alors α ⇒ γ
Grammaires
Dérivation : Dérivation la plus à gauche, la plus à droite
Etant donné que plusieurs variables peuvent apparaître dans le corps d’une règle de production, il est possible d’imposer le choix de la
variable à remplacer. On peut ainsi imposer celle figurant le plus à gauche (respectivement le plus à droite).
Soit la grammaire suivante : Symboles terminaux : T = {a, b, 0, 1, +, ∗,(,)}. non terminaux : N = {E, I}. Symbole de départ E. Règles de
production P, telles que :
• E→I
• E→ E + E
• E→ E ∗ E
• E→ (E)
• I→ a
• I→ b
• I→ Ia
• I→ Ib
• I→ I0
• I→ I1
Dérivation la plus à gauche de : a ∗ (b + a0)
E ⇒ E ∗ E ⇒ I ∗ E ⇒ a ∗ E ⇒ a ∗ (E) ⇒ a ∗ (E + E) ⇒ a ∗ (I + E) ⇒ a ∗ (b + E) ⇒ a ∗ (b + I) ⇒ a ∗ (b + I0) ⇒ a ∗ (b + a0)
Dérivation la plus à droite de : a ∗ (b + a0)
E ⇒ E ∗ E ⇒ E ∗ (E) ⇒ E ∗ (E + E) ⇒ E ∗ (E + I) ⇒ E ∗ (E + I0) ⇒ E ∗ (E + a0) ⇒ E ∗ (I + a0) ⇒ E ∗ (b + a0) ⇒ I ∗ (b + a0)
⇒ a ∗ (b + a0)
Grammaires
Dérivation : Arbre de dérivation
Pour déterminer si une chaîne terminale appartient au langage engendré par une grammaire, on établit un arbre de
dérivation dont la racine est l’axiome, les feuilles sont des terminaux formant la chaîne donnée et les nœuds sont des
variables décrivant les règles utilisées.
Soit la grammaire suivante : Symboles terminaux : T = {a, b, 0, 1, +, ∗,(,)}. non terminaux : N = {E, I}. Symbole de départ E.
Règles de production P, telles que :
• E → I | E + E | E ∗ E | (E)
• I→ a | b | Ia | Ib |I0 | I1
La figure représente l’arbre de dérivation de l’expression : a∗(a+b00).
La dérivation la plus à gauche et la plus à droite fournissent le même arbre.
Analyse syntaxique
Langage défini par une grammaire
Étant donné des mots 𝑢 et v sur 𝑇 ∪ 𝑁 et une production A → w, on dit que 𝑢𝑤𝑣 peut être dérivé à partir de 𝑢𝐴𝑣, et on
note uAv →uwv . →+ désigne la fermeture transitive de →.
Une grammaire G défini un langage L(G) sur l’alphabet Σ dont les éléments sont les mots engendrés par dérivation à partir
du symbole de départ S :
L(G) := {w ∈ 𝑇 ∗ | S →+ w}
Le langage engendré par une grammaire G est l’ensemble des chaînes de terminaux que l’on peut dériver à partir de
l’axiome.
Remarques :
• - Une grammaire définit un seul langage.
• - Par contre, un même langage peut être engendré par plusieurs grammaires différentes
Analyse syntaxique
Exemple1 : 𝑖𝑛𝑡 + 𝑖𝑛𝑡 ∗ 𝑖𝑛𝑡 ∈ 𝐿(𝐺) comme le montre les dérivations suivantes :
• E → E + E → E + E ∗ E → int + E ∗ E → int + int ∗ E → int + int ∗ int
• E → E + E → int + E → int + E ∗ E → int + int ∗ E → int + int ∗ int
• E → E ∗ E → E + E ∗ E → int + E ∗ E → int + int ∗ E → int + int ∗ int
• L’arbre correspondant aux deux premières dérivations est le suivant :
• Celui correspondant à la dernière est :

Analyse syntaxique
Exemple2 : Soit la grammaire G suivante :

S → EXPR
EXPR → EXPR OP EXPR | ( EXPR ) | - EXPR | id
OP → + | - | * | /
La chaîne -(id+id) est engendrée par G car :
S →EXPR → - EXPR → -( EXPR ) → -( EXPR OP EXPR) → -(id OP EXPR) → -(id + EXPR) → -(id + id)
S ⇒* −(id +id)
Grammaires
Ambiguïté
Une grammaire G est ambiguë s’il existe une chaîne du langage L(G) qui possède plusieurs arbres de dérivation.
Exemple de grammaire ambiguë
La grammaire suivante : Symboles terminaux : Σ = {id, +, ∗,(,)}. Symboles non terminaux : N= {E}. Symbole de départ E.
Règles de production P, telles que :
E→E+E
E→E∗E
E → (E) | id est ambiguë.
La figure montre les deux arbres de dérivation possibles de l’expression : id ∗ id + id.

E ⇒ E ∗ E ⇒ E ∗ E + E ⇒ id ∗ E + E ⇒ id ∗ id + E ⇒ id ∗ id + id
E ⇒ E + E ⇒ E ∗ E + E ⇒ id ∗ E + E ⇒ id ∗ id + E ⇒ id ∗ id + id
Types de grammaires
En introduisant des critères plus ou moins restrictifs sur les règles de production, on obtient des classes de grammaires
hiérarchisées, ordonnées par inclusion. La classification des grammaires, définie en 1957 par Noam CHOMSKY 1 , distingue
les quatre classes suivantes :
Type 0
Pas de restriction sur les règles. Elles sont de la forme ;
α → β avec α ∈ (𝑁 ∪ 𝑇)+ et β ∈(𝑁 ∪ 𝑇)∗
Toute sous-chaîne de α peut être remplacée par une chaîne quelconque.
Type 1
Grammaires sensibles au contexte ou contextuelles (CSG). Les règles sont de la forme :
αAβ → αγβ avec A ∈ N ; α, β ∈ (𝑁 ∪ 𝑇)∗ et γ ∈ (𝑁 ∪ 𝑇)+ .
Autrement dit, le symbole non terminal A est remplacé par la forme γ de (V ∪ T)+ si les contextes α et β sont présents à
gauche et à droite.
Types de grammaires
Types de grammaires
Type 2
Grammaires hors-contexte (CFG).
Les règles sont de la forme : A → α avec A ∈ N et α ∈ (𝑁 ∪ 𝑇)∗ .
Autrement dit, le membre de gauche de chaque règle est constitué d’un seul symbole non terminal.
Type 3
Grammaires régulières à droite (respectivement à gauche).
Les règles sont de la forme : A → aB, (respectivement A → Ba) avec A, B ∈ N et a ∈ T. ou de la forme : A → a avec A ∈ N et a
∈ T. Autrement dit, le membre de gauche de chaque règle est constitué d’un seul symbole non terminal, et le membre de
droite est constitué d’un symbole terminal éventuellement suivi (respectivement précédé) d’un seul non terminal.
Types de grammaires
A chaque type de grammaire est associé un type de langage :
– les grammaires de type 3 génèrent les langages réguliers,
– les grammaires de type 2 génèrent les langages hors-contexte,
– les grammaires de type 1 génèrent les langages contextuels,
– les grammaires de type 0 permettent de générer tous les langages “décidables”, autrement dit, tous les langages qui
peuvent être reconnus en un temps fini par une machine. Les langages qui ne peuvent pas être générés par une
grammaire de type 0 sont dits “indécidables”.
Ces langages sont ordonnés par inclusion : l’ensemble des langages générés par les grammaires de type n est strictement
inclus dans celui des grammaires de type n − 1 (pour n ∈ {1, 2, 3}). Enfin, à chaque type de grammaire est associé un type
d’automate qui permet de reconnaître les langages de sa classe (c’est-à-dire de déterminer si un mot donné appartient au
langage) : les langages réguliers sont reconnus par des automates finis, les langages hors-contexte sont reconnus par des
automates à pile, et les autres langages, décrits par des grammaires de type 1 ou 0, sont reconnus par des machines de
Turing. Ainsi, la machine de Turing peut être considérée comme le modèle de machine le plus puissant qu’il soit, dans la
mesure où tout langage (ou plus généralement, tout problème) qui ne peut pas être traité par une machine de Turing, ne
pourra pas être traité par une autre machine.
Elimination de la récursivité a gauche
Récursivité gauche
∗
Un symbole non terminal A d'une grammaire est dit récursif si A→αAβ avec α, β ∈(X∪V)∗. Si α=ε, A est dit récursif (à)
gauche. Une grammaire comportant au moins un symbole non terminal récursif gauche est dite récursive gauche
La récursivité gauche pose divers problèmes en analyse, et dans l’application de certains algorithmes de transformation de
grammaire. C’est la raison pour laquelle on cherche à́ éliminer cette récursivité.
Règle simple
Au niveau d’une règle, cela peut se faire simplement :
A→Aα|β, devient : A→βA′
A′→αA′|ε
Généralisation
Pour chaque non terminal récursif, on propose :
𝐴 → 𝛽1𝐴′|𝛽2𝐴′|. . . |𝛽𝑘𝐴′
A→Aα1|Aα2|. . .|Aαm|β1|. . .|βk devient ቊ
𝐴′ → 𝛼1𝐴′|𝛼2𝐴′|. . . |𝛼𝑚𝐴′|𝜀
Factorisation a gauche
Factorisation a gauche
On peut appliquer la factorisation a gauche par:
• 𝐴 →α𝛽1 |α𝛽2 | … … . |α𝛽𝑛
• A->αA’
• A’->𝛽1 𝛽2 … |𝛽𝑛
Types d’analyse
Il existe deux grandes classes de techniques différentes pour construire un arbre syntaxique et vérifier si une chaîne
appartient au langage. L’analyse de la chaîne se fait toujours de la gauche vers la droite (Left scanning).
• L’approche descendante. Un analyseur gauche construit l’arbre de dérivation à partir de sa racine et en effectuant
des dérivations en considérant la tête des règles de production et en faisant des dérivations les plus à gauche. C’est
la famille des analyseurs LL (left scanning, leftmost derivation).
• L’approche ascendante. Un analyseur droit construit l’arbre de dérivation à partir de ses feuilles et en effectuant
des dérivations en considérant la partie droite des règles de production et en faisant des dérivations les plus à
droite. C’est la famille des analyseurs LR (left scanning, rightmost derivation).

Types d’analyse
Exemple d’analyse
Soit la grammaire G suivante :

T = {a, c, d} V = {S, T}
P={
S → aSbT
S → cT
S→d
T → aT
T → bS
T→c
}
Types d’analyse
Exemple d’analyse
Analyse LL
La dérivation permettant de construire l’arbre est la suivante :
S ⇒ aSbT ⇒ acT bT ⇒ accbT ⇒ accbbS ⇒ accbbaSbT ⇒ accbbadbT ⇒ accbbadbc
Analyse LR
Pour le même exemple une analyse ascendante donnerait :
accbbadbc ⇐ acT bbadbc ⇐ aSbbadbc ⇐ aSbbaSbc ⇐ aSbbaSbT ⇐ aSbbS ⇐ aSbT ⇐ S

Des fonctions pour l’analyse syntaxique
Soit 𝐺 = (𝑁, 𝑇, 𝑃, 𝑆) la grammaire hors-contexte qui décrit le langage source.
Soit 𝛼 ∈ (𝑁 ∪ 𝑇)∗ une forme sur G.
Pour achever son travail, l’analyse syntaxique nécessite un certain nombre de fonctions.
Définition Le prédicat ”Nullable”
∗
On dit qu’une forme α est nullable, et l’ on écrit Nullable(α) = true, si et seulement si α ⇒ ε.
Remarques
On peut calculer Le prédicat ”nullable” d’une manière récursive.
Règles de calcul du prédicat ”nullable”

 Nullable(ε) = true.
 ∀a ∈ T, Nullable(a) = false.
 Nullable(αβ) = Nullable(α) ∧ Nullable(β).
 Si X → α1 | α2 | ... | αk , alors Nullable(X) = Nullable(α1) ∨ Nullable(α2) ∨ ... ∨ Nullable(αk ).
Exemples
Soit la grammaire définie par les productions :
T → R | aTc
R → bR | ε
En appliquant les règles précédentes, on obtient un système d’ équations booléennes pour les nullables.
Le système d’équations booléennes définissant les nullables

• Nullable(T) = Nullable(R) ∨ Nullable(aTc).
• Nullable(R) = Nullable(bR) ∨ Nullable(ε).
• Nullable(ε) = true.
• Nullable(aTc) = Nullable(a) ∧ Nullable(T) ∧ Nullable(c).
• Nullable(bR) = Nullable(b) ∧ Nullable(R).
• Nullable(a) = false.
• Nullable(b) = false.
• Nullable(c) = false.
Résolution du système
• Nullable(R) = true.
• Nullable(T) = true.
• Nullable(ε) = true.
• Nullable(aTc) = false.
• Nullable(bR) = false.
Fonction FIRST (PREMIER)
Définition
 Soit α une forme sur G.
 On définit l’ensemble FIRST(α) comme étant l’ensemble des terminaux qui peuvent
apparaître au début d’une forme dérivable à partir de α.
∗
 Formellement, FIRST(α) = {a ∈ T | α⇒ aβ}.
Algorithme de calcul des ensembles FIRST

 FIRST(ε) = ∅.
 ∀a ∈ T, FIRST(a) = {a}.
 Si Nullable(α) = true, alors FIRST(αβ) = FIRST(α) ∪ FIRST(β).
 Si Nullable(α) = false, alors FIRST(αβ) = FIRST(α),
 Si X → α1 | α2 | ... | αk , alors FIRST(X) = FIRST(α1) ∪ FIRST(α2) ∪ ... ∪ FIRST(αk ).
Fonction FIRST (PREMIER)
Exemples
T → R | aTc
R → bR | ε
En appliquant les règles de l’algorithme précédent, on obtient un système d’équations qui vont aider à déterminer les
ensembles FIRST.
Le système d’équations obtenu
• FIRST(T) = FIRST(R) ∪ FIRST(aTc).
• FIRST(R) = FIRST(bR) ∪ FIRST(ε).
• FIRST(aTc) = FIRST(a).
• FIRST(bR) = FIRST(b).
• FIRST(a) = {a}.
• FIRST(b) = {b}.
• FIRST(ε) = ∅.
Résolution du système
• FIRST(aTc) = FIRST(a) = {a}.
• FIRST(bR) = FIRST(b) = {b}.
• FIRST(R) = {b}.
• FIRST(T) = {a, b}
Fonction FOLLOW (SUIVANT)
Définition
Soit X ∈ N un symbole variable de G.
On définit l’ensemble FOLLOW (X) comme étant l’ensemble des terminaux qui peuvent apparaître juste après
le symbole X dans une dérivation à partir de l’axiome S de G.
∗
Formellement, FOLLOW (X) = {a ∈ T | S⇒ αXaβ}.
Traitement des conditions de fin de chaîne

∗
• On a besoin de détecter si S ⇒ αX, c’est-à-dire, s’il existe des dérivations dans lesquelles le symbole ”X”
peut être suivi immédiatement par la fin de l’entrée.
• On ajoute une production supplémentaire à la grammaire de départ de la forme 𝑆 ′ → S$, où ”𝑆 ′ ” est un
nouveau symbole variable qui remplace l’axiome ”S”, et ’$’ est un nouveau symbol terminal qui représente
la fin de l’entrée.
• Par suite, dans la nouvelle grammaire -dite grammaire augmentée de G- le symbole ’$’ va être dans
∗ ∗
l’ensemble FOLLOW (X), si et seulement si 𝑆 ′ ⇒αX$, ce qui est le cas lorsque S ⇒ αX.
Règles pour le calcul des ensembles FOLLOW
 La façon la plus simple pour calculer les ensembles FOLLOW est de générer une collection de contraintes ensemblistes
qui seront résolues de proche en proche.
 Pour une production M → αVβ, on a les contraintes suivantes :
1. FIRST(β) ⊆ FOLLOW (V).
2. Si Nullable(β) = true, alors FOLLOW (M) ⊆ FOLLOW (V).
 Si la partie droite d’une production contient plusieurs occurrences de symboles variables, on ajoute des contraintes
pour toutes ces occurrences, en fractionnant la partie droite de la production en les différents α,V et β.
 Par exemple, la production A → BcB génèrera les deux contraintes:
1. {c} ⊆ FOLLOW (B), en fractionnant après le premier symbole B.
2. FOLLOW (A) ⊆ FOLLOW (B), en fractionnant après le dernier symbole B.

Algorithme de résolution des contraintes pour le calcul des FOLLOW
Au départ, on pose FOLLOW (X) := ∅, ∀X ∈ N.
Pour une contrainte ”FIRST(β) ⊆ FOLLOW (V)”, on calcule FIRST(β), puis on l’ajoute à FOLLOW (V).
Pour une contrainte de la forme ”FOLLOW (M) ⊆ FOLLOW (V)”, on calcule FOLLOW (M), puis on l’ajoute à FOLLOW (V).
On itère les deux dernières étapes jusqu’ à ce qu’aucun nouveau changement ne se produit.
Algorithme de calcul des ensembles FOLLOW
1. Obtenir la grammaire augmentée : on ajoute un nouveau symbole variable S’à N, un nouveau symbole terminal ’$’ à T,
et la règle ” S’ → S$” à P.
2. Pour chaque non-terminal N, trouver toutes les occurrences de N dans les parties droites des productions. Puis,
construire l’ensemble des contraintes qui donneront les ensembles FOLLOW.
3. Résoudre les contraintes obtenues.
Exemples
T → R | aTc
R → bR | ε
L’axiome étant le symbole T.
On ajoute T’ → T$ (grammaire augmentée).
On passe au calcul des contraintes.
Exemples (suite)
Contraintes donnant les ensembles FOLLLOW
Pour la règle T’→ T$ : FIRST($) ⊆ FOLLOW (T).
Pour la règle T → R : FOLLOW (T) ⊆ FOLLOW (R).
Pour la règle T → aTc : FIRST(c) ⊆ FOLLOW (T).
Pour la règle R → bR : rien à ajouter.
Pour la règle R → ε : rien à ajouter.
Résolution des contraintes
FOLLOW (T) = {c, $}.
FOLLOW (R) = {c, $}.
Analyse descendante
Exemple
𝑆 → aSbT|cT|d
ቊ avec le mot 𝑤 = 𝑎𝑐𝑐𝑏𝑏𝑎𝑑𝑏𝑐
𝑇 → 𝑎𝑇|𝑏𝑆|𝑐
On part avec l arbre contenant le seul sommet S La lecture de la première lettre du mot (a) nous permet
d’avancer la construction.
Analyse descendante
Table d’analyse LL(1)

Construction de la table d’analyse LL
Une table d’analyse est un tableau M a deux dimensions qui indique pour chaque symbole non-terminal A et chaque
symbole terminal a ou symbole $ la règle de production à appliquer.
1. Pour chaque production A𝛼
1. Pour tout a∈ 𝐹𝑖𝑟𝑠𝑡 𝛼 ( 𝑒𝑡 𝑎 ≢ 𝜀) rajouter la production A𝛼 dans la case M[A,a]
2. Si 𝜀 ∈ 𝐹𝑖𝑟𝑠𝑡 𝛼 alors pour chaque b ∈ 𝐹𝑜𝑙𝑙𝑜𝑤 𝐴 ajouter A𝛼 dans M[A,b]
2. Chaque case M[A,a] vide est une erreur de syntaxe
Analyse descendante
Exemple : Soit la grammaire suivante:
La table LL de la grammaire est:

Analyse descendante
Analyseur syntaxique
∗
Maintenant qu’ on a la table comment l’utiliser pour déterminer si un mot m donné est tel que S →m?
On utilise une pile.
Algorithme :
Données : mot m terminé par $, table d’analyse M
Initialisation de la pile et un pointeur ps sur la 1ère lettre de m
Analyse descendante
Sur l’exemple E, E’, T, T’, F, soit le mot 3+4*5
Analyse descendante
Si l’on essaye d’analyser maintenant le mot m=(7+3)5
Donc ce mot n’appartient pas au langage généré par cette grammaire

Analyse descendante
Grammaire LL(1)
L’algorithme précédent ne peut pas être appliqué a toutes les grammaires. En effet si la table d’analyse comporte des entrées multiples
plusieurs productions pour une même case M[A,a] on ne pourra pas faire une telle analyse descendante car on ne pourra pas savoir quelle
production appliquer.
Définition
On appel le grammaire 𝐿𝐿(1) une grammaire pour laquelle la table d’analyse décrite précédemment n’a aucune case définie de façon
multiple.
Par exemple, nous avons déjà vu la grammaire
Nous avons First(S)={a}, First(A)={c}, Follow(S)={$}, Follow(A)={b}, ce qui donne la table d’analyse.
Il y a deux réductions pour la case M[A,c] donc ce n est pas une grammaire LL(1). On ne peut pas utiliser cette méthode d analyse. En effet
on l’a déjà remarqué, pour pouvoir choisir entre la production A cd et la production Ac il faut lire la lettre qui suit celle que l’on pointe.

THEORIE DES LANGAGES ET COMPILATION (Cours2) V5

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

THEORIE DES LANGAGES ET COMPILATION (Cours2) V5

Transféré par

Droits d'auteur :

Formats disponibles

Langages et expressions rationnels

Opérations sur les langages

• Union ∶ Tous les éléments de deux ensembles

• Elément neutre : ensemble vide ∅

• Notée + dans la théorie des langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

Opérations sur les langages

• 𝐿1 ◦𝐿2 = 𝐿1 . 𝐿2 = 𝐿1 𝐿2 = {b, ba, ab, aba, abb, abba}

Opérations sur les langages

EXEMPLE: soit L = {a, ab, ba, ac},

• 𝐿𝑖 = LL...L, la concaténation de i fois L

Opérations sur les langages

∀𝐿1 , 𝐿2 , 𝐿3 ⊆ 𝑿∗ 𝐿1 .(𝐿2 ∪ 𝐿3 ) = (𝐿1 . 𝐿2 ) ∪ (𝐿1 . 𝐿3 )

(𝐿2 ∪ 𝐿3 ). 𝐿1 = (𝐿2 . 𝐿1 ) ∪ (𝐿3 . 𝐿1 )

• Ce théorème reste vrai pour des unions infinies

• Attention ! : Le produit de langages n’est pas distributif par rapport à l’intersection.

∀𝐿1 , 𝐿2 , 𝐿3 ⊆ 𝑿∗ , 𝐿1 .(𝐿2 ∩ 𝐿3 ) ⊆ (𝐿1 . 𝐿3 ) ∩ (𝐿1 . 𝐿3 )

• 𝐿𝑛+𝑚 = 𝐿𝑛 𝐿𝑚 et (𝐿𝑚 )𝑛 = 𝐿𝑚𝑛

Opérations sur les langages

Opérations sur les langages

Soit L ⊆ X ∗ . On note 𝐿+ =⋃∞ 𝑖

Opérations sur les langages

Opérations sur les langages

Soit 𝐿1 ,𝐿2 ⊆ X ∗ . On a (𝐿1 .𝐿2 )𝑅 = 𝐿2 𝑅 𝐿1 𝑅

• 𝐿෫1 ∪𝐿2 =𝐿1 ∪ 𝐿2

• La réunion exprime le choix.

• La concaténation exprime la séquence.

• La fermeture de Kleene exprime la répétition ´ .

• La fermeture de Kleene positive exprime la répétition non nulle.

Il est clair que 𝐿 = 𝐿1 𝐿2 𝐿3 , où 𝐿1 = 𝑎, 𝑏 , 𝐿2 = {𝑐𝑐}∗ 𝑒𝑡 𝐿3 = {𝑏}+ .

Finalement, 𝐿 = 𝑎, 𝑏 ({𝑐𝑐}∗ ) {𝑏}+ , qui sera simplifié (a|b) (𝑐𝑐)∗ 𝑏+

1. ∅ ∈ L et {𝜀} ∈ 𝐿 sont régulières

2. ∀a ∈ Σ, {a} ∈ L le langage {a} est régulier

Si 𝐸 est une expression régulière on notera 𝐿(𝐸) le langage engendré par 𝐸.

1. ∅ et 𝜀 sont des expressions régulières

2. ∀ a ∈ Σ, a est une expression régulière

3. Si 𝛼 𝑒𝑡 𝛽 sont des expressions régulières alors

Langage représenté par une expression régulière

𝐿(∅) = ∅, L(𝜀) = {𝜀}

L(α ,β) = L(α) ∪ L(β) = L(α) + L(β)

Le langage 𝐿(𝑀) engendré par l’automate 𝑀 suivant est un langage régulier.

𝐿(𝑀) = (𝑎 + 𝑏)∗ 𝑎(𝑎 + 𝑏)∗

Egalité d’expressions régulières

Propriétés des expressions régulières • (r.s).t = r.(s.t) = r.s.t

Soient r, s et t trois expressions régulières sur le même • r.(s + t) = rs + rt

1. l’operateur de fermeture ‘*’ a la plus haute priorité.

2. l’operateur de concaténation à la deuxième plus haute priorité.

3. l’operateur de réunion ‘ | ‘a la plus faible priorité.

• DEC → (0|1|...|9) + (ε|. (0|1|...|9) + )

• DEC → 𝐶ℎ𝑖𝑓𝑓𝑟𝑒 + (ε |. 𝐶ℎ𝑖𝑓𝑓𝑟𝑒 + )

Autres constructions obtenues à partir des précédentes

• [^abc] désigne le complémentaire de {a,b,c} dans Σ

• . pour Σ (n’importe quel caractère )

• a? est une abréviation de a|ε

• Le rôle d'un analyseur lexical est la reconnaissance des unités lexicales.