Vous êtes sur la page 1sur 11

Contenu

Langages rguliers
Dfinition inductive des langages rguliers (Lreg)

Thorie des langages formels

Base : Lreg
{}Lreg
alphabet , x, {x}Lreg
Induction : L1,L2 Lreg, L1L2, L1.L2 et L1* Lreg

Langages naturels VS langages formels


Dfinitions, proprits et oprations sur les langages
Gnration VS reconnaissance
Hirarchie de Chomsky

Thorme: Tout langage fini est rgulier

Langages rguliers
Dfinitions et proprits
Trois reprsentations: grammaires rgulires, expressions
rgulires, automates tats finis
Manipulation: dterminisation, minimisation, changement
de reprsentation
Dcider si un langage est rgulier

Autres dfinitions :
engendr par une grammaire rgulire
reconnu par un automate tats finis
dfini par une expression rgulire

=> Question: quivalence de toutes ces dfinitions ?


49

Langages rguliers

Langages rguliers

Grammaires rgulires

Prservation (clture) de la rgularit par :


Oprations ensemblistes :

50

Union (par dfinition)


Complmentation (admis)
Intersection: L1L2 = (L1cL2c)c
Diffrence: L1-L2= L1L2c

Rappel: G=(VT,VN,S,R) est rgulire ssi R,


VN et ((VT*.VN)VT+)
Thorme : Langages engendrs par grammaires
rgulires L(Greg) = Langages rguliers (Lreg)
Preuve :
1. Montrer Lreg L(Greg) en construisant des grammaires
gnrant tout langage vrifiant la dfinition inductive
2. Montrer L(Greg) Lreg en dfinissant le langage engendr
par une grammaire rgulire par la dfinition inductive

Oprations algbriques :
Concatnation (par dfinition)
Itration (par dfinition)
Puissance: L1n=L1.L1.L1. .L1

Langages rguliers

51

Lreg L(Greg)

52

L(Greg) Lreg

Base:

Soit G=(VT,VN,S,R) une grammaire rgulire


Pour chaque zVN, on dfinit Lz le langage des mots
engendrs partir de z :

engendr par (,{S},S,{SS})


{} engendr par (,{S},S,{S})
{x} engendr par ({x},{S},S,{Sx})

Soit z v1 | v2 | | vn | w1z1 | w2z2 | | wmzm R


lensemble des rgles ayant pour partie gauche le
symbole non-terminal z, avec viVT+, wiVT* et ziVN
Alors, Lz={v1} {v2} {vn}
({w1}.Lz1) ({w2}.Lz2) ({wm}.Lzm)

Induction:
Soient L1G1=(VT1,VN1,S1,R1) et L2G2=(VT2,VN2,S2,R2)
L1L2 G=(VT1VT2, VN1VN2{S}, S,
R1R2{SS1|S2})
L1.L2 G=(VT1VT2, VN1VN2, S1, {w.X R1, XVN1}
{w.S2 | w R1, wVT1+} R2)
L1* G=(VT1, VN1{S}, S, R1 {SS1|}
{w.S1 | w R1, wVT1+})

=> Lz se dfinit en fonction des langages Lzi : On


obtient un systme dquations ensemblistes sur les
langages Lzi

Attention : type(G)3 si S1R1 ou S2R2


Langages rguliers

Langages rguliers

53

Langages rguliers

54

Expressions rgulires

L(Greg) Lreg

Expression rgulire (e-reg) = notation algbrique


de lensemble des mots appartenant un langage
Dfinition inductive:

Thorme: tout systme dquations de la forme


L1 = A1 B11.L1 B12.L2 B1n.Ln
L2 = A2 B21.L1 B22.L2 B2n.Ln

Ln = An Bn1.L1 Bn2.L2 Bnn.Ln

Base : e-reg dfinit le langage


e-reg dfinit le langage {}
, x, xe-reg dfinit le langage {x}
Induction : e1, e2 e-reg dfinissant les langages L1, L2
e1+e2 e-reg dfinit le langage L1L2
e1.e2 e-reg dfinit le langage L1.L2
e1* e-reg dfinit le langage L1*
(e1) e-reg dfinit le langage L1
Ex: a*.b dfinit
{a}*.{b} = {w{a,b}* | w=anb, n0}
a.a* dfinit
{a}.{a}* = {w{a}* | w=an, n>0}
(a+b)* dfinit
({a}{b})* = {w{a,b}*}

