Limbaje Formale Si Automate 1

For Evaluation Only.
Copyright (c) by VeryPDF.com Inc

Edited by VeryPDF PDF Editor Version 2.2
LIMBAJE FORMALE SI AUTOMATE

Notite de curs
2.1 Gramatici ......................................................................................................................

2.1.1
Ierarhia Chomsky...............................................................................................................
2.1.1.1 Exerciii .............................................................................................................................
2.1.2
Verificarea limbajului generat de ctre o gramatic
2.1.2.1 Exerciii .............................................................................................................................
2.1.3
Transformri asupra gramaticilor independente de context............................................................. 11
2.1.3.1 Eliminarea ambiguitii............................................................................................................... 12
2.1.3.2 Eliminarea - produciilor .......................................................................................................... 16
2.1.3.3 Eliminarea recursivitii stnga................................................................................................... 16
2.1.3.4 Factorizare stnga .............................................................................................................
2.1.3.5 Eliminarea simbolilor neterminali neutilizai.............................................................................. 19
2.1.3.6 Substituia de nceputuri(corner substitution)............................................................................. 20
2.1.4
Construcii dependente de context................................................................................................... 22
2.1.4.1 Exerciii ...................................................................................................................................... 23
2.1.5
Proprieti ale limbajelor independente de context.......................................................................... 24
2.1.5.1 Exerciii ...................................................................................................................................... 25
2.2
Mulimi regulate, expresii regulate. ...................................................................................................... 25
2.3 Acceptoare............................................................................................................................................... 28
2.3.1
Automate finite ................................................................................................................................ 29
2.3.1.1 Construcia unui automat finit nedeterminist care accept limbajul descris de o expresie regulat
dat
30
2.3.1.2 Conversia unui automat finit nedeterminist (AFN) ntr-un automat finit determinist(AFD)...... 34
2.3.1.3 Construcia unui automat finit determinist care accept limbajul descris de o expresie regulat
dat
37
2.3.1.4 Simularea unui automat finit determinist.................................................................................... 43
2.3.1.5 Simularea unui automat finit nedeterminist ................................................................................ 44
2.3.1.6 Probleme de implementare pentru automatele finite deterministe i nedeterministe.................. 45
2.3.1.7 Minimizarea numrului de stri pentru AFD.............................................................................. 46

2.3.2
Automate cu stiv (pushdown) ........................................................................................................ 49
2.3.2.1 Automate cu stiv cu acceptare prin stiv goal ......................................................................... 52
2.3.2.2 Relaia ntre automate cu stiv i limbajele independente de context......................................... 53
2.3.3
Maina Turing.................................................................................................................................. 57
2.3.3.1 Calcule realizate de Maina Turing ............................................................................................ 60
2.3.3.2 Compunerea mainilor Turing .................................................................................................... 63
2.3.3.3 Extensii pentru maina Turing.................................................................................................... 67
2.3.3.4 Automate liniar mrginite ........................................................................................................... 73
2.3.3.5 Relaia ntre maina Turing i gramatici ..................................................................................... 74
2.3.3.6 Elemente de calculabilitate ......................................................................................................... 77
2.3.3.6.1 Maina Turing Universal ................................................................................................... 77
2.3.3.7 . Maina Turing cu limit de timp............................................................................................... 81

1 Elemente de teoria limbajelor formale
Fie T o mulime de simboluri denumita alfabet. Orice submulime a mulimii T* reprezint un limbaj
asupra alfabetului T. Elementele limbajului se numesc propoziii. Dac limbajul este finit atunci el poate
s fie definit prin enumerare. De exemplu considernd alfabetul B = {0, 1} atunci L = {01, 10, 101} este
un limbaj. Mulimea cuvintelor din limbajul natural este i el un limbaj pentru care se poate pune
problema enumerrii tuturor cuvintelor, chiar dac lista care ar rezulta este imens, deci este un limbaj
reprezentabil prin enumerare. Dar cazul interesant este cel n care limbajul este infinit. S considerm de
exemplu limbajul "irurilor formate din 0 i 1 a cror lungime este divizibila cu 3". Evident este vorba de
un limbaj infinit. Textul prin care am specificat limbajul constituie o reprezentare finit a limbajului. Nu
este singura soluie posibil de reprezentare finit. De exemplu dac notam cu L limbajul respectiv atunci:
L = { w {0,1}* | |w| mod 3 = 0}
este un alt mod de a specifica acelai limbaj.

Se pune problema dac dndu-se un limbaj oarecare este posibil ntotdeauna construirea unei
reprezentri finite. S considerm c o astfel de reprezentare finit se realizeaz utiliznd simboli dintr-un
alfabet finit A. Se poate demonstra c mulimea A* este infinit numrabil (se poate construi o bijecie f :
N A*). Deci exist o mulime infinit numrabil de reprezentri finite. Numrul de limbaje ce se pot
construi utiliznd simboli dintr-un alfabet dat T, este 2|T*| deci mulimea limbajelor este infinit
nenumrabila. Rezult deci c ar trebui s reprezentm un numr infinit nenumrabil de obiecte avnd la
dispoziie numai un numr infinit numrabil de reprezentri. Din acest motiv nu orice limbaj va putea s
fie reprezentabil ntr-un mod finit. Nu putem s oferim un exemplu de limbaj pentru care nu avem o
reprezentare finit pentru c exemplul ar fi tocmai o reprezentare finit a limbajului respectiv. Spre
norocul nostru, nu suntem interesai de toate limbajele ci numai de o clas mai mic a limbajelor infinite
cu reprezentri finite.
n general exist doua mecanisme distincte de definire finit a limbajelor: prin generare sau prin
recunoatere. n primul caz este vorba de un "dispozitiv" care tie s genereze toate propoziiile din limbaj
(i numai pe acestea) astfel nct alegnd orice propoziie din limbaj ntr-un interval finit de timp
dispozitivul va ajunge s genereze propoziia respectiv. n al doilea caz este vorba de un "dispozitiv" care
tie s recunoasc (s accepte ca fiind corecte) propoziiile limbajului dat.
2.1
Gramatici
O gramatic reprezint cel mai important exemplu de generator de limbaje. Prin definiie o gramatic
este G = (N, T, P, S) unde :
N este o mulime finit de simboli numit mulimea simbolilor neterminali;

T este o mulime finit de simboli numit mulimea simbolilor terminali,
(T N = );
P este o submulime finit din (N T)* N (N T)* x (N T)*; numit mulimea produciilor
gramaticii. Un element (, ) P este notat cu i se numete producie.
S N este un simbol special numit simbol de start al gramaticii G.
n cele ce urmeaz vom utiliza o serie de notaii devenite "clasice". i anume :
literele mici de la nceputul alfabetului latin (a,b,c,...) reprezint elemente din T (simboli terminali);
literele mici de la sfritul alfabetului latin (u, v, x,...) reprezint elemente din T* (iruri de simboli
terminali);

literele mari de la nceputul alfabetului latin (A, B, C,...) reprezint elemente din N (simboli
neterminali);
literele mari de la sfritul alfabetului latin (U, V, X,...) reprezint elemente din N T (simboli
terminali sau neterminali);
literele alfabetului grecesc (, , ...) reprezint iruri din (N T)* (iruri de simboli terminali i
neterminali).
O form propoziional pentru o gramatic G se definete recursiv n modul urmtor:
(1) S este o form propoziional;
(2) dac este o forma propoziional i exist o producie atunci este o
form propoziional.
O form propoziional care conine numai simboli terminali se numete propoziie generat de G.
Notm cu L(G) mulimea tuturor propoziiilor generate de G altfel spus L(G) este limbajul generat de
gramatica G.
Se observ c o gramatic este o reprezentare finit (toate elementele sale sunt finite) pentru un limbaj
care poate s fie infinit. Conform observaiei fcute la nceputul acestui capitol nu orice limbaj are o
reprezentare finit, cu alte cuvinte nu pentru orice limbaj exist o gramatic care s l reprezinte.
Dou gramatici G i G' sunt echivalente dac i numai dac L(G) = L(G').
Asupra formelor propoziionale se definete o relaie numit relaie de derivare n modul urmtor.
Fie i doua forme propoziionale, dac i numai dac exist w1, w2 i P astfel nct
= w1 w2 i = w1 w2.
Relaia poate s fie extins obinndu-se derivarea n k pai. i anume k dac exist 0, 1,
..., k forme propoziionale astfel nct = 0, i-1 i ,1 i k i k = .
nchiderea tranzitiv a relaiei se noteaz cu + . nchiderea tranzitiv i reflexiv a relaiei se
noteaz cu =*>.
S considerm de exemplu gramatica G = ({A,S}, {0,1}, P, S) unde P = {S 1A1, S 0S0, 1A
11A1, A } (cu s-a notat irul vid de simboli). O derivare posibil este:
S 0S0 00S00 001A100 0011A1100 00111100
deci 00111100 este o propoziie n L(G).

n general L(G) = { w | w T+, S + w}.
2.1.1
Ierarhia Chomsky.
Noam Chomski este lingvist i lucreaz n domeniul limbajelor naturale. Ierarhia care i poarta
numele a rezultat dintr-o ncercare a acestuia de a formaliza limbajele naturale. Gramaticile sunt clasificate
conform complexitii produciilor n urmtoarea ierarhie :
gramatici de tip 0 (fr restricii) - au produciile de forma:

cu (N T)* N (N T)* , (N T)*
gramatici de tip 1 (dependente de context) - au produciile de forma :

A , , (N T)*, A N, (N T)+

sau de forma
S
n al doilea caz S nu apare n membrul drept al nici unei producii. Se utilizeaz termenul de
dependen de context deoarece producia A poate s fie interpretat sub forma - dac
simbolul neterminal A apare ntre i atunci poate s fie nlocuit cu .
gramatici de tip 2 (independente de context) - au produciile de forma :

A , A N, (N T)*.
Denumirea de independent de context apare n contrast cu gramaticile de tipul 1 (dependente de

context)
gramatici de tip 3 (regulate la dreapta) au producii de forma:

A aB cu A N , B (N {}) si a T+.
Corespunztor gramaticilor, despre limbajele generate de acestea se poate spune respectiv c sunt
regulate, independente de context, dependente de context sau de tipul zero. Se poate arata c un limbaj ce
poate s fie generat de o gramatic regulat poate s fie generat i de ctre o gramatic independent de
context. Un limbaj independent de context poate s fie generat i de o gramatic dependent de context iar
un limbaj dependent de context poate s fie generat i de o gramatic de tipul zero. Deoarece cu ct o
gramatic este mai restrictiv ea reprezint un mecanism mai simplu, suntem ntotdeauna interesai de cea
mai restrictiv gramatic care reprezint un limbaj dat.
S considerm cteva exemple:
a) G1 = ({S},{0,1},{S 0S, S 1S, S }, S). Se observ c G1 este o gramatic regulat care
genereaz limbajul {0,1}*
b) G2 = ({S, A},{0,1},{S AS, S , A , A 0, A 1}, S). Se observ c G2 este o
gramatic independent de context iar limbajul generat este tot {0,1}*. Rezult deci c un acelai limbaj
poate s fie definit de mai multe gramatici diferite eventual chiar de tipuri diferite.
c) G3 = ({, T, F},{a, +, *, (, )}, P, ) cu P = { + T, T, T T * F, T F, F (), F
a}. S considerm un exemplu de derivare n aceast gramatic :
+ T T + T F + T a + T a + T * F a + F * F a + a * F a + a * a.
Se observ c gramatica G3 este o gramatic independent de context i este o gramatica care descrie
limbajul expresiilor aritmetice cu paranteze care se pot forma cu operandul a i cu operatorii + i *.
n cele ce urmeaz pentru simplificarea notaiilor dac pentru un neterminal exist mai multe producii
: A w1, A w2, ... A wk le vom reprezenta sub o form mai compact: A w1 | w2 | ... | wk.
De asemenea pentru specificarea unei gramatici nu vom mai preciza n general dect mulimea
produciilor sale, celelalte elemente rezultnd n mod banal din aceasta.
2.1.1.1
Exerciii
S se construiasc gramaticile care genereaz limbajul:

1. irurilor formate din simboli a i b avnd un numr egal de a i b.
2. {anbn | n 1}
3. {anbmcmdn | n 1, m 1}
4. {anbncmdm | n 1, m 1}
5. irurilor formate cu simboli a i b care nu conin subirul abb
6. irurilor formate cu simboli a i b avnd lungimea divizibil cu 3
7. {aibj | i /= j, i, j > 0}
8. {ambn | n < m sau n > 2m, n, m 1}
9. irurilor formate dintr-un numr par de simboli a i un numr impar de simboli b
10.irurilor formate din simboli a, b i c, pentru care toi simboli a apar nainte de toi
simboli b iar toi simboli b apar nainte de toi simboli c
11.{anbncn | n >_ 1}
12.{xcxR |x {a,b}*}, {xxR|x {a,b}*}, {x = xR|x {a,b}*}
13.{xx | x {a,b}*}
14.{anbncn | n 1 }
15.listelor de elemente care pot s nu conin nici un element, respectiv trebuie s conin
cel puin un element, construirea listei este asociativ dreapta respectiv stnga (vor
rezulta 4 variante)
2.1.2
Verificarea limbajului generat de ctre o gramatic
n toate exemplele considerate pn acum s-a fcut "ghicirea" gramaticii care genereaz un limbaj dat
sau a limbajului generat de ctre o gramatic dat. Se pune ns problema cum se poate demonstra
corectitudinea rezultatului unei astfel de ghiciri. S considerm de exemplu gramatica:
G = ({S}, {(,)}, {S (S)S | }, S)
Aceast gramatica genereaz toate irurile de paranteze bine nchise (echilibrate). Dorim ns s
demonstrm aceast afirmaie. De fapt aici trebuie s demonstrm egalitatea a dou mulimi: mulimea
reprezentat de limbajul generat de G i mulimea irurilor de paranteze bine formate. Deci demonstraia
presupune demonstrarea dublei incluziuni. Adic trebuie s demonstrm c orice ir derivat din S satisface
condiia enunat i apoi trebuie s demonstrm incluziunea n sens invers. Dndu-se un ir de paranteze
bine nchise trebuie s artm c acest ir poate s fie derivat din S. Pentru prima parte a demonstraiei
vom utiliza inducia asupra numrului de pai n derivare. Considerm c irul vid care se obine ntr-un
pas din S este un ir de paranteze bine nchise. S presupunem c pentru toate derivrile realizate n mai
puin de n pai se obin iruri de paranteze bine nchise i s considerm o derivare de exact n pai. O
astfel de derivare poate s arate ca :
S (S)S * (x)S * (x)y
unde x i y sunt iruri de terminale derivate din S n mai puin de n pai, adic sunt iruri de paranteze
bine nchise. Rezult c irul (x)y este un ir de paranteze bine nchise. Cu alte cuvinte orice ir derivat din
S este "corect".
S considerm acum i includerea n sens invers. De data asta demonstraia se face prin inducie
asupra lungimii irului. Pentru primul pas observm c irul vid este un ir derivabil din S. S presupunem
acum ca orice ir cu mai puin de 2n simboli este derivabil din S. S considerm un ir w de paranteze bine
nchise avnd lungimea de 2n, cu n mai mare sau egal cu 1. Sigur irul ncepe cu o parantez deschis. Fie
(x) cel mai scurt prefix format din paranteze bine nchise. Se observ c w = (x)y, unde x i y sunt iruri

de paranteze bine nchise de lungime mai mic dect 2n. n acest caz x i y pot s fie derivate din S.
Rezult c exist o derivare:
S (S)S * (x)y
n care pentru obinerea irurilor x i respectiv y s-au utilizat mai puin de 2n pai i deci w este un ir
derivabil din S. Desigur o astfel de demonstraie este practic imposibil de realizat pentru un limbaj
"adevrat". n general se pot face ns demonstraii "pe poriuni".
2.1.2.1
Exerciii
1. Fie gramatica G : S AA, A AAA, a, A bA, Ab, s se arate ca limbajul L(G) este limbajul
tuturor irurilor formate din simboli a avnd un numr par de simboli.
2. Fie gramatica G : S aB | bA, A a | aS | bAA, B b | bS | aBB s se arate ca L(G) este setul
tuturor irurilor din {a,b}+ care au un numr egal de apariii pentru a i pentru b.
2.1.3
Transformri asupra gramaticilor independente de context
Din punctul de vedere al procesului de compilare, gramaticile sunt utilizate pentru faza de analiz
sintactic, pentru care se utilizeaz gramatici independente de context. Exist o serie de metode de analiza
sintactic, bine puse la punct att din punct de vedere teoretic ct i practic. Fiecare dintre aceste metode
impune ns o serie de restricii asupra gramaticilor utilizate. n general atunci cnd se construiete o
gramatic se pleac de la forma general a structurilor pe care aceasta trebuie s le descrie i nu de la
metoda de analiza sintactica ce va fi utilizat. n acest mod se obine o gramatic ce poate s fie "citit"
uor de ctre proiectant. Pentru a satisface ns condiiile impuse de ctre metodele de analiza sintactic
sau de ctre generarea de cod, se realizeaz transformri asupra gramaticilor. Aceste transformri trebuie
s pstreze neschimbat limbajul generat. n cele ce urmeaz vom prezenta cteva transformri tipice
asupra gramaticilor independente de context. Pentru a explica semnificaia acestor transformri n
contextul analizei sintactice vom prezenta nti noiunea de arbore de derivare.
Un arbore de derivare este o reprezentare grafic pentru o secven de derivri (de aplicri ale relaiei
ntre formele propoziionale). ntr-un arbore de derivare nu se mai poate identifica ordinea n care s-a
fcut substituia simbolilor neterminali. Fiecare nod interior arborelui, reprezint un neterminal.
Descendenii unui nod etichetat cu un neterminal A sunt etichetai de la stnga la dreapta prin simbolii
care formeaz partea dreapt a unei producii care are n partea stnga neterminalul A. Parcurgnd de la
stnga la dreapta frunzele unui astfel de arbore se obine o form propoziional. S considerm de
exemplu din nou gramatica irurilor de paranteze bine formate:
G = ({S}, {(,)}, {S (S)S | }, S)
Fie urmtoarea secven de derivri:
S ( S ) S ( ( S ) S ) S ( () S ) S
( () ( S ) S ) S ( () () S ) S
( () () ) S ( () () ) ( S ) S + ( ()() ) ()
Se obine arborele de derivare:

S
//\ \
// \ \
//
\ \
(S
) S
//\ \
//\
// \ \ (S )
//
\ \
|
(S
) S
|
//\ \
// \ \
( S
) S
|
|
\
S
|
Arborele de derivare este construit de ctre analizorul sintactic. Aceasta construcie se poate face
pornind de la rdcin aplicnd succesiv producii - n acest caz se spune c analiza sintactic este topdown (descendent). Dar, se poate porni i invers de la irul de atomi lexicali (frunze) identificndu-se
simbolii neterminali din care se poate obine un ir de atomi lexicali. n acest caz se spune c analiza
sintactic este de tip bottom-up (ascendent).
Deoarece arborele de derivare descrie relaia ierarhica ntre entitile sintactice (neterminale) i atomii
lexicali (terminale) se poate asocia o interpretare n termeni de evaluare a entitilor sintactice. Astfel,
considernd de exemplu gramatica expresiilor aritmetice pentru irul a + a * a se obine arborele derivare :
/|\
/ | \
+
T
|
/|\
T
/ | \
|
T
*
F
F
|
|
|
F
a
a
|
a
n care se poate observa c a fost evideniat faptul c operaia de nmulire este prioritar fa de
operaia de adunare (aspect semantic).
2.1.3.1
Eliminarea ambiguitii
O gramatic care produce mai muli arbori de derivare pentru aceeai propoziie este o gramatic
ambigu. Deoarece exist tehnici de analiz sintactic care lucreaz numai cu gramatici neambigue vom
ncerca s construim gramatici care genereaz acelai limbaj i care sunt neambigue. S considerm de
exemplu urmtoarea gramatic :
instr if expresie then instr |
if expresie then instr else instr |
alte_instr
S construim arborele de derivare pentru propoziia :

if E1 then if E2 then S1 else S2

instr
/ /\ \
// \\
//
\\
/ expr \ \
/ / \ then \
if / E1 \
\
------instr
/ /\ \ \ \
// \\ \ \
//
\\ \ \
/ expr \ \ \ \
/ / \ then \ \ \
if / E2 \
\ \ \
------instr \ \
/ \ else \
/ S1 \
instr
-----/ \
/ S2 \
------
Pentru aceast propoziie mai exist ns un arbore de derivare.

instr
//\ \ \ \
// \ \ \ \
//
\ \ \ \
/ expr
\ \ \ \
/ / \ then \else \
if / E1 \
\
\
------instr instr
/ \
/ \
/ /\ \ / S2 \
/ / \ \ -----if / then\
expr instr
/ \
/ \
/ E2 \ / S1 \
------ ------
n toate limbajele de programare care accept construcii de tip if then else se consider cu sens prima
derivare n care fiecare clauza else este atribuit instruciunii if cea mai interioar. Rezult deci condiia pe
care trebuie s o satisfac o instruciune if. Instruciunea cuprins ntre then i else trebuie s nu fie o
instruciune if sau s fie o instruciune if cu clauza else. Rezult urmtoarea gramatic obinut prin
transformarea gramaticii anterioare:
instr if_cu_else| if_fara_else
if_cu_else if expresie then if_cu_else else if_cu_else |
alte_instr
if_fara_else if expresie then instr |
if expresie then if_cu_else else if_fara_else
Se observ c aceast gramatic genereaz acelai limbaj cu gramatica anterioar dar accept o
derivare unic pentru propoziia :

if E1 then if E2 then S1 else S2

instr
|
if_fara_else
/ /\ \
// \\
//
\\
/ expr \ \
/ / \ then \
if / E1 \
\
------instr
|
if_cu_else
/ /\ \ \ \
// \\ \ \
//
\\ \ \
/ expr \ \ \ \
/ / \ then \ \ \
if / E1 \
\ \ \
------instr \ \
/ \ else \
/ S1 \
instr
-----/ \
/ S2 \
------
Se numete producie ambigu o producie care are n partea dreapt mai multe apariii ale aceluiai
simbol neterminal. Existena unei producii ambigue nu implic faptul c gramatica este ambigu. S
considerm gramatica G = ({S, A}, {a, b, c }, {S aAbAc, A a | b}). Se observ c aceast gramatic
nu este ambigu, gramatica genernd limbajul {aabac, aabbc, abac, abbc}
S considerm de exemplu i gramatica pentru expresii aritmetice:
G = ({}, {a, +, *}, { + | * | a}, )
Gramatica G este o gramatic ambigu (se poate verifica uor utiliznd de exemplu irul a + a * a). n
gramatica G nu au fost evideniate relaiile de preceden dintre operatori. Aceasta gramatica poate s fie
transformata ntr-o gramatica neambigu n care operaia de nmulire este mai prioritar dect cea de
adunare n doua moduri:
1. + T | T
T T * F | F
F a
2. T + | T
T F * T | F
F a
Fie irul a * a * a. Pentru cele doua gramatici se obin arborii de derivare respectivi:

|
T
/|\
/ | \
T * F
/|\
|
/ | \
a
T * F
|
|
F
a
|
a
|
T
/|\
/ | \
F * T
|
/|\
a
/ | \
F * T
|
|
a
F
|
a
Se observ c primul arbore evideniaz asociativitatea stnga a operatorului * n timp ce al doilea

arbore evideniaz asociativitatea dreapta. n funcie de definiia limbajului este de preferat prima variant
sau a doua.
n cazul general dac pentru un neterminal A exist produciile:
A
A B A
| 1 | 2 | ... | n
, BN, 1, ... n T*
acestea pot s fie nlocuite cu:

A A' B A | A'
A' A | 1 | 2 | ... | n
Producia A' A poate s fie eliminat (exist i A A') i se obine:

A
A' B A
| A'
A' 1 | 2 | ... | n
Dac se construiete arborele de derivare se observ c n acest caz se utilizeaz asociativitatea

dreapt. Pentru a se descrie asociativitatea stnga se utilizeaz transformarea:
A A B A' | A'
A' 1 | 2 | ... | n.
Trebuie s remarcam ns faptul c exist limbaje pentru care nu se pot construi gramatici neambigue.
Un astfel de limbaj se numete inerent ambiguu. De exemplu limbajul :
L = { aibjckdl | i = k sau j = l, i, j, k, l 0}
este inerent ambiguu. O gramatic care descrie acest limbaj va trebui probabil s considere c L este
de fapt reuniunea a dou limbaje:
L = { anbjcndl | n, j, l 0} i L = { aibnckdn | i, n, j, k 0}
Un ir de forma apbpcpdp va face parte din ambele limbaje i deci probabil c va avea doi arbori de
derivare. Exemplul anterior nu constituie ns o demonstraie, o demonstraie adevrat depete ca
dificultate cadrul textului curent.

2.1.3.2
Eliminarea - produciilor
Se spune ca o gramatic este - free dac satisface una dintre urmtoarele condiii:
a. Nu exist nici o producie care s aib n partea dreapta irul vid
b. Exist o singura producie care are n partea dreapta irul vid i anume o producie de forma S
. Simbolul S nu apare n acest caz n partea dreapt a nici unei producii.
Algoritmul de transformare pleac de la gramatica G = (N, T, P, S) i construiete gramatica G' = (N',
T, P', S') care satisface condiiile :
(i) L(G) = L(G')
(i) G' este - free.
Descrierea algoritmului este :
i=0
Ni = {A | A P}
repeta
i=i+1
Ni = { A | A P, a N*i-1} Ni-1
pn Ni = Ni-1
Ne = Ni
dac S Ne
N' = N {S'}
P' = {S' , S' S}
altfel
N' = N
S' = S
P' =
pentru fiecare p P executa

dac p este de forma : A a0 B1 a1 ... Bk ak, k 0,
Bi Ne, 1 i k, aj ((N \ Ne) T)*, 0 j k
P' = P' ({A a0 X1 a1 ... Xk ak | Xi {Bi, }} \{A })
altfel
P' = P' {p}
Fie de exemplu gramatica S aSbS | bSaS | . Aplicnd algoritmul anterior se obine:

S' S, S aSbS | aSb | abS | ab | bSaS | bSa | baS | ba
2.1.3.3
Eliminarea recursivitii stnga
O gramatic este recursiv stnga dac exist un neterminal A astfel nct exist o derivare A + A
pentru (T N)*. O analiz sintactic descendent determinist nu poate s opereze cu o astfel de
gramatic, deci este necesar o transformare. S considerm nti cazul cel mai simplu pentru care n
gramatic exist producii de forma A A | . n acest caz limbajul generat este de forma n cu n 0.
Acelai limbaj poate s fie generat de ctre gramatica: A A', A' A'| .

S considerm de exemplu gramatica expresiilor aritmetice :
+ T | T, T T * F | F, F () | a
Se observ c pentru un ir de forma a + a * a, examinnd numai primul simbol terminal(a) nu este
clar cu care dintre produciile pentru trebuie s se nceap derivarea. Aplicnd ideea anterioar se obine
:
T ', ' +TE' | , T FT', T' *FT' | , F () | a
n acest caz derivarea va ncepe sigur prin aplicarea produciei TE' i se obine derivarea TE'
FT''. n acest moment se vede c pentru F trebuie s se aplice producia F a. Deci se obine +
aT''. Urmeaz simbolul terminal + datorit cruia pentru T' se va aplica producia T' , etc.
n general dac pentru un neterminal A exist produciile :
A A1 |A2 | ... |Am | 1 | 2 | ... | n
unde i nu ncepe cu A, 1 i n, se pot nlocui aceste producii cu :
A 1A' | 2A' | ... | nA'
A' 1A' | 2A' | ... | mA'|
Aceast construcie elimin recursivitatea stng imediat. S considerm ns gramatica:
A1 A2 a | b
A2 A3 c | d
A3 A1 e | f
cu A1 simbolul de start al gramaticii. Se observ c este posibil urmtoarea derivare:
A1 A2a => A3 ca => A1 eca
deci gramatica este recursiv stnga. Se observ c dac am considerat o ordine a simbolilor, toate
produciile mai puin ultima, respect regula "un simbol neterminal este nlocuit de un ir care ncepe cu
alt simbol neterminal cu un numr de ordine mai mare". Existena unei producii care nu respect condiia
conduce la apariia recursivitii stnga.
Dac gramatica nu permite derivri de tipul A + A (fr cicluri) i nu conine - producii poate s
fie transformat n vederea eliminrii recursivitii stnga utiliznd urmtorul algoritm, obinndu-se o
gramatic echivalent fr recursivitate stnga.

Se aranjeaz neterminalele n ordinea A1, ..., An

pentru i = 1 pn la n executa
pentru j = 1 pn la i - 1 executa
nlocuiete fiecare producie de forma Ai Aj cu
produciile Ai 1 | 2 | ... | k
unde Aj 1|2| ... |k sunt toate produciile
pentru Aj
elimin recursivitatea stnga ntre produciile Ai
S considerm pasul i. Produciile Ak Al care au mai rmas (pentru care k < i), au l > k. n aceasta
iteraie prin variaia lui j se ajunge ca pentru orice producie de forma Ai Am , m i. Dac se elimin
recursivitatea direct rmne m > i. S considerm de exemplu din nou gramatica :
A1 A2a | b, A2 A2c | A1d | e
Considerm pentru neterminale ordinea : A1, A2. Pentru A1 (i = 1) nu exist recursivitate stnga
direct deci nu se face nici o modificare. Pentru i = 2, producia A2 A1d se inlocuiete cu A2
A2ad | bd. Rezult deci c A2 A2c | A2ad | bd | e.
Eliminnd recursivitatea stnga se obine :
A1 A2a | b, A2 bdA2' | eA2', A2' cA2' | adA2' |
2.1.3.4
Factorizare stnga
Acest tip de transformare este util pentru producerea unei gramatici potrivite pentru analiza sintactic
descendent de tip determinist. Ideea este c dac nu este clar care dintre produciile alternative poate s
fie aplicat pentru un neterminal se va amna luarea unei decizii pn cnd s-a parcurs suficient din irul
de intrare pentru a se putea lua o decizie. S considerm de exemplu produciile :
SAbS|A
ABcA|B
B a | dSd
S presupunem c ncercm s construim irul derivrilor pentru a b a c a pornind de la simbolul de
start al gramaticii. Din recunoaterea simbolului a la nceputul irului nu se poate nc trage concluzia care
dintre cele doua producii corespunztoare neterminalului S trebuie s fie luata n considerare (abia la
ntlnirea caracterului b pe irul de intrare se poate face o alegere corect). n general pentru producia A
1 | 2 dac se recunoate la intrare un ir nevid derivat din nu se poate tii dac trebuie aleas
prima sau a doua producie. Corespunztor este util transformarea: A A', A' 1 | 2.
Algoritmul de factorizare funcioneaz n modul urmtor. Pentru fiecare neterminal A se caut cel mai
lung prefix comun pentru dou sau mai multe dintre produciile corespunztoare neterminalului A. Dac
atunci se nlocuiesc produciile de forma A 1 | 2 | ... | n | (unde reprezint alternativele
care nu ncep cu ) cu :
A A' |
A' 1 | 2 | ... | n

A' este un nou neterminal. Se aplic n mod repetat aceast transformare pn cnd nu mai exist dou
alternative producii cu un prefix comun pentru acelai simbol neterminal.
Relund exemplul considerat se obine :
S AX
X bS |
A BY
Y cA |
B a | dSd
Deci n analiza irului a b a la ntlnirea simbolului b pentru neterminalul Y se va utiliza producia Y
, n acest mod rezult irul de derivri :
S AX BYX aYX ...
2.1.3.5
Eliminarea simbolilor neterminali neutilizai
Un simbol neterminal neutilizat este un simbol care:

nu poate s apar ntr-o form propoziional, adic ntr-un ir derivat din simbolul de start al
gramaticii (simbol inaccesibil)
din care nu poate deriva un ir format numai din simboli terminali (simbol nefinalizabil)
care apare n formele propoziionale numai datorit sau mpreun cu simboli neterminali ce
satisfac una dintre condiiile anterioare.
Pornind de la o gramatic G = (N, T, P, S) se poate obine o gramatic fr simboli nefinalizai i care
satisface urmtoarele condiii:
(i) L(G) = L(G')
(i) A N, A + w, w T*.
utiliznd urmtorul algoritm :
N0 =
i=0
repeta
i=i+1
Ni = { A | A P si (Ni-1 T)* } Ni-1
pn Ni = Ni-1
N' = Ni
P' P conine numai produciile din P care au n partea stnga simboli din N' si n
partea dreapta simboli din N' si T.
Prin inducie asupra numrului de pai se poate demonstra corectitudinea algoritmului. S considerm
ca exemplu o gramatic avnd produciile : P = {S A, A a, B b, B a}, se observ c B este un
simbol neterminal inaccesibil. Aparent condiia de inaccesibilitate pentru un neterminal const din ne
apariia n partea dreapt a unei producii. Dac ns considerm o gramatic avnd produciile: {S A,
A a, B cC, C bB} se observ c este necesar o alt condiie.
Pornind de la o gramatic G = (N, T, P, S) se poate construi o gramatic fr simboli inaccesibili G' =
(N', T, P', S) care s satisfac condiiile:
(i) L(G) = L(G')

(i) A N', w (N T)*, S w i A apare n w
utiliznd urmtorul algoritm.
N0 = {S}
i=0
repeta
i = i + 1;
Ni = {A | A apare n partea dreapta a unei producii
pentru un neterminal din Ni-1} Ni-1
pn Ni = Ni-1
N' = Ni
P' conine numai producii care corespund neterminalelor din
N' si care conin n partea dreapta simboli neterminali numai din N'
Prin inducie asupra numrului de pai se poate determina corectitudinea algoritmului. Utiliznd
algoritmii pentru eliminarea simbolilor nefinalizai i cel pentru eliminarea simbolilor inaccesibili se
obine o gramatic care nu conine simboli neutilizai. Ordinea n care se aplic aceti algoritmi nu este
indiferent. S considerm de exemplu gramatica cu produciile:
S a | A, A AB, B b.
Dac se aplic nti algoritmul pentru eliminarea simbolilor nefinalizai, rmn produciile S
a i B b. Prin eliminarea simbolilor inaccesibili rmne numai producia S a. Dac ns se
aplic nti algoritmul pentru eliminarea simbolilor inaccesibili i apoi cel pentru eliminarea simbolilor
nefinalizai vor rmne pn la sfrit produciile S a i B b, adic nu se obine o gramatic fr
simboli neutilizai. Rezultatul obinut nu este ntmpltor n sensul c nu se poate gsii un exemplu pentru
care ordinea corect de aplicare a celor doi algoritmi s fie invers. Ideea este c prin eliminarea unui
simbol neterminal neaccesibil nu pot s apar simboli neterminali nefinalizai, n timp ce prin eliminarea
unui simbol neterminal nefinalizat pot s apar simboli neterminali inaccesibili deoarece anumii simboli
neterminali puteau s fie accesibili numai prin intermediul simbolului neterminal respectiv.
2.1.3.6
Substituia de nceputuri(corner substitution)
Anumite metode de analiz sintactic impun ca partea dreapt a fiecrei producii care nu este irul
vid s nceap cu un terminal. S considerm de exemplu gramatica avnd produciile:
lista a(numr) lista | *elem lista | a
elem a(numr) | *elem
n acest caz dac pe irul de intrare se gsete terminalul a nu este clar care dintre produciile pentru
neterminalul lista trebuie s fie utilizat.
Dac factorizm produciile neterminalului lista:
lista aX | *elem lista
X
(numr) lista |
elem a(numr) | *elem

Se observ ca n acest caz n funcie de simbolul terminal curent se poate decide n mod determinist
care este producia urmtoare ce trebuie s fie aplicat pentru derivare (construirea arborelui de derivare).
O gramatic independent de context pentru care este ndeplinit condiia ca partea dreapt a oricrei
producii ncepe cu un terminal sau este irul vid se numete gramatic de tip Q. O form particular de
gramatica de tip Q este forma normal Greibach. n acest caz nu exist --producii cu excepia cel mult a
unei --producii corespunztoare simbolului de start al gramaticii. n cazul n care aceasta producie
exist simbolul de start al gramaticii nu apare n partea dreapt a nici unei producii. n forma normal
Greibach produciile sunt de forma Aa cu a T i N*. S presupunem c o gramatic are
produciile:
P a1 1 | a2 2 | ... | an n |
unde ai T, i j ai aj, 1 i, j n. O procedur care recunoate irurile derivate din P este de
forma:
p(){
switch (caracter_urmtor){
case a1 : avans(); a1 /* tratare a1 */
case a2 : avans(); a2
...
case an : avans(); an
default: /* ? - producie */
}
}
Pe baza transformrilor anterioare se poate elabora un algoritm pentru construirea unei gramatici n
forma normal Greibach pentru o gramatic independent de context care nu este recursiv stnga.
Se definete nti o relaie de ordine asupra neterminalelor unei gramatici. i anume A < B dac exist
o producie A B . Considernd aceast relaie se observ c se poate construi o relaie parial de
ordine care poate s fie extinsa la o relaie liniar de ordine. Dac gramatica pentru care se construiete
aceast relaie nu este recursiv dreapta atunci produciile celui "mai mare" neterminal ncep sigur cu
simboli terminali. Rezult algoritmul:
Se construiete relaia de ordine asupra N astfel nct
N=
{A1, A2, ..., An} si A1 < A2 < ... < An.
pentru i = n - 1 pn la 1 pas = -1 executa
fiecare producie de forma Ai Aj cu i < j se nlocuiete cu Ai 1 | ... |
m unde Aj 1 | ...| m (se observa ca 1, ..., m ncep cu terminale)
pentru fiecare producie de forma p = A a X1 ... Xk execut

pentru i = 1 pn la k execut
dac Xi T
N = N {Xi'}
P = P { Xi' Xi}
P = P \ {p} {A aX1'X2' ... Xk'}
Prin inducie asupra numrului de pai se poate demonstra c algoritmul realizeaz transformarea
dorit. De exemplu pentru gramatica expresiilor aritmetice n forma fr --producii:

'
T
T'
F
T '
+TE'
FT'
*FT'
()
|
|
|
|
|
T,
+T,
F,
*F
a
Relaia de ordine liniar poate s fie ' < < T' < T < F. Se pornete de la F, pentru care toate
produciile ncep cu un terminal. Rezult modificarea produciilor pentru T:
T () T' | a T' | () | a.
Urmeaz T' care nu necesit transformri. Pentru se obine:

()T'' | a T' ' | ()' | aE' | ()T' | aT' | () | a
De asemenea ' nu se modific. Rezult urmtoarea gramatic n forma normal Greibach:
'
T
T'
F
A
2.1.4
(EAT'' | a T' ' | (EAE' | aE' | (EAT' | aT' | (EA | a

+TE' | +T
(EA T' | a T' | (EA | a.
*FT' | *F
(EA | a
)
Construcii dependente de context
Anumite construcii specifice limbajelor de programare nu pot s fie descrise prin limbaje
independente de context. S considerm cteva exemple :
1. Fie limbajul L1 = {wcw| w {0,1}*}. Acest limbaj realizeaz abstractizarea condiiei ca un
identificator s fie declarat nainte de a fi utilizat. L1 nu poate s fie generat de o gramatic
independent de context. Din acest motiv condiia ca un identificator s fie definit nainte de a fi
utilizat nu pot s fie verificat prin analiz sintactic, deci va fi verificat de ctre analiza
semantic.
2. Fie limbajul L2 = {anbmcndm | n > 1, m > 1}. Acest limbaj realizeaz abstractizarea corespondenei
ca numr ntre numrul de parametrii cu care au fost declarate procedurile i numrul de
parametrii cu care se utilizeaz acestea. Nici acest limbaj nu pot fi descris de o gramatic
independent de context. Pe de alt parte limbajul L2' = {anbn | n > 1}, poate s fie descris de
gramatica : S a S b | a b. Deci i aici dup o prim recunoatere fcut n analiza sintactic,
partea de dependen de context va fi rezolvat de ctre faza de analiz semantic.
Observaie
n general interpretnd gramaticile ca algoritmi de generare de iruri crora le corespund ca
echivaleni algoritmi de recunoatere de iruri, se constat c pentru cazul limbajelor regulate este necesar
ca pentru recunoatere s se fac o numrare pn la o valoare finit (care poate ns s fie orict de mare).
Astfel c limbajul LR = {anbn | 0 n 20000000000000} este un limbaj regulat. Numrul de a-uri
ntlnite poate s fie memorat n neterminalele. De altfel, LR este un limbaj finit i deci automat este
regulat (produciile gramatici pot s reprezinte de fapt lista irurilor care formeaz limbajul). Limbajul

LR1 = {w {0,1}* | |w| mod 3 = 0} este infinit i regulat. Se observ c pentru recunoaterea irurilor
este necesar s se numere cte dou elemente. n schimb limbajul LI = {anbn | 0 n} nu este regulat,
algoritmul pe care s-ar baza recunoaterea irurilor nu are o limit. Tratarea unei astfel de situaii se face n
mod natural utiliznd un contor infinit sau o stiv.
2.1.4.1
Exerciii
1. Fie gramatica:
A BC | a. B CA | Ab, C AB | cC | b
S se construiasc gramatica echivalenta nerecursiva stnga
2. S se elimine simbolii neutilizai pentru gramatica:
S A | B, A aB | bS | b, B AB | BA, C AS|b
3. S se construiasc gramatica echivalenta fr -producii pentru gramatica:
S ABC, A BB | , B CC | , C AA | b
4. S se construiasc un algoritm care verific dac pentru o gramatic dat G, L(G) este mulimea
vid. S se demonstreze c algoritmul este corect

2.1.5
Proprieti ale limbajelor independente de context
Limbajele formale sunt mulimi - putem s aplicm asupra lor operaii caracteristice mulimilor :
reuniune, intersecie, diferen dar i operaii specifice cum este de exemplu concatenarea. Dac L1 i L2
sunt dou limbaje, concatenarea lor este un limbaj L = L1L2 astfel nct:
L = { w | w = xy, x L1, y L2}
O alt operaie specific ce se poate aplica asupra unui limbaj formal L este "Kleen star". Notaia
utilizat pentru rezultat este L* i reprezint mulimea irurilor obinute prin concatenarea a zero sau mai
multe iruri din L (concatenarea a zero iruri este irul vid, concatenarea unui singur ir este el nsui etc.).
Se va utiliza i notaia L+ pentru LL*.
Dac aplicnd o operaie asupra oricror doua limbaje independente de context obinem un limbaj
independent de context vom spune c mulimea limbajelor independente de context este nchis sub
operaia respectiv. Se poate demonstra c mulimea limbajelor independente de context este nchis sub
operaiile: reuniune, concatenare i Kleen star.
S demonstrm de exemplu nchiderea sub operaia de reuniune. Fie doua gramatici G1 = (N1, T1, P1,
S1), G2 = (N2, T2, P2, S2). Putem ntotdeauna s presupunem c N1 N2 = eventual prin redenumirea
simbolilor neterminali din una dintre gramatici). Gramatica corespunztoare limbajului reuniune a
limbajelor generate de ctre cele doua gramatici se poate construi n modul urmtor:
G = (N, T, P, S), N = N1 N2 {S}, T = T1 T2, P = P1 P2 {S S1 | S2}
Pentru a demonstra c limbajul L(G) = L(G1) L(G2) trebuie s demonstrm includerea mulimilor
n ambele sensuri. Dac w L(G) nseamn c a fost obinut printr-o derivare ca S S1 * w sau S
S2 * w. Deci un ir derivat din S aparine limbajului L(G1) L(G2). Invers dac alegem un ir w
L(G1) L(G2) el este obinut dintr-o derivare din S1 sau din S2, deci se poate construi o derivare pentru
acest ir i n G. Construcii similare se pot face i pentru operaia de concatenare i pentru operaia Kleen
star. De exemplu L(G1)* pentru o gramatica G1 = (N1, T1, P1, S1) poate s fie generat de ctre:
G = (N1, T1, P1 {S1 | S1 S1}, S1)
Clasa limbajelor independente de context nu este nchis la operaiile de intersecie i complementare.
S considerm de exemplu limbajele L1 = {anbncm | n,m 0}, L2 = {ambncn | n,m 0}.
Limbajul L = L1 L2 este "cunoscut" ca fiind un limbaj dependent de context. S presupunem acum
c pentru un limbaj independent de context generat de ctre gramatica G = (N, T, P, S), limbajul
complementar, adic T* - L(G) este ntotdeauna independent de context. n acest caz, fie L un limbaj
obinut prin intersecia a dou limbaje independente de context: L1 i L2. Se poate scrie:
L = L1 L2 = T* - ((T* - L1) (T* - L2)).
Dac mulimea limbajelor independente de context este nchis la operaia de complementare atunci
(T* - L1) i (T* - L2) sunt limbaje independente de context i la fel este i reuniunea lor i la fel va fi i
complementarea limbajului obinut prin reuniune. Adic ar rezulta c L1 L2 este un limbaj independent
de context ceea ce deja tim c nu este adevrat.
Dup cum s-a constatat acelai limbaj poate s fie descris de mai multe gramatici, eventual de tipuri
diferite. Este util gsirea unui criteriu prin care s se indice tipul restrictiv al gramaticilor care pot s
descrie un limbaj dat, ntr-o manier mai precis dect observaia de la pagina 24. De exemplu s
considerm limbajul:

{ an * n | n > 1 }
Se pune problema dac exist o gramatica independent de context care s-l genereze. Urmtorul
rezultat ne d un criteriu cu ajutorul cruia putem s demonstrm c o gramatic nu este independent de
context.
Lema de pompare Fie L un limbaj independent de context. Atunci, exist o constanta k care este
caracteristic limbajului astfel nct dac z L i |z| k, atunci z poate s fie scris sub forma z = uvwxy
cu vx , |vwx| k , |w| 1 i pentru orice i, uviwxiy L.
S utilizm rezultatul anterior pentru a studia limbajul:
L = { an * n | n > 1 }
s presupunem c L este independent de context. nseamn c exist un numr k (asociat limbajului)
astfel nct dac n * n k atunci an x n = uvwxy astfel nct v i x nu sunt amndou iruri vide i |vwx| k.
S presupunem ca n este chiar k ( k * k > k). Rezult ca uv2wx2yL. Deoarece |vwx| k rezult 1 |vx| <
k deci lungimea irului iniial k x k < |uv2wx2y| < k x k + k. Dup k x k urmtorul ptrat perfect este (k +
1) x (k + 1) care este mai mare deci k x k + k, adic |uv2wx2y| nu poate s fie un ptrat perfect, deci L nu
poate s fie generat de o gramatic independent de context.
2.1.5.1
Exerciii
1. S se arate c limbajul { anbncn | n > 1 } nu este independent de context

2. S se arate c limbajul { anbncj | n > 1, j < n } nu este independent de context
2.2
Mulimi regulate, expresii regulate.
Fie T un alfabet finit. Se numete mulime regulat asupra alfabetului T mulimea construit recursiv
n modul urmtor:
1.
2.
3.
4.
este o mulime regulat asupra alfabetului T;

Dac a T atunci {a} este o mulime regulat asupra alfabetului T;
Dac P i Q sunt mulimi regulate atunci PQ, PQ, P* sunt mulimi regulate asupra alfabetului T.
Nimic altceva nu este o mulime regulat.
Se observ deci c o submulime a mulimii T* este o mulime regulat asupra alfabetului T dac i
numai dac este mulimea vida, este o mulime care conine un singur simbol din T sau poate s fie
obinut din aceste dou tipuri de mulimi utiliznd operaiile de reuniune (P Q), concatenare (PQ) sau
nchidere P*.
Descrierea mulimilor regulate se poate face cu ajutorul expresiilor regulate. O expresie regulat este
la rndul ei definit recursiv n modul urmtor (prin analogie cu definiia mulimilor regulate) :

1. este o expresie regulata care descrie mulimea ;
2. a T este o expresie regulat care descrie mulimea {a};
3. dac p,q sunt expresii regulate care descriu mulimile P i Q atunci :
a. (p + q) sau (p | q) este o expresie regulat care descrie mulimea P Q;
b. (pq) este o expresie regulat care descrie mulimea PQ;
c. (p)* este o expresie regulat care descrie mulimea P*.
4. nimic altceva nu este o expresie regulat.
De exemplu expresia (0 | 1)* reprezint mulimea {0,1}*, expresia regulat : (00 | 11)*((01 | 10)(00 |
11)*(01 | 10)(00 | 11)*)* reprezint mulimea care conine toate irurile formate din 0 i 1 i care conin un
numr par din fiecare simbol. n particular pp* este notat cu p+. ntre operatorii utilizai n descrierea
mulimilor regulate exist o serie de relaii de preceden. Cea mai prioritar operaie este operaia de
nchidere (notat cu *), urmeaz operaia de concatenare, cel mai puin prioritar este operaia + (|). De
exemplu, expresia regulat (0 | (1(0)*)) poate s fie scrisa i sub forma 0 | 10*.
Expresiile regulate au o serie de proprieti. Fie , , , expresii regulate. Spunem ca = dac i
numai dac i descriu aceleai mulimi regulate. Sunt adevrate urmtoarele proprieti :
1. | = | 2. | ( |) = ( | ) |
3. () = () 4. ( |) = |
5. ( | ) = | 6. ? = ? =
7. * = | * 8. (*)* = *
9. | =
Utiliznd expresii regulate se pot construi i rezolva ecuaii avnd ca soluii expresii regulate. S
considerm de exemplu ecuaia:
X = aX + b
unde a,b i X sunt expresii regulate. Se poate verifica uor c X = a * b este o soluie a acestei ecuaii.
Dac a este o expresie regulat care poate s genereze irul vid atunci soluia prezentat anterior nu este
unic. S nlocuim n ecuaie pe X cu expresia regulat:
a*(b + )
Se obine:
a*(b + ) = a[a*(b + )] + b =
= a+ b + a+ + b =
= (a+ + )b + a+ = a*b + a*
= a*(b + )
Se numete punct fix al unei ecuaii cea mai mic soluie a ecuaiei respective.
Propoziie Dac G este o gramatic regulat atunci L(G) este o mulime regulata.
Demonstraia acestei teoreme se face prin construcie. Nu vom face demonstraia dar vom considera
un exemplu de construcie. Fie gramatica G = ({A, B, C}, {0,1}, P,A) cu P = {A 1A | 0B, B 0B | 1C,
C 0B| 1A| }. Se cere s se construiasc expresia regulat care genereaz acelai limbaj ca i G. Se pot
scrie urmtoarele ecuaii:
A = 1A + 0B
B = 0B + 1C

C = 0B + 1A +
Din prima ecuaie se obine: A = 1*0B. Din a doua ecuaie se obine: B = 0*1C. nlocuind n A se
obine: A = 1*00*1C = 1*0+1C. nlocuind n a treia ecuaie se obine:
C = 0+1C + 1+0+1C +
C = ( + 1+)0+1C + = 1*0+1C
C = (1*0+1)*
Rezult:
A = 1*0+1 (1*0+1)*
A = (1*0+1)+
Mulimea regulat descrie irurile de 0 i 1 care se termin cu sub irul 01. Evident o expresie mai
simpl pentru descrierea aceluiai limbaj este:
(0 | 1)*01
Se observ c se poate considera c limbajul se obine prin concatenarea a doua limbaje unul descris
de expresia (0 | 1)* i cellalt descris de expresia 01. Rezult urmtoarea gramatic:
S AB
A 0A | 1A |
B 01
Se observ c gramatica obinut nu este regulat. S transformm aceast gramatic prin substituie
de nceputuri:
S 0AB | 1AB | B
A 0A | 1A |
B 01
Se obine:
S 0S | 1S |01
Utiliznd factorizarea:
S 0X | 1S
X S | 1
Din nou prin nlocuire de nceputuri se obine:
X 0X | 1S |1
Aplicnd factorizarea:
X 0X | 1Y
YS|

Rezult gramatica descris de produciile:

S 0X | 1S
X 0X | 1Y
Y 0X | 1S | .
Se observ c s-a ajuns la aceeai gramatic cu cea iniial ( desigur dac redenumim neterminalele).
Expresiile regulate reprezint o metod alternativ generativ pentru definirea limbajelor regulate.
Limbajele definite de gramatici regulate sunt utilizate la nivelul analizei lexicale, n majoritatea limbajelor
de programare modul de scriere al numelor i al identificatorilor pot s fie descrise de gramatici respectiv
de expresii regulate. Construirea expresiilor regulate corespunztoare atomilor lexicali reprezint prima
etapa n proiectarea unui analizor lexical.
2.3
Acceptoare
Un acceptor este un dispozitiv format dintr-o band de intrare, o unitate de control i o memorie
auxiliar.
+--------------|a0|a1|...|an|
+--------------\ cap de citire
\
+---------+
| unitate |
| de
|
| control |
+---------+
|
+-----------+
| memorie |
| auxiliara |
+-----------+
Banda de intrare este formata din elemente n care se nscriu simbolii din irul de intrare. La un
moment dat capul de citire este fixat pe un simbol. Funcionarea dispozitivului este dat de aciunile
acestuia. ntr-o aciune capul de citire se poate deplasa la stnga sau la dreapta sau poate s rmn
nemicat. n cadrul unei aciuni unitatea de control are acces la informaia din memoria auxiliar pe care o
poate modifica. Se observ ca acest model este foarte general. Utiliznd diferite restricii asupra benzii de
intrare, organizrii i accesului la memoria auxiliar se obin diferite cazuri particulare de acceptoare.
O aciune a acceptorului este formata din :
deplasarea capului de citire la stnga sau la dreapta sau meninerea capului de citire pe aceeai poziie
i / sau;
memorarea unei informaii n memoria auxiliar i / sau;
modificarea strii unitii de control.
Comportarea unui acceptor poate s fie descris n funcie de configuraiile acestuia. O configuraie
este format din urmtoarele informaii :
starea unitii de control;

coninutul benzii de intrare i poziia capului de citire;

coninutul memoriei.
Rezult c o aciune a acceptorului poate s fie precizat prin configuraia iniial (nainte de aciune)
i cea final (dup execuia aciunii).
Dac pentru o configuraie dat sunt posibile mai multe aciuni atunci spunem c acceptorul este
nedeterminist altfel este determinist.
Un acceptor are o configuraie iniial n care unitatea de control este ntr-o stare iniial, capul de
citire este fixat pe simbolul cel mai din stnga al irului de intrare iar memoria are un coninut iniial
specific. Acceptorul are o configuraie final pentru care capul de citire este situat pe simbolul cel mai din
dreapta de pe banda de intrare. Se spune c dispozitivul a acceptat un ir de intrare w dac pornind din
configuraia iniial ajunge n configuraia finala. Eventual, noiunea de acceptare poate s fie condiionata
i de ajungerea ntr-o anumit stare a unitii de control sau de un anumit coninut al memoriei auxiliare.
Evident dac acceptorul este nedeterminist dintr-o configuraie iniial pot avea loc mai multe evoluii.
Dac exist ntre acestea una pentru care se ajunge la o configuraie final atunci se spune c dispozitivul a
acceptat irul de intrare.
Limbajul acceptat de ctre un acceptor este format din mulimea irurilor acceptate de ctre acesta.
Pentru fiecare tip de gramatica din ierarhia Chomsky exist o clasa de acceptoare care definesc
aceeai clas de limbaje. Dintre acestea cele utilizate pentru implementarea compilatoarelor sunt
automatele finite care sunt acceptoare pentru limbaje regulate i automatele cu stiv (push-down), care
sunt acceptoare pentru limbajele independente de context. Automatele finite sunt acceptoare fr memorie
auxiliar iar automatele cu stiv sunt acceptoare pentru care accesul la memoria auxiliar se face conform
unui mecanism de tip stiv.
2.3.1
Automate finite
Un automat finit este un obiect matematic AF = (Q, T, m, s0, F) unde :
Q este mulimea finit a strilor;

T este o mulime finit numit alfabet de intrare;
m : Q x (T {}) P(Q) este funcia parial a strii urmtoare;
s0 Q este o stare numit stare de start;
F Q este o mulime de stri numit mulimea strilor finale (de acceptare).
Dac pentru q Q, a T m(q,a) este definit, atunci m(q,a) se numete tranziie, dac a = atunci
m(q,a) se numete -tranziie. Se observ ca pentru o combinaie stare(q Q), intrare(a T) pot s
corespund mai multe stri urmtoare, deci aa cum a fost definit, automatul este nedeterminist (AFN).
Pentru reprezentarea unui automat finit se pot utiliza dou moduri de reprezentare, printr-o tabela de
tranziie sau printr-un graf. S considerm de exemplu automatul care accepta limbajul definit de expresia
(a | b)* abb. Poate s fie descris sub forma urmtoarei tabele :
simbol de intrare
stare
0
1
2
3
a
{0, 1}
-
b
{0}
{2}
{3}
+
Se observ c n fiecare intrare este specificat mulimea strilor urmtoare n care se trece pentru
starea i simbolul corespunztor intrrii respective. Acelai automat finit poate s fie descris de urmtorul
graf de tranziie :

a
--\/
+---+ +---+ +---+ +---+
start
| | a | | b | | b |+-+|
-------->| 0 |-->| 1 |-->| 2 |-->||3||
| | | | | | |+-+|
+---+ +---+ +---+ +---+
/\
--b
Se observ c pentru fiecare stare exist cte un nod, ntre dou noduri exist un arc etichetat cu un
simbol de intrare dac i numai dac se poate trece din starea reprezentat de primul nod n starea
reprezentat de al doilea nod la aplicarea la intrare a simbolului cu care este etichetat arcul. De remarcat
modul n care a fost specificat starea final.
Se spune c un automat finit accept un ir de intrare dac exist o cale n graful de tranziie ntre
nodul care reprezint starea de start i un nod care reprezint o stare final, astfel nct irul simbolilor
care eticheteaz arcele care formeaz aceast cale este irul de intrare. De exemplu irul aabb este acceptat
de automatul descris anterior, care va executa urmtoarele micri:
a a b b
0 0 1 2 3
Se observa c pentru acelai ir de intrare exist i alte secvene de intrri care ns nu duc ntr-o stare
de acceptare:
a
a
b
b
00000
Un caz particular al automatelor finite este dat de automatele finite deterministe (AFD). n cazul
automatelor finite deterministe definiia funciei strii urmtoare se modific:
m : S x T S.
Se observ c sunt satisfcute urmtoarele restricii:
1. nu exist -tranziii;
2. pentru (q, a) Q x T este definit cel mult o tranziie.
Se observ ca n acest caz, pentru un ir de intrare dat, n graful de tranziie exist cel mult o cale care
pornete din starea de start i duce ntr-o stare de acceptare.
2.3.1.1
Construcia unui automat finit nedeterminist care accept limbajul descris de o expresie regulat dat
Algoritmul pe care l vom prezenta utilizeaz direct structurile din definiia expresiilor regulate. Se
pleac de la o expresie regulat r asupra unui alfabet T i se obine un automat finit nedeterminist (N) care
accept limbajul L(r).
Pentru construirea automatului se identific n structura expresiei r structurile care n mod recursiv
compun expresia i se construiesc automatele finite nedeterministe (AFN) elementare corespunztoare.

1. Pentru expresia , automatul care accept limbajul corespunztor este :
+---+
+-----+
start
| |
|+---+|
------->| i |------>|| f ||
| |
|+---+|
+---+
+-----+
2. Pentru expresia a, automatul care accept limbajul corespunztor este :

+---+
+-----+
start
| | a
|+---+|
-------->| i |------>|| f ||
| |
|+---+|
+---+
+-----+
3. Fie dou expresii regulate r,t pentru care s-au construit automatele finite nedeterministe
corespunztoare N(r) i N(t).
a. pentru expresia regulat r|t limbajul corespunztor este acceptat de :

------------------------| +---+
+-----+ |
| | | N(r) |+---+| |
--------->| |-- >|| ||---/
| | |
|+---+| | \
/
| +---+
+-----+ | \
+---+ /
|
| \ +-----+
| |/
------------------------\|+---+|
->| i |
|| f ||
| |\
------------------------/|+---+|
+---+ \
|
| / +-----+
\
| +---+
+-----+ | /
\
| | | N(t) |+---+| | /
---------->| |-- >|| ||---/
| | |
|+---+| |
| +---+
+-----+ |
|
|
-------------------------
b. pentru expresia regulat rt limbajul corespunztor este acceptat de :

---------------------------|
|
--------------+----------|
| +---+
| +---+ |
+-----+ |
| | | N(r) | | | | N(t)|+---+| |
--------->| i |--- -+> | |---- >|| f ||---| | |
| | | |
|+---+| |
| +---+
| +---+ |
+-----+ |
|
|
|
|
--------------+----------|
|
|
----------------------------
Se observ ca n acest caz starea final a automatului corespunztor expresiei r coincide cu starea
iniial a automatului corespunztor expresiei t.
c. pentru expresia regulata r* limbajul corespunztor este acceptat de :
+-<------------+
|
|
-----|--------------|----+---+
| +---+
+---+ |
+-----+
| |
| | | N(r)
| | | |+---+|
---->| i |----------> | |--- ---> | |-------->|| f ||
| |
| | |
| | |
|+---+|
+---+
| +---+
+---+ |
+-----+
|
|
|
/\
|
-------------------------|
|
|
+---------------------------------------------+
d. pentru expresia (r) limbajul corespunztor este acceptat de automatul care accepta N(r).

Se observ c pentru fiecare AFN - elementar se adaug cel mult o stare iniial i o stare final.
Corespunztor pentru o expresie regulat dat automatul va avea un numr de stri egal cu maxim dublul
numrului de simboli de intrare care apar n expresie. Compunerea acestor automate elementare va
produce evident un automat care recunoate limbajul generat de expresie. De exemplu pentru expresia
regulata : (a|b)*abb se obine :
pentru fiecare a din expresie :
+---+
+-----+
| | a
|+---+|
-------->| i |------> || f ||
| |
|+---+|
+---+
+-----+
pentru fiecare b din expresie :

+---+
+-----+
| | b
|+---+|
-------->| i |------> || f ||
| |
|+---+|
+---+
+-----+
pentru a | b :
+---+
+-----+
| | a |+---+|
----------> | |------>|| ||---/
| |
|+---+|
\
/
+---+
+-----+
\
+---+ /
\ +-----+
| |/
\|+---+|
->| i |
|| f ||
| |\
/|+---+|
+---+ \
/ +-----+
\
+---+
+-----+
/
\
| | b |+---+|
/
---------->| |------>|| ||---/
| |
|+---+|
+---+
+-----+
n final se obine :

---------------+
/
|
/
+-+ +-+
|
/
| |a | |
|
/
/ >|2|->|3|\ |
/
/
|| || \|
+-+ +-+ /
+-+ +-+ +-+ +-+ +-+ +-+ +--+
| | | |/
| | | |a | |b | |b |--|
> |0|->|1|
|6|->|7|->|8|->|9|->|10|
| | | |\
/| | | | | | | | |--|
+-+ +-+ \
+-+ +-+ / +-+ +-+ +-+ +-+ +--+
\
\ | |b | | /
/\
\
\ > |4|->|5|/
/
\
|| ||
/
\
+-+ +-+
/
\
/
--------------------
2.3.1.2
Conversia unui automat finit nedeterminist (AFN) ntr-un automat finit determinist(AFD)
Din exemplele anterioare s-a observat c un acelai limbaj reprezentat de expresia regulat (a | b)*
abb poate s fie recunoscut de dou automate diferite - unul nedeterminist i unul determinist.
Propoziie Pentru orice automat finit nedeterminist exist un automat finit determinist care accept
acelai limbaj.
Avnd n vedere aceast echivalen ntre cele dou automate se pune problema, cum se poate
construi un automat determinist echivalent unui automat nedeterminist dat. n cele ce urmeaz vom
considera c automatul finit nedeterminist a fost construit pornind de la o expresie regulat pe baza
construciei prezentate n capitolul anterior. Algoritmul care construiete automatul determinist utilizeaz
o metod de construire a submulimilor unei mulimi date. Diferena ntre automatele deterministe i cele
nedeterministe este dat de cardinalitatea funciei m. Automatul determinist se va construi calculnd n
mod recursiv strile acestuia, simulnd n paralel toate evoluiile posibile pe care le poate parcurge
automatul nedeterminist. Starea iniial a automatului finit determinist va corespunde mulimii strilor din
automatul nedeterminist n care se poate ajunge pornind din starea iniiala s0 i utiliznd numai -tranziii.
Orice stare s' a automatului determinist corespunde unei submulimi Q' Q a automatului nedeterminist.
Pentru aceasta stare i un simbol de intrare a T,
m(s',a) = {s Q | ( q Q')(s = m(q,a))}.
Rezult deci c n funcionarea AFD care simuleaz de fapt funcionarea AFN se urmresc simultan
toate "cile" pe care poate evolua automatul finit nedeterminist. Algoritmul care construiete automatul
finit determinist echivalent cu un automat nedeterminist dat utilizeaz dou funcii : -nchidere i mutare.
Funcia -nchidere : P(Q) P(Q) determin pentru fiecare mulime Q' Q setul strilor n care se poate
ajunge datorit -tranziiilor. Considernd o stare q a automatului finit determinist (AFD), aceasta
reprezint de fapt o submulime Q' Q a automatului nedeterminist. Notm cu
-nchidere(Q) = -nchidere({s})
sQ

unde dac s S este o stare care nu are -tranziii atunci:

-nchidere({s}) = {s}
altfel
-nchidere({s}) = -nchidere({s'}) {s}
s' m(s,)
Construcia funciei -nchidere pentru o mulime Q' se poate face utiliznd urmtorul algoritm :
A = Q', B =
ct timp A \ B execut
fie t A \ B
B = B {t}
pentru fiecare u Q astfel nct m(t,) = u executa
A = A {u}
-nchidere(Q') = A
Funcia mutare : P(Q) x T P(Q) este utilizat pentru construcia strii urmtoare a automatului
determinist. Astfel pentru o stare q a automatului determinist, cruia i corespunde o mulime Q' Q, i o
intrare a T,
mutare(Q,a) = m(s,a)
sQ'
Construcia automatului determinist se face prin construcia unei tabele de tranziii tranz_AFD[] i a
unei mulimi de stri stari_AFD.
stari_AFD = {-inchidere({s0})}
A=
ct timp stari_AFD \ A execut
fie t stari_AFD \ A
A = A {t}
pentru fiecare a T execut
B = -inchidere(mutare(t,a))
stari_AFD = stari_AFD {B}
tranz_AFD[t,a] = B
Fie automatul nedeterminist :

---------------+
/
|
/
+-+ +-+
|
/
| |a | |
|
/
/ >|2|->|3|\ |
/
/
|| || \|
+-+ +-+ /
+-+ +-+ +-+ +-+ +-+ +-+ +--+
| | | |/
| | | |a | |b | |b |--|
> |0|->|1|
|6|->|7|->|8|->|9|->|10|
| | | |\
/| | | | | | | | |--|
+-+ +-+ \
+-+ +-+ / +-+ +-+ +-+ +-+ +--+
\
\ | |b | | /
/\
\
> |4|->|5|/
/
\
|| ||
/
\
+-+ +-+
/
\
/
--------------------
Se observ c
-inchidere(0) = {0, 1, 2, 4, 7}, -inchidere(mutare({0,1,2,4,7}),a)) = -inchidere({3,8}) =
{1,2,3,4,6,7,8}. Dac q1 = {0,1,2,4,7}, q2 = {1,2,3,4,6,7,8} atunci tran_AFD(q1,a) = q2. Continund se
obine urmtoarea tabel de tranziie :
stare | intrare | multime corespunzatoare AFN
|a |b |
-----------+----+----+-------------------------------------q1 | q2 | q3 | {0,1,2,4,7} -inchidere({0})
-----------+----+----+-------------------------------------q2 | q2 | q4 | {1,2,3,4,6,7,8} -inchidere({3,8})
-----------+----+----+-------------------------------------q3 | q2 | q3 | {1,2,4,5,6,7} -inchidere({5})
-----------+----+----+-------------------------------------q4 | q2 | q5 | {1,2,4,5,6,7,9} -inchidere({5,9})
-----------+----+----+-------------------------------------q5 | q2 | q3 | {1,2,4,5,6,7,10} -inchidere({5,10})
------------------------------------------------------------
Graful automatului finit determinist care a rezultat este:

b
--\/
+---+
| |
b
b >| q3|<---------------------+
/ +-| |
|
+---+ /a | +---+
|
start | |/ | +---+
+---+
+------+
------>| q1| a \/| | b
| |b
|+----+|
| |---> | q2|------>| q4|----->|| q5 ||
+---+
| |
| |
|+----+|
+---+
+---+
+------+
/\ ||
a
|
|
-- |+-<--------+
|
a|
|
|
a
|
+--<--------------------+
Se observ c s-a obinut un automat cu 5 stri fa de 4 stri ct avea automatul finit determinist cu
care s-au exemplificat automatele finite deterministe. Deci algoritmul utilizat nu produce neaprat o
soluie optim.
2.3.1.3
Construcia unui automat finit determinist care accept limbajul descris de o expresie regulat dat
O expresie regulat poate s fie reprezentat sub forma unui arbore (sintactic). De exemplu pentru
expresia regulata (a|b)*abb rezult arborele:
.
/\
/ \
.
b
/\
/ \
.
b
/\
/ \
*
a
|
/\
/ \
a
b
Se observ c n nodurile interioare apar operatori iar frunzele sunt reprezentate de ctre simbolii de
intrare. Exist trei operatori (|, *, .). Pentru a simplifica construciile considerm pentru orice expresie
regulata i un simbol de sfrit pe care l vom nota cu # astfel nct orice expresie regulata r va fi
reprezentat de r#. Relund pentru expresia anterioar va rezulta graful:

/\
/ \
.
#
/\
/ \ 6
.
b
/\
/ \ 5
.
b
/\
/ \ 4
*
a
|
/\
3
/ \
a
b
1
Vom ataa fiecrei frunze un cod unic, de exemplu acest cod poate s fie reprezentat de poziia
simbolului respectiv n expresia regulat.
Fie C mulimea codurilor ataate fiecrei frunze i N mulimea nodurilor arborelui. Fie c funcia de
codificare i c-1 funcia invers (c : N C). Definim patru funcii:
nullable : N {adevrat, fals}
firstpos : N P(C)
lastpos : N P(C)
followpos : C P(C)
Funcia nullable este o funcie logic care are valoarea adevrat dac i numai dac subarborele
corespunztor nodului respectiv reprezint o expresie regulat care poate s genereze irul vid. Astfel
funcia nullable aplicat subarborelui:
|
/\
a b
are valoarea fals n schimb aplicat asupra subarborelui:
*
|
a
are valoarea adevrat.
Funcia firstpos aplicat unui subarbore are ca valoare mulimea codurilor frunzelor corespunztoare
poziiilor de nceput pentru subirurile care pot s fie generate de ctre expresia regulat corespunztoare
subarborelui
respectiv.
De
exemplu
pentru
nodul
rdcin
al
subarborelui:

x
.
/\
/ \
*
a
|
/\
3
/ \
a
b
1
2
(a | b)* a
1 2 3
firstpos(x) = {1,2,3}
lastpos(x) = {3}
Funcia lastpos aplicat unui subarbore are ca valoare setul codurilor frunzelor corespunztoare
poziiei de sfrit pentru subirurile care pot s fie generate de ctre expresia regulat corespunztoare
subarborelui respectiv.
Funcia followpos este definit asupra mulimii codurilor frunzelor. Dac i este un cod i i este asociat
simbolului x, (i = c-1(x)) atunci followpos(i) este mulimea codurilor j (j = c-1(z)) care satisfac urmtoarea
condiie: xy (etichetate cu i i respectiv j ) pot s apar ntr-un ir generat din rdcin.
Altfel spus dac se consider irurile obinute din cuvintele din L(r) (limbajul generat de expresia
regulat) prin nlocuirea simbolilor din T cu codurile asociate frunzelor din graf care le genereaz,
followpos(i) conine toate codurile care pot s apar imediat dup i n aceste iruri. De exemplu
followpos(1) = {1,2,3}. Pentru a calcula funcia followpos trebuie s se calculeze funciile firstpos i
lastpos care la rndul lor necesit calculul funciei nullable. Regulile pentru calculul funciilor nullable,
firstpos i lastpos sunt urmtoarele :
forma nod n
n este o frunz
cu eticheta
n este o frunz
cu eticheta
avnd codul i
nullable(n)
adevrat
firstpos(n)
lastpos(n)
fals
{i}
{i}
nullable(c1)
sau
nullable(c2)
firstpos(c1)
firstpos(c2)
lastpos(c1)
lastpos(c2)
nullable(c1)
si
nullable(c2)
dac nullable(c1)
firstpos(c1)
firstpos(c2)
altfel
firstpos(c1)
firstpos(c)
dac nullable(c2)
lastpos(c1)
lastpos(c2)
altfel
lastpos(c2)
lastpos(c)
|
/\
/ \
c1 c2
.
/\
/ \
c1 c2
*
|
c
adevrat
Pentru a calcula followpos(i) care indic ce coduri pot s urmeze dup[ codul i conform arborelui se
utilizeaz dou reguli :
1. dac n este un nod corespunztor operatorului de concatenare cu subarborii c1 i c2 (respectiv stnga
dreapta) atunci dac i este un cod din lastpos(c1) toate codurile din firstpos(c2) sunt n mulimea
followpos(i).

2. dac n este un nod corespunztor operatorului *, i i este un cod din lastpos(n) atunci toate codurile
din firstpos(n) sunt n mulimea followpos(i).
Pentru arborele anterior valorile funciilor firstpos i lastpos sunt reprezentate n stnga respectiv
dreapta fiecrui nod.
{1,2,3} .{6}
/\
/ \
/
\
{1,2,3} .{5} {6}#{6}
/\
6
/ \
/
\
{1,2,3} .{4} {5}b{5}
/\
5
/ \
/
\
{1,2,3} .{3} {4}b{4}
/\
4
/ \
/
\
{1,2} *{1,2} {3}a{3}
|
3
{1,2} | {1,2}
/\
/ \
/
\
{1} a{1} {2}b{2}
1
2
Singurul nod pentru care funcia nullable are valoarea adevrat este nodul etichetat cu *. Pe baza
acestor valori s calculm followpos(1). n followpos(1) vor apare codurile din firstpos pentru nodul
etichetat cu * i codurile din firstpos pentru subarborele dreapta corespunztor operatorului de concatenare
(followpos(1) = followpos(2) = {1,2,3}. Rezult urmtoarele valori :
nod
1
2
3
4
5
6
followpos
{1,2,3}
{1,2,3}
{4}
{5}
{6}
-
Pornind de la aceste valori se poate construi un graf n care fiecare nod reprezint un cod iar ntre
dou noduri corespunztoare codurilor i i j exist un arc dac j followpos(i).

--\/
+---+
+- | |
|
| 1 |\ +---+
| +-| | \| |
| | +---+ | 3 |-
| | +---+ | |
| | | | /+---+
| +>| 2 |/
+----| |
+---+
/\
--
+---+
| |
| 4 |-
| |
+---+
+---+
| |
| 5 |-
| |
+---+
+-----+
|+---+|
|| 6 ||
|+---+|
+-----+
Pe baza unui astfel de graf se poate obine un automat finit nedeterminist fr -tranziii, etichetnd
arcele n modul urmtor. Dac ntre nodul i i nodul j exist un arc acesta va fi etichetat cu simbolul care
are codul j. Fiecare stare a automatului corespunde unui nod din graf. Automatul are ca stri iniiale strile
din firstpos pentru nodul rdcin. Strile finale sunt strile asociate cu simbolul #. Automatul care a
rezultat, avnd mai multe stri iniiale nu se ncadreaz de fapt n definiia pe care am dat-o pentru un
automat finit. Dac ns mai adugm o stare suplimentar care s reprezinte unica stare iniial din care
pe baza unor -tranziii ajungem ntr-una dintre strile automatului obinut, se vede c ne ncadrm n
definiia considerat
a
--\/
+---+
+-> | | a
|
| 1 |\ +---+
| +-| | \| | b
a |b | +---+ | 3 |->
| | +---+ | |
| | | | /+---+
| +>| 2 |/ a
+----| |
+---+
/\
-b
+---+
+---+
+-----+
| | b | | # |+---+|
| 4 |->| 5 |->|| 6 ||
| |
| |
|+---+|
+---+
+---+
+-----+
Mai interesant ns este faptul c funcia followpos poate s fie utilizat pentru construirea unui
automat determinist utiliznd un algoritm similar celui pentru construirea submulimilor.

stari_AFD = { first_pos(radacina) } // multime de multimi de coduri
A=
ct timp stari_AFD \ A execut
fie t stari_AFD \ A
// mulime de coduri
A = A {t}
pentru fiecare a T execut
X = { followpos(p) | c-1(p) = a}
pt
daca X
stari_AFD = stari_AFD {X}
tranz_AFD(t,a) = X
n algoritm firstpos(rdcin) este valoarea funciei firstpos aplicat nodului rdcin.

Se observ c firstpos(rdcina) corespunde cu -inchidere(s0) iar followpos(p) reprezint nchidere(mutare(...)).
Aplicnd acest algoritm i rezultatele anterioare se obine automatul finit determinist reprezentat de
urmtorul graf :
b
b
---------<---------------------+
\/ /
|
(a | b)* a b b #
+---+ /
|
1 2 3456
start | 1,|/
+---+
+---+
+------+
| |
| 1,|
| 1,|
|+----+|
-----> | 2,| a | 2,| b
| 2,| b
||1,2,||
| 3 |----->| 3,|---- | 3,|----||3,6 ||
+---+
|4|
|5|
|+----+|
+---+
+---+
+------+
/\ ||
a
|
|
-- |+-<--------+
|
a|
|
|
a
|
+--<---------------------+
Fie q1 = firstpos(rdcina) = {1,2,3}. Se observ c r(1) = r(3) = a, r(2) = r(4) = r(5) = b. Pentru q1 i
a se obine q2 = followpos(1) followpos(3) = {1,2,3,4}, deci tranz_AFD(q1,a) = q2. Pentru q2 i b,
followpos(2) = {1,2,3} = q1 i tranz_AFD(q1,b) = q1, etc.
Nici aceasta construcie nu garanteaz faptul c automatul obinut este minim.

2.3.1.4
Simularea unui automat finit determinist
Construim un algoritm care urmeaz s rspund la ntrebarea - dndu-se un automat finit determinist
D i un ir, este irul acceptat de ctre automat ?
Algoritmul utilizeaz funciile mutare (care determin starea urmtoare pentru o stare i un simbol de
intrare dat) i caracterul_urmtor (care obine caracterul urmtor din irul de intrare).
s = s0
c = caracterul_urmtor
cat timp c eof executa
s = mutare(s,c)
c = caracterul_urmtor
daca s F
atunci rezultat "DA"
altfel rezultat "NU"
Dac aplicm acest algoritm pentru automatul :

b
-------------b
/
\
--/
\
\/ V
\
+---+ +---+ +---+ +---+
start
| | a | | b | | b |+-+|
------> | 0 |>| 1 |> | 2 |> ||3||
| | | | | | |+-+|
+---+ +---+ +---+ +---+
|
|
/\
-- | |
|
|
a | +-----+
|
|
a
|
+---------------+
a
care accepta limbajul (a | b)* abb, pentru irul ababb, se observ c va parcurge secvena de stri
012123.

2.3.1.5
Simularea unui automat finit nedeterminist
Prezentm n continuare un algoritm pentru simularea unui automat finit nedeterminist. Algoritmul
citete un ir de intrare i verific dac automatul l accepta sau nu. Se consider c automatul a fost
construit direct pornind de la expresia regulat. n consecin automatul va satisface urmtoarele
proprieti:
1. are cel mult de dou ori mai multe stri fa de numrul de simboli i operatori care apar n expresia
regulat;
2. are o singur stare de start i o singur stare de acceptare. Dintr-o stare de acceptare nu pleac nici o
tranziie;
3. din fiecare stare pleac fie o tranziie pentru un simbol din alfabetul de intrare T, fie o -tranziie sau
doua -tranziii.
Se consider c exist un mecanism prin care se poate stabilii faptul c s-a ajuns la sfritul irului de
intrare (test de tip eof). Algoritmul de simulare se aseamn cu cel utilizat pentru construcia unui automat
finit determinist echivalent cu automatul N, diferenele constau n faptul c pentru fiecare mulime de stri
Q n care poate s ajung automatul pentru un prefix al irului x se consider pentru construirea mulimii
Q' de stri urmtoare numai simbolul curent din irul x. n momentul n care s-a ajuns la sfritul irului
(s-a ajuns la eof) dac n setul strilor curente este inclus i o stare de acceptare (final), atunci rspunsul
este "DA" altfel rspunsul este "NU".
S = -inchidere({s0}) # -inchidere(S) = {s' Q | s S, s' m(s,)} S
a = caracterul_urmtor
ct timp a eof execut
S = -inchidere(mutare(S,a)) # mutare(S,a) = m(s',a)
s' S
a = caracterul_urmtor
daca S F
atunci rezultat "DA"
altfel rezultat "NU"
Algoritmul poate s fie implementat eficient utiliznd dou liste i un vector indexat cu strile
automatului finit nedeterminist. ntr-o list se pstreaz mulimea strilor curente ale automatului, n
cealalt mulimea strilor urmtoare. Utiliznd algoritmul de calcul al strilor urmtoare pentru -tranziii
se calculeaz setul -nchidere pentru o stare dat. Vectorul este utilizat pentru a asigura funcionarea listei
ca o mulime n sensul c dac o stare este coninuta n list atunci ea nu trebuie s mai poat fi adugat.
Dup ce s-a terminat calculul -inchiderii pentru o stare se face schimbarea rolului celor dou liste.
Deoarece fiecare stare are cel mult dou tranziii, fiecare stare poate s produc cel mult dou stri noi. Fie
|N| numrul de stri pentru AFN. Deoarece n lista pot s fie memorate maximum |N| stri, calculul strii
urmtoare se poate face ntr-un timp proporional |N|. Deci timpul necesar pentru simularea AFN pentru
irul de intrare x va fi proporional cu |N| x |x|. S relum de exemplu automatul :

---------------+
/
|
/
+-+ +-+
|
/
| |a | |
|
/
/ > |2|->|3|\ |
/
/
|| || \|
+-+ +-+ /
+-+ +-+ +-+ +-+ +-+ +-+ +--+
| | | |/
| |? | |a | |b | |b |--|
> |0|->|1|
|6|->|7|->|8|->|9|->|10|
| | | |\
/| | | | | | | | |--|
+-+ +-+ \
+-+ +-+ / +-+ +-+ +-+ +-+ +--+
\
\ | |b | | /
/\
\
> |4|->|5|/
/
\
|| ||
/
\
+-+ +-+
/
\
/
--------------------
Acest AFN accept expresia regulata (a|b)*abb. S considerm de exemplu irul de intrare x = ab.
Evoluia celor dou liste va fi urmtoarea :
lista 1
lista 2
a
--------->
-i({0}) = {0,1,2,4,7}
-i({3,8}) = {1,2,3,4,6,7,8}
b
<------------i({5,9}) = {1,2,4,5,6,7,9}
Se observ c s-a ajuns la mulimea {1,2,4,5,6,7,9} care nu conine o stare de acceptare deci irul x nu
este acceptat de ctre automat.
2.3.1.6
Probleme de implementare pentru automatele finite deterministe i nedeterministe
n compilatoare, automatele finite sunt utilizate pentru implementarea analizoarelor lexicale.

Specificarea atomilor lexicali se face sub forma de expresii regulate. Din acest motiv este interesant s
discutm modul n care pornind de la o expresie regulat putem s ajungem la un program care s
realizeze "execuia" sau altfel spus simularea automatului finit corespunztor. Din cele prezentate anterior
se observ c dndu-se o expresie regulat r i un ir de intrare x exist doua metode pentru a verifica dac
x L(r).
Se poate construi automatul finit nedeterminist (AFN) corespunztor expresiei regulate. Dac
expresia regulata r conine |r| simboli atunci aceasta construcie se face ntr-un timp proporional cu |r|.
Numrul maxim de stri pentru AFN este de maximum 2 x |r|, iar numrul de tranziii pentru fiecare stare
este 2 (conform construciei), deci memoria maxim necesar pentru tabela de tranziii este proporional
cu |r|. Algoritmul de simulare pentru AFN are un numr de operaii proporional cu |Q| x |x| deci cu |r| x |x|
(unde |x| reprezint lungimea irului x). Dac |x| nu este foarte mare soluia este acceptabil.
O alt abordare posibil este construirea automatului finit determinist (AFD) corespunztor
automatului finit nedeterminist construit pornind de la expresia regulat. Simularea AFD se face ntr-un

timp proporional cu |x| indiferent de numrul de stri ale AFD. Aceast abordare este avantajoas dac
este necesar verificarea mai multor iruri de lungime mare pentru o aceeai expresie regulat (vezi de
exemplu situaia n care un editor de texte are o funcie de cutare pentru un subir de o form general
dat). Pe de alta parte exist expresii regulate pentru care AFD-ul necesit un spaiu de memorie
exponenial n numrul de simboli i operatori din expresia regulata. S considerm de exemplu expresia :
(a|b)*a(a|b)(a|b)...(a|b)
care reprezint un ir de simboli a i b i care se termina cu (n -1) simboli (a|b). irul reprezentat de
aceasta expresie regulat este format din cel puin n simboli a i b, astfel nct exist un simbol a pe
poziia n de la sfritul irului. Se observ c un AFD pentru recunoaterea acestei expresii trebuie s
memoreze ultimele n caractere, deci sunt necesare cel puin 2n stri (pentru a codifica toate combinaiile
posibile de caractere a i b de lungime n).
O alta abordare este de a utiliza un AFD, fr a construi ntreaga tabela de tranziii. Ideea este de a
determina o tranziie numai dac este necesar. Odat calculat o tranziie aceasta este memorat ntr-o
memorie asociativ. Ori de cte ori este necesar o tranziie se face nti o cutare n memoria asociativ.
Dac nu se gsete se face calculul.
Concentrnd rezultatele se obine urmtoarea tabel :
complexitate construcie
memorie ocupat
complexitate simulare
2.3.1.7
AFN
O(|r|)
O(|r|)
O(|r| x |x|)
AFD
O(|r| x |T|)
O(c |r|)
O(|x|)
Minimizarea numrului de stri pentru AFD
Se poate demonstra c fiind dat o mulime regulata exist un unic automat finit determinist cu numr
minim de stri care accept limbajul generat de mulimea respectiv. n cele ce urmeaz considerm c
automatul finit are funcia de tranziie definit pentru ntreg domeniul Q X T. Dac exist combinaii (s,i)
Q x T pentru care m(s,i) nu este definit considerm o extindere a automatului pentru care adugm o
stare d. Pentru i T, m(d, i) = d, pentru s Q, i T pentru care m(s,i) este nedefinit n automatul
iniial vom considera c m(s, i) = d.
Construim o extensie a funciei m, m : x T* Q n modul urmtor :
1. ( s Q) (m(s, ) = s)
2. ( s Q)( w T*)(i I)(m(s, wi) = m(m(s, w), i)
Fie w T* spunem c w separ strile s, t Q dac i numai dac m(s,w) F i m(t,w) F sau
m(t,w) F i m(s,w) F.
Un automat este redus dac i numai dac pentru oricare dou stri q1, q2 F exist o secven de
intrare care s le separe. Problema construirii automatului redus echivalent unui automat dat este de fapt
problema construirii partiiilor induse de o relaie de echivalen. Iniial, considerm ca mulimea Q este
mprit n F, Q - F i {d}. Fie P = { Q - F, F, {d}}. n continuare pentru o mulime de stri A P, pentru
care |A| > 1, se parcurg simbolii de intrare. Dac pentru un simbol a i strile q1, q2 A, m(q1, a) i
m(q2, a) fac parte din elemente diferite din P nseamn c strile succesoare strilor q1 i q2 nu fac parte
din aceeai mulime a partiiei. Corespunztor Q va fi mprit n 4 mulimi, etc. Algoritmul corespunztor
este:
Descrierea algoritmului de minimizare este:

P = {F, Q - F, {d}}
repeta
P' = P
repeta
alege A P, Q ne marcat si marcheaz A
new =
daca |A| > 1
alege first A
A' = A - {first}
cat timp A' executa
alege next A'
A' = A' - {next}
se_imparte = false
T' = T
cat timp T' si nu se_imparte executa
alege a T'
T' = T' - {a}
goto_first = tranz_AFD[first,a]
goto_next = tranz_AFD[next, a]
daca goto_next si goto_first sunt n elemente
(multimi) diferite din P
new = new {next}
se_imparte = true
daca new
P = P - {A}
A = A - new
P = P {A}{new}
pana nu mai exist A P ne marcat

pana P = P'
Algoritmul utilizat nu este optim din punct de vedere al timpului de execuie. La fiecare pas mulimea
de stri Q se mparte n cel mult dou noi mulimi : new i Q \ new. Exist algoritmi pentru care numrul
de operaii este proporional cu n log n. S considerm urmtorul exemplu :

b
--\/
+---+
| |
b
b > | 2 |<---------------------+
/ +-| |
|
+---+ /a | +---+
|
start | |/ | +---+
+---+
+------+
-------| 0 | a \/| | b
| |b
|+----+|
| |---> | 1 |---->| 3 |--->|| 4 ||
+---+
| |
| |
|+----+|
+---+
+---+
+------+
/\ ||
a
|
|
-- |+-<--------+
|
a|
|
|
a
|
+--<--------------------+
Iniial P = {{0, 1, 2, 3}, {4}}, A = {0, 1, 2, 3}. Fie first = 0, next = 1, m(0, a), m(1, a) A; m(0, b),
m(1, b) A. Pentru next = 2, m(0, a) A, m(2, a) A; m(0, b) A, m(2,b) A. Continund pentru next
= 3, m(0, b) A dar m(3, b) A, deci new = {3}. S-a obinut P = {{0, 1, 2}, {3}, {4}}. Se observ c P
P'. Urmeaz A = {0, 1, 2}. Se obine m(0, b) Q dar de aceasta data m(1, b) A. Rezult P = {{0, 2},
{1}, {3}, {4}}. Pentru A = {0, 2} se obine m(0, a), m(2, a) {1}; m(0, b), m(2, b) A. Se obine
automatul finit determinist cu numr minim de stri:
b
b
---------<--------------------+
\/ /
|
+---+ /
|
start | |/
+---+
+---+
+-----+
-----> |02 | a | | b
| |b
|+---+|
| |--- | 1 |------>| 3 |--- || 4 ||
+---+
| |
| |
|+---+|
+---+
+---+
+-----+
/\ ||
a
|
|
-- |+-<--------+
|
a|
|
|
a
|
+--<--------------------+

2.3.2
Automate cu stiv (pushdown)
Un astfel de automat are o memorie organizat ca o stiv :

+--------------|a0|a1|...|an|
banda de intrare
+--------------\ cap de citire
\
+---------+
| unitate | +----+
| de
|---| z1 |
| control | |----|
+---------+ | z2 |
|----|
|... | memoria stiva
|
|
|----|
| zn |
+----+
Un automat cu stiv (PDA) este un obiect matematic P = (Q, T, Z, m, q0, z0, F) unde:
Q - este o mulime finit de simboli ce reprezint strile posibile pentru unitatea de control a
automatului;
T - este mulimea finit a simbolilor de intrare;
Z - este mulimea finit a simbolilor utilizai pentru stiv;
m - este o funcie, m : S x (T {}) x Z P(S x Z*) este funcia care descrie modul n care se obine
starea urmtoare i informaia care se introduce n stiv pentru o combinaie stare, intrare, coninut
stiv dat;
q0 Q este starea iniial a unitii de control;
z0 Z este simbolul aflat n vrful stivei n starea iniial;
F Q reprezint mulimea finit a strilor finale.
O configuraie de stare a automatului este un triplet (q, w, ) Q x T* x Z* unde :
q - reprezint starea curent a unitii de control;

w - reprezint partea din irul de intrare care nu a fost nc citit. Dac w = nseamn c s-a ajuns la
sfritul irului de intrare;
- reprezint coninutul stivei.
O tranziie a automatului este reprezentat prin relaia |- asupra mulimii configuraiilor automatului,
este definit n modul urmtor :
(q, aw, z) |- (q', w, )
unde (q', ) m(q, a, z), q Q, a T {}, w T*, z Z, Z*.
Dac a nseamn c, dac unitatea de control este n starea q, capul de citire este pe simbolul a iar
simbolul din vrful stivei este z atunci automatul poate s i schimbe configuraia n modul urmtor :
starea unitii de control devine q', capul de citire se deplaseaz cu o poziie la dreapta iar simbolul din
vrful stivei se nlocuiete cu .

Dac a = nseamn c avem o -tranziie pentru care simbolul aflat n dreptul capului de citire pe
banda de intrare nu conteaz (capul de citire nu se va deplasa), ns starea unitii de control i coninutul
memoriei se pot modifica. O astfel de tranziie poate s aib loc i dup ce s-a parcurs ntregul ir de
intrare.
Dac se ajunge ntr-o configuraie pentru care stiva este goal nu se mai pot executa tranziii. Relaia
|- se poate generaliza la |-i, |-+, |-*, ntr-o manier similar relaiei de derivare pentru forme propoziionale.
O configuraie iniial pentru un automat cu stiv este o configuraie de forma (q0, w, z0) unde w
T*. O configuraie final este o configuraie de forma (q, , ) cu q F, Z*.
Aa cum a fost definit automatul cu stiv este nedeterminist, adic pentru o configuraie dat n cazul
general pot s urmeze mai multe configuraii urmtoare.
Un automat cu stiv este determinist dac pentru orice configuraie exist cel mult o singur tranziie
urmtoare. Mai precis un automat cu stiv PD = (Q, T, Z, m, q0, z0, F) este determinist dac pentru orice
(q, a, z) x (T {}) x Z sunt ndeplinite urmtoarele condiii:
1. |m(q, a, z)| 1,
2. dac m(q, , z) atunci m(q, a, z) = pentru a T
Spunem c un ir w este acceptat de un automat cu stiv prin stri finale dac este posibil o evoluie
ca (q0, w, z0) |-* (q, , ) pentru q F i Z*. Limbajul acceptat de un automat cu stiv P n acest
mod se noteaz cu L(P). Se observ c pentru un automat cu stiv nedeterminist pentru un ir dat sunt
posibile mai mute evoluii.
S considerm de exemplu automatul cu stiv care accept limbajul L = {0n1n | n > 0}.
P = ({q0, q1 ,q2}, {0,1}, {z, 0}, m, q0, z,{q0}) unde
m(q0,0,z)
m(q1,0,0)
m(q1,1,0)
m(q2,1,0)
m(q2,,z)
=
=
=
=
=
{(q1,0z)}
{(q1,00)}
{(q2,)}
{(q2,)}
{(q0,z)}
Pentru toate celelalte elemente (s, a, z) Q x (T {}) x Z care nu sunt descrise de regulile de mai
sus, m(s, a, z) = . Se observ c automatul copiaz toate zerourile de pe banda de intrare n stiv i apoi
descarc stiva pentru fiecare simbol 1 ntlnit la intrare. De exemplu pentru irul 0011, automatul va
executa urmtoarea secven de tranziii :
(q0,0011,z)
||||-
(q1,011,0z)
(q1,11,00z)
(q2,1,0z)
(q2,,z)
|- (q0,,z)
Pentru irul de intrare 011 care nu aparine limbajului evoluia va fi :

(q0,011,z)
||||-
(q1,11,0z)
(q2,1,z)
(q2,1,z)
(q0,1,z)

Se observ c dei s-a ajuns ntr-o stare final nu s-a ajuns la sfritul irului de intrare deci irul nu a
fost acceptat. Pentru irul de intrare 001, evoluia este :
(q0,001,z)
|- (q1,01,0z)
|- (q1,1,00z)
|- (q2,,0z)
n acest caz s-a ajuns la sfritul irului dar starea n care se gsete automatul nu este final deci nici
acest ir nu este acceptat.
Pentru a demonstra c L(P) = {0n1n} trebuie s artm c {0n1n} L(P) i L(P) {0n1n}. Se pot face
urmtoarele observaii :
(q0,0,z) |- (q1,,0z)
(q1,0i,0z) |-i (q1,,0i+1z)
(q1,1,0i+1z) |- (q2,,0iz)
(q2,1i,0iz) |-i (q2,,z)
(q2,,z) |- (q0,,z)
Rezult c pentru irul 0n1n, n > 1 se obine :

(q0,0n1n,z) |-2n+1 (q0, , z), n > 1
(q0,,z) |-0(q0,,z)
Deci {0n1n} L(P). Trebuie s artm c i L(P) {0n1n} . Se observ c pentru a accepta un ir din
{0 1 } pentru care n > 0, P trece n mod obligatoriu prin succesiunea de stri q0, q1, q2, q0.
n n
Dac (q0, w, z) |-i (q1, , ), i > 1 nseamn ca w = 0i i = 0iz.

Dac (q2, w, ) |-i (q2, , ) nseamn c w = 1i i a = 0i.
Dac (q1, w, ) |- (q2, , ) nseamn c w = 1 i a = 0
Dac (q2, w ,z) |-* (q0, , z) nseamn c w = .
Deci dac (q0, w, z) |-i (q0, , z) atunci fie w = i i = 0 fie w = 0n1n, i = 2 n + 1. Deci L(P) {0n1n} .
S considerm i automatul care accept limbajul L = {wcwR| w {a,b}+}, P = ({q0, q1, q2}, {a, b},
{z, a, b}, m,q0, z, {q2}) unde :
m(q0,x,y)
m(q0,c,x)
m(q1,x,x)
m(q1,,z)
=
=
=
=
{(q0,xy)}, x {a, b}, y {z, a, b}

{(q1,x)}, x {z, a, b}
{(q1,)}, x {a, b}
{(q2,)}
Funcionarea automatului parcurge trei etape. nti se copiaz n stiv irul w, apoi se identific
simbolul c care marcheaz mijlocul irului, dup care se descarc stiva conform wR.
S considerm i automatul care accept limbajul L = {wwR| w {a,b}+}, P = ({q0, q1, q2}, {a, b},
{z, a, b}, m,q0, z, {q2}) unde :

m(q0,x,z)
m(q0,x,x)
m(q0,a,b)
m(q0,b,a)
m(q1,x,x)
m(q1,b,b)
=
=
=
=
=
=
{(q0,xz)}, x {a, b}
{(q0,xx),(q1,)}, x {a, b}
{(q0,ab)}
{(q0,ba)}
{(q1,)}, x {a, b}
{(q1,)}
De data aceasta nu se tie unde se gsete mijlocul irului, astfel nct ori de cte ori simbolul din
vrful stivei este acelai cu cel de la intrare s-ar putea s se fi gsit mijlocul irului. Se observ c cel de al
doilea automat nu este determinist i c nici nu se poate construi un automat determinist care s accepte
limbajul L = {wwR| w {a,b}+}.
S considerm de exemplu secvena de micri pentru irul abba.
(q0,abba,z)
||||-
(q0,bba,az)
(q0,ba,baz)
(q0,a,bbaz)
(q0,,abbaz)
Se observ c pentru aceast secven de tranziii nu se ajunge ntr-o stare final. Automatul fiind
nedeterminist trebuie s cercetm ns toate secvenele de tranziii posibile. O alt secven este:
(q0,abba,z)
|||||-
(q0,bba,az)
(q0,ba,baz)
(q1,a,az)
(q1,,z)
(q2,,)
Rezult ca automatul ajunge n starea q2 deci accept irul abba.

2.3.2.1
Automate cu stiv cu acceptare prin stiv goal
Fie P = (Q, T, Z, m, q0, z0, F) un automat cu stiv. Spunem c un ir w T* este acceptat de P prin
stiva goal dac exist o evoluie pentru care (q0, w, z0) |-+ (q, , ) pentru q Q.
Fie Le(P) mulimea irurilor acceptate de P prin stiva goal. Se poate demonstra urmtorul rezultat.
Dac L(P) este limbajul acceptat de automatul P prin stri finale atunci se poate construi un automat cu
stiv P' astfel nct L(P) = Le(P').
Automatul P' va simula funcionarea automatului P. Ori de cte ori P intr ntr-o stare final, P' poate
continua simularea sau intr ntr-o stare speciala qe n care golete stiva (qe Q). Se poate ns observa c
P poate s execute o secven de micri pentru un ir de intrare w care s permit golirea stivei fr ca
irul s fie acceptat de ctre automatul P (pentru P nu conteaz dect ajungerea ntr-o stare final). Pentru
a evita astfel de situaii se consider un simbol special pentru iniializarea stivei, simbol care nu poate s
fie scos din stiva dect n starea qe. Fie P' = (Q {qe, q'}, T, Z {z'}, m', q', z', ) unde funcia m' este
definit n modul urmtor :
1. dac (r, t) m(q, a, z) atunci (r, t) m'(q, a, z), pentru r, q Q, t Z*, a T {}, z Z.
2. m'(q', , z') = {(q0, z0z')}. P' i iniializeaz stiva cu z0z' (z' reprezint simbolul de iniializare al
stivei pentru P').
3. pentru q F i z Z, (qe, ) m'(q, , z);
4. pentru z Z {z'}, m'(qe, , z) = {(qe, )}

Se observ c :
(q',w,z') |- (q0,w,z0z') |-n (q, , y1 y2 ... yr)
|- (qe, , y2 ... yr)
|-r-1 (qe, , )
cu yr = z' dac i numai dac (q0, w, z0) |-n (q, , y1 y2 ... yr-1) pentru q F i y1 y2 ... yr-1 Z*. Deci
Le(P') = L(P).
Se poate demonstra i rezultatul invers, adic dndu-se un automat cu stiv i limbajul acceptat de
acesta prin stiva goal se poate construi un automat cu stiv care accept acelai limbaj prin stri finale.
2.3.2.2
Relaia ntre automate cu stiv i limbajele independente de context
Limbajele acceptate de automatele cu stiv sunt limbajele care pot s fie descrise de gramatici
independente de context. Dndu-se o gramatic independent de context s construim automatul care
accept limbajul generat de aceasta gramatica. Fie G = (N, T, P, S), se obine automatul cu stiv R = ({q},
T, N T, m, q, S, ) unde m este construit conform urmtoarelor reguli :
1. dac A P atunci (q, ) m(q, , A)
2. m(q, a, a) = {(q, )} pentru orice a T.
Se observ c automatul astfel construit va accepta limbajul prin stiv goal. Se poate arata c A k
w dac i numai dac (q,w,A) |-n (q, , ) k, n > 1. Altfel spus exist o derivare S + w dac i numai dac
(q, w, S) |-+ (q, , ). Rezult deci c L(G) = L(R). S construim de exemplu automatul care accept
limbajul expresiilor aritmetice G = ({, T, F}, {a, +, (, )}, P, ) unde P = { + T | T, T T * F | F, F
() | a}. Aplicnd construcia propus rezult R = ({q}, {a, +, *, (, )},{, T, F, a, +, *, (, )}, m, q, , )
unde m este definit n modul urmtor :
m(q,
m(q,
m(q,
m(q,
,
,
,
b,
)
T)
F)
b)
=
=
=
=
{(q,
{(q,
{(q,
{(q,
+ T),(q, T)}
T * F),(q, F)}
()),(q, a)}
)} cu b {a,+,*,(,)}.
S considerm de exemplu o succesiune de configuraii pentru a + a * a.

(q, a + a * a, )
|||||||||||||-
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
a + a * a,
a + a * a,
a + a * a,
a + a * a,
+ a * a, +
a * a, T)
a * a, T *
a * a, F *
a * a, a *
* a, * F)
a, F)
a, a)
, ).
+
T+
F+
a+
T)
T)
T)
T)
T)
F)
F)
F)
n reprezentarea tranziiilor vrful stivei a fost reprezentat n stnga. Se observ c secvena de tranziii
considerat, simuleaz urmtoarea secven de derivri de forme propoziionale :

+TT+TF+Ta+Ta+T*F a+F*Fa+a*Fa+a*a
Se observ ca n aceasta secven s-a nlocuit ntotdeauna cel mai din stnga neterminal. Din acest
motiv se spune c am utilizat o derivare stnga. Secvena de derivri anterioare poate s fie reprezentat de
urmtorul arbore de derivare.
/|\
/|\
+ T
|
/|\
| /|\
T T * F
| |
|
| |
|
F F
a
| |
a a
Acest gen de construire de secvene de derivare i deci automatele cu stiv care accept limbaje prin
stiv goal sunt utilizate n analiza sintactic descendent.
Un tip special de automat cu stiv l reprezint automatul cu stiv extins = (Q, T, Z, m, q0, z0, F)
pentru care m : Q x (T {}) x Z* P(Q x Z*). Se observ c n acest caz din stiv se consider nu
numai simbolul din vrful stivei ci un ir de simboli plasat n vrful stivei. Considerm pentru acest tip de
automat c acceptarea se face prin stri finale ( i n acest caz se poate construi un automat echivalent care
s fac acceptarea prin stiv goal). S considerm de exemplu automatul care accept limbajul L = {wwR
| w {a,b}*}. Fie P = ({q, p}, {a, b}, {a,b,S,z}, m, q, z, {p}) unde funcia m este definit n modul
urmtor:
m(q,a,) = {(q,a)}
m(q,b,) = {(q,b)}
m(q,,) = {(q,S)}
m(q,,aSa) = {(q,S)}
m(q,,bSb) = {(q,S)}
m(q,,Sz) = {(p,)}
De exemplu pentru secvena de intrare aabbaa este posibil urmtoarea secven de tranziii :
(q, aabbaa, z)
|||||||||||-
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(q,
(p,
abbaa, az)
bbaa, aaz)
baa, baaz)
baa, Sbaaz)
aa, bSbaaz)
aa, Saaz)
a, aSaaz)
a, Saz)
, aSaz)
, Sz)
, )
Se observ ca datorit tranziiei m(q, , ) = {(q, S)} automatul este nedeterminist.

