%% This is a LaTeX document. Hey, Emacs, -*- latex -*- , get it? \documentclass[12pt,a4paper]{article} \usepackage[a4paper,twoside,inner=2.75cm,outer=2.25cm,vmargin=3cm]{geometry} \usepackage[francais]{babel} \usepackage[utf8]{inputenc} \usepackage[T1]{fontenc} %\usepackage{ucs} \usepackage{times} % A tribute to the worthy AMS: \usepackage{amsmath} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsthm} % \usepackage{mathrsfs} \usepackage{wasysym} \usepackage{url} % \usepackage{makeidx} %% Self-note: compile index with: %% xindy -M texindy -C utf8 -L french notes-inf105.idx % \usepackage{graphics} \usepackage[usenames,dvipsnames]{xcolor} \usepackage{tikz} \usetikzlibrary{arrows,automata,positioning,calc} \usepackage[hyperindex=false]{hyperref} % \theoremstyle{definition} \newtheorem{comcnt}{Tout}[subsection] \newcommand\thingy{% \refstepcounter{comcnt}\medskip\noindent\textbf{\thecomcnt.} } \newcommand\exercice{% \refstepcounter{comcnt}\bigskip\noindent\textbf{Exercice~\thecomcnt.}} \newtheorem{defn}[comcnt]{Définition} \newtheorem{prop}[comcnt]{Proposition} \newtheorem{lem}[comcnt]{Lemme} \newtheorem{thm}[comcnt]{Théorème} \newtheorem{cor}[comcnt]{Corollaire} \newtheorem{scho}[comcnt]{Scholie} \newtheorem{algo}[comcnt]{Algorithme} \renewcommand{\qedsymbol}{\smiley} % \newcommand{\limp}{\mathrel{\Longrightarrow}\relax} \newcommand{\liff}{\mathrel{\Longleftrightarrow}\relax} % \DeclareUnicodeCharacter{00A0}{~} \DeclareUnicodeCharacter{03B5}{$\varepsilon$} \DeclareUnicodeCharacter{0101}{\=a} \DeclareUnicodeCharacter{1E47}{\d{n}} % \DeclareMathSymbol{\tiret}{\mathord}{operators}{"7C} \DeclareMathSymbol{\traitdunion}{\mathord}{operators}{"2D} % % \DeclareFontFamily{U}{manual}{} \DeclareFontShape{U}{manual}{m}{n}{ <-> manfnt }{} \newcommand{\manfntsymbol}[1]{% {\fontencoding{U}\fontfamily{manual}\selectfont\symbol{#1}}} \newcommand{\dbend}{\manfntsymbol{127}}% Z-shaped \newcommand{\danger}{\noindent\hangindent\parindent\hangafter=-2% \hbox to0pt{\hskip-\hangindent\dbend\hfill}} % \newcommand{\defin}[2][]{\def\latexsucks{#1}\ifx\latexsucks\empty\index{#2}\else\index{\latexsucks}\fi\textbf{#2}} \newcommand{\spaceout}{\hskip1emplus2emminus.5em} % \newif\ifcorrige \corrigetrue \newenvironment{corrige}% {\ifcorrige\relax\else\setbox0=\vbox\bgroup\fi% \smallbreak\footnotesize\noindent{\underbar{\textit{Corrigé.}}\quad}} {{\hbox{}\nobreak\hfill\checkmark}% \ifcorrige\relax\else\egroup\fi\par} % % % NOTE: compile dot files with % dot2tex --figonly -f tikz --tikzedgelabels --graphstyle=automaton file.dot > file.tex \tikzstyle{automaton}=[>=stealth',initial text={},thick,every loop/.style={min distance=7mm,looseness=5}] \tikzstyle{state}=[] \tikzstyle{final}=[accepting by arrow] % % % \makeindex \begin{document} \title{THL (Théorie des langages)\\Notes de cours} \author{David A. Madore} \maketitle \centerline{\textbf{INF105}} \vskip2cm {\footnotesize \immediate\write18{sh ./vc > vcline.tex} \begin{center} Git: \input{vcline.tex} \\ (Recopier la ligne ci-dessus dans tout commentaire sur ce document) \end{center} \immediate\write18{echo ' (stale)' >> vcline.tex} \par} \pretolerance=8000 \tolerance=50000 \linepenalty=5 % Default is supposedly 10 \vskip3cm % % % {\footnotesize \tableofcontents \par} \bigbreak \setcounter{comcnt}{0} \thingy \textbf{Présentation générale et plan :} On se propose de développer ici des techniques mathématiques et algorithmiques ayant à la fois un intérêt théorique comme théorie des langages formels, et une application informatique pratique à l'analyse de textes ou de chaînes de caractères (qu'on appellera par la suite « mots », cf. §\ref{subsection-introduction-and-words}). \smallbreak Après des définitions générales (sections \ref{subsection-introduction-and-words} à \ref{subjection-languages}), ces notes sont divisées en grandes parties (inégales) de la manière suivante : \begin{itemize} \item l'étude des expressions rationnelles et des automates finis, et des langages qu'ils définissent, dans les sections \ref{section-languages-and-rational-languages} à \ref{section-recognizable-languages}, qui sert notamment dans la recherche de texte et de motifs dans une chaîne de caractères ou un document ; \item l'étude de certaines grammaires formelles dans la section \ref{section-context-free-grammars}, qui sert notamment à définir et analyser la syntaxe de langages de programmation ; \item une introduction à la calculabilité dans la section \ref{section-computability}, qui place des limites théoriques sur ce qu'un algorithme peut faire. \end{itemize} \smallbreak À ces parties seront associées la définition de différentes classes de « langages » (voir §\ref{subjection-languages} pour la définition de ce terme) qu'il s'agit d'étudier : \begin{itemize} \item les langages « rationnels » (définis par des expressions rationnelles, §\ref{subsection-rational-languages}) et « reconnaissables » (définis par des automates finis, §\ref{section-finite-automata}), qui s'avèrent coïncider (\ref{kleenes-theorem}) ; \item les langages « algébriques » (définis par des grammaires hors contexte, §\ref{subsection-context-free-grammars}) ; \item les langages « décidables » (définis par un algorithme quelconque, \ref{definition-computable-function-or-set}) et « semi-décidables » (définis par un algorithme qui pourrait ne pas terminer). \end{itemize} La progression logique vient de l'inclusion qui donne une hiérarchie entre ces classes : tout langage rationnel/reconnaissable est algébrique (\ref{rational-languages-are-algebraic}), tout langage algébrique est décidable (\ref{algebraic-languages-are-decidable}), et tout langage décidable est semi-décidable (\ref{decidable-iff-semidecidable-and-complement}). On procède donc du plus particulier au plus général. \thingy \textbf{Notations :} On écrit $A:=B$, ou parfois $B=:A$, pour dire que $A$ est défini comme égal à $B$ (cela signifie simplement $A=B$ mais en insistant sur le fait que c'est la définition du membre du côté duquel se situent les deux points). On note $\mathbb{N}$ l'ensemble $\{0,1,2,3\ldots\}$ des entiers naturels. Le symbole \qedsymbol{} marque la fin d'une démonstration. Les passages en petits caractères (ainsi que les notes en bas de page) sont destinés à apporter des éclaircissements, des précisions ou des compléments mais peuvent être ignorés sans nuire à la compréhension globale du texte. \section{Alphabets, mots et langages ; langages rationnels}\label{section-languages-and-rational-languages} \subsection{Introduction, alphabets, mots et longueur}\label{subsection-introduction-and-words} \thingy L'objet de ces notes, au confluent des mathématiques et de l'informatique, est l'étude des \textbf{langages} : un langage étant un ensemble de \textbf{mots}, eux-mêmes suites finies de \textbf{lettres} choisies dans un \textbf{alphabet}, on va commencer par définir ces différents termes avant de décrire plus précisément l'objet de l'étude. \thingy Le point de départ est donc ce que les mathématiciens appelleront un \defin{alphabet}, et qui correspond pour les informaticiens à un \textbf{jeu de caractères}. Il s'agit d'un ensemble \emph{fini}, sans structure particulière, dont les éléments s'appellent \defin[lettre]{lettres}, ou encore \index{caractère|see{lettre}}\textbf{caractères} dans une terminologie plus informatique, ou parfois aussi \defin[symbole]{symboles}. Les exemples mathématiques seront souvent donnés sur un alphabet tel que l'alphabet à deux lettres $\{a,b\}$ ou à trois lettres $\{a,b,c\}$. On pourra aussi considérer l'alphabet $\{0,1\}$ appelé \defin{binaire} (puisque l'alphabet n'a pas de structure particulière, cela ne fait guère de différence par rapport à n'importe quel autre alphabet à deux lettres). Dans un contexte informatique, des jeux de caractères (=alphabets) souvent importants sont ASCII, Latin-1 ou Unicode : en plus de former un ensemble, ces jeux de caractère attribuent un numéro à chacun de leurs éléments (par exemple, la lettre A majuscule porte le numéro 65 dans ces trois jeux de caractères), mais cette structure supplémentaire ne nous intéressera pas ici. Dans tous les cas, il est important pour la théorie que l'alphabet soit \emph{fini}. \smallskip L'alphabet sera généralement fixé une fois pour toutes dans la discussion, et désigné par la lettre $\Sigma$ (sigma majuscule). \thingy Un \defin{mot} sur l'alphabet $\Sigma$ est une suite finie de lettres (éléments de $\Sigma$) ; dans la terminologie informatique, on parle plutôt de \index{caractères (chaîne de)|see{chaîne de caractères}}\defin{chaîne de caractères}, qui est une suite finie (=liste) de caractères. Le mot est désigné en écrivant les lettres les unes à la suite des autres : autrement dit, si $x_1,\ldots,x_n \in \Sigma$ sont des lettres, le mot formé par la suite finie $x_1,\ldots,x_n$ est simplement écrit $x_1\cdots x_n$. À titre d'exemple, $abbcab$ est un mot sur l'alphabet $\Sigma = \{a,b,c,d\}$, et \texttt{foobar} est un mot (= chaîne de caractères) sur l'alphabet ASCII. (Dans un contexte informatique, il est fréquent d'utiliser une sorte de guillemet pour délimiter les chaînes de caractères : on écrira donc \texttt{\char`\"foobar\char`\"} pour parler du mot en question. Dans ces notes, nous utiliserons peu cette convention.) \medskip L'ensemble de tous les mots sur un alphabet $\Sigma$ sera désigné $\Sigma^*$ (on verra en \ref{kleene-star} ci-dessous cette notation comme un cas particulier d'une construction « étoile » plus générale). Par exemple, si $\Sigma = \{0,1\}$, alors $\Sigma^*$ est l'ensemble (infini !) dont les éléments sont toutes les suites finies binaires (= suites finies de $0$ et de $1$). Ainsi, écrire « $w \in \Sigma^*$ » signifie « $w$ est un mot sur l'alphabet $\Sigma$ ». \medskip {\footnotesize\thingy Typographiquement, on essaiera autant que possible de désigner des mots par des variables mathématiques telles que $u,v,w$, tandis que $x,y,z$ désigneront plutôt des lettres quelconques dans un alphabet (quant à $a,b,c$, ils serviront de lettres dans les exemples). Il n'est malheureusement pas possible d'être complètement systématique (il arrivera que $x$ désigne un mot) : on cherchera donc à toujours rappeler le type de toute variable en écrivant, par exemple, $t \in\Sigma$ ou $t \in\Sigma^*$.\par} \thingy\label{length-of-word} Le nombre $n$ de lettres dans un mot $w \in \Sigma^*$ est appelé la \defin{longueur} du mot, et généralement notée $|w|$ ou bien $\ell(w)$ : autrement dit, si $x_1,\ldots,x_n \in \Sigma$, alors la longueur $|x_1\cdots x_n|$ du mot $x_1\cdots x_n$, vaut $n$. Ceci coïncide bien avec la notion usuelle de longueur d'une chaîne de caractères en informatique. À titre d'exemple, sur l'alphabet $\Sigma=\{a,b,c,d\}$, la longueur du mot $abbcab$ vaut $6$ (on écrira $|abbcab|=6$ ou bien $\ell(abbcab)=6$). \thingy Quel que soit l'alphabet, il existe un unique mot de longueur $0$, c'est-à-dire un unique mot n'ayant aucune lettre, appelé le \defin{mot vide} (ou la \textbf{chaîne [de caractères] vide}). Étant donné qu'il n'est pas commode de désigner un objet par une absence de symbole, on introduit un symbole spécial, généralement $\varepsilon$, pour désigner ce mot vide : on a donc $|\varepsilon|=0$. On souligne que le symbole $\varepsilon$ \underline{ne fait pas partie} de l'alphabet $\Sigma$, c'est un symbole \emph{spécial} qui a été introduit pour désigner le mot vide. (Lorsque les mots sont délimités par des guillemets, comme il est usage pour les chaînes de caractères en informatique, le mot vide n'a pas besoin d'un symbole spécial : il s'écrit juste \texttt{\char`\"\char`\"} — sans aucun caractère entre les guillemets.) {\footnotesize Lorsque l'alphabet $\Sigma$ est \emph{vide}, c'est-à-dire $\Sigma=\varnothing$, alors le mot vide est le seul mot qui existe : on a $\Sigma^*=\{\varepsilon\}$ dans ce cas. C'est la seule situation où l'ensemble $\Sigma^*$ des mots est un ensemble fini. Dans la suite, nous négligerons parfois ce cas particulier, qu'on pourra oublier : c'est-à-dire que nous ferons parfois l'hypothèse tacite que $\Sigma \neq \varnothing$.\par} La notation $\Sigma^+$ est parfois utilisée pour désigner l'ensemble des mots \emph{non vides} sur l'alphabet $\Sigma$ (par opposition à $\Sigma^*$ qui désigne l'ensemble de tous les mots, y compris le mot vide) ; on verra en \ref{kleene-plus} ci-dessous que c'est un cas particulier d'une construction plus générale. \thingy\label{convention-on-words-of-length-one} Les mots d'une seule lettre sont naturellement en correspondance avec les lettres elles-mêmes : on identifiera souvent tacitement, quoique un peu abusivement, une lettre $x\in\Sigma$ et le mot de longueur $1$ formé de la seule lettre $x$. (En informatique, cette identification entre \emph{caractères} et \emph{chaînes de caractères de longueur $1$} est faite par certains langages de programmation, mais pas par tous : \textit{caveat programmator}.) Cette convention permet d'écrire par exemple $\Sigma \subseteq \Sigma^*$ ou bien $|x|=1 \liff x\in\Sigma$. \thingy\label{number-of-words-of-length-n} Si le cardinal de l'alphabet $\Sigma$ vaut $\#\Sigma = N$, alors, pour chaque $n$, le nombre de mots de longueur exactement $n$ est égal à $N^n$ (combinatoire classique). Le nombre de mots de longueur $\leq n$ vaut donc $1 + N + \cdots + N^n = \frac{N^{n+1}-1}{N-1}$ (somme d'une série géométrique). \subsection{Concaténation de mots, préfixes, suffixes, facteurs, sous-mots} \thingy Si $u := x_1\cdots x_m$ et $v := y_1\cdots y_n$ sont deux mots, de longueurs respectives $m$ et $n$, sur un même alphabet $\Sigma$, alors on définit un mot $uv := x_1\cdots x_m y_1\cdots y_n$ de longueur $m+n$, dont les lettres sont obtenues en mettant bout à bout celles de $u$ puis celles de $v$ (dans cet ordre), et on l'appelle \defin{concaténation} (ou, si cela ne prête pas à confusion, simplement \index{produit (de mots)|see{concaténation}}\textbf{produit}) des mots $u$ et $v$. (Dans un contexte informatique, on parle de concaténation de chaînes de caractères.) \thingy Parmi les propriétés de la concaténation, signalons les faits suivants : \begin{itemize} \item le mot vide $\varepsilon$ est « \textbf{neutre} » pour la concaténation, ce qui signifie par définition : $\varepsilon w = w \varepsilon = w$ quel que soit le mot $w \in \Sigma^*$ ; \item la concaténation est « \textbf{associative} », ce qui signifie par définition : $u(vw) = (uv)w$ quels que soient les mots $u,v,w \in \Sigma^*$ (on peut donc noter $uvw$ sans parenthèse). \end{itemize} On peut traduire de façon savante ces deux propriétés en une phrase : l'ensemble $\Sigma^*$ est un \defin{monoïde}, d'élément neutre $\varepsilon$, pour la concaténation (cela signifie exactement ce qui vient d'être dit). \thingy On a par ailleurs $|uv| = |u| + |v|$ (la longueur de la concaténation de deux mots est la somme des concaténations), et on rappelle par ailleurs que $|\varepsilon| = 0$ ; on peut traduire cela de manière savante : la longueur est un \textbf{morphisme de monoïdes} entre le monoïde $\Sigma^*$ des mots (pour la concaténation) et le monoïde $\mathbb{N}$ des entiers naturels (pour l'addition) (cela signifie exactement ce qui vient d'être dit). {\footnotesize\thingy\label{universal-property-remark} \textbf{Complément :} Le monoïde $\Sigma^*$ possède la propriété suivante par rapport à l'ensemble $\Sigma$ : si $M$ est un monoïde quelconque (c'est-à-dire un ensemble muni d'une opération binaire associative $\cdot$ et d'un élément $e$ neutre pour cette opération), et si $\psi\colon \Sigma\to M$ est une application quelconque, alors il existe un unique morphisme de monoïdes $\hat\psi\colon \Sigma^* \to M$ (c'est-à-dire une application préservant le neutre et l'opération binaire) tel que $\hat\psi(x) = \psi(x)$ si $x\in\Sigma$. (Démonstration : on a nécessairement $\hat\psi(x_1\cdots x_n) = \psi(x_1)\cdots \psi(x_n)$, or ceci définit bien un morphisme comme annoncé.) On dit qu'il s'agit là d'une propriété « universelle », et plus précisément que $\Sigma^*$ est le \textbf{monoïde libre} sur l'ensemble $\Sigma$. Par exemple, le morphisme « longueur » $\ell\colon\Sigma^*\to\mathbb{N}$ est le $\ell = \hat\psi$ obtenu en appliquant cette propriété à la fonction (constante) $\psi(x) = 1$ pour tout $x\in\Sigma$.\par} \thingy\label{powers-of-a-word} Lorsque $w \in \Sigma^*$ et $r \in \mathbb{N}$, on définit un mot $w^r$ comme la concaténation de $r$ mots tous égaux à $w$, autrement dit, comme la répétition $r$ fois du mot $w$. Formellement, on définit par récurrence : \begin{itemize} \item $w^0 = \varepsilon$ (le mot vide), \item $w^{r+1} = w^r w$. \end{itemize} (Ces définitions valent, d'ailleurs, dans n'importe quel monoïde. On peut constater que $w^r w^s = w^{r+s}$ quels que soient $r,s\in\mathbb{N}$.) On a bien sûr $|w^r| = r|w|$. \smallskip Cette définition sert notamment à désigner de façon concise les mots comportant des répétitions d'une même lettre : par exemple, le mot $aaaaa$ peut s'écrire tout simplement $a^5$, et le mot $aaabb$ peut s'écrire $a^3 b^2$. (De même que pour le mot vide, il faut souligner que ces exposants \emph{ne font pas partie} de l'alphabet.) \thingy Lorsque $u,v,w \in \Sigma^*$ vérifient $w = uv$, autrement dit lorsque le mot $w$ est la concaténation des deux mots $u$ et $v$, on dira également : \begin{itemize} \item que $u$ est un \defin{préfixe} de $w$, ou \item que $v$ est un \defin{suffixe} de $w$. \end{itemize} De façon équivalente, si $w = x_1\cdots x_n$ (où $x_1,\ldots,x_n \in \Sigma$) est un mot de longueur $n$, et si $0\leq k\leq n$ est un entier quelconque compris entre $0$ et $n$, on dira que $u := x_1\cdots x_k$ (c'est-à-dire, le mot formé des $k$ premières lettres de $w$, dans le même ordre) est le \textbf{préfixe de longueur $k$} de $w$, et que $v := x_{k+1}\cdots x_n$ (mot formé des $n-k$ dernières lettres de $w$, dans le même ordre) est le \textbf{suffixe de longueur $n-k$} de $w$. Il est clair qu'il s'agit bien là de l'unique façon d'écrire $w = uv$ avec $|u|=k$ et $|v|=n-k$, ce qui fait le lien avec la définition donnée au paragraphe précédent ; parfois on dira que $v$ est le suffixe \defin[correspondant (préfixe ou suffixe)]{correspondant} à $u$ ou que $u$ est le préfixe correspondant à $v$ (dans le mot $w$). Le mot vide est préfixe et suffixe de n'importe quel mot. Le mot $w$ lui-même est aussi un préfixe et un suffixe de lui-même. Entre les deux, pour n'importe quelle longueur $k$ donnée, il existe un unique préfixe et un unique suffixe de longueur $k$. (Il peut tout à fait se produire que le préfixe et le suffixe de longueur $k$ soient égaux pour d'autres $k$ que $0$ et $|w|$, comme le montre l'exemple qui suit.) \smallskip À titre d'exemple, le mot $abbcab$ sur l'alphabet $\Sigma=\{a,b,c,d\}$ a les sept préfixes suivants, rangés par ordre croissant de longueur : $\varepsilon$ (le mot vide), $a$, $ab$, $abb$, $abbc$, $abbca$ et $abbcab$ lui-même ; il a les sept suffixes suivants, rangés par ordre croissant de longueur : $\varepsilon$ (le mot vide), $b$, $ab$, $cab$, $bcab$, $bbcab$ et $abbcab$ lui-même. Le suffixe correspondant au préfixe $abb$ est $cab$ puisque $abbcab = (abb)(cab)$. \thingy Comme généralisation à la fois de la notion de préfixe et de celle de suffixe, on a la notion de facteur : si $u_0,v,u_1 \in \Sigma^*$ sont trois mots quelconques sur un même alphabet $\Sigma$, et si $w = u_0 v u_1$ est leur concaténation, on dira que $v$ est un \defin{facteur} de $w$. Alors qu'un préfixe ou suffixe du mot $w$ est déterminé simplement par sa longueur, un facteur est déterminé par sa longueur et l'emplacement à partir duquel il commence. \smallskip À titre d'exemple, les facteurs du mot $abbcab$ sont : $\varepsilon$ (le mot vide), $a$, $b$, $c$, $ab$, $bb$, $bc$, $ca$, $abb$, $bbc$, $bca$, $cab$, $abbc$, $bbca$, $bcab$, $abbca$, $bbcab$ et $abbcab$ lui-même. \smallskip Dans un contexte informatique, ce que nous appelons ici « facteur » est souvent appelé « sous-chaîne [de caractères] ». Il ne faut cependant pas confondre ce concept avec celui de sous-mot défini ci-dessous. \thingy\label{definition-subword} Si $w = x_1\cdots x_n$ est un mot de longueur $n$, on appelle \defin{sous-mot} de $w$ un mot de la forme $x_{i_1} \cdots x_{i_k}$ où $1\leq i_1 < \cdots < i_k \leq n$. En plus clair, cela signifie que $v$ est obtenu en ne gardant que certaines lettres du mot $w$, dans le même ordre, mais en en effaçant d'autres ; à la différence du concept de facteur, celui de sous-mot n'exige pas que les lettres gardées soient consécutives. \smallskip À titre d'exemple, le mot $acb$ est un sous-mot du mot $abbcab$ (obtenu en gardant les lettres soulignées ici : $\underline{a}bb\underline{c}a\underline{b}$ ; pour se rattacher à la définition ci-dessus, on pourra prendre $(i_1,i_2,i_3) = (1,4,6)$). {\footnotesize\thingy Les remarques de dénombrement suivantes peuvent aider à mieux comprendre les notations de préfixe, suffixe, facteur et sous-mot : si $w$ est un mot de longueur $n$, alors il a \begin{itemize} \item exactement $n+1$ préfixes (car un préfixe est déterminé par sa longueur $k$ entre $0$ et $n$), \item exactement $n+1$ suffixes (raison analogue), \item au plus $\sum_{k=1}^n (n+1-k) + 1 = \frac{1}{2}(n^2+n+2)$ facteurs (car un facteur est déterminé par sa longueur $k$ et son point de départ qui peut être choisi parmi $n+1-k$ possibilités, le $+1$ final étant mis pour le facteur vide), \item au plus $2^n$ sous-mots (car un sous-mot est déterminé en choisissant, pour chacune des $n$ lettres, si on l'efface ou la conserve). \end{itemize} Le nombre exact peut être plus petit en cas de coïncidences entre certains choix (par exemple, $aaa$ n'a que $4$ facteurs, $\varepsilon, a, aa, aaa$ alors que $abc$ en a bien $\frac{1}{2}(3^2+3+2) = 7$) ; mais les bornes ci-dessus sont effectivement atteintes pour certains mots.\par} \thingy\label{definition-mirror-word} Si $w = x_1\cdots x_n$, où $x_1,\ldots,x_n \in \Sigma$, est un mot de longueur $n$ sur un alphabet $\Sigma$, alors on définit son mot \defin{miroir} ou \index{transposé (mot)|see{miroir}}\textbf{transposé}, parfois noté $w^{\textsf{R}}$ ou $w^{\textsf{T}}$ (parfois les exposants sont écrits à gauche), comme le mot $x_n\cdots x_1$ dont les lettres sont les mêmes que celles de $w$ mais dans l'ordre inverse. À titre d'exemple, $(ababb)^{\textsf{R}} = bbaba$. On remarquera que $(w_1 w_2)^{\textsf{R}} = w_2^{\textsf{R}} w_1^{\textsf{R}}$ si $w_1,w_2$ sont deux mots quelconques. \smallskip Un mot $w$ est dit \defin{palindrome} lorsque $w = w^{\textsf{R}}$. Par exemple, $abba$ est un palindrome sur $\{a,b,c,d\}$ (ou bien le mot « ressasser » sur l'alphabet du français). {\footnotesize\thingy\label{number-of-occurrences-of-letter} La notation suivante est souvent utile : si $w$ est un mot sur un alphabet $\Sigma$ et si $z$ est une lettre (= élément de $\Sigma$), on note $|w|_z$ le \index{occurrences (nombre d')}nombre total d'occurrences de la lettre $z$ dans $w$. À titre d'exemple, sur l'alphabet $\Sigma=\{a,b,c,d\}$, le nombre d'occurrences des différentes lettres dans le mot $abbcab$ sont : $|abbcab|_a=2$, $|abbcab|_b=3$, $|abbcab|_c=1$ et $|abbcab|_d=0$. Formellement, on peut définir $|w|_z$ de la façon suivante : si $w = x_1 \cdots x_n$ où $x_1,\ldots,x_n \in \Sigma$, alors $|w|_z$ est le cardinal de l'ensemble $\{i : x_i = z\}$. On peut remarquer qu'on a : $|w| = \sum_{z\in\Sigma} |w|_z$ (i.e., la longueur de $w$ est la somme des nombres d'occurrences dans celui-ci des différentes lettres de l'alphabet).\par} \subsection{Langages et opérations sur les langages}\label{subjection-languages} \thingy Un \defin{langage} $L$ sur l'alphabet $\Sigma$ est simplement un ensemble de mots sur $\Sigma$. Autrement dit, il s'agit d'un sous-ensemble (= une partie) de l'ensemble $\Sigma^*$ (de tous les mots sur $\Sigma$) : en symboles, $L \subseteq \Sigma^*$. On souligne qu'on ne demande pas que $L$ soit fini (mais il peut l'être, auquel cas on parlera fort logiquement de « langage fini »). \thingy À titre d'exemple, l'ensemble $\{d,dc,dcc,dccc,dcccc,\ldots\} = \{dc^r \colon r\in\mathbb{N}\}$ des mots formés d'un $d$ suivi d'un nombre quelconque (éventuellement nul) de $c$ est un langage sur l'alphabet $\Sigma = \{a,b,c,d\}$. On verra plus loin que ce langage est « rationnel » (et pourra être désigné par l'expression rationnelle $dc{*}$). Voici quelques autres exemples de langages : \begin{itemize} \item Le langage (fini) $\{foo,bar,baz\}$ constitué des seuls trois mots $foo$, $bar$, $baz$ sur l'alphabet $\Sigma = \{a,b,f,o,r,z\}$. \item Le langage (fini) constitué des mots de longueur exactement $42$ sur l'alphabet $\Sigma = \{p,q,r\}$. Comme on l'a vu en \ref{number-of-words-of-length-n}, cet ensemble a pour cardinal exactement $3^{42}$. \item Le langage constitué des mots de longueur exactement $1$ sur un alphabet $\Sigma$ (= mots de une seule lettre), qu'on peut identifier à $\Sigma$ lui-même (en identifiant un mot de une lettre à la lettre en question, cf. \ref{convention-on-words-of-length-one}). \item Le langage (fini) constitué du seul mot vide (= mot de longueur exactement $0$) sur l'alphabet, disons, $\Sigma = \{p,q,r\}$. Ce langage $\{\varepsilon\}$ a pour cardinal $1$ (ou $3^0$ si on veut). Il ne faut pas le confondre avec le suivant : \item Le langage vide, qui ne contient aucun mot (sur un alphabet quelconque). Ce langage a pour cardinal $0$. \item Le langage sur l'alphabet $\Sigma=\{a,b\}$ constitué des mots qui commencent par trois $a$ consécutifs : ou, si on préfère, qui ont le mot $aaa$ comme préfixe. \item Le langage sur l'alphabet $\Sigma=\{a,b\}$ constitué des mots qui contiennent trois $a$ consécutifs ; ou, si on préfère, qui ont $aaa$ comme facteur. \item Le langage sur l'alphabet $\Sigma=\{a,b\}$ constitué des mots qui contiennent au moins trois $a$, non nécessairement consécutifs ; ou, si on préfère, qui ont $aaa$ comme sous-mot. \item Le langage sur l'alphabet $\Sigma=\{a\}$ constitué de tous les mots dont la longueur est un nombre premier ($L = \{aa, aaa, a^5, a^7, a^{11},\ldots\}$). Ce langage est infini. \item Le langage sur l'alphabet $\Sigma=\{0,1\}$ constitué de tous les mots commençant par un $1$ et qui, interprétés comme un nombre écrit en binaire, désignent un nombre premier ($L = \{10, 11, 101, 111, 1011, \ldots\}$). \item Le langage sur l'alphabet Unicode constitué de tous les mots qui représentent un document XML bien-formé d'après la spécification XML 1.0. \end{itemize} \thingy On pourrait aussi considérer un langage (sur l'alphabet $\Sigma$) comme une \emph{propriété} des mots (sur l'alphabet en question). Précisément, si $P$ est une propriété qu'un mot $w \in \Sigma^*$ peut ou ne pas avoir, on considère le langage $L_P = \{w \in \Sigma^* : w \text{~a la propriété~} P\}$, et inversement, si $L \subseteq \Sigma^*$ est un langage, on considère la propriété « appartenir à $L$ » : en identifiant la propriété et le langage qu'on vient d'associer l'un à l'autre (par exemple, le langage des mots commençant par $a$ et la propriété « commencer par $a$ »), un langage pourrait être considéré comme une propriété des mots. \smallskip {\footnotesize(Ce qui précède n'a rien de spécifique aux langages : une partie d'un ensemble $E$ quelconque peut être identifiée à une propriété que les éléments de $E$ peuvent ou ne pas avoir, à savoir, appartenir à la partie en question.)\par} \smallskip On évitera de faire cette identification pour ne pas introduire de complication, mais il est utile de la garder à l'esprit : par exemple, dans un langage de programmation fonctionnel, un « langage » au sens de ces notes peut être considéré comme une fonction (pure, c'est-à-dire, déterministe et sans effet de bord) prenant en entrée une chaîne de caractères et renvoyant un booléen. \thingy\label{union-and-intersection-of-languages} Si $L_1$ et $L_2$ sont deux langages sur un même alphabet $\Sigma$ (autrement dit, $L_1,L_2 \subseteq \Sigma^*$), on peut former les langages \index{réunion (de langages)|see{union}}\defin[union (de langages)]{union} $L_1\cup L_2$ et \defin[intersection (de langages)]{intersection} $L_1\cap L_2$ qui sont simplement les opérations ensemblistes usuelles (entre parties de $\Sigma^*$). \smallskip Les opérations correspondantes sur les propriétés de mots sont respectivement le « ou logique » (=disjonction) et le « et logique » (=conjonction) : à titre d'exemple, sur $\Sigma = \{a,b\}$ si $L_1$ est le langage des mots commençant par $a$ et $L_2$ le langage des mots finissant par $b$, alors $L_1 \cup L_2$ est le langage des mots commençant par $a$ \emph{ou bien} finissant par $b$, tandis que $L_1 \cap L_2$ est le langage des mots commençant par $a$ \emph{et} finissant par $b$. \thingy Si $L$ est un langage sur l'alphabet $\Sigma$, autrement dit $L \subseteq \Sigma^*$, on peut former le langage $\Sigma^*\setminus L$, parfois noté simplement $\overline L$ si ce n'est pas ambigu, dit \defin[complémentaire (langage)]{complémentaire} de $L$, et qui est simplement l'ensemble des mots sur $\Sigma$ \emph{n'appartenant pas} à $L$. L'opération correspondante sur les propriétés de mots est la négation logique. \smallskip À titre d'exemple, sur $\Sigma=\{a,b\}$, si $L$ est le langage des mots commençant par $a$, alors $\overline{L}$ est le langage des mots ne commençant pas par $a$, c'est-à-dire, la réunion de $\{\varepsilon\}$ et du langage des mots commençant par $b$ (car sur $\Sigma=\{a,b\}$, un mot ne commençant pas par $a$ est vide ou bien commence par $b$). \thingy\label{concatenation-of-languages} Si $L_1$ et $L_2$ sont deux langages sur un même alphabet $\Sigma$ (autrement dit, $L_1,L_2 \subseteq \Sigma^*$), on peut former le langage \defin[concaténation (de langages)]{concaténation} $L_1 L_2$ : il est défini comme l'ensemble des mots $w$ qui peuvent s'écrire comme concaténation d'un mot $w_1$ de $L_1$ et d'un mot $w_2$ de $L_2$, soit \[ \begin{aligned} L_1 L_2 &:= \{w_1 w_2 : w_1 \in L_1,\, w_2 \in L_2\}\\ &= \{w \in \Sigma^* : \exists w_1 \in L_1\, \exists w_2 \in L_2\,(w = w_1 w_2)\}\\ \end{aligned} \] \smallskip À titre d'exemple, sur l'alphabet $\Sigma = \{a,b,c,d\}$, si on a $L_1 = \{a,bb\}$ et $L_2 = \{bc, cd\}$ alors $L_1 L_2 = \{abc, acd, bbbc, bbcd\}$. \thingy Si $L$ est un langage sur l'alphabet $\Sigma$, autrement dit $L \subseteq \Sigma^*$, et si $r \in \mathbb{N}$, on peut définir un langage $L^r$, par analogie avec \ref{powers-of-a-word}, comme le langage $L^r = \{w_1\cdots w_r : w_1,\ldots,w_r \in L\}$ constitué des concaténation de $r$ mots appartenant à $L$, ou si on préfère, par récurrence : \begin{itemize} \item $L^0 = \{\varepsilon\}$, \item $L^{r+1} = L^r L$. \end{itemize} \smallskip À titre d'exemple, sur l'alphabet $\Sigma = \{a,b,c,d\}$, si on a $L = \{a,bb\}$, alors $L^2 = \{aa, abb, bba, bbbb\}$ et $L^3 = \{aaa, aabb, abba, abbbb, \penalty-100 bbaa, bbabb, bbbba, bbbbbb\}$. \medskip \emph{Attention}, $L^r$ n'est pas le langage $\{w^r : w\in L\}$ constitué des répétitions $r$ fois ($w^r$) des mots $w$ de $L$ : c'est le langage des concaténations de $r$ mots appartenant à $L$ \emph{mais ces mots peuvent être différents}. À titre d'exemple, si $L = \{a,b\}$ alors $L^r$ est le langage constitué des $2^r$ mots de longueur exactement $r$ sur $\{a,b\}$, ce n'est pas l'ensemble à deux éléments $\{a^r, b^r\}$ constitué des seuls deux mots $a^r = aaa\cdots a$ et $b^r = bbb\cdots b$. \thingy\label{kleene-star} Si $L$ est un langage sur l'alphabet $\Sigma$, on définit enfin l'\index{Kleene (étoile de)|see{étoile de Kleene}}\defin{étoile de Kleene} $L^*$ de $L$ comme le langage constitué des concaténations d'un nombre \emph{quelconque} de mots appartenant à $L$, c'est-à-dire la réunion de tous les langages $L^r$ mentionnés ci-dessus : \[ \begin{aligned} L^* &:= \bigcup_{r=0}^{+\infty} L^r = \bigcup_{r\in\mathbb{N}} L^r\\ &= \{w_1\cdots w_r : r\in\mathbb{N},\, w_1,\ldots,w_r\in L\}\\ \end{aligned} \] \smallskip À titre d'exemple, sur l'alphabet $\Sigma = \{a,b,c,d\}$, si on a $L = \{a,bb\}$, alors on a $L^* = \{\varepsilon, a, bb, \penalty-200 aa, abb, bba, bbbb, \penalty-200 aaa, aabb, abba, abbbb, \penalty-100 bbaa, bbabb, bbbba, bbbbbb, \ldots\}$. \smallskip Comme ci-dessus, il faut souligner que les mots $w_1,\ldots,w_r$ concaténés n'ont pas à être égaux : notamment, $\{a,b\}^*$ est le langage constitué de tous les mots sur l'alphabet $\{a,b\}$, pas le langage $\{a\}^* \cup \{b\}^*$ constitué des mots obtenus en répétant la lettre $a$ ou en répétant la lettre $b$. \smallskip On remarquera que la définition de $L^*$ ci-dessus redonne bien, lorsqu'on l'applique à l'alphabet $\Sigma$ lui-même (considéré comme langage des mots de longueur $1$), l'ensemble $\Sigma^*$ de tous les mots : la notation $\Sigma^*$ est donc justifiée \textit{a posteriori}. \smallskip Le mot vide appartient toujours à $L^*$ (quel que soit $L$) puisque $L^0 = \{\varepsilon\}$ et qu'on peut prendre $r=0$ ci-dessus (autrement dit, le mot vide est la concaténation de zéro mots de $L$). \smallskip {\footnotesize On peut par ailleurs montrer que $L^*$ est le plus petit (pour l'inclusion) langage $M$ tel que $M = \{\varepsilon\} \cup LM$. Cette observation sera implicite par exemple dans \ref{cfg-union-concatenation-and-star} ci-dessous, et motive aussi la construction $L^+$ qui suit.\par} \thingy\label{kleene-plus} On introduit parfois la notation $L^+ := \bigcup_{r=1}^{+\infty} L^r = \{w_1\cdots w_r : r>0,\penalty-100\, w_1,\ldots,w_r\in L\}$ pour l'ensemble des mots formés par concaténation d'un nombre \emph{non nul} de mots de $L$. Lorsque le mot vide $\varepsilon$ n'appartient pas déjà à $L$, ce langage $L^+$ diffère de $L^*$ seulement en ce qu'il ne contient pas $\varepsilon$ ; tandis que si $\varepsilon$ appartient déjà à $L$, alors $L^+$ est égal à $L^*$. En toute généralité, on a $L^+ = LL^*$. \thingy\label{definition-mirror-language} En rappelant la définition du mot miroir faite en \ref{definition-mirror-word}, si $L$ est un langage sur l'alphabet $\Sigma$, on définit le langage miroir $L^{\mathsf{R}}$ comme l'ensemble des mots miroirs des mots de $L$, c'est-à-dire $L^{\mathsf{R}} = \{w^{\mathsf{R}} : w \in L\}$. \bigbreak \thingy\label{set-of-languages} De même que l'ensemble des mots sur un alphabet $\Sigma$ admet une notation, à savoir $\Sigma^*$, on peut introduire une notation pour l'ensemble de tous les \emph{langages} (= ensembles de mots) sur $\Sigma$ : ce sera $\mathscr{P}(\Sigma^*)$. Il s'agit d'un cas particulier de la construction « ensemble des parties » (si $E$ est un ensemble, $\mathscr{P}(E) = \{A : A\subseteq E\}$ est l'ensemble de tous les sous-ensembles de $A$ ; c'est un axiome de la théorie des ensembles qu'un tel ensemble existe bien). On pourrait donc écrire « $L \in \mathscr{P}(\Sigma^*)$ » comme synonyme de « $L\subseteq \Sigma^*$ » ou de « $L$ est un langage sur $\Sigma$ » ; on évitera cependant de le faire, car cette notation est plus lourde qu'utile. \smallskip {\footnotesize Il sera marginalement question dans ces notes de « classes de langages » : une classe de langages est un ensemble de langages (c'est-à-dire une partie de $\mathscr{P}(\Sigma^*)$, ou si on préfère un élément de $\mathscr{P}(\mathscr{P}(\Sigma^*))$). On ne développera pas de théorie générale des classes de langages et on n'en parlera pas de façon systématique, mais on parlera de certaines classes de langages importantes : la classe des langages rationnels ou reconnaissables (§\ref{subsection-rational-languages} à §\ref{section-recognizable-languages}), la classe des langages algébriques (§\ref{section-context-free-grammars}), la classe des langages décidables (§\ref{section-computability}) et la classe des langages semi-décidable (\textit{ibid.}).\par} \subsection{Langages rationnels et expressions rationnelles}\label{subsection-rational-languages} \thingy \textbf{Introduction :} Les langages qui vont jouer le rôle le plus important dans ces notes sont les langages dits « rationnels » (qui seront définis de \ref{rational-languages} à \ref{regular-expressions} ci-dessous, et qui s'avéreront être les mêmes que les langages « reconnaissables » par automates finis définis en \ref{definition-recognizable-language}). Pour donner un premier aperçu informel de ce dont il s'agit avant de passer à une définition précise, commençons par donner quelques exemples, disons, sur l'alphabet $\Sigma = \{a,b,c,d\}$, de langages rationnels : \begin{itemize} \item le langage constitué des mots contenant au moins un $d$ ; \item le langage constitué des mots ne contenant aucun $d$ ; \item le langage constitué des mots commençant par un $d$ ; \item le langage constitué des mots commençant par un $d$ et finissant par un $c$ ; \item le langage constitué des mots commençant par un $d$ et finissant par un $c$, et dont toutes les lettres intermédiaires sont des $a$ ou des $b$, c'est-à-dire, le langage constitué des mots de la forme suivante : un $d$, puis un nombre quelconque de $a$ et de $b$, et enfin un $c$ ; \item le langage constitué des mots de la forme suivante : un $d$, puis un nombre quelconque de mots qui peuvent être soit $a$ soit $bb$, et enfin un $c$. \end{itemize} Ce dernier exemple est assez typique : on dira plus loin qu'il s'agit du langage « dénoté » par l'expression rationnelle $d(a|bb){*}c$, à lire comme « un $d$, puis autant qu'on veut (“$*$”) de mots qui peuvent être soit (“$|$”) un $a$ soit $bb$, et enfin un $c$ ». Les constructions essentielles qui permettront de fabriquer les langages rationnels sont : la réunion (j'autorise ceci \emph{ou} cela, par exemple « un $a$ \emph{ou bien} $bb$ », cf. \ref{union-and-intersection-of-languages}), la concaténation (je demande ceci \emph{puis} cela, par exemple « un $d$, \emph{puis} une suite quelconque de $a$ ou de $b$ », cf. \ref{concatenation-of-languages}), et l'étoile de Kleene (représentant une répétition quelconque d'un certain motif, cf. \ref{kleene-star}). \medskip L'importance des langages rationnels, et des expressions rationnelles (=régulières) qui les décrivent, vient : \begin{itemize} \item du point de vue théorique : de ce qu'ils forment une classe à la fois suffisamment simple pour pouvoir être étudiée, suffisamment riche pour contenir toutes sortes de langages intéressants, suffisamment naturelle pour être définie de plusieurs manières différentes, et suffisamment flexible pour être stable un certain nombre d'opérations ; \item du point de vue pratique et informatique : de ce qu'ils sont algorithmiquement commodes à manier (grâce à la théorie) et suffisent à représenter beaucoup de « recherches » qu'on a naturellement envie de faire dans un texte, de « motifs » qu'on peut vouloir trouver, ou de « contraintes » qu'on peut vouloir imposer à une chaîne de caractères. \end{itemize} \smallskip Passons maintenant à une définition plus précise. \bigbreak \thingy\label{rational-languages} Soit $\Sigma$ un alphabet. On va considérer les langages de base triviaux suivants : \begin{itemize} \item le langage vide $\varnothing$, \item le langage constitué du seul mot vide, $\{\varepsilon\}$, et \item les langages constitués d'un seul mot lui-même formé d'une seule lettre, $\{x\}$ pour chaque $x\in\Sigma$, \end{itemize} et on va les combiner par les opérations dites « rationnelles » suivantes : \begin{itemize} \item la réunion $(L_1,L_2) \mapsto L_1 \cup L_2$ (discutée en \ref{union-and-intersection-of-languages}), \item la concaténation $(L_1,L_2) \mapsto L_1 L_2$ (définie en \ref{concatenation-of-languages}), et \item l'étoile de Kleene $L \mapsto L^*$ (définie en \ref{kleene-star}). \end{itemize} On obtient ainsi une certaine famille de langages (cf. ci-dessous pour une définition plus précise), qu'on appelle \defin[rationnel (langage)]{langages rationnels} : les langages rationnels sont par définition exactement ceux qui peuvent s'obtenir à partir des langages de base énumérés ci-dessus par application (un nombre \emph{fini} de fois) des opérations qu'on vient de dire. Autrement dit, la réunion de deux langages rationnels, la concaténation de deux langages rationnels, et l'étoile de Kleene d'un langage rationnel, sont rationnels ; et les langages rationnels sont exactement ceux qu'on obtient ainsi à partir des langages de base. \smallskip À titre d'exemple, sur l'alphabet $\{a,b,c,d\}$, comme le langage $\{c\}$ (constitué du seul mot $c$) est rationnel, son étoile de Kleene, c'est-à-dire $\{c\}^* = \{\varepsilon, c, cc, ccc, cccc,\ldots\}$, est rationnel, et comme $\{d\}$ l'est aussi, la concaténation $\{d\}(\{c\}^*) = \{d, dc, dcc, dccc, \ldots\}$ est encore un langage rationnel. \thingy\label{stable-under-rational-operations} Formellement, la définition des langages rationnelles est la suivante : un ensemble $\mathscr{C} \subseteq \mathscr{P}(\Sigma^*)$ de langages (où $\mathscr{P}(\Sigma^*)$ est l'ensemble des parties de $\Sigma^*$, i.e., l'ensemble de tous les langages sur $\Sigma$, cf. \ref{set-of-languages}) est dit \emph{stable par opérations rationnelles} lorsqu'il est stable par les opérations de réunion, concaténation et étoile de Kleene, i.e., si $L_1,L_2 \in \mathscr{C}$ alors $L_1\cup L_2 \in \mathscr{C}$ et $L_1 L_2 \in \mathscr{C}$, et si $L \in \mathscr{C}$ alors $L^* \in \mathscr{C}$ ; le \emph{plus petit}\footnote{La classe des langages rationnelles (qu'on cherche à définir) n'est pas le seul ensemble de langages stable par opérations rationnelles : l'ensemble $\mathscr{P}(\Sigma^*)$ de tous les langages est aussi évidemment stable par opérations rationnelles ; on s'intéresse au plus petit $\mathscr{C}$ possible pour n'avoir que ce qu'on peut construire à partir des langages de base triviaux par un nombre fini d'opérations rationnelles.} (pour l'inclusion) ensemble de langages stable par opérations rationnelles et contenant les langages $\varnothing$, $\{\varepsilon\}$ et $\{x\}$ pour $x \in \Sigma$ (i.e. $\varnothing\in\mathscr{C}$, $\{\varepsilon\} \in \mathscr{C}$ et si $x\in\Sigma$ alors $\{x\}\in\mathscr{C}$), ou plus exactement, l'intersection de tous les ensembles $\mathscr{C}$ vérifiant tous ces propriétés, est la classe $\mathscr{R}$ des langages rationnels (et un langage rationnel est simplement un élément de $\mathscr{R}$). \medskip \emph{Attention !}, le fait que la classe $\mathscr{R}$ des langages rationnels soit stable par concaténation signifie que si $L_1$ et $L_2$ sont rationnels alors le langage $L_1 L_2$ (constitué de tous les mots concaténés d'un mot de $L_1$ et d'un mot de $L_2$) est rationnel ; \emph{cela ne signifie pas} qu'un langage rationnel donné soit stable par concaténation (un langage stable $L$ par concaténation est un langage tel que si $w_1,w_2\in L$ alors $w_1 w_2 \in L$). \thingy\label{regular-expressions} Pour décrire la manière dont un langage rationnel est fabriqué (à partir des langages de base par les opérations rationnelles), comme il est malcommode d'écrire quelque chose comme $\{d\}(\{c\}^*)$, on introduit un nouvel objet, les \index{expression rationnelle|see{rationnelle (expression)}}\defin[rationnelle (expression)]{expressions rationnelles} (certains préfèrent le terme d'\index{régulière (expression)|see{rationnelle}}\textbf{expressions régulières}), qui sont des expressions servant à dénoter un langage rationnel. Par exemple, plutôt que d'écrire « $\{d\}(\{c\}^*)$ », on parlera du langage « dénoté par l'expression rationnelle $dc{*}$ ». Ceci fournit du même coup une nouvelle définition des langages rationnels : ce sont les langages dénotés par une expression rationnelle. \smallskip Plus exactement, une expression rationnelle (sur un alphabet $\Sigma$) est un mot sur l'alphabet $\Sigma \cup \{\bot, \underline{\varepsilon}, {(}, {)}, {|}, {*}\}$, où $\bot, \underline{\varepsilon}, {(}, {)}, {|}, {*}$ sont de nouveaux caractères \emph{n'appartenant pas} à l'alphabet $\Sigma$, appelés \defin[métacaractère]{métacaractères}, et qui servent à marquer la manière dont est formée l'expression rationnelle. On définit simultanément la notion d'expression rationnelle $r$ et de \defin[dénoté (langage)]{langage dénoté} (ou \textbf{désigné} ou simplement \textbf{défini}) par l'expression $r$, noté $L(r)$ (ou $L_r$), de la manière suivante\footnote{Si on veut être tout à fait rigoureux, il faudrait démontrer, pour que cette définition ait un sens, qu'une expression rationnelle $r$ ne désigne qu'un seul langage $L(r)$, c'est-à-dire, qu'il n'y a qu'une seule façon de la lire : pour cela, il faudrait faire appel aux techniques qui seront introduites en §\ref{section-context-free-grammars} et dire que la grammaire que nous définissons ici pour les expressions rationnelles est \emph{inambiguë} (cf. \ref{ambiguous-grammar}).} : \begin{itemize} \item $\bot$ est une expression rationnelle et son langage dénoté est $L(\bot) := \varnothing$, \item $\underline{\varepsilon}$ est une expression rationnelle et son langage dénoté est $L(\underline{\varepsilon}) := \{\varepsilon\}$, \item si $x\in\Sigma$ est une lettre de l'alphabet $\Sigma$, alors le mot $x$ est une expression rationnelle et son langage dénoté est $L(x) := \{x\}$, \item si $r_1,r_2$ sont deux expressions rationnelles et $L_1 = L(r_1)$ et $L_2 = L(r_2)$ les langages dénotés correspondants, alors $r_1 r_2$ est une expression rationnelle et son langage dénoté est $L(r_1 r_2) := L_1 L_2$, \item si $r_1,r_2$ sont deux expressions rationnelles et $L_1 = L(r_1)$ et $L_2 = L(r_2)$ les langages dénotés correspondants, alors $(r_1|r_2)$ est une expression rationnelle\footnote{Certains préfèrent la notation $r_1+r_2$ ici, cf. \ref{regexp-notation-variations} pour une discussion.} et son langage dénoté est $L((r_1|r_2)) := L_1\cup L_2$, \item si $r$ est une expression rationnelle et $L = L(r)$ les langage dénoté correspondant, alors $(r){*}$ est une expression rationnelle\footnote{Notons que certains auteurs préfèrent mettre le $*$ en exposant ici, c'est-à-dire noter $(r)^*$ (comme nous l'avons fait pour l'étoile de Kleene $L^*$ d'un langage $L$) ; comme nous avons choisi de définir une expression rationnelle comme un mot sur l'alphabet $\Sigma \cup \{\bot, \underline{\varepsilon}, {(}, {)}, {|}, {*}\}$, il semble plus raisonnable de ne pas rentrer dans la considération byzantine de savoir si un mot peut contenir des symboles en exposant. En tout état de cause, il n'apparaîtra jamais aucune circonstance où les deux notations $X^*$ et $X{*}$ auraient tous les deux un sens et que ces sens diffèrent ! On peut donc ignorer purement et simplement la question de savoir si oui ou non l'étoile est en exposant.} et son langage dénoté est $L((r){*}) := L^*$. \end{itemize} Un langage rationnel est par construction la même chose qu'un langage pour lequel il existe une expression rationnelle qui le dénote. \thingy À titre d'exemple, sur l'alphabet $\Sigma = \{a,b,c,d\}$, $c$ est une expression rationnelle qui dénote le langage $\{c\}$, donc $(c){*}$ en est une qui dénote le langage $\{c\}^* = \{\varepsilon, c, cc, ccc,\ldots\}$, et enfin $d(c){*}$ en est une qui dénote le langage $\{d, dc, dcc, \ldots\}$ des mots formés d'un $d$ et d'une succession quelconques de $c$. Voici quelques autres exemples, toujours sur $\Sigma = \{a,b,c,d\}$ : \begin{itemize} \item l'expression rationnelle $(a|b)$ dénote le langage $\{a\} \cup \{b\} = \{a,b\}$ constitué des deux mots d'une seule lettre $a$ et $b$ ; \item l'expression rationnelle $(a|b)c$ dénote le langage $\{a,b\}\{c\} = \{ac,bc\}$, de même que $(ac|bc)$ ; \item l'expression rationnelle $(bc){*}$ dénote le langage $\{bc\}^* = \{\varepsilon, bc, bcbc, bcbcbc, \ldots\}$ ; \item l'expression rationnelle $(a|(bc){*})$ dénote le langage $\{a\} \cup \{bc\}^* = \{a,\penalty0 \varepsilon,\penalty1000 bc,\penalty1000 bcbc,\penalty1000 bcbcbc, \ldots\}$ ; \item l'expression rationnelle $(a|(bc){*})d$ dénote le langage $\{ad, d, bcd, bcbcd, bcbcbcd, \ldots\}$ ; \item l'expression rationnelle $\bot d$ dénote le langage vide $\varnothing$ (car il n'y a pas de mot dans le langage vide, donc pas non plus de mot dans sa concaténation avec le langage $\{d\}$) ; \item l'expression rationnelle $\underline{\varepsilon} d$ dénote le langage $\{d\}$ ; \item l'expression rationnelle $(\bot|c)$ dénote le langage $\{c\}$ ; \item l'expression rationnelle $(\underline{\varepsilon}|c)$ dénote le langage $\{\varepsilon, c\}$. \end{itemize} \thingy On dira qu'un mot $w$ \defin[vérifier (une expression rationnelle)]{vérifie} une expression rationnelle $r$ lorsque ce mot appartient au langage qu'elle dénote (i.e., $w \in L(r)$). Par exemple, $dccc$ vérifie l'expression rationnelle $d(c){*}$. \thingy Deux expressions rationnelles $r_1,r_2$ sont dites \defin[équivalentes (expressions rationnelles)]{équivalentes} lorsqu'elles dénotent le même langage. À titre d'exemple, sur l'alphabet $\{a,b\}$, les deux expressions rationnelles $(ab){*}a$ et $a(ba){*}$ sont équivalentes (toutes les deux dénotent le langage $\{a, aba, ababa, \ldots\}$ constitué des mots commençant et finissant par un $a$ et dans lesquels chaque paire de $a$ est séparée par un unique $b$). On verra plus loin (en \ref{equivalence-of-regexps-is-decidable}) qu'on dispose d'un algorithme permettant de décider si deux expressions rationnelles sont équivalentes. {\footnotesize\thingy\label{regexp-identities} Voici quelques exemples d'équivalences d'expressions rationnelles (valables en remplaçant les différents $r$ qui interviennent dedans par des expressions rationnelles quelconques) : \begin{itemize} \item identités « triviales » :\quad $(r|\bot)\equiv r$,\quad $(\bot|r)\equiv r$,\quad $r\bot\equiv \bot$,\quad $\bot r\equiv \bot$, \quad $r\underline{\varepsilon} \equiv r$,\quad $\underline{\varepsilon}r \equiv r$,\quad $(\bot){*}\equiv \underline{\varepsilon}$ ; \item identité d'associativité :\quad $((r_1|r_2)|r_3)\equiv (r_1|(r_2|r_3))$ ; \item identités de distributivité :\quad $r(r_1|r_2)\equiv (rr_1|rr_2)$,\quad $(r_1|r_2)r\equiv (r_1r|r_2r)$ ; \item identité de commutativité :\quad $(r_1|r_2)\equiv (r_2|r_1)$ ; \item identités « apériodiques » :\quad $((r_1|r_2)){*} \equiv (r_1){*}(r_2(r_1){*}){*}$,\quad $((r_1|r_2)){*} \equiv ((r_1){*}r_2){*}(r_1){*}$\quad et\quad $(r_1 r_2){*} \equiv (\underline{\varepsilon}|r_1(r_2 r_1){*}r_2)$ ; \item identités « cycliques » :\quad $(r){*} \equiv (\underline{\varepsilon}|r)(rr){*} \equiv (\underline{\varepsilon}|r|rr)(rrr){*} \equiv (\underline{\varepsilon}|r|rr|rrr)(rrrr){*} \equiv \cdots$ ; \item identités d'« idempotence » :\quad $(r|r)\equiv r$,\quad $((r){*}){*} \equiv (r){*}$ ; \end{itemize} Ces différentes identités présentent un intérêt théorique dont l'explication dépasserait le cadre de ces notes ; cependant, il peut être intéressant de réfléchir à ce que chacune signifie. Signalons au passage que toutes ces identités \emph{ne suffisent pas} à produire toutes les équivalences entre expressions rationnelles. Par exemple, elles ne permettent pas de démontrer l'équivalence suivante : $(a|b){*} \equiv ((a|b)(b|ab{*}ab{*}ab{*}a)){*}(\underline{\varepsilon}|(a|b)(|ab{*}|ab{*}ab{*}|ab{*}ab{*}ab{*}))$ (écrite avec les conventions de \ref{convention-on-writing-regexps}) ; la question d'arriver à trouver un système d'axiomes qui permet de déduire toutes les équivalences entre expressions rationnelles est un problème délicat (il n'y en a notamment pas qui soit fini). \par} \thingy\label{convention-on-writing-regexps} La convention de parenthésage introduite ci-dessus est inambiguë mais parfois inutilement lourde : on se permettra parfois de l'alléger, par exemple d'écrire $(r_1|r_2|r_3)$ pour $((r_1|r_2)|r_3)$ (ou pour $(r_1|(r_2|r_3))$, ce qui n'a guère d'importance vu qu'elles dénotent le même langage), ou encore $x{*}$ pour $(x){*}$ lorsque $x$ est formé d'un seul caractère. Pour retirer des parenthèses, la convention sur la priorité des opérations est la suivante : l'opération d'étoile ${*}$ est la plus prioritaire (c'est-à-dire que $ab{*}$ se lit comme $a(b){*}$ et non pas comme $(ab){*}$), la concaténation est de priorité intermédiaire, et la barre de disjonction $|$ est la moins prioritaire (c'est-à-dire que $ab|cd$ se lit comme $(ab|cd)$ et pas comme $a(b|c)d$). \thingy\label{regexp-notation-variations} La disjonction que nous avons notée « ${|}$ » est plus souvent notée « $+$ » par les mathématiciens\footnote{Dans le même contexte mathématique, il est alors fréquent de noter « $0$ » pour ce que nous avons noté « $\bot$ » (c'est un élément neutre pour la disjonction), et on en profite souvent pour noter « $1$ » pour « $\varepsilon$ » et/ou « $\underline{\varepsilon}$ » (c'est un élément neutre pour la concaténation). Par exemple, beaucoup des identités énoncées en \ref{regexp-identities} sembleront plus naturelles si on les écrit avec ces notations.}. Cette notation est plus élégante pour faire le lien avec l'algèbre, et plus logique dans des cadres plus généraux (expressions rationnelles et automates « avec multiplicités ») ; nous avons cependant préféré l'éviter parce qu'elle prête à confusion : en effet, on a introduit en \ref{kleene-plus} une opération $L \mapsto L^+$ qui n'a rien à voir avec la disjonction, et de nombreux moteurs d'expressions régulières en informatique (par exemple, \texttt{egrep}, cf. §\ref{subsection-remarks-on-regexp-syntax}) utilisent effectivement le symbole \texttt{+} dans ce sens, c'est-à-dire pour désigner « au moins une répétition » (cf. \ref{remarks-egrep-plus-etc}). Même si nous avons cherché à ne pas utiliser le symbole $+$ pour éviter l'ambiguïté, il faut savoir que ce double sens existe (soit comme disjonction, soit comme l'opération de \ref{kleene-plus}). {\footnotesize Les métacaractères $\bot$ et $\underline{\varepsilon}$ sont introduits ici par souci de complétude mais sont rarement utilisés dans les expressions rationnelles (le métacaractère $\underline{\varepsilon}$ a été souligné parce qu'il s'agit d'une vraie lettre et non pas du mot vide ; on peut ignorer cette subtilité qui n'a que très peu d'importance).\par} \subsection{Remarques sur les moteurs d'expressions régulières en informatique}\label{subsection-remarks-on-regexp-syntax} \thingy Dans le monde informatique, il existe de nombreux \emph{moteurs d'expressions régulières}, c'est-à-dire outils (qu'il s'agisse de primitives d'un langage, de bibliothèques externes, de programmes en ligne de commande, ou autres) permettant de savoir si un mot est reconnu par une expression régulière (=rationnelle), autrement dit, s'il appartient au langage dénoté par elle. L'un de ces moteurs est le programme \texttt{egrep} standard sous Unix/POSIX ; un autre est le moteur \texttt{java.util.regex} de Java. \thingy Les expressions régulières au sens de ces différents moteurs sont généralement plus puissantes que les expressions rationnelles au sens mathématique défini en \ref{regular-expressions} ci-dessus : différentes extensions permettent de désigner des langages qui ne sont pas rationnels au sens mathématique. L'extension la plus fréquente est celle des \emph{références arrière} (ou \emph{backreferences} en anglais) qui permettent de demander qu'un facteur du mot se retrouve aussi à un autre emplacement. Par exemple, pour beaucoup de moteurs (notamment \texttt{egrep}), l'expression régulière « \texttt{(a*)b\char"5C\relax 1} » désigne le langage $\{a^nba^n : a\in\mathbb{N}\} = \{b,aba, aabaa,\ldots\}$ des mots formés d'un nombre quelconque de $a$ puis d'un $b$ puis de la \emph{même suite de $a$} (le « \texttt{\char"5C\relax 1} » désigne « une copie de la chaîne de caractères qui a été capturée par le premier jeu de parenthèses ») ; or ce langage \emph{n'est pas rationnel} au sens mathématique (ce sera une conséquence du « lemme de pompage » \ref{pumping-lemma}), c'est donc bien le signe qu'on sort du cadre théorique décrit plus haut. \thingy\label{remarks-egrep-plus-etc} Il existe aussi un certain nombre de constructions qui, sans dépasser la puissance des expressions rationnelles au sens mathématique, apportent des commodités d'écriture dans un contexte informatique. Parmi les caractères les plus courants de cette sorte, mentionnons le \texttt{+} qui signifie « au moins une répétition » (alors que \texttt{*} signifie « au moins zéro répétitions ») : ainsi, « $r\texttt{+}$ » est équivalent à $rr{*}$ ; on trouve aussi \texttt{?} pour « au plus une répétition » : c'est-à-dire que « $r\texttt{?}$ » est équivalent à $(\underline{\varepsilon}|r)$ (qui sera d'ailleurs simplement noté $(|r)$ car il n'y a jamais de symbole spécial pour $\underline{\varepsilon}$). Parmi d'autres constructions qui ne sortent pas du cadre théorique des langages rationnels, mentionnons encore le point « \texttt{.} » qui désigne un caractère quelconque de l'alphabet (on peut le voir comme une abréviation pour $(x_1|x_2|\ldots|x_N)$ où $x_1,x_2,\ldots,x_N$ sont tous les éléments de $\Sigma$ — ce qui serait très fastidieux à écrire si on devait énumérer tout Unicode). Les crochets tels que « \texttt{[$xyz$]} » désignent un caractère quelconque parmi ceux listés (c'est donc la même chose que $(x|y|z)$ mais cela ne fonctionne qu'avec des caractères individuels ; en contrepartie, on peut écrire des intervalles comme « \texttt{[a-z]} » qui désigne un caractère quelconque entre \texttt{a} et \texttt{z} dans l'ordre ASCII/Unicode\footnote{...ou parfois l'ordre de tri défini par la « locale » en cours : c'est malheureusement une source supplémentaire de confusion et de bugs.}, ou bien des négations, comme « \texttt{[\char"5Ea-z]} » qui désigne un caractère qui \emph{n'est pas} entre \texttt{a} et \texttt{z}) ou « \texttt{[\char"5Eaeio-z]} » qui désigne un caractère qui \emph{n'est ni} \texttt{a} ni \texttt{e} ni\texttt{i} ni entre \texttt{o} et \texttt{z}). Toutes sortes d'autres raccourcis ou commodités de notation peuvent exister, par exemple \texttt{\char"5C<} et \texttt{\char"5C>} pour désigner un début et une fin de mot (la définition précise de « mot » pouvant varier), ou encore \texttt{$r$\{$n_1$,$n_2$\}} qui cherche entre $n_1$ et $n_2$ répétitions de $r$ : ainsi, « $r\texttt{\{2,5\}}$ » est équivalent à $(rr|rrr|rrrr|rrrrr)$. \thingy Une autre subtilité est que la plupart des moteurs d'expressions régulières en informatique vont, par défaut, \emph{rechercher un facteur} (appelé « sous-chaîne » en informatique) vérifiant l'expression \emph{à l'intérieur} de la chaîne donnée, plutôt que tester si la chaîne tout entière vérifie l'expression. Pour éviter ce comportement, on peut utiliser des \index{ancre (métacaractère)}\emph{ancres}, typiquement commandées par les (méta)caractères « \texttt{\char"5E} » et « \texttt{\char"24} » qui servent à ancrer l'expression au début et à la fin de la chaîne respectivement : c'est-à-dire que rechercher « \texttt{a} » recherche un \texttt{a} quelconque à l'intérieur de la chaîne donnée, rechercher « \texttt{\char"5E\relax a} » demande que le \texttt{a} soit au début de la chaîne donnée rechercher « \texttt{a\char"24} » demande que le \texttt{a} soit à la fin de la chaîne donnée, et rechercher « \texttt{\char"5E\relax a\char"24} » demande que la chaîne donnée soit exactement \texttt{a} (cet exemple n'est donc pas très utile, mais de façon générale, trouver si une chaîne vérifie une expression rationnelle $r$, revient à y chercher « \texttt{\char"5E\relax $r$\char"24} »). \thingy Comme les expressions régulières en informatique sont représentées par des chaînes de caractères qui appartiennent au même alphabet (ASCII ou Unicode) que les chaînes sur lesquelles on effectue la recherche, le problème se pose de distinguer les métacaractères (l'étoile de Kleene \texttt{*}, par exemple) des caractères eux-mêmes (comment rechercher les chaînes contenant le caractère « \texttt{*} » si \texttt{*} est utilisé par l'étoile de Kleene ?). La solution est d'introduire un mécanisme d'\emph{échappement}, normalement par le caractère \emph{backslash} : ainsi, « \texttt{x\char"5C*} » recherche un \texttt{x} suivi d'un astérisque \texttt{*}, tandis que « \texttt{x*} » recherche un nombre quelconque de répétitions de la lettre \texttt{x}. \thingy Il existe malheureusement de nombreuses différences, parfois très subtiles, entre moteurs, ne serait-ce que dans les notations : un moteur pourra par exemple noter « \texttt{(?)} » ce qu'un autre note « \texttt{\char"5C(\char"5C?\char"5C)} » et vice versa. La seule solution est de consulter attentivement la documentation de chaque moteur d'expressions régulières pour connaître la syntaxe utilisée. Signalons tout de même qu'il existe deux principales familles de syntaxes d'expressions régulières en informatique : les expressions régulières « POSIX étendues », utilisée notamment par le programme Unix \texttt{egrep}, et les expressions régulières de Perl, qui ont été réadaptées dans beaucoup de langages, notamment Java, JavaScript, Python et d'autres. \thingy Signalons comme complication supplémentaire que dans de nombreux langages, les expressions régulières sont saisies comme des chaînes de caractères plutôt que d'avoir une syntaxe spéciale, et ceci a pour effet d'introduire un niveau supplémentaire d'échappement : par exemple, en Java, pour rechercher si une chaîne de caractères $s$ contient un astérisque, on utilisera \texttt{$s$.matches("\char"5C\char"5C*")} puisque l'expression régulière à utiliser est \texttt{\char"5C*} et que cette chaîne de caractères s'écrit \texttt{"\char"5C\char"5C*"} en Java. De même, dans le shell Unix, pour rechercher une ligne d'un fichier contenant un \texttt{x} suivi d'un nombre quelconque de \texttt{y} suivi d'un \texttt{z}, on utilisera \texttt{egrep \char"27xy*z\char"27 \ monfichier}, les guillemets (simples) ayant pour fonction d'éviter que le shell Unix interprète lui-même l'astérisque comme un caractère spécial (dont le rôle est différent de l'étoile de Kleene, quoique suffisamment proche pour pouvoir causer une confusion). \section{Automates finis}\label{section-finite-automata} \setcounter{comcnt}{0} \thingy Les automates finis sont un modèle de calcul particulièrement simple et particulièrement appropriés à l'étude et à l'analyse des langages rationnels. Il faut imaginer un automate fini comme une machine disposant d'une quantité finie (et sous-entendu, très limitée) de mémoire : la configuration complète de cette mémoire est décrite par un \emph{état}, qui appartient à un ensemble fini d'états possibles. On fournit un mot à l'automate en le lui faisant consommer lettre par lettre (de la première à la dernière), et à chaque lettre qu'il reçoit, l'automate prend une décision (à savoir, passer dans un nouvel état) en fonction de son état actuel et de la lettre qu'on lui donne à consommer ; l'automate commence par un état dit \emph{initial} ; lorsque le mot a été entièrement consommé, l'état dans lequel l'automate se trouve a pour conséquence soit que l'automate \emph{accepte} le mot (s'il se trouve dans un état \emph{final}), soit qu'il le \emph{rejette}. L'ensemble des mots acceptés par l'automate est un langage dit \emph{reconnaissable}. On va voir en \ref{kleenes-theorem} que ces langages reconnaissables sont en fait les mêmes que les langages rationnels définis en \ref{rational-languages}. \thingy Une subtilité est qu'il existe plusieurs sortes d'automates finis. Nous allons en définir quatre ou cinq, de plus en plus généraux, mais nous allons voir qu'ils sont, finalement, tous équivalents, c'est-à-dire que leur puissance de calcul, ou les langages qu'ils sont capables de reconnaître, sont toujours les mêmes (en revanche, cette équivalence peut avoir un coût algorithmique, car la conversion d'une sorte d'automate en une autre n'est pas gratuite). Du plus particulier au plus général, les automates que nous allons définir sont informellement décrits ainsi : \begin{itemize} \item les automates finis déterministes (complets) (cf. \ref{definition-dfa}) : ceux-ci partent d'un état initial bien défini, suivent à chaque lettre consommée une transition bien définie vers un nouvel état, et leur comportement est donc entièrement déterministe (d'où le nom) ; \item les automates finis déterministes à spécification incomplète (cf. \ref{definition-dfai}) : la différence est qu'ici l'automate n'a pas forcément d'instruction sur quoi faire quand il est dans un certain état et reçoit un certain symbole, il peut manquer des transitions, auquel cas l'automate cesse de fonctionner et rejette le mot ; \item les automates non-déterministes (cf. \ref{definition-nfa}) : ceux-ci peuvent admettre \emph{plusieurs} possibilités de nouvel état dans lequel transitionner lorsqu'on leur donne une lettre donnée à consommer depuis un état donné, et l'automate accepte le mot s'il y a une manière de faire les transitions qui résulte en ce que le mot soit accepté ; \item les automates non-déterministes à transitions spontanées (cf. \ref{definition-enfa}) : ceux-ci ont, en plus des précédents, le pouvoir d'évoluer spontanément, sans consommer de lettre ; \item on introduira aussi des automates encore plus généraux, à transitions étiquetées par des expressions rationnelles (cf. \ref{definition-rnfa}) pour montrer que tout langage reconnaissable est rationnel. \end{itemize} \thingy Dans tous les cas, les automates se représenteront comme des graphes orientés (admettant des boucles et arêtes multiples ; cf. \ref{discussion-example1} ci-dessous pour un exemple simple), dont les sommets sont les états de l'automate (on leur donne généralement des noms pour les reconnaître, mais ces noms sont arbitraires), dont les arêtes sont étiquetées par des symboles (des lettres de l'alphabet, ou éventuellement le mot vide $\varepsilon$ ou une expression rationnelle sur l'alphabet), et dont certains sommets (=états) sont distingués comme « initiaux » et/ou « finaux » (par une flèche pointant depuis nulle part vers l'état en question ou depuis l'état en question vers nulle part). Un mot sera accepté par l'automate toujours selon la même logique : s'il y a moyen de relier un état initial à un état final par un chemin orienté dans le graphe tel que le mot corresponde à la lecture des étiquettes des arêtes du chemin dans l'ordre. \subsection{Automates finis déterministes complets (=DFA)} \thingy\label{definition-dfa} Un \defin{automate fini déterministe} (complet), ou en abrégé \index{DFA|see{automate fini déterministe}}\textbf{DFA} (pour \textit{deterministic finite automaton}), sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un ensemble fini $Q$ dont les éléments sont appelés \defin[état]{états}, \item d'un état $q_0 \in Q$ appelé \defin[initial (état)]{état initial} (un DFA a un \emph{unique} état initial), \item d'un ensemble $F \subseteq Q$ d'états appelés états \defin[final (état)]{finaux}\footnote{Le pluriel de « final » est indifféremment « finaux » ou « finals ».} ou \index{acceptant (état)|see{final}}\textbf{acceptants}, \item d'une fonction $\delta \colon Q\times\Sigma \to Q$ appelée \defin[transition (fonction de)]{fonction de transition}. \end{itemize} \thingy\label{graphical-representation-of-dfa} Graphiquement, on représente un DFA comme un graphe orienté aux arêtes étiquetées par des éléments de $\Sigma$ : plus exactement, on trace un nœud pour chaque élément $q \in Q$, et lorsque $\delta(q,x) = q'$ on introduit une flèche $q \to q'$ étiquetée par la lettre $x$. La condition cruciale (pour être un DFA) est que, pour chaque état $q \in Q$ et chaque lettre $x \in \Sigma$, \emph{il existe une unique} arête partant de $q$ et étiquetée par $x$ (c'est essentiellement une reformulation du fait que $\delta$ est une fonction). En outre, on introduit une flèche pointant de nulle part vers $q_0$ (pour marquer celui-ci comme l'état initial), et pour chaque $q\in F$ une flèche pointant de $q$ vers nulle part\footnote{Certains auteurs préfèrent d'autres conventions, par exemple celle consistant à entourer deux fois les états finaux.} (pour marquer ceux-ci comme états finaux). Pour abréger la représentation graphique, lorsque plusieurs arêtes étiquetées par des lettres $x,y$ différentes relient les mêmes sommets $q,q'$ (i.e., lorsqu'on a à la fois $\delta(q,x) = q'$ et $\delta(q,y) = q'$), on pourra écrire « $x,y$ », voire « $x|y$ », sur l'arête en question et ne la tracer qu'une seule fois. (Voir \ref{discussion-example2} ci-dessous pour un exemple.) \thingy\label{discussion-example1} Pour donner un exemple simple, l'automate sur $\Sigma = \{a,b\}$ représenté ci-dessous a $Q = \{0,1\}$ et $q_0 = 0$ et $F = \{1\}$ et la fonction de transition $\delta$ donnée par $\delta(0,a) = 0$ et $\delta(0,b) = 1$ et $\delta(1,a) = 1$ et $\delta(1,b) = 0$. On pourra se convaincre (une fois lues les définitions plus loin) que cet automate accepte les mots dont le nombre de $b$ est impair. \begin{center} %%% begin example1 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,20.306bp) [draw,circle,state,final] {$1$}; \node (q0) at (18bp,20.306bp) [draw,circle,state,initial] {$0$}; \draw [->] (q1) ..controls (75.212bp,3.6347bp) and (64.284bp,-1.3057bp) .. (54bp,1.3057bp) .. controls (50.042bp,2.3107bp) and (46.047bp,3.8633bp) .. node[auto] {$b$} (q0); \draw [->] (q0) ..controls (46.106bp,20.306bp) and (58.578bp,20.306bp) .. node[auto] {$b$} (q1); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); \draw [->] (q0) to[loop above] node[auto] {$a$} (q0); % \end{tikzpicture} %%% end example1 %%% \end{center} \thingy Il faut comprendre le fonctionnement d'un DFA de la manière suivante : initialement, l'automate est dans l'état initial $q_0$. On va lui présenter un mot $w \in \Sigma^*$, lettre par lettre, de la gauche vers la droite : i.e., si $w = x_1\cdots x_n$ on va faire consommer à l'automate les lettres $x_1,x_2,\ldots,x_n$ dans cet ordre. Le fait de consommer une lettre $x$ fait passer l'automate de l'état $q$ à l'état $\delta(q,x)$ ; autrement dit, l'automate passe successivement dans les états $q_0$ puis $q_1 := \delta(q_0,x_1)$ puis $q_2 := \delta(q_1,x_2)$, et ainsi de suite jusqu'à $q_n := \delta(q_{n-1},x_n)$ : on dit que l'automate effectue les transitions $q_0\to q_1$ (en consommant $x_1$) puis $q_1\to q_2$ (en consommant $x_2$) et ainsi de suite. Si $q_n$ est l'état dans lequel se trouve l'automate une fois qu'il a consommé le mot $w$, on dira que l'automate \emph{accepte} ou \emph{rejette} le mot selon que $q_n \in F$ ou que $q_n \not\in F$. \smallskip Graphiquement, on peut présenter la procédure de la manière suivante : on part de l'état $q_0$ (sommet du graphe représentant l'automate) indiqué par la flèche entrante (pointant de nulle part), et pour chaque lettre du mot $w = x_1\cdots x_n$ considéré, on suit l'arête portant cette lettre pour étiquette (et partant de l'état où on se trouve actuellement). Si à la fin l'état $q_n$ est acceptant (représenté par une flèche pointant vers nulle part), le mot $w$ est accepté, sinon il est rejeté. Cela revient encore à dire que le mot $w$ est accepté lorsqu'il existe un chemin orienté dans l'automate, reliant l'état $q_0$ initial à un état $q_n$ final, et tel que le mot $w = x_1 \cdots x_n$ soit obtenu en lisant dans l'ordre les étiquettes $x_i$ des différentes arêtes $q_{i-1} \to q_i$ de ce chemin. Cette définition pourra resservir presque à l'identique pour les autres sortes d'automates, la spécificité des DFA est que l'état initial $q_0$ est unique et que connaissant l'étiquette $x_i$ il n'y a qu'une seule transition $q_{i-1} \to q_i$ possible (il n'y a pas de choix à faire, pas de non-déterminisme). \thingy\label{definition-multiple-transition-function} Pour donner de façon plus formelle la définition du langage accepté par un automate, il sera utile d'introduire une fonction $\delta^*$ de transition multiple (une généralisation de $\delta$), qui définit l'état $\delta^*(q,w)$ dans lequel aboutit un DFA si à partir de l'état $q$ on lui fait consommer successivement les lettres d'un mot $w$. Formellement : si $A = (Q,q_0,F,\delta)$ est un DFA sur l'alphabet $\Sigma$, on définit une fonction $\delta^* \colon Q\times\Sigma^* \to Q$ par $\delta^*(q,x_1\cdots x_n) = \delta(\cdots\delta(\delta(q,x_1),x_2)\cdots,x_n)$ ou, ce qui revient au même (par récurrence sur la longueur du second argument) : \begin{itemize} \item $\delta^*(q,\varepsilon) = q$ quel que soit $q\in Q$ (où $\varepsilon$ désigne le mot vide), \item $\delta^*(q,wx) = \delta(\delta^*(q,w),x)$ quels que soient $q\in Q$, $w\in\Sigma^*$ et $x\in\Sigma$, \end{itemize} (en particulier, $\delta^*(q,x) = \delta(q,x)$ si $x\in\Sigma$, donc avec la convention faite en \ref{convention-on-words-of-length-one}, on peut dire que $\delta^*$ prolonge $\delta$ ; il sera par ailleurs utile de remarquer que $\delta^*(q,ww') = \delta^*(\delta^*(q,w),w')$, ce qui se démontre par récurrence). Cette fonction $\delta^*$ étant définie, on dira que l'automate $A$ \defin[accepter]{accepte} ou \index{reconnaître|see{accepter}}\textbf{reconnaît} un mot $w$ lorsque $\delta^*(q_0,w) \in F$ ; dans le cas contraire, on dira qu'il \textbf{rejette} le mot $w$. \thingy\label{definition-recognizable-language} L'ensemble $L(A)$ (ou $L_A$) des mots acceptés par l'automate $A$ s'appelle \textbf{langage accepté}, ou \textbf{reconnu}, ou \textbf{défini}, par l'automate $A$. \smallskip Un langage $L \subseteq \Sigma^*$ qui peut s'écrire sous la forme du langage $L(A)$ accepté par un DFA $A$ s'appelle \defin[reconnaissable (langage)]{reconnaissable} (sous-entendu : par automate déterministe fini). \smallskip On dit que deux DFA $A,A'$ sont \defin[équivalents (automates)]{équivalents} lorsqu'ils reconnaissent le même langage, i.e., $L(A) = L(A')$. \thingy\label{discussion-example2} Donnons un exemple : l'automate fini ci-dessous sur $\Sigma := \{a,b,c\}$ a trois états, $Q = \{0,1,2\}$. On peut en faire la description informelle suivante : l'automate commence dans l'état $0$, où il reste jusqu'à rencontrer un $a$ qui le fait passer dans l'état $1$, où il reste ensuite jusqu'à rencontrer un $b$ qui le fait passer dans l'état $2$, où il reste définitivement et qui constitue le seul état acceptant. \begin{center} %%% begin example2 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q2) at (178bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (46.106bp,18bp) and (58.578bp,18bp) .. node[auto] {$a$} (q1); \draw [->] (q1) to[loop above] node[auto] {$a,c$} (q1); \draw [->] (q1) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$b$} (q2); \draw [->] (q0) to[loop above] node[auto] {$b,c$} (q0); \draw [->] (q2) to[loop above] node[auto] {$a,b,c$} (q2); % \end{tikzpicture} %%% end example2 %%% \end{center} Cette description rend clair le fait que l'automate en question accepte exactement les mots contenant un $a$ suivi, pas forcément immédiatement, d'un $b$ ; autrement dit, les mots dont $ab$ est un sous-mot (cf. \ref{definition-subword}). Ce langage est donc reconnaissable. (Il est aussi rationnel puisque dénoté par l'expression rationnelle $(b|c){*}a(b|c){*}b(a|b|c){*}$.) \thingy\label{definition-dfa-accessible-state} Un état $q$ d'un DFA est dit \defin[accessible (état)]{accessible} lorsqu'il existe un mot $w \in \Sigma^*$ tel que $q = \delta(q_0,w)$, autrement dit, graphiquement, lorsqu'il existe un chemin orienté $q_0,q_1,\ldots,q_n=q$ reliant l'état initial $q_0$ à l'état $q$ considéré : bref, cela correspond à un état auquel il est possible que l'automate arrive (en partant de l'état initial et en consommant un certain mot). Dans le cas contraire, l'état est dit \textbf{inaccessible}. Il est évident qu'ajouter ou supprimer (ou modifier) les états inaccessibles dans un DFA ne change rien au langage reconnu (on obtient des automates équivalents). \smallskip Par exemple, dans le DFA qui suit, l'état $2$ est inaccessible (l'automate est donc équivalent à celui représenté en \ref{discussion-example1}). On remarquera qu'il ne change rien que cet état soit final ou non. \begin{center} %%% begin example1b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,20.306bp) [draw,circle,state,final] {$1$}; \node (q0) at (18bp,20.306bp) [draw,circle,state,initial] {$0$}; \node (q2) at (172bp,20.306bp) [draw,circle,state,final] {$2$}; \draw [->] (q1) ..controls (75.212bp,3.6347bp) and (64.284bp,-1.3057bp) .. (54bp,1.3057bp) .. controls (50.042bp,2.3107bp) and (46.047bp,3.8633bp) .. node[auto] {$b$} (q0); \draw [->] (q0) ..controls (46.106bp,20.306bp) and (58.578bp,20.306bp) .. node[auto] {$b$} (q1); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); \draw [->] (q0) to[loop above] node[auto] {$a$} (q0); % \end{tikzpicture} %%% end example1b %%% \end{center} \thingy On va maintenant introduire différentes variations sur le thème des automates finis, c'est-à-dire différentes généralisations de la définition faite en \ref{definition-dfa} correspondant à des types d'automates finis plus puissants que les DFA mais dont on va montrer, à chaque fois, qu'ils peuvent se ramener à des DFA au sens où pour chacun de ces automates généralisés on pourra construire algorithmiquement un DFA qui reconnaît le même langage (si bien que la classe des langages reconnaissables par n'importe laquelle de ces sortes d'automates sera toujours la même). Les plus simples sont les automates déterministes finis incomplets et on va donc commencer par eux. \subsection{Automates finis déterministes à spécification incomplète (=DFAi)} \thingy\label{definition-dfai} Un \textbf{automate fini déterministe à spécification incomplète} ou \textbf{...partielle}, ou simplement \defin{automate fini déterministe incomplet}\footnote{\label{footnote-on-word-incomplete}Le mot « incomplet » signifie en fait « non nécessairement complet », i.e., l'automate a le droit de manquer certaines transitions, mais il peut très bien être complet (un DFA est un DFAi particulier, pas le contraire).}, en abrégé \index{DFAi|see{automate fini déterministe incomplet}}\textbf{DFAi}, sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un ensemble fini $Q$ d'états, \item d'un état initial $q_0 \in Q$, \item d'un ensemble $F \subseteq Q$ d'états finaux, \item d'une fonction de transition \emph{partielle}\footnote{Une « fonction partielle » $f\colon X\dasharrow Y$, où $X, Y$ sont deux ensembles est, par définition, la même chose qu'une fonction $f\colon D\to Y$ où $D\subseteq X$ est un sous-ensemble de $X$ appelé \textbf{ensemble de définition} de $f$. (Lorsque en fait $D=X$, la fonction est dite « totale ».)} $\delta \colon Q\times\Sigma \dasharrow Q$, \end{itemize} autrement dit, la seule différence avec la définition faite en \ref{definition-dfa} est que la fonction $\delta$ est partielle, ce qui signifie qu'elle n'est pas obligatoirement définie sur tout couple $(q,x) \in Q\times\Sigma$. \smallskip Un DFA est considéré comme un DFAi particulier où la fonction de transition $\delta$ se trouve être définie partout. \thingy Graphiquement, on représente un DFAi comme un DFA, à la différence près que pour chaque $q\in Q$ et chaque $x\in \Sigma$, il y a maintenant \emph{au plus une} (et non plus exactement une) arête partant de $q$ et étiquetée par $x$. \smallskip L'intérêt informatique des DFAi est de ne pas s'obliger à stocker inutilement des transitions et des états inutiles au sens où ils ne permettront jamais d'accepter le mot (voir la notion d'automate « émondé » en \ref{coaccessible-and-useful-states} ci-dessous). C'est la raison pour laquelle, même si les DFA complets sont théoriquement plus satisfaisants à manier (pour la même raison qu'une fonction totale est plus satisfaisante qu'une fonction partielle), il est souvent algorithmiquement plus judicieux de travailler sur des DFAi. \thingy Le fonctionnement d'un DFAi est le même que celui d'un DFA, à la modification suivante près : si on donne à consommer à l'automate une lettre pour laquelle la transition n'est pas définie, i.e., s'il rencontre un $x$ pendant qu'il se trouve dans un état $q$ pour lequel $\delta(q,x)$ n'est pas défini, alors l'automate cesse de fonctionner : l'automate n'a plus d'état, n'effectue plus de transition, et n'acceptera pas le mot quelles que soient les lettres ultérieures. \smallskip Cela revient une fois de plus à dire que le mot $w$ est accepté lorsqu'il existe un chemin orienté dans l'automate, reliant l'état $q_0$ initial à un état $q_n$ final, et tel que le mot $w = x_1 \cdots x_n$ soit obtenu en lisant dans l'ordre les étiquettes $x_i$ des différentes arêtes $q_{i-1} \to q_i$ de ce chemin. La différence des DFAi par rapport aux DFA est que, cette fois, la tentative de chemin pourrait s'arrêter prématurément (on ne peut plus consommer un symbole et passer dans un nouvel état, et à plus forte raison, aboutir à un état final). \thingy Formellement : si $A = (Q,q_0,F,\delta)$ est un DFAi sur l'alphabet $\Sigma$, on définit une fonction $\delta^* \colon Q\times\Sigma^* \dasharrow Q$ par $\delta^*(q,x_1\cdots x_n) = \delta(\cdots\delta(\delta(q,x_1),x_2)\cdots,x_n)$ avec la convention que dès qu'une sous-expression n'est pas définie, toute l'expression n'est pas définie, ou, ce qui revient au même (par récurrence sur la longueur du second argument) : \begin{itemize} \item $\delta^*(q,\varepsilon) = q$ quel que soit $q\in Q$ (où $\varepsilon$ désigne le mot vide), \item $\delta^*(q,wx) = \delta(\delta^*(q,w),x)$ à condition que $q' := \delta^*(q,w)$ soit défini et que $\delta(q',x)$ le soit (et si ces deux conditions ne sont pas satisfaites, $\delta^*(q,wx)$ n'est pas défini). \end{itemize} Enfin, l'automate $A$ accepte un mot $w$ lorsque $\delta^*(q_0,w)$ \emph{est défini} et appartient à $F$ ; dans le cas contraire (que ce soit parce que $\delta^*(q_0,w)$ n'est pas défini ou parce qu'étant défini il n'appartient pas à $F$), l'automate rejette le mot. \smallskip Le langage accepté $L(A)$ et l'équivalence de deux automates sont définis de façon analogue aux DFA (cf. \ref{definition-recognizable-language}). \thingy\label{discussion-example2b} Voici un exemple de DFAi sur l'alphabet $\Sigma = \{a,b,c\}$. Cet automate reconnaît exactement les mots formés d'un nombre quelconque de $c$, suivis d'un $a$, suivis d'un nombre quelconque de $c$, suivis d'un $b$, suivis d'un nombre quelconque de $c$. \begin{center} %%% begin example2b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q2) at (178bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (46.106bp,18bp) and (58.578bp,18bp) .. node[auto] {$a$} (q1); \draw [->] (q1) to[loop above] node[auto] {$c$} (q1); \draw [->] (q1) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$b$} (q2); \draw [->] (q0) to[loop above] node[auto] {$c$} (q0); \draw [->] (q2) to[loop above] node[auto] {$c$} (q2); % \end{tikzpicture} %%% end example2b %%% \end{center} (Ce langage est aussi dénoté par l'expression rationnelle $c{*}ac{*}bc{*}$.) \begin{prop}\label{completion-of-dfai} Soit $A = (Q,q_0,F,\delta)$ un DFAi sur un alphabet $\Sigma$. Alors il existe un DFA $A' = (Q',q'_0,F',\delta')$ (sur le même alphabet $\Sigma$) qui soit équivalent à $A$ au sens où il reconnaît le même langage $L(A') = L(A)$. De plus, $A'$ se déduit algorithmiquement de $A$ en ajoutant au plus un état « puits » à $A$ : on a $\#Q' \leq \#Q + 1$. \end{prop} \begin{proof} On définit $Q' = Q \cup \{q_\bot\}$ où $q_\bot$ est un nouvel état (n'appartenant pas à $Q$), qu'on appellera « puits ». On garde l'état initial $q'_0 = q_0$. On garde l'ensemble $F' = F$ d'états finaux, c'est-à-dire notamment que le puits n'est pas acceptant. Enfin, on définit $\delta'(q,x)$ pour $q\in Q'$ et $x\in\Sigma$ par \[ \begin{aligned} \delta'(q,x) &= \delta(q,x)\text{ si $\delta(q,x)$ est défini}\\ \delta'(q,x) &= q_\bot\text{ sinon}\\ \end{aligned} \] (notamment, $\delta'(q_\bot,x) = q_\bot$ quel que soit $x$). Il est alors facile de voir que $A'$ a le même comportement que $A$ au sens où $\delta^{\prime*}(q,w) = \delta^*(q,w)$ lorsque le terme de droite est défini et $\delta^{\prime*}(q,w) = q_\bot$ sinon (le DFA $A'$ « tombe dans le puits » lorsque le DFAi $A$ cesse de fonctionner). En particulier, ils reconnaissent les mêmes langages. \end{proof} \thingy De façon générale, un état \defin[puits (état)]{puits} dans un DFA est un état $q_\bot$ tel que $\delta(q_\bot,x)=q_\bot$ pour toute lettre $x$. On dit que le DFA $A'$ est obtenu en \defin[compléter (un DFAi)]{complétant} le DFAi $A$ lorsqu'il est obtenu par la procédure décrite dans la démonstration de cette proposition, c'est-à-dire par l'addition d'un état puits vers lequel on fait pointer toutes les transitions manquantes (sauf si $A$ est déjà complet, auquel cas on convient qu'il est son propre complété, i.e., on n'ajoute un puits que quand c'est réellement nécessaire). \thingy À titre d'exemple, le DFA suivant représente la complétion du DFAi représenté en \ref{discussion-example2b} : \begin{center} %%% begin example2c %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \filldraw (0bp,0bp) -- (0bp,182bp) -- (214bp,182bp) -- (214bp,0bp) -- cycle; \end{scope} \node (q1) at (102bp,131bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,85bp) [draw,circle,state,initial] {$0$}; \node (q2) at (196bp,85bp) [draw,circle,state,final] {$2$}; \node (qbot) at (102bp,22bp) [draw,circle,state] {$\bot$}; \draw [->] (q1) to[loop above] node[auto] {$c$} (q1); \draw [->] (q2) to[loop above] node[auto] {$c$} (q2); \draw [->] (qbot) to[loop below] node[auto] {$a,b,c$} (qbot); \draw [->] (q0) ..controls (44.565bp,65.359bp) and (61.506bp,52.343bp) .. node[auto] {$b$} (qbot); \draw [->] (q0) to[loop above] node[auto] {$c$} (q0); \draw [->] (q1) ..controls (102bp,96.993bp) and (102bp,73.356bp) .. node[auto] {$a$} (qbot); \draw [->] (q0) ..controls (46.061bp,100.18bp) and (63.141bp,109.76bp) .. node[auto] {$a$} (q1); \draw [->] (q2) ..controls (166.87bp,65.735bp) and (145.76bp,51.281bp) .. node[auto] {$a,b$} (qbot); \draw [->] (q1) ..controls (132.83bp,116.08bp) and (154.08bp,105.46bp) .. node[auto] {$b$} (q2); % \end{tikzpicture} %%% end example2c %%% \end{center} \thingy\label{coaccessible-and-useful-states} On définit un état accessible d'un DFAi comme pour un DFA (cf. \ref{definition-dfa-accessible-state}). \smallskip On dira en outre d'un état $q$ d'un DFAi qu'il est \defin[co-accessible (état)]{co-accessible} lorsqu'il existe un mot $w \in \Sigma^*$ tel que $\delta^*(q,w)$ soit défini et soit final, autrement dit, graphiquement, lorsqu'il existe un chemin orienté reliant l'état $q$ considéré à un état final (remarquer que les états finaux eux-mêmes sont co-accessibles : prendre $w=\varepsilon$ dans ce qu'on vient de dire). Un état non co-accessible est donc un état à partir duquel il est impossible de faire accepter le mot. Cette définition pourrait également être faite pour les DFA, mais pour les DFAi elle présente l'intérêt qu'on peut supprimer les états non co-accessibles (ainsi, bien sûr, que toutes les transitions qui y conduisent) et obtenir de nouveau un DFAi. \smallskip Un DFAi dont tous les états sont à la fois accessibles et co-accessibles (on les dit aussi \defin[utile (état)]{utiles}) est parfois appelé \defin[émondé (automate)]{émondé}. On peut émonder un DFAi en ne conservant que ses états utiles\footnote{Si on aime pinailler, il y a un petit problème pour émonder un DFAi n'ayant aucun état final (donc aucun état co-accessible, donc aucun état utile) ; pour résoudre ce problème, on peut modifier légèrement la définition d'un DFAi et autoriser que l'état initial ne soit pas défini (auquel cas l'automate n'accepte évidemment aucun mot, i.e., reconnaît le langage $\varnothing$), si bien que l'automate émondé d'un DFAi sans état final est l'automate vide (sans aucun état).} : ainsi, tout DFAi est équivalent à un DFAi émondé. \thingy Il faut prendre garde au fait que certains auteurs définissent les « automates finis déterministes » (sans précision supplémentaire) comme étant complets par défaut, d'autres comme étant incomplets par défaut. Le plus prudent est de préciser systématiquement « complet » ou « incomplet » (en se rappelant qu'« incomplet » signifie « non nécessairement complet », cf. la note \ref{footnote-on-word-incomplete} sous \ref{definition-dfai}) dès qu'il est important de ne pas confondre. \subsection{Automates finis non-déterministes (=NFA)} \thingy\textbf{Idée générale :} Le principe directeur général du non-déterminisme en informatique est, grossièrement parlant, le suivant : on a un mécanisme de calcul (ici, un automate fini) qui doit accepter ou rejeter une certaine donnée (ici, un mot qui lui est présenté), mais plutôt que d'évoluer de façon déterministe d'une configuration à une autre (ici, d'un état à un autre), il se peut qu'il existe plusieurs possibilités différentes, autrement dit, une configuration peut évoluer de plusieurs manières différentes, ce qui donne lieu à plusieurs chemins de calcul différents. Selon le point de vue qu'on adopte, et éventuellement la stratégie algorithmique pour modéliser le non-déterminisme, on peut considérer que ces chemins sont empruntés tous simultanément (et qu'on est dans tous les états possibles à la fois\footnote{Certains sont parfois tentés de comparer avec une superposition quantique : il existe effectivement une analogie, mais le quantique implique une description bien précise des états (avec des amplitudes associées) qui n'est pas pertinente ici, et l'analogie mal appliquée conduirait à des erreurs en complexité algorithmique ; il vaut donc mieux ne pas y penser.}, c'est d'ailleurs l'approche qui servira en \ref{determinization-of-nfa}), ou que tous les chemins possibles sont testés successivement, ou encore que l'appareil non-déterministe « devine » quel est le bon ; mais en tout cas la règle fondamentale du non-déterminisme est toujours la suivante : \emph{la donnée est acceptée dès lors qu'il existe au moins un chemin de calcul possible qui conduit à l'accepter} (dans notre cas, cela signifiera au moins un chemin acceptant le mot). \thingy\label{definition-nfa} Un \defin{automate fini non-déterministe}, en abrégé \index{NFA|see{automate fini non-déterministe}}\textbf{NFA}, sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un ensemble fini $Q$ d'états, \item d'un ensemble $I \subseteq Q$ d'états dits initiaux, \item d'un ensemble $F \subseteq Q$ d'états dits finaux, \item d'une \emph{relation} de \index{transition (relation de)}transition $\delta \subseteq Q \times \Sigma \times Q$ (c'est-à-dire une partie du produit cartésien $Q \times \Sigma \times Q$, i.e., un ensemble de triplets $(q,x,q') \in Q \times \Sigma \times Q$) ; lorsque $(q,x,q') \in \delta$, on dira qu'il existe une transition étiquetée par $x$ de $q$ vers $q'$. \end{itemize} Autrement dit, on autorise maintenant un ensemble quelconque d'états initiaux, et de même, au lieu qu'un état $q$ et une lettre $x$ déterminent un unique état $q' = \delta(q,x)$, on a maintenant affaire à un ensemble $\delta$ quelconque de triplets $(q,x,q')$ pour les transitions possibles. \thingy Un DFAi (ou \textit{a fortiori} un DFA) est considéré comme un NFA particulier en définissant l'ensemble des états initiaux du NFA comme un singleton, $I_{\mathrm{NFA}} = \{q_{0,\mathrm{DFAi}}\}$, et en définissant la relation de transition du NFA comme le graphe de la fonction de transition du DFAi, c'est-à-dire $(q,x,q') \in \delta_{\mathrm{NFA}}$ lorsque $\delta_{\mathrm{DFAi}}(q,x)$ est défini et vaut $q'$. \thingy Graphiquement, on représente un NFA comme un DFA : comme un graphe orienté dont les nœuds sont les éléments de $Q$, et où on place une arête étiquetée $x$ de $q$ vers $q'$ pour chaque triplet $(q,x,q') \in \delta$ ; comme précédemment, on marque les états initiaux par une flèche entrante (i.e., pointant de nulle part) et les états finaux par une flèche sortante (i.e., pointant vers nulle part). \thingy Il faut comprendre le fonctionnement d'un NFA de la manière suivante : un mot $w$ est accepté par l'automate lorsqu'\emph{il existe} un chemin orienté conduisant d'\emph{un} état initial $q_0$ à un état final $q_n$ et tel que le mot $w = x_1 \cdots x_n$ soit obtenu en lisant dans l'ordre les étiquettes $x_i$ des différentes arêtes $q_{i-1} \to q_i$ de ce chemin ; autrement dit, $w$ est accepté lorsqu'\emph{il existe} $q_0,\ldots,q_n \in Q$ tels que $q_0 \in I$ et $q_n\in F$ et $(q_{i-1},x_i,q_i) \in \delta$ pour chaque $1\leq i\leq n$. \smallskip La différence cruciale avec les DFAi est donc que, maintenant, il pourrait exister plusieurs chemins possibles partant d'un état initial dont les transitions sont étiquetées par les lettres du même mot. Insistons bien sur le fait que le mot est accepté dès lors que \emph{l'un} au moins de ces chemins relie un état initial à un état final. \thingy De même que dans le cadre des DFA et DFAi on a étendu la fonction de transition $\delta$ à une fonction $\delta^*$ qui décrit le comportement de l'automate quand on consomme plusieurs caractères (cf. \ref{definition-multiple-transition-function}), on va étendre la relation de transition $\delta$ d'un NFA à la situation où on consomme plusieurs caractères. On a $(q,w,q') \in \delta^*$ lorsqu'il existe un chemin orienté conduisant de $q$ à $q'$ et tel que le mot $w$ soit obtenu en lisant dans l'ordre les étiquettes des différentes arêtes de ce chemin. \smallskip Formellement : si $A = (Q,I,F,\delta)$ est un NFA sur l'alphabet $\Sigma$, on définit une relation $\delta^* \subseteq Q \times \Sigma^* \times Q$ par $(q,w,q') \in \delta^*$ lorsque $w = x_1\cdots x_n$ et qu'il existe $(q_0,\ldots,q_n)$ tels que $q_0 = q$ et $q_n = q'$ et $(q_{i-1},x_i,q_i) \in \delta$ pour chaque $1\leq i\leq n$ ; ou, ce qui revient au même (par récurrence sur la longueur de $w$) : \begin{itemize} \item $(q,\varepsilon,q') \in \delta^*$ si et seulement si $q'=q$, \item $(q,wx,q') \in \delta^*$ si et seulement si il existe $q^\sharp$ tel que $(q,w,q^\sharp) \in \delta^*$ et $(q^\sharp,x,q') \in \delta$. \end{itemize} Enfin, l'automate $A$ accepte un mot $w$ lorsqu'il existe $q_0\in I$ et $q_\infty\in F$ tels que $(q_0,w,q_\infty) \in \delta^*$. \smallskip Le langage accepté $L(A)$ et l'équivalence de deux automates sont définis de façon analogue aux DFA (cf. \ref{definition-recognizable-language}). \thingy\label{discussion-example4} Pour illustrer le fonctionnement des NFA, considérons l'automate à trois états sur $\Sigma=\{a,b\}$ représenté par la figure suivante : on a $Q = \{0,1,2\}$ avec $I=\{0\}$ et $F=\{2\}$ et $\delta = \{(0,a,0),\penalty0 (0,b,0),\penalty-100 (0,a,1),\penalty-50 (1,a,2),\penalty0 (1,b,2)\}$. \begin{center} %%% begin example4 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q2) at (188bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (46.106bp,18bp) and (58.578bp,18bp) .. node[auto] {$a$} (q1); \draw [->] (q1) ..controls (128.76bp,18bp) and (145.63bp,18bp) .. node[auto] {$a,b$} (q2); \draw [->] (q0) to[loop above] node[auto] {$a,b$} (q0); % \end{tikzpicture} %%% end example4 %%% \end{center} Cet automate n'est pas déterministe car il existe deux transitions étiquetées $a$ partant de l'état $0$. En considérant les différents chemins possibles entre $0$ et $2$ dans ce graphe, on comprend que le langage qu'il reconnaît est le langage des mots sur $\{a,b\}$ dont l'avant-dernière lettre est un $a$ (c'est aussi le langage dénoté par l'expression rationnelle $(a|b){*}a(a|b)$). Une façon de présenter le non-déterminisme est que l'automate « devine », quand il est dans l'état $0$ et qu'on lui fait consommer un $a$, si ce $a$ sera l'avant-dernière lettre, et, dans ce cas, passe dans l'état $1$ pour pouvoir accepter le mot. \bigbreak Comme les DFAi avant eux, les NFA sont en fait équivalents aux DFA ; mais cette fois-ci, le coût algorithmique de la transformation peut être bien plus important : \begin{prop}\label{determinization-of-nfa} Soit $A = (Q,I,F,\delta)$ un NFA sur un alphabet $\Sigma$. Alors il existe un DFA $A' = (Q',\textbf{q}'_0,F',\delta')$ (sur le même alphabet $\Sigma$) qui soit équivalent à $A$ au sens où il reconnaît le même langage $L(A') = L(A)$. De plus, $A'$ se déduit algorithmiquement de $A$ avec une augmentation au plus exponentielle du nombre d'états : $\#Q' \leq 2^{\#Q}$. \end{prop} \begin{proof} On définit $Q' = \mathscr{P}(Q) = \{\mathbf{q} \subseteq Q\}$ l'\emph{ensemble des parties} de $Q$ : c'est ce qui servira d'ensemble d'états du DFA $A'$ qu'on construit (i.e., un état de $A'$ est un ensemble d'états de $A$ — intuitivement, c'est l'ensemble des états dans lesquels on se trouve simultanément). On pose $\textbf{q}'_0 = I$ (l'état initial de $A'$ sera l'ensemble de tous les états initiaux de $A$, vu comme un élément de $Q'$) ; et on pose $F' = \{\mathbf{q}\subseteq Q :\penalty-100 \mathbf{q}\cap F \neq\varnothing\}$ : les états finaux de $A'$ sont les états $\mathbf{q}$ qui, vus comme des ensembles d'états de $A$, contiennent \emph{au moins un} état final. Enfin, pour $\mathbf{q}\subseteq Q$ et $x \in \Sigma$, on définit $\delta'(\mathbf{q},x) = \{q_1\in Q : \exists q_0\in\mathbf{q}\, ((q_0,x,q_1) \in \delta)\}$ comme l'ensemble de tous les états $q_1$ de $A$ auxquels on peut accéder depuis un état $q_0$ dans $\mathbf{q}$ par une transition $(q_0,x,q_1)$ (étiquetée par $x$) de $A$. Il est alors facile de voir (par récurrence sur $|w|$) que $\delta^{\prime*}(\mathbf{q},w)$ est l'ensemble de tous les les états $q_1 \in Q$ tels que $(q_0,w,q_1)\in\delta^*$, i.e., auxquels on peut accéder depuis un état $q_0$ dans $\mathbf{q}$ par une suite de transitions de $A$ étiquetées par les lettres de $w$. En particulier, $\delta^{\prime*}(I,w)$ est l'ensemble de tous les états de $A$ auxquels on peut accéder depuis un état initial de $A$ par une suite de transitions de $A$ étiquetées par les lettres de $w$ : le mot $w$ appartient à $L(A)$ si et seulement si cet ensemble contient un élément de $F$, ce qui par définition de $F'$ signifie exactement $\delta^{\prime*}(I,w) \in F'$. On a bien prouvé $L(A') = L(A)$. Enfin, $\#Q' = \#\mathscr{P}(Q) = 2^{\#Q}$ (car une partie de $Q$ peut se voir à travers sa fonction indicatrice, qui est une fonction $Q \to \{0,1\}$). \end{proof} \thingy On dit que le DFA $A'$ est obtenu en \defin[déterminiser (un NFA)]{déterminisant} le NFA $A$ lorsqu'il est obtenu par la procédure décrite dans la démonstration de cette proposition en ne gardant que les états accessibles. \smallskip Algorithmiquement, la déterminisation de $A$ s'obtient par la procéduire suivante : \begin{itemize} \item créer une file (ou une pile) d'ensembles d'états de $A$ ; initialiser cette file avec le seul élément $I$ (vu comme un sous-ensemble de $Q$) ; et créer l'automate $A'$ avec initialement l'unique état $I$, marqué comme état initial, et aussi comme final s'il contient un état final de $A$ ; \item tant que la file/pile n'est pas vide : en extraire un élément $\mathbf{q}$, et, pour chaque lettre $x\in\Sigma$, \begin{itemize} \item calculer l'ensemble $\mathbf{q}' = \{q_1\in Q : \exists q_0\in\mathbf{q}\, ((q_0,x,q_1) \in \delta)\}$ (en listant tous les triplets $(q_0,x,q_1) \in\delta$ dont le premier élément est dans $\mathbf{q}$ et le second élément est $x$), \item si $\mathbf{q}'$ n'existe pas déjà comme état de $A'$, l'y ajouter, et dans ce cas, l'ajouter à la file/pile, et de plus, si $\mathbf{q}'$ contient un état final de $A$, marquer cet état comme final pour $A'$, \item et ajouter à $A'$ la transition $\delta'(\mathbf{q},x) = \mathbf{q}'$. \end{itemize} \end{itemize} La file/pile sert à stocker les états de $A'$ qui ont été créés mais pour lesquels les transitions sortantes n'ont pas encore été calculées. L'algorithme se termine quand la file/pile se vide, ce qui se produit toujours en au plus $2^{\#Q}$ étapes car chaque $\mathbf{q} \subseteq Q$ ne peut apparaître qu'une seule fois dans la file/pile. Il se peut que l'état $\varnothing$ soit créé : cet état servira effectivement de puits, au sens où on aura $\delta'(\varnothing,x) = \varnothing$ quel que soit $x$ (et l'état n'est pas acceptant). Il arrive souvent que l'automate déterminisé soit plus petit que les $2^{\#Q}$ états qu'il a dans le pire cas. \thingy À titre d'exemple, déterminisons le NFA $A$ présenté en \ref{discussion-example4} : on commence par construire un état $\{0\}$ pour $A'$ car le NFA a $\{0\}$ pour ensemble d'états initiaux ; on a $\delta'(\{0\},a) = \{0,1\}$ car $0$ et $1$ sont les deux états auxquels on peut arriver dans $A$ par une transition partant de $0$ et étiquetée par $a$, tandis que $\delta'(\{0\},b) = \{0\}$ ; ensuite, $\delta'(\{0,1\},a) = \{0,1,2\}$ car $0,1,2$ sont les trois états auxquels on peut arriver dans $A$ par une transition partant de $0$ ou $1$ et étiquetée par $a$ ; et ainsi de suite. En procédant ainsi, on construit l'automate à $4$ états qui suit : \begin{center} \footnotesize %%% begin example4det %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \filldraw (0bp,0bp) -- (0bp,163bp) -- (212bp,163bp) -- (212bp,0bp) -- cycle; \end{scope} \node (q02) at (188bp,27bp) [draw,circle,state,final] {$\{0,2\}$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$\{0\}$}; \node (q01) at (100bp,56bp) [draw,circle,state] {$\{0,1\}$}; \node (q012) at (188bp,106bp) [draw,circle,state,final] {$\{0,1,2\}$}; \draw [->] (q01) ..controls (127.39bp,49.663bp) and (137.27bp,46.959bp) .. (146bp,44bp) .. controls (150.77bp,42.384bp) and (155.77bp,40.486bp) .. node[auto] {$b$} (q02); \draw [->] (q02) ..controls (159.35bp,21.739bp) and (147.76bp,21.451bp) .. (138bp,25bp) .. controls (132.05bp,27.164bp) and (126.38bp,30.754bp) .. node[auto] {$a$} (q01); \draw [->] (q0) ..controls (45.691bp,30.678bp) and (60.407bp,37.668bp) .. node[auto] {$a$} (q01); \draw [->] (q0) to[loop above] node[auto] {$b$} (q0); \draw [->] (q01) ..controls (128.64bp,72.07bp) and (144.34bp,81.198bp) .. node[auto] {$a$} (q012); \draw [->] (q012) to[loop above] node[auto] {$a$} (q012); \draw [->] (q02) ..controls (155.56bp,18.853bp) and (136.78bp,14.735bp) .. (120bp,13bp) .. controls (102.32bp,11.172bp) and (97.763bp,12.273bp) .. (80bp,13bp) .. controls (68.968bp,13.451bp) and (56.843bp,14.36bp) .. node[auto] {$b$} (q0); \draw [->] (q012) ..controls (188bp,73.926bp) and (188bp,64.965bp) .. node[auto] {$b$} (q02); % \end{tikzpicture} %%% end example4det %%% \end{center} On remarquera qu'on a construit moins que les $2^3 = 8$ états qu'on pouvait craindre. {\footnotesize Il est par ailleurs instructif de regarder comment fonctionne l'automate $A'$ ci-dessus pour déterminer si l'avant-dernière lettre d'un mot est un $a$ : essentiellement, il retient deux bits d'information, à savoir « est-ce que la dernière lettre consommée était un $a$ ? » et « est-ce que l'avant-dernière lettre consommée était un $a$ ? » ; chacune des quatre combinaisons de ces deux bits correspond à un état de $A'$ : non/non est l'état $\{0\}$, oui/non est l'état $\{0,1\}$, non/oui est l'état $\{0,2\}$, et oui/oui est l'état $\{0,1,2\}$.\par} \thingy On vient donc de voir que les NFA sont équivalents aux DFA en ce sens qu'ils permettent de définir les mêmes langages. Il est néanmoins intéressant de les définir et de les étudier pour plusieurs raisons : d'une part, l'équivalence qu'on vient de voir, c'est-à-dire la déterminisation d'un NFA en DFA, a un coût algorithmique important (exponentiel en nombre d'états dans le pire cas), d'autre part, certaines opérations sur les automates se définissent plus naturellement sur les NFA que sur les DFA, et certaines constructions conduisent naturellement à un NFA. On verra en particulier en \ref{subsection-recognizable-languages-under-rational-operations} que pour transformer une expression rationnelle en automate, on passera naturellement par un NFA, même si on peut souhaiter le déterminiser ensuite. \subsection{Automates finis non-déterministes à transitions spontanées (=εNFA)} \thingy\label{definition-enfa} Un \defin{automate fini non-déterministe à transitions spontanées} ou \textbf{...à $\varepsilon$-transitions}, en abrégé \index{epsilon-NFA@$\varepsilon$NFA|see{automate fini non-déterministe à transitions spontanées}}\textbf{εNFA}, sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un ensemble fini $Q$ d'états, \item d'un ensemble $I \subseteq Q$ d'états dits initiaux, \item d'un ensemble $F \subseteq Q$ d'états dits finaux, \item d'une relation de transition $\delta \subseteq Q \times (\Sigma\cup\{\varepsilon\}) \times Q$. \end{itemize} Autrement dit, on autorise maintenant des transitions étiquetées par le mot vide $\varepsilon$ plutôt que par une lettre $x \in\Sigma$ : ces transitions sont dites \defin[spontanée (transition)]{spontanées}, ou \index{epsilon-transition@$\varepsilon$-transition|see{spontanée}}\textbf{ε-transitions}. \smallskip Soulignons qu'on ne définit les ε-transitions \emph{que} pour les automates non-déterministes : ou, pour dire les choses autrement, \emph{un automate qui possède des ε-transitions est par nature même non-déterministe}. \smallskip La représentation graphique des εNFA est évidente (on utilisera le symbole « $\varepsilon$ » pour étiqueter les transitions spontanées). Un NFA est considéré comme un εNFA particulier pour lequel il n'y a pas de ε-transition. \thingy Intuitivement, les transitions spontanées signifient que l'automate a la possibilité de passer spontanément, c'est-à-dire \emph{sans consommer de lettre}, d'un état $q$ à un état $q'$, lorsque ces états sont reliés par une ε-transition. (On comprend, du coup, pourquoi un automate à transition spontanée est forcément non-déterministe : ces transitions spontanées ne sont qu'une \emph{possibilité}, ce qui sous-entend le non-déterminisme.) \smallskip De façon plus précise, un εNFA accepte un mot $w$ lorsqu'\emph{il existe} un chemin orienté conduisant d'un état initial $q_0$ à un état final $q_n$ et tel que $w$ coïncide avec le mot obtenu en lisant dans l'ordre les étiquettes $t_i$ des différentes arêtes $q_{i-1} \to q_i$ de ce chemin, quitte à ignorer les $\varepsilon$. Autrement dit, $w$ est accepté lorsqu'\emph{il existe} $q_0,\ldots,q_n \in Q$ et $t_1,\ldots,t_n \in (\Sigma\cup\{\varepsilon\})$ tels que $q_0 \in I$ et $q_n\in F$ et $(q_{i-1},t_i,q_i) \in \delta$ pour chaque $1\leq i\leq n$ et $w = t_1\cdots t_n$ (\emph{attention} : dans cette écriture, $t_1,\ldots,t_n$ ne sont pas forcément les lettres de $w$, certains des $t_i$ peuvent être le mot vide $\varepsilon$, les lettres de $w$ sont obtenues en ignorant ces symboles). \thingy On veut de nouveau définir une relation $\delta^*$ telle que $(q,w,q') \in \delta^*$ lorsqu'il existe un chemin orienté conduisant de $q$ à $q'$ et tel que le mot $w$ soit obtenu en lisant dans l'ordre les étiquettes des différentes arêtes de ce chemin. Voici une formalisation possible : si $A = (Q,I,F,\delta)$ est un εNFA sur l'alphabet $\Sigma$, on définit une relation $\delta^* \subseteq Q \times \Sigma^* \times Q$ par $(q,w,q') \in \delta^*$ lorsqu'il existe $q_0,\ldots,q_n \in Q$ et $t_1,\ldots,t_n \in (\Sigma\cup\{\varepsilon\})$ tels que $q_0 = q$ et $q_n = q'$ et $(q_{i-1},t_i,q_i) \in\delta$ pour chaque $1\leq i\leq n$, et enfin $w = t_1\cdots t_n$. Enfin, l'automate $A$ accepte un mot $w$ lorsqu'il existe $q_0\in I$ et $q_\infty\in F$ tels que $(q_0,w,q_\infty) \in \delta^*$. \smallskip Le langage accepté $L(A)$ et l'équivalence de deux automates sont définis de façon analogue aux DFA (cf. \ref{definition-recognizable-language}). \thingy\label{discussion-example5} Voici un exemple de εNFA particulièrement simple sur $\Sigma = \{a,b,c\}$: \begin{center} %%% begin example5 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q2) at (178bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (46.106bp,18bp) and (58.578bp,18bp) .. node[auto] {$\varepsilon$} (q1); \draw [->] (q1) to[loop above] node[auto] {$b$} (q1); \draw [->] (q1) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$\varepsilon$} (q2); \draw [->] (q0) to[loop above] node[auto] {$a$} (q0); \draw [->] (q2) to[loop above] node[auto] {$c$} (q2); % \end{tikzpicture} %%% end example5 %%% \end{center} En considérant les différents chemins possibles entre $0$ et $2$ sur ce graphe, on comprend que le langage qu'il reconnaît est celui des mots sur $\{a,b,c\}$ formés d'un nombre quelconque de $a$ suivi d'un nombre quelconque de $b$ suivi d'un nombre quelconque de $c$, ou, si on préfère, le langage dénoté par l'expression rationnelle $a{*}b{*}c{*}$. \thingy Si $q$ est un état d'un εNFA, on appelle \defin[epsilon-fermeture@$\varepsilon$-fermeture]{ε-fermeture} de $q$ l'ensemble des états $q'$ (y compris $q$ lui-même) accessibles depuis $q$ par une succession quelconque de ε-transitions, c'est-à-dire, si on veut, $\{q'\in Q :\penalty0 (q,\varepsilon,q') \in\delta^*\}$. On notera temporairement $C(q)$ cet ensemble. (Par exemple, dans l'exemple \ref{discussion-example5} ci-dessus, on a $C(0) = \{0,1,2\}$ et $C(1) = \{1,2\}$ et $C(2) = \{2\}$. Dans tout NFA sans ε-transitions, on a $C(q) = \{q\}$ pour tout état $q$.) \smallskip Il est clair qu'on peut calculer algorithmiquement $C(q)$ (par exemple par un algorithme de Dijkstra / parcours en largeur, sur le graphe orienté dont l'ensemble des sommets est $Q$ et l'ensemble des arêtes est l'ensemble des ε-transitions de $A$ : la ε-fermeture $C(q)$ est simplement l'ensemble des sommets accessibles depuis $q$ dans ce graphe). \begin{prop}\label{removal-of-epsilon-transitions} Soit $A = (Q,I,F,\delta)$ un εNFA sur un alphabet $\Sigma$. Alors il existe un NFA $A^\S = (Q,I^\S,F^\S,\delta^\S)$ (sur le même alphabet $\Sigma$) ayant le même ensemble d'états $Q$ que $A$ et qui soit équivalent à $A$ au sens où il reconnaît le même langage $L(A^\S) = L(A)$. De plus, $A^\S$ se déduit algorithmiquement de $A$. \end{prop} \begin{proof} On pose $I^\S = I$ (mêmes états initiaux). L'idée est maintenant de faire une transition $(q,x,q') \in \delta^\S$ à chaque fois qu'on peut atteindre $q'$ à partir de $q$ dans $A$ par une suite quelconque de ε-transitions suivie d'une unique transition étiquetée par $x$, autrement dit, $(q,\varepsilon,q^\sharp) \in \delta^*$ (c'est-à-dire $q^\sharp \in C(q)$) et $(q^\sharp,x,q') \in \delta$. On définit donc $\delta^\S \subseteq Q\times\Sigma\times Q$ par $(q,x,q') \in \delta^\S$ lorsqu'il existe $q^\sharp \in C(q)$ tel que $(q^\sharp,x,q') \in \delta$ : autrement dit, pour créer les transitions $q\to q'$ dans $A^\S$, on parcourt tous les $q^\sharp \in C(q)$, et on crée une transition $q\to q'$ étiquetée par $x \in \Sigma$ dans $A^\S$ lorsqu'il existe une transition $q^\sharp\to q'$ étiquetée par ce $x$ dans $A$. De même, on définit $F^\S \subseteq Q$ comme l'ensemble des $q\in Q$ tels que $C(q) \cap F \neq \varnothing$, c'est-à-dire, depuis lesquels peut atteindre un état final par une succession de ε-transitions. Si on a un chemin $q_0 \to q_1 \to \cdots \to q_n$ dans $A$ menant d'un état initial $q_0 \in I$ à un état final $q_n \in F$ et étiquetées par $t_1,\ldots,t_n \in (\Sigma\cup\{\varepsilon\})$ (c'est-à-dire $(q_{i-1},t_i,q_i) \in \delta$), appelons $j_1<\ldots=latex,line join=bevel,automaton] %% \node (q1) at (97bp,48bp) [draw,circle,state,final,accepting below] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (176bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (47.643bp,10.917bp) and (64.2bp,7.4655bp) .. (79bp,6bp) .. controls (94.922bp,4.4234bp) and (99.078bp,4.4234bp) .. (115bp,6bp) .. controls (125.98bp,7.0877bp) and (137.94bp,9.2693bp) .. node[auto] {$c$} (q2); \draw [->] (q2) to[loop above] node[auto] {$c$} (q2); \draw [->] (q0) to[loop above] node[auto] {$a$} (q0); \draw [->] (q1) to[loop above] node[auto] {$b$} (q1); \draw [->] (q1) ..controls (124.28bp,37.762bp) and (137.94bp,32.438bp) .. node[auto] {$c$} (q2); \draw [->] (q0) ..controls (45.279bp,28.238bp) and (58.943bp,33.562bp) .. node[auto] {$b$} (q1); % \end{tikzpicture} %%% end example5ne %%% \end{center} (Sur cet exemple précis, on obtient un automate déterministe incomplet, mais ce n'est pas un phénomène général : en général il faut s'attendre à obtenir un NFA.) {\footnotesize \thingy\textbf{Remarque :} La manière dont on a éliminé les ε-transitions ci-dessus consiste à remplacer \emph{une succession de ε-transitions suivie d'une unique transition étiquetée $x$} par une transition étiquetée $x$ (et de même, on modifie les états finaux, mais pas les états initiaux). Il existait un moyen « dual » d'éliminer les ε-transitions, à savoir remplacer \emph{une unique transition étiquetée $x$ suivie d'une succession de ε-transitions} par une transition étiquetée $x$ (et de même, on modifie les états initiaux, mais pas les états finaux). Autrement dit, la construction $A \mapsto A^\S$ décrite en \ref{removal-of-epsilon-transitions} définit $(q,x,q') \in \delta^\S$ lorsqu'il existe $q^\sharp \in C(q)$ tel que $(q^\sharp,x,q') \in \delta$, et $I^\S=I$ et $F^\S$ comme l'ensemble des états $q$ tels que $C(q) \cap F \neq \varnothing$ ; la construction « duale » $A \mapsto A^\P$ consiste à poser $(q,x,q') \in \delta^\P$ lorsqu'il existe $q^{\flat\prime}$ tel que $(q,x,q^{\flat\prime}) \in \delta$ et $q' \in C(q^{\flat\prime})$, et $F^\P=F$ et $I^\P$ comme la réunion des $C(q)$ pour tout $q\in I$. Ces deux manières d'éliminer les ε-transitions donnent des NFA équivalents. En fait, on peut définir l'une en termes de l'autre en utilisant la définition de l'automate transposé $A^{\mathsf{R}}$ présentée en \ref{nfa-mirror} plus bas (et qui consiste simplement à inverser le sens de toutes les flèches de l'automate) : si on inverse les flèches, qu'on élimine les ε-transitions à la manière décrite en \ref{removal-of-epsilon-transitions}, et qu'on inverse de nouveau les flèches, on obtient l'élimination « duale », autrement dit, $A^\P = ((A^{\mathsf{R}})^\S)^{\mathsf{R}}$. L'une ou l'autre manière d'éliminer les ε-transitions était possible, mais il vaut mieux ne pas les mélanger. C'est pour cette raison qu'on a fait un choix en \ref{removal-of-epsilon-transitions} ; la présente remarque a principalement pour objectif d'expliquer la raison d'une perte de symétrie (notamment entre états initiaux et finaux) dans ce choix. \par} \thingy L'intérêt des εNFA, même s'ils sont finalement équivalents aux NFA, est que certaines constructions sur les automates sont plus simples ou plus transparentes lorsqu'on s'autorise à fabriquer des εNFA (à titre d'exemple, l'automate présenté en \ref{discussion-example5} est beaucoup plus transparent à lire que le NFA équivalent donné en \ref{removal-of-epsilon-transitions-from-example5}). On verra notamment en \ref{subsection-thompson-construction} qu'il est facile (quoique inefficace) de construire un εNFA reconnaissant le langage dénoté par une expression rationnelle quelconque ; et en \ref{subsection-recognizable-languages-under-rational-operations} que, même si on fabrique directement un NFA, il peut être utile d'introduire temporairement des transitions spontanées dans la construction de ce NFA, quitte à les éliminer immédiatement (cela simplifie la description). \section{Langages reconnaissables et langages rationnels}\label{section-recognizable-languages} \subsection{Stabilité des langages reconnaissables par opérations booléennes et miroir} \thingy On rappelle qu'on a défini un langage \index{reconnaissable (langage)}reconnaissable comme un langage $L$ pour lequel il existe un DFA $A$ tel que $L = L(A)$. D'après \ref{completion-of-dfai}, \ref{determinization-of-nfa} et \ref{removal-of-epsilon-transitions}, on peut remplacer « DFA » dans cette définition par « DFAi », « NFA » ou « εNFA » sans changer la définition. \smallskip Nous allons maintenant montrer que les langages reconnaissables sont stables par différentes opérations. Dans cette section, nous traitons le cas des opérations booléennes (complémentaire, union, intersection) et l'opération « miroir » ; la section \ref{subsection-recognizable-languages-under-rational-operations} traite des opérations rationnelles. \begin{prop}\label{dfa-complement} Si $L$ est un langage reconnaissable sur un alphabet $\Sigma$, alors le \index{complémentaire (langage)}complémentaire $\Sigma^*\setminus L$ de $L$ est reconnaissable ; de plus, un DFA reconnaissant l'un se déduit algorithmiquement d'un DFA reconnaissant l'autre. \end{prop} \begin{proof} Par hypothèse, il existe un DFA (complet !) $A = (Q,q_0,F,\delta)$ tel que $L = L(A)$. Considérons le DFA $A'$ défini par l'ensemble d'états $Q' = Q$, l'état initial $q'_0 = q_0$, la fonction de transition $\delta' = \delta$ et pour seul changement l'ensemble d'états finaux $F' = Q \setminus F$ complémentaire de $F$. Pour $w \in \Sigma^*$, on a $w \in L(A')$ si et seulement si $\delta^{\prime*}(q_0,w) \in F'$, c'est-à-dire $\delta^*(q_0,w) \in F'$ (puisque $\delta' = \delta$), c'est-à-dire $\delta^*(q_0,w) \not\in F$ (par définition du complémentaire), c'est-à-dire $w \not\in L(A)$. Ceci montre bien que $L(A')$ est le complémentaire de $L(A)$. \end{proof} \thingy Cette démonstration a utilisé la caractérisation des langages reconnaissables par les DFA : il était crucial de le faire, et les autres sortes d'automates définis plus haut n'auraient pas permis d'arriver (simplement) à la même conclusion. Il est intéressant de réfléchir à pourquoi. (Essentiellement, dans un NFA, un mot est accepté dès qu'\emph{il existe} un chemin qui l'accepte, or l'existence d'un chemin aboutissant à un état non-final n'est pas la même chose que l'inexistence d'un chemin aboutissant à un état final.) \begin{prop}\label{dfa-union-and-intersection} Si $L_1,L_2$ sont des langages reconnaissables (sur un même alphabet $\Sigma$), alors la \index{union (de langages)}réunion $L_1\cup L_2$ et \index{intersection (de langages)}l'intersection $L_1\cap L_2$ sont reconnaissables ; de plus, un DFA reconnaissant l'un comme l'autre se déduit algorithmiquement de DFA reconnaissant $L_1$ et $L_2$. \end{prop} \begin{proof} Traitons le cas de l'intersection. Par hypothèse, il existe des DFA (complets !) $A_1 = (Q_1,q_{0,1},F_1,\delta_1)$ et $A_2 = (Q_2,q_{0,2},F_2,\delta_2)$ tels que $L_1 = L(A_1)$ et $L_2 = L(A_2)$. Considérons le DFA $A'$ défini par l'ensemble d'états $Q' = Q_1 \times Q_2$ (c'est-à-dire l'ensemble des couples formés d'un état de $A_1$ et d'un état de $A_2$), l'état initial $q'_0 = (q_{0,1},q_{0,2})$, la fonction de transition $\delta' \colon ((p_1,p_2),x) \mapsto (\delta_1(p_1,x), \delta_2(p_2,x))$ et pour ensemble d'états finaux $F' = F_1\times F_2$. Remarquons que $(p_1,p_2) \in Q'$ appartient à $F' = F_1\times F_2$ si et seulement si $p_1 \in F_1$ \emph{et} $p_2 \in F_2$ (i.e., $F' \subseteq Q'$ est l'ensemble des couples dont les deux composantes sont finales). Par ailleurs, si $w\in \Sigma^*$, on a $\delta^{\prime*}(q_0',w) = (\delta_1^*(q_{0,1},w), \delta_2^*(q_{0,2},w))$, et par ce qui vient d'être dit, ceci appartient à $F'$ si et seulement $\delta_1^*(q_{0,1},w) \in F_1$ et $\delta_2^*(q_{0,2},w) \in F_2$. On voit donc qu'un mot $w$ appartient à $L(A')$ si et seulement il appartient à la fois à $L_1$ et à $L_2$, ce qu'il fallait démontrer. Pour la réunion, on peut invoquer le fait que la réunion est le complémentaire de l'intersection des complémentaires, et utiliser \ref{dfa-complement} ; si on déroule cette démonstration, on voit qu'on construit un DFA $A''$ exactement égal à $A'$ construit ci-dessus, à la seule différence près que son ensemble d'états finaux est $F'' = (F_1\times Q_2) \cup (Q_1\times F_2)$, qui est le sous-ensemble de $Q'' = Q_1\times Q_2$ formé des couples dont \emph{l'une au moins} des deux composantes est finale. \end{proof} \thingy La construction $A'$ ci-dessus est parfois appelée automate \index{produit (d'automates)}\emph{produit} des DFA $A_1$ et $A_2$. Intuitivement, il faut comprendre que faire fonctionner l'automate $A'$ revient à faire fonctionner les automates $A_1$ et $A_2$ simultanément (en parallèle), en leur donnant à consommer les mêmes symboles. La construction de l'automate produit pour fabriquer le langage union ou intersection utilise la caractérisation des langages reconnaissables par les DFA ; une construction du même type pourrait être définie pour les NFA, mais uniquement pour le langage intersection. (Pour la réunion effectuée sur les NFA, on renvoie à la construction présentée en \ref{nfa-union}.) \begin{prop}\label{nfa-mirror} Si $L$ est un langage reconnaissable sur un alphabet $\Sigma$, alors le langage miroir (cf. \ref{definition-mirror-language}) $L^{\mathsf{R}}$ de $L$ est reconnaissable ; de plus, un NFA ou εNFA reconnaissant l'un se déduit algorithmiquement d'un NFA ou εNFA reconnaissant l'autre : il s'agit simplement d'inverser le sens de toutes les flèches (y compris celles qui marquent les états initiaux et finaux). \end{prop} L'automate ainsi construit en inversant toutes les flèches d'un automate $A$ (la définition précise est donnée dans la démonstration qui suit) et qui reconnaît le langage miroir de celui reconnu par $A$ peut s'appeler automate \defin[transposé (automate)]{transposé} $A^{\mathsf{R}}$ de $A$. \begin{proof} Par hypothèse, il existe un NFA ou un εNFA $A = (Q,I,F,\delta)$ tel que $L = L(A)$. Considérons l'automate $A^{\mathsf{R}}$ de même type défini par l'ensemble d'états $Q^{\mathsf{R}} = Q$ et inversant toutes les flèches de $A$, c'est-à-dire $I^{\mathsf{R}} = F$ et $F^{\mathsf{R}} = I$ et $(q,t,q') \in \delta^{\mathsf{R}}$ si et seulement si $(q',t,q) \in \delta$. Un chemin existe dans $A^{\mathsf{R}}$ si et seulement si le même chemin inversé existe dans $A$, ce qui montre qu'un mot appartient à $L(A^{\mathsf{R}})$ si et seulement si son miroir appartient à $L(A)$. On a donc bien $L(A^{\mathsf{R}})=L^{\mathsf{R}}$, langage miroir de $L$. \end{proof} \thingy Alors que les constructions du complémentaire et de l'intersection s'effectuaient naturellement sur les DFA, celle du langage miroir s'effectue naturellement sur les NFA. (On peut, bien sûr, considérer un DFA comme un NFA particulier, et effectuer dessus l'opération d'inversion des flèches qu'on vient de décrire, mais en général on n'obtiendra pas un DFA, seulement un NFA ; les NFA dont l'automate transposé est déterministe — c'est-à-dire tels que, pour chaque état $q$ et chaque lettre $x$, il existe une unique arête aboutissant à $q$ et étiquetée par $x$ — sont parfois dits « co-déterministes ».) \subsection{Stabilité des langages reconnaissables par opérations rationnelles, automates standards, construction de Glushkov}\label{subsection-recognizable-languages-under-rational-operations} \thingy Nous allons maintenant montrer que la classe des langages reconnaissables est stable par les opérations rationnelles (union, concaténation et étoile de Kleene, cf. \ref{stable-under-rational-operations} ; on l'a déjà vu sur les DFA en \ref{dfa-union-and-intersection} pour la réunion, mais on va en donner une nouvelle démonstration, cette fois basée sur les NFA, qui a un contenu algorithmique utile dans des circonstances différentes). Cela permettra de conclure en \ref{rational-languages-are-recognizable} que les langages rationnels sont reconnaissables (la réciproque faisant l'objet de la section \ref{subsection-rnfa-and-kleenes-algorithm}). \smallskip Pour établir ces stabilités, on va travailler sur les NFA et utiliser la construction parfois appelée « de Glushkov » ou « automate standard » ; ceci fournira un « automate de Glushkov » pour chaque expression rationnelle $r$. Cette construction travaille, en fait, sur des NFA vérifiant une propriété supplémentaire facile à assurer, et on va commencer par un lemme dans ce sens : \begin{lem}\label{standard-automaton-lemma} Soit $A$ un NFA. Alors il existe un NFA $A'$ (sur le même alphabet $\Sigma$) qui soit équivalent à $A$ et qui possède la propriété supplémentaire d'avoir un \emph{unique} état initial $q_0$ et qu'aucune transition n'aboutit à $q_0$. De plus, $A'$ se déduit algorithmiquement de $A$ et a au plus un état de plus que $A$. (On pourra appeler \defin[standard (automate)]{standard} un NFA vérifiant cette propriété d'avoir un unique état initial qui n'est la cible d'aucune transition. L'affirmation est donc que tout NFA est équivalent à un NFA \emph{standard} qui s'en déduit algorithmiquement par l'ajout d'au plus un état.) \end{lem} \begin{proof} On fabrique $A'$ en reprenant le même ensemble d'états $Q$ que dans $A$ auquel on ajoute un unique nouvel état $q_0$ qui sera le seul état initial de $A'$ ; pour chaque transition partant d'un état initial de $A$, on ajoute dans $A'$ une transition identiquement étiquetée, et de même cible, partant de $q_0$. Formellement : soit $A = (Q,I,F,\delta)$. On définit alors $A' = (Q',\{q_0\},F',\delta')$ de la manière suivante : $Q' = Q \uplus \{q_0\}$ (où $\uplus$ désigne une réunion disjointe\footnote{C'est-à-dire qu'on exige que $q_0$ n'appartienne pas à $Q$ (c'est un nouvel état).}), $\delta'$ est la réunion de l'ensemble des transitions $(q,x,q')$ qui étaient déjà dans $\delta$ et de l'ensemble des $(q_0,x,q')$ telles qu'il existe une transition $(q,x,q') \in \delta$ avec $q\in I$, et enfin $F' = F$ ou $F' = F\cup\{q_0\}$ selon que $I\cap F = \varnothing$ ou $I\cap F \neq \varnothing$ respectivement (i.e., $q_0$ est final lorsqu'il existait déjà un état à la fois initial et final). La figure suivante illustre la transformation en question : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=75bp] {$A$}; \node (q) at (-15bp,15bp) [draw,circle,state,initial] {\footnotesize $q$}; \node (qp) at (15bp,15bp) [draw,circle,state] {\footnotesize\vbox to0pt{\vss\hbox to0pt{$q'$\hss}}\phantom{$q$}}; \draw [->] (A.east) -- ($(A.east)+(3ex,0)$); \draw [->] (q) -- node[auto] {\footnotesize $x$} (qp); \end{tikzpicture} \quad devient\quad \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=75bp] {\phantom{$A$}}; \node (q) at (-15bp,15bp) [draw,circle,state] {\footnotesize $q$}; \node (qp) at (15bp,15bp) [draw,circle,state] {\footnotesize\vbox to0pt{\vss\hbox to0pt{$q'$\hss}}\phantom{$q$}}; \node (q0) at (-40bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \draw [->] (A.east) -- ($(A.east)+(3ex,0)$); \draw [->] (q) -- node[auto] {\footnotesize $x$} (qp); \draw [->] (q0) to[out=0,in=270] node[auto,swap] {\footnotesize $x$} (qp.south); \end{tikzpicture} \end{center} (\emph{Remarque : } De façon équivalente, on peut fabriquer $A'$ en ajoutant d'abord un unique état initial $q_0$ et des ε-transitions de $q_0$ vers chacun des états qui étaient initiaux dans $A$, puis en éliminant les ε-transitions qu'on vient d'ajouter (cf. \ref{removal-of-epsilon-transitions}). Cela donne le même résultat que ce qui vient d'être dit.) \end{proof} \bigbreak On a vu en \ref{dfa-union-and-intersection} une preuve, à base de DFA, que $L_1 \cup L_2$ est reconnaissable lorsque $L_1$ et $L_2$ le sont. Donnons maintenant une autre preuve de ce fait, à base de NFA : \begin{prop}\label{nfa-union} Si $L_1,L_2$ sont des langages reconnaissables (sur un même alphabet $\Sigma$), alors la \index{union (de langages)}réunion $L_1 \cup L_2$ est reconnaissable ; de plus, un NFA la reconnaissant se déduit algorithmiquement de NFA reconnaissant $L_1$ et $L_2$. \end{prop} \begin{proof} Par hypothèse, il existe des NFA reconnaissant $L_1$ et $L_2$ : d'après \ref{standard-automaton-lemma}, on peut supposer qu'ils sont \emph{standards} en ce sens qu'ils ont un unique état initial qui n'est la cible d'aucune transition. Disons que $A_1 = (Q_1,\{q_1\},F_1,\delta_1)$ et $A_2 = (Q_2,\{q_2\},F_2,\delta_2)$ sont des NFA standards tels que $L_1 = L(A_1)$ et $L_2 = L(A_2)$. L'automate $A'$ s'obtient réunissant $A_1$ et $A_2$ mais en « fusionnant » les états initiaux $q_1$ et $q_2$ de $A_1$ et $A_2$ en un unique état initial $q'_0$, d'où partent les mêmes transitions (avec les mêmes étiquettes) que depuis l'un ou l'autre de $q_1$ ou $q_2$. Graphiquement : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {$A_1$}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_1$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} et \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {$A_2$}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_2$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} \\deviennent\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A1) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {\phantom{$A_1$}}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q'_0$}; \node (A1) at (90bp,0bp) [draw,dotted,circle,minimum size=60bp] {\phantom{$A_2$}}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (l1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (l2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (l3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (r1) at (80bp,20bp) [circle,inner sep=2bp,fill] {}; \node (r2) at (80bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (105bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (115bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (105bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (l1) -- ($(l1.east)+(3ex,0)$); \draw [->] (l2) -- ($(l2.east)+(3ex,0)$); \draw [->] (l3) -- ($(l3.east)+(3ex,0)$); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \draw [->] (q0) to[out=10,in=180] (r1); \draw [->] (q0) to[out=350,in=180] (r2); \end{tikzpicture} \end{center} De façon plus formelle, considérons un nouvel ensemble d'états $Q' = (Q_1 \uplus Q_2) \setminus \{q_1,q_2\} \uplus \{q'_0\}$ où $\uplus$ désigne la réunion disjointe (autrement dit, on prend la réunion disjointe des états non-initiaux de $A_1$ et $A_2$ et on ajoute un nouvel état $q'_0$), et la fonction $\varphi_1\colon Q_1 \to Q'$ qui envoie $q_1$ sur $q'_0$ et tout autre état de $Q_1$ sur lui-même, et $\varphi_2\colon Q_2 \to Q'$ de façon analogue. On définit alors l'automate $A'$ dont l'ensemble d'états est $Q'$, l'état initial est $q'_0$, les états finaux $F' = \varphi_1(F_1) \cup \varphi_2(F_2)$, et la relation de transition $\delta'$ est formée des triplets $(\varphi_1(q),x,q')$ où $(q,x,q') \in \delta_1$ et des $(\varphi_2(q),x,q')$ où $(q,x,q') \in \delta_2$. (\emph{Remarque : } De façon équivalente, on peut fabriquer $A'$ en ajoutant d'abord un unique état initial $q'_0$ à la réunion disjointe de $A_1$ et $A_2$ et des ε-transitions de $q'_0$ vers $q_1$ et $q_2$, puis en éliminant les ε-transitions qu'on vient d'ajouter (cf. \ref{removal-of-epsilon-transitions}) ainsi que les états $q_1$ et $q_2$ devenus inutiles. Cela donne le même résultat que ce qui vient d'être dit.) Il est alors clair qu'un chemin de l'état initial à un état final dans cet automate $A'$ consiste soit en un chemin d'un état initial à un état final dans $A_1$ soit en un tel chemin dans $A_2$. On a donc bien $L(A') = L_1 \cup L_2$. \end{proof} \begin{prop}\label{nfa-concatenation} Si $L_1,L_2$ sont des langages reconnaissables (sur un même alphabet $\Sigma$), alors la \index{concaténation (de langages)}concaténation $L_1 L_2$ est reconnaissable ; de plus, un NFA la reconnaissant se déduit algorithmiquement de NFA reconnaissant $L_1$ et $L_2$. \end{prop} \begin{proof} Par hypothèse, il existe des NFA reconnaissant $L_1$ et $L_2$ : d'après \ref{standard-automaton-lemma}, on peut supposer qu'ils sont \emph{standards} en ce sens qu'ils ont un unique état initial qui n'est la cible d'aucune transition. Disons que $A_1 = (Q_1,\{q_1\},F_1,\delta_1)$ et $A_2 = (Q_2,\{q_2\},F_2,\delta_2)$ sont des NFA standards tels que $L_1 = L(A_1)$ et $L_2 = L(A_2)$. L'automate $A'$ s'obtient en réunissant $A_1$ et $A_2$, en ne gardant que les états finaux de $A_2$, en supprimant $q_2$ et en remplaçant chaque transition sortant de $q_2$ par une transition identiquement étiquetée, et de même cible, partant de \emph{chaque} état final de $A_1$. Graphiquement : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {$A_1$}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_1$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} et \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {$A_2$}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_2$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} \\deviennent\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A1) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {\phantom{$A_1$}}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_1$}; \node (A1) at (90bp,0bp) [draw,dotted,circle,minimum size=60bp] {\phantom{$A_2$}}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (l1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (l2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (l3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (r1) at (80bp,20bp) [circle,inner sep=2bp,fill] {}; \node (r2) at (80bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (105bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (115bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (105bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (l1) to[out=0,in=180] (r1); \draw [->] (l1) to[out=0,in=180] (r2); \draw [->] (l2) to[out=0,in=180] (r1); \draw [->] (l2) to[out=0,in=180] (r2); \draw [->] (l3) to[out=0,in=180] (r1); \draw [->] (l3) to[out=0,in=180] (r2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} \end{center} De façon plus formelle, considérons un nouvel ensemble d'états $Q' = (Q_1 \uplus Q_2) \setminus \{q_2\}$ où $\uplus$ désigne la réunion disjointe. On définit alors l'automate $A'$ dont l'ensemble d'états est $Q'$, l'état initial est $q_1$, les états finaux $F' = F_2$, et la relation de transition $\delta$ est la réunion de $\delta_1$, de l'ensemble des triplets $(q,x,q') \in \delta_2$ tels que $q\neq q_2$, et enfin de l'ensemble des triplets $(q,x,q')$ tels que $(q_2,x,q') \in \delta_2$ et que $q\in F_1$. (\emph{Remarque : } De façon équivalente, on peut fabriquer $A'$ en ajoutant d'abord à la réunion disjointe de $A_1$ et $A_2$ une ε-transition de chaque état final de $A_1$ vers $q_2$, puis en éliminant les ε-transitions qu'on vient d'ajouter (cf. \ref{removal-of-epsilon-transitions}) ainsi que l'état $q_2$ devenu inutile. Cela donne le même résultat que ce qui vient d'être dit.) Il est alors clair qu'un chemin de l'état initial $q_1$ à un état final dans cet automate $A'$ consiste en un chemin de $q_1$ à un état final dans $A_1$ suivi d'un chemin de $q_2$ à un état final dans $A_2$ (moins $q_2$ lui-même). On a donc bien $L(A') = L_1 L_2$. \end{proof} \begin{prop}\label{nfa-star} Si $L$ est un langage reconnaissable (sur un alphabet $\Sigma$), alors \index{étoile de Kleene}l'étoile de Kleene $L^*$ est reconnaissable ; de plus, un NFA la reconnaissant se déduit algorithmiquement de NFA reconnaissant $L$. \end{prop} \begin{proof} Par hypothèse, il existe un NFA reconnaissant $L$ : d'après \ref{standard-automaton-lemma}, on peut supposer qu'ils est \emph{standard} en ce sens qu'il a un unique état initial qui n'est la cible d'aucune transition. Disons que $A = (Q,\{q_0\},F,\delta)$ est un NFA standard tel que $L = L(A)$. L'automate $A'$ s'obtient en ajoutant à $A$, pour chaque transition sortant de $q_0$, une transition identiquement étiquetée, et de même cible, partant de chaque état final de $A$, et en rendant $q_0$ final s'il ne l'était pas déjà : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {$A$}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \end{tikzpicture} devient \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (0bp,0bp) [draw,dotted,circle,minimum size=60bp] {\phantom{$A$}}; \node (q0) at (-35bp,0bp) [draw,circle,state,initial,accepting below,fill=white] {$q_0$}; \node (i1) at (-10bp,20bp) [circle,inner sep=2bp,fill] {}; \node (i2) at (-10bp,-20bp) [circle,inner sep=2bp,fill] {}; \node (o1) at (15bp,20bp) [circle,inner sep=2bp,fill] {}; \node (o2) at (25bp,0bp) [circle,inner sep=2bp,fill] {}; \node (o3) at (15bp,-20bp) [circle,inner sep=2bp,fill] {}; \draw [->] (q0) -- (i1); \draw [->] (q0) -- (i2); \draw [->] (o1) -- ($(o1.east)+(3ex,0)$); \draw [->] (o2) -- ($(o2.east)+(3ex,0)$); \draw [->] (o3) -- ($(o3.east)+(3ex,0)$); \draw [->] (o1) -- (i1); \draw [->] (o1) -- (i2); \draw [->] (o2) -- (i1); \draw [->] (o2) -- (i2); \draw [->] (o3) -- (i1); \draw [->] (o3) -- (i2); \end{tikzpicture} \end{center} De façon plus formelle, on considère l'automate $A'$ dont l'ensemble d'états est $Q' := Q$, l'état initial est $q_0$, les états finaux $F' := F \cup \{q_0\}$, et la relation de transition $\delta'$ est la réunion de $\delta$ et de l'ensemble des triplets $(q,x,q')$ tels que $(q_0,x,q') \in \delta$ et que $q \in F$. (\emph{Remarque : } De façon équivalente, on peut fabriquer $A'$ en ajoutant d'abord à $A$ une ε-transition de chaque état final de $A$ vers $q_0$, puis en éliminant les ε-transitions qu'on vient d'ajouter (cf. \ref{removal-of-epsilon-transitions}), et enfin en marquant $q_0$ comme final. Cela donne le même résultat que ce qui vient d'être dit.) Il est alors clair qu'un chemin de l'état initial $q_0$ à un état final dans cet automate $A'$ consiste en un nombre quelconque (éventuellement nul) de chemins de l'état initial à un état final dans $A$. On a donc bien $L(A') = L^*$. \end{proof} \thingy\label{trivial-standard-automata} Il sera utile de fixer également des NFA (« standards » au sens de \ref{standard-automaton-lemma}) reconnaissant les langages de base triviaux $\varnothing$, $\{\varepsilon\}$ et $\{x\}$ (pour chaque $x\in\Sigma$), c'est-à-dire ceux dénotés par les expressions rationnelles $\bot$, $\underline{\varepsilon}$ et $x$ respectivement. On prendra les suivants : \begin{center} \begin{tabular}{ll} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q0.base)] \node (q0) at (0bp,0bp) [draw,circle,state,initial] {$q_0$}; \end{tikzpicture} &pour le langage $\varnothing$ (i.e., pour l'expression rationnelle $\bot$),\\[1.75ex] \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q0.base)] \node (q0) at (0bp,0bp) [draw,circle,state,initial,final] {$q_0$}; \end{tikzpicture} &pour le langage $\{\varepsilon\}$ (i.e., pour l'expression rationnelle $\underline{\varepsilon}$), et\\[1.75ex] \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q0.base)] \node (q0) at (0bp,0bp) [draw,circle,state,initial] {$q_0$}; \node (q1) at (60bp,0bp) [draw,circle,state,final] {$q_1$}; \draw [->] (q0) to node[auto,swap] {$x$} (q1); \end{tikzpicture} &pour le langage $\{x\}$ (i.e., pour l'expression rationnelle $x$). \end{tabular} \end{center} \bigbreak Récapitulons le contenu essentiel de ce que nous avons montré : \begin{cor}\label{rational-languages-are-recognizable} Tout langage rationnel est reconnaissable ; de plus, un NFA le reconnaissant se déduit algorithmiquement d'une expression rationnelle le dénotant. En particulier, il existe un algorithme qui, donnée une expression rationnelle $r$ (sur un alphabet $\Sigma$) et un mot $w \in \Sigma^*$, décide si $w\in L(r)$, c'est-à-dire si $w$ vérifie $r$. (Autrement dit, les langages rationnels sont \emph{décidables} au sens de \ref{definition-computable-function-or-set}.) \end{cor} \begin{proof} L'affirmation du premier paragraphe résulte de façon évidente de la définition des langages rationnels (cf. §\ref{subsection-rational-languages}), du fait que les langages $\varnothing$, $\{\varepsilon\}$ et $\{x\}$ (pour chaque $x\in\Sigma$) sont reconnaissables par automates finis (cf. \ref{trivial-standard-automata}), et grâce aux propositions \ref{nfa-union}, \ref{nfa-concatenation} et \ref{nfa-star}. On renvoie à \ref{glushkov-construction} ci-dessous (ou à §\ref{subsection-thompson-construction}) pour une description algorithmique plus précise. Pour décider si un mot $w$ vérifie une expression rationnelle $r$, on commence par transformer cette expression rationnelle en NFA comme on vient de l'expliquer (c'est-à-dire construire un NFA $A(r)$ reconnaissant le langage $L(r)$ dénoté par $r$), puis on déterminise cet automate (cf. \ref{determinization-of-nfa}), après quoi il est facile de tester si le DFA résultant de la déterminisation accepte le mot $w$ considéré (il suffit de suivre l'unique chemin dans l'automate partant de l'état initial et étiqueté par $w$, et de voir si l'état auquel il aboutit est final). \end{proof} \thingy\label{glushkov-construction} Les constructions que nous avons décrites dans cette section associent naturellement un NFA standard à chaque expression rationnelle : il s'obtient en partant des automates de base décrits en \ref{trivial-standard-automata} et en appliquant les constructions décrites dans les démonstrations de \ref{nfa-union}, \ref{nfa-concatenation} et \ref{nfa-star}. \medskip Plus exactement, on associe à chaque expression rationnelle $r$ (sur un alphabet $\Sigma$ fixé) un automate $A(r)$ (ou $A_{\textrm{Glushkov}}(r)$) standard, appelé \defin[Glushkov (construction d'automate de)]{automate de Glushkov}, qui reconnaît le langage $L(r)$ dénoté par $r$, de la manière suivante (par induction sur la complexité de l'expression rationnelle telle que définie en \ref{regular-expressions}) : \begin{itemize} \item les automates de Glushkov de $\bot$, $\underline{\varnothing}$ et $x$ (pour $x\in\Sigma$) sont définis comme ceux décrits et illustrés en \ref{trivial-standard-automata}, \item connaissant les automates de Glushkov $A_1$ et $A_2$ de $r_1$ et $r_2$ respectivement, celui de $(r_1|r_2)$ est celui décrit et illustré dans la démonstration de \ref{nfa-union}, \item connaissant les automates de Glushkov $A_1$ et $A_2$ de $r_1$ et $r_2$ respectivement, celui de $r_1 r_2$ est celui décrit et illustré dans la démonstration de \ref{nfa-concatenation}, \item connaissant l'automate de Glushkov $A$ de $r$, celui de $(r){*}$ est celui décrit et illustré dans la démonstration de \ref{nfa-star}. \end{itemize} \smallskip Cet automate de Glushkov $A_{\textrm{Glushkov}}(r)$ possède les propriétés suivantes : \begin{itemize} \item c'est un NFA reconnaissant le langage $L(r)$ dénoté par l'expression rationnelle $r$ dont on est parti, \item il est standard au sens de \ref{standard-automaton-lemma}, c'est-à-dire qu'il possède un unique état initial auquel n'aboutit aucune transition, \item les transitions aboutissant à n'importe quel état donné sont toutes étiquetées par la même lettre, \item son nombre d'états est égal à $1$ plus le nombre de lettres (à l'exclusion des métacaractères) contenues dans l'expression $r$. \end{itemize} Les deux dernières propriétés se vérifient inductivement, c'est-à-dire qu'on observe qu'elles sont satisfaites sur les automates de base décrits en \ref{trivial-standard-automata} qu'elles sont préservées par les constructions de \ref{nfa-union}, \ref{nfa-concatenation} et \ref{nfa-star}. En fait, on peut être un peu plus précis : chaque état, autre que l'état initial, de l'automate de Glushkov associé à l'expression rationnelle $r$ correspond à une lettre $x$ (à l'exclusion des métacaractères) de $r$, l'état en question provient de l'état $q_1$ de l'automate décrit en \ref{trivial-standard-automata} pour le langage $\{x\}$, et toutes les transitions menant à cet état sont étiquetées par $x$. Ces observations sont utiles pour détecter des erreurs lors de la construction de l'automate. \thingy À titre d'exemple pour illustrer la construction de Glushkov, construisons l'automate qu'elle associe à l'expression rationnelle $((a{*}|b)c){*}$ sur l'alphabet $\Sigma = \{a,b,c\}$. On doit obtenir un automate ayant $4$ états. L'automate de Glushkov de $a{*}$ est le suivant, obtenu en appliquant la construction de \ref{nfa-star} à l'automate trivial pour le langage $\{a\}$ (donné en \ref{trivial-standard-automata}) : \begin{center} %%% begin example8a %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,18bp) [draw,circle,state,final] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial,final,accepting below] {$0$}; \draw [->] (q0) ..controls (45.659bp,18bp) and (57.817bp,18bp) .. node[auto] {$a$} (q1); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); % \end{tikzpicture} %%% end example8a %%% \end{center} On en déduit au moyen de \ref{nfa-union} l'automate suivant pour $a{*}|b$ : \begin{center} %%% begin example8b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,72bp) [draw,circle,state,final] {$1$}; \node (q0) at (18bp,41bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (97bp,18bp) [draw,circle,state,final] {$2$}; \draw [->] (q0) ..controls (45.279bp,51.58bp) and (58.943bp,57.081bp) .. node[auto] {$a$} (q1); \draw [->] (q0) ..controls (40.761bp,31.564bp) and (47.615bp,28.946bp) .. (54bp,27bp) .. controls (58.828bp,25.529bp) and (64.04bp,24.206bp) .. node[auto] {$b$} (q2); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); % \end{tikzpicture} %%% end example8b %%% \end{center} On en déduit au moyen de \ref{nfa-concatenation} l'automate suivant pour $(a{*}|b)c$ : \begin{center} %%% begin example8c %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,99.608bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,45.608bp) [draw,circle,state,initial] {$0$}; \node (q3) at (176bp,45.608bp) [draw,circle,state,final] {$3$}; \node (q2) at (97bp,45.608bp) [draw,circle,state] {$2$}; \draw [->] (q0) ..controls (42.871bp,23.135bp) and (60.567bp,9.4181bp) .. (79bp,3.6077bp) .. controls (94.26bp,-1.2026bp) and (99.74bp,-1.2026bp) .. (115bp,3.6077bp) .. controls (129.69bp,8.2379bp) and (143.91bp,17.889bp) .. node[auto] {$c$} (q3); \draw [->] (q2) ..controls (124.66bp,45.608bp) and (136.82bp,45.608bp) .. node[auto] {$c$} (q3); \draw [->] (q0) ..controls (45.659bp,45.608bp) and (57.817bp,45.608bp) .. node[auto] {$b$} (q2); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); \draw [->] (q0) ..controls (44.341bp,63.379bp) and (60.249bp,74.535bp) .. node[auto] {$a$} (q1); \draw [->] (q1) ..controls (123.34bp,81.836bp) and (139.25bp,70.68bp) .. node[auto] {$c$} (q3); % \end{tikzpicture} %%% end example8c %%% \end{center} Et enfin, de nouveau par \ref{nfa-star} l'automate suivant pour $((a{*}|b)c)*$ : \begin{center} %%% begin example8d %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \node (q1) at (97bp,101.45bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,45.453bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q3) at (176bp,63.453bp) [draw,circle,state,final] {$3$}; \node (q2) at (97bp,45.453bp) [draw,circle,state] {$2$}; \draw [->] (q0) ..controls (49.576bp,16.777bp) and (84.747bp,-9.0778bp) .. (115bp,3.4533bp) .. controls (133.15bp,10.97bp) and (148.67bp,26.932bp) .. node[auto,below,near start] {$c$} (q3); \draw [->] (q2) ..controls (124.6bp,51.671bp) and (137.34bp,54.651bp) .. node[auto] {$c$} (q3); \draw [->] (q0) ..controls (45.659bp,45.453bp) and (57.817bp,45.453bp) .. node[auto] {$b$} (q2); \draw [->] (q3) ..controls (148.91bp,76.331bp) and (134.76bp,83.311bp) .. node[auto] {$a$} (q1); \draw [->] (q1) to[loop above] node[auto] {$a$} (q1); \draw [->] (q3) ..controls (156.78bp,44.679bp) and (148.66bp,38.493bp) .. (140bp,35.453bp) .. controls (134.61bp,33.562bp) and (128.7bp,33.684bp) .. node[auto] {$b$} (q2); \draw [->] (q3) to[loop above] node[auto] {$c$} (q3); \draw [->] (q0) ..controls (44.52bp,64.013bp) and (60.758bp,75.823bp) .. node[auto] {$a$} (q1); \draw [->] (q1) ..controls (120.07bp,117.96bp) and (130.95bp,122.37bp) .. (140bp,117.45bp) .. controls (151.16bp,111.39bp) and (159.31bp,100.06bp) .. node[auto,above] {$c$} (q3); % \end{tikzpicture} %%% end example8d %%% \end{center} Toutes les transitions aboutissant à l'état $1$ sont étiquetées $a$, toutes celles aboutissant à l'état $2$ sont étiquetées $b$, et toutes celles aboutissant à $3$ sont étiquetées $c$. \subsection{L'automate de Thompson (alternative à l'automate de Glushkov)}\label{subsection-thompson-construction} \thingy La construction de Glushkov (exposée en \ref{glushkov-construction}) d'un automate reconnaissant le langage dénoté par expression rationnelle $r$ fabrique un NFA. Cette construction produit un automate raisonnablement compact (en nombre d'états), mais il peut être intéressant de disposer d'une autre construction, plus transparente mais moins efficace : la \defin[Thompson (construction d'automate de)]{construction de Thompson} fournit un autre moyen d'associer à une expression rationnelle $r$ un automate $A_{\textrm{Thompson}}(r)$ reconnaissant le langage qu'elle dénote. Elle possède pour sa part les propriétés suivantes : \begin{itemize} \item c'est un εNFA reconnaissant le langage $L(r)$ dénoté par l'expression rationnelle $r$ dont on est parti, \item il possède un unique état initial auquel n'aboutit aucune transition, et un unique état final duquel ne part aucune transition, \item son nombre d'états est égal au double du nombre de symboles autres que les parenthèses constituant l'expression $r$ (en comptant aussi bien les lettres de $\Sigma$ que les métacaractères $\bot$, $\underline{\varepsilon}$, $|$ et $*$ ; mais sans compter la concaténation implicite). \end{itemize} \smallskip Dans les dessins qui suivent, on symbolisera de la manière suivante un automate de Thompson $A$ quelconque : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} \end{center} \thingy\label{trivial-thompson-automata} Les automates de Thompson des expressions rationnelles $\bot$, $\underline{\varepsilon}$ et $x$ (pour $x\in\Sigma$) seront les suivants : \begin{center} \begin{tabular}{ll} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(qi.base)] \node (qi) at (0bp,0bp) [draw,circle,state,initial] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} &pour le langage $\varnothing$ (i.e., pour l'expression rationnelle $\bot$),\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(qi.base)] \node (qi) at (0bp,0bp) [draw,circle,state,initial] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \draw [->] (qi) to node[auto] {$\varepsilon$} (qf); \end{tikzpicture} &pour le langage $\{\varepsilon\}$ (i.e., pour l'expression rationnelle $\underline{\varepsilon}$), et\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(qi.base)] \node (qi) at (0bp,0bp) [draw,circle,state,initial] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \draw [->] (qi) to node[auto,swap] {$x$} (qf); \end{tikzpicture} &pour le langage $\{x\}$ (i.e., pour l'expression rationnelle $x$). \end{tabular} \end{center} \thingy\label{thompson-union} Si $A_1$ et $A_2$ sont les automates de Thompson pour les expressions rationnelles $r_1$ et $r_2$, celui de $(r_1|r_2)$ sera construit de la manière suivante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_1$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} et \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_2$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} \\deviennent\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(qi.base)] \node (qi) at (-35bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (95bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \node (A1) at (30bp,35bp) [draw,dotted,circle,minimum size=50bp] {$A_1$}; \node (qi1) at (0bp,35bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (qf1) at (60bp,35bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (A2) at (30bp,-35bp) [draw,dotted,circle,minimum size=50bp] {$A_2$}; \node (qi2) at (0bp,-35bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (qf2) at (60bp,-35bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \draw[->] (qi) to node[auto] {$\varepsilon$} (qi1); \draw[->] (qi) to node[auto] {$\varepsilon$} (qi2); \draw[->] (qf1) to node[auto] {$\varepsilon$} (qf); \draw[->] (qf2) to node[auto] {$\varepsilon$} (qf); \end{tikzpicture} \end{center} \thingy\label{thompson-concatenation} Si $A_1$ et $A_2$ sont les automates de Thompson pour les expressions rationnelles $r_1$ et $r_2$, celui de $r_1 r_2$ sera construit de la manière suivante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_1$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} et \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_2$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} \\deviennent\\ \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(qi.base)] \node (A1) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_1$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (ql) at (60bp,0bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (A2) at (150bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A_2$}; \node (qr) at (120bp,0bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (qf) at (180bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \draw[->] (ql) to node[auto] {$\varepsilon$} (qr); \end{tikzpicture} \end{center} \thingy\label{thompson-star} Si $A$ est l'automate de Thompson pour l'expression rationnelle $r$, celui de $(r){*}$ sera construit de la manière suivante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (A) at (30bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A$}; \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (60bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \end{tikzpicture} devient \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(A.base)] \node (qi) at (0bp,0bp) [draw,circle,state,initial,fill=white] {$q_0$}; \node (qf) at (180bp,0bp) [draw,circle,state,final,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_\infty$\hss}}\phantom{$q_0$}}; \node (A) at (90bp,0bp) [draw,dotted,circle,minimum size=50bp] {$A$}; \node (qai) at (60bp,0bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \node (qaf) at (120bp,0bp) [draw,circle,state,fill=white] {\phantom{$q_0$}}; \draw[->] (qi) to node[auto] {$\varepsilon$} (qai); \draw[->] (qaf) to node[auto] {$\varepsilon$} (qf); \draw[->] (qi) ..controls (60bp,-60bp) and (120bp,-60bp) .. node[auto] {$\varepsilon$} (qf); \draw[->] (qaf) ..controls (120bp,60bp) and (60bp,60bp) .. node[auto,above] {$\varepsilon$} (qai); \end{tikzpicture} \end{center} \thingy Comme on le voit ci-dessus, la construction de Thompson est très simple à appliquer ; mais elle conduit à des automates rapidement énormes, comportant un nombre considérable d'états et de transitions spontanées « stupides ». \medskip À titre d'exemple, voici l'automate de Thompson, déjà gros, de l'expression rationnelle $(a|b){*}b$ : \begin{center} \scalebox{0.70}{% %%% begin example9 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,61bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,23bp) [draw,circle,state,initial] {$0$}; \node (q3) at (255bp,138bp) [draw,circle,state] {$3$}; \node (q2) at (176bp,138bp) [draw,circle,state] {$2$}; \node (q5) at (255bp,84bp) [draw,circle,state] {$5$}; \node (q4) at (176bp,84bp) [draw,circle,state] {$4$}; \node (q7) at (413bp,23bp) [draw,circle,state] {$7$}; \node (q6) at (334bp,61bp) [draw,circle,state] {$6$}; \node (q9) at (571bp,23bp) [draw,circle,state,final] {$9$}; \node (q8) at (492bp,23bp) [draw,circle,state] {$8$}; \draw [->] (q3) ..controls (280.5bp,113.5bp) and (299.16bp,94.836bp) .. node[auto] {$\varepsilon$} (q6); \draw [->] (q2) ..controls (203.66bp,138bp) and (215.82bp,138bp) .. node[auto] {$a$} (q3); \draw [->] (q6) ..controls (303.95bp,58.621bp) and (287.5bp,57.483bp) .. (273bp,57bp) .. controls (221.92bp,55.299bp) and (209.08bp,55.299bp) .. (158bp,57bp) .. controls (147.24bp,57.358bp) and (135.4bp,58.078bp) .. node[auto] {$\varepsilon$} (q1); \draw [->] (q8) ..controls (519.66bp,23bp) and (531.82bp,23bp) .. node[auto] {$b$} (q9); \draw [->] (q7) ..controls (440.66bp,23bp) and (452.82bp,23bp) .. node[auto] {$\varepsilon$} (q8); \draw [->] (q5) ..controls (282.27bp,76.154bp) and (295.19bp,72.293bp) .. node[auto] {$\varepsilon$} (q6); \draw [->] (q6) ..controls (361.12bp,48.108bp) and (375.27bp,41.127bp) .. node[auto] {$\varepsilon$} (q7); \draw [->] (q4) ..controls (203.66bp,84bp) and (215.82bp,84bp) .. node[auto] {$b$} (q5); \draw [->] (q1) ..controls (124.27bp,68.846bp) and (137.19bp,72.707bp) .. node[auto] {$\varepsilon$} (q4); \draw [->] (q0) ..controls (49.792bp,8.7612bp) and (73.956bp,0bp) .. (96bp,0bp) .. controls (96bp,0bp) and (96bp,0bp) .. (335bp,0bp) .. controls (352.91bp,0bp) and (372.22bp,5.7837bp) .. node[auto] {$\varepsilon$} (q7); \draw [->] (q0) ..controls (45.123bp,35.892bp) and (59.268bp,42.873bp) .. node[auto] {$\varepsilon$} (q1); \draw [->] (q1) ..controls (122.5bp,85.495bp) and (141.16bp,104.16bp) .. node[auto] {$\varepsilon$} (q2); % \end{tikzpicture} %%% end example9 %%% } \end{center} (Il a $10$ états puisqu'il y a $5$ symboles autres que les parenthèses dans $(a|b){*}b$.) Pour comparaison, voici son automate de Glushkov : \begin{center} \scalebox{0.85}{% %%% begin example9b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \node (q9) at (176bp,45.608bp) [draw,circle,state,final] {$9$}; \node (q0) at (18bp,45.608bp) [draw,circle,state,initial] {$0$}; \node (q3) at (97bp,150.61bp) [draw,circle,state] {$3$}; \node (q5) at (97bp,45.608bp) [draw,circle,state] {$5$}; \draw [->] (q0) ..controls (42.244bp,77.303bp) and (64.303bp,107.38bp) .. node[auto] {$a$} (q3); \draw [->] (q5) ..controls (124.66bp,45.608bp) and (136.82bp,45.608bp) .. node[auto] {$b$} (q9); \draw [->] (q3) ..controls (121.24bp,118.91bp) and (143.3bp,88.83bp) .. node[auto] {$b$} (q9); \draw [->] (q5) to[loop below] node[auto] {$b$} (q5); \draw [->] (q0) ..controls (45.659bp,45.608bp) and (57.817bp,45.608bp) .. node[auto] {$b$} (q5); \draw [->] (q0) ..controls (42.871bp,23.135bp) and (60.567bp,9.4181bp) .. (79bp,3.6077bp) .. controls (94.26bp,-1.2026bp) and (99.74bp,-1.2026bp) .. (115bp,3.6077bp) .. controls (129.69bp,8.2379bp) and (143.91bp,17.889bp) .. node[auto] {$b$} (q9); \draw [->] (q3) to[loop above] node[auto] {$a$} (q3); \draw [->] (q5) ..controls (112.04bp,72.544bp) and (117.47bp,87.733bp) .. (115bp,101.61bp) .. controls (113.63bp,109.34bp) and (111.12bp,117.45bp) .. node[auto,swap,pos=-0.2] {$a$} (q3); \draw [->] (q3) ..controls (97bp,116.41bp) and (97bp,92.55bp) .. node[auto,swap,near end] {$b$} (q5); % \end{tikzpicture} %%% end example9b %%% } \end{center} Il a $4$ états puisqu'il y a $3$ lettres dans $(a|b){*}b$. Ces états ont été étiquetés de manière à illustrer la proposition suivante, qui fait le lien entre les deux constructions : \begin{prop} L'élimination des transitions spontanées (au sens de \ref{removal-of-epsilon-transitions}, suivie de la suppression des états devenus inutiles) dans l'automate de Thompson d'une expression rationnelle conduit à l'automate de Glushkov de cette même expression. \end{prop} Sans que cela constitue une démonstration, on peut comprendre l'idée en considérant les « remarques » qui ont été faites dans les démonstrations de \ref{nfa-union}, \ref{nfa-concatenation} et \ref{nfa-star}. \subsection{Automates à transitions étiquetées par des expressions rationnelles (=RNFA), algorithme d'élimination des états}\label{subsection-rnfa-and-kleenes-algorithm} \thingy On cherche dans cette section à montrer la réciproque de \ref{rational-languages-are-recognizable}, c'est-à-dire, que les langages rationnels sont reconnaissables. On va pour cela donner un algorithme (très coûteux !) qui transforme un automate en expression rationnelle (dénotant le langage qu'il reconnaît). Cette algorithme « d'élimination des états » fonctionne naturellement sur une sorte d'automate encore plus générale que tous ceux que nous avons définis jusqu'à présent : on va donc commencer par définir ces automates, même si leur intérêt réside presque uniquement en la preuve de \ref{recognizable-languages-are-rational} ci-dessous. \thingy\label{definition-rnfa} Un \defin[automate fini à transitions étiquetées par des expressions rationnelles]{automate fini (non-déterministe) à transitions étiquetées par des expressions rationnelles}, en abrégé \index{RNFA|see{automate fini à transitions étiquetées par des expressions rationnelles}}\textbf{RNFA}, sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un ensemble fini $Q$ d'états, \item d'un ensemble $I \subseteq Q$ d'états dits initiaux, \item d'un ensemble $F \subseteq Q$ d'états dits finaux, \item d'un ensemble \emph{fini} de transitions $\delta \subseteq Q \times (\mathrm{regexp}(\Sigma)) \times Q$ où $(\mathrm{regexp}(\Sigma))$ désigne l'ensemble des expressions rationnelles sur $\Sigma$. \end{itemize} Autrement dit, on autorise maintenant des transitions étiquetées par des expressions rationnelles quelconques sur $\Sigma$. Remarquons qu'on doit maintenant demander \emph{explicitement} que l'ensemble $\delta$ des transitions permises soit fini car l'ensemble $Q \times (\mathrm{regexp}(\Sigma)) \times Q$, lui, ne l'est pas. \thingy\label{rnfa-multiple-transition-relation} Pour un tel automate, on définit une relation $\delta^* \subseteq Q \times \Sigma^* \times Q$ par $(q,w,q') \in \delta^*$ lorsqu'il existe $q_0,\ldots,q_n \in Q$ et $r_1,\ldots,r_n \in \mathrm{regexp}(\Sigma)$ tels que $q_0 = q$ et $q_n = q'$ et $(q_{i-1},r_i,q_i) \in\delta$ pour chaque $1\leq i\leq n$, et enfin $w \in L(r_1\cdots r_n)$. Concrètement, $(q,w,q') \in \delta^*$ signifie que le RNFA peut passer de l'état $q$ à l'état $q'$ en effectuant des transitions ($q_0\to q_1 \to \cdots \to q_n$ étiquetées par $r_1,\ldots,r_n \in \mathrm{regexp}(\Sigma)$) et en consommant le mot $w$ au sens où ce dernier se décompose comme concaténation d'autant de facteurs que de transitions ($w = v_1\cdots v_n$), chacun vérifiant l'expression rationnelle qui étiquette la transition (soit $v_i \in L(r_i)$). Enfin, l'automate $A$ accepte un mot $w$ lorsqu'il existe $q_0\in I$ et $q_\infty\in F$ tels que $(q_0,w,q_\infty) \in \delta^*$. \smallskip Le langage accepté $L(A)$ et l'équivalence de deux automates sont définis de façon analogue aux DFA (cf. \ref{definition-recognizable-language}). \thingy Un εNFA (ou \textit{a fortiori} un NFA, DFAi ou DFA) est considéré comme un RNFA particulier dont les transitions sont étiquetées soit par une unique lettre (considérée comme expression rationnelle) soit par le symbole $\underline{\varepsilon}$ (dénotant le langage $\{\varepsilon\}$) dans le cas des transitions spontanées. \smallskip Une expression rationnelle $r$ peut aussi être considérée comme un RNFA particulier comportant un unique état initial, un unique état final, et une unique transition de l'un vers l'autre, étiquetée par l'expression $r$ elle-même. Il est évident que ce RNFA reconnaît exactement le langage dénoté par $r$. \smallskip La représentation graphique des RNFA ne pose pas de problème particulier (voir en \ref{example-of-state-elimination} pour différents exemples). \thingy\label{give-rnfa-single-transitions} On peut toujours modifier un RNFA de manière à ce qu'il y ait au plus une, ou même si on le souhaite, exactement une, transition entre deux états $q$ et $q'$ donnés. En effet, s'il existe plusieurs transitions $(q,r_1,q'),\ldots, \penalty0 (q,r_k,q') \in \delta$ possibles entre $q$ et $q'$, on peut les remplacer par une unique transition $(q,(r_1|\cdots|r_k),q')$, cela ne change visiblement rien au fonctionnement de l'automate (et notamment pas le langage reconnu). S'il n'y a \emph{aucune} transition de $q$ vers $q'$, on peut toujours choisir d'en ajouter une $(q,\bot,q')$ (qui ne peut pas être empruntée !) si c'est commode. \medskip Comme les εNFA, les NFA et les DFAi avant eux, les RNFA peuvent se ramener aux automates précédemment définis : \begin{prop} Soit $A = (Q,I,F,\delta)$ un RNFA sur un alphabet $\Sigma$. Alors il existe un εNFA $A' = (Q',I',F',\delta')$ (sur le même alphabet $\Sigma$) et qui soit équivalent à $A$ au sens où il reconnaît le même langage $L(A') = L(A)$. De plus, $A'$ se déduit algorithmiquement de $A$. \end{prop} \begin{proof} On a vu en \ref{rational-languages-are-recognizable} que pour chaque expression rationnelle $r$ on peut trouver (algorithmiquement) un εNFA $A(r)$ (par exemple l'automate de Glushkov ou l'automate de Thompson) qui reconnaît le langage dénoté par $r$. On peut donc construire $A'$ en remplaçant chaque transition $(q,r,q')$ de $A$ par une copie de l'automate $A(r)$ placée entre les états $q$ et $q'$. Symboliquement : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q1.base)] \node (q1) at (0bp,0bp) [draw,circle,state] {$q$}; \node (q2) at (70bp,0bp) [draw,circle,state] {$q'$}; \draw [->] (q1) to node[auto] {$r$} (q2); \end{tikzpicture} \quad devient\quad \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q1.base)] \node (q1) at (0bp,0bp) [draw,circle,state] {$q$}; \node (q2) at (100bp,0bp) [draw,circle,state] {$q'$}; \node (A) at (50bp,0bp) [draw,dotted,circle] {$A(r)$}; \draw [->] (q1) to node[auto] {$\varepsilon$} (A); \draw [->] (A) to node[auto] {$\varepsilon$} (q2); \end{tikzpicture} \end{center} Plus précisément, si $\{(q_j,r_j,q'_j) : 1\leq j\leq M\}$ est une énumération de $\delta$, on construit $A'$ en lui donnant pour ensemble d'états $Q \uplus \biguplus_{j=1}^M Q_{r_j}$ où $Q_{r_j}$ est l'ensemble d'états de l'automate $A(r_j)$ construit pour reconnaître $r_j$, les ensembles d'états initiaux et finaux sont $I'=I$ et $F'=F$ comme dans $A$, et la relation de transition $\delta'$ est la réunion de chacune $\delta_{r_j}$ de celle des εNFA $A(r_j)$ à quoi on ajoute encore des transitions spontanées $(q_j,\varepsilon,q^\sharp)$ pour tout état initial $q^\sharp \in I_{r_j}$ de $A(r_j)$ et des transitions spontanées $(q^\flat,\varepsilon,q'_j)$ pour tout état final $q^\flat \in F_{r_j}$ de $A(r_j)$. Il est clair que faire un chemin dans $A'$ revient à un faire un chemin dans $A$ où, à chaque fois qu'on fait la transition $q_j\to q'_j$ étiquetée par $r_j$, on la remplace par un chemin $q_j \to q^\sharp \to \cdots \to q^\flat \to q'_j$ formé d'une transition spontanée vers un état initial de $A(r_j)$ suivi d'un chemin dans ce dernier, suivi d'une transition spontanée depuis un état final de $A(r_j)$. \end{proof} \medskip Mais la surprise des RNFA est qu'ils peuvent aussi se ramener à des expressions rationnelles ! \begin{prop}\label{recognizable-languages-are-rational} Soit $A = (Q,I,F,\delta)$ un RNFA (ou, en particulier, un NFA ou DFA(i)) sur un alphabet $\Sigma$. Alors il existe une expression rationnelle $r$ sur $\Sigma$ qui dénote le langage reconnu par $A$, soit $L(r) = L(A)$. De plus, $r$ se déduit algorithmiquement de $A$. \end{prop} \begin{proof} On a expliqué qu'on pouvait considérer une expression rationnelle comme un RNFA ayant un unique état initial, un unique état final, et une unique transition de l'un vers l'autre (étiquetée par l'expression rationnelle en question). On va montrer que $A$ est équivalent à un RNFA de cette nature, ce qui montrera bien qu'il est équivalent à une expression rationnelle. Remarquons tout d'abord qu'on peut supposer que $A$ a un unique état initial $q_0$, qui ne soit pas final, et qui n'ait aucune transition qui y aboutisse (si ce n'est pas le cas, il suffit de créer un nouvel état $q_0$, d'en faire le seul état initial, et de le munir de transitions spontanées — c'est-à-dire étiquetées par $\underline{\varepsilon}$ — vers tous les états précédemment initiaux). De même (symétriquement), on peut supposer que $A$ a un unique état final $q_\infty$, qui ne soit pas initial, et sans aucune transition qui en part. On fera l'hypothèse que $A$ a ces propriétés, et on s'arrangera pour les préserver dans ce qui suit. Soient maintenant $q$ un état de $A$ qui n'est ni l'état initial $q_0$ ni l'état final $q_\infty$. On va montrer qu'on peut \emph{éliminer} $q$, c'est-à-dire, quitte à ajouter des transitions, remplacer $A$ par un automate équivalent $A'$ qui n'a pas cet état. Pour cela, soient $q_1,q_2$ deux états quelconques de $A$, autres que $q$ mais possiblement égaux entre eux, où $q_1$ peut être l'état initial (mais pas l'état final) et $q_2$ peut être l'état final (mais pas l'état initial). On a vu en \ref{give-rnfa-single-transitions} qu'on pouvait supposer qu'il existait une unique transition $(q_1,r_{12},q_2)$ et de même $(q_1,r_1,q)$ et $(q,r_2,q_2)$ et $(q,s,q)$ (transition de $q$ vers lui-même). En même temps qu'on élimine $q$, on met dans $A'$ la transition $(r_{12}|r_1(s){*}r_2)$ entre $q_1$ et $q_2$. Symboliquement : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q1.base)] \node (q1) at (0bp,0bp) [draw,circle,state] {$q_1$}; \node (q2) at (70bp,0bp) [draw,circle,state] {$q_2$}; \node (q) at (35bp,50bp) [draw,circle,state] {$q$}; \draw [->] (q1) to node[auto] {$r_{12}$} (q2); \draw [->] (q1) to node[auto] {$r_1$} (q); \draw [->] (q) to node[auto] {$r_2$} (q2); \draw [->] (q) to[loop above] node[auto] {$s$} (q); \end{tikzpicture} \quad devient\quad \begin{tikzpicture}[>=latex,line join=bevel,automaton,baseline=(q1.base)] \node (q1) at (0bp,0bp) [draw,circle,state] {$q_1$}; \node (q2) at (100bp,0bp) [draw,circle,state] {$q_2$}; \draw [->] (q1) to node[auto] {$\scriptstyle (r_{12}|r_1(s){*}r_2)$} (q2); \end{tikzpicture} \end{center} Cette transformation doit être effectuée \emph{simultanément pour toute paire} $(q_1,q_2)$ d'états de $A$ pour laquelle $q_1\not\in\{q,q_\infty\}$ et $q_2\not\in\{q,q_0\}$ : pour chaque telle paire, on remplace l'étiquette de la transition $r_{12}$ entre eux par $(r_{12}|r_1(s){*}r_2)$. Ceci ne change pas le fonctionnement de l'automate, car tout chemin dans $A$ peut être remplacé par un chemin dans $A'$ en effaçant simplement les $q$ (si on considère $q_1$ et $q_2$ les états avant un bloc de $q$ dans le chemin, on voit que le chemin $q_1 \to q \to q \to \cdots \to q \to q_2$ peut se transformer en $q_1 \to q_2$ en consommant un mot qui vérifie l'expression rationnelle $(r_{12}|r_1(s){*}r_2)$). En éliminant (dans n'importe quel ordre) tous les états autres que $q_0$ et $q_\infty$, on aboutit ainsi à un automate ayant une unique transition $(q_0,r,q_\infty)$, qui est donc essentiellement l'expression rationnelle $r$. \end{proof} \thingy La procédure qu'on a décrite dans la démonstration de cette proposition s'appelle l'algorithme d'\defin{élimination des états} ou \index{Kleene (algorithme de)|see{élimination des états}}\textbf{algorithme de Kleene}\footnote{Peut-être abusivement (le théorème \ref{kleenes-theorem} est indubitablement dû à Kleene, mais le contenu algorithmique ne l'est peut-être pas) ; il est peut-être plus correct d'attribuer l'algorithme à Brzozowski et McCluskey.}. Il va de soi qu'on peut la simplifier un petit peu : s'il n'y a pas de transition de $q_1$ vers $q$ ou qu'il n'y en a pas de $q$ vers $q_2$ (c'est-à-dire que soit $r_1$ soit $r_2$ doit être considéré comme valant $\bot$), on ne touche simplement pas à $r_{12}$ (et si la transition de $q_1$ vers $q_2$ n'existait pas non plus, il n'y a pas besoin de la créer) ; de même, s'il n'y a pas de transition de $q$ vers lui-même, on ignore la partie $s{*}$. En revanche, il faut bien penser à créer une transition de $q_1$ vers $q_2$, même si elle n'existait pas au départ, lorsqu'on peut arriver de l'un vers l'autre en passant par $q$. Et il faut se souvenir que le cas $q_2=q_1$ est à traiter aussi. En général, l'élimination des états conduit à une expression extrêmement compliquée (exponentielle dans le nombre d'états de l'automate, au moins dans le pire cas, mais aussi dans beaucoup de cas « typiques »). \thingy\label{example-of-state-elimination} À titre d'exemple, considérons le DFA suivant sur l'alphabet $\{0,1\}$, qui reconnaît les suites binaires qui représentent un nombre multiple de $3$ écrit en binaire\footnote{Les états $0,1,2$ représentent respectivement les états dans lesquels le nombre binaire lu jusqu'à présent par l'automate est congru à $0,1,2$ modulo $3$.} (en convenant que le mot vide est une représentation binaire du nombre $0$, ce qui est logique) : \begin{center} %%% begin example6 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,20.28bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,20.28bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (176bp,20.28bp) [draw,circle,state] {$2$}; \draw [->] (q1) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$1$} (q0); \draw [->] (q2) to[loop above] node[auto] {$1$} (q2); \draw [->] (q2) ..controls (153.76bp,3.6593bp) and (143.08bp,-1.2803bp) .. (133bp,1.2803bp) .. controls (129.04bp,2.2853bp) and (125.05bp,3.838bp) .. node[auto] {$0$} (q1); \draw [->] (q0) to[loop above] node[auto] {$0$} (q0); \draw [->] (q0) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$1$} (q1); \draw [->] (q1) ..controls (124.66bp,20.28bp) and (136.82bp,20.28bp) .. node[auto] {$0$} (q2); % \end{tikzpicture} %%% end example6 %%% \end{center} On commence par ajouter un état initial $q_0$ et un état final $q_\infty$, avec des ε-transitions $q_0 \to 0$ et $0\to q_\infty$. Pour gagner de la place, nous ne figurerons pas ces deux états sur les dessins qui suivent, mais il faut s'imaginer qu'ils sont toujours là. L'élimination de l'état $2$ conduit à l'automate suivant : \begin{center} %%% begin example6b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,20.28bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,20.28bp) [draw,circle,state,initial,final,accepting below] {$0$}; \draw [->] (q1) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$1$} (q0); \draw [->] (q0) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$1$} (q1); \draw [->] (q1) to[loop right] node[auto] {$01{*}0$} (q1); \draw [->] (q0) to[loop above] node[auto] {$0$} (q0); % \end{tikzpicture} %%% end example6b %%% \end{center} \noindent (Répétons qu'on n'a pas figuré l'état initial $q_0$ ni l'état final $q_\infty$ : les flèches vers et depuis l'état $0$ doivent se comprendre comme des ε-transitions $q_0\to 0$ et $0\to q_\infty$.) L'élimination de l'état $1$ conduit alors à l'automate ayant un unique état $0$, avec une transition vers lui-même étiquetée $0|1(01{*}0){*}1$. Enfin, en éliminant l'état $0$, il ne reste qu'une transition de l'état initial vers l'état final, étiquetée par $(0|1(01{*}0){*}1){*}$ : le langage reconnu par l'automate de départ est donc celui dénoté par l'expression rationnelle $(0|1(01{*}0){*}1){*}$. On pouvait aussi choisir d'éliminer l'état $1$ en premier, ce qui conduit à l'automate suivant : \begin{center} %%% begin example6c %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q0) at (18bp,20.114bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (104bp,20.114bp) [draw,circle,state] {$2$}; \draw [->] (q2) ..controls (82.598bp,6.6202bp) and (75.237bp,2.9515bp) .. (68bp,1.1137bp) .. controls (59.228bp,-1.1137bp) and (49.898bp,1.2372bp) .. node[auto] {$01$} (q0); \draw [->] (q0) ..controls (47.743bp,20.114bp) and (62.773bp,20.114bp) .. node[auto] {$10$} (q2); \draw [->] (q0) to[loop above] node[auto] {$0|11$} (q0); \draw [->] (q2) to[loop above] node[auto] {$1|00$} (q2); % \end{tikzpicture} %%% end example6c %%% \end{center} \noindent et finalement à l'expression rationnelle $(0|11|10(1|00){*}01){*}$, qui est équivalente à la précédente. \bigbreak \thingy Donnons encore l'exemple du DFAi suivant : \begin{center} %%% begin example10 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,20.28bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,20.28bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q3) at (255bp,20.28bp) [draw,circle,state] {$3$}; \node (q2) at (176bp,20.28bp) [draw,circle,state] {$2$}; \node (q4) at (334bp,20.28bp) [draw,circle,state] {$4$}; \draw [->] (q1) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$b$} (q0); \draw [->] (q2) ..controls (203.66bp,20.28bp) and (215.82bp,20.28bp) .. node[auto] {$a$} (q3); \draw [->] (q2) ..controls (153.76bp,3.6593bp) and (143.08bp,-1.2803bp) .. (133bp,1.2803bp) .. controls (129.04bp,2.2853bp) and (125.05bp,3.838bp) .. node[auto] {$b$} (q1); \draw [->] (q3) ..controls (282.66bp,20.28bp) and (294.82bp,20.28bp) .. node[auto] {$a$} (q4); \draw [->] (q3) ..controls (232.76bp,3.6593bp) and (222.08bp,-1.2803bp) .. (212bp,1.2803bp) .. controls (208.04bp,2.2853bp) and (204.05bp,3.838bp) .. node[auto] {$b$} (q2); \draw [->] (q0) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$a$} (q1); \draw [->] (q4) ..controls (311.76bp,3.6593bp) and (301.08bp,-1.2803bp) .. (291bp,1.2803bp) .. controls (287.04bp,2.2853bp) and (283.05bp,3.838bp) .. node[auto] {$b$} (q3); \draw [->] (q1) ..controls (124.66bp,20.28bp) and (136.82bp,20.28bp) .. node[auto] {$a$} (q2); % \end{tikzpicture} %%% end example10 %%% \end{center} Il s'agit d'un automate « compteur limité », qui ne sait compter que de $0$ à $4$, incrémentant son compteur quand il reçoit un $a$ et le décrémentant quand il reçoit un $b$ (et cessant de fonctionner si le compteur passe au-dessus du maximum ou en-dessous du minimum), et qui accepte finalement les mots dont le nombre de $b$ égale le nombre de $a$ sans qu'il y ait jamais eu plus de $b$ que de $a$ ni plus de quatre $a$ de plus que de $b$. (On peut dire aussi qu'il s'agit d'une \emph{approximation} du langage des expressions bien-parenthésées définies en \ref{example-well-parenthesized-expressions} plus loin, où $a$ joue le rôle de parenthèse ouvrante et $b$ de parenthèse fermante ; l'approximation est due au fait qu'on n'accepte que quatre niveaux d'imbrication des « parenthèses ».) Si on élimine les états dans l'ordre $4,3,2,1,0$, on montre que le langage reconnu par cet automate est décrit par l'expression rationnelle $(a(a(a(ab){*}b){*}b){*}b){*}$. Si on les élimine dans l'ordre $0,1,2,3,4$, en revanche, on obtient une expression de taille considérable\footnote{À savoir : $\underline{\varepsilon} \penalty0 \; | \penalty0 \; a(ba){*}b \penalty0 \; | \penalty0 \; a(ba){*}a(b(ba){*}a){*}b(ba){*}b \penalty0 \; | \penalty0 \; a(ba){*}a(b(ba){*}a){*}a(b(b(ba){*}a){*}a){*}b(b(ba){*}a){*}b(ba){*}b \penalty0 \; | \penalty0 \; a(ba){*}a(b(ba){*}a){*}a(b(b(ba){*}a){*}a){*}a(b(b(b(ba){*}a){*}a){*}a){*}b(b(b(ba){*}a){*}a){*}b(b(ba){*}a){*}b(ba){*}b$ (mais si on la regarde d'assez près, on peut comprendre comment elle fonctionne).} et beaucoup moins transparente. \bigbreak Récapitulons le contenu essentiel à retenir comme conséquence immédiate de \ref{rational-languages-are-recognizable} et \ref{recognizable-languages-are-rational} : \begin{thm}[Kleene]\label{kleenes-theorem}\index{Kleene (théorème de)} La classe des langages rationnels et celle des langages reconnaissables coïncident. (On pourra donc considérer ces termes comme synonymes.) \end{thm} \smallskip Il faut cependant retenir que s'il y a, mathématiquement, équivalence entre ces deux classes de langages, cette équivalence \emph{a un coût algorithmique}, c'est-à-dire que la conversion d'une expression rationnelle en automate (surtout si on souhaite un DFA), ou à plus forte raison d'un automate en expression rationnelle, a une complexité exponentielle dans le pire cas. Il est donc pertinent, en informatique, de ne pas considérer les descriptions d'un langage par une expression rationnelle, un DFA, et un NFA, comme interchangeables. \thingy Une conséquence de \ref{kleenes-theorem} est, par exemple, que le complémentaire d'un langage rationnel est rationnel (cf. \ref{dfa-complement}) ou que l'intersection de deux langages rationnels est rationnelle (cf. \ref{dfa-union-and-intersection}), et que ces opérations se calculent algorithmiquement. Il est donc possible, en principe, à partir d'une expression rationnelle $r$ (sur un alphabet $\Sigma$), de fabriquer algorithmiquement une expression rationnelle $r'$ (« négation » de $r$) qui dénote le langage complémentaire de celui dénoté par $r$ ; et de même, à partir d'expressions rationnelles $r_1,r_2$, de fabriquer algorithmiquement une expression rationnelle $r''$ (« conjonction » de $r_1$ et $r_2$) qui dénote le langage intersection de ceux dénotés par $r_1$ et $r_2$. \smallskip Le coût de ces opérations, cependant, est astronomique : doublement exponentiel, puisqu'il s'agit de convertir l'expression en NFA, de déterminiser le NFA en DFA (à un premier coût exponentiel), d'effectuer l'opération sur un DFA, et de reconvertir le DFA en expression rationnelle (à un deuxième coût exponentiel). Ce n'est pas faute d'avoir les bons algorithmes : on peut montrer qu'il existe effectivement des familles d'expressions rationnelles pour lesquelles la négation ou la conjonction produisent une augmentation de taille doublement exponentielle. %% Gelade & Neven (STACS 2008), %% "Succinctness of the Complement and Intersection of Regular Expressions" \subsection{Le lemme de pompage}\label{subsection-pumping-lemma} \thingy On ne dispose à ce stade-là d'aucun moyen pour montrer qu'un langage \emph{n'est pas} rationnel. La proposition \ref{pumping-lemma} qui va suivre, et qui s'appelle couramment « lemme de pompage » (une traduction abusive de l'anglais « pumping lemma ») constitue le moyen le plus fréquent permettant d'y arriver : il énonce une condition \emph{nécessaire} pour qu'un langage soit rationnel, si bien qu'on peut arriver à montrer qu'un langage n'est pas rationnel en invalidant cette condition (généralement en procédant par l'absurde). \begin{prop}[lemme de pompage pour les langages rationnels]\label{pumping-lemma}\index{pompage (lemme de)} Soit $L$ un langage rationnel. Il existe alors un entier $k$ tel que tout mot de $t \in L$ de longueur $|t| \geq k$ admette une factorisation $t = uvw$ en trois facteurs $u,v,w \in \Sigma^*$ où : \begin{itemize} \item[(i)] $|v| \geq 1$ (c'est-à-dire $v\neq\varepsilon$), \item[(ii)] $|uv| \leq k$, \item[(iii)] pour tout $i\geq 0$ on a $uv^iw \in L$. \end{itemize} \end{prop} \begin{proof} Soit $A$ un DFA (complet) qui reconnaît $L$, et soit $k$ son nombre d'états : on va montrer que $k$ vérifie les propriétés énoncées. Pour cela, soit $t = x_1 \cdots x_n$ un mot de $L$ de longueur $n \geq k$, et soient $q_0,\ldots,q_n$ les états traversés par $A$ pendant la consommation de $t$, autrement dit, $q_0$ est l'état initial, et $q_j = \delta(q_{j-1}, x_j)$ pour chaque $1\leq j\leq n$ ; l'état $q_n = \delta^*(q_0, t)$ est final puisque $t \in L$. Comme $n+1 > k$ et comme l'automate $A$ a $k$ états, par le principe des tiroirs, il existe $j_1\neq j_2$ tels que $q_{j_1} = q_{j_2}$ : pour être plus précis, soit $j_2$ le plus petit possible tel que les états $q_0,\ldots,q_{j_2}$ ne soient pas tous distincts, autrement dit, le premier état répété, et soit $j_1$ la précédente occurrence (forcément unique) de cet état, c'est-à-dire l'indice tel que $j_1=latex,line join=bevel,automaton] \draw[draw=none,fill=green!20!white] (-58.476bp,-58.476bp) rectangle (58.476bp,58.476bp); \draw[dotted] (29.238bp,50.642bp) arc (60:-100:58.476bp); \draw[draw=none,fill=red!20!white] (-188.476bp,-25bp) rectangle (-68.476bp,25bp); \draw[draw=none,fill=blue!20!white] (-48.476bp,-25bp) rectangle (110bp,25bp); \node[anchor=south west] at (-188.476bp,-25bp) {$u$}; \node[anchor=south east] at (58.476bp,-58.476bp) {$v$}; \node[anchor=south east] at (110bp,-25bp) {$w$}; \node (q0) at (-198.476bp,0bp) [draw,circle,state,fill=white,initial] {\vbox to0pt{\vss\hbox to0pt{$q_0$\hss}}\phantom{$q_{j_0}$}}; \node (q1) at (-138.476bp,0bp) [draw,circle,state,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_1$\hss}}\phantom{$q_{j_0}$}}; \node (q2) at (-98.476bp,0bp) {$\cdots$}; \node (qj1) at (-58.476bp,0bp) [draw,circle,state,fill=white] {\vbox to0pt{\vss\hbox to0pt{$q_{j_1}$\hss}}\phantom{$q_{j_0}$}}; \node (qj1p1) at (-44.795bp,37.588bp) [draw,circle,state,fill=white] {\phantom{$q_{j_0}$}}; \node (qj1p2) at (-10.154bp,57.588bp) [draw,circle,state,fill=white] {\phantom{$q_{j_0}$}}; \node (qj1p3) at (29.238bp,50.642bp) {}; \node (qj2m2) at (-10.154bp,-57.588bp) {}; \node (qj2m1) at (-44.795bp,-37.588bp) [draw,circle,state,fill=white] {\phantom{$q_{j_0}$}}; \node (qj2p1) at (0bp,0bp) [draw,circle,state,fill=white] {\phantom{$q_{j_0}$}}; \node (qj2p2) at (60bp,0bp) {$\cdots$}; \node (qn) at (120bp,0bp) [draw,circle,state,fill=white,final] {\vbox to0pt{\vss\hbox to0pt{$q_n$\hss}}\phantom{$q_{j_0}$}}; \draw[->] (q0) -- node[auto] {\footnotesize $x_1$} (q1); \draw[->] (q1) -- (q2); \draw[->] (q2) -- node[auto] {\footnotesize $x_{j_1}$} (qj1); \draw[->] (qj1) -- node[auto] {\footnotesize $x_{j_1+1}$} (qj1p1); \draw[->] (qj1p1) -- node[auto] {\footnotesize $x_{j_1+2}$} (qj1p2); \draw[->] (qj1p2) -- (qj1p3); \draw[->] (qj2m2) -- (qj2m1); \draw[->] (qj2m1) -- node[auto] {\footnotesize $x_{j_2}$} (qj1); \draw[->] (qj1) -- node[auto] {\footnotesize $x_{j_2+1}$} (qj2p1); \draw[->] (qj2p1) -- (qj2p2); \draw[->] (qj2p2) -- node[auto] {\footnotesize $x_n$}(qn); \end{tikzpicture} \end{center} Posons $u = x_1\cdots x_{j_1}$ (le préfixe de $t$ de longueur $j_1$, qui est le mot vide si $j_1 = 0$) et $v = x_{j_1+1}\cdots x_{j_2}$ (de longueur $j_2 - j_1$), et enfin $w = x_{j_2+1}\cdots x_n$ (le suffixe de $t$ de longueur $n-j_2$, avec la convention $w = \varepsilon$ si $j_2 = n$). Ceci définit bien une factorisation $t = uvw$. On a bien (i) $|v| \geq 1$ puisque $j_2 > j_1$. On a par ailleurs (ii) $|uv| \leq k$ puisque $|uv| = j_2$ et que les $j_2$ états $q_0,\ldots,q_{j_2-1}$ sont distincts (c'est la minimalité de $j_2$) de sorte que $j_2 \leq k$ (toujours par le principe des tiroirs). Montrons enfin (iii). On rappelle tout d'abord que $\delta^*(q,x_1\cdots x_j) =\penalty0 \delta(\cdots\penalty500 \delta(\delta(q,x_1),x_2)\cdots,x_j)$. Remarquons que $\delta^*(q_0,u) = \delta^*(q_0,x_1\cdots x_{j_1}) = q_{j_1}$, et que $\delta^*(q_{j_1},v) = \delta^*(q_{j_1},x_{j_1+1}\cdots x_{j_2}) = q_{j_2} = q_{j_1}$. De cette dernière égalité, on tire $\delta^*(q_{j_1},v^i) = q_{j_1}$ pour tout $i \geq 0$ (par récurrence sur $i$). Enfin, $\delta^*(q_{j_1},w) = \delta^*(q_{j_2},w) = \delta^*(q_{j_2}, x_{j_2+1}\cdots x_n) = q_n$ (qui est un état final). En mettant ces faits ensemble, on a $\delta^*(q_0, uv^iw) = \delta^*(q_{j_1}, v^iw) = \delta^*(q_{j_1}, w) = q_n$, et puisque $q_n$ est final, ceci montre que le mot $uv^iw$ est accepté par $A$, i.e., $uv^iw \in L$. \end{proof} \thingy On attire l'attention sur l'alternation des quantificateurs. Le lemme de pompage énonce le fait que : \begin{itemize} \item\emph{pour tout} langage rationnel $L$, \item\emph{il existe} un entier $k\geq 0$ tel que \item\emph{pour tout} mot $t\in L$ de longueur $|t|\geq k$, \item\emph{il existe} une factorisation $t=uvw$ vérifiant les propriétés (i) $|v|\geq 1$, (ii) $|uv|\leq k$ et (iii) qui suit : \item\emph{pour tout} $i\geq 0$ on a $uv^iw \in L$. \end{itemize} La complexité logique d'un énoncé étant justement mesurée par le nombre d'alernations de quantificateurs (passages entre « pour tout » et « il existe » ou vice versa), celui-ci mérite une attention particulière. Rappelons donc, du point de vue logique, que, quand on veut \emph{appliquer} un résultat de ce genre, on \emph{choisit librement} les objets introduits par un quantificateur universel (« pour tout »), mais \emph{on ne choisit pas} ceux qui sont introduits par un quantificateur existentiel (« il existe ») (ces derniers sont, si on veut, choisis par l'énoncé qu'on applique : on ne fait que recevoir leur existence) ; les choses sont inversées quand on doit démontrer un tel énoncé, mais la démonstration a été faite ci-dessus et il est donc plus fréquent de devoir appliquer le lemme de pompage. \thingy Le modèle d'une démonstration par l'absurde pour montrer qu'un langage $L$ n'est pas rationnel est donc quelque chose comme ceci : \begin{itemize} \item on entame un raisonnement par l'absurde en supposant que $L$ est rationnel, et on choisit $L$ pour appliquer le lemme de pompage (parfois on l'applique à autre chose, comme l'intersection de $L$ avec un langage connu pour être rationnel, mais en général ce sera $L$), \item le lemme de pompage fournit un $k$ (on \emph{ne choisit donc pas} ce $k$, il est donné par le lemme), \item on choisit alors un mot $t \in L$ de longueur $\geq k$, et c'est là que réside la difficulté principale de la démonstration, \item le lemme de pompage fournit une factorisation $t = uvw$, qu'on \emph{ne choisit pas} non plus mais qu'on peut analyser, souvent en utilisant (i) et (ii), \item et on cherche à appliquer la propriété (iii), ce qui implique de choisir un $i$, pour arriver à une contradiction (typiquement : le mot $uv^i w$ n'est pas dans le langage alors qu'il est censé y être). \end{itemize} \smallskip Donnons maintenant un exemple d'utilisation du lemme : \begin{prop}\label{example-of-pumping-lemma} Soit $\Sigma = \{a,b\}$. Le langage $L = \{a^n b^n : n\in\mathbb{N}\} = \{\varepsilon, ab, aabb, aaabbb,\ldots\}$ constitué des mots formés d'un certain nombre ($n$) de $a$ suivis du même nombre de $b$ n'est pas rationnel. \end{prop} \begin{proof} Appliquons la proposition \ref{pumping-lemma} au langage $L$ considéré : appelons $k$ l'entier dont le lemme de pompage garantit l'existence. Considérons le mot $t := a^k b^k$ : il doit alors exister une factorisation $t = uvw$ pour laquelle on a (i) $|v|\geq 1$, (ii) $|uv|\leq k$ et (iii) $uv^iw \in L$ pour tout $i\geq 0$. La propriété (ii) assure que $uv$ est formé d'un certain nombre de répétitions de la lettre $a$ (car tout préfixe de longueur $\leq k$ de $a^k b^k$ est de cette forme) ; disons $u = a^\ell$ et $v = a^m$, si bien que $w = a^{k-\ell-m} b^k$. La propriété (i) donne $m\geq 1$. Enfin, la propriété (iii) affirme que le mot $uv^iw = a^{k+(i-1)m} b^k$ appartient à $L$ ; mais dès que $i\neq 1$, ceci est faux : il suffit donc de prendre $i=0$ pour avoir une contradiction. \end{proof} \thingy L'idée intuitive derrière la démonstration qu'on vient de faire est la suivante : un automate fini ne dispose que d'une quantité finie (bornée) de mémoire, donc ne peut « compter » que jusqu'à un nombre borné (au-delà, il va retomber sur un état déjà atteint par un plus petit nombre de $a$, et sera incapable de vérifier si le nombre de $b$ est égal). C'est ce type de raisonnement que le lemme de pompage permet de formaliser. Généralement parlant, on doit garder à l'esprit le fait que toutes sortes de langages ne sont pas rationnels pour la raison informelle que les identifier demande une quantité de mémoire qui pourrait être arbitrairement grande, et que pour le montrer rigoureusement, le lemme de pompage sera souvent utile. \subsection{L'automate minimal, et la minimisation} \thingy On sait maintenant convertir une expression rationnelle en un automate équivalent, et réciproquement convertir un automate en expression rationnelle équivalente. Il reste un problème auquel nous n'avons pas donné de réponse : comment savoir si deux automates \emph{donnés} ou deux expressions rationnelles données (ou un de chaque) sont équivalents ? \smallskip Pour cela, on va introduire un DFA particulier, \emph{canonique}, associé à un langage rationnel, qu'on pourra calculer algorithmiquement, et qui sera véritablement associé au langage, c'est-à-dire que deux descriptions équivalentes du même langage donneront exactement le \emph{même} automate canonique ; par conséquent, pour tester l'égalité de deux langages, quelle que soit leur description, il suffira de calculer leurs automates canoniques et de les comparer. En fait, cet automate canonique est simplement le DFA ayant le plus petit nombre d'états reconnaissant le langage en question ; ce qui est remarquable, et qui n'est pas du tout évident \textit{a priori}, c'est qu'il est effectivement canonique (c'est-à-dire qu'il n'existe qu'un seul DFA ayant un nombre minimal d'états reconnaissant le langage) et qu'on peut le calculer algorithmiquement. \begin{thm}[Myhill-Nerode]\label{myhill-nerode}\index{Myhill-Nerode (théorème de)} Soit $L$ un langage. Pour $w\in \Sigma^*$, notons $w^{-1} L := \{t \in \Sigma^* : wt \in L\}$ (autrement dit, l'ensemble des mots qu'on peut concaténer à $w$ pour obtenir un mot de $L$). Considérons la relation d'équivalence $\equiv$ sur $\Sigma^*$ définie par $u \equiv v$ si et seulement si $u^{-1}L = v^{-1}L$ ; ce qui signifie, si on préfère, que $\forall t\in \Sigma^*\,((ut\in L) \liff (vt \in L))$. Alors : \begin{itemize} \item le langage $L$ est rationnel si et seulement si la relation d'équivalence $\equiv$ possède un nombre \emph{fini} $k$ de classes d'équivalence, \item lorsque c'est le cas, il existe un DFA (complet) ayant $k$ états qui reconnaît $L$, il est unique à renommage des états\footnote{C'est-à-dire, si on préfère ce terme, isomorphisme d'automates.} près, et il n'existe pas de DFA (complet) ayant $=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,67bp) [draw,circle,state,initial] {$0$}; \node (q3) at (186bp,18bp) [draw,circle,state] {$3$}; \node (q2) at (98bp,105bp) [draw,circle,state] {$2$}; \node (q5) at (266bp,67bp) [draw,circle,state,final] {$5$}; \node (q4) at (186bp,105bp) [draw,circle,state,final] {$4$}; \draw [->] (q2) ..controls (125.5bp,78.193bp) and (148.96bp,54.459bp) .. node[auto] {$c$} (q3); \draw [->] (q0) ..controls (45.307bp,79.816bp) and (60.14bp,87.042bp) .. node[auto] {$a$} (q2); \draw [->] (q2) to[loop above] node[auto] {$a$} (q2); \draw [->] (q5) to[loop below] node[auto] {$a,b,c$} (q5); \draw [->] (q4) ..controls (213.31bp,92.184bp) and (228.14bp,84.958bp) .. node[auto] {$c$} (q5); \draw [->] (q1) ..controls (128.25bp,18bp) and (144.18bp,18bp) .. node[auto] {$a,c$} (q3); \draw [->] (q4) to[loop above] node[auto] {$a,b$} (q4); \draw [->] (q1) to[loop below] node[auto] {$b$} (q1); \draw [->] (q3) ..controls (213bp,34.334bp) and (228.89bp,44.318bp) .. node[auto] {$b$} (q5); \draw [->] (q3) to[loop below] node[auto] {$a,c$} (q3); \draw [->] (q0) ..controls (45.002bp,50.666bp) and (60.894bp,40.682bp) .. node[auto] {$c$} (q1); \draw [->] (q0) to[loop above] node[auto] {$b$} (q0); \draw [->] (q2) ..controls (128.25bp,105bp) and (144.18bp,105bp) .. node[auto] {$b$} (q4); % \end{tikzpicture} %%% end example7 %%% \end{center} Cet automate est bien déterministe, complet et sans état inaccessible. Dans un premier temps, on partitionne les états en états non-finaux et finaux, soit $\{0,1,2,3\}$ d'un côté et $\{4,5\}$ de l'autre. Ensuite, on doit séparer la classe $\{0,1,2,3\}$ en deux selon que la transition étiquetée par $b$ tombe dans la classe $\{0,1,2,3\}$ elle-même ou bien dans la classe $\{4,5\}$ : on arrive donc à trois classes, $\{0,1\}$, $\{2,3\}$ et $\{4,5\}$. Enfin, on doit séparer la classe $\{0,1\}$ en deux selon que la transition étiquetée par $c$ tombe dans la classe $\{0,1\}$ elle-même ou bien dans la classe $\{2,3\}$ : on arrive alors à quatre classes, $\{0\}$, $\{1\}$, $\{2,3\}$ et $\{4,5\}$, et à l'automate minimal suivant : \begin{center} %%% begin example7m %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,76bp) [draw,circle,state,initial] {$0$}; \node (q23) at (190bp,76bp) [draw,circle,state] {$2\equiv 3$}; \node (q45) at (278bp,76bp) [draw,circle,state,final] {$4\equiv 5$}; \draw [->] (q1) to[loop below] node[auto] {$b$} (q1); \draw [->] (q23) to[loop above] node[auto] {$a,c$} (q23); \draw [->] (q1) ..controls (126.79bp,35.911bp) and (146.9bp,48.867bp) .. node[auto] {$a,c$} (q23); \draw [->] (q0) ..controls (48.315bp,77.182bp) and (65.168bp,77.757bp) .. (80bp,78bp) .. controls (106.51bp,78.434bp) and (136.64bp,77.795bp) .. node[auto] {$a$} (q23); \draw [->] (q23) ..controls (222.17bp,76bp) and (234.88bp,76bp) .. node[auto] {$b$} (q45); \draw [->] (q0) ..controls (44.591bp,56.971bp) and (61.407bp,44.466bp) .. node[auto] {$c$} (q1); \draw [->] (q0) to[loop above] node[auto] {$b$} (q0); \draw [->] (q45) to[loop above] node[auto] {$a,b,c$} (q45); % \end{tikzpicture} %%% end example7m %%% \end{center} \medskip Il est intéressant de voir comment des petits changements sur l'automate initial modifient la minimisation. Si on fait pointer la transition étiquetée par $c$ de l'état $1$ vers lui-même (au lieu d'aller vers l'état $3$), c'est-à-dire : \begin{center} %%% begin example7b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,18bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,67bp) [draw,circle,state,initial] {$0$}; \node (q3) at (178bp,18bp) [draw,circle,state] {$3$}; \node (q2) at (98bp,105bp) [draw,circle,state] {$2$}; \node (q5) at (258bp,67bp) [draw,circle,state,final] {$5$}; \node (q4) at (178bp,105bp) [draw,circle,state,final] {$4$}; \draw [->] (q2) ..controls (123.52bp,77.652bp) and (143.78bp,55.049bp) .. node[auto] {$c$} (q3); \draw [->] (q0) ..controls (45.307bp,79.816bp) and (60.14bp,87.042bp) .. node[auto] {$a$} (q2); \draw [->] (q2) to[loop above] node[auto] {$a$} (q2); \draw [->] (q5) to[loop below] node[auto] {$a,b,c$} (q5); \draw [->] (q4) ..controls (205.31bp,92.184bp) and (220.14bp,84.958bp) .. node[auto] {$c$} (q5); \draw [->] (q1) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$a$} (q3); \draw [->] (q4) to[loop above] node[auto] {$a,b$} (q4); \draw [->] (q1) to[loop below] node[auto] {$b,c$} (q1); \draw [->] (q3) ..controls (205bp,34.334bp) and (220.89bp,44.318bp) .. node[auto] {$b$} (q5); \draw [->] (q3) to[loop below] node[auto] {$a,c$} (q3); \draw [->] (q0) ..controls (45.002bp,50.666bp) and (60.894bp,40.682bp) .. node[auto] {$c$} (q1); \draw [->] (q0) to[loop above] node[auto] {$b$} (q0); \draw [->] (q2) ..controls (126.11bp,105bp) and (138.58bp,105bp) .. node[auto] {$b$} (q4); % \end{tikzpicture} %%% end example7b %%% \end{center} \noindent alors la minimisation ne sépare pas les états $0$ et $1$, et on obtient (le même automate qu'en \ref{discussion-example2}, à savoir) : \begin{center} %%% begin example7bm %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q45) at (198bp,21bp) [draw,circle,state,final] {$4\equiv 5$}; \node (q01) at (22bp,21bp) [draw,circle,state,initial] {$0\equiv 1$}; \node (q23) at (110bp,21bp) [draw,circle,state] {$2\equiv 3$}; \draw [->] (q45) to[loop above] node[auto] {$a,b,c$} (q45); \draw [->] (q23) ..controls (142.17bp,21bp) and (154.88bp,21bp) .. node[auto] {$b$} (q45); \draw [->] (q23) to[loop above] node[auto] {$a,c$} (q23); \draw [->] (q01) to[loop above] node[auto] {$b,c$} (q01); \draw [->] (q01) ..controls (54.17bp,21bp) and (66.885bp,21bp) .. node[auto] {$a$} (q23); % \end{tikzpicture} %%% end example7bm %%% \end{center} En revanche, si on change l'automate pour rendre l'état $4$ non-final (avec ou sans la modification précédemment évoquée), la minimisation aboutit sur la partition triviale en six états, c'est-à-dire que l'automate est, en fait, déjà minimal. {\footnotesize\thingy\textbf{Cas dégénérés :} Si aucun état d'un DFA n'est final (c'est-à-dire s'il reconnaît le langage vide $\varnothing$), alors l'algorithme de minimisation termine immédiatement avec une seule classe d'équivalence, et donne donc un automate minimal ayant un unique état, initial mais non final, et des transitions étiquetées par toutes les lettres de cet état vers lui-même. Si \emph{tous} les états d'un DFA sont finaux (il reconnaît le langage $\Sigma^*$ de tous les mots), de même, l'algorithme de minimisation termine immédiatement avec une seule classe d'équivalence, et donne donc un automate minimal ayant un unique état, à la fois initial et final (et toujours des transitions étiquetées par toutes les lettres de cet état vers lui-même).\par} \bigbreak Énonçons ici le fait évoqué plus haut comme application de l'algorithme de minimisation : \begin{cor}\label{equivalence-of-regexps-is-decidable} On peut décider algorithmiquement si deux automates finis (de n'importe quelle sorte), ou deux expressions rationnelles, ou un automate et une expression rationnelle, sont équivalents (au sens de reconnaître/dénoter le même langage). \end{cor} \begin{proof} D'après ce qu'on a déjà vu, et quitte à transformer une expression rationnelle en εNFA (cf. \ref{rational-languages-are-recognizable}), et quitte à éliminer les ε-transitions (cf. \ref{removal-of-epsilon-transitions}) et à déterminiser (cf. \ref{determinization-of-nfa}), on peut construire algorithmiquement un DFA reconnaissant le même langage que chacune des deux données. La question devient donc de savoir si deux DFA reconnaissent le même langage. Or d'après \ref{dfa-minimization}, on sait transformer un DFA en DFA minimal reconnaissant le même langage, et d'après \ref{myhill-nerode} on sait que ce DFA est unique à renumérotation près des états. On est donc ramené au problème suivant : donnés deux DFA $A$ et $A'$ (complets et sans états inaccessibles), trouver s'ils sont le même à renumérotation près (i.e., s'ils sont isomorphes). La correspondance entre états de $A$ et de $A'$ peut se construire état par état : on fait correspondre l'état initial de $A$ à celui de $A'$, puis pour chaque état $q$ de $A$ mis en correspondance avec un état $q'$ de $A'$, on fait correspondre chacun des états $\delta(q,x)$ avec chacun des états $\delta'(q',x)$ où $x$ parcourt les lettres de l'alphabet. Si on aboutit ainsi à une contradiction (deux états de l'un des automates veulent être mis en correspondance avec le même état de l'autre), on renvoie un échec ; sinon, tous les états de $A$ et ceux de $A'$ seront mis en correspondance bijective, et les langages reconnus sont les mêmes. \end{proof} \section{Grammaires hors contexte}\label{section-context-free-grammars} \setcounter{comcnt}{0} \thingy Alors que les langages et expressions rationnelles servent, dans le monde informatique, principalement à définir des outils de recherche de « motifs » (pour la recherche et le remplacement dans un texte, la validation d'entrées, la syntaxe de bas niveau, etc.), les grammaires formelles, dont les plus importantes sont les grammaires \emph{hors contexte} que nous allons maintenant considérer, ont pour principal intérêt de définir des \emph{syntaxes structurées}, par exemple la syntaxe d'un langage informatique (typiquement un langage de programmation). En fait, l'étude des grammaires formelles en général, et des grammaires hors contexte en particulier, a été démarrée\footnote{Certains font remonter leur origine bien plus loin : on peut trouver une forme de grammaire hors contexte dans la manière dont l'Indien Pāṇini (probablement au IV\textsuperscript{e} siècle av. notre ère) décrit la grammaire du sanskrit.} en 1956 par le linguiste (et activiste politique) Noam Chomsky pour servir dans l'analyse des langues naturelles ; mais c'est plus en informatique qu'en linguistique qu'elles ont trouvé leur utilité, à commencer surtout par la définition de la syntaxe du langage ALGOL 60. \smallskip Cette fois-ci, on ne s'intéressera pas simplement au langage défini (par la grammaire hors contexte, dit langage « algébrique »), mais aussi à la manière dont ces mots s'obtiennent par la grammaire, et donc, à la manière d'\emph{analyser} (en anglais, \emph{to parse}) un mot / programme en une structure de données qui le représente : pour cela, on va définir la notion d'\emph{arbre d'analyse}. \thingy Un exemple typique d'usage de grammaire hors contexte pour définir la syntaxe d'un langage de programmation hypothétique pourrait ressembler à ceci : \[ \begin{aligned} \mathit{Statement} &\rightarrow \mathtt{begin}\ \mathit{Block}\ \mathtt{end}\\ \mathit{Statement} &\rightarrow \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{Block}\ \mathtt{fi}\\ \mathit{Statement} &\rightarrow \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{Block}\ \mathtt{else}\ \mathit{Block}\ \mathtt{fi}\\ \mathit{Block} &\rightarrow \varepsilon\\ \mathit{Block} &\rightarrow \mathit{Statement}\ \mathit{Block}\\ \end{aligned} \] Il faut comprendre ces règles de la manière suivante : « pour définir une instruction ($\mathit{Statement}$), on peut mettre un $\mathtt{begin}$ suivi d'un bloc ($\mathit{Block}$) suivi d'un $\mathtt{end}$, ou bien un $\mathtt{if}$ suivi d'une expression ($\mathit{Expression}$) suivi d'un $\mathtt{then}$ suivi d'un bloc, éventuellement suivie encore d'un $\mathtt{else}$ et d'un nouveau bloc, et enfin un $\mathtt{fi}$ ; pour définir un bloc ($\mathit{Block}$), on peut soit ne rien mettre du tout, soit mettre une instruction suivi d'un nouveau bloc ». \smallskip Notre but va être d'expliquer quel genre de règles de ce genre on peut autoriser, comment elles se comportent, quels types de langages elles définissent, et comment on peut analyser (essentiellement, retrouver la manière dont on a construit) un texte produit par une application de telles règles. \thingy Dans un contexte informatique, l'usage des grammaires formelles se fait à un niveau différent de celui des chaînes de caractères où nous nous sommes placés dans les sections précédentes : cette fois, les lettres de notre alphabet ne seront généralement pas des caractères mais des \defin[token]{tokens} du langage dont on définit la grammaire, un « token » pouvant être une unité variable selon le langage, mais généralement soit un caractère spécial, soit un mot-clé du langage (\texttt{begin}, \texttt{end}, \texttt{for}, etc., constituent donc généralement un unique token dans l'analyse, et ne sont pas divisés en leurs lettres individuelles), soit encore une unité (« nombre », « identificateur », éventuellement « commentaire ») qui aura été découpée dans une première phase d'analyse, appelée « analyse lexicale ». Nous ne rentrerons pas ici dans ces considérations, et nous nous en tiendrons à l'approche mathématique où on continue à avoir affaire à des lettres d'un alphabet $\Sigma$ abstrait. \subsection{Définition, notations et premier exemple}\label{subsection-context-free-grammars} \thingy\label{definition-context-free-grammar} Une \index{hors contexte (grammaire)|see{grammaire hors contexte}}\defin{grammaire hors contexte} (on dit parfois aussi « sans contexte » ; en anglais, « context-free grammar » ou \index{CFG|see{grammaire hors contexte}}« CFG » ; ou encore grammaire de \textbf{type 2}) sur un alphabet $\Sigma$ est la donnée \begin{itemize} \item d'un second alphabet $N$, disjoint de $\Sigma$, appelé ensemble des \defin[nonterminal]{nonterminaux}, \item d'un élément $S \in N$ appelé \defin[axiome (d'une grammaire)]{axiome} ou \index{initial (symbole)|see{axiome}}\textbf{symbole initial} de la grammaire, \item d'un ensemble \emph{fini} $R \subseteq N \times (\Sigma\cup N)^*$ de couples $(T,\alpha)$ où $T$ est un nonterminal et $\alpha$ un mot sur l'alphabet $\Sigma\cup N$, les éléments $(T,\alpha)$ de $R$ étant appelés les \index{règle (d'une grammaire)|see{production}}\textbf{règles} ou \defin[production]{productions} de la grammaire. \end{itemize} \thingy Une grammaire hors contexte fait donc intervenir deux alphabets : l'alphabet $\Sigma$ sur lequel sera le langage (encore à définir), et l'alphabet $N$ (disjoint de $\Sigma$) qui intervient dans la définition de la grammaire. Pour fixer la terminologie, on appellera \defin{symbole} un élément de $\Sigma \cup N$, ces symboles étant dits \defin[terminal]{terminaux} lorsqu'ils appartiennent à $\Sigma$ (ou simplement « lettres »), et \textbf{nonterminaux} lorsqu'ils appartiennent à $N$. Un mot sur $\Sigma\cup N$ (c'est-à-dire, une suite finie de symboles) sera appelé \defin{pseudo-mot} (ou parfois une « forme »), tandis que le terme « \index{mot}mot » sans précision supplémentaire sera utilisé pour désigner un mot sur $\Sigma$ (autrement dit, un mot est un pseudo-mot ne comportant que des symboles terminaux). \smallskip Pour redire les choses autrement, les symboles terminaux sont les lettres des mots du langage qu'on cherche à définir ; les symboles nonterminaux sont des symboles qui servent uniquement à titre transitoire dans l'utilisation de la grammaire, et qui sont destinés à disparaître finalement. Un « pseudo-mot » est un mot pouvant contenir des nonterminaux, tandis qu'un « mot » sans précision du contraire ne contient que des terminaux. \medskip {\footnotesize Typographiquement, on aura tendance à utiliser des lettres minuscules pour désigner les symboles terminaux, et majuscules pour désigner les symboles nonterminaux ; et on aura tendance à utiliser des lettres grecques minuscules pour désigner les pseudo-mots. Il n'est malheureusement pas possible d'être complètement systématique.\par} \thingy Intuitivement, il faut comprendre la grammaire de la manière suivante. Les règles $(T,\alpha)$, où on rappelle que $T$ est un symbole nonterminal et $\alpha$ un pseudo-mot, doivent se comprendre comme « le symbole $T$ peut être remplacé par $\alpha$ » (et on notera $T \rightarrow \alpha$, cf. ci-dessous). On part de l'axiome $S$, et on peut effectuer librement des substitutions $T \rightarrow \alpha$ (consistant à remplacer un nonterminal $T$ par un pseudo-mot $\alpha$) autorisées par les règles : le langage défini par la grammaire est l'ensemble de tous les mots (ne comportant plus aucun nonterminal) qu'on peut obtenir de la sorte. Rendons maintenant cette définition précise : \thingy\label{derivations-and-contexts} Lorsque $G$ est une grammaire hors contexte comme en \ref{definition-context-free-grammar}, on note $T \mathrel{\rightarrow_G} \alpha$, ou simplement $T \rightarrow \alpha$ (lorsque $G$ est clair) pour signifier que $(T,\alpha)$ est une règle de $G$. \smallskip On définit une relation $\Rightarrow$ en posant $\gamma T \gamma' \Rightarrow \gamma\alpha\gamma'$ pour toute règle $(T,\alpha)$ et tous pseudo-mots $\gamma,\gamma'$ : autrement dit, formellement, on définit $\lambda\Rightarrow\xi$ lorsqu'il existe $\gamma,\gamma' \in (\Sigma\cup N)^*$ et $(T,\alpha) \in R$ (ensemble des règles de $G$) tels que $\lambda = \gamma T \gamma'$ et $\xi = \gamma\alpha\gamma'$. Concrètement, $\lambda\Rightarrow\xi$ signifie donc que $\xi$ est obtenu en remplaçant un nonterminal $T$ du pseudo-mot $\lambda$ par la partie droite d'une production $T \rightarrow \alpha$ de la grammaire $G$ : on dit encore que $\lambda \Rightarrow \xi$ est une \defin{dérivation immédiate} de $G$. On pourra dire que $T \rightarrow \alpha$ est la règle \textbf{appliquée} dans cette dérivation immédiate, que $T$ est le \textbf{symbole réécrit} (souvent souligné dans l'écriture de la dérivation immédiate), et que $\gamma$ et $\gamma'$ sont respectivement le \index{contexte}\textbf{contexte gauche} et le \textbf{contexte droit} de l'application de la règle\footnote{Pour être extrêmement rigoureux, une dérivation immédiate doit comporter la donnée du symbole réécrit (ou de façon équivalente, du contexte gauche et/ou droit), car elle ne peut pas se déduire de la seule donnée de $\lambda$ et $\xi$ (par exemple, dans $XX \Rightarrow XXX$, même si on sait que la règle appliquée était $X \rightarrow XX$, on ne peut pas deviner si c'est le $X$ de gauche ou de droite qui a été réécrit : il faut donc écrire $\underline{X}X \Rightarrow XXX$ ou bien $X\underline{X} \Rightarrow XXX$, en soulignant le symbole réécrit, pour distinguer les deux). De même, dans une dérivation, on devrait inclure la donnée du symbole réécrit à chaque étape.}. Bien sûr, si nécessaire, on précisera la grammaire appliquée en écrivant $\lambda \mathrel{\Rightarrow_G} \xi$ au lieu de simplement $\lambda\Rightarrow\xi$. \smallskip Une suite de pseudo-mots $(\lambda_0,\ldots,\lambda_n)$ telle que \[ \lambda_0 \Rightarrow \lambda_1 \Rightarrow \cdots \Rightarrow \lambda_n \] autrement dit $\lambda_{i-1} \Rightarrow \lambda_i$ pour chaque $1\leq i\leq n$, est appelée \defin{dérivation} de $\lambda_n$ à partir de $\lambda_0$ dans la grammaire $G$, et on note $\lambda_0 \mathrel{\Rightarrow^*} \lambda_n$ pour indiquer son existence (c'est-à-dire, si on préfère, que la relation $\Rightarrow^*$ est la clôture réflexive-transitive de $\Rightarrow$, i.e., la plus petite relation binaire réflexive et transitive contenant $\Rightarrow$). Remarquons que $n=0$ est permis, autrement dit $\lambda \mathrel{\Rightarrow^*} \lambda$ pour tout pseudo-mot $\lambda$. Bien sûr, si nécessaire, on précisera la grammaire appliquée en écrivant $\lambda \mathrel{\Rightarrow^*_G} \xi$ au lieu de simplement $\lambda \mathrel{\Rightarrow^*} \xi$. Concrètement, $\lambda \mathrel{\Rightarrow^*} \xi$ signifie donc qu'on peut passer de $\lambda$ à $\xi$ en effectuant une suite (finie !) de dérivations immédiates, c'est-à-dire en remplaçant à chaque étape un nonterminal $T$ par la partie droite $\alpha$ d'une règle $T \rightarrow \alpha$ de la grammaire $G$. \smallskip Il va de soi qu'un pseudo-mot qui ne comporte que des terminaux, i.e., qui est en fait un mot (sur $\Sigma$), ne peut pas être dérivé plus loin. Ceci justifie au moins en partie la terminologie de « terminal ». \thingy Le \defin[engendré (langage)]{langage engendré} $L(G)$ par une grammaire hors contexte $G$ est l'ensemble des mots $w$ (ne comportant plus de nonterminaux !) qui peuvent s'obtenir par dérivation à partir de l'axiome $S$ de $G$, autrement dit : \[ L(G) = \{w \in \Sigma^* : S \mathrel{\Rightarrow^*} w\} \] \smallskip Un langage qui peut s'écrire sous la forme $L(G)$ où $G$ est une grammaire hors contexte est appelé \index{hors contexte (langage)|see{algébrique}}\textbf{langage hors contexte} ou \defin[algébrique (langage)]{algébrique}. \smallskip Deux grammaires hors contexte $G$ et $G'$ sont dites \defin[faiblement équivalentes (grammaires)]{faiblement équivalentes} ou \index{langage-équivalentes (grammaires)|see{faiblement équivalentes}}\textbf{langage-équivalentes} lorsqu'elles engendrent le même langage ($L(G) = L(G')$). \thingy\label{basic-example-context-free-grammar} À titre d'exemple, considérons la grammaire sur l'alphabet $\Sigma = \{a,b\}$ donnée par \[ \begin{aligned} S &\rightarrow aSb\\ S &\rightarrow \varepsilon\\ \end{aligned} \] où implicitement $S$ est l'axiome et le seul nonterminal : autrement dit, $G$ est donnée par $N = \{S\}$, d'axiome $S$, et de règles de production $(S,aSb)$ et $(S,\varepsilon)$ (où $\varepsilon$, bien entendu, désigne le mot vide). Un pseudo-mot pour cette grammaire est un mot sur l'alphabet $\Sigma\cup N = \{a,b,S\}$, et une dérivation immédiate consiste \emph{soit} à ajouter un $a$ et un $b$ à gauche et à droite d'un $S$ dans un pseudo-mot, \emph{soit} à retirer un $S$. Dans ces conditions, il est clair qu'une dérivation partant de l'axiome $S$ est constituée d'un certain nombre d'applications de la première règle suivi d'au plus une application de la seconde (puisque le nombre d'occurrences de $S$ va alors tomber de $1$ à $0$ et on ne pourra plus dériver). Autrement dit, une telle dérivation prend la forme \[ S \Rightarrow aSb \Rightarrow aaSbb \Rightarrow \cdots \Rightarrow a^n S b^n \] ou éventuellement \[ S \Rightarrow aSb \Rightarrow aaSbb \Rightarrow \cdots \Rightarrow a^n S b^n \Rightarrow a^n b^n \] Le langage $L(G)$ défini par la grammaire est donc $\{a^n b^n : n\in\mathbb{N}\}$. \smallskip On a vu en \ref{example-of-pumping-lemma} que ce langage n'est pas rationnel : il existe donc des langages algébriques qui ne sont pas rationnels. En revanche, pour ce qui est de la réciproque, on verra dans la section suivante que tout langage rationnel est algébrique. \thingy\label{more-general-formal-grammars} Mentionnons brièvement qu'il existe des types de grammaires plus généraux que les grammaires hors contexte. Les \defin[grammaire contextuelle]{grammaires contextuelles} (ou grammaires de \textbf{type 1}) sont définies par des règles du type $\gamma T \gamma' \rightarrow \gamma \alpha \gamma'$ où $T$ est un nonterminal, et $\alpha,\gamma,\gamma'$ des pseudo-mots (= mots sur l'alphabet de tous les symboles), c'est-à-dire des règles qui autorisent la réécriture d'un symbole $T$ en $\alpha$ mais uniquement s'il est entouré d'un certain contexte ($\gamma$ à gauche, $\gamma'$ à droite). Les \defin[grammaire syntagmatique]{grammaires syntagmatiques générales} (ou grammaires de \textbf{type 0}) sont définies par des règles de réécriture $\lambda \rightarrow \mu$ où $\lambda,\mu$ sont des pseudo-mots quelconques, c'est-à-dire qu'elles permettent la réécriture de multiples symboles à la fois. Dans tous les cas, le langage défini par la grammaire est l'ensemble de tous les mots (sans nonterminaux) qui peuvent s'obtenir par application des règles de remplacement à partir de l'axiome. \smallskip Les grammaires de types 0 et 1, avec celles de type 2 c'est-à-dire hors contexte, et celles de type 3 (= régulières) qui seront définies en \ref{regular-grammar} ci-dessous, forment une hiérarchie appelée \defin[Chomsky (hiérarchie de)]{hiérarchie de Chomsky} : plus le numéro du type est élevé plus la grammaire est contrainte et plus la classe de langages définie est petite. \subsection{Langages rationnels et algébriques, stabilité} \begin{prop}\label{rational-languages-are-algebraic} Tout langage rationnel est algébrique. Mieux, on peut déduire algo\-ri\-thmi\-quement une grammaire hors contexte $G$ d'un εNFA $A$ de façon à avoir $L(G) = L(A)$. \end{prop} \begin{proof} Soit $A$ un εNFA : on sait qu'on peut supposer sans perte de généralité qu'il a un unique état initial $q_0$ (quitte à en créer un et à ajouter pour tout état $q$ anciennement initial une ε-transition $q_0 \to q$). Soit $Q$ son ensemble des états et $\delta \subseteq Q \times (\Sigma\cup\{\varepsilon\}) \times Q$ sa fonction de transition. On construit une grammaire hors contexte $G$ dont l'ensemble des nonterminaux est $Q$, dont l'axiome est $S := q_0$, et dont les règles sont les suivantes : (A) pour chaque transition $(q,t,q') \in \delta$ une règle $q \to tq'$ (on rappelle que $t \in \Sigma\cup\{\varepsilon\}$), et (B) pour chaque état final $q\in F$ une règle $q\to\varepsilon$. De même que dans l'exemple \ref{basic-example-context-free-grammar}, une dérivation partant de l'axiome va comporter un certain nombre d'applications de règles de type (A) suivies éventuellement d'une unique application d'une règle de type (B) (ce qui est nécessaire pour faire passer le nombre de nonterminaux de $1$ à $0$). Autrement dit, elle prend la forme $q_0 \Rightarrow t_1 q_1 \Rightarrow t_1 t_2 q_2 \Rightarrow \cdots \Rightarrow t_1 t_2\cdots t_n q_n$ où $(q_{i-1},t_i,q_i) \in \delta$ pour $1\leq i\leq n$, suivie éventuellement par $t_1\cdots t_n q_n \Rightarrow t_1\cdots t_n$ lorsque $q_n \in F$. Manifestement, les dérivations de la sorte (terminant sur un mot sur $\Sigma$) sont en bijection avec les chemins $q_0 \to \cdots \to q_n$ dans $A$ où $q_n \in F$, et le mot $t_1\cdots t_n$ dérivé est précisément le mot formé en concaténant les étiquettes du chemin. On a donc bien $L(G) = L(A)$. \end{proof} \thingy\label{regular-grammar} Une grammaire hors contexte telle que construite dans la preuve de \ref{rational-languages-are-algebraic} est dite \index{régulière (grammaire)|see{grammaire régulière}}\defin[grammaire régulière]{régulière} : autrement dit, il s'agit d'une grammaire ayant uniquement des règles de deux formes : (A) $Q \rightarrow tQ'$ où $t \in \Sigma\cup\{\varepsilon\}$, et (B) $Q \rightarrow \varepsilon$. Les langages définis par des grammaires régulières sont donc exactement les langages rationnels. {\footnotesize La définition des grammaires régulières varie un peu d'auteur en auteur, ces différences n'étant pas très importantes. Certains auteurs imposent $t \in \Sigma$ dans les règles de type (A), ce qui revient à imposer qu'on part d'un NFA sans ε-transition dans la construction ; et certains autorisent (ou autorisent uniquement) dans le type (B) les règles de la forme $Q \rightarrow x$ avec $x\in\Sigma$, ce qui impose des petits changements dans la construction ci-dessus. Dans tous les cas, il reste vrai que les langages définis par des grammaires régulières sont exactement les langages rationnels.\par} Les grammaires régulières sont également appelées grammaires de \textbf{type 3}. \begin{prop}\label{cfg-union-concatenation-and-star} Si $L_1,L_2$ sont des langages algébriques (sur un même alphabet $\Sigma$), alors la \index{union (de langages)}réunion $L_1 \cup L_2$ est algébrique ; de plus, une grammaire hors contexte l'engendrant se déduit algorithmiquement de grammaires hors contexte engendrant $L_1$ et $L_2$. Si $L_1,L_2$ sont des langages algébriques (sur un même alphabet $\Sigma$), alors la \index{concaténation (de langages)}concaténation $L_1 L_2$ est algébrique ; de plus, une grammaire hors contexte l'engendrant se déduit algorithmiquement de grammaires hors contexte engendrant $L_1$ et $L_2$. Si $L$ est un langage algébrique, alors \index{étoile de Kleene}l'étoile de Kleene $L^*$ est algébrique ; de plus, une grammaire hors contexte l'engendrant se déduit algorithmiquement d'une grammaire hors contexte engendrant $L$. \end{prop} \begin{proof} Pour la réunion : supposons que $G_1$ et $G_2$ engendrent $L_1$ et $L_2$ respectivement, et ont des ensembles de nonterminaux $N_1$ et $N_2$ disjoints, avec axiomes $S_1$ et $S_2$ respectivement. On construit une grammaire $G$ dont l'ensemble des nonterminaux est $N_1 \cup N_2 \cup \{S\}$ où $S$ est un nouveau nonterminal, choisi comme axiome, et les règles de production de $G$ sont celles de $G_1$, celles de $G_2$, et les deux règles supplémentaires $S \rightarrow S_1$ et $S \rightarrow S_2$. Il est évident qu'une dérivation de $G$ partant de $S$ est soit de la forme $S \Rightarrow S_1$ suivie d'une dérivation de $G_1$, soit de la forme $S \Rightarrow S_2$ suivie d'une dérivation de $G_2$ : ainsi, $L(G) = L_1 \cup L_2$. Pour la concaténation : la construction est presque exactement la même, mais on prend pour règle supplémentaire $S \rightarrow S_1 S_2$. Pour l'étoile : si $G$ engendre $L$ et a pour ensemble de nonterminaux $N$ et pour axiome $S$, on défit une nouvelle grammaire $G'$ dont l'ensemble des nonterminaux est $N' = N \cup \{S'\}$ où $S'$ est un nouveau nonterminal, choisi comme axiome, et les règles de production de $G'$ sont celles de $G$ et les deux règles supplémentaires $S' \rightarrow SS'$ et $S' \rightarrow \varepsilon$. Il est facile de se convaincre qu'une dérivation de $G'$ partant de $S'$ et utilisant $n$ fois la règle $S' \rightarrow SS'$ se ramène à $n$ dérivations de $G$ partant de $S$, et seule la règle $S' \rightarrow \varepsilon$ permet de faire disparaître le symbole $S'$. (Les détails sont omis et peuvent être rendus plus clairs en utilisant la notion d'arbre de dérivation.) \end{proof} \thingy Ceci fournit une nouvelle démonstration (partant d'une expression rationnelle plutôt que d'un automate) de \ref{rational-languages-are-algebraic}, tant il est évident que les langages $\varnothing$, $\{\varepsilon\}$ et $\{x\}$ (pour $x\in\Sigma$) sont algébriques. À cause de cette construction, on se permettra parfois, dans l'énoncé des règles d'une grammaire, d'écrire $T \rightarrow \alpha_1 | \cdots | \alpha_n$ pour réunir en une seule ligne plusieurs règles $T \rightarrow \alpha_1$ jusqu'à $T \rightarrow \alpha_n$. Par exemple, la grammaire présentée en \ref{basic-example-context-free-grammar} peut s'écrire $S \rightarrow aSb | \varepsilon$. Il s'agit d'un simple raccourci d'écriture (comparer avec une convention semblable faite pour les automates en \ref{graphical-representation-of-dfa}). {\footnotesize On pourrait même se permettre l'abus de notation consistant à écrire $T \rightarrow U^*$ pour $T \rightarrow UT|\varepsilon$ (c'est-à-dire $T \rightarrow UT$ et $T \rightarrow \varepsilon$), mais il vaut mieux éviter car cela pourrait aussi bien signifier $T \rightarrow TU|\varepsilon$, qui engendre le même langage (i.e., elle est faiblement équivalente à la précédente) mais dont l'analyse peut être plus problématique. De façon encore plus générale, on pourrait imaginer d'autoriser des règles de la forme $T \rightarrow r$ où $T$ est un nonterminal et $r$ une expression rationnelle quelconque sur l'alphabet $\Sigma \cup N$ : de telles règles pourraient se ramener aux règles qu'on a autorisées, quitte à introduire de nouveaux nonterminaux pour les expressions intermédiaires (par exemple, $T \rightarrow UV^*$ se transformerait par l'introduction d'un nouveau nonterminal $V'$ en $T \rightarrow UV'$ et $V' \rightarrow VV'|\varepsilon$). Nous éviterons ces extensions aux grammaires hors contexte pour ne pas introduire de confusion. \par} \thingy\label{words-deriving-from-another-nonterminal} Il peut être utile, pour raisonner sur les langages algébriques, d'introduire, lorsque $G$ est une grammaire hors contexte et $T$ un nonterminal quelconque, le langage $L(G,T) := \{w \in \Sigma^* : T \mathrel{\Rightarrow^*_G} w\}$ des mots qui dérivent de $T$, c'est-à-dire le langage engendré par la grammaire $G'$ identique à $G$ à ceci près que son axiome est $T$. {\footnotesize On a alors $L(G) = L(G,S)$ où $S$ est l'axiome de $G$, et chaque règle de production $T \rightarrow \alpha_1 | \cdots | \alpha_n$ se traduit par une équation portant sur $L(G,T)$, par exemple $T \rightarrow aUbV | cW$ implique $L(G,T) = a\, L(G,U)\, b\, L(G,V) \; \cup \; c L(G,W)$. De cette manière, une grammaire hors contexte donne lieu à un système d'équations portant sur des langages (par exemple, la grammaire de \ref{basic-example-context-free-grammar} donne lieu à l'équation $L(G) = (a\,L(G)\,b) \cup \{\varepsilon\}$ : on peut montrer que la définition des grammaires hors contexte revient à considérer la plus petite (au sens de l'inclusion) solution de ce système d'équations. \par} \bigbreak \thingy À la différence des langages rationnels, il \emph{n'est pas vrai} en général que l'intersection de deux langages algébriques soit algébrique : un contre-exemple est fourni par les deux langages $\{a^i b^i c^j : i,j\in\mathbb{N}\}$ et $\{a^i b^j c^j : i,j\in\mathbb{N}\}$ (chacun des deux est algébrique : par exemple, le premier est la concaténation du langage $\{a^i b^i : i\in\mathbb{N}\}$ dont on a vu en \ref{basic-example-context-free-grammar} qu'il était algébrique, et du langage $\{c\}^*$, qui est algébrique car rationnel) ; leur intersection $\{a^i b^i c^i : i\in\mathbb{N}\}$ n'est pas algébrique, comme on le démontrera en \ref{example-of-pumping-lemma-for-algebraic-languages}. En conséquence, il n'est pas non plus vrai en général que le complémentaire d'un langage algébrique soit algébrique. \smallskip En revanche, le fait suivant, que nous admettons sans démonstration, peut s'avérer utile : \begin{prop}\label{intersection-of-algebraic-and-rational} L'intersection d'un langage \emph{algébrique} et d'un langage \emph{rationnel} est algébrique. \end{prop} \subsection{Autres exemples de grammaires hors contexte} \thingy\label{example-lr-non-ll-grammar} Sur l'alphabet $\Sigma = \{a,b\}$, considérons la grammaire (d'axiome $S$) \[ \begin{aligned} S &\rightarrow AT\\ A &\rightarrow aA \;|\; \varepsilon\\ T &\rightarrow aTb \;|\; \varepsilon\\ \end{aligned} \] Il est clair que le langage $L(G,A)$ des mots qui dérivent de $A$ est simplement $\{a\}^* = \{a^i : i\in\mathbb{N}\}$ ; et le langage $L(G,T)$ est $\{a^j b^j : j\in\mathbb{N}\}$ comme en \ref{basic-example-context-free-grammar}. Le langage $L(G) = L(G,A)\, L(G,T)$ est donc $\{a^i b^j : i \geq j\}$, l'ensemble des mots de la forme $a^i b^j$ pour lesquels $i \geq j$. On peut aussi considérer la grammaire $G'$ définie par \[ \begin{aligned} S &\rightarrow T \;|\; aS\\ T &\rightarrow aTb \;|\; \varepsilon\\ \end{aligned} \] Il n'est pas difficile de se convaincre qu'elle engendre le même langage $L(G)$ que la précédente (elle est donc faiblement équivalente à $G$). {\footnotesize (Ce langage est intéressant sur le plan théorique, car bien qu'il soit algébrique, et ici défini par une grammaire $G'$ inambiguë (cf. \ref{ambiguous-grammar}), il ne peut pas être analysé par un analyseur LL (cf. \ref{handwaving-on-ll-and-lr}).)\par} \thingy\label{example-unambiguous-but-not-deterministic-grammar} Sur l'alphabet $\Sigma = \{a,b\}$, considérons la grammaire (d'axiome $S$) \[ \begin{aligned} S &\rightarrow U \;|\; V \;|\; \varepsilon\\ U &\rightarrow aUb \;|\; ab\\ V &\rightarrow aVbb \;|\; abb\\ \end{aligned} \] Il est clair que le langage $L(G,U)$ des mots qui dérivent de $U$ est $\{a^i b^i : i\geq 1\}$ comme en \ref{basic-example-context-free-grammar}, et de façon analogue, le langage $L(G,V)$ des mots qui dérivent de $V$ est $\{a^i b^{2i} : i\geq 1\}$. Le langage $L(G) = L(G,U) \cup L(G,V)$ est donc l'ensemble des mots de la forme $a^i b^j$ où $i\geq 1$ et $j=i$ \emph{ou bien} $j=2i$. {\footnotesize (Ce langage est intéressant sur le plan théorique, car bien qu'il soit algébrique et défini par une grammaire inambiguë (cf. \ref{ambiguous-grammar}), il n'est pas analysable par un automate à pile déterministe (cf. \ref{handwaving-on-stack-automata}).)\par} \thingy\label{example-for-intrinsic-ambiguity} Sur l'alphabet $\Sigma = \{a,b,c\}$, considérons la grammaire (d'axiome $S$) \[ \begin{aligned} S &\rightarrow UC \;|\; AV\\ A &\rightarrow aA \;|\; \varepsilon\\ C &\rightarrow cC \;|\; \varepsilon\\ U &\rightarrow aUb \;|\; \varepsilon\\ V &\rightarrow bVc \;|\; \varepsilon\\ \end{aligned} \] Il est clair que le langage $L(G,A)$ des mots qui dérivent de $A$ est simplement $\{a\}^* = \{a^i : i\in\mathbb{N}\}$ et que le langage $L(G,C)$ des mots qui dérivent de $C$ est simplement $\{c\}^* = \{c^j : j\in\mathbb{N}\}$ ; le langage $L(G,U)$ est $\{a^i b^i : i\in\mathbb{N}\}$ comme en \ref{basic-example-context-free-grammar}, et de même $L(G,V) = \{b^j c^j : j\in\mathbb{N}\}$. Finalement, $L(G) = L(G,U)\,L(G,C) \;\cup\; L(G,A)\,L(G,V)$ montre que $L(G) = \{a^i b^i c^j : i,j\in\mathbb{N}\} \cup \{a^i b^j c^j : i,j\in\mathbb{N}\}$ est le langage des mots de la forme $a^i b^r c^j$ où $r=i$ \emph{ou} $r=j$. {\footnotesize (Ce langage est intéressant sur le plan théorique, car il est algébrique mais « intrinsèquement ambigu » (cf. \ref{intrinsic-ambiguity}).)\par} \thingy\label{example-well-parenthesized-expressions} Sur l'alphabet $\Sigma = \{a,b\}$, considérons la grammaire (d'axiome $S$) \[ S\; \rightarrow\; aSbS \;|\; \varepsilon \] ou, ce qui revient au même \[ \begin{aligned} S &\rightarrow TS \;|\; \varepsilon\\ T &\rightarrow aSb\\ \end{aligned} \] (la première ligne revient par ailleurs à $S \rightarrow T^*$). On a alors $L(G) = L(G,T)^*$ où $L(G,T) = a\, L(G)\, b$ désigne le langage des mots qui peuvent être dérivés à partir de $T$. Ce langage $L(G)$ s'appelle langage des \defin[bien-parenthésée (expression)]{expressions bien-parenthésées} où $a$ représente une parenthèse ouvrante et $b$ une parenthèse fermante (et $L(G,T)$ est le langage des blocs parenthésés : autrement dit, une expression bien-parenthésée est une suite de blocs parenthésés, et un bloc parenthésé est une expression bien-parenthésée entourée par une parenthèse ouvrante et une parenthèse fermante — c'est ce que traduit la grammaire). Soit dit en passant, ce langage algébrique des expressions bien-parenthésées n'est pas rationnel : la façon la plus simple de s'en convaincre est de remarquer que s'il l'était, son intersection avec le langage $\{a^i b^j : i,j\in\mathbb{N}\}$ dénoté par l'expression rationnelle $a{*}b{*}$ le serait aussi (par \ref{dfa-union-and-intersection}), or cette intersection est précisément le langage $\{a^n b^n : n\in\mathbb{N}\}$ dont on a montré en \ref{example-of-pumping-lemma} qu'il n'était pas algébrique. \thingy\label{example-grammar-equal-a-and-b} Sur l'alphabet $\Sigma = \{a,b\}$, montrons que la grammaire $G$ (d'axiome $S$) donnée par \[ S\; \rightarrow\; aSbS \;|\; bSaS \;|\; \varepsilon \] (c'est-à-dire $N = \{S\}$ où $S$ est l'axiome, et pour règles $S \rightarrow aSbS$ et $S \rightarrow bSaS$ et $S \rightarrow \varepsilon$) engendre le langage $L$ formé des mots ayant un nombre total de $a$ égal au nombre total de $b$, i.e., $L := \{w \in\Sigma^* : |w|_a = |w|_b\}$ où $|w|_x$ désigne le nombre total d'occurrences de la lettre $x$ dans le mot $w$ (cf. \ref{number-of-occurrences-of-letter}). \begin{proof} Dans un sens il est évident que tout pseudo-mot (et en particulier, tout mot sur $\Sigma$) obtenu en dérivant $S$ a un nombre de $a$ égal au nombre de $b$, puisque cette propriété est conservée par toute dérivation immédiate. Autrement dit, $L(G) \subseteq L$. Pour ce qui est de la réciproque, on va montrer par récurrence sur $|w|$ que tout mot $w \in \Sigma^*$ ayant autant de $a$ que de $b$ est dans $L(G)$. Pour $|w|=0$ c'est trivial. Sinon, on peut supposer sans perte de généralité que le mot $w$ considéré commence par $a$, soit $w = aw'$ où $w'$ vérifie $|w'|_b - |w'|_a = 1$. Considérons maintenant la fonction $h$ qui à un entier $k$ entre $0$ et $|w'|$ associe le nombre de $b$ moins le nombre de $a$ dans le préfixe de longueur $k$ de $w'$ (i.e., parmi les $k$ premières lettres de $w'$) : cette fonction prend les valeurs $h(0) = 0$ et $h(|w'|) = 1$, et elle varie de $\pm 1$ à chaque fois (i.e., $h(i) = h(i-1) \pm 1$ selon que la $i$-ième lettre de $w'$ est $b$ ou $a$). Soit $k_0$ le plus grand entier tel que $h(k_0) = 0$ : cet entier est bien défini car $h(0)=0$. On a forcément $h(k_0+1) = 1$ car l'autre possibilité, $h(k_0+1) = -1$ impliquerait que $h$ devrait repasser par la valeur $0$ pour atteindre la valeur finale $h(|w'|) = 1$, ce qui contredirait la maximalité de $k_0$. Bref, si $u$ est le préfixe de $w'$ de longueur $k_0$, on a $|u|_b - |u|_a = h(k_0) = 0$ et la lettre suivante de $w'$ est un $b$, si bien que $w' = ubv$ et finalement $w = aubv$ où $u$ et donc $v$ ont autant que $a$ que de $b$, i.e., appartiennent à $L$, et par récurrence (ils sont de longueur strictement plus courte que $w$) appartiennent à $L(G)$. On peut donc dériver $u$ et $v$ de $S$, donc $w$ de $aSbS$, et comme $aSbS$ se dérive immédiatement de $S$, on a bien $w \in L(G)$, ce qui conclut la récurrence. \end{proof} Un raisonnement analogue montre que la grammaire $G'$ donnée par \[ \begin{aligned} S &\rightarrow aUbS \;|\; bVaS \;|\; \varepsilon\\ U &\rightarrow aUbU\\ V &\rightarrow bVaV\\ \end{aligned} \] engendre le même langage $L = \{w \in\Sigma^* : |w|_a = |w|_b\}$ que ci-dessus (elle est donc faiblement équivalente à $G$) : l'idée est que le langage $L(G,U)$ des mots qui dérivent de $U$ est l'ensemble des expressions bien-parenthésées où $a$ est la parenthèse ouvrante et $b$ la fermante (avec les notations de la démonstration ci-dessus, ce sont les mots pour lesquels la fonction $h$, partant de $0$, revient à $0$, et reste toujours positive ou nulle), tandis que $L(G,V)$ est l'ensemble des expressions bien-parenthésées où $b$ est la parenthèse ouvrante et $a$ la fermante (la fonction $h$ reste toujours négative ou nulle), et tout mot de $L$ peut s'écrire comme concaténation de tels mots (en divisant selon le signe de $h$). Une différence entre $G$ et $G'$ est que la grammaire $G$ est ambiguë (terme qui sera défini en \ref{ambiguous-grammar}) tandis que $G'$ ne l'est pas. \subsection{Arbres d'analyse, dérivations gauche et droite} \thingy Soit $G$ une grammaire hors contexte sur un alphabet $\Sigma$ et $N$ l'ensemble de ses nonterminaux. Un \defin{arbre d'analyse} (ou \index{dérivation (arbre de)|see{arbre d'analyse}}\index{arbre de dérivation|see{arbre d'analyse}}\textbf{arbre de dérivation} ; en anglais \textbf{parse tree}) \textbf{incomplet} pour $G$ est un arbre (fini, enraciné et ordonné\footnote{C'est-à-dire que l'ensemble des fils d'un nœud quelconque de l'arbre est muni d'un ordre total, ou, ce qui revient au même, qu'ils sont numérotés (disons de la gauche vers la droite).}) dont les nœuds sont étiquetés par des éléments de $\Sigma \cup N \cup \{\varepsilon\}$, vérifiant les propriétés suivantes : \begin{itemize} \item la racine de l'arbre est étiquetée par l'axiome $S$ de $G$ ; \item si un nœud de l'arbre n'est pas une feuille (i.e., s'il a des fils) et si on appelle $T$ son étiquette, alors \begin{itemize} \item soit ce nœud a un unique fils étiqueté $\varepsilon$ et il existe une règle $T \rightarrow \varepsilon$ dans $G$, \item soit ce nœud a des fils étiquetés par des éléments $x_1\cdots x_n$ (où $n\geq 1$) de $\Sigma \cup N$ et il existe une règle $T \rightarrow x_1\cdots x_n$ dans $G$, \end{itemize} (dans ces deux sous-cas, il résulte de l'existence d'une règle $T\rightarrow\cdots$ que $T$ est un nonterminal : seules les feuilles peuvent être étiquetées par un terminal ou $\varepsilon$). \end{itemize} \smallskip On dit de plus que l'arbre est \textbf{complet}, ou simplement qu'il s'agit d'un arbre d'analyse, lorsqu'il vérifie la propriété supplémentaire suivante : \begin{itemize} \item toute feuille de l'arbre est étiquetée soit par un terminal (= élément de $\Sigma$) soit par $\varepsilon$. \end{itemize} (Les feuilles étiquetées $\varepsilon$ servent uniquement à marquer la complétude de l'arbre : certains auteurs procèdent différemment ou les omettent.) \thingy Si $T$ est un arbre d'analyse incomplet, et $\alpha$ le pseudo-mot obtenu en lisant les étiquettes des \emph{feuilles} de $T$ en profondeur ordonnée (c'est-à-dire en commençant par toutes les feuilles qui descendent du premier fils de la racine elles-mêmes dans le même ordre, puis toutes celles qui descendent du second fils, et ainsi de suite) et en ignorant tous les $\varepsilon$, alors on dit que $T$ est un arbre d'analyse \emph{de} $\alpha$, ou que $\alpha$ est le pseudo-mot analysé par $T$. La définition d'un arbre d'analyse complet signifie exactement qu'il est l'arbre d'analyse d'un \emph{mot} (c'est-à-dire, d'un mot sur $\Sigma$). \thingy\label{example-of-parse-tree} À titre d'exemple, considérons la grammaire (considérée en \ref{example-well-parenthesized-expressions}) \[ \begin{aligned} S &\rightarrow TS \;|\; \varepsilon\\ T &\rightarrow aSb\\ \end{aligned} \] L'arbre d'analyse suivant est un arbre d'analyse du mot $aabbab$ (et on verra en \ref{inambiguity-of-well-parenthesized-expressions} que c'est le seul possible) : \begin{center} \tikzstyle{automaton}=[scale=0.5] %%% begin parsetree1 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (e3) at (99bp,18bp) [draw,draw=none] {$\varepsilon$}; \node (S3) at (549bp,234bp) [draw,draw=none] {$S$}; \node (S2) at (225bp,234bp) [draw,draw=none] {$S$}; \node (S1) at (441bp,306bp) [draw,draw=none] {$S$}; \node (S0) at (369bp,378bp) [draw,draw=none] {$S$}; \node (T2) at (117bp,162bp) [draw,draw=none] {$T$}; \node (S6) at (99bp,90bp) [draw,draw=none] {$S$}; \node (T0) at (261bp,306bp) [draw,draw=none] {$T$}; \node (T1) at (441bp,234bp) [draw,draw=none] {$T$}; \node (a1) at (369bp,162bp) [draw,draw=none] {$a$}; \node (a0) at (153bp,234bp) [draw,draw=none] {$a$}; \coordinate (spacer) at (297bp,162bp); \node (a2) at (27bp,90bp) [draw,draw=none] {$a$}; \node (b0) at (297bp,234bp) [draw,draw=none] {$b$}; \node (S5) at (441bp,162bp) [draw,draw=none] {$S$}; \node (b2) at (171bp,90bp) [draw,draw=none] {$b$}; \node (S4) at (225bp,162bp) [draw,draw=none] {$S$}; \node (e1) at (243bp,90bp) [draw,draw=none] {$\varepsilon$}; \node (e0) at (585bp,162bp) [draw,draw=none] {$\varepsilon$}; \node (e2) at (441bp,90bp) [draw,draw=none] {$\varepsilon$}; \node (b1) at (513bp,162bp) [draw,draw=none] {$b$}; \draw [] (S1) ..controls (484.16bp,277.03bp) and (505.72bp,263.05bp) .. (S3); \draw [] (S0) ..controls (397.96bp,348.85bp) and (412.29bp,334.92bp) .. (S1); \draw [] (S5) ..controls (441bp,132.85bp) and (441bp,118.92bp) .. (e2); \draw [] (S2) ..controls (225bp,204.85bp) and (225bp,190.92bp) .. (S4); \draw [] (T2) ..controls (109.76bp,132.85bp) and (106.18bp,118.92bp) .. (S6); \draw [] (T1) ..controls (469.96bp,204.85bp) and (484.29bp,190.92bp) .. (b1); \draw [] (T0) ..controls (217.84bp,277.03bp) and (196.28bp,263.05bp) .. (a0); \draw [] (T2) ..controls (80.802bp,132.85bp) and (62.893bp,118.92bp) .. (a2); \draw [] (T2) ..controls (138.72bp,132.85bp) and (149.46bp,118.92bp) .. (b2); \draw [] (S1) ..controls (441bp,276.85bp) and (441bp,262.92bp) .. (T1); \draw [] (S4) ..controls (232.24bp,132.85bp) and (235.82bp,118.92bp) .. (e1); \draw [] (S3) ..controls (563.48bp,204.85bp) and (570.64bp,190.92bp) .. (e0); \draw [] (S0) ..controls (325.84bp,349.03bp) and (304.28bp,335.05bp) .. (T0); \draw [] (S6) ..controls (99bp,60.846bp) and (99bp,46.917bp) .. (e3); \draw [] (T0) ..controls (275.48bp,276.85bp) and (282.64bp,262.92bp) .. (b0); \draw [] (T0) ..controls (246.52bp,276.85bp) and (239.36bp,262.92bp) .. (S2); \draw [] (T1) ..controls (412.04bp,204.85bp) and (397.71bp,190.92bp) .. (a1); \draw [] (T1) ..controls (441bp,204.85bp) and (441bp,190.92bp) .. (S5); \draw [] (S2) ..controls (181.84bp,205.03bp) and (160.28bp,191.05bp) .. (T2); % \end{tikzpicture} %%% end parsetree1 %%% \end{center} On obtient des exemples d'arbres d'analyse incomplet en effaçant arbitrairement tous les descendants d'un ou plusieurs nœuds de cet arbre. \thingy À toute dérivation à partir de l'axiome $S$ dans une grammaire hors contexte $G$ on peut associer un arbre d'analyse incomplet : ce dernier est construit en partant de la racine et, à chaque fois qu'un symbole est réécrit (dans la dérivation), en faisant pousser des fils à la feuille correspondante de l'arbre (qui cesse donc d'être une feuille) pour indiquer la règle appliquée. De façon plus formelle : si $S =: \lambda_0 \Rightarrow \lambda_1 \Rightarrow \cdots \Rightarrow \lambda_n$ est une dérivation à partir de l'axiome $S$ dans une grammaire hors contexte $G$, on va lui associer, par récurrence sur le nombre d'étapes $n$ de la dérivation, un arbre d'analyse incomplet du pseudo-mot $\lambda_n$. Si $n=0$, l'arbre $\mathscr{T}_0$ en question est simplement l'arbre trivial (ayant pour seul nœud la racine $S$). Sinon, on part de l'arbre $\mathscr{T}_{n-1}$ (qu'on a défini par récurrence) pour la dérivation $\lambda_0 \Rightarrow \cdots \Rightarrow \lambda_{n-1}$ : supposons que la dernière dérivation immédiate $\lambda_{n-1} \Rightarrow \lambda_n$ réécrive le symbole nonterminal $T$ par application de la règle $T \rightarrow \alpha$ avec pour contextes gauche et droit $\gamma,\gamma'$ (cf. \ref{derivations-and-contexts}), si bien que $\lambda_{n-1} = \gamma T \gamma'$ et $\lambda_n = \gamma \alpha \gamma'$ ; le symbole $T$ réécrit correspond à un certain nœud de l'arbre $\mathscr{T}_{n-1}$, à savoir la feuille, étiquetée $T$, telle qu'on lise $\gamma$ à sa gauche et $\gamma'$ à sa droite en suivant les feuilles dans l'ordre de profondeur ; on ajoute alors au nœud en question des fils correspondant à la règle $T \to \alpha$, c'est-à-dire soit un unique fils étiqueté $\varepsilon$ si $\alpha = \varepsilon$, soit $k$ fils étiquetés $x_1,\ldots,x_k$ si $\alpha = x_1\cdots x_k$ avec $k\geq 1$. Notons que l'arbre obtenu est complet exactement lorsque la dérivation aboutit à un mot (sur $\Sigma$). Notons aussi que le nombre $n$ d'étapes dans la dérivation est égal au nombre de nœuds de l'arbre qui \emph{ne sont pas} des feuilles. Deux dérivations (forcément du même mot ou pseudo-mot) auxquelles sont associées le même arbre d'analyse sont dites \defin[équivalentes (dérivations)]{équivalentes}. \thingy\label{example-of-derivations} À titre d'exemple, l'arbre illustré en \ref{example-of-parse-tree} est associé à la dérivation \[ \begin{aligned} \underline{S} &\Rightarrow \underline{T}S \Rightarrow a\underline{S}bS \Rightarrow a\underline{T}SbS \Rightarrow aa\underline{S}bSbS \Rightarrow aab\underline{S}bS \Rightarrow aabb\underline{S}\\ &\Rightarrow aabb\underline{T}S \Rightarrow aabba\underline{S}bS \Rightarrow aabbab\underline{S} \Rightarrow aabbab\\ \end{aligned} \] (on a souligné à chaque fois le symbole réécrit), mais aussi à la dérivation \[ \begin{aligned} \underline{S} &\Rightarrow T\underline{S} \Rightarrow TT\underline{S} \Rightarrow T\underline{T} \Rightarrow Ta\underline{S}b \Rightarrow \underline{T}ab\\ &\Rightarrow a\underline{S}bab \Rightarrow aT\underline{S}bab \Rightarrow a\underline{T}bab \Rightarrow aa\underline{S}bbab \Rightarrow aabbab\\ \end{aligned} \] Ces deux dérivations sont donc équivalentes. Elles ont toutes les deux $10$ étapes puisque l'arbre considéré a $10$ nœuds qui ne sont pas des feuilles. \thingy On appelle \defin{dérivation gauche} une dérivation (pour une grammaire hors contexte donnée) dans laquelle le symbole réécrit est toujours \emph{le nonterminal le plus à gauche} du pseudo-mot courant : autrement dit, une dérivation gauche est une dérivation telle que le contexte gauche de chaque dérivation immédiate la constituant ne comporte que des symboles terminaux (i.e., appartient à $\Sigma^*$). Symétriquement, on appelle \textbf{dérivation droite} une dérivation dans laquelle le symbole réécrit est toujours \emph{le nonterminal le plus à droite}, c'est-à-dire que le contexte droit de chaque dérivation immédiate la constituant ne comporte que des symboles terminaux. \smallskip À titre d'exemple, les deux dérivations données en \ref{example-of-derivations} sont respectivement une dérivation gauche et une dérivation droite. \smallskip À chaque arbre d'analyse est associée une et une seule dérivation gauche : on l'obtient de façon évidente en réécrivant à chaque étape le symbole nonterminal le plus à gauche en suivant la règle indiquée par l'arbre d'analyse sous le nœud correspondant ; cela revient à parcourir l'arbre d'analyse en profondeur de gauche à droite, et à réécrire le symbole correspondant à chaque nœud que l'on rencontre qui n'est pas une feuille. De même, à chaque arbre d'analyse est associée une et une seule dérivation droite. \subsection{Ambiguïté} \thingy\label{ambiguous-grammar} On dit qu'une grammaire hors contexte est \defin[ambiguë (grammaire)]{ambiguë} lorsqu'il existe un mot (i.e., un mot sur l'alphabet $\Sigma$ des terminaux) qui admet deux arbres d'analyse \emph{différents}. Dans le cas contraire, elle est dite \defin[inambiguë (grammaire)]{inambiguë} : autrement dit, une grammaire inambiguë est une grammaire $G$ pour laquelle tout $w \in L(G)$ a un unique arbre d'analyse ; il revient au même de dire que tout mot de $L(G)$ a une unique dérivation droite, ou encore que tout mot de $L(G)$ a une unique dérivation gauche. \smallskip Les grammaires des langages informatiques réels sont évidemment (presque ?) toujours inambiguës : on souhaite qu'un programme (c'est-à-dire, dans la terminologie mathématique, un mot du langage) admette une unique interprétation, autrement dit, un unique arbre d'analyse. \thingy\label{trivial-example-ambiguity} À titre d'exemple, la grammaire \[ S\; \rightarrow\; SS \;|\; a \] sur l'alphabet $\{a\}$ est ambiguë. En effet, le mot $aaa$ admet l'arbre d'analyse \begin{center} \tikzstyle{automaton}=[scale=0.5] %%% begin parsetree2 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (S3) at (99bp,90bp) [draw,draw=none] {$S$}; \node (S2) at (99bp,162bp) [draw,draw=none] {$S$}; \node (S1) at (27bp,162bp) [draw,draw=none] {$S$}; \node (S0) at (63bp,234bp) [draw,draw=none] {$S$}; \node (S4) at (171bp,90bp) [draw,draw=none] {$S$}; \node (a1) at (99bp,18bp) [draw,draw=none] {$a$}; \node (a0) at (27bp,90bp) [draw,draw=none] {$a$}; \node (a2) at (171bp,18bp) [draw,draw=none] {$a$}; \draw [] (S0) ..controls (48.521bp,204.85bp) and (41.357bp,190.92bp) .. (S1); \draw [] (S1) ..controls (27bp,132.85bp) and (27bp,118.92bp) .. (a0); \draw [] (S2) ..controls (127.96bp,132.85bp) and (142.29bp,118.92bp) .. (S4); \draw [] (S2) ..controls (99bp,132.85bp) and (99bp,118.92bp) .. (S3); \draw [] (S0) ..controls (77.479bp,204.85bp) and (84.643bp,190.92bp) .. (S2); \draw [] (S4) ..controls (171bp,60.846bp) and (171bp,46.917bp) .. (a2); \draw [] (S3) ..controls (99bp,60.846bp) and (99bp,46.917bp) .. (a1); % \end{tikzpicture} %%% end parsetree2 %%% \end{center} mais aussi \begin{center} \tikzstyle{automaton}=[scale=0.5] %%% begin parsetree2b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (S3) at (27bp,90bp) [draw,draw=none] {$S$}; \node (S2) at (171bp,162bp) [draw,draw=none] {$S$}; \node (S1) at (99bp,162bp) [draw,draw=none] {$S$}; \node (S0) at (135bp,234bp) [draw,draw=none] {$S$}; \node (S4) at (99bp,90bp) [draw,draw=none] {$S$}; \node (a1) at (99bp,18bp) [draw,draw=none] {$a$}; \node (a0) at (27bp,18bp) [draw,draw=none] {$a$}; \node (a2) at (171bp,90bp) [draw,draw=none] {$a$}; \draw [] (S1) ..controls (70.042bp,132.85bp) and (55.714bp,118.92bp) .. (S3); \draw [] (S0) ..controls (120.52bp,204.85bp) and (113.36bp,190.92bp) .. (S1); \draw [] (S0) ..controls (149.48bp,204.85bp) and (156.64bp,190.92bp) .. (S2); \draw [] (S1) ..controls (99bp,132.85bp) and (99bp,118.92bp) .. (S4); \draw [] (S3) ..controls (27bp,60.846bp) and (27bp,46.917bp) .. (a0); \draw [] (S2) ..controls (171bp,132.85bp) and (171bp,118.92bp) .. (a2); \draw [] (S4) ..controls (99bp,60.846bp) and (99bp,46.917bp) .. (a1); % \end{tikzpicture} %%% end parsetree2b %%% \end{center} Cette grammaire est donc ambiguë. Remarquons que le langage qu'elle engendre est $\{a\}^+ = \{a^n : n\geq 1\}$ (car il est évident que tout mot engendré par la grammaire est dans $\{a\}^+$, et réciproquement il est facile de fabriquer une dérivation de $a^n$ pour tout $n\geq 1$, par exemple $\underline{S} \Rightarrow S\underline{S} \Rightarrow \cdots \Rightarrow S^{n-1} S \Rightarrow \cdots a^n$). Le \emph{même} langage $\{a\}^+ = \{a^n : n\geq 1\}$ peut aussi être engendré par la grammaire \[ S\; \rightarrow\; aS \;|\; a \] (faiblement équivalente à la précédente, donc) qui, elle, \emph{n'est pas} ambiguë : en effet, la seule manière de dériver $a^n$ consiste à appliquer $n-1$ fois la règle $S \rightarrow aS$ et finalement une fois la règle $S \rightarrow a$ (il y a donc une unique dérivation du mot, et \textit{a fortiori} un unique arbre d'analyse). \thingy\label{inambiguity-of-well-parenthesized-expressions} La grammaire $G$ des expressions bien-parenthésées \[ \begin{aligned} S &\rightarrow TS \;|\; \varepsilon\\ T &\rightarrow aSb\\ \end{aligned} \] considérée en \ref{example-well-parenthesized-expressions} est inambiguë. Le point crucial pour s'en convaincre est que dans l'application de la règle $S \rightarrow TS$ dans l'analyse d'un mot $w \neq \varepsilon$ engendré par la grammaire, il n'y a qu'une seule possibilité sur la limite du préfixe $u$ qui dérivera de $T$ (et donc du suffixe qui dérivera de $S$) : en s'inspirant de \ref{example-grammar-equal-a-and-b} on peut se convaincre que $u$ est le préfixe de $w$ de la plus petite longueur $>0$ possible comportant autant de $b$ que de $a$ (par exemple si $w = aabbab$ alors $u = aabb$) ; ce point étant acquis, tout mot $w\neq\varepsilon$ de la grammaire $L(G) = L(G,S)$ s'analyse de façon unique comme concaténation d'un mot $u \in L(G,T)$ (c'est-à-dire dérivant de $T$) et d'un mot $v \in L(G,S)$, et chacun de ces morceaux s'analyse à son tour de façon unique (la règle $T \rightarrow aSb$ ne permet manifestement qu'une seule analyse d'un mot de $L(G,T)$ : une fois qu'on enlève le $a$ initial et le $b$ final, il reste un mot de $L(G,S)$). Notamment, l'arbre représenté en \ref{example-of-parse-tree} est l'\emph{unique} arbre d'analyse de $aabbab$ pour la grammaire présentée ci-dessus. \thingy\label{intrinsic-ambiguity} Il arrive que le \emph{même} langage puisse être engendré par une grammaire ambiguë et par une grammaire inambiguë (on a vu un exemple en \ref{trivial-example-ambiguity}). L'ambiguïté est donc une caractéristique de la \emph{grammaire} hors contexte et non du \emph{langage} algébrique qu'elle engendre. \smallskip Cependant, certains langages algébriques ne sont définis \emph{que} par des grammaires hors contexte ambiguës. De tels langages sont dits \defin[intrinsèquement ambigu (langage algébrique)]{intrinsèquement ambigus}. C'est le cas du langage $\{a^i b^i c^j : i,j\in\mathbb{N}\} \cup \{a^i b^j c^j : i,j\in\mathbb{N}\}$ dont on a vu en \ref{example-for-intrinsic-ambiguity} qu'il était algébrique : il n'est pas évident (cela dépasse le cadre de ce cours) de démontrer qu'il est intrinsèquement ambigu, mais on peut au moins en donner une explication intuitive : quelle que soit la manière dont on construit une grammaire engendrant ce langage, elle devra forcément distinguer le cas de $a^i b^i c^j$ et celui de $a^i b^j c^j$, or ces cas ne sont pas disjoints, il existe des mots $a^i b^i c^i$ qui sont à l'intersection des deux, et ce sont ces mots qui forcent ce langage à être intrinsèquement ambigu. \subsection{Le lemme de pompage pour les langages algébriques} On a vu en §\ref{subsection-pumping-lemma} une condition nécessaire que doivent vérifier les langages rationnels, et qui est souvent utile pour montrer qu'un langage \emph{n'est pas} rationnel. Un lemme tout à fait analogue existe pour les langages algébriques, est qui s'avère utile dans des circonstances semblables, même si son emploi est plus difficile ; on prendra garde au fait que, dans l'énoncé suivant, $x$ et $y$ désignent des mots et non des lettres comme d'habitude : \begin{prop}[lemme de pompage pour les langages algébriques]\label{pumping-lemma-for-algebraic-languages}\index{pompage (lemme de)} Soit $L$ un langage algébrique. Il existe alors un entier $k$ tel que tout mot de $t \in L$ de longueur $|t| \geq k$ admette une factorisation $t = uvwxy$ en cinq facteurs $u,v,w,x,y \in \Sigma^*$ où : \begin{itemize} \item[(i)] $|vx| \geq 1$ (c'est-à-dire que l'un au moins de $v$ et $x$ est $\neq\varepsilon$), \item[(ii)] $|vwx| \leq k$, \item[(iii)] pour tout $i\geq 0$ on a $uv^iwx^iy \in L$. \end{itemize} \end{prop} \smallskip Donnons maintenant un exemple d'utilisation du lemme : \begin{prop}\label{example-of-pumping-lemma-for-algebraic-languages} Soit $\Sigma = \{a,b,c\}$. Le langage $L = \{a^n b^n c^n : n\in\mathbb{N}\} = \{\varepsilon, abc, aabbcc, aaabbbcc,\ldots\}$ n'est pas algébrique. \end{prop} \begin{proof} Appliquons la proposition \ref{pumping-lemma-for-algebraic-languages} au langage $L$ considéré : appelons $k$ l'entier dont le lemme de pompage garantit l'existence. Considérons le mot $t := a^k b^k c^k$ : il doit alors exister une factorisation $t = uvwxy$ pour laquelle on a (i) $|vx|\geq 1$, (ii) $|vwx|\leq k$ et (iii) $uv^iwx^iy \in L$ pour tout $i\geq 0$. La propriété (ii) assure que le facteur $vwx$ ne peut pas contenir simultanément les lettres $a$ et $c$ : en effet, tout facteur de $t$ comportant un $a$ et un $c$ doit avoir aussi le facteur $b^k$, et donc être de longueur $\geq k+2$. Supposons que $vwx$ ne contienne pas la lettre $c$ (l'autre cas étant complètement analogue) : en particulier, ni $v$ ni $x$ ne la contient, donc le mot $uv^iwx^iy$, qui est dans $L$ d'après (iii), a le même nombre de $c$ que le mot $t$ initial ; mais comme son nombre de $a$ ou bien de $b$ est différent (d'après (i)), on a une contradiction. \end{proof} \thingy La proposition \ref{intersection-of-algebraic-and-rational} peut s'avérer utile pour montrer qu'un langage n'est pas algébrique, en permettant de simplifier le langage auquel on va appliquer le lemme de pompage. \smallskip À titre d'exemple, montrons que le langage $L$ formé des mots sur $\{a,b,c\}$ ayant le même nombre total de $a$, de $b$ et de $c$ (autrement dit $\{w \in \{a,b,c\}^* : |w|_a = |w|_b = |w|_c\}$ où $|w|_x$ désigne le nombre d'occurrences de la lettre $x$ dans le mot $w$, cf. \ref{number-of-occurrences-of-letter}) n'est pas algébrique ; le plus simple pour le voir est de l'intersecter avec le langage rationnel $M := \{a^i b^j c^k : i,j,k\in\mathbb{N}\}$ (dénoté par l'expression rationnelle $a{*}b{*}c{*}$) : si $L$ était algébrique alors d'après \ref{intersection-of-algebraic-and-rational}, le langage $L\cap M$ le serait aussi ; mais $L\cap M = \{a^i b^i c^i : i\in\mathbb{N}\}$, et on vient de voir en \ref{example-of-pumping-lemma-for-algebraic-languages} qu'il n'est pas algébrique ; c'est donc que $L$ n'est pas non plus algébrique. \subsection{Notions sur l'analyse algorithmique des langages hors contexte} \thingy Il est naturel de se poser la question suivante : existe-t-il un algorithme qui, donnée une grammaire hors contexte $G$, permet de déterminer si un mot donné appartient au langage $L(G)$ engendré par $G$, et, si oui, d'en trouver un arbre d'analyse ? La réponse à cette question est positive, mais plus délicate que dans le cadre des langages rationnels où la notion d'automate fini a permis de donner un point de vue clair (cf. \ref{rational-languages-are-recognizable}). \thingy\label{handwaving-on-stack-automata} Il existe bien un modèle de calcul qu'on peut imaginer comme l'analogue pour les langages algébriques (et grammaires hors contexte) de ce que les automates finis sont pour les langages rationnels (et expressions régulières) : il s'agit des \emph{automates à pile}. Informellement, un automate à pile non déterministe fonctionne comme un automate fini non déterministe à transitions spontanées, mais il a, en plus de son état courant, accès à une « pile », qui contient des éléments d'un autre alphabet (l'alphabet de pile), et pour choisir la transition à effectuer, il peut consulter, en plus du symbole proposé, les symboles au sommet de la pile (jusqu'à une profondeur bornée), et une fois cette transition effectuée, décider de rajouter, retirer ou remplacer des symboles au sommet de la pile. \medskip {\footnotesize De façon plus formelle, un \index{automate à pile}automate à pile non déterministe est la donnée d'un ensemble fini $Q$ d'états, d'un ensemble $I \subseteq Q$ d'états dits initiaux, d'un ensemble $F \subseteq Q$ d'états dits finaux, d'un ensemble fini $\Gamma$ appelé alphabet de pile, et d'une relation de transition $\delta \subseteq (Q \times (\Sigma\cup\{\varepsilon\}) \times \Gamma^*) \times (Q \times \Gamma^*)$. Dire que $((q,t,\lambda), (q',\lambda')) \in \delta$ signifie que l'automate peut transitionner de l'état $q$ avec $\lambda$ au sommet de la pile vers l'état $q'$ avec $\lambda'$ (à la place de $\lambda$) au sommet de la pile en consommant la lettre $t$ (ou spontanément si $t=\varepsilon$), et l'automate \emph{accepte} un mot $w$ lorsqu'il existe une suite de transitions d'un état initial avec pile vide vers un état final avec pile vide qui consomme les lettres de $w$. \smallskip De façon plus précise, l'automate accepte $w$ lorsqu'il existe $q_0,\ldots,q_n \in Q$ (les états traversés) et $t_1,\ldots,t_n \in (\Sigma\cup\{\varepsilon\})$ (les symboles consommés) et $\gamma_1,\ldots,\gamma_n \in \Gamma^*$ (les états intermédiaires de la pile) et $\lambda_1,\ldots,\lambda_n \in \Gamma^*$ (les mots dépilés) et $\lambda'_1,\ldots,\lambda'_n \in \Gamma^*$ (les mots empilés) tels que : $q_0 \in I$ et $q_n\in F$ et et $\lambda_1\gamma_1 = \varepsilon$ et $\lambda'_n\gamma_n = \varepsilon$ et $((q_{i-1},t_i,\lambda_i),(q_i,\lambda'_i)) \in \delta$ pour chaque $1\leq i\leq n$ et $w = t_1\cdots t_n$ et enfin $\lambda_i\gamma_i = \lambda'_{i-1}\gamma_{i-1}$ pour chaque $1\leq i\leq n$. (Il existe différentes variations autour de cette notion, certaines sans importance : notamment, on peut relaxer l'exigence que l'automate termine le calcul avec la pile vide, cela ne change rien à la classe des langages acceptés.) \par} \medskip On peut montrer qu'il y a équivalence entre grammaires hors contexte et automates à pile non déterministes au sens où tout langage engendré par une grammaire hors contexte est le langage accepté par un automate à pile non déterministe et réciproquement. Il n'est d'ailleurs pas très difficile de construire algorithmiquement un automate à pile non déterministe qui accepte le langage engendré par une grammaire hors contexte donnée. Mais une différence essentielle avec les automates finis est que cette fois \emph{le non déterministe est essentiel} : les automates à pile déterministes (qu'il faut définir soigneusement) acceptent strictement moins de langages que les automates à pile non déterministes. \bigbreak \thingy Une approche simple, quoique terriblement inefficace, pour résoudre algorithmiquement, \emph{en théorie}, le problème de décider si un mot $w$ appartient au langage $L(G)$ engendré par une grammaire hors contexte $G$ (absolument quelconque) est la suivante : \begin{itemize} \item réécrire la grammaire (i.e., la remplacer par une grammaire équivalente) de manière à ce que le membre de droite de chaque production soit \emph{non vide}, quitte à traiter spécialement la question de savoir si $\varepsilon \in L(G)$, \item on a ensuite affaire à une grammaire \emph{monotone}, c'est-à-dire que l'application d'une règle ne peut qu'augmenter (au sens large) la longueur du pseudo-mot en cours de dérivation, ce qui permet d'explorer exhaustivement toutes les possibilités et de s'arrêter dès qu'on dépasse la longueur $|w|$ à atteindre. \end{itemize} \smallskip Énonçons précisément le résultat en question : \begin{thm}\label{algebraic-languages-are-decidable} Il existe un algorithme qui, donnée une grammaire hors contexte $G$ (sur un alphabet $\Sigma$) et un mot $w \in \Sigma^*$, décide si $w \in L(G)$. Autrement dit, les langages algébriques sont \emph{décidables} au sens de \ref{definition-computable-function-or-set}. Plus exactement, on montre : \begin{itemize} \item Il existe un algorithme qui, donnée une grammaire hors contexte $G$ (sur un alphabet $\Sigma$), calcule une grammaire $G'$ (sur le même alphabet $\Sigma$ et ayant le même ensemble $N$ de nonterminaux que $G$) dont toutes les productions sont soit de la forme $T \rightarrow \alpha$ avec $|\alpha| \geq 1$, et une partie $E$ de $\{\varepsilon\}$ (c'est-à-dire soit $\varnothing$ soit $\{\varepsilon\}$), telles que $L(G) = L(G') \cup E$. \item Il existe un algorithme qui, donnée une grammaire $G'$ comme on vient de le dire, et un mot $w \in \Sigma^*$, décide si $w \in L(G')$. \end{itemize} \end{thm} \begin{proof} Montrons d'abord l'affirmation du premier point. Pour cela, on va d'abord calculer l'ensemble $N_0$ des nonterminaux « \index{évanescent (nonterminal)}évanescents » de $G$, un nonterminal $T$ étant dit « évanescent » lorsque $T \mathrel{\Rightarrow^*} \varepsilon$. Mais il est évident que toute dérivation de $\varepsilon$ dans $G$ ne peut faire intervenir que des nonterminaux évanescents. On peut donc calculer l'ensemble des nonterminaux évanescents de la manière suivante : on commence avec $N_0 = \varnothing$, et tant qu'il existe dans $G$ une règle $T \rightarrow \alpha$, pour laquelle $T$ n'est pas encore dans $N_0$, avec $\alpha \in N_0^*$ (c'est-à-dire, ne faisant intervenir que des nonterminaux connus pour être évanescents ; y compris $\alpha = \varepsilon$), on ajoute $T$ à $N_0$ et on recommence. Cette boucle va évidemment terminer en temps fini (il n'y a qu'un nombre fini de nonterminaux) et lorsque c'est le cas $N_0$ sera l'ensemble des nonterminaux évanescents. Une fois calculé l'ensemble $N_0$ des nonterminaux évanescents, on peut définir $G'$ de la manière suivante : pour chaque production $T \rightarrow \alpha$ de $G$, on met dans $G'$ toutes les productions $T \rightarrow \alpha'$ où $\alpha'$ est un sous-(pseudo-)mot $\neq\varepsilon$ de $\alpha$ obtenu en effaçant un sous-ensemble quelconque de ses nonterminaux évanescents. La grammaire $G'$ est alors « presque » faiblement équivalente à $G$ : tout arbre de dérivation dans $G'$ donne un arbre de dérivation du même mot dans $G$, quitte à ajouter, à chaque fois qu'une règle $T \rightarrow \alpha'$ est utilisée dans $G'$, les nonterminaux évanescents manquants, qui portent eux-mêmes un sous-arbre de dérivation du mot vide (puisqu'ils sont, justement, évanescents) ; et réciproquement, tout arbre de dérivation dans $G$ en donne un dans $G'$ quitte à effacer tout sous-arbre qui ne porte que des feuilles $\varepsilon$ (ce qui assure que sa racine est évanescente). La seule subtilité est qu'on a éventuellement perdu le mot vide dans $L(G)$ (la procédure qu'on vient de décrire conduisant à effacer la totalité de l'arbre), mais il suffit de poser $E = \{\varepsilon\}$ exactement lorsque l'axiome $S$ de $G$ est évanescent pour corriger ce problème. Montrons maintenant l'affirmation du second point. Pour cela, on considère l'ensemble (fini !) $(\Sigma\cup N)^{\leq|w|}$ de tous les pseudo-mots de longueur $\leq |w|$. On construit et on explore progressivement (par exemple par un algorithme de Dijkstra / parcours en largeur), à partir de $S$, le graphe sur cet ensemble de sommets dont les arêtes sont les dérivations immédiates de $G'$ (dont le membre de droite soit de longueur $\leq |w|$) : comme la grammaire $G'$ est monotone, toute dérivation de $w$ sera un chemin dans le graphe qu'on vient de dire (elle ne peut pas passer par des pseudo-mots de longueur $>|w|$), donc on peut détecter sur ce graphe fini si une telle dérivation existe. \end{proof} {\footnotesize \thingy\label{handwaving-on-dynamical-programming} Expliquons comment on peut approcher de façon algorithmiquement plus efficace le problème de reconnaître si $w \in L(G)$, et fournir une autre démonstration du théorème \ref{algebraic-languages-are-decidable}, tout en continuant à ne faire aucune hypothèse sur la grammaire hors contexte $G$. \smallskip Il s'agit de travailler en deux étapes : \begin{itemize} \item D'abord, trouver algorithmiquement une grammaire $G'$ et un $E \subseteq \{\varepsilon\}$ tels que $L(G) = L(G') \cup E$, et que $G'$ soit en \defin[Chomsky (forme normale de)]{forme normale de Chomsky}, c'est-à-dire que toute production de $G'$ est de la forme $T \rightarrow UV$ avec $U,V$ (exactement) deux nonterminaux, ou bien $T \rightarrow x$ avec $x$ un terminal. \item Ensuite, utiliser un algorithme de programmation dynamique pour calculer, pour chaque facteur $u$ de $w$ (par ordre croissant de taille), l'ensemble de tous les terminaux $T$ tels que $T \mathrel{\Rightarrow^*} u$ (ce qui répond notamment à la question de savoir si $S \mathrel{\Rightarrow^*} w$). \end{itemize} \smallskip Détaillons un peu plus chacune de ces étapes. Pour transformer la grammaire $G$ en une grammaire $G'$ sous forme normale de Chomsky, on effectue les transformations suivantes : \begin{itemize} \item Introduire pour chaque terminal $x$ un nouveau nonterminal $X$ et une règle $X \rightarrow x$, et remplacer chaque occurrence de $x$ par $X$ dans le membre de droite de toute règle autre que $X \rightarrow x$. Ceci permet de faire en sorte qu'à part les règles $X \rightarrow x$, le membre de droite de toute règle soit uniquement constitué de nonterminaux. \item Pour chaque règle $T \rightarrow U_1 \cdots U_n$ dont le membre de droite est de longueur $n\geq 3$, introduire $n-2$ nouveaux nonterminaux $Z_1,\ldots, Z_{n-2}$ et remplacer la règle $T \rightarrow U_1 \cdots U_n$ par les $n-1$ règles $T \rightarrow U_1 Z_1$ et $Z_i \rightarrow U_{i+1} Z_{i+1}$ pour $1\leq i\leq n-3$ et $Z_{n-2} \rightarrow U_{n-1} U_n$. Ceci permet de faire en sorte que le membre de droite de chaque règle soit de longueur $\leq 2$. \item Éliminer les règles produisant $\varepsilon$ (et calculer l'ensemble $E$) exactement comme dans la démonstration du premier point de \ref{algebraic-languages-are-decidable}. À ce stade-là, le membre de droite de chaque règle est de longueur exactement $1$ ou $2$ (et dans le second cas, constitué de deux nonterminaux). \item Pour chaque règle $V \rightarrow \alpha$ où $\alpha$ n'est pas un unique nonterminal, et chaque terminal tel qu'il existe une suite $T \rightarrow \cdots \rightarrow V$ de règles produisant à chaque fois un unique nonterminal, et réécrivant $T$ en $V$, introduire une règle $T \rightarrow \alpha$, puis supprimer toutes les règles dont le membre de droite est un unique nonterminal. (Cette transformation fonctionne exactement comme l'élimination des ε-transitions d'un εNFA, cf. \ref{removal-of-epsilon-transitions}, si on imagine que les règles de la forme $T \rightarrow U$ sont des sortes de transitions spontanées d'un nonterminal vers un autre.) \end{itemize} L'ordre de ces transformations peut être légèrement varié, mais celui proposé ci-dessus est sans doute le meilleur. \smallskip Une fois la grammaire $G'$ en forme normale de Chomsky connue, lorsqu'on a un mot $w$ dont on cherche à tester s'il appartient à $L(G')$, on calcule, pour chaque facteur $u$ de $w$ (identifié par son point de départ et sa longueur), dans l'ordre croissant de longueur, l'ensemble $\Lambda(u)$ des nonterminaux $T$ tels que $u \in L(G',T)$ (on rappelle, cf. \ref{words-deriving-from-another-nonterminal}, que $L(G',T) := \{v \in \Sigma^* : T \mathrel{\Rightarrow^*} v\}$) : \begin{itemize} \item Si $|u|=1$, c'est-à-dire $u \in \Sigma$, il s'agit simplement de l'ensemble des $T$ tels que la règle $T \rightarrow u$ soit dans $G'$. \item Si $|u|\geq 2$, considérer chaque factorisation $u = v_1 v_2$ en deux facteurs de taille $\geq 1$ (il y en a $|u|-1$ possibles), pour chacune d'entre elles, pour chaque $X_1 \in \Lambda(v_1)$ (i.e., tel que $v_1 \in L(G',X_1)$) et chaque $X_2 \in \Lambda(v_2)$ (i.e., tel que $v_2 \in L(G',X_2)$) (ces deux ensembles étant connus par récurrence), et chaque $Y$ tel que la règle $Y \rightarrow X_1 X_2$ soit dans $G'$, mettre l'élément $Y$ dans $\Lambda(u)$. \end{itemize} Il n'est pas difficile de se convaincre que ceci construit bien les ensembles $\Lambda(u)$ annoncés : la deuxième partie revient à rechercher toutes les dérivations $Y \Rightarrow X_1 X_2 \mathrel{\Rightarrow^*} v_1 v_2 = u$ possibles dans lesquelles $X_1$ a donné $v_1$ et $X_2$ a donné $v_2$. Une fois les $\Lambda(u)$ connus, tester si $w \in L(G')$ revient à tester si $S \in \Lambda(w)$. \smallskip L'algorithme qu'on vient de décrire (pour tester si $w \in L(G')$ une fois $G'$ sous forme normale de Chomsky) porte le nom d'\defin[Cocke-Younger-Kasami (algorithme de)]{algorithme de Cocke–Younger–Kasami} ou algorithme \index{CYK (algorithme de)|see{Cocke-Younger-Kasami}}\textbf{CYK}. Sa complexité est cubique en la longueur de $w$. \par} \bigbreak \thingy\label{handwaving-on-ll-and-lr} Du point de vue pratique, on ne cherche pas simplement à savoir si un mot appartient au langage engendré par une grammaire, mais aussi à en construire un arbre d'analyse ; par ailleurs, la complexité algorithmique des approches décrites en \ref{algebraic-languages-are-decidable} et même en \ref{handwaving-on-dynamical-programming} est inacceptable. En contrepartie de ces exigences, on est prêt à accepter de mettre des contraintes sur la grammaire qui la rendent plus facile à analyser : \emph{au minimum}, on supposera que la grammaire est inambiguë (cf. \ref{ambiguous-grammar}), et en fait, on imposera des contraintes beaucoup plus fortes (par exemple, la grammaire présentée en \ref{example-unambiguous-but-not-deterministic-grammar}, bien qu'inambiguë, ne sera pas acceptable car il n'y a pas de manière déterministe de l'analyser, ni même d'analyser le langage qu'elle engendre) ; ces contraintes sont assez techniques et difficiles à décrire : dans la pratique, elles consistent essentiellement à essayer de fabriquer l'analyseur et à constater si l'algorithme échoue. \smallskip Il existe deux principales approches pour construire un analyseur pour une grammaire hors contexte (sujette à diverses contraintes supplémentaires) ; dans les deux cas, on construit une sorte d'automate à pile (cf. \ref{handwaving-on-stack-automata}) déterministe, mais l'utilisation de la pile est très différente dans les deux cas. De façon très simplifiée : \begin{itemize} \item Les analyseurs \defin[LL (analyse)]{LL} procèdent de façon \emph{descendante} (en anglais « top-down »), parcourent le mot depuis la gauche (« L ») et génèrent la dérivation gauche (« L ») de l'arbre d'analyse fabriqué, en partant de la racine et en descendant jusqu'aux feuilles\footnote{En botanique, un arbre a la racine en bas et les feuilles en haut ; en informatique, on les représente plutôt racine en haut et feuilles en bas.}. La pile de l'analyseur LL sert, intuitivement, à mémoriser les règles qu'on a commencé à reconnaître, en partant de l'axiome de la grammaire, et qui restent encore à compléter. \item Les analyseurs \defin[LR (analyse)]{LR} procèdent de façon \emph{ascendante} (en anglais « bottom-up »), parcourent le mot depuis la gauche (« L ») et génèrent la dérivation droite (« R ») de l'arbre d'analyse fabriqué, en partant des feuilles et en remontant jusqu'aux racines. La pile de l'analyseur LR sert, intuitivement, à mémoriser les fragments d'arbre déjà construits, en partant des feuilles, et qui restent encore à regrouper. \end{itemize} \smallskip On peut écrire un analyseur LL ou (plus difficilement) LR à la main dans un cas simple, mais en général ces analyseurs sont fabriqués par des algorithmes systématiques, implémentés dans des programmes tels que YACC ou Bison (qui produit des analyseurs LR, même si Bison peut dépasser ce cadre) ou JavaCC (qui produit des analyseurs LL). \smallskip L'idée générale à retenir est que les analyseurs LR sont strictement plus puissants que les analyseurs LL (ils sont capables d'analyser strictement plus de grammaires, cf. \ref{example-lr-non-ll-grammar}), mais leur génération est plus difficile et les messages d'erreur qu'ils retournent en cas de problème de syntaxe sont plus difficiles à comprendre pour l'utilisateur. \thingy\label{example-ll-and-lr-analysis} Pour illustrer le fonctionnement et les différences des analyseurs LL et LR, considérons une grammaire très simple à analyser comme \[ \begin{aligned} S &\rightarrow TS \;|\; c\\ T &\rightarrow aSb\\ \end{aligned} \] (il s'agit d'une variante de celle considérée en \ref{example-well-parenthesized-expressions}, où on a ajouté un $c$ pour rendre l'analyse plus simple en évitant les productions $\varepsilon$ ; on peut imaginer, si on veut, qu'il s'agit d'une forme extrêmement primitive de XML où $a$ représente une balise ouvrante, $b$ une balise fermante, et $c$ une balise vide). \medskip L'approche la plus évidente, si on doit écrire une fonction « analyser un mot comme dérivant de $S$ dans cette grammaire » consiste à coder deux fonctions mutuellement récursives, « chercher un préfixe qui dérive de $S$ » et « chercher un préfixe qui dérive de $T$ ». En observant que tout mot qui dérive de $T$ doit commencer par la lettre $a$, ce qui permet de distinguer les mots dérivant des règles $S\rightarrow TS$ et $S\rightarrow c$, on va écrire : \begin{itemize} \item La fonction « rechercher un préfixe qui dérive de $S$ » (prenant en entrée un mot $w\in\{a,b\}^*$, et renvoyant un préfixe de $w$ et un arbre de dérivation de $w$ à partir de $S$) est définie comme suit : \begin{itemize} \item si la première lettre de $w$ est $c$, renvoyer le préfixe $c$ et l'arbre trivial $S\to c$, sinon : \item appeler la fonction « rechercher un préfixe qui dérive de $T$ » sur $w$, qui retourne un préfixe $u$ de $w$ et un arbre $\mathscr{U}$, \item appeler la fonction « rechercher un préfixe qui dérive de $S$ » sur le suffixe correspondant $t$ de $w$ (c'est-à-dire le $t$ tel que $w=ut$), qui retourne un préfixe $v$ de $t$ et un arbre $\mathscr{V}$, \item renvoyer le préfixe $uv$ de $w$ ainsi que l'arbre d'analyse dont la racine est donnée par la règle $S\rightarrow TS$ et les sous-arbres $\mathscr{U}$ et $\mathscr{V}$ (i.e., une racine étiquetée $S$ et deux fils étiquetés $T$ et $S$ qui sont chacun racines de sous-arbres donnés par $\mathscr{U}$ et $\mathscr{V}$ respectivement). \end{itemize} \item La fonction « rechercher un préfixe qui dérive de $T$ » (prenant en entrée un mot $u\in\{a,b\}^*$, et renvoyant un préfixe de $u$ et un arbre de dérivation de $u$ à partir de $T$) est définie comme suit : \begin{itemize} \item vérifier que la première lettre est un $a$ (sinon, soulever une exception indiquant une erreur d'analyse), \item appeler la fonction « rechercher un préfixe qui dérive de $S$ » sur le suffixe correspondant $x$ de $u$ (c'est-à-dire le $x$ tel que $u=ax$), qui retourne un préfixe $w$ de $x$ et un arbre $\mathscr{W}$, \item vérifier que la lettre qui suit $w$ dans $x$ est bien $b$, c'est-à-dire que $u$ commence par $awb$ (sinon, soulever une exception indiquant une erreur d'analyse), \item renvoyer le préfixe $awb$ de $u$ ainsi que l'arbre d'analyse dont la racine est donnée par la règle $T\rightarrow aSb$ et les sous-arbres $a$, $\mathscr{W}$ et $b$ (i.e., une racine étiquetée $T$ et trois fils étiquetés $a$, $S$ et $b$, celui du milieu étant racine d'un sous-arbre donné par $\mathscr{W}$). \end{itemize} \end{itemize} \smallskip Cette approche réussit sur cette grammaire très simple (où on peut notamment se convaincre que l'éventuel préfixe dérivant de $S$ ou de $T$ est toujours défini de façon unique). L'analyseur qu'on vient de décrire s'appelle un « analyseur par descente récursive ». Or, plutôt qu'utiliser la récursivité du langage de programmation (c'est-à-dire la pile système), on peut aussi utiliser une pile comme structure de données, et transformer les fonctions récursives en fonctions itératives\footnote{Ceci est un fait général : tout ensemble de fonctions récursives peut se réécrire pour utiliser une pile comme structure de données explicite à la place de la pile système.}. On obtient ainsi essentiellement un automate à pile, qui utilise sa pile pour retenir les règles qu'il a commencé à analyser (à partir de la racine de l'arbre d'analyse en cours de construction). On a essentiellement construit un analyseur LL, ou plus exactement LL($1$) (le « $1$ » indiquant qu'on se contente de lire une unique lettre du mot pour décider quelle règle chercher à analyser), pour ce langage. C'est ici l'approche « descendante » : l'arbre se construit à partir de la racine et la pile sert à retenir les règles qu'on a commencé à reconnaître. \medbreak L'approche « ascendante » de la même grammaire serait plutôt la suivante : on parcourt le mot de gauche à droite en gardant de côté une pile (initialement vide) qui pourra contenir les symboles $a,S,T$, les deux derniers étant alors associés à des arbres d'analyse ; \begin{itemize} \item si on lit un $a$, on se contente de l'empiler, \item si on lit un $c$, on crée un arbre d'analyse $S\rightarrow c$ et on empile le $S$, puis, tant que la pile contient $T$ et $S$ en son sommet, on dépile ces deux symboles, on rassemble les deux arbres d'analyse associés en les mettant sous un $S\rightarrow TS$ et on empile le $S$ correspondant, \item si on lit un $b$, on vérifie que les deux symboles au sommet de la pile sont $a$ et $S$ (sinon on soulève une erreur d'analyse), on les dépile et on rassemble l'arbre d'analyse associé au $S$ en le mettant sous un $T\rightarrow aSb$, et enfin on empile un $T$ associé à cet arbre, \item enfin, si on arrive à la fin du mot, la pile ne doit contenir qu'un unique symbole $S$ (sinon on soulève une erreur d'analyse), et l'arbre d'analyse final est celui qui lui est associé. \end{itemize} Il est un peu difficile d'expliquer en général comment construire un tel analyseur, mais sur cet exemple précis il est facile de se convaincre qu'il fonctionne et de comprendre pourquoi : il s'agit essentiellement là d'un analyseur LR (en fait, LR($0$), le « $0$ » indiquant qu'on n'a jamais eu besoin de regarder au-delà du symbole courant pour décider quoi faire). C'est ici l'approche « ascendante » : l'arbre se construit à partir des feuilles et la pile sert à retenir les nonterminaux au sommet des morceaux d'arbre déjà construits (et éventuellement les arbres eux-mêmes). % % % \section{Introduction à la calculabilité}\label{section-computability} \subsection{Présentation générale} \thingy\textbf{Discussion préalable.} On s'intéresse ici à la question de savoir ce qu'un \defin{algorithme} peut ou ne peut pas faire. Pour procéder de façon rigoureuse, il faudrait formaliser la notion d'algorithme (par exemple à travers le concept de machine de Turing) : on a préféré rester informel sur cette définition — par exemple « un algorithme est une série d'instruction précises indiquant des calculs à effectuer étape par étape et qui ne manipulent, à tout moment, que des données finies » ou « un algorithme est quelque chose qu'on pourrait, en principe, implémenter sur un ordinateur » — étant entendu que cette notion est déjà bien connue et comprise, au moins dans la pratique. Les démonstrations du fait que tel ou tel problème est décidable par un algorithme ou que telle ou telle fonction est calculable par un algorithme deviennent beaucoup moins lisibles quand on les formalise avec une définition rigoureuse d'algorithme (notamment, programmer une machine de Turing est encore plus fastidieux que programmer un ordinateur en assembleur, donc s'il s'agit d'exhiber un algorithme, c'est probablement une mauvaise idée de l'écrire sous forme de machine de Turing). \smallskip Néanmoins, il est essentiel de savoir que ces formalisations existent : on peut par exemple évoquer le paradigme du $\lambda$-calcul de Church (la première formalisation rigoureuse de la calculabilité), les fonctions générales récursives (=$\mu$-récursives) à la Herbrand-Gödel-Kleene, les machines de Turing (des machines à états finis capables de lire, d'écrire et de se déplacer sur un ruban infini contenant des symboles d'un alphabet fini dont à chaque instant tous sauf un nombre fini sont des blancs), les machines à registres, le langage « FlooP » de Hofstadter, etc. Toutes ces formalisations sont équivalentes (au sens où, par exemple, elles conduisent à la même notion de fonction calculable ou calculable partielle, définie ci-dessous). La \defin[Church-Turing (thèse de)]{thèse de Church-Turing} affirme, au moins informellement, que tout ce qui est effectivement calculable par un algorithme\footnote{Voire, dans certaines variantes de la thèse, tout ce qui est physiquement calculable dans notre Univers (y compris par des processus quantiques).} est calculable par n'importe laquelle de ces notions formelles d'algorithmes, qu'on peut rassembler sous le nom commun de \defin[calculable (fonction)]{calculabilité au sens de Church-Turing}, ou « calculabilité » tout court. \smallskip Notamment, quasiment tous les langages de programmation informatique\footnote{C, C++, Java, Python, JavaScript, Lisp, OCaml, Haskell, Prolog, etc. Certains langages se sont même révélés Turing-complets alors que ce n'était peut-être pas voulu : par exemple, HTML+CSS.}, au moins si on ignore les limites des implémentations et qu'on les suppose capables de manipuler des entiers, chaînes de caractère, tableaux, etc., de taille arbitraire (mais toujours finie)\footnote{Autre condition : ne pas utiliser de générateur aléatoire matériel.}, sont « Turing-complets », c'est-à-dire équivalents dans leur pouvoir de calcul à la calculabilité de Church-Turing. Pour imaginer intuitivement la calculabilité, on peut donc choisir le langage qu'on préfère et imaginer qu'on programme dedans. Dans la pratique, pour qu'un langage soit Turing-complet, il lui suffit d'être capable de manipuler des entiers de taille arbitraire, de les comparer et de calculer les opérations arithmétiques dessus, et d'effectuer des tests et des boucles. \bigbreak \thingy Il faut souligner qu'on s'intéresse uniquement à la question de savoir ce qu'un algorithme peut ou ne peut pas faire (calculabilité), pas au temps ou aux autres ressources qu'il peut prendre pour le faire (complexité), et on ne cherche donc pas à rendre les algorithmes efficaces en quelque sens que ce soit. Par exemple, pour arguër qu'il existe un algorithme qui décide si un entier naturel $n$ est premier ou non, il suffit de dire qu'on peut calculer tous les produits $pq$ avec $2\leq p,q\leq n-1$ et tester si l'un d'eux est égal à $n$, peu importe que cet algorithme soit absurdement inefficace. \smallskip De même, nos algorithmes sont capables de manipuler des entiers arbitrairement grands : ceci permet de dire, par exemple, que toute chaîne binaire peut être considérée comme un entier, peu importe le fait que cet entier ait peut-être des milliards de chiffres ; dans les langages informatiques réels, on a rarement envie de considérer toute donnée comme un entier, mais en calculabilité on peut se permettre de le faire. \thingy\label{computability-all-data-are-integers} Soulignons et développons le point esquissé au paragraphe précédent : plutôt que de travailler avec des « mots » (éléments de $\Sigma^*$ avec $\Sigma$ un alphabet fini), en calculabilité, il est possible, dès que cela est commode, de remplacer ceux-ci par des entiers naturels. Il suffit pour cela de choisir un « codage », parfois appelé \index{Gödel (codage de)|see{codage de Gödel}}\defin{codage de Gödel} permettant de représenter un élément de $\Sigma^*$ par un entier naturel : la chose importante est que la conversion d'un mot en entier ou d'un entier en mot soit calculable par un algorithme (même très inefficace), si bien que toute manipulation algorithmique sur des mots puisse être convertie en manipulation sur des entiers. Il est commode pour simplifier les raisonnements (quoique pas indispensable) de supposer que le codage est bijectif, c'est-à-dire qu'on dispose d'une bijection $\mathbb{N} \to \Sigma^*$ algorithmiquement calculable et dont la réciproque l'est aussi. Il existe toutes sortes de manières d'obtenir un tel codage. La plus simple est sans doute la suivante : une fois choisi un ordre total arbitraire sur l'alphabet (fini !) $\Sigma$, on peut énumérer les mots sur $\Sigma$ par ordre de taille et, pour une taille donnée, par ordre lexicographique (par exemple : $\varepsilon, a, b,\penalty0 aa, ab, ba, bb, aaa, aab...$ sur l'alphabet $\{a,b\}$) ; cette énumération est visiblement faisable algorithmiquement, et quitte à numéroter au fur et à mesure qu'on énumère, on obtient un codage comme souhaité (par exemple $0 \leftrightarrow\varepsilon$, $1 \leftrightarrow a$, $2 \leftrightarrow b$, $3 \leftrightarrow ab$, etc.). Insistons sur le fait que ce n'est là qu'une possibilité parmi d'autres et que les détails du codage sont sans importance tant qu'il est calculable ; l'important est que ce soit faisable en théorie et donc qu'on peut considérer qu'au lieu de mots on a affaire à des entiers naturels. Il va de soi que la concaténation de deux mots, la longueur d'un mot, le miroir d'un mot, sont tous calculables algorithmiquement. \smallskip Grâce au codage de Gödel, on peut considérer que, dans cette partie, le terme de \index{langage}« langage » désigne non plus une partie de $\Sigma^*$ mais une partie de $\mathbb{N}$. {\footnotesize (Le remplacement des mots par des entiers naturels en utilisant un codage comme on vient de le dire est assez standard en calculabilité. Il ne doit pas dérouter : on peut imaginer qu'on a affaire à $\Sigma^*$ à chaque fois qu'il est question de $\mathbb{N}$ ci-dessous, et on a toujours affaire à la théorie des langages. Le point central est justement que cela n'a pas d'importance ; comme $\mathbb{N}$ est un objet mathématiquement plus simple, c'est surtout pour cela qu'il est utilisé à la place.)\par} \bigbreak \thingy\textbf{Terminaison des algorithmes.} Un algorithme qui effectue un calcul utile doit certainement terminer en temps fini. Néanmoins, même si on voudrait ne s'intéresser qu'à ceux-ci, il n'est pas possible d'ignorer le « problème » des algorithmes qui ne terminent jamais (et ne fournissent donc aucun résultat). C'est le point central de la calculabilité (et du théorème de Turing \ref{undecidability-of-halting-problem} ci-dessous) qu'on ne peut pas se débarrasser des algorithmes qui ne terminent pas : on ne peut pas, par exemple, formaliser une notion suffisante\footnote{Tout dépend, évidemment, de ce qu'on appelle « suffisant » : il existe bien des notions de calculabilité, plus faibles que celle de Church-Turing, où tout calcul termine, voir par exemple la notion de fonction « primitive récursive » ou le langage « BlooP » de Hofstadter ; mais de telles notions ne peuvent pas disposer d'une machine universelle comme expliqué plus loin (en raison d'un argument diagonal), donc elles sont nécessairement incomplètes en un certain sens.} de calculabilité dans laquelle tout algorithme termine toujours ; ni développer un langage de programmation suffisamment général dans lequel il est impossible qu'un programme « plante » indéfiniment ou parte en boucle infinie. {\footnotesize (Cette subtilité est d'ailleurs sans doute en partie responsable de la difficulté historique à dégager la bonne notion d'« algorithme » : on a commencé par développer des notions d'algorithmes terminant forcément, comme les fonctions primitives récursives, et on se rendait bien compte que ces notions étaient forcément toujours incomplètes.)\par} \bigbreak \begin{defn}\label{definition-computable-function-or-set} On dit qu'une fonction $f\colon\mathbb{N}\to\mathbb{N}$ est \defin[calculable (fonction)]{calculable} (ou \index{récursive (fonction)|see{calculable}}« récursive ») lorsqu'il existe un algorithme qui prend en entrée $n\in\mathbb{N}$, termine toujours en temps fini, et calcule (renvoie) $f(n)$. \smallskip On dit qu'un ensemble $A \subseteq \mathbb{N}$ (un « langage », cf. \ref{computability-all-data-are-integers}) est \defin{décidable} (ou \index{calculable (langage)|see{décidable}}« calculable » ou \index{récursif (langage)|see{décidable}}« récursif ») lorsque sa fonction indicatrice $\mathbf{1}_A \colon \mathbb{N} \to \mathbb{N}$ (valant $1$ sur $A$ et $0$ sur son complémentaire) est calculable. Autrement dit : lorsqu'il existe un algorithme qui prend en entrée $n\in\mathbb{N}$, termine toujours en temps fini, et renvoie « oui » ($1$) si $n\in A$, et « non » ($0$) si $n\not\in A$ (on dira que l'algorithme « décide » $A$). \smallskip On dit qu'une fonction partielle $f\colon\mathbb{N}\dasharrow\mathbb{N}$ (c'est-à-dire une fonction définie sur une partie de $\mathbb{N}$, appelé ensemble de définition de $f$) est \defin[calculable partielle (fonction)]{calculable partielle} (ou « récursive partielle ») lorsqu'il existe un algorithme qui prend en entrée $n\in\mathbb{N}$, termine en temps fini si et seulement si $f(n)$ est définie, et dans ce cas calcule (renvoie) $f(n)$. (Une fonction calculable est donc simplement une fonction calculable partielle qui est toujours définie : on dira parfois « calculable totale » pour souligner ce fait.) On utilisera la notation $f(n)\downarrow$ pour signifier le fait que la fonction calculable partielle $f$ est définie en $n$, c'est-à-dire, que l'algorithme en question termine. \smallskip On dit qu'un ensemble $A \subseteq \mathbb{N}$ est \defin{semi-décidable} (ou \index{semi-calculable|see{semi-décidable}}« semi-calculable » ou \index{semi-récursif|see{semi-décidable}}« semi-récursif ») lorsque la fonction partielle $\mathbb{N}\dasharrow\mathbb{N}$ définie exactement sur $A$ et y valant $1$, est calculable partielle. Autrement dit : lorsqu'il existe un algorithme qui prend en entrée $n\in\mathbb{N}$, termine en temps fini si et seulement si $n \in A$, et renvoie « oui » ($1$) dans ce cas\footnote{En fait, la valeur renvoyée n'a pas d'importance ; on peut aussi définir un ensemble semi-décidable comme l'ensemble de définition d'une fonction calculable partielle.} (on dira que l'algorithme « semi-décide » $A$). \end{defn} \smallskip On s'est limité ici à des fonctions d'une seule variable (entière), mais il n'y a pas de difficulté à étendre ces notions à plusieurs variables, et de parler de fonction calculable $\mathbb{N}^k \to \mathbb{N}$ (voire $\mathbb{N}^* \to \mathbb{N}$ avec $\mathbb{N}^*$ l'ensemble des suites finies d'entiers naturels) ou de fonction calculable partielle de même type : de toute manière, on peut « coder » un couple d'entiers naturels comme un seul entier naturel (par exemple par $(m,n) \mapsto 2^m(2n+1)-1$, qui définit une bijection calculable $\mathbb{N}^2 \to \mathbb{N}$), ou bien sûr un nombre fini quelconque (même variable), ce qui permet de faire « comme si » on avait toujours affaire à un seul paramètre entier. {\footnotesize\thingy\textbf{Complément :} Comme on n'a pas défini formellement la notion d'algorithme, il peut être utile de signaler explicitement les faits suivants (qui devraient être évidents sur toute notion raisonnable d'algorithme) : les fonctions constantes sont calculables ; les opérations arithmétiques usuelles sont calculables ; les projections $(n_1,\ldots,n_k) \mapsto n_i$ sont calculables, ainsi que la fonction qui à $(m,n,p,q)$ associe $p$ si $m=n$ et $q$ sinon ; toute composée de fonctions calculables (partielle ou totale) est calculable idem ; si $\underline{m} \mapsto g(\underline{m})$ est calculable (partielle ou totale, où $\underline{m}$ désigne une liste d'entiers) et que $(\underline{m}, n, v) \mapsto h(\underline{m}, n, v)$ l'est, alors la fonction $f$ définie par récurrence par $f(\underline{m},0) = g(\underline{m})$ et $f(\underline{m},n+1) = h(\underline{m}, n, f(\underline{m},n))$ est encore calculable idem (algorithmiquement, il s'agit juste de boucler $n$ fois) ; et enfin, si $(\underline{m}, n) \mapsto g(\underline{m},n)$ est calculable partielle, alors la fonction $f$ (aussi notée $\mu_n g$) définie par $f(\underline{m}) = \min\{n : g(\underline{m},n) = 0 \land \forall n'=latex,line join=bevel,automaton] %% \node (qY) at (97bp,105bp) [draw,circle,state,final] {$Y$}; \node (qX) at (18bp,74bp) [draw,circle,state,initial] {$X$}; \node (qZ) at (97bp,18bp) [draw,circle,state,final] {$Z$}; \draw [->] (qX) ..controls (45.279bp,84.58bp) and (58.943bp,90.081bp) .. node[auto] {$0$} (qY); \draw [->] (qX) ..controls (44.52bp,55.44bp) and (60.758bp,43.63bp) .. node[auto] {$1$} (qZ); \draw [->] (qZ) to[loop below] node[auto] {$0,1$} (qZ); % \end{tikzpicture} %%% end ex1p1 %%% \end{center} (2) (a) Le langage $L_a$ est rationnel car il s'agit du langage des mots binaires qui soit sont le mot vide soit finissent par $0$ : il est dénoté par l'expression rationnelle $\underline{\varepsilon}|(0|1){*}0$.\spaceout (b) On a $L_b = L_a \cap L_n$ et on a vu que $L_a$ et $L_n$ sont rationnels, donc $L_b$ l'est aussi (on peut aussi exhiber une expression rationnelle qui le dénote : $0|1(0|1){*}0$). (c) Ajouter un $0$ ou un $1$ à la fin d'un mot binaire de valeur numérique $n$ le transforme en un mot de valeur numérique $2n+x$ où $x$ est le chiffre affixé. Considérons les six combinaisons entre les trois cas possibles de la valeur numérique $n$ modulo $3$ et les deux cas possibles de la valeur de $x$ : \begin{center} \begin{tabular}{c|c|c} $n\equiv?\pmod{3}$&$x=?$&$2n+x\equiv?\pmod{3}$\\\hline $0$&$0$&$0$\\ $0$&$1$&$1$\\ $1$&$0$&$2$\\ $1$&$1$&$0$\\ $2$&$0$&$1$\\ $2$&$1$&$2$\\ \end{tabular} \end{center} Ceci définit un DFA dont les trois états correspondent aux trois valeurs possibles de $n$ modulo $3$, la transition $n\to n'$ étiquetée par $x$ correspond au passage de $n$ à $2n+x$ modulo $3$, c'est-à-dire : \begin{center} %%% begin example6 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,20.28bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,20.28bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (176bp,20.28bp) [draw,circle,state] {$2$}; \draw [->] (q1) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$1$} (q0); \draw [->] (q2) to[loop above] node[auto] {$1$} (q2); \draw [->] (q2) ..controls (153.76bp,3.6593bp) and (143.08bp,-1.2803bp) .. (133bp,1.2803bp) .. controls (129.04bp,2.2853bp) and (125.05bp,3.838bp) .. node[auto] {$0$} (q1); \draw [->] (q0) to[loop above] node[auto] {$0$} (q0); \draw [->] (q0) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$1$} (q1); \draw [->] (q1) ..controls (124.66bp,20.28bp) and (136.82bp,20.28bp) .. node[auto] {$0$} (q2); % \end{tikzpicture} %%% end example6 %%% \end{center} (On a marqué l'état $0$ comme initial car le mot vide a une valeur numérique congrue à $0$ modulo $3$, et seul $0$ comme final car on veut reconnaître les multiples de $3$.) (d) Le langage $L_d$ n'est pas rationnel (on pourrait le démontrer à l'aide du lemme de pompage, mais ce n'est pas très facile). (e) Le langage $L_e$ est rationnel car il s'agit du langage dénoté par l'expression rationnelle $0{*}10{*}$. \end{corrige} % \exercice Soit $\Sigma = \{a\}$. Montrer que le langage $L = \{a^2, a^3, a^5, a^7, a^{11}, a^{13}\ldots\}$ constitué des mots ayant un nombre \emph{premier} de $a$, n'est pas rationnel. \begin{corrige} Supposons par l'absurde que $L$ soit rationnel. D'après le lemme de pompage, il existe un certain $k$ tel que tout mot de $L$ de longueur $\geq k$ se factorise sous la forme $uvw$ avec (i) $|v|\geq 1$, (ii) $|uv|\leq k$ et (iii) $uv^iw \in L$ pour tout $i\geq 0$. Soit $p$ un nombre premier supérieur ou égal à $k$ (qui existe car l'ensemble des nombres premiers est infini) : le mot $a^p \in L$ admet une factorisation comme on vient de dire. Posons $|u| =: m$ et $|v| =: n$, si bien que $|w| = p-m-n$. On a alors $n\geq 1$ d'après (i), et $|uv^iw| = m + in + (p-m-n) = p+(i-1)n$ est premier pour tout $i\geq 0$ d'après (iii). En particulier pour $i=p+1$ on voit que $p + pn = p(n+1)$ est premier, ce qui contredit le fait qu'il s'agit d'un multiple non-trivial ($n+1\geq 2$) de $p$. \end{corrige} % \exercice On considère l'automate suivant : \begin{center} %%% begin ex1p2a %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (98bp,72bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,47bp) [draw,circle,state,initial] {$0$}; \node (q3) at (258bp,72bp) [draw,circle,state] {$3$}; \node (q2) at (178bp,72bp) [draw,circle,state] {$2$}; \node (q5) at (178bp,18bp) [draw,circle,state] {$5$}; \node (q4) at (98bp,18bp) [draw,circle,state] {$4$}; \node (q7) at (338bp,47bp) [draw,circle,state,final] {$7$}; \node (q6) at (258bp,18bp) [draw,circle,state] {$6$}; \draw [->] (q2) ..controls (206.11bp,72bp) and (218.58bp,72bp) .. node[auto] {$a$} (q3); \draw [->] (q3) ..controls (285.85bp,63.395bp) and (299.33bp,59.074bp) .. node[auto] {$\varepsilon$} (q7); \draw [->] (q7) to[loop below] node[auto] {$a,b$} (q7); \draw [->] (q6) ..controls (285.62bp,27.897bp) and (299.46bp,33.043bp) .. node[auto] {$\varepsilon$} (q7); \draw [->] (q4) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$b$} (q5); \draw [->] (q0) to[loop below] node[auto] {$a,b$} (q0); \draw [->] (q0) ..controls (45.62bp,37.103bp) and (59.462bp,31.957bp) .. node[auto] {$\varepsilon$} (q4); \draw [->] (q5) ..controls (206.11bp,18bp) and (218.58bp,18bp) .. node[auto] {$b$} (q6); \draw [->] (q0) ..controls (45.849bp,55.605bp) and (59.331bp,59.926bp) .. node[auto] {$\varepsilon$} (q1); \draw [->] (q1) ..controls (126.11bp,72bp) and (138.58bp,72bp) .. node[auto] {$a$} (q2); % \end{tikzpicture} %%% end ex1p2a %%% \end{center} (0) Décrire brièvement le langage accepté par l'automate en question. (1) Cet automate est-il déterministe ? Si non, le déterminiser. (2) Minimiser l'automate déterminisé (on doit trouver un DFA ayant quatre états). Décrire brièvement la signification de ces quatre états, de façon à vérifier qu'il accepte le même langage que décrit en (0). (3) Éliminer les états de l'automate d'origine de façon à obtenir une expression rationnelle dénotant le langage reconnu par le langage décrit en (0). \begin{corrige} (0) L'automate proposé accepte les mots ayant soit deux $a$ consécutifs (en passant par le chemin $0\to 1\to 2\to 3\to 7$) soit deux $b$ consécutifs (en passant par le chemin $0\to 4\to 5\to 6\to 7$). (1) L'automate ayant des ε-transitions, il ne peut pas être déterministe : on a affaire à un εNFA. Avant de le déterminiser, on élimine ses ε-transitions : la ε-fermeture de $0$ est $\{0,1,4\}$, celle de $3$ est $\{3,7\}$ et celle de $6$ est $\{6,7\}$ ; on est amené au NFA suivant : \begin{center} %%% begin ex1p2b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q0) at (18bp,47bp) [draw,circle,state,initial] {$0$}; \node (q3) at (178bp,72bp) [draw,circle,state,final,accepting above] {$3$}; \node (q2) at (98bp,72bp) [draw,circle,state] {$2$}; \node (q5) at (98bp,18bp) [draw,circle,state] {$5$}; \node (q7) at (268bp,47bp) [draw,circle,state,final] {$7$}; \node (q6) at (178bp,18bp) [draw,circle,state,final,accepting below] {$6$}; \draw [->] (q2) ..controls (126.11bp,72bp) and (138.58bp,72bp) .. node[auto] {$a$} (q3); \draw [->] (q3) ..controls (208.21bp,63.701bp) and (225.92bp,58.67bp) .. node[auto] {$a,b$} (q7); \draw [->] (q7) to[loop below] node[auto] {$a,b$} (q7); \draw [->] (q6) ..controls (208.34bp,27.667bp) and (226.26bp,33.576bp) .. node[auto] {$a,b$} (q7); \draw [->] (q5) ..controls (126.11bp,18bp) and (138.58bp,18bp) .. node[auto] {$b$} (q6); \draw [->] (q0) ..controls (45.62bp,37.103bp) and (59.462bp,31.957bp) .. node[auto] {$b$} (q5); \draw [->] (q0) ..controls (45.849bp,55.605bp) and (59.331bp,59.926bp) .. node[auto] {$a$} (q2); \draw [->] (q0) to[loop below] node[auto] {$a,b$} (q0); % \end{tikzpicture} %%% end ex1p2b %%% \end{center} (Les états $1$ et $4$ étant inaccessibles, ils ont été retirés. Il ne faut pas oublier que $3$ et $6$ sont finaux puisqu'ils ont l'état final $7$ dans leur ε-fermeture.) On peut maintenant procéder à la déterminisation. Pour abréger les noms des états, on note, par exemple, $023$ pour $\{0,2,3\}$. En construisant de proche en proche, on obtient le DFA suivant : \begin{center} \scalebox{0.8}{%PLEASE! There HAS to be a better way to do this! %%% begin ex1p2c %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \end{scope} \node (q0) at (18bp,121.73bp) [draw,circle,state,initial] {$0$}; \node (q027) at (382bp,39.732bp) [draw,circle,state,final] {$027$}; \node (q056) at (188bp,58.732bp) [draw,circle,state,final,accepting below] {$056$}; \node (q023) at (188bp,166.73bp) [draw,circle,state,final,accepting above] {$023$}; \node (q057) at (382bp,185.73bp) [draw,circle,state,final] {$057$}; \node (q0567) at (285bp,58.732bp) [draw,circle,state,final,accepting above] {$0567$}; \node (q02) at (100bp,160.73bp) [draw,circle,state] {$02$}; \node (q0237) at (285bp,166.73bp) [draw,circle,state,final,accepting below] {$0237$}; \node (q05) at (100bp,68.732bp) [draw,circle,state] {$05$}; \draw [->] (q057) ..controls (367.95bp,143.33bp) and (356.68bp,115.58bp) .. (340bp,95.732bp) .. controls (334.17bp,88.79bp) and (326.73bp,82.582bp) .. node[auto] {$b$} (q0567); \draw [->] (q0) ..controls (45.352bp,134.58bp) and (60.273bp,141.85bp) .. node[auto] {$a$} (q02); \draw [->] (q0237) to[loop above] node[auto] {$a$} (q0237); \draw [->] (q023) ..controls (213.27bp,203.89bp) and (232.48bp,226.69bp) .. (256bp,236.73bp) .. controls (279.71bp,246.86bp) and (289.57bp,244.97bp) .. (314bp,236.73bp) .. controls (330.09bp,231.3bp) and (345.38bp,220.3bp) .. node[auto] {$b$} (q057); \draw [->] (q023) ..controls (222.58bp,166.73bp) and (234.64bp,166.73bp) .. node[auto] {$a$} (q0237); \draw [->] (q02) ..controls (129.57bp,162.73bp) and (142.05bp,163.6bp) .. node[auto] {$a$} (q023); \draw [->] (q0567) to[loop below] node[auto] {$b$} (q0567); \draw [->] (q05) ..controls (129.65bp,65.401bp) and (142.24bp,63.937bp) .. node[auto] {$b$} (q056); \draw [->] (q056) ..controls (222.58bp,58.732bp) and (234.64bp,58.732bp) .. node[auto] {$b$} (q0567); \draw [->] (q0237) ..controls (322.23bp,165.23bp) and (331.57bp,165.88bp) .. (340bp,167.73bp) .. controls (343.63bp,168.53bp) and (347.33bp,169.66bp) .. node[auto] {$b$} (q057); \draw [->] (q056) ..controls (217.15bp,28.639bp) and (235.83bp,12.746bp) .. (256bp,5.7322bp) .. controls (280.35bp,-2.7337bp) and (288.93bp,-0.26493bp) .. (314bp,5.7322bp) .. controls (327.41bp,8.9409bp) and (341.18bp,15.299bp) .. node[auto,below] {$a$} (q027); \draw [->] (q05) ..controls (100bp,100.68bp) and (100bp,117.05bp) .. node[auto] {$a$} (q02); \draw [->] (q057) ..controls (397.04bp,148.37bp) and (402.36bp,127.76bp) .. (400bp,109.21bp) .. controls (398.44bp,96.972bp) and (395.4bp,83.809bp) .. node[auto] {$a$} (q027); \draw [->] (q027) ..controls (362.81bp,75.635bp) and (351.82bp,95.041bp) .. (340bp,110.73bp) .. controls (332.19bp,121.1bp) and (322.64bp,131.57bp) .. node[auto] {$a$} (q0237); \draw [->] (q0567) ..controls (324.14bp,51.105bp) and (336.81bp,48.57bp) .. node[auto,below] {$a$} (q027); \draw [->] (q027) ..controls (382bp,87.723bp) and (382bp,124.52bp) .. node[auto] {$b$} (q057); \draw [->] (q02) ..controls (115.85bp,134.94bp) and (120.35bp,122.5bp) .. (118bp,110.98bp) .. controls (116.93bp,105.75bp) and (115.19bp,100.36bp) .. node[auto] {$b$} (q05); \draw [->] (q0) ..controls (45.218bp,104.36bp) and (61.545bp,93.546bp) .. node[auto] {$b$} (q05); % \end{tikzpicture} %%% end ex1p2c %%% } \end{center} (À titre d'exemple, la transition étiquetée $b$ partant de l'état $0237$ conduit à l'état $057$ car les transitions étiquetées $b$ dans le NFA précédent et partant des états parmi $\{0,2,3,7\}$ sont $0\to 0$, $0\to 5$, $3\to 7$ et $7\to 7$. Tous les états contenant l'un des symboles $3,6,7$ sont finaux.) (2) On a affaire à un DFA (sous-entendu : \emph{complet}) dont tous les états sont accessibles, on peut donc appliquer directement l'algorithme de Moore. Une première partition sépare les états finaux, soit $023, 0237, 027, 056, 0567, 057$ des non-finaux, soit $0, 02, 05$. L'étape suivante distingue $02$ parce que sa $a$-transition conduit à une classe différente que celles de $0$ et $05$, et $05$ parce que sa $b$-transition conduit à une classe différente de $0$ et $02$. Les étapes suivantes ne changent rien. Finalement, on arrive à un automate à quatre états : \begin{center} %%% begin ex1p2d %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \begin{scope} \pgfsetstrokecolor{black} \definecolor{strokecol}{rgb}{1.0,1.0,1.0}; \pgfsetstrokecolor{strokecol} \definecolor{fillcol}{rgb}{1.0,1.0,1.0}; \pgfsetfillcolor{fillcol} \filldraw (0bp,0bp) -- (0bp,112bp) -- (200bp,112bp) -- (200bp,0bp) -- cycle; \end{scope} \node (q02) at (100bp,93bp) [draw,circle,state] {$02$}; \node (q0) at (18bp,56bp) [draw,circle,state,initial] {$0$}; \node (qA) at (182bp,60bp) [draw,circle,state,final] {$A$}; \node (q05) at (100bp,19bp) [draw,circle,state] {$05$}; \draw [->] (q0) ..controls (45.691bp,68.345bp) and (60.407bp,75.151bp) .. node[auto] {$a$} (q02); \draw [->] (qA) to[loop below] node[auto] {$a,b$} (qA); \draw [->] (q02) ..controls (129.2bp,81.367bp) and (143.35bp,75.529bp) .. node[auto] {$a$} (qA); \draw [->] (q05) ..controls (128.81bp,33.252bp) and (143.85bp,40.959bp) .. node[auto,below] {$b$} (qA); \draw [->] (q05) ..controls (100bp,46.09bp) and (100bp,55.041bp) .. node[auto] {$a$} (q02); \draw [->] (q02) ..controls (116.71bp,70.13bp) and (120.2bp,60.948bp) .. (118bp,52.251bp) .. controls (117.33bp,49.598bp) and (116.4bp,46.928bp) .. node[auto] {$b$} (q05); \draw [->] (q0) ..controls (45.691bp,43.655bp) and (60.407bp,36.849bp) .. node[auto] {$b$} (q05); % \end{tikzpicture} %%% end ex1p2d %%% \end{center} où $A$ représente la classe de tous les états finaux de l'automate précédent. La signification des quatre états est la suivante : l'état $0$ signifie que l'automate n'a encore rien lu, l'état $02$ signifie que l'automate vient de lire un $a$, le $05$ signifie qu'il vient de lire un $b$, le $A$ signifie qu'il a lu deux $a$ consécutifs ou bien deux $b$ consécutifs. Sur cette description, il est clair que l'automate accepte les mots contenant deux $a$ consécutifs ou bien deux $b$ consécutifs. (3) L'élimination des états $1$ à $6$ peut se faire dans un ordre quelconque et conduit à l'automate (à transitions étiquetées par des expressions rationnelles) suivant : \begin{center} %%% begin ex1p2a2 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q0) at (18bp,20.549bp) [draw,circle,state,initial] {$0$}; \node (q7) at (104bp,20.549bp) [draw,circle,state,final] {$7$}; \draw [->] (q0) ..controls (47.743bp,20.549bp) and (62.773bp,20.549bp) .. node[auto] {$aa$} (q7); \draw [->] (q0) ..controls (42.511bp,4.2138bp) and (55.796bp,-1.5495bp) .. (68bp,1.5495bp) .. controls (71.958bp,2.5545bp) and (75.953bp,4.1071bp) .. node[auto,below] {$bb$} (q7); \draw [->] (q0) to[loop below] node[auto] {$a,b$} (q0); \draw [->] (q7) to[loop below] node[auto] {$a,b$} (q7); % \end{tikzpicture} %%% end ex1p2a2 %%% \end{center} Il y a plusieurs flèches entre les mêmes états : quitte à les remplacer par des disjonctions, on obtient : \begin{center} %%% begin ex1p2a3 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q7) at (119bp,18bp) [draw,circle,state,final] {$7$}; \draw [->] (q0) ..controls (51.292bp,18bp) and (73.384bp,18bp) .. node[auto] {$aa|bb$} (q7); \draw [->] (q0) to[loop below] node[auto] {$a|b$} (q0); \draw [->] (q7) to[loop below] node[auto] {$a|b$} (q7); % \end{tikzpicture} %%% end ex1p2a3 %%% \end{center} Enfin, on doit éliminer les états $0$ et $7$ eux-mêmes : pour cela, on ajoute un nouvel état initial qui ne soit la cible d'aucune flèche et un nouvel état final d'où ne part aucune flèche, \begin{center} %%% begin ex1p2a4 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (qi) at (18bp,18bp) [draw,circle,state,initial] {$\phantom{0}$}; \node (q0) at (97bp,18bp) [draw,circle,state] {$0$}; \node (q7) at (198bp,18bp) [draw,circle,state] {$7$}; \node (qf) at (277bp,18bp) [draw,circle,state,final] {$\phantom{7}$}; \draw [->] (qi) ..controls (45.659bp,18bp) and (57.817bp,18bp) .. node[auto] {$\varepsilon$} (q0); \draw [->] (q7) ..controls (225.66bp,18bp) and (237.82bp,18bp) .. node[auto] {$\varepsilon$} (qf); \draw [->] (q0) ..controls (130.29bp,18bp) and (152.38bp,18bp) .. node[auto] {$aa|bb$} (q7); \draw [->] (q0) to[loop below] node[auto] {$a|b$} (q0); \draw [->] (q7) to[loop below] node[auto] {$a|b$} (q7); % \end{tikzpicture} %%% end ex1p2a4 %%% \end{center} Et l'élimination des états $0$ et $7$ dans un ordre quelconque conduit finalement à l'expression rationnelle $(a|b){*}(aa|bb)(a|b){*}$. \end{corrige} % \exercice Soit $\Sigma = \{a,b\}$. (1) Tracer l'automate de Thompson de l'expression rationnelle $a{*}(baa{*}){*}$. Cet automate est-il déterministe ? (2) En éliminer les transitions spontanées. (3) Déterminiser l'automate obtenu (on demande un automate complet). (4) Minimiser l'automate obtenu (on demande un automate complet). (5) Vérifier le résultat en décrivant en français le langage dénoté par l'expression rationnelle initiale et reconnu par l'automate finalement obtenu. \begin{corrige} (1) L'automate de Thompson de $a{*}(baa{*}){*}$ doit comporter $14$ états puisque cette expression rationnelle contient $7$ symboles parenthèses non comptées. Il est le suivant (où on a omis les $\varepsilon$ sur les transitions spontanées) : \begin{center} \scalebox{0.34}{% %%% begin ex3p1 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,45bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,18bp) [draw,circle,state,initial] {$0$}; \node (q3) at (255bp,18bp) [draw,circle,state] {$3$}; \node (q2) at (176bp,45bp) [draw,circle,state] {$2$}; \node (q5) at (413bp,48bp) [draw,circle,state] {$5$}; \node (q4) at (334bp,18bp) [draw,circle,state] {$4$}; \node (q7) at (571bp,86bp) [draw,circle,state] {$7$}; \node (q6) at (492bp,86bp) [draw,circle,state] {$6$}; \node (q9) at (729bp,86bp) [draw,circle,state] {$9$}; \node (q8) at (650bp,86bp) [draw,circle,state] {$8$}; \node (q11) at (891.49bp,125bp) [draw,circle,state] {$11$}; \node (q10) at (809.5bp,125bp) [draw,circle,state] {$10$}; \node (q13) at (1055.5bp,25bp) [draw,circle,state,final] {$13$}; \node (q12) at (973.49bp,63bp) [draw,circle,state] {$12$}; \draw [->] (q0) ..controls (59.7bp,17.371bp) and (103.03bp,16.838bp) .. (140bp,17bp) .. controls (169.56bp,17.13bp) and (203.43bp,17.448bp) .. node[auto] {{}} (q3); \draw [->] (q12) ..controls (939.5bp,48.432bp) and (914.89bp,40bp) .. (892.49bp,40bp) .. controls (491bp,40bp) and (491bp,40bp) .. (491bp,40bp) .. controls (474.34bp,40bp) and (455.77bp,41.875bp) .. node[auto] {{}} (q5); \draw [->] (q2) ..controls (203.44bp,35.73bp) and (216.64bp,31.102bp) .. node[auto] {{}} (q3); \draw [->] (q10) ..controls (835.62bp,135.26bp) and (845.21bp,137.3bp) .. (854bp,136bp) .. controls (856.94bp,135.57bp) and (859.98bp,134.94bp) .. node[auto] {$a$} (q11); \draw [->] (q7) ..controls (598.66bp,86bp) and (610.82bp,86bp) .. node[auto] {$a$} (q8); \draw [->] (q9) ..controls (788.12bp,80.488bp) and (892.85bp,70.553bp) .. node[auto] {{}} (q12); \draw [->] (q8) ..controls (677.66bp,86bp) and (689.82bp,86bp) .. node[auto] {{}} (q9); \draw [->] (q11) ..controls (915.87bp,107.43bp) and (926.56bp,99.325bp) .. (935.99bp,92bp) .. controls (940.47bp,88.526bp) and (945.22bp,84.783bp) .. node[auto] {{}} (q12); \draw [->] (q2) ..controls (152.62bp,39.018bp) and (146.07bp,37.685bp) .. (140bp,37bp) .. controls (134.92bp,36.427bp) and (129.53bp,36.741bp) .. node[auto] {{}} (q1); \draw [->] (q6) ..controls (519.66bp,86bp) and (531.82bp,86bp) .. node[auto] {{}} (q7); \draw [->] (q12) ..controls (1002.2bp,49.853bp) and (1016.2bp,43.176bp) .. node[auto] {{}} (q13); \draw [->] (q9) ..controls (756.02bp,98.925bp) and (770.16bp,105.95bp) .. node[auto] {{}} (q10); \draw [->] (q3) ..controls (282.66bp,18bp) and (294.82bp,18bp) .. node[auto] {{}} (q4); \draw [->] (q11) ..controls (866.59bp,118.91bp) and (860.06bp,117.66bp) .. (854bp,117bp) .. controls (848.92bp,116.45bp) and (843.55bp,116.73bp) .. node[auto] {{}} (q10); \draw [->] (q5) ..controls (440.12bp,60.892bp) and (454.27bp,67.873bp) .. node[auto] {$b$} (q6); \draw [->] (q4) ..controls (366.77bp,7.9414bp) and (390.7bp,2bp) .. (412bp,2bp) .. controls (412bp,2bp) and (412bp,2bp) .. (974.49bp,2bp) .. controls (992.87bp,2bp) and (1012.7bp,7.6737bp) .. node[auto] {{}} (q13); \draw [->] (q0) ..controls (45.436bp,27.27bp) and (58.635bp,31.898bp) .. node[auto] {{}} (q1); \draw [->] (q1) ..controls (121.23bp,55.953bp) and (131.02bp,58.496bp) .. (140bp,57bp) .. controls (143.13bp,56.478bp) and (146.36bp,55.711bp) .. node[auto] {$a$} (q2); \draw [->] (q4) ..controls (361.28bp,28.238bp) and (374.94bp,33.562bp) .. node[auto] {{}} (q5); % \end{tikzpicture} %%% end ex3p1 %%% } \end{center} Cet automate n'est pas déterministe : un automate comportant des ε-transitions est forcément non-déterministe. \smallbreak (2) Tous les états autres que $0$ (car il est initial) et $2,6,8,11$ (car des transitions non spontanées y aboutissent) vont disparaître ; les ε-fermetures $C(q)$ de ces états sont les suivantes : \begin{center} \begin{tabular}{r|l} $q$&ε-fermeture $C(q)$\\ \hline $0$&$\{0,1,3,4,5,13\}$\\ $2$&$\{1,2,3,4,5,13\}$\\ $6$&$\{6,7\}$\\ $8$&$\{5,8,9,10,12,13\}$\\ $11$&$\{5,10,11,12,13\}$\\ \end{tabular} \end{center} En remplaçant chaque transition $q^\sharp \to q'$ étiquetée d'un $x\in\Sigma$ dans l'automate par une transition $q\to q'$ pour chaque état $q$ tel que $q^\sharp \in C(q)$, on obtient le NFA suivant : \begin{center} %%% begin ex3p1b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q0) at (18bp,31.498bp) [draw,circle,state,initial,final,accepting below] {$0$}; \node (q2) at (97bp,61.498bp) [draw,circle,state,final] {$2$}; \node (q11) at (335.5bp,19.498bp) [draw,circle,state,final,accepting below] {$11$}; \node (q8) at (255bp,49.498bp) [draw,circle,state,final,accepting above] {$8$}; \node (q6) at (176bp,31.498bp) [draw,circle,state] {$6$}; \draw [->] (q0) ..controls (45.279bp,41.737bp) and (58.943bp,47.06bp) .. node[auto] {$a$} (q2); \draw [->] (q2) to[loop above] node[auto] {$a$} (q2); \draw [->] (q8) ..controls (282.44bp,39.394bp) and (295.8bp,34.29bp) .. node[auto] {$a$} (q11); \draw [->] (q11) to[loop above] node[auto] {$a$} (q11); \draw [->] (q11) ..controls (297.15bp,8.7001bp) and (264.63bp,2.1768bp) .. (237bp,7.4983bp) .. controls (224.85bp,9.8374bp) and (212.04bp,14.613bp) .. node[auto,near start] {$b$} (q6); \draw [->] (q0) ..controls (47.643bp,24.415bp) and (64.2bp,20.964bp) .. (79bp,19.498bp) .. controls (94.922bp,17.922bp) and (99.078bp,17.922bp) .. (115bp,19.498bp) .. controls (125.98bp,20.586bp) and (137.94bp,22.768bp) .. node[auto,below] {$b$} (q6); \draw [->] (q2) ..controls (124.28bp,51.26bp) and (137.94bp,45.936bp) .. node[auto] {$b$} (q6); \draw [->] (q8) ..controls (234.03bp,34.749bp) and (226.51bp,30.579bp) .. (219bp,28.498bp) .. controls (214.15bp,27.154bp) and (208.87bp,26.751bp) .. node[auto,near start] {$b$} (q6); \draw [->] (q6) ..controls (198.21bp,42.911bp) and (205.25bp,45.859bp) .. (212bp,47.498bp) .. controls (216.59bp,48.613bp) and (221.55bp,49.292bp) .. node[auto] {$a$} (q8); % \end{tikzpicture} %%% end ex3p1b %%% \end{center} Les états $0,2,8,11$ sont finaux car ce sont eux qui ont $13$ dans leur ε-fermeture. \smallbreak (3) L'automate ainsi obtenu est déjà déterministe incomplet ; pour le déterminiser-compléter, il n'y a qu'à ajouter un puits $\bot$ avec la seule transition qui manque, c'est-à-dire une transition étiquetée par $b$ depuis l'état $6$ (et des transitions de $\bot$ vers lui-même étiquetées $a$ et $b$). Nous ne représentons pas l'automate à $6$ états ainsi fabriqué. \smallbreak (4) On part de l'algorithme déterministe complet obtenu à la question (3), et on lui applique l'algorithme de minimisation. On sépare d'abord ses états en deux classes, les finaux $\{0,2,8,11\}$ et les non-finaux $\{6,\bot\}$. La transition étiquetée $a$ sépare les états $6$ et $\bot$ car le premier aboutit dans la classe $\{0,2,8,11\}$ tandis que le second aboutit dans la classe $\{6,\bot\}$. On vérifie ensuite qu'aucune transition ne sépare des états. L'automate minimal est donc le suivant : \begin{center} %%% begin ex3p1c %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q6) at (97bp,20.28bp) [draw,circle,state] {$6$}; \node (qbot) at (176bp,20.28bp) [draw,circle,state] {$\bot$}; \node (qF) at (18bp,20.28bp) [draw,circle,state,initial,final,accepting below] {$F$}; \draw [->] (q6) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$a$} (qF); \draw [->] (q6) ..controls (124.66bp,20.28bp) and (136.82bp,20.28bp) .. node[auto] {$b$} (qbot); \draw [->] (qbot) to[loop above] node[auto] {$a,b$} (qbot); \draw [->] (qF) to[loop above] node[auto] {$a$} (qF); \draw [->] (qF) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$b$} (q6); % \end{tikzpicture} %%% end ex3p1c %%% \end{center} où l'état $F$ représente la classe $0\equiv 2\equiv 8\equiv 11$. \smallbreak (5) Il s'agit du langage constitué des mots n'ayant jamais deux $b$ consécutifs ni de $b$ final, c'est-à-dire des mots dans lesquels chaque $b$ est suivi d'au moins un $a$ : l'expression rationnelle initiale le présente comme le langage constitués des mots formés d'un nombre quelconque de $a$ puis d'un nombre quelconque de répétitions d'un $b$ suivi d'au moins un $a$. L'automate final interdit les suites de deux $b$ consécutifs comme ceci : l'état $F$ correspond à la situation où on ne vient pas de rencontrer un $b$ (=la lettre précédente était un $a$ ou bien on vient de commencer le mot) et on n'en a jamais rencontré deux, l'état $6$ à la situation où on vient de rencontrer un $b$ et on n'en a jamais rencontré deux, et l'état $\bot$ à la situation où on a rencontré au moins une fois deux $b$ consécutifs. Avec cette description, il est clair que l'automate fait ce qui était demandé. \end{corrige} % \exercice Donner plusieurs (au moins trois) expressions rationnelles équivalentes dénotant le langage reconnu par l'automate suivant sur l'alphabet $\Sigma = \{a,b\}$ : \begin{center} %%% begin ex3p2 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (q1) at (97bp,20.28bp) [draw,circle,state] {$1$}; \node (q0) at (18bp,20.28bp) [draw,circle,state,initial,final,initial above,accepting below] {$0$}; \node (q2) at (176bp,20.28bp) [draw,circle,state] {$2$}; \draw [->] (q1) ..controls (74.757bp,3.6593bp) and (64.084bp,-1.2803bp) .. (54bp,1.2803bp) .. controls (50.042bp,2.2853bp) and (46.047bp,3.838bp) .. node[auto] {$b$} (q0); \draw [->] (q2) to[loop right] node[auto] {$b$} (q2); \draw [->] (q2) ..controls (153.76bp,3.6593bp) and (143.08bp,-1.2803bp) .. (133bp,1.2803bp) .. controls (129.04bp,2.2853bp) and (125.05bp,3.838bp) .. node[auto] {$a$} (q1); \draw [->] (q0) to[loop left] node[auto] {$a$} (q0); \draw [->] (q0) ..controls (45.659bp,20.28bp) and (57.817bp,20.28bp) .. node[auto] {$b$} (q1); \draw [->] (q1) ..controls (124.66bp,20.28bp) and (136.82bp,20.28bp) .. node[auto] {$a$} (q2); % \end{tikzpicture} %%% end ex3p2 %%% \end{center} (On pourra considérer les ordres suivants d'élimination des états : (A) $2,1,0$, ensuite (B) $1,2,0$ et enfin (C) $0,2,1$.) \begin{corrige} (A) Si on commence par éliminer l'état $2$ (en considérant l'automate comme un automate à transitions étiquetées par des expressions rationnelles), l'état $1$ reçoit une transition vers lui-même étiquetée $ab{*}a$. Si on élimine l'état $1$, l'état $0$ reçoit à la place une transition vers lui-même étiquetée par $b(ab{*}a){*}b$, qu'on peut fusionner avec la transition vers lui-même déjà existante étiquetée par $a$ pour une seule étiquetée par $a|b(ab{*}a){*}b$. Quitte éventuellement à ajouter un nouvel état initial (conduisant à $0$ par une transition spontanée) et un nouvel état final (vers lequel $0$ conduit par une transition spontanée) et à éliminer n'état $0$, on obtient finalement l'expression rationnelle \[ (a|b(ab{*}a){*}b){*} \] \smallbreak (B) Si on commence par éliminer l'état $1$, il apparaît une transition $0\to 2$ étiquetée $ba$ et une $2\to 0$ étiquetée $ab$ (si on veut appliquer l'algorithme de façon puremnet mécanique, l'état $1$ n'a pas de transition vers lui-même, c'est-à-dire qu'on pourrait l'étiqueter par $\bot$, symbole d'expression rationnelle qui dénote le lagange vide, et l'expression rationnelle $\bot{*}$ est équivalente à $\varepsilon$) ; mais il ne faut pas oublier que l'état $2$ reçoit lui aussi une transition vers lui-même (en passant par $1$) étiquetée $aa$, qu'on peut fusionner avec la transition vers lui-même déjà existante étiquetée par $b$ pour obtenir une transition étiquetée $b|aa$ ; de même, l'état $0$ reçoit une transition étiquetée $bb$, qu'on peut fusionner avec celle existante pour obtenir $a|bb$. L'élimination de l'état $2$ fait alors apparaître une transition de $0$ vers lui-même étiquetée $ba(b|aa){*}ab$, qu'on peut fusionner avec la transition vers lui-même déjà étiquetée par $a|bb$ pour une seule étiquetée par $a|bb|ba(b|aa){*}ab$. On obtient finalement \[ (a|bb|ba(b|aa){*}ab){*} \] (en particulier, cette expression est équivalente à celle obtenue précédemment). \smallbreak (C) Si on préfère commencer par éliminer l'état $0$, il faut au préalable ajouter un nouvel état initial $I$ (conduisant à $0$ par une transition spontanée) et un nouvel état final $F$ (vers lequel $0$ conduit par une transition spontanée). L'élimination de l'état $0$ fait apparaître une transition de $I$ vers $1$ étiquetée $a{*}b$, une transition $1$ vers $F$ étiquetée $ba{*}$, et une transition de l'état $1$ vers lui-même étiquetée $ba{*}b$, et enfin une transition de $I$ vers $F$ étiquetée $a{*}$. L'élimination de l'état $2$ fait apparaître une transition de $1$ vers lui-même étiquetée $ab{*}a$, qu'on peut fusionner avec celle déjà existante étiquetée $ba{*}b$ pour obtenir une transition $(ab{*}a|ba{*}b)$. Finalement, l'élimination de l'état $1$ done l'expression rationnelle \[ a{*}|a{*}b(ab{*}a|ba{*}b){*}ba{*} \] (toujours équivalente aux précédentes). \end{corrige} % \exercice On considère l'automate fini $M$ sur l'alphabet $\Sigma = \{a,b\}$ représenté par la figure suivante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (X) at (-80bp,0bp) [draw,circle,state,initial] {$X$}; \node (Y) at (80bp,0bp) [draw,circle,state,final] {$Y$}; \node (A1) at (-40bp,50bp) [draw,circle,state] {$A\phantom{'}$}; \node (A2) at (40bp,50bp) [draw,circle,state] {$A'$}; \node (B1) at (-40bp,-50bp) [draw,circle,state] {$B\phantom{'}$}; \node (B2) at (40bp,-50bp) [draw,circle,state] {$B'$}; \draw[->] (X) -- node[auto]{$\varepsilon$} (A1); \draw[->] (X) -- node[auto,below left]{$\varepsilon$} (B1); \draw[->] (A1) -- node[auto]{$a$} (A2); \draw[->] (B1) -- node[auto]{$b$} (B2); \draw[->] (A1) to[loop above] node[auto]{$b$} (A1); \draw[->] (A2) to[loop above] node[auto]{$b$} (A2); \draw[->] (B1) to[loop below] node[auto]{$a$} (B1); \draw[->] (B2) to[loop below] node[auto]{$a$} (B2); \draw[->] (A2) -- node[auto]{$\varepsilon$} (Y); \draw[->] (B2) -- node[auto,below right]{$\varepsilon$} (Y); \end{tikzpicture} \end{center} (0) De quelle sorte d'automate s'agit-il ? (Autrement dit : est-il déterministe ou non ? avec transitions spontanées ou non ?) (1a) Décrire brièvement, en français, le langage $L$ reconnu (=accepté) par l'automate $M$, puis donner une expression rationnelle qui le dénote. (On pourra préférer traiter la question (1b) d'abord.) (1b) Pour chacun des mots suivants, dire s'ils sont dans $L$ ou non : $\varepsilon$, $a$, $b$, $ab$, $aa$, $aab$, $aabb$, $abab$, $ababa$. (Note : il est recommandé de réutiliser ces mots pour vérifier rapidement les réponses aux questions suivantes et ainsi détecter d'éventuelles erreurs lors des transformations des automates.) (2) Éliminer les transitions spontanées de l'automate $M$. (On supprimera les états devenus inutiles.) On appellera $M_2$ l'automate obtenu. (3) Déterminiser l'automate $M_2$ obtenu en (2), si nécessaire. (On demande un automate déterministe complet.) On appellera $M_3$ l'automate déterminisé. Pour simplifier le travail du correcteur, on demande de représenter $M_3$ de sorte que les transitions étiquetées par $a$ soient, dans la mesure du possible, horizontales de la gauche vers la droite, et celles étiquetées par $b$, verticales du haut vers le bas. (4) Minimiser l'automate $M_3$ obtenu en (3), si nécessaire (justifier). (5) Donner un automate (de n'importe quelle sorte) qui reconnaît le langage $\overline{L} = \Sigma^*\setminus L$ complémentaire de $L$. (6) Décrire brièvement, en français, ce langage complémentaire $\overline{L}$. (7) (Question bonus, plus longue, à ne traiter qu'en dernier.) Calculer une expression rationnelle qui dénote ce langage complémentaire $\overline{L}$. (Ne pas hésiter à introduire des notations intermédiaires.) \begin{corrige} (0) L'automate $M$ est un automate fini non-déterministe à transitions spontanées, ou ε-NFA (le concept d'« automate déterministe à transitions spontanées » n'aurait tout simplement pas de sens). \smallbreak (1a) Le chemin par les états $X,A,A',Y$ accepte les mots exactement un $a$, c'est-à-dire le langage dénoté par $b{*}ab{*}$. Le chemin par les états $X,B,B',Y$ accepte les mots comportant exactement un $b$, c'est-à-dire le langage dénoté par $a{*}ba{*}$. L'automate $M$ dans son ensemble accepte les mots comportant exactement un $a$ ou (inclusif) exactement un $b$ (i.e. $L = \{w\in\Sigma^* : |w|_a = 1 \penalty0\ \textrm{ou}\penalty0\ |w|_b = 1\}$ si $|w|_x$ désigne le nombre total d'occurrences de la lettre $x$ dans le mot $w$). C'est le langage dénoté par l'expression rationnelle $b{*}ab{*} | a{*}ba{*}$ (nous notons ici et ailleurs $|$ pour la disjonction, qu'on peut aussi noter $+$). (1b) Parmi les mots proposés, $a$, $b$, $ab$ et $aab$ appartiennent à $L$, tandis que $\varepsilon$, $aa$, $aabb$, $abab$ et $ababa$ n'y appartiennent pas. \smallbreak (2) La ε-fermeture (arrière) de l'état $X$ est $\{X,A,B\}$ ; la ε-fermeture de l'état $A'$ est $\{A',Y\}$ et celle de l'état $B'$ est $\{B',Y\}$ ; les autres états sont leur propre ε-fermeture (i.e., celle-ci est un singleton). L'élimination des transitions spontanées conduit donc à l'automate $M_2$ suivant : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (X) at (-80bp,0bp) [draw,circle,state,initial] {$X$}; \node (A1) at (-40bp,50bp) [draw,circle,state] {$A\phantom{'}$}; \node (A2) at (40bp,50bp) [draw,circle,state,final] {$A'$}; \node (B1) at (-40bp,-50bp) [draw,circle,state] {$B\phantom{'}$}; \node (B2) at (40bp,-50bp) [draw,circle,state,final] {$B'$}; \draw[->] (X) -- node[auto]{$b$} (A1); \draw[->] (X) -- node[auto,below left]{$a$} (B1); \draw[->] (X) -- node[auto,below right]{$a$} (A2); \draw[->] (X) -- node[auto,above right]{$b$} (B2); \draw[->] (A1) -- node[auto]{$a$} (A2); \draw[->] (B1) -- node[auto]{$b$} (B2); \draw[->] (A1) to[loop above] node[auto]{$b$} (A1); \draw[->] (A2) to[loop above] node[auto]{$b$} (A2); \draw[->] (B1) to[loop below] node[auto]{$a$} (B1); \draw[->] (B2) to[loop below] node[auto]{$a$} (B2); \end{tikzpicture} \end{center} (On a supprimé l'état $Y$ qui est devenu inutile car aucune transition non-spontanée n'y conduit.) \smallbreak (3) L'algorithme de déterminisation conduit à l'automate $M_3$ suivant où, pour plus de lisibilité, les états finaux ont été marqués en les entourant deux fois plutôt que par une flèche sortante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (s00) at (0bp,0bp) [draw,rounded corners,state,initial] {$\{X\}$}; \node (s01) at (75bp,0bp) [draw,rounded corners,state,accepting by double] {$\{A',B\}$}; \node (s02) at (150bp,0bp) [draw,rounded corners,state] {$\{B\}$}; \node (s10) at (0bp,-50bp) [draw,rounded corners,state,accepting by double] {$\{A,B'\}$}; \node (s11) at (75bp,-50bp) [draw,rounded corners,state,accepting by double] {$\{A',B'\}$}; \node (s12) at (150bp,-50bp) [draw,rounded corners,state,accepting by double] {$\{B'\}$}; \node (s20) at (0bp,-100bp) [draw,rounded corners,state] {$\{A\}$}; \node (s21) at (75bp,-100bp) [draw,rounded corners,state,accepting by double] {$\{A'\}$}; \node (s22) at (150bp,-100bp) [draw,rounded corners,state] {$\varnothing$}; \draw[->] (s00) -- node[auto]{$a$} (s01); \draw[->] (s01) -- node[auto]{$a$} (s02); \draw[->] (s10) -- node[auto]{$a$} (s11); \draw[->] (s11) -- node[auto]{$a$} (s12); \draw[->] (s20) -- node[auto]{$a$} (s21); \draw[->] (s21) -- node[auto]{$a$} (s22); \draw[->] (s02) to[loop right] node[auto]{$a$} (s02); \draw[->] (s12) to[loop right] node[auto]{$a$} (s12); \draw[->] (s22) to[loop right] node[auto]{$a$} (s22); \draw[->] (s00) -- node[auto]{$b$} (s10); \draw[->] (s10) -- node[auto]{$b$} (s20); \draw[->] (s01) -- node[auto]{$b$} (s11); \draw[->] (s11) -- node[auto]{$b$} (s21); \draw[->] (s02) -- node[auto]{$b$} (s12); \draw[->] (s12) -- node[auto]{$b$} (s22); \draw[->] (s20) to[loop below] node[auto]{$b$} (s20); \draw[->] (s21) to[loop below] node[auto]{$b$} (s21); \draw[->] (s22) to[loop below] node[auto]{$b$} (s22); \end{tikzpicture} \end{center} Pour la commodité de la suite de la correction, on renomme les états de cet automate $M_3$ de la façon suivante : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (s00) at (0bp,0bp) [draw,rounded corners,state,initial] {$00$}; \node (s01) at (75bp,0bp) [draw,rounded corners,state,accepting by double] {$01$}; \node (s02) at (150bp,0bp) [draw,rounded corners,state] {$02$}; \node (s10) at (0bp,-50bp) [draw,rounded corners,state,accepting by double] {$10$}; \node (s11) at (75bp,-50bp) [draw,rounded corners,state,accepting by double] {$11$}; \node (s12) at (150bp,-50bp) [draw,rounded corners,state,accepting by double] {$12$}; \node (s20) at (0bp,-100bp) [draw,rounded corners,state] {$20$}; \node (s21) at (75bp,-100bp) [draw,rounded corners,state,accepting by double] {$21$}; \node (s22) at (150bp,-100bp) [draw,rounded corners,state] {$22$}; \draw[->] (s00) -- node[auto]{$a$} (s01); \draw[->] (s01) -- node[auto]{$a$} (s02); \draw[->] (s10) -- node[auto]{$a$} (s11); \draw[->] (s11) -- node[auto]{$a$} (s12); \draw[->] (s20) -- node[auto]{$a$} (s21); \draw[->] (s21) -- node[auto]{$a$} (s22); \draw[->] (s02) to[loop right] node[auto]{$a$} (s02); \draw[->] (s12) to[loop right] node[auto]{$a$} (s12); \draw[->] (s22) to[loop right] node[auto]{$a$} (s22); \draw[->] (s00) -- node[auto]{$b$} (s10); \draw[->] (s10) -- node[auto]{$b$} (s20); \draw[->] (s01) -- node[auto]{$b$} (s11); \draw[->] (s11) -- node[auto]{$b$} (s21); \draw[->] (s02) -- node[auto]{$b$} (s12); \draw[->] (s12) -- node[auto]{$b$} (s22); \draw[->] (s20) to[loop below] node[auto]{$b$} (s20); \draw[->] (s21) to[loop below] node[auto]{$b$} (s21); \draw[->] (s22) to[loop below] node[auto]{$b$} (s22); \end{tikzpicture} \end{center} Ici, l'état $0\bullet$ signifie que l'automate n'a pas rencontré de $a$, l'état $1\bullet$ qu'il en a rencontré exactement un, et l'état $2\bullet$ qu'il en a rencontré au moins deux ; les états $\bullet0$, $\bullet1$ et $\bullet2$ ont la même signification pour la lettre $b$. \smallbreak (4) L'automate $M_3$ est déjà minimal. En effet, l'algorithme de minimisation commence par séparer les classes $\{01,10,11,12,21\}$ (états finaux) et $\{00,02,20,22\}$ (états non-finaux) ; ensuite, la transition étiquetée par $a$ sépare la classe $\{01,10,11,12,21\}$ en $\{01,21\}$ (qui vont vers un état non-final) et $\{10,11,12\}$ (qui vont vers un état final), et la classe $\{00,02,20,22\}$ en $\{00,20\}$ (qui vont vers un état final) et $\{02,22\}$ (qui vont vers un non-final). La transition étiquetée par $b$ sépare ensuite en deux chacune des trois classes $\{00,20\}$, $\{01,21\}$ et $\{02,22\}$ (car le premier élément va dans la classe $\{10,11,12\}$ tandis que le second reste dans la même classe) et sépare en trois la classe $\{10,11,12\}$. On a donc séparé chacun des états. \smallbreak (5) Pour reconnaître le complémentaire du langage reconnu par un automate fini déterministe complet, il suffit d'échanger états finaux et non-finaux : on peut donc prendre l'automate dessiné en (3) avec, cette fois, la convention que les états simplement entourés sont finaux (et les doublement entourés sont non-finaux). Appelons-le $M_5$. \emph{Attention :} échanger états finaux et non-finaux ne marche pas pour reconnaître le complémentaire du langage reconnu par un automate non-déterministe ou incomplet (car la négation de « il existe un chemin qui va vers un état final » est « aucun chemin ne va vers un état final » et pas « il existe un chemin qui va vers un état non-final »). \smallbreak (6) Puisque $L$ est le langage formé des mots comportant exactement un $a$ ou (inclusif) exactement un $b$, son complémentaire $\overline{L}$ est formé des mots ayant un nombre différent de $1$ de $a$ \emph{et} un nombre différent de $1$ de $b$ ; si on préfère, il s'agit du langage comportant ($0$ ou au moins $2$ fois la lettre $a$) \emph{et} ($0$ ou au moins $2$ fois la lettre $b$). \smallbreak (7) L'élimination des états n'est pas trop complexe car l'automate $M_5$ a très peu de boucles. Éliminons simultanément tous les états non-finaux ($01$, $10$, $11$, $12$ et $21$), et profitons-en pour créer un nouvel (et unique) état final $F$ : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (s00) at (0bp,0bp) [draw,rounded corners,state,initial] {$00$}; \node (s02) at (100bp,0bp) [draw,rounded corners,state] {$02$}; \node (s20) at (0bp,-60bp) [draw,rounded corners,state] {$20$}; \node (s22) at (100bp,-60bp) [draw,rounded corners,state] {$22$}; \node (F) at (160bp,-60bp) [draw,circle,state,final] {$F$}; \draw[->] (s00) -- node[auto]{$aa$} (s02); \draw[->] (s20) -- node[auto]{$ab{*}a$} (s22); \draw[->] (s02) to[loop above] node[auto]{$a$} (s02); \draw[->] (s00) -- node[auto]{$bb$} (s20); \draw[->] (s02) -- node[auto]{$ba{*}b$} (s22); \draw[->] (s20) to[loop left] node[auto]{$b$} (s20); \draw[->] (s22) to[loop below] node[auto]{$a|b$} (s22); \draw[->] (s22) -- node[auto]{$\varepsilon$} (F); \draw[->] (s00) -- node[auto]{$r$} (s22); \draw[->,out=0,in=90] (s02) to node[auto]{$\varepsilon$} (F); \draw[->,out=270,in=270] (s20) to node[auto,below]{$\varepsilon$} (F); \draw[->] (s00) to[out=45,in=180] (100bp,40bp) to[out=0,in=45] node[auto,above]{$\varepsilon$} (F); \end{tikzpicture} \end{center} où $r := abaa{*}b \,|\, abbb{*}a \,|\, baaa{*}b \,|\, babb{*}a$ (correspondant aux quatre façons de passer de $00$ à $22$ dans le graphe ci-dessus). Éliminons l'état $02$ et l'état $20$ : \begin{center} \begin{tikzpicture}[>=latex,line join=bevel,automaton] \node (s00) at (0bp,0bp) [draw,rounded corners,state,initial] {$00$}; \node (s22) at (100bp,-60bp) [draw,rounded corners,state] {$22$}; \node (F) at (160bp,-60bp) [draw,circle,state,final] {$F$}; \draw[->] (s22) -- node[auto]{$\varepsilon$} (F); \draw[->] (s22) to[loop above] node[auto]{$a|b$} (s22); \draw[->] (s00) -- node[auto]{$r'$} (s22); \draw[->,out=0,in=90] (s00) to node[auto]{$\varepsilon|aaa{*}|bbb{*}$} (F); \end{tikzpicture} \end{center} où $r' := r \penalty0\,|\, aaa{*}ba{*}b \penalty0\,|\, bbb{*}ab{*}a = abaa{*}b \penalty0\,|\, abbb{*}a \penalty0\,|\, baaa{*}b \penalty0\,|\, babb{*}a \penalty0\,|\, aaa{*}ba{*}b \penalty0\,|\, bbb{*}ab{*}a$. On obtient finalement l'expression rationnelle suivante pour $\overline{L}$ : \[ \varepsilon\,|\,aaa{*}\,|\,bbb{*}\,|\,(abaa{*}b \,|\, abbb{*}a \,|\, baaa{*}b \,|\, babb{*}a \,|\, aaa{*}ba{*}b \,|\, bbb{*}ab{*}a)(a|b){*} \] Pour comprendre cette expression rationnelle, la disjonction de plus haut niveau correspond aux quatre possibilités : (i) $0$ fois la lettre $a$ et $0$ fois la lettre $b$, (ii) au moins $2$ fois la lettre $a$ et $0$ fois la lettre $b$, (iii) $0$ fois la lettre $a$ et au moins $2$ fois la lettre $b$, et (iv) au moins $2$ fois la lettre $a$ et au moins $2$ fois la lettre $b$. Pour mieux comprendre l'expression du cas (iv), on peut remarquer que $abaa{*}b \penalty0\,|\, baaa{*}b \penalty0\,|\, aaa{*}ba{*}b$ dénote le langage formé des mots comportant au moins deux $a$ et exactement deux $b$ et qui finissent par un $b$, et symétriquement $abbb{*}a \penalty0\,|\, babb{*}a \penalty0\,|\,bbb{*}ab{*}a$ dénote le langage formé des mots comportant au moins deux $b$ et exactement deux $a$ et qui finissent par un $a$ : l'expression du cas (iv) correspond donc à écrire un mot ayant au moins deux $a$ et au moins deux $b$ comme le premier préfixe qui vérifie cette propriété suivi d'un suffixe quelconque. (On pouvait utiliser directement ce raisonnement pour produire l'expression.) \end{corrige} % % % \subsection{Langages algébriques et grammaires hors contexte} \exercice Considérons le fragment simplifié suivant de la grammaire d'un langage de programmation hypothétique : \[ \begin{aligned} \mathit{Instruction} &\rightarrow \mathtt{foo} \;|\; \mathtt{bar} \;|\; \mathtt{qux} \;|\; \mathit{Conditional}\\ |&\phantom{\rightarrow} \mathtt{begin}\ \mathit{InstrList}\ \mathtt{end}\\ \mathit{Conditional} &\rightarrow \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{Instruction}\ \mathtt{else}\ \mathit{Instruction}\\ |&\phantom{\rightarrow} \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{Instruction}\\ \mathit{InstrList} &\rightarrow \mathit{Instruction} \;|\; \mathit{Instruction}\ \mathit{InstrList}\\ \mathit{Expression} &\rightarrow \mathtt{true} \;|\; \mathtt{false} \;|\; \mathtt{happy} \;|\; \mathtt{trippy}\\ \end{aligned} \] (Ici, les « lettres » ou tokens ont été écrits comme des mots, par exemple $\mathtt{foo}$ est une « lettre » : les terminaux sont écrits en police à espacement fixe tandis que les nonterminaux sont en italique et commencent par une majuscule. On prendra $\mathit{Instruction}$ pour axiome.) (1) Donner l'arbre d'analyse de : $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}\penalty0\ \mathtt{else}\penalty0\ \mathtt{bar}\penalty0\ \mathtt{else}\penalty0\ \mathtt{qux}$ ; expliquer brièvement pourquoi il n'y en a qu'un. (2) Donner deux arbres d'analyse distincts de : $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}\penalty0\ \mathtt{else}\penalty0\ \mathtt{bar}$. Que peut-on dire de la grammaire présentée ? (3) En supposant que, dans ce langage, $\mathtt{begin}\penalty0\ I\penalty0\ \penalty0\mathtt{end}$ (où $I$ est une instruction) a le même effet que $I$ seul, comment un programmeur peut-il réécrire l'instruction considérée en (2) pour obtenir un comportant équivalent à l'une ou l'autre des deux interprétations ? (4) Modifier légèrement la grammaire proposée de manière à obtenir une grammaire faiblement équivalente dans laquelle seul l'un des arbres d'analyse obtenus en (2) est possible (i.e., une grammaire qui force cette interprétation-là par défaut) ; on pourra être amené à introduire des nouveaux nonterminaux pour des variantes de $\mathit{Instruction}$ et $\mathit{Conditional}$ qui interdisent récursivement les conditionnelles sans $\mathtt{else}$. \begin{corrige} (1) L'arbre d'analyse de $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}\penalty0\ \mathtt{else}\penalty0\ \mathtt{bar}\penalty0\ \mathtt{else}\penalty0\ \mathtt{qux}$ est le suivant (en notant $I$, $C$ et $E$ pour $\mathit{Instruction}$, $\mathit{Condition}$ et $\mathit{Expression}$ respectivement) : \begin{center} \tikzstyle{automaton}=[scale=0.4] %%% begin ex2p1 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (foo) at (279bp,18bp) [draw,draw=none] {$\mathtt{foo}$}; \node (then1) at (207bp,90bp) [draw,draw=none] {$\mathtt{then}$}; \node (if0) at (27bp,234bp) [draw,draw=none] {$\mathtt{if}$}; \node (if1) at (63bp,90bp) [draw,draw=none] {$\mathtt{if}$}; \node (bar) at (423bp,18bp) [draw,draw=none] {$\mathtt{bar}$}; \node (I1) at (243bp,234bp) [draw,draw=none] {$I$}; \node (I0) at (207bp,378bp) [draw,draw=none] {$I$}; \node (I3) at (423bp,90bp) [draw,draw=none] {$I$}; \node (I2) at (279bp,90bp) [draw,draw=none] {$I$}; \node (I4) at (387bp,234bp) [draw,draw=none] {$I$}; \node (trippy) at (135bp,18bp) [draw,draw=none] {$\mathtt{trippy}$}; \node (else0) at (315bp,234bp) [draw,draw=none] {$\mathtt{else}$}; \node (else1) at (351bp,90bp) [draw,draw=none] {$\mathtt{else}$}; \node (qux) at (387bp,162bp) [draw,draw=none] {$\mathtt{qux}$}; \node (C1) at (243bp,162bp) [draw,draw=none] {$C$}; \node (then0) at (171bp,234bp) [draw,draw=none] {$\mathtt{then}$}; \node (C0) at (207bp,306bp) [draw,draw=none] {$C$}; \node (E1) at (135bp,90bp) [draw,draw=none] {$E$}; \node (E0) at (99bp,234bp) [draw,draw=none] {$E$}; \node (happy) at (99bp,162bp) [draw,draw=none] {$\mathtt{happy}$}; \draw [] (I2) ..controls (279bp,60.846bp) and (279bp,46.917bp) .. (foo); \draw [] (C0) ..controls (192.52bp,276.85bp) and (185.36bp,262.92bp) .. (then0); \draw [] (I0) ..controls (207bp,348.85bp) and (207bp,334.92bp) .. (C0); \draw [] (C0) ..controls (250.16bp,277.03bp) and (271.72bp,263.05bp) .. (else0); \draw [] (C1) ..controls (286.16bp,133.03bp) and (307.72bp,119.05bp) .. (else1); \draw [] (C1) ..controls (257.48bp,132.85bp) and (264.64bp,118.92bp) .. (I2); \draw [] (E0) ..controls (99bp,204.85bp) and (99bp,190.92bp) .. (happy); \draw [] (C1) ..controls (199.84bp,133.03bp) and (178.28bp,119.05bp) .. (E1); \draw [] (C1) ..controls (228.52bp,132.85bp) and (221.36bp,118.92bp) .. (then1); \draw [] (C0) ..controls (263.23bp,285.79bp) and (310.83bp,268.84bp) .. (351bp,252bp) .. controls (353.93bp,250.77bp) and (356.97bp,249.43bp) .. (I4); \draw [] (C1) ..controls (186.77bp,141.79bp) and (139.17bp,124.84bp) .. (99bp,108bp) .. controls (96.068bp,106.77bp) and (93.027bp,105.43bp) .. (if1); \draw [] (C0) ..controls (150.77bp,285.79bp) and (103.17bp,268.84bp) .. (63bp,252bp) .. controls (60.068bp,250.77bp) and (57.027bp,249.43bp) .. (if0); \draw [] (E1) ..controls (135bp,60.846bp) and (135bp,46.917bp) .. (trippy); \draw [] (C1) ..controls (299.23bp,141.79bp) and (346.83bp,124.84bp) .. (387bp,108bp) .. controls (389.93bp,106.77bp) and (392.97bp,105.43bp) .. (I3); \draw [] (C0) ..controls (221.48bp,276.85bp) and (228.64bp,262.92bp) .. (I1); \draw [] (I4) ..controls (387bp,204.85bp) and (387bp,190.92bp) .. (qux); \draw [] (I1) ..controls (243bp,204.85bp) and (243bp,190.92bp) .. (C1); \draw [] (I3) ..controls (423bp,60.846bp) and (423bp,46.917bp) .. (bar); \draw [] (C0) ..controls (163.84bp,277.03bp) and (142.28bp,263.05bp) .. (E0); % \end{tikzpicture} %%% end ex2p1 %%% \end{center} Il est le seul possible car une fois acquis que les deux $\mathtt{if}$ comportent chacun un $\mathtt{else}$, il se construit ensuite en descendant de façon unique (l'instruction est forcément une condition, qui s'analyse en $\mathtt{if}\ E\ \mathtt{then}\ I\ \mathtt{else}\ I$ de façon unique, et chacun des morceaux s'analyse de nouveau de façon unique). \vskip .5explus.1fil (2) Un arbre d'analyse possible consiste à associer le $\mathtt{else}\penalty0\ \mathtt{bar}$ avec $\mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}$ : \begin{center} \tikzstyle{automaton}=[scale=0.4] %%% begin ex2p1a %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (bar) at (423bp,18bp) [draw,draw=none] {$\mathtt{bar}$}; \node (then1) at (207bp,90bp) [draw,draw=none] {$\mathtt{then}$}; \node (if0) at (27bp,234bp) [draw,draw=none] {$\mathtt{if}$}; \node (if1) at (63bp,90bp) [draw,draw=none] {$\mathtt{if}$}; \node (I1) at (243bp,234bp) [draw,draw=none] {$I$}; \node (I0) at (135bp,378bp) [draw,draw=none] {$I$}; \node (I3) at (423bp,90bp) [draw,draw=none] {$I$}; \node (I2) at (279bp,90bp) [draw,draw=none] {$I$}; \node (trippy) at (135bp,18bp) [draw,draw=none] {$\mathtt{trippy}$}; \node (else1) at (351bp,90bp) [draw,draw=none] {$\mathtt{else}$}; \node (foo) at (279bp,18bp) [draw,draw=none] {$\mathtt{foo}$}; \node (C1) at (243bp,162bp) [draw,draw=none] {$C$}; \node (then0) at (171bp,234bp) [draw,draw=none] {$\mathtt{then}$}; \node (C0) at (135bp,306bp) [draw,draw=none] {$C$}; \node (E1) at (135bp,90bp) [draw,draw=none] {$E$}; \node (E0) at (99bp,234bp) [draw,draw=none] {$E$}; \node (happy) at (99bp,162bp) [draw,draw=none] {$\mathtt{happy}$}; \draw [] (I2) ..controls (279bp,60.846bp) and (279bp,46.917bp) .. (foo); \draw [] (C0) ..controls (149.48bp,276.85bp) and (156.64bp,262.92bp) .. (then0); \draw [] (I0) ..controls (135bp,348.85bp) and (135bp,334.92bp) .. (C0); \draw [] (C1) ..controls (228.52bp,132.85bp) and (221.36bp,118.92bp) .. (then1); \draw [] (C1) ..controls (286.16bp,133.03bp) and (307.72bp,119.05bp) .. (else1); \draw [] (I3) ..controls (423bp,60.846bp) and (423bp,46.917bp) .. (bar); \draw [] (E0) ..controls (99bp,204.85bp) and (99bp,190.92bp) .. (happy); \draw [] (C1) ..controls (199.84bp,133.03bp) and (178.28bp,119.05bp) .. (E1); \draw [] (C1) ..controls (186.77bp,141.79bp) and (139.17bp,124.84bp) .. (99bp,108bp) .. controls (96.068bp,106.77bp) and (93.027bp,105.43bp) .. (if1); \draw [] (C0) ..controls (91.844bp,277.03bp) and (70.277bp,263.05bp) .. (if0); \draw [] (E1) ..controls (135bp,60.846bp) and (135bp,46.917bp) .. (trippy); \draw [] (C1) ..controls (299.23bp,141.79bp) and (346.83bp,124.84bp) .. (387bp,108bp) .. controls (389.93bp,106.77bp) and (392.97bp,105.43bp) .. (I3); \draw [] (C0) ..controls (178.16bp,277.03bp) and (199.72bp,263.05bp) .. (I1); \draw [] (C1) ..controls (257.48bp,132.85bp) and (264.64bp,118.92bp) .. (I2); \draw [] (I1) ..controls (243bp,204.85bp) and (243bp,190.92bp) .. (C1); \draw [] (C0) ..controls (120.52bp,276.85bp) and (113.36bp,262.92bp) .. (E0); % \end{tikzpicture} %%% end ex2p1a %%% \end{center} un autre consiste à associer le $\mathtt{else}\penalty0\ \mathtt{bar}$ avec $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ ...$ : \begin{center} \tikzstyle{automaton}=[scale=0.4] %%% begin ex2p1b %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (bar) at (387bp,162bp) [draw,draw=none] {$\mathtt{bar}$}; \node (then1) at (279bp,90bp) [draw,draw=none] {$\mathtt{then}$}; \node (if0) at (27bp,234bp) [draw,draw=none] {$\mathtt{if}$}; \node (if1) at (135bp,90bp) [draw,draw=none] {$\mathtt{if}$}; \node (I1) at (243bp,234bp) [draw,draw=none] {$I$}; \node (I0) at (207bp,378bp) [draw,draw=none] {$I$}; \node (I2) at (351bp,90bp) [draw,draw=none] {$I$}; \node (I4) at (387bp,234bp) [draw,draw=none] {$I$}; \node (trippy) at (207bp,18bp) [draw,draw=none] {$\mathtt{trippy}$}; \node (else0) at (315bp,234bp) [draw,draw=none] {$\mathtt{else}$}; \node (foo) at (351bp,18bp) [draw,draw=none] {$\mathtt{foo}$}; \node (C1) at (243bp,162bp) [draw,draw=none] {$C$}; \node (then0) at (171bp,234bp) [draw,draw=none] {$\mathtt{then}$}; \node (C0) at (207bp,306bp) [draw,draw=none] {$C$}; \node (E1) at (207bp,90bp) [draw,draw=none] {$E$}; \node (E0) at (99bp,234bp) [draw,draw=none] {$E$}; \node (happy) at (99bp,162bp) [draw,draw=none] {$\mathtt{happy}$}; \draw [] (I2) ..controls (351bp,60.846bp) and (351bp,46.917bp) .. (foo); \draw [] (C0) ..controls (192.52bp,276.85bp) and (185.36bp,262.92bp) .. (then0); \draw [] (I0) ..controls (207bp,348.85bp) and (207bp,334.92bp) .. (C0); \draw [] (C0) ..controls (250.16bp,277.03bp) and (271.72bp,263.05bp) .. (else0); \draw [] (C1) ..controls (286.16bp,133.03bp) and (307.72bp,119.05bp) .. (I2); \draw [] (I4) ..controls (387bp,204.85bp) and (387bp,190.92bp) .. (bar); \draw [] (E0) ..controls (99bp,204.85bp) and (99bp,190.92bp) .. (happy); \draw [] (C1) ..controls (228.52bp,132.85bp) and (221.36bp,118.92bp) .. (E1); \draw [] (C0) ..controls (263.23bp,285.79bp) and (310.83bp,268.84bp) .. (351bp,252bp) .. controls (353.93bp,250.77bp) and (356.97bp,249.43bp) .. (I4); \draw [] (C1) ..controls (199.84bp,133.03bp) and (178.28bp,119.05bp) .. (if1); \draw [] (C0) ..controls (150.77bp,285.79bp) and (103.17bp,268.84bp) .. (63bp,252bp) .. controls (60.068bp,250.77bp) and (57.027bp,249.43bp) .. (if0); \draw [] (E1) ..controls (207bp,60.846bp) and (207bp,46.917bp) .. (trippy); \draw [] (C0) ..controls (221.48bp,276.85bp) and (228.64bp,262.92bp) .. (I1); \draw [] (C1) ..controls (257.48bp,132.85bp) and (264.64bp,118.92bp) .. (then1); \draw [] (I1) ..controls (243bp,204.85bp) and (243bp,190.92bp) .. (C1); \draw [] (C0) ..controls (163.84bp,277.03bp) and (142.28bp,263.05bp) .. (E0); % \end{tikzpicture} %%% end ex2p1b %%% \end{center} La grammaire présentée est donc ambiguë. \vskip .5explus.1fil (3) Pour forcer la première interprétation (le $\mathtt{else}\penalty0\ \mathtt{bar}$ se rapporte au $\mathtt{if}\penalty0\ \mathtt{trippy}$), on peut écrire : $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{begin}\penalty0\ \mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}\penalty0\ \mathtt{else}\penalty0\ \mathtt{bar}\penalty0\ \mathtt{end}$. Pour forcer la seconde interprétation (le $\mathtt{else}\penalty0\ \mathtt{bar}$ se rapporte au $\mathtt{if}\penalty0\ \mathtt{happy}$), on peut écrire : $\mathtt{if}\penalty0\ \mathtt{happy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{begin}\penalty0\ \mathtt{if}\penalty0\ \mathtt{trippy}\penalty0\ \mathtt{then}\penalty0\ \mathtt{foo}\penalty0\ \mathtt{end}\penalty0\ \mathtt{else}\penalty0\ \mathtt{bar}$. \vskip .5explus.1fil (4) Pour forcer la première interprétation (le $\mathtt{else}$ se rapporte au $\mathtt{if}$ le plus proche possible), on peut modifier la grammaire comme suit : \[ \begin{aligned} \mathit{Instruction} &\rightarrow \mathtt{foo} \;|\; \mathtt{bar} \;|\; \mathtt{qux} \;|\; \mathit{Conditional}\\ |&\phantom{\rightarrow} \mathtt{begin}\ \mathit{InstrList}\ \mathtt{end}\\ \mathit{InstrNoSC} &\rightarrow \mathtt{foo} \;|\; \mathtt{bar} \;|\; \mathtt{qux} \;|\; \mathit{CondNoSC}\\ |&\phantom{\rightarrow} \mathtt{begin}\ \mathit{InstrList}\ \mathtt{end}\\ \mathit{Conditional} &\rightarrow \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{InstrNoSC}\ \mathtt{else}\ \mathit{Instruction}\\ |&\phantom{\rightarrow} \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{Instruction}\\ \mathit{CondNoSC} &\rightarrow \mathtt{if}\ \mathit{Expression}\ \mathtt{then}\ \mathit{InstrNoSC}\ \mathtt{else}\ \mathit{InstrNoSC}\\ \mathit{InstrList} &\rightarrow \mathit{Instruction} \;|\; \mathit{Instruction}\ \mathit{InstrList}\\ \mathit{Expression} &\rightarrow \mathtt{true} \;|\; \mathtt{false} \;|\; \mathtt{happy} \;|\; \mathtt{trippy}\\ \end{aligned} \] L'idée est d'obliger une instruction conditionnelle qui apparaîtrait après le $\mathtt{then}$ d'une conditionnelle complète à être elle-même complète (elle ne peut pas être courte, car alors le $\mathtt{else}$ devrait se rattacher à elle), et ce, récursivement. On peut montrer que la grammaire ci-dessus est inambiguë et faiblement équivalente à celle de départ. On peut aussi fabriquer une grammaire inambiguë, faiblement équivalente à celle de départ, qui force l'autre interprétation (le $\mathtt{else}$ se rapporte au $\mathtt{if}$ le plus lointain possible), mais c'est nettement plus complexe (l'idée générale pour apparier un $\mathtt{else}$ avec un $\mathtt{if}...\mathtt{else}$ dans cette logique est de demander que \emph{soit} le $\mathtt{else}$ n'est suivi d'aucun autre $\mathtt{else}$, \emph{soit} toute instruction conditionnelle entre le $\mathtt{then}$ et le $\mathtt{else}$ est elle-même complète). Contrairement à la grammaire précédente, cette grammaire, bien qu'inambiguë, est probablement impossible à analyser avec un analyseur LR (ou même, déterministe). \end{corrige} % \exercice\label{non-square-words-is-algebraic} Soit $\Sigma = \{a,b\}$. On considère le langage $M$ des mots qui \emph{ne s'écrivent pas} sous la forme $ww$ avec $w\in\Sigma^*$ (c'est-à-dire sous la forme d'un carré ; autrement dit, le langage $M$ est le \emph{complémentaire} du langage $Q$ des carrés considéré dans l'exercice \ref{square-words-not-algebraic}) : par exemple, $M$ contient les mots $a$, $b$, $ab$, $aab$ et $aabb$ mais pas $\varepsilon$, $aa$, $abab$ ni $abaaba$. (0) Expliquer pourquoi tout mot sur $\Sigma$ de longueur impaire est dans $M$, et pourquoi un mot $x_1\cdots x_{2n}$ de longueur paire $2n$ est dans $M$ si et seulement si il existe $i$ tel que $x_i \neq x_{n+i}$. On considère par ailleurs la grammaire hors contexte $G$ (d'axiome $S$) \[ \begin{aligned} S &\rightarrow A \;|\; B \;|\; AB \;|\; BA\\ A &\rightarrow a \;|\; aAa \;|\; aAb \;|\; bAa \;|\; bAb\\ B &\rightarrow b \;|\; aBa \;|\; aBb \;|\; bBa \;|\; bBb\\ \end{aligned} \] (1) Décrire le langage $L(G,A)$ des mots dérivant de $A$ dans la grammaire $G$ (autrement dit, le langage engendré par la grammaire identique à $G$ mais ayant pour axiome $A$). Décrire de même $L(G,B)$. (2) Montrer que tout mot de longueur impaire est dans le langage $L(G)$ engendré par $G$. (3) Montrer que tout mot $t \in M$ de longueur paire est dans $L(G)$. (Indication : si $t = x_1\cdots x_{2n}$ est de longueur paire $2n$ et que $x_i \neq x_{n+i}$, on peut considérer la factorisation de $t$ en $x_1\cdots x_{2i-1}$ et $x_{2i}\cdots x_{2n}$.) (4) Montrer que tout mot de $L(G)$ de longueur paire est dans $M$. (5) En déduire que $M$ est algébrique. \begin{corrige} (0) En remarquant que si $n = |w|$ alors $|ww| = 2n$, on constate que tout mot de la forme $ww$ est de longueur paire, et de plus, que pour un mot de longueur $2n$, être de la forme $ww$ signifie que son préfixe de longueur $n$ soit égal à son suffixe de longueur $n$ ; c'est-à-dire, si $t = x_1\cdots x_{2n}$, que $x_1\cdots x_n = x_{n+1}\cdots x_{2n}$, ce qui signifie exactement $x_i = x_{n+i}$ pour tout $1\leq i\leq n$. (1) La règle $A \rightarrow a \,|\, aAa \,|\, aAb \,|\, bAa \,|\, bAb$ permet de faire à partir de $A$ une dérivation qui ajoute un nombre quelconque de fois une lettre ($a$ ou $b$) de chaque part de $A$, et finalement remplace ce $A$ par $a$. On obtient donc ainsi exactement les mots de longueur impaire ayant un $a$ comme lettre centrale : $L(G,A) = \{w_1aw_2 : |w_1|=|w_2|\}$. De même, $L(G,B) = \{w_1bw_2 : |w_1|=|w_2|\}$. (2) Tout mot de longueur impaire est soit dans $L(G,A)$ soit dans $L(G,B)$ selon que sa lettre centrale est un $a$ ou un $b$. Il est donc dans $L(G)$ en vertu des règles $S\rightarrow A$ et $S\rightarrow B$. (3) Soit $t = x_1\cdots x_{2n}$ un mot de $M$ de longueur paire $2n$ : d'après (0), il existe $i$ tel que $x_i \neq x_{n+i}$. Posons alors $u = x_1\cdots x_{2i-1}$ et $v = x_{2i}\cdots x_{2n}$. Chacun de $u$ et de $v$ est de longueur impaire. De plus, leurs lettres centrales sont respectivement $x_i$ et $x_{n+i}$, et elles sont différentes : l'une est donc un $a$ et l'autre un $b$ ; mettons sans perte de généralité que $x_i = a$ et $x_{n+i} = b$. Alors $u \in L(G,A)$ d'après (1) et $v \in L(G,B)$ : le mot $t = uv$ s'obtient donc par la règle $S \rightarrow AB$ (suivie de dérivations de $u$ à partir de $A$ et de $v$ a partir de $B$) : ceci montre bien $t \in L(G)$. (4) On a vu en (1) que tout mot dérivant de $A$ ou de $B$ est de longueur impaire. Un mot $t$ de $L(G)$ de longueur paire $2n$ dérive donc forcément de $AB$ ou de $BA$. Sans perte de généralité, supposons qu'il dérive de $AB$, et on veut montrer qu'il appartient à $M$. Appelons $u$ le facteur de $t$ qui dérive de $A$ et $v$ le facteur de $t$ qui dérive de $B$ : on sait alors (toujours d'après (1)) que $u$ s'écrit sous la forme $x_1\cdots x_{2i-1}$ où la lettre centrale $x_i$ vaut $a$, et que $v$ s'écrit sous la forme (quitte à continuer la numérotation des indices) $x_{2i}\cdots x_{2n}$ où la lettre centrale $x_{n+i}$ vaut $b$. Alors $x_{n+i} \neq x_i$ donc le mot $t$ est dans $M$ d'après (0). (5) On a $M = L(G)$ car d'après les questions précédentes, tout mot de longueur impaire est dans les deux et qu'un mot de longueur paire est dans l'un si et seulement si il est dans l'autre. On a donc montré que $M$ est algébrique. \end{corrige} % \exercice\label{square-words-not-algebraic} Soit $\Sigma = \{a,b\}$. Montrer que le langage $Q := \{ww : w\in\Sigma^*\}$ constitué des mots de la forme $ww$ (autrement dit, des carrés ; par exemple, $\varepsilon$, $aa$, $abab$, $abaaba$ ou encore $aabbaabb$ sont dans $Q$) n'est pas algébrique. On pourra pour cela considérer son intersection avec le langage $L_0$ dénoté par l'expression rationnelle $a{*}b{*}a{*}b{*}$ et appliquer le lemme de pompage. \begin{corrige} Supposons par l'absurde que $Q$ soit algébrique : alors son intersection avec le langage rationnel $L_0 = \{a^m b^n a^{m'} b^{n'} : m,n,m',n' \in \mathbb{N}\}$ est encore algébrique. Or $Q \cap L_0 = \{a^m b^n a^m b^n : m,n \in \mathbb{N}\}$. On va maintenant utiliser le lemme de pompage pour arriver à une contradiction. Appliquons le lemme de pompage pour les langages algébriques au langage $Q \cap L_0 = \{a^m b^n a^m b^n : m,n \in \mathbb{N}\}$ considéré : appelons $k$ l'entier dont le lemme de pompage garantit l'existence. Considérons le mot $t := a^k b^k a^k b^k$ : dans la suite de cette démonstration, on appellera « bloc » de $t$ un des quatre facteurs $a^k$, $b^k$, $a^k$ et $b^k$. D'après la propriété de $k$ garantie par le lemme de pompage, il doit exister une factorisation $t = uvwxy$ pour laquelle on a (i) $|vx|\geq 1$, (ii) $|vwx|\leq k$ et (iii) $uv^iwx^iy \in Q \cap L_0$ pour tout $i\geq 0$. Chacun de $v$ et de $x$ doit être contenu dans un seul bloc, i.e., doit être de la forme $a^\ell$ ou $b^\ell$, sinon sa répétition ($v^i$ ou $x^i$ pour $i\geq 2$, qui appartient à $L_0$ d'après (iii)) ferait apparaître plus d'alternations entre $a$ et $b$ que le langage $L_0$ ne le permet. Par ailleurs, la propriété (ii) assure que le facteur $vwx$ ne peut rencontrer qu'un ou deux blocs de $t$ (pas plus). Autrement dit, $v$ et $x$ sont contenus dans deux blocs de $t$ qui sont identiques ou bien consécutifs\footnote{La formulation est choisie pour avoir un sens même si $v$ ou $x$ est le mot vide (ce qui est possible \textit{a priori}).}. D'après la propriété (i), au moins l'un de $v$ et de $x$ n'est pas le mot vide. Si ce facteur non trivial est dans le premier bloc $a^k$, l'autre ne peut pas être dans l'autre bloc $a^k$ d'après ce qui vient d'être dit : donc $uv^iwx^iy$ est de la forme $a^{k'} b^n a^k b^k$ avec $k'>k$ si $i>1$, qui n'appartient pas à $Q\cap L_0$, une contradiction. De même, le facteur non trivial est dans le premier bloc $b^k$, l'autre ne peut pas être dans l'autre bloc $b^k$ : donc $uv^iwx^iy$ est de la forme $a^m b^{k'} a^{m'} b^k$ avec $k'>k$ si $i>1$, qui n'appartient pas à $Q\cap L_0$, de nouveau une contradiction. Les deux autres cas sont analogues. \end{corrige} \textbf{Remarque :} Les exercices \ref{non-square-words-is-algebraic} et \ref{square-words-not-algebraic} mis ensemble donnent un exemple explicite d'un langage $M$ algébrique dont le complémentaire $Q$ n'est pas algébrique. % \exercice On considère la grammaire hors contexte $G$ suivante (d'axiome $S$) sur l'alphabet $\Sigma = \{a,b\}$ : \[ S \rightarrow aSS \;|\; b \] Soit $L = L(G)$ le langage algébrique qu'elle engendre. (0) Donner quelques exemples de mots dans $L$. (1) Expliquer pourquoi un $w\in \Sigma^*$ appartient à $L$ si et seulement si : soit $w = b$, soit il existe $u,v\in L$ tels que $w = auv$. (2) En déduire par récurrence sur la longueur $|w|$ de $w$ que si $w \in L$ alors on a $wz \not\in L$ pour tout $z \in \Sigma^+$ (c'est-à-dire $z \in \Sigma^*$ et $z \neq \varepsilon$). Autrement dit : en ajoutant des lettres à la fin d'un mot de $L$ on obtient un mot qui n'appartient jamais à $L$. (Indication : si on a $auvz = au'v'$ on pourra considérer les cas (i) $|u'|>|u|$, (ii) $|u'|<|u|$ et (iii) $|u'|=|u|$.) (3) En déduire que si $auv = au'v'$ avec $u,v,u',v'\in L$ alors $u=u'$ et $v=v'$. (Indication analogue.) (4) En déduire que $G$ est inambiguë, c'est-à-dire que chaque mot $w\in L$ a un unique arbre d'analyse pour $G$ (on pourra reprendre l'analyse de la question (1) et procéder de nouveau par récurrence sur $|w|$). (5) En s'inspirant des questions précédentes, décrire un algorithme simple (en une seule fonction récursive) qui, donné un mot $w\in\Sigma^*$ renvoie la longueur du préfixe de $w$ appartenant à $L$ s'il existe (il est alors unique d'après la question (2)) ou bien « échec » s'il n'existe pas ; expliquer comment s'en servir pour décider si $w\in L$ (i.e., écrire une fonction qui répond vrai ou faux selon que $w\in L$ ou $w\not\in L$). \begin{corrige} (0) Quelques exemples de mots dans $L$ sont $b$, $abb$, $aabbb$, $ababb$ ou encore $aabbabb$. (1) Si $w \in L$, considérons un arbre d'analyse $\mathscr{W}$ de $w$ pour $G$ : sa racine, étiquetée $S$, doit avoir des fils étiquetés selon l'une des deux règles de la grammaire, soit $S\rightarrow b$ ou bien $S\rightarrow aSS$, autrement dit, soit elle a un unique fils étiqueté $b$, soit elle a trois fils étiquetés respectivement $a,S,S$. Dans le premier cas, le mot $w$ est simplement $b$ ; dans le second, les sous-arbres $\mathscr{U}, \mathscr{V}$ ayant pour racine les deux fils étiquetés $S$ sont encore des arbres d'analyse pour $G$, et si on appelle $u$ et $v$ les mots dont ils sont des arbres d'analyse (c'est-à-dire, ceux obtenus en lisant les feuilles de $\mathscr{U}$ et $\mathscr{V}$ respectivement par ordre de profondeur), alors on a $w = auv$ et $u,v\in L$ (puisqu'ils ont des arbres d'analyse pour $G$). La réciproque est analogue : le mot $b$ appartient trivialement à $L$, et si $u,v\in L$, ils ont des arbres d'analyse $\mathscr{U}, \mathscr{V}$ pour $G$, et on peut fabriquer un arbre d'analyse pour $w := auv$ qui a une racine étiquetée $S$ ayant trois fils étiquetés $a,S,S$, ces deux derniers ayant pour descendants des sous-arbres donnés par $\mathscr{U}$ et $\mathscr{V}$. \smallbreak (2) Montrons par récurrence sur $|w|$ que si $w \in L$ alors on a $wz \not\in L$ pour tout $z \in \Sigma^+$. La récurrence permet de supposer la conclusion déjà connue pour tout mot de longueur $<|w|$. D'après la question (1), le mot $w$ est soit $b$ soit de la forme $auv$ avec $u,v\in L$ et trivialement $|u|<|w|$ et $|v|<|w|$. Si $w=b$, il est évident qu'aucun mot de la forme $bz$ ne peut appartenir à $L$ (la question (1) montre que les seuls mots de $L$ sont le mot $b$ et des mots commençant par $a$). Il reste le cas $w = auv$ : on veut montrer que $wz$, c'est-à-dire $auvz$, n'appartient pas à $L$. Mais s'il y a appartenait, toujours d'après la question (1), il serait de la forme $au'v'$ (le cas $b$ étant trivialement exclu), où $u',v' \in L$ ; notamment, $uvz = u'v'$. Distinguons trois cas : (i) soit $|u'|>|u|$, mais alors $u$ est un préfixe strict de $u'$, c'est-à-dire que $u'$ peut s'écrire sous la forme $u' = ut$ pour un $t\in \Sigma^+$, et par l'hypothèse de récurrence, on a $u'\not\in L$, une contradiction ; (ii) soit $|u'|<|u|$, mais alors $u'$ est un préfixe strict de $u$, c'est-à-dire que $u$ peut s'écrire sous la forme $u = u't$ pour un $t\in\Sigma^+$, et par l'hypothèse de récurrence (puisque $|u'|<|u|<|w|$), on a $u\not\in L$, de nouveau une contradiction ; (iii) soit $|u'|=|u|$, donc $u'=u$ (puisqu'ils sont préfixes de même longueur du même mot $uvz = u'v'$), et on a alors $v' = vz$, mais comme $v\in L$, l'hypothèse de récurrence entraîne $v'\not\in L$, encore une contradiction. \smallbreak (3) Montrons que si $auv = au'v'$ avec $u,v,u',v'\in L$ alors $u=u'$ et $v=v'$. On a notamment $uv = u'v'$. Distinguons trois cas : (i) soit $|u'|>|u|$, mais alors $u$ est un préfixe strict de $u'$, c'est-à-dire que $u'$ peut s'écrire sous la forme $u' = ut$ pour un $t\in \Sigma^+$, et par la question (2), on a $u'\not\in L$, une contradiction ; (ii) soit $|u'|<|u|$, mais alors $u'$ est un préfixe strict de $u$, c'est-à-dire que $u$ peut s'écrire sous la forme $u = u't$ pour un $t\in\Sigma^+$, et par la question (2), on a $u\not\in L$, de nouveau une contradiction ; (iii) soit $|u'|=|u|$, donc $u'=u$ (puisqu'ils sont préfixes de même longueur du même mot $uv = u'v'$), et on a alors $v' = v$, la conclusion annoncéee. \smallbreak (4) Soit $w \in L$ : on veut montrer qu'il a un unique arbre d'analyse pour $G$. On procède par récurrence sur $|w|$, ce qui permet de supposer la conclusion connue pour tout mot de longueur $<|w|$. Comme on l'a expliqué en (1), il y a deux possibilités pour un arbre d'analyse de $w$ : soit la racine a un unique fils étiqueté $b$ et le mot analysé est $w=b$, soit la racine a trois fils étiquetés $a,S,S$, et des deux derniers fils partent des arbres d'analyse $\mathscr{U},\mathscr{V}$ de mots $u,v\in L$ tels que $w=auv$. Ces deux cas sont évidemment incompatibles : il reste donc simplement à expliquer que dans le dernier, $\mathscr{U}$ et $\mathscr{V}$ sont uniquement déterminés. Or la question (3) assure que $u,v$ (tels que $w=auv$) sont uniquement déterminés, et l'hypothèse de récurrence permet de conclure (comme $|u|<|w|$ et $|v|<|w|$) que les arbres d'analyse $\mathscr{U}$ et $\mathscr{V}$ de $u$ et $v$ sont uniquement déterminés, comme on le voulait. \smallbreak (5) Donné un mot $w\in\Sigma^*$, la fonction « rechercher préfixe dans $L$ » suivante renvoie la longueur du préfixe de $w$ appartenant à $L$, ou bien « échec » si ce préfixe n'existe pas : \begin{itemize} \item si $w=\varepsilon$, renvoyer échec, \item si la première lettre de $w$ est $b$, renvoyer $1$, \item sinon (la première lettre de $w$ est $a$), soit $x$ le suffixe de $w$ correspondant (c'est-à-dire $w = ax$, ou si on préfère, $x$ enlève la première lettre de $w$), \item appeler la fonction elle-même (rechercher préfixe dans $L$) sur $x$ : \item si elle échoue, renvoyer échec, \item si elle retourne $k$, soit $u$ le préfixe de $x$ de longueur $k$, et $y$ le suffixe correspondant (c'est-à-dire $x = uy$, ou si on préfère, $y$ enlève les $k$ premières lettres de $x$), \item appeler la fonction elle-même (rechercher préfixe dans $L$) sur $y$ : \item si elle échoue, renvoyer échec, \item si elle retourne $\ell$, retourner $1+k+\ell$ (en effet, on a $w = auvz$ où $u$ est de longueur $k$ et $v$ est de longueur $\ell$). \end{itemize} Pour savoir si un mot appartient à $w$, il s'agit simplement de vérifier que la valeur retournée (=la longueur du préfixe appartenant à $L$) n'est pas un échec et est égale à la longueur $|w|$. La terminaison de cet algorithme est claire par récurrence sur la longueur (chaque appel récursif est fait sur un mot de longueur strictement plus courte), et sa correction est garantie par les questions précédentes : les cas $b$ et $auv$ sont disjoints et dans le dernier cas, $u$ et $v$ sont uniquement déterminés (c'est ce qu'affirme la non-ambiguïté de la grammaire). (Il s'agit ici du cas le plus simple d'un analyseur LL, et l'algorithme présenté ci-dessus est essentiellement un analyseur LL(1) camouflé sous forme d'analyseur par descente récursive.) \end{corrige} % \exercice On considère la grammaire hors-contexte $G$ d'axiome $S$ et de nonterminaux $N = \{S, T, U, V\}$ sur l'alphabet $\Sigma = \{{\#},{@},{(},{)}, x, y, z\}$ (soit $7$ lettres) donnée par \[ \begin{aligned} S &\rightarrow T \;|\; S\mathbin{\#}T\\ T &\rightarrow U \;|\; U\mathbin{@}T\\ U &\rightarrow V \;|\; (\,S\,)\\ V &\rightarrow x \;|\; y \;|\; z\\ \end{aligned} \] (On pourra imaginer que $\#$ et $@$ sont deux opérations binaires, les parenthèses servent comme on s'y attend, et $x,y,z$ sont trois opérandes auxquelles on peut vouloir appliquer ces opérations.) La grammaire en question est inambiguë (on ne demande pas de le démontrer). (1) Donner les arbres d'analyse (=de dérivation) des mots suivants : (a) $x\mathbin{\#}y\mathbin{\#}z$, (b) $x\mathbin{\#}y\mathbin{@}z$, (c) $x\mathbin{@}y\mathbin{\#}z$, (d) $x\mathbin{@}y\mathbin{@}z$, (e) $(x\mathbin{\#}y)\mathbin{@}z$. \begin{corrige} On obtient les arbres d'analyse suivants : (a) % S>>>#.T>>>#.T>>> \begin{tikzpicture}[line join=bevel,baseline=(S0.base)] \node (S0) at (53.333bp,0.000bp) [draw=none] {$S$}; \node (S1) at (20.000bp,-30.000bp) [draw=none] {$S$}; \draw (S0) -- (S1); \node (S2) at (0.000bp,-60.000bp) [draw=none] {$S$}; \draw (S1) -- (S2); \node (T0) at (0.000bp,-80.000bp) [draw=none] {$T$}; \draw (S2) -- (T0); \node (U0) at (0.000bp,-100.000bp) [draw=none] {$U$}; \draw (T0) -- (U0); \node (V0) at (0.000bp,-120.000bp) [draw=none] {$V$}; \draw (U0) -- (V0); \node (x0) at (0.000bp,-140.000bp) [draw=none] {$x$}; \draw (V0) -- (x0); \node (o0) at (20.000bp,-60.000bp) [draw=none] {$\#$}; \draw (S1) -- (o0); \node (T1) at (40.000bp,-60.000bp) [draw=none] {$T$}; \draw (S1) -- (T1); \node (U1) at (40.000bp,-80.000bp) [draw=none] {$U$}; \draw (T1) -- (U1); \node (V1) at (40.000bp,-100.000bp) [draw=none] {$V$}; \draw (U1) -- (V1); \node (y0) at (40.000bp,-120.000bp) [draw=none] {$y$}; \draw (V1) -- (y0); \node (o1) at (60.000bp,-30.000bp) [draw=none] {$\#$}; \draw (S0) -- (o1); \node (T2) at (80.000bp,-30.000bp) [draw=none] {$T$}; \draw (S0) -- (T2); \node (U2) at (80.000bp,-50.000bp) [draw=none] {$U$}; \draw (T2) -- (U2); \node (V2) at (80.000bp,-70.000bp) [draw=none] {$V$}; \draw (U2) -- (V2); \node (z0) at (80.000bp,-90.000bp) [draw=none] {$z$}; \draw (V2) -- (z0); \end{tikzpicture} \hskip1cmplus5cmminus.5cm (b) % S>>>#.T>@.T>>>> \begin{tikzpicture}[line join=bevel,baseline=(S0.base)] \node (S0) at (26.667bp,0.000bp) [draw=none] {$S$}; \node (S1) at (0.000bp,-30.000bp) [draw=none] {$S$}; \draw (S0) -- (S1); \node (T0) at (0.000bp,-50.000bp) [draw=none] {$T$}; \draw (S1) -- (T0); \node (U0) at (0.000bp,-70.000bp) [draw=none] {$U$}; \draw (T0) -- (U0); \node (V0) at (0.000bp,-90.000bp) [draw=none] {$V$}; \draw (U0) -- (V0); \node (x0) at (0.000bp,-110.000bp) [draw=none] {$x$}; \draw (V0) -- (x0); \node (o0) at (20.000bp,-30.000bp) [draw=none] {$\#$}; \draw (S0) -- (o0); \node (T1) at (60.000bp,-30.000bp) [draw=none] {$T$}; \draw (S0) -- (T1); \node (U1) at (40.000bp,-60.000bp) [draw=none] {$U$}; \draw (T1) -- (U1); \node (V1) at (40.000bp,-80.000bp) [draw=none] {$V$}; \draw (U1) -- (V1); \node (y0) at (40.000bp,-100.000bp) [draw=none] {$y$}; \draw (V1) -- (y0); \node (o1) at (60.000bp,-60.000bp) [draw=none] {$@$}; \draw (T1) -- (o1); \node (T2) at (80.000bp,-60.000bp) [draw=none] {$T$}; \draw (T1) -- (T2); \node (U2) at (80.000bp,-80.000bp) [draw=none] {$U$}; \draw (T2) -- (U2); \node (V2) at (80.000bp,-100.000bp) [draw=none] {$V$}; \draw (U2) -- (V2); \node (z0) at (80.000bp,-120.000bp) [draw=none] {$z$}; \draw (V2) -- (z0); \end{tikzpicture} \hskip1cmplus5cmminus.5cm (c) % S>@.T>>>>#.T>>> \begin{tikzpicture}[line join=bevel,baseline=(S0.base)] \node (S0) at (53.333bp,0.000bp) [draw=none] {$S$}; \node (S1) at (20.000bp,-30.000bp) [draw=none] {$S$}; \draw (S0) -- (S1); \node (T0) at (20.000bp,-50.000bp) [draw=none] {$T$}; \draw (S1) -- (T0); \node (U0) at (0.000bp,-80.000bp) [draw=none] {$U$}; \draw (T0) -- (U0); \node (V0) at (0.000bp,-100.000bp) [draw=none] {$V$}; \draw (U0) -- (V0); \node (x0) at (0.000bp,-120.000bp) [draw=none] {$x$}; \draw (V0) -- (x0); \node (o0) at (20.000bp,-80.000bp) [draw=none] {$@$}; \draw (T0) -- (o0); \node (T1) at (40.000bp,-80.000bp) [draw=none] {$T$}; \draw (T0) -- (T1); \node (U1) at (40.000bp,-100.000bp) [draw=none] {$U$}; \draw (T1) -- (U1); \node (V1) at (40.000bp,-120.000bp) [draw=none] {$V$}; \draw (U1) -- (V1); \node (y0) at (40.000bp,-140.000bp) [draw=none] {$y$}; \draw (V1) -- (y0); \node (o1) at (60.000bp,-30.000bp) [draw=none] {$\#$}; \draw (S0) -- (o1); \node (T2) at (80.000bp,-30.000bp) [draw=none] {$T$}; \draw (S0) -- (T2); \node (U2) at (80.000bp,-50.000bp) [draw=none] {$U$}; \draw (T2) -- (U2); \node (V2) at (80.000bp,-70.000bp) [draw=none] {$V$}; \draw (U2) -- (V2); \node (z0) at (80.000bp,-90.000bp) [draw=none] {$z$}; \draw (V2) -- (z0); \end{tikzpicture} \hskip1cmplus5cmminus.5cm (d) % S>@.T>@.T>>>>> \begin{tikzpicture}[line join=bevel,baseline=(S0.base)] \node (S0) at (26.667bp,0.000bp) [draw=none] {$S$}; \node (T0) at (26.667bp,-20.000bp) [draw=none] {$T$}; \draw (S0) -- (T0); \node (U0) at (0.000bp,-50.000bp) [draw=none] {$U$}; \draw (T0) -- (U0); \node (V0) at (0.000bp,-70.000bp) [draw=none] {$V$}; \draw (U0) -- (V0); \node (x0) at (0.000bp,-90.000bp) [draw=none] {$x$}; \draw (V0) -- (x0); \node (o0) at (20.000bp,-50.000bp) [draw=none] {$@$}; \draw (T0) -- (o0); \node (T1) at (60.000bp,-50.000bp) [draw=none] {$T$}; \draw (T0) -- (T1); \node (U1) at (40.000bp,-80.000bp) [draw=none] {$U$}; \draw (T1) -- (U1); \node (V1) at (40.000bp,-100.000bp) [draw=none] {$V$}; \draw (U1) -- (V1); \node (y0) at (40.000bp,-120.000bp) [draw=none] {$y$}; \draw (V1) -- (y0); \node (o1) at (60.000bp,-80.000bp) [draw=none] {$@$}; \draw (T1) -- (o1); \node (T2) at (80.000bp,-80.000bp) [draw=none] {$T$}; \draw (T1) -- (T2); \node (U2) at (80.000bp,-100.000bp) [draw=none] {$U$}; \draw (T2) -- (U2); \node (V2) at (80.000bp,-120.000bp) [draw=none] {$V$}; \draw (U2) -- (V2); \node (z0) at (80.000bp,-140.000bp) [draw=none] {$z$}; \draw (V2) -- (z0); \end{tikzpicture} \hskip1cmplus5cmminus.5cm (e) % S>>>#.T>>>).>@.T>>>> \begin{tikzpicture}[line join=bevel,baseline=(S0.base)] \node (S0) at (86.667bp,0.000bp) [draw=none] {$S$}; \node (T0) at (86.667bp,-20.000bp) [draw=none] {$T$}; \draw (S0) -- (T0); \node (U0) at (40.000bp,-50.000bp) [draw=none] {$U$}; \draw (T0) -- (U0); \node (p0) at (0.000bp,-80.000bp) [draw=none] {$($}; \draw (U0) -- (p0); \node (S1) at (40.000bp,-80.000bp) [draw=none] {$S$}; \draw (U0) -- (S1); \node (S2) at (20.000bp,-110.000bp) [draw=none] {$S$}; \draw (S1) -- (S2); \node (T1) at (20.000bp,-130.000bp) [draw=none] {$T$}; \draw (S2) -- (T1); \node (U1) at (20.000bp,-150.000bp) [draw=none] {$U$}; \draw (T1) -- (U1); \node (V0) at (20.000bp,-170.000bp) [draw=none] {$V$}; \draw (U1) -- (V0); \node (x0) at (20.000bp,-190.000bp) [draw=none] {$x$}; \draw (V0) -- (x0); \node (o0) at (40.000bp,-110.000bp) [draw=none] {$\#$}; \draw (S1) -- (o0); \node (T2) at (60.000bp,-110.000bp) [draw=none] {$T$}; \draw (S1) -- (T2); \node (U2) at (60.000bp,-130.000bp) [draw=none] {$U$}; \draw (T2) -- (U2); \node (V1) at (60.000bp,-150.000bp) [draw=none] {$V$}; \draw (U2) -- (V1); \node (y0) at (60.000bp,-170.000bp) [draw=none] {$y$}; \draw (V1) -- (y0); \node (p1) at (80.000bp,-80.000bp) [draw=none] {$)$}; \draw (U0) -- (p1); \node (o1) at (100.000bp,-50.000bp) [draw=none] {$@$}; \draw (T0) -- (o1); \node (T3) at (120.000bp,-50.000bp) [draw=none] {$T$}; \draw (T0) -- (T3); \node (U3) at (120.000bp,-70.000bp) [draw=none] {$U$}; \draw (T3) -- (U3); \node (V2) at (120.000bp,-90.000bp) [draw=none] {$V$}; \draw (U3) -- (V2); \node (z0) at (120.000bp,-110.000bp) [draw=none] {$z$}; \draw (V2) -- (z0); \end{tikzpicture} \end{corrige} (2) En considérant que $(w)$ a le même effet ou la même valeur que $w$ : (a) L'une des deux opérations $\#$ et $@$ est-elle prioritaire\footnote{On dit qu'une opération binaire $\boxtimes$ est \emph{prioritaire} sur $\boxplus$ lorsque « $u\boxtimes v\boxplus w$ » se comprend comme « $(u\boxtimes v)\boxplus w$ » et « $u\boxplus v\boxtimes w$ » comme « $u\boxplus (v\boxtimes w)$ ».} sur l'autre ? Laquelle ?\quad (b) L'opération $\#$ s'associe-t-elle\footnote{On dit qu'une opération binaire $\boxdot$ \emph{s'associe à gauche} lorsque « $u\boxdot v\boxdot w$ » se comprend comme « $(u\boxdot v)\boxdot w$ », et \emph{s'associe à droite} lorsque « $u\boxdot v\boxdot w$ » se comprend comme « $u\boxdot (v\boxdot w)$ ».} à gauche ou à droite ?\quad (c) L'opération $@$ s'associe-t-elle à gauche ou à droite ? \begin{corrige} (a) Les arbres d'analyse (b) et (c) de la question (1) montrent que l'opération $@$ est prioritaire sur $\#$ (elle est toujours plus profonde dans l'arbre, c'est-à-dire appliquée en premier aux opérandes).\quad (b) L'arbre d'analyse (a) de la question (1) montre que $\#$ s'associe à gauche (le $\#$ entre les deux opérandes gauche est plus profond, c'est-à-dire appliqué en premier).\quad (c) Symétriquement, l'arbre d'analyse (d) de la question (1) montre que $@$ s'associe à droite. \end{corrige} \smallskip (La question (3) est indépendante de (1) et (2). Par ailleurs, on pourra, si on souhaite s'épargner des confusions, choisir d'appeler $a$ la lettre « parenthèse ouvrante » de $\Sigma$ et $b$ la lettre « parenthèse fermante » afin de les distinguer des parenthèses mathématiques.) (3) Soit $L = L(G)$ le langage engendré par $G$. Soit $M$ le langage des mots sur $\Sigma$ formés d'un certain nombre de parenthèses ouvrantes, puis de la lettre $x$, puis d'un certain nombre (possiblement différent) de parenthèses fermantes : autrement dit, des mots de la forme « ${(}^i\, x\, {)}^j$ », où on a noté « ${(}^i$ » une succession de $i$ parenthèses ouvrantes et « ${)}^j$ » une succession de $j$ parenthèses fermantes (on pourra noter ce mot $a^i x b^j$ si on préfère).\quad (a) Décrire le langage $L\cap M$ (des mots de $L$ qui appartiennent aussi à $M$).\quad (b) Ce langage $L\cap M$ est-il rationnel ?\quad (c) Le langage $L$ est-il rationnel ? \begin{corrige} (a) Cherchons pour quelles valeurs $(i,j) \in \mathbb{N}^2$ le mot « ${(}^i\, x\, {)}^j$ » de $M$ appartient à $L$. La dérivation $S \Rightarrow T \Rightarrow U \Rightarrow (S) \Rightarrow (T) \Rightarrow (U) \Rightarrow ((S)) \Rightarrow \cdots \Rightarrow{(}^i\, S\, {)}^i \Rightarrow{(}^i\, T\, {)}^i \Rightarrow{(}^i\, U\, {)}^i \Rightarrow{(}^i\, V\, {)}^i \Rightarrow{(}^i\, x\, {)}^i$ montre que c'est le cas si $j=i$, autrement dit s'il y a autant de parenthèses fermantes qu'ouvrantes. Mais réciproquement, la propriété d'avoir autant de parenthèses fermantes qu'ouvrantes est préservée par toutes les productions de $G$ (et est satisfaite par l'axiome), donc est vérifiée par tout mot de $L=L(G)$. On a donc prouvé que le $L\cap M$ est l'ensemble des mots de la forme « ${(}^i\, x\, {)}^i$ » où $i\in \mathbb{N}$. (b) Le langage $L\cap M$ constitué des mots de la forme « ${(}^n\, x\, {)}^n$ » où $i\in \mathbb{N}$ n'est pas rationnel. Cela résulte du lemme de pompage (presque exactement comme l'exemple du langage $\{a^n b^n : i\in\mathbb{N}\}$ donné en cours) : donnons l'argument en remplaçant la parenthèse ouvrante par $a$ et la parenthèse fermante par $b$ pour plus de clarté notationnelle. Appliquons le lemme de pompage pour les langages rationnels au langage $L \cap M = \{a^n x b^n : i\in\mathbb{N}\}$ supposé par l'absurde être rationnel : appelons $k$ l'entier dont le lemme de pompage garantit l'existence. Considérons le mot $t := a^k x b^k$ : il doit alors exister une factorisation $t = uvw$ pour laquelle on a (i) $|v|\geq 1$, (ii) $|uv|\leq k$ et (iii) $uv^iw \in L\cap M$ pour tout $i\geq 0$. La propriété (ii) assure que $uv$ est formé d'un certain nombre de répétitions de la lettre $a$ (car tout préfixe de longueur $\leq k$ de $a^k x b^k$ est de cette forme) ; disons $u = a^\ell$ et $v = a^m$, si bien que $w = a^{k-\ell-m} x b^k$. La propriété (i) donne $m\geq 1$. Enfin, la propriété (iii) affirme que le mot $uv^iw = a^{k+(i-1)m} x b^k$ appartient à $L\cap M$ ; mais dès que $i\neq 1$, ceci est faux : il suffit donc de prendre $i=0$ pour avoir une contradiction. (c) Le langage $M$ est rationnel puisqu'il est dénoté par l'expression rationnelle $a{*}xb{*}$ (toujours en notant $a$ la parenthèse ouvrante et $b$ la parenthèse fermante). Si le langage $L$ était rationnel, le langage $L\cap M$ le serait aussi (on sait que l'intersection de deux langages rationnels est rationnelle), ce qui n'est pas le cas d'après la question (b). Le langage $L$ n'est donc pas rationnel. \end{corrige} % \exercice On considère la grammaire hors contexte $G$ suivante (d'axiome $S$) sur l'alphabet $\Sigma = \{a,b\}$ : \[ S \rightarrow SaS \;|\; b \] Soit $L = L(G)$ le langage algébrique qu'elle engendre. (0) Donner quelques exemples de mots dans $L$. (1) Cette grammaire $G$ est-elle ambiguë ? (2) Décrire simplement le langage $L$. (3) Donner une grammaire inambiguë engendrant le même langage $L$ que $G$. \begin{corrige} (0) Quelques exemples de mots dans $L$ sont $b$, $bab$, $babab$, et ainsi de suite (cf. (2)). (1) La grammaire $G$ est ambiguë : le mot $babab$ a deux arbres d'analyse différents, à savoir \begin{center} \tikzstyle{automaton}=[scale=0.5] %%% begin ex3pt1 %%% \begin{tikzpicture}[>=latex,line join=bevel,automaton] %% \node (S3) at (27bp,90bp) [draw,draw=none] {$S$}; \node (S2) at (243bp,162bp) [draw,draw=none] {$S$}; \node (S1) at (99bp,162bp) [draw,draw=none] {$S$}; \node (S0) at (171bp,234bp) [draw,draw=none] {$S$}; \node (S4) at (171bp,90bp) [draw,draw=none] {$S$}; \node (a1) at (99bp,90bp) [draw,draw=none] {$a$}; \node (a0) at (171bp,162bp) [draw,draw=none] {$a$}; \node (b0) at (243bp,90bp) [draw,draw=none] {$b$}; \node (b1) at (27bp,18bp) [draw,draw=none] {$b$}; \node (b2) at (171bp,18bp) [draw,draw=none] {$b$}; \draw [] (S1) ..controls (70.042bp,132.85bp) and (55.714bp,118.92bp) .. (S3); \draw [] (S0) ..controls (142.04bp,204.85bp) and (127.71bp,190.92bp) .. (S1); \draw [] (S0) ..controls (171bp,204.85bp) and (171bp,190.92bp) .. (a0); \draw [] (S2) ..controls (243bp,132.85bp) and (243bp,118.92bp) .. (b0); \draw [] (S1) ..controls (99bp,132.85bp) and (99bp,118.92bp) .. (a1); \draw [] (S0) ..controls (199.96bp,204.85bp) and (214.29bp,190.92bp) .. (S2); \draw [] (S3) ..controls (27bp,60.846bp) and (27bp,46.917bp) .. (b1); \draw [] (S4) ..controls (171bp,60.846bp) and (171bp,46.917bp) .. (b2); \draw [] (S1) ..controls (127.96bp,132.85bp) and (142.29bp,118.92bp) .. (S4); % \end{tikzpicture} %%% end ex3pt1 %%% \end{center} et son symétrique par rapport à l'axe vertical. \smallbreak (2) Montrons que $L$ est égal au langage $L_{(ba){*}b}$ dénoté par l'expression rationnelle $(ba){*}b$ comme la question (0) le laisse entrevoir. Pour cela, il suffit de voir que l'ensemble des pseudo-mots (:= mots sur l'ensemble des terminaux et des nonterminaux) qu'on peut dériver de $S$ dans $G$ est le langage $((S|b)a){*}(S|b)$ constitué des pseudo-mots de la forme $xaxax\cdots ax$ où chaque $x$ est soit un $S$ soit un $b$, indépendamment les uns des autres. Or il est clair que remplacer un $x$ (et notamment, remplacer un $S$) par $SaS$ (qui est de la forme $xax$) dans un pseudo-mot de cette forme donne encore un pseudo-mot de cette forme : ceci montre qu'une dérivation de $G$, quelle que soit l'application faite de la règle $S\rightarrow SaS$, donne des pseudo-mots de cette forme, donc tout pseudo-mot obtenu par dérivation de $S$ dans la grammaire $G$ est de la forme qu'on vient de dire ; et réciproquement, il est facile de produire n'importe quel nombre $n$ de répéritions du motif $aS$ en appliquant $n$ fois la règle $S\rightarrow SaS$ à partir de $S$, et on peut ensuite librement transformer certains $S$ en $b$. \smallbreak (3) La grammaire $G'$ donnée par $S \rightarrow baS\,|\,b$ engendre le même langage que $G$ d'après la question précédente ; et il est évident que cette grammaire est inambiguë : toutes les dérivations sont de la forme $S \Rightarrow baS \Rightarrow babaS \Rightarrow (ba)^n S$ suivie éventuellement de $\Rightarrow (ba)^n b$. \end{corrige} % % % \subsection{Introduction à la calculabilité} \exercice Soit $\Sigma$ un alphabet (fini, non vide) fixé. Les questions suivantes sont indépendantes (mais on remarquera leur parallélisme). Ne pas hésiter à décrire les algorithmes de façon succincte et informelle. (1) Expliquer, au moyen des résultats vus en cours, pourquoi il existe un algorithme $A_1$ qui, étant donnée une expression rationnelle $r$ sur $\Sigma$, décide si le langage $L_r$ dénoté par $r$ est différent du langage $\Sigma^*$ de tous les mots sur $\Sigma$. (Autrement dit, l'algorithme $A_1$ doit prendre en entrée une expression rationnelle $r$, terminer en temps fini, et répondre « vrai » s'il existe un mot $w\in\Sigma^*$ tel que $w\not\in L_r$ et « faux » si $L_r = \Sigma^*$. On ne demande pas que l'algorithme soit efficace.) (2) Expliquer pourquoi il existe un algorithme $A_2$ qui, étant donnée une grammaire hors contexte $G$ sur $\Sigma$, « semi-décide » si le langage $L_G$ engendré par $G$ est différent du langage $\Sigma^*$ de tous les mots. (« Semi-décider » signifie que l'algorithme $A_2$ doit prendre en entrée une grammaire hors contexte $G$, terminer en temps fini en répondant « vrai » s'il existe un mot $w\in\Sigma^*$ tel que $w\not\in L_G$, et ne pas terminer\footnote{On peut admettre qu'il termine parfois en répondant « faux », mais ce ne sera pas utile.} si $L_G = \Sigma^*$.) Indication : on peut tester tous les mots possibles. (3) Expliquer pourquoi il existe un algorithme $A_3$ comme suit : on lui fournit en entrée un algorithme $T$ qui décide un langage $L_T \subseteq \Sigma^*$ (c'est-à-dire que $T$ termine toujours en temps fini quand on lui présente un mot sur $\Sigma$, et répond « vrai » ou « faux », et $L_T$ est le langage des mots sur lesquels il répond « vrai »), et l'algorithme $A_3$ doit semi-décider si $L_T$ est différent de $\Sigma^*$. (C'est-à-dire que $A_3$ doit terminer en répondant « vrai » s'il existe un mot $w\in\Sigma^*$ tel que $w\not\in L_T$, et ne pas terminer si $L_T = \Sigma^*$.) Indication : la même approche permet de traiter les questions (2) et (3). (4) Expliquer pourquoi il \emph{n'existe pas} d'algorithme $A_4$ qui, dans les mêmes conditions que $A_3$, décide (au lieu de seulement semi-décider) si $L_T$ est différent de $\Sigma^*$. (C'est-à-dire que $A_4$ est censé terminer toujours, et répondre « vrai » s'il existe un mot $w\in\Sigma^*$ tel que $w\not\in L_T$, et « faux » si $L_T = \Sigma^*$.) Indication : expliquer comment on pourrait utiliser un tel $A_4$ pour résoudre le problème de l'arrêt, en cherchant à fabriquer un $T$ qui rejette un mot précisément si un programme donné s'arrête. \begin{corrige} (1) Donnée une expression rationnelle $r$, on sait qu'on peut algorithmiquement fabriquer un automate fini non-déterministe à transitions spontanées qui reconnaît exactement le langage $L_r$ dénoté par $r$, et ensuite éliminer les transitions spontanées et déterminiser l'automate pour obtenir un automate fini déterministe complet reconnaissant $L_r$. Sur un tel automate, savoir si $L_r \neq \Sigma^*$ est trivial : dès lors qu'il existe un état $q$ non-final accessible, il existe un mot rejeté par l'automate (i.e., n'appartenant pas à $L_r$), à savoir le mot lu en suivant les étiquettes d'un chemin quelconque de l'état initial $q_0$ jusqu'à $q$, et inversement, si tous les états sont finaux, il est trivial que l'automate accepte tous les mots. (On pouvait aussi minimiser l'automate et le comparer à l'automate minimal trivial qui reconnaît le langage $\Sigma^*$.) \smallbreak (2) On sait qu'il existe un algorithme qui, donnée une grammaire hors-contexte $G$ et un mot $w$, décide si $w \in L_G$. Pour semi-décider s'il existe un $w$ tel que $w \not\in L_G$, il suffit de tester tous les mots possibles : plus exactement, on construit un algorithme $A_2$ qui effectue une boucle infinie sur tous les $w\in\Sigma^*$ (il est évidemment algorithmiquement faisable d'énumérer tous les mots sur $\Sigma$) et, pour chacun, teste si $w \in L_G$, et si ce n'est pas le cas, termine immédiatement en répondant « vrai » (on a trouvé un $w$ n'appartenant pas à $L_G$), tandis que si c'est le cas, l'algorithme $A_2$ ne terminera jamais. \smallbreak (3) On procède exactement comme en (2) : par hypothèse on dispose d'un algorithme $T$ qui, donné un mot $w$, décide si $w \in L_T$. Pour semi-décider s'il existe un $w$ tel que $w \not\in L_T$, il suffit de tester tous les mots possibles : plus exactement, on construit un algorithme $A_3$ qui effectue une boucle infinie sur tous les $w\in\Sigma^*$ et, pour chacun, teste si $w \in L_T$ (en lançant l'algorithme $T$ qui, par hypothèse, termine toujours), et si ce n'est pas le cas, termine immédiatement en répondant « vrai » (on a trouvé un $w$ n'appartenant pas à $L_T$), tandis que si c'est le cas, l'algorithme $A_3$ ne terminera jamais. \smallbreak (4) Supposons par l'absurde qu'on dispose d'un algorithme $A_4$ comme on vient de dire, et montrons pour arriver à une contradiction qu'on peut s'en servir pour résoudre le problème de l'arrêt. On se donne donc un algorithme $S$ et une entrée $x$ de $S$ et on cherche à savoir (en utilisant $A_4$) si $S$ termine sur l'entrée $x$. Pour cela, on va construire un $T$ auquel appliquer $A_4$. Voici une solution possible : donné un mot $w \in \Sigma^*$, le programme $T$ ne considère que la longueur $|w|$ de $w$, et lance (=simule) l'exécution de $S$ sur l'entrée $x$ pour au plus $|w|$ étapes : si l'exécution termine dans le temps imparti, alors $T$ rejette le mot $w$, sinon, il l'accepte (dans tous les cas, $T$ termine et répond « vrai » ou « faux », donc il est une entrée légitime à $A_4$). Cette construction fait que $L_T$ rejette au moins un mot précisément lorsque $S$ termine sur $x$ : si au contraire $S$ ne termine pas sur $x$, alors $L_T = \Sigma^*$. L'utilisation de $A_4$ sur $T$ permet donc de savoir algorithmiquement si $S$ termine sur $x$, ce qui contredit l'indécidabilité du problème de l'arrêt. \textit{Variante de la même idée :} on appelle « trace d'exécution » de $S$ sur $x$ un mot $w$ qui code le calcul complet de l'exécution de $S$ sur $x$ (par exemple, si on voit $S$ comme une machine de Turing, l'état courant et le contenu du ruban à chaque étape), du début à l'arrêt. Une telle trace d'exécution existe donc précisément si $S$ termine sur $x$. Or il est visiblement décidable de savoir si un mot $w$ donné est une trace d'exécution (il suffit de vérifier qu'à chaque étape la machine a bien fait ce qu'elle devait faire). On peut donc écrire un algorithme $T$ qui termine toujours et accepte précisément les mots qui \emph{ne sont pas} une trace d'exécution de $S$ sur $x$. Le fait que $L_T$ soit différent de $\Sigma^*$ signifie alors exactement qu'une trace d'exécution existe, donc que $S$ termine sur $x$. Ainsi l'utilisation de $A_4$ permet de savoir algorithmiquement si $S$ termine sur $x$, ce qui contredit l'indécidabilité du problème de l'arrêt. \end{corrige} % \exercice (1) Soit $\Sigma$ un alphabet (i.e., un ensemble fini). L'ensemble $L = \{u^k : u\in\Sigma^*, k\geq 2\}$ des mots qui sont une puissance $k$-ième pour un $k\geq 2$ est-il décidable ? Semi-décidable ? (2) L'ensemble des $e \in \mathbb{N}$ tels que l'exécution du $e$-ième programme (ou, si on préfère, de la $e$-ième machine de Turing), exécuté sur l'entrée $42$, termine en au plus $10^{1000+e}$ étapes est-il décidable ? Semi-décidable ? (3) L'ensemble des $e \in \mathbb{N}$ tels que l'exécution du $e$-ième programme (ou, si on préfère, de la $e$-ième machine de Turing), exécuté sur l'entrée $42$, termine en temps fini est-il décidable ? Semi-décidable ? (On pourra montrer qu'on peut y ramener le problème de l'arrêt.) \begin{corrige} (1) Si $w = u^k$ pour un certain $u\neq\varepsilon$, alors nécessairement $k\leq |w|$ puisque $|w|=k\cdot|u|$. On dispose donc de l'algorithme suivant pour décider si $w\in L$ : si $w=\varepsilon$, retourner vrai immédiatement ; sinon, pour $k$ allant de $2$ à $|w|$ et qui divise $|w|$, considérer les $k$ facteurs successifs de $w$ de longueur $|w|/k$ (c'est-à-dire, pour $0\leq i 0$, on peut effectuer une boucle pour un nombre de facteurs $k$ allant de $1$ à $n$, et, pour chaque $k$, effectuer $k$ boucles emboîtées pour déterminer les limites des facteurs $u_1,\ldots,u_k \in \Sigma^+$ tels que $w = u_1\cdots u_k$ (il suffit par exemple de faire boucler $i_1,\ldots,i_k$ chacun de $1$ à $n$, et lorsque $i_1+\cdots+i_k = n$, appeler $u_j$ le facteur de $w$ de longueur $i_j$ commençant à la position $i_1+\cdots+i_{j-1}$). Pour chaque factorisation comme on vient de le dire, on teste si tous les $u_i$ appartiennent à $L$, et si c'est le cas on renvoie vrai (le mot $w$ appartient à $L^*$) ; si aucune factorisation ne convient, on renvoie faux. (Dans l'algorithme qui précède, on a écarté les factorisations faisant intervenir le mot vide, car si $w$ est factorisable en mots de $L$ en faisant intervenir le mot vide, quitte à retirer celui-ci, il est encore factorisable en mots non vides de $L$.) \smallbreak (B) Les algorithmes sont très semblables à ceux de la partie (A) si ce n'est qu'il faut tenir compte de la possibilité qu'ils puissent ne pas terminer. À part pour l'intersection, on doit donc les lancer « en parallèle » et pas « en série » : lorsqu'on dira qu'on lance deux algorithmes $T$ et $T'$ « en parallèle », cela signifie qu'on exécute une étape du calcul de $T$, puis une étape de $T'$, puis de nouveau une de $T$, et ainsi de suite en alternant entre les deux, jusqu'à ce que l'un termine et renvoie vrai. Si $L_1$ et $L_2$ sont semi-dédicables et si $T_1$ et $T_2$ sont des algorithmes qui les « semi-décident » (i.e., $T_i$ termine en temps fini et répond oui si $w\in L_i$, et ne termine pas sinon), pour semi-décider $L_1\cup L_2$, on lance les deux algorithmes $T_1$ et $T_2$ en parallèle sur le même mot $w$ : si l'un d'eux termine, on termine en renvoyant vrai (sinon, bien sûr, on ne termine pas). Pour semi-décider $L_1\cap L_2$, en revanche, il n'y a pas de raison de procéder en parallèle : on lance d'abord $T_1$ sur le mot $w$ à tester : si $T_1$ termine, on lance ensuite $T_1$ sur le même mot : si $T_2$ termine et renvoie vrai, on renvoie vrai ; si l'un des deux algorithmes $T_i$ lancés séquentiellement ne termine pas, bien sûr, le calcul dans son ensemble ne terminera pas. Pour semi-décider $L_1 L_2$ ou $L^*$, on procède comme dans le cas (A) en lançant en parallèle les algorithmes pour tester toutes les différentes factorisations possibles $w = uv$ ou bien $w = u_1\cdots u_k$ (en mots non vides) du mot $w$. \end{corrige} % \exercice On rappelle qu'une fonction $f\colon \mathbb{N} \to \mathbb{N}$ est dite \emph{calculable} lorsqu'il existe un algorithme (par exemple, un programme pour une machine de Turing) prenant en entrée un $n\in\mathbb{N}$ qui termine toujours en temps fini et renvoie la valeur $f(n)$. On rappelle qu'une partie $E$ de $\mathbb{N}$ ou de $\mathbb{N}^2$ est dite \emph{décidable} lorsque sa fonction indicatrice est calculable, ou, ce qui revient au même, lorsqu'il existe un algorithme prenant en entrée un élément de $\mathbb{N}$ ou de $\mathbb{N}^2$ qui termine toujours en temps fini et renvoie vrai ($1$) ou faux ($0$) selon que l'élément fourni appartient ou non à $E$. On rappelle enfin qu'une partie $E$ de $\mathbb{N}$ ou de $\mathbb{N}^2$ est dite \emph{semi-décidable} lorsqu'il existe un algorithme prenant en entrée un élément de $\mathbb{N}$ ou de $\mathbb{N}^2$ qui termine toujours en temps fini et renvoie vrai ($1$) si l'élément fourni appartient à $E$, et sinon ne termine pas (on peut aussi accepter qu'il termine en renvoyant faux, cela ne change rien). Soit $f\colon \mathbb{N} \to \mathbb{N}$ : montrer qu'il y a équivalence entre les affirmations suivantes : \begin{enumerate} \item la fonction $f$ est calculable, \item le graphe $\Gamma_f := \{(n,f(n)) : n\in\mathbb{N}^2\} = \{(n,p)\in\mathbb{N}^2 : p=f(n)\}$ de $f$ est décidable, \item le graphe $\Gamma_f$ de $f$ est semi-décidable. \end{enumerate} (Montrer que (3) implique (1) est le plus difficile : on pourra commencer par s'entraîner en montrant que (2) implique (1). Pour montrer que (3) implique (2), on pourra chercher une façon de tester en parallèle un nombre croissant de valeurs de $p$ de manière à s'arrêter si l'une quelconque convient.) \begin{corrige} Montrons que (1) implique (2) : si on dispose d'un algorithme capable de calculer $f(n)$ en fonction de $n$, alors il est facile d'écrire un algorithme capable de décider si $p=f(n)$ (il suffit de calculer $f(n)$ avec l'algorithme supposé exister, de comparer avec la valeur de $p$ fournie, et de renvoyer vrai/$1$ si elles sont égales, et faux/$0$ sinon). Le fait que (2) implique (3) est évident car tout ensemble décidable est semi-décidable. Montrons que (2) implique (1) même si ce ne sera au final pas utile : supposons qu'on ait un algorithme $T$ qui décide $\Gamma_f$ (i.e., donnés $(n,p)$, termine toujours en temps fini, en répondant oui si $p=f(n)$ et non si $p\neq f(n)$), et on cherche à écrire un algorithme qui calcule $f(n)$. Pour cela, donné un $n$, il suffit de lancer l'algorithme $T$ successivement sur les valeurs $(n,0)$ puis $(n,1)$ puis $(n,2)$ et ainsi de suite (c'est-à-dire faire une boucle infinie sur $p$ et lancer $T$ sur chaque couple $(n,p)$) jusqu'à trouver un $p$ pour lequel $T$ réponde vrai : on termine alors en renvoyant la valeur $p$ qu'on a trouvée, qui vérifie $p=f(n)$ par définition de $T$. \smallbreak Reste à montrer que (3) implique (1) : supposons qu'on ait un algorithme $T$ qui « semi-décide » $\Gamma_f$ (i.e., donnés $(n,p)$, termine en temps fini et répond oui si $p=f(n)$, et ne termine pas sinon), et on cherche à écrire un algorithme qui calcule $f(n)$. Pour cela, on va tester les valeurs $0\leq p\leq M$ chacune pour $M$ étapes et faire tendre $M$ vers l'infini : plus exactement, on utilise l'algorithme $U$ suivant : \begin{itemize} \item pour $M$ allant de $0$ à l'infini, \begin{itemize} \item pour $p$ allant de $0$ à $M$, \begin{itemize} \item exécuter l'algorithme $T$ sur l'entrée $(n,p)$ pendant au plus $M$ étapes, \item s'il termine en renvoyant vrai ($1$), terminer et renvoyer $p$ (sinon, continuer les boucles). \end{itemize} \end{itemize} \end{itemize} (Intuitivement, $U$ essaie de lancer l'algorithme $T$ sur un nombre de valeurs de $p$ de plus en plus grand et en attendant de plus en plus longtemps pour voir si l'une d'elles termine.) Si l'algorithme $U$ défini ci-dessus termine, il renvoie forcément $f(n)$ (puisque l'algorithme $T$ a répondu vrai, c'est que $p=f(n)$, et on renvoie la valeur en question) ; il reste à expliquer pourquoi $U$ termine toujours. Mais la valeur $f(n)$ existe (même si on ne la connaît pas) car la fonction $f$ était supposée définie partout, et lorsque l'algorithme $T$ est lancé sur $(n,f(n))$ il est donc censé terminer en un certain nombre (fini !) d'étapes : si $M$ est supérieur à la fois à $f(n)$ et à ce nombre d'étapes, la valeur $f(n)$ va être prise par $p$ dans la boucle intérieure, et pour cette valeur, l'algorithme $T$ va terminer sur l'entrée $(n,p)$ en au plus $M$ étapes, ce qui assure que $U$ termine effectivement. L'algorithme $U$ calcule donc bien la fonction $f$ demandée, ce qui prouve (1). \end{corrige} % \exercice\label{decidable-iff-image-of-computable-increasing} Soit $A \subseteq \mathbb{N}$ un ensemble infini. Montrer qu'il y a équivalence entre : \begin{itemize} \item l'ensemble $A$ est décidable, \item il existe une fonction calculable \emph{strictement croissante} $f\colon\mathbb{N}\to\mathbb{N}$ telle que $f(\mathbb{N}) = A$. \end{itemize} \begin{corrige} Supposons $A$ décidable : on va construire $f$ comme indiqué. Plus exactement, on va appeler $f(n)$ le $n$-ième élément de $A$ par ordre croissant (c'est-à-dire que $f(0)$ est le plus petit élément de $A$, et $f(1)$ le suivant par ordre de taille, et ainsi de suite ; noter que $A$ est infini donc cette fonction est bien définie). Montrons que $f$ est calculable : donné un entier $n$, on teste successivement si $0\in A$ puis $1\in A$ puis $2\in A$ et ainsi de suite, à chaque fois en utilisant un algorithme décidant $A$ (qui est censé exister par hypothèse) jusqu'à obtenir $n$ fois la réponse « oui » ; plus exactement : \begin{itemize} \item initialiser $m \leftarrow 0$, \item pour $k$ allant de $0$ à l'infini, \begin{itemize} \item interroger l'algorithme qui décide si $k\in A$, \item s'il répond « oui » : \begin{itemize} \item si $m=n$, terminer et renvoyer $k$, \item sinon, incrémenter $m$ (c'est-à-dire faire $m \leftarrow m+1$). \end{itemize} \end{itemize} \end{itemize} La boucle termine car $A$ est infini. Réciproquement, supposons $f$ strictement croissante calculable et posons $A = f(\mathbb{N})$ : on veut montrer que $A$ est décidable. Or pour décider si $k \in A$, il suffit de calculer successivement $f(0)$, $f(1)$, $f(2)$ et ainsi de suite, et de terminer si $f(n)$ atteint ou dépasse le $k$ fixé : s'il l'atteint, on renvoie vrai (on a trouvé $n$ tel que $f(n)=k$), sinon, on renvoie faux (la valeur $k$ a été sautée par la fonction $f$ et ne sera donc jamais atteinte). L'algorithme est donc explicitement : \begin{itemize} \item pour $n$ allant de $0$ à l'infini, \begin{itemize} \item calculer $f(n)$, \item si $f(n) = k$, renvoyer vrai, \item si $f(n) > k$, renvoyer faux. \end{itemize} \end{itemize} La boucle termine car toute fonction strictement croissante $\mathbb{N}\to\mathbb{N}$ est de limite $+\infty$ en l'infini (donc $f(n)$ finit forcément par atteindre ou dépasser $k$). \end{corrige} % \exercice Soit $S(e,n)$ le nombre d'étapes de l'exécution du $e$-ième programme (ou, si on préfère, de la $e$-ième machine de Turing) quand on lui fournit le nombre $n$ en entrée, à supposer que cette exécution termine ; sinon, $S(e,n)$ n'est pas défini. Soit par ailleurs $M(k)$ le maximum des $S(e,n)$ pour $0\leq e\leq k$ et $0\leq n\leq k$ qui soient définis (et $0$ si aucun d'eux n'est défini). Autrement dit, il s'agit du plus petit entier supérieur ou égal au nombre d'étapes de l'exécution de l'un des programmes $0\leq e\leq k$ sur l'un des entiers $0\leq n\leq k$ en entrée, lorsqu'ils terminent. Montrer que la fonction $M$ n'est pas calculable (i.e., n'est pas calculable par un algorithme) : on pourra pour cela montrer que la connaissance de $M$ permet de résoudre le problème de l'arrêt. Montrer même qu'\emph{aucune} fonction $M'$ telle que $M'(k) \geq M(k)$ pour tout $k$ n'est calculable. Montrer que même si $M'$ vérifie simplement $M'(k)\geq M(k)$ pour $k\geq k_0$, alors $M'$ n'est pas calculable. \emph{Remarque :} La fonction $M$, ou différentes variantes de celle-ci, s'appelle fonction du « castor affairé ». On peut montrer encore plus fort : si $F$ est une fonction calculable quelconque, alors il existe $k_0$ tel que $M(k) \geq F(k)$ pour $k\geq k_0$ (autrement dit, la fonction $M$ finit par dépasser n'importe quelle fonction calculable : Radó, 1962, \textit{On Non-Computable Functions}). \begin{corrige} Supposons que $M$ soit calculable. On peut alors résoudre le problème de l'arrêt de la manière suivante : donné un algorithme $T$, de numéro $e$, et une entrée $n$ à fournir à cet algorithme, pour savoir si $T$ s'arrête, on calcule $M(k)$ où $k = \max(e,n)$, on exécute ensuite l'algorithme $T$ pendant au plus $M(k)$ étapes : s'il termine dans le temps imparti, on répond vrai (il a terminé), sinon, on répond faux (il ne terminera jamais). Cette résolution du problème de l'arrêt est correcte, car si $T$ termine sur l'entrée $n$, il prendra par définition $S(e,n)$ étapes, avec $0\leq e\leq k$ et $0\leq n\leq k$ par définition de $k$, donc $S(e,n) \leq M(k)$ par définition de $M(k)$ : ceci signifie précisément que si $T$ n'a pas terminé en $M(k)$ étapes, il ne terminera jamais. Exactement le même argument montre que $M'$ n'est pas calculable sous l'hypothèse que $M'(k) \geq M(k)$ pour tout $k$ : s'il l'était, on pourrait exécuter l'algorithme $T$ pendant au plus $M'(k)$ étapes, et comme on a $S(e,n) \leq M(k) \leq M'(k)$, la même démonstration convient. Enfin, si on suppose seulement $M'(k)\geq M(k)$ pour $k\geq k_0$, la fonction $M'$ n'est toujours pas calculable : en effet, si on suppose par l'absurde qu'elle l'est, la fonction $M''$ qui à $k$ associe $M'(k)$ si $k\geq k_0$ et $M(k)$ sinon, serait encore calculable puisqu'elle ne diffère de $M'$ qu'en un nombre fini de valeurs, or changer la valeur en un point d'une fonction calculable donne toujours une fonction calculable (même si on « ne connaît pas » la valeur à changer, elle existe, donc l'algorithme modifié existe). Mais d'après le paragraphe précédent, $M''$ n'est pas calculable puisqu'elle est partout supérieure ou égale à $M$. \end{corrige} % \exercice Dans cet exercice, on s'intéresse au langage $L$ formé des programmes $e$ (codés, dans une formalisation quelconque de la calculabilité\footnote{Par exemple, un langage de programmation (Turing-complet) quelconque.}, comme des entiers naturels ou comme des mots sur un alphabet fixé sans importance) qui, quel que soit le paramètre $n$ qu'on leur fournit en entrée, terminent en temps fini et retournent la valeur $0$ : soit $L = \{e : (\forall n) {\varphi_e(n)\downarrow} = 0\}$. Si l'on préfère, $L$ est l'ensemble de toutes les façons de coder la fonction constante égale à $0$. On appellera aussi $M$ le complémentaire de $L$. On se demande si $L$ ou $M$ sont semi-décidables. \smallskip (1) Thésée et Hippolyte se disputent pour savoir si $L$ est semi-décidable. Thésée pense qu'il l'est, et il tient le raisonnement suivant pour l'expliquer : {\narrower Pour savoir si un programme $e$ est dans l'ensemble $L$, il suffit de l'examiner pour vérifier que toutes les instructions qui mettent fin au programme renvoient la valeur $0$ : si c'est le cas, on termine en répondait « oui » (c'est-à-dire $e\in L$) ; sinon, on rentre dans une boucle infinie. Ceci fournit un algorithme qui semi-décide $L$. \par} \smallskip \noindent Hippolyte, elle, pense que $L$ n'est pas semi-décidable. Son argument est le suivant : {\narrower Si $L$ était semi-décidable, je pourrais m'en servir pour résoudre le problème de l'arrêt. En effet, donné un programme $e'$ et une entrée $m$ sur laquelle je cherche à tester l'arrêt de $e'$, je peux fabriquer le programme $e$ qui prend une entrée $n$, lance l'exécution de $e'$ sur l'entrée $m$ pendant au plus $n$ étapes et à la fin renvoie $1$ si ces $n$ étapes ont suffi à terminer l'exécution de $e'$, et $0$ sinon. Dire que $e \in L$ signifie que $e'$ ne termine jamais sur $m$, donc pouvoir semi-décider $L$ permet de résoudre algorithmiquement le problème de l'arrêt, ce qui est impossible. \par} \smallskip \noindent Qui a raison ? Expliquer précisément quelle est l'erreur (ou les erreurs) commise(s) par le raisonnement incorrect, et détailler les éventuels passages incomplets dans le raisonnement correct. \begin{corrige} C'est Hippolyte qui a raison ($L$ n'est pas semi-décidable). L'argument de Thésée est stupide : une instruction mettant fin au programme avec une valeur autre que $0$ pourrait ne jamais être atteinte, et réciproquement, même si toutes les instructions mettant fin au programme renvoyaient $0$, il pourrait aussi ne jamais terminer. (Au passage, l'argument de Thésée semblerait même montrer que $L$ est décidable, pas juste semi-décidable.) L'argument d'Hippolyte, lui, est correct : il montre que si $L$ était semi-décidable, le complémentaire du problème de l'arrêt (l'ensemble des $e'$ qui ne terminent jamais) serait semi-décidable, ce qui n'est pas le cas. (Le complémentaire du problème de l'arrêt n'est pas semi-décidable, car s'il l'était, le problème de l'arrêt serait décidable, vu qu'il est déjà semi-décidable.) Parmi les points qui méritent éventuellement d'être précisés, on peut mentionner : le fait que $e$ se déduise algorithmiquement de $e'$ et $m$ ; et le fait qu'il est algorithmiquement possible de lancer l'exécution d'un programme sur $n$ étapes (peu importe la définition exacte de « étape » tant que chacune termine à coup sûr en temps fini) et tester si elle est bien finie au bout de ce temps. \end{corrige} \medskip (2) Achille et Patrocle se disputent pour savoir si $M$ (le complémentaire de $L$) est semi-décidable. Achille pense qu'il l'est, et il tient le raisonnement suivant pour l'expliquer : {\narrower Pour savoir si un programme $e$ est dans l'ensemble $M$, il suffit de tester successivement les valeurs $\varphi_e(n)$ pour tous les $n$ possibles : si l'on rencontre un $n$ tel que $\varphi_e(n)$ n'est pas $0$, alors on termine en répondant « oui » (c'est-à-dire $e\in M$) ; sinon, on ne va jamais terminer, et cela signifie que $e\not\in M$. Ceci fournit un algorithme qui semi-décide $M$. \par} \smallskip \noindent Patrocle, lui, pense que $M$ n'est pas semi-décidable. Son argument est le suivant : {\narrower Si $M$ était semi-décidable, je pourrais m'en servir pour résoudre le problème de l'arrêt. En effet, donné un programme $e'$ et une entrée $m$ sur laquelle je cherche à tester l'arrêt de $e'$, je peux fabriquer le programme $e$ qui prend une entrée $n$, l'ignore purement et simplement, exécute $e'$ sur l'entrée $m$ et à la fin renvoie $0$. Dire que $e\in M$ signifie que $e'$ ne termine pas sur $m$, donc pouvoir semi-décider $M$ permet de résoudre algorithmiquement le problème de l'arrêt, ce qui est impossible. \par} \smallskip \noindent Qui a raison ? Expliquer précisément quelle est l'erreur (ou les erreurs) commise(s) par le raisonnement incorrect, et détailler les éventuels passages incomplets dans le raisonnement correct. \begin{corrige} C'est Patrocle qui a raison ($M$ n'est pas semi-décidable). Le raisonnement d'Achille se fonde sur l'idée que le complémentaire de « l'ensemble des programmes qui renvoient toujours la valeur $0$ » est « l'ensemble des programmes qui renvoient parfois une valeur autre que $0$ », ce qui oublie la possibilité que le programme ne termine pas. C'est là la principale erreur (le reste est globalement correct). L'argument de Patrocle, lui, est correct : il montre que si $M$ était semi-décidable, le complémentaire du problème de l'arrêt (l'ensemble des $e'$ qui ne terminent jamais) serait semi-décidable, ce qui n'est pas le cas. (Le complémentaire du problème de l'arrêt n'est pas semi-décidable, car s'il l'était, le problème de l'arrêt serait décidable, vu qu'il est déjà semi-décidable.) On fait appel à des fonctions constantes, et qui ne peuvent renvoyer que $0$ ou ne pas terminer, mais ce n'est pas spécialement problématique. Parmi les points qui méritent éventuellement d'être précisés, on peut mentionner le fait que $e$ se déduise algorithmiquement de $e'$ et $m$. \end{corrige} % % % \printindex % % % \end{document}