Calculabilité

1
TABLE DES MATIERES
TABLE DES MATIERES .................................................................................... 1

CONTENU DU COURS ...................................................................................... 3
Chapitre 1. INTRODUCTION ............................................................................. 5
1.1. MOTIVATION .......................................................................................... 5
1.2. LES PROBLEMES ET PROGRAMMES ................................................. 5
1.2.1. Notion de problème ............................................................................. 5
1.2.2. Notion de programme exécuté sur un ordinateur ................................ 6
1.3. LA FORMALISATION DES PROBLEMES............................................ 7
1.3.1. Alphabet et mots .................................................................................. 8
1.3.2. La représentation des problèmes ......................................................... 8
1.3.3. Langages .............................................................................................. 9
1.4. LA DESCRIPTION DE LANGAGES....................................................... 9
1.4.1. Des opérations sur les langages ......................................................... 10
1.4.2. Les expressions régulières. ................................................................ 10
EXERCICES SUR LE CHAPITRE 1. ............................................................... 13
Chapitre 2. LES AUTOMATES FINIS .............................................................. 15
2.1. INTRODUCTION .................................................................................... 15
2.2. DESCRIPTION ........................................................................................ 17
2.3. FORMALISATION ................................................................................. 17
2.4. REPRESENTATION ET EXEMPLES ................................................... 18
2.5. LES AUTOMATES FINIS NON-DETERMINISTES............................ 19
2.5.1. Description ......................................................................................... 19
2.5.3. Exemples ............................................................................................ 20
2.6. L’ELIMINATION DU NON DETERMINISME .................................... 20
2.7. AUTOMATES FINIS ET EXPRESSIONS REGULIERS...................... 22
Chapitre 3. LES GRAMMAIRES REGULIERES ............................................. 24
3.1. INTRODUCTION .................................................................................... 24
3.2. LES GRAMMAIRES ............................................................................... 24
3.3. LES GRAMMAIRES REGULIERES ..................................................... 27
3.4. LES LANGAGES REGULIERS ............................................................. 28
3.4.1. Propriétés des langages réguliers ....................................................... 28
3.4.2. Algorithmes........................................................................................ 30
Chapitre 4. AUTOMATES A PILE ET LANGAGES HORS-CONTEXTE..... 33
C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Cours de Calculabilité – L1 et L2 Génie/Informatique – 2011
2
4.1. INTRODUCTION .................................................................................... 33

4.2. LES AUTOMATES A PILE .................................................................... 33
4.2.1. Description ......................................................................................... 33
4.2.2. Formalisation ..................................................................................... 34
4.2.3. Exemples ............................................................................................ 34
4.3. LES LANGAGES HORS-CONTEXTE .................................................. 35
4.4. LES AUTOMATES A PILE DETERMINISTES ................................... 36
4.3.1. Principe .............................................................................................. 36
4.3.2. Formalisation ..................................................................................... 37
4.3.3. Les langages hors-contexte déterministes ......................................... 37
4.4.4. Propriétés des langages hors-contexte déterministes......................... 37
4.4.5. Applications. ...................................................................................... 38
EXERCICES SUR LE CHAPITRE 4 ................................................................ 39
Chapitre 5. LES MACHINES DE TURING. ..................................................... 41
5.1. INTRODUCTION .................................................................................... 41
5.2. DEFINITION ........................................................................................... 41
5.2.1. Définition ........................................................................................... 41
5.2.2. Formalisation ..................................................................................... 42
5.2.3. Langage accepté et langage décidé .................................................... 43
5.3. THESE DE TURING-CHURCH ............................................................. 44
EXERCICES SUR LE CHAPITRE 5 ................................................................ 45
Chapitre 6. LES FONCTIONS RECURSIVES ................................................. 46
6.1. INTRODUCTION .................................................................................... 46
6.2. LES FONCTIONS PRIMITIVES RECURSIVES .................................. 47
6.2.1. Définition ........................................................................................... 47
6.2.2. Exemples ............................................................................................ 48
6.3. LES PREDICATS PRIMITIFS RECURSIFS ......................................... 51
6.3.1. Définition ........................................................................................... 51
6.3.2. Exemples ............................................................................................ 51
BIBLIOGRAPHIE .............................................................................................. 55

3
CONTENU DU COURS
Chapitre 1. INTRODUCTION
1.1. Motivation
1.2. Les problèmes et programmes
1.3. La formalisation des problèmes
1.4. La description de langages
1.5. Les langages non réguliers
Chapitre 2. LES AUTOMATES FINIS
2.1. Introduction
2.2. Description
2.3. Formalisation
2.4. Représentation et exemples
2.5. Les automates finis non-déterministes
2.6. L’élimination du non déterminisme
2.7. Automates finis et expressions réguliers
Chapitre 3. LES GRAMMAIRES REGULIERES
3.1. Introduction
3.2. Les grammaires
3.3. Les grammaires régulières
3.4. Les langages réguliers
3.5. Au-delà des langages réguliers
3.6. Les applications des langages réguliers
Chapitre 4. AUTOMATES A PILE ET LANGAGES HORS-CONTEXTE
4.1. Les automates à pile
4.2. Les langages hors-contexte
4.3. Au-delà des langages hors-contexte
4.4. Les automates à pile déterministes

4
Chapitre 5. LES MACHINES DE TURING

5.1. Introduction
5.2. Définition
5.3. Thèse de Turing-Church
5.4. Machines de Turing non déterministes
5.5. Machines de Turing universelles
5.6. Fonctions calculables par une machine de Turing
Chapitre 5. LES FONCTIONS RECURSIVES
6.1. Introduction
6.2. Les fonctions primitives récursives
6.3. Les prédicats primitifs récursifs
6.4. Au-delà des fonctions primitives récursives

5
Chapitre 1. INTRODUCTION
1.1. MOTIVATION
L’objectif de la science informatique étant le calcul, mais le calcul au sens
large, c'est-à-dire non limité exclusivement à la manipulation des nombres,
mais de tout type d’informations formelles que l’on peut traiter de manière
systématique tel que : textes, couleurs, données, valeurs logiques.
Une connaissance élémentaire de la calculabilité fait maintenant partie du
bagage scientifique indispensable à l’informatique.
La calculabilité est une discipline qui fait partie de l’informatique théorique.
Son but est apprendre aux étudiants à reconnaître ce qui est calculable et ce qui
n’est le pas, par l’informatique.
Dans ce cours, nous allons étudier les limites qui sont indépendantes
de la réalisation physique des machines. Nous allons par exemple, démontrer
que certains problèmes ne sont pas solubles et ne le seront jamais, quel que soit
les développements technologiques futurs. Ainsi, notre approche sera basée sur
des principes fondamentaux indépendants de la technologie.
La calculabilité tire ses origines vers les années 1930 (avant l’apparition
des ordinateurs) dans le cadre de preuves formelles initiées par les logiciens et
les mathématiciens.
1.2. LES PROBLEMES ET PROGRAMMES
La question fondamentales que nous nous posons et celle de savoir, quels
problèmes sont solubles par un programme exécuté sur ordinateur.
Pour pouvoir répondre à cette question de façon rigoureuse, nous devons
préciser les deux notions qui y interviennent :
 la notion de problème,
 la notion de programme exécuté sur un ordinateur.
1.2.1. Notion de problème
Caractéristiques
- un problème est une question générique, c'est-à-dire une question qui
s’applique à un ensemble d’éléments.
- Chaque question posée qui constitue alors l’instance du problème, doit avoir
une réponse oui ou non.
- La notion de problème est indépendante de la notion de programme,
d’autant plus qu’on peut avoir un problème sans avoir un problème
le résolvant. De plus, il existe le plus souvent plusieurs programmes
permettant de résoudre un même problème.

6
Exemple 1.1. Déterminer si un nombre naturel est pair ou impair est

un problème. En effet, la question s’applique à un ensemble des nombres
naturels et puis ensuite, la question « 35 est-il pair » a une réponse non.
Pour résoudre un problème par un programme, il est nécessaire de se fixer
une représentation des instances du problème. C’est sur cette représentation
qu’opérera le programme.
Exemple 1.2. Les instances du problème de l’exemple 1.1 peuvent être
représentées à l’aide de la notation binaire. Maintenant, le programme qui
résout le problème est alors celui qui examine le dernier chiffre
de la représentation. Dans ce cas, le programme répond nombre pair si
ce chiffre est 0 et nombre impair si ce chiffre est 1. De même, on peut
utiliser la notation décimale. Le problème pourrait être résolu par
le programme qui convertit la représentation binaire en représentation
décimale et répond nombre pair si le dernier chiffre de cette représentation
est dans l’ensemble {0, 2, 4, 6, 8} et nombre impair dans les autres cas.
Considérons maintenant d’autres exemples de problèmes.
Exemple 1.3.
 Trier un tableau de nombres est un problème. C’est bien un problème
soluble par l’informatique, il existe beaucoup d’algorithmes de tri, dans la
littérature informatique.
 Déterminer si un programme écrit dans un langage de programmation tel que
c ou C++, s’arrête quelles que soient les valeurs des données qui lui sont
fournies est un problème (problème d’arrêt).
 Déterminer si un polynôme à coefficients entiers a des racines entière est un
problème (dixième problème de Hilbert).
La théorie que nous allons développer dans ce cours montrera que
les deux autres ne le sont pas.
Dans ce qui suit, nous considérons seulement une classe limitée
de problèmes : les problèmes dont la réponse est binaire (oui/non, 1/0).
La classe des problèmes binaires (dont la réponse est binaire) est visiblement
une classe limitée, mais elle est suffisante pour étudier les phénomènes qui nous
intéressent. De plus, il y a des résultats qui montrent que la classe des
problèmes binaires peuvent être généralisées aux problèmes non binaires.
1.2.2. Notion de programme exécuté sur un ordinateur
On appellera procédure effective, une solution à un problème qui a
la forme d’un programme pouvant être exécuté sur un ordinateur.

7
Par exemple, un programme écrit en C est une procédure effective si c’est

un programme qui s’arrête. Pourquoi ? Parce que le programme C peut être
compilé en code machine et que le processeur de la machine est à même
d’exécuter ce code en le réduisant à son tour à des opérations élémentaires sur
des représentations binaires.
Une autre explication est que le programme C contient toute l’information
nécessaire pour résoudre le problème. Une fois que l’on dispose
du programme et des outils qui permettent de l’exploiter, il est possible
de résoudre sans la moindre information complémentaire, sans prendre
la moindre décision. Tout est précisé par le programme l’ordre ne devra poser
aucune question pour exécuter le programme.
On sait que le langage de programmation ne définit une procédure effective
que par l’intermédiaire d’une procédure d’interprétation (compilateur ou
interpréteur). Le fait que cette procédure existe sera suffisant pour que les
résultats que nous démontrerons soient applicables aux
programmes écrits dans tous les langages de programmation usuels.
Pour formaliser la notion de procédure effective, nous utiliserons en fait
des formes tellement simples de langages de programmation, où la procédure
d’interprétation correspondante est immédiate. Cela va nous faciliter
de raisonner sur des comportements possibles de tels programmes.
Nous appellerons ces types de programmes dont le mécanisme d’interprétation
est immédiat des automates. Dans ce qui suit, un automate sera donc un
programmeur et non pas une machine sur laquelle est un programme est
exécuté.
A chaque classe d’automates (langage de programmation) que nous
définissons, sera associé un mécanisme d’exécution (très simple) qui nous
permettra de raisonner au sujet de ce qui se passe lors de l’exécution d’un tel
automate (programme).
1.3. LA FORMALISATION DES PROBLEMES
Si un problème doit être résolu par une procédure effective, il faut que
ses instances soient représentées d’une façon accessible à cette procédure
effective. Quelles sont les représentations possibles ? Si, par exemple,
la procédure effective est un programme en C, l’instance du problème (les
données sur lesquelles le programme opère) devra être représentée par
une collection d’entiers, de chaînes de caractères, des réels, …
Ici, nous voulons adopter une représentation générale faisant abstraction
des types de données particuliers utilisés par un langage de programmation.

