THEORETICAL ASPECTS OF COMPUTER SCIENCE

STEFAN BRUDA, Bishops University, Winter 2007

I.

Rappels : Ensembles, Relations, Preuves, Complexit

1) Rappels sur les ensembles

Un ensemble (set) est une collection dlments distincts. Pour un ensemble S, P(S) est appel power
set, et contient tous les sous-ensembles que lon peut former avec S, plus lensemble vide. Par exemple :
S = {a, b, c}
P(S) = { {}, {a}, {b}, {c}, {a,b}, {a,c}, {b,c}, {a,b,c} }
Si S est fini avec |S| = n, alors | P(S)| = 2n, do une autre notation 2S pour le powerset.
Une partition de S est faites avec quelques uns des sous-ensembles que lon peut former avec S.
Lorsquon parle des partitions de S, ce sont toutes les partitions telles que leurs unions donne couvre S et
que leur intersection est vide. Par exemple :
S = {1,2,3}
P1 = { {1}, {2}, {3} }
P2 = { {1,2}, {3} }
P3 = { {1,3}, {2} }
P4 = { {1}, {2,3} }
P5 = { {1,2,3} }
Le nombre de Bell Bn est le nombre de partitions diffrentes que lon peut former avec un ensemble n
lments ; les premiers nombres sont B0 = 1, B1 = 1, B2 = 2, B3 = 5, B4 = 15, B5 = 52, B6 = 203. On a :

2) Relations
Une relation entre n ensembles est un ensemble de n-uplets, reprsentants des associations. Nous allons
nous intresser aux relations binaires. R2ZA*A est une relation dun ensemble dans lui-mme. Exemple :
R = { (a,b), (a,c), (b,b), (b,c) }2Z{a,b,c}*{a,b,c}
a
b
<a,b,c> est un chemin (path) car (a,b) et (b,c) sont dans la relation.
<a,b,b,c> est un autre chemin.
c
Les relations binaires ont des proprits :
- [1] Rflexive ssi (a,a)2R pour tout a2A. Correspond avoir des boucles pour tout sommet.
- [2] Transitive ssi (a,b)2R ^ (b,c)2R (a,c)2R pour tout a, b, c2A.
- [3] Symtrique ssi (a,b)2R (b,a)2R pour tout a, b2A.
- [4] Antisymtrique ssi (a,b)2R ^ (b,a)2R a = b pour tout a, b2A.
Rflexif et Transitif est preorder. Rflexif, Transitif, Symtrique est une relation dquivalence (qui induit
une partition sur lensemble). Rflexif, Antisymtrique, Transitif (RAT) est un ordre partiel.
On note par [a] = {b2A | (a,b)2R} une classe dquivalence. On note que [a] n [b] = et Ua2A[a] = A.
Ainsi, les classes dquivalences forment une partition de lensemble A.
3) Vocabulaire
On a des bijections naturelles A,B,C | (AxB)xC ; par exemple, f((a,b,c)) = ((a,b),c).
On peut dequinumerosity lorsque deux ensembles dune relation sont de mme cardinalit.
La preuve par rcurrence (induction proof) sapplique uniquement aux ensembles dnombrables. Une
preuve de bas niveau sur les ensembles est le principe des tiroirs et des chaussettes (pigeonhole).

4) Preuves par diagonalisation

Soit R2ZA*A. On a D = {a2A : (a,a) ; R}, qui est lensemble diagonal de R (diagonal set).
On a Ra = {b2A : (a,b) 2 R}, pour tout a dans lensemble A. On remarque que pour tout a, D Ra.
Prenons lexemple R = { (a,b), (a,c), (b,b), (b,c) }2Z{a,b,c}*{a,b,c}
Dans la reprsentation de la relation par matrice dadjacence,
a
on peut voir les Ra comme tant les lignes. Le diagonal set est
b
loppos de la diagonale de la matrice dadjacence. Ici, on a 101. c

a
0
0
0

b
1
1
0

c
1
1
0

b
c

Application : 2N est indnombrable.

Supposons que 2N est dnombrable. Il y aurait donc une faon dnumrer ses lments : 2N = {R0, }.
Rappelons les dfinitions : R = {(i,j) : j 2 Ri} et D = {n : (n,n) ; R}.
Est-ce que D22N ? Il devrait, puisque cest une suite de nombres. Donc il existe un k tel que D = Rk.
On a alors deux possibilits :
- k2D donc k;Rk en regardant les dfinitions. Dans ce cas l, D Rk : contradiction.
- k;D donc k2Rk : autre contradiction.
On est parti du principe que 2n est dnombrable et on arrive uniquement des contradictions.
Remarques : - Si A et B sont dnombrables, alors AxB et AuB le sont galement.
- Pour prouver quil ny a pas disomorphisme (i.e. bijection), on utilise la diagonalisation.
- Si on a un sous-ensemble B indnombrable de A, alors A est indnombrable.

