IFT313 Introduction aux langages formels

Présentation au sujet: "IFT313 Introduction aux langages formels"— Transcription de la présentation:

1 IFT313 Introduction aux langages formels
Froduald Kabanza Département d’informatique Université de Sherbrooke planiart.usherbrooke.ca/kabanza/cours/ift313 Automates à pile

2 Sujets C’est quoi un automate à pile ?
Quel est le langage accepté par un automate à pile? Quelle est la correspondance entre un automate à pile et une grammaire hors-contexte? Quelle est la correspondance entre un automate à pile et un automate fini? IFT313 © Froduald Kabanza

3 Objectifs Savoir décrire un automate à pile acceptant un langage donné ? Savoir simuler l’exécution d’un automate à pile ? Exprimer le pouvoir d’expressivité d’un automate à pile ? IFT313 © Froduald Kabanza

4 Rappel Exp Þ Productions 1. Exp → num 2. Exp → ( Exp )
Le problème d’analyse syntaxique (parsing) est : étant donné une chaîne de lexèmes (tokens) et une grammaire déterminer si oui ou non la chaîne est dérivable de la grammaire et si oui, donner la séquence de dérivation ou un arbre d’analyse (ou un arbre syntaxique). Exemple : est-ce que (num + num) * num est syntaxiquement correcte? Grammaire Dérivation Arbre d’analyse Exp Þ Exp Exp * Productions 1. Exp → num 2. Exp → ( Exp ) 3. Exp → Exp + Exp 4. Exp → Exp * Exp Symbole de départ Exp * Exp Þ Exp * num Þ Exp ( ) num (Exp) * num Þ Exp + (Exp + Exp) * num Þ (Exp + num) * num Þ num num (num + num) * num IFT313 © Froduald Kabanza

5 Automate à pile L’approche pour analyser la syntaxe du code source d’un programme est de scanner le programme de gauche à droite, en cherchant une dérivation qui génère ce programme. Le modèle de base d’un programme qui fait une telle analyse est un automate à pile (en anglais: pushdown automaton ou stack automaton). C’est une généralisation de la notion d’automate fini à des grammaires hors-contexte. Comme expliqué auparavant, les automates finis peuvent analyser seulement la syntaxe d’une grammaire régulière. Pour analyser la syntaxe d’une grammaire hors-contexte, nous ajoutons une pile à un automate fini pour obtenir un modèle de programmes plus puissant connu sous le nom de “automate à pile”. IFT313 © Froduald Kabanza

6 Modèle général Dans cette leçon on voit une modèle générale d’automate à pile, valide pour les grammaires hors-contexte en général. Par la suite nous verrons des modèles d’automates à pile LL et LR, qui correspondent, respectivement aux analyseurs syntaxiques LL et LR, c-à-d., à des sous-ensembles de grammaires hors-contexte pouvant être analysés efficacement. En fait nous verrons que des parseurs LL et LR ne sont rien d’autres que des automates à piles implémentés efficacement. Nous verrons aussi comment ces parseurs peuvent être générés automatiquement à partir d’une grammaire. D’ici là, nous utiliserons des exemples artificiels très simples. IFT313 © Froduald Kabanza

7 Limite des automates finis
Nous avons vu qu’un automate fini est un modèle de programme avec un nombre fini d’états. Par conséquent, il a nombre fini d’actions ou transitions qu’il peut effectuer. Comme il a un nombre fini d’états et de transitions, il est très simple à programmer et même à visualiser graphiquement. Par contre il ne peut pas analyser le langage généré par une grammaire hors-contexte. Il peut seulement analyser le langage généré par une grammaire régulière. IFT313 © Froduald Kabanza

8 Automate à pile Un automate à pile ressemble à un automate fini. Il a : un flux (stream) de lecture et un pointeur vers le prochain symbole (lexème/token) à lire; un nombre fini d’états, y compris un état initial et des états accepteurs; une relation de transition. La différence est qu’un automate à pile a en plus une pile, initialement vide, mais pouvant croître arbitrairement. Le contenu de la pile fait partie de la configuration (~ état) d’un automate. Donc un automate à pile a potentiellement un nombre infini de configurations (~ d’états). IFT313 © Froduald Kabanza

9 Automate à pile Un automate à pile a :
Une entrée et une tête de lecture. Un nombre fini d’états dont un état initial et des états accepteurs. Une relation de transition. Une pile pouvant croître arbitrairement. Un alphabet d’entrée (terminaux d’une grammaire); Un alphabet de la pile (terminaux et non terminaux d’une grammaire) Automate à pile entrée pile $ IFT313 © Froduald Kabanza

10 Automate à pile L’entrée est une chaîne de tokens scanné à partir du code source du programme à analyser. La pile contient une chaîne de symboles de l’alphabet de la pile (terminaux et non-terminaux de la grammaire) Les transitions indiquent comment mettre à jour le contenu de la pile en fonction du token courant. Automate à pile entrée pile 1 2 3 4 $ IFT313 © Froduald Kabanza