8
Pour concevoir une telle représentation, examinons ce qui se passe

au niveau du code machine. A ce niveau, toutes les données sur lesquelles
un programme opère sont représentées par des séquences de bits.
Nous allons adopter une légère généralisation de ce point de vue et supposer
que chaque ensemble de données (instance de problème) est représenté par une
chaîne (instance de symboles) est représenté par une chaîne finie de
symbole. L’ensemble des symboles que nous utiliserons dépendra du problème
considéré, il pourrait par exemple, être l’ensemble des chiffres {0, …, 9}
ou l’ensemble des lettres [a, ..., z}.
1.3.1. Alphabet et mots
Pour représenter un problème, nous choisissons d’abord un ensemble fini
de symboles. Nous appelons cet ensemble l’alphabet, que nous noterons
souvent par la lettre grecque .
Définition 1.1. Un alphabet est un ensemble fini des symboles.
Cela signifie que, nous allons associer à chaque élément de l’ensemble
une représentation arbitraire. La seule caractéristique importante
d’un alphabet est sa lettre (le nombre d’éléments qu’il contient).
Exemple.  a, b, c ,  ,  ,  , 1, 2, 3  ou encore {, , }, son des
alphabet de taille 3.
Définition 1.2. Un mot défini sur un alphabet est une séquence finie d’élément
de cet alphabet. Un mot a une longueur finie mais arbitraire.
Exemple. – a, abs, bbbssnbnzzyyyn ordinateurapide, sont des mots
de l’alphabet  =  a, b, . . . , z 
- 4  3  5  2 , 12765,   sont des mots de l’alphabet {0, …, 7, ,
, , }.
On appellera la longueur d’un mot, le nombre de caractères qu’il contient.
Si un mot est donné par , sa longueur sera notée ω . Par exemple,
la longueur du mot  = aaabbaaaabb est ω = 11, on écrira aussi pour chaque
caractère  (1) = a,  (2) = a, …,  (11) = b.
1.3.2. La représentation des problèmes
On sait que toutes les données (nombres, chaînes de caractères, images, son)
utilisées en informatique sont clairement représentables par des chaînes
de caractères. Donc, les mots servent à représenter les instances
d’un problème.

9
Soit un problème binaire dont les instances sont encodées par les mots
définis sur un alphabet . L’ensemble de tous les mots définis sur  peut être
partitionné en trois sous ensembles :
 les mots représentant les instances du problème pour lesquelles
la réponse est oui, ce sont les instances positives ;
 les mots représentant des instances du problème pour lesquelles
la réponse est non, ce sont les instances négatives ;
 les mots qui ne représentent pas des instances du problème.
On regroupe souvent les deux dernières classes et on obtient ainsi
une partition de l’ensemble de tous les mots en deux sous-ensembles :
les instances positives et les instances négatives.
1.3.3. Langages
Définition 1.3. Un langage est un ensemble de mots définis sur le même
alphabet.
On peut donc dire qu’un problème est caractérisé par le langage
des encodages de ses instances positives et que résoudre un problème revient à
reconnaître les instances positives de ses encodages. C’est pourquoi, dans
ce qui suit, nous considérerons toujours le problème de reconnaître
des langages, c'est-à-dire de distinguer parmi tous les mots construits sur un
alphabet donné ceux qui font partie du langage de ceux qui n’en font pas partie.
De ce fait, on ne fera plus des distinctions entre résoudre un problème et
reconnaître le langage des encodages des instances positives du problème.
Exemple.
  aab, aaaa,ε, a, b, ababababbb bbb ,  ε, aaa aaa,a, bbbbb et 
 (l’ensemble vide) sont des langages sur l’alphabet {a, b}.
 Pour l’alphabet  0, 1 ,   , 0,1, 00,01,10,11,000,001,010011,101,110,111,...  est
un langage (le langage contenant tous les mots). De même, l’ensemble de
toutes les représentations binaires de nombres pairs est un langage.
 Le langage  (langage vide ne contenant aucun mot) est différent
du langage {} (langage contenant le mot vide).
 L’ensemble des mots représentant des programmes écrits en C qui s’arrêtent
toujours est un langage.
1.4. LA DESCRIPTION DE LANGAGES
Nous allons dans cette partie, introduire une notation qui nous permettra
de décrire certains langages.

10
1.4.1. Des opérations sur les langages

Soit deux langages L1 et L2.
 L’union de L1 et L2 noté L1 L2, est le langage L1L2,= ω ω L1 ou ω L 2 .
 La concaténation de deux langages L1 et L2 est le langage contenant tous
les mots formés d’un mot de L1 suivi d’un mot de L2.
Formellement, L1 . L2 = ω ω  x y, x  L1 et y  L2 
 La fermeture itérative d’un langage L1 ou fermeture de Kleene est
l’ensemble des mots formés par une concaténation finie de mots de L1.
Formellement, L*1   ω  k  0 et ω1 , . . ., ωk  L1 tels que ω  ω1 ω2 . . . ωk .
 Le complément d’un langage est l’ensemble de tous les mots qui ne sont pas
dans ce langage. Formellement, L1   ω ω   L1 .
L’ensemble des langages que nous allons définir est appelé l’ensemble
des langages réguliers. Il est défini à partir de langages élémentaires et
des opérations d’union, de concaténation et de fermeture itérative.
Définition 1.4. L’ensemble  des langages réguliers sur un alphabet  est
le plus petit ensemble de langages satisfaisant les conditions suivantes :
1.    ;  ε   ;
2.  a   pour tout a   ;
3. si A, B  , alors A  B, A . B et A*  .
Dans cette définition, on veut dire que seuls les ensembles construits à partir
des ensembles élémentaires ,  ε  et  a  par les opérations d’union
de concaténation et de fermeture itérative sont dans .
Pour représenter les langages réguliers, nous allons utiliser une notation qui
porte le nom d’expressions régulières.
1.4.2. Les expressions régulières.
Définition 1.5. Les expressions régulières pour un alphabet  sont
les expressions formées par les règles suivantes :
1. ,  et les éléments de  sont des expressions régulières ;
2. si  et  sont des expressions régulières, alors     ,    ,   sont
des expressions régulières.
Les expressions régulières sont une notation pour représenter les langages
réguliers. Une expression régulière est une chaîne de caractères sur l’alphabet
’ =    ), (, , , ,  

11
Une expression régulière représente un langage régulier ? Lequel ?

La réponse à cette question peut paraître évidente et l’est puisqu’on la devine
aisément. La voici.
Définition 1.6. Le langage L  ε  représenté par une expression régulière  est
défini comme suit :
1. L() = , L() =  ε ;
2. L(a) =  a  pour tout a   ;
3. L α β  L  α   L  β ;
4. L α β  L α. L β ;
5. L α*   L α*
Théorème 1.1. Un langage est régulier si et seulement si il est dénoté par
une expression régulière.
Exemple.
 L’ensemble de tous les mots définis à partir d’un alphabet 
=  a1 , . . . , a n  est dénoté par l’expression régulière  a1  . . .  a n . Cette
expression est souvent abrégée en *.
 L’ensemble de tous les mots non vides (différents de ) définis à partir
d’un alphabet  =  a1 , . . . , a n  est dénoté par l’expression régulière
a1  . . .  a n a1  . . .  a n * . On écrit souvent cette expression par  * ou
encore   . Ainsi, la notation a  représentée aa*.
 Le langage dénoté par l’expression régulière a  b* a a  b* est
le langage des mots composés avec les lettres a et b qui contiennent
au moins un a.
Exercice. Montrer que a *b  b*a   a  b * , c'est-à-dire que les deux
* *
expressions régulières dénotent le même ensemble régulier.

Preuve.
a  b* , dénote l’ensemble de tous les mots composés des caractères a et b.
D’où il est clair que
a b  b a  a  b   i  .
* * * * *
Il nous reste à démontrer que a  b*  a *b  b*a  .

* *
Considérons le mot ω  ω1 ω2 . . . ωu a  b* .

12
On peut distinguer les quatre cas suivants :

1. ω  a n et donc ω ε a*  b* a
*
2. ω  bn et donc ω ε b*  a * b
*
3.  contient des a et des b et se termine par b. On a donc :

ω  a
.
.. 
a
bb . . .
 b a
.
.. 
a
bb . . .
 b
a* b a b
* *
a* b a b
* *
Ce qui montre que  appartient bien au langage dénoté par a *b  b*a  .
* *
4.  contient des a et des b et se termine par a. Une décomposition similaire à

celle du cas trois est possible.
Remarque. Il existe des langages non réguliers, c'est-à-dire qui ne sont pas
dénotés par des expressions régulières.

13
EXERCICES SUR LE CHAPITRE 1.
1.1. Démontrer que pour tout langage L, L* = L*  .

*
1.2. Montrer qu’il existe des langages L1 et L2 tels que L1  L2 *  L*1  L*2 .
1.3. Montrer qu’il existe des langages L1 et L2 tels que L1. L2 *  L*1. L*2 .
1.4. Soit R et S deux expressions régulières définies comme suit :
R = a a  b* ba
S = a b*  ba*  a *  b* 
1. Trouver un mot appartenant au langage dénoté par R, mais pas
au langage dénoté par S.
2. Trouver un mot appartenant au langage dénoté par S, mais pas
au langage dénoté par R.
3. Trouver un mot appartenant au langage dénoté par R et au langage dénoté
par S.
4. Trouver un mot qui n’appartienne ni au langage dénoté par S, ni
au langage dénoté par R.
1.5. Soit l’alphabet  =  0,1, 2, 3, 4, 5, 6, 7, 8, 9,  et l’expression
E = 1  2  ...  90 1  2  ...  9*  0 1  ...  9*  0 1  ...  9* 
Les mots 1998, 314, 71, 3140 appartiennent-ils au langage L(E) ?
1.6. Pour chacun des langages suivants, donner une expression régulière
représentant son complément.
1. a  b* b
2. a  ba  b*
1.7. Simplifier les expressions régulières suivantes.
1.   a *  b*  a  b
*
2. a  a  b * b   a b *   b a *

14
1.8. Montrer que chacune des expressions régulières suivantes représente

le langage a  b* .
1. a *b* 
*
2.     a  a  b *  b  a  b *
3. a *  a *b*  b a  b *
*
1.9. Les égalités suivantes sont-elles vérifiées ? Justifier.

1.10. Donner une expression régulière dénotant l’ensemble des mots sur
l’alphabet  =  a, b, c  comportant exactement deux a, dans lesquels tout
b est suivi d’au moins deux c et qui se terminent par a.

15
Chapitre 2. LES AUTOMATES FINIS
2.1. INTRODUCTION
Dans ce chapitre nous allons étudier une première classe d’automates :
les automates finis. Le concept d’automate fini nous aidera à cerner
la notion de procédure effective, mais ne sera pas un choix final
de modélisation pour cette notion.
Pour bien comprendre en quoi le concept d’automate fini est
une modélisation de la notion de procédure effective, il suffit de comprendre,
qu’elle est dérivée de la notion de programme exécuté sur un ordinateur.
En effet, considérons un ordinateur qui exécute un programme fixé.
On peut supposer qu’il est composé :
 d’un processeur auquel sont attachés un certain nombre de registres (dont le
compteur de programme, habituellement dénoté PC),
 d’une mémoire contenant le programme (comme celui-ci est fixé,
cette mémoire pourrait être une mémoire morte ou ROM),
 d’une mémoire servant à stocker les données.
Supposons qu’au départ, les données à traiter se trouvent dans la mémoire
de l’ordinateur. On peut alors schématiser l’exécution du programme par
une succession de cycles composés comme suit :
1. l’instruction indiquée par le compteur de programme est transférée
de la mémoire vers le processeur,
2. le processeur exécute cette instruction, ce qui a pour effet de modifier
le contenu des registres et/ou de la mémoire de donnée,
3. le PC est incrémenté (ou modifié si l’instruction exécutée est
une instruction de branchement).
Comment peut-on décrire cette succession de cycles d’exécution de façon
plus abstraite ? Pour pouvoir déterminer l’effet d’un cycle, il suffit
de connaître le contenu de la mémoire de données et des registres (dont
le PC).
A l’aide de cette information, on peut sans ambiguïté déterminer ce que sera
le contenu de la mémoire et des registres après l’exécution (d’une instruction).
On peut donc voir l’exécution d’une instruction comme une
transformation du contenu de la mémoire et des registres.
Nous appellerons le contenu de la mémoire et des registres de l’ordinateur,
son état. Chaque contenu de la mémoire et des registres définit un état différent.

16
Chaque cycle transforme donc l’état de la machine. Cette transformation ne

dépend que du programme et de la machine. Si ces deux éléments sont fixés
comme nous le supposons, cette transformation peut donc être vue comme une
fonction de l’ensemble des états de la machine vers lui-même.
Nous appellerons cette fonction, la fonction de transition. Connaître cette
fonction et l’état dans lequel la machine se trouve au départ, l’état initial, est
suffisant pour savoir exactement ce qui va se passer durant l’exécution du
programme par la machine. Remarquons enfin que, sur une machine sur une
machine donnée, le nombre d’états possibles est fini et fixé a priori, bien qu’en
général énorme.
Nous arrivons donc à une première modélisation d’un programme exécuté
par une machine est modélisé par :
 un ensemble fini d’états,
 une fonction définie sur cet ensemble d’état,
 un état initial.
Une exécution du programme par la machine est représentée parla séquence
d’états obtenus par applications successives de la fonction de transition à l’état
initial. Notre modélisation implique que le nombre de données différentes qui
peuvent être traitées est fini et fixé. Or, nous avons modélisé les problèmes par
des langages. Cela signifie qu’une procédure effective doit pouvoir être
appliquée à une infinité de mots différents, ce qui n’est pas possible dans notre
modèle. Nous devons donc l’adapter pour que des mots de longueur arbitraire
puissent être traités.
Supposons donc que la machine possède un dispositif de lecture qui peut
consulter à chaque instant le caractère suivant du mot à traiter. Le seul point à
éclaircir pour adapter notre modèle à cette situation est de déterminer quand on
passe au caractère suivant. Nous allons supposer que cela se fait à chaque cycle.
 Si les caractères sont fournis plus lentement que les cycles de la machine, on
peut supposer que celle-ci est bloquée jusqu’à ce que le caractère suivant soit
disponible.
 Dans notre modélisation, un cycle équivaut à une application
de la fonction de transition. S’il faut plusieurs cycles pour traiter
un caractère, ceux-ci peuvent être remplacés par un cycle unique.
En effet, il suffit de redéfinir la fonction de transition pour qu’elle modélise
cette succession de cycles par une seule transition.
 Après avoir lu le dernier caractère, la machine s’arrête et fournit
sa réponse.

17
2.2. DESCRIPTION
Un automate fini déterministe se compose des éléments suivants.
 Un ruban d’entrée sur lequel on place le mot à traiter. Ce ruban est
divisé en casses et chaque case contient un seul caractère du mot à traiter
appelé le mot d’entrée. L’automate possède une tête de lecture qui
indique la position du caractère suivant à lire dans le mot d’entrée.
Ruban : b a a a b
Tête :
Figure 2.1. Automate fini

 Un ensemble fini d’états. Parmi ces états, nous distinguerons :
- un état initial qui est l’état de l’automate au début de l’exécution,
- des états accepteurs qui serviront à définir les mots que l’automate
accepte (c'est-à-dire ceux pour lesquels il répond « oui »).
 Une fonction de transition. Cette fonction indique pour chaque état et
symbole lu quel est l’état suivant de l’automate.
L’exécution d’un automate fini sur un mot donné peut se décrire comme
suit :
a) Au départ, la machine se trouve dans l’état initial et le mot d’entrée est
placé sur le ruban. La tête de lecture se trouve devant le premier caractère
du mot d’entrée.
b) A chaque étape de son exécution, l’automate lit un symbole du ruban,
détermine l’état suivant au moyen de la fonction de transition puis avance
la tête de lecture vers la case suivante du ruban.
c) L’automate s’arrête lorsque toute la chaîne a été lue. Le mot est accepté
(l’automate répond qu’il fait partie du langage) si la machine se trouve
alors dans un état accepteur.
2.3. FORMALISATION
Plus formellement, nous pouvons dire qu’un automate fini déterministe est
défini par un quintriplet M = (Q, , , s, F), où
- Q est un ensemble fini d’états,
-  est un alphabet,
-  : Q x   Q est la fonction de transition,
- s  Q est l’état initial,
- F Q est l’ensemble des états accepteurs.

