Nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Prnom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Groupe . . .

ou Numro dtudiant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . si lexamen est anonyme

RICM3 Automates et Grammaires

Dure : 2h00, sans documents.

Tous les appareils lectroniques sont interdits lexception des montres

Le barme est donn titre indicatif
Le sujet comporte 7 exercices indpendants
Le sujet est sur 42 mais il suffit davoir 30 pour avoir la note maximale, ce qui vous
donne le choix et vous permet de faire limpasse sur des exercices.
Commencez par lire tout le sujet pour reprer les questions faciles

Exercice 1 : Un automate ( nombre) dtats fini qui reconnat ... (3.5 pt)
Q1. (1 pt)

Donnez un automate ( nombre) dtats fini qui reconnat le langage a .b .a .b .

Q2. Algorithme (2.5 pt)

Expliquez comment construire un automate ( nombre) dtats fini A
qui reconnat les mots sur lalphabet {a, b, c} qui contiennent b et qui contiennent la squence ac ou
la squence ca. Rdigez soigneusement votre rponse.


Indication : On ne demande pas lautomate A mais simplement de donner deux automates A1 et A2

et les oprations effectuer pour obtenir A partir des automates A1 et A2 .
solution
On constuit lautomate non-dterministe A1 qui reconnat les mots contenant b. On constuit lautomate nondterministe A2 qui reconnat les mots contenant les squences ac ou ca. On construit lautomate A comme le
produit des automates A1 et A2 . Lautomate A = A1 A2 reconnat le langages sL(A1 ) L (A2 ) cherch.
?

A1 =

A2 =


?
c

 

Exercice 2 : Algorithmes


(5 pt)

Indication : On ne demande pas de code mais un description prcise des tapes des algorithmes.

On considre un aef A sur un alphabet possdant un seul tat initial qi et un ensemble Acc dtat
accepteur. Vous supposerez ( votre convenance) que lautomate est dcrit par une liste de transitions
ou par un tableau.
Accessibilit
Q3. (0.5 pt)
initial.

Dessinez un automate qui comporte deux tats qui ne sont pas accessibles depuis ltat

Q4. (1.5 pt)

Dcrire un algorithme qui permet dliminer dun aef A les tats qui ne sont pas
accessibles depuis son tat initial qi .
Langage vide
Q5. (1.5 pt)
En dduire un algorithme qui permet de dterminer si un aef A reconnat le langage
vide, cest--dire si L (A) =
Langage universel
Q6. Algorithme (1.5 pt)
le langage universel .

En dduire un algorithme qui permet de dterminer si un aef A reconnat

Exercice 3 : Minimisation

(3.5 pt)

Minimisez lautomate A ci-dessous en justifiant les tapes de la minimisation.

Q7. (2.5 pt)

A
a
b
c

i1

4
1
5

2a
4
1
6

3
3
3
3

4 5a
4 4
6 6
6 6

6
4
6
2

solution
Minimisation:
* initial partition = { {1,2,3,4,5,6} }
states 1 ~/~ 2 : NOT same accepting status
So, {1,2,3,4,5,6} is splitted into {1,3,4,6} |_| {2,5}
states 1 ~/~ 3 : NOT same behavior on symbol c
So, {1,3,4,6} is splitted into {1,6} |_| {3,4}
states 3 ~/~ 4 : NOT same behavior on symbol b
So, {3,4} is splitted into {3} |_| {4}
* final partition = { {1,6} , {2,5} , {3} , {4} }

Q8. (1 pt)

Dessinez lautomate minimis.

Exercice 4 : Grammaire des squences dinstructions

(4 pt)

On souhaite dfinir un langage de programmation qui respecte les rgles suivantes :

1. Un programme est une squence dinstructions (ventuellement vide) spares par des pointvirgules
2. Une instruction est soit une affectation, soit un if, soit un return
3. Linstruction return ne peut apparatre quen fin de squence et nest pas obligatoire
4. Loprateur daffectation est not :=, loprateur dgalit est not ==
5. Le test dun if est forcment un test dgalit entre deux expressions

{2,5}

a b c

cc

{1,6}

{3}

b a

bc

{4}

Figure 1 Exercice 3:Q8. lautomate A minimis

