Les Automates a` Pile

ABDALLAH MOHAMED KAMIL Marwa

24 Novembre 2014

Motivations

Dans les cours precedents, nous avons vu que les langages rationnels sont reconnus par les automates finis, mais que ceux-ci ne reconnaissent pas tous les
langages algebriques (on rappelle que les langages rationnels sont strictement
inclus dans les langages algebriques).
Revenons sur les mode de reconnaissance des langages algebriques.
Pour linstant, nous savons que les langages algebriques sont ceux engendres
par les grammaires algebriques. Ceux sont aussi ceux que lon peut construire
par union, concatenation entre langages algebriques, ou en utilisant letoile de
Kleene.
Il est interessant de chercher un autre mode de reconnaissance des langages
algebriques. Nous allons introduire dans ce cours les automates `a pile. Nous
verrons que la classe des langages acceptes par les automates `a pile est exactement la classe des langages algebriques..

Forme normale de Greibach et langages alg

ebriques

Revenons sur la forme normale de Greibach (GNF). Nous verrons que les grammaires GNF engendrent les langages algebriques propres (ceux sont les langages
qui ne contiennent pas le mot vide, ou qui ne contiennent que le mot vide).
Definition 1 Soit G = (, V, P )
- est lensemble des symboles terminaux
-V est lensemble des variables
-P est lensemble des r`egles de production.
On dit que G est sous forme normale de Greibach si ses r`egles de production
sont de la forme:
A aB(a , B V )
i.e, P V V .
Proposition 1 Pour tout langage algebrique propre L, il existe une grammaire
algebrique sous FNG qui lengendre et que lon peut effectivement construire `
a
partir dune grammaire algebrique engendrant L.
Soit G une grammaire algebrique sous forme normale de Chomsky.
Rappelons que toute grammaire algebrique peut-etre transformee en grammaire
CNF(forme normale de Chomsky), comme nous lavons vu dans le cours sur les
langages algebriques. Cela nous permet par ailleurs de ne pas considerer le mot
vide, car la seule -r`egle est S , o`
u S , laxiome, ne figure dans aucun membre droit des r`egles.
Les r`egles de production de G sont donc de la forme: A BC et A a,
(a , B, C V ).
A a est en GNF. Ramenons `a A BC `a une GNF.
Enumerons les elements de V , ensemble fini par definition: V = (A1 , A2 , ..., Ak ),
k etant le nombre delements de V .
Remarque 1 Si les r`egles ayant A pour membre gauche sont de la forme A
B, (, ( V ) , B V ) et les r`egles ayant B comme membre gauche
sont toutes les r`egles B 1 | 2 | ... | s , alors on peut reecrire A B :
A 1 | 2 , | ... | s . sans modifier le langage engendre.
Elimination de la recursivite a gauche
A peut etre recursive `
a gauche. Si oui, les membres gauche de ses r`egles sont de
la forme
A A1 | A2 | ... | Am (recursivite a gauche)
A 1 | 2 | ... | s (pas de recursivite, les i 6 A( V ) , i entre 1 et s)
La deuxi`eme ligne est necessaire, pour chaque r`egle non recursive on doit avoir
une alternative nous permettant de sortir de la recursivite.
Une r`egle recursive `
a gauche particuli`ere sera: Ai Ai | (*)
Pour illustrer, une derivation est: Ai Ai Ai Ai