18
Intuitivement, un automate est une machine qui résout un problème, c'est-à-

dire qui reconnaît (accepte) un certain langage. Donner une signification à un
automate revient donc à définir le langage qu’il accepte.
2.4. REPRESENTATION ET EXEMPLES
Un automate fini est entièrement défini par le quintriplet (Q, , , s, F).
Toutefois, en pratique, on représentera souvent un automate fini au moyen
d’un graphe. Chaque état de l’automate est représenté par un sommet
du graphe. La relation de transition est représentée par de arcs étiquetés.
Si (, ) = q, le graphe comporte un arc étiqueté par  reliant les sommets  et
q. Par convention, l’état initial est repéré par une pointe de flèche, et les états
accepteurs par un double cercle.
Exemple 1.
a b
Le graphe b
qo q1
a
représente l’automate défini par
: q   (q, )
qo a qo
qo b q1 Q =  q o , q1 
q1 a qo  =  a, b 
q1 b q1 s= q o
F =  q1 
Cet automate accepte l’ensemble des mots se terminant par b.

Exemple 2. Le langage accepté par l’automate
b a
a
qo q1 q2
b b
est  ω ω contient pas 2a consécutifs .

19
2.5. LES AUTOMATES FINIS NON-DETERMINISTES

Dans cette section nous allons considérer une généralisation des automates
finis. Cette généralisation permettra à l’automate de choisir une exécution parmi
plusieurs. Cette possibilité est en contraction avec notre intuition de la notion de
procédure effective. Alors, pourquoi la considérer ? Il y a plusieurs raisons.
1. lorsque l’on considère une modélisation de la notion de procédure effective,
il est important de se poser des questions du genre : « Et si on ajoutait la
possibilité X … ? » L’intérêt de ce type de question est de voir si notre
modélisation est robuste, c'est-à-dire si de petites variations ne modifient pas
les conclusions que l’on peut tirer. Par extension, il est aussi intéressant de
voir les conséquences de modifications plus profondes.
2. indépendamment de leur relation avec la notion de procédure effective,
les automates finis sont intéressants comme formalise de description
de langages. Or, il se fait que l’introduction du non-déterminisme facilite
nettement la description de certains langages.
2.5.1. Description
Les automates finis non-déterministes sont des automates finis où l’on
permet :
- plusieurs transitions correspondant à la même lettre dans chaque état,
- des transitions sur le mot vide (c'est-à-dire sans avancer dans le mot
d’entrée),
- des transitions sur des mots de longueur supérieure à 1 (regroupement
de transitions).
On voit déjà à partir de cette définition qu’un automate non-déterministe
aura en général plusieurs exécutions sur un même mot. Pour que ce mot soit
accepté, il suffira qu’une seule de ces exécutions mène à un état accepteur.
De façon imagée, on peut dire que l’on laisse à l’automate le soin de choisir
la « bonne » exécution.
Insistons encore sur le fait que les automates finis non-déterministes ne
définissent pas en tant que tels une procédure de calcul. Ils représentent
seulement un formalisme utile pour la définition de langages. L’utilité de non-
déterministe vient de ce qu’il permet de représenter très simplement
la disjonction. Construire un automate non-déterministe qui accepte tous
les mots acceptés par un automate A ou par un automate B est très simple.
Il n’en irait pas de même de la construction d’un automate déterministe.

20
2.5.2. Formalisme
Formellement, un automate fini non-déterministe se définit presque comme
un automate fini déterministe. La différence est que nous avons maintenant une
relation de transition et non plus une fonction de transition, puisque on laisse la
possibilité à un état d’avoir plusieurs successeurs pour une même lettre se
trouvant sur le ruban d’entrée.
2.5.3. Exemples
1. Le langage accepté par l’automate M suivant
a aa

b
qo q1
a,b q2
b a
b
q3
bbb q4
  
est L(M) = a  ab* bbbb*  a  ab* abb aa* a * . 
2. Soit M l’automate ci-dessous.
a ab
a
qo q1 q2
est L(M) =  * ab ab* , c'est-à-dire l’ensemble des mots se terminant par

au moins une répétition de ab.
Remarque. Notons que dans un automate non-déterministe, la relation
de transition n’est pas nécessairement totale. C'est-à-dire que dans chaque
état il n’y a pas forcément une transition pour chaque lettre de l’alphabet.
2.6. L’ELIMINATION DU NON DETERMINISME
Dans cette section nous allons démontrer que le non-déterminisme n’ajoute
rien à la capacité des automates finis. Pour ce faire, nous allons prouver que
l’on peut toujours remplacer un automate fini non-déterministe par un automate
fini déterministe équivalent. La notion d’équivalence entre automate est
naturellement celle d’égalité des langages acceptés.

21
Définition. Deux automates M1 et M2 sont équivalents s’ils acceptent le même

langage, c'est-à-dire si L(M1) = L(M2).
Théorème 2.1. Pour tout automate fini non-déterministe, il est possible
de construire un automate fini déterministe équivalent.
Principe de la construction. Il y a deux éléments essentiels qui différencient un
automate non-déterministe d’un automate déterministe :
- la présence de transition sur des mots de longueur supérieure à 1,
- le fait que les transitions possibles pour un même état et même contenu
du ruban d’entrée ne sont pas exclusives (autrement dit la présence
du non-déterministe).
Pour obtenir un automate déterministe à partir d’un automate non-
déterministe, nous commencerons donc par éliminer les transitions sur des mots
de longueur supérieure à 1. Cela se fait par une construction schématisée dans la
figure 2.2.
aba
a b a
Figure 2.2. Elimination des transitions de longueur > 1.
Chaque état de l’automate déterministe correspondra à un ensemble d’états

de l’automate non-déterministe.
Exemple 1.
a q1 {qo , q1 }
a
qo
 {qo}
b
q2 b
{q2}
Figure 2.3 Elimination du non-déterministe.

