Rezolvari Subiecte 1, 2, 3

CALCULABILITATE SI COMPLEXITATE
Cuprins
Bibliografie ........................................................................................................................ 2
Introducere ....................................................................................................................... 4
1. Teza Church-Turing ..................................................................................................... 6
1.1. Maşina Turing (MT) ............................................................................................... 6
1.2. Maşini Turing cu mai multe benzi .........................................................................12
1.3. Maşini Turing nedeterministe ...............................................................................13
1.4. Echivalenţa modelelor de calculabilitate ...............................................................14
1.5. Algoritm: o definiţie...............................................................................................14
Rezumat ......................................................................................................................15
2. Decidabilitate ..............................................................................................................16
2.1. Probleme decidabile privind limbajele regulate .....................................................16
2.2. Probleme decidabile privind limbajele independente de context ...........................18
3. Nedecidabilitate: problema opririi ................................................................................21
3.1. Un limbaj care nu este Turing-decidabil (nu este recursiv) ...................................21
3.2. Un limbaj care nu este recunoscut de o maşină Turing (nu este recursiv
enumerabil) ..................................................................................................................23
3.3. Problema opririi ....................................................................................................24
3.4. Funcţii calculabile; reductibilitate funcţională ........................................................27
3.4.1. Funcţii calculabile ..........................................................................................27
3.4.2. Definiţia formală a reducerii funcţionale .........................................................27
Rezumat ......................................................................................................................29
4. Clasa de complexitate TIMP ......................................................................................30
4.1. Terminologie ........................................................................................................30
4.2. Notaţia asimptotică...............................................................................................31
4.3. Analiza algoritmilor ...............................................................................................33
4.4. Complexitatea modelelor de calculabilitate...........................................................35
4.5. Clasa P ...............................................................................................................39
4.5.1. Timpul polinomial ..........................................................................................39
4.5.2. Exemple de probleme cu timp de calcul polinomial .......................................41
4.6. Clasa NP .............................................................................................................42
4.6.1. Exemple de probleme cu timp de calcul polinomial nedeterminist .............45
4.7. Problema P versus NP ......................................................................................46
4.8. NP-completitudine ................................................................................................48
4.8.1. Importanţa fenomenului .................................................................................48
4.8.2. Un exemplu de problemă NP-completă .........................................................48
Rezumat ......................................................................................................................49
5. Clasa de complexitate SPATIU ..................................................................................50
5.1. Definiţii şi exemple introductive ............................................................................50
5.2. Teorema lui Savitch .............................................................................................52
5.3. Clasele PSPACE şi NPSPACE ............................................................................54
5.4. PSPACE-completitudine ......................................................................................56
5.4.1. Problema TQBF .............................................................................................56
5.4.2. Alte probleme PSPACE-complete ..................................................................57
5.5. Clasele L şi NL ..................................................................................................58
5.6. NL-completitudine ................................................................................................60
Rezumat ......................................................................................................................62
1
Bibliografie
1. Alfred AHO, John E HOPCROFT, Jeffrey D. ULLMAN: The Design and Analysis of
Computer Algorithms, Addison-Wesley Publ. Co., Reading Mass., 1974, II
24220, II 37734 (Cap.1: “Models of Computation: pp 2-35: Masini RAM şi
masini Turing; HORNER RULE: p. 21).
2. Walter S. BRAINERD, Lawrence H. LANDWEBER: Theory of Computation, John
Wiley & Sons Inc., New York, 1974, II 24912 (History, Representation of data,
Recursive functions, Markov algorithms, Formal languages, Complexity of
computation).
3. Cristian Sorin CALUDE: Complexitatea calculului; aspecte calitative, Editura
Stiinţifică şi Enciclopedica, Bucureşti, 1982 (cota??).
4. Cristian Sorin CALUDE: Theories of Computational Complexity, Elsevier Science
Publ., Amsterdam, 1988, II 34948.
5. Daniel I. A. COHEN: Introduction to Computation Theory, 2nd Ed., John Wiley & Sons
Inc., New York, 1997, II 39568 (Languages, Regular Expressions, Automata,
TM, Decidability).
6. Thomas H. CORMEN, Charles E. LEISERSON, Ronald L. RIVEST: Algorithms, MIT
Press, 1990-2000: 24 printings, II 39751 (notaţia O, , ; NP-completitudine).
7. Nigel J. CUTLAND: Computability: An Introduction to Recursive Function Theory,
Cambridge Univ. Press, Cambridge, 1986, II 37289 (Computable functions,
Church Thesis, s-m-n theorem, Universal programs, Decidability, Godel
arithmetic, Recursive sets, Complexity of computation – speed-up theorem).
8. Martin D. DAVIES, Elaine WEYUKER: Computability, Complexity, and Languages,
Academic Press, Orlando, Fl., 1983, II 33413 (TM, Primitive recursive
functions, Universal programs, Computations on strings, Grammars, Abstract
complexity, Polynomial time computability, P=NP, Unsolvability).
9. Peter J. DENNING, Jack B. DENNIS, Joseph E. QUALITZ: Machines, Languages
and Computation, Prentice Hall Inc. Englewood Cliffs, NJ, 1978, II 27675 (TM
universala, Teza lui Church, Unsolvable problems, Fctii recursive, Sisteme
Post).
10. Cristian GIUMALE: Introducere în analiza algoritmilor; Teorie şi aplicaţii, Editura
Polirom, Iaşi, 2004 II 40105 (notaţia O, , ; clase de complexitate, clase de
algoritmi).
11. Richard JOHNSONBAUGH, Marcus SCHAEFER: Algorithms, Pearson Prentice Hall,
Upper Saddle River, NJ., 2004, II 40112 (structuri d edate, metode de
programare, masuri de complexitate şi notatii de complexitate, P versus NP)
12. Carlos MARTĺN-VIDE, Victor MITRANA, Gheorghe PĂUN (Eds.): Formal
Languages and Applications, Springer-Verlag, Berlin Heidelberg, 2004, II
40157.
13. Christos H. PAPADIMITRIOU: Computational Complexity, Addison-Wesley Publ. Co.,
Reading Mass., 1994.
14. Gheorghe PĂUN, Grzegorz ROZENBERG, Aarto SALOMAA (Eds.): Current Trends
in Theoretical Computer Science, World Scientific Publ. Co., Singapore, 2001,
II 39698 (Computational complexity, Formal language theory).
15. Grzegorz ROZENBERG, Aarto SALOMAA (Eds.): Handbook of Formal Languages,
3 vols., Springer-Verlag, Berlin Heidelberg, 1997, II 39019 (vol. 1: Cap.1:
Formal languages: an introduction and a synopsis (history); Cap.2: Regular
languages; Cap.3: CFL and pushdown automata; vol. 2: Cap.1: Complexity: a
language-theoretic point of view; Cap.2: Parsing of CFL).
2
16. Michael SIPSER: Introduction to the Theory of Computation, PWS Publ. Co. –
International Thomson Publ. Inc., Boston, Ma., 1997.
17. Marius ZIMAND: Computational Complexity: A Quantitative Perspective, Elsevier
B.V., Amsterdam, 2004, II 40110 (Complexity classes gap and compression,
speed-up, P,NP,E 3-SAT, Quantum computation, Hard function, Optimization
problems minimization/maximization problems).
3
Introducere
Introducere1
Cursul îşi propune să răspundă la înterbarea:
CARE SUNT POSIBILITATILE SI LIMITELE ESENTIALE ALE CALCULATOARELOR?
Această întrebare datează din anii 1930, când logicienii şi matematicienii au început să
studieze obicetele matematice, în particular noţiunea de CALCULABILITATE. Progresele
tehnologice ulterioare au extins problema din sfera teoretică în cea practică.
Răspunsul la această intrebare îmbracă mai multe forme, în funcţie de domeniile în care
este împărţită teoria calculului:
a) automate;
b) calculabilitate propriu-zisă;
c) complexitate.
Vom examina aceste domenii în ordinea înversă enumerării pentru că examinând finalul
înţelegem mai bine motivaţia debutului.
Observaţie 1: terminologie
Probleme: (ne)rezolvabile;
Funcţii: (ne)calculabile;
Limbaje: (ne)decidabile.
c) Teoria complexităţii:
Problemele au grade variate de “dificultate”:
i) problema sortării: uşoară: orice calculator (slab) poate sorta destul de rapid mulţimi de
numere a căror cardinalitate este chiar de ordinul milioanelor;
ii) problema orarului: grea: chiar un supercalculator are nevoie de secole pentru a găsi o
planificare optimă pentru un număr de numai 1000 de cursuri.
CE FACE CA O PROBLEMA SA FIE USOR / DIFICIL DE REZOLVAT ?

Deşi în ultimii 30 de ani s-au desfăşurat cercetări susţinute, nu se cunoaşte încă
răspunsul la această întrebare, care este întrebarea esenţială în teoria complexităţii.
O realizare importantă în teora complexităţii a fost descoperirea unei scheme elegante

pentru clasificarea problemelor în funcţie de complexitatea lor computaţională, similară
tabelului periodic al elementelor datorat lui Mendeleev  putem aprecia – chiar dacă nu
putem demosntra – că o problemă este dificil de rezolvat încadrând-o într-o anumită
clasă2.
Un domeniu practic afectat direct de teoria complexităţii este cel al criptografiei. Este un
domeniu “ciudat” pentru că este interesat de probleme dificil de rezolvat (nu uşor şi “ieftin”
de calculat, ca majoritatea celorlalte domenii): noile coduri, dificil despart fără chei şi
parole secrete, au fost şi sunt proiectate tocmai pe baza problemelor dificil de rezolvat.
1 MS
2 O chestiune de metodică: Tratarea unei probleme dificile poate fi simplificată astfel:
(1) înţelegem (descoperim) aspectul care o face dificil de rezolvat şi – eventual – îl îndepărtăm sau
îl atenuăm;
(2) ne mulţumim cu o soluţie nu tocmai optimă (gsirea unei soluţii aproximative este adesea destul
de simplă);
(3) unele probleme sunt dificile numai în cazul cel mai nefavorabil, în rest fiind destul de simple;
uneori putem fi mulţumiţi cu astfel de soluţii;
(4) putem recurge la alte tipuri de calculabilitate, înafara celei deterministe (calculabilitate
nedeterministă, calculabilitate AND etc.)
4
Introducere
b) Teoria calculabilităţii
În prima jumătate a secolului XX, mai mulţi matematicieni precum Kurt Gödel, Alan
Turing, Alonzo Church (Stephen Kleene, Emile Post, N.N. Markov), au descoperit că
unele probleme FUNDAMENTALE NU pot fi rezolvate de către calculatoare: stabilirea
adevărului sau falsităţii unui enunţ matematic (nu există un algoritm care să dea acest
răspuns pentru orice enunţ matematic).
O consecinţă a acestui rezultat a fost dezvoltarea mai multor modele teoretice de

calculatoare (funcţiile general recursive, maşinile Turing, funcţiile -calculabile, sistemele
Post3, algoritmii normali Markov) care ar trebui să conducă la producerea unor
calculatoare reale mai performante.
Spre deosebire de teoria complexităţii, al cărei obiectiv este

uşor
clasificarea problemelor în de rezolvat
dificil
în teoria calculabilităţii, rezolvabile
clasificarea problemelor se face în probleme
nerezolvabile
 teria calculabilităţii introduce şi studiază o serie de concepte necesare în teoria
complexităţii.
a) Teoria automatelor
 se ocupă cu definiţiile şi proprietăţile modelelor matematice de calculabilitate:
 automatul finit (utilizat în procesarea textelor, scrierea compilatoarelor, proiectarea
hardware etc.)
 gramatica independentă de context (utilizată în limbajele de programare,
inteligenţa artificială etc.);
definiţii formale pentru conceptul de calculabilitate şi noţiunea de calcualtor;
 oferă
posibilitatea de a jongla cu acestea;
 introduce concepte relevante şi pentru alte domenii –neteoretice – ale informaticii.
 este un punct de plecare excelent pentru studierea teoriei calculabilităţii.
3
Emil Leon POST (1897 – 1954): matematician de origine poloneza, profesor la City College of
New York. În teza sa de doctorat, sustinuta în 1920, Post a demonstrat completitudinea şi
noncontradictia calculului cu propoziţii – descris de B. Russell şi A.N. Whitehead în „Principia
Mathematica” – folosind pentru prima dată metoda tabelelor de adevar. Este considerat părintele
teoriei demonstraţiei, un precursor al lui Kurt Gödel (prin lucrarile sale privind multimile recursiv
enumerabile, gradele de nedecidabilitate) şi John von Neumann (printr-un model matematic de
masina de calcul foarte asemanator celui descris de von Neumann în celebrul sau articol din
1946).
5
Teza Church-Turing
1. Teza Church-Turing4
Teoria complexităţii încearcă să demostreze ca anumite probleme sut mai complexe
decât altele. Termenul “complex” înseamnă aici cantitatea de resurse de calcul (in general
timp de lucru şi spaţiu de memorie, dar de multe ori şi alţi parametri) necesare pentru
rezolvarea respectivei probleme. Se pot defini clase sintetice de complexitate care pot fi
apoi populate cu probleme de calculabilitate bine cunoscute din lumea reală. Teoria
complexităţii se ocupă cu stabilirea şi demonstrarea relaţiilor existente între aceste clase
(de obicei, relaţii de incluziune, strictă sau estrictă). Astfel, dacă stabilim care este cea
mai mică clase din care face parte o problemă căpătăm implicit o serie întreagă de indicii
teoretice privind dificultatea practică de rezolvare a acelei probleme cu ajutorul
calculatorului.
Ce înţelegem însă printr-o problemă (de calcul)? Intuitiv vorbind, o problemă de calcul
este o problemă pe care încercăm să o rezolvăm cu ajutorul calculatorului (ca de
exemplu, căutarea într-o bază de date, găsirea tuturor drumurilor într-un graf etc.)
O întrebare mai relevantă este însă următoarea: ce este un calculator? Evident, este un
dispozitiv de calcul! Ce este atunci un calcul?! Un calcul este o secvenţă bine definită de
instrucţiuni realizate de un dispozitiv de calcul. Iată deci un cerc vicios!! Vom ieşi din acest
cerc vicios dacă vom defini mai întâi riguros noţiunea de sistem de calcul şi apoi pe cea
de problemă de calcul drept un “obiect” care poate fi rezolvat cu ajutorul sistemului de
calcul într-un intreval finit de timp. Vom arăta, că în anumite ipoteze, acest model abstract
de calcultor pe care l-am definit este la fel de puternic precum un calculator real.
1.1. Maşina Turing (MT)

O mulţime finită oarecare se numeşte alfabet. O secvenţă finită (ordoată) de elemente din
 se numeşte cuvânt peste alfabetul . Mulţimea tuturor cuvintelor peste alfabetul  se
notează cu *. Cuvântul vid se notează cu . Numărul de simboluri din cuvântul *
(numărându-se si repetiţiile) se numeşte lungime a cuvântului si se notează cu ||.
Evident, || = 0.
Se numeşte limbaj peste  orice submulţime L  *. Pentru a trata limbajele trebuie să
dispunem de reprezentări finite ale acestora:
 dacă L  * este finit, atunci putem enumera pur şi simplu elementele sale;
 dacă L  * este infinit, atunci avem nevoie de mecanisme speciale de reprezentare:
gramaticile regulate, gramaticile independente de context, gramaticile dependente de
context, gramaticile fără restricţii descriu clase de limbaje din ce în ce mai bogate. Aceste
clase de limbaje pot fi reprezentate şi cu ajutorul unor dispozitive de calcul precum
automatele finite, automatele pushdown, respectiv maşinile Turing.
Odată ce dispunem de o astfel de reprezentare finită a unui limbaj L  * apare o nouă

întrebare:
dându-se un cuvânt oarecare *, putem decide dacă L sau nu?
Această problemă se numeşte problema apartenenţei (language membership problem)

şi este problema esenţială a teoriei calculului. Este o problemă de decizie, răspunsul fiind
de tip “da” sau “nu”.
4
CP
6
Teza Church-Turing
Multe dintre cele mai interesante probleme pe care încercăm să le rezolvăm cu ajutorul
calculatoarelor pot fi reformulate în termenii problemei apartenenţei la un limbaj, dar NU
TOATE! Această metodă de transformare a unei probleme de calculabilitate într-o
problemă de apartenenţă la un limbaj, este general acceptată şi a rezistat foarte bine
testului timpului, deşi – în fond – ea relevă incapacitatea noastră de a găsi o reprezentare
mai bună a problemelor.
Observaţiile de mai sus indică faptul că putem da reprezentări finite numai pentru
limbajele infinite dar numărabile. Ori, mulţimea tuturor limbajelor este nenumărabilă
(demonstraţia recurge la metoda diagonalizării).
 există mult mai multe limbaje decât cele pe care le pot recunoaşte dispozitivele de
calcul de care dispunem.
O MT are o unitate de control finită (într-un moment oarecare de timp poate fi în una din
stările qQ, unde Q este o mulţime finită, numită mulţimea stărilor MT). Mai conţine şi o
bandă de intrare sau de lucru, care este infinită în ambele direcţii şi împărţită în celule
(finite). Fiecare celulă poate conţine un simbol dintr-o mulţime finită de simboluri, numită
alfabetul benzii şi notată cu . Unitatea de control dispune şi de un cap de citire/scriere,
numit şi cursor, care poate scana (citi) şi scrie simboluri în celulele benzii. Atunci când MT
începe să lucreze ea se află în următoarea configuraţie:
 secvenţa (cuvântul) de intrare (peste un alfabet oarecare ) este scris pe bandă;
toate celelalte celule ale benzii conţin un simbol special, simbolul blank, notat cu  . Se
presupune că    şi că ;
 cursorul este poziţionat este poziţionat în dreptul primului simbol din stânga al
cuvântului de intrare;
 unitatea de control se află într-o stare specială, numită starea iniţială (sau de start) şi
notată de obicei cu q0
Ulterior, MT intră într-o secvenţă constând din următorii paşi: cursorul scanează simbolul
a aflat în celula curentă a benzii; în funcţie de acest simbol a şi de starea curentă a
unităţii de control q  Q , MT efectuează tranziţia (q,a) = (p,b,D), unde:
 p  Q este noua stare a unităţii de control (în unele cazuri: p = q);
 cursorul scrie simbolul b peste simbolul a din celula curentă (în unele cazuri: b = a);
 cursorul de deplasează în dreptul următoarei celule de pe bandă, aflată fie la drepta
(D= R) fie la stânga (D = L) celulei prelucrate.
Q conţine o submulţime specială de stări, F  Q , numită mulţimea stărilor finale;

distingem stările finale de acceptare (MT acceptă cuvântul de intrare şi se opreşte) de
cele de respingere (MT respinge cuvântul de intrare şi se opreşte) . MT poate, de
asemenea, pentru anumite cuvinte de intrare, intra intr-un ciclu infinit (nu ajunge niciodată
nici într-o stare de acceptare nici în una de respingere). Spunem că MT ciclează.
1.1 Definiţie.
O MT este un sistem ( , , Q q0, F, ) unde:
 este o mulţime finită, numită alfabet de intrare;
 este o mulţime finită, numită alfabetul benzii;   ,    şi    ;
Q este o mulţime finită, numită mulţimea stărilor MT;
q0  Q se numeste stare iniţială;
F  Q se numeşte mulţimea stărilor finale (de acceptare sau de respingere);
: Q x   Q x  x { L , R } se numeşte funcţie de tranziţie.
7
Teza Church-Turing
Limbajul acceptat de o MT M este mulţimea

L(M) = {   * | M acceptă cuvântul de intrare  şi se opreşte}
Spunem că5
 limbajul este recunoscut de MT M (sau este recursiv enumerabil);
 M este o MT acceptoare.
1.2. Observaţie. O MT poate eşua asupra unui cuvânt de intrare dacă:

 intră intr-o stare finală de respingere, sau
 intră într-o ciclare infinită (ceea ce nu înseamnă neapărat repetarea nedefinită a
aceleiaşi secvenţe de paşi ci o comportare mai mult sau mai puţin complexă care însă nu
duce niciodată în una dintre stările finale – de accepatre sau de respingere - )
 pot apărea situaţii în care MT calculează un timp mai îndelungat fără a produce un