On remarque que cette r`egle produit le langage n . Peut-on reformuler la

r`egle (*) pour engendrer le meme langage sans r`egle recursive?
Les n sont generables a partir de la r`egle: B B | . A laide de cette
nouvelle variable, nous pouvons reecrire les r`egles dont A est le membre gauche:
A B
B B |
Nous obtenons:

A 1 | 2 | ... | s | 1 B | 2 B | ... | s B
B 1 | 2 | ... | m | 1 B | 2 B | ... | m B()
De cette construction, nous observons:
Remarque 2 Tout langage algebrique propre peut-etre engendre par une grammaire algebrique propre sans recursivite a gauche
En effet, la grammaire CNF de depart et la grammaire non recursive obtenue
engendrent le meme langage.
A noter que la suppression de la recursivite a gauche est necessaire en informatique. Si un automate a pile, que nous navons pas encore defini, analyse
une grammaire comportant une recursivite a gauche, celui-ci bouclera.

D
emonstration 1 Les r`egles de notre grammaire CNF de depart sont de trois
types:
(1)- Ai Aj , avec j i
(2)- Ai Aj , avec j > i
(3)- Ai a, pour tout V
Etape 1 On commence par eliminer les r`egles (1) en les transformant.Procedons
par induction:
(a) Pour i=1, j=1.toutes les r`egles dont le membre gauche est A1 secrivent
A1 A1 1 | ... | A1 m | 1 | ... | s o`
u j = a ou Aj As , j 6= i (les r`egles
engendrant les ne sont pas recursives sur A1 )
Soit B une nouvelle variable (pas dans notre ensemble V de depart). En utilisant (*) on elimine la recursivite `
a gauche. les r`egles dont le membre gauche
est A1 secrivent:
A1 1 | ... | s | 1 B | ... | s B
B 1 | ...m | 1 B | ...m B
En eliminant la recursivite on a supprime les r`egles Ai Aj , avec j = i = 1
(b) On suppose lelimination de la r`egle (1) effectuee jusqu`
a lordre p, p k.
On va la supprimer pour la p + 1-i`eme variable. Les r`egles de type Ap+1 Aj
sont:
- Soit Ap+1 Aj avec j < p + 1. Par hypoth`ese dinduction, toutes les r`egles
3

Aj Al sont telles que l > j. On peut donc appliquer la remarque 1 et

remplacer tous les Aj obtenus en derivant Ak+1 par les Al correspondant. On
continue tant quil existe des r`egles Ap+1 Aj avec j < p + 1. Lensemble
etant fini, cette construction termine necessairement et on obtient une grammaire seulement avec des r`egles Ap+1 Aj avec j p + 1.
- Soit Ap+1 Aj avec j > p + 1 pour toutes les r`egles. Ce que lon cherche.
- Sinon, on applique la meme transformation que pour le cas recursif p=1, en
introduisant une nouvelle variable.
Etape 2. V contient k elements.
- Les r`egles avec Ak sont necessairement de la forme Ak a, V .
nos sommes en GNF
- Pour Ak1 , puisque nos derivations sont triees dans lordre ascendant, des
r`egles Ak1 Ak peuvent exister (sinon Ak1 un terminal). On applique
alors la remarque 1 pour remplacer Ak . Comme les r`egles dont le membre
gauche est Ak commencent par des terminaux, les membres droits des r`egles
ayant Ak1 pour membre gauche commenceront aussi par des terminaux. - On
continue sur toutes les autres variable jusqu`
a arriver `
a A1
Exemple Soit G = (, V, P ), grammaire en CNF. = {a, b, c} et lensemble
des variables de depart est V = {A1 , A2 , A3 , A4 }. Les r`egles de production sont:

A1 A1 A2 | a

A2 A2 A3 | b
A3 A3 A1 | c

A4 A3 a
Eliminons les r`egles recursives a gauche. Il y en a 3, nous introduisons donc 3
nouvelles variables: A1 , A2 , A3 :

A1 aA1 | a

A1 A2 A1 | A2

A2 bA2 | b
A2 A3 A2 | A3

A3 cA3 | c

A3 A1 A3 | A1

A4 A3 a
La r`egle A4 A3 a est de la forme Ai Aj Ak , j i. Derivons jusqu`a obtenir
uniquement des r`egles de la forme Ai Aj Ak , j > i, ou Ai a.
A4 A3 a cA3 a | ca

Nous pouvons normaliser pour etre en GNF:

A1 aA1 | a

A1 bA2 A1 | bA1 | bA2 | b

A2 bA2 | b
A2 cA3 A2 | cA2 | cA3 | c

A3 cA3 | c

A3 aA1 A3 | aA3 | aA1 | a

A4 cA3 a | ca
Conclusion: gain en temps de derivation. Pour une GNF la complexite de la
derivation est lineaire et depend de n, le nombre de symboles terminaux (non
distincs) apparaissant a gauche de chaque membre droit dune r`egle. Deriver
une grammaire qui nest pas en GNF necessiter plus de calcul. avantages dans
lanalyses syntaxiques ...

3
3.1

Les Automates `
a pile
D
efinitions

Definition 2 Un Automate `
a pile est un 7-uplet: A = (, , Q, 0 , s, , F ):
- est un alphabet, lalphabet dentree
- est un alphabet, lalphabet de pile
- Q est lensemble fini des etats
- 0 est le symbole initial de fond de pile
- qo Qest letat initial
- , partie finie de Q ( ) Q est la fonction de transition
- F Q est lensemble des etats finaux
Un element (q, y, , q 0 , 0 ) de est une r`egle de lautomate `
a pile, generalement
note (q, y, ) (q 0 , 0 ), ou ((q, y, ), (q 0 , 0 )).
3.1.1