La figure 2.3 représente une transformation de l’automate non-déterministe à
l’automate déterministe. Dans l’état qo et pour la lettre a, l’automate non-
déterministe peut aller vers l’état qo vers l’état q 1 . L’automate
déterministe, quant à lui, aura une seule transition pour la lettre a. Cette
transition mène vers un état étiqueté  qo , qo  indiquant qu’il correspond à deux
états possibles de l’automate non-déterministe.

22
Exemple 2. La figure 2.4 représente un automate non-déterministe et l’automate

déterministe correspondant. b
q1 a q2

a a a
qo a

q3
b
 q4
a
b
a
{q1, q2, q3 }
a b
{qo , q1, q3 } a
{q1, q3, q4 }
a
b
{q3, q4 }
b
b
Figure 2.4. Transformation selon l’exemple 2.
Dans la figure 2.4, nous n’avons pas représenté tous les 25 états
de l’automate M’. Nous avons uniquement représenté les états accessibles à
partir de l’état initial de M’. Intuitivement, un état p est accessible à partir d’un
état q s’il existe une exécution qui mène de p à q.
2.7. AUTOMATES FINIS ET EXPRESSIONS REGULIERS
Théorème 2.2. Un langage est régulier si et seulement si il est accepté par un
automate fini.
Pour déterminer ce théorème, nous utiliserons le fait qu’un langage est
régulier si et seulement si il est décrit par une expression régulière
(théorème 1.1).
Lemme 2.1. Si un langage est dénoté par une expression régulière, il est accepté
par un automate fini non-déterministe.
Lemme 2.2. Si un langage est accepté par un automate fini non-déterministe, il
est régulier.

23
2.1. Soit M = (Q, , , so, F) un automate fini déterministe. Soit M’ = (Q, ,

, so, F’), où F’ est l’ensemble des états q'Q à partir desquels un état q Q
est accessible dans l’automate M, c'est-à-dire qu’il existe un mot  tel que
q', ω * q, ε . Quelle est la relation entre les langages acceptés par M et
par M’ ?
2.2. Pour chacun des langages suivants, construire un automate fini non-
déterministe l’acceptant.
1. les représentations binaires des nombres pairs.
2. les représentations décimales des multiples de 3.
3. le langage des mots sur l’alphabet  a, b contenant soit la chaîne aab soit
la chaîne aaab.
2.3. Construire des automates déterministes pour les langages décrits à
l’exercice 2.2.
2.4. Appliquer la construction éliminant le non-déterministe à l’automate décrit
à l’exemple du paragraphe 2.5.
2.5. Pour chacune des expressions régulières suivantes, construire un automate
acceptant le langage qu’elle décrit.
1. a* b
2.   a  aab*  a * aab*

24
Chapitre 3. LES GRAMMAIRES REGULIERES
3.1. INTRODUCTION
Dans ce chapitre, nous allons faire une parenthèse dans notre recherche
d’une formalisation de la notion de procédure effective. Nous nous
intéresserons de plus près à la notion de langage, non pas en tant que
formalisation de la notion de problème mais en tant qu’ensemble de mots
satisfaisant un certain nombre de règles
Cette vue de concept de langage a son origine dans des essais de
formalisation du langage naturel. Le but était de donner une description précise
des règles permettant de construire les phrases correctes d’une langue.
Une grammaire, est un ensemble de règles. Les grammaires donnent
une description générative d’un langage, c'est-à-dire qu’elles nous disent
comment construire des éléments appartenant au langage. Par contre, un
automate donne une description analytique d’un langage. C'est-à-dire qu’il nous
donne un procédé pour reconnaître les éléments du langage. Ces deux forment
de description de langages sont complémentaires et il est souvent utile de
disposer de l’une et de l’autre.
Exemple. Dans le cas d’un langage de programmation, on se sert d’une
description générative lorsque l’on écrit un programme et d’une description
analytique lorsque l’on en fait l’analyse syntaxique (lors de la compilation).
Dans ce chapitre, nous allons donner une description générative (autres que
les expressions régulières) des langages réguliers et montrer comment elle peut
être convertie en une description analytique (un automate fini) et vice-versa.
3.2. LES GRAMMAIRES
Principe. Le principe de base des grammaires et de données un ensemble de
règles qui permettent de générer les mots d’un langage. Ces règles sont des
formes de règles de réécriture, c'est-à-dire qu’elles indiquent qu’une
séquence de symboles peut être remplacée par une autre séquence de
symboles. Les mots générés par la grammaire sont alors ceux qui peuvent
être obtenus en appliquant ces règles à partir d’un symbole spécial appelé
symbole de départ.

25
Définition 3.1. Une grammaire est un quadruplet G = (V, , R, S). Ses éléments
sont les suivants :
 V est un alphabet (ensemble fini de symboles)
   V est l’ensemble des symboles terminaux
 V -  est l’ensemble des symboles non terminaux.
Les des symboles terminaux sont ceux qui fait partie de l’alphabet sur lequel
le langage généré par la grammaire est défini. Les symboles non terminaux
sont ceux qui n’apparaissent pas dans les mots générés mais qui sont utilisés au
cours de la génération.
 R   V x V*  est un ensemble fini de règles aussi appelées productions.
La signification intuitive de ces règles est que le premier élément d’une
règle peut être remplacé par le deuxième élément de cette règle. des
symboles non terminaux.
 S  V -  est le symbole de départ, c’est à partir de ce symbole que l’on
commencera la génération de mots au moyen de la grammaire.
Il y a quelques habitudes de notation lorsque l’on décrit une grammaire.
- Les éléments de V -  sont représentés par des lettres majuscules : A, B,
- Les éléments de  sont représentés par des lettres minuscules : a, b, …
- Les règles ou productions (, )  R sont notées    ou encore par
  G
  si l’on veut explicitement indiquer que la règle fait partie
de la grammaire G.
- Le symbole de départ est souvent désigné par S.
- Comme dans le contexte des expressions régulières, le mot vide est
dénoté par .
Exemple 1. Les éléments suivants définissent une grammaire :
 V   S, A, B, a, b ,
    a, b ,
 R   S  A, S  B, B  b B, A  aA, A   , B   ,
 S est le symbole de départ.
Exemple 2. Le mot aaaa fait partie du langage défini par la grammaire
de l’exemple 1. En effet, il est obtenu comme suit :

26
S
A Règle S  A
aA A  aA
aaA A  aA
aaaA A  aA
aaaa A  aA
A
aaaa A
Types de grammaires
Les grammaires sont habituellement classifiées en 4 types suivant les
restriction que l’on place sur la forme de leur règles. Cette classification a pour
but de définir des classes de grammaires suffisamment puissants pour être utiles
dans de nombreuses dans applications, mais plus faciles à traiter que les
grammaires générales (sans restriction sur les règles). Les types de grammaires
que nous considérons sont les suivants.
Type 0 : pas de restriction sur les règles.
Type 1 : grammaires sensibles au contexte. Les règles de ces grammaires  
 doivent satisfaire la condition α   , c'est-à-dire leur membre de
droite doit contenir au moins autant de symboles que leur membre de
gauche. Pour permettre aux grammaires de type 1 de générer le mot vide, on
permet une expression à la restriction précédente : la production
S  , où S est le symbole de départ, peut faire partie de la grammaire pour
autant que S n’apparaisse pas dans le membre de droite d’une production.
Type 2 : grammaires hors-contexte. Dans ces grammaires, toutes les
productions doivent avoir la forme où A  V -  et où il n’y a pas de
restriction sur . Une grammaire est donc hors-contexte si le membre de
gauche de chacune de ses productions est constitué d’un seul symbole non
terminal.
Type 3 : grammaires régulières. Une grammaire est régulière si toutes
ses productions ont une des formes : A  B
A  où A, B  V -  et ω  * . Toute production d’une grammaire régulière
a donc un membre de gauche constitué d’un seul non-terminal et un membre
de droite constitué d’un mot de symboles terminaux suivi éventuellement
d’un seul non-terminal.
La relation entre les différents types de grammaires que nous venons de
définir est alors simplement la suivante :
type 3  type 2  type 1  type 0

27
3.3. LES GRAMMAIRES REGULIERES

Si les grammaires de type 3 sont appelées grammaires régulières, ce n’est
pas un hasard. En effet, les langages qui peuvent être générés par ce type de
grammaires sont les langages réguliers. Démontrons-le.
Théorème 3.1. Un langage est régulier si et seulement si il est généré par
une grammaire régulière.
Démonstration
Si un langage est régulier, il est généré par une grammaire régulière.
Considérons un langage régulier L. puisque ce langage est régulier, il existe
un automate fini non déterministe M = (Q, , , s, F) qui accepte ce langage,
i.e. L = L(M). Utilisant l’automate M, nous allons construire une grammaire
régulière.
G  VG , G , SG , R G 
qui génère L(M) = L. Les éléments de G sont définis en fonction des éléments
de M comme suit :
 G   (les symboles terminaux de la grammaire sont ceux de l’alphabet
de M),
 VG  Q  Σ (il y a un non-terminal de G pour chaque état de M),
 S G = s (le symbole de départ de G correspond à l’état initial de M),
 A   B, pour tout A,  , B  
 RG    (il y a une production pour
 A   pour tout A  F 
chaque transition de  est une production vers le mot vide pour chaque
état dans F).
Pour terminer cette partie de la démonstration, nous devons encore montrer
qu’un mot est bien accepté par M si et seulement si il est généré par G.
Cela est relativement évident et l’on s’en convainc aisément en faisant le
parallèle entre les exécutions de M et les dérivations de G.
Si un langage est généré par une grammaire régulière, il est régulier.
Nous allons démontrer qu’un langage L généré par une grammaire
régulière est accepté par un automate fini non-déterministe. Soit
G  VG , G , SG , R G 
La grammaire qui génère le langage L.
Un automate fini non-déterministe
M = (Q, , , s, F)
qui accepte L peut être défini comme suit :

28
 Q  ΣG  ΣG   f  (les états de M sont les non-terminaux de G plus un

nouvel état f),
 Σ  ΣG ,
 s = SG ,
 A, ω, B  pour tout A  ω B  R G 
 Δ  
 A, ω, f  pour tout A  ω  R G 
Il est aisé de voir que le langage généré par G est identique au langage accepté
par M.
3.4. LES LANGAGES REGULIERS
Nous avons rencontré quatre caractérisations différentes des langages
réguliers :
- les expressions régulières,
- les automates finis déterministes,
- les automates finis non-déterministes,
- les grammaires régulières.
Il est très utile de disposer de plusieurs caractérisations des langages
réguliers, en effet :
 pour montrer qu’un langage est régulier, il suffit de le décrire à l’aide
d’une de ces caractérisations, en pratique la plus commode pour le
langage considéré ;
 de même, pour démontrer une propriété des langages réguliers, on peut
choisir la caractérisation la mieux adaptée.
Illustrons ce type de démarche en démontrant quelques propriétés des
langages réguliers.
3.4.1. Propriétés des langages réguliers
Soit deux langages L1 et L2 . Il est aisé d’établir les propriétés suivantes :
 le langage L1  L2 est régulier. En effet, soit 1 ,  2 les expressions
régulières dénotant respectivement les langages L1 et L2 . L’expression
1  2 dénote le langage L1  L2 qui est donc régulier (théorème 1.1).
 une démonstration semblable nous permet d’établir que les langages
L1. L2 et L*1 sont réguliers.
Dénotons par  R l’inverse d’un mot , c'est-à-dire le mot  écrit de droite
à gauche (l’inverse de aab est baa). Alors le langage LR1    R  L1  est
régulier.

