Vous êtes sur la page 1sur 76

Chapitre IV

automates
Automates finis
• Introduction
Les automates finis sont de bon model pour les
ordinateurs avec une mémoire à capacité
limitée.
Le contrôleur d’une porte automatique est l’un
des exemples.
Automates finis déterministes (AFD)
• Description
Quand l’automate M1 reçoit une séquence comme
1101 (à l’entrée) il manipule cette séquence et
produit une sortie. La sortie est soit il l’accepte soit
il la rejette.
Il reçoit les symboles un à un de gauche à droite
après la lecture de chaque symbole il passe d’un
état à l’autre. Quand il arrive au dernier symbole,
M1 produit la sortie
Ex: 01 il l’accepte
010 il la refuse
Détermination formelle d’un (AFD)
Un AFD est formé de la quintuplet M = (Q;∑; 𝛿; s; F)

• Q est un ensemble fini d‘états,
• ∑ est un alphabet,
• 𝛿 = 𝑄𝑥∑ →Q est la fonction de transition,
• s ϵ Q est l‘état initial,
• F ⊆ Q est l'ensemble des états accepteurs.
Détermination formelle d’un (AFD)
• ∅

• ϵ

• 𝜎∈∑ 𝜎
Exemples
1
0
0
1
q1 q2 q3

0,1
• Q={q1,q2,q3} ∑={0,1} s={q1} F={q2}
• 𝛿 = 𝑄𝑥∑ →Q
0 1
q1 q1 q2
q2 q2 q3
q3 q2 q2

• Des suites de 0 et de 1 qui terminent par 1 ou


par un nombre pair de 0
Exemples
0 1
1

q1 q2

0
• Toujours termine par 1
1
0
1

q1 q2

• Toujours termine par 0


Exemples
b
a S
a b

q1 r1

b a a b

b
q2 r2 a

• Si ça commence par a doit terminer par a et si


