You are on page 1of 53

Support de Cours Thorie des Langages et des Automates

Prpar par Moez Hammami


Chapitre I Alphabet et langages .............................................................................................. 3
I.1 Dfinition: Alphabet ......................................................................................................... 3
I.2 Dfinition: Mot ................................................................................................................. 3
I.3 Oprations sur les mots ..................................................................................................... 3
I.4 Dfinition: Langage. ......................................................................................................... 4
Chapitre II Reprsentation finie des langages......................................................................... 6
II.1 Dfinition: Langages formels ........................................................................................ 6
II.2 Expressions rgulires .................................................................................................... 6
II.2.1 Exemples Introductifs.............................................................................................. 6
II.2.2 Dfinition d'une expression rgulire ...................................................................... 7
II.3 Langages rguliers ........................................................................................................... 8
II.3.1

Thorme (Langages rguliers) ............................................................................. 8

II.3.2

Proprits des langages rguliers........................................................................... 8

II.4 Exercices.......................................................................................................................... 9
Chapitre III

Automates tats finis...................................................................................... 10

III.1 Introduction ................................................................................................................. 10


III.2 Dfinition d'un automate l'tat fini dterministe ...................................................... 10
III.3 Fonctionnement d'un automate tat fini .................................................................... 12
III.3.1 Dfinition d'une configuration .............................................................................. 12
III.3.2 Dfinition d'un langage connu par un automate.................................................... 13
III.4 Reprsentation graphique d'un automate tats fini.................................................... 14
III.5 Exemples de DFA ........................................................................................................ 14
III.6 Automate tat fini complet ....................................................................................... 16
III.7 Automates finis non dterministes (NFA) ................................................................... 17
III.8 Algorithmes de conversion........................................................................................... 18
III.8.1 Algorithme de dterminisation ou transformation NFADFA ........................... 18
III.8.2 Algorithme de transformation d'une expression rgulire en un NFA.................. 20
III.8.3 Automate dterministe minimal ............................................................................ 23
III.9 Simulation d'un Automate tats finis non dterministe............................................. 27
III.10 Lemme de pompage ................................................................................................... 28
Chapitre IV

Les langages contexte libre (Context Free Languages).................................. 30

IV.1 Introduction par un exemple ........................................................................................ 30


IV.2 Dfinition d'une Grammaire hors contexte .................................................................. 31
IV.3 Dfinition d'une Drivation.......................................................................................... 31
IV.3.1 Drivation gauche ................................................................................................. 31
IV.3.2 Drivation droite ................................................................................................... 32
IV.4 Arbre syntaxique (Parse Tree) ..................................................................................... 33
IV.5 Grammaires ambigus.................................................................................................. 34
IV.6 Exemples de grammaires ............................................................................................. 35
IV.7 Classification de chomsky ........................................................................................... 37
IV.7.1 Grammaires contextuelles context-sensitive ou de type 1(CG)...................... 37
IV. 7.2 Grammaires non contextuelles context-free ou de type 2 (CFG) ................. 38
IV. 7.3 Grammaires Rgulires ou de type3 :RG ........................................................... 38
IV.8 Classification des langages formels ............................................................................. 39
IV.9 Transformation d'une grammaire rgulire droites en NFA .................................... 39
IV.10 Transformation d'un DFA en grammaire rgulire.................................................... 40
Chapitre V Automates pile (Push Down Automaton, PDA)................................................. 42
V.1 Introduction ................................................................................................................... 42
V.2 Dfinition d'un automate pile ..................................................................................... 43
V.3 Dfinition d'une transition ............................................................................................. 44
V.4 Langages reconnus par un PDA .................................................................................... 44
V.5 Dfinition: langage reconnu par un automate pile vide.............................................. 45
V.6 Dterminisme ............................................................................................................... 47
V.7 Transformation d'une grammaire hors contexte en PDA .............................................. 49
V.8 Proprits de clture ...................................................................................................... 50
V.11 Clture des langages hors contexte (intersection et complmentation) ...................... 52
Bibliographie............................................................................................................................ 52

Chapitre I Alphabet et langages

I.1 Dfinition: Alphabet


L'alphabet est un ensemble fini de symboles, not en gnral par
Exemple 1: l'alphabet latin ={a,b,c,z}
Exemple 2: l'alphabet binaire ={0,1}
Exemple 3: ={rouge, noir, 0,1,A}

I.2 Dfinition: Mot


Un mot ou une chane est une squence de symboles pris de l'alphabet.
Exemple 1: 1= voiture, 2= voyage sont deux mots dfinis sur {a,b,c,z}
Exemple 2: 1=00101 ,2=101101 sont deux mots dfinis sur {0,1}
Exemple 3: 1=rouge0noir ,2=10Arouge sont deux mots dfinis sur {rouge ,noir, 0,1,A}
La taille d'un mot note || est le nombre de symboles constituant le mot
Exemple 1: |voiture|=7 en considrant l'alphabet {a,b,c,z}
Exemple 2: |00101|=5 en considrant l'alphabet {0,1}
Exemple 3: |rouge0noir|=3 en considrant l'alphabet {rouge ,noir, 0,1,A}
la chane vide note est une chane de taille nulle : | | = 0.
Sous chane: x est une sous chane de ssi y, z