29
En effet, à partir d’un automate M = (Q, , , s, F) acceptant L1 , on peut

construire un automate M’ = (Q, , ’, s’, F’) acceptant LR1 .
En termes simples, cela se fait en inversant les transitions de M. Plus
précisément :
- F’ = { s } (l’état initial devient le seul état final),
- l’état initial est un nouvel état s’,
- Δ'   q, ωR ,     , ω, q   Δ    s' ,  , q   q  F  
(les transitions sont celles de M inversées plus une transition du nouvel
état initial vers chaque état final de M).
 Le langage L1  * - L1 (le complémentaire de L1 ) est régulier.
En effet, on peut construire un automate fini déterministe
M’ = (Q, , , s, F’) acceptant L1 , à partir d’un automate
déterministe M = (Q, , , s, F) acceptant L1 . Cela se fait en
permettant les états accepteurs et non accepteurs de M, à savoir F’ =
Q – F. Remarquons que la même construction ne peut pas se faire
avec un automate fini non-déterministe. En effet, un automate non-
déterministe accepte un mot s’il existe une exécution sur ce mot qui
mène à des états non accepteurs pour un mot qui est accepté par
l’automate. Pour un automate déterministe, cette difficulté n’existe
pas vu que l’exécution correspondant à un mot est unique.
 Le langage L1  L2 est régulier. Une première démonstration est
simplement d’observer que
L1  L2  L1  L2 (Loi de Morgan).
Une autre possibilité est de construire directement un automate déterministe
M = (Q, , , s, F) acceptant L1  L2 à partir d’automates déterministes.
M1 = (Q, , 1, s1, F1) et M2 = (Q2, , 2, s2, F2) acceptant respectivement L1 et
L2 . L’automate M simule l’exécution simultanée des deux automates M1 et M2
deux états de M seront donc une paire d’états : un état de M1 et un état de M2 .
Nous avons
Q  Q1 x Q2
 q1 , q 2 ,    1 , 2  si et seulement si 1 q1 ,    1 et  2 q2 ,    2 ,
s = ( s1, s2 )
F  F1 x F2

30
 Le langage L1 /L2   x  y  L2 tel que x y  L1  est régulier. Ce

langage porte le nom de quotient de L1 par L2 . Si M = (Q, , , s, F) où
F   q Q L Q, ,  , q, F1   L2   .
L’automate M est donc identique à M1 sauf en ce qui concerne ses états
accepteurs. Ceux-ci sont les états de M1 à partir desquels il est possible
d’atteindre un état accepteur de M1 par un mot de L2 .
3.4.2. Algorithmes
La plupart des problèmes concernant les langages réguliers sont solubles
par des procédures effectives. Considérons quelques exemples importants.
 Etant donné un langage régulier L et un mot   * , le problème
détermine si   L est soluble par une procédure effective. En effet, il
suffit de construire un automate déterministe à partir de la description
fournie pour le langage L (automate, expression régulière ou grammaire
régulière) et d’examiner l’exécution de cet automate sur le mot .
 Le problème de déterminer si un langage régulier L est vide, c'est-à-dire
si L =  est soluble par une procédure effective. On construit un
automate (déterministe ou non-déterministe) acceptant le langage L est
alors non vide si, dans le graphe représentant cet automate, il existe un
chemin entre l’état initial et un état final quelconque.
 Pour déterminer si un langage régulier L est universel (contient tous
les mots), c'est-à-dire si L  * , il suffit de tester si L   . Pour ce faire,
on construit l’automate acceptant le complément du langage L et on
vérifie que celui-ci n’accepte aucun mot.
 Pour vérifier que L1  L2 , on vérifie que L1  L2   .
 L’égalité de deux langages réguliers, L1  L2 , peut se vérifier en testant
les conditions L1  L2 et L2  L1 .

31
3.1. Décrire des grammaires générant les langages suivants :

1. a * b
2.  a  b   ab *  baab *
3. les mots sur l’alphabet  a, b   ), (, , , ,  représentant les
expressions régulières sur l’alphabet  a, b .
3.2. Décrire des grammaires générant les langages suivants :
1. a m b n c  m  n   
2. a m
b n c  m  n ou n   
3. le langage des palindromes sur  a, b , c'est-à-dire le langage des mots
  o1 ,...n tels que i, 0  i  n, i  ni
3.3. Donner un exemple montrant qu’il n’est pas vrai que tout sous-ensemble
d’un langage régulier est un langage régulier.
3.5. Les langages générés par les grammaires suivantes (symbole de départ S)
sont-ils réguliers ?
1. S  ABC Bb
A  aAB CC
A C
2. S  AC CC
A  abC C
bA  bC
3.6. Démontrer que le langage des mots construits sur l’alphabet  a, b et
comportant le même nombre de lettres a que des lettres b dans un ordre
quelconque n’est pas régulier.
3.7. Pour chacun des langages suivants, démontrer que ce langage n’est pas
régulier.
1. Le langage généré par la grammaire définie par les règles suivantes :
S  SS, S  aSa, S  bSb, S
2. L =   * Na ()  N b () , où Na () est le nombre de symboles a dans
le mot  et Nb () le nombre de symboles b.

32
3.8. Déterminer si les assertions suivantes sont vraies ou fausses.

1. Tout langage régulier a un sous-ensemble propre régulier.
2. Si L est régulier, alors   R   L  est régulier. (Note : si   o1 ,...n
alors  R  n ...1o )
3. Si L1 et L2 sont réguliers, alors  x x  L1 et x  L2  est régulier.
4. Toute union finie de langages réguliers est un langage régulier.
3.9. Soient les langages générés par une grammaire G dont toutes les
productions ont une des formes suivantes :
A  B, A  B, A
où A, B  V –  et    * . La classe de ces langages coïncide-t-elle avec la
classe des langages réguliers ? Justifier.

33
Chapitre 4. AUTOMATES A PILE ET LANGAGES

HORS-CONTEXTE
4.1. INTRODUCTION
Il n’existe pas d’automate fini qui accepte le langage a n b n . Par contre,
chaque langage composé des mots contenant le même nombre de lettres a et b,
mais où ce nombre est borné, c’est à die chaque langage de la forme

Lk  a n bn n  k 
est accepté par un automate fini. La situation est donc la suivante :
- chaque mot de la forme a n b n appartient à un langage Lk et ce mot peut donc
être reconnu par l’automate fini acceptant Lk ;
- par contre, il n’existe pas d’automate fini qui accepte tous les mots a n b n ,
c'est-à-dire l’union (infinie) de tous les langages Lk .
En termes intuitifs, chaque mot du langage a n b n peut être reconnu à l’aide
d’une mémoire finie, mais aucune mémoire finie ne permet de reconnaître
tous les mots a n b n . Est-ce une raison suffisante pour considérer que ce langage
ne peut être reconnu par une procédure effective ? Nous disons que non.
Donc, pour cerner la notion de procédure effective, il est nécessaire d’étudier
des automates dont la mémoire a une capacité illimitée.
Dans ce chapitre, nous allons introduire une première classe d’automates
de ce type. Ces automates sont des automates finis auxquels on a adjoint
une mémoire de capacité non bornée. Cette mémoire a la structure d’une pile,
c'est-à-dire d’une file à accès LIFO (las in first out, dernier arrivé premier parti).
4.2. LES AUTOMATES A PILE
4.2.1. Description
Un automate à pile non-déterministe se compose des mêmes éléments
qu’un automate fini, à savoir :
 un ruban d’entrée, et une tête de lecture,
 un ensemble d’états parmi lesquels on distingue un état initial et des états
accepteurs,
 une relation de transition.
A cela, on ajoute une pile de capacité illimitée initialement vide.
L’exécution d’un automate à pile sur un mot donné est semblable à celle
d’un automate fini non-déterministe. Toutefois, à chaque étape, l’automate à
pile consulte une partie du sommet de sa pile et la remplace par une suite de
symboles.

34
4.2.2. Formalisation
Un automate à pile non-déterministe, ou simplement un automate à pile, est
défini par un septuplet M = (Q, , , , s, F) où
 Q est un ensemble fini d’états,
  est un alphabet d’entrée,
  est un alphabet de pile,
 Z   est le symbole initial de pile,
 s  Q est l’état initial,
 F  Q est l’ensemble des états accepteurs,
    Q x * x *  x Q x *   est la relation de transition (ensemble
fini).
L’alphabet de pile  contient l’ensemble des symboles qui pourront
apparaître sur la pile. Il n’est pas nécessairement distinct de l’alphabet d’entrée
 (on peut avoir     ). Le symbole Z est le contenu initial de la pile. Les
transitions dans  sont semblables à celles d’un automate fini non-déterministe,
à part qu’elles spécifient en plus la manipulation de la pile. Ainsi, une transition
  ,  ,   , q,    
signifie que l’automate peut passer de l’état  à l’état q, pour autant que le mot
d’entrée commence par le préfixe u et que la chaîne  se trouve au sommet de la
pile. Après la transition, l’automate a consommé le préfixe u du mot d’entrée et
a remplacé le sommet de la pile  par la chaîne .
4.2.3. Exemples
Exemples 4.1. L’automate M = (Q, , , , Z, s, F) décrit ci-dessous accepte le
langage
a n
bn n  0 
 Q =  s,  , q ,
  =  a, b ,
  =  A ,
 F =  q , et  contient les transitions
(s, a, )  (s, A)
(s, , Z)  (q, )
(s, b, A)  (, )
(, , Z)  (q, )

35
Exemples 4.2. L’automate M = (Q, , , , Z, s, F) décrit ci-dessous accepte le

langage
 R 
 Q =  s,  , q ,
  =  a, b ,
  =  A, B ,
 F =  q , et  contient les transitions
(s, a, )  (s, A)
(s, b, )  (s, B)
(s, , )  (, )
(, a, A)  (, )
(, b, B)  (, )
(, , Z)  (q, )
Le langage ω ωR  est accepté par l’automate M à la foi sur état final et sur
pile vide. Il est toutefois possible de construire un automate comportant
seulement deux états acceptant le langage sur pile vide :
 Q =  s,  ,
  =  a, b ,
  =  A, B ,
  contient les transitions
(s, a, )  (s, A)
(s, b, )  (s, B)
(s, , )  (, )
(, a, A)  (, )
(, b, B)  (, )
(, , Z)  (, )
4.3. LES LANGAGES HORS-CONTEXTE
Définition
Au chapitre précédent, nous avons défini un grammaire hors-contexte
comme étant une grammaire G = (V, , R, S) dont toutes les productions sont
de la forme
AB
où A  (V –) et où il n’y a pas de restriction sur . La notion de grammaire
hors-contexte nous permet de définir la notion de langage hors-contexte.

36
Un langage est hors-contexte s’il existe une grammaire hors-contexte qui

génère ce langage.
Exemples 4.3. Le langage a n bn , n  0 est généré par la grammaire dont
les productions sont
1. S  aSb,
2. S  .
Ce langage est donc hors-contexte.
Exemples 4.4. Le langage des mots de la forme   R est généré par la
grammaire dont les productions sont
1. S  aSa,
2. S  bSb,
3. S  .
Ce langage est donc hors-contexte.
Exemples 4.5. Le langage généré par la grammaire dont les productions sont
1. S  ,
2. S  aB,
3. S  bA,
4. S  aS,
5. A  bAA,
6. A  bS,
7. B  aBB.
est un langage de tous les mots comportant le même nombre de lettres a et de
lettres b dans un ordre quelconque.
Théorème 4.1. Un langage est hors-contexte si et seulement si il est accepté par
un automate à pile.
Ce théorème établit un pont entre un langage hors-contexte et un automate
à pile. La démonstration de ce dernier se trouve dans [ ].
4.4. LES AUTOMATES A PILE DETERMINISTES
4.3.1. Principe
L’intérêt des automates déterministes est que, contrairement aux automates
non-déterministes, ils représentent une procédure de calcul qui peut être
directement simulée. Par exemple, si un langage hors-contexte est accepté par
un automate à pile déterministe dont chaque exécution est finie, cet automate
représente un algorithme pour reconnaître les mots appartenant à ce langage.
Cet algorithme sera en général beaucoup plus efficace.
Un automate à pile déterministe si, dans chaque configuration, il n’y a
qu’une seule transition possible. Formalisons cela.
37
Définition. Deux transitions   1 , μ1 , β1  , q1 , γ1   et   2 , μ2 , β2  , q2 , γ 2  
sont compatibles si
1. 1   2
2. μ1 et μ2 compatibles (c'est-à-dire μ 1 est un préfixe de μ 2 ou μ 2 est
préfixe de μ 1 ).
3. β1 et β2 compatibles.
Un automate à pile déterministe est simplement un automate à pile n’a pas
de transitions compatibles distincts.
Définition. Un automate à pile est déterministe, si pour toute paire de transitions
compatibles, ces transitions sont identiques.
4.3.3. Les langages hors-contexte déterministes
Les langages hors-contexte déterministes sont ceux acceptés par un automate
à pile déterministe.
Définition. Soit L un langage défini sur un alphabet , le langage L est un
langage hors-contexte déterministe, si et seulement si il est accepté par un
automate à pile déterministe.
 
Exemple. Le langage L1  ω o ωR ω   a, b * est déterministe hors-contexte.
 
Par contre, le langage L 2  ω ωR ω   a, b * est hors-contexte, mais pas
déterministe hors-contexte. Intuitivement, cela s’explique par le fait qu’il
faut pouvoir deviner où est le milieu du mot pour reconnaître L2 . Par contre
pour L1 , le milieu du mot est indiqué par la lettre C.
4.4.4. Propriétés des langages hors-contexte déterministes.
Si L1 et L2 sont des langages hors-contexte déterministes, nous avons
les propriétés suivantes :
 le langage * - L1 est aussi hors contexte déterministe. Intuitivement, cela
s’explique par le fait que pour complémenter le langage accepté par un
automate déterministe il suffit d’inverser les états accepteurs et non
accepteurs. En pratique, la démonstration est assez complexe car un
automate à pile peut avoir des transitions sur le mot vide,
 il existe des langages hors-contexte qui ne sont pas déterministes hors-
contexte. En effet, si tous les langages hors-contexte étaient déterministes
hors-contexte, alors le complément d’un langage hors-contexte serait
toujours hors-contexte, ce que nous savons être faux,

38
 les langages.
L1  L2 et L1  L2
ne sont pas forcement déterministes hors-contexte. Dans le cas de l’union,
cela se comprend intuitivement car, pour déterminer si un mot est dans
L1  L2 , il faut pouvoir décider s’il est dans L 1 ou s’il est dans L2 , ce qu’il
n’est pas toujours possible de faire de façon déterministe. La propriété
concernant l’intersection est alors une conséquence de la propriété
concernant l’union et celle concernant le complément.
4.4.5. Applications.
L’application principale des langages hors-contexte est la description de la
syntaxe des langages de programmation et l’analyse syntaxique correspondante.
Dans cette application, la syntaxe d’un langage de programmation est
donnée par une grammaire hors-contexte. Les programmes syntaxiquement
corrects sont alors tous ceux qui ont des mots générés par cette grammaire. Le
problème de l’analyse syntaxique est alors celui de déterminer si un mot (le
texte d’un programme) est dans le langage généré par la grammaire hors-
contexte et d’établir comment (c'est-à-dire à l’ide de quel arbre d’analyse) ce
mot a été généré.

39
EXERCICES SUR LE CHAPITRE 4
4.1. Soit M = (Q, , , , Z, s, F) l’automate à pile tel que :

 Q = { s, },   a, b ,   A, Z , F   s t
 ∆ contenant les transitions
(s, a, )  (s, A), (s, , )  (, ), (, b, A)  (, ), (, , Z)  (s, Z).
Les mots , aab et abaabb appartiennent-ils au langage accepté par M?
4.2. Décrire des automates à pile acceptant les langages suivants :
1. a n bn Cm
2. a n Cm bn
3. Les mots sur l’alphabet a, b  ), (,  , , ,   représentant les

expressions régulières sur l’alphabet a, b .
4.3. Décrire un automate à pile acceptant chacun des langages suivants :
1. a n bnm Cm avec n, m  0

2. L  a n x n  0, x  a, b* et x  n 
3. Le langage généré par la grammaire définie par les règles S  SS, S 
aSb, S  .
4.4. Pour chacun des langages suivants, donner une grammaire hors-contexte
qui le génère.
1. a n bn Cm
2. a n Cm bn
3. a n bm Cnm

40
4.5. Quel est le langage accepté par l’automate M = (Q, ∑, T, ∆, Z, s, F) décrit

ci-dessous ?
 Q = { s, , q, f },
   a, b, c ,
    A ,
 F   s et
 ∆ contenant les transitions
(s,a, )  (s, a) (s,b, )  (q, ) (s, C,A)  (, )
(q, b, )  (q, ) (q, C,A)  (, ) (, C, A)  (, ).
4.6. Démontrer que le langage a i

bi Ck i  j ou i  k  est hors-contexte.
Le complément de ce langage est-il hors-contexte ?
4.7. Démontrer que les langages suivants ne sont pas hors-contexte.
1) L  a n n est un nombre premier
2) L  a n bn Cm n  m  2 n 