6. Les expressions sont formes de variables, de valeurs, des oprateurs + et *, et de parenthses
(correctement places).
7. On distingue deux formes de if
Pour la forme if...then...fi sans partie else, la partie then doit alors contenir exactement une affectation et se termine par fi
Pour la forme if...then {...} else {...}, les accolades sont obligatoires et peuvent
contenir tout un programme
Q9. (4 pt)

Donnez la grammaire de ce langage.

Indication : On suppose que la grammaires des noms de variables et celles des valeurs sont dj dfinies
et quelles ont respectivement pour germes les non-terminaux Var et Val.
solution
Prog Seq Ret
Ret "return(" Expr ")" | 
Seq  | Inst ";" Seq
Inst Aff | If
Aff Var ":=" Expr
If "If" Cond "then" te
te Aff "fi" | "{" Prog "}" "else"
Cond Expr "==" Expr
Expr "(" Expr ")" | vv OpExpr
vv Var | Val
OpExpr  | Op Expr
Op "+" | "*"

"{"

Prog

Exercice 5 : Un automate une pile qui reconnat...

(6 pt)

"}"

(20min)

Soit L le langage form des mots sur lalphabet = {a, b, c} qui ont autant de a que de b (sans tenir
compte de lordre des lettres).
Q10. (0.5 pt)
Donnez trois mots de qui appartiennent au langage L et trois mots de qui
nappartiennent pas L. En particulier, que dire du mot  ?
solution

, c, abc L
a, b, abb
/L

Q11. (2.5 pt)

Donnez un aup qui reconnat le langage L.

version non-dterministe
b
/ b

a
/ a


/ 2
_h

a
b

/ b

a /

version dterministe
a
b

/
b
a
/

c
/

/ 1
c
/


7 2_
'

a
/

b
/ b

a ,
a
/

Q12. (1.5 pt)

a
a

b
b

Votre aup est-il dterministe ? Justifiez soigneusement votre rponse.

solution

Lautomate est dterministe car dans chacun des tats de lautomate, il ne peut y avoir plusieurs transitions
possibles. Dans ltat 1, les lettres reconnues par les transitions sont toutes diffrentes. Dans ltat 2, les transitions qui reconnaissent la mme lettre (2 transitions possibles pour a, idem pour b) le sommet des piles est
diffrent ( a pour lune des transitions sur a et b pour lautre transition sur a).

Q13. Question de cours (1.5 pt)

automate une pile A .

Rappelez les conditions pour quun mot m soit reconnu par un

solution
Un mot m est reconnu par un automate une pile A si il existe une excution de A qui commence dans ltat
initial de A avec une pile vide qui consomme toutes les lettres du mot m et atteint un tat accepteur avec une
pile vide.

Exercice 6 : Complmentaire dune expression rgulire

(10 pt)

(30min)

On considre lalphabet = {a, b, c}.

Q14. (1 pt)

Donnez lautomate T de Thompson associ lexpression rgulire a .b + a.c.

solution


x
?

T =

/

Q15. (1 pt)
Donnez un automate A non-dterministe et sans -transitions correspondant lexpression rgulire a .b + a.c.
solution
a

/ 1

A=


3

/ 2

 
/ 4

Q16. (2.5 pt)

Dterminisez lautomate A de la question prcdente. Donnez les tapes du calcul
sous la forme dun tableau puis dessinez lautomate.
solution
a

AD =

{1}

{ 2,3 }

b,c

"  |


{2}

{4}

Complmentaire dune expression rgulire Soit e une expression rgulire.

On dfinie le lan

gage associe lexpression rgulire ![e] de la manire suivante : L ![e] = L (e)
Q17. (0.5 pt)

Dfinissez L ![e] en une phrase.
solution

L ![e] est lensemble de tous les mots forms des lettres a, b, c priv des mots reconnus par lexpression
rgulire e.

Q18. (1.5 pt)

vos calculs.

Donnez lautomate B correspondant lexpression rgulire ![a .b + a.c] . Expliquez

solution
Pour obtenir lautomate B, on complte lautomate AD et on prend le complmentaire en inversant le statut
des tats (accepteurs non-accepteurs).
a,b,c

puit o
b
<
c

a
c

B=

{1}

a
b

{ 2,3 }

b,c

"  |


{2}

a,b,c

