transducteurs et additionneurs

Cours A&G Vers l'ordinateur quantique
Données innies On a vu dans les chapîtres précédents qu'un automate permet de représenter de
manière nie (et même compacte) une innité de données. En eet, un automate A a un nombre ni
d'états alors que le langage qu'il reconnaît L (A) est le plus souvent inni.
Le miracle vient du fait que l'automate ne représente pas directement les données mais un calcul à
eectuer pour obtenir les données. On a donc échangé de l'espace mémoire (celui des données) contre
du temps (le temps nécessaire pour les calculer).
Le même principe de représentation des données sous forme de calcul permet de représenter l'innité
des décimales du nombre π par un programmme (d'un millier de ligne) qui calcule la ne décimale de
π pour tout n ∈ N.
Innités d'opérations Maintenant qu'on sait représenter des données innies, on aimerait eectuer
des calculs sur ces données sans avoir à les énumérer sinon on sera à nouveau confronter à l'inni. C'est
possible dans une certaine mesure et les automates en orent un bon exemple.
Construction d'additionneurs L'objectif de ce chapître est de faire un pas vers l'informatique
quantique capable de réaliser une innité d'opérations en un temps ni.
Considérons des automates An et Ap qui reconnaissent des mots sur Σ = {0, 1}. Les mots de L (An )
et L (Ap ) peuvent être vus comme des nombres binaires. L'automate An est le codage de l'ensemble
des nombres binaires (éventuellement une innité) qu'il reconnaît L (An ) = {n1 , n2 , . . .}. De même
L (Ap ) = {p1 , p2 , . . .}
On va voir qu'il est possible de constuire un automate, noté An ⊕ Ap , qui reconnaît exactement
l'ensemble des sommes formées de nombres n ∈ L (An ) et p ∈ L (Ap ). Autrement dit, L (An ⊕ Ap ) =
{n + p | n ∈ L (An ), p ∈ L (Ap )}.
Pour calculer et acher explicitement cet ensemble, il faudrait faire une innité d'opérations. L'utilisation d'automates permet de contourner cet obstacle et d'obtenir une représentation compacte de cet
ensemble sous la forme d'un automate An ⊕ Ap par un algortihme ecace en O((N × P )2 ) où N est
la taille An et P celle de Ap .
1
Transducteur
Un transducteur T est un automate qui consomme des symboles dans un ux d'entrée et produit des
symboles sur un ux de sortie (un automate est un cas particulier de transducteur qui ne produit rien).
i/o
Les transitions d'un transducteur sont de la forme q −−→ q 0 où i est le symbole consommé sur le ux
d'entrée par la transition et o est le symbole produit sur le ux de sortie. La transition consomme i et
produit o : on dit donc que o est la traduction du symbole i ; d'où le nom de transducteur.
Ainsi, lorsqu'on exécute un transducteur T sur un mot ω , il se comporte comme un automate et s'il
reconnaît le mot il produit une traduction du mot sur le ux de sortie.
Langage d'entrée, langage de sortie Le langage
d'un transducteur T est le langage de
l'automate obtenu en considérant les transitions de T comme des transitions d'automate classique ;
i/o
i
c'est-à-dire en considérant uniquement la partie q −
→ q 0 des transitions q −−→ q 0 .
Li (T ) = L (Input(T ))
avec
i/o
def
d'entrée
i
Input(q −−→ q 0 ) = q −
→ q0
Le langage de sortie d'un transducteur T est le langage de l'automate obtenu en considérant uniquement
i/o
o
la partie q −
→ q 0 des transitions q −−→ q 0 .
1
Lo (T ) = L (Output(T ))
avec
def
i/o
o
Output(q −−→ q 0 ) = q −
→ q0
Exécution d'un transducteur (à rédiger)
Exercice Donnez un transducteur
inverse les 0 et les 1.
T qui reconnaît les mots sur Σ = {0, 1} commençant 1 et qui
Exercice Donnez un transducteur T qui reconnaît tous les mots sur Σ = {0, 1} et qui supprime les
0.
Exercice Donnez un transducteur T qui reconnaît tous les mots sur Σ = {0, 1} et qui supprime les
1 situés après un 0.
Produit d'un automate
et d'un transducteur
Le principe est le même que pour les automates (à nombre) d'états ni : on exécute simultanément A et T ; pour avancer de concert il faut que
A et T soient d'accord sur le symbole d'entrée, et on garde la partie production des transitions de T .
A
i/o
(qa , qt ) −−→(qa0 , qt0 ) ∈ A × T
T
si et seulement si
i
qa −
→ qa0 ∈ A
et
i/o
qt −−→ qt0 ∈ T
Image d'un automate A par un transducteur T La traduction (ou l'image) des mots de A par
un transducteur correspond au langage de sortie de l'automate produit A × T , c'est donc
Image de A par T
def
= Output(A × T )
Exercice
Q1. Donnez un automate A qui reconnaît les nombres binaires pairs écrits avec les unités à gauche.
Exemples :
- (1)N ≡ (1)2 ≡ (1.0.0.0.0)2 ≡ (1.0∗ )2 ∈
/ L (A)
∗
- (2)N ≡ (0.1)2 ≡ (0.1.0 )2 ∈ L (A)
- (3)N ≡ (1.1)2 ≡ (1.1.0∗ )2 ∈
/ L (A)
solution
89:;
/ ?>=<
a0
def
A=
1
0
0
G?>=<
89:;
FED
/ @ABC
a1
L
0
Q2. Faîtes le produit de A par le transducteur T qui reconnaît tous les mots et inverse les 0 et les 1.
solution
def
A×T =
?>=<
/ 89:;
a
1/0
1
0
?()*+
/.-,
>=<
/ 89:;
q ≡
I
?>=<
0123
7654
/ 89:;
a0 ×
J
0
0/1
2
HIJK
/ ONML
(a,q)
1/0
0/1
HIJK
@ABC
GFED
/ ONML
(a0 ,q)
I
0/1
Q3. Donnez l'automate qui correspond aux mots de A traduit par le transducteur T . et décrire
en une phrase le langage reconnu par cet automate.
solution
0
ONML
/ HIJK
(a,q)
def
Output(A × T ) =
1
HIJK
@ABC
GFED
/ ONML
(a0 ,q)
I
≡ nombres binaires impairs
1
Addition numérique des langages de deux automates Pour constuire l'automate An ⊕ Ap , on
transforme l'un d'eux (le plus simple), disons Ap en
des mots de An par le transducteur-additionneur Tp
transducteur-additionneur
Tp , on prend l'image
def
An ⊕ Ap = Output(An × Tp )
2
Algorithme de construction d'un transducteur additionneur
2.1 Remarque préliminaire
Lorsqu'on veut additionner deux nombres n et p, on complète le plus court des deux par des 0 an
d'obtenir des nombres de même taille ou on leur ajoute même un 0 pour prévoir le cas d'une retenue
en n d'addition.
Exemple :