Configuration

Une configuration de lAutomate a pile A est un triplet c = (q, w, h) o`

u:
-q est letat courant dans lautomate
-w est le mot restant `
a lire
-h est le mot dans la pile

3.1.2

Transition

Une transition fait passer dune configuration `a une autre.

Soit c = (q, yw, h), avec y ( ), w , q Q, h , et soit
c = (q 0 , w, 0 h), avec w et h comme dans c, q 0 Q et 0 . On dit quil existe
une transition (derivation) entre c et c0 si et seulement si (q, y, , q 0 , 0 ) est dans

On note c ` c0 .
5

Si y est le mot vide, la transition sappelle -transition. On ne peut lire une

lettre et changer detat que si la pile est non vide.
3.1.3

Calcul valide

Un calcul valide de lautomate est une suite de transitions:

c1 ` c02 ,c2 ` c02 ,...,cr ` c0r et, ir, c0i = ci+1 .
On dira que ce calcul valide m`ene de la configuration c1 `a la configuration c0r .
On note c1 ` cr
Exemple 1 Lautomate reconnaissant exactement le langage {an bn | n N }
defini et represente en classe.

3.2

Modes de reconnaissance dun langage

Definition 3 Un mot w est reconnu ou accepte par lautomate `

a pile
A = (, , Q, 0 , s, , F ) sil existe un calcul valide c1 ` c0 partant de la configuration c1 = (w, q0 , 0 ), q0 etat initial, et menant `
a la configuration c0 = (, q, )
telle que:
-soit =, on dit que w est reconnu par la pile vide
-soit q A, A F sous ensemble designe, et on dit alors que w est reconnu
par etats dacceptations (ou etats aceptants)
-soit = 0 z, ou z est un element designe de , on dit alors que w est reconnu
par symbole de sommet de pile.
-soit des combinaisons de ces conditions, dont la plus utilisee est =  et q A,
et on dit alors que f est reconnu par pile vide et etats acceptants.

Dans un souci pedagogique, nous allons nous interesser uniquement aux

mode de reconnaissance: par pile vide, par etats dacceptation, par pile vide et
etats dacceptation.
Definition 4 On appelle langage reconnu par lautomate `
a pile A par pile
vide(respectivement: par etats dacceptations, par pile vide et etats dacceptation)
lensemble des mots de reconnus de cette mani`ere. On les note:
Ln (A) = {w | (s, w, 0 ) ` (q, , ), q quelconque} (pile vide)

L(A, A) = {w | q A(s, w, 0 ) ` (q, , )} (Etats

Acceptants)

et Ln (A, A)) = {w | q A(s, w, 0 ) ` (q, , )}(Pile vide et Etats acceptants)

Voir lexemple 1.
Remarque 3 Une pile peut etre initalement vide, ou peut contenir un symbole
initial. Ces deux types de dispositifs sont en fait equivalents

En effet, si un automate a pile A est avec pile initalement vide, on peut creer
A0 , automate `
a pile avec symbole initial de pile qui reconnait le meme langage
avec les memes modes de reconnaissance. Et inversement.
- Si A = (, , Q, s, , F ) est avec pile initialement vide, on introduit s0 , nouvel
etat initial, s0 6 F . On choisit dans comme symbole initial de pile, et on
cree la transition ((s0 , , )(s, )) qui depilera .
Alors, A0 = (, , Q {s0 }, , s0 , 0 , F ), avec 0 = {((s0 , , )(s, ))}
- Si A = (, , Q, 0 , s, , F ) est avec pile contenant intialement 0 , on cree
s0 6 F etat initial et la transition {((s0 , , )(s, 0 ))} qui empilera 0 .
On obtient A0 = (, , Q {s0 }, s0 , 0 , F ), avec 0 = {((s0 , , )(s, 0 ))} .
Proposition 2 Tout langage reconnaissable par un automate `
a pile par etats
acceptants est reconnaissable par un automate `
a pile par pile vide et etats acceptants, et inversement.
D
emonstration 2 Nous procederons par construction dans toute la suite.
Demontrons quun langage reconnaissable par un automate `
a pile par etats
dacceptations est reconnaissable par un automate `
a pile par pile vide et etats
dacceptation.
Soit A = (, , Q, s, , A) un automate `
a pile par etats acceptants. Nous allons
construire un nouvel automate A0 en modifiant A. Nous voulons que A0 soit un
automate a pile par pile vide et etats acceptants. A0 va reconnaitre exactement
le meme langage que A.
Pour quun mot soit reconnu par pile vide et etats dacceptation, il suffit de
vider la pile, une fois le mot lu.
On introduit qf , nouvel etat final, des -transitions entre chacun des etats acceptant et qf . On cree enfin des -transitions qui vident la pile en bouclant sur
letat qf .
La fonction 0 de transition de A0 contient tous les elements de .
Pour tout q A etat acceptant, tel que soit le symbole de sommet
du mot restant dans la pile (pour chaque transition), les nouvelles transitions
ajoutees dans 0 sont ((q, , ), (qf , )) et ((qf , , ), (qf , )).
Ainsi, A0 = (, , Q {qf }, s, 0 , A {qf }).

