Les languages formels

La théorie des langages formels fut initialement initiée par les linguistes qui tentaient de représenter les langages naturels (exemple, français, anglais, etc). Mais elle s'est révélée être très utile pour l'informatique pour tout un cas d'applications. Notamment les RegEx, et les règles syntaxiques des langages de programmations (avec l'analyse syntaxique).

Un langage naturel va être défini par une orthographe, une grammaire, une conjugaison. Un langage dit formel (tel que les langages de programmations), vont être défini par des règles de constructions. Ainsi, les erreurs syntaxiques d'un code peuvent être détectées grâce à ces mêmes règles de constructions.

La théorie des langages a pour but de décrire les langages formels. Elle ne concerne que les aspects purement syntaxiques du langage. Un langage formel est généralement défini par une grammaire formelle (grammaires algébriques, par exemple) et analysé à l’aide d’automates.

Donc un langage formel va être généré à l'aide d'une grammaire formelle et analysé à l'aide d'un automate.

Alphabets, lettres et mots

L'alphabet est un ensemble fini et non-vide d'éléments appelé lettres ou symboles terminaux. Cet ensemble va être représenté par la lettre $\mathrm{\Sigma }$, par exemple : $\mathrm{\Sigma }=a,b,c,1,2,3,if,else$

• ${\mathrm{\Sigma }}^{+}$ correspond à l'ensemble de tous les mots sur $\mathrm{\Sigma }$
• ${\mathrm{\Sigma }}^{\ast }$ correspond à l'ensemble de tous les mots non-vide sur $\mathrm{\Sigma }$

Un mot est une séquence finie de lettres. Ainsi dans l'alphabet précédent a, ab et else sont des mots par exemples.

Le mot vide est noté $\epsilon$ et est défini pour tous les alphabets. Par conséquent, le mot vide ne peut pas être une lettre de l'alphabet $\mathrm{\Sigma }$.

Opérations

La concaténation est une opération binaire effectuée sur l'ensemble $\mathrm{\Sigma }$ et qui donne un mot obtenu par la concaténation des 2 mots. Elle est associative et non commutative et admet le mot vide $\epsilon$ comme neutre (donc si $u$ est un mot alors $u=\epsilon u=u\epsilon$).

Une concaténation des mots $u$ et $v$ est représentée par $uv$ ou $u\ast v$ et une concaténation d'un nombre $k$ de $u$ est représentée par $u^k$ donc $uuuuuuuuu=u^9$

Un exposant $+$ correspond à "1 ou plus" (comme en RegEx) tandis qu'un exposant $\ast$ sur un mot représente "0 ou plus" (toujours comme en regex)

Ainsi $(ab{)}^{+}$ signifie que la séquence ab est présente une fois ou plus. Et $(vb{)}^{\ast }$ signifie que la séquence vb est présente 0 fois ou plus.

Une autre opération est qu'un mot peut être retourné en lui mettant un exposant de -1. Donc $(abc{)}^{-1}=cba$ et un palindrome peut être détecté lorsque $u=u^{-1}$ (par exemple $(radar{)}^{-1}=(radar)$)

Et on peut aussi récupérer la longueur d'un mot (nombre de symboles terminaux/lettres) comme ceci $|u|$ donc $|(radar)|=5$

Langage

Un langage est un sous ensemble de ${\mathrm{\Sigma }}^{\ast }$ et on peut reconnaitre quelques langages particuliers :

• $\mathrm{\Sigma }$ est le langage de tous les mots de longueur 1 sur $\mathrm{\Sigma }$
• $\varnothing$ est un langage ne contenant aucun mot
• {$\epsilon$} est un langage ne contenant que le mot vide
• ${\mathrm{\Sigma }}^{+}$ langage contenant tous les mots sur ${\mathrm{\Sigma }}^{+}$
• ${\mathrm{\Sigma }}^{\ast }$ langage contenant tous les mots sur ${\mathrm{\Sigma }}^{\ast }$

Sur l'ensemble $P({\mathrm{\Sigma }}^{\ast })$ représentant tous les langages sur ${\mathrm{\Sigma }}^{\ast }$ on peut utiliser les opérations ensemblistes habituelles, mais également $\cdot$ permetant de faire un produit des deux langages en utilisant la concaténation sur chaque mot.

Aisni si $L_1=1,2,3$ et $L_2=a,b,c$ et que l'on fait $L_1\cdot L_2$ on obtient $1a,1b,1c,2a,2b,2c,3a,3b,3c$

On peut utiliser la notation $L^k$ où $k$ est le nombre de lettres, pour représenter une concaténation de k mots du langage L. Et $L^k=L\cdot L^{k-1}$ ainsi :

• $L^0=\epsilon$
• $L^1=L\cdot L^0=L\epsilon =L$
• $L^2=L\cdot L^1=LL$

Pour décrire un langage avec une infinité de mots, on peut utiliser un système générateur (grammaire, RegEx ou diagramme syntaxique) pour générer des mots du langage et des automates finis pour les détecter.

Grammaire