IFT 313 Introduction aux langages formels Froduald Kabanza

IFT 313 Introduction aux langages formels Froduald Kabanza Département d’informatique Université de Sherbrooke planiart. usherbrooke. ca/kabanza/cours/ift 313 Convertir un AFN en un AFD

Rappel IFT 313 © Froduald Kabanza 2

Sujet couvert • Convertir un automate fini non-déterministe en un automate fini. déterministe. • Simuler un AFN IFT 313 © Froduald Kabanza 3

Références [1] Sudkamp, T. A. . Languages and Machines. Third Edition. Addison-Wesley, 2005. – Sections 5. 6. [2] Appel, A. and Palsberg. J. Modern Compiler Implementation in Java. Second Edition. Cambridge, 2004. – Section 2. 4 [3] Wolper, P. Introduction à la calculabilité, 3è édition. Dunod, 2006 – Section 2. 6 [4] Aho, A. , Lam, M. , Sethi R. , Ullman J. Compilers: Principles, Techniques, and Tools, 2 nd Edition. Addison Wesley, 2007. – Sections 3. 7. 1 à 3. 7. 3 IFT 313 © Froduald Kabanza 4

Élimination du non-déterminisme - La méthode pour convertir un AFN en AFD est appelée « subset construction method » en anglais. - La méthode consiste à grouper des ensembles d’états de l’AFN en un seul état de l’AFD : + L’idée est de simuler l’exécution parallèle de l’AFN sur une entrée donnée. + À chaque étape, nous avons un ensemble d’états dans lequel l’AFN pourrait se trouver si on considérait toutes ses exécutions nondéterministes. + Ces états représentent un état de l’AFD. - Nous allons encore utiliser cette technique plus tard pour l’analyse syntaxique LR. IFT 313 © Froduald Kabanza 6

Idée de base - Il y a deux différences fondamentales entre un AFN et un AFD : + Transitions sur des chaînes de plus d’un caractère. + Non-déterminisme: + plusieurs transitions partant d’un même état, sur le même symbole. + transitions sur la chaîne vide (‘’, aussi notée ε). - Pour obtenir un AFD à partir d’un AFN: - Nous commençons par remplacer des transitions sur des chaînes de plus d’un caractère. - Nous éliminons ensuite les transitions non déterministes. IFT 313 © Froduald Kabanza 7

Idée de base : transitions sur des chaînes - L’exemple suivant illustre la procédure pour éliminer les transitions avec des chaînes de caractères: abc 1 1 IFT 313 a 3 b 2 4 c 2 © Froduald Kabanza 8

Idée de base : éliminer le non-déterminisme - L’idée pour éliminer le non-déterminisme est de construire un AFD qui à chaque étape de son exécution mémorise les états dans lesquels l’AFD se trouverait potentiellement avec le même input. - Donc un état de l’AFD est un sous-ensemble des états de l’AFN tel qu’illustré par les exemples suivants. (a) a 1 a 2 b 3 a a {1} b b IFT 313 {1, 2} (b) a 1 a 2 ε 3 a b [ab] {1, 3} 4 b a b {4} [ab] {1, 2, 3} a {3} © Froduald Kabanza 9

Fermeture-ε (ε-closure) - Pour définir l’algorithme d’élimination du non-déterminisme plus formellement, la notion de ε-closure est nécessaire. - Étant donné un ensemble S d’états de l’AFN, ε-closure(S) est l’ensemble des états atteignables dans l’automate, à partir d’un état dans S, et sans consommer un symbole d’entrée; c-à-d. , en suivant seulement des transitions ε. - Il va de soi que S est dans ε-closure(S). - Par extension, pour un état z, ε-closure(z) = ε-closure({z}) IFT 313 © Froduald Kabanza 10

Définitions préliminaires - Soit succ(s, c) les états successeurs de s sous la transition c - Par définition : ε-closure(S) = S È {s | s dans succ(s’, ε) avec s’ dans S} - On peut maintenant définir l’algorithme epsilon-closure IFT 313 © Froduald Kabanza 11