3) L       a  b * 
4.8. Soit L un langage hors-contexte quelconque.
1. Le langage LR contenant les mots de L inversés est-il toujours contexte ?
Justifier.
2. L  LR est-il toujours hors-contexte ? justifier
4.9. Décrire un automate à pile déterministe qui accepte le langage
 
   R    a, b * .

41
Chapitre 5. LES MACHINES DE TURING.
5.1. INTRODUCTION
Bien que disposant d’une mémoire non bornée, les automates à pile ne
peuvent reconnaître le langage
a n b n Cn .
Or, il semble tout à fait possible de reconnaître ce langage à l’aide d’une
procédure effective. On ne peut donc pas adopter les automates à pile comme
formalisation de cette notion et il est utile d’examiner d’autres classes
d’automates. C’est exactement le but du présent chapitre où sont introduites les
machines de Turing (Alan Turing (1912 – 1954) : mathématicien anglais qui
décrit ce type d’automate en 1936). La différence principale entre les automates
à pile et les machines de Turing est que ces dernières disposent d’une mémoire
non bornée dont l’accès n’est pas limité à une discipline LIFO. On se terminera
par un théorème permettant de montrer que certains langages intuitivement
reconnaissables par une procédure effectue effective ne peuvent être accepté par
une machine de Turing. Nous allons adopter les machines de Turing comme
formalisation de la notion de procédure effective.
5.2. DEFINITION
5.2.1. Définition
Une machine de Turing (déterministe est composé des éléments suivants) :
 une mémoire infinie nous forme de ruban divisé en cases. Chaque case
du ruban peut contenir un symbole d’un alphabet de ruban,
 une tête de lecture se déplaçant sur le ruban,
 un ensemble fini d’écarts parmi lesquels on distingue un état initial et
un ensemble d’états accepteurs,
 une fonction de transition qui pour chaque état de la machine et symbole se
trouvant sous la tête de lecture précise :
- l’état suivant,
- un caractère qui sera écrit sur le ruban à la place du caractère se trouvant
sous la tête de lecture,
- un sens de déplacement de la tête de lecture.
L’exécution d’une machine de Turing peut se décrire comme suit :
 Initialement, le mot d’entrée se trouve au début du ruban. Les autres cases
du ruban contiennent toutes un symbole spéciale symbole blanc.
La tête de lecture est sur la première case du ruban et la machine se
trouve dans son état initial.

42
 A chaque étape de l’exécution, la machine :

- lit le symbole pour celui précisé par la fonction de transition,
- remplace ce symbole par celui précisé par la fonction de transition,
- déplace sa tête de lecture d’une case vers la gauche ou vers droite suivant
le sens précisé par la fonction de transition,
- change d’état comme indiqué par la fonction de transition.
a b a b b a b b b b
q q’
 Un mot est accepté par la machine lorsque l’exécution atteint un état
accepteur.
Une machine de Turing est formellement décrite par un septuplé
M = (Q , , ∑, , s, B, F),
où
 Q est un ensemble fini d’états,
  est l’alphabet de ruban (l’alphabet utilisé sur le ruban),
 ∑   est l’alphabet d’entrée (l’alphabet utilisé pour le mot d’entrée),
 s  Q est l’état initial,
 F  Q est l’ensemble des états accepteurs,
 B   – ∑ est le « symbole blanc » (souvent dénoté ≠),
 S : Q x   Q x  x  L, R  est la fonction de transition (L et R) sont
utilisés pour représenter respectivement un déplacement de la tête de
lecture vers la gauche (left) et vers la droite (right).
Exemple. Soit la machine de Turing
M = (Q, , ∑, S, , s, B, F),
où :
 Q =  qo , q1 , q 2 , q 3 , q 4 ,
  = { a, b, x, y,  },
  =  a, b ,
 s = qo ,
 B = ,
 F =  q4 
  est donné par le tableau ci-dessous (le symbole « - » indique que la
fonction de transition n’est pas définie pour ces valeurs).

43
a b X Y 
qo  q1 , X, R  - -  q 3 , Y, L  -
q1  q1 , a, R   q2 , Y, L  -  q1 , Y, L  -
q2  q2 , a, L  -  qo , X, R   q2 , Y, L  -
q3 - - -  q 3 , Y, L  ( q 4 , ,
R)
q4 - - - - -
On peut se convaincre que cette machine de Turing accepte le langage a n b n

pour n  o. En effet, elle remplace de façon répétée une paire de symboles a et b
respectivement par X et Y. si tous les remplacements sont possibles et qu’une
fois terminée, le ruban ne contient plus aucun symbole a ou b, le mot est
accepté. A titre d’exemple, la suite des configurations obtenues pour le mot
d’entrée aaabbb est à la figure ci-dessous.
 qo ,  , aaabbb  q1 , XXXYY,b 
 q1 , X, aabbb  q2 , XXXY,YY 
 q1 , Xa,abbb   q2 , XXX, YYY 
 q1 , Xaa,bbb   q2 , XX, XYYY 
 q2 , Xa,aYbb   qo , XXX,YYY 
 q2 , X, aaYbb  q3 , XXXY,YY 
 q2 ,  , XaaYbb  q3 , XXXYY,Y 
 qo , X, aaYbb  q3 , XXXYYY, 
 q1 , XX,aYbb  ( q 4 , XXX, YYY , )
Cette figure représente l’exécution d’une machine de Turing.

5.2.3. Langage accepté et langage décidé
Définition. L’exécution d’une machine de Turing sur un mot w est la suite
de configuration maximale, c'est-à-dire telle que soit
 elle est infinie,
 elle se termine dans une configuration dont l’état est accepteur, ou
 elle se termine par une configuration à partir de laquelle aucune
configuration n’est dérivable.
Définition : un langage l est décidé par une machine de Turing M si
 M accepte L,
 M n’a pas d’exécution infinie.
