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}

c

ba est un chemin (path) car (a,b) et (b,c) sont dans la relation. est un autre chemin. 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}

c

ba a b c a 0 1 1 b 0 1 1 c 0 0 0

Dans la reprsentation de la relation par matrice dadjacence, on peut voir les Ra comme tant les lignes. Le diagonal set est loppos de la diagonale de la matrice dadjacence. Ici, on a 101. 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 : R1 b11 b12 b13 b14R2 b21 b22 b23 b24R3 b31 b32 b33 b34 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 l 2, , Rn. minimal signifie que si lon enlve un lment de lensemble, alo : BJD et B est clt. Cela revient dire quil existe un ensemble minimal stable pour le Application : dterminer la fermeture rflexive et transitive dLa fermeture rflexive consiste avoir des boucles sur tout sommles autres sommets qui sont accessibles en suivant des chemins da

a b c d

On a alors D = b11 . b22 . b33 . b44. On peut utiliser la mme notation en base 10, avec le sens tout ce qui peut-tre dans lensemble et nest pas le symbole barr .

c c

a b b a es relations R1, Rrs il nest plus clt s oprations.

un ensemble.

et. La transitive relie tout sommet S

ns le graphe.

a b c d

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

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. 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} 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).

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).

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. 1 2 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 :

- K est lensemble fini dtats - est lalphabet dentre - s0 est ltat unique de dmarrage (initial state) - est une fonction de transition - F est lensemble des tats finals

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.

{w2{a,b}*: w does not contain bbb}

a,b

a

b b b a

a

q1 q2 q4q3

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 (NDans un automate dterministe, est une fon telle que 4Kx(u{})xK, et on a (q,aw)M

- Il peut y avoir des -transitions, cest-- Comme cest une relation, on peut se

Il ny a plus ncessairement quun chemin ddterministe peut-tre transform en un autoutilise les deux notations suivantes :

- E(q), fermeture rflexive et transitive (fermeture par -transition)

- (Q,a) = {E(p) : q2Q ^ (q,a,p)2}.

Les tats finals sont les F = {Q2K: QnF dans lautomate non-dterministe. Attentioncompltement dterministe. Dune part, le noet dautre part on rduit considrablement lesplusieurs morceaux dun automate non-dterm

5) Fermetures Le langage accept par les automates finis estpartir dun nouvel tat initial vers tous les ta

K = K1uK2u{} tel que s;K1uK2

Est-il clt sous le complment ? Oui, il faut intats en les voyant vers un nouvel tat commu La clture par intersection dcoule des deux c

L(M1) n L On a aussi une clture par concatnation : pode tout tat final de M1 vers ltat initial de Mest lintrt de toutes ces proprits ? La cons

6) Un langage est rgulier ssi il est acceVoir preuve page 79. On traitera ici que le lanUn langage rgulier est la fermeture de {w: wSoit R(i,j,k) toutes les chanes acceptes parne dpasse pas ltat qk). L(M)= U{R(1,j,n)

Preuve par induction. Base : k = 0. R Hypothse (assumption). R(i,j,k) son Preuve. R(i,j,k+1) = R(i,j,k) U R(i

qk+1qjqmqlqiFA) ction de transition. Ici, on utilise une relation de transition (q,w) ssi (q,a,q)2. Consquences immdiates : -dire un changement dtat qui ne consomme pas dentre. projeter sur plusieurs lments la fois ( fonction !). e ltat initial ltat final. Cependant, tout automate non-mate dterministe (voir 71 preuve de dterminisation). On

de ltat q par la relation {(q,q) : (q,,q)2}.

(fermeture par lentre a puis par -transition)

}. Lalgorithme de construction est en O(2n) avec n tats : il nest pas ncessairement mieux davoir un automate mbre de ses tats peut potentiellement augmenter jusqu 2n, possibilits de traitement parallle ; on peut donner traiter iniste lors dintersection sur des -transitions.

-il clt sous lunion ? Oui, il suffit de crer une -transition ts de lunion. Formellement :

F = F1uF2 = 1u2u{(s,,s1),(s,,s2)})

tervertir les tats finals et non finals, et on complte les n ( sink state ).

ltures prcdents, si lon applique les rgles de De Morgan:

(M2) = L(M1) u L(M2)