(chanes sur l'alphabet) tq = yxz.

Prfixe: x est un prfixe de ssi y tq =xy


Suffixe: x est un suffixe de ssi y tq =yx
Exemple x=voi est un prfixe de voiture car y= ture tq =voiture
x=ture est un suffixe de voiture car y=voi tq =voiture

Facteur: soient u, v, , t des mots dfinis sur tq =uvt


si u= alors v est dit facteur gauche de (ou prfixe)
si t= alors v est dit facteur droit (ou suffixe)
si u=t= alors =v est donc un facteur de lui mme

I.3 Oprations sur les mots


Concatnation: soient u, v deux mots dfinis sur , tq u=xx2..xn , v= yy2..yn.

la chane concatnation de u et v note =u.v = uv = xx2..xnyy2..yn.


Remarque: la concatnation est non commutative
Proprits: ||=|uv|=|u|+|v|
la concatnation est associative :xyz=(xy)z=x(yz).
est l'lment neutre pour la concatnation.
Occurrence d'un symbole dans un mot: c'est le nombre d'apparition du symbole dans le
mot.
Exemple:
|abbba|b=3
|abbab|b=3
Image (reverse): =aabab

R=babaa

Exercice
Montrer par rcurrence que (u)R=uR.R k tq |u|=k

Preuve
Base: k=0, (x)R=()R=R= R= xR.R
Hypothse: on suppose que (x)R=xR.R 0<=k<=n , avec|x|=k
Rcurrence: on veut dmontrer que (x)R=xR.R avec |x|=n+1
|x|=n+1 x=u.a avec |u|=n et a
(x)R=(ua)R=a.(u)R=a.uR.R=(ua)R.R=xR.R
Donc l'hypothse est vraie, c'est ce qu'il faut dmontrer.

I.4 Dfinition: Langage.


Un langage est un ensemble de mots
*={squence de taille finie dfinie sur }= fermeture de l'alphabet
C'est l'ensemble de toutes les squences de tailles finies dfinies sur
Exemple: ={a,b} => *={, a, b, ab, ba, aa, bb, aaa, bbb, abb, ...}
Dfinition: un langage est un ensemble de mots appartenant * et qui vrifient une
proprit donne => L={ *; a la proprit P}
Exemple: ={a,b}
L={ *, ||a=||b}

L={ , ab, ba, aabb, baba, ..}


l'ensemble des palindromes est dfini par
L2={ * , =R }
L2={, aba , bab, a,b,}
Proprits:
* est infinie est dnombrable
L=L1 L2={ * tq L1 ou L2}
L=L1 L2={ * tq L1 et L2 }
Concatnation: L=L1L2=L1L2={ * tq x, y tq = xy avec x L1 et y L2}
Fermeture de Kleene :
L*={ * :=12.. pour k0 et 1,2,, L}
C'est dire que si L est un langage (ensemble de mots) alors L* dsigne l'ensemble de toutes
les chanes de longueur finies formes par concatnation de mots de L, o chaque mot peut
tre utilis de 0 n fois, et o la chane vide est aussi incluse.
Exemple
L={aa,b}
L*={, b, aa,bb,aab,baa,bbb,aaaa,aabb,baab,bbaa,bbbb,aaaab,aabaa,aabbb,baaaa,bbaab,bbbaa,
bbbbb,...}
Remarque:
*= {}
* est la rptition de 0 ou plusieurs fois de
Exercice:
soit = {0,1}
L = { *: contient #0 #1 }
Montrez que L* = *
L* * par dfinition
on a L * L*
1 et 2 L* = *

Chapitre II Reprsentation finie des langages

II.1 Dfinition: Langages formels


C'est tout sous ensemble de
conformment :

* dont les mots peuvent tre dfinis de deux faons

Dfinition par proprit: il s'agit d'une modlisation formelle d'une description naturelle
d'un langage.
Exemple L1 = {ensemble des mots dfinis sur {a,b} de longueur paire}
L1 = { {a,b}* / || = 2n avec n 0}
Dfinition rcursive : Dfinition dans laquelle, un langage est dfini sur lui mme.
Exemple:
L2 = { * / = a ou = a1 ; 1L2} = {a,aa,..,aaaa,...}
L3= { * / = ou = 12 avec |1|= 2 et L3}
L3 L1

II.2 Expressions rgulires


II.2.1 Exemples Introductifs
Considrons le langage suivant:
L4 = { , x, xx, xxx, xxxx,...}
Jusque l, on prsente cet ensemble comme tant la fermeture d'un autre ensemble plus petit,
soit S = {x}
alors L4 = S*
On aurait pu crire d'une faon plus courte
L4 = {x}*
On reprsente maintenant l'toile de fermeture de Kleene applique non pas l'ensemble mais
directement la lettre x.
La simple expression x* va tre utilise pour indiquer une squence quelconque qui peut tre
vide de x. x* = ou x ou xx ou xxx...
Donc on peut dire que L4 = langage (x*) puisque x* est n'importe quelle chane de x alors L4
est l'ensemble de toutes les chanes possibles de x (incluant )
Soit maintenant le langage L = { a, ab, abb, abbb, abbbb...}, on peut rsumer ce langage en
franais par " tous les mots de la forme : un a suivi par un nombre quelconque de b".
On peut noter L = langage (ab*). La signification est claire: c'est un langage dans lequel les
mots sont la concatnation d'un a initial avec un nombre quelconque de b (b*). On peut
appliquer l'toile de Kleene toute la chane ab si on veut, comme suit :
(ab)* = ou ab ou abab ou ababab...
6

Remarque: Les parenthses ne sont pas des lettres de l'alphabet de ce langage, alors elles
peuvent tre utilises pour indiquer la factorisation sans accidentellement changer les mots.
Le langage dfini par l'expression ab*a est l'ensemble de toutes les chanes de a et de b qui
ont au moins 2 lettres, qui commencent et finissent par a et qui n'ont que des b ou rien
l'intrieur.
Langage (ab*a) = {aa, aba, abba, abbba, abbbba,...}
Remarque: il serait faux de dire que notre langage est l'ensemble de tous les mots qui
commencent et qui finissent par a et qui n'ont que des b (ou rien) entre eux, car cette
description peut tre aussi applique au mot a. Notre symbolisme limine cette ambigut.
Exemple: Le langage de l'expression a*b* contient toutes les chanes de a et de b dans
lesquelles tous les a's viennent avant tous les b's.
Language (a*b*) = {, a, b, aa, ab, bb, aaa, aab, abb, bbb,...}
Remarque: Il est noter que ba et aba n'appartiennent pas ce langage et on n'a pas besoin
du mme nombre de a et de b. On observe aussi que a*b* (ab)*
Puisque le langage droite contient abab tandisque celui gauche ne le contient pas.
Exemple: soit le langage T dfini sur l'alphabet = {a,b,c}
T = {a, c, ab, cb, abb, cbb, abbb, cbbb, abbbb, cbbbb...}
tous les mots de T commencent avec un a ou un c ensuite, ils sont suivis par un nombre
quelconque eventuellement nulle de b. symboliquement on peut crire :
T = langage ((ac) b*)
= langage (soit a ou c ensuite quelque b)
Exemple: soit L l'ensemble qui contient touts les chanes de a et de b de longueur 3
exactement.
L = {aaa, aab, aba, abb, baa, bab, bba, bbb}
L = langage ((a b) (a b) (a b)) alors si on veut reprsenter L', le langage qui contient
toutes les chanes de a et de b de n'importe quel longueur L = (a b)*
II.2.2 Dfinition d'une expression rgulire
Une expression rgulire sur un alphabet est une chane de caractres sur l'alphabet
{(,),,*, , } tel que:
toute lettre de {, } est une expression rgulire
si r1 et r2 sont deux expressions rgulires alors
(r1) est une expression rgulire
r1r2 est une expression rgulire
r1r2 est une expression rgulire
r1* est une expression rgulire
rien d'autre n'est expression rgulire

Exemple: soit ={a,b}


L = {*, contient la sous chane aa}
= aa
aaa
...........................................aa......................................
n'importe quelle chane de
a et de b

n'importe quelle chane de


a et de b

R = (a b)* aa (a b)*
Exemple: soit ={a,b}
L = {*, ne contient pas 3b conscutifs}
R = (a ba bba)* ( b bb)

II.3 Langages rguliers


II.3.1

Thorme (Langages rguliers)

Un langage L est dit rgulier si et seulement s'il existe une expression rgulire qui le gnre.

II.3.2

Proprits des langages rguliers

Etant donn deux langages rguliers L1 et L2


P1) L1 L2: dfinit un langage rgulier
P2) L1.L2 est un langage rgulier
P3) L1* est un langage rgulier
_

P4) L1 est un langage rgulier


_____
_
_

P5) L1 L2 = L 1 L 2

est un langage rgulier

Dfinition Deux expressions rgulires et sont dites quivalentes ssi L() = L()
Exemple: a = a
a. =
* = {}
Exemple: Le langage de tous les mots qui ont au moins 2 a's peut tre dcrit par l'expression
(ab)*a(ab)*a(ab)*
(quelque a et b au dbut) (le premier a) (quelque a et b au milieu) (le deuxime a ) (quelque a et b la fin)

une autre expression peut dnoter le mme langage


b*ab*a(a b)*
8

On passe par un nombre arbitraire (ventuellement nulle de b) jusqu' ce qu'on trouve le


premier a, ensuite encore des b's, ensuite le deuxime a, ensuite on termine par une suite
quelconque de a et b.
On peut noter: (ab)*a(ab)*a(ab)* = b*ab*a(a b)*