{4}

Q19. (1.5 pt)

Donnez les quations dArden correspondant lautomate B.

solution

L{ 1 }

L{ 2,3 }
L{ 2 }

{4}

L{ puit }

=
=
=
=
=

a L{ 2,3 } + b L{ 4 } + c L{ puit } + 
a L{ 2 } + (b + c) L{ 4 } + 
a L{ 2 } + b L{ 4 } + c L{ puit } + 
(a + b + c) L{ puit }
(a + b + c) L{ puit } + 

Q20. Algorithmique (2 pt)

Expliquez les tapes dun algorithme permettant de convertir une
expression rgulire E contenant des oprateurs ! en une expression rgulire sans oprateur !.


Indication : Lexpression rgulire peut contenir plusieurs symboles !.

![a + b] . ![c] + ![c .d] ] .
Comme, par exemple, ![
solution
Pour liminer les ! dune expression rgulire E qui contient des sous-expressions rgulires ![e], on dfinit
une fonction ThompsonAut qui construit lautomate de Thompson de e. Lorsquelle rencontre un expression
rgulire de la forme ![e] elle procde comme suit :
def

T hompsonAut( ![e] ) = Complementaire(Completer(Determiniser(EliminerEpsilon(T hompsonAut(e)))))

Autrement dit,
on constuit lautomate Ae de Thompson de e (appel rcursif)
on limine les -transitions, on dterminise, on complte et on prend le complmentaire de lautomate Ae .
Soit AC
e lautomate ainsi obtenu.
On construit lautomate de Thompson correspondant E o lexpression rgulire ![e] est remplace par
lautomate AC
e .
Lorsquon a obtenu lautomate AE associ E, on le traduit sous forme dun systme dquations quon rsout
grce au lemme dArden. Lexpression rgulire associe ltat initial de lautomate AE est alors lexpression
rgulire cherche. Elle correspond E et ne contient plus doprateur !.

Exercice 7 : Grammaires attribues : un compilateur optimisant

(10 pt)

Le but de cet exercice est dcrire un compilateur optimisant qui traduit des squences daffectations
en squence de let...in... Ocaml. Loptimisation consiste effectuer durant la compilation tous les
calculs qui peuvent ltre, cest--dire ceux qui ne dpendent que de constantes et de variables dont la
valeur est calculable. Cette technique classique des compilateurs optimisants est appele propagation de
constantes. Elle amliore de manire significative les performances du code gnr comme le dmontre
les exemples ci-dessous.
Exemples :
- Le programme P1 suivant est compil en une constante 8 ;; puisque tous les calculs peuvent tre
effectus durant la compilation car les valeurs de toutes les variables sont connues au moment de
la compilation.
programme P1
programme gnr par la grammaire attribue
x:= 0 ;
u:= 1 ;
8 ;;
v:= u + u ;
y:= x + 1 ;
z:= y + x + v + 1 ;
return(x+y+z+v+u) ;
- Le programme P2 ci-dessous est compil en un programme Ocaml simplifi qui utilise moins de
mmoire puisque les variables u et v ne sont plus utilises.
programme P2
programme gnr par la grammaire attribue
u:= 1 ;
v:= u + u ;
let y = x+1 in
y:= x + 1 ;
let z = y+x+3 in
z:= y + x + v + 1 ;
x+y+z+3 ;;
return(x+y+z+v+u) ;

Principe Chaque fois que la valeur dune variable est connue (par exemple lors dune affectation
x:=0) on ajoute le couple (variable, valeur) dans la liste V AV des variables ayant une valeur. .
Chaque fois quon rencontre une expression contenant une variable, on regarde dans la liste V AV si la
valeur de la variables est connue
1

Prog "return("
2

Prog Aff

";"

":="

Aff Var

Expr

Expr VarOuVal

") ;"

Prog

Expr
PlusExpr

VarOuVal Var
6

VarOuVal Val
7

PlusExpr 
8

PlusExpr "+"
Q21. (1.5 pt)

Expr

Dessinez larbre de drivation qui permet de reconnatre le programme :

x:=0 ; return(x+1) ;
Indiquez chaque drivation le numro de la rgle utilise.
solution

Prog
2
Aff
";"
Var ":=" Expr
";"
x ":=" Expr
";"
":=" Val PlusExpr
";"
x ":=" 0 
";"
x ":=" 0 
";"
x ":=" 0 
";"
x ":=" 0
";"

Prog
"return("
"return("
"return("
"return("
"return("
"return("
"return("

Expr ") ;"

Expr ") ;"
VarOuVal PlusExpr ") ;"
Var "+" Expr ") ;"
x "+" Val PlusExpr ") ;"
x "+" 1  ") ;"
x "+" 1 ") ;"

Construction du compilateur optimisant par ajout dattributs la grammaire On dfinit

le type Ocaml eval qui permet de reprsenter le rsultat dvaluation dune expression et distingue les
trois cas possibles :
un entier I(i) si lexpression se rduit une constante i
une chane de caractre S(s) si certaine variable de lexpression nont pas une valeur constante
Eps dans le cas de la rgle 6 qui reconnat 
On dfinit le type Ocaml vav des variables ayant une valeur comme une liste de couples (variable,valeur)
Le germe Prog de la grammaire doit retourner une chane de caractre qui reprsente le programme
Ocaml gnr lors du calcul des attributs.
type Ocaml utiles pour la suite
type vav = (string * int) list
type eval = S of string | I of int | Eps
Q22. (1 pt)

Compltez le type des non-terminaux

Prog : stream vav (vav string)

Aff : stream vav (vav string)
Expr : stream vav eval
PlusExpr : stream vav eval
VarOuVal : stream vav eval
Var : stream string
Val : stream int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Q23. (1 pt)
crivez en Ocaml la fonction find qui sera utilise pour le non-terminal VarOuVal
pour rechercher si une variable x reconnue par Var dans le stream est dans la liste des variables ayant
une valeur. La fonction find : string vav eval qui prend en paramtre un nom de variable
x, la liste ` des variables ayant une valeur et retourne une valeur de type eval (une chane ou un entier)
selon que la variable x a ou non une valeur dans la liste `.
solution
let rec (find: string -> vav -> eval) = fun x l ->
match l with
| [] -> S(x)
| (v,i)::l -> if v=x then I(i) else find x l

Q24. (0.5 pt)

crivez en Ocaml la fonction compilateur : stream string qui prend en paramtre le flot analyser stream et qui fournit en retour le programme Ocaml gnr par la grammaire
attribue.
Indication : On suppose que les non-terminaux correspondent des fonctions Ocaml avec le type quils
ont reu la question prcdente.

solution
let (compilateur: stream string) = fun stream ->
let (_,o) = Prog stream [ ]
in o ;;

Q25. (6 pt)
Ajoutez des attributs la grammaire des squences dinstructions ci-dessus de manire
obtenir un compilateur optimisant.
Indication : On fournit une grammaire complter avec le calcul des attributs crit en Ocaml avec
des match ... with. Mais si vous prfrez, vous pouvez rpondre la question en crivant des parsers
Ocaml.
solution
{`} Prog {(`0 , o)}