ur deux automates M1, M2, il suffit de faire une -transition 2. Enfin, on a la clture sous la fermeture de Kleene. Quel

truction automatique dautomates (c.f. algo de Thompson).

pt par un automate fini gage reconnu par un automate fini est rgulier. sur u{}} par concatnation, fermeture de Kleene, union. les chemins de ltat qi qj de rang k (cela veut dire quon : qj2F}. Si on prouve R(i,j,k) rgulier alors L(M) rgulier. (i,j,0) est rgulier. t rguliers. ,l,k)R(l,k+1,1)R(k+1,k+1,k)*R(k+1,m,0)R(m,j,k)

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 bb

aaa

S A B A aA A bB B aS B bB

Tout langage accept par un automate fini peut-tre accept par une grammaire (puisque suprieure de langage). Soit un automate M = (K, , s0, , F) et on veut G(V, , R, S) la grque L(M)= L(G). On la construit de faon suivante : V = K u 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 grammairesdonc cas particuliers de grammaires context free). Comme on a un exemple de grammaire conest pas rgulier, alors la classe des langages rguliers est strictement incluse dans celle con 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 parcours ou drivations possibles. Deux drivations sont similaires si elles diffrent unilordre dapplication de rgles conscutives. b

cest la classe ammaire telle

rgulires (et ntext free qui text free.

y a plusieurs quement dans

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

is a parse tree.

- Nothing else is a parse tree

of yields y1, , yn

AnA2A1

A

yn y2 y1

AnA2A1

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 : E E + E E E * E E identifier E ( E ) Ce langage nest pas ambigu, car la grammaire suivante dfini le langage : E E + T T T * F F identifier E T T F F ( E ) Parse tree pour (())()

)