II.4 Exercices
Exercice 1: Donner les expressions rgulires qui gnrent les langages suivants:
L1 = {
{a,b}*, tel que contient exactement bbb}
L2 = {
{a,b}*, tel que contient la sous chane bbb}
L3 = {
{a,b}*, tel que contient seulement 3b, le reste c'est des a's}
L4 = {
{a,b}*, tel que contient un nombre de a divisible par 3}
L5 = {
{a,b}*, tel que contient un nombre paire de a}
L6= {{
{a,b}*, tel que ne contient pas 3b Conscultifs}
L6 = {{a,b}*, tel que contient un nombre impaire de b}
L7 = {{a,b}*, tel que contient la sous chane aaa ou la sous chane bbb mais pas les
deux en mme temps}
avec:

Chapitre III

Automates tats finis

III.1 Introduction
Un reconnaisseur pour un programme est un programme qui prend en entre une chane x et
rpond OUI si x est une chane du programme et NON dans le cas contraire.On compile une
expression rgulire en un reconnaisseur en construisant un diagramme de transitions
gnralis appel automate fini. Un automate fini peut tre dterministe ou non-dterministe
(c..d. qu'on peut trouver plus d'une transition sortant d'un tat sur le mme symbole d'entre).

III.2 Dfinition d'un automate l'tat fini dterministe


Un automate tat fini dterministe (DFA) est un modle mathmatique M(k,,,s,F):
tel que:
k: l'ensemble des tats de l'automate
: l'alphabet des symboles d'entre
: une fonction de transition qui fait correspondre des couples tat-symbole des tats.
s: est un tat qui est distingu comme un tat de dpart ou tat initial.
F: un ensemble d'tats distingus comme tats d'acceptation, ou tats finaux.
Remarque:
: fonction : K x K ; (q,a) =p: Transition de q p en lisant (reconnaissant ) le symbole a.
Exemple 1:
:

(b)

soient ={b, }

q1

q2

q4

K={q1, q2, q3, q4}

q2

q3

q2

F={q3}

q3

q4

q4

S={q1}

q4

q4

q4

Cet automate peut tre reprsent comme suit:

b
q1

q2

q4

b,

q3

b,

10

()

Remarque:
Un automate tats fini peut tre considr comme un mcanisme de calcul sans mmoire.
Mot connu par un automate:
Formellement, on dfinit la fonction *(e, u) qui nous dit dans quel tat on arrive en partant
de l'tat e et on analysant la chane u.
-si u est la chane vide

*(e, )=e

-si u commence par le symbole t suivi de la sous-chane :


*=(e, t)=*((e,t),)
une chane u est accepte par l'automate M dont l'tat initial est q0 si *(q0, u) appartient aux
tat finaux de M.
Exemple 2:
Soit l'automate M de l'exemple 1
Est ce que est reconnu par l'automate?
*(q1, )=q1 F donc n'est pas reconnu par M
tat initial
Est ce que 1 =bb est reconnue par l'automate ?
*=(q1,b b)=*((q1, b),b)
= *( q2,b)
= *((q2,),b)
= *(q2,b)
= *((q2,), b)
= *(q2, b)
= *((q2,b), )
= *(q3,)
=q3 F donc = bb est reconnu par M.
Est ce que 2= bb est reconnu par l'automate?
*(q1, bb)=*((q1, ), bb)
= *( q4, bb)
= *((q4,b),b)
= *(q4,b)
= *((q4,), b)
= *(q4, b)
=* ((q4,b),)
=*(q4,)=q4 F donc 2=bb n'est pas reconnu par M
11

III.3 Fonctionnement d'un automate tat fini


III.3.1 Dfinition d'une configuration
Une configuration est un triplet(x,q,v) avec x, v * et q K o:
x: dsigne la sous-chane du mot dj traite
q: est l'tat courant
v: dsigne la sous chane du mot restante traiter
Remarque: le mot est xv
Exemple:
*=(q1,bb)=*(q2,b) car (q1,b)=q2
La configuration

(b, q2, b )

dj lu
Remarque:

tat courant restant lire

gnralement on travaille avec seulement l'tat courant, et le restant lire:


=(q, v)

tat courant

restant lire

Configuration successeur:
Soit (x, q, v)
(x', q , v') est une configuration successeur de i
ssi
- pour v= , j=i on dit que i n'a pas de configuration successeur
-pour v=av"
x'=xa
qj=(qi,a)
v'=v"
configuration initiale:
note 0=(, q0,) avec q0: tat initial;
: le mot reconnatre
Configuration initiale d'acceptation:
f=(, qF, ) avec qF F;

est le mot reconnatre .

Configuration finale de non acceptation: f = (,qF,) avec qF F


12

Configuration successeur aprs n transitions


Notation:
n

'
M

' est la configuration successeur de aprs n tapes de transition


ssi
-'= pour n=0
" et '' n-1 '

- " /

pour n0

Notation:
configuration successive d'un nombre
quelconque d'tats de transition
*

ssi k tq

'

'
M

III.3.2 Dfinition d'un langage connu par un automate


Notation L(M)
Soit M: Automate a tat fini { , K, q0, , F}
Le langage connu(accept) par M est not L(M) est l'ensemble
L(A)={ */(, q0, )

(, qF, ) avec qF F}

Exemple:
M=( K, , , s, F) avec ={a, b}
K={q0, q1}
s=q0;F={q0}

q0

q0

q1

q1

q1

q0

(q0,ababa) (q0,baba)
(q1,aba)
(q1,ba)
(q0,a)
(q0,)

13

q0 est un tat d'acceptation = ababa est accept par M.


(q0, aba) (q0,ba) (q1, a) (q1, )
q1 F 1 = aba n'est pas accept.

III.4 Reprsentation graphique d'un automate tats fini

tat

a
transition sur le symbole a

q0

qF

tat initial
tat final ou d'acceptation

Remarque
un automate tats fini dterministe (DFA) est un cas particulier d'automate tats fini dans
lequel:
Aucun tat n'a de -transition, c'est dire de transition sur l'entre et
Pour chaque tat q et chaque symbole d'entre a, il y'a au plus un arc tiquet a qui quitte q

III.5 Exemples de DFA


L(M) = { {a,b}*: contient un nombre pair de b} (a*ba*ba*)*
b
a

q1

q0
b

remarque: q0 est la fois tat initial et


tat final

a
b
q0

L = * = (ab)* = (a*b*)*
a

14

L = { {a,b}* / ne contient pas la sous chane bbb}


R = (ababba)* (bbb)
a

a,b
b

q0

q1

q2

q3
tat mort

a
a

L = {{a,b}*, = bbb} = {bbb}


b
b
b
q0
q1
q2
a a
a
a

q3

q4
a,b

L= {{a,b}*, contient un nombre pair de a et un nombre paire de b}


a paire,
b paire

q0
b

a impaire,
b paire

b
q3

a paire,
b impaire

q1

a
b
a

remarque: Il suffit de changer la place de


l'tat d'acceptation pour obtenir:
a impaire, b paire: q1

a impaire, b impaire: q2
a paire, b impaire: q3

q2
a impaire,
b impaire

={0,1,2,3,4,5,6,7,8,9}
L = { *: divisible par 3} : la somme des chiffres est divisible par 3

15

0,3,6,9

q0

chiffre mod 3 = 0 :{0,3,6,8}

,7

1,4,7

1,4,7

1,4

2,5,8

0,3,6,9

Remarque: On part de l'ide

q2

,8
2,5

chiffre mod 3 = 1 :{1,4,7}


chiffre mod 3 = 2 :{2,5,8}

q3

2,5,8

0,3,6,9

L= {{a,b}*, contient (3k+1)b; k 0}


a
q1
b

b
a
q2

q0
a

III.6 Automate tat fini complet


Un automate tats fini dterministe est complet si et seulement si est une fonction totale
sur Q x .
C'est dire de chaque tat, il part exactement une flche tiquete par chacune des lettres de
l'alphabet .
Exemple:
C = (,Q, , q0,F)
= {0,1}
Q = {q0,q1,q2}
= {(q0,0,q1), (q0,1,q0), (q1,0,q2), (q1,1,q2), (q2,0,q2), (q2,1,q2)}
q0 est l'tat initial
F = {q1}
16

0,1
1

q2

q0

0,1
q1

C accepte les mots du langage L(C) dcrit par: 1*0

III.7 Automates finis non dterministes (NFA)


Un automate fini non dterministe est un modle Mathmatique qui consiste en (K, , , S, F)
K : ensemble des tats
: Alphabet
: relation de transition
S : tat initial
F : ensemble des tats finaux
Le mme caractre peut tiqueter deux transitions ou plus en sortie dun mme tat et les arcs
peuvent- tre tiquets par .
Exemple : la figure suivante reprsente le graphe de transition pour un NFA qui reconnat le
langage (ab)* abb

a
q0

q1

q2

q3

b
On voit bien qu'en sortie de ltat 0, on a deux arcs tiquets a.
Remarque 1 : Dans un automate fini non dterministe (NFA) il peut y avoir le choix entre
plusieurs chemins lors de la lecture dun mot.
Pour quun mot soit accept, il suffit que ses lettres tiquettent un chemin dun tat initial un
tat final (mme sil yen a dautres ne menant pas un tat final, ou bien sarrtant en cours
de route)
Remarque 2 : un DFA est un NFA particulier

NFA DFA

17

III.8 Algorithmes de conversion


III.8.1 Algorithme de dterminisation ou transformation NFA
DFA
Thorme : Pour chaque automate fini non dterministe correspond un automate fini
dterministe qui lui est quivalent.
Ou
Si un langage est reconnu par un automate, alors il est galement reconnu par un automate
fini dterministe.
Algorithme NFA
DFA
Soit A= (K, , , q0, F,) un NFA, on construit lautomate B= (K, , , q0, F), Ksera alors
un sous ensemble de P(K) lensemble des parties de K.

q0 {q0} {q K tel que (q0,,q) } (-fermeture(q0))


KK q0
pour tout q K non encore considr faire
Pour tout a faire
q " {y K tel que x q' tq (x,,y) } (Transiter(q',a))
Si q " alors
q " {q"} {z K tel que y q" tq (y,,z) } (-fermeture(q"))
{(q, a, q")}
KK {q"}
F {q tel que qF}
Exercice : Construire le DFA pour le NFA suivant.

2
0

6
4

10

Dans lalgorithme de dtermination


-fermeture (q) : Ensemble des tats de lNFA accessibles depuis un tat q de lNFA par des
-Transitions uniquement (sous lecture).
- fermeture (T) : Ensemble des tats de lNFA accessibles depuis un tat qT
18

Transiter(T,a): Ensemble des tats de l'NFA vers lequel il existe une transition sur le symbole
a partir d'un tat q T.
Dans lexemple:
- fermeture (0) = {0, 1, 2, 4,7}
Transiter({0,1,2,4,7},a} = {3,8}
- fermeture ({3,8})= {1, 2, 3, 4, 6, 7,8}
Avant de voir le premier symbole dentre, N peut appartenir nimporte lesquels des tats de
lensemble -fermeture(0) ou 0 est ltat de dpart de N donc il peut-tre dans T={0,1,2,4,7}
cest ltat de dpart du DFA.
Supposons que a est le prochain symbole dentre. Quand il voit a, N peut passer dans lun
des tats de lensemble Transiter (T, a)=Transiter ({0, 1, 2, 4,7}, a)= {3,8}
Quand on autorise des -transitions, N peut-tre dans lun des
fermeture(Transiter(T,a)), aprs avoir lu le a, -fermeture({3,8})={1,2,3,4,6,7,8}

tats

Appliquons lalgorithme sur notre exemple


Etat de dpart= - fermeture (0)=A= {0, 1, 2, 4,7}
Lalphabet des symboles dentre est ici {a, b}. Donc on marque A comme considr et on
calcule -fermeture (Transiter(A,a))= -fermeture({3,8})={1,2,3,4,6,7,8}=B
Dtran[A,a]=B.

On fait la mme chose avec b, -fermeture (Transiter(A,b))=-fermeture ({5})={1,2,4,5,6,7}


Dtran (A,b)=C={1 ,2 ,4 ,5 ,6 ,7}.

Nous continuons ce processus avec les ensembles actuellement non marqus B et C on atteint
finalement le point ou tous les ensembles qui sont des tats du DFA sont marqus.
Les cinq diffrents ensembles que nous construisons rellement sont :
A= {0, 1, 2, 4,7}
B= {1, 2, 3, 4, 6, 7,8}
C= {1, 2, 4, 5,6 ,7}
D= {1, 2, 4, 5, 6, 7,9}
E= {1, 2, 4, 5, 6, 7,10}
Ltat A est ltat de dpart et ltat E est lunique tat dacceptation car il contient un tat
dacceptation du NFA (10)

19

Voici la table de transition :


Etat

Symbole dentre
a

b
B

a
A

III.8.2 Algorithme de transformation d'une expression rgulire en un NFA


Lalgorithme est dirig par la syntaxe, car il utilise larbre syntaxique dcrivant lexpression
rgulire pour guider le processus de construction.
Algorithme
Construction dun NFA partir dune expression rgulire, ou construction de Thompson
Donne : une expression rgulire sur un alphabet
Rsultat: un NFA de N qui reconnat L(r)
Mthode : on dcompose dabord r en ses sous expressions, puis, en utilisant les rgles (1) et
(2) ci-dessous, on construit des NFA pour chacun des symboles de base de r, cest--dire soit
soit les symboles de lalphabet.
Remarque : si un symbole a apparat plusieurs fois dans r, un NFA spar est construit pour
chaque occurrence.
Ensuite en se guidant par larbre syntaxique dans un parcours en profondeur, on combine
rgulirement ces NFA en utilisant la rgle (3) ci-dessous, jusqu obtenir le NFA pour
lexpression rgulire complte.
Rgles de construction
1) Pour , construire le NFA
i

Ici i est un nouvel tat de dpart et f un nouvel tat dacceptation.

20

2) Pour a construire le NFA

Ici encore, i est un nouvel tat de dpart et f un nouvel tat dacceptation.


3) Supposons que N(s) et N (t) soient les NFA pour les expressions rgulires s et t.
a) pour lexpression rgulire S T, construire le NFA compos suivant : N (st)
N(S)