admet pour solution des langages L1, L2, , Ln rguliers


si tous les coefficients Ai et Bij sont des langages rguliers
Dans notre cas:
Lz= {v1} {v2} {vn} ({w1}.Lz1) ({w2}.Lz2) ({wm}.Lzm)

Ai

B1i

rgulier

B2i

rgulier

Bmi

rgulier

rgulier

Ainsi LS le langage issu de laxiome (= L(G)) est rgulier


55

Langages rguliers

Langages rguliers

Expressions rgulires

L(e-reg) = Lreg
Thorme : Langages dfinis par expressions
rgulires L(e-reg) = Langages rguliers (Lreg)

Prsance : (pour viter parenthses inutiles)


() > * > . > +
Ex:

a.b*+c+d*

Preuve: par quivalence des dfinitions inductives:


Langages

expressions

{}

{x}

x
L1.L2
(e1.e2)
L1L2
(e1+e2)

e1*
L1*

<=> (a . (b*)) + (c + (d*))

Proprits, notations :
Le . est souvent omis (sauf ambigut)
Le + est parfois not |
On ajoute loprateur + : ee-reg => e+e-reg; e+=(e.e*)
Ex:

(a+b)+ <=> ((a+b).(a+b)*)

On ajoute loprateur ? : ee-reg => e?e-reg; e?=(e+)


Ex:

=> Toute construction inductive dun langage rgulier


correspond une unique construction inductive
dexpression rgulire

a.b? <=> a.(b+)

mmes proprits que sur les langages (associativit,


distributivit, idempotence, lment neutre/absorbant, )
57

Langages rguliers

Langages rguliers

Simplification dexpressions rgulires

Un automate reprsente un ensemble dtats entre


lesquels on volue par des transitions

Cas de base :

* =

e. = .e = e

+e* = e*

+e+ = e*

e. = .e =

Ex: tats = {porte ouverte, porte ferme}


transitions = {ouvrir, fermer}

Cas avancs :

Ex:

si L(e1)L(e2) alors e1+e2 = e2 (inclusion)


e1+e2+e2 = e1+e2 (idempotence)
e1+e2 = e2+e1 (commutativit)
e** = e* (idempotence)
e1.e2 + e1.e3 = e1.(e2+e3) (factorisation/distribution)

Les applications sont plus larges que simplement les


langages formels

a+a.a*+a.a*.b+a.a*.b.b* = a+b*

Mais attention :
(e1+e2)* e1*+e2*
Ex:

(a+b)*={a,b}*

a*+b*={a}*{b}*

(e1.e2)* e1*.e2*
Ex:

(a.b)*=({a}.{b})*={ab}*

description de processus industriels,


conception de circuits logiques,
modlisation comportementale dun programme,

En langages formels : automates tats finis,


automates pile, machine de Turing

a*.b*={a}*.{b}*

Langages rguliers

58

Automates

Soient e, e1, e2 et e3 des expressions rgulires :


* =
+e = e

56

59

Langages rguliers

60

Automates tats finis

Automates tats finis

Un automates tats finis (AF) sert reconnatre


des mots: les transitions se font la lecture des
symboles du mot reconnatre

Proprits des tats :

Un AF se dfinit par (V,Q,I,F,T):

Un tat q est accessible ssi il existe une squence


de transitions (I,x0,qi1), (qi1,x1,qi2), , (qik,xk,q)

I peut appartenir F (tat initial et final)


Q et F ne peuvent tre vides

V est lalphabet des mots reconnaissables


Q = {q1,q2, , qn} est un ensemble fini dtats
IQ est ltat initial (unique!)
FQ est lensemble des tats finaux
T est un ensemble de transitions (qi,x,qj), qi,qj Q et xV
Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,b,q2), (q2,b,q2)})

Un tat q est co-accessible ssi il existe une


squence de transitions (q,x0,qi1), (qi1,x1,qi2), ,
(qik,xk,f) telle que fF
Un tat q est utile ssi il est accessible et coaccessible

61

Langages rguliers

Automates tats finis

Langages rguliers

62

Automates tats finis

Proprits des transitions :

Proprits des AF :

(qi,,qj) est appele -transition (transition sans


lecture de symbole)