on considére des nombres binaires écrits avec les unités à gauche
et donc on fait l'addition de gauche à droite :
sens du calcul
−−−−−−−−→
111111
+ 11
0100001
=n
=p
111111 retenue
1111110 = n complété
+ 1100000 = p complété
0100001
détail des calculs :
Tout nombre binaire p est équivalent à p.0∗ : le nombre p auquel on a ajouté des 0 non signicatifs.
2.2 Étapes de constructions du transducteur-additionneur associé à Ap
Étant donné un automate Ap sur l'alphabet Σ = {0, 1}, l'algorithme suivant produit un transducteur
qui implante l'addition numérique avec retenue d'un nombre p du langage L (Ap ).
Exemple :
def
On commence par un exemple simple en considérant l'automate A =
89:;
/ ?>=<
a0
89:;
0123
7654
/ ?>=<
a1
1
étape 1 : extension de Ap avec des 0 non-signicatifs À chaque état accepteur de Ap on ajoute
/.-,
l'extension suivante qui reconnaît les 0 non-signicatifs : ()*+
()*+
// .-,
E
0
1
0
+1
+0
Puis on renomme les transitions −
→ et −
→ de Ap en −−→ et −−→.
Exemple :
Pour Ap , on obtient
89:;
/ ?>=<
a0
1
89:;
0123
7654
/ ?>=<
a1
89:;
0123
7654
/ ?>=<
a2 qui se simplie en
H
0
on obtient alors une chose qui n'est ni un automate ni un transducteur
def
A⊕
p =
89:;
/ ?>=<
a0
89:;
/ ?>=<
a0
+1
1
89:;
0123
7654
/ ?>=<
a2
H
89:;
0123
7654
/ ?>=<
a2
H
+0
3
0
Transformation des transitions
+?
−−→
en transitions de transducteur
Chaque transition
0/..
+1
q −−→ q 0 doit incrémenter le digit lu en entrée ; elle donne donc naissance à deux transitions −−→
1/..
et −−→ en fonction de l'entrée et en tenant compte de la retenue.
On indique la valeur de la retenue dans les états du transducteur qui sont donc de la forme (q, r = 0),
(q, r = 1).
+1
Une transition q −−→ q 0 génère donc les transitions suivantes dans le transducteur :
0/1
(q, r = 0) −−
→(q 0 , r = 0)
+1
1/0
(q, r = 0) −−
→(q 0 , r = 1)
+1
0/0
(q, r = 1) −−
→(q 0 , r = 1)
+1
1/0
(q, r = 1) −−
→(q 0 , r = 1)
+1
car
r = 0 +1 +
le
'0' lu
donne
1
et
r=0
car
r = 0 +1 +
le
'1' lu
donne
0
et
r=1
car
r = 1 +1 +
le
'0' lu
donne
0
et
r=1
car
r = 1 +1 +
le
'1' lu
donne
1
et
r=1
+0
Une transition q −−→ q 0 génère donc les transitions suivantes dans le transducteur :
0/0
(q, r = 0) −−
→(q 0 , r = 0)
+0
1/1
(q, r = 0) −−
→(q 0 , r = 0)
+0
0/1
(q, r = 1) −−
→(q 0 , r = 0)
+0
1/0
(q, r = 1) −−
→(q 0 , r = 1)
+0
car
r = 0 +0 +
le
'0' lu
donne
0
et
r=0
car
r = 0 +0 +
le
'1' lu
donne
1
et
r=0
car
r = 1 +0 +
le
'0' lu
donne
1
et
r=0
car
r = 1 +0 +
le
'1' lu
donne
0
et
r=1
L'état initial de T est l'état initial de A avec la retenue égale à 0.
Les états accepteurs du transducteur sont les états de la forme (q, r = 0) avec q accepteur et une
retenue égale à 0.
Exemple :
89:;
/ ?>=<
a0
def
À partir de A⊕
p =
+1
89:;
0123
7654
/ ?>=<
a2
H
on obtient le transducteur :
+0
def
Tp =
PQRS
/ WVUT
(a0 ,r=0)
+0: 0/0,1/1
PQRS
HIJK
ONML
/ WVUT
a2 ,r=0
+1
ss9
+0 sss
s
1/0 +1
ss
sss 0/1
PQRS
WVUT
(a2 ,r=1)
V
0/1
qu'on écrit plus simplement
def
Tp =
()*+
// .-,
0/0,1/1
()*+
/.-,
/ ?


1/0


 0/1
()*+
/.-,
Y
0/1
1/0
+0: 1/0
2.3 Généralition et algorithme
Le Transducteur-additionneur T associé à un automate A sur l'alphabet Σ = {0, 1} est déni de la
manière suivante :
4
+0
q −−→ q 0 ∈ Ap
+1
q −−→ q 0 ∈ Ap



(q, r



=⇒
(q, r




 (q, r


(q, r






 (q, r
=⇒


(q, r





 (q, r

0/0, 1/1

= 0) −−−−−→(q 0 , r = 0) 



0/1
0
∈ Tp
= 1) −−→(q , r = 0)



1/0


= 1) −−→(q 0 , r = 1)

0/1
= 0) −−→(q 0 , r = 0) 





1/0

0
= 0) −−→(q , r = 1) 
∈ Tp
0/0

= 1) −−→(q 0 , r = 1) 




1/1

0
= 1) −−→(q , r = 1) 
q ∈ Init(Ap ) =⇒ (q, r = 0) ∈ Init(Tp )
q ∈ Acc(Ap ) =⇒ (q, r = 0) ∈ Acc(Tp )
Tout état avec une retenue (. . . , r = 1) ne peut-être ni initial, ni accepteur.
Exercice
Q1. Donnez l'automate An qui reconnaît les nombres binaires pairs écrits avec les unités à gauche et
donnez une expression régulière équivalente.
solution
def
An =
89:;
/ ?>=<
a0
1
0
0
G?>=<
89:;
FED
/ @ABC
a1
L
≡ 0.(1|0)∗
0
Q2. Construire le transducteur-additionneur Tp associé à l'automate Ap def
=
@ABC
/ GFED
a0
1
@ABC
/ GFED
a1
0
1
GFED
?>=<
89:;
/ @ABC
a2
Q3. À partir de l'automate An et du transducteur-additionneur Tp , constuire l'automate qui reconnait
le langage {n + p | n ∈ L (An ), p ∈ L (Ap )}.
5