f
N(t)

Remarque : Les tats de dpart et dacceptation de N(s) et N(t) ne sont pas les tats de dpart
et dacceptation de N(st).
Remarque : tout chemin depuis i vers f doit traverser soit N(s), soit N(t) exclusivement, on
voit donc que lautomate compos reconnat L(s) L(t)
b) pour lexpression st , construire lNFA compos N(st) :
N(S)

N(t)

Ltat de dpart de N(s) devient ltat de dpart du NFA compos et ltat dacceptation de
N(s) est fusionn avec ltat de dpart de N (t).
Toutes les transitions depuis ltat de dpart de N (t) deviennent des transitions depuis ltat
dacceptation de N(s). Le nouvel tat fusionn perd son statut dtat de dpart ou
dacceptation dans le NFA compos.
c) pour lexpression rgulire S*, construire le NFA compos N(S*) .

21

Ici i est un nouvel tat de dpart et f un nouvel tat dacceptation. Dans le NFA compos, on
peut aller de i f directement en suivant un arc tiquet qui reprsente que appartient
(L(s))*, ou bien on peut aller de i f en traversant N(s) une ou plusieurs fois.
d) Pour lexpression rgulire (s), utiliser N(s) lui-mme comme NFA.
Remarque Chaque fois quon construit un nouvel tat, on lui donne un nom distinct. Ainsi il
ne peut y avoir deux tats dans deux sous automates qui aient le mme nom, mme si le
mme symbole apparat plusieurs fois dans r, on cre, pour chaque instance de ce symbole, un
NFA spar avec ses propres tats.
Exemple: soit r = (ab) * abb la figure suivante reprsente un arbre syntaxique pour r.
r11
r9
r7
r5
*
r3

r8

r6

r4
(

r10

r1

r2

Pour le composant r1, le premier a, on construit le NFA


2

Pour r2 on construit

On peut maintenant combiner N(r1) et N(r2) on utilisant la rgle de lunion pour obtenir
r1 r2

Le NFA pour (r4) est le mme que celui pour r3


Le NFA pour (r4)* est alors
22

Le NFA pour r6=a est


7

Pour obtenir lautomate pour r7=r5 r6 on fusionne les tats 7 et 7 en appelant ltat rsultant 7
pour obtenir

En continuant ainsi on obtient le NFA pour r11 = (ab)*abb

III.8.3 Automate dterministe minimal


Objectif : Construire un automate minimal dterministe en partant dun automate tat fini
dterministe
Dfinition 1 : Sparation
Soit (q1, q2) Q ; On dit que q1 et q2 sont spars par w * ssi *(q1, w) F ou bien
*(q2, W) F et pas les deux la fois.
Dfinition 2 :
q1 et q2 sont dits insparables ssi aucun mot de * ne les spares.
c.a.d q1, q2 Q,

w * ; *(q1, w) F ssi *(q2, W) F.

Dfinition 3 : Equivalence de Nerode


On dit que q1 est quivalent q2 quon note q1q2 ssi q1 et q2 sont insparables.
Dfinition 4 : Langage associ un tat
Soit un DFA A= (, Q, , q0, F), on appelle langage associ q de Q et on note Lq(A) le
langage suivant :
23

Lq(a)= {w * , *(q, w) F }.
Lq(a) est le langage reconnu par un automate dont ltat initial serait q et qui aurait F comme
ensemble dtat finaux.
L(A)=Lq0(A).
Thorme :
Chaque langage rgulier est reconnu par un unique automate dterministe minimal
Problme :
Soit A un automate fini dterministe complet dont chaque tat est accessible depuis ltat
initial. Construire un DFA minimal qui reconnaisse le mme langage que A.
Ide : Fusionner les tats quivalents
En pratique lalgorithme est fond sur un principe de sparation des tats.
Remarque DFA complet :
Chaque tat a une translation sur chaque symbole de , Si ce ntait pas le cas, nous pourrions
introduire un nouvel tat mort d avec des transitions depuis d vers d sur tout les symboles,
ainsi quune transition depuis ltat e vers d sur le symbole a sil navait pas dj de transition
de e sur a.
Dfinition : Equivalence dtats
tant donn A un DFA, deux tats p et q sont quivalents (on note pq) si Lp(A)=Lq(A).
Ainsi (pq)

(pour tout mot w de*,


*(p,w) F et *(q,w) F
ou
*(p,w) F et *(q,w) F )

Exemple :

24

01 ? non car (0,b) F et (1,b) F


36 ? oui car 3 F et 6 F et

w *, *(3, aw) F et *(6, aw) F


Et
*(3, bw) F et *(6, bw) F

Proprit : la relation est une relation dquivalence. En effet, elle est rflexive,
symtrique et transitive
Notation : Si q est un tat, on note [q] sa classe dquivalence. c.a.d lensemble des tats qui
lui sont quivalents.
Dfinition :
Soit le DFA A= (, Q, , q0, F), lautomate minimal associ A est : Amin= (, Q, , [q0], F)
Tel que
Q= {[q], q Q}
F= {[f], f F}
= {([q],a,[q])tels que p [p], q [q] (p,a,q) }
Proprits :
Amin reconnat le mme langage que A.
Pour tout DFA B tel que L(B)=L(A), le nombre dtats de B est suprieur ou gal celui de
Amin.
Tous les automates minimaux C tel que L(C)=L(A), sont identiques un renommage de leurs
tats prs : on peut parler dunicit.
Algorithme de minimisation :(raffinements successifs)
Itration i=0 (construire deux classes dquivalence : les tats dacceptation F et les tats de
non acceptation Q-F)
p 0 q ssi (p F et q F ) ou (p F et q F)
Itration i>0
piq ssi
pi-1q
Et
Pour tout a : (p, a) i-1 (q, a)
Arrt de lalgorithme : quand i est identique i-1
Supprimer tous les tats morts et ceux non accessibles depuis ltat de dpart.
Exemple : Construction des classes dquivalences
Soit A (, Q, , q0, F) tel que = {a, b}, Q= {1, 2, 3, 4, 5, 6}, q0=1, F= {3, 6}
Et dfinie par
25

1
3
2

a
b

2
1
3

3
2
1

4
3
5

5
4
6

6
5
4

b
b

a
a

6
b

4
b

3 classes
dquivalences

Nouvelles classes
dquivalences
E1=E2 on sarrte, on
a 3 classes
dquivalences I={1,
4} II={2, 5}III={3, 6}

Ltat1 (1, a)=3 classe quivalence I


(1, b)=2 classe quivalence II
Les transitions de E1 (dernier ensemble de classe dquivalence) sur a et b donne la table de
transition de lautomate minimale.
(I, a)=III, (I, b)=II, (II, a)=I, (II, b)=III
Ce qui donne lautomate minimal suivant:

26

III.9 Simulation d'un Automate tats finis non dterministe


Algorithme
Donnes : un NFA N construit par la construction de Thompson, et une chane dentre x. On
suppose que x est termine par un caractre de fin de fichier fdf. N a un tat de dpart e0 et un
ensemble dtats dacceptation F.
Rsultats : la rponse oui si N accepte x ; non dans le cas contraire.
Mthode : appliquer lalgorithme suivant la chane dentre x.
E :=-fermeture ({e0}) ;
C :=carsuiv () ;
Tant que Cfdf faire
Dbut
E :=-fermeture (transiter (E,C)) ;
C :=carsuiv () ;
Fin
Si EF alors
Retourner oui
Sinon
Retourner non
Exemple soit le NFA ci-dessous essayons de le simuler sur la chane x1=ababb et x2=abba
Pour x2 initialement E=-fermeture ({0}))= {0, 1, 2, 4,7}
C :=a
E :=-fermeture (transiter (E,a)) = -fermeture({3,8}) = {3,6,1,2,4,8} = {1,2,3,4,6,7,8}
C :=b
E :=-fermeture (transiter (E, b)) = -fermeture ({5,9}) = {1, 2, 4, 5, 6, 7,9}
C :=a
E :=-fermeture (transiter (E,a)) = -fermeture({3,8}) = {1,2,3,4,6,7,8}
C :=b
E :=-fermeture (transiter (E, b)) = -fermeture ({5,9}) = {1, 2, 4, 5, 6, 7,9}
C :=b
E :=-fermeture (transiter (E, b)) = -fermeture ({5,10}) = {1, 2, 4, 5, 6, 7,10}
27

