Functii recursive, Turing calculabile, cu Programe Standard:

==================================================
==========
Definitii:
==========
##################################################
#############################
1. Functii Recursive:
=================
Functii elementare:
1. Succesor:
succ : N -> N
succ(x) = x+1
2. Constanta:
(n) n
C : N -> N
k
(n)
C (x1, ..., xn ) = k
k
3. Proiectia:
(n) n
P : N -> N
k
(n)
P (x1, ..., xn ) = xk
k
Operatii:
1. Compunere functionala:
k
f : N -o-> N
k

g : N -o-> N i de la 1 la m
i
m
h : N -o-> N
f(x1,...,xk) = h(g1(x1,...,xk) , ... , gm(x1,...,xk))
2. Recurenta Primitiva:
k+1
f : N -o-> N
k
g : N -o-> N
k+2
h : N -o-> N
f(x1,...,xk,0) = g(x1,...,xk)
f(x1,...,xk,t+1) = h(x1,...,xk,t,f(x1,...,xk,t))
3. Minimizare Marginita:
k
f : N -o-> N
k+1
g : N -0-> N
f(x1,...,xk) = min( g(x1,...,xn,t) = 0 ) - minim dupa t
t
##################################################
#############################
1. Programe Standard:
=================
1. Limbajul Abstract S
Variabile:
x1 ... xn - Variabile de intrare
y
- Variabile de iesire
z1 ... zm - variabile de lucru
Instructiuni:

1.
2.
3.
4.

V <- V
V <- V+1
V <- V-1 ( Daca se poate )
IF V =/= 0 GOTO L

Terminare:
Salt la eticheta E.
Salt la o eticheta inexistenta.
Terminarea instructiunilor.
Vom numi f functia calculata de programul P.
Relatii:
========
Functiile recursive si programele standard sunt modele de calcul
echivalente.
1. Toate functile elementare poat fi calculate cu programe standard.
2. Legat de compunerea functionala, daca g si h sunt calculabile cu PS,
atunci si f este calculabila cu PS.
3. Legat de recurenta primitiva, daca g si h sunt calculabile cu PS,
atunci si f este calculabila cu PS.
4. Legat de minimizarea marginita, daca g este calculabila cu PS,
atunci si f este calculabila cu PS.
5. Din cele 4 afirmatii de mai sus, reiese faptul ca orice functie recursiva
sau partial recursiva este calculabila cu PS.
Demonstratii:
============
Demonstratiile celor doua teoreme, de cate 2 puncte fiecare.
##################################################
#############################
1. Orice functie recursiva sau partial recursiva este calculabila cu PS.
Aceasta teorema reiese din demonstratia celor 4 relatii intre functiile
recursive si PS.

1. Toate functile elementare poat fi calculate cu programe standard.

Succesorul:
Y <- X
Y <- Y+1
Constanta:
Y <- Y+1
........ De k ori
Y <- Y+1
Proiectia:
Y <- Xk
2. Legat de compunerea functionala, daca g si h sunt calculabile cu PS,
atunci si f este calculabila cu PS.
Z <- g(x1,...,xk) - Putem scrie asa pentru ca din ipoteza am presupus ca
p1
g este calculabila cu PS. Z este prima variabila
p1
de llucru nefolosita.
..................
Z <- g(x1,...,xk)
pm
Y <- h(Zp1,...,Zp2)
3. Legat de recurenta primitiva, daca g si h sunt calculabile cu PS,
atunci si f este calculabila cu PS.
Zp <- g(x1,...,xk)
Ar+1: IF Zp =/= 0 GOTO Ar ---|
Y <- Zp
| Aceasta secventa este echivalenta cu
E
---| f(x1,...,xk,0) = g(x1,...,xk)
Ar: Z[p+1] <- h(x1,...,xk,Z[p+2],Zp) ---|
Zp
<- Z[p+1]
|
Z[p+2] <- Z[p+2] + 1
| Aceasta secventa este recurenta
X[k+1] <- X[k+1] - 1
|

GOTO Ar+1

---|

"r" din numele etichetelor este sugestiv, vine de la recurenta.

4. Legat de minimizarea marginita, daca g este calculabila cu PS,
atunci si f este calculabila cu PS.
Zp <- g(x1,...,xk,Y)
Ar+1: IF Zp =/= 0 GOTO Ar
GOTO E
--- Daca Zp e 0, atunci programul s-a terminat,
s-a gasit cel mai mic Y pentru care functia este
0
Ar: Y <- Y+1
Goto Ar+1
##################################################
##############################
2. Orice functie calculabila cu Programe Standard este Turing calculabila.
Structura unui program standard este urmatoarea:
1.
2.
3.
4.

Variabile de intrare: x1,...,xk

Variabila de iesire: Y
Variabile de lucru: z1,...,zm
Instructiuni:
I1,...,In

In constructia masinii M, care va calcula fP ( fP fiind notatia pentru

functia calculata cu PS )
vom "mima" aceste lucruri.
1. Construim masina M care va avea initial pe banda x1,...,xk, separati
prin 0.
111...10111...10...0111...10BBB
|_____| |_____|
|_____|
x1
x2
xk
2. Adaugam variabilele de lucru. Ele sunt initializate cu 0. 0 intr-o masina
Turing se traduce prin 1.
111...10111...10...0111...10101010...01BBB
|_____| |_____|
|_____| |_________|

x1

x2

xk

3. Masina va intra in starea I1, care corespunde instructiunii I1.

4. Masina va mima executarea instructiunilor in urmatorul mod:
Pentru fiecare stare Ij:
1. Ij este instructiunea V <- V
Masina va trece in starea I[j+1]
2. Ij este intructiunea V <- V+1
Masina va cauta pozitia corespunzatoare lui V.
Masina va adauga un "1" la segmentul ce defineste V in M.
Masina trece in starea I[j+1]
3. Ij este intructiunea V <- V-1
Masina va cauta pozitia corespunzatoare lui V.
Masina va verifica daca segmentul corespunzator lui V are lungimea 1.
Daca DA, nu se face nici o modificare asupra benzii.
Daca NU, atunci se "sterge" un "1" din segmentul respectiv.
Masina trece in starea I[j+1]
4. Ij este instructiunea IF V =/= 0 GOTO L
Masina va cauta pozitia corespunzatoare lui V.
Masina va verifica daca segmentul corespunzator lui V are lungimea 1.
Daca DA, atunci masina trece in starea I[j+1]
Daca NU, atunci masina face urmatoarele verificari:
1. L = E

Daca da, atunci se trece in starea I[n+1] - stare pre

finala
2. Nu exista L Daca da, atunci se trece in starea I[n+1] - stare pre
finala
3. Se trece in starea in starea It, unde t este cel mai mic indice
cu proprietatea ca It are eticheta L.
In starea pre finala I[n+1], masina se va comporta in urmatorul mod:
1. Se deplaseaza toate componentele lui Y in inceputul benzii.
2. Tot ce nu e Y ( la dreapta lui ) este transformat in 0, pana la primul B
3. Se intra in starea finala.