Algorithme epsilon. Closure - Entrée : + S : un sous-ensemble des états de l’AFN + succ : la relation des transitions de l’AFN - Sortie : ε-closure(S) - Méthode : S 1 = S do { S 2= S 1 ; // S 2 devient S 1 au début de l’itération S 3 = {}; // S 3 est l’ensemble des états atteignable à partir de S 2 for (s in S 2) S 3 = union(S 3, succ(s, ε)); S 1 = union(S 2, S 3); } while (! S 1. equals (S 2)); // jusqu’à plus de nouvel état atteignable IFT 313 © Froduald Kabanza 12

Algorithme replace. String. Transitions - Entrée : Un AFN X 1 =(N 1, A, R 1, n 0, F) - Sortie : Un AFN X 2=(N 2, A, R 2, n 0, F) avec transitions à un caractère ou ε - Méthode : N 2=N 1; R 2=R 1 ; Pour toute transition (s, u, t) dans R 2 telle que u =a 1…ak (k>1) + supprimer (s, u, t) de R 2 + ajouter des nouveaux états s 1, s 2, …, sk-1 dans N 2 + ajouter de nouvelles transitions (s, a 1, s 1), …, (sk-1, ak, t) à R 2 IFT 313 © Froduald Kabanza 13

Algorithme remove. Nondeterminism - Entrée : Un AFN X =(N, A, R, n 0, F) avec transitions à un caractère ou ε - Sortie : Un AFD Y=(D, A, T, d 0, P) - Méthode : + D = 2 N // L’ensemble des sous-ensembles de N + d 0 = ε-closure(n 0) + P = {d dans D | l’interesction de d et F est non vide} // c-à-d. , ensembles des états d ayant un état accepteur + T est définie comme suit: Pour chaque a dans A et d dans D È T[d][a] = ε-closure ( {n’|(n, a, n’) R}) nÎd // c-à-d. : T[d][a] est la fermeture-epsilon des états atteignable dans // l’automate X à partir d’un état dans d, le long d’une transition // étiquetée a. IFT 313 © Froduald Kabanza 14

Algorithm remove. Nondeterminism - Pour donner une description plus algorithmique : Dtrans(d, a) = epsilon. Closure ( È trans(n, a)) nÎd - Où trans est la relation de transition de l’AFN X. - Autrement dit, il y a une transition de di à dj, étiquetée a, si et seulement si dj=Dtrans(di, a) IFT 313 © Froduald Kabanza 15

Algorithm remove. Nondeterminism - Entrée : AFN (N, A, R, n 0, F) - Sortie : AFD (D, A, T, d 0, P) - Méthode : P {d dans D | l’interesction de d et F est non vide} //défini comme avant; d 0 = ε-closure(n 0) D={d 0} et d 0 est non marqué while (il y a un état non marqué d in D) { marquer d; for (chaque symbole a dans A) { d’= Dtrans(d, a); if (d’Ï D) {ajouter d’ comme état non marqué dans D; } T[d][a] = d’; }} IFT 313 © Froduald Kabanza 16

Récapitulation - construct. DFAFrom. NFA(NFA) ¬ remove. Nondeterminism(replace. String. Transitions(NFA)). - À la fin de la construction, les états de l’AFD sont remplacés par des nombres. - D’autres simplifications sont effectuées sur l’AFD : minimisation. IFT 313 © Froduald Kabanza 17

Exemple (AFN) f 2 i 1 a. . . 4 ε ε z 9 ε 0. . . 9 ε [a-z] 5 ε ε 10 8 ID ε NUM ε 13 7 ara y c h an IFT 313 . . 6 [0 -9] 12 0. . . 11 9 cte r 14 IF 3 . 15 ERROR ε © Froduald Kabanza 18

Exemple (AFD correspondant) f {2, 5, 6, 8, 15} i {1, 4, 9, 14} ID [a-hj-z] [0 -9] other {3, 6, 7, 8} [a-z 0 -9] {5, 6, 8, 15} [a-z 0 -9] {6, 7, 8} {10, 11, 13, 15} [a-z 0 -9] NUM {11, 12, 13} IFT 313 ID ID [0 -9] {15} IF NUM ERROR [0 -9] © Froduald Kabanza 19

Récapitulation : produire un scanner à partir d’une liste d’expression régulières - Approche : (1) Convertir les expressions régulières en AFNs. (2) Combiner les AFNs. (3) Convertir L’AFN global en AFD équivalent. (4) Appliquer le DFADriver à l’AFD pour reconnaître les tokens. - L’étape 4 fait l’objet du devoir 1. - Les étapes (1)-(3) sont laissés comme exercices de programmation. IFT 313 © Froduald Kabanza 20

Algorithme NFASimulator La procédure de déterminisation d’un AFN est la composante principale d’un simulateur d’AFN. -Entrée : + Un AFN N (avec seulement des transitions sur un caractère ou sur ε) + Une chaîne de caractères x terminée par le symbole EOF. -Sortie : + True si N accepte x. + False sinon. -Méthode : Faire la déterminization (subset construction) à la volée (on the fly), au fur et à mesure qu’on lit x, un caractère à la fois. IFT 313 © Froduald Kabanza 21

Algorithme : NFA Simulator current. State = epsilon. Closure({initial. State. Of. The. NFA}); current. Char = nextchar(); while ((current. Char!=EOF) && (current. State != NULL)){ current. State = Dtrans(current. State, current. Char); current. Char = next. Char(); } if (is. Final. State(current. State)) && (current. Char == EOF) return True else return False IFT 313 © Froduald Kabanza 22

Exercice - Comment modifieriez-vous l’algorithme précédent pour reconnaître des tokens (c-à-d. , trouver la plus longue sous-chaîne acceptée)? Laissé comme exercice. IFT 313 © Froduald Kabanza 23

Vous devriez être capable de • Écrire un automate fini déterministe correspondant à un automate fini non déterministe. • Simuler un AFN. IFT 313 © Froduald Kabanza 24