rezultat şi totusi nu se poate decide daca acest fapt indică intrarea în ciclare sau, pur şi
simplu, un calcul foarte complicat care cere mult timp.
 e preferabil să lucrăm cu MT care, pentru orice cuvânt de intrare, se opresc (nu
ciclează niciodată). Aceste MT se numesc decidente iar limbajele recunoscute de ele se
Turing-decidabile sau recursive.
1.3. Observaţie.
Orice limbaj Turing-decidabil (recursiv) este şi recunsocut de o MT (recursiv enumerabil).
Reciproca nu este adevărată: există limbaje recunoscute de MT (recursiv enumerabile)
care nu sunt Turing-decidabile(recursive).
1.4. Exemplu6.
Construim MT M care care acceptă palindroame şi numai palindroame peste alfabetul
binar  = {0,1}. Luăm  = {0,1,  } şi Q = (s, p1, p2, p3, q1, q2, q3, r1, r2, r3}, unde s = starea
iniţială şi { r1, r2, r3, p3, q3} = F. Funcţia de tranziţie este dată în Figura 1.1.
Informal, M citeşte simbolul din extremitatea stângă, îl memorează, îl şterge şi apoi
încearcă să găsească acelaşi simbol în extremitatea dreaptă a cuvântului de intrare. Dacă
intrarea este un palindrom a cărui lungime este un număr par, atunci M ajunge la un
moment dat în starea finală de acceptare r1; dacă intrarea este un palindrom a cărui
lungime este un număr impar, atunci M ajunge la un moment dat fie în starea finală de
acceptare r2 fie în starea finală de acceptare r3 . În fine, dacă intrarea nu este un
palindrom, M stabileşte acest lucrusi intră fie în starea p3 fie în q3, oprindu-se respingând.
Prin urmare, M este o MT decidentă.
Să examinăm numărul de paşi elementari (tranziţii) executaţi de M pentru un cuvânt de

intrare de lungime n. Identificarea fiecărei perechi de simboluri exterme identice necesită
o parcurgere completă de la stânga la dreapta şi o parcurgere completă de la dreapta la
stânga a porţiunii rămase din cuvântul de intrare (după eliminarea simbolului extrem
stâng). Prin urmare, numărul maxim de paşi este de cel mult
2 ( n + (n - 2) + (n - 4) + …) = 2 (n(n+1)/4) = n(n+1)/2 adică O(n2).
Observăm, de asemenea, că M utilizează o singură celulă auxiliară aflată la dreapta
cuvântului de intrare.
 stabilirea caracterului de palindrom pentru o secvenţă binară este o problemă “uşoară”.
5
MS
6
CP
8
Teza Church-Turing
Figura 1.1. O MT care acceptă palindroame şi numai palindroame binare
1.5. Exemplu.
O MT poate fi folosită şi pentru “a face ceva”, adică pentru a calcula o funcţie f : *  *.
Aceasta înseamnă că dacă  este cuvântul de intrare atunci MT se opreşte având f() (şi
nimic altceva) pe banda sa de intrare. Să luăm, de exemplu, o MT N care primeşte la
intrare cuvântul  şi se opreşte după ce a calculat  + 1 pe banda sa. Aici, secvenţele
binare sunt identificate cu întregi nenegativi în modul natural, dat de conversia din baza
de numeraţie 10 în baza 2. Figura 1.2. defineşte diagrama tranziţiilor lui N. NU este
indicată nici o stare finală deoarece MT nu este proiectată pentru a accepta un limbaj în
sensul convenţiilor de mai sus. Timpul de execuţie necesar pentru calcularea succesorului
pentru o secvenţă binară de lungime n este O(n).
0/0R
1/1R 1/1L
/L 0/1L
/1L
Figura 1.2: O maşină Turing care calculează succesorul unui număr natural
9
Teza Church-Turing
Următoarea întrebare este: cât de robust şi de general este acest model de

calculabilitate? Observăm imediat câteva îmbunătăţiri ale modelului de bază: de exemplu,
 putem permite, pe lângă deplasarea cursorului la dreapta/stânga cu o celulă şi
rămânerea pe loc a cursorului;
 putem adăuga una sau mai multe benzi (finite şi / sau infinite), fiecare având asociat
propriul său cursor;
 putem înzestra înzestra fiecare bandă cu mai multe cursoare;
 putem considera benzi multidimensioanle;
 putem considera benzi cu mai multe piste;
 putem înzestra unitatea de control cu o memorie finită (unul sau mai mulţi registri);
Se poate demonstra că toate aceste variante de MT pot fi simulate cu o MT clasică,
având însă un timp de lucru mai mare – dar de acelaşi ordin – decât MT simulată (de
exemplu, ordinul polinomului poate fi mai mare pentru MT clasică decât pentru MT
simulată). Această observaţie este esenţială pentru o definiţie coerentă a claselor de
complexitate.
În fine, care este relaţia unei MT cu un calculator real?

Un calculator dispune de o memorie cu acces direct, în timp ce
memoria unei MT (banda ei de lucru) este scanată întotdeauna secvenţial (nu este permis
nici un fel de salt). Prin scanări repetate şi marcarea simbolurilor prelucrate, putem simula
însă accesul direct la simbolurile de pe banda MT.
O7 MT poate fi privită şi ca un limbaj de programare (foarte slab şi primitiv dar capabil
totuşi să programeze orice algoritm):
 dispune de o structură de date (unică): stringul;
 dispune de un set redus de instrucţiuni (de calcul şi de test):
o deplasarea cursorului la dreapta;
o deplasarea cursorului la stânga;
o citirea simbolului din celula curentă;
o scrierea unui simbol peste simbolul din celula curentă;
o alegerea uneia dintre operaţiile de mai sus în funcţie de simbolul citit în celula
curentă;
 există variante de MT (numite enumeratoare) care, pe lângă banda de intrare, dispun
şi de o “imprimantă” ca dispozitiv de ieşire.
1.6. Observaţie importantă

În continuare, vom lucra în următoarele ipoteze:
 mulţimea F  Q a stărilor finale conţine o singură stare de acceaptare, notată qa, şi o
singură stare de respingere, notată qr;
 ne vom concentra asupra algoritmilor, MT rămânând doar un model de calculabilitate
suficient de puternic şi de formalizat pentru noţiunea intuitivă de algoritm.
O MT poate fi descrisă în trei moduri:

 descrierea formală (nivelul inferior şi cel mai detaliat): sunt date complet Q, , , .
 descrierea implementării MT: se utilizează limba naturală pentru a defini modul în care
se deplasează cursorul şi modul de memorare a informaţiei pe banda de lucru.
 descrierea de nivel înalt: se utilizează limba naturală pentru a descrie un algoritm,
ignorând complet modul de implementare a acestuia (la acest nivel, nu mai trebuie să
indicăm explicit modul în care MT îşi utilizează banda de lucru sau cursorul).
Datele de intrare pentru o MT constau întotdeauna dintr-o secvenţă de simboluri. Dacă

intrarea trebuie să fie însă un obiect (un graf, un polinom, un automat, o combinaţie a
acestora), atunci va trebui mai întâi să-l reprezentăm printr-o secvenţă (cum codificările
7
MS
10
Teza Church-Turing
alternative pot fi decodificate una în alta de către o MT, putem alaege orice codifcare
pentru obiectul de intrare; în plus, MT poate fi programată să decodifice reprezentarea
astfel încât aceasta să poată fi interpretrată în modul dorit de noi). Vom nota:
 un singur obiect O, codificat printr-o secvenţă, prin <O>;
 mai multe obiecte O1,O2,…,On, codifcate printr-o unică secvenţă, prin <O1,O2,…,On>
Vom descrie algoritmii implementaţi prin MT printr-un text inclus între ghilimele:
 prima linie a textului va descrie datele de intrare; dacă intrarea este
 o secvenţă de simboluri w , ea este interpretată ca un cuvânt şi notată cu w;
 codificarea unui obiect <O> , atunci MT începe automat cu verificarea corectitudinii
acestei codifcări: dacă respectiva codificare nu respectă convenţiile stabilite, MT
respinge intrarea <O>.
 algoritmul este împărţit în etape, fiecare etapă constând din mai mulţi paşi de calcul;
atât etapele cât şi paşii sunt numerotaţi iar structura de bloc este semnalată prin
indentare.
1.7. Un exemplu
Fie A limbajul care constă din toate secvenţele care reprezintă grafuri conexe 
A = { <G> | G graf conex, neorientat }
Dăm o descriere de nivel înalt pentru MT, M, care decide asupra limbajului A.
M = “Fie intrarea <G>, adică o codificare a grafului conex, neorientat G:
1. Se selectează primul nod din G şi se marchează.
2. Se reia pasul următor până când nu se mai pot marca noi noduri:
3. Fie un nod oarecare din G: dacă el este legat printr-o muchie de un nod deja
marcat, atunci nodul trebuie marcat şi el.
4. Se scanează toate nodurile din G pentru a determina dacă sunt sau nu marcate
toate. Dacă sunt toate marcate, atunci M acceptă <G>, altfel respinge.”
Explicităm numai modul de codificare (şi verificare a codificării) pentru un graful G de mai
jos:
1 4
2 3
 <G> = ((1,2,3,4) ; ((1,2) , (1,3) , (1,4) , (2.3)))

 <G> constă dintr-o listă de noduri şi o listă de arce; prima listă conţine numere în baza
10 iar a doua listă conţine perechi de numere în baza 10.
MT începe prin a verifica această codificare: scanează banda de intrare pentru a verifica:
 existenţa a două liste;
 prima listă să conţină numere distincte;
 a doua listă să conţină perechi de numere, luate exclusiv din prima listă şi tot fără
repetiţii.
Dacă testul se încheie cu succes (codificarea este corectă) atunci MT trece la prima etapă
a algoritmului.
11
Teza Church-Turing
1.2. Maşini Turing cu mai multe benzi

1.8. Definiţie
O MT cu mai multe benzi este o MT standard care
(i) are n  1 benzi de intraresi n cursoare, corespunzătoare;
(ii) iniţial, cuvânt de intrare se află pe prima bandă iar celelalte n - 1 benzi sunt vide;
(iii) funcţia de tranziţie este modificată pentru a permite tuturor cursoarelor sa citească, să
scrie şi să se deplaseze pe banda respectivă:
 : Q x  n  Q x  n x {L,R}n unde:
(qi,a1, a2, …, an) = (qj,b1, b2, …, bn, L, R, L, … ,R)
adică: MT se află în starea qi şi cursorul k, 1  k  n, citeşte pe banda k în celula curentă
simbolul ak; în consecinţă, MT trece în starea qj iar cursorul k scrie pe banda k în celula
curentă simbolul bk după care se deplasează fie la dreapta fie la stânga, conform definiţiei
lui .
Aparent, mai puternice, aceste MT pot fi simulate cu MT standard:
1.9. Teoremă
Pentru oricare MT cu mai multe benzi se poate construi o MT echivalentă.
Demonstraţie
Fie o MT M cu mai multe benzi şi o MT S cu o singură bandă de intrare; vom simula M cu
ajutorul lui S, memorând informaţia de pe cele n benzi ale M pe singura bandă a lui S.
În acest scop, folosim:

 un simbol adiţional, #, ca delimitator, pentru a separa pe unica bandă a lui S, cele n
cuvânte de intrare de pe cele n benzi ale M;
 câte un nou simbol pentru fiecare simbol din  , pentru a simula poziţia cursorului
corespunzător (adică, pentru fiecare simbol    adăugăm un simbol   
 S devine o MT cu mai multe benzi şi cursoare virtuale.
Fie cuvânt de intrare w = w1w2…wn; S calculează astfel:

1. S îşi reformatează banda de intrare pentru a reprezenta cele n benzi ale M, la
momentul iniţial;
# w1w2…wn#  #  # …#
10 bandă a 2a bandă a 3a bandă ….
2. Pentru a simula o singură mişcare (simultană) a celor n cursoare ale M, S scanează

unica sa bandă de la primul delimitator # (care marchează extremitatea stângă a
benzii) până la cel de-al (n+1)lea delimitator # (care marchează extremitatea dreaptă a
benzii) în scopul de a determina simbolurile aflate în dreptul cursoarelor virtuale. Apoi,
S mai face o parcurgere pentru a actualiza benzile virtuale conform definiţiei funcţiei
de tranziţie a lui M;
3. Dacă, într-un moment oarecare, S deplasează unul dintre cursoarele virtuale la
dreapta unui delimitator #, aceasta înseamnă că M a mutat cursorul (real)
corespunzător peste porţiunea vidă a benzii (reale) respective. Ca urmare, S:
 depune simbolul special  în celula respectivă de pe unica sa bandă,
 deplasează conţinutul benzii sale, de la acea celulă până la cel mai din dreapta
delimitator #, cu o celulă la dreapta.
Apoi, continuă simularea ca mai sus. q.e.d.
12
Teza Church-Turing
1.10. Corolar
Limbajul L este recunoscut de o MT  există o MT cu mai multe benzi care îl recunoşte.
Demonstraţie “”
Este imediată: orice MT standard este o MT cu mai multe benzi trivială (n = 1).
““
Fie M o MT cu mai multe benzi care recunoaşte limbajul L; conform Teoremei 1.9, există
o MT standard S echivalentă cu M  S recunoaşte limbajul L  q.e.d.
1.3. Maşini Turing nedeterministe

O MT nedeterministă este definită într-un mod asemănător cu automatele finite şi
pushdown nedeterministe: în fiecare moment al calculului, MT poate alege între mai multe
posibilităţi de continuare. 
: Q x   P (Q x  x { L , R }).
1.11. Teoremă
Pentru oricare MT nedeterministă se poate construi o MT deterministă echivalentă.
Demonstraţie
Fie N o MT nedeterminsită; este suficient să construim o MT D cu trei benzi care să o
simuleze deoarece, conform Teoremei 1.4, vom putea apoi să construim o MT standard
care să o simuleze pe D.
Cele 3 benzi ale MT D sunt definite astfel:

 banda 1: conţine permanent cuvântul de intrare şi nu este niciodată modificată pe
parcursul calculului;
 banda 2: păstrează un duplicat al benzii de intrare a lui N, corespunzător unei ramuri
de calcul nedeterminist;
 banda 3: ţine evidenţa poziţiei - din arborele asociat lui N – în care se află D. Mai
exact:
o fiecare nod din arborele de calcul (derivare) al N poate avea maximum b copíi,
unde b = cel mai mare număr de posibilităţi de alegere date de funcţia de tranziţie;
o fiecărui nod din arbore îi asociem o adresă, adică un cuvânt peste alfabetul
b = {1, 2, …, b}
(de exemplu, asociem adresa 231 nodului la care ajungem plecând din rădăcină
către al doilea ei fiu, apoi la al treilea fiu al fiului rădăcinii (nepot!) şi, în fine, la
primul fiu al acestuia (strănepot!)
 banda a treia conţine un cuvânt peste alfabetul b = {1, 2, …, b}; unele cuvinte
reprezintă ramuri ale calcului nedeterminist efectuat de N de la rădăcină la frunza
cu adresa respectivă; alte cuvinte (apar toate cuvintele din b, în ordine
lexicografică) reprezintă adrese nevalide pentru că sunt prea scurte (nu ajung la
frunze) sau prea lungi (cicluri etc.).
o în fine, rădăcina arborelui are ca adresă cuvântul vid.
Acum putem descrie D, după cum urmează:
P1: Iniţial, banda 1 conţine cuvânt de intrare w , iar benzile 2 şi 3 sunt vide.
P2. Se copiază conţinutul benzii 1 pe banda 2.
P3. Se utilizează banda 2 pentru a simula una dintre ramurile calcului nedeterminist
efectuat de N pentru intrarea w.
Înainte ca N să efectueze fiecare pas, trebuie examinat simbolul curent (următor) de
pe banda 3 pentru a determina care dintre variantele furnizate de funcţia de tranziţie
a lui N trebuie aleasă. Dacă pe banda 3 nu mai există simboluri sau dacă această
alegere nedeterministă nu este validă, se abandonează această ramură trecând
direct la Pasul 4.
13
Teza Church-Turing
Dacă s-a intrat într-o configuraţie de respingere, se merge tot la Pasul 4.

Dacă s-a intrat într-o configuraţie de acceptare, se recunoaşte intrarea w şi STOP.
P4. Se înlocuieşte secvenţa de pe banda 3 cu următorul cuvânt peste b, în ordine
lexicografică. Se simulează următoarea ramură de calcul al N reluând de la Pasul 2.
1.12. Corolar
Un limbaj L este recunoscut de o MT  există o MT nedeterministă care îl recunoaşte.
Este imediată: orice MT standard este o MT nedeterministă trivială.
““
Fie N o MT nedeterministă care recunoaşte limbajul L; conform Teoremei 1.11, există o
MT standard S echivalentă cu N  S recunoaşte limbajul L  q.e.d.
1.13. Corolar
Un limbaj L  * este decidabil  există o MT nedeterministă decidentă care decide
asupra limbajului L.
1.4. Echivalenţa modelelor de calculabilitate

Am definit mai multe variante de MT şi am demosntrat echivalenţa lor (am arătat că
recunosc aceeaşi clasă de limbaje).
Există şi alte modele de calculabilitate: funcţiile general recursive, funcţiile -calculabile,

sistemele Post, algoritmii normali Markov. Toate au aceeaşi caracteristică: acces
nerestricţionat la o memorie nelimitată, ceea ce le deosebeşte de alte modele (AFD,
APD) mai slabe. În plus, toate sunt echivalente cu MT (şi deci unele cu altele)
 în ciuda inerentului grad de arbitrariu pe care îl au toate aceste modele de
calculabilitate, clasa algoritmilor pe care o descriu (MT) este unică şi naturală.
1.5. Algoritm: o definiţie

Algoritmii au o istorie lungă în matematică (găsirea numerelor prime, a cmmdc etc.) dar
noţiunea însăşi nu a căpătat (încă) o definiţie matematică precisă, lucru esenţial pentru
rezolvarea unor probleme importante, care au – de cele mai multe ori – conotaţii filosofice.
Se operează însă cu noţiunea intuitivă de algoritm, se folosesc descrieri, proprietăţi etc.
Problema a 10a a lui Hilbert

La Congresul Internaţional al matematicienilor care a avut loc în 1900 la Paris,
matematicianul german David HILBERT a ţinut o conferinţă devenită celebră.In această
conferinţă, Hilbert a identificat 23 de probleme pe care le-a considerat ca o provocare
pentru matematicienii secolului XX. A 10a problemă implica noţiunea – neformalizată – de
algoritm:
să se găsească un algoritm care să verifice dacă un

polinom în oricâte variabile admite o rădăcină în Z.
1.14. Observaţii.
1. David Hilbert nu a folosit termenul de algoritm ci: “… un proces cu ajutorul căruia,
după un număr finit de operaţii, să se determine ….”
2. Formularea problemei indică faptul ca Hilbert presupunea că algoritmul există
sitrebuie doar descoperit.
3. Noţiunea intuitivă, neformalizată, de algoritm cu care operau matematicienii la
începutul secolului XX le permitea să găsească algoritmi pentru anumite sarcini
14
Teza Church-Turing
particulare – când existau – dar nu să demonstreze că un astfel de algoritm există în

cazul general.
Un progres esenţial în această direcţie a fost făcut de Alonzo Church şi Alan Turing, prin
lucrările publicate în 1936 şi în care Church a dezvoltat -calculul iar Turing maşina care îi
va purta numele, totul în scopul de a defini noţiunea de algoritm.
S-a demonstrat că aceste două definiţii sunt echivalente. Legătura dintre aceste două
definiţii formale şi noţiunea intuitivă de algoritm poartă numele de TEZA CHURCH-
TURING:
Clasa algoritmilor intuitiv calculabili coincide cu

clasa algoritmilor Turing sau Church calculabili.
Este o teză şi nu o teoremă pentru că un membru al echivalenţei nu este definit riguros.
Totuşi, teza Chirch Turing a furnizat o definiţie pentru noţiunea de algoritm suficientă (şi
necesară) pentru a rezolva Problema a 10a a lui Hilbert. În 1970, Yuri MATIJASEVIČ,
bazându-se pe rezultate anterioare datorate lui Martin DAVIS, Hilary PUTNAM, Julia
ROBINSON, arată că nu există nici un algoritm care să verifice dacă un polinom în oricâte
variabile admite o rădăcină în Z ( .Problema a 10a alui Hilbert este nerezolvabilă
algoritmic.)
Rezumat
15
Decidabilitate
2. Decidabilitate
Este util să explorăm limitele rezolvabilităţii algoritmice, adică s9 studiem problemele
nerezolvabile algoritmic pentru că dacă ştim ca o problemă este nerezolvabilă algoritmic
atunci:
 putem alege între a o simplifica sau a o modifica, după care putem încerca din nou
să o rezolvăm;
 putem demonstra că şi alte probleme sunt nerezolvabile algoritmic, arătând
echivalenţa lor cu o problemă ştiută ca nerezolvabilă algoritmic.
2.1. Probleme decidabile privind limbajele regulate

Vom demonstra rezolvabilitatea algoritmică a următoarelor probleme privind limbajele
regulate:
 un automat finit determinist (AFD) acceptă sau nu o secvenţă oarecare?
 limbajul acceptat de un AFD este sau nu vid?
 sunt două AFD oarecare echivalente (recunosc acelaşi limbaj)?
Vom reprezenta problemele computaţionale cu ajutorul limbajelor întrucât am dezvoltat

deja un întreg formalism pentru ele.
De exemplu, PROBLEMA ACCEPTABILITATII pentru AFD este:

“se poate decide algoritmic dacă un AFD oarecare acceptă o secvenţă oarecare”.
Ea poate fi exprimată cu ajutorul limbajelor astfel:
ACCAFD = { <A,w> | A este un AFD care acceptă secvenţa w }
Acest limbaj constă din codificările tuturor AFD şi ale tuturor secvenţelor w acceptate de
acestea. Problema testării faptului că automatul finit determinist A acceptă cuvântul de
intrare w este echivalentă cu problema testării aparteneţei secvenţei <A,w> la limbajul
ACCAFD .
 a demonstra că o problemă de calculabilitate este rezolvabilă algoritmic (decidabilă)
este echivalent cu a demonstra că un limbaj (asociat) este decidabil.
2.1. Teoremă
Limbajul ACCAFD = { <A,w> | A este un AFD care acceptă secvenţa w } este decidabil.
Demonstraţie
E suficient să construim o MT care să decidă asupra limbajului ACCAFD. Fie MT M
definită astfel:
M = “Fie secvenţa de intrare <A,w>, unde A este un AFD oarecare iar w  *:
1. Se simulează calculul efectuat de A asupra cuvântului de intrare w.
2. Dacă simularea se încheie în starea qa atunci M acceptă secvenţa de intrare <A,w>;
dacă simularea se încheie în altă stare atunci M respinge.”
 Conform convenţiilor de terminologie din Capitolul 1, M începe prin a verifica gradul de
corectitudine al codificării <A,w> (o reprezentare rezonabilă a AFD A constă din lista
celor cinci elemente din definiţia sa: Q, , , q0, F). Dacă <A,w> nu codifică corect AFD A
şi cuvântul w  * atunci M respinge secvenţa <A,w>.
 Altfel, M continuă simularea: ţine evidenţa stării curente a A şi a poziţiei cursorului
peste cuvântul w , scriind această informaţie pe propria sa bandă de lucru
o iniţial, starea curentă alui A este q0 iar cursorul este poziţionat în dreptul simbolului
din extremitatea stângă a cuvântului w;
o ulterior, starea automatului A şi poziţia cursorului sunt actualizate conform funcţiei de
tranziţie );
16
Decidabilitate
 când M încheie procesarea ultimului simbol din w, M acceptă sau respinge secvenţa