Il nous reste `
a present `
a montrer quun langage reconnaissable par un automate `
a pile par pile vide et etat acceptant est reconnaissable par un automate `
a
pile par etats acceptants.
Il vous est laisse en exercice...
Proposition 3 Tout langage reconnaissable par un automate `
a pile par pile vide
est reconnaissable par un automate `
a pile par etats acceptants, et inversement.
D
emonstration 3 Pour passer dun automate A = (, , Q, s, , F ) `
a pile par
pile vide `
a un automate A0 `
a pile par etats acceptants, il suffit de creer un nouvel
etat initial s0 , un symbole initial de pile et un etat final qf . Soient 0 comme
7

le symbole initial de sommet de pile (ou  si la pile est initialement vide), et

q Q lensemble des etats dans lesquels on se trouve apr`es avoir lu le mot et
vide la pile.
Le but est daller `
a un nouvel etat final une fois le mot lu. On cree alors
les nouvelles transition ((s0 , , )(s, 0 )) et ((q, , )(qf , )). 0 contient toutes les
transitions de et ces nouvelles transitions crees. Ainsi, A0 = (, , Q, , 0 , qf )

Le passage dun automate `

a pile par etats acceptants `
a un automate `
a pile
par pile vide est similaire `
a celui que lon a utilise pour passer dun automate `
a
pile par etats acceptants `
a un automate `
a pile par pile vide et etats acceptants.
Le principe est donc de vider la pile une fois le mot reconnu par etats acceptants.

Automates `
a Pile et Langages Alg
ebriques

Dans la suite, nous allons montrer quun langage est algebrique si et seulement
si il est reconnu par un automate a pile, en demontrant chacune des inclusions.
Nous allons limiter nos automates `a pile aux automates `a pile par pile vide. En
effet, nous allons associer une grammaire algebrique `a un langage reconnu par
un automate `
a pile. Letude des equivalences entre les modes de reconnaissance
nous laisse libre de faire la preuve sur un des modes seulement. Nous choisissons
le mode de reconnaissance par pile vide, car une r`egle de grammaire consiste `a
remplacer une variable (et donc consommer celle-ci) par une chane de caract`ere.
Par analogie, le symbole du haut de pile devra etre depile avant detre remplace.
Nous serons donc amener `
a depiler des symboles jusqu`a la reconnaissance du
mot, jusqu`
a ce que la pile soit vide.
Proposition 4 Tout langage algebrique peut etre reconu par un automate `
a pile
par pile vide.
D
emonstration 4 Soit G = (, V, S, P ) une GNF qui reconnait L, langage
algebrique. Nous definissons un automate `
a pile simple comme un automate ne
possedant quun seul etat.
Soit A un tel automate par pile vide, A = (, {q0 }, V, S, q0 , ) o`
u
: {q0 }  V {q0 } V
{((q0 , a, A), (q0 , )) | A a P }
{((q0 , , S), (q0 , )) Si | S  P }
Remarquons que lensemble des variables de la pile est pris dans les non-terminaux
de notre grammaire.
La transition {(q0 , a, A), (q0 , ) | A a P } depile A, reconnat le caract`ere a du mot et empile . On y associe simplement une derivation grammaticale.
On note Ln (A) le langage reconnu par cet automate. Nous allons montrer
que celui-ci est algebrique.
8

1. Montrons que Ln est algebrique

Soit u Ln (A) tel que (q0 , u, S) `n (q0 , , ). n represente le nombre de
transitions effectuees.
Nous voulons montrer lhypoth`ese H: ((q0 , u, S) `n (q0 , , )) A u,
i.e, sil existe un calcul valide dans notre automate nous permettant de
reconnaitre un mot u alors u est obtenu en derivant en GNF les symboles
de la pile . Autrement dit, u sera obtenu a laide des derivations definies
pour chacune de nos transitions, et celles ci respecteront la GNF.