Un AF est complet ssi qQ, xV, qQ tq (q,x,q)T


Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,b,q2), (q2,b,q2)}) nest pas
complet car il ny a pas de transition depuis q2 la lecture dun a

Deux transitions (qi,x,qj) et (qi,x,qk) sont


conflictuelles ssi qjqk

Un AF dterministe (AFD) nadmet ni -transitions ni


transitions conflictuelles
Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,b,q2), (q2,b,q2)}) est dterministe

Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,a,q2), (q2,b,q2)})

Un AF non-dterministe (AFN) admet des transitions


conflictuelles ou une -transition

contient 2 transitions conflictuelles: (q1,a,q1) et (q1,a,q2)

Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,a,q2), (q2,b,q2)}) est nondterministe

63

Langages rguliers

Automates tats finis


tat q  nud q
transition (q,x,q)  arc tiquet x entre les nuds q et q
tat initial I  arc non-tiquet entrant sur nud I
tat final f  nud f doublement entour

Ex: ({a,b},
{q1,q2},

q1,
{q2},
{(q1,a,q1), (q1,b,q2), (q2,b,q2)})
Langages rguliers

a
q1

64

Automates tats finis

Reprsentation graphique dautomates :

Langages rguliers

q2

T  table de transition indice par Q et par V


(q,x)={ qiQ | (q,x,qi)T }
Ex: ({a,b}, {q1,q2}, q1, {q2}, {(q1,a,q1), (q1,b,q2), (q2,b,q2)})
donne

q1

q1

q2

q2

q2

complet => qQ, xV, |(q,x)|1


dterministe => qQ, xV, |(q,x)|1
65

Langages rguliers

66

Lecture par un automate

Lecture par un automate


A:

q1

Ex: sur A, (abc,q1) (bc,q1) (c,q2)

Un mot w est reconnu par un automate A ssi il existe une


lecture terminale russie de w par A
Ex: sur A, (aab,q1) (ab,q1) (b,q1) (,q2) est terminale et russie
=> aab est reconnu
(abc,q1) (bc,q1) (c,q2) est russie mais pas terminale
=> abc nest pas reconnu

Le langage L(A) reconnu par un automate A est lensemble


des mots reconnus par cet automate

est la squence (aab,q1)(ab,q1)(b,q1)(,q2)


67

Lecture par un automate


Ex: lecture de aab par
b

q1

q2

68

Thorme : Langages reconnus par automates L(AF)


= Langages rguliers Lreg
Preuve :
Lreg L(AF) par construction dun AF pour toute dfinition
inductive dun langage rgulier

(aab,q1)(ab,q2) [non terminale]


(aab,q1)(ab,q1)(b,q2)(,q2) [terminale,
russie]
(aab,q1)(ab,q1)(b,q1) [non-russie]

L(AF) Lreg en dfinissant le langage reconnu par un AF


partir des rgles inductives de construction des
langages rguliers.

a
q1

q2

Langages rguliers

L(AF) = Lreg ?

Unicit: la lecture dun mot est unique sur un AF dterministe,


mais pas ncessairement sur un AF non-dterministe
a

q2

Ex: sur A, (aab,q1) (ab,q1) (b,q1) (,q2)

q2

Langages rguliers

Une lecture est russie ssi elle se termine par (w,q) et qF

b
b

q1

Une lecture est terminale ssi elle se termine par (,q)

Notation: on peut omettre les tapes et noter (w,I)*(w,qi)


Ex: une lecture de w=aab par
a

On appelle lecture du mot w=x0x1xn par un AF


A=(V,Q,I,F,T) une squence
(x0x1xn,I)(x1xn,q1)(xixn,qi)
correspondant lutilisation successive des
transitions
(I,x0,q1), (q1,x1,q2), , (qi-1,xi,qi) T

(aab,q1)(ab,q1)(b,q1)(,q2) [terminale,
russie]

=> Pour dterminer si un mot est reconnu par un automate nondterministe, il faut calculer toutes ses lectures par cet
automate
Langages rguliers

69

Lreg L(AF)

70

L(AF) Lreg
Soit A=(V,Q,I,F,T) un automate tats finis
Pour chaque qQ, on dfinit le langage Lq des mots qui
admettent un lecture terminale russie issue de q, c-a-d.
{wV* | fF, (w,q)*(,f)}