C :=fdf

Arrt

EF= {10} donc retourner oui


Pour x2=abba
Initialement E=-fermeture ({0}))= {0, 1, 2, 4,7}
C :=a
E :=-fermeture (transiter (E, a)) = -fermeture ({3,8}) =

{1, 2, 3, 4, 6, 7,8}

C :=b
E :=-fermeture (transiter (E, b)) = -fermeture ({5,9}) = {1, 2, 4, 5, 6, 7,9}
C :=b
E :=-fermeture (transiter (E, b)) = -fermeture ({5,9}) = {1, 2, 4, 5, 6, 7,9}
C :=a
E :=-fermeture (transiter (E, a)) = -fermeture ({3,8}) = {1, 2, 3, 4, 6, 7,8}
C :=fdf Arrt
EF=

donc retourner non

III.10 Lemme de pompage


Ce lemme sert dmontrer qu'un langage est non rgulier
Principe de Diricklet ou Pigeonhole principale
M un automate avec n tats {q0, ., qn-1}
=1...p une chane de longueur p>n
alors la succession de transitions qui mne un tat final qF en acceptant passe forcment
deux fois ou plus par le mme tat (disons qr).
Exemple :
=1 2.r.s..k
q0 q1..........qr..qr...qf

circuit
qr

qf

q0
Il y a donc un circuit de qr qr dans l'automate.
Remarque:
28

Si M accepte , M accepte
1..r(r+1.s)*s+p

aussi

toutes

les

chanes

de

la

forme:

Lemme de Pompage
Si L est un langage rgulier infini, il existe un entier n 1 tel que:
Pour tout mot de L de longueur n, il existe une factorisation de en xvy telle que
0 < |v| n
i 0, xviy L
Preuve:
Soit A=(Q, , , q0, F), un automate tats fini n tats tel que L=L(A)
Prenons un mot L de langueur Lgn: =12. lg
On sait que *(q0, 12.lg) F
La lecture de dans A passe forcement deux fois par le mme tat q de Q
Il existe donc deux indices i lg et j lg (i<j) tel que q=*(q0, 1..i)=*(q0,1j)
Si on pose x=1i
v=i+1..j
y=j+1lg
partir de la dfinition A accepte =xvy
Quel serait le chemin parcouru par l'automate A sur la chane xvvy?
Il suit le chemin dcrit par x jusqu' arriver q car *(q0,x)=q, ensuite il boucle sur la chane
v=i+.j qui va le ramener q car *(q, v)=q , ensuite encore il boucle une deuxime fois
sur le deuxime v qui va le ramener encore q. Ensuite comme pour , il suit le chemin dcrit
par y qui mne au mme tat final avec lequel a fini c.a.d. xvvy a t accepte par
l'automate A.
Si on trace les chemins pour xvvy xvvvy xvvvvv..vy ils seront les mmes; aller jusqu'au
circuit, boucler l'intrieur du circuit un certain nombre de fois ensuite continuer jusqu' l'tat
final.
Application:
Soit ={a, b}, L={ab, n0 },prouvons que L n'est pas rgulier
Voyons comment on va appliquer le lemme de pompage directement ce cas.
Supposons que L est rgulier
En effet si M possde m tats alors =ambm et de taille suprieure m, donc il doit exister
trois sous chanes x, y, v de tel que ambm ==xvy et M accepte xvvy.
Si v ne contient que des a il y'aura plus de a que de b dans xvvy
Si v ne contient que des b il y'aura plus de b que de a dans xvvy
Si v contient des a et des b alors il contient la squence ab

29

Donc la chane xvvy contiendra deux copies de la squence ab mais chaque mot de L contient
une seule fois la squence ab. Donc xvvy ne peut pas tre un mot de b, ce qui prouve que le
lemme de pompage ne peut pas tre appliqu L et par suite L n'est pas rgulier.
Thorme de pompage
Soit L un langage rgulier infini reconnu par un automate fini N tat
Alors pour tout L, ||>N , x, v, y tq v et |xv| N
Tel que
=xvy et n 0 xvy L
Exemple
On va montrer que le langage des palindromes n'est pas rgulier.
Considrons un automate acceptant ce langage, supposons qu'il est a m tats.
Soit le palindrome =am+3bam+3, ce mot doit tre accept par cet automate puisque c'est un
palindrome.
Puisque ||>m , selon le thorme, on peut subdiviser en trois parties x, v, y et puisque |xv|
doit tre m, ils doivent contenir uniquement des a's parce que les m premires lettres de
sont des a's.
Donc quand on forme le mot xvvy, nous sommes en train d'ajouter plus de a's la partie
frontale de mais nous n'ajoutons pas de a's la partie arrire de qui contiendra toujours
les a's de y dont le nombre reste fix m+3 (dans l'exemple)
On peut donc conclure que la chane xvvy n'est pas un palindrome parce qu'elle aura la forme
a Plus que m+3 b am+3
Mais le thorme de pompage dis que ce mot doit appartenir Palindrome ce qui implique
que Palindrome n'est pas rgulier.

Chapitre IV Les langages contexte libre (Context Free Languages)

IV.1 Introduction par un exemple


Soit le langage L dcrit par l'expression rgulire suivante: a(a* b*)b
Un mot peut avoir la forme a bbb...b b

ou a aaa...a b

On peut dire que a la forme aMb, il reste dcrire M


S aMb
M A

M peut tre une suite de a ou une suite de b

M B
A aA

dcrit rcursivement une suite de a


30

A
B bB

dcrit rcursivement une suite de b

IV.2 Dfinition d'une Grammaire hors contexte


une grammaire G est un quadruplet (V,,R,S) o:

V est un ensemble fini de symboles terminaux et n on terminaux: (alphabet globale)

est l'alphabet des symboles terminaux

V- ensemble des non terminaux

S: Axiome (start symbol), toute drivation commence par S.

R: rgles de production. R ( V-)V*

Dans l'exemple de l'introduction:


V = {S,M,A,B,a,b}.
={a,b} ensemble des terminaux.
V-={S,M,A,B} ensemble des non terminaux.
S = Axiome, R={ S aMb, M A, M B, A aA, A , B bB, B }

IV.3 Dfinition d'une Drivation


se drive directement en et on note: s'il existe une suite de mots 0, 1,.., n de
V* tels que:
= 0
= n
i, 0 i <n, i i+1
*

Remarque: est drivable si S


Le langage engendr par la grammaire G est:
*

L(G) = {*, S }
L est dit langage contexte libre (CFL) s'il existe une grammaire G qui le gnre.
IV.3.1 Drivation gauche
se drive directement le plus gauche en et on note: s'il existe des mots 1 *,
g

2 V* tels que:
= 1 X 2
= 1 W 2
31

R contient une production X W


*

se drive le plus gauche en et on note s'il existe une suite de mots 0, 1,.., n de
g

V* tels que: = 0, = n et i, 0 i <n, i i+1


g

