# Automate d'arbres

En informatique théorique, plus précisément en théorie des langages, un automate d'arbre est une machine à états qui prend en entrée un arbre, plutôt qu'une chaîne de caractères pour les automates plus conventionnels, comme les automates finis.

## Introduction

Comme pour les automates classiques, les automates d'arbres finis (FTA pour finite tree automata en anglais) peuvent être déterministes ou pas. Suivant la façon dont les automates se « déplacent » sur l'arbre qu'ils traitent, les automates d'arbres peuvent être de deux types : (a) ascendants ; (b) descendants. La distinction est importante, car si les automates non déterministes (ND) ascendants et descendants sont équivalents, les automates déterministes descendants sont strictement moins puissants que leurs homologues déterministes ascendants. En effet, les propriétés d'arbres spécifiées par les automates déterministes descendants ne peuvent dépendre que des propriétés de chemins.

## Définitions
### Alphabet gradué

Un alphabet gradué (ranked alphabet en anglais) est un alphabet $F$ muni d'une fonction $\operatorname {ar}$ qui, à chaque symbole $f$ de $F$, associe un entier naturel $\operatorname {ar} (f)$ qui est son arité (le nombre d'arguments qu'elle requiert).
On considère les constantes comme des opérateurs nullaires (i.e. d'arité 0). Parfois, l'ensemble des symboles d'arité 0 est partagé en deux sous-ensembles, les constantes et les variables.
Un alphabet gradué est donc une signature (ensemble de symboles de constante, de fonction et de relation), considérée comme indépendante de l'algèbre sur laquelle elle agit éventuellement.

### Terme, arbre

* Étant donné un alphabet gradué $F$, les termes (de base) ou arbres sur $F$ sont définis comme suit :
* Un symbole de $F$ d'arité 0 est un terme ;
* Si $f$ est un symbole d'arité $n$, et si $t_{1},t_{2},\ldots ,t_{n}$ sont des termes, alors la suite $(f,t_{1},t_{2},\ldots ,t_{n})$ est un terme ; ce terme est généralement noté $f(t_{1},t_{2},\ldots ,t_{n})$ ;
* Tout terme s'obtient, à partir des symboles d'arité 0, par un nombre fini d'applications de la règle précédente.
On peut voir un terme $(f,t_{1},t_{2},\ldots ,t_{n})$ comme un arbre. La racine de l'arbre a pour étiquette le symbole $f$, et les enfants de la racine sont les termes $t_{1},t_{2},\ldots ,t_{n}$.
* Un terme clos est un terme sans variable.
* Un terme linéaire est un terme où chaque variable apparaît au plus une fois.
* Un contexte est un terme linéaire.
* On définit la hauteur d'un terme $t$ par :
$h(t)=\left\{{\begin{array}{c @{=} c}0&{\text{si }}t{\text{ est d'arité }}0\\\max(h(t_{1}),...,h(t_{n}))+1&{\text{si }}t=f(t_{1},...t_{n})\\\end{array}}\right.$

### Automate d'arbres ascendant

Un automate d'arbres fini ascendant (bottom-up finite tree automaton en anglais) sur $F$ est défini par les objets :
    $(Q,F,Q_{f},\Delta )$
Ici $Q$ est un ensemble fini d'états, $F$ est un alphabet gradué, $Q_{f}\subseteq Q$ est un ensemble d'états finaux, et $\Delta$ est un ensemble de règles de transition, c'est-à-dire de règles de réécritures qui transforment les nœuds dont les racines des fils sont des états en nœuds dont les racines sont des états. $\Delta$ est constitué d'éléments de la forme $(f(q_{1},...,q_{n})\rightarrow q)$, où $q_{1},...,q_{n},q$ sont des états de $Q$, et $f\in F$ est un symbole d'arité $n$. Par conséquent l'état d'un nœud est déduit des états de ses fils.
Il n'y a pas d'état initial en tant que tel, mais les règles de transition pour les symboles constants peuvent être considérées comme des états initiaux. L'arbre est accepté si l'état de la racine est un état acceptant.

#### Exemple

Un automate d'arbres ascendant reconnaissant les expressions booléennes valant vrai sur l'alphabet $\{et:2\ ,\ ou:2\ ,\ non:1\ ,\ vrai:0\ ,\ faux:0\}$ est $A=(Q,F,Q_{f},\Delta )$ avec:
$Q=\{q_{0},\ q_{1}\}$
$F=\{et,\ ou,\ non,\ faux,\ vrai\}$
$Q_{f}=\{q_{1}\}$
$\Delta =\left\{{\begin{array}{c c c}faux&\rightarrow &q_{0}\\vrai&\rightarrow &q_{1}\\et(q_{a},q_{b})&\rightarrow &q_{min(a,b)}\\ou(q_{a},q_{b})&\rightarrow &q_{max(a,b)}\\non(q_{a})&\rightarrow &q_{1-a}\end{array}}\right.$

### Automate d'arbres descendant

Un automate d'arbres fini descendant sur $F$ est défini par :
    $(Q,F,I,\Delta )$
$Q$ est un ensemble fini d'états, $F$ est un alphabet gradué, $I\subseteq Q$ est l'ensemble des états initiaux, et $\Delta$ l'ensemble des règles de transition, constitué d'éléments de la forme $((q,f)\rightarrow (q_{1},...,q_{n}))$, où $q_{1},...,q_{n},q$ sont des états de $Q$, et $f\in F$ est un symbole d'arité $n$.
Il y a deux différences avec les automates d'arbres ascendants : d'abord, $I\subseteq Q$, l'ensemble de ses états initiaux, remplace $Q_{F}$ ; ensuite, ses règles de transition sont l'inverse, c'est-à-dire des règles de réécriture qui transforment les nœuds dont les racines sont des états en nœuds dont les racines des fils sont des états. L'arbre est accepté si toutes les branches sont complètement traversées jusqu'au bout.

## Propriétés
### Déterminisme

Un automate d'arbres est déterministe s'il ne possède aucune paire de règles de transition ayant le même côté gauche. Cette définition correspond à l'idée intuitive que pour qu'un automate soit déterministe, une transition et une seule doit être possible pour un nœud donné. De plus, pour un arbre descendant $(Q,F,I,\Delta )$, on a $|I|=1$.
Pour les automates d'arbres non déterministes, on peut remarquer qu'il suffit d'inverser les règles de transition pour transformer un automate ascendant en un automate descendant et inversement; les états finaux deviennent les états initiaux. Ainsi, les automates d'arbres descendants non déterministes sont équipotents à leurs homologues ascendants.
Dans le cas déterministe, les arbres ascendants sont strictement plus puissants que les automates d'arbres descendants. En effet, pour les premiers, l'état d'un nœud est déterminé par l'étiquette de ses $n$ fils, alors que pour les seconds, les états des $n$ fils sont déterminés seulement par l'étiquette de leur père.
Considérons le langage $L=\{f(a,b),f(b,a)\}$ défini sur l'alphabet $F=\{f:2\ ,\ a:0\ ,\ b:0\}$.
* $L$ est reconnaissable par l'automate ascendant $A=(Q,F,Q_{f},\Delta )$ où:
$Q=\{q_{a},q_{b},q_{f}\}$, $Q_{f}=\{q_{f}\}$ et $\Delta =\left\{{\begin{array}{c c c}a&\rightarrow &q_{a}\\b&\rightarrow &q_{b}\\f(q_{a},q_{b})&\rightarrow &q_{f}\\f(q_{b},q_{a})&\rightarrow &q_{f}\end{array}}\right.$
* Supposons que $L$ est accepté par un automate descendant déterministe $B=(Q,F,I,\Delta )$.
$B$ étant déterministe, on a $|I|=1$. Posons $I=\{q_{0}\}$. De plus, pour tout état $q\in Q$ et $x\in F$, $\Delta$ contient au plus une règle dont le membre gauche est $(q,x)$.
En particulier, il existe une unique règle de transition de la forme $(q_{0},f)\rightarrow (q_{1},q_{2})$. Et comme $L=\{f(a,b),f(b,a)\}$ est reconnu par l'automate $B$, on a $q_{1}=q_{2}$.
Donc l'automate $B$ reconnaîtrait les termes $f(a,b)$, $f(b,a)$ mais aussi $f(a,a)$ et $f(b,b)$ qui n'appartiennent pas au langage $L$.
$L$ n'est donc pas reconnaissable par un automate descendant déterministe.

### Reconnaissabilité

Pour un automate ascendant, un terme de base $t$ (c'est-à-dire un arbre) est accepté s'il existe une réduction qui part de $t$ et aboutit à $q(t)$, où $q$ est un état final. Pour un automate descendant, un terme de base $t$ est accepté s'il existe une réduction qui part de $q(t)$ et aboutit à $t$, où $q(t)$ est un état initial.
Le langage d'arbres $L(A)$ reconnu par un automate d'arbres $A$ est l'ensemble de tous les termes de base acceptés par $A$. Un ensemble de termes de base est reconnaissable s'il existe un automate qui le reconnaît. Les langages d'arbres réguliers sont les langages d'arbres reconnu par les automates d'arbres non-déterministes et les automates d'arbres déterministes ascendants.
Une propriété importante est que les homomorphismes linéaires (c'est-à-dire qui préservent l'arité) préservent la reconnaissabilité.
Un langage d'arbres finis binaires est définissable en logique monadique du second ordre (ou de manière équivalente en WMSO, pour logique monadique du second ordre faible, ou la quantification porte sur des sous-ensembles finis) si, et seulement si $L$ est reconnaissable par un automate ascendant$^,$$^,$.

### Complétude et réduction

Un automate d'arbres fini non déterministe est complet s'il y a au moins une règle de transition disponible pour chaque combinaison possible symbole-état. Un état $q$ est accessible s'il existe un terme de base $t$ tel qu'il existe une réduction de $t$ à $q(t)$. Un FTA est réduit si tous ses états sont accessibles.

### Lemme de l'étoile

Soit $L$ un ensemble reconnaissable de termes de base. Alors, il existe une constante $k>0$ telle que : pour chaque terme de base $t$ dans $L$ tel que $h(t)>k$, il existe un contexte $C\in C(F)$, un contexte non trivial $C'\in C(F)$ et un terme de base $u$ tels que $t=C[C'[u]]$ et pour tout $n\geq 0$ $C[C'^{n}[u]]\in L$.

### Fermeture

La classe des langages d'arbres reconnaissables est fermée pour l'union, la complémentation et l'intersection :
Soit $L_{1}$ et $L_{2}$ sont deux langages d'arbres, ${\mathcal {A}}_{1}=(Q_{1},F,Q_{f_{1}},\Delta _{1})$ et ${\mathcal {A}}_{2}=(Q_{2},F,Q_{f_{2}},\Delta _{2})$ des automates ascendants reconnaissant $L_{1}$ et $L_{2}$ respectivement.
On peut supposer ${\mathcal {A}}_{1}$ et ${\mathcal {A}}_{2}$ complets (quitte à leur ajouter un "état puits", c'est-à-dire un état non terminal tel que les transitions bloquant l'automate pointent sur cet état à la place).
On peut également supposer $Q_{1}\cap Q_{2}=\emptyset$.
L'automate ${\mathcal {A}}=(Q_{1},F,Q_{1}\setminus Q_{f_{1}},\Delta _{1})$ reconnaît ${\overline {L_{1}}}$.
L'automate ${\mathcal {A}}=(Q_{1}\times Q_{2},F,Q_{f_{1}}\times Q_{f_{2}},\Delta )$ reconnaît $L_{1}\cap L_{2}$, où $f((q_{1},q_{1}'),...,(q_{n},q_{n}'))\rightarrow (q,q')$ avec $f(q_{1},...,q_{n})\rightarrow q$ dans $\Delta _{1}$ et $f(q_{1}',...,q_{n}')\rightarrow q'$ dans $\Delta _{2}$.
L'automate ${\mathcal {A}}=(Q_{1}\times Q_{2},F,Q_{f_{1}}\times Q_{2}\cup Q_{1}\times Q_{f_{2}},\Delta )$ reconnaît $L_{1}\cup L_{2}$, où $f((q_{1},q_{1}'),...,(q_{n},q_{n}'))\rightarrow (q,q')$ avec $f(q_{1},...,q_{n})\rightarrow q$ dans $\Delta _{1}$ et $f(q_{1}',...,q_{n}')\rightarrow q'$ dans $\Delta _{2}$.

### Théorème de Myhill-Nerode
#### Congruence sur des langages d'arbres

* Une congruence sur des langages d'arbres est une relation $\equiv$ telle que : $u_{i}\equiv v_{i}1\leq i\leq n\Rightarrow f(u_{1},\ldots ,u_{n})\equiv f(v_{1},\ldots ,v_{n})$ ;
* Elle est à index fini si son nombre de classes d'équivalence est fini ;
* Pour un langage d'arbres $L$ donné, $u\equiv _{L}v$ si pour tout contexte $C\in C(F)$, $C[u]\in L$ si et seulement si $C[v]\in L$.

#### Théorème de Myhill-Nerode

Les trois affirmations suivantes sont équivalentes :
* L est un langage d'arbres reconnaissable ;
* L est l'union de classes d'équivalence d'une congruence à index fini ;
* La relation $\equiv _{L}$ est une congruence à index fini.