Base:
est reconnu par (,{i,f},i,{f},)
{} est reconnu par (,{i},i,{i},)
x, {x} est reconnu par (,{i,f},i,{f},{(i,x,f)})

Soit {(q,x1,q1),(q,x2,q2),,(q,xn,qn)}Q lensemble des transitions


issues de q
Alors, Lq=({x1}.Lq1) ({x2}.Lq2) ({xn}.Lqn)
{} si q est final

Induction:
Soient L1 A1=(V1,Q1,I1,F1,T1) et L2 A2=(V2,Q2,I2,F2,T2)
L1L2 (V1V2, Q1Q2{I}, I, F1F2, T1T2{(I,,I1),
(I,,I2)})
L1.L2 (V1V2, Q1Q2, I1, F2, T1T2{(q,,I2) | qF1})
L1* (V1, Q1{I}, I, F1{I}, T1{(q,,I) | qF1}{(I,,I1)})

Langages rguliers

Langages rguliers

=> Lq se dfinit en fonction des langages Lqi : on obtient un


systme dquations ensemblistes sur les langages Lqi
Avec le thorme dj utilis pour les grammaires, on conclue
que LI le langage issu de ltat initial (= L(A)) est rgulier
71

Langages rguliers

72

mondage

Remarque: les tats qui ne sont pas utiles (pas


accessibles ou pas co-accessibles) ne participent
jamais la reconnaissance dun mot car aucune
lecture terminale russie ne peut les employer:

mondage
Algorithme dmondage:
Entre: un automate A=(V,Q,I,F,T)
Sortie: un automate A
1.
2.
3.
4.

Calculer lensemble des tats accessibles A


Calculer lensemble des tats co-accessibles C
En dduire lensemble des tats utiles U := AC
En dduire lensemble des tats inutiles IN := Uc - {I,f}
avec fF (on conserve toujours ltat initial et au moins
un tat final parmi les tats utiles)
5. Supprimer les tats inutiles de lautomate, ainsi que
toutes les transitions o ils apparaissent :
A:=(V, Q-IN, I, F-IN, T-{(q,x,q) | qIN ou qIN})

q pas accessible => w (w,I)*(w,q)


q pas co-accessible => w (w,q)*(,f) avec fF

Le retrait des tats inutiles dun automate


(V,Q,I,F,T) sappelle lmondage de lautomate

Langages rguliers

73

mondage
Calcul des accessibles:

Calcul des co-accessibles:

Entre: un automate (V,Q,I,F,T)


Sortie: un ensemble dtats AQ

Entre: un automate (V,Q,I,F,T)


Sortie: un ensemble dtats CQ

A:=; tmp:={I}
Tant que tmp<> faire
q:=premier_lment(tmp)
A:=A{q}; tmp:=tmp\{q}
Pour chaque (q,x,q)T faire
Si qA Alors
tmp:=tmp{q}
Fin pour
Fin tant que

C:=; tmp:=F
Tant que tmp<> faire
q:=premier_lment(tmp)
C:=C{q}; tmp:=tmp\{q}
Pour chaque (q,x,q)T faire
Si qC Alors
tmp:=tmp{q}
Fin pour
Fin tant que

Langages rguliers

mondage
q4
q1

q6

q9

q7

q2
q3

q5

q8

1. Calcul des accessibles: A={q1,q2,q3,q4,q5,q8}


2. Calcul des co-accessibles: C={q8,q9,q6,q5,q3,q2,q1}
3. Calcul des tats utiles: U= AC = {q1,q2,q3,q5,q8}
4. Calcul des tats inutiles IN= Uc \ {I,f} = {q4,q6,q7,q9}
5. Retrait de tous les inutiles et de leurs transitions
=> Automate mond !

75

AFD = AFN ?

Langages rguliers

76

Dterminisation

Remarque: les automates construits pour


reconnatre les langages rguliers peuvent tre nondterministes (avec -transitions)

Remarque: dans un AFN, un mme symbole peut


conduire dans plusieurs tats diffrents
Ide: crire un AF dont les tats reprsentent des
ensembles dtats de lAFN; ainsi, toute transition
sur un symbole partira dun unique tat (= ensemble
dtats de lAFN) vers un unique tat (= ensemble
dtats de lAFN) => Cet AF sera un AFD

Question: les AFD peuvent-ils reprsenter tous les