Application : [0, 1[ est indnombrable.

Supposons que est [0, 1] est dnombrable. On fait toujours une preuve par contradiction.
Il y aurait donc une faon dnumrer ses lments : [0, 1[ = { R1, R2, }. Tout nombre tant prcd
par 0, on peut les reprsenter uniquement avec la partie aprs la virgule, sous forme binaire. Do :
b12
b13
b14
R1 b11
On a alors D = b11 . b22 . b33 . b44. On peut utiliser la
R2 b21
b22
b23
b24
mme notation
en base 10, avec le sens tout ce qui
R3 b31
b32
b33
b34
peut-tre dans lensemble et nest pas le symbole barr .
Il doit y avoir un K tel que RK = D. Or D = RK bKK = bKK, ce qui est impossible.
5) Fermeture (closure)
Soit D, R4Dn, n > 0. Cest une relation darit n.
Soit B4D. On dit que B est clt (ou stable) par R ssi pour tout a1, a2, , an-12B, pour de quelconques
(a1, a2, , an-1, an)2R alors an2B.
Par exemple, est-ce que N est stable/clt par addition ou multiplication ? Oui. Mais pas par soustraction !
Soit A un ensemble clt sous les relations R1, R2, , Rn. Soit D4A.
Il existe un ensemble B tel que D4B, B est minimal et clt sous les relations R1, R2, , Rn.
minimal signifie que si lon enlve un lment de lensemble, alors il nest plus clt : BJD et B est clt.
Cela revient dire quil existe un ensemble minimal stable pour les oprations.
Application : dterminer la fermeture rflexive et transitive dun ensemble.
La fermeture rflexive consiste avoir des boucles sur tout sommet. La transitive relie tout sommet S
les autres sommets qui sont accessibles en suivant des chemins dans le graphe.
a

b
c

b
c

6) Analyse de complexit : Algorithme de construction dune fermeture rflexive et transitive

1. R 42A*A
2. C {(a,a) : a2A}
3. From i 2 to |A| do
4.
For each b1b2bi with bk2A, 0 < k i, do
5.
If b1b2bi is a path in R
6.
Then C C u {b1,bi}
Illustration dun passage du Repeat :
C = {(a,b), (b,c), (a,a), (b,b), (c,c)}
(i.e. schma en bas gauche page prc.)
a1 = a ; a2 = b ; a3 = c (a, c) ;C
C = {(a,c)}
On a n choix pour le premier lment, n-1
pour le 2nd et n-2 pour le dernier. (4) est
donc en O(n3). Lalgorithme est en O(n5).

Avec (2) on construit les fermetures rflexives en

crant toutes les boucles. Ensuite, pour chaque
chemin existant, on rajoute ses extrmits. Le
problme est la recherche parmi toutes les
squences de i lments de A, ce qui nous amne
une complexit en (nn), impraticable.

1. C R u {(a,a) : a2A}
2. Repeat
3.
C
4.
For each a1, a2, a32A, a1 a2 a3, do
5.
If (a1, a2)2C ^ (a2, a3)2C ^ (a1, a3) ;C
6.
C C u {(a1, a3)}
7.
C C u C
8. Until C =

On peut faire encore plus rapide, en multipliant la matrice dadjacence. Le for each peut se faire en
regardant dans la matrice, do un n au lieu de n3. On peut aussi calculer directement la fermeture In, ce
qui se fait en log n multiplications de matrices ; une multiplication est en n3 do du n3.log(n).
Il y a encore des amliorations par des algorithmes de multiplication rapide, soit du n2+.log(n).

II.

Langages

1) Principes gnraux
Un alphabet est un quelconque ensemble fini. Une phrase sur cet alphabet est un ensemble de symboles.
Un langage est un ensemble de phrases, not * : lensemble de tous les mots sur lalphabet . Si A et B
sont deux alphabets, AxB est toujours un ensemble fini donc cest galement un alphabet.
Si L4 *, alors L est un langage. La chane vide se note (voire , ou e dans le livre de Papadimitriou).
Un langage peut contenir , ou mme tre vide. Remarquons que ; . Les oprations qui peuvent tre
faites sur les chanes sont : la longueur | |, la concatnation ou ., la sous-chane (substring prefix/suffix).
A partir de l, on peut dfinir de nouvelles oprations comme la puissance ou linverse (reversal) :
wn = w . w . . w, n times, tel que w0 = , pour tout w 2 *. Dfinition inductive :

Linverse (abc)R est cba. La dfinition inductive est :

On a (wR)i = (wi)R. Comme lensemble a t construit par induction, il est conseill de prouver par
rcurrence. De mme, on peut prouver (wu)R = uRwR par induction sur la longueur de w.
P(*) est lensemble de tous les langages sur un alphabet. Or, |P(*)| = 2|N|, donc indnombrable. On a
|0| = |N| qui est dnombrable, et par lordre lexicographique on peut voir que certains langages sont
galement dnombrables : on construit la squence a1 an a1a1 a1a2 a1an a2a1 anan.
12
n
Ceci est une bijection avec les entiers naturels. Il y a donc certains langages indescriptibles (pigeonhole).

On peut dfinir lunion ou lintersection de langages, ainsi que :

- Loppos /L1 = * - L1 pour tout L1 bas sur
- La concatnation L1L2 = {w1w2 : w12L1, w22L2}
- Kleene Star, ou Kleene Closure L* = {w1wn : pour tout i > n, wi 2L, n 0}
Il sagit de la fermeture de L u {} par la concatnation.
L+ = LL* ne contient pas L ne contient pas .
2) Langages rguliers
Un langage rgulier REG est la fermeture de {{a}:a2}u{} par union, concatnation, toile de Kleene.
La dfinition par induction de langages rgulier est :
1. , {a}2REG
2. , 2 REG 2 REG
3. , 2 REG U 2 REG
4. 2 REG * 2 REG
5. Rien dautre nest dans REG (implicite)
Exemple : {a}*({b}{a}*)*, not a*(ba*)*. La dfinition dune expression rgulire est base sur le mme
modle : et a sont des expressions rgulires ; si et sont des expressions rgulires, alors il en va de
mme pour , U, et *.
On note par L la bijection entre une expression rgulire et le langage rgulier quelle gnre.
Exemple : L = {w2{0,1}* : |w|{1} 0 [3]} L((0*10*10*10*)*) u L(0*)
On note par |w|{1} la longueur de la chane u sur lensemble {1}, i.e. le nombre de 1 dans la chane.
(0*10*10*10*)* est le gnrateur du langage. Les automates finis sont les accepteurs pour ces gnrateurs.
Soit L((aUb)*) = {a,b}* et L(a*(ba*)*) = {a,b}*. On veut montre lgalit, cest dire linclusion dans les
deux sens. On va ici dmontrer que L(a*(ba*)*) 4{a,b}*. Soit w2{a,b}* :wn = aD0bE1aD1bE2aD2...bEnaDn
avec di, ei 2N, 0 < i n. On prouve quil sagit du mme ensemble par une induction sur n :
n = 0 : w = aD0 2 L(a*)4L(a*(ba*)*)
wn2 L(a*(ba*)*). On veut prouver que wn+1 = wnbE(n+1)aD(n+1) 2L(a*(ba*)*).
Considrons En+1 = 1. On a wn+1 = wnbaD(n+1)2L(a*(ba*)*) L(ba*) = L(a*(ba*)*(ba)*))
4L(a*(ba*)*)
Pour En+1 > 1, on a wnbE(n+1) -1baD(n+1). On a wn2L(a*(ba*)*), bE(n+1) -12L(b*)4L((ba*)*), et
baD(n+1) 2L(ba*)4L((ba*)*). Do wn+12 L(a*(ba*)*) L((ba*)*) L((ba*)*) =
L(a*(ba*)*(ba*)*(ba*))) 4L(a*(ba*)*).
3) Automates Dterministes Finis (DFA : Deterministic Finite Automaton)
Un automate dterministe fini est reprsent par le tuple M = {K, , s0, , F), tel que :
a,b
- K est lensemble fini dtats
a
- est lalphabet dentre
b
b
b
- s0 est ltat unique de dmarrage (initial state)
q1
q2
q3
q4
a
- est une fonction de transition
a
- F est lensemble des tats finals
{w2{a,b}*: w does not contain bbb}
Une configuration Kx* est ltat courant avec la chane restant traiter. Par exemple, (q1, 01101) quand
on dmarre avec la chane 01101 sur lautomate prcdent. Les transitions effectues par lautomate M
sont reprsentes par (q1, 01101)M (q2, 1101), etc. On note par*M la fermeture rflexive et transitive de
M, dite yields.
M accepte une entre w
il existe f 2F tel que (s0, w)*M (f, )
lautomate se trouve dans un tat final en ayant consomm toute la chane
L(M) = {w2* : M accepte lentre w} = { w2* : il existe f 2F : (s0, w)*M (f, )}.

4) Automates Non-Dterministes Finis (NFA)

Dans un automate dterministe, est une fonction de transition. Ici, on utilise une relation de transition
telle que 4Kx(u{})xK, et on a (q,aw)M (q,w) ssi (q,a,q)2. Consquences immdiates :
- Il peut y avoir des -transitions, cest--dire un changement dtat qui ne consomme pas dentre.
- Comme cest une relation, on peut se projeter sur plusieurs lments la fois ( fonction !).
Il ny a plus ncessairement quun chemin de ltat initial ltat final. Cependant, tout automate nondterministe peut-tre transform en un automate dterministe (voir 71 preuve de dterminisation). On
utilise les deux notations suivantes :
- E(q), fermeture rflexive et transitive de ltat q par la relation {(q,q) : (q,,q)2}.
(fermeture par -transition)
- (Q,a) = {E(p) : q2Q ^ (q,a,p)2}. (fermeture par lentre a puis par -transition)
Les tats finals sont les F = {Q2K: QnF }. Lalgorithme de construction est en O(2n) avec n tats
dans lautomate non-dterministe. Attention : il nest pas ncessairement mieux davoir un automate
compltement dterministe. Dune part, le nombre de ses tats peut potentiellement augmenter jusqu 2n,
et dautre part on rduit considrablement les possibilits de traitement parallle ; on peut donner traiter
plusieurs morceaux dun automate non-dterministe lors dintersection sur des -transitions.
5) Fermetures
Le langage accept par les automates finis est-il clt sous lunion ? Oui, il suffit de crer une -transition
partir dun nouvel tat initial vers tous les tats de lunion. Formellement :
K = K1uK2u{} tel que s;K1uK2
F = F1uF2
= 1u2u{(s,,s1),(s,,s2)})
Est-il clt sous le complment ? Oui, il faut intervertir les tats finals et non finals, et on complte les
tats en les voyant vers un nouvel tat commun ( sink state ).
La clture par intersection dcoule des deux cltures prcdents, si lon applique les rgles de De Morgan:
L(M1) n L(M2) = L(M1) u L(M2)
On a aussi une clture par concatnation : pour deux automates M1, M2, il suffit de faire une -transition
de tout tat final de M1 vers ltat initial de M2. Enfin, on a la clture sous la fermeture de Kleene. Quel
est lintrt de toutes ces proprits ? La construction automatique dautomates (c.f. algo de Thompson).
6) Un langage est rgulier ssi il est accept par un automate fini
Voir preuve page 79. On traitera ici que le langage reconnu par un automate fini est rgulier.
Un langage rgulier est la fermeture de {w: w sur u{}} par concatnation, fermeture de Kleene, union.
Soit R(i,j,k) toutes les chanes acceptes par les chemins de ltat qi qj de rang k (cela veut dire quon
ne dpasse pas ltat qk). L(M)= U{R(1,j,n): qj2F}. Si on prouve R(i,j,k) rgulier alors L(M) rgulier.
Preuve par induction. Base : k = 0. R(i,j,0) est rgulier.
Hypothse (assumption). R(i,j,k) sont rguliers.
Preuve. R(i,j,k+1) = R(i,j,k) U R(i,l,k)R(l,k+1,1)R(k+1,k+1,k)*R(k+1,m,0)R(m,j,k)
qk+1
qi

ql

qm

qj

Au lieu de faire le chemin normal de qi qj, on va en

sortie un point ql pour joindre le nouvel tat qk+1, et on y
re-rentre en qm. On va donc de qi ql au pire en k tapes,
on va directement qk+1 (o on reste aussi longtemps
quon veut), on va directement qm et on peut aller en k
tapes qj. Cest une preuve plutt par construction.

