Cours 1 - Département Informatique

Organisation
http://deptinfo.unice.fr/~julia/AL
1,5 h de cours + 1,5 h de TD hebdo sur 12 semaines
Automates & Langages
Cours : S.Julia
lundi 11h30-13h
amphi Géologie
TD
: S.Julia
lundi 15h-16h30
salle M.3.3
S.Julia
lundi 16h45-18h
salle M.3.3
(+ soutien)
Les TD ont lieu en alternance pour les groupes 1 et 2,
on commence aujourd’hui avec le groupe 1.
Sandrine Julia
Evaluation :
L3 Info, L3 Math-MI
2016/17
Bibliographie
•
Introduction à la calculabilité
Wolper, Dunod, 3e édit°, 2006.
•
Logique et automates
Bellot/Sakarovitch, Ellipses, 1998.
•
Langages formels, calculabilité et complexité
Carton, Vuibert, 2008.
à la BU !
•
Introduction to Automata theory, Languages, and Computation
Hopcroft, Ullman, Addison-Wesley, 1979.
•
A Second Course in Formal Languages and Automata Theory
Shallit, Cambridge Univ.Press, 2009.
•
Introduction to the theory of computation
Sipser, PWS publishing company, 1997.
Simulateurs : JFLAP, Visual Automata Simulator, AMoRE, ...
( 30 * partiel + 20 * contrôle flash + 50 * exam final ) / 100
1h30
20 mn
1h30
31 oct.
nov.
déc. ou janv.
Utilisation (plutôt pratique)
•
•
codage de l’information
spécification des langages de programmation
•
•
compilation, analyseurs lexicaux
recherche de motifs
✦
✦
✦
dans un texte
dans une BD
sur le web
•
•
•
•
•
•
•
•
systèmes d’exploitation, éditeurs
compression de textes
électronique des ordinateurs
model-checking
images de synthèse
cryptographie
biologie, génétique
linguistique ( TALN )
•
sciences cognitives
•
...
Utilité théorique
Spécification des langages de prog.
2
NN
: A
012
EE
TU
G
RIN
!
Les solutions d’un problème
vues comme un langage
Problème du loup, de la chèvre et des choux ...
Modélisation
Vérification
C
(model-checking)
HLX/C
LX/HC
HLCX/
C
Complexité
-
X
L
Calculabilité :
A.Church
A.Turing
1903-1995
1912-1954
C
les mots représentent toutes les instances d’un problème
•
un langage regroupe les instances positives du problème
•
un automate (ou une autre machine) correspond à un programme.
X
L/HCX
C
Où se situent les limites de l’informatique actuelle ?
•
L
X/HLC
C
HCX/L
X
C
/HLCX
X
L
L
HC/LX
C
HLC/X
C/HLX
-
Contenu du cours
✦
Automates finis déterministes
✦
Langages rationnels
✦
Expressions régulières
✦
Grammaires régulières
✦
Grammaires hors-contexte
✦
Automates à pile
✦
Langages hors-contexte
✦
Machines de Turing
✦
Automates cellulaires
(ou réguliers)
1 - Automates finis déterministes
C
Opérations sur les langages
Matériel de base
Soit L et M deux langages donnés.
•
symbole, lettre, chiffre, caractère
alphabet : ensemble fini
mot : concaténation de lettres
langage : ensemble de mots
mot vide noté ε : l’unique mot à aucune lettre !
•
longueur d’un mot m : |m|
•
produit de concaténation de L et M :
L . M = { w = u v / u ∈ L, v ∈ M }
•
puissance de L :
•
•
•
•
opérations ensemblistes
•
longueur représentation binaire de n : |bin(n)| = "log2 (n)#+1
longueur du mot vide : |
ε |= 0
•
nombre d’occurrences de la lettre a dans le mot m : |m|a
•
le ie caractère du mot m : m[i]
•
•
•
•
•
•
préfixe (propre)
suffixe (propre)
facteur (propre)
sous-mot
miroir
ordres sur les mots : préfixe, lexicographique, hiérarchique
union, intersection, différences, complémentation, produit cartésien, ...
ε
(B) L0 = {
}
(I) pour tout entier i>0, Li = L . Li-1
fermeture de Kleene du langage L :
•
appelée
“opération
étoile”
L* = ∪i≥0 Li
✴ on note L+ = ∪i>0 Li
✴ même si L=∅, L0 = {
ε}
✴ l’ensemble des mots Σ* est la fermeture de Kleene de l’alphabet Σ
✴ L* : plus petit langage contenant
Ensemble des langages rationnels*
ε,
L et fermé par concaténation.
Expressions régulières
•
plus petit ensemble contenant les langages finis et clos par
union, intersection et étoile
•
formalisme simplifié pour décrire les langages réguliers
•
définition inductive :
•
définition inductive :
(B)
(I)
(B)
∅ ∈ R
{ε} ∈ R
{a} ∈ R, pour tout a ∈ Σ
(I)
si L, M ∈ R alors
L ∪ M ∈ R
L.M ∈ R
L* ∈ R
•
par construction, l’ensemble des langages rationnels est dénombrable
Exemple : les lexèmes des langages de programmation ( les entiers, les hexadécimaux, les
identificateurs, les commentaires ... )
* On dit aussi réguliers du fait de l’anglais.
∅ ∈ ER
ε ∈ ER
a ∈ ER, pour tout a ∈ Σ
Unix a son propre
formalisme pour les exp.
régulières que
grep, find ...
utilisent
si α, β ∈ ER alors
( α + β ) ∈ ER
( α . β ) ∈ ER
α* ∈ ER
par construction, l’ensemble des expressions régulières est
dénombrable
•
Exemple : sur l’alphabet binaire ( ( ( 0 +
simplifiable en ( 0 + ε ) ( 1 0 )* ( 1 + ε )
ε).(1
. 0 )* ) . ( 1 +
avec, du plus au moins prioritaire, les opérations : * puis . puis +
ε ))
Correspondance entre langage rationnel (ensemble)
et expression régulière (formalisme)
Automate fini
On dit qu’une expression régulière
Un automate fini A est la donnée d’un quintuplet :
dénote ou décrit un langage.
(B)
(I)
∅ ∈ ER
ε ∈ ER
a ∈ ER, pour tout a ∈ Σ
si α, β ∈ ER alors
(α + β) ∈ ER
(α .β) ∈ ER
α* ∈ ER
Expression régulière
Langage
(B) L(∅) = ∅
L(ε) = {ε}
L(a) = {a}
(Σ, Q, δ, q0, F)
tel que :
• Σ
pour tout a ∈
Σ
• δ
(I)
L(α + β) = L(α) ∪ L(β)
L( α.β ) = L(α) . L(β) L( α* ) = L (α) *
est un alphabet
• Q est un ensemble fini d’états
est un ensemble de règles de transition (les flèches)
δ : Q × ( Σ ∪ {ε} ) × Q
• q0 est l’état initial
• F est l’ensemble des états finals
(un sous-ensemble de Q)
A
Théorème
accepte un mot m s’il existe un chemin de q0 à un état de F
étiqueté par les lettres de m.
un langage est rationnel si et seulement si
il est dénoté par une expression régulière.
L’ensemble des mots acceptés forme le langage L(A) reconnu par A.
Exemple
Automates finis déterministes
Automate fini
A = (Σ,
Q, δ, q0, F)
Σ = {0,1}
Q = {q0,q1}
δ = {(q0,0,q1),(q0,1,q0),(q0,ε,q1) }
Un automate fini est déterministe (A.F.D) ssi
A
1
ε
q0
δ est une
fonction de transition :
q1
0
q0 est l’état initial
δ :
Q × Σ → Q
✦ d’un état donné, il part au plus une seule flèche étiquetée par
une lettre donnée
✦ on n’autorise plus les
ε-transitions
F = {q1}
Un automate fini déterministe est complet ssi
Ici, A reconnaît le langage L(A) décrit par l’expression
régulière :
1* (0 + ε)
fonction définie sur l’ensemble Q ×
δ
est une
Σ tout entier.
✦ de chaque état, il part exactement une flèche étiquetée par
chacune des lettres de l’alphabet Σ.
Exemple d’A.F.D
B = (Σ,
Exemple d’A.F.D complet
B
1
Q, δ, q0, F)
q0
Σ = {0,1}
Q = {q0,q1}
C = (Σ,
1
q1
0
Q, δ, q0, F)
0,1
C
q2
1
Σ = {0,1}
0
1
q0
Q = {q0,q1,q2}
q1
0
δ = {(q0,0,q1),(q0,1,q0),(q1,1,q1)}
δ = {(q0,0,q1),(q0,1,q0),(q1,0,q2),(q1,1,q1),(q2,0,q2),(q2,1,q2)}
q0 est l’état initial
F = {q1}
q0 est l’état initial
B accepte
les mots du langage L(B) décrit par l’expression
régulière :
1* 0 1*
C reconnaît
B
1
F = {q1}
le langage L(C) décrit par 1*0 1*.
C’est la version complétée l’automate
Non-déterminisme
q0
B.
1
q1
0
Equivalence A.F.N. et A.F.D.
Dans un automate fini non-déterministe (A.F.N.) il peut y avoir
le choix entre plusieurs chemins lors de la lecture d’un mot.
Théorème
si un langage est reconnu par un automate fini,
alors il est également reconnu par un automate
fini déterministe.
Pour qu’un mot soit accepté, il suffit que ses lettres
étiquettent un chemin de l’état initial à un état final
✦ si l’automate fini du départ A est déterministe, c’est
évident
(même s’il existe d’autres chemins non réussis).
Notez qu’un A.F.D.
c’est aussi un A.F.N. !
A.F.N.
A.F.D.
✦ si l’automate de
on se propose de
qui intègre tous
(cf. algorithme de
départ n’est pas déterministe,
construire un automate fini déterministe B
les choix existant dans l’automate de départ
déterminisation)
✦ il resterait à prouver formellement que le nouvel automate B accepte
exactement les mots acceptés par A.
Exemple de déterminisation
soit l’AFN
E = (Σ,
Algorithme de déterminisation
Q, δ, q0, F)
= { 0,1 }
Q = { q0,q1 }
Σ
q0
δ = { (q0,0,q0), (q0,0,q1),(q0,ε,q1), (q1,1,q1) }
q0 est l’état initial
D = (Σ,
1.
1
2.
3.
Q’, δ’, q0’, F’)
0
q0’= {q0q1} est l’état initial
Q’= { {q0,q1 } , {q1 }}
δ’ = {, ( { q0,q1 },0,{ q0,q1 }),
({ q0,q1 },1,{ q1 } ),
({ q1 },1,{q1 } )
1
{q0,q1} q0,q1
{q1}
-
q1
D
0
q1
1
q1
q 0q 1
4.
1
F’ = {{ q0q1} ,{q1 } }
Application
tio
pila
soit un AFN A = (Σ, Q, δ, q0, F)
on construit l’automate B = (Σ, Q’, δ’, q0’, F’)
Q’ sera inclus dans
q1
0,ε
F = { q1 }
on construit
E
0
Clôtures par
δ’ ← ∅
q0’ ← {q0} ∪ {q ∈ Q tels que (q0,ε,q) ∈ δ* }
Q’ ← { q0’ }
ε-transitions
pour tout q’ ∈ Q’ non encore considéré faire
pour tout σ ∈ Σ faire
q’’← { y ∈ Q / ∃ x ∈ q’ tel que (x,σ,y) ∈ δ }
si q’’ ≠ ∅ alors
q’’ ← q’’∪ { z ∈ Q / ∃ y ∈ q’’ tel que (y,ε,z ) ∈ δ* }
δ’ ← δ’ ∪ {( q’,σ,q’’) }
Q’ ← Q’ ∪ { q’’ }
F’ ← {q’ tels que q’ ∩ F ≠ ∅ }
Algorithme : E.R. →
n
om
UE C
6
au S
P(Q)
A.F.D.
•
de gauche à droite, on indice les n lettres de Σ figurant
dans E par les entiers de 1 à n
En début de compilation, lors de l’analyse lexicale,
•
on transforme E en E’ en remplaçant chaque lettre par q (q∉Σ)
le flot de caractères est découpé. Chaque morceau
•
on ajoute q0 au tout début de E’
cf.
appartient à un lexème i.e. un petit langage décrit
par une expression régulière.
• pour tout i de 1 à n faire
pour tout σ ∈ Σ faire
succ(qi,σ) ← {qj qui suivent qi dans E’après lecture de σ}
• Q ← {q0},
Les générateurs automatiques d’analyseurs lexicaux
(Lex, Flex …)
utilisent alors un algorithme
pour passer directement d’une expression régulière
à un automate fini déterministe complet.
δ←∅
• pour tout q ∈ Q non encore considéré faire
pour tout σ ∈ Σ faire
q’ ← succ(q,σ)
si q’≠ ∅ alors
δ ← (δ ∪ (q,σ, q’))
+
+
+
+
Q ← Q ∪ {q’}
• F ← { états qui contiennent un symbole final de E’ }
Exemple : E.R. →
•
•
E l’expression régulière :
on indice les lettres :
A.F.D.
( a + ε ) ( b a )* ( b + ε)
( a 1 + ε ) ( b 2 a 3 )* ( b 4 + ε )
on remplace les lettres par le symbole q (hors alphabet) et on met q0
devant :
q0 ( q1 + ε )( q2 q3 )* ( q4 + ε)
•
•
•
•
•
•
initialisations :
Q ←
q0 ,a:
q0 ,b:
q1 ,a:
q1 ,b: Q ←
Q ←
{q2,q4},a: {q2,q4},b: q3 ,a:
q3 ,b: {{ q0 }}, ,
δ←,
∅
Q ∪ {q1}
Q ∪ {{q2,q4}}
δ ←
δ ←
δ ∪ { (q0,a,q1) }
δ ∪ { (q0,b,{q2,q4}) }
Q ∪ {q3}
δ ←
δ ←
δ ∪ { (q1,b,{q2,q4})
δ ∪ { ({q2,q4},a,q3) }
(rien)
Q ←
(rien)
(rien)
δ ←
δ ∪ { (q3,b,{q2,q4}) }
➡ A = ( Σ,Q={q0, q1, q3,{q2,q4}}, {q0}, δ, F={q0,q1,q3,{q2,q4}})