Se poate demonstra c pentru orice automat cu stiv extins , exist un automat cu stiv P astfel nct
L() = L(P).
S revenim la problema acceptrii limbajelor independente de context de ctre automate cu stiv i s
considerm din nou exemplul expresiilor aritmetice. Pentru generarea irului a + a * a putem s
considerm i urmtoarea secven de derivri :
+T+T*F+T*a+F*a +a*aT+a*a
F+a*aa+a*a
Se observ ca n aceast secven s-a nlocuit ntotdeauna cel mai din dreapta neterminal. Din acest
motiv se spune ca s-a construit o derivare dreapta. Considernd acest tip de derivri i parcurgndu-le n
ordine invers (de la sfrit) se poate introduce noiunea de reducere stnga. Fie gramatica G = (N,T,P,S) o
gramatic independent de context s presupunem c S * aAw aw * xw. Dac n fiecare derivare a
fost nlocuit de fiecare dat neterminalul cel mai din dreapta atunci se spune c aw se reduce stnga la
aAw dac A P. Dac este cel mai din stnga astfel de ir atunci spunem ca este nceputul irului
aw. Un nceput (handle) pentru o derivare dreapta este orice ir care este partea dreapta a unei producii
i poate s fie nlocuit de neterminalul corespunztor ntr-o form propoziional care a aprut dintr-o
derivare dreapta obinndu-se forma propoziional anterioar din derivarea dreapta.
S considerm de exemplu gramatica: G = ({S, A, B},{a, b, c, d}, {S Ac | Bd, A aAb | ab, B
aBbb | abb}, S). Aceast gramatic genereaz limbajul {anbnc | n > 1} {anb2nd | n > 1}. S considerm
urmtoarea secven de derivri S Bd aBbbd aabbbbd. Pentru irul obinut abb este nceput
deoarece aBbbd este forma propoziional anterioar din derivarea dreapta, n timp ce ab nu este deoarece
aAbbbd nu este o forma propoziional care poate s apar ntr-o derivare dreapta.
Relund din nou gramatica pentru expresii aritmetice i secvena de derivri dreapta :
+T+T*F+T*a+F*a +a*aT+a*a
F+a*aa+a*a
Rezult arborele de derivare :
|
|
T
|
|
F
|
|
a
/| \
/ | \
+ T
/| \
/| \
T * F
|
|
|
|
F
a
|
|
a
Dac analizm acest arbore se vede c a (care reprezint frunza celui mai din stnga subarbore) este
un nceput, dac se face o reducere se obine arborele :