langages rguliers galement ?
Rponse: Oui ! A tout AFN correspond un AFD
reconnaissant le mme langage
Dmonstration: en construisant un AFD par
dterminisation de lAFN

Langages rguliers

74

Langages rguliers

Problme: les -transitions ne consomment pas de


symboles comment les liminer ?
77

Langages rguliers

78

Dterminisation

Dterminisation
Algorithme de dterminisation:

On appelle -fermeture dun tat q (not E(q))


lensemble des tats atteignables partir de q par 0
ou plusieurs -transitions,
c-a-d. E(q) ={qiQ | (,q)*(,qi)}

Entre: (V,Q,I,F,T) un AFN


Sortie: (V,Q,I,F,T) un AFD
V:=V, I:=E(I), tmp:={I}, Q:=, F:=, T:= (* initialisations *)
Tant que tmp<> Faire
q := premier_lment(Q)
(* extraction dun tat *)
tmp := tmp\{q}; Q:=Q{q}
(* suppr. de tmp et ajout Q *)
Si q contient fF Alors F := F{f} (* ajout aux tats finaux *)
Pour chaque symbole xV faire
q := {qjQ | qiq, (qi,x,qj)T}
(* construction dun nouvel tat *)
q := E(q)
(* -fermeture de q *)
T:=T{(q,x,q)}
(* ajout dune nouvelle transition *)
Si qQ Alors tmp:=tmp{q}
(* si q na pas t trait,

Ex: E(q1) = {q1} et E(q2)={q1,q2} dans lautomate


b

a
b

q1

q2

Construction inductive de E(q) : E(q) = {q} UiE(qi)


tel que (q,,qi)T

le mettre en attente dans tmp *)

Ex: mme automate, E(q1)={q1} et E(q2)={q2}E(q1)

Fin Pour
Fin Tantque

Gnralisation: E({q1,q2,,qn}) = Ui E(qi)


79

Langages rguliers

Dterminisation

Dterminisation

Exemple:
AFN

80

Langages rguliers

Exemple:
a

q1

q1,q2

q2

q2

q1

a
q1

AFN

q2

q1

q1,q2

q2

q2

q1

AFD

a
q1

q2

I=E(q1)

81

Langages rguliers

Dterminisation

Dterminisation

Exemple:
AFN

Exemple:
a

q1

q1,q2

q2

q2

q1

AFD

82

Langages rguliers

a
q1

AFN

q2

q1

q1,q2

q2

q2

q1

AFD

I={q1}

I={q1}

{q1}

Langages rguliers

83

a
q1

q2

E({q1,q2})

{q1}

Langages rguliers

84

Dterminisation

Dterminisation

Exemple:
AFN

Exemple:
a

q1

q1,q2

q2

q2

q1

AFD

I={q1}

a
q1

AFN

q2

q1

q1,q2

q2

q2

q1

AFD

{q1,q2}

{q1}

I={q1}

{q1,q2}

a
q1

q2

{q1,q2}

{q1}

{q1,q2}

Nouvel tat quil faudra traiter

85

Langages rguliers

Dterminisation

Dterminisation

Exemple:
AFN

Exemple:
a

q1

q1,q2

q2

q2

q1

AFD
I={q1}

86

Langages rguliers

{q1,q2}

a
q1

AFN

q2

q1

q1,q2

q2

q2

q1

AFD
{q1}

I={q1}

{q1,q2}

{q1,q2}

a
q1

{q1}

q2

{q1,q2}

{q1,q2}

87

Langages rguliers

Dterminisation

Dterminisation

Exemple:
AFN

Exemple:
a

q1

q1,q2

q2

q2

q1

AFD

88

Langages rguliers

I={q1}

{q1,q2}

{q1,q2}

E({q1,q2})

a
q1

AFN

q2

q1

q1,q2

q2

q2

q1

AFD
{q1}

{q1,q2}

I={q1}

{q1,q2}

{q1,q2}

{q1,q2}

a
q1

q2

a
{q1}

{q1,q2}

tat dj engendr: pas besoin de traiter nouveau

Langages rguliers

89

Langages rguliers

90

Dterminisation

Dterminisation

Exemple:
AFN

Exemple:
a

q1

q1,q2

q2

q2

q1

AFD

a
q1

AFN

q2

I={q1}

{q1,q2}

{q1,q2}

{q1,q2}

E({q2})

{q1}

q1