{`} Prog {(`0 , o)}

"return(" {`} Expr {e} ") ;"

match e with

";;"
`0 := `, o := | S(s) s

| I(i) string-of-int i
2
{`} Aff {(`1 , a)} ";" {`1 } Prog {(`2 , o0 )}

{`} VarOuVal {e}

{`0 := `2 , o := a o0 }
3
Var {x} ":=" {`} Expr {e}

match e with

| S(s) `0 := `,
o := "let" x "=" s "in"

| I(i) `0 := (x, c) :: `, o := ""

4
{`} VarOuVal {e1 } {`} PlusExpr {e2 }

match (e1 , e2 ) with

| S(s1 ), S(s2 ) S(s1 "+" s2 )

|
S(s),
I(i)

S(s

"+"

(string
of
int
i)
0
e :=
| I(i1 ), I(i2 ) I(i1 + i2 )

| I(i), S(s) S((string-of-int i) "+" s)

| e1 , Eps e1
5
Var {s}

{`} VarOuVal {e}

{e := find s `}
Val {i}

{`} Aff {(`0 , o)}

{`} Expr {e0 }

{`} PlusExpr {e }

{e := I(i)}


{`} PlusExpr {e0 }

{e0 := Eps}
"+" {`} Expr {e}

{e0 := e}