Par conséquent, un langage décidé par une machine de Turing peut être reconnu
par une procédure effective.

44
Remarque
 Pour les automates finis déterministes, les langages acceptés sont les mêmes
que les langages décidés.
 Pour les automates finis non-déterministes, on ne peut pas parler de langages
décidés (non déterministe). Cependant, tout langage accepté peut être décidé
par un automate fini déterministe.
 Le concept de langage décidé ne s’applique pas non plus aux automates à
pile non déterministe.
 Un automate à pile déterministe décide un langage s’il n’y a pas d’exécution
infinie, ce qui est le cas si l’automate ne comporte de boucle sur des
transitoires  (transitions sur le mot vide).
5.3. THESE DE TURING-CHURCH
La thèse de Turing-Church s’énonce comme suit. « Les langages reconnus
par une procédure effective sont ceux décidés par une machine de Turing ».
Cette thèse est la clé de voûte de notre étude des notions de calculabilité.
En effet, elle fournit l’élément qui nous manquant jusqu'à présent pour
démontrer que certaines langage ne peuvent pas être reconnus par une
procédure effective : une formalisation de cette notion. Notons encore une fois
que cette la thèse de Turing-Church est une thèse et non un théorème. Adopter
la thèse de Turing-church revient à choisir une modélisation du concept de
procédure effective.
Ce qui est décidé par une machine de Turning de simuler le fonctionnement
d’une machine de Turing à l’aide d’un crayon et de papier ou, de façon plus
moderne, à l’aide d’un programme tournant sur une machine réelle.

45
EXERCICES SUR LE CHAPITRE 5
5.1. Soit la machine de Turning M = ( Q, , Σ, , qo , #, )

où
 Q =  q o , q1 , q 2 , q 3 
  =  a, b, A, A' , B, B' 
 Σ =  a, b  et
  contient les transitions
 qo , a    q1 , A' , R   qo , b    q3 , B' , R 
 q1 , a    q1 , a, R   q3 , a    q 3 , a, R 
 q1 , b    q1 , b, R   q 3 , b    q3 , b, R 
 q1 , A    q1 , A, R   q3 , A    q3 , A, R 
 q1 , B    q1 , B, R   q 3 , B    q3 , B, R 
( q1 , )   q2 , A, L  ( q 3 , )   q 3 , B, L 
 q2 , a   q2 , a, L   q 2 , b    q 2 , b, L 
 q2 , A   q2 , A, L   q 2 , B    q2 , B, L 
 q2 , A   qo , A, R   q 2 , B'    qo , B, R 
1. Quel est le contenu du ruban après l’exécution de M sur le mot d’entrée
abab ?
2. Quel est le comportement général de M sur un mot d’entrée   (a 
b)* ?
5.2. Construire une machine de Turing qui accepte le langage L =
a n
bn n  m 
5.3. Décrire une machine de Turing calculant la fonction f(x) = x div 2 où div
représente la division entière, et où x et est représenté selon la notation unaire.
5.4. Construire une machine de Turing qui calcule la somme de deux nombres
représentés en notation binaire.
5.5. Que peut-on dire à propos du langage accepté par une machine de Turing
M, si toutes les transitions de M déplaçant la tête de lecture vers la date ?

46
Chapitre 6. LES FONCTIONS RECURSIVES
6.1. INTRODUCTION
Jusqu’à présent, nous avons abordé la formalisation du concept
de procédure effective par l’intermédiaire d’automates reconnaissant des
langages. D’autres approches peuvent être envisagées. Une possibilité est de
considérer les fonctions définies sur les nombres naturels et de caractériser
celles qui sont calculables par une procédure effective. Dans ce chapitre, nous
adoptions cette démarche.
Considérons donc les fonctions dont les arguments et la valeur sont des
nombres naturels par exemple, x + y, x x y, x y , x 2  y 2 sont des fonctions que
nous considérons comme calculables. Pourquoi ? On peut classer ces fonctions
en deux catégories.
1. Des fonctions de base (+, x) que nous considérons comme calculables parce
que nous connaissons un algorithme permettant de les calculer sur une
représentation (par exemple binaire ou décimale) des entiers naturels.
2. Des fonctions obtenues par composition de fonctions de base. Par exemple,
x x (y+z) est la composition d’une addition et d’une multiplication. Nous
considérons cette fonction comme calculable parce qu’elle peut se calculer
en effectuant d’abord l’addition et ensuite la multiplication.
Pour pouvoir définir un ensemble suffisamment large de fonctions sur
les naturels, il nous faut un mécanisme permettant la définition d’un nombre
variable de compositions de fonction de base. Celui que nous allons étudier est
la recuisions.
La factorielle peut, par exemple, être définie par
O!
(n+1) ! = (n+1) x n !
Cette définition nous donne une procédure de calcul pour la factorielle
puisqu’elle permet de ramener le calcul de cette fonction à une suite de
multiplications.

47
6.2. LES FONCTIONS PRIMITIVES RECURSIVES

6.2.1. Définition
Soit  Nk  N k  0 l’ensemble des fonctions dont les arguments et la
valeur sont des nombres naturels. Nous allons définir un sous-ensemble de ces
fonctions que nous appellerons fonctions primitives récursives. Les fonctions
primitives récursives sont définies à partir de fonctions de base, d’une règle de
composition et d’une règle de récursion.
Définition 6.1. Les fonctions primitives récursives de base sont les suivantes :
1. La fonction 0 ( ) est la fonction zéro. Elle n’a pas d’arguments et à toujours
la valeur 0.
2. Les fonctions  ik  n1 , . . ., n k   ik  k  1 et 1  i  k  sont les fonctions
de projection de projections. La fonction  ik a comme valeur le i-ième
arguments parmi k  ik  n1 , . . ., n k  ni . Par exemple,  11 est la fonction
identité   n   n
1
1 et  35 permet de sélectionner le troisième parmi
un ensemble de 5 arguments.
3. La fonction (n) est la fonction successeur. Elle est définie par
 (n) = n+1.
Définition 6.2. Soit g une fonction à l’arguments k et h1 , . . . , h des fonctions à
k arguments. Si nous dénotons n1 , . . . , nk par n , alors la composition de g
et de h1 , . . . , h est la fonction dans Nk  N définie par
f  n   g h1  n , . . . , h  n 
Définition 6.3. Soit g une fonction à k arguments et h une fonction à k + 2
arguments. Alors la fonction f à k+1 arguments telle que :
f  n, 0   g  n 
f  n, m  1   h  n, m,f(n, m) 
est la fonction définie à partir de g et h par récursion primitive.
Remarquons que si les fonctions g et h utilisées pour définir une fonction f
par récursion primitive sont calculables par une procédure effective, lors f est
aussi calculable.
En effet, f  n, 0  est calculable puis qu’égale à g n . Par induction sur m,
on a alors que f  n, m est calculable pour tout m. Cela vérifie aisément, car si
f  n, m est calculable, alors f  n, m  1   h  n, m,f(n, m)  est aussi calculable
vu que l’on a supposé h calculable.

48
Définition 6.4. Les fonctions primitives récursives sont :

 les fonctions primitives de base ;
 toutes les fonctions quelconque obtenues à partir des fonctions
primitives récursives de base par un nombre quelconque d’applications
de la composition et la récursion primitive.
6.2.2. Exemples
Dans cette section, nous examinerons une série d’exemples dont le but est
de convaincre le lecteur qu’un grand nombre de fonctions courantes définies sur
les entiers sont primitives récursives.
Exemple 6.1. Toutes les fonctions constantes j ( ) = j sont primitives récursives.
En effet, chacune se définit par une suite de compositions
j
  
j    ( ( . . .  (0 ( ) ) ) )
Exemple 6.2. La fonction d’addition plus  n1 , n 2  dont la valeur est la somme
arithmétique de n1 et n2 est primitive récursive puis qu’elle peut être définie
par récursion primitive :
plus  n1 , 0  = 11  n1 
plus  n1 , n 21  =   33  n1 , n 2 , plus(n1 , n 2 )
Dans ce qui suit nous omettons le plus souvent les fonctions de projection.
Par exemple, puis que  11 (n) = n, nous écrivons n plutôt que  11 (n).
Similairement, plutôt que d’écrire.  23 n1 , n 2 , n 3  , nous écrirons n 2 . Pour la
fonction de l’exemple 6.2, cela donne
plus  n1 , 0  = n1
plus  n1 , m21  =   plus(n1 , n2 )
Exemple 6.3. Pour nous familiariser avec le mécanisme d’évaluation des
fonctions primitives récursives, considérons la fonction plus de l’exemple
6.2 appliquée aux arguments 7 et 4 :
Plus (7, 4) = plus ( 7, 3+1)
=  (plus (7,3))
=  (  (plus (7,2)))
=  (  (  (plus (7,1))))
=  (  (  (  (plus (7,0)))))
=  (  (  (  (7))))
=  (  (  (8)))
=  (  (9))
=  (10)
= 11.
49
Exemple 6.4. La fonction produit (n x m) est primitive récursive puisqu’elle se

définit par récursion primitive à partir de l’addition.
nxo =0
n (m+1) = n + (n x m)
ou encore produit (n, 0) = 0
produit n (m+1) = n plus (n, m)
Exemple 6.5. Similairement, la fonction puissance n m  produit se définit par
récursion primitive à partir de la multiplication.
no =1
nm
n = n x mm
ou encore puissance (n, 0) = 1
puissance (n, m+1) = n produit (n, m)
Exemple 6.6. La fonction n  m définie par
n0 = 1
n m+1 = n n   m
est primitive récursive. Il est aisé de voir que
n  m  n n
n...n
m
La fonction n  m définie par
n0= 1
n m+1 = n (n  m)
est aussi primitive récursive. Il en va de même de toutes les fonctions
n k m  k  2  définie par
n k 0  1
 
.
n k m  1  n k-1 n k m
Exemple 6.7. La fonction factorielle (n !) est bien sûre primitive récursive :
0!=1
(n+1) ! = (n+1) . n !
Exemple 6.8. Considérons maintenant la fonction précédente (-1). Vu que nous
travaillons sur les naturels, nous ne pouvons écrire 0 – 1 = -1. Nous adoptons
donc la convention que le prédécesseur de 0 est 0 :
0 si m  0
pred(m)  
m - 1 si m  0
Cette fonction est primitive récursive puisqu’elle se définit par récursion
primitive :
pred(0) = 0
pred (m+1) = m

50
Exemple 6.9. La fonction différentielle (-) est définie suivant une convention
similaire à celle utilisée pour la fonction prédécesseur (nous dénotons cette

fonction par  pour la distinguer de la différence usuelle).
 0 si n  m
n-m 
n - m si n  m
Cette fonction est définissable par récursion primitive :

n-0n
 
n - m  1  pred(n - m)
et est donc primitive récursive.
Exemple 6.10. La fonction signe (sg) a la valeur si son argument est 0. 1 sinon :
0 si m  0
sg (m)  
1 si m  0
Cette fonction peut être définie par récursion primitive :
sg(1) = 0
sg (m+1) = 1
Exemple 6.11. Le produit borné par m d’une fonction g  n, i  est le produit de g
pour les m premières valeurs de i :
m
 g  n, i  .
i 0
Si g est primitive récusrive, la fonction

m
f (n, m)   g  n, i 
i 0
est aussi primitive récursive. En effet,

f ( n, 0 )  g  n, 0 
f ( n, m  1 )  f  n, m  x g  n, m  1 .
En utilisant la forme stricte de la définition de la récursion primitive, on
écrirait :
f ( n, m  1 )  h  n, m,f  n, m 
avec h  n1 , n 2 , n 3   produitg 13 (n1 , n 2 , n 3 ),  ( 23 (n1 , n 2 , n 3 ),  33 (n1 , n 2 , n 3 ).

51
6.3. LES PREDICATS PRIMITIFS RECURSIFS

6.3.1. Définition
Un prédicat est une fonction dont les valeurs sont prises dans l’ensemble
 vrai, faux. L’ensemble des prédicats définis sur les naturels est donc :
Nk  vrai, faux k  0.
De façon équivalente, un prédicat défini sur Nk peut être défini par un sous-
ensemble de Nk (l’ensemble des éléments de Nk pour lesquels il est vrai).
Nous adoptons cette dernière définition vu qu’elle ne nécessite pas
l’introduction de l’ensemble  vrai, faux .
Définition 6.5. Un prédicat  à k arguments est un sous-ensemble de Nk (les
éléments de Nk pour lesquels  est vrai).
Exemple 6.12. Le prédicat pair (n) est vrai si son argument est un nombre pair,
faux sinon. Il correspond au sous-ensemble des naturels composé de tous les
nombres pairs.
Exemple 6.13. Le prédicat n < m est vrai si n est inférieur à m. Il correspond au
sous-ensemble de N2 comprenant toutes les paires (n, m) où n < m.
Définition 6.6. La fonction caractéristique d’un prédicat   Nk est la fonction
f : Nk  {0, 1} telle que
0 si n  
f (n)  
1 si n  
La notion de prédicat primitif récursif est alors directement définie à partir
de la notion de fonction caractéristique.
Définition 6.7. Un prédicat est primitif récursif si sa fonction caractéristique est
primitive récursive.
6.3.2. Exemples
Exemple 6.14. Le prédicat zéro, qui n’est vrai que pour l’entier 0, est primitif
récursif. En effet, sa fonction caractéristique zerop peut être définie par
récursion primitive comme suit :
zerop (0) = 1
zerop (n+1) = 0
Il ne faut pas confondre la fonction zéro (0( )) dont la valeur est toujours 0 avec
le prédicat zéro dont la fonction caractéristique est zerop.
Exemple 6.15. La fonction caractéristique du prédicat plus petit (n < m) est
définie par petit (n, m) = sg  m - n  . Ce prédicat est donc primitif récursif.

 

52
Exemple 6.16. Les prédicats obtenus à partir de prédicats primitifs récursifs par
les opérations booleennes sont aussi primitifs. Soit g1  n  et g 2  n  les
fonctions caractéristiques de deux prédicats primitifs récursifs g1 et g 2 .
Nous avons
et  g1  n , g 2  n   g1  n  x g 2  n 
ou g1  n , g 2  n   sg  g1  n   g 2  n 
nou g1  n   1 - g 2  n 
Exemple 6.17. Les prédicats d’égalité (n = m) est aussi primitif récursif puisque
n = m si  (n < m  m < n) ce qui traduit au niveau des fonctions
caractéristiques par
  
egal n, m  1 -  sg  m - n   sg  n - m   .
 
    
Exemple 6.18. La quantification bornée universelle (existentielle) permet de
préciser qu’un prédicat est vrai pour toutes les (pour des) valeurs d’un de ses
arguments inférieurs à une certaine borne. Précisément,
 i  m   n, i .
est vrai si   n, i  est vrai pour tout i  m. Similairement,
 i  m   n, i  est vrai si   n, i  est vrai pour au moins une i 
m. Si  est primitif récursif, alors  i  m   n, i  et  i  m   n, i  sont
aussi primitifs récursifs. En effet, la fonction caractéristique de
 i  m   n, i  est définie par
m
   n, i 
i 0
m
Vu que    n, i  vaut 1 uniquement si   n, i  =1 pour tout im.
i 0
Pour la quantification bornée existentielle, nous utiliserons le fait que

 x  (x) si et seulement si   x (x)
Pour obtenir la définition primitive récursive suivante
 1 -   n, i  .
 m 
1-
i 0

53
Exemple 6.19. Soit une fonction définie par

g 1 (n) si 1  n 
.

f(n)   .
.

 g  (n) si   n 
.
où les fonctions g1 , . . . , g  ainsi que les prédicats 1 , . . . ,  sont primitifs
récursifs, alors la fonction f ( n ) est aussi primitive récursive. En effet, elle est
donnée par
f (n)  g1 (n) x 1 (n)  . . . , g (n) x  (n) .
Notons que pour cette représentation soit correcte, il faut que les prédicats ρ i
soit mutuellement exclusifs (ne soient jamais vrais simultanément).
Exemple 6.20. La minimisation bornée est un mécanisme qui permet de définir
une fonction à partir d’un prédicat q ( n, i ) . Pour une borne m, la valeur de
cette fonction est le plus petit entier 0  i  m tel que q ( n, i ) soit vrai. Si
pour tout 0  i  m le prédit q ( n, i ) est faux, la valeur de la minimisation
bornée de q est conventionnellement fixée à 0. La
minimisation bornée d’un prédicat q ( n, i ) se dénote par
le plus petit i  m tel que q ( n, i )  1
 i  m q ( n, i )  
0 s' il n' existe pas de tel i
La fonction  i  m q ( n, i ) peut effectivement être définie par récursion
primitive sur m :
 i  m q ( n, i )  0
0 si   i  m  1 q ( n, i )

 i  m  1 q ( n, i )   i  mq ( n, i ) si  i  m q ( n, i )
m  1 si q ( n, m  1 ) et   i  mq ( n, i )


54
6.1. Montrer que les fonctions suivantes sont primitives récursives.

1. 2 n
2. divise (x, y) = 1 si x divise y et 0 sinon.
3. nbdivs(x) = le nombre de diviseurs de x.
6.2. Montrer que si q ( n, i ) est un prédicat primitif récursif, alors la fonction
le plus grand i  m tel que q ( n, i )  1
 i  m q ( n, i )  
0 s' il n' existe pas de tel i
est primitive récursive. Utiliser ce résultat pour montrer que la fonction gcd(x,
y) donnant le plus grand commun diviseur de x et y est primitive.
6.3. Montrer que la fonction fib(n) calculant les nombres de Fibonacci est
primitive récursive. Pour mémoire, cette fonction est définie comme suit :
fib(0) = 1
fib(1) = 1
fib(n) = fib(n – 1) + fib(n – 2) (n > 1).

55
BIBLIOGRAPHIE
1. Alfred V. Aho, Ravi sethi, and Jeffrey D. Ullman. Compiles :

Principles, Tools and Techniques. Addison – Wesley, 1985.
2. J.M. Brady. The theory of computer science (A programming
approach). Chapman and Hall, 1977.
3. John. E., Hopcroft and Jeffrey D. Ullman. Format languages and their
relation to automata. Addison – Wesley, 1969.
4. Wolper. P., Introduction à la calculabilité, Dunod, Paris, 2001.

1
INTERROGATION DE CALCULABILITE
L1 ET L2 GENIE INFORMATIQUE
1) Quel est le sens du mot « science » en informatique, en particulier en

calculabilité ?
2) Quelle est en peu de mots la différence entre la calculabilité et complexité du
point de vue algorithmique ?
3) Vrai ou faux ? Pourquoi ?
a. Algorithmes  calculs
b. Modèle pour les calculs  automates, machines, …
c. Description et complexité des problèmes  langages formels
4) Peut-on dire que la calculabilité sert à l’économie de temps dans la recherche
de solutions qui ne peuvent pas exister ? Pourquoi ?
5) Quelle est la signification de la phrase « une fonction est calculable ? Y- a-t-
il des fonctions non-calculables ?
6) Peut-on déduire le pouvoir de calcul de certaines instructions des langages
de programmations ?
7) Quelles sont les relations qui existent entre les mots : compilation, automates
et reconnaissances des langages.
8) Dessiner les graphes de l’automate déterministe et de l’automate non-
déterministe correspondant qui reconnaissent les mots avec a en avant-
dernière lettre, sur l’alphabet {a, b}.
9) Trouver le nombre d’états pour l’automate déterministe reconnaissant. Les
mots dont la 3-ième lettre à partir de la fin est a.