IV.3.2 Drivation droite


se drive directement le plus droite en et on note: s'il existe des mots 1 V *,
d

2 * tels que: = 1 X 2 , = 1 W 2 et
R contient une production X W
*

se drive le plus droite en et on note s'il existe une suite de mots 0, 1,.., n de
d

V* tels que: = 0, = n et i, 0 i <n, i i+1


d

Exemple:
soit G =(V, ,R,S) avec
= {x1,x2,+,*,(,)}, V = {E,T,F},S = E et R:
E E+T
E T
T T*F
T F
F (E)
F x1
F x2

soit = x1 *(x2+x1)

32

Drivation gauche
E T

F*F

formes sententielles

Drivation droite
Pour la drivation droite, c'est le non
terminal le plus droite qui est driv
chaque tape
E T

x1*F

non terminales

T*F

T*F
g
g
g

x1*(E)
g

x1*(E+T)
g

x1*(T+T)
g

x1*(F+T)
g

x1*(x2+T)
g

x1*(x2+F)
g

x1*(x2+x1) forme sententielle


g

terminale

T*(E)
d

T*(E+T)
d

T*(E+F)
d

T*(E+x1)
d

T*(T+x1)
d

T*(F+x1)
d

T*(x2+x1)
d

F*(x2+x1)
d

x1*(x2+x1)
d

IV.4 Arbre syntaxique (Parse Tree)


soit une grammaire G(V, ,R,S), un arbre syntaxique pour un mot engendr par G est un
arbre dont:

La racine est tiquete par l'axiome S

Les feuilles sont tiquetes par {}

Les nuds internes le sont par des lments de V-

Un nud interne tiquet B a des fils, de gauche droite, tiquets 1,2,..,n s'il existe
une production de R: B 12..n
est form de la concatnation des feuilles lues dans un parcours suffixe (profondeur
d'abord, gauche droite)

33

Exemple: arbre syntaxique pour x1*(x2+x1)


E
T
T

( E )

x1

E + T
T

x1

x2

IV.5 Grammaires ambigus


Une grammaire G est dite ambigu s'il existe un mot * possdant plus qu'un arbre
syntaxique.
Une grammaire G est dite ambigu s'il existe un mot * ayant plus d'une drivation
gauche
Une grammaire G est dite ambigu s'il existe un mot * ayant plus d'une drivation
droite
Exemple:
G(V, ,R,E)
={x1,x2,+,*,(,)}
V-= {E} et R dfinit par:
E E+E
E E*E
E (E)
E x1
E x2
soit = x1+x1*x2
Cette grammaire est ambigu car la chane a plus d'une drivation gauche. en effet:
E E+E x1+E x1 +E*E x1+x1*E x1+x1*x2
g

E E*E E+E*E x1+E*E x1+x1*E x1+x1*x2


g

de mme on peut trouver deux drivations droites

34

E
E

+ E

x1 E

x1

x2

E
E

E
x2

+ E

x1

x1

IV.6 Exemples de grammaires


soit G1(V, , R, S) avec = {a}, V-={S} et
R dfinit par
S aS
S
G1 reprsente langage (a*)
soit G2(V, , R, S) avec = {a}, V-={S} et
R dfinit par
S SS
S a
S
G2 reprsente aussi le langage (a*)
soit G3(V, , R, S) avec = {a}, V-={S,A} et
R dfinit par
S AA
A AAA on enlve A, on ajoute 3A donc on est en train de rajouter 2A
S a
voici une drivation:
S AA AAAA AAAAAA aAAAAA aaAAAA aaaAAA aaaaAA
g

aaaaaA aaaaaa
g

Le langage reconnu est aa(aa)*.


Exercice:
soit ={a,b}
L = {*, contient 2n a, n >=1}
1) Donnez G = (V,,R,S) tq L(G) = L
2) Donnez une drivation gauche de la chane = abaababa L.
3) Montrer que L(G) = L.
35

Rponse:
1)
S AA
A bA
A Ab
A AAA
Aa

gnre rcursivement une suite de b gauche


gnre rcursivement une suite de b droite

2) = bbaababa
S AA
g

bAA
g

bbAA
g

bbaA
g

bbaAAA
g

bbaAbAA
g

bbaabAA
g

bbaabaA
g

bbaababA
g

bbaababa
g

3) Montrons que L(G) = L, Il faut montrer que L(G) L et L L(G)


L = {*, possde la proprit P}
L(G) L ssi L(G), possde la proprit P.
Dmonstration L(G) L
Au lieu de dmontrer que seules les formes sententielles terminales sont dans L, on va
dmontrer que toute forme sententielle ou pas est dans L. (contient un nombre pair de a ou
A).
Par rcurrence sur la longueur de la drivation
base k = 1

S AA

contient bien un nombre paire de A ou a

hypothse: On suppose que toute drivation de longueur k, k [1..n] possde un nombre


pair de A ou a.
Recurrence:
Prenons une drivation de longueur n+1
S 0 1...n n+1
36

Dans la drivation directe n n+1 on passe travers une rgle qui ne change pas la
parit, en effet
A bA

ne change pas le nombre de A + a

A Ab

ne change pas le nombre de A + a

A AAA

ajoute 2A donc preserve la parit des A+a

Aa

ne change pas le nombre de A + a

Donc l'hypothse est aussi vraie l'ordre n+1. Donc toute forme sententielle a un nombre
paire de a ou A, or la forme sententielle terminale ne contient que des terminaux (0A)
donc elle contient forcement un nombre paire de a. Donc L(G), possde 2n a.
Dmonstration L L(G)
soit L, = bm1 a bm2 a... bm2n-1 a bm2n a bm2n+1
Voici une drivation de S en w
S AA

1 fois

AA

A AAA

(n-1) fois

AA....A

A bA

m1 fois

b AA...A

Aa

1 fois

bm1aA...A

(2n A)

m1

A bA
Aa
2n-1 fois
bm1abm2a....bm2n-1aA
A bA

m2n fois

bm1abm2a....bm2n-1aA bm2nA

A Ab

m2n+1 fois

bm1abm2a....bm2n-1aA bm2nAbm2n+1

A a

1 fois

bm1abm2a....bm2n-1aA bm2nabm2n+1

IV.7 Classification de chomsky


Chomsky a tabli une classification des langages par types de grammaires. Il a ainsi tabli
quatre types de grammaires: type0, type1, type2 et type3. Selon Chomsky toute grammaire
gnrant un langage formel est de type 0. Pour dfinir les autres types de grammaires, il
introduit des restrictions de plus en plus svres sur les rgles de production.
IV.7.1 Grammaires contextuelles context-sensitive ou de type 1(CG)
Une grammaire est contextuelle si toute rgle de production :
37


peut scrire A
Peut scrire
Avec , , , dans V* (suite de terminaux ou non terminaux)
A dans Vn (non terminal)
Dans V* (suite non vide de terminaux ou non terminaux)
On voit que le symbole A de Vn qui se trouve dans prcd par et suivi par (dans le
contexte et ) peut tre substitu par et prcd par et suivi par (do le nom
contextuelle).
Exemple:
aBab
B est substitu par b que si elle est prcde par a.
IV. 7.2 Grammaires non contextuelles context-free ou de type 2 (CFG)
Les productions dans ce cas sont de mme forme que les CG mais avec une nouvelle
contrainte telle que :
= = et = =
Ainsi toutes les productions sont de la forme :
A
Avec A Vn (non terminal)
et B V* (suite non vide de terminaux et de non terminaux )
Le symbole A de Vn est substitu par sans restriction de contexte
Exemple : Soit G une grammaire dfinie par :
G= {Vn ,Vt ,P,S}
Avec Vn = {S ,A,B} et Vt={a,b}
P:

S aB|bA
A a|aS|bAA
Bb|bS|aBB

G est une grammaire hors contexte; toutes les productions de G ont un seul lment de
Vn gauche.
IV. 7.3 Grammaires Rgulires ou de type3 :RG
C'est une grammaire Hors contexte, on impose en plus la contrainte suivante :
toutes les productions sont de la forme : A
avec = a ou =aB ou =
38

avec a dans Vt et B dans Vn


Exemple : Soit G une grammaire dfinie par:
G={Vn, Vt, P, S}
avec Vn= {S,A ,B} et Vt={0,1}
Les productions de P sont:
S 0A | 1B | 0
A 0A | 0S |1B
B 1B|1 | 0
Toutes les productions ont un lment de Vn gauche et un lment de Vt suivi ou non par
un lment de Vn droite. Donc cest une grammaire rgulire.

IV.8 Classification des langages formels

Un langage contextuel ou de type 1 est un langage gnr par une grammaire contextuelle.

Un langage non contextuel ou de type 2 est un langage gnr par une grammaire non
contextuelle.

Un langage rgulier ou de type 3 est un langage gnr par une grammaire rgulire .