/|\
/|\
+ T
|
/|\
| /|\
T T * F
| |
|
| |
|
F F
a
|
|
a
Continund se ajunge la :
/|\
/|\
+ T
/|\
/|\
T * F
|
|
F
a
|
a
Urmtorul nceput este a, etc.

Se observ c pentru a identifica un nceput pentru o form propoziional obinut printr-o derivare
dreapta se consider secvena frunzelor celui mai din stnga subarbore de adncime 1 (toate nodurile
acestuia sunt fie frunze fie noduri din care se deriveaz frunze). De exemplu :
|
|
|
a sau F sau T sau
T
/|\
/ | \
T * F
pentru care a, F, T respectiv T * F reprezint pri dreapta ale unor producii. Aceasta metoda de
reducere a arborilor de derivare se numete reducerea capetelor ("handle pruning").
Dndu-se o gramatic independent de context G = (N, T, P, S) se poate construi un automat cu stiv
extins care s opereze conform metodei reducerii capetelor n modul urmtor :
R = ({q, r},T,N T {$}, m, q, $, {r}) unde:
1. dac A P atunci (q, A) m(q, , )
2. m(q, a, ) = {(q, a)} pentru orice a T. Se observ c terminalele sunt copiate n stiva;
3. m(q, , $S) = {(r, )}.
S construim utiliznd aceast tehnic automatul cu stiv extins care accept limbajul expresiilor
aritmetice :
R = ({q, r},{a, +, *, (, )},{a, +, *, (, ), T, F, , $}, m, q, $,{r}) unde