de intrare <A,w> după cum automatul A ajunge în una dintre stările sale finale de
acceptare sau într-o stare finală care nu este de acceptare. q.e.d..
2.2. Teoremă
Limbajul ACCAFN = { <A,w> | A este un AFN care acceptă secvenţa w } este decidabil.
Demonstraţie
Construim o MT N care să decidă asupra limbajului ACCAFN
Putem construi N ca in Teorema 2.1, adică N să simuleze un automat finit

nedeterminist în loc de un automat finit determinist. Preferăm însă să construim N astfel
încât aceasta să utilizeze MT M de mai sus ca o subrutină.
 întrucât M a fost construită ca să lucreze cu automate finite deterministe, N va trebui
să convertească AFN primit prin secvenţa de intrare <A,w> într-un AFD înainte de a-l
transmite lui M ca parametru de intrare.
Fie MT N definită astfel:

N = “Fie secvenţa de intrare <A,w>, unde A este un AFN oarecare iar w  *:
1. Se converteşte automatul finit nedeterminist A într-un AFD echivalent, B , cu
ajutorul procedurii din teorema care demonstreaza echivalenţa dintre AFD şi AFN.
2. Se rulează MT M descrisă în Teorema 2.1 pentru secvenţa de intrare <B,w>.
3. Dacă M acceptă secvenţa de intrare <B,w> atunci N acceptă secvenţa de intrare
<A,w>, altfel respinge.”
Observăm că rularea MT M în etapa a doua revine la incorporarea M în descrierea lui

N ca o subprocedură. q.e.d..
2.3. Teoremă
Limbajul EMPAFD = { <A> | A este un AFD şi L(A) =  } este decidabil.
Demonstraţie
Dacă în teoremele anterioare trebuia să verificăm dacă un automat acceptă sau nu un
anumit cuvânt de intrare, acum trebuie să verificăm dacă un automat acceptă măcar un
cuvânt sau nu. Aceasta este PROBLEMA LIMBAJULUI VID (pentru AFD).
În acest scop, reamintim că unui AFD îi putem asocia un arbore de derivare care să
descrie toate derivările posibile pornind de la starea iniţială (luată ca etichetă a rădăcinii).
Unele derivări au ca frunze stări finale, ceea ce înseamnă că secvenţele cu care sunt
etichetate trebuie acceptate, altele nu (secvenţele lor trebuie respinse)
 vom testa faptul că, navigând de-a lungul unei anumite ramuri de calcul din arborele de
derivare asociat AFD, ajungem într-o stare de acceptare.
 vom construi o MT V care va folosi un algoritm de marcarea stărilor prin care trece
AFD.
V = “ Fie secvenţa de intrare <A>, unde A este un AFD oarecare:

1. Se marchează starea iniţială a lui A.
2. Se reia Pasul 3 până când nu mai există stări nemarcate:
3. Se marchează orice stare în care intră o săgeată (o tranziţie) care pleacă dintr-o
stare deja marcată.
4. Dacă nici una dintre stările finale de acceptare nu este marcată, atunci V acceptă
<A>, altfel respinge. q.e.d..
17
Decidabilitate
2.4. Teoremă
Limbajul EQVAFD = { <A,B> | A şi B sunt AFD şi L(A) = L(B) } este decidabil.
Demonstraţie
Această problemă este cunoscută drept PROBLEMA ECHIVALENTEI (pentru AFD).
Vom folosi Teorema 2.3: EMPAFD este decidabil.

Vom construi un nou AFD C , pornind de la A şi B, cu proprietatea că C acceptă
numai acele cuvinte care sunt acceptate fie de A fie de B dar nu de ambele, adică:
L(C ) ( L( A)  L ( B ))  ( L ( A )  L( B))
observăm că L(C) este regulat (multimea limbajelor regulate este inchisă la reuniune,
intersecţie, complementară – precum şi la concatenare şi operaţia *). În plus, operaţiile de
reuniune, intersecţie şi complementară cu limbaje regulate pot fi realizate cu MT
Observăm că dacă A şi B acceptă acelaşi limbaj înseamnă că C nu acceptă nimic
(L(C)este vid).
 vom construi o MT E care să obţină automatul C din A şi B simulând operaţiile de
reuniune, intersecţie, complementară şi apoi vom aplica Teorema 2.3 pentru a verifica
dacă L( C) =  ; în caz afirmativ, înseamnă ca L(A) = L(B).
E = “ Fie secvenţa de intrare <A,B>, unde A şi B sunt automate finite deterministe:

1. Se construieşte automatul finit determinist C conform observaţiei de mai sus.
2. Se rulează MT V construită în demonstraţia Teoremei 2.3, pe intrarea <C>.
3. Dacă V acceptă intrarea <C> atunci E acceptă intrarea <A,B>; altfel, respinge.
q.e.d..
2.2. Probleme decidabile privind limbajele independente de

context
Analizăm cele trei probleme descrise mai sus dar acum pentru limbajele independe de
context.
2.5. Teoremă
Limbajul
ACCGIC = { <G,w> | G este o gramatică independentă de context care generează w }
este decidabil.
Demonstraţie
Fie G o gramatică independentă de context şi un cuvânt oarecare w  *; pentru a verifica
dacă G generează w putem proceda în două moduri:
 utilizăm arborele de derivare asociat lui G şi examinăm toate derivările pentru a o
găsi pe cea care produce secvenţa w ( ar trebui să exeminăm un număr infinit de
derivări; în plus, dacă G nu generează w , acest algoritm nu se opreşte niciodată 
obţinem o MT acceptoare pentru ACCGIC nu decidentă);
 aplicăm aceeaşi idee dar transformăm această MT de tip acceptor în una de tip
decident făcând algoritmul să verifice numai un număr finit de derivări. Pentru aceasta
aplicăm următoarea lemă:
Fie G o gramatică independentă de context în forma normală Chomski şi

w  L(G): |w| = n, n  N;
 orice derivare a lui w în G are 2n-1 paşi.
Prin urmare, pentru a verifica dacă w  L(G), algoritmul va testa – în funcţie de lungimea
cuvântului cercetat, |w| = n – numai derivările de lungime 2n-1; cum aceste derivări sunt
în număr finit (|||w|) înseamnă că avem o MT decidentă. În plus, conversia G în forma
18
Decidabilitate
normală Chomski8 se poate face tot de către MT, folosind procedura descrisă în
demonstraţia teoremei de aducere la forma normală Chomski.
Construim o MT C care să decidă asupra limbajului ACCGIC astfel:

C = “Fie secvenţa de intrare <G,w>, unde G este o gramatică independentă de context şi
w  *:
1. Se converteşte G într-o gramatică G’ în forma normală Chomski.
2. Se listează toate derivările din G’ care au 2n-1 paşi, unde n = |w| (dacă w =  atunci
se listează toate derivările care au un singur pas).
3. Dacă între aceste derivări există una care generează w dat, atunci C acceptă
secvenţa de intrare <G,w>; altfel, respinge.” q.e.d..
2.6. Teoremă (fără demonstraţie)

Limbajul EMPGIC = { <G> | G este o gramatică independentă de context şi L(G) =  }
este decidabil.

Fie problema echivalenţei limbajelor generate de două gramatici independente de context;
nu putem utiliza în demonstraţia ei metoda folosită în Teorema 2.4 deoarece mulţimea
limbajelor independente de context nu este închisă la intersecţie şi complementară. În
plus, vom demonstra ulterior ca limbajul
EQVGIC = { <G,H> | G şi H sunt gramatici independente de context şi L(G) = L(H) }
NU este decidabil.
2.8. Observaţie
O teoremă anterioară descrie modul de conversie a unei gramatici independente de
context intr-un automat pushdown şi reciproc  toate rezultatele demonstrate pentru
gramaticile independente de context au loc şi pentru automatele pushdown.
2.9. Teoremă
Orice limbaj independent de context este decidabil.
Demonstraţie
Fie L un limbaj independent de context; putem proceda în două moduri:
 convertim automatul pushdown care recunoaşte limbajul L direct într-o MT (conversia
este imediată pentru că putem simula stiva automatului cu ajutorul benzii de lucru – mult
mai performante – a MT); în plus, chiar dacă automatul pushdown ar fi nedeterminist ştim
să-l convertim într-o MT nedeterministă şi apoi, cu procedura din Teorema 1.11, s-o
convertim pe aceasta într-o MT deterministă. Apare însă o dificultate: unele ramuri ale
calculului efectuat de automatul pushdown pot fi infinite, pot efectua citiri şi scrieri în stivă
fără a se opri vreodată  MT care va simula acest automat va avea şi ea nişte ramuri de
calcul pe care nu se va opri niciodată  MT nu va fi decidentă ci doar acceptoare;
 utilizăm MT C descrisă în demonstraţia Teoremei 2.5.
Fie o gramatică independentă de context G şi L = L(G); construim o MT MG decidentă

pentru L astfel:
MG = “ Fie cuvânt de intrare w  *:
1. Se rulează MT C pe secvenţa de intrare <G,w> (se verifică dacă această gramatică
generează o secvenţă oarecare w  *).
2. Dacă C acceptă secvenţa de intrare <G,w> atunci MG acceptă w ; altfel,
respinge.” q.e.d..
8
Producţiile unei gramatici în forma normală Chomski sunt exclusiv de forma A  BC, sau
A  a, unde A,B,C sunt simboluri neterminale iar a este un simbol terminal.
19
Decidabilitate
20
Nedecidabilitate: problema opririi
3. Nedecidabilitate: problema opririi

Vom demonstra una dintre cele mai importante – din punct de vedere filosofic – şi – sigur
– cea mai celebră teoremă din teoria calculabilităţii:
există o problemă nerezolvabilă algoritmic
Pentru aceasta avem nevoie de mai multe rezultate pregătitoare şi metode de

demonstrare:
 metoda diagonalizării
 metoda reducerii.
Metoda diagonalizării a fost propusă în 1873 de fondatorul teoriei mulţimilor, Georg

CANTOR. Scopul: determinarea cardinalităţii mulţimilor infinite şi a faptului că mulţimea
numerelor reale este nenumărabilă în timp ce mulţimea numerelor raţionale este
numărabilă.
Metoda reducerii este una dintre cele mai naturale metode de a rezolva sau a demonstra
un rezultat matematic. Reductibilitatea presupune întotdeauna existenţa a două probleme;
metoda nu menţionează nimic despre rezolvarea problemei P1 sau P2 în sine
(independent) ci numai despre rezolvarea problemei P1 dându-se o luţie pentru P2.
3.1. Definiţie
Reducerea este o metodă de a transforma o problemă P1 într-o altă problemă P2 astfel
încât o soluţie dată problemei P2 poate fi utilizată pentru a rezolva problema P1.
3.2. Exemplu
P1: rezolvarea unui sistem de n ecuaţii lineare cu m necunoscute, n,m  N.
P2: inversarea unei matrice.
P3: calcularea valorii unui determinant.
3.3. Observaţie
Reductibilitatea joacă un rol important în
(i) teoria calculabilităţii:
dacă P1 este reductibilă la P2 şi P2 este decidabilă, atunci P1 este decidabilă;
sau, echivalent:
dacă P1 este reductibilă la P2 şi P1 este nedecidabilă, atunci P2 este nedecidabilă;
Obţinem astfel o metodă de a demonstra că o problemă P este nedecidabilă
(nerezolvabilă algoritmic): căutăm o problemă Q, cunoscută ca nedecidabilă şi
demonstrăm că problema Q este reductibilă la P.
(ii) teoria complexităţii:
dacă P1 este reductibilă la P2 atunci rezolvarea lui P1 nu poate fi mai dificilă decât
rezolvarea lui P2 pentru că o soluţie obţinută pentru P2 furnizează o luţie pentru P1
sau, echivalent:
P1 are aceeaşi complexitate ca şi P2.
3.1. Un limbaj care nu este Turing-decidabil (nu este recursiv)

Prima problemă nerezolvabilă algoritmic de care ne ocupăm (sau, echivalent, prima
teoremă privind nedecidabilitatea unui limbaj) constă în verificarea faptului că o MT M
acceptă sau nu o anumită secvenţă de intrare w  *. Cu alte cuvinte, PROBLEMA
ACCEPTABILITATII pentru maşini Turing, problemă numită uneori (eronat!) problema
opririi.
21
3.4. Teoremă
Limbajul ACCMT = { <M,w> | M este o maşină Turing şi M acceptă cuvântul w  * } NU
este decidabil.
Demonstraţie (utilizăm 2 metode: reducerea la absurd şi diagonalizarea)

Observăm că limbajul ACCMT este recunoscut de o MT dar nu este Turing-decidabil. Intr-
adevăr, fie MT U definită astfel:
U = “Fie secvenţa de intrare <M,w>, unde M este o MT oarecare şi w  *:
1. Se simulează MT M pe cuvântul de intrare w.
2. Dacă la un moment dat, M intră în starea sa de acceptare / respingere atunci U
acceptă / respinge intrarea <M,w>.”
Această MT recunoaşte limbajul ACCMT dar nu decide asupra lui deoarece, dacă M
ciclează pe un cuvânt de intrare oarecare w  * atunci şi U ciclează pe intrarea
corespunzătoare <M,w>. Dacă acest algoritm ar putea determina faptul că pe intrarea w
maşina Turing M nu se opreşte, atunci U ar putea respinge intrarea corespunzătoare
<M,w> şi limbajul ACCMT ar fi decidabil. Vom demonstra mai jos că nu există nici un
algoritm capabil să facă această apreciere.
Presupunem prin absurd ca limbajul ACCMT este decidabil 

fie H o MT care decide asupra limbajului ACCMT 
oricare ar fi secvenţa de intrare <M,w>, unde M este o MT şi w cuvântul său de intrare,
atunci H se opreşte şi, dacă M acceptă w atunci şi H acceptă <M,w>. În plus, dacă
M nu acceptă w atunci H se opreşte şi respinge <M,w>.
Cu alte cuvinte, presupunem că există o MT H cu proprietatea:
acceptă, dacă M acceptă w,
H(<M,w>) =
respinge, dacă M nu acceptă w.
Construim acum o altă MT D având MT H ca subrutină. Această nouă MT D apelează

H pentru a determina ce acţiune execută M atunci când primeşte, ca secvenţă de intrare
w , propria sa descriere <M>. După ce D a obţinut această informaţie ea execută exact
acţiunea contrară, adică:
respinge intrarea sa, dacă M acceptă propria sa descriere <M>,
D=
acceptă intrarea sa, dacă M nu acceptă propria sa descriere <M>.
Iată descrierea completă a MT D:

D = “Fie secvenţa de intrare <M> , unde M este o MT oarecare:
1. Se rulează H pe secvenţa de intrare <M,<M>>.
…2. Se returnează rezultatul opus rezultatului returnat de H, adică, dacă H acceptă
intrarea <M,<M>> (ceea ce se întâmplă atunci când M acceptă <M>) atunci D
respinge iar dacă H respinge intrarea <M,<M>> (ceea ce se întâmplă atunci când
M nu acceptă <M>) atunci D acceptă <M>.”
(Observăm că D poate fi privită ca un compilator care primeşte la intrare un program şi
care poate fi scris chiar în limbajul în care este scris şi programul respectiv.)
acceptă, dacă M nu acceptă <M>,

 D(<M>) =
respinge, dacă M acceptă <M>.
22
Ce se întâmplă însă atunci când D primeşte la intrare propria sa descriere <D> ? Atunci
avem:
acceptă, dacă D nu acceptă <D>,
 D(<D>) =  contradicţie
respinge, dacă D acceptă <D>.
 nici D nici H nu pot exista în realitate  limbajul ACCMT nu este decidabil. q.e.d.
3.5. Obervaţie importantă

Maşina Turing U din demonstraţia Teoremei 2.12 este importantă în sine, fiind un
exemplu de MT universală. Propusă iniţial de Alan Turing, MT universală a jucat un rol
important în dezvoltarea calculatoarelor cu program memorat.
3.6. Definiţie
O MT oarecare se numeşte universală dacă poate simula orice MT, cu condiţia să
primească la intrare o descriere corectă a acesteia.
3.2. Un limbaj care nu este recunoscut de o maşină Turing (nu

este recursiv enumerabil)
3.7. Propoziţie
Există limbaje care nu sunt recunoscute de MT (nu sunt nici măcar recursiv enumerabile).
Nu dăm o demonstraţie (ea poate rămâne ca temă) ci doar o justificare:

mulţimea limbajelor este nenumărabilă (se demonstrează prin metoda diagonalizării) în
timp ce mulţimea maşinilor Turing este numărabilă şi orice MT nu poate recunoaşte decât
un singur limbaj (se demonstrează tocmai cu ajutorul codificării oricărei MT printr-o
secvenţă <M> peste un alfabet  suficient de bogat dar finit).
În sprijinul acestei afirmaţii, vom indica acum un limbaj concret care nu numai că nu este
decidabil dar nu este nici recunoscut de o MT. Pentru aceasta vom demonstra mai întâi
ca dacă atât un limbaj cât şi complementul său sunt recunoscute de maşini Turing atunci
limbajul respectiv este decidabil.
3.8. Definiţie
Limbajul L  * se numeşte co-Turing-recunoscut dacă L este compelmentul unui
limbaj Turing-recunoscut.
3.9. Teoremă
Fie limbajul L  * Atunci, L este decidabil dacă şi numai dacă L este Turing-recunoscut
şi L este co-Turing-recunoscut.
Conform ipotezei, L este decidabil  L este evident Turing-recunoscut.
Pe de altă parte, dacă L este decidabil atunci şi L este decidabil şi, prin urmare, L
este şi Turing-recunoscut  L este co-Turing-recunoscut (conform Definiţiei 2.15).
““
Conform ipotezei, L este Turing-recunoscut şi co-Turing-recunoscut
 L şi L sunt Turing-recunoscute  fie M1, M2 cele două MT care le recunosc, respectiv.
Construim următoarea MT M cu ajutorul lor:
M = “Fie cuvânt de intrare w  *:
1. Se rulează M1 şi M2 în paralel pe intrarea w.
23
2. Dacă M1 (asociată lui L) acceptă w atunci M acceptă w iar dacă M2 (asociată lui
L ) acceptă w atunci M respinge w.”
Rularea în paralel a celor doua MT M1 şi M2 revine la înzestrarea lui M cu două benzi

de lucru: una pentru simularea lui M1, cealaltă pentru simularea lui M2. Simularea se
face alternativ, astfel: M simulează câte un pas al fiecărei maşini până când una dintre
ele se opreşte.
Arătăm acum că M decide asupra limbajului L: fie un cuvânt oarecare w  * 

w  L sau w  L  fie M1 fie M2 acceptă intrarea w.
Dar, conform definiţiei sale, M se opreşte oridecâteori M1 sau M2 acceptă cuvântul de
intrare primit. În plus, M acceptă toate secvenţele din L şi respinge toate secvenţele din
L  M decide asupra limbajului L  L este decidabil q.e.d.
3.10. Corolar
Limbajul A C C MT NU este Turing-recunoscut.
Demonstraţie
Presupunem prin absurd că limbajul A C C MT este Turing-recunoscut
În demonstraţia Teoremei 2.12 am arătat şi că limbajul ACCMT este Turing-recunoscut
Teorema 2.16
 A C C MT este decidabil  ACCMT este decidabil  contradicţie cu Teorema 2.12