(a) pour n = 1, pour une transition, on reconnat soit le mot vide soit
une lettre. En utilisant les fonctions de transition definies:
((q0 , , S) `1 (q0 , , )) si et seulement si S  P
((q0 , a, A) `1 (q0 , , )) si et seulement si A a P .
On obtient u a
` laide de derivations normales de Greibach, lhypoth`ese
est donc vraie au rang 1.
(b) Supposons que lhypoth`ese est vraie jusquau rang n. Montrons quelle
est vraie au rang n + 1.
| u | 1 et soit v tel que u = av. (a, lue `
a n=1).
Soit A1 le symbole de sommet de pile qui sera empile apr`es depilement
de A (qui est maintenant notre symbole de sommet de pile). On
definit A2 , ..., Ap de la meme mani`ere. Soit v1 le plus petit prefixe de
v, celui qui sera letiquette de la transition depilant A1 et empilant
A2 . On definit v2 , ..., vp de la meme mani`ere.
Illustons:
Nous avons (q0 , u, S) `n+1 (q0 , , ) que lon peut decomposer en
((q0 , a, A) `1 (q0 , v1 ...vp , A1 ...Ap )) et (q0 , v1 ...vp , A1 ...Ap ) `n (q0 , , )).
Pour chaque i {1, ..., p}, on sait quil existe un calcul valide permettant de lire le mot vi ...vp en depilant successivement les Ai ...Ap :
((q0 , vi , Ai) `ki (q0 , , )) en un certain nombre de transitions ki pour
chaque i. Comme ce nombre ki n , on peut donc appliquer H:
Ai vi (GNF)
Donc, A aA1 ...Ap av1 ...vp = u P
2. Montrons que les langages algebriques sont reconnus par notre automate.
Soit u un mot appartenant a un langage algebrique.
Montrons par induction H: A n u ((q0 , u, S) ` (q0 , , )).
(a) n=1, A u. u = a ou u =  car la graimmaire est en GNF. Soit
S  ce qui nous donne la transition ((q0 , , S) ` (q0 , , )) de notre
automate. Soit A a pour la transition ((q0 , a, A) ` (q0 , , )) de
notre automate.