m(q,
m(q,
m(q,
m(q,
m(q,
m(q,
m(q,
m(q,
b,
,
,
,
,
,
,
,
) = {(q, b)}, pentru b {a, +, *, (, )}

+ T) = {(q, )}
T) = {(q, )}
T * F) = {(q, T)}
F) = {(q, T)}
()) = {(q, F)}
a) = {(q, F)}
$) = {(r, )}
Fiind vorba de o derivare dreapta, vrful stivei a fost figurat n dreapta. Se observ c aceast secven
de tranziii este unica secven ce duce la acceptarea irului de intrare. Pentru irul a + a * a, automatul R
va executa urmtoarele tranziii :
(q, a + a * a, $) |- (q, + a * a, $a)
|- (q, + a * a, $F)
|- (q, + a * a, $T)
|- (q, + a * a, $)
|- (q, a * a, $ +)
|- (q, * a, $ + a)
|- (q, * a, $ + F)
|- (q, * a, $ + T)
|- (q, a, $ + T *)
|- (q, , $ + T * a)
|- (q, , $ + T * F)
|- (q, , $ + T)
|- (q, , $)
|- (q, , ?)
Automatele cu stiv construite dup modelul prezentat anterior vor fi utilizate n analiza sintactic de
tip ascendent.
Avnd n vedere echivalena dintre un automat cu stiv i limbajele independente de context, vom
spune c un limbaj independent de context este determinist dac este acceptat de un automat cu stiv
determinist. Vom modifica puin condiia de acceptare, considernd c un limbaj independent de context
este determinist dac exist un automat cu stiv determinist care accept limbajul L$. Simbolul $ este un
simbol care nu apare n alfabetul peste care este definit limbajul L. Se observ c utilizarea acestui simbol
care apare concatenat cu fiecare ir din L indic de fapt posibilitatea automatului cu stiv de a recunoate
sfritul irului. n acest mod se extinde puin clasa limbajelor independente de context deterministe.
Se pune ntrebarea dac orice limbaj independent de context este determinist. S considerm de
exemplu limbajul :
L = {wwR | w {a, b, c}
Dup cum s-a mai discutat un automat cu stiv care accept acest limbaj trebuie s ghiceasc unde este
mijlocul irului pentru ca s nceap descrcarea stivei. Intuitiv, o astfel de operaie nu se poate realiza cu
un dispozitiv determinist.
Propoziie. Exist limbaje independente de context care sunt acceptate de automate cu stiv
nedeterministe i nu sunt acceptate de automate cu stiv deterministe.
2.3.3
Maina Turing

O main Turing este un acceptor care "tie" s scrie pe banda de intrare. n acest mod banda de
intrare devine memorie auxiliar. Maina Turing a fost definit de ctre matematicianul englez Alan
Turing (1912 - 1954) n anul 1930. Cnd a inventat maina care i poart numele, Turing era interesat nu
de calculatoare ci de posibilitatea specificri i rezolvri problemelor matematice utiliznd mijloace
automate. Adic, poate s fie rezolvat orice problema matematic utiliznd nite reguli elementare de
prelucrare a irurilor ?.
Structura unei maini Turing este:
+---------------------------|
+----------------------------
banda de intrare
| cap de citire / scriere

|
+---------+
| unitate |
| de
|
| control |
+---------+
Unitatea de control comand execuia micrilor. O micare este format din :
stabilirea strii urmtoare pentru unitatea de control;

scrierea unui simbol pe banda de intrare sau execuia unei deplasri cu o poziie spre stnga sau spre
dreapta.
Banda de intrare este mrginit la stnga i infinit la dreapta. Dup poziia ocupat de irul de intrare
pe banda aceasta conine blancuri. n cele ce urmeaz vom indica simbolul blanc cu ajutorul caracterului #
(presupunnd c acest simbol nu face parte din alfabetul limbajului pentru care se construiete maina). De
asemenea vom utiliza caracterele L i respectiv R pentru a indica o deplasare la stnga respectiv la
dreapta. Maina Turing poate s scrie pe banda de intrare, deci poate s scrie att informaii intermediare
ct i un rspuns nainte de a se oprii. Maina Turing are o stare special numit stare de oprire (de halt)
pe care o vom nota n continuare cu h. S considerm o definiie formal a noiunii de main Turing.
Se numete main Turing obiectul matematic :
MT = (Q, T, m, q0)
unde
Q este o mulime finit a strilor mainii Turing, h Q;

T este alfabetul finit de intrare care conine simbolul # dar nu conine simbolii L i R;
m este funcia de tranziie
m : Q x T (Q {h}) x (T {L, R}).
q0 Q este starea iniial a mainii Turing;
Dac q Q, a T i m(q, a) = (p, b) nseamn c fiind n starea q, avnd simbolul a sub capul de
citire maina trece n starea p. Dac b T atunci simbolul a va fi nlocuit cu b, altfel capul se va deplasa
cu o poziie la stnga sau la dreapta n funcie de valoarea simbolului b {L, R}. Se observ c maina
Turing a fost definit ca un acceptor determinist.

ncetarea funcionrii mainii Turing se face dac se ajunge n starea h (cnd maina se oprete) sau
dac se ncearc deplasarea la stnga dincolo de captul din stnga al benzii. n acest ultim caz se spune ca
maina s-a agat (a ajuns ntr-o stare de agare - hanging state).
Definiia anterioar corespunde mainii Turing standard. Fa de aceast definiie exist diferite
variante, care permit ca n aceeai micare s se fac i o scriere i o deplasare sau care consider c banda
este infinit la ambele capete. Se va arta c toate aceste variante conduc la acceptoare echivalente ca
putere.
S considerm un exemplu de main Turing MT = ({q0, q1}, {a, #}, m, q0), unde:
m(q0,
m(q0,
m(q1,
m(q1,
a)
#)
a)
#)
=
=
=
=
(q1, #)
(h, #)
(q0, a)
(q0, R)
S considerm c pe banda de intrare se gsete irul aaa i c poziia capului este pe primul caracter
din ir. Se observ c pentru aceast stare iniial, primul simbol a este nlocuit cu #, noua stare fiind q1.
Pentru q1, dac sub capul de citire se gsete un caracter # atunci se va face o deplasare la dreapta starea
devenind q0. Se continu evoluia ntr-o manier similar pn cnd n starea q0 capul de citire se gsete
pe un caracter #. n acest moment se trece n starea h i maina se oprete. Rezult ca evoluia mainii
duce la tergerea unui ir de a-uri nscris pe banda de intrare.
S considerm i urmtorul exemplu MT = ({q0}, {a, #}, m, q0), unde
m(q0, a) = (q0, L)
m(q0, #) = (h, #)
n acest caz maina caut primul simbol # la stnga poziiei din care pleac capul de citire / scriere. La
gsirea acestui simbol se trece n starea h. Dac nu exist un astfel de simbol maina nceteaz s
funcioneze cnd ajunge la captul din stnga al benzii, dar nu se oprete (este n stare de agare).
O configuraie pentru o main Turing este un element din mulimea :
(Q {h}) x T* x T x (T* (T - {#}) {})
Elementele unei configuraii sunt:
starea curent q (Q {h})
irul aflat pe banda de intrare la stnga capului de citire / scriere (a T*)
simbolul aflat sub capul de citire / scriere ( i T)
irul aflat la dreapta capului de citire / scriere ( (T* (T - {#}) {})).
Se observ c, deoarece irul de intrare este finit, n timp ce banda de intrare este infinit la dreapta
putem s considerm ntotdeauna c irul se termin cu un caracter care nu este # (oricum n continuare pe
band apar numai caractere #). Deci o configuraie este de forma (q, a, i, ). Pentru simplificare, o
configuraie se poate reprezenta i sub forma (q, ai), subliniind simbolul pe care se gsete capul de citire
/ scriere.
Asupra configuraiilor se poate defini o relaie de tranziie |- n modul urmtor. Fie (q1, w1, a1, u1) i
(q2, w2, a2, u2) dou configuraii. Atunci:
(q1,w1,a1,u1) |- (q2,w2,a2,u2)
# w1 a1 u1#
# w2 a2 u2#
# w1a1 u1 #
# w2 a2 u2 #
# w1 a1 u1 #
# w2 a2 u2 #

dac i numai dac exist b T {L, R} astfel nct m(q1, a1) = (q2, b) i este ndeplinit una dintre
urmtoarele condiii:
1. b T, w1 = w2, u1 = u2, a2 = b;
2. b = L, w1 = w2a2
dac a1 # sau u1
u2 = a1 u1
altfel u2 =
// capul de citire / scriere este poziionat dup irul de intrare
3. b = R, w2 = w1a1
dac u1 =
u2 =
a2 = #
altfel u1 = a2 u2
n cazul 1 se face nlocuirea simbolului curent de pe banda de intrare (a) cu b. n al doilea caz este
descris o micare la stnga, respectiv n cazul 3 se descrie o micare la dreapta.
Dac b = L i w1 = atunci (q1, w1, a1, u1) nu are o configuraie urmtoare, n acest caz se spune c
(q1, w1, a1, u1) este o configuraie de agare, maina fiind ntr-o stare de agare (hanging state).
Pentru relaia |- se poate considera nchiderea reflexiv i tranzitiv notat cu |-*.
2.3.3.1
Calcule realizate de Maina Turing
Un calcul efectuat de o maina Turing este o secven de configuraii c0, c1, ..., cn astfel nct n 0 i
c0 |- c1 |- ... |- cn. Se spune despre calcul c are loc n n pai.
Termenul de calcul nu a fost utilizat ntmpltor. Se poate considera c o main Turing tie s
evalueze funcii definite pe iruri de simboli cu valori n iruri de simboli. Dac T1 i T2 sunt doua
mulimi alfabet care nu conin simbolul #, s considerm funcia f : T1* T2*. Spunem ca MT = (Q, T,
m, s) calculeaz f dac T1, T2 T i pentru orice ir w T1* dac u = f(w), u T2*, atunci (s, #w#) |-*
(h, #u#). Se observ c s-a considerat c capul este poziionat dup sfritul irului de intrare att la
nceputul execuiei ct i la sfritul acesteia.
Dac pentru o funcie f dat exist o maina Turing care o calculeaz spunem c funcia f este Turing
calculabil.
S considerm de exemplu maina Turing MT = ({q0, q1, q2}, {a, b, #}, m ,q0) unde funcia m este
definit n modul urmtor:
m(q0, a) = (q1, L)
m(q0, b) = (q1, L)
m(q0, #) = (q1, L)
m(q1, a) = (q0, b)
m(q1, b) = (q0, a)
m(q1, #) = (q2, R)
m(q2, a) = (q2, R)
m(q2, b) = (q2, R)
m(q2, #) = (h, #)
S considerm evoluia pentru irul de intrare aab.

(q0, #aab#)
||||||||||||-
(q1, #aab#)
(q0, #aaa#)
(q1, #aaa#)
(q0, #aba#)
(q1, #aba#)
(q0, #bba#)
(q1, #bba#)
(q2, #bba#)
(q2, #bba#)
(q2, #bba#)
(q2, #bba#)
(h, #bba#)
Pentru irul vid evoluia este :

(q0, ##) |- (q1, ##) |- (q2, ##) |- (h, ##)
Funcia calculat de aceast main Turing este funcia de interschimbare a caracterelor a i b.

Din domeniul irurilor putem s trecem n domeniul numerelor naturale considernd reprezentarea
unar a numerelor naturale. Adic utiliznd un alfabet I care conine un singur simbol, I diferit de #,
reprezentarea unui numr natural n este data de irul = In. Se observ c numrul 0 este reprezentat de
irul vid. n acest caz o funcie f : N N este calculat de o main Turing, dac aceasta calculeaz f' : I*
I* unde f'() = cu In i If(n) pentru orice numr natural.
De la un singur argument funcia f se poate extinde la mai multe argumente - f : Nk N pentru care
corespunde f' : (I {,})* I* cu f'() = pentru un ir de forma i1, i2, ..., ik ,... ij Inj, 1 j k, i
If(n1,...,nk).
S considerm de exemplu funcia succesor f(n) = n + 1, n numr natural. MT = ({q0}, {i, #}, m, q0)
cu
m(q0, I) = (h, R)
m(q0, #) = (q0, I)
De exemplu (q0, #II#) |- (q0, #III#) |- (h, #III#). n general :

(q0, #In#) |- (q0, #InI#) |- (h, #In+1#)
O main Turing poate s fie utilizat i ca acceptor de limbaj. i anume s considerm un limbaj L
definit asupra alfabetului T care nu conine simbolii #, D i N. Fie dL : T* {D, N} o funcie definit n
modul urmtor - pentru w T*
D dac w L
/
dL(w) =
\
N dac w L
Se spune ca limbajul L este decidabil n sens Turing (Turing decidable) dac i numai dac funcia dL
este calculabil Turing. Dac dL este calculat de o maina Turing MT spunem ca MT decide L.
S considerm de exemplu limbajul L = {w T* | |w| mod 2 = 0, T = {a}} (limbajul irurilor peste
alfabetul T = {a} care au lungimea un numr par). Funcia dL corespunztoare poate s fie calculat de
urmtoarea main Turing :

MT = ({q0, q1, q2, q3, q4, q5, q6}, {a, D, N, #}, m , q0)
unde m este o funcie parial definit n modul urmtor :
m(q0,
m(q1,
m(q1,
m(q2,
m(q3,
m(q3,
m(q4,
m(q5,
m(q5,
m(q6,
#)
a)
#)
#)
a)
#)
#)
D)
N)
#)
=
=
=
=
=
=
=
=
=
=
(q1, L) pornim spre stnga

(q2, #) se terge un a
(q4, R) s-au ters un numr par de a
(q3, L) s-a ters un a se continu spre stnga
(q0, #) s-au ters doi de a, suntem ca la nceput
(q6, R) s-a ajuns la stnga cu un numr imapar de a
(q5, D) s-au ters zero sau un numr par de a
(h, R) rspuns D i oprire
(h, R) rspuns N i oprire
(q5, N) au fost un numr impar de a
S considerm evoluia mainii pentru un ir corect :

(q0, #aa#) |- (q1, #aa#) |- (q2, #a#) |- (q3, #a#)
|- (q0, ##) |- (q1, ##) |- (q4, ##)
|- (q5, #D#) |- (h, #D#)
Pentru un ir incorect se obine :

(q0, #aaa#)|- (q1, #aaa#) |- (q2, #aa#) |- (q3, #aa#)
|- (q0, #a#) |- (q1, #a#) |- (q2, ##)
|- (q3, ##) |- (q6, ##) |- (q5, #N#)
|- (h, #N#)
Noiunea de acceptare este mai larg dect noiunea de decidabilitate n legatura cu limbajele. i
anume dac L este un limbaj asupra alfabetului T, spunem ca limbajul L este Turing acceptabil dac exist
o maina Turing care se oprete dac i numai dac w L.
Limbajele Turing decidabile sunt i Turing acceptabile. Reciproca nu este ns adevarat.
Fie limbajul :
L = {w {a, b}* | w conine cel puin un simbol a}
considernd maina Turing MT = ({q0}, {a, b, #}, m, q0) cu
m(q0, a) = (h, a)
m(q0, b) = (q0, L)
m(q0, #) = (q0, L)
Se poate constata ca dac pe banda de intrare se gsete un ir din limbaj atunci pornind din
configuraia iniial se va face cutarea unui simbol a prin deplasare spre stnga. Dac un astfel de caracter
este gsit maina se oprete (deci accept irul). Dac ns pe banda de intrare se gsete un ir care nu
aparine limbajului atunci maina va intra n starea de agare dup ce a ajuns la captul din stnga al
benzii.

2.3.3.2
Compunerea mainilor Turing
Pentru a evidenia "puterea" de calcul a mainilor Turing vom prezenta mecanismul prin care o
main Turing se poate construi pe baza unor maini Turing mai simple.
Propoziie Fie MT o maina Turing i fie (qi, wiaiui), (i = 1, 2, 3) configuraii ale acestei maini. Dac
sunt posibile evoluiile :
(q1, w1a1u1) |-* (q2, ww2a2u2) i
(q2, w2a2u2) |-* (q3, w3a3u3)
atunci este posibila i evoluia :
(q1, w1a1u1) |-* (q3, ww3a3u3)
Justificare. n evoluia din (q2, ww2a2u2) n (q3, w3a3u3) maina nu poate s ajung pe banda de intrare
pe un simbol aflat la stnga irului w2 (ntr-o astfel de situaie s-ar ajunge la marginea din stnga a benzii,
deci s-ar intra n starea de agare i deci nu s-ar mai ajunge n configuraia urmtoare). Deoarece maina
are o funcionare determinist va rezult aceeai evoluie i dac irul w2a2u2 nu este la nceputul benzii de
intrare. Rezult c este posibil i evoluia (q2, ww2a2u2) |-* (q3, ww3a3u3).
Pe baza propoziiei anterioare putem s realizm compunerea mainilor Turing ntr-o manier similar
utilizrii subprogramelor. S considerm de exemplu o maina Turing M1 care "tie" s funcioneze
primind un ir pe banda de intrare pornind cu capul de citire / scriere poziionat dup ir. S presupunem
c M1 nu poate s ntre ntr-o stare de agare. La oprire, capul va fi plasat de asemenea dup irul care a
rezultat pe banda de intrare. Dac M1 este utilizat n cadrul unei alte maini Turing care printre alte aciuni
pregtete i un ir de intrare pentru M1, atunci dup ce M1 primete controlul nu va depi limita stnga
a irului su de intrare, deci nu va modifica un ir care eventual a fost memorat nainte pe banda de intrare.
n cele ce urmeaz considerm ca mainile Turing care se combin nu pot s ntre n starea de agare
i c fiecare are strile sale proprii diferite de strile tuturor celorlalte maini Turing. Ca maini de baza
pornind de la care vom construi noi maini Turing vom considera cteva cu funcionare elementar.
Aceste maini au un un alfabet de intrare T comun.
1. exist |T| maini care scriu fiecare cte un simbol din T n poziia curent a capului. O astfel de main
este definit ca fiind Wa = ({q}, T, m, q), a T, m(q, b) = (h, a), b T. Pentru a simplifica notaiile
Wa va fi reprezentat de simbolul a.
1. exist dou maini care execut deplasri elementare. i anume VL = ({q}, T, m, q) cu m(q, a) = (h,
L) i VR = ({q}, T, m, q) cu m(q, a) = (h, R), a T. Vom nota aceste maini cu L i respectiv R.
Reprezentarea compunerii mainilor Turing se face ntr-o manier asemntoare unei structuri de
automat finit pentru care o stare este reprezentat de o maina Turing. Intrarea ntr-o stare a automatului
corespunde cu iniierea funcionrii unei maini Turing. La oprirea unei maini Turing (intrarea acesteia n
starea h) n funcie de simbolul aflat sub capul de citire se va trece ntr-o alt stare, adic se va iniia
funcionarea unei alte maini Turing.
O schem de main Turing este tripletul = (M, , M0) unde
M este o mulime finit de maini Turing care au toate un alfabet comun T i mulimi de stri
distincte;
M0 M este maina iniial;
este o funcie parial , : M x T M.

O schem de main Turing reprezint o maina Turing compus din mainile care formeaz
mulimea M. Funcionarea acesteia ncepe cu funcionarea mainii M0. Dac M0 se oprete atunci poate
continua eventual funcionarea conform altei maini din M. Dac M0 se oprete cu capul de citire / scriere
pe caracterul a atunci exist urmtoarele situaii :
(M0, a) este nedefinit, n acest caz se oprete;

(M0, a) = M', n acest caz funcionarea continu cu starea iniial a mainii M'.
Acelai mod de nlnuire va avea loc i la oprirea (dac intervine) mainii M'. n mod formal acest
gen de compunere de maini Turing poate s fie descris n modul urmtor. Fie M = {M0, .., Mk}, k 0
astfel nct Mi = (Qi, T, mi, si), 0 i k. Fie q0, ..., qk stri care nu apar n mulimile Qi, 0 i k. Dac
(M, , M0) este o schem de main Turing , ea va reprezenta maina MT = (Q, T, m, s) unde
Q = Q0 ... Qk {q0, ..., qk}

s = s0
m este definit n modul urmtor:
a. dac q Qi, 0 i k, a T i mi(q,a) = (p, b), p h atunci m(q, a) = mi(q, a) = (p, b);
b. dac q Qi, 0 i k, a T i mi(q, a) = (h, b) atunci m(q, a) = (qi, b);
c. dac (Mi, a) (0 i k, a T) este nedefinit atunci m(qi, a) = (h,a);
d. dac (Mi, a) = Mj (0 i k, a T) i mj(sj, a) = (p, b) atunci
(p,b) p h
/
m(qi, a) =
\
(qj, b) p = h
Se observ c strile noi q0, ..., qk au fost introduse ca puncte de trecere de la o main la alta. Din
definiie rezult c fiecare main funcioneaz "normal" pn cnd se oprete. Dac o main se oprete i
este definit maina urmtoare se va trece n starea care face legatura cu maina urmtoare. Dac nu este
definit maina urmtoare, MT se va opri. Dintr-o stare de legatur se intra n funcionarea mainii
urmtoare pe baza simbolului curent de pe banda de intrare.
S considerm de exemplu mulimea M = {M0} cu M0 = R = ({q}, T, m, q). Definim funcia n
modul urmtor :
(M0, a) = M0 dac a #
(M0, #) este nedefinit
n acest caz (M, , M0) reprezint o main notat cu R#, R# = ({q, q0}, T, m, q) unde
m(q, a) = (q0, R), a T
m(q0, a) = (q0, R), a #
m(q0, #) = (h, a)
Se observ c maina se deplaseaz la dreapta pn la primul simbol #. Dac T = {a, b. c} putem s

reprezentm maina R# sub forma:

a
---\ / /|
\/ / |
>R< | b
/\ \ |
/ \ \|
---c
n cele ce urmeaz vom reprezenta grafic compunerea mainilor Turing utiliznd o serie de reguli :
fiecare main Mi M apare o singur dat;

maina iniial (M0) este indicat prin semnul >;
dac a T i (Mi, a) este definit i de exemplu M' = (Mi,a) atunci va exist un arc de la Mi la
M' etichetat cu a.
Se poate ntmpla ca n M s apar mai multe copii ale aceleiai maini (fiecare cu strile ei proprii
diferite de strile celorlalte). n acest caz fiecare dintre exemplare reprezint o alt main Turing deci
va fi desenat separat.
n reprezentrile grafice urmtoare vom utiliza o serie de simplificri. De exemplu schema :
a
---------/
b
\
> R ----------> R
\
c
/
| ---------- |
\
#
/
------------
peste alfabetul T = {a, b, c, #}

poate s fie reprezentata
a,b,c,#
> R --------- R sau > R -- R sau RR sau R2
indicnd faptul c se fac dou deplasri la dreapta indiferent de coninutul benzii de intrare.
Dac a T, a reprezint orice simbol din T diferit de a. Deci maina care caut simbolul # la
dreapta poate s fie reprezentat ca :
/|
/|
>R< |
\|
\|
Urmtoarea schem:
a # sau
/|
/|
> R < | #
\|
\|

/|
/|
>R< | #
| \|
| \|
|
|a #
La
caut mergnd la dreapta un simbol diferit de #, cnd l gsete l copiaz la stnga poziiei pe care la gsit. Se observ c din notaia a # rezult c simbolul gsit, i care este diferit de #, este notat
generic cu a i poate s fie utilizat n continuare.
n cele ce urmeaz utilizm urmtoarele notaii :
R#, este maina care caut primul simbol # la dreapta

L#, este maina care caut primul simbol # la stnga
R#, este maina care caut primul simbol diferit de # la dreapta
L#, este maina care caut primul simbol diferit de # la stnga
Utiliznd aceste maini "simple" s construim o maina de copiere C care funcioneaz n modul
urmtor. S presupunem c pe banda de intrare se gsete un ir w care nu conine simboli #
(eventual irul poate s fie i vid). Presupunem ca la stnga irului de intrare se gsete un singur
simbol #; pe banda de intrare nu se mai gsesc simboli diferii de # care s nu fac parte din w. Capul
este poziionat pe simbolul # care marcheaz sfritul irului w. Evoluia mainii trebuie s fie (s, #w#) |* (h, #w#w#). Se spune ca maina transform irul #w# n #w#w#. Reprezentarea grafic pentru aceasta
main este :
>L#
+-------------------------+
| x #
|
-->R --------#R# 2x L# 2 x ---+
# |
R#
S urmrim evoluia mainii pentru coninutul benzii #abc#

(q, #abc#) |-* (q, #abc#)
|- (q, #abc#) |- (q, ##bc#)
L#
R
#
|- (q,##bc#)
|- (q,##bc##)
R#
R#
|- (q, ##bc#a#) |- (q, ##bc#a#) |- (q, ##bc#a#)
x
L#
L#
|- (q, #abc#a#) |- (q, #abc#a#) |- (q, #a#c#a#)
x
R
#
|- (q, #a#c#a#) |- (q, #a#c#a#)
R#
R#
|- (q, #a#c#ab#) |- (q, #a#c#ab#)
x
L#
|- (q, #a#c#ab#) |- (q, #abc#ab#)
L#
x
|- (q, #abc#ab#) |- (q, #ab##ab#)
R
#
|- (q, #ab##ab#) |- (q, #ab##abc#)
R#R#
x
|- (q, #ab##abc#) |- (q,#abc#abc#)
L#L#
x
|- (q, #abc#abc#) |- (q,#abc#abc#)
R
R#
|- (h,#abc#abc#)
n evoluia prezentat anterior starea nu conteaz aa c a fost notat cu un simbol generic q. Se

observ c dac C ncepe s funcioneze cu un coninut al benzii de forma #u#v#w# la sfritul
execuiei se obine pe banda #u#v#w#w#. C nu funcioneaz corect dac la pornire la dreapta
capului de citire se gsete un simbol diferit de #.
Maina SL :
+----------------+
| x #
|
>L ->R ----> LxR ----+
#
|#
L#
transform irul #w# n w#. Similar se poate construi o maina SR care transform irul #w# n
##ww#.
Fie T0 = T - {#} cu f : T0* T0* astfel nct f(w) =wwR, f poate s fie calculat de urmtoarea
main:
+--------------------+
| x #
|
>L ----> #R# xL# x ----+
|#
R#
Pe parcursul funcionrii maina transform iruri de forma #x1 ... xn# n #x1 ... xi ... xnxnxn-1 ...
xi+1#, i = n-1, ..., 0. Pentru i = 0 se ajunge la #x1 ... xnxn ... x1#.
2.3.3.3
Extensii pentru maina Turing
Avnd n vedere simplitatea deosebit a funcionrii unei maini Turing standard, se pune
problema dac aceasta nu poate s fie fcut mai "puternic": prin adugarea unor extensii care s

o apropie eventual de un calculator real. Se poate demonstra c adugarea unor faciliti ca de
exemplu :
banda de intrare infinit la ambele capete;

mai multe capete de citire / scriere;
mai multe benzi de intrare;
o banda de intrare organizat n dou sau mai multe dimensiuni (eventual o memorie aa cum
apare la calculatoare);
nu crete puterea de calcul oferit. Adic, nu se schimb nici clasa funciilor care pot s fie calculate
i nici a limbajelor acceptate sau decise.
Demonstraiile de echivalen sunt constructive realizndu-se pentru fiecare extensie construirea
unei maini Turing standard capabil s simuleze funcionarea unei maini Turing avnd extensia
considerat. S considerm de exemplu o maina Turing care are o band infinit la ambele capete.
Schimbarea definiiei formale pentru acest model de maina Turing intervine n modul n care se definete
noiunea de configuraie i relaia |- asupra configuraiilor. n acest caz o configuraie este de forma (q, w,
a, u) i w nu ncepe cu un simbol # iar u nu se termina cu un
simbol #. Nu mai exist limitri referitoare la deplasarea la stnga i deci dispar noiunile de
stare i respectiv de configuraie de agare.
Propoziie. Fie M1 = (Q1, T1, m1, q1) o main Turing cu banda de intrare infinit la ambele
capete. Exist o main Turing standard M2 = (Q2, T2, m2, q2) astfel nct, pentru orice w (T1 {#})* sunt ndeplinite urmtoarele condiii :
dac M1 se oprete pentru w, adic:

(q1, w#) |-* (h, uav), u, v T1*, a T1
atunci i M2 se oprete pentru w, adic:

(q2, #w#) |-* (h, #uav), u, v T1*, a T1
dac M1 nu se oprete pentru w atunci nici M2 nu se oprete pentru w.

Demonstraie. Banda de intrare pentru M2 se obine prin ndoirea benzii de intrare a mainii M1.
Adic, dac considerm c banda de intrare M1 are un "mijloc" ales arbitrar :
---------------------------------------| -3 | -2 | -1 | 0 | 1 | 2 | 3 |
----------------------------------------
atunci banda de intrare pentru M2 va avea forma:

+--------------------------|
| 0| 1| 2| 3|
| $ |----+----+----+----|
|
| -1 | -2 | -3 | -4 |
+---------------------------

n simulare se va consider deci c funcionarea maini M1 n partea dreapta a benzii de intrare
corespunde funcionrii maini M2 pe pista superioar a benzii sale de intrare, respectiv funcionarea
maini M1 n partea stng corespunde funcionrii maini M2 pe pista inferioar a benzii sale de intrare.
Rezult deci c pentru M2 se va utiliza un alfabet care conine perechi de simboli din alfabetul
T1. O astfel de pereche (a, b) va indica faptul c a este coninut de pista superioar iar b este coninut de
pista inferioar. Vom nota cu T o mulime definit n modul urmtor :
T = {a | a T1}
n acest caz T2 = {$} T1 (T1 x T1) (T1 x T) (T x T1). M2 simuleaza M1 n modul

urmtor :
1. se mparte banda de intrare n dou piste i se copiaz irul de intrare pe pista superioar;
2. se simuleaz funcionarea M1 pe banda obinut;
3. cnd i dac M1 se oprete, se reface forma iniial a benzii.
Pentru a realiza prima etapa trebuie s se realizeze o prelucrare de iruri. Adic, dintr-o banda de
intrare de forma :
---------------------------------------| # | a1 | a2 | ...| an | # | # |
---------------------------------------
trebuie s se ajung la un coninut al benzii de forma :

+-----------------------------------|
| a1 | a2 | ...| an | # |
|
| $ |----+----+----+----+----| # |
|
| # | # | ...| # | # |
|
+-----------------------------------
unde a1, ..., an (T1 - {#})*. Se observ c prelucrrile necesare nu sunt deosebit de dificile.
Etapa a doua poate s fie realizat de ctre o maina M1' care are n mulimea sa de stri pentru
fiecare q Q1 o pereche de stri notate <q, 1> i <q, 2>. Dac M1' este ntr-o stare <q, 1> nseamn c
M1' acioneaz asupra pistei superioare a benzii de intrare. Dac M1' este n starea <q, 2> atunci nseamn
c M1' acioneaz asupra pistei inferioare. De asemenea exist strile <h, 1> i <h, 2> care reprezint
oprirea n situaia n care M1' lucra pe pista superioar respectiv inferioar.
Funcia de tranziie m' pentru M1' este definit n modul urmtor :
a) dac q Q1, (a1, a2) T1 x T1 i m1(q, a1) = (p,b)
atunci
/ (<p, 1>, L)
dac b = L
m1'(<q,1>,(a1,a2) = (<p, 1>, R)
dac b = R
\ (<p, 1>, (b, a2)) dac b T1
b) dac q Q1, (a1, a2) T1 x T1 i m1(q, a2) = (p, b)

atunci

/ (<p, 2>, R)
dac b = L
m1'(<q,2>,(a1,a2) = (<p, 2>, L)
dac b = R
\ (<p, 2>, (a1, b)) dac b T1
c) dac q Q1 {h} atunci

m1'(<q, 1>, $) = (<q, 2>, R)
m1'(<q, 2>, $) = (<q, 1>, R)
d) dac q Q1 {h} atunci

m1'(<q, 1>, #) = (<q, 1>, (#, #))
m1'(<q, 2>, #) = (<q, 2>, (#, #))
e) dac a1, a2 T1 atunci

m1'(<h, 1>, (a1, a2)) = (h, (a', a2))
m1'(<h, 2>, (a1, a2)) = (h, (a1, a'))
f) pentru situaiile care nu se ncadreaz n nici unul dintre cazurile anterioare m1' se
definete arbitrar.
Se observ c n cazurile a i b este descris funcionarea mainii M1 la dreapta i respectiv la stnga
"mijlocului" ales. Cazul c. trateaz comutarea ntre piste care trebuie realizat atunci cnd se ajunge la
limita din stnga a benzii. Cazul d. indic modul n care se face extinderea celor doua piste la dreapta.
Cazul e trateaz intrarea n starea de oprire (h) a maini simulate M1. Se observ c la intrarea n aceasta
stare se va produce intrarea n starea h i a mainii M1' cu nregistrarea pistei pe care s-a fcut oprirea
mainii simulate.
Dac banda de intrare a maini M1 conine irul w (T1 - {#})* i aceasta se oprete cu un coninut
de forma :
----------------------------------------------| # | b1 | b2 | ...| bi | ...| bn | # | # |
-----------------------------------------------
atunci M1' se va opri cu un coninut de forma :

+------------------------------------|
| ck+1 | ck+2 | ... | c2k |
|
| $ |------+------+-----+-----| # |
|
| ck | ck-1 | ... | c1 |
|
+-------------------------------------
unde c1c2 ... c2k = # ... # b1b2 ... bi-1 b bi+1 ... bn # ... # cu bi #, 1 i n.
Pentru etapa a treia se face translatarea simbolilor diferii de # de pe pista inferioar pe pista
superioar :

+------------------------------------------|
| b1 | b2 | ... | bi | ... | bn |
|
| $ |----+----+-----+----+-----+----| # |
|
| # | # | ... | # | ... | # |
|
+------------------------------------------
Din nou aceasta prelucrare este simpl. n final se reface banda sub forma :
+------------------------------------------| # | b1 | b2 | ... | bi | ... | bn | # |
+------------------------------------------
Rolul alfabetului T utilizat n construirea mainii M1' este de a permite identificarea poziiei capului
la oprirea mainii M1'.
Similar definiiei din cazul mainilor Turing standard putem s considerm i n acest caz definiia
noiunii de calcul. i anume dac T1 i T2 sunt doua mulimi de tip alfabet care nu conin simbolul #
atunci spunem c funcia f : T1* T2* este calculat de maina Turing, M care are banda de intrare
infinit la ambele capete, dac i numai dac pentru orice w T1*, dac f(w) = u atunci (q, w#) |-*
(h,u#). De asemenea noiunile de acceptare respectiv de decidabilitate referitoare la limbaje pot s fie
definite pentru mainile Turing cu banda infinit la ambele capete ntr-o maniera similara celei de la
maina Turing standard.
Orice funcie care este calculat i orice limbaj care este acceptat sau decis de o maina Turing cu
banda infinit la ambele capete este calculat respectiv acceptat sau decis de o main Turing standard.
Construcii i rezultate similare pot fi realizate i pentru celelalte extensii considerate la nceputul
acestui subcapitol. Din acest motiv n tratarea pe care o vom realiza n continuare putem s considerm
pentru a simplifica demonstraiile n loc de maini Turing standard maini care au oricare dintre
extensiile amintite sau chiar combinaii ale acestora.
Extinderea maini Turing se poate face i prin renunarea la caracterul determinist al acestora.
Pentru o main Turing nedeterminist funcia m este definit n modul urmtor :
m : Q x T P((Q {h}) x (T {L, R}))
Dup cum s-a artat pentru orice automat finit nedeterminist se poate construi un automat finit
determinist echivalent. n cazul automatelor cu stiv aceasta echivalen nu exist. Cu alte cuvinte
automatele cu stiv nedeterministe sunt "mai puternice" dect cele deterministe deoarece automatele
cu stiv nedeterministe accepta o clasa mai larga de limbaje.
n cazul mainilor Turing nedeterministe deoarece pentru acelai ir de intrare se pot obine
rezultate diferite, se pune problema cum se alege "calculul util" efectuat de maina Turing. Vom
restringe puin problema considernd numai noiunea de acceptare. n acest caz ceea ce conteaz este
c maina Turing se oprete n una din evoluiile sale posibile. Rezultatul depus pe band nu este n acest
caz neaprat semnificativ. S considerm mai nti un exemplu de main Turing nedeterminist. Fie
limbajul
L = { w { a, b}* | w contine sirul abaab}
Evident, limbajul este de tip regulat i poate s fie acceptat de un automat finit determinist. O
soluie de maina Turing nedeterminista care accepta acest limbaj este :

a, b
-\/ b
a
a
b
a
/|
>L -----> L ----> L ----> L ----> L ----> a R | #
|
|
|
|
|
| \|
#|
b,# |
b,# |
a,# |
b,# |
#|
-------->------>-------<--------<-------|
| /|
# |
\|
Configuraia din care se pleac este (q, #w#). Maina Turing pornete spre stnga. La un moment
dat, la ntlnirea unui simbol b, maina Turing "ghicete" ca a gsit sfritul sub irului cutat.
Dac ghicirea este corect atunci maina se va opri, altfel maina nu se oprete. Fiind vorba de o
funcionare nedeterminist tot ce conteaz este c dintre toate soluiile posibile exist una pentru care
maina se oprete. Se poate demonstra urmtoarea propoziie.
Propoziie Pentru orice maina Turing, M1 nedeterminist exist o maina Turing M2 determinist
(standard) astfel nct pentru orice ir w care nu conine simbolul # :
i) dac M1 se oprete pentru w atunci i M2 se va opri pentru w;
i) dac M1 nu se oprete pentru w atunci nici M2 nu se oprete pentru w.
S considerm o schi de demonstraie pentru propoziia anterioar. Fie M1 = (S, T1, m, s). M2
trebuie s ncerce toate evoluiile posibile pentru M1 n cutarea unei evoluii pentru care M1 se oprete.
M1 poate avea ns un numr infinit de evoluii pornind din s i avnd un ir w pe banda de intrare ( s nu
uitm c dac irul nu este acceptat de M1 aceasta nu se va opri). Se pune problema cum trebuie s fac
M2 cutarea ntre aceste evoluii (n ce ordine ?).
Ideea este urmtoarea, dac M1 este n configuraia C atunci exist mai multe configuraii C' astfel
nct C |- C'. Numrul configuraiilor C' este ns finit i depinde numai de definiia funciei m (nu de
configuraia C). Dac starea curenta este q i simbolul curent la intrare este a, atunci m(q, a) P((Q
{h}) x (T {L, R})) este o mulime finit, deoarece |m(q,a)| (|Q| + 1) x (|T| + 2). Fie
r = max (|m(q,a)|)
qQ
aT
Valoarea r rezult din definiia funciei m i reprezint numrul maxim de configuraii urmtoare
posibile pentru o configuraie dat. Deci dac pornim din configuraia iniial C = (q,#w#), M1 poate s
treac n maximum r configuraii urmtoare diferite. Fiecare dintre aceste r configuraii diferite poate s
treac la rndul ei n alte r configuraii diferite. Rezult deci c pentru o evoluie n k pai se poate ajunge
la un numr de maximum rk configuraii diferite pornind din configuraia iniial. Pentru fiecare mulime
m(q, a), q Q, a T, considerm cte o ordonare arbitrar a elementelor care o compun.
M2 va analiza n mod sistematic nti toate configuraiile n care se poate ajunge ntr-un pas, apoi n
doi pai, etc. Dac n aceasta cutare se trece printr-o configuraie pentru care M1 se oprete se va opri i
M2. Dac M1 se oprete vreodat atunci ea se oprete ntr-un numr finit de pai. Corespunztor M2 va
descoperi aceasta oprire ntr-un numr finit de pai.
Maina M2 poate s fie construit avnd trei piste. O pist este utilizat ca martor, pe ea se pstreaz
irul iniial. A doua pist este utilizat pentru a simula funcionarea maini M1. Fiecare simulare ncepe cu
o copiere a coninutului primei benzi (partea util) pe a doua band. A treia band pstreaz evidena
ncercrilor fcute. i anume pe aceast band se gsete un ir dintr-un alfabet D = {d1, ..., dr}, unde r
este numrul maxim de configuraii urmtoare posibile pentru orice configuraie a maini M1. Pe aceasta

band se vor genera iruri care codific modul n care se aleg alternativele posibile n fiecare pas al
simulrii. Astfel, un ir de forma d3 d5 d1 indic faptul c se va ncerca un calcul n trei pai. n primul
pas se alege dac exist a treia alternativ din cele maximum r posibile, n al doilea pas se alege a cincea
alternativ iar n al treilea pas se alege prima alternativ posibil. Dac n aceasta alegere nu exist o
alternativ cu numrul celei indicate se abandoneaz calculul.
Generarea irurilor pe a treia band se face n ordine lexicografic. Dupa fiecare ncercare care nu a
dus la oprire se va terge coninutul celei de a doua benzi i se genereaz un nou ir pe a treia band.
Dac ncercarea duce la oprirea maini simulate se oprete i M2.
Se observ c toate prelucrrile descrise anterior sunt prelucrri simple asupra unor iruri de simboli
ce pot s fie realizate de ctre maini Turing standard.
Pe baza propoziiei enunate anterior rezult ca orice limbaj acceptat de o main Turing
nedeterminist va fi acceptat i de o maina Turing determinist.
2.3.3.4
Automate liniar mrginite
Un automat liniar mrginit este un caz particular de main Turing nedeterminist. Definiia unui astfel de
automat este:
ALM = (Q, T, m, s, F)
unde:
Q este o mulime finit de stri
T este alfabetul benzii de intrare, #, L, R T
m este funcia de tranziie
m : Q x T P(Q x (T {L, R})).
s Q este starea iniial pentru automatul liniar mrginit.
F Q este mulimea strilor finale
Dac q Q este o stare, a T este un simbol de pe banda de intrare i (p, b) m(q, a) nseamn c
din starea curent q pentru simbolul de intrare a se poate trece n starea p, nlocund sibmbolul de pe banda
de intrare sau efectund o micare la stnga sau la dreapta. Definiia este a unui acceptor nedeterminist.
Funcionarea automatului pornete cu o configuraie avnd pe banda de intrare un ir cuprins ntre doi
simboli # (dou blancuri). Deoarece funcia de tranziie nu este definit pentru simbolul #, nseamn c
spaiul de micare al capului de citire/scriere pe banda d intrare este limitat la lungimea iniial a irului de
intrare. Cu alte cuvinte dac printr-o deplasare la stnga sau la dreapta capul de citire/scriere ajunge n
afara spaiului ocupat iniial de ctre irul analizat automatul se oprete. Conform definiiei, pentru
automatele liniat mrginite se consider o acceptare prin stri finale. Dac la oprirea automatului capul de
citire se gsete la captul din dreapta al irului i starea automatului face parte din F nseamn c evoluia
automatului a dus la acceptare.
Se poate demonstra c pentru orice gramatic dependent de context exist o gramatic echivalent
liniar mrginit. Produciile unei gramatici n liniar mrginit au n partea dreapt cel mult doi simboli.
Dac exist o producie S AB (unde S este simbolul de start al gramaticii) atunci A = S. Pentru orice
gramatic dependent de context liniar mrginit se poate construi un automat liniar mrginit care accept
acelai limbaj. De asemenea pentru orice automat liniar mrginit este posibil s se construiasc o
gramatic dependent de context care genereaz acelai limbaj. Adic, clasa limbajelor acceptate de
automate liniar mrginite este clasa limbajelor dependente de context. Intuitiv, relaia de echivalen dintre
gramaticile dependente de context i automatele liniar mrginite este susinut de condiia pe care o
satisfac produciile unei gramatici dependente de context. i anume - dac A este o producie
atunci |A| ||. Adic orice ir din limbajul generat de ctre gramatic este mai lung cel puin egal
cu orice form propoziional obinut n secvena de derivri prn care se obine irul respectiv.

Se poate construi i o definiie de automat liniar mrginit determinist. Automatele liniar mrginite
nedeterministe sunt mai puternice dect cele deterministe, n sensul c existe limbaje acceptate de ctre
automate liniar mrginite nedeterministe dar care nu sunt acceptate de automate liniar mrginite
deterministe. n particular limbajele independente de context sunt acceptate i de automatele liniar
mrginite deterministe (acceptoarele obinuite pentru limbajele independente de context sunt automatele
cu stiv).
2.3.3.5
Relaia ntre maina Turing i gramatici
Propoziie. Fie M = (Q, TM, m, q) o main Turing. Exist o gramatic G = (N, TG, P, S) astfel
nct pentru orice pereche de configuraii (q, uav) i (q', u'a'v') ale maini Turing
*
(q, uav) |- (q', u'a'v')
M
dac i numai dac

*
[uqav] [u'q'a'v']
G
Demonstraie. Se observ c formele propoziionale ce se obin n gramatica G conin iruri care

corespund configurailor maini Turing. Astfel, pentru o configuraie de forma (q,u,a,w) se obine o
form propoziional [uqaw]. Poziia pe care o ocupa simbolul corespunztor strii indic de fapt poziia
capului de citire pe banda de intrare.
Mulimea simbolilor terminali pentru G este TG = TM {[, ]}. Mulimea simbolilor
neterminali N = Q {h, S}. Mulimea produciilor se construiete n modul urmtor :
i) q Q, a TM dac m(q,a) = (p, b) b T atunci qa pb P
i) q Q, a TM dac m(q,a) = (p, R) atunci
qab apb P pentru b TM i qa] ap# P
iii) q Q, a TM dac m(q,a) = (p, L) atunci dac a # sau c ] atunci
bqac pbac P, b TM, c TM {]}
dac a = # atunci
bq#] pb] P, b TM.
Se observ c n construcia anterioara simbolul de start al gramatici nu joac nici un rol.
n toate produciile se observ ca apare cte un singur neterminal att n partea dreapta ct i n
partea stnga. Acest neterminal corespunde unei stri. Poziia sa n cadrul fiecrui ir reprezint de fapt
poziia capului de citire. Simbolul de start al gramaticii nu este utilizat. Se poate demonstra utiliznd
aceast construcie c :
(q, u, a, v) |- (q', u', a', v')
dac i numai dac
[uqav] [u'q'a'v']

Demonstraia se realizeaz considernd toate formele posibile de producii. Mai departe rezultatul se
extinde natural pentru nchiderile acestor relaii.
S considerm de exemplu maina Turing
M = ({q0, q1, q2}, {a, #}, m, q0)
pentru care m este definit n modul urmtor :
m(q0,
m(q0,
m(q1,
m(q1,
m(q2,
m(q2,
a)
#)
a)
#)
#)
a)
=
=
=
=
=
=
(q1,
(q0,
(q2,
(q1,
(h,
(q2,
R)
a)
R)
a)
#)
R)
s considerm pentru aceast main evoluia pentru configuraia (q0, #a#)

(q0, #a#) |- (q0, aa#)
|- (q1, aa#)
|-+ (h, aa#).
S construim gramatica corespunztoare :

G = ({q0, q1, q2, h, S}, {q, #, [, ]}, P, S)
P va conine urmtoarele producii :
i) n cazul n care se face scriere pe banda
q0# q0 a ( corespunde m(q0, #) = (q0, a) )
q1# q1 a ( corespunde m(q1, #) = (q1, a) )
q2# h # ( corespunde m(q2, #) = (h, #) )
i) n cazul n care se fac deplasri dreapta

q0aa a q1 a ( corespunde m(q0, a) = (q1, R))
q0a# a q1 #
q0a] a q1 #]
q1aa a q2 a (corespunde m(q1, a) = (q2, R))
q1a# a q2 #
q1a] a q2 # ]
q2aa a q2 a (corespunde m(q2, a) = (q2, R))
q2a# a q2 #
q2a] a q2 #]
Un calcul realizat de M poate s fie :

(q0, #) |- (q0, a#) |- (q1, a#) |- (q1, aa# |- (q2, aa#)
|- (h, aa#)
O derivare n G care pornete din irul [q0#] este :

[q0#] [q0a] [aq1#] [aq1a] [aaq2#]
[aah#]
Se observ c n aceasta derivare simbolul de start al gramatici nu a intervenit. Gramatica este n

acest caz utilizat ca mecanism de specificare a unor substituii de iruri i nu ca generator de limbaj.
Aa cum o main Turing a fost tratat ca acceptor de limbaj o gramatica poate s fie privit ca
un dispozitiv capabil s reprezinte (efectueze) calcule.
Fie T1 i T2 dou mulimi de tip alfabet care nu conin simbolul # i fie f : T1* T2*,
spunem c f este calculabil gramatical dac i numai dac exist o gramatica G = (N, T, P, S) astfel
nct T1, T2 T i exist irurile x, y, x', y' (N T)* care ndeplinesc urmtoarea condiie pentru u
T1* i v T2* v = f(u) dac i numai dac xuy * x'vy'. n acest caz se spune c G calculeaz
funcia f. De la iruri definiia se poate extinde la numere naturale ntr-o manier similar celei
utilizate la maina Turing.
S considerm de exemplu T1 = {a, b} i f : T1* T1*, f(w) = wR. Funcia f este calculabil de
ctre gramatica G = (N, T, P, S} unde N = {A, B, S}, T = {a, b, *, [, ]} iar P conine urmtoarele
producii :
1. [a [A,[b [B
2. Aa aA, Ab bA, Ba aB, Bb bB
3. A* *a, B* *b
irurile x, y, x' i y' sunt [, *], [* i respectiv ]. G transform un ir de forma [w*] cu w {a, b}*
n modul urmtor. Se transform nti primul simbol (a sau b) cu care ncepe irul n A sau B utiliznd
una dintre produciile [a [A sau [b [B. n continuare neterminalul astfel obinut migreaz spre
limita din dreapta a irului. La ntlnirea simbolului * se aplic una dintre produciile A* *a sau B*
*b. De exemplu pentru irul abb se obine :
[abb*] [Abb*] [bAb*] [BAb*] [BbA*]
[Bb*a] [bB*a] [b*ba] [B*ba]
[*bba]
Se observ c nu este semnificativ ordinea n care se aplic produciile.

Propoziie Orice funcie calculabil n sens Turing este calculabil i gramatical.
Demonstraia acestei propoziii este constructiv, adic pornind de la o maina Turing se
construiete o gramatic care realizeaz acelai calcul.
Din rezultatele prezentate putem trage concluzia echivalenei ntre gramaticile de tip 0
(fr restricii) i mainile Turing din punctul de vedere al limbajelor acceptate (generate) i al puterii
de calcul.
Considernd echivalena dintre gramatici i mainile Turing se pune ntrebarea cum se poate
construi o main Turing care s accepte limbajul generat de o gramatica G = (N, T, P, S). Avnd n
vedere ca operaia de derivare presupune de fapt prelucrri simple de iruri de simboli, se poate construi
o main Turing care s execute operaia de derivare. O astfel de main se poate obine de exemplu
utiliznd cte o main Turing pentru fiecare producie. Avnd n vedere modul n care se obine un ir

care face parte din L(G) se poate construi o main Turing eventual nedeterminist care s realizeze
aceleai operaii.
2.3.3.6
Elemente de calculabilitate
Discuia coninut n acest subcapitol depete cadrul limbajelor formale dar este important
pentru a realiza legtura dintre modelele de calcul considerate i lumea real a calculatoarelor, mai
ales pentru a oferi o caracterizare a posibilitilor oferite de acestea.
n momentul n care s-a dat definiia limbajelor s-a precizat faptul c numai o anumit parte a
acestora poate s fie descris ntr-o form finit. Gramaticile, automatele finite, automatele push down,
maina Turing sunt astfel de reprezentri finite. Se pune problema dac odat cu maina Turing s-a atins
ntr-adevr limita de reprezentare finit a limbajelor. De asemenea, avnd n vedere c o
gramatica poate s fie interpretat i ca un dispozitiv capabil s efectueze calcule, se pune ntrebarea
dac nu exist mecanisme mai puternice de reprezentare dect gramaticile i maina Turing (avnd n
vedere faptul c un calculator real pare mult mai puternic dect o maina Turing).
2.3.3.6.1
Maina Turing Universal
Spre deosebire de o maina Turing standard, modelul Von Neumann de calculator presupune
noiunea de program memorat. Ar apare aici o diferen important ntre o main Turing i un
calculator real. i anume o main Turing standard este dedicat rezolvrii unei anumite probleme
(calculului unei anumite funcii) n timp ce un calculator este un dispozitiv universal, capabil s treac
la calculul unei noi funcii prin schimbarea programului, deci a ceva coninut n memorie, fr a schimba
ns modul de funcionare a unitii de control. Se pune ntrebarea dac nu se poate construi o maina
Turing care s funcioneze ntr-o manier similar adic, s primeasc la intrare att irul care se
transform ct i o descriere a transformrii. O astfel de main Turing se numete maina Turing
universal. Pentru a construi o main Turing universal este necesar s obinem nti un mod de
descriere al unei maini Turing sub forma de ir astfel nct aceast descriere s poat s fie utilizat
ca intrare pentru o alta main Turing .
Fiecare main Turing este definit utiliznd patru elemente MT = (Q, T, m,s). Deoarece Q i T
sunt mulimi finite descrierea unei maini Turing poate s fie fcut sub forma unui ir utiliznd
simboli din Q, T, paranteze, virgule i alte semne de punctuaie. O asemenea reprezentare sub forma de
ir, nu este recomandabil deoarece avem nevoie pentru maina pe care o construim de un alfabet
finit pe care s l utilizm n definiia acesteia, alfabet care s permit reprezentarea oricrui alfabet
posibil pentru o main Turing. Vom consider ca exist mulimile infinit numrabile :
Qinf = {q1, q2, ...} i Tinf = {a1, a2, ...}.
astfel nct pentru orice main Turing, mulimea strilor i respectiv alfabetul de intrare sunt
submulimi finite din Qinf i respectiv Tinf. Se consider urmtoarea codificare pentru elementele care
aparin unei definiii de main Turing utiliznd un alfabet ce conine un singur simbol {I}:

element | cod(element)
---------+-------------| Ii+1
qi
---------+-------------h
|I
---------+-------------L
|I
---------+-------------R
| II
---------+-------------| Ii+2
ai
------------------------
Se observ c fiecare stare q Q {h} are un cod unic, acelai lucru este valabil i pentru fiecare
simbol din alfabetul de intrare. Fie c un simbol c I. Pentru construirea irului care descrie o main
Turing se utilizeaz numai simbolii c i I. Fie MT = (Q, T, m, s) o main Turing cu Q Sinf i T Tinf.
Deci Q = {qi1, qi2, ..., qik}, i1 < i2 < ... < ik, iar T = {aj1, aj2, ... ajl}. Construim kl iruri notate cu Spr, unde
1 p k i 1 r l. Fiecare ir Spr codific valoarea funciei de tranziie pentru o pereche (qip, ajr).
Fie de exemplu m(qip, ajr) = (q', b), q' Q {h} i b T {L, R} atunci Spr = cw1cw2cw3cw4c
unde :
w1
w2
w3
w4
=
=
=
=
cod(qip)
cod(ajr)
cod(q')
cod(b).
Notm cu codif(M) irul cS0cS11S12 ... S1lS21 ... S2l ... Sk1 Sk2 ... Skl c. S0 este codificarea strii iniiale,
S0 = cod(s). Se observ c irul astfel obinut reprezint o codificare unic pentru o maina Turing. De
asemenea pe baza unui astfel de ir se poate reconstrui descrierea "clasica" a mainii.
S considerm de exemplu MT = (Q, T, m,s) cu Q = {q2}, T = {a1, a3, a6}, s = q2 i m(q2, a3) =
m(q2, a6) = (q2, R) i m(q2, a1) = (h,a3). Utiliznd notaiile anterioare, rezult k = 1, i1 =
2, l = 3 i j1 = 1, j2 = 3, j3 = 6. Se obine :
S11 | m(q2, a1) = (h, a3) | cIIIcIIIcIcIIIIIc
-----+---------------------+----------------------S12 | m(q2, a3) = (q2,R) | cIIIcIIIIIcIIIcIIc
-----+---------------------+----------------------S13 | m(q2, a6) = (q2, R) | cIIIcIIIIIIIIcIIIcIIc
Rezult
codif(M) = cI3c|cI3cI3cIcI5c|cI3cI5cI3cI2c|cI3cI8cI3cI2c|c
O main Turing universal U primete pe banda de intrare un ir de tip codif(M) i un ir w pe care

trebuie s funcioneze M. irul w trebuie s fie i el codificat utiliznd alfabetul {c, I}. Codificarea se
face n modul urmtor. Dac w = b1 ... bn, cu bi Tinf atunci:
codif(w) = c cod(b1) c cod(b2) c ... c cod(bn) c.
Se observ c irul obinut codif(w) nu poate s conin simboli #, chiar dac w conine simboli #. U =
(Qu, {I, c, #}, mu, qu) trebuie s satisfac urmtoarele condiii - pentru orice main Turing , M = (Q, T,
m, s) :

1. dac (h, uaw) este o configuraie de oprire pentru M astfel nct (s, #w#) |-*M (h, uav) atunci, (qu,
#codif(M) codif(w) #) |-*U (h, #codif(uav)#)
2. dac (qu, #codif(M)codif(w)#) |-*U (h,u'a'v') pentru o configuraie de oprire (h, u'a'v') pentru U atunci
a' = #, v' = , u' = #codif(uav) pentru u, a, v astfel nct (h, uav) este o configuraie de oprire pentru M
i (s, #w#) |-*M (h, uav).
Adic dac M se oprete pentru w atunci i U se oprete pentru un ir obinut prin concatenarea
irurilor codif(M) i codif(w). Mai mult, pentru o astfel de oprire coninutul benzii U reprezint o
codificare a rspunsului maini Turing, M pentru w. De asemenea dac U se oprete pentru un ir care
reprezint codif(M)codif(w) atunci i M se va opri pentru w i rezultatul lsat de U reprezint codificarea
rezultatului lsat de M.
Pentru a simplifica discuia vom consider o variant U' a maini U, variant care utilizeaz trei benzi.
Conform celor menionate anterior pentru aceasta variant se poate construi o main Turing echivalent
cu o singur band. Prima band va conine iniial codif(M)codif(w), a doua band conine n timpul
simulrii codif(M) iar a treia band va conine codificarea strii curente a maini M care se simuleaz.
Funcionarea ncepe cu prima band coninnd codif(M)codif(w), celelalte benzi find goale. U' va copia
irul codif(M) pe a doua band i va modifica coninutul primei benzi la forma #c codif(#w#). Se observ
c localizarea nceputului irului codif(w) n irul iniial se face uor pentru c aici exist trei simboli c
consecutivi. Din codif(M) se identific S0 (codul pentru starea iniial) i se copiaz pe cea de a treia
band. n continuare U' ncepe s simuleze funcionarea maini Turing M. ntre paii de simulare cele trei
capete de citire / scriere utilizate (exist trei benzi de intrare) sunt poziionate n modul urmtor :
pentru prima band pe ultimul c care indic sfritul codului pentru simbolul curent parcurs de M;
pentru a doua i a treia band la marginea stnga a benzilor respective.
n acest mod cnd M pornete s trateze ultimul simbol # din irul de intrare #w#, U' va ncepe
simularea deplasndu-i capul pe ultimul simbol c de pe banda. U' va cuta pe a doua band un subir de
forma ccIicIjcIkcIlcc unde Ii este irul coninut n a treia banda, iar Ij este irul curent de pe prima banda. La
identificarea unui astfel de subsir U' se va mica corespunztor. Dac Il este codif(L) sau codif(R) atunci se
realizeaz deplasarea pe prima banda de intrare la stnga respectiv la dreapta. Dac Il este cod(a) pentru a
Tinf se observ c nlocuirea simbolului curent poate s presupun deplasarea coninutului primei benzi
pentru ca spaiul ocupat de codul pentru a poate s fie diferit de cel ocupat de simbolul nlocuit. n cadrul
aceleiai micri U' nlocuiete irul nscris n a treia band cu Ik. Dac acum coninutul acestei benzi este
cod(h) U' va deplasa capul de pe prima banda pe primul simbol # aflat la dreapta poziiei curente dup
care se oprete. Dac pe banda a treia nu se gsete cod(h) atunci se continu simularea.
Rezult deci c o main Turing este suficient de puternic pentru a fi comparata cu un calculator
real. De fapt o main Turing este echivalent cu noiunea intuitiv de algoritm. Mai
mult conform ipotezei Church (Church's Thesis) nici o procedur de calcul nu este un algoritm dac
nu poate s fie executat de o maina Turing. Acest rezultat care este acceptat, n prezent constituie numai
o ipotez pentru c nu constituie un rezultat matematic, ci indic numai faptul c un anumit obiect
matematic (maina Turing) este echivalent cu un concept informal.
Revenind la problema reprezentri finite a limbajelor se pune problema cum arat limbajele care nu
sunt Turing decidabile. Cu alte cuvinte putem s dm o reprezentare finit pentru un astfel de limbaj ?.
Dac aa ceva este posibil nseamn c putem s construim un algoritm care s decid dac un ir face
parte din limbajul respectiv. Conform ipotezei Church ns noiunea de algoritm i cel de maina Turing
sunt echivalente, Rezult deci c ar exist o maina Turing care s verifice dac irul face parte din limbaj,
adic limbajul ar fii Turing decidabil ceea ce contrazice ipoteza.
S discutm puin i relaia dintre limbajele Turing acceptabile i limbajele Turing decidabile. Se
poate demonstra urmtorul rezultat:

Propoziie. Orice limbaj L Turing decidabil este i Turing acceptabil.
Demonstraie. Fie M o main Turing care decide L. Atunci se poate construi M' care s accepte L.
N /|
> M L ----- N |
\|
Se observ c M' simuleaz M dup care studiaz rspunsul obinut pe band. Dac rspunsul este N,
M' va intra ntr-un ciclu infinit.
Se pune ntrebarea care este raportul invers ntre limbajele acceptabile i cele decidabile Turing.
Dac ar fi posibil ca pentru orice maina Turing i orice ir de intrare w, s prevedem dac maina
Turing se va opri pentru w, atunci orice limbaj Turing acceptabil ar fi i Turing decidabil, deoarece dac
M1 este maina Turing care accept L putem s construim M2 care decide L n modul urmtor. M2 va
executa calculele necesare pentru o prevedea dac M1 se oprete pentru w. Corespunztor M2 se va opri
cu un simbol D sau N pe banda de intrare dup cum M1 accept sau nu irul w.
Rezult c cele doua probleme:
este orice limbaj Turing acceptabil i Turing decidabil ?

se poate construi o main Turing care s prevad pentru orice main Turing, M, dac aceasta se
oprete sau nu pentru un ir, w ?
sunt echivalente.
Am artat c dac se poate construi o main Turing care s prevad pentru orice main Turing dac
aceasta se oprete sau nu pentru orice ir atunci orice limbaj acceptabil este i decidabil. S presupunem
acum c orice limbaj acceptabil este i decidabil. n acest caz limbajul:
L0 = { codif(M)codif(w) | M accepta w}
care este acceptat de maina Turing universal, este un limbaj decidabil. Fie M+ maina Turing care
decide acest limbaj. n acest caz M+ poate s prevad pentru orice main Turing dac aceasta se oprete
sau nu pentru orice ir w.
Vom arta n continuare c L0 nu este decidabil. n mod corespunztor rspunsul la cele doua
probleme enunate anterior este : NU.
Dac L0 este Turing decidabil atunci limbajul :
L1 = { codif(M) | M accepta codif(M) }
este Turing decidabil. Dac M0 este maina care decide L0 atunci se poate construi maina M1 care s
decid L1. Funcionarea M1 const din transformarea intrrii din #w# n #wcodif(w)# pe care va funciona
apoi M0. Deci M1 va calcula acelai rezultat asupra irului #w# ca i M0 asupra irului #wcodif(w)#.
Conform definiiei limbajului L0, M0 va scrie D pe banda dac i numai dac :
a. w este codif(M) pentru o main Turing
b. maina Turing M, accept irul w, adic irul de intrare codif(M).
Dar asta este exact definiia limbajului L1. Rezult c este suficient s artm c L1 nu este Turing
decidabil. S presupunem c L1 este Turing decidabil n acest caz i limbajul

L1 = { w {I,c}* | w nu este codif(M) pentru nici o main Turing
sau w = codif(M) pentru o maina Turing, M,
care nu accept sirul codif(M) }
este decidabil. O main Turing care decide L1 se obine din maina Turing care decide L1 inversnd
la oprirea mainii rspunsurile D i N.
Limbajul L1nu este ns Turing acceptabil. S presupunem c exist o maina Turing M* care
accepta L1. Din definiia limbajului L1 rezult c:
M, codif(M) L1 M nu accept codif(M) (1)
dar, M* a fost construit pentru a accept L1, adic:
codif(M*) L1 => M* accept codif(M*) (2)
Din (1) i (2) rezult
M* nu accept codif(M*) M* accept codif(M*)
adica M* nu poate s existe, adic L1, L1 i deci L0 nu sunt Turing decidabile.
Deoarece L0 nu este Turing decidabil nu exist un algoritm care s stabileasc dac o main Turing
oarecare se oprete pentru un ir oarecare. Se observ c am gsit o problema pentru care nu avem o
soluie sub form de algoritm. Astfel de probleme se numesc nedecidabile (nerezolvabile). De fapt L0
descrie cea mai cunoscut problema nedecidabila i anume problema opriri maini Turing. Enunul acestei
probleme este : "s se determine pentru o main Turing M, arbitrar dac se oprete pentru un ir de
intrare dat ".
Alte probleme nedecidabile echivalente de fapt cu aceast problem sunt :
dndu-se o main Turing, M, se oprete M pentru irul vid ?

dndu-se o maina Turing , M, exist un ir pentru care M se oprete ?
dndu-se o main Turing, M, se oprete M pentru orice ir de intrare ?
dndu-se dou maini Turing, M1 i M2 se opresc ele pentru acelai ir de intrare ?
dndu-se o main Turing, M este limbajul acceptat de M regulat, independent de context, Turing
decidabil ?
dndu-se dou gramatici G1 i G2 arbitrare L(G1) = L(G2) ?
dndu-se o gramatic G arbitrar este L(G) = ?
dndu-se o gramatic G independent de context este G ambigu ?
2.3.3.7
. Maina Turing cu limit de timp
Chiar dac o problem poate s fie rezolvat cu ajutorul unei maini Turing dac timpul de
rezolvare este mult prea mare nseamn c practic problema nu poate s fie rezolvabil cu ajutorul unei
maini Turing. Unul dintre exemplele clasice pentru o astfel de enun este problema comis-voiajorului.
Ideea este c un comis-voiajor trebuie s viziteze 10 orae. Se cunosc distanele dintre orae i se cere s
se construiasc un intinerariu de lungime minim care s permit comis-voiajorului s viziteze toate
oraele. Evident, problema este rezolvabil. Numrul de drumuri posibile este finit (9!) i deci o
parcurgere a tuturor va produce o soluie. S considerm c 9! este nc o valoare siportabil, dar dac am
vorbi de 30 de orae. n acest caz numrul de posibiliti este mai mare dect 1030. Timpul pentru a a
analiza toate aceste soluii reprezint mai multe miliarde de viei omeneti. Rezult deci, c din punct de
vedere practic definiia de problem rezolvabil/nerezolvabil trebuie s fie redefinit. n continuare vom

lucra cu maini Turing cu mai multe benzi. Se poate demonstra c timpul de decizie pentru un limbaj nu
depinde de numrul de benzi utilizate.
*
Fie t o funcie pe numere naturale. Fie L T0 un limbaj i M = (Q, T, m, s) o main Turing cu k
piste avnd T0 T. Vom spune c M decide L n timp t dac pentru orice w L
(s, #w#, #, ..., #) |-x (h, #D#, #, ..., #) pentru x t(|w|);
iar pentru w L
(s, #w#, #, ..., #) |-x (h, #N#, #, ..., #) pentru x t(|w|).
Vom spune c L este decidabil n timp t dac exist un k > 0 i o main Turing cu k piste astfel
nct s decid L n timp t. Clasa limbajelor decidabile n timp t este reprezentat de TIME(t).
Rezult c numrul de pai executai de o main Turing pentru un ir dat depinde de lungimea sa.
Deoarece maina Turing trebuie cel puin s tearg irul de intrare, i s scrie un simbol (D sau N) i s
i poziioneze capul dup acest simbol nseamn c sunt necesare cel puin |w| + 1 operaii de scriere i
|w| + 3 operaii de deplasare. Rezult c pentru funcia t utilizat ca limit de timp t(n) > 2n + 4. S
considerm de exemplu maina care decide limbajul:
L = {w {a,b}* | w nu contine sirul aa}
#\
----+b
\ /
|--/
\b/
/ #
>L --#L ----->#L/
a
a
#
#
RDR
RNR
n timp ce maina parcurge irul de intrare de la stnga la dreapta l i terge. M va executa numrul
minim de pai, adic M decide L n timp t, cu t(n) = 2n + 4 adic L TIME(t). Acelai lucru se poate
scrie sub forma - L TIME(2n + 4).
Obiectivul unui studiu de complexitate pentru rezolvarea unei probleme const n construirea unei
maini Turing care s asigure c decizia limbajului respectiv se va face n maximum t pai, cu t propus
sau dac asta nu este posibil s se construiasc o demonstraie riguroas c o astfel de main nu se poate
construi.
Se poate demonstra c dndu-se un limbaj L TIME(t) atunci L TIME(t') unde t'(n) = 2n + 18
+ _ x t(n) _ unde x este o valoare real orct de mic (_ r _ reprezint cel mai mic numr ntreg m
astfel nct m r). Ceea ce exprim rezultatul anterior este faptul c ceea ce conteaz este viteza de
cretere i nu factorii constani sau termenii de ordin mai mic.
Fie f i g dou funcii pe numere naturale. Vom nota cu f = O(g) dac i numai dac exist o
constant c > 0 i un numr ntreg n0 astfel nct:
f(n) c g(n) pentru n n0.
d
j
Dac f(n) = ajn atunci f = O(nd). Adic viteza de cretere polinomial este reprezentat de

j=0
rangul polinomului. n afar de polinoame mai exist i alte funcii care dei nu sunt polinomiale sunt
mrginite de polinoame. De exemplu n |_log2(n+1)_ = O(n2). Evident creterile polinomiale sunt de
preferat celor exponeniale (de forma rn) pentru c se poate demonstra c orice funcie exponenial crete
strict mai repede dect una polinomial.
Clasa P ( limbajelor decidabile n timp polinomial) este definit ca:
d
P = {TIME(n ) | d > 0}
Adic este clasa tuturor limbajelor care pot s fie decise de o main Turing ntr-un timp care este
mrginit de o funcie polinomial.
*
Fie t o funcie pe numere naturale. Fie L T0 i fie M = (Q, T, m, s) o main Turing
nedeterminist. Spunem c M accept limbajul L n timp t nedeterminist dac pentru w T0*,
w L daca si numai daca (s, #w#) |-x (h, vau)
*
x t(|w|). Vom spune c limbajul L este acceptabil ntr-un timp t

pentru v, u T , a T i
nedeterminist dac exist o main M care accept L n timp t nedeterminist. Clasa limbajelor acceptabile
n timp t nedeterminist este notat cu NTIME(t). Vom definii
NP = {NTIME(nd) | d > 0}
Mai puin formal, P este clasa tuturor mulimilor pentru care apartenena unui element poate s fie
testat eficient. Acelai lucru nu este adevrat pentru NP. Clasa NP conine probleme pentru care
apartenena la P nu a fost demonstrat.
Fie L1 T1* i L2 T2*. O funcie g : T1* T2* este calculabil n timp polinomial dac
exist o main Turing M care calculeaz f n timp t polinomial. O funcie g : T1* T2* calculabil n
timp polinomial. este o transformare polinomial din L1 n L2 dac i numai dac pentru orice w T1*,
w L1 dac i numai dac g(w) L2. Cu alte cuvinte irurile din L1 pot s fie transformate n iruri din
L2 ntr-un timp polinomial.
Se spune c un limbaj L este NP-complet dac i numai dac
(a) L NP;
(b) pentru L' NP, exist o transformare n timp polinomial din L' n L.
Se poate demonstra c dac L este NP-complet atunci P = NP dac i numai dac L P. Deocamdat
nu s-a demonstrat c P NP sau P = NP. Exist numeroase probleme "clasice" care sunt NP-complete.
Pentru aceste probleme de fapt nu se tie dac exist algoritmi de rezolvare n timp polinomiali. Se
consider c este mai probabil c P NP i deci c astfel de algoritmi nu exist. De obicei dac pentru o
problem "nou" se dorete s se cerceteze apartenena la clasa P sau NP se ncearc construirea unei
transformri polinomiale la una dintre problemele cunoscute (de exemplu problema comis voiajorului este
o problem NP-complet).

Limbaje Formale Si Automate 1

Încărcat de

Informații document

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

Limbaje Formale Si Automate 1

Încărcat de

Drepturi de autor:

Formate disponibile

For Evaluation Only.

Copyright (c) by VeryPDF.com Inc