q.e.d.
3.11. Observaţie
Aceaste rezultate încheie demonstrarea următoarelor relaţii (începută în cursul de Teoria
limbajelor formale) privind familiile de limbaje formale:
Limbaje
Limbaje recunoscute
Limbaje decidabile de MT (recursiv
Limbaje indep. (recursive) enumerabile)
regulate context
3.3. Problema opririi

PROBLEMA OPRIRII constă în a determina dacă o MT M oarecare se opreşte pe o
intrare oarecare w  * (acceptând-o sau respingând-o). Conform formalismului dezvoltat
anterior, a demonstra ca această problemă este nerezolvabilă algoritmic este echivalent
cu a demonstra că limbajul
HALTMT = { <M,w> | M este o maşină Turing şi M se opreşte pe intrarea w  * }
este nedecidabil.
Pentru a demonstra aceasta, aplicăm metoda reducerii:
24
 ştim că PROBLEMA ACCEPTABILITATII este nerezolvabilă algoritmic (limbajul

ACCMT este nedecidabil);
 reducem PROBLEMA ACCEPTABILITATII la PROBLEMA OPRIRII
 demonstrăm astfel că PROBLEMA OPRIRII este nerezolvabilă algoritmic (limbajul
HALTMT este nedecidabil).
3.12. Teoremă
Limbajul HALTMT = {<M,w> | M este o maşină Turing şi M se opreşte pe intrarea w  *}
este nedecidabil.
Demonstraţie (utilizăm metoda presupunerii prin absurd şi metoda reducerii)

Presupunem prin absurd ca limbajul HALTMT este decidabil şi demonstrăm că limbajul
ACCMT este decidabil, ceea ce contrazice Teorema 3.4.
Faptul că ACCMT se reduce la HALTMT va rezulta din faptul că MT care decide asupra
ACCMT este construită pe baza MT care decide asupra HALTMT într-un mod care leagă
enunţul PROBLEMEI ACCEPTABILITATII de enunţul PROBLEMEI OPRIRII:
fie MT H care decide asupra limbajului HALTMT; construim MT A care să decidă asupra
limbajului ACCMT cu ajutorul H, adică: A utilizează H pentru a “observa” comportamentul
maşinii Turing M pe intrarea w  * (unde M şi w sunt arbitrare), şi anume:
 dacă H indică faptul că M se opreşte şi acceptă w atunci A acceptă <M,w>;
 dacă H indică faptul că M se opreşte şi respinge w atunci A respinge <M,w>;
 dacă H indică faptul că M ciclează pe intrarea w atunci convenim ca A să
respingă intrarea <M,w> (intr-adevăr, dacă M ciclează pe w înseamnă că M nu se
opreşte şi nu acceptă w deci <M,w>  ACCMT);
 A este decidentă nu doar acceptoare.
Formal, MT A este definită astfel:

A = “Fie secvenţa de intrare <M,w>, unde MT M şi cuvântul w  * sunt arbitrare:
1. Se rulează MT H pe intrarea <M,w>.
2. Dacă H respinge <M,w> atunci şi A respinge <M,w>.
3. Dacă H acceptă <M,w> atunci se simulează M pe intrarea w până când M se
opreşte (lucru garantat de ipoteza acestui pas: <M<w>  HALTMT).
4. Dacă M a acceptat / a respins w  * atunci A acceptă / respinge <M,w>.”
Evident, H este decidentă şi decide asupra limbajului HALTMT ; conform construcţiei

sale, MT A este şi ea decidentă şi decide asupra limbajului ACCMT. Dar, conform
Teoremei 3.4, limbajul ACCMT nu este decidabil  contradicţie 
limbajul HALTMT este nedecidabil q.e.d.
Următoarele teoreme privind nerezolvabilitatea algoritmică a unor probleme privind

limbajele recunoscute de MT (nedecidabilitatea limbajelor prin care le-am codificat) se pot
demonstra – ca şi PROBLEMA OPRIRII – prin acceaşi metodă a reducerii (dar nu
neapărat la PROBLEMA ACCEPTABILITATII). Singura teoremă privind nedecidabilitatea
unui limbaj care nu se demonstrează în acest fel, ci direct, prin metoda diagonalizării, este
PROBLEMA ACCEPTABILITATII PENTRU MT.
3.13. Teoremă
Limbajul EMPMT = {<M> | M este o maşină Turing şi L(M) =  } este nedecidabil.
3.14. Teoremă
Limbajul EQVMT = { <M1,M2> | M1 şi M2 sunt maşini Turing şi L(M1) = L(M2) } este
nedecidabil.
25
Demonstraţia se face prin reducere la PROBLEMA LIMBAJULUI VID (vezi Teorema

3.13).
3.15. Observaţie
O altă problemă de calculabilitate interesantă relativă la MT se referă la posibilitatea ca o
MT să recunoască un limbaj care poate fi recunoscut şi de un model de calculabilitate mai
slab: un automat finit, un automat pushdown etc. De exemplu, problema verificării
echivalenţei dintre o MT şi un AFD (altfel spus: poate o MT să recunoască un limbaj
regulat) ar trebui să aibă – intuitiv – un răspuns afirmativ. Teorema 3.16 (a cărei
demonstraţie rămâne ca exerciţiu) arată că această problemă nu este rezolvabilă
algoritmic.
3.16. Teorema
Limbajul REGMT = { <M> | M este o MT oarecare şi L(M) este un limbaj regulat } este
nedecidabil.
Demonstraţie
Presupunem prin absurd că există o MT R care decide asupra REGMT şi o utilizăm
pentru a construi o MT A care să decidă asupra limbajului ACCMT , astfel: A primeşte
secvenţa de intrare <M,w> şi modifică M astfel încât MT rezultată, fie ea M2, să
recunoască un limbaj regulat dacă şi numai dacă M acceptă w. Mai exact:
recunoaşte limbajul neregulat {0n1n| n  0}, dacă M nu acceptă w,
M2 =
recunoaşte limbajul regulat *, dacă M acceptă w.
A poate construi M2 din M şi w în mai multe feluri, de exemplu, astfel:

M2 acceptă automat toate cuvintele din limbajul neregulat {0n1n| n  0} şi, dacă M
recunoaşte w, atunci M2 acceptă şi restul cuvintelor din *. Iată definiţia formală a lui A:
A = “Fie secvenţa de intrare <M,w>, unde M este o MT oarecare şi w  *:

1. Se construieşte următoarea MT M2:
M2 = “Fie cuvântul de intrare x  *:
1. Dacă x este de forma 0n1n atunci M2 acceptă x.
2. Dacă x nu este de această formă atunci se rulează M pe intrarea w şi, dacă
M acceptă w atunci M2 acceptă x.”
2. Se rulează R pe intrarea <M2>.
3. Dacă R acceptă /respinge <M2> atunci A acceptă / respinge <M,w>.
Evident, R este o MT decidentă pentru limbajul REGMT şi R se reduce la A

 A este o MT decidentă pentru limbajul ACCMT  contradicţie cu Teorema 3.4.
3.17. Observaţie
Toate problemele privind verificarea caracterului finit, independent de context, respectiv
recursiv al unui limbaj recunoscut de o MT sunt nedecidabile (demonstraţiile sunt similare
celei de mai sus). De fapt, dispunem de un rezultat general care afirmă că orice
proprietate privitoare la limbajele recunoscute de o MT este nedecidabilă. Acesta este:
3.18. Teorema lui Rice

Fie limbajul P = {<M> | M este o MT oarecare}. Presupunem ca limbajul P satisface
următoarele două proprietaţi:
(i) P nu este trivial (adică, proprietatea are loc pentru unele limbaje recursiv enumerabile
iar pentru altele nu are loc, sau, încă: există limbaje care aparţin lui P şi altele care
nu aparţin lui P):
26
() MT M1 şi M2 astfel încât <M1>  P şi <M2>  P

(ii) aparteneţa unei MT M la P (prin descrierea ei <M>) depinde numai de limbajul
recunoscut de M:
oricare ar fi MT M1 şi M2 cu proprietatea L(M1) = L(M2) atunci <M1>  P  <M2>  P.
Atunci, limbajul P este nedecidabil.
3.4. Funcţii calculabile; reductibilitate funcţională

În continuare, vom defini noţiunea de funcţie calculabilă şi vom formaliza conceptul de
reductibilitate a unei probleme A la o problemă B.
Noţiunea de reductibilitate poate fi formalizată în mai multe moduri iar alegerea depinde –
în principal – de natura aplicaţiei avute în vedere. Aici alegem un caz simplu de
reductibilitate: REDUCTIBILITATEA FUNCTIONALA.
În esenţă, reductibilitatea funcţională a problemei A la problema B revine la găsirea

uneui funcţii calculabile – numite REDUCERE – care să transforme fiecare instanţă a
problemei A într-o instanţă a problemei B  orice metodă de rezolvare a problemei B
furrnizează o metodă de rezolvare a problemei A.
3.4.1. Funcţii calculabile
O MT calculează o funcţie astfel:
 primeşte la intrare argumentul;
 se opreşte având pe bandă imaginea corespunzătoare.
3.19. Definiţie
Funcţia f : *  * se numeşte calculabilă  există o MT care, oricare ar fi secvenţa de
intrare w  *, se opreşte, având pe bandă secvenţa f(w).
3.20. Exemple
Toate funcţiile aritmetice definite pe N sunt calculabile; de exemplu, putem construi o MT
care primeşte la intrare perechea de numere naturale <n,m> şi produce la ieşire suma
m+n.
3.4.2. Definiţia formală a reducerii funcţionale
3.21. Definiţie
Fie limbajele A, B  *. Limbajul A se numeşte reductibil funcţional la limbajul B şi
se notează prin A m B 
() f : *  * calculabilă astfel încât () w  *: w  A  f(w)  B.
Funcţia f se numeşte reducerea lui A la B.
3.22. Observaţie
Existenţa unei reduceri funcţionale a lui A la B permite transformarea problemei
apartenenţei lui w la A la problema apartenenţei lui f(w) la B
 pentru a demosntra că w  A utilizăm reducerea f pentru a asocia w cu f(w) şi
demonstrăm că f(w)  B.
Cu această metodă demonstrăm acum formal observaţia anterioară protrivit căreia dacă
A este reductibilă la B şi B este algoritmic rezolvabilă atunci A este algoritmic
rezolvabilă.
3.23. Teoremă
Dacă A m B şi limbajul B este decidabil, atunci limbajul A este decidabil.
27
Demonstraţie
Conform ipotezei “B = limbaj decidabil”  există o MT M decidentă pentru B.
Conform ipotezei “A m B “  () f : *  * o reducere a lui A la B  putem construi
o MT N decidentă pentru A astfel:
N = “Fie cuvânt de intrare w  *:
1. Se calculează f(w).
2. Se rulează M pe intrarea f(w); rezultatul furnizat de M este preluat de N.”
Evident, dacă w  A atunci - conform ipotezei “A m B “ - f(w)  B

 întrucât M decide asupra limbajului B înseamnă că M acceptă f(w) exact atunci
când w  A
 N decide asupra limbajului A q.e.d.
3.24. Corolar
Dacă A m B şi limbajul A este nedecidabil atunci şi limbajul B este nedecidabil.
3.25. Observaţie
Putem acum să încheiem demonstraţiile teoremelor privind nedecidabilitatea unor limbaje
(nerezolvabilitatea algoritmică a unor probleme) formalizând şi reducerea limbajelor unul
la altul.
3.26. Exemplu
În Teorema 3.12 am demonstrat nedecidabilitatea limbajului HALTMT prin reducerea
limbajului ACCMT la HALTMT şi prin metoda reducerii la absurd. Această reducere a
arătat cum poate fi folosită o MT decidentă pentru HALTMT în scopul definirii unei MT
deciedente pentru ACCMT; presupunerea prin absurd că o astfel de MT există ne-a
condus la obţinerea unei contradicţii cu Teorema 3.4 care arăta că ACCMT nu este
decidabil.
Vom formaliza acum reducerea limbajului ACCMT la HALTMT . Pentru a demonstra că
ACCMT m HALTMT trebuie să găsim o funcţie f : *  *, calculabilă, astfel încât
oricare ar fi secvenţa <M,w>: <M,w>  ACCMT  f(<M<w>) = <M’,w’>  HALTMT.
Fie următoarea MT , F, care calculează o astfel de reducere f:

F = “Fie secvenţa de intrare <M,w>, unde M este o MT oarecare şi w  *:
1. Se construieşte următoarea MT M’ astfel:
M’ = “Fie cuvântul de intrare x  *:
1. Se rulează M pe intrarea x.
2. Dacă M acceptă x, atunci şi M’ acceptă x (pentru că, M acceptând, M s-a
oprit deci şi M’ trebuie să se oprească).
3. Dacă M respinge x, atunci M’ ciclează (pentru că atunci <M,x>  ACCMT
trebuie ca <M,x>  HALTMT deci M’ să nu se oprescă pe x).”
2. Se returnează secvenţa <M’,w>.”
Evident, dacă secvenţa de intrare primită de F nu este corect formată (adică nu este
codificarea unei MT şi a unui cuvânt din *, <M,w>  ACCMT) atunci F produce la ieşire
o secvenţă v  HALTMT. În general, cănd definim o MT care calculează o reducere de la
limbajul A la limbajul B, se presupune că secvenţele de intrare incorect formate conduc
la secvenţe din * \ B.
3.27. Teoremă
Fie A m B şi limbajul B recunoscut de MT ; atunci limbajul A este recunoscut de MT.
28
Demonstraţie
Analogă demonstraţiei Teoremei 3.23 privind decidabilitatea, numai că cele două MT M
şi N sunt doar acceptoare nu decidente pentru B, respectiv A.
3.28. Corolar
Dacă A m B şi limbajul A nu este Turing-recunoscut atunci nici limbajul B nu este
Turing-recunoscut.
3.29. Observţie
Putem aplica acest corolar pentru a rezolva probleme de calculabilitate astfel:
să presupunem că trebuie să demonstrăm că limbajul L nu este Turing-recunoscut;
arătăm că ACCMT m L
A C C MT m L
pe de altă parte, evident: A m B  A m B 
Dar, conform Corolarului 3.10, A C C MT nu este Turing-recunoscut.
Aplicând Corolarul 3.28
 L nu este Turing-recunoscut.
Deci: pentru a demonstra că limbajul L nu este Turing-recunoscut e suficient să
demonstrăm că ACCMT m L .
Rezumat
29
Clasa de complexitate TIMP
4. Clasa de complexitate TIMP

Chiar dacă o problemă este rezolvabilă algoritmic în principiu, există posibilitatea ca
obţinerea soluţiei să necesite cantităţi mult prea mari de resurse de calcul: fie timp, fie
memorie, fie ambele. Admitem atunci că problema este nerezolvabilă algoritmic în
practică.
Abordăm acum teoria complexităţii calculului, definind şi studiind – dintre diferitele tipuri
de resurse de calcul necesare rezolvării problemelor – pe cele mai importante: timpul de
calcul şi spaţiul de memorie.
4.1. Terminologie
Fie limbajul L1 = { 0k1k  {0,1}* | k  0 }
Am demonstrat ca L1 este independent de context şi că ACCGIC este decidabil; prin
urmare ştim că L1 este decidabil (vezi şi Teorema 2.9)
Problema care ne interesează acum este însă:
după cât timp o MT răspunde afirmativ la această întrebare?
Fie o MT M1 clasică (cu o singură bandă de lucru) care calculează L1. Descriem această
MT în detaliu pentru a putea număra paşii pe care îi face:
M1 = “Fie cuvântul de intrare w  *:
1. Se examinează banda de intrare şi se respinge w dacă se descoperă un simbol 0
la dreapta unui simbol 1.
2. Se execută etapa următoare, atât timp cât pe bandă există atât simboluri 0 cât şi
simboluri 1:
3. Se scanează banda şi se barează un singur simbol 0 şi un singur simbol 1.
4. Dacă, după ce toate simbolurile 0 au fost barate pe bandă au mai rămas simboluri
1 nebarate, sau dacă, după ce toate simbolurile 1 au fost barate pe bandă au mai
rămas simboluri 0 nebarate, atunci secvenţa w se respinge.
Altfel, dacă toate simbolurile 0 şi toate simbolurile 1 de pe bandă au fost barate,
atunci secvenţa w se acceptă.”
Numărul de paşi executaţi de un algoritm (o MT) pentru prelucrarea unei date de intrare şi
obţinerea rezultatului paote depinde de mai mulţi parametri. De exemplu, dacă data de
intrare a algoritmului este un graf, atunci numărul de paşi poate depinde de numărul de
noduri / muchii, de gradul maxim al grafului, de o combinaţie a acestor factori şi / sau a
altora.
Aici, pentru simplificare, vom calcula TIMPUL DE EXECUTIE al unui algoritm numai ca
funcţie de LUNGIMEA SECVENTEI care reprezintă informaţia sa de intrare şi vom ignora
ceilalţi parametri. Se pot aborda:
 cazul cel mai nefavorabil (în care se consideră cel mai lung timp de execuţie al
algoritmului pentru toate secvenţele de o lungime dată);
 cazul cel mai favorabil (în care se consideră cel mai scurt timp de execuţie al
algoritmului pentru toate secvenţele de o lungime dată);
 cazul mediu (în care se consideră media timpilor de execuţie ai algoritmului pentru
toate secvenţele de o lungime dată).
30
4.1. Definiţie
Fie M o MT oarecare care se opreşte pentru orice secvenţă de intrare. Prin
complexitate timp înţelegem timpul de execuţie al M adică o funcţie
f : N  N, f(n) = numărul maxim de paşi executaţi de M pentru o secvenţa de intrare
de lungime n, () n  N .
4.2. Notaţia asimptotică

Timpul exact de execuţie a unui algoritm poate fi o expresie foarte complexă; de aceea,
de obicei, el este doar aproximat printr-o expresie mai simplă, conţinând numai termenul
de ordinul cel mai mare şi către care tinde asimptotic (putem ignora termenii de ordin
inferior şi coeficienţii deoarece, pentru intrări mari, aceştia sunt dominaţi de termenii de
ordin superior; vezi Observaţia 4.6).
4.2. Exemplu
Fie f : N  N, f(n) = 5n3 + 2n2 + 22n + 6;
spunem că f tinde asimptotic către n3 şi notăm acest lucru cu O(n3).
4.3. Observaţie
Notaţia O a fost introdusă de P. BACHMANN in cartea sa “Analytische Zahlentheorie” în
1892, ca o notaţie convenabilă pentru operarea cu aproximaţii. Ea ne permite să inlocuim
semnul  cu semnul =. În general, notaţia O(f(n)) poate fi utilizată oridecâteori f este o
funcţie de n , pentru a înlocui o anumită cantitate care nu este cunoscută explicit.
4.4. Definiţie
Fie f, g : N  R+
(i) f(n) = O(g(n)) şi citim “f(n) este de ordin cel mult g(n)” sau “f(n) este O mare de
g(n)”  () constantele c1 > 0 şi n1  N astfel încât f(n)  c1.g(n), () n  n1.
c1.g(n)
f(n)
n1
(îi) f(n) =  (g(n)) şi citim “f(n) este de ordin cel puţin g(n)” sau “f(n) este omega mare
de g(n)”  () constantele c2 > 0 şi n2  N astfel încât f(n)  c2.g(n), () n  n2.
f(n)
c2.g(n)
n2
31
(iii) f(n) =  (g(n)) şi citim “f(n) este de ordin g(n)” sau “f(n) este theta de g(n)” 
f(n) = O(g(n)) şi f(n) =  (g(n)).
c1.g(n)
f(n)
c2.g(n)
n0
Spunem că g este o limită asimptotică superioară, o limită asimptotică inferioară,

respectiv o limită asimptotică pentru f.
4.5. Exemplu
Revenim la notaţia O şi la funcţia polinomială f(n) = 5n3 + 2n2 + 22n + 6 
f(n) = O(n3), de exemplu, pentru c1 = 6 şi n1 = 10;
f(n) = O (n4), de exemplu, pentru c1 = 1 şi n1 = 6 sau pentru c1 = 36 şi n1 = 1;
f(n)  O (n2), presupunem prin absurd că există c1 >0 şi n1  N astfel încât
5n3 + 2n2 + 22n + 6  c1.n2, () n  n1  5n3 + (2- c1).n2 + 22n + 6  0 etc.
4.6. Observaţie
Fie f1 : N  N, f1(n) = 3n.log2n + 5n.log2(log2n) + 2 
f1(n) = O(n.log n) pentru că log n domină log(log n).
Analog, f2(n) = O(n2) + O(n) = O(n2) pentru că O(n2) domină O(n). Să mai observăm că
fiecare apariţie a lui O poate reprezenta o altă constantă.
4.7. Observaţie
A) Specificarea bazei logaritmilor nu este necesară ea intervenind cu cel mult un
coeficient constant, conform formulei:
log b x
log a x 
log b a
B) Analog, nici specificarea bazei exponenţialei nu este necesară pentru că:
log x c  log2 n
() x: x  2 2  n c  2  2O(log n) este o limită superioară pentru nc, unde c
este o constantă oarecare. Evident, şi 2O(n) este o limită superioară pentru nc.
4.8. Observaţie
Limitele asimptotice de tipul nc se numesc limite polinomiale.