(b) Supposons H vraie jusquau rang n. Montrons que lhypoth`ese est

vraie au rang n + 1:
On a A n+1 u, et u = av. Puisque nos derivations sont normalisees
en Greibach et que le premier terminal obtenu (mot non vide) est a,
alors la premi`ere r`egle secrit A aA1 ...Ap . Et A1 ...Ap n v.
Dapr`es le lemme fondamental (cf cours sur les langages algebriques),
il existe v1 ...vp tels que pour tout i {1, ..., p}, Ai ki vi .
comme les ki sont tous inferieurs a n, on peut utiliser lhypoth`ese
de recurence. Ainsi, on a pour tout i, lexistence des calculs valides
(q0 , vi , Ai ) ` (q0 , , ).
On en deduit le calcul valide ((q0 , a, A) ` (q0 , v1 ...vp , A1 ..Ap) `
(q0 , , )).
Ce quil fallait demontrer.
Proposition 5 Tout langage algebrique reconnu par pile vide par un automate
`
a pile est algebrique.
D
emonstration 5 Soit A = (, , Q, 0 , S, q0 , ). Maintenant que lon a etablit
le lien entre un calcul valide dun automate `
a pile et une derivation GNF, nous
sommes en mesure de creer une grammaire algebrique `
a partir des elements dun
automate `
a pile par pile vide quelconque. Et de prouver ainsi que les langages
acceptes par les automates `
a pile sont exactement les langages algebriques.
Etablissons quelaues r`egles de construction de cette grammaire:
1. Si, pour tout p, q Q, a , on a z , ((q, a, z)(p, )) , on cree
le non-terminal < qzp > et la r`egle < qzp > a.
2. Si ((q, a, z)(p, 1 ...l )) avec les i , a , z , p, q Q, alors
pour chaque qi Q, q 0 Q, on pose
< qzq 0 > a < p1 q1 >< q1 2 q2 > ... < ql1 l q 0 >
3. S est laxiome. On ajoute pour chaque q 0 Q, la r`egle S < q0 0 q 0 >.
Montrons donc H : ((q, u, z) ` (p, , )) < qzp > u, cette derivation etant
une GNF.
: montrons par recurrence sur n, nombre de transition dun calcul valide,
que ((q, u, z) `n (p, , )) < qzp > u, derivations GNF.
(a) Si n = 1 alors ((q, u, z), (p, )) avec u =  ou u = a . Par
construction, < qzp > u, on a bien ((q, u, z) `n (p, , )) < qzp >
u au rang 1.
(b) Supposons notre hypoth`ese vraie jusqu`
a un rang n fixe. On cherche `
a
generaliser au rang n + 1.
10

Pour n + 1 transitions, on ecrit ((q, a, z) `1 (q 0 , v, 0 ), et (q 0 , v, 0 ) `n

(p, , ) avec a , v , ((q, a, z), (q 0 , 0 )) 0 , et evidemment
0 6= .
Nous allons exhiber une `
a une nos derivations obtenues `
a partir de la suite
de transitions.
Soient 1 , ..., l , chaque i , tels que 0 = 1 ...l . On sait que ((q 0 , v, 1 ...l ) `
(p, , ). Ce calcul valide se reecrit en une suite de transitions, notre
mot v se decompose donc: v = v1 ...vl de sorte que ((q 0 , v, 1 ...l ) `n1
(q10 , , 1 ...l1 )).
De meme pour leffacement des i suivants. Comme les ni sont plus petits
0
n, dapr`es lhypoth`ese de recurrence, pour tout i < qi1
i qi0 > u0i . Donc
< q 0 1 ...l > v1 ...vl = v
.
: montrons par recurrence sur n que les derivations GNF < qzp >n
u ((q, u, z) ` (p, , )).
(a) Si n = 1 alors < qzp > u. Il se trouve que cest une r`egle de notre grammaire definie. On en deduit que ((q, u, z), (p, )) et donc ((q, u, z) `
(p, , )).
(b) Supposons notre hypoth`ese vraie jusqu`
a un rang n fixe. On cherche `
a
generaliser au rang n + 1.
On decompose la derivation en < qzp > n u, avec < qzp >
G.
Donc < qzp > a < q 0 1 q1 >< q1 2 q2 > ... < ql1 l ql >. Ce qui
entrane que u = av, avec v = v1 ...vl . Dapr`es le lemme fondamental,
< q 0 1 q1 >n1 v1 , et pour tout i, < qi i+1 qi+1 >ni vi .
Mais `
a chaque pas de derivation dans G correspond un pas de derivation
dans lautomate (hypoth`ese de recurrrence). On a bien une derivation
dans lautomate au total.
Ce quil fallait demontrer
Nous pouvons maintenant demontrer:
Proposition 6 Lintersection dun langage rationnel L1 et dun langage algebrique
L2 est algebrique.
D
emonstration 6 Soient A1 = , Q1 , 1 , q01 , F1 et A2 = , , Q2 , 2 , q02 , 0 , F1
reconnaissant respectivement L1 et L2 . Il suffit de construire lautomate produit,
avec:
(((q1 , q2 ), a, z), ((q10 , q20 ), 1 ...p)) une transition du nouvel automate si on passe
de q1 `
a q10 en lisant a et ((q2 , a, z), (q20 , 1 ...p)) 2 .
(((q1 , q2 ), , z), ((q10 , q20 ), 1 ...p)) une transition du nouvel automate si on passe
de q1 `
a q10 avec une -transition et ((q2 , , z), (q20 , 1 ...p)) 2 .
11

R
ef
erences
Thomas Blossier, cours universitaire sur les automates `a pile, Universite
Claude Bernard Lyon 1. Repere `a http://math.univ-lyon1.fr/ blossier/odi2009/chap8.pdf
Claude JARD. Cours universitaire sur les langages formels, universite de
Nantes Repere `
a http://pagesperso.lina.univ-nantes.fr/ jard-c/Cours/LF.pdf.
Jacques Desarmenien. Cours universitaire sur les automates, Universite de
Marne la Vallee. Repere `a http://www-igm.univ-mlv.fr/ desar/Cours/automates/ch4.pdf

12