11 Automate à pile Comment définir un automate à pile correspondant à une grammaire? Le principe de base est de mettre sur la pile des symboles de la grammaire qui correspondent (match) au préfixe de l’entrée lue jusque là et d’utiliser cette information d’une certaine façon pour déterminer la production à appliquer à la prochaine étape de dérivation. Ceci deviendra clair avec des exemples. Automate à pile entrée pile 1 2 3 4 $ IFT313 © Froduald Kabanza

12 Automate à pile : définition formelle
Un automate à pile non-déterministe (ou simplement automate à pile) est un tuple : M = (S,V,A,R,s0,F,$), tel que : S est une ensemble fini d’états. V est l’alphabet de la pile A est l’alphabet d’entrée R: (S × A*× V*)  (S × V*) est la relation de transitions Autrement dit, la relation spécifie pour chaque état dans S, sous-chaîne lue de l’entrée (A*) et sous-chaîne en haut de la pile (V*), le prochain état (dans S) et la sous-chaîne à mettre au sommet de la pile à la place de celle dans l’antécédent de la relation. s0 (dans S) est l’état initial. F (inclus dans S) est un ensemble d’états accepteurs. $ est le symbole initialement au fond de la pile et dénote aussi la fin de l’entrée (fin de fichier). IFT313 © Froduald Kabanza

13 Transitions Une transition de la forme (p, u, b)  (q, g) signifie que l’automate peut passer de l’état p à l’état q, pourvu que la chaîne d’entrée commence par le préfixe u et le la chaîne b est au sommet de la pile. Après la transition, u est lu et consommé du mot d’entrée, b est enlevé de la pile et remplacé par g, et le nouvel état devient q. La chaîne b est lue de gauche à droite : son premier caractère doit donc être au sommet de la pile. La chaîne g est écrite de telle façon que son premier caractère soit au sommet de la pile. entrée pile p q $ u b g IFT313 © Froduald Kabanza

14 Configurations, trace, acceptation
La configuration d’un automate est un triplet (S, V*, A*), indiquant, respectivement, son état courant, le contenu de la pile, et la partie de l’entrée qui reste à lire. Une trace (ou exécution) d’un automate sur une entrée est la séquence de configurations qu’il produit en lisant son entrée et en suivant ses transitions. Une exécution accepte une chaîne d’entrée si la dernière configuration est de la forme (p, $, $), avec p un état accepteur. En d’autre mot, dans la dernière configuration, la pile est vide, on est à la fin de l’entrée et l’état est accepteur. IFT313 © Froduald Kabanza

15 Automates à pile déterministe
Un automate à pile est déterministe s’il a une seule exécution possible pour toute entrée donnée. Sinon, il est non-déterministe. Contrairement aux automates finis, il n’est pas toujours possible d’avoir un automate à pile déterministe correspondant à un automate à pile non-déterministe. Les analyseurs lexicaux pratiques (inclus ceux que nous allons étudier) sont basés sur des automates à pile déterministes. Pour toute grammaire hors-contexte, il existe un automate à pile non-déterministe acceptant le langage généré par la grammaire. IFT313 © Froduald Kabanza

16 Exemple 1 M = (S,V,T,R,s,S,$), tel que: S = {s,p}
V = {A} T = {a,b} R = { (s, a, ε)  (s, A), (s, ε, $)  (p, ε), (s, b, A) (p, ε), (p, b, A) (p, ε)} La deuxième transition est inutile. En la supprimant on obtient un automate déterministe équivalent. Automate à pile non-déterministe correspond à la grammaire G = (V,A,R,S), tel que : V = {S} A = {a,b} R = {S ® ε, S ® aSb} L(G) = {an bn | n >= 0}, c-à-d., chaîne commençant par des a suivi d’autant de b. IFT313 © Froduald Kabanza

17 Exemple 1 (représentation graphique)
M = (S,V,T,R,s,S,$), tel que: S = {s,p} V = {A} T = {a,b} R = { (s, a, ε)  (s, A), (s, b, A) (p, ε), (p, b, A) (p, ε)} L(M) = {an bn | n >= 0} Représentation graphique de l’automate a, ε/A b, A/ε b, A/ε s p IFT313 © Froduald Kabanza

18 Exemple 1 (Exécutions) M = (S,V,T,R,s,S,$) : S = {s,p} V = {A}
Rappel : configuration: (état, pile, reste-de-l’entrée) M = (S,V,T,R,s,S,$) : S = {s,p} V = {A} T = {a,b} R = { (s, a, ε)  (s, A), (s, ε, $)  (p, ε), (s, b, A) (p, ε), (p, b, A) (p, ε)} L(M) = {an bn | n ≥ 0} Entrée: aabb Entrée: aabbb (s, $, aabbb$) (s, $A, abbb$) (s, $AA, bbb$) (p, $A, bb$) (p, $, b$) (s, $, aabb$) (s, $A, abb$) (s, $AA, bb$) (p, $A, b$) (p, $, $) Rejette. Aucune autre exécution n’accepte. Donc, aabbb n’est pas dans le langage. Accepte IFT313 © Froduald Kabanza