q1,q2

q2

q2

q1

AFD

{q1,q2}

a
a

q1

q2

a,b

I={q1}

{q1,q2}

{q1,q2}

{q1,q2}

{q1,q2}

{q1}

{q1,q2}

tat dj engendr: pas besoin de traiter nouveau


91

Langages rguliers

Dterminisation

Minimisation

Exemple:
AFN

q1

q1,q2

q2

q2

q1

AFD

Remarque: infinit dautomates reconnaissant le mme


langage

a
q1

q2

Question: comment dcider si 2 AFD reconnaissent le mme


langage ?
Rponse: en utilisant lAFD minimal pour ce langage

a,b

I={q1}

{q1,q2}

{q1,q2}

{q1,q2}

{q1,q2}

{q1}

92

Langages rguliers

Un automate A est minimal ssi tout autre automate B


reconnaissant le mme langage (L(A)=L(B)) contient au
moins autant dtats

{q1,q2}

Thorme: deux AFD minimaux reconnaissant le mme


langage sont identiques un renommage de leurs tats prs

Aucun nouvel tat engendr: dterminisation termine


Automate dterminis: ({a,b}, { {q1}, {q1,q2} }, { {q1} }, { {q1,q2} },
{({q1},a,{q1,q2}), ({q1,q2},a,{q1,q2}), ({q1,q2},b,{q1,q2})})
Langages rguliers

93

94

Langages rguliers

Minimisation

Compltion

Calculer lautomate minimal correspondant un automate


donn, cest effectuer une minimisation de cet automate

Un AF (V,Q,I,F,T) incomplet peut-tre rendu complet


par introduction dun tat poubelle p tel que:

Pour minimiser un automate, on spare les tats nonquivalents (ou distinguables)

xV, on ajoute (p,x,p) dans T


xV, qQ, (q,x,q) => on ajoute (q,x,p) dans T

Dfinition inductive de lquivalence dtats:

Ex:

Base:
p0q ssi p,qF ou bien p,qQ\F
Induction:
pi+1q ssi piq et (p,x,p),(q,x,q)T => piq
c-a-d. que toute transition sur le mme symbole depuis 2
tats quivalents conduit sur 2 tats quivalents
Arrt: i = i-1 c-a-d. aucun tats distinguables

Thorme : Le calcul des quivalences ne peut se faire que


sur un AFD complet
Langages rguliers

a,b

95

q1
q2

q1
p

p
q2

p
Langages rguliers

a b

b
q1

q2

96

Minimisation

Minimisation
i

Algorithme de minimisation:

Calcul des c.e.

Entre: un AF A=(V,Q,I,F,T)
Sortie: un AFD minimal B=(V,Q,I,F,T)
A := Dterminisation(A)
A := Compltion (A)
Q := {Q\F, F}
Tant que Q est modifi faire
Calculer i+1 partir de i
Q := partition de Q selon i+1
Fin Tant que
I := qQ tel que Iq
F := {qQ | fF et fq}
T := T ramen aux c.e.
B := mondage (B)

(* construction dun AFD complet *)


(* calcul de lquivalence niveau 0 : 0 *)

q1
b

q3

q6

q2

q5

a
b

(* suppression des tats inutiles *)

i
1

97

k
3

j
2

a i f i

f i

a 3 1 5 6 4 4

b i f i

f f f

b 2 1 6 5 6 6

i k

1 3 2 4 5 6

1 3 2 4 5 6

a i

i f f j

a 3 1 5 6 4 4

b j

i f f f f

b 2 1 6 5 6 6

3 = 2 Plus aucun tats sparables


Langages rguliers

98

Nous avons vu 3 reprsentations des langages rguliers :

f
4

Grammaires rgulires (engendre le langage)


Expressions rgulires (dfinit le langage)
Automates tats finis (reconnat le langage)

Les grammaires sont bien adaptes au problme de


gnration; les cycles peuvent tre dtects
Les automates sont bien adapts au problme de
reconnaissance; il existe un automate canonique pour tout
langage rgulier

j
a

b
a,b
i

a,b
k

1 2 3 4 5 6
3 5 1 6 4 4
2 6 1 5 6 6

Question: comment passer des expressions rgulires aux


grammaires et aux automates tats finis ?
99

Langages rguliers

Langages rguliers

E-reg Greg ou AF

100