Soient F0,F1,F2,F3 les familles de langages de types 0 ,type1,type2 et type3 respectives alors
F3 F2 F1 F0

IV.9 Transformation d'une grammaire rgulire droites en NFA


Soit G=(N,T ,P,S) une grammaire rgulires droite , on peut construire un automate fini
A=(,Q,,q0,F) qui accepte les mots engendrs par G:
Pour toutes les productions B de P ,on ajoute un nouveau symbole non terminal X et
on remplace ces productions par BX et X
Lensemble des tats Q de lautomate est celui des non-terminaux
renommage prs)

Lalphabet est gale lensemble T des terminaux.

Ltat q0 correspond laxiome A de la grammaire.

N{X}( un

Pour toute production BC de P, il existe la flche (B, ,C) dans (au renommage
prs)

Pour toute production B de P, ltat correspondant B est final dans A.

39

Exemple
b

G=(N ,T ,P,A) une grammaire rgulire


droite
N={A,B,axiome A}
T={a,b,c}

P{AaA
A

AbB

Ac (devient ACX et X)

BbB
Ba(devient BaX)
B
E :a*bb*(a ) (a*C)
A=(,Q,, q0=A, F)
={a,b,c},={A,B,X},F{B,X}
L(G) = L(A)

IV.10 Transformation d'un DFA en grammaire rgulire


Thorme:
Un langage est rgulier si et seulement si il existe une grammaire rgulire qui engendre les
mots de L.
Soit un automate fini donn A=(,Q,, q 0,F)
G=(N,T,P,A)est une grammaire rgulire qui engendre les mots de L(A) si :
Lensemble des non terminaux N est celui des tats Q de lautomate ( un renommage
prs)

Lensemble des terminaux T gale .

Laxiome A de la grammaire correspond ltat q0.

Pour tout lment (q,6,q) de il existe la production q 6q dans P(au renommage prs)

Pour tout f F il existe la production f dans P(au renommage prs)

Exemple :

A=(,Q,, q0=A,F)

={a,b},Q={A,B,C,D},F={D}

a,b

G=(V,,R ,A)

V- ={A,B,C,D},axiome A

D
b

={a,b}

40

R={AaC
AbB
BaD
BbA
CaD
CbB
DaD
DbD
D}
L (G) = L (A)

41

Chapitre V Automates pile (Push Down Automaton, PDA)

V.1 Introduction
Par analogie avec les expressions rgulires qui engendrent les langages rguliers, les
grammaires hors contextes engendrent les langages hors contexte. Aussi par analogie avec
automates tats finis qui reconnaissent les langages rguliers, les automates pile
reconnaissent les langages hors contextes.
Exemple: Utilisation d'un automate pile
L'automate pile va tenter de lire le mot aaabbb pour vrifier s'il appartient ou pas L = {
{a,b}*, = anbn n 0} qui n'est pas rgulier sinon on aurait utilis un DFA.
Le PDA enpile un X la lecture d'un a et ds la lecture du premier b il commence dpiler
la rencontre de chaque b. Il accepte le mot quand la pile devient vide.
a a

b
Pile

PDA

X
empiler X la lecture d'un a
a

b
Pile

PDA
X
X
empiler X la lecture d'un a
a a

b
Pile

PDA
X
X
X
42

empiler X la lecture d'un a


a a

b
Pile

PDA
X
X
dpiler X la lecture d'un b
a a

b
Pile

PDA

X
dpiler X la lecture d'un b
a a

b
Pile vide

PDA

dpiler X la lecture d'un b. Le mot est accept par pile vide


Pourquoi un automate pile

Les automates finis n'ont pas d'autres mmoires que leurs tats.

Ils ne savent donc pas compter au-del de leur nombre d'tats.

Une pile procure une mmoire additionnelle non borne.

Le nombre de symboles utiliss dans la pile est fini.

La pile vide peut tre un critre d'acceptation des mots.

V.2 Dfinition d'un automate pile


Un automate pile non dterministe est un septuple (Q, ,,,q0, z, F) o:
43

Q : ensemble fini d'tats

: alphabet fini des symboles d'entre

: alphabet fini des symboles de pile

: ensemble des rgles de transition

q0 : tat initial

z : symbole de pile vide

F : ensemble des tats d'acceptation

V.3 Dfinition d'une transition

Une rgle de transition (q, , q',) considre:


L'tat courant q de l'automate
Le caractre lu sur le ruban (ou peut tre )
Le symbole de sommet de pile (ou peut tre z ou )

une rgle de transition indique :


Le prochain tat q' de l'automate
La suite de symboles empiler la place du sommet de la pile ou dans la pile vide

La relation de transition est l'ensemble des rgles de transition vues comme des
quintuples (Q ( {}) ( {})) (Q *)
(q, , q',): on est l'tat q avec en sommet de pile, on peut lire du restant lire,
remplacer par et transiter l'tat q'.

V.4 Langages reconnus par un PDA


Dfinitions: soit A(Q, ,,,q0, z, F) un PDA
1. On appelle configuration initiale d'un PDA, le triplet (q0, ,z), avec la chane
reconnatre par le PDA.
2. On appelle configuration finale d'un PDA, le triplet (qF, , ) avec qF F et *.
3. Une configuration est un triplet (q:tat courant , x:restant lire,:contenu de la pile).
Remarques:

si = , la pile est vide.

La succession des configurations se fait travers , not .

Le langage reconnu par un PDA est l'ensemble des mots lus partir de la configuration
initiale jusqu' l'obtention d'une configuration finale.
Formellement
L(A) = {*/ (q0, ,z) * (qF, , ) avec qF F et *}

44

Remarque:
Pour la configuration finale d'un PDA, le contenu de la pile importe peu. Cependant, un cas
particulier est de considrer une configuration finale o la pile serait alors vide. L'automate
est dit alors automate pile vide.

V.5 Dfinition: langage reconnu par un automate pile vide


On dit qu'un langage est reconnu par un automate pile vide, si lorsqu'on parcourt tous ses
mots ( partir de la configuration initiale), on obtient une pile vide et un tat d'acceptation.
L (A) = { */ (q0, , z) * (qF, , ) avec qF F}.
Exemple1: soit le langage contexte libre L ={anbn, n 0}.
Dterminons le PDA qui reconnat L. Le principe tant d'empiler X chaque rencontre d'un a,
et de dpiler un X au fur et mesure de la lecture des b: A est donc
A (Q,,,,q0, #, F)
Q = {q0,q1,q2,q3}; = {a,b}; = {X,#}; F = {q3}; dfinie par
1 (q0,a,#) = (q1,X#)

On a empil X et on se dplace q1 qui va faire une boucle


d'empilement.

2 (q1,a,X) = (q1,XX)
3 (q1,b,X) = (q2,)

On dpile X et on se dplace q2 qui va avoir une boucle


de dpilement

4 (q2,b,X) = (q2, )

dpilement successif de tous les X

5 (q2,,#) = (q3,#)

tat final q3 atteint

Remarque: si n= 0 (L), il faut donc ajouter l'instruction (q0,,#) = (q3,#)


faisons tourner l'automate sur quelques mots a) a2b2

b) a2b

c)ab2

a)
tat

restant lire

contenu de la pile

transition utilise

q0

aabb

q1

abb

X#

q1

bb

XX#

q2

X#

q2

q3

Autre reprsentation
(q0,aabb, #) (q1,abb,X#) (q1, bb,XX#) (q2,b,X#) (q2, , #) (q3, , #)
45

on a (q0, a2b2, #) * (q3, , #) donc le mot est lu on est arriv un tat d'acceptation donc a2b2
L(A)..
b) (q0, aab,#) (q1, ab, X#) (q1, b, XX#) (q2, , X#) il n y'a pas de transition pour la
configuration dont l'tat courant est q2, le mot est lu et il y a un X en sommet de la pile; Bien
que le mot soit lu, la configuration finale n'est pas obtenue, Donc aab L(A).
c) (q0, abb, #) (q1,ab,X#) (q2,b,#) il n'existe pas de transition quand l'automate est en q2,
il reste un b lire et # en sommet de pile, il y a donc blocage et abb L.
Remarque: si on veut un PDA pile vide, il faut ajouter la transition (q2, ,#) = (q3, )
Notation
(qi, , )(qj, )
sans tenir compte du restant lire (ne pas avancer dans le ruban)
(qi, ,)(qj, X) empiler X quel que soit le contenu de la pile.
sans tenir compte de la pile
Exemple:
(p, , a) (q, ) dpiler a le restant lire et aller q
(p, , ) (q,a) empiler a le contenu de la pile et le restant lire (sans avancer dans le
ruban)
Exemple: soit = {a,b} et L = {cR : *}

a b c b a
empiler a

empiler b

aller l'tat de
dpilement

dpiler b

A (Q,,,,q0, #, F)
1

(q0,a, #) (q1,a#)

(q0,b,#) (q1,b#)

(q1,a, ) (q1, a)

Q= {q0,q1,q2}, = , F = q2
empiler a la tte de la pile
46

dpiler a

(q1,b, ) (q1,b)

empiler b la tte de la pile

(q1, c, ) (q2, )

aller q2 la tte de la pile

(q2,a,a) (q2, )

dpiler a si je rencontre a sur la bande et que le symbole


en sommet de pile est a.

(q2,b,b) (q2, )

dpiler b si je rencontre b sur la bande et que le symbole


en sommet de pile est b.

(q2, , #) (q2, )
a,a
b,b

a,a
b,b
,#

q0 c, q1

abbcbba
tat

restant lire

contenu pile

Transition utilise

q0

abbcbba

# 1

q1

bbcbba

a# 4

q1

bcbba

ba# 4

q1

cbba

bba# 5

q2

bba

bba# 7

q2

ba

ba# 7

q2

a# 6

q2

# 8

q2

Mot accept par pile vide

Remarque : Un NFA M= {Q, , , s, F) est la mme chose qu'un PDA M'(Q,,,',s, null,
F) avec '= ((p,u, ) (q, ) tel que (p,u,q) } c'est dire un PDA dont la pile n'est pas
utilise.
Equivalence: Tout langage hors contexte reconnu par un PDA avec le mode de
reconnaissance sur pile vide est galement reconnu par un automate pile acceptant sur tat
final et vice-versa.

V.6 Dterminisme
un automate pile est dterministe (PDA dterministe) si:

pour un tat q donn

pour un symbole d'entre donn

pour un symbole de pile donn

Il existe une et une seule transition partant de (q, ,)


47

ceci correspond bien au fait de ne pas avoir le choix quant- la transition appliquer
Thorme
Il existe des langages non contextuels qui ne sont pas reconnus par un automate pile
dterministe.
Exemple:
Le langage { R , *} n'est pas reconnu par un PDA dterministe.
M (Q,,,,s, null, F)
1

(s, a, ) (s,a)

empiler a le symbole en sommet de pile la


rencontre de a dans la bande

(s, b, ) (s,b)

empiler b le symbole en sommet de pile la


rencontre de b dans la bande

(s, ,) (f, )

passer l'tat f le symbole en sommet de


pile et le symbole rencontr sur la bande
d'entre

(f,a,a) (f, )

(f,b,b) (f, )

Dfinitions

2 chanes sont dites persistantes si l'une est un prfixe de l'autre

2 transitions (p1, 1, 1) (q1, 1)


(p2, 2, 2) (q2, 2)

sont dites compatibles si

p1= p2
1 et 2 sont persistantes
1 et 2 sont persistantes
Thorme:
un PDA est dterministe s'il ne contient aucune transition compatible
Exemple 1
= {a,b}
L = {cR, *}
M (Q,,,,s, null, F)
:
(s,a,a) (s,a)

le mme tat de dpart mais a n'est pas prfixe de b ni b de c ni a de c

(s,b, ) (s,b)
(s,c,) (f,)
(f,a,a) (f, )

mme tat de dpart mais a n'est pas prfixe de b

(f,b,b) (f, )
48

Il n y a pas de transitions compatibles donc le PDA est dterministe.


Exemple 2: L = {R, *}
:
(s,a, ) (s,a)

3 transitions compatibles prfixe de a et de b, prfixe de

(s,b, ) (s,b)
(s, ,) (f,)
(f,a,a) (f, )

transitions non compatibles

(f,b,b) (f, )

V.7 Transformation d'une grammaire hors contexte en PDA


Thorme: Pour toute grammaire hors contexte, il existe un automate pile vide A tel que
L(G) = L(A)
L'ide consiste commencer par empiler l'axiome, ensuite, chaque symbole de la chane
d'entre, on remplace la partie gauche de la production concerne par le reste de la partie
droite.
Algorithme:
L: langage engendr par G = (V, , R, S), il s'agit de trouver A (Q,,,,q0, #, F) tel que L(G)
= L(A).
= de la grammaire
= V {#}
Q = {q0, q1}
F = q1
dfinie par:
1) (q0, , #) = (q1, S#)

on empile l'axiome la chane d'entre

2) si (A ) R alors (q1, , A)= (q1, )


3) (q1, , ) = (q1, )
4) (q1, , #) = (q1, )
Exemple:
soit L = {anbn, n 1}
L est engendr par G = (V, , R, S) avec V = {a,b,S}; = {a,b},
et R dfinit par S aSb|ab
49

Le PDA pile vide qui reconnat L(G) est:


A (Q,,,,q0, z, F) avec ={a,b}; ={a,b,S,#}, z = #, Q={q0,q1}; F={q1} et dfinie par:
(q0, , #) = (q1, S#)

[F1]

(q1, , S) = (q1, aSb)

[F2]

(q1, , S) = (q1, ab)


(q1, a, a) = (q1, )

[F3]

(q1, b, b) = (q1, )
(q1, , #) = (q1, )

[F4]

Faisons tourner l'automate sur a2b2


(q0,aabb, #) (q1, aabb, S#) (q1, aabb, aSb#) (q1, abb, Sb#) (q1, abb, abb#) (q1, bb,
bb#) (q1, b, b#) (q1, , #) (q1, , )

V.8 Proprits de clture


La classe des langages hors contexte est close pour lunion
Preuve par construction:

Soient G1 = (N1, T1, R1, S1) et G2 = (N2, T2, R2, S2) engendrant respectivement L1 et L2

Construisons G pour engendrer L1 L2


G = (N1 N2 {S},
T1 T2,
S,
R1 R2 {S  S1 | S2 })

En sassurant au pralable que N1 N2 = et S N1 N2 sinon renommage.


La classe des langages algbriques est close par concatnation
Preuve par construction

Soient G1 = (N1, T1, R1, S1) et G2 = (N2, T2, R2, S2) engendrant respectivement L1 et L2

Construisons G pour engendrer L = L1L2


G = (N1 N2 {S}, T1 T2, S, R1 R2 {S  S1S2})
En sassurant au pralable que N1 N2 = et S N1 N2

50

La classe des langages algbriques est close pour lopration toile de Kleene
Preuve par construction

G = (N, T, R, S) engendrant le langage L

Construisons G pour engendrer L* :

G = (N {A}, T, axiome A, P {A  | SA}


On sassure au pralable que A N
Exemple
Question : construire une grammaire pour L = {ai bj ck, i=j, ou j=k}
Rponse :
L est lunion de deux langages = L1 L2
Avec L1 : {ai bj ck , i=j, k 0}
L2 : {ai bj ck , i 0, j=k}

Concernant L1 :{ai bj ck, i=j, k 0} est la concatnation de L1= {ai bj, i=j}
L1= {ck, k 0}

Concernant L2 :{ai bj ck, i 0, j=k} est la concatnation de L2= {ai, i 0}


L2= {bj ck, j=k}

Les langages {ck, k 0}, respectivement {ai, i 0} sont toile de {c}, respectivement {a}.

Construisons maintenant la grammaire pour L.


{ai bj, i=j}: S1  | a S1 b
{ck, k 0}: S2  | c S2
L1 = {ai bj ck, i=j, k 0}
S1  | a S1 b
S2  | c S2
SL1  S1 S2 /*concatnation
L2 = {ai bj ck, i 0, j=k}
S3  | a S3
S4  | b S4 c
SL2  S3 S4 /*concatnation

L = {ai bj ck, i=j, ou j=k} est engendr par


G = (N, T, R, S)
N = {S1, S2, S3, S4, SL1, SL2, S}
51

T = {a, b}
P = {S1  | a S1 b; S2  | c S2; SL1  S1 S2; S3  | a S3;
S4  | b S4 c; SL2  S3 S4; S SL1 | SL2}

V.11 Clture des langages hors contexte (intersection et complmentation)

La classe des langages hors contexte nest pas close par intersection.
Contre exemple :
Comme on la montr par lemme de Pompage, le langage
L = {ai bj ck, i 0} nest pas hors contexte.
Or L = L1 L2 avec L1 et L2 les deux langages hors contexte ;
L1 = {ai bj ck, i = j} /*concatnation de ai bj et ck
L2 = {ai bj ck, j = k} /*concatnation de ai et bj ck

La classe des langages hors contexte nest close par complmentation.


Preuve :
Si cette classe tait la fois close par union et complmentation, elle serait
forcment close par intersection, car L1 L2 = L1 L2 on vient de voir quelle nest pas
close (intersection).

Thorme:
L'intersection d'un langage hors contexte et d'un langage rgulier est un langage hors
contexte.

Bibliographie

1. D. Cohen, "Introduction to computer Theory", Edition wiley, 1996.


2. J. E. Hopcropft, J. Ullman, "Introduction to Automata Theory, languages and
computation, Edition Addison-Wesley 1979.
3. H.R. Lewis, C.H. Papadimitriou, "Elements of The Theory of computation", Edition
Prentice Hall, 1998.

52

53