S ) (

SS S

S )(

S(

Cette grammaire est ambigu car une mme expression peut donner des parse trees diffrents. On parle de langage ambigu sil ny a aucune grammaire qui ne soit pas ambigu.

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

= { ((s, (, ), (s, ()), ((s, ), (), (s, )) } (je vois une parenthse ouvrante, jempile ; je vois une parenthse fermante, je d

Soit L(M) = {w2{a,b} : there exist u so that w = uuR}, le langage des palindrome = { ((s, a, ), (s, a)) ((s, b, ), (s, b)) ((s, , ), (f, )) ((f, a, a), (f, )) ( un certain moment on se place tel que on est la moiti ; lautomate est non mme pas dit quil puisse tre dterministe car la position de la moiti est totlangage est gnr en rpondant des rgles context-free mais il est context-sensitde la faon suivante : pile. Un seul tat !)

s. La relation est : ((f, b, b), (f, )) } dterministe, et il nest alement inconnue ! Le ive : 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, q2K, A2} o on a { S } U shortcut : je dmarre de s avec z sur la pile { a : ((q, a, A), (q, )), avec A, B 2 u {}, r2K} U { a : ((q, a, A),(q, , 2))2, avec A, 1, 22, r, r2K} U { : 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 V = V1 u V2 u S R = R1 u R2 u {S S1, S S2} 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)*. V = V1 u S R = R1 u {S , S S1S} 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 context-free 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 bottom-up 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 Rcrire le contenu de la cellule courante

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

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 : pour tout x2 : (s,x) = (h, a). pour tout a2 : a = Ma, L = ML, R = MROn peut combiner ces machines de base : 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 : > L dL dL dL

##N#

x;{q,d,#} c,d

cd

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

2 1

3

a M2

M3a

>M1 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

Autres constructions

On rcrit sur a, b et c jusqu ce quil ny ait plus rien rcrire.

bb,d

aa,d

3

On d Si MprimSoitf : Unelang Si ode m

4On aet m Pouchosbandtout x;{b,d,a} x;{c,d,b} x;{c,d,#} #N##

#Y# #N##N#

) Langages rcursifs et rcursit que M dcide le langage M s

dcide L alors L est un langaires qui sont des outils aussi p

M une machine de Turing, M =* * est rcursif ssi il existe u

machine de turing M semi-dcage rcursivement numrable.

n dcide, alors on semi-dcide aettre #N#. En revanche, il y a d

) Machine de turing multi-tap k tapes pour un k donn. La foaintenant quon a k tapes, cela d

r toute machine de Turing k tae. Cest simplement le ct praes diffrentes. Pour prouver qu

es les bandes et on les considreivement numrabli en recevant #w# a

age rcursif, cestuissantes que les m (K, , , s, {h}) etne machine de turi

ide un langage L2

ussi ; il suffit de fes langages rcursi

e nction de transitioonne : K x k

pes, il existe une tique qui nous inte cette machine n comme les pistes des lors M sarrte toujours et donne #Y# si w2 L

#N# sinon --dire dfini en utilisant des fonctions rcursives achines de Turing (et dont le mot a t emprunt).

M(w) = y o (s, #w#)M* (h, #y#). ng M tel que pour tout w2 *, M(w) = f(w).

* ssi M sarrte sur w ssi w2 L. Alors L est un aire une boucle infinie pour ne pas sarrter au lieu vement numrables qui ne sont pas rcursifs.

n de la machine tait : K x K x ( u {L, R}) K x ( u {L, R})k.

machine de turing 1 seule bande faisant la mme resse, pour isoler des parties en les mettant sur des est pas plus puissante que celle de base, on prend une grosse bande, en sauvegardant ltat courant.

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. c M avec m |K| (|| + 2) ,car 4KxxKx( u {L,R})

Bande avec piste piste

piste

Bande

avec k

c1 cm

00010000

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 - la 3me contient une chane de nombres

Tous les possibles Md

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 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 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 f-time 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 non-deterministic 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 rticales ? Il est facile de montrer que le problme est NP : on peut construire la machine de Turing associe anon-deterministic guess pour f ; tester que f0 est la ligne infrieure se fait en temps linaire ainsi tester les restrictions (4 voisins chaque fois). Rappel : pour tout p2NP on a une machine de turindterministe et polynomially time-bounded. Ce problme est NP complet. Prouvons quil est NP-hard, en montrant quil y a une rdpolynomiale des machine de Turing de tous les autres problmes NP vers une instance du bounded t 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

Longueur s

Tape 2 Tape 1

A chaque tape, on fab e une tape. Comme le dtapes est polynomial ounded, un jour on finarrter de rajouter. Le til est limit par une taille s,un polynme de la taille de lentre.

Tape s

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 connatreco v rs o pointe la tte. On dnote Po 2, on a : Pour tout (q, a, p, b)2, b2, on a : Pour tout (q, a, p, L)2, b2, on a les deux tiles : On a vu que f0 est quivalent #w#, soit la premire ligne :

# #

(#,s) #

wnwn

w1w1

# #

On va en b tte, on se dun cran ga

va en b avec le symbole p

Pour tout (q, a, p, R)2, b2, de mme.

a Lq

(a,q)

(b,p) Lq

b

(b,p) (a,q)

a a

(b,p) Rq

b

a Rq

(a,q)

Quand la machine veut sarrter et dire non, il ne faut pas quon continue de se propager : on fait udu 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 langabounded tiling. Construire un tile se fait en temps constant. Il y a || tiles a a ; pour chaque (q, aon a ||.||.2 (car il faut deux tiles), de mme pour (q, a, p, R), do un O(||.||) soit O(||) nomtiles comme la taille de lalphabet est fixe. Le nombre de tiles est linaire en la taille de lentrenous avons un polynme. Comme le Tiling System est calculable en temps linaire, il y a une rdpolynomiale et donc cest un problme NP-Complet. /vevec un que de g non-

uction iling.

nombre ira par qui est

ltat

urant et

ur tout ae par le tile actuellement point.

Quand on a le symbole a et quon est en q, alors on

Dans cet exemple, le tile point est le 3me

a a

a a

a (a,q)

a a riquly bing # #

avec la dplace uche

n arrt

ge du , p, L) bre de , donc uction

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. /Xmnd v /Xmnd pour tout d d, pour tout 0 m,n < s Il ny a pas deux tiles sur le mme carr

/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, 1 j n - Tout sommet doit tre visit : Xi1 v Xi2 x x Xin, 1 i n - 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.

S X'

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.

T

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 NP-complet 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. On a R2 = 1 U 2 U U m tel que i = i1i2...in, avec ij = 0 si Xj apparat dans Ci 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 NP-Completeness, Freeman, 1991. Call number QA 76.6 .G35 1991.