ça commence par b doit terminer par b
Remarques
• Si le premier état est en même temps état
acceptable alors l’automate peut lire ϵ
• L’automate M connait le langage A si
A={W/M accepte W}
• M accepte A s’il accepte toutes les composantes
(mots) de A.
• Un langage est dit régulier s’il y a un automate
fini qui le connaît.
Les automates finis non déterministes
(AFN ou AFND)
• Dans cette section nous allons considérer une
généralisation des automates finis.
• Description
Les AFND sont des automates fini où l’on permet
• Plusieurs transitions correspondantes à la même
lettre dans chaque état.
• Des transitions sur le mot vide.
• Des transitions sur des mots de longueur
supérieure à 1 (regroupement de transitions.
Les automates finis non déterministes
(AFN ou AFND)
• On voit déjà à partir de cette définition qu’un
AFND 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 alors on peut dire que l’on
laisse à l’automate le soin de choisir la bonne
exécution.
Détermination formelle d’un (AFND)
• Un automate fini non déterministe est défini par un
quintuplet
• M = (Q;∑; 𝝙; s; F) , ou
• Q est un ensemble d’états,
• ∑ est un alphabet,
• ∆ ⊂ (Q x ∑*x Q) est la relation de transition,
• s ∈ Q est l‘état initial,
• F ⊆ Q est l'ensemble des états accepteurs.
On a remplacé la relation de transition par ∆ parce que on a
laissé la possibilité à un état d’avoir plusieurs successeurs pour
une même lettre se trouvant sur le ruban d’entrée.
Exemples
aa
a
ϵ
b
q0 q1 q2
ab

b a

a
q3 q4
bbb

• 𝐿 𝑀 = ( 𝑎⋃𝑎𝑏 ∗ 𝑏𝑏𝑏𝑏∑∗ ) ∪( 𝑎⋃𝑎𝑏 ∗ 𝑎𝑏𝑏 𝑎𝑎 ∗ 𝑎∑∗ )


Exemple
a a ab

a q1 b q2
q1

• 𝐿 𝑀 = ∑∗ 𝑎𝑏(𝑎𝑏)∗
• C’est à dire l’ensemble des mots se terminant par
au moins une répétition de ab
Elimination du non déterministe
• Dans cette section nous allons prouver que l’on peut
toujours remplacer un AFND par un AFD équivalent. La
notion d’équivalence entre les automates est
naturellement celle de l’égalité des langages acceptés.
• Définition
Deux automates M1 et M2 sont équivalents s'ils
acceptent le même langage, c'est-a-dire si
L(M1) = L(M2).
• Théorème
Pour tout automate non déterministe, il est possible de
construire un automate déterministe équivalent.
Principe de la construction
• Il y a deux éléments essentiels qui différencient
un AFND d’un AFD.
– La présence de transitions 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.
Pour obtenir un AFD à partir d’un AFND nous
commençons donc par éliminer les transitions sur des
mots de longueur >1.
Principe de la construction
• Eliminer les transitions de longueur
supérieure a 1.
aba

a b a
Principe de la construction
• Eliminer les transitions compatibles.
{q0,q1}
q1
a a
a
{q0}
q0
b
b {q2}
q2
Formalisation de la construction
• Soit un Automate non déterministe M = (Q;∑;𝝙; s; F).
Construire un automate déterministe équivalent
M0 = (Q’; ∑; 𝝙’; s; F) tel que ∀(q; u; q’) ∈ 𝝙’; |u|≤ 1
• Initialement Q’ = Q et 𝝙’ = 𝝙 .
• Pour chaque transition (q; u; q’) ∈ 𝝙 avec u = 𝜎1𝜎2 … 𝜎k
(k > 1) :
• on enlève cette transition de 𝝙’,
• on ajoute de nouveaux états p1; : : : ; pk-1 a Q’,
• on ajoute les nouvelles transitions (q1; 𝜎1; p1), (p1; 𝜎2;
p2), . . . , (pk-1; 𝜎k-1; q’) a 𝝙’
Elimination du non déterministe
• Soit AFND M = (Q;∑;𝝙; s; F) où pour toute transition (q;
u; q’) ∈ 𝝙 on a |u|<=1 c.à.d que chaque transition a :
soit la forme (q; 𝜎; q’) soit la forme (q; 𝜖; q’).
Construisons un AFD M’ = (Q’;∑;𝝙’; s’; F’) équivalent à
M.
• Une des difficultés de cette construction est le
traitement des transitions sur le mot vide (celles de
la forme (q; 𝜖; q’)).
• En effet un AFD ne peut pas avoir de transitions sur
le mot vide nous devons donc regrouper toute suite
de transitions sur le mot vide du AFND avec une
transition sur un élément de 𝜖.
Définitions des éléments de
l’automate M’
• L’ensemble des états Q’ est l’ensemble des sous-
ensembles des états de M.
• S’: tous les états accessibles de l’état initial, s de M, par
une séquence de transitions sur le mot vide.
• La fonction de transition 𝝙’ doit regrouper les
transitions possibles de M. donc pour un état q de
M’, 𝝙’(q , a) sera l’ensemble des états q1 ∈ Q par une
suite de transitions dont la première est étiquetée par
a et les suivantes par le mot vide.
• Un état de AFD M’ sera accepteur s’il contient un état
accepteur du AFND M.
Exemple 1
b
q1 a q2

q0 a a a a

ϵ
b
q3 ϵ q4

a b
Exemple 1
État de départ a est lu b est lu
{q0, q1, q3} {q1, q2, q3} {q3, q4}
{q3, q4} {q1, q2, q3} {q3, q4}
{q1, q2, q3} {q1, q2, q3} {q1, q3, q4}
{q1, q3, q4} {q1, q2, q3} {q3, q4}
Exemple 1
a

{q1, q2, q3}

a b
a

{q0, q1, q3} a {q1, q3, q4}

b
b

{q3, q4}

b
Exemple 2

a b a b
1 2 3 4 5

b
Exemple 3
0

1
1 1 1
0
1

0, 1 0
Langage d’un automate fini
Langage d’un automate fini
Méthode de départ

• On associe à chaque état k un langage Dk = langage de départ de l’état k


Dk = ensemble des mots acceptés si k était initial
L=D1 (si 1 est l’état initial)

• Théorème.
les langages de départ sont liés par les équations:
𝐷𝑘 = 𝑓𝑘 + 𝑎𝐷𝛿(𝑘,𝑎) + 𝑎𝐷𝛿(𝑘,𝑏) + ⋯ = 𝑓𝑘 + 𝑎𝐷𝛿(𝑘,𝑎)

Dans laquelle
𝑓𝑘 = 𝜖 𝑠𝑖 𝑘 𝑒𝑠𝑡 𝑎𝑐𝑐𝑒𝑝𝑡𝑎𝑛𝑡 𝑒𝑡𝑓𝑘 = ∅ 𝑠𝑖 𝑘 𝑒𝑠𝑡 𝑟𝑒𝑓𝑢𝑠𝑎𝑛𝑡
Méthode de départ pour obtenir un
système d’équations
• On commence par écrire :
D1= + aD + bD + ….
D2= + aD + bD + ….
etc.
Dn= + aD + bD + ….
• Pour les états acceptants on ajoute ϵ au début du
second membre
• Enfin on écrit l’indice de chaque lettre D: c’est
l’état où va le repère quittant k sous l’action de la
lettre qui est avant D.
Méthode de l’arrivée
• On associe à chaque état k un langage
Ak = langage de l’arrivée de l’état k.
Ak = ensemble des mots dont la lecture se termine à l’état
k.
L=somme des langages associés à des états acceptants.
• Théorème.
Les langages d’arrivée sont liés par les équations:
𝐴𝑘 = 𝑒𝑘 + 𝐴𝛿(𝑙,𝑎) 𝑎 + ⋯ = 𝑒𝑘 + 𝐴𝛿(𝑙,𝑎) 𝑎
𝑎∈Σ
𝛿 𝑙,𝑎 =𝑘
Dans laquelle 𝑒𝑘 = 𝜀, 𝑠𝑖 𝑘 = 1 𝑒𝑡 𝑒𝑘 = 𝜙 𝑠𝑖 𝑘 ≠ 1.
Méthode de l’arrivée pour obtenir un
système d’équations
• On commence par écrire:
A1= + Aa + Ab + ….
A2= + Aa + Ab + ….
etc.
An= + Aa + Ab + ….
• On complète chaque ligne en regardant quelle
lettre fait arriver dans cet état, et en venant
d’où.
Lemme de Arden
Méthode de résolution du système de
départ
Méthode de résolution du système de
l’arrivée
Remarques sur les deux méthodes
Solution du système de départ
• D1=ϵ + aD2 + bD3
• D2= aD2 + bD3
• D3=ϵ + aD2 + bD3
• Alors D3=bD3 + (ϵ + aD2)
D3=b*(ϵ + aD2)=b*aD2+b*
D2=aD2 + bb*aD2+bb*=(ϵ+bb*)aD2+bb*=b*aD2+b+
D1= ϵ + aD2+bb*aD2+bb*=(ϵ+bb*)aD2+b++ ϵ
= b*aD2+b*
Solution du système de départ
• Le Lemme de Arden appliqué à la deuxième
équation donne:
• D2=(b*a)*b+
• Et en reportant cette expression dans la première
équation on a:
• L=D1=(b*a)(b*a)*b++b*
• On peut arranger un peu cette expression en
écrivant:
• L=(b*a)(b*a)*b++b++ ϵ=[(b*a)(b*a)*+ ϵ] b++ ϵ
=(b*a)* b++ ϵ
Solution du système de l’arrivée
• A1= ϵ
• A2=a+A2a+A3a
• A3=b+A2b+A3b
• La deuxième équation donne alors:
• A2=A2a+(a+A3a)=(a+A3a) a*
• A3=b+(a+A3a)a*b+A3b=b+aa*b+A3aa*b+A3b
=b+aa*b+A3(aa*+ ϵ)b=b+aa*b+A3a*b
=(ϵ+aa*)b+A3a*b=a*b+A3a*b=a*b(a*b)*
Le langage de l’automate est L=A1+A3=(a*b)*
Automate complet
Exemple
Etats puits et poubelles
Automates équivalents
Exemple
Opérations sur les automates
Complémentation
Exemple
Automate avec transition instantanée
Exemple
Union de deux automates
Exemple
Exemple
Intersection de deux automates
Produit de deux automates
Exemple
Exemple
Transformation d’un AFD en
grammaire
Exemple
Théorème de Kleene
Addition

M1 M2

M1+M2
Addition
• On ajoute un état initial et on le relie à l’état
initial de chacun des automates par une
transition epsilon.
Fin