Limitele asimptotice de tipul 2 n se numesc limite exponenţiale.
Limitele asimptotice de tipul k.n se numesc limite lineare.
Limitele asimptotice de tipul n se numesc limite sublineare.
4.9. Observaţie
Pe lângă notaţiile O şi  mai există şi notaţiile o şi  , obţinute din Definiţia 4.4 prin
înlocuirea inegalităţii  cu inegalitatea strictă < , sau
32
f ( n)
f (n)  o( g (n))  lim 0
n  g ( n)
4.10. Exemple
n  o(n)
n =o(n.log log n)
n.log log n = o(n.log n)
n.log n = o (n2)
n2 = o(n3)
4.11. Propoziţie9
(i) Notaţiile O, , , o,  sunt tranzitive;
(îi) Notaţiile O, , , sunt reflexive, dar nu şi o,  ;
(îii) Notaţia  este simetrică dar nu şi celelalte notaţii
4.12. Propoziţie10
Notaţiile O, , , o,  pot fi manipulate algebric dar cu precauţie:
c.O(f(n)) = O(f(n))
O(f(n)) + O(f(m)) = O(f(n))
O(O(f(n))) = O(f(n))
O(f(n)) O(g(n)) = O(f(n).g(n))
O(f(n).g(n)) = f(n).O(g(n));
atenţie: ultima “egalitate“ are loc într-un singur sens: de la stânga la dreapta.
4.3. Analiza algoritmilor

Reluăm MT care calculează L1 = { 0k1k  {0,1}* | k  0 }. Fie | 0k1k | = n.
 Pentru a efectua prima etapă a algoritmului este nevoie de n paşi  O(n) paşi.
 Aducerea cursorului în extremitatea stângă pentru a începe bararea necesită alţi n
paşi  O(n) paşi.
 În etapele 2, 3 MT scanează în mod repetat banda pentru a bara simbolurile 0 şi 1.
Fiecare scanare necesită n paşi iar la fiecare scanare se barează 2 simboluri  se fac
n/2 scanări de câte n paşi fiecare  O(n2) paşi.
 În etapa a patra, MT face o singură scanare pentru a hotărî dacă acceptă / respinge
secvenţa de intrare  se execută maximum n paşi (pentru secvenţe de tipul 011…1) 
O(n) paşi.
 f(n) = O(n) + O(n) + O(n2) + O(n) = O(n2)
Observăm că în descrierea acestei MT nu am menţionat şi repoziţionarea cursorului în
extremitatea stângă a secenţei. Motivul: notaţia asimptotică ne permite să omitem din
descrierea MT (algoritmului) acele detalii care afectează timpul de lucru al MT prin cel
mult un factor constant.
4.13. Definiţie
Fie t : N  N. Se defineşte clasa de complexitate TIME (timp polinomial) prin:
TIME(t(n)) = { L  * | () o MT care decide asupra limbajului L în timp O(t(n)) }
9
Johnsonbaugh
10
Idem
33
4.14. Exemplu
L1 = { 0k1k  {0,1}* | k  0 }  TIME(n2) pentru că M1 decide asupra L1 în timp O(n2) iar
TIME(n2) conţine toate limbajele asupra cărora se poate decide în timp O(n2). Putem
îmbunătăţi această limită? Putem defini o MT care să decidă asupra limbajului L1 mai
repede?
(i) Modificăm MT M1 astfel încât la fiecare Etapă 3 barăm câte două simboluri 0 şi
două simboluri 1 (în loc de câte unul singur)  reducem numărul de scanări din Etapa 3
la jumătate  avem n/4 scanări de câte maximum n paşi fiecare  O(n2)  această
reducere inseamnă un factor constant egal cu 2 deci nu afectează timpul asimptotic de
execuţie al algoritmului;
(ii) Fie acum o altă MT M2, definită astfel:
2. Se execută următoarele două etape, atât timp cât pe bandă există atât simboluri 0
cât şi simboluri 1:
3. Se scanează banda pentru a determina dacă numărul total de simboluri 0 şi 1
aflat pe bandă este impar. Dacă da, atunci cuvântul se respinge.
4. Se scanează banda şi se barează simbolurile 0 din doi în doi începând cu
primul simbol 0 şi se barează simbolurile 1 din doi în doi începând cu primul
simbol 1.
5. Dacă, după ce toate simbolurile 0 au fost barate pe bandă au mai rămas simboluri
1 nebarate, sau dacă, după ce toate simbolurile 1 au fost barate pe bandă au mai
rămas simboluri 0 nebarate, atunci secvenţa w se respinge.
Altfel, dacă toate simbolurile 0 şi toate simbolurile 1 de pe bandă au fost barate,
atunci secvenţa w se acceptă.”
Este evidentă similitudinea dintre MT M1 şi M2 ; putem afirma deci că M2 decide
asupra limbajului L1. calculăm acum timpul său de execuţie:
 observăm că fiecare etapă se execută în O(n) paşi;
 numărăm de câte ori seexecută fiecare etapă:
o Etapa 1 se execută o singură dată,
o Etapa 5 se execută o tot singură dată,
o în Etapa 4 se barează cel puţin jumătate din simbolurile 0 şi jumătate din
simbolurile 1 la fiecare scanare  e nevoie de cel mult (1+log2n) scanări pentru a
bara toate simbolurile  Etapele 2, 3, 4 se execută de cel mult (1+log2n) ori.
 timpul de execuţie pentru MT M2 este de:
O(n) + (1+log2n).O(n) + O(n) = O(n) + O(n . log n) = O(n . log n)
 L1  TIME(n . log n)
(iii) Poate fi decis L1 în timp o(n . log n)? Răspunsul este negativ, conform Teoremei 4.3,
dată mai jos, fără demonstraţie.
(iv) Limbajul L1 poate fi decis chiar în timp linear dacă MT respectivă are două benzi.
Fie MT M3 cu doua benzi definită astfel:
2. Se scanează subşirul de simboluri 0 de pe Banda 1 a MT până la întâlnirea primului
simbol 1 şi se copiază pe Banda 2 a MT.
3. Se scanează subşirul de simboluri 1 rămas pe Banda 1 a MT până la sfârşit,
barându-se – pentru fiecare simbol 1 scanat – câte un simbol 0 de pe Banda 2..
4. Dacă toate simbolurile 0 de pe Banda 2 au fost barate dar pe Banda 1 au mai
rămas simboluri 1 de citit sau dacă pe Banda 2 au mai rămas simboluri 0
34
nebarate dar pe Banda 1 nu mai sunt simboluri 1 de citit, atunci secvenţa w se

respinge.
Altfel, dacă toate simbolurile 0 de pe Banda 2 au fost barate iar pe Banda 1 nu au
mai rămas simboluri 1 de citit, atunci secvenţa w se acceptă.”
Evident, M3 decide asupra limbajului L1; timpul său de execuţie este O(n) deoarece
fiecare etapă se execută o singură dată şi are nevoie de maximum n paşi.
Observăm că acest timp nu mai poate fi ameliorat pentru că simpla citire a cuvântului de
intrare necesită n paşi.
4.15. Teoremă
Orice limbaj care poate fi decis în timp o(n.log n) de o MT cu o singură bandă este
regulat.

Calculul timpului de execuţie pentru MT care decide asupra limbajului L1 a pus în
evidenţă o problemă interesantă:
 cu o MT cu o singură bandă, L1 este decidabil în timp O(n2) sau O(n.log n);
 cu o MT cu două benzi, L1 este decidabil în timp O(n);
 nici o MT cu o singură bandă nu poate ameliora performanţa de mai sus.
 complexitatea problemei L1 poate fi modificată dacă găsim un algoritm mai eficient (o
MT mai eficientă)
 complexitatea problemei L1 depinde de modelul de calculabilitate ales.
Aceasta evidenţiază o diferenţa esenţială care există între teoria calculabilităţii şi teoria
complexităţii:
 în teoria calculabilităţii, Teza Church-Turing arată că toate modelele de calculabilitate
“valabile” sunt echivalente între ele (adică decid asupra aceleiaşi clase de limbaje);
 în teoria complexităţii, alegerea unui model de calculabilitate afectează complexitatea-
timp a limbajului (problemei): un limbaj care – printr-un model de calculabilitate – este
decidabil în timp linear poate să fie – prin alt model de calculabilitate – decidabil doar în
timp polinomial.
Faptul că acelaşi limbaj poate necesita timpi de calcul diferiţi în diferite modele de
calculabilitate pare să torpileze orice incercare de clasificare a problemelor de
calculabilitate în funcţie de complexitatea timp a acestora. Din fericire, necesarul de timp
de calcul nu diferă în mod esenţial la nivelul modelelor de calcul deterministe.
4.4. Complexitatea modelelor de calculabilitate

Vom examina modul în care alegerea unui model de calculabilitate sau a altuia afectează
măsura timp de complexitate a limbajelor (problemelor). Vom analiza trei modele de
calculabilitate:
 MT cu o singură bandă (clasică);
 MT cu mai multe benzi;
 MT nedeterministă.
4.17. Teoremă
Fie t : N  N cu proprietatea că () n  N : t(n)  n.
Atunci, orice MT M cu mai multe benzi şi cu timp de lucru t(n) admite o MT S cu o
singură bandă de intrare şi cu timp de lucru O(t2(n)), echivalentă.
35
Demonstraţie
Ideea demonstraţiei
În Teorema 1.9 am arătat cum se poate transforma o MT M cu mai multe benzi într-o MT
S cu o singură bandă, echivalentă.
Acum trebuie doar să reluăm demonstraţia Teoremei 1.9 şi să analizăm modul în care S
simulează M pentru a calcula timpul suplimentar necesar. Vom demonstra că simularea
fiecărui pas efectuat de M necesită cel mult O(t(n)) paşi în cazul lui S. Prin urmare,
timpul de execuţie total al lui M este de O(t2(n)).
Formalizare
Fie M o MT cu k benzi de intrare care rulează în timp t(n), unde t : N  N , t(n)  n,
() n  N .
Construim (după metoda utilizată în demonstraţia Teoremei 1.9) o MT S cu o singură
bandă de intrare care să simuleze M şi analizăm timpul de lucru care îi este necesar
pentru aceasta.
Iniţial, S depune pe banda sa de intrare conţinuturile celor k benzi al M, separându-le

printr-un caracter special, # , care nu se află în alfabetul S = M (a se vedea
demonstraţia Teoremei 1.9); în plus, S simulează poziţiile cursoarelor lui M prin bararea
simbolurilor corespunzătoare de pe banda sa (de fapt, înlocuieşte un simbol s cu s,
()s  S = M).
Apoi, S simulează paşii efectuaţi de M pentru un cuvânt de intrare oarecare w  *.

Pentru a simula un pas efectuat de M, S trebuie să scaneze toată informaţia depusă pe
banda sa de intrare ca să poată astfel determina simbolurile aflate “sub” cursoarele lui M
(simbolurile barate). Apoi, S îşi parcurge din nou banda de intrare pentru a actualiza
conţinutul acesteia şi a repoziţiona cursoarele virtuale, conform definiţiei funcţiei de
tranziţie a lui M. Dacă unul dintre cursoarele reale ale M se deplasează la dreapta pe
propria sa bandă de lucru peste o celulă vidă (adică a parcurs complet propria sa
secvenţă de intrare), atunci S trebuie să-şi mărească spaţiul alocat pe propria sa bandă
de intrare. S face acest lucru deplasând toată informaţia (aflată pe banda sa la dreapta
celulei respective) cu o locaţie la dreapta.
Analizăm acum această simulare din punctul de vedere al timpului de calcul necesar.
(i) În prima etapă, în care S copiază pe banda sa informaţiile de pe cele k benzi ale M
şi le separă prin delimitatorii # , lui S îi sunt necesari O(n) paşi deoarece, conform
ipotezei, M rulează – pe o intrare de lungime n – în timp t(n).
(ii) Ulterior, S simulează fiecare dintre cei (conform ipotezei) t(n) paşi ai lui M.
Pentru fiecare pas executat de M, S parcurge de 2 ori porţiunea activă (cu informaţie) a
benzii sale de intrare:
 prima parcurgere serveşte la obţinerea informaţiei necesare pentru a determina
mişcarea următoare;
 a doua parcurgere serveşte la efectuarea acestei mişcări.
Timpul necesar efectuării acestor parcurgeri este evident determinat de numărul celulelor
cu informaţie de pe banda lui S. Căutăm deci o limită superioară pentru această lungime.
36
Conform construcţiei lui S:
marchează extremitatea
stângă a benzii
numărul de celule cu
informaţie de pe prima
bandă
delimitatorul celor
(S) = 1 + (M1) + 1 + (M2) + 1 + … + (Mk) + 1  două benzi alăturate
.
 1 + t(n) + 1 + t(n) + 1 + … + t(n) + 1  1 + k t(n) + k
exact t(n) celule de pe banda sa,

atunci când cursorul se deplasează
mereu la dreapta;
Conform ipotezei, M rulează în timp t(n),
deci efectuează t(n) paşi utilizând:
mai puţin de t(n) celule, atunci
când există şi deplasări la stânga.
Deci, S scanează porţiunile cu informaţie de pe banda sa de intrare în

O(t(n)) paşi (modulo constantele k şi k + 1, banda lui S este “la fel (*)
de lungă” ca oricare dintre benzile lui M).
Prin urmare, pentru a simula oricare dintre paşii lui M , S consumă:

 un timp de calcul de ordinul O(t(n)) pentru fiecare dintre cele două scanări şi
 un timp de lucru constant pentru cele maximum k deplasări la dreapta (când
cursoarele virtuale ajung peste delimitatori).
 timpul total necesar lui S pentru a simula un pas oarecare al lui M este de ordinul
O(t(n)).
Dar conform ipotezei, M efectuează t(n) paşi; prin urmare, în etapa propriu-zisă de
simulare a lui M , S consumă un timp de calcul egal cu
t(n) x O(t(n)) = O(t2(n))
Prin urmare, din (i) şi (ii) rezultă că întreaga simulare a lui M de către S consumă
O(n) + O(t2(n)) paşi
Dar, în ipoteză am presupus că t(n)  n, () n  N. Aceasta înseamnă că putem aprecia

timpul total de execuţie al lui S la O(t2(n)). q.e.d.
4.18. Observaţie
Ipoteza t(n)  n, () n  N nu este restrictivă, ci dimpotrivă: în caz contrar, M “nu ar
avea timp” nici măcar să citească toată informaţia, darămite să o prelucreze!
În continuare, demonstrăm o teoremă analogă pentru MT nedeterministe cu o singură

bandă de lucru. Arătăm că orice limbaj care este decidabil de către o MT nedeterministă
cu o singură bandă de lucru este decidabil şi de către o MT deterministă cu o singură
bandă, dar într-un timp de execuţie semnificativ mai mare.
37
4.19. Definiţie
Fie N o MT nedeterministă decidentă. Timpul de execuţie al N este o funcţie
f : N  N, f(n) = numărul maxim de paşi efectuaţi de N de-a lungul oricărei
ramuri de calcul, pe intrarea w, |w| = n, () w  *, () n  N.
Această definiţie nu încearcă să modeleze o maşină de calcul care există în realitate ci

este o definiţie matematică utilă pentru caracterizarea complexităţii unei clase importante
de probleme de calculabilitate. De asemenea, această definiţie subliniază faptul că o MT
nedeterministă decide aupra unui limbaj L dacă toate ramurile sale de calcul se opresc,
indiferent de intrarea primită.
MT deterministă MT nedeterminsită
. .
f(n) . .
f(n)
. .
acceptă
acceptă / respinge respinge
4.20. Teoremă
Fie t : N  N cu proprietatea că () n  N : t(n)  n.
Atunci, orice MT N nedeterministă cu o singură bandă de intrare şi cu timp de lucru t(n)
admite o MT D determinsită cu o singură bandă de intrare şi cu timp de lucru 2O(t(n)),
echivalentă.
Demonstraţie
Fie N o MT nedeterministă cu o singură bandă de intrare care rulează în timp t(n), unde
t : N  N , t(n)  n, () nN .
Construim (după metoda utilizată în demonstraţia Teoremei 1.11) o MT D deterministă
cu o singură bandă de intrare care să simuleze N şi analizăm timpul de lucru care îi este
necesar pentru aceasta.
38
Iniţial, am construit o MT deterministă D’ cu 3 benzi de lucru care poate fi apoi convertită

intr-o MT deterministă D cu o singură bandă (după metoda dată în demonstraţia
Teoremei 1.9; în plus, acum ştim deja că timpul de calcul necesar acestei ultime conversii
este – conform Teoremei 4.17 – pătratul timpului de lucru al MT cu mai multe benzi).
Fie un cuvânt de intrare oarecare w de lungime n  îi putem asocia un arbore de

derivare care să figureze toate posibilităţile de calcul efectuate de N pentru w. Acest
arbore de derivare are următoarele caracteristici:
(i) lungimea maximă a ramurilor de calcul (lungimea drumului de la rădăcină la o frunză)
este de maximum t(n);
(ii) numărul maxim de descendenţi ai unui nod oarecare este b, unde b = cardinalul
maxim al unei imagini din definiţia funcţiei de tranziţie a lui N:
: Q x   P (Q x  x { L , R }).
(iii) numărul maxim de frunze din acest arbore este bt(n) (conform (i) şi (ii));
(iv) numărul total de noduri din acest arbore este mai mic decât dublul numărului de
frunze, adică inferior lui 2.bt(n)  nr total de noduri din acest arbore este de ordin O(bt(n)).
Analizăm acum, din punctul de vedere al timpului de calcul necesar, modul în care D
simulează N.
 Simularea presupune explorarea arborelui de derivare; cum N este decidentă,
înseamnă că se opreşte pentru orice intrare, deci putem folosi oricare dintre metodele de
parcurgere (chiar şi Depth First!! alegem totuşi parcurgerea Breadth First, adică vom vizita
toate nodurile de pe nivelul d înainte de a vizita un nod oarecare de pe nivelul d+1).
Putem începe parcurgerea arborelui de la rădăcină şi continua de-a lungul oricărui drum
către o frunză, oricât de ineficientă ar fi această tehnică – expusă în demonstraţia
Teoremei 1.11). Conform observaţiilor (i) – (iv), timpul necesar acestei parcurgeri (de la
rădăcină la un nod oarecare) este de ordinul O(t(n)) şi deci timpul de lucru al MT D’
(deterministă cu 3 benzi) este de ordinul O(t(n)bt(n)) = 2O(t(n)) (vezi Observaţia 4.7).
 Conversia lui D’ într-o MT D deterministă cu o singură bandă produce, conform
Teoremei 4.17) o anumită creştere a timpului de calcul: de la O(t(n)) la O(t2(n)).
 Prin urmare, timpul de calcul total necesar conversiei unei MT nederministe cu o
singură bandă într-o MT deterministă cu o singură bandă este de
(2 O(t (n)) ) 2  2 O(2t (n))  2 O(t (n))
q.e.d.
4.5. Clasa P
Cele două teoreme de mai sus au ilustrat distincţii importante din punctul de vedere al
complexităţii între diferite modele de calculabilitate:
 complexitatea timp a problemelor se modifică cu un factor polinomial (o ridicare la
pătrat) atunci când trecem de la MT cu mai multe benzi la MT cu o singură bandă (ambele
deterministe);
 complexitatea timp a problemelor se modifică cu un factor exponenţial atunci când
trecem de la MT nedeterministe la MT deterministe (ambele cu o singură bandă).
În continuare, vom cerceta această diferenţă mai pe larg.

4.5.1. Timpul polinomial
Diferenţa dintre un algoritm cu timp de lucru polinomial şi unul cu timp de lucru
exponenţial este foarte importantă. Chiar pentru valori mici ale datelor de intrare (de
exemplu, n = 1000) un algoritm cu complexitatea n3 poate rula şi pe un calculator cu
39
performanţe rezonabile deoarece necesită resurse de ordinul unui miliard în timp ce un

algoritm cu complexitate 2n ar avea nevoie de resurse de ordinul 21000, număr care
depăşeşte cu mult numărul de atomi din Univers!!
Algoritmii cu timp de lucru polinomial sunt – în majoritatea cazurilor – suficient de rapizi

(eficienţi), indiferent de gradul polinomului şi de coeficienţii implicaţi; algoritmii exponenţiali
sunt însă arareori utilizabili în practică. Algoritmii exponeţiali apar atunci când rezolvarea
problemei propuse presupune o căutare brută (cercetarea exhausitivă, secvenţială a
tuturor posibilităţilor, ca în cazul descompunerii unui număr în factori primi prin aplicarea
definiţiei: domeniul de căutare a divizorilor creşte exponenţial cu numărul care trebuie
descompus).
Toate modelele de calculabilitate deterministe “rezonabile” sunt polinomial echivalente,

adică simularea unuia cu instrumentele celuilalt antrenează doar o creştere polinomială a
timpului de lucru (nu putem formaliza termenul “rezonabil” dar îl înţelegem în sensul unei
bune aproximări, corelaţii cu calculatoarele din lumea reală).
În continuare ne vom concentra asupra acelor aspecte ale teoriei complexităţii-timp care
nu sunt afectate, în ceea ce priveşte timpul de lucru, de diferenţe de tip polinomial (le
considerăm nesemnificative şi le ignorăm, adică: dacă atunci când am introdus notaţia
asimptotică O am ignorat factorii constanţi, acum, în aproximarea timpului de lucru,
ignorăm diferenţe polinomiale şi mai importante, precum cea dintre n şi n3)
 vom putea dezvolta teoria complexităţii timp într-un mod care să nu fie dependent de