E-reg Greg ou AF
e = a+b+a.(a+b)*.b

E-reg Greg : preuve que Lreg L(Greg)


=> A toute e-reg on associe une grammaire
rgulire construite inductivement

E-reg AF : preuve que Lreg L(AF)


=> A toute e-reg on associe un automate tats
finis construit inductivement

101

Langages rguliers

1 3 2 4 5 6

Gnration VS reconnaissance (round 4)

1 2 3 4 5 6
3 5 1 6 4 4
2 6 1 5 6 6

1 2 3 4 5 6

(* report des transitions sur les c.e. *)

a
a
b

q5

q4

(* c.e. contenant au moins un final *)

q4

a
a
a

(* c.e. contenant ltat initial *)

a
a

q6
b

Minimisation

a,b

q2

(* classes dquiv. (c.e.) niveau i+1 *)

q3

(* calcul de lquivalence niveau i+1 *)

a 3 5 1 6 4 4
b 2 6 1 5 6 6

q1

(* partir de A pour le calcul des equiv. *)

Langages rguliers

Mise jour de
mondage:
Dtermination
aucun
des
la table
inutile
nouveaux
de
tats initiaux et finaux
transitions

a,b

1 2 3 4 5 6

b
b

Ga=({a},{A},A,{Aa})
Gb=({b},{B},B,{Bb})
Ga+b=({a,b},{C,D,E},C,
{CD|E, Da, Eb})
G(a+b)*=({a,b},{C,D,E,F},F,
{FC|, CD|E,
Da|aC, Eb|bC})
Ga.(a+b)*.b=({a,b},{C,D,E,F,G,H},H,
{HaF|aG, FC, CD|E,
DaG|aC, EbG|bC, Gb})
Ge=({a,b},{A,B,C,D,E,F,G,H,I},I,
{IA|B|H, Aa, Bb,
HaF|aG, FC, CD|E,
DaG|aC, EbG|bC, Gb})

Langages rguliers

102

Greg ou AF E-reg

Greg ou AF E-reg

Il suffit de rsoudre le systme dquations :

2
b

L1 = A1 + B11.L1 + B12.L2 + + B1n.Ln


L2 = A2 + B21.L1 + B22.L2 + + B2n.Ln

Ln = An + Bn1.L1 + Bn2.L2 + + Bnn.Ln

b
1

ou

a
a
b

3
a

issu des tats de lautomate ou des symboles non-terminaux


de la grammaire (cf. preuve L(AF)Lreg ou L(Greg)Lreg)

L1 = b.L2+aL3
L2 = b.L1+aL3
L3 = b.L1+aL3+

Lemme dArden: Lunique solution de lquation L=X+Y.L


est L=Y*.X si Y
Pour obtenir la solution dun systme, on procde par
substitutions successives (limination de variables)