2
10) Additionneur binaire série

A partir d’un additionneur sur 1 – bit ADD1, on fabrique un additionneur
série sur n bits. La porte ADD1 a un fil d’entrée pour les entrées x et y
sérialisées, et un autre fil d’entrée pour la retenue entrante C in et deux fils de
sortie pour la somme résultante S et la retenue sortante Cout. Pour faire un
additionneur sur n bits, la retenue de sortie reboucle sur l’entrée (après
amplification) et on suppose le dispositif synchronisé sur une horloge pour
faire d’abord entier Cin et x, puis y, puis laisser sortir S et Cout comme
indiqué sur la figure ci-dessous.
y x x
ADD1
Figure 1. Additionneur série
Donner le graphe de l’automate d’un additionneur série.


Calculabilité

Transféré par

Droits d'auteur :

Formats disponibles

Calculabilité

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Calculabilité

Transféré par

Droits d'auteur :

Formats disponibles

1

TABLE DES MATIERES

TABLE DES MATIERES .................................................................................... 1

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

4.1. INTRODUCTION .................................................................................... 33

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Chapitre 5. LES MACHINES DE TURING

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Exemple 1.1. Déterminer si un nombre naturel est pair ou impair est

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Par exemple, un programme écrit en C est une procédure effective si c’est

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Pour concevoir une telle représentation, examinons ce qui se passe

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

1.4.1. Des opérations sur les langages

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Une expression régulière représente un langage régulier ? Lequel ?

expressions régulières dénotent le même ensemble régulier.

Il nous reste à démontrer que a  b*  a *b  b*a  .

Considérons le mot ω  ω1 ω2 . . . ωu a  b* .

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

On peut distinguer les quatre cas suivants :

3.  contient des a et des b et se termine par b. On a donc :

4.  contient des a et des b et se termine par a. Une décomposition similaire à

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

EXERCICES SUR LE CHAPITRE 1.

1.1. Démontrer que pour tout langage L, L* = L*  .

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

1.8. Montrer que chacune des expressions régulières suivantes représente

1.9. Les égalités suivantes sont-elles vérifiées ? Justifier.

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Chapitre 2. LES AUTOMATES FINIS

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Chaque cycle transforme donc l’état de la machine. Cette transformation ne

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Figure 2.1. Automate fini

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Intuitivement, un automate est une machine qui résout un problème, c'est-à-

Cet automate accepte l’ensemble des mots se terminant par b.

est  ω ω contient pas 2a consécutifs .

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

2.5. LES AUTOMATES FINIS NON-DETERMINISTES

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

est L(M) =  * ab ab* , c'est-à-dire l’ensemble des mots se terminant par

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Définition. Deux automates M1 et M2 sont équivalents s’ils acceptent le même

Figure 2.2. Elimination des transitions de longueur > 1.

Chaque état de l’automate déterministe correspondra à un ensemble d’états

Figure 2.3 Elimination du non-déterministe.

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Exemple 2. La figure 2.4 représente un automate non-déterministe et l’automate

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

EXERCICES SUR LE CHAPITRE 2.

2.1. Soit M = (Q, , , so, F) un automate fini déterministe. Soit M’ = (Q, ,

C.T. WETSHINDJADI, Doctorant en Sciences Informatiques

Chapitre 3. LES GRAMMAIRES REGULIERES

Il nous reste à démontrer que a  b*  a b  ba  .