modelul de calculabilitate ales (scopul nostru este cercetarea proprietăţilor fundamentale
ale calculabilităţii şi mai puţin a proprietăţilor MT sau a altui model particular).
Această decizie nu implică desconsiderarea diferenţelor de ordin polinomial în execuţia

algoritmilor (ştim bine cât de importantă este pentru programatori chiar o reducere cu 50%
a timpului de execuţie al unui program), ci doar că am ales această aboradare – a
distincţiei dintre timpul de lucru polinomial şi timpul de lucru exponenţial – şi nu alta.
4.21. Definiţie
Notăm cu P clasa limbajelor decidabile în timp polinomial de către MT deterministe
cu o singură bandă de intrare:
P TIME (n k )

k N
Această clasă de probleme are următoarele proprietăţi:

(a) este invariantă faţă de toate modelele de calculabilitate care sunt polinomial
echivalente cu MT deterministe cu o singură bandă de intrare;
(b) corespunde clasei de probleme practic rezolvabile cu un calculator real.
Proprietatea (a) arată că P este o clasă robustă (nu este afectată de modelul de
calculabilitate particular ales);
Proprietatea (b) arată că P are relevanţă practică. Dacă o problemă P  P , înseamnă
că dispunem de o metodă de a o rezolva în timp nk, pentru un k  N corespunzător.
Dacă putem sau nu să utilizăm efectiv metoda, aceasta depinde de valoarea lui k.
Evident, un timp de lucru de ordinul n1000 nu este prea utilizabil în realitate. Totuşi,
stabilirea graniţei rezolvabilităţii practice la nivelul polinomial s-a dovedit foarte utilă: odată
ce pentru o problemă cu timp de calcul exponenţial s-a decoperit un algoritm de rezolvare
cu timp de lucru polinomial înseamnă că s-a descoperit aspectul (cauza) care făcea
problema dificil de rezolvat (Atenţie: nu am răspuns astfel întrebării din cursul introductiv!!)
40
şi, în continuare, complexitatea algoritmului polinomial va putea fi redusă astfel încât

problema să devină efectiv rezolvabilă.
4.5.2. Exemple de probleme cu timp de calcul polinomial
4.22. Câteva precizări
 vom descrie algoritmii, tot ca în cazul MT, cu ajutorul etapelor şi paşilor;
 vom calcula timpul de lucru al algoritmilor în 2 trepte:
o vom căuta o limită superioară a numărului de etape şi paşi executaţi de algoritm pe
o intrare oarecare n  N,
o vom examina fiecare pas al algoritmului pentru a determina dacă poate fi
implementat în timp polinomial, cu ajutorul unui model de calculabilitate determinist,
“rezonabil”,
o cum compunerea a 2 polinoame este încă un polinom, vom putea conchide că
algoritmul rulează în timp polinomial;
 vom utiliza o metodă “rezonabilă” de codificare a problemelor: vom folosi tot
codificarea sub forma unei secvenţe pe care o vom nota cu < >. Vom aprecia că o
metodă de codificare este “rezonabilă” dacă ea foloseşte un timp de lucru polinomial (de
exemplu, codificarea numărului natural 17 ca o secvenţă de 17 simboluri 1 nu este
rezonabilă pentru că timpul de codificare creşte exponenţial cu valoarea datei de intrare!!).
În general, metodele clasice de codificare a grafurilor, mulţimilor, automatelor etc., sunt
“rezonabile”: matricea de adiacenţă, lista nodurilor şi a muchiilor, etc. Cum, în ambele
aceste reprezentări ale grafurilor, dimensiunea grafului (şi deci a reprezentării) este
determinată în mod esenţial de numărul de noduri, vom aprecia complexitatea timp a unor
probleme de grafuri în raport cu numărul de noduri ale grafului şi nu cu lungimea
reprezentării acestuia.
Prima problemă pe care o studiem se numeşte PATH şi constă în a determina existenţa

unui drum între două noduri oarecare s, t ale unui graf G.
4.23. Teoremă
PATH = { <G,s,t> | G este un digraf în care există un drum de la nodul s la nodul t }  P.
Demonstraţie
Un algoritm care rezolvă problema prin căutare directă nu este suficient de rapid: el
trebuie să examineze toate drumurile din G pentru a veda dacă există unul, orientat, de la
s la t , adică trebuie să examineze un număr de mm drumuri, unde m = numărul de
noduri din G (cel mai lung drum – cel hamiltonian – are m noduri, pentru că ciclurile nu
sunt nici semnificative nici permise)
 acest algoritm este exponenţial, deci neinteresant.
Pentru a evita căutarea brută vom utiliza una dintre metodele de parcurgere a grafului, de
exemplu Breadth First, şi vom marca toate nodurile care pot şi atinse din nodul s prin
drumuri de lungime 1 (arce), 2, 3, … , m. Vom demonstra că această strategie este
limitată superior de un polinom.
Formalizare
Următorul algoritm rezolvă problema PATH în timp polinomial:
M = “Fie secvenţa de intrare <G,s,t>, unde G este un digraf oarecare iar s şi t două
noduri oarecare ale sale:
1. Se marchează nodul s.
2. Se repetă pasul următor atât timp cât mai există noduri nemarcate:
3. Se examinează toate arcele din G : dacă există un arc (a,b) de la nodul marcat
a la nodul nemarcat b atunci se marchează nodul b.
41
4. Dacă t este marcat atunci M acceptă secvenţa de intrare <G,s,t>, altfel respinge.”
Analizăm complexitatea timp a acestui algoritm:

(i)
o evident, prima şi ultima etapă se execută o singură dată;
o etapa a 3a se execută de cel mult m ori (pentru că de fiecare dată – cu excepţia
ultimeia – se marchează un nod din G iar G are, prin ipoteză, m noduri;
 numărul total de paşi este 1 + m + 1, deci O(m).
(ii)
o prima şi ultima etapă se implementează uşor în timp polinomial, în oricare dintre
modelele deterministe “rezonabile”;
o etapa a 3a presupune o scanare a nodurilor şi o testare a stării acestora: marcat /
nemarcat; deci şi aceste operaţii se pot implementa în timp polinomial
 complexitatea timp a acestui algoritm de rezolvare a problemei PATH este polinomială
în raport cu numărul de noduri ale grafului q.e.d.
4.24. Teoremă
RELPRIME = { <x,y> | x, y  N şi (x,y) = 1 }  P.
Demonstraţia: exerciţiu
4.25. Teoremă
Orice limbaj independent de context11 este decidabil în timp polinomial, adică
() L  LIC  L  P .
Demonstraţia: se utilizează metoda programării dinamice; timpul de calcul este de ordin

O(n3), unde n = lungimea cuvântului de intrare.
4.6. Clasa NP
Dacă pentru unele probleme cu timp de calcul exponenţial s-au găsit – mai uşor sau mai
greu – algoritmi care rulează în timp polinomial, pentru altele astfel de algoritmi nu s-au
găsit încă. MOTIVUL NU ESTE CUNOSCUT:
o poate pentru unele dintre ele astfel de algoritmi polinomiali există dar nu au fost încă
descoperiţi pentru că – probabil – folosesc principii şi metode încă necunoscute;
o poate că unele dintre ele pur şi simplu nu pot fi rezolvabile în timp polinomial (sunt
intrinsec dificile).
Totuşi, cu privire la aceste probleme a fost făcută o constatare remarcabilă:
asemenea rezolvabilităţii algoritmice şi complexitatea unor probleme se

află în strânsă relaţie cu complexitatea altora
 descoperirea unui algoritm polinomial pentru o astfel de problemă va
permite rezolvarea în timp polinomial a unei clase întregi de probleme.
Vom studia mai atent acest fenomen, începând cu un exemplu, numit HAMILTPATH.
Această problemă constă în a determina existenţa unui drum hamiltonian12 (orientat) între
două noduri oarecare s şi t ale unui digraf G.
11
LIC = clasa limbajelor independente de context
12
Un drum hamiltonian într-un digraf G este un drum care trece prin fiecare nod al digrafului o
data şi numai o dată.
42
Formalizat:
HAMILTPATH = {<G,s,t> | G este un digraf care conţine un drum hamiltonian de la s la t}
În demonstraţia Teoremei 4.23 (PATH  P ) algoritmul de căutare brută (exponenţial) a

fost înlocuit cu un alt algoritm, polinomial. Dacă modificăm algoritmul de căutare directă
astfel încât să verificăm nu numai existenţa unui drum de la s la t ci şi faptul că acesta
trece prin fiecare nod din G exact o singură dată, am rezolvat problema dar în timp
exponenţial!! Nu se cunoaşte încă un algoritm polinomial care să rezolve HAMILTPATH.
Această problemă are o caracteristică interesantă:

 nu este rezolvabilă în timp polinomial dar
 este verificabilă în timp polinomial.
(dacă determinăm existenţa un drum hamiltonian de la s la t - indiferent cum! – putem
apoi verifica existenţa lui în timp polinomial, verificând pur şi simplu că fiecare nod apare o
dată şi numai o dată – adică un test care se execută în timp O(m2), unde m = numărul de
noduri din G).
O altă problemă verificabilă în timp polinomial este problema neprimalităţii unui număr (a
caracterului său de număr compus). Formalizat:
COMPOSITES = { x  N | () p, q  N, p, q > 1 astfel încât x = p.q }
Deşi nu se cunoaşte un algoritm polinomial care să decidă asupra acestui limbaj (care să
rezolve problema neprimalităţii), verificarea caracterului compus al unui număr natural se
poate face foarte uşor (în timp polinomial): e sufiecient să dispunem de un divizor propriu
al acelui număr13.
4.26. Observaţie
Există şi probleme neverificabile în timp polinomial. De exemplu, complementul problemei
drumului hamiltonian, HAMILTPATH : Să presupunem că găsim un algoritm care să
determine inexistenţa unui drum hamiltonian într-un digraf G; singura metodă prin care
altcineva poate verifica inexistenţa unui astfel de drum constă tot în aplicarea aceluiaşi
algoritm exponenţial care a determinat inexistenţa drumului.
4.27. Definiţie
Un verificator pentru limbajul L este un algoritm V cu proprietatea:
L = { w  * | () v  * astfel încât V acceptă <w,v> }
Măsurăm timpul necesar unui verificator în funcţie de lungimea cuvântului w 
Un verificator polinomial rulează în timp polinomial faţă de lungimea cuvântului w.
Un limbaj L este polinomial verificabil dacă admite un verificator polinomial.
4.28. Observaţie
Cuvântul v  * din Definiţia 4.27 reprezintă informaţia auxiliară utilizată de verificator
pentru a verifica apartenenţa cuvântului w  * la limbajul L. Acest cuvânt se numeşte
certificat sau dovadă a apartenenţei la L.
Să remarcăm faptul că, în cazul verificatoarelor polinomiale, certificatele au o lungime
polinomială în funcţie de lungimea lui w deoarece aceasta este singura informaţie
accesibilă verificatoarelor în timpul limitat de care dispun.
13
De curând a fost descoperit un algoritm de determinare a caracterului compus sau prim al unui
număr; acest algoritm este insă mult mai complicat decât metoda de verificare a caracterului
compus al unui număr, descrisă mai sus.
43
4.29. Exemple
 În cazul problemei HAMILTPATH, certificatul corespunzător secvenţei de intrare
<G,s,t>  HAMILTPATH este însuşi drumul hamiltonian de la s la t.
 În cazul problemei COMPOSITES, certificatul corespunzător numărului natural x 
COMPOSITES este unul dintre divizorii acestuia.
În ambele cazuri, dându-se certificatele corespunzătoare, verificatoarele pot verifica în
timp polinomial apartenenţa la limbajul respectiv a secvenţelor de intrare.
4.30. Teoremă
Pentru orice verificator polinomial putem construi o MT nedeterministă cu timp de lucru
polinomial echivalentă şi reciproc.
Demonstraţie
O MT nedeterministă cu timp de lucru polinomial (pe scurt: o MT nedeterminsită
polinomială) simulează un verificator polinomial “ghicind” certificatul.
Un verificator simulează o MT nedeterministă polinomială folosind ca certificat ramura de
calcul care acceptă.
“”
Fie L un limbaj care admite un verificator V polinomial.
Presupunem că V este o MT care rulează în timp nk şi construim MT N astfel:
N = “Fie cuvântul de intrare w  *, |w| = n:
1. Selectăm în mod nedeterminist un cuvânt v de lungime cel mult nk.
2. Se rulează V pe intrarea <w,v>.
3. Dacă V acceptă <w,v> atunci şi N acceptă w; altfel respinge.”
Din construcţia de mai sus rezultă imediat că N decide asupra limbajului L în timp
polinomial şi este echivalentă cu V.
““
Fie L un limbaj şi N o MT nedeterministă care rulează în timp polinomial şi decide
asupra limbajului L .
Construim un verificator V polinomial pentru L astfel:
V = “Fie secvenţa de intrare <w,v>, unde w, v  *, oarecari:
1. Se simulează N pe intrarea w; fiecare simbol din v este tratat ca o descriere a
alegerii următorului nod din arborele de derivare (alegere care trebuie făcută la
fiecare pas; a se vedea demonstraţia Teoremei 1.11).
2. Dacă această ramură de calcul a lui w din N acceptă atunci şi V acceptă intrarea
<w,v>, altfel respinge.”
Din construcţia de mai sus rezultă imediat că verificatorul V este polinomial şi echivalent
cu N. q.e.d.
4.31. Definiţie
Fie t : N  N. Se defineşte clasa de complexitate NTIME (timp polinomial
nedeterministic) prin:
NTIME(t(n)) = { L  * | () o MT nedeterministă care decide asupra limbajului L
în timp O(t(n)) }
4.32. Definiţie
NP este clasa limbajelor care admit verificatoare polinomiale.
NP este clasa limbajelor decidabile în timp polinomial de către MT nedeterministe14 cu o
singură bandă de intrare:
14
Conform Teoremei 4.30
44
NP   NTIME (n k )
k N
4.33. Observaţie
Importanţa clasei NP rezidă în faptul că ea inglobează o serie intreagă de probleme
importante din punct de vedere practic. Şi ea este invariantă la alegerea oricărui model de
calculabilitate “rezonabil” (deoarece toate aceste modele sunt polinomial echivalente).
Vom descrie şi analiza algoritmii nedeterminişti cu timp de calcul polinomial după metoda
folosită în cazul algoritmilor polinomiali determinişti:
 arătăm că fiecare etapă a algoritmului are o implementare în timp polinomial
nedeterminist într-un model de calculabilitate nedeterminist “rezonabil”;
 arătăm că implementarea fiecărei ramuri de calcul necesită un număr de etape de
ordin polinomial.
4.6.1. Exemple de probleme cu timp de calcul polinomial
nedeterminist
4.34. Teoremă
HAMILTPATH = { <G,s,t> | G este un digraf care conţine un drum
hamiltonian de la s la t }  NP.
Demonstraţie
Construim o MT nedeterminsită NH care să decidă asupra limbajului HAMILTPATH în
timp polinomial.
Conform Definiţiei 4.19, timpul de lucru al unei MT nedeterministe este dat de numărul de
paşi necesari celei mai lungi dintre ramurile calculului nedeterminist. Atunci, definim NH
astfel:
NH = “Fie secvenţa de intrare <G,s,t>, unde G este un digraf oarecare iar s, t sunt oricare
două dintre nodurile sale:
1. Se compune o listă de m numere naturale p1, p2, … , pm, unde m = numărul de
noduri ale G. Fiecare număr din listă este ales nedeterminist din mulţimea
{1, 2, …, m}.
2. Dacă lista conţine repetiţii, atunci NH respinge intrarea.
3. Se verifică dacă s = p1 şi t = pm; dacă oricare dintre condiţii nu are loc, atunci NH
respinge intrarea.
4. Pentru fiecare i : 1  i  m-1, se verifică dacă (pi, pi+1) este un arc din G; dacă cel
puţin una dintre condiţii nu are loc atunci NH respinge intrarea <G,s,t>; dacă toate
condiţiile sunt îndeplinite atunci NH acceptă.”
Analizăm acest algoritm din punct de vedere al complexităţii timp:

 prima etapă constă dintr-o generare nedeterministă a numerelor p1, p2, … , pm dintre
numerele 1, 2, … , m  timp de lucru polinomial nedeterminist;
 etapa a doua constă din găsirea unei repetiţii, cel puţin, deci se fac teste de tipul
pi=pj, unde i = 1, 2, … , m-1 şi j = i+1, … , m  se execută cel mult m2 teste;
 etapa a treia constă din 2 verificări  un factor constant egal cu 2;
 etapa a patra constă din verificarea fiecăreia dintre cele m.(m-1) perechi de numere
generate nedeterminist (pi, pi+1) cu cele maximum m.(m-1) arce din G  se execută
cel mult m4 teste.
 algoritmul rulează în timp polinomial nedeterminist.
O altă problemă de teoria grafurilor, problema clicilor, constă în a determina dacă un

graf dat conţine o clică de o anumită dimensiune.
45
4.35. Teoremă15
CLIQUE = { <G,n> | G este un graf care conţine o n-clică }  NP.
O problemă de aritmetica numerelor întregi, problema submulţimilor sumă, constă în a

determina dacă un multiset dat conţine un submultiset ale cărui elemente însumate sunt
egale cu un număr natural dat.
4.36. Teoremă16
SUBSET-SUM = { <S,t> | S = {x1, x2, … , xk} şi () {y1, y2, … , yn}  {x1, x2, … , xk}
astfel încât yi = t }
De remarcat că {x1, x2, … , xk} şi {y1, y2, … , yn} sunt multiseturi nu mulţimi obişnuite.
De exemplu, < {4,11,16,21,27} , 25 >  SUBSET-SUM deoarece 4 + 21 = 25
Nu rezultă imediat că mulţimile CLIQUE şi SUBSET SUM fac parte din NP. E mai
dificil să verificăm absenţa unui elemnt decât prezenţa lui într-o mulţime!
4.37. Definiţie
coNP este clasa limbajelor care sunt complementarele unor limbaje din NP.
Nu se ştie dacă coNP este diferit de NP.
4.7. Problema P versus NP

Problema dacă P = NP este una dintre cele mai importante probleme nerezolvate din
informatica teoretică şi din matematicile contemporane.
Reamintim:
 P = clasa limbajelor pentru care apartenenţa poate fi decisă în timp de lucru
polinomial determinist;
 NP = clasa limbajelor pentru care apartenenţa poate fi decisă în timp de lucru
polinomial nedeterminist (sau verificată în timp de lucru polinomial determinist).
 am considerat – informal – că rezolvabilitatea în timp polinomial este o rezolvabilitate
rapidă.
Puterea verificatoarelor polinomiale pare mult mai mare decât puterea MT decidente
polinomiale. Puterea MT nedeterministe pare, de asemenea, mai mare decât a MT
deterministe (Teorema 1.11 a demonstrat echivalenţa lor dar Teorema 4.20 a arătat
diferenţa în timpul de lucru), în sensul că există probleme pentru care nu se cunosc
algoritmi determinişti polinomiali de rezolvare dar se cunosc algoritmi nedeterminişti
polinomiali. Pe de altă parte, nu putem demonstra că există măcar un limbaj care este în
NP dar nu este în P.
 există argumente atât în favoarea tezei P  NP cât şi în favoarea tezei P = NP .
15
Fie G un graf neorientat. O clică în G este un subgraf al lui G cu proprietatea că între oricare
două noduri ale sale există o muchie. O n-clică este o clică având n noduri.
Problema clicii constă în a determina dacă un graf dat conţine o clică de o anumită dimensiune.
16
Fie G un graf neorientat. O clică în G este un subgraf al lui G cu proprietatea că între oricare
două noduri ale sale există o muchie. O n-clică este o clică având n noduri.
Problema clicii constă în a determina dacă un graf dat conţine o clică de o anumită dimensiune.
46
Curios, pare mai dificil de demonstrat că P  NP pentru că ar însemna să demonstrăm

că nu există un algoritm rapid (cu timp de lucru polinomial determinist) care să inlocuiască
cautarea directă.
Cea mai bună metodă cunoscută în prezent pentru a rezolva probleme din clasa NP în
mod determinist necesită timp de lucru exponenţial
 putem demonstra că:
k
NP  EXPTIME   TIME(2 n )
k N
dar nu ştim dacă NP este conţinută într-o clasă de complexitate timp deterministă mai
mică decât EXPTIME.
4.38. Terminologie
Totuşi, din motivul de mai sus şi pe baza Teoremei 4.20, putem face un “abuz” şi putem
să ne referim în continuare la NP
 fie ca la clasa problemelor rezolvabile algoritmic în timp polinomial nedeterminist,
 fie ca la clasa problemelor rezolvabile algoritmic în timp exponenţial determinist.
Mai mult, în continuare, vom considera

 P drept clasa problemelor rezolvabile algoritmic în timp de lucru polinomial
(determinist),
 NP drept clasa problemelor rezolvabile algoritmic în timp de lucru exponenţial
(determinist).
Dăm fără demonstraţie următoarea teoremă17:
4.39. Teoremă
P  NP  coNP
De fapt, se crede că P  NP  coNP .
Figura de mai jos descrie relaţiile despre care se presupune că există între clasele de
complexitate definite mai sus. Se crede că toate incluziunile sunt stricte; singurul caz în
care se poate şi demonstra este P  EXPTIME.
EXP
NP coNP
P coNP-complete
NP-complete
17
CP
47
4.8. NP-completitudine18
4.8.1. Importanţa fenomenului
Un pas important în problema relaţiei dintre clasele P şi N a fost făcut la începutul anilor
1970 de către cercetătorii Stephen COOK şi Leonid LEVIN: ei au identificat o serie de
probleme din clasa NP a căror complexitate proprie este strâns legată de complexitatea
întregii clase.
Dacă s-ar descoperi un algoritm cu timp de lucru polinomial pentru oricare dintre aceste
probleme,atunci toate problemele din NP ar fi rezolvabile în timp polinomial (determinist).
De aceea, aceste probleme se numesc NP-complete.
Fenomenul NP-completitudinii este important din punct de vedere:

 teoretic:
o un cercetător care încearcă să demonstreze că P  NP ar trebui să se
concentreze asupra unei probleme NP-complete (dintre problemele din NP ,
acestea sunt cele care solicită mai mult decât restul problemelor, un timp de lucru
superior celui polinomial),
o un cercetător care încearcă să demonstreze că P = NP şi-ar atinge scopul prin
simpla găsire a unui algoritm polinomial (determinist) pentru una dintre problemele
NP-complete;
 practic:
o fenomenul NP-completitudinii poate evita pierderea timpului cu căutarea unui
algoritm polinomial (determinist) pentru o anumită problemă, algoritm care de fapt
nu există.
Deşi nu putem încă demonstra că o anumită problemă este nerezolvabilă algoritmic în

timp polinomial, credem că P  NP  demonstrarea faptului că o problemă este NP-
completă este o dovadă puternică a caracterului ei nepolinomial.
4.8.2. Un exemplu de problemă NP-completă
4.39. Definiţii
O formulă booleeană este o expresie care conţine variabile booleene, constantele
booleene 0 şi 1 şi operatorii booleeni , ,  .
O formulă booleană (de exemplu: (x  y)  (x  z) se numeşte evaluabilă  există o
combinaţie de valori de adevăr care, date variabilelor booleene din formulă, evaluează
formula la valoarea 1 (altfel spus: “fac formula adevărată”). Spunem că acea combinaţie
de valori satisface formula.
Problema evaluării19 (sau a satisfiabilităţii) constă în a verifica dacă o formulă booleeană

oarecare este evaluabilă20 (satisfezabilă) şi se codifică prin:
SAT = { <  > |  este o formulă booleeană evaluabilă }
4.40. Teoremă (Cook-Levin)

SAT  P  P = NP
Demonstraţie
Metoda folosită este reductibilitatea polinomială a timpului de lucru, unde
18
MS
19
Satisfiability Problem
20
satisfiable
48
4.41. Definiţie
Funcţia f: *  * se numeşte calculabilă în timp polinomial (prescurtat: polinomial
calculabilă)  există o MT cu timp de lucru polinomial care, oricare ar fi secvenţa de
intrare w  *, se opreşte, având pe bandă secvenţa f(w).
4.42. Definiţie
Fie limbajele A, B  *. Limbajul A se numeşte reductibil funcţional în timp
polinomial (prescurtat polinomial reductibil) la limbajul B şi se notează prin A P B
 () f : *  * polinomial calculabilă astfel încât () w  *: w  A  f(w)  B.
Funcţia f se numeşte reducerea polinomială a lui A la B.
Rezumat
49
Clasa de complexitate SPATIU
5. Clasa de complexitate SPATIU

5.1. Definiţii şi exemple introductive
În continuare, vom evalua complexitatea problemelor computaţionale din punctul de
vedere al spaţiului (sau memoriei) pe care îl folosesc.
Motivul: timpul şi spaţiul sunt doi dintre cei mai importanţi parametri care trebuie luaţi în
considerare atunci când se caută soluţii efective pentru cele mai multe dintre problemele
de calcul.
Deşi complexitatea spaţiu seamănă în multe privinţe cu complexitatea timp, ea oferă

posibilităţi noi de clasificare a problemelor din punctul de vedere al complexităţii lor
computaţionale.
Şi în cazul complexităţii spaţiu este necesar un model de calculabilitate (care să permită

măsurarea spaţiului folosit de un algoritm). Vom utiliza tot modelul maşinii Turing pentru
că este simplu din punct de vedere matematic şi foarte apropiat de calculatorul real.
5.1. Definiţie
(i) Fie M o MT deterministă care se opreşte, oricare ar fi secvenţa pe care o primeşte pe
banda de intrare.
Se numeşte complexitatea spaţiu determinist a M o funcţie
f : N  N , f(n) = numărul maxim de locaţii de pe banda de intrare pe care le scanează
M atunci când primeşte o secvenţă de intrare de lungime n, ()nN.
Mai spunem că M rulează într-un spaţiu de memorie egal cu f(n).
(ii) Fie M o MT nedeterministă în care oricare dintre ramurile calculului nedeterminist se

opreşte, oricare ar fi secvenţa pe care o primeşte pe banda de intrare.
Se numeşte complexitatea spaţiu nedeterminist a M o funcţie
f : N  N , f(n) = numărul maxim de locaţii de pe banda de intrare pe care le scanează
M de-a lungul oricăreia dintre ramurile de calcul atunci când primeşte
o secvenţă de intrare oarecare, de lungime n, () nN.
5.2. Observaţie
Vom estima complexitatea spaţiu a maşinilor Turing tot cu ajutorul notaţiei asimptotice.
5.3. Definiţie
Fie f : N  R+. Definim clasele de complexitate SPACE(f(n)) şi NSPACE(f(n)) astfel:
SPACE(f(n)) = { L  * | () o MT deterministă care decide asupra limbajului L
într-un spaţiu O(f(n)) }
NSPACE(f(n)) = { L  * | () o MT nedeterministă care decide asupra limbajului L
într-un spaţiu O(f(n)) }
5.4. Exemple
(1) Una dintre cele mai cunoscute probleme NP-complete este SAT (problema evaluării:
satisfiability problem). Am afirmat că SAT nu poate fi rezolvată cu un algoritm cu timp de
lucru polinomial (şi cu atât mai puţin cu un algoritm cu timp de lucru linear).
Vom da aici un algoritm pentru rezolvarea SAT cu spaţiu linear. O justificare: spre
deosebire de timp, spaţiul poate fi refolosit  resursa spaţiu pare să fie mai puternică
decât resursa timp.
50
Definim următoarea MT deterministă cu o singură bandă:

M1 = “Fie secvenţa de intrare <  >, unde  este o formulă booleeană oarecare:
1. Pentru fiecare combinaţie de valori de adevăr atribuite variabilelor booleene
x1, x2, … , xm din  :
2. Se evaluează valoarea de adevăr a formulei .
3. Dacă  se evaluează la 1, atunci M1 acceptă secvenţa de intrare; altfel, respinge.
Observăm că la fiecare iteraţie a etapei a doua M1 utilizează aceeaşi porţiune a benzii de

intrare pentru că M1 trebuie să memoreze numai combinaţia curentă de valori de adevăr
ale variabilelor x1, x2, … , xm  spaţiul necesar este de ordinul O(m). Cum numărul de
variabile m este măriginit superior de n (adică de lungimea secvenţei de intrare),
înseamnă că M1 rulează în spaţiu de ordinul O(n).
(2) Ilustrăm complexitatea spaţiu nedeterministă a unui limbaj, tratând o”complementară”

a problemei limbajului vid: problema limbajului universal:
Fie un automat finit nedeterminist (AFN) A . Vrem să verificăm dacă el acceptă toate
secvenţele din *. Codificăm această problemă prin următorul limbaj
ALLAFN = { <A> | A este un AFN oarecare şi L(A) = * }
Ideea soluţiei
Construim un algoritm nedeterminist cu spaţiu linear care să decidă asupra
complementarei acestui limbaj, ALL AFN astfel:
 se utilizează nedeterminismul pentru a “ghici” o secvenţă respinsă de AFN;
 se utilizează un spaţiu de lucru linear pentru a ţine evidenţa stărilor prin care poate
trece AFN la diferite momente de timp;
Observăm că nu se ştie dacă ALL AFN  NP sau ALL AFN  coNP .
Soluţie
N = “Fie secvenţa de intrare <A>, unde A este un AFN:
1. Se marchează starea iniţială a lui A.
2. Se repetă etapa a treia de 2q ori, unde q = numărul de stări ale A.
3. Se selectează nedeterminist un simbol de intrare şi se remarchează stările lui A
pentru a simula citirea acelui simbol.
4. Dacă în etapele 2 şi 3 apare o secvenţă pe care A o respinge (adică dacă la un
moment dat nici una dintre stările de acceptare ale lui A nu este marcată) atunci N
acceptă secvenţa de intrare <A>; altfel o respinge.”
Dacă există secvenţe din * pe care A le respinge atunci printre ele trebuie să se afle
una de lungime cel mult 2q , deoarece în cazul tuturor secvenţelor de lungime mai mare,
respinse de A, locaţiile markerilor descrişi în algoritmul de mai sus ar trebui să se repete
(A are prin ipoteză doar q stări). Porţiunea din secvenţă cuprinsă între repetiţii poate fi
eliminată pentru a se obţine astfel o secvenţă respinsă, mai scurtă. Prin urmare, N
decide asupra limbajului ALL AFN . (Se observă că N acceptă şi secvenţa de intrare
incorect formate.)
Acest algoritm necesită spaţiu de memorie suplimentar numai pentru stocarea locaţiilor
markerilor şi a contorului de ciclare, deci necesită spaţiu linear. Prin urmare, algoritmul
rulează în spaţiu nedeterminist de ordinul O(n).
Următoarea teoremă oferă informaţii despre complexitatea spaţiu determinist a

limbajului ALLAFN.
51
5.2. Teorema lui Savitch

Acesta este unul dintre primele rezultate privind complexitatea spaţiu. El arată că MT
deterministe (prescurtat MTD) pot simula MT nedeterministe (prescurtat: MTN) utilizând o
cantitate de memorie surprinzător de mică. Dacă din punct de vedere al complexităţii timp
o astfel de simulare pare să necesite un timp de lucru exponenţial, din punct de vedere al
complexităţii spaţiu creşterea este – conform Teoremei Savitch – de la ordinul f(n)
(spaţiul necesitat de MTN) la ordinul f2(n) (spaţiul necesitat de MTD).
5.5. Teorema lui SAVITCH

Fie o funcţie f: N  R+ cu proprietatea: f(n)  n
 NSPACE (f(n))  SPACE (f2(n))
Demonstraţie
Pentru a simula o MTN cu spaţiu de lucru de ordinul f(n) în mod determinist am putea
încerca să verificăm, una câte una, ramurile de calcul ale acelei MTN. Simularea trebuie
să marcheze ramura curent prelucrată pentru a putea trece la prelucrarea ramurii
următoare. Fiecare dintre aceste ramuri de calcul (care utilizează f(n) locaţii de pe banda
O(f(n))
de intrare) poate executa un număr de paşi de ordinul 2 iar fiecare pas ar putea fi
ales în mod nedeterminist.
 Examinarea secvenţială a ramurilor de calcul ar necesita – pentru fiecare ramură –
memorarea paşilor executaţi  ar fi nevoie de 2O(f(n)) locaţii de memorie, deci mult mai
mult decât O(f2(n))!
 Este necesară o altă abordare: vom rezolva o problemă mai generală, numită
PROBLEMA TRANZITIEI21: fie două configuraţii c1 = uaqrbv şi c2 = zcqsdw (a,b,c,d  ,
u,v,z,w  *, qr, qs  Q) ale unei MTN şi un număr t  N; trebuie să verificăm dacă MTN
poate trece din configuraţia c1 în configuraţia c2 în t paşi.
 Rezolvând PROBLEMA TRANZITIEI pentru
o c1 = configuraţia de start a MTN;
o c1 = configuraţia de acceptare a MTN;
o t = numărul maxim de paşi pe care îi poate face MTN.
putem verifica dacă MTN acceptă secvenţa de intrare primită.
Vom prezenta un algoritm determinist recursiv care rezolvă PROBLEMA TRANZITIEI.

Acest algoritm:
 caută o configuraţie intermediară cm,
 verifică recursiv dacă
o c1 trece în cm în t/2 paşi,
o cm trece în c2 în t/2 paşi.
Reutilizarea spaţiului necesar fiecăreia dintre cele două verificări recursive permite o
economie de spaţiu semnificativă.
Acest algoritm are nevoie de spaţiu pentru a memora informaţia din stiva recursivă.
Fiecare nivel al recurenţei utilizează pentru memorarea unei configuraţii un număr de
locaţii de memorie de ordinul O(f(n)). Adâncimea recurenţei este log(t), unde t = timpul
maxim utilizat de MTN pe o ramură oarecare de calcul. Stim că
t = 2O(f(n))  log(t) = O(f(n))
 simularea deterministă necesită O(f2(n)) locaţii de memorie.
21
Yieldability Problem
52
Formalizare
Fie N o MTN care decide asupra limbajului L în spaţiu f(n). Construim o MTD M care
să decidă asupra limbajului L. Maşina M va utiliza o procedură, TRANZ, care verifică
dacă o configuraţie oarecare a lui N poate produce o altă configuraţie într-un anumit
număr de paşi. Această procedură rezovă PROBLEMA TRANZITIEI descrisă mai sus.
(i) Definim procedura TRANZ

Fie w secvenţa de intrare primită de N,
t  N (pentru simplificare, putem presupune că t este o putere a lui 2),
c1, c2 două configuraţii oarecare ale N;
atunci, TRANZ(c1, c2, t) acceptă dacă N poate trece din configuraţia c1 în configuraţia c2
printr-un calcul nedeterminist cu maximum t paşi; altfel respinge.
TRANZ = “Fie datele de intrare c1, c2 şi t, ca mai sus:

1. Dacă t = 1 atunci se verifică direct dacă c1 = c2 sau dacă c1 trece în c2
într-un singur pas conform funcţiei de tranziţie a lui N.
Dacă oricare dintre cele două condiţii este îndeplinită atunci TRANZ acceptă;
dacă nici una dintre condiţii nu e îndeplinită atunci TRANZ respinge.
2. Dacă t > 1 atunci următoarele instrucţiuni se execută pentru fiecare
configuraţie cm a lui N pe intrarea w şi cu spaţiu de lucru f(n):
3. Se rulează TRANZ(c1, cm, t/2).
4. Se rulează TRANZ(cm, c2, t/2).
5. Dacă paşii 3 şi 4 se încheie ambii cu acceptare, atunci TRANZ
acceptă.
6. Dacă cel puţin unul dintre paşii 3 sau 4 se încheie cu respingere atunci
TRANZ respinge.”
(ii) Definim o MTD M care simulează N astfel:

 mai întâi modificăm N astfel încât atunci când N acceptă, N îşi goleşte banda de
intrare şi îşi deplasează cursorul în celula cea mai din stânga, intrând astfel într-o
configuraţie numită caccept;
 notăm cu cstart configuraţia de start a lui N pe intrarea w ;
 alegem o constantă d  N cu proprietatea că N are maximum 2df(n) configuraţii
care utilizează f(n) locaţii pe banda de intrare, unde n = |w|. Ca urmare, 2df(n) este o
limită superioară pentru timpul de lucru al oricărei ramuri de calcul a lui N pe intrarea w.
M = “Fie cuvântul de intrare w:

1. Furnizează rezultatul produs de TRANZ(cstart, caccept, 2df(n)).”
Justificare
Evident, algoritmul TRANZ rezolvă PROBLEMA TRANZITIEI şi, prin urmare, M
simulează corect N. Mai trebuie să demonstrăm că M lucrează cu spaţiu O(f2(n)).
La fiecare apel recursiv al TRANZ, procedura memorează în stivă numărul de ordine al

pasului de calcul curent precum şi valorile lui c1, c2 şi t pentru a le putea restaura la
revenirea din apelul recursiv. Ca atare, fiecare nivel de recurenţă utilizează un spaţiu de
lucru suplimentar de ordinul O(f(n)). În plus, fiecare nivel de recurenţă reduce
dimensiunea lui t la jumătate. Iniţial, t = 2df(n)  adâncimea recurenţei este O(log 2df(n))
sau O(f(n))  spaţiul de memorie total este O(f2(n)).
În justificarea de mai sus apare o dificultate tehnică: atunci când apelează procedura
TRANZ, algoritmul M trebuie să cunoască valoarea lui f(n). Soluţia constă în modificarea
53
lui M astfel încât M să încerce pe rând diverse valori pentru f(n): f(n) = 1, 2, 3, …Pentru
fiecare valoare f(n) = i algoritmul M modificat utilizează TRANZ pentru a verifica dacă
se poate ajunge în configuraţia de acceptare. De asemenea, M utilizează procedura
TRANZ pentru a verifica dacă N foloseşte cel puţin (i+1) locaţii, astfel:
fie f(n) = i; algoritmul M modificat utilizează procedura TRANZ pentru a verifica dacă N
poate ajunge din configuraţia de start în una dintre configuraţiile de lungime i+1:
dacă nici una dintre configuraţiile de lungime i+1 nu este atinsă atunci M respinge;
dacă este atinsă una dintre configuraţiile de lungime i+1 şi aceasta este o configuraţie de
acceptare atunci M acceptă;
dacă este atinsă una dintre configuraţiile de lungime i+1 şi aceasta nu este o configuraţie
de acceptare atunci M continuă cu f(n) = i+1.
q.e.d.
5.6. Observaţie
Teorema este adevărată şi pentru funcţii f: N  R+ cu proprietatea: f(n)  log(n).
5.3. Clasele PSPACE şi NPSPACE

Această clasă este analogul pentru complexitatea spaţiu al clasei P , relative la
complexitatea timp.
5.7. Definiţie
Notăm cu PSPACE clasa limbajelor decidabile în spaţiu polinomial de către MT
deterministe cu o singură bandă de intrare:
PSPACE  SPACE (n k )

k N
Notăm cu NPSPACE clasa limbajelor decidabile în spaţiu polinomial de către MT
nedeterministe cu o singură bandă de intrare:
NPSPACE   NSPACE (n k )
k N
5.8. Corolar
PSPACE = NPSPACE
Demonstraţie
Rezultă din Teorema lui Savitch şi din faptul că pătratul unui polinom este încă un
polinom.

Spre deosebire de complexitatea timp, unde problema P = NP este deschisă, aici, avem:
PSPACE = NPSPACE.
Conform exemplelor 5.4: SAT  SPACE(n) şi ALLAFN  coNSPACE(n). Conform

Teoremei Savitch, ALLAFN  SPACE(n2), deoarece clasele de complexitate spaţiu
determinist sunt închise la complementară. Prin urmare, ambele limbaje sunt în clasa
PSPACE.
5.10. Conjectura privind relaţia dintre diferitele clase de complexitate timp şi spaţiu
(i) P  PSPACE
Fie funcţia t: N  N, t(n)  n, () n  N; orice MT care rulează în timp t(n) poate
utiliza cel mult t(n) celule de pe banda de intrare deoarece la fiecare pas de calcul ea nu
poate examina decât cel mult o celulă.
54
(ii) NP  PSPACE
Cu un raţionament analog rezultă că NP  NPSPACE. Aplicând Observaţia 5.8
obţinem: NP  PSPACE.
(iii) Reciproc, putem găsi o majorare pentru complexitatea timp a unei MT în funcţie de
complexitatea spaţiu.
Stim că o configuraţie a unui automat (AFD, …, MT) constă dintr-o stare, o combinaţie de
simboluri de intrare (secvenţa de intrare de o anumită lungime, n) şi, eventual, poziţia
cursorului pe bandă. Se demonstrează că un automat linear mărginit (ALM) cu q stări
care citeşte un cuvânt de lungime n de pe banda de intrare şi care dispune de un alfabet
de intrare  cu s elemente poate avea cel mult q.n.sn configuraţii distincte.
Dacă generalizăm acest rezultat anterior rezultă imediat că o MT care utilizează f(n) locaţii
de memorie, unde f(n)  n, este o funcţie definită pe N cu valori în N, poate avea cel mult
O(f(n))
f(n).2 configuraţii distincte.
Am presupus că MT se opreşte indiferent de secvenţa de intrare primită  ea nu poate

repeta o configuraţie de mai multe ori
 o MT care utilizează f(n) locaţii de memorie trebuie să execute f(n).2O(f(n)) paşi de
calcul, deci:
k
PSPACE  EXPTIME  TIME(2 n )

k N
Din (i), (ii) şi (iii) rezultă că:

NP  PSPACE = NPSPACE  EXPTIME
P  PSPACE = NPSPACE  EXPTIME
5.11. Observaţie
Nu se ştie încă dacă vreuna dintre incluziuni nu este de fapt chiar o egalitate. S-ar putea
descoperi oricând o simulare asemănătoare celei din demonstraţia Teoremei lui Savitch
care să permită fuzionarea unora dintre aceste clase într-o singură clasă.
Pe de altă parte, se demonstrează că P  EXPTIME (curs 9)  cel puţin una dintre

incluziunile de mai sus este strictă dar nu se ştie care!! În fapt, cei mai mulţi cercetători
cred că toate incluziunile sunt stricte, adică acceptă diagrama de mai jos ca descriind cel
mai corect relaţia dintre clasele de complexitate timp şi spaţiu:
PSPACE=
P NP NPSPACE EXPTIME
55
5.4. PSPACE-completitudine
Am studiat problemele NP-complete şi am arătat că ele reprezintă categoria celor mai
dificile limbaje din clasa NP . Dacă o problemă este NP-completă atunci este destul de
sigur că ea nu este în clasa P (dacă ar fi, atunci clasele P şi NP ar fi egale).
Introducem o noţiune similară NP-completitudinii, dar pentru clasa PSPACE: PSPACE-

completitudinea.
5.12. Definiţie
Un limbaj B este PSPACE-complet dacă şi numai dacă satisface următoarele două
condiţii:
(1) B  PSPACE
(2) () A  PSPACE  A P B (A este polinomial reductibil la B)
Dacă limbajul B satisface numai condiţia (2) atunci spunem că el este PSPACE-dificil
(PSPACE-hard).
5.13. Observaţie
Motivul pentru care definim PSPACE-completitudinea tot în termenii reductibilităţii în timp
polinomial este legat de esenţa definiţiei problemelor complete: Problemele complete sunt
importante pentru că ele sunt exemple de probleme dintre cele mai dificile din clasa lor de
complexitate. O problemă completă este foarte dificilă pentru că orice altă problemă din
clasa respectivă se poate reduce uşor la ea astfel încât, dacă găsim o meotdă simplă de a
rezolva problema completă atunci vom putea rezolva uşor toate celelalte probleme din
clasa respectivă. Pentru ca acest raţionament să fie valabil, este necesar ca reducerea să
fie simplă în raport cu tipul de complexitate a problemelor specifice clasei.  Regula este:
oridecâteori definim probleme complete pentru o anumită clasă de complexitate, modelul
de reductibilitate trebuie să fie mai limitat decât modelul folosit pentru a defini clasa însăşi.
5.4.1. Problema TQBF
5.14. Definiţie
O formulă booleeană complet cuantificată22 (numită şi propoziţie) este o formulă
booleeană în care fiecare variabilă este cuantificată.
5.15. Exemplu
 = ()x ()y [(x  y)  (x  y)] este o formulă booleeană complet cuantificată.
5.16. Definiţie
Problema TQBF constă în verificarea valorii de adevăr a unei formule booleene complet
cuantificată (a unei propoziţii) oarecare şi este formalizată prin limbajul:
TQBF = {<> |  este o propoziţie adevărată }
5.17. Teoremă
TQBF este o problemă PSPACE-completă.
 Pentru a demonstra că TQBF  PSPACE construim un algoritm care asignează valori
de adevăr variabilelor din formulă şi apoi evaluează recursiv valoarea de adevăr a
acesteia. Pe baza acestei informaţii, algoritmul poate determina dacă formula dată este
sau nu adevărată.
 pentru a arăta că toate limbajele L din PSPACE se reduc polinomial la TQBF
22
Fully Quantified Boolean Formula
56
o construim mai întâi pentru L o MT cu spaţiu de lucru mărginit polinomial;

o construim apoi o reducere polinomială care asociază unei secvenţe o formulă
booleeană cuantificată  care codifică o simulare a MT pe acea intrare ,
Formula este adevărată  MT acceptă.
5.4.2. Alte probleme PSPACE-complete23
(1) Fie o formulă booleeană complet cuantificată  = ()x1()x2()x3 … ()xk [];
considerăm un joc la care participă doi jucători, E şi U , care asignează pe rând valori
de adevăr variabilelor x1, x2, x3, … ,xk astfel încât E asignează valori variabilelor
cuantificate existenţial iar U asignează valori variabilelor cuantificate universal. Dacă prin
această asignare formula  se evaluează la TRUE atunci câştigă jucătorul E ; altfel
câştigă jucătorul A . Spunem că jucătorul E are o strategie câştigătoare pentru formula
 dacă – indiferent de asignările făcute de jucătorul A – jucătorul E poate asigna valori
de adevăr varibilelor (legate prin cuantificatori existenţiali) în aşa fel încat să câştige. Este
evident că jucătorul E are o startegie câştigătoare pentru  dacă şi numai dacă  se
evaluează la valoarea 1. Avem astfel:
5.18. Teoremă
Limbajul
Formula-joc = {< > | jucătorul E are o strategie câştigătoare pentru formula-joc
asociată formulei booleene complet cuantificate  }
este PSPACE-complet
(2) Să considerăm acum un alt joc, numit jocul geografic sau Antakhshari, relativ la
numele oraşelor. El poate fi modelat printr-o problemă de grafuri orientate:
 fiecare nod din digraf este etichetat cu numele unui oraş
 există un arc de la nodul u la nodul v dacă ultima literă a etichetei nodului u
coincide cu prima literă a etichetei nodului v.
Jocul începe într-un nod oarecare, fixat; cei doi jucători se deplasează alternativ în digraf,
de-a lungul arcelor, în noduri nevizitate încă. Jucătorul care nu reuşeşte să facă o nouă
deplasare pierde. Jocul poate fi generalizat la un digraf arbitrar (în care nodurile şi arcele
nu mai au nici o legatura cu oraşele sau literele) şi un nod predeterminat. Problema
constă în a determina dacă primul jucător are o strategie câştigătoare. Avem astfel:
5.19. Teoremă
Limbajul
Joc-geografic = {<G,s> | primul jucător are o strategie câştigătoare pentru
jocul Antakhshari generalizat în digraful G,
dacă jocul începe din nodul s }
este PSPACE-complet.
Pentru a demonstra teorema ar trebui să găsim o reducere în timp polinomial a problemei
Formula-joc la problema Joc-geografic. Intrucât se crede că P  PSPACE este de
presupus că nu există nici un algoritm cu timp de lucru polinomial care să-i permită
primului jucător să verifice existenţa unei strategii câştigătoare, cu atât mai puţin să o
determine.
23
CP
57
5.5. Clasele L şi NL24

În capitolele anterioare am analizat probleme a căror complexitate (timp sau spaţiu) este
cel puţin lineară; în continuare examinăm limite sublineare ale complexităţii:
 limita sublineară pentru complexitatea timp este insuficientă pentru citirea datelor de
intrare, deci nu ne ocupăm de aceasta;
 limita sublineară pentru complexitatea spaţiu permite MT respective să citească
întreaga secvenţă de intrare dar nu îi permite să o memoreze pe banda de intrare 
pentru a cerceta eficient această situaţie trebuie schimbat modelul de calculabilitate 
5.20. Definiţie
O MT cu spaţiu logaritmic este o MT care are:
 o bandă de intrare, finită, de tip read-only, pe care se află permanent secvenţa de
intrare şi numai ea;
 o bandă de lucru infinită de tip read/write, obişnuită.
o pe banda de intrare cursorul poate doar citi simbolurile dar nu poate scrie (vom
introduce o convenţie pentru a determina situaţia în care cursorul a ajuns în
extremitatea stângă / dreaptă a benzii de intrare deoarece el trebuie să rămână
permanent numai pe proţiunea benzii care conţine informaţie);
o pe banda de lucru cursorul poate citi şi/sau scrie simboluri în mod normal.
 numai celulele scanate de cursor pe banda de lucru determină complexitatea spaţiu a
acestui tip de MT.
Unitatea de control
5.21 Definiţie
Fie M o MT dotată cu o bandă de intrare separată de tip read-only;
cuvântul de intrare w  *
 o configuraţie a lui M pentru intrarea w trebuie să descrie:
 starea maşinii,
 secvenţa de pe banda de lucru şi
 proziţiile celor două cursoare.
De remarcat faptul că secvenţa w de pe banda de intrare nu face parte din configuraţie;
motivul: banda de intrare conţine – neschimbată, pe parcursul intregului calcul – tocmai
secvenţa w.
24
MS
58
5.22. Observaţie
Putem asimila această MT cu spaţiu sublinear cu un calculator a cărui memorie principală
este destul de mică dar care totuşi poate manipula cantităţi mult mai mari de date (stocate
de exemplu pe un CD-ROM, DVD etc.) fără a le depune complet în memoria principală.
5.23. Observaţie
Dacă spaţiul de lucru al acestei MT cu 2 benzi este de ordin cel puţin linear atunci ea este
echivalentă cu o MT standard. Pentru spaţiu de lucru de ordin sublinear nu putem utiliza
ca model de calcul decât MT cu două benzi descrisă mai sus.
5.24. Lemă25
Fie M o MT cu spaţiu logaritmic (conform Definiţiei 5.22) , mărginit de o funcţie f(n). 
(1) numărul configuraţiilor lui M pentru o secvenţa de intrare de lungime n este de cel
mult n.2O(f(n));
(2) dacă f(n)  log n atunci acest număr este de 2O(f(n)).
Demonstraţie26
(1) Să presupunem că M are s stări şi b simboluri în alfabetul benzii.  numărul de
cuvinte care pot apărea pe banda d elucru este bf(n).
Cursorul benzii de intrare poate avea n poziţii iar cel al benzii de lucru f(n) poziţii.
 numărul total de configuraţii ale M pentru w , care este o limită superioară pentru
timpul de calcul al M pentru w , este s.n.f(n) .bf(n), sau n.2O(f(n))
(2) rezultă imediat din (1) şi din ipoteza f(n)  log n. q.e.d.
Tratăm ordinul de complexitate log n (în loc de n sau log2 n) deoarece spaţiul
logaritmic este suficient de mare pentru a stoca pointeri către secvenţa de intrare ceea ce
permite rezolvarea unor probleme computatioanle interesante. În plus, spaţiul logaritmic
are proprietăţi matematice remarcabile (precum robusteţea). Clasele N şi NL , şi mai
exact algoritmii de reducere cu spaţiu logaritmic sunt foarte utili atunci când trebuie să
facem distincţie între diferitele probleme “uşoare”, cum sunt cele din clasa P .
5.25 Definiţie
Notăm cu L clasa limbajelor decidabile de către o MT deterministă in spaţiu de lucru
logaritmic:
L = SPACE(log n)
Notăm cu NL clasa limbajelor decidabile de către o MT nedeterministă in spaţiu de lucru
logaritmic:
NL = NSPACE(log n)
5.26. Exemple27
(1) Limbajul L1 = { 0k1k  {0,1}* | k  0 }  L.
Aşa cum am arătat mai sus, o MT cu 2 benzi care primeşte la intrare un cuvânt w 
{0,1}* începe prin a verifica dacă w are forma corectă; această etapă a algoritmului nu
necesită spaţiu suplimentar. Dacă w este corect format, adică w = 0k1h , numerele k şi
h sunt memorate pe banda de lucru şi comparate unul cu celălalt. Cum k şi h pot fi
memorate pe bandă în format binar utilizând O(log n) biţi, rezultă că banda de lucru
utilizează un spaţiu de lucru de ordin algoritmic.
25
CP
26
MS
27
CP
59
(2) Limbajul PATH = {<G,s,t>| G este un digraf în care există un drum de la s la t}  NL

Am demonstrat că PATH  P ; nu ştim dacă PATH  L. Putem însă construi o MTN care
să exporeze nedeterminist drumurile de lungime cel mult m (m = numărul de noduri din G)
şi care să accepte secvenţa de intrare <G,s,t> dacă şi numai dacă nodul t poate fi atins
din s. Intrucât la fiecare pas de calcul este suficient să memorăm numai nodul curent de
pe drumul curent cercetat, rezultă că PATH  NL.
5.27. Observaţie28
O(f(n))
Am arătat că orice MT cu spaţiu de lucru f(n) rulează în timp 2 . Această proprietate
nu mai este adevărată pentru MT cu spaţiu de lucru de mici dimensiuni: de exemplu, o MT
care rulează cu spaţiu de lucru O(1) (adică o constantă) poate rula în n paşi. Definiţia
următoare ne permite să obţinem limite superioare pentru timpul de lucru al MT care să se
aplice şi în cazul spaţiului de lucru mărginit de orice funcţie f(n).
5.28. Observaţie
Teorema lui Savitch demonstrează faptul că transformarea unei MTN într-o MTD
determină o creştere a complexităţii spaţiu de la f(n) doar la f 2(n), dacă f(n)  n. Putem
generaliza Teorema lui Savitch şi la MT cu spaţiu sublinear de tip f(n)  log n.
Demonstraţia este similară celei iniţiale dar cu două deosebiri:
 se foloseşte o MT cu spaţiu logaritmic (vezi Definiţia 5.20);
 în locul configuraţiilor MTN N se utilizează configuraţii ale N pentru w .
Memorarea unei configuraţii a lui N pentru w necesită
log(n.2O(f(n))) = log n + O(f(n)) locaţii.
Dacă f(n)  log n atunci spaţiul folosit este de ordin O(f(n)) , restul demonstraţiei
rămânând la fel.
5.6. NL-completitudine29
Problema PATH ilustrează posibilitatea ca L NL. Pentru a aborda această conjectură –
nedemonstrată încă, asemenea conjecturii P  NP – este necesar să analizăm
problemele NL-complete. Conform Lemei 5.26, L  P  reductibilitatea polinomială nu
este adecvată pentru compararea problemelor din NL după dificultatea lor. Trebuie
utilizate reduceri mai “simple”.
5.29. Definiţie
Un transducer cu spaţiu logaritmic (log-space transducer) este o MT care are:
 o bandă de intrare, finită, de tip read-only, pe care se află permanent secvenţa de
intrare şi numai ea;
 o bandă de ieşire, eventual infinită, de tip write-only;
 o bandă de lucru infinită de tip read/write, obişnuită.
Pentru un cuvânt de intrare w de lungime n transducerul utilizează (scanează) O(log n)
simboluri de pe banda sa de lucru şi îşi încheie calculul având pe banda de ieşire cuvântul
f(w) (şi nimic altceva).
 numai celulele scanate de cursor pe banda de lucru determină complexitatea spaţiu a
acestui tip de MT.
28
MS
29
CP
60
Banda de intrare, finită, de tip read-only
Unitatea de control
Banda de ieşire de tip write-only
Banda de lucru, infinită, de tip read-write
5.30. Definiţie
Funcţia f: *  * se numeşte calculabilă în spaţiu logaritmic  există un transducer
spaţiu logaritmic care, oricare ar fi secvenţa w  * de pe banda de intrare, se opreşte,
având pe banda de ieşire secvenţa f(w).
5.31. Definiţie
Fie limbajele A, B  *. Limbajul A se numeşte reductibil funcţional în spaţiu
logaritmic la limbajul B şi se notează prin A L B  () f : *  * calculabilă în
spaţiu logaritmic astfel încât () w  *: w  A  f(w)  B.
5.32. Definiţie
Un limbaj L se numeşte NL-complet dacă satisface următoarele două condiţii:
(1) L  NL;
(2) () A  NL: A L L .
5.33. Teoremă
Dacă A L B şi B  L atunci şi A  L.
5.34. Teoremă
Dacă A L B şi A este NL-complet atunci şi B este NL-complet.
5.35. Teoremă
Dacă există un limbaj L NL-complet cu proprietatea că L  L , atunci L =NL.
5.36. Teoremă
PATH este NL-complet.
5.37 Corolar
NL  P .
5.38. Teoremă
NL = coNL.
coNL = { L | L = A , A  NL }
61
Trebuie construit un algoritm nedeterminist cu spaţiu de lucru logaritmic pentru limbajul

PATH .
Cum PATH este NL-complet (Teorema 5.36) rezultă că NL = coNL.
5.39. Teoremă
PolyL  PSPACE
unde
PolyL   NLk
k N
este una dintre clasele de algoritmi cu spaţiu de lucru logaritmic super-linear
5.40. Observaţie
Relaţiile dintre clasele de complexitate spaţiu şi timp – cunoscute în prezent – sunt:
L NL = coNL  P  PSPACE
Nu ştim dacă vreuna dintre aceste incluziuni este strictă (deşi, într-un corolar din Cursul 9,
demonstrăm că P  PSPACE). Prin urmare, fie coNL  P fie P  PSPACE are loc dar
nu ştim care dintre ele! Cei mai mulţi dintre cercetători presupun că toate aceste incluziuni
sunt stricte.
Rezumat
62

Rezolvari Subiecte 1, 2, 3

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Rezolvari Subiecte 1, 2, 3

Încărcat de

Drepturi de autor:

Formate disponibile

CALCULABILITATE SI COMPLEXITATE

CARE SUNT POSIBILITATILE SI LIMITELE ESENTIALE ALE CALCULATOARELOR?

CE FACE CA O PROBLEMA SA FIE USOR / DIFICIL DE REZOLVAT ?

O realizare importantă în teora complexităţii a fost descoperirea unei scheme elegante

O consecinţă a acestui rezultat a fost dezvoltarea mai multor modele teoretice de

Spre deosebire de teoria complexităţii, al cărei obiectiv este

1.1. Maşina Turing (MT)

Odată ce dispunem de o astfel de reprezentare finită a unui limbaj L  * apare o nouă

Această problemă se numeşte problema apartenenţei (language membership problem)

Q conţine o submulţime specială de stări, F  Q , numită mulţimea stărilor finale;

Limbajul acceptat de o MT M este mulţimea

1.2. Observaţie. O MT poate eşua asupra unui cuvânt de intrare dacă:

Să examinăm numărul de paşi elementari (tranziţii) executaţi de M pentru un cuvânt de

Figura 1.1. O MT care acceptă palindroame şi numai palindroame binare

Următoarea întrebare este: cât de robust şi de general este acest model de

În fine, care este relaţia unei MT cu un calculator real?

1.6. Observaţie importantă

O MT poate fi descrisă în trei moduri:

Datele de intrare pentru o MT constau întotdeauna dintr-o secvenţă de simboluri. Dacă

 <G> = ((1,2,3,4) ; ((1,2) , (1,3) , (1,4) , (2.3)))

1.2. Maşini Turing cu mai multe benzi

În acest scop, folosim:

Fie cuvânt de intrare w = w1w2…wn; S calculează astfel:

10 bandă a 2a bandă a 3a bandă ….

2. Pentru a simula o singură mişcare (simultană) a celor n cursoare ale M, S scanează

1.3. Maşini Turing nedeterministe

Cele 3 benzi ale MT D sunt definite astfel:

Dacă s-a intrat într-o configuraţie de respingere, se merge tot la Pasul 4.

1.4. Echivalenţa modelelor de calculabilitate

Există şi alte modele de calculabilitate: funcţiile general recursive, funcţiile -calculabile,

1.5. Algoritm: o definiţie

Problema a 10a a lui Hilbert

să se găsească un algoritm care să verifice dacă un

particulare – când existau – dar nu să demonstreze că un astfel de algoritm există în

Clasa algoritmilor intuitiv calculabili coincide cu

Este o teză şi nu o teoremă pentru că un membru al echivalenţei nu este definit riguros.

2.1. Probleme decidabile privind limbajele regulate

Vom reprezenta problemele computaţionale cu ajutorul limbajelor întrucât am dezvoltat

De exemplu, PROBLEMA ACCEPTABILITATII pentru AFD este:

Putem construi N ca in Teorema 2.1, adică N să simuleze un automat finit

Fie MT N definită astfel:

Observăm că rularea MT M în etapa a doua revine la incorporarea M în descrierea lui

V = “ Fie secvenţa de intrare <A>, unde A este un AFD oarecare:

Vom folosi Teorema 2.3: EMPAFD este decidabil.

E = “ Fie secvenţa de intrare <A,B>, unde A şi B sunt automate finite deterministe:

2.2. Probleme decidabile privind limbajele independente de

Fie G o gramatică independentă de context în forma normală Chomski şi

Construim o MT C care să decidă asupra limbajului ACCGIC astfel:

2.6. Teoremă (fără demonstraţie)

2.7. Observaţie importantă

Fie o gramatică independentă de context G şi L = L(G); construim o MT MG decidentă

3. Nedecidabilitate: problema opririi

există o problemă nerezolvabilă algoritmic

Pentru aceasta avem nevoie de mai multe rezultate pregătitoare şi metode de

Metoda diagonalizării a fost propusă în 1873 de fondatorul teoriei mulţimilor, Georg

3.1. Un limbaj care nu este Turing-decidabil (nu este recursiv)

Demonstraţie (utilizăm 2 metode: reducerea la absurd şi diagonalizarea)

Presupunem prin absurd ca limbajul ACCMT este decidabil 

Construim acum o altă MT D având MT H ca subrutină. Această nouă MT D apelează

Iată descrierea completă a MT D:

acceptă, dacă M nu acceptă <M>,

3.5. Obervaţie importantă

3.2. Un limbaj care nu este recunoscut de o maşină Turing (nu