({a,b}, {S1,S2,S3}, S1,


{ S1 bS2 | aS3
S2 bS1 | aS3
S3 bS1 | aS3 |
L1 = bb.L1+ba.L3+a.L3
L3 = b.L1+a.L3+
L1 = bb.L1+(ba+a).L3
L3 = a*(b.L1+)
L1 = bb.L1+(ba+a).a*.(b.L1+)
L1 = (bb+(ba+a)a*b).L1+(ba+a)a*
L1 = (bb+(ba+a)a*b)*(ba+a)a*

103

Langages rguliers

Langages rguliers

Grammaires, automates, expressions

Dcider si un langage est rgulier

En
g
pa en
r dr

ind
uct
iv

tion

compltion
mondage
dterminisation
minimisation
105

Langages rguliers

Dmontrer que L est rgulier

106

Dmontrer que L nest pas rgulier


1. Dmontrer quune proprit ensembliste ou
algbrique nest pas prserve:

1. Trouver lexpression/grammaire/automate : pas de


mthode, suivre son intuition

Soit L un langage connu rgulier, montrer que


L.L non rgulier
LL non rgulier
Ln non rgulier, n0
LL non rgulier
L* non rgulier
Lc non rgulier

2. Montrer que lexpression/grammaire/automate


dfinit/engendre/reconnat bien L : si L est dfini
par une proprit P (c-a-d. L={w* | P(w)}), il faut
montrer que le langage dfini/engendr/reconnu
vrifie bien P

L-L non rgulier

Quelques langages connus non-rguliers:


{w{a,b}* | w=anbn, n0}
{w{a,b,c}* | w=anbncn, n0}
Ex: L= {w{a,b}* | |w|a=|w|b} nest pas rgulier car
L={w{a,b}* | w=anbm, n,m0} est rgulier (df. par a*b*)
et LL={w{a,b}* | w=anbn, n0} qui nest pas rgulier

Ex: L= {w{a,b}* | |w| paire} est dfini par e=((a+b).(a+b))*


car si v vrifie e, alors v=x1.y1.x2.y2.xn.yn avec xi, yi
{a,b} ; donc |v| = 2n
Langages rguliers

Deux approches:

2. Dmontrer quil nest pas rgulier


Preuve: En dmontrant que L ne vrifie pas une certaine
proprit des langages rguliers

Automates tats finis

Langages rguliers

Question: un langage donn L est-il rgulier ?

1. Dmontrer quil est rgulier


Preuve: En exhibant une expression rgulire, une
grammaire rgulire ou un automate tats finis qui
dfinit/engendre/reconnat L

Co
nst
ruc

ns
tio
ua
q
d

iv
uct
ind

Sy
st
m

tion

us
nn
co
Re par

Grammaires rgulires

m
st
Sy

ruc
nst
Co

Dfinis
par

qu
at
io
ns

Expressions rgulires

Langages rguliers

104

107

Langages rguliers

108

10

Dmontrer que L nest pas rgulier

Dmontrer que L nest pas rgulier

2. Dmontrer que le lemme de la pompe nest pas vrifi

L ne vrifie pas le lemme de la pompe si


n0, wL tq |w|n, u1,v,u2* tq w=u1.v.u2,
|v|>0 et |u1.v|n, i0 tq u1viu2 L

Lemme de la pompe: , L sur , L rgulier =>


n0, wL tq |w|n => u1,v,u2* tq w=u1.v.u2 et :

i0, u1viu2 L
|v|>0
|u1.v|n
Autrement dit: tout mot suffisamment long dun langage rgulier contient
un facteur non vide qui peut tre rpt autant de fois quon veut
(Ide de) preuve : les AF ont un nombre fini dtats !

autrement dit: tout mot suffisamment long ne contient aucun


facteur non-vide pouvant tre rpt autant de fois quon
veut, i.e. pour chaque facteur, il existe une rptition qui
engendre un mot nappartenant pas au langage

Quand w est factoris en u1.v.u2, u1 ou u2 peut tre mais la


condition 2 assure que v.
La condition 3 assure que le prfixe u1.v est de longueur au
plus n.
Langages rguliers

109

Dmontrer que L nest pas rgulier

La thorie des langages formels dfinit les moyens


de communication prcis avec les machines
Les langages formels sont des ensembles de mots
auxquels on peut appliquer des oprations
ensemblistes et algbriques
On distingue plusieurs classes de langages, dont les
langages rguliers
Les langages rguliers peuvent tre reprsents par
expressions rgulires, grammaires rgulires et
automates tats finis
On dispose de traducteurs entre ces reprsentations
On sait dcider (partiellement) si un langage est
rgulier ou pas

Considrer un entier n0
Trouver un mot w bien choisi tel que |w|n
Considrer toutes ses factorisations w=u1.v.u2 (|v|>0 et |u1.v|n)
Pour chacune, montrer quil existe i tel que u1.vi.u2 L

Ex: montrons que {w{a,b}* | w=apbp, p0} nest pas rgulier


1. Considrons n0
2. Prenons w=anbn qui vrifie bien |w|n
3. Toutes ses factorisations w=u1.v.u2 (|v|>0 et |u1.v|n) vrifient
ncssairement v=ak, 0<kn
4. Prenons i=2 et montrons que u1.v.v.u2 L

v=ak => |u1.v.v.u2|a = |u1|a+2|v|a+|u2|a = |w|a + |v|a = n+k > n car k>0
v=ak => |u1.v.v.u2|b = |u1|b+2|v|b+|u2|b = |w|b + |v|b = n
Donc |u1.v.v.u2|a |u1.v.v.u2|b => u1.v.v.u2 L
Langages rguliers

110

Conclusion

Cette dmonstration peut tre vue comme suit:


Etant donn le langage L,
1.
2.
3.
4.

Langages rguliers

111

Langages rguliers

112

11