Correction EXAMEN Aspects Théoriques de l`Informatique 1ère

Correction EXAMEN Aspects Théoriques de l'Informatique
1ère session 2014-2015
L3 Info – durée 3h – documents de cours autorisés, sans calculatrice
Exercice 1 (5 pt) : On veut reconnaître, pour un langage de programmation de type C, des constantes
entières écrites en binaire (on ne s'intéresse pas aux dépassements de capacité et donc une constante peut être
exprimée avec un nombre quelconque de 0 et de 1).
1. On vous propose la représentation suivante : utiliser une lettre b minuscule suivie de 0 et de 1,
comme dans : ma_var = b10001010 ; Ce choix de représentation vous paraît-il pertinent ?
Commentez et expliquez votre avis.
Ce choix n'est pas pertinent, car il introduit une ambiguïté entre noms de variables et constantes
binaires. Par exemple b1 pourrait être soit une variable soit une constante.
Finalement on se décide pour la représentation suivante : une constante commence par un 0, suivi de b, suivi
d'une parenthèse ouvrante, suivie de 0 et de 1, suivis d'une parenthèse fermante, comme dans : ma_var =
0b(10001010) ;
2. Peut-on reconnaître ces constantes par un automate fini ?
Oui, il y certes des parenthèses qui se répondent, mais en nombre borné : on peut donner un
automate fini, ou une expression rationnelle (puisqu'on sait que Rec = Rat)
par exemple : constante_binaire = 0b\( (0+1)+ \)
3. Peut-on engendrer ces constantes par une grammaire régulière ou par une grammaire algébrique (si
les 2 sont possibles, répondez par le type de grammaire le plus simple) ? Précisez votre réponse
précédente en donnant une grammaire engendrant ces constantes.
Par une grammaire régulière, évident si on a répondu oui à la question précédente, par exemple
G=<A, {A,},{0,1,b,(,)}, {A-> 0B, B->bC, C->(D, D->0E|1E, E->0E|1E|) } >
Exercice 2 (6 pt) : Cet exercice est indépendant du précédent. Soit une donnée binaire par exemple d=1010
pour aider à la retrouver dans un flux de communication entièrement binaire, on la transforme par une
fonction f qui ajoute en préfixe autant de 1 qu'il y a de bits dans la donnée, suivis d'un 0, suivi de la donnée :
pour d, on obtient f(d)=111101010 (c'est à dire 4 fois 1, puis 0, puis la donnée qui fait 4 bits). De même si on
a d'=100111, alors f(d')=1111110100111 (6 fois 1, puis 0, puis les 6 bits de la donnée).
Soit X={0,1} et X* l'ensemble des mots sur l'alphabet X. On note F={f(d) tel que d est dans X*}, l'ensemble
des images par notre fonction f des mots de X*.
1. Indépendamment de F, que peut-on dire du langage X* par rapport à la hiérarchie de Chomsky ?
Il est régulier, ce sont les mots engendrés par l'E.R. (0+1)*
2. Donnez un argumentaire pour justifier que F ne peut pas être régulier.
Il faut faire correspondre autant de 1 avant le 0 du milieu que de bits de données après. C'est donc
une forme du type a^nb^n, donc algébrique et pas régulier.
3. Prouvez que F n'est pas régulier en utilisant le lemme de l'étoile (vous ferez l'intersection de F avec
par exemple 1*0* pour simplifier la preuve).
On sait que l'intersection de 2 réguliers est un régulier. Si F est régulier, alors E=F ᑎ 1*0* = { mots
de la forme 1^n0^(n+1) quelque soit n entier naturel} doit être régulier et vérifier le lemme de
l'étoile.
On prend un mot w de E suffisamment grand par rapport à N le nombre de variables d'une
grammaire régulière engendrant E, par exemple 1^N0^(N+1). Il devrait y avoir une factorisation
w=xyz, où y serait facteur itérant. Il y a seulement trois cas possible
• x dans 1*, y dans 1+, z dans 1*0* : on a |xyyz|_1 > |xyyz|_0 – 1 (on retire 1 pour décompter le
0 "du milieu") donc xyyz n'est pas dans E, y pas un facteur itérant ;
x dans 1*0*, y dans 0+, z dans 0* : on a |xyyz|_1 < |xyyz|_0 – 1 (on retire 1 pour décompter le
0 "du milieu") donc xyyz n'est pas dans E, y pas un facteur itérant ;
• x dans 1*, y dans 1+0+, z dans 0* : on a xyyz dans 1+0+1+0+ donc pas dans E, et y pas un
facteur itérant ;
Conclusion : E n'est pas régulier donc F n'est pas régulier.
•
4. Donnez une grammaire engendrant les mots de F
Elle va être algébrique – voir 2) :
A -> 1A0 | 1A1 | B
// crée autant de 1 à gauche que de bits quelconques à droite
B -> 100 | 101
// dernier bit de donnée (donc toujours non vide) et 0 du milieu
1
A
Exercice 3 (3 pt) : Déterminisez
l'automate suivant (donner la table de
déterminisation et l'automate résultat) :
1
1
B
D
0,1
1
1
0
C
1
Table de transition : (l'ordre des lignes est libre)
0
1
{A} initial, final {C}
{B,C}
{C}
{D}
{A,B}
{D}
∅ (état puits)
{A}
{B,C}
{D}
{A,B,C}
{A,B} final
{C}
{A,B,C}
{A,B,C} final
{C,D}
{A,B,C}
{C,D}
{D}
{A,B,C}
Exercice 4 (3 pt) : Minimisez l'automate sur {0,1} donné par la table de transition suivante :
états
0
1
A initial et final
B
C
B final
A
C
C
A
D
D final
E
B
E
E
E
Vous donnerez la table de minimisation et l'automate résultat.
En notant ẟ la fonction de transition donnée par la table ci-dessus, on construit la table de minimisation
suivante. En partant de la partition initiale états non terminaux / terminaux, on observe que la lettre 0 est
"séparante", et que la lettre 1 ne l'est plus.
initialement
C
E
A
B
D
0
ẟ(C,0)=A
ẟ(E,0)=E
ẟ(A,0)=B
ẟ(B,0)=A
ẟ(D,0)=E
1
ẟ(C,1)=D
ẟ(E,1)=E
ẟ(A,1)=C
ẟ(B,1)=C
ẟ(D,1)=B
La table de transition de l'automate minimal sera donc :
0
1
{A, B} initial et final
{A, B}
{C}
{C}
{A, B}
{D}
{D} final
{E}
{A, B}
{E}
{E}
{E}
Notons que {E} n'est pas co-accessible (on ne peut plus reconnaître un mot une fois en E. On peut donc
l'émonder (le retirer) ou le fusionner avec l'état puits.
Exercice 5 (3 pt) :
• Soit g(n) une fonction calculable totale sur ℕ l'ensemble des entiers naturels : on dispose d'une
machine de Turing (ou d'un programme) qui calcule g(n), s'arrête et renvoie toujours le résultat
quelque soit la valeur de l'entier n.
• Soit l'ensemble A = { x ϵ ℕ tel que il existe y ϵ ℕ avec y > x et g(y) < g(x) }.
• L'ensemble A est dit "récursivement énumérable" si il existe une machine de Turing (ou un
programme) qui prend en paramètre un entier n et s'arrête toujours si n appartient à A (mais ne
s'arrête pas forcément si n n'est pas dans A).
Montrez en donnant un programme (en C ou en pseudo-code) que A est récursivement énumérable.
D'après l'énoncé on a une fonction pré-définie d'en-tête (à la C) :
int g(int n) ;
On va écrire une fonction qui détermine si un entier est dans A :
vois determine_A(int x) {
for (int y = x+1 ; ; y++) { // boucle infinie
if (g(y) < g(x))
break ;
}
printf("%d est dans A\n", x) ;
}
– FIN –