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

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

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

Références [1] Sudkamp, T. A.. Languages and Machines. Third Edition Edition. Addison-Wesley, 2005. Section 7.1 [3] Wolper, P. Introduction à la calculabilité, 3è édition. Dunod, 2006 Sections 4.1 à 4.2, 4.4 IFT313 © Froduald Kabanza

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

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

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

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 (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

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

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 $ En pratique, l’ensemble des terminaux est l’ensemble des token. Donc, potentiellement un alphabet de taille infini. Mais en théorie, on aime souvent supposer un alphabet fini. IFT313 © Froduald Kabanza

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

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 la dérivation. Ceci deviendra clair avec des exemples. Automate à pile entrée pile 1 2 3 4 $ IFT313 © Froduald Kabanza

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 transition Autrement dit, la relation spécifie pour chaque état dans S, sous-chaîne lue de l’entrée (A*) et sous-chaîne au sommet 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. Il dénote aussi la fin de l’entrée (fin de fichier). IFT313 © Froduald Kabanza

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 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

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

Exemple 1 M = (S, V U A, 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, ε)} 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} Note : La deuxième transition de l’automate est inutile. L(G) = {an bn | n >= 0}, c-à-d., chaîne commençant par des a suivi d’autant de b. IFT313 © Froduald Kabanza

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 s p a, ε/A b, A/ε C’est un automate à pile déterministe. IFT313 © Froduald Kabanza

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, 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, $, $) Exercice : quelle grammaire correspond à cet automate à pile? 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, ε)} C’est le même que le précédent, mais j’ai ajouté la transition (s, ε, $)  (p, ε). Réponse: c’est la même grammaire. La transition (s, ε, $)  (p, ε) est inutile. Par contre, ce nouvel automate est non déterministe, alors que l’autre était déterministe. Rejette. Aucune autre exécution n’accepte. Donc, aabbb n’est pas dans le langage. Accepte IFT313 © Froduald Kabanza

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

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} palindrome: chaîne concaténé avec son inverse 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(G) = {w wR | w est dans A*}, c-à-d., un palindrome: chaîne concaténé avec son inverse IFT313 © Froduald Kabanza

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, BA$, ab$) (p, BA$, ab$) Pas de transition ! (s, $, abba$) (s, A$, bba$) (s, BA$, ba$) (p, BA$, 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

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*} Question 1 : est-ce que cet automate à pile est il déterministe? Réponse : non. IFT313 © Froduald Kabanza

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 acceptent 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

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. Réponse: G = (V,A,R,S), tel que: V = {S} A = {a,b} R = { S  ε S  aSbS S  bSaS } IFT313 © Froduald Kabanza

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},$) : s0 a, A/AA a, $/$A b, B/BB b, $/$B a, B/ε b, A/ ε IFT313 © Froduald Kabanza

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 seront sur les parseurs LL. Nous verrons les parseurs LR vers la fin du cours. IFT313 © Froduald Kabanza