19 Exemple 2 Automate non-déterministe correspondant à la grammaire :
M = (S,V,T,R,s,S,$) : S = {s,p} V = {A,B} T = {a,b} R = { (s, a, ε)  (s, A), (s, b, ε) (s, B), (s, ε, ε) (p, ε), (p, a, A) (p, ε), (p, b, B) (p, ε)} G = (V,A,R,S), tel que: V = {S} A = {a,b} R = {S ® ε, S ® aSa, S ® bSb} L(G) = {w wR | w est dans A*}, c-à-d., un palindrome: chaîne concaténé avec son inverse IFT313 © Froduald Kabanza

20 Exemple 2 (Exécutions) M = (S,V,T,R,s,S,$) :
Rappel : configuration: (état, pile, reste-de-l’entrée) M = (S,V,T,R,s,S,$) : S = {s,p} V = {A,B} T = {a,b} R = { (s, a, ε) -> (s, A), (s, b, ε) ->(s,B), (s, ε, ε) ->(p,ε), (p, a, A) ->(p,ε), (p, b, B) ->(p,ε)} L(M) = {w wR | w est dans T*} Input: abba Input: abab (s, $, abab$) (s, $A, aab$) (s, $AB, ab$) (p, $AB, ab$) Pas de transition ! (s, $, abba$) (s, $A, bba$) (s, $AB, ba$) (p, $AB, ba$) (p, $A, a$) (p, $,$) Accepte. Il y a des exécutions qui n’acceptent pas. Mais abba est dans le langage puisque au moins une exécution accepte. Rejette. Aucune autre exécution n’accepte. Donc abab n’est pas dans le langage. IFT313 © Froduald Kabanza

21 Discussion M = (S,V,T,R,s,S,$) : L(M) = {w wR | w est dans T*}
Cet automate à pile est non-déterministe. Une question intéressante est « y-a-t-il un automate à pile déterministe équivalent? » La réponse est «non». Donc le langage L1 = {w wR | w est dans {a,b}*}, est non-déterministe hors-contexte. Par contre, le langage similaire L2 = {w c wR | w est dans {a,b}*} est déterministe hors-contexte. Intuitivement, avec L2 on peut de manière déterministe vérifier le milieu de la chaîne. Avec L1, on ne peut pas. Exercice: Donner une grammaire hors-contexte et un automate à pile déterministe pour L2. M = (S,V,T,R,s,S,$) : S = {s,p} V = {A,B} T = {a,b} R = { (s, a, ε) -> (s, A), (s, b, ε) ->(s, B), (s, ε, ε) ->(p, ε), (p, a, A) ->(p, ε), (p, b, B) ->(p, ε)} L(M) = {w wR | w est dans T*} IFT313 © Froduald Kabanza

22 Au delà des langages hors-contexte
Bien qu’un automate à pile peut avoir un nombre infini d’états (configurations), il existe des langages qui ne sont pas acceptés par un automate à pile, c-à-d., des langages qui ne sont pas hors-contextes. Exemple: L(M) = {an bn cn | n ≥0} n’est pas hors-contexte. Toutefois, il existe des modèles théoriques de programmes qui accepte un tel langage. En particulier, les machines de Turing sont des généralisations des automates à piles, pouvant accepter n’importe quel langage. IFT313 © Froduald Kabanza

23 Exercice Étant donné l’alphabet {a,b}, donnez :
Une grammaire générant le langage composé de mots ayant le même nombre de a et de b, peu importe l’ordre dans lequel ces deux symboles apparaissent dans le mot. (b) Un automate à pile (non-déterministe) acceptant le même langage. IFT313 © Froduald Kabanza

24 M = ({s0},{A,B},{a,b},R, s0,{s0},$) :
Solution Automate à pile correspondant Grammaire générant le langage composé de mots ayant le même nombre de a et de b G = (V,A,R,S), tel que: V = {S} A = {a,b} R = { S  ε S  aSbS S  bSaS } M = ({s0},{A,B},{a,b},R, s0,{s0},$) : a, A/AA a, $/$A a, B/ε s0 b, A/ ε b, B/BB b, $/$B IFT313 © Froduald Kabanza

25 Résumé Un automate à pile est un modèle de programme simple pour l’analyse syntaxique. Les parsers LL et LR sont fondamentalement des automates à pile déterministes. On les obtient en imposant des restrictions sur les grammaires hors-contexte. En général ces restrictions sont acceptables pour les langages de programmation courants. Les quelques prochaines leçons sera sur les parsers LL. Nous verrons les parsers LR vers la fin. IFT313 © Froduald Kabanza