7) Pumping Theorem
Si L2REG, il existe un unique n > 0 tel que pour tout w2L, |w|>n, w = xyz, y et xyiz2L i 0.
Autrement dit, il y a une partie du mot que lon peut dupliquer autant de fois que lon veut pour tout
mot assez grand . Cela marche pour les langages qui contiennent au moins une chane infinie ; dans ce
cas, cela nous donne une infinit de mots infinis puisquil suffit que lon en prenne un, on applique le
pumping theorem et on obtient une chane infinie plus longue.
Ce thorme est utilis en preuves par contradiction pour montrer quun langage nest pas rgulier.
L = {anbn : n 0}4 L1(a*b*) 4 L2(w2{a,b}*:|w|a = |w|b}. On affirme que L est rgulier (preuve par
contradiction). Donc, pour un certain n on a anbn = xyz, y et xyiz2L. On a 3 possibilits :
Le y contient juste des a, donc xyiz = an-kak*ibn or le nombre de a augmente mais pas les b,; L2
Le y contient juste des b, donc xyiz donc le nombre de b augmente mais pas les a, ; L2
Le y contient un peu des deux, donc y = akbl et xyz = an-kakbkakb1b-1 ; L1
Donc L nest pas un langage rgulier.
Comment montrer que L2 nest pas rgulier ? Ce nest pas parce quil inclut un langage non rgulier
quil est ncessairement non rgulier : un ensemble plus petit nest pas ncessairement plus faible.
L2 n L1 = L car avoir des a avant les b et autant de a que de b correspond au langage L. Or, L2 est
rgulier par assomption, L1 est rgulier par dfinition mais L nest pas rgulier alors quil devrait.
Comme les langages rguliers sont clt par intersection, alors cest que L2 nest pas un langage rgulier.
Montrons que {an : n est premier} nest pas non plus rgulier. xyiz = akal*iam tel que k+l+m tait premier.
On devrait avoir k+m+li premier pour tout i dans N. Or si i = k+m on a (k+m)(l+1), qui nest pas premier.
8) Simulation dun automate
Entre : w2*. Sortie : oui ou non (appartenance au langage reprsent). Pour un automate dterministe :
1. S s0
On commence par ltat initial
2. while w
Tant quon a un symbole traiter
3.
let w = aw
4.
if (S, a) = s then
Sil y a une transition alors on lapplique
5.
S s
6.
w w
7.
else return false
Sinon rejet immdiat
8 return (S2F)
Il faut tre sur un tat final pour accepter le langage
La simulation se fait en O(|w|). Maintenant, dans le cas dun automate non-dterministe, il faut considrer
en mme temps tous les autres chemins possibles. On arrive lalgorithme suivant :
1. S E(s0)
On prend tous les tats atteints par -transition sur ltat init.
2. while w
Tant quon a un symbole traiter
3.
let w = aw
4.
S
4.
for each si 2S, if (si,a,s) = s
5.
S S u {E(S)}
6.
w w
7.
if S = return false
8 return (S n F )
La simulation se fait en O(|k||w|). Cest extrmement intressant, surtout compar lalgorithme de
dterminisation qui est exponentiel. Il est donc mieux de simuler un automate non dterministe que de
vouloir le dterminiser dabord (surtout si on additionne des cots de minimisation par la suite).

III.

Grammaires formelles : Context Free Grammar

1) Les principes
Il y a typiquement des choses que lon peut vouloir exprimer qui sortent du contexte des langages
rguliers. Typiquement, une langue naturelle ou un programme informatique. Mme certaines expressions
simples ne sont pas rgulires, telles {d*and*b*d* : n 0} ; cette expression est pourtant bien pratique car
elle reprsente un programme avec une fonction dclare darit n et utilise darit n, par exemple.
Une grammaire G = (V, , R, S) est compose des lments suivants :
- : terminaux
- VJ : alphabet
- V : non terminaux (utiliss dans les productions)
- S2(V ) : axiome, ou symbole de dpart
- R4(V )xV* : les rgles, de la forme {V V*}, soit {non terminaux expanss en un mix}.
Une rgle scrit avec et une rcriture avec . Ainsi :
vw ssix,y2V*, a2(V ), (a z) 2 R, tel que v = xay et w = xyz.
G indique quon rcrit avec la grammaire G. G* est la fermeture rflexive et transitive de et on la
nomme drivation. Un langage peut se dfinir par succession de rgles :
L(G)={w2* : S G* w} (ensemble des mots auxquels on arrive en partant de laxiome S et par rgles)
Les grammaires context-sensitive ont les rgles R4V*(V )VV* soit A w o et sont le
contexte autour de A.
Exemple : G = ({S,a,b},{a,b},R,S}) tel que R = {S aSb, S ). Cela engendre L = {anbn : n 0}.
Exemple de rgles plus complexes :
S
S aS
S bA
b
b
b
A aA
A bB
S
A
B
B aS
B bB
a

Tout langage accept par un automate fini peut-tre accept par une grammaire (puisque cest la classe
suprieure de langage). Soit un automate M = (K, , s0, , F) et on veut G(V, , R, S) la grammaire telle
que L(M)= L(G). On la construit de faon suivante :
V=Ku
S = s0
R = {q ap : (q, a, p) 2 } u {q : q 2 F}.
On recopie toutes les transitions et on arrte la grammaire sur un tat final.
Ces rgles sont spciales : R4(V ) x ((V ) u {}), caractristiques de grammaires rgulires (et
donc cas particuliers de grammaires context free). Comme on a un exemple de grammaire context free qui
nest pas rgulier, alors la classe des langages rguliers est strictement incluse dans celle context free.
Le langage des parenthses balances (balanced brackets) est dfini par les rgles :
S (S)
S
S SS
Un exemple : (())() donne S SS (S)S (S)(S) ((S))(S) (())(S) (())()
Cependant, il y a plusieurs faons de produire (())() partir de nos rgles. On dit quil y a plusieurs
parcours ou drivations possibles. Deux drivations sont similaires si elles diffrent uniquement dans
lordre dapplication de rgles conscutives.

2) Parse Tree
On a des labels sur les nuds, et le label de la racine est laxiome. Le yield de larbre est la
concatnation des symboles des feuilles de gauche droite (i.e. inorder). La dfinition par induction est :
- For all a 2 , .a is a parse tree (of yield a)
- For all rules (A ) 2 R, .A is a parse tree (of yield ).
- If
are parse trees and A A1, A A2, , A An 2 R, then
A1
A2
An
is a parse tree.
A

y1
-

y2

Nothing else is a parse tree

yn

A1

A2

An

of yields y1,
, yn

Pour toute derivation S * w, il exist un (ou plus) parse tree avec comme racine le label S and yield w.
Deux drivations similaires donnent un mme parse tree. On peut sen servir pour faire une nouvelle
dfinition : deux drivations sont similaires si elles produisent le mme parse tree. Toutes les grammaires
ne produisent pas ncessairement de mme parse trees ; prenons par exemple la suivante :
EE+E
Cette grammaire est ambigu car une mme
S
EE*E
expression peut donner des parse trees diffrents.
S
S
E identifier
On parle de langage ambigu sil ny a aucune
E(E)
grammaire qui ne soit pas ambigu.
(
S )
(
S )
Ce langage nest pas ambigu, car la grammaire suivante dfini le langage :

(
S
)
EE+T
TT*F
F identifier
Parse tree pour (())()

ET
TF
F(E)
On note par LG une leftmost derivation (rcriture du non-terminal le plus gauche) et LG une
rightmost derivation (rcriture du non-terminal le plus droite). Pour toute drivation S G* w, il existe
une drivation S LG* w et une drivation S RG* w.
3) Push-down Automata (automate pile)
Un automate pile est reprsent par M = (K, , , , S, F) o est lalphabet de la pile, et une
relation sur laquelle on rajoute la manipulation de la pile : 2( x u{} x * x K x *). La premire
partie est lentre x u{} x *, et u{} montre que lon peut oprer sans rien faire (non dterministe).
Une transition est gnralement symbolise ((p, a, ), (q, )).
Exemple : {anbn : n0}. On met tous les a vus sur la pile, et en dpilant on regarde pour le nombre de b.
Do = { ((q0, a, ), (q0, a))
((q0, b, a), (q1, ))
((q1, b, a), (q1, ))
}
et M = ({q0,q1}, {a,b}, {a}, , q0, {q1}).
La configuration dun automate pile est K x * x * soit (q, w, u)M (q, w, u) si et seulement si :
w = aw, a2 u {}, u = x, u = x and for some x2*, there exist ((q1, a, ), (q, a)) 2
La dfinition du langage accept est donc L(M) = {w2* : (s, w, )M* (f, , ) with f 2F}. Cela
signifie que le langage est accept lorsquon a fini lentre ainsi que la pile, et quon est sur un tat final.
Pour le langage dfini par les rgles S SS, S ( S ), S , on crit la relation de la faon suivante :
= { ((s, (, ), (s, ()),
((s, ), (), (s, )) }
(je vois une parenthse ouvrante, jempile ; je vois une parenthse fermante, je dpile. Un seul tat !)
Soit L(M) = {w2{a,b} : there exist u so that w = uuR}, le langage des palindromes. La relation est :
= { ((s, a, ), (s, a))
((s, b, ), (s, b))
((s, , ), (f, ))
((f, a, a), (f, ))
((f, b, b), (f, )) }
( un certain moment on se place tel que on est la moiti ; lautomate est non dterministe, et il nest
mme pas dit quil puisse tre dterministe car la position de la moiti est totalement inconnue ! Le
langage est gnr en rpondant des rgles context-free mais il est context-sensitive : SaSa, SbSb)

Chaque langage Context Free est accept par un automate pile, et chaque automate pile reprsente un
langage Context Free (i.e. il y a quivalence). Montrons que pour toute grammaire Context Free, on peut
crer un automate pile qui laccepte. On a la grammaire G = (V, , R, S) et M = ({p,q},, V, , p, {q}) :
= {((p, , ), (q, S))} U {((q, a, a),(q, )) : a2} U {((q, , A), (q, w)) : A w2R}
Pour le langage dfini par les rgles S SS, S ( S ), S , cette dfinition automatique donne :
{((p, , ), (q, S)),
((q, (, (), q, )),
((q, ), )), (q, )) ((q, , S), (q, SS))
((q, , S),(q,(S))), ((q, , S),(q, ))
}

MIDTERM Jeudi au retour des vacances New York

Open Book

Maintenant on a un automate et on veut en extraire la grammaire (prouve lquivalence dans lautre sens).
On dfinit un automate pile simple (PDA) sur lequel on veut oprer, de la faon suivante :
Soit M = (K, , , S, , F). Pour tout ((q, a, ), (q, ))2 , avec q S, on a :
2
| | 2 (limite de ce quon peut pousser sur la pile chaque fois : 2 symboles)
Cet automate est simple car on tablit des restrictions : on ne peut regarder quun seul symbole et en
pousser au maximum deux. Maintenant, on cherche rendre tout automate simple par une transformation.
On met un symbole z de fond de pile, pour sassurer quil y ait toujours quelque chose : = u { z }. On
ajoute donc la transition ((s, , ), (s, z)) o s est le nouvel tat initial qui nous permet de mettre z. On
invente un nouvel tat final : F = { f }, et on ajoute les transitions {((f, , z), (f , )) : f2F}.
Il faut sassurer que lon conserve les restrictions sur toute transition. On ne veut pas les ((q, a, ), (q, )):
o = 1 n, n > 1, car on regarde plus dun symbole
o = 1 n, n > 2, car on empile plus de deux symboles
La solution est de crer des tats intermdiaires : utiliser plusieurs tats qui regardent un symbole si on
veut simuler un tat qui regarde plusieurs symboles. Ainsi, ((q, a, 1 n), (q, )) est remplac par :
{((q, a, 1), (q1, )) ((q1, , 2), (q2, ))
((qn-1, , n), (q, )) }
o qi, 1 i < n, sont les nouveaux tats
De mme, on remplace ((q, a, ), (q, 1 n)) par :
{ ((q, a, ), (qn, n)) ((qn, , n), (qn-1, nn-1))

((q2, , 2), (q, 21)) }

il faut empiler partir de la fin n. A chaque fois on pose le symbole vu aussi, et cest pour cela que notre
automate simple a besoin davoir jusqu 2 symboles empils en mme temps.
A prsent, on peut utiliser lautomate simplifi pour en extraire une grammaire G = (V, , R, S). On a :
V = u { S } u {<p, A, q> : p, q2K, A2} o on a <start state, top of the stack, end state>
{ S <s, z, f> } U shortcut : je dmarre de s avec z sur la pile
{ <q, A, r> a<q, , r> : ((q, a, A), (q, )), avec A, B 2 u {}, r2K}
U {<q, A, r> a<q, 1, r><r, 2, r> : ((q, a, A),(q, , 2))2, avec A, 1, 22, r, r2K}
U {<q, , q> : q2K}
4) Oprations sur les grammaires
Soient deux grammaires G1 = (V1, , R1, S1) et G2 = (V2, , R2, S2), V1 V2 , S;V1, S;V2. On veut
construire la grammaire G = (V, , R, S) pour les oprations suivantes :
Union : L(G) = L(G1) u L(G2). On met simplement un nouvel tat initial S et lon runit, do
R = R1 u R2 u {S S1, S S2}
V = V1 u V2 u S
Concatnation : V = V1 u V2 u S
R = R1 u R2 u {S S1S2}

 La fermeture de Kleene nest quune succession de concatnation : L(G) = L(G1)*.

R = R1 u {S , S S1S}
V = V1 u S
Les langages Context Free ne sont pas clt par complment, donc pas par intersection.
Soit un automate fini (reg. lang.) M1 = (K1, , S1, 1, F1) et un automate pile M2 = (K2, , 2, S2, 2, F2).
On veut construire un automate M = (K, , , S, , F) tel que L(M) = L(M1) L(M2). Comme on ne
peut pas faire lintersection entre deux langages Context Free, on le fait entre un langage Context Free et
un langage rgulier. Sur la mme ide que le transducer, on veut construire un automate en parallle :
K = K1 x K2
S = (S1, S2)
F = F1 x F2
= { ( ((q, p), a, ) , ((q,p),) ) : q = (q, a) ^ ((p, a, ), (p, )) 2 2 }
Consuming one input : (pre-requisite, where we end)
U { (((q, p), a, ), ((q, p), )) : ((p, , ), (p, )) 2 2 }
Si linput nest pas considre alors seul M2 peut faire quelque chose car M1 dterministe
Si les deux automates sont pile et quon veut faire un device fonctionnant en parallle, alors il lui
faudrait 2 piles, donc nous sortons du cadre des automates pile.
5) Pumping theorem for Context Free Languages
Soit une grammaire G = (V, , R, S). Le nombre maximal denfants que peut avoir le nud du parsing
tree est dit branching factor, ou fan-out, not (G), et donn par la plus longue rgle de la grammaire.
Soit un parse tree de hauteur h et largeur y. On a |y| (G)h. Au 1er niveau, on a 1 nud et il peut y avoir
jusqu (G) enfants ; de mme au niveau 2 on va jusqu (G) enfants, etc. etc.
Soit un chemin de longueur maximale dans larbre et h > |V |. Par le pigeon-hole principle, on en
conclu quil y a au moins un non-terminal rpt. Il existe donc une portion o lon peut dupliquer autant
de fois que lon veut.
For any w 2 L(G) ^ |w| > (G)|V-|, we have w = xyzuv with yu and xynzunv2 L(G) for all n 0.
Prouvons que L = {anbncn : n 0} nest pas context-free. On fait la preuve classique par contradiction.
On affirme que L est context free. Il y a donc w = xyzuv tel que xykzukv2 L. Pour y et u, 2 variantes :
- yu contiens a, b et c alors xykzukv2 L(a*b*c*) car on a le rsultat dans le dsordre
- yu ne contient pas a, alors xykzukv ne contient pas un nombre gal de a, b, et c. De mme b et c.
Soientt L1 = {ambmcn : m, n 0}, L2 = {ambncn : m, n 0}. On remarque L1 = {ambm : m 0}.{cn 0}.
La premire partie de L1 est context-free et la seconde rgulire, donc L1 est context free. En revanche,
L2 = {a}*.{bncn : n 0} et L1 L2 = L qui nest pas context-free. Donc, les langages context-free ne
sont pas clt par intersection, ce qui veut dire quils ne le sont pas non plus par complment.
6) Automate pile dterministe
Deux squences , sur 2 alphabets sont dites consistants si est un prfixe de ou est un prfixe de .
Les transitions ((p, a, ), (q, )) et ((p, a, ), (q, )) sont dites compatibles si a et a sont consistants
ainsi que et . Un automate pile dterministe est un automate pile dans lequel il ny a pas deux
transitions distinctes qui sont compatibles.
L est un langage context-free dterministe si L$ est accept par un automate pile dterministe. Les
automates pile dterministes sont clt par complment et intersection ; corollaire : les langages contextfree dterministes sont un sous-ensemble strict des langages context-free.

7) Complment dun automate fini pile

Pour tablir le complment, le problme est la gestion de la pile. Soit M un automate simple et une
configuration (q, aw, bw) M (q, w, bu) pouvant rsulter de :
- ((q, , b), (q, b)) a = et b = ou b . On a un espoir daccepter lentre si a fait
descendre la pile.
- ((q, a, b), (q, b)) a .
On veut identifier les transitions de qui ne peuvent pas conduire accepter lentre. Ainsi (p, , ) est
sans issue (dead end) sil ne conduit pas en une tape (p, , ) ou (p, , ). On remplace toute
transition considre comme morte/inutile en utilisant le sink state (ltat puit sur lequel on envoie tout) :
((p, , ), (q, )) 2 D ((p, , ), (r, )) o r est le nouvel tat
On ajoute des transitions afin de rejeter de faon civilise : on regarde quand mme la chane jusqu la
fin et on vide la pile. On introduit les (((r, a, ), (r, )) pour tout a2, ((r, $, ), (r, ))) o r est un nouvel
tat, et ((r, , ), (r, )) pour tout 2.
On a L(M) = L(M) car on accepte toujours le mme langage mais on a juste modifi les rejets. On fait
de r le seul tat final (on intervertit les rles). Par conclusion, cette preuve constructiviste montre que les
langages context-free dterministes sont clt par complment.
8) Simulation
On veut un automate acceptant le langage gnr par une grammaire G = (V, , R, S). On fait du bottomup parsing sur des grammaires dites weak precedence (cest le cas de toutes les grammaires pour langages
de programmation rcents) ; SLR et LR(1) sont des restrictions de ce type de grammaire. On simule par :
= { ( (p, a, ), (p, a) : a2 } U {((p, , R), (p, A)) : A 2R} U {((p, , s), (q, ))}
Shift
Reduce

IV.

Machines de Turing et Calculabilit

1) Dfinition
Dans une machine de Turing, on peut se dplacer comme on veut
de faon linaire, lire et crire dans la bande. Toute la bande est
initialise par le symbole ou #. Formel : M = (K, , , s, H) o
les tats finis H sont les Halting states, est lalphabet de la
bande avec deux symboles spciaux (end, marker, blank) et deux
symboles L (bouger la tte gauche), R (bouger la tte droite).
Une fois dans un Halting State, la rgle est quon ne peut en sortir.

Marqueur
de la fin de
bande

automate

Rcrire le contenu de la cellule courante

Les transitions sont les : K x K x ( u {L, R}).
ou faire bouger la tte
On dfinit certaines restrictions :
- pour tout h2H, f(h, a) est indfini pour tout a2. On ne sort pas dun halting state.
- Si (q, ) = (p, b) alors b = r. Si on vient sur le marqueur de fin de bande alors la seule action
possible est daller droite, puisquon est la fin.
- Si (q, a) = (p, b) alors b .
Une configuration c est telle que c2K x * x *(( {#}) U {}). On la note par (q, uaw) en soulignant
le symbole o la tte se trouve actuellement. Par exemple abbaa#a### donne (q, abbaa#a).
Le yield in one step (mouvements de la machine) est ((q, uaw) M (q, ua,w) si (q, a) = (q, b) pour
b2 u {L, R} et :
- si b2 alors u = u, w = w, a = b
- si b = L (bouger la tte gauche) alors ua = u, w = aw si a # ou w
sinon w =
- si b = R (bouger la tte droite) alors u = ua,
w = aw si a #
sinon w = w =

Construisons une machine de Turing pour sentraner. Soit = {i, #, }, s = q1, H = {k}, K = {q1,q2,q3,q4}
(q1, #) = (q2, L)
(q2, i) = (q2, #)
(q2, #) = (q3, L)
(q3, i) = (q3, L)
(q3, #) = (q4, i)
(q4, i) = (q4, R)
(q4, #) = (h, #)
On fait marcher la machine sur un exemple : (q1, #iii#ii#) (q2, #iii#ii)(q2, #iii#i#)(q3, #iii#i)
(q3, #iii#i)(q4, #iiiii)(q4, #iiiii)(q4, #iiiii#)(h, #iiiii#).
Cette machine concatne 2 chanes de contenue identique. Si on compte en nombre de barres on peut
mme dire que a ralise une addition
2) Comment crire une machine de Turing
On dfinit une machine de base (basic machine) Ma :
On peut combiner ces machines de base :

pour tout x2 : (s,x) = (h, a).

pour tout a2 : a = Ma, L = ML, R = MR

>M1

R # = R# L # = L# R # = R# L # = L#
a
La flche signifie jump over : on
M3
saute tous les symboles incrimins.
M1 M2 se note M1M2
Autres
x2
constructions

M2
1

Ca donne une machine de turing M :

= 1 U 2 U 3
remplacer toutes les occurrences de h
dans 1 par q nouveaux tats
on ajoute (q,a) = q2 et pour tout x2
\{a}, (q,x) = q3 o q2 est ltat de
dpart de M2 et q3 celui de M3

En utilisant nos nouvelles constructions, la machine prcdente scrit >L #L# i R#

Soit la machine L = {anbncn : n 0}. La machine accepte avec #Y# et refuse avec #N#. On lcrit par :
d
> L
#

c,d
c dL

b,d
b dL

x;{c,d,#}
#Y#
#N#

a,d
a dL

x;{c,d,b}
#N#

x;{q,d,#}
#

x;{b,d,a}

#N#

On rcrit sur a, b et c jusqu ce

quil ny ait plus rien rcrire.

#N#

3) Langages rcursifs et rcursivement numrables

On dit que M dcide le langage M si en recevant #w# alors M sarrte toujours et donne #Y# si w2 L
#N# sinon
Si M dcide L alors L est un langage rcursif, cest--dire dfini en utilisant des fonctions rcursives
primaires qui sont des outils aussi puissantes que les machines de Turing (et dont le mot a t emprunt).
Soit M une machine de Turing, M = (K, , , s, {h}) et M(w) = y o (s, #w#)M* (h, #y#).
f : * * est rcursif ssi il existe une machine de turing M tel que pour tout w2 *, M(w) = f(w).
Une machine de turing M semi-dcide un langage L2 * ssi M sarrte sur w ssi w2 L. Alors L est un
langage rcursivement numrable.
Si on dcide, alors on semi-dcide aussi ; il suffit de faire une boucle infinie pour ne pas sarrter au lieu
de mettre #N#. En revanche, il y a des langages rcursivement numrables qui ne sont pas rcursifs.
4) Machine de turing multi-tape
On a k tapes pour un k donn. La fonction de transition de la machine tait : K x K x ( u {L, R})
et maintenant quon a k tapes, cela donne : K x k K x ( u {L, R})k.
Pour toute machine de Turing k tapes, il existe une machine de turing 1 seule bande faisant la mme
chose. Cest simplement le ct pratique qui nous intresse, pour isoler des parties en les mettant sur des
bandes diffrentes. Pour prouver que cette machine nest pas plus puissante que celle de base, on prend
toutes les bandes et on les considre comme les pistes dune grosse bande, en sauvegardant ltat courant.

Bande
avec k

piste

Bande avec

piste
piste

00010000

Chaque bande est divise en 2 parties. La partie infrieure marque (avec un 1) la position de la tte sur la
bande dorigine : il ne faut pas ngliger le fait que chaque bande tait cense avoir sa propre tte.
Lalphabet de la machine est maintenant {, #} U ({0,1}x)K. On scanne la bande une fois pour trouver,
et une seconde fois pour modifier ; chaque transition se fait en kn + kn = O(n) ; autrement dit on est O(n)
fois plus lents que la machine dorigine, mais cela ne modifie pas la classe de complexit puisquon reste
polynomial ou exponentiel selon ce quon tait au dpart.
5) Variante : Random Access Turing Machine
Dans cette machine, on a un accs en temps constant nimporte quel endroit de la bande, comme la
mmoire dun ordinateur. Rappelons que la machine de Turing de base on doit faire passer la tte par
toutes les cases intermdiaires. Une fois encore, cela naugmente pas le pouvoir de calculabilit et ne
modifie pas la classe de complexit.
6) Machines de Turing non dterministes
Il sagit dune machine de Turing classique M = (K, , , s, H) o est une relation de transition non
dterministe telle que 4KxxKx( u {L,R}) ; on autorise plusieurs futurs.
On veut savoir si un nombre n est composite (i.e. il admet une dcomposition en nombre premiers). La
machine devine p et q, p n, q n, et on regarde si pq = n. La multiplication pq se fait assez facilement
puisquon a dj une machine permettant dadditionner. Pour comparer, il suffit de faire un et bit bit
entre les deux bandes. La partie intressante est donc le non-deterministic guess , ou la possibilit que
la machine puisse deviner. Pour cela, elle essaye en parallle toutes les combinaisons possibles de p et q.
Pour gnrer des p et q, on les fait chacun sur leur bande en mettant des 0 et des 1 tant quon est pas sorti
de n (ds quon lit un # sur la 1re ligne alors on arrte la machine) ; si on a pas de blanc, on peut sarrter
ou continuer : cest important car on doit aussi pouvoir gnrer les nombres infrieurs n.
Accepter une chane dans la machine de Turing de base consiste sarrter dans un halting state. Ici, la
machine accepte ou semi-dcide un langage ssi (s, #w#) M* (h, x) o x est nimporte quel output ; on
conserve la mme dfinition mais la smantique est un peu diffrente dans le cas non-dterministe.
M dcide un langage L ssi (s, #w#) M* (h, #y#) si x2 L et (s, #w#) M* (h, #n#) si ; L
et il existe n 0 tel quil ny a pas de c tel que (s, #w#) MN c
(autrement dit toutes les branches doivent sarrter un jour on lexpanse :
c1 MN c ssi il existe c1,c2,,cn t.q. c1 = c1, cn = c2, c1Mc2MMcn )
Une machine de Turing M calcule la fonction f : * * si M(w) = f(w) pour tout w2* et que toutes
les branches possibles sarrtent. Une alternative la 1re condition est (s, #w#) M* (h, #f(w)#).
Pour toute machine de Turing non dterministe qui dcide ou semi-dcide un langage, ou calcule une
fonction, il existe une machine de Turing dterministe qui fait la mme chose.
c1
c M avec m |K| (|| + 2) ,car 4KxxKx( u {L,R})
cm
On a un degr maximal de non-dterministe. Soit Md la variante dterministe pour M, elle a 2 branches :
- working tape (contient le mot w)
- guiding tape (contient une chane de nombres, ou une squence, tel que 1 ij |K|(||+2) )

On utilise une machine de Turing dterministe M avec 3 bandes :

- la 1re contient w en read only (aucune altration possible)
- la 2nd est la working tape
Tous les possibles Md
- la 3me contient une chane de nombres
Et on la fait fonctionner de la faon suivante :
1. Copier w sur la working tape
2. Lancer Md
3. Si on obtient loutput dsir (en accord avec ce quon cherche) sur la 2nd tape, on sarrte.
Formellement : si Md atteint (h, u) pour un u2*
4. Sinon, on gnre le contenu suivant de la 3me tape en suivant lordre lexicographique (i.e. on
gnre une autre machine Md de faon ordonne)
5. Recommencer ltape 1
Si loutput est produit en n tapes, comme on teste toutes les configurations avec lordre lexicographique,
on obtient une complexit 1 + m + m + + mn = i=1nmi = O(mn).
7) Machine de Turing Universelle
Considrons une machine de Turing universelle U (en gros, un ordinateur) qui prend une chane et une
machine de Turing simuler ; U renvoie une certaine sortie. On cherche une faon dcrire une machine
de Turing en binaire pour quelle puisse tre donne comme argument U, et ainsi simule. On note par
q<n> les tats, avec n un codage binaire taille fixe selon la machine de Turing ; on a q00 ltat initial
et q11 le halting state. Une fois les tats encods, on soccupe du reste : lalphabet et les transitions .
On note lalphabet par a<n> avec n un code binaire taille fixe selon la machine de Turing ; on a
quelques symboles spciaux : a00 pour #, a01 pour , a010 pour L et a011 pour R. Les
transitions sont des (q, a, q, a) et comme chacun peut sencoder, il suffit de concatner. Par exemple :
q : q001
a : a111
q : q010
a : a000
concatnation q001a111q010a000$
M M dnote lencodage de M, ou encore M enc(M). On voit que enc(M) = enc() car cela
suffit pour spcifier compltement la machine (bijection).
On a U(enc(M)#enc(w)) = enc(M(w)). Ainsi (s, #enc(M)#enc(w)#) U* (h, #M(w)#). U a trois bandes :
- input, soit #enc(M)#enc(w)#
- storage tape, initialement vide
- simulation, initialement q00
On commence par copier #enc(M)# sur la 2nd bande et on simule M.
8) Le Halting Problem
Soit halt(P, x) = stop ssi P stop sur lentre X. On dfinit diagonal(X) par :
si halt(X,X) sarrte alors diagonal(X) sinon stop
On donne un programme le programme lui-mme, et on lui demande de voir sil va sarrter. On dfini
H = {enc(M)#enc(w) : M sarrte sur w) le langage correspondant, semi-dcid par U donc rcursivement
numrable. Nous allons prouver quil nest pas rcursif, ou que MH ne dcide pas H.
On fait une preuve par contradiction : supposons que H est rcursif et regardons ce que a engendre. On
devrait avoir H1 = {enc(M) : M sarrte sur enc(M)} rcursif, et comme les langages rcursifs sont clts
par complments alors /H1 = {x : x nest pas lencodage dune machine de Turing ou x = enc(M) et M ne
sarrte pas sur x} devrait tre rcursif. Comme /H1 doit tre rcursif, il est aussi rcursivement
numrable et il existe une machine M* qui le semi-dcide. Mais est-ce que enc(M*)2/H1 ? Si oui :
- M* ne sarrte pas sur enc(M*) par dfinition de H1
- mais la machine qui semi-dcide /H1 doit sarrter sur enc(M*).
Or la machine qui semi-dcide /H1 est M* par dfinition de semi-dcidabilit, do une contradiction. H
nest donc pas rcursif, bien que rcursivement numrable.
Corollaire : les langages rcursivement numrables ne sont pas clt par complments.

9) Calculabilit
Un problme est une fonction f : entres sortie. Un langage vu par les automates est une fonction
boolenne : oui si lentre et dans le langage, et non pour le reste. Examinons certains problmes
classiques en donnant leur nonc, puis en les transcrivant sous forme de langages.
Problme du voyageur de commerce (travelling salesman). Soit I une matrice dadjacence, on veut une
permutation des {1, , n} telle que d12 + d23 + + dn-1n + dn1 (car cest un cycle) soit minimale.
Dfinition du langage pour le voyageur de commerce. Etant donn (dij), k 0, y a-t-il une
permutation de {1, 2, , n} telle que d12 + d23 + + dn-1n + dn1 k (on veut minimiser).
Problme du mariage stable (stable marriage). On a un graphe non-orient G = (V, E) et on veut trouver
lensemble maximal C de sommets tels que pour tout vi, vj2C alors (vi, vj)2E ; on recherche le plus gros
graphe fortement connexe.
Dfinition du langage pour le mariage stable. Etant donn G = (V, E), k 0, y a-t-il un C4V tel
que pour tout vi, vj2C alors (vi, vj)2E et |C| k (on veut maximiser).
En gnral, on parle du langage correspondant un problme lorsquon soccupe de la thorie. Par abus,
dans la suite du cours on identifiera un langage comme tant quivalent un problme.
On a vu par le halting problem quil existe des langages indcidables. Ceci nous permettra de rpondre
des questions comme : tant donn une machine de Turing M, est-ce quelle sarrte sur une bande vide ?
Est-ce quil existe une entre telle que la machine sarrte ? Ces problmes sont toujours indcidables, et
on peut le montrer avec des preuves par diagonalisation. Cependant, il existe un outil extrmement
pratique qui est la rduction. Une rduction de L1 L2 (langages sur *) est une fonction rcursive (i.e.
il doit y avoir une machine de Turing qui peut la faire) : * * telle que w2L1 ssi (w)2L2.
Si L1 nest pas rcursif et quil y a une rduction de L1 L2 alors L2 nest pas rcursif. Preuve par
contradiction : si L2 tait rcursif alors il y aurait une machine de Turing qui le dciderait, et une M ;
comme cela quivaut MM2 qui dciderait L1, cest une contradiction.
La rduction va dun langage connu non-rcursif un langage inconnu (cest le contraire de la thorie de
la complexit). Etant donns M, w = w1w2wn, on veut Mw = w1Rw2RwnRM par ; autrement dit on
fait une rduction du halting problem en celui de savoir si la machine sarrte sur une bande vide. On
dtruit w de la bande et on devine (non-deterministic guess) une entre x, puis on lance M.
Etant donns M1 et M2, est-ce ce quils dcident le mme langage ? Ce serait extrmement pratique si on
pouvait dire oui, pour tout ce qui est vrification de la correction de programmes et de modles Voir le
thorme de Rice et la preuve, page 270, comme suit : Pour toute proprit exhaustive non triviale
Soit RE la classe des langages rcursivement numrables c C=RE tel que C s :, le problme
Etant donn une machine de Turing M, est-ce que le langage dcid par M est dans C est indcidable.
Autrement dit : toute proprit non triviale propos du langage reconnu par une machine de Turing est
indcidable .
Deux problmes indcidables :
- dterminer si une grammaire CF gnre toutes les chanes possibles ou si elle est ambigu
- tant donns deux grammaires CF, dterminer si elles gnrent le mme ensemble, ou si lune
gnre un sous-ensemble de lautre, ou sil existe des chanes quelles gnrent toutes les deux
(voir aussi : complexit de Kolmogorov, problme de correspondance de Post, Tiling de Penrose, 10me
problme de Hilbert i.e. dterminer si une quation Diophantienne admet une solution, nombres de Gdel)

V.

Thorie de la Complexit

1) Time Bounded Turing Machine

Soit f : N N et une machine de Turing M, dterministe ou non. M est f-time bounded si pour tout w,
|w| = n, alors il nexiste pas de configuration telle que (s, #w#)Mf(n)+1 (q1, ). En commenant, la machine
fonctionne avec f(n) pour chaque transition au plus. De faon similaire, on pourra dfinir space bounded.
M est polynomialy time bounded sil existe un polynme p tel que M est p-time bounded, i.e. M est ftime bounded pour un f(n) = nO(1). P est la classe des langages dcid par une machine de Turing
dterministe polynomialy bounded. NP est la classe de langages pour la version non-dterministe. EXP
est la classe des langages dcid par une machine de Turing dterministe exponentially bounded f(n)=2n^O(1)
P4NP4EXP
2) Prouver quun langage est dans NP : vrifiable en temps polynomial
Dfinition alternative pour NP : on peut vrifier une solution en temps polynomial.
Soit L2*,* le langage des paires. L is polynomially bounded balanced language if there exist a
polynomial p such that u,v2 L |v| p(|w|).
L est NP sil existe un tel langage L avec les proprits suivantes :
- L2P
- L = {x : il existe y : x, y2 L}
On dit que y est le succint certificate (ou solution candidate)
Exemple : les nombres composites.
Soit L = {w2{0,1}* : w est un nombre compositive).
Soit L = {w,a,b2{0,1}*,{0,1}*,{0,1}* : w = a*b}. Ce langage est dans P et a,b est le succint certificate.
Comme L2P et on a un succint certificate alors L2NP : on peut le vrifier en temps polynomial.
On peut vrifier en temps polynomial si un nombre est composite, partir du moment o on propose les
composants. Par contre, on pense quil nexiste pas de rsolution en temps polynomial pour les trouver.
3) Rduction
Une rduction est une fonction : * * telle que est rcursif et x2 L1 (x) 2 L2. On sintresse
au temps ncessaire pour faire la rduction : on parle de rduction polynomiale de L1 L2 si la
rduction est faisable avec un polynomialy bounded deterministic Turing machine.
L est NP-hard si pour tout L2NP, il existe : * * rduction polynomiale.
L L
Le plus dur des problmes NP est celui pour lequel on a une rduction polynomiale de tous les autres.
L est NP-complet si L2NP et L est NP-hard.
4) Problmes NP-Complet : SAT et le bounded tiling
Le premier problme prouv comme tant NP-complet par Cook est SAT (Satisfiability).
Soit X = {x1, , xn} un ensemble de variables boolennes, et /X = {/x, , /xn}. Xu/X est dit lensemble
des littraux (cest lunivers des boolens). Une formule scrit 1 ^ ^ m, i = xi1 v v xik, o les i
sont des clauses (une formule est une conjonction de clause quand elle est crite sous forme normale).
Une interprtation est un ensemble daffectations de valeurs aux variables, et cela engendre un rsultat
vrai ou faux. On dit quune formule est satisfiable sil existe une interprtation telle quelle est vrai.
Le problme SAT est : tant donn une formule F, est-ce que F est satisfiable ?
Ce problme est dans NP car on peut trouver un certificate pour chaque instance de SAT. On peut aussi
construire une machine de Turing qui devine une interprtation et la vrifie, en utilisant lhabituel nondeterministic guessing. On parle de generate & test paradigm, et cest une mthode trs commune.

Etudions le problme du tiling. Soit S et NS = N [0, S]. Un tiling system est un tuple D = {D, d0, H, V} :
- D est le genre de tiles quon met (on fait du carrelage, D caractrise les carreaux)
- d02D est le tile initial dans le coin infrieur gauche
- H2DxD, V2DxD sont les spcifications horizontales et verticales des motifs
Un tiling est une fonction f : NSxNS D qui donne chaque tile sa place, tel que f(0,0) = d0 et :
- (f(m,n),f(m+1,n))2H, la restriction horizontale
- (f(m,n),f(m,n+1))2H, la restriction verticale
Le problme du bounded tiling : tant donn un tiling system D et un tiling initial f0 : Ns D, a-t-on un
tiling f : NSxNS D qui tend f0 ? Autrement dit : la 1re ligne est dj carrele, peut-on trouver une
fonction qui continue le motif en accord avec les restrictions horizontales/verticales ?
Il est facile de montrer que le problme est NP : on peut construire la machine de Turing associe avec un
non-deterministic guess pour f ; tester que f0 est la ligne infrieure se fait en temps linaire ainsi que de
tester les restrictions (4 voisins chaque fois). Rappel : pour tout p2NP on a une machine de turing nondterministe et polynomially time-bounded.
Ce problme est NP complet. Prouvons quil est NP-hard, en montrant quil y a une rduction
polynomiale des machine de Turing de tous les autres problmes NP vers une instance du bounded tiling.
Tape s

A chaque tape, on fabrique une tape. Comme le nombre

dtapes est polynomially bounded, un jour on finira par
arrter de rajouter. Le tiling est limit par une taille s, qui est
un polynme de la taille de lentre.

Tape 2
Tape 1
Longueur s

Un tile est labell sur chaque ct. Deux tiles vont ensembles ssi ils ont le mme label sur le

ct par lequel on les joint. La machine de Turing M quivaut au systme D et f0 quivaut

w ; donc un f qui tend f0, cest un M acceptant w.
On va crer des blocs de bases quon va stocker dans notre machine. Pour chaque, on veut connatre ltat
courant et vers o pointe la tte. On dnote par <symbol, state> le tile actuellement point.
Pour tout a2, on a :

a
a

Pour tout (q, a, p, b)2, b2, on a :

(b,p)
(a,q)

a
Dans cet exemple, le
a
a
a
(a,q)
tile point est le 3me
a
a
a
Quand on a le symbole a et quon est en q, alors on
va en b avec le symbole p

Pour tout (q, a, p, L)2, b2, on a les deux tiles :

(b,p)
Lq
b

Pour tout (q,

a, p, R)2,
Rq
b2,
de
(a,q)
mme.
On a vu que f0 est quivalent #w#, soit la premire ligne :
a

(b,p)
Rq
b

#
#

On va en b avec la
tte, on se dplace
dun cran gauche

a
Lq
(a,q)
w1
w1

wn
wn

(#,s)
#

#
#

Quand la machine veut sarrter et dire non, il ne faut pas quon continue de se propager : on fait un arrt
du tiling. Ainsi le bloc N N est exclu. Cependant, le bloc Y Y est autoris ;
On note lquivalence par la rduction avec M accepte w ssi (M,w) est une chane dans le langage du
bounded tiling. Construire un tile se fait en temps constant. Il y a || tiles a a ; pour chaque (q, a, p, L)
on a ||.||.2 (car il faut deux tiles), de mme pour (q, a, p, R), do un O(||.||) soit O(||) nombre de
tiles comme la taille de lalphabet est fixe. Le nombre de tiles est linaire en la taille de lentre, donc
nous avons un polynme. Comme le Tiling System est calculable en temps linaire, il y a une rduction
polynomiale et donc cest un problme NP-Complet.

#
#

5) Comme pourrait-on prouver que P = NP

Soit L un problme NP-complet, alors P = NP ssi L2P (i.e. L NP-complet et L 2P P = NP)
Montrons que si P = NP et L est un problme NP-complet, alors L 2P. Cest assez direct.
L est NP complet donc L 2NP et comme P = NP alors L2P.
Montrons le dans lautre sens.
Pour tout L2P on a une machine de Turing polynomially time bounded M telle que le
langage dcid par M est L (par dfinition de la classe P). Pour tout L2NP on veut
construire une machine de Turing polynomially time bounded M telle que L(M) = L.
On a M = MM o M est la machine de Turing calculant la rduction polynomiale de L
L. Or, cette machine M existe par dfinition de NP-complet.
Le mme principe marche entre deux autres classes de problmes o on ne sait pas si linclusion est stricte,
comme NL4P (c.f. assignment 4). Notons au passage que les algorithmes de la classe NL peuvent tre
parallliss, tandis que si un algorithme est dans P (de faon stricte) et quon a plusieurs processeurs alors
on pense quil ne peut pas en bnficier.
6) Rductions entre problme
Rappel : si 1 et 2 sont des rductions polynomiales alors il en va de mme pour 1 o 2 = 1(2(x)). On
associe M1 1 et M2 2 des machines de Turing dterministes, alors M2M1 est dterministe et
polynomialy bounded (on lance M2 jusqu arrt puis lancement de M1 sur le contenu de la bande).
Les rductions polynomiales sont transitives : si on a un nouveau problme et quon a une rduction
polynomiale vers un problme NP-complet, alors ce nouveau problme est lui aussi NP-complet. Il est
trs important de connatre une liste raisonnable de problmes NP-complets pour faire ses rductions.
Montrons que SAT est NP-complet en utilisant le fait quon puisse le rduire au bounded tiling. On a
Xmnd les variables boolennes telles que f(m, n) = d (true ou false).
Xmnd1 v Xmnd2 v v Xmndk pour D = {d1, , dk} pour tout 0 m,n < s
Pour tout carr, il y a au moins un tile.
Il ny a pas deux tiles sur le mme carr
/Xmnd v /Xmnd pour tout d d, pour tout 0 m,n < s
/Xnmd v /Xn(m+1)d et /Xnmd v /X(n+1)md pour tout (d, d)2D - V Restrictions horizontal/vertical
Il suffit de mettre un ET logique entre toutes ces formules et on a lquivalence. Rduction polynomiale.
Examinons le problme SAT3. Il sagit de la mme chose que SAT mais o chaque claus peut avoir au
plus trois littraux. Le modle est (11 v 12 v 13) ^ ^ (n1 v n2 v n3). On opre de rduction de SAT
SAT3 : lide est de simplifier les clauses dun modle SAT pour les exprimer comme un modle SAT3.
Exemple : on a 1 v 2 v 3 v 4. Le modle quivalent dans SAT3 est (1 v 2 v y1) ^ (/y1 v 3 v 4), tel
que y1 = /( 1 v 2). Ainsi, si 1 v 2 est vrai alors /y1 est vrai donc lensemble est vrai ; si 1 v 2 est faux
alors y1 est vrai et on dlgue la responsabilit de rendre la formule vrai 3 v 4 (car /y1 faux i.e. neutre).
Do : 1 v 2 v v n (1 v 2 v y1) ^ (/y1 v 3 v y2) ^ (/y2 v 4 v y3) ^ ^ (/yn-3 v n-1 v n). La
rduction est-elle polynomiale ? Au pire, on a trois fois plus de clauses et chaque clause se construit en
temps linaire, donc la reduction est en O(n) et ainsi SAT3 est un problme NP-complet.
En revanche, SAT22P. Par exemple, on a (X1 u X2) ^ (/X1 v X2) ^ (/X2 v X1). Affectons X1 = T et
rcrivons : il ne reste plus que X2, donc la combinaison X1 = X2 = T permet de satisfaire la formule.
Exemple : (X1 v X2) ^ (/X1 v X2) ^ (/X2 v X1) ^ (/X1 v /X2). Affectons X1 = T, il reste X2 ^ /X2 ; si on
essaye X2 = F alors il reste X2 ^ /X2 ; la formule nest donc pas satisfaisable. Notons bien quon ne gnre
pas toutes les possibilits, ce qui serait exponentiel.

Montrons que le problme des cycles hamiltoniens est NP-complet en utilisant une rduction avec SAT.
On sait que le problme est dans NP puisquon a une machine qui devine toutes les permutations et la
vrification se fait en temps linaire. Les arcs sont les dij2{0, } et on veut le cycle qui passe par tout
sommet une fois et une seule, donc les sommets sont les xij, 0 < i,j n tels que j = i (le sommet i du
graphe est le sommet j du cycle). On sait une instance de SAT satisfaisable ssi le graphe admet un cycle
hamiltonien.
La technique consiste nonc en posant des clauses, et de les lier la fin. Ainsi :
- Il doit y avoir au moins 1 sommet pour chaque position, soit Xij v X2j v x Xnj,
1jn
- Tout sommet doit tre visit : Xi1 v Xi2 x x Xin,
1in
- Il doit y avoir au plus 1 sommet pour chaque position. Si on a une position, alors Xik ^ Xjk doit
tre faux puisque lun des deux ne doit pas y tre, autrement dit on a /Xik v /Xjk, 1 i, j, k n, i j
- De mme, on a /Xki v /Xkj,
1 i, j, k n, i j
Ceci tablit que xij reprsente une bijection sur lensemble des sommets (i.e. une permutation).
Maintenant, on tablit une dernire clause pour spcifier lexistence du cycle :
Pour tout arc (i, j);G, /Xik v /Xj(k+1),
1 k n et n+1 1 (cyclique)
Pour les deux premires clauses on a n clauses n littraux, pour les autres on a n3 clauses nombre
constant de littraux. La rduction de O(n3) soit polynomial. Notons que pour la dernire clause il y a
peut-tre un check faire mais au pire on est en O(n5) et a reste polynomial quoiquil en soit. Montrons
donc que (G) la conjonction est satisfaisable ssi G admet un cycle hamiltonien :
Si = (1, , n) reprsente un cycle hamiltonien, alors (G) est satisfaisable.
Notons Interpretation(Xij) = T ssi j = i. Xik ou Xj(k+1) de la dernire clause doit tre faux
par dfinition du cycle, donc la clause doit tre vrai.
Si (G) est satisfaisable alors il doit y avoir une permutation = (1, , n)
Il existe une interprtation telle que la formule est vraie. Il y a un arc (i,j)2G, /Xik v /Xj(k+1)
est faux donc Interpretation(Xik) = Interpretation(Xj(k+1)).
Montrons que trouver un cycle hamiltonien dans un graphe non-orient est aussi un problme NP-complet.
Il nous suffit de transformer le graphe orient de la faon suivante, puisquon ne peut passer quune fois
par un sommet :

De mme, montrons que trouver un chemin hamiltonien dans un graphe orient est aussi NP-complet.

On duplique le sommet ainsi que toutes les

connexions qui y sont lies. On rajoute les tats
S de dpart du chemin et T de fin du chemin.

X'

Il y a un cycle hamiltonien passant par x. Donc, on commence notre chemin S, on passe par X et comme
cest un cycle on le fait finir sur X qui termine le chemin en passant sur T.

7) Problmes ouverts
P est clt par complment. Pour NP, on ne sait pas On note son complement CO-NP = {L | /L2NP};
actuellement, on pense plutt que NP nest pas clt par complment, i.e. que CO-NP NP. Lautre
suspicion serait que si L2NP et L2CO-NP alors L nest pas complet ; une fois encore, on ne sait pas.
Une variante de la factorisation de nombres snonc de la faon suivante : tant donn n2N et m n, y
a-t-il un facteur de n plus petit que m ? Ce problme est dans NP, et cest justement la base de bons
nombres de techniques de cryptographie. Ce problme est galement dans CO-NP. On pense quil est en
dehors de P, en dehors de NP-complet et en dehors de CO-NP-Complete; il est quelque part au milieu .
8) Le principe du Model Checking (preuve de correction)
Etant donns deux expressions rgulires R1 et R2, est-ce quelles gnrent le mme langages ?
Regardons le problme oppos : a-t-on L(R1) L(R2). On peut trouver un certificate : nimporte quelle
chane gnre par R1 mais pas par R2. Le certificate est-il un succint ? Il ny a pas de limite vidente, et
en fait on ne sait mme pas si le problme est dans NP
Examinons alors un problme plus simple. On se contraint navoir que des expressions rgulires qui
nutilisent pas la fermeture de Kleene. On a donc : pour tout x2L(R), R une *-free R.E., |x| |R|. Ici, le
certificate a une borne et il devient un succint. Ce problme l est donc dans NP, et il est aussi NPcomplet comme on le montre avec une rduction depuis SAT.
Lentre est C = c1 ^ c2 ^ ^ cm sur X = {X1, , Xn}.
En sortie : R1, R2 tels que L(R1) L(R2) ssi C est satisfisable.
On a R1 = (0 u 1)(0 u 1)(0 u 1), n fois. On a donc L(R1) = {0, 1}n affectations de X qui rend C vrai.
0 si Xj apparat dans Ci
On a R2 = 1 U 2 U U m tel que i = i1i2...in, avec ij =
1 si /Xj apparat dans Ci
{0 u 1} sinon
On a donc L(i) le langage des interprtations qui ne satisfont pas Ci, et ainsi L(R2) est lensemble de
toutes les interprtations qui ne satisfont pas certains Ci. Donc L(R2) = {0, 1}n si C est insatisfaisable
={0, 1}n sinon
L(R2) ={0, 1}n si C est satisfaisable car il y a au moins une des interprtations qui satisfait C et L(R2)
est lensemble des interprtations qui ne satisfont pas C : a ne peut donc pas tre {0,1}n tout entier
puisquune des interprtations satisfait.
Ainsi C satisfaisable ssi L(R1) L(R2), et donc la comparaison dexpressions rgulires sans la
fermeture de Kleene est un problme NP-complet. On en dduit que le problme en autorisant la
fermeture de Kleene est plus compliqu encore, et on sait quil est au moins NP-complet.

Pour continuer ltude des problmes NP-complets, on recommande louvrage suivant :

Michael R. Garey and David S. Johnson, Computers and Intractability : A Guide to the Theory of NPCompleteness, Freeman, 1991. Call number QA 76.6 .G35 1991.