IFT313
Introduction aux langages formels
Froduald Kabanza
Département d’informatique Université de Sherbrooke
planiart.usherbrooke.ca/kabanza/cours/ift313
Convertir un AFN en un AFD
IFT313 © Froduald Kabanza
2
Rappel
IFT313 © Froduald Kabanza
3
Sujet couvert
• Convertir un automate fini non-déterministe en un automate fini.
déterministe.
• Simuler un AFN
IFT313 © Froduald Kabanza
4
Références
[1] Sudkamp, T. A.. Languages and Machines. Third Edition 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
ndEdition. Addison Wesley, 2007.
– Sections 3.7.1 à 3.7.3
IFT313 © Froduald Kabanza
6
Élimination du non-déterminisme
- La méthode pour convertir un AFN en AFD est appelée « subset construc- tion 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 non-déter- ministes.
+ Ces états représentent un état de l’AFD.
- Nous allons encore utiliser cette technique plus tard pour l’analyse syntax-
ique LR.
IFT313 © Froduald Kabanza
7
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.
IFT313 © Froduald Kabanza
8
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:
1 abc 2
1 a 3 b 4 c 2
IFT313 © Froduald Kabanza
9
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 poten- tiellement 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.
1 3
a 2
a
b
(a) (b) 1
2 3
4 a
a ε
a b [ab]
b a
b {1,3}
{4} [ab]
{1,2,3}
a
{1}
{3}
a
{1,2}b
a
b
IFT313 © Froduald Kabanza
10
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 transi- tions ε.
- Il va de soi que S est dans ε-closure(S).
- Par extension, pour un état z, ε-closure(z) = ε-closure({z})
IFT313 © Froduald Kabanza
11
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
IFT313 © Froduald Kabanza
12
Algorithme epsilonClosure
- Entrée :
+ S : un sous-ensemble des états de l’AFN + succ : la relation des transitions de l’AFN - Sortie : ε-closure(S)
- Méthode : S1 = S do {
S2= S1 ; // S2 devient S1 au début de l’itération
S3 = {}; // S3 est l’ensemble des états atteignable à partir de S2
for (s in S2)
S3 = union(S3, succ(s, ε));
S1 = union(S2,S3);
} while (! S1.equals (S2)); // jusqu’à plus de nouvel état atteignable
IFT313 © Froduald Kabanza
13
Algorithme replaceStringTransitions
- Entrée : Un AFN X1 =(N1,A,R1,n0,F)
- Sortie : Un AFN X2=(N2,A,R2,n0,F) avec transitions à un caractère ou ε - Méthode :
N2=N1;
R2=R1 ;
Pour toute transition (s, u,t) dans R2 telle que u =a
1…a
k(k>1) + supprimer (s, u,t) de R2
+ ajouter des nouveaux états s
1,s
2,…,s
k-1dans N2
+ ajouter de nouvelles transitions (s, a
1, s
1),…,(s
k-1,a
k,t) à R2
IFT313 © Froduald Kabanza
14
Algorithme removeNondeterminism
- Entrée : Un AFN X =(N,A,R,n0,F) avec transitions à un caractère ou ε - Sortie : Un AFD Y=(D,A,T,d0,P)
- Méthode :
+ D = 2
N// L’ensemble des sous-ensembles de N + d0 = ε-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})
// 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.
nd È
IFT313 © Froduald Kabanza
15
Algorithm removeNondeterminism
- Pour donner une description plus algorithmique :
Dtrans(d,a) = epsilonClosure ( trans(n,a))
- Où trans est la relation de transition de l’AFN X.
- Autrement dit, il y a une transition de d
ià d
j, étiquetée a, si et seulement si d
j=Dtrans(d
i,a)
nd È
IFT313 © Froduald Kabanza
16
Algorithm removeNondeterminism
- Entrée : AFN (N,A,R,n0,F) - Sortie : AFD (D,A,T,d0,P)
- Méthode :
P {d dans D | l’interesction de d et F est non vide} //défini comme avant;
d0 = ε-closure(n
0)
D={d0} et d0 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 ’ ;
}}
IFT313 © Froduald Kabanza
17
Récapitulation
- constructDFAFromNFA(NFA)
¬ removeNondeterminism(replaceStringTransitions(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.
IFT313 © Froduald Kabanza
18
Exemple (AFN)
1 4
2
9 14
3
5
10 15
8 7 6
13 12 11
i
f IF
ε ε ε
a z ...
0 ...
9
ERROR an y ch ar ac te r
ε
ε ε
ε
0 ...
9
ε
ε
[a-z]
[0-9]
ID NUM
...
IFT313 © Froduald Kabanza
19
Exemple (AFD correspondant)
{1,4,9,14}
{2,5,6,8,15} {3,6,7,8}
{6,7,8}
{5,6,8,15}
{10,11,13,15}
{15} {11,12,13}
i
f
[a-z0-9]
[a-z0-9]
[a-z0-9]
[a-hj-z]
other
[0-9]
[0-9]
[0-9]
ERROR
ID
ID
IF
[a-z0-9]
ID
NUM
NUM
IFT313 © Froduald Kabanza
20
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.
IFT313 © Froduald Kabanza
21
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.
IFT313 © Froduald Kabanza
22
Algorithme : NFA Simulator
currentState = epsilonClosure({initialStateOfTheNFA});
currentChar = nextchar();
while ((currentChar!=EOF) && (currentState != NULL)){
currentState = Dtrans(currentState, currentChar);
currentChar = nextChar();
}
if (isFinalState(currentState)) && (currentChar == EOF) return True
else return False
IFT313 © Froduald Kabanza
23
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.
IFT313 © Froduald Kabanza
24
Vous devriez être capable de
• Écrire un automate fini déterministe correspondant à un automate fini non déterministe.
• Simuler un AFN.
IFT313 © Froduald Kabanza
25
