Functia Universala. Problema Opririi.

Multimi recursive, recursiv enumerabile

si nerecursive.
===============
Definitii:
=========
1. Functia Universala:
=====================
(n)
(/) (x1,...,xn,t) - functia universala de n variabile.
Despre ea putem spune ca oricare n >= 1, aceasta functie este calculabila
Aceasta functie primeste ca argumente variabilele de intrare ale unui
program standard ( x1,...,xn ) si codificarea acestui program ( t )
Simbolul "#" inseamna codificare. Codificarea lui program P este de
forma:
#(P) = [#(I1),#(I2),...,#(In)]
#(P) este argumentul "t" din prototipul functiei (/).
#(I) reprezinta codificarea unui instructiuni si este de forma:
#(I) = <a,<b,c>> unde: a - eticheta
b - numarul variabilei in S
c - tipul instructiunii
a = 0 daca instructiunea I nu are eticheta
= #(L) daca are eticheta
Etichetele sunt codificate: E = 1, A1 = 2, A2 = 3, ...
Deci, de exemplu, #(A3) = 4
b = Numarul variabilei care apare in I
c = 0 corespunde lui V <- V
= 1 corespunde lui V <- V+1
= 2 corespunde lui V <- V-1
= #(L)+2 Este necesar "+2" pentru a se evita confuzia cu celelalte
tipuri de instructiuni

Corespunde lui IF V =/= 0 GOTO L

2. Problema Opririi:
=====================
Enunt informal: Dat un program oarecare, sa se decida daca acest program
va rula la nesfarsit sau se va sfarsi.
Enunt formal: Data codificarea unui program #(P), notata cu y si o intrare,
pentru acest program, notata cu x, se poate calcula
functia/predicatul HALT(x,y)?
Unde HALT(x,y) = 1 daca programul de termina, 0 daca programul
nu se termina.
Un predicat, in contextul acesta, este o functie care
returneaza 0 sau 1.
Predicatul HALT nu se poate calcula.
3. Multimi Recursive:
=====================
Functia caracteristica a unei multimi este o functie predicat care
primeste ca argument un element al unei multimi, de exemplu, X si returneaza
1 daca elementul apartine unei submultimi A a lui X si 0 altfel.
Detalii: http://en.wikipedia.org/wiki/Indicator_function
O multime X se numeste recursiva daca functia sa caracteristica este
Turing calculabila si masina se opreste pe fiecare intrare.
4. Multimi Recursiv Enumerabile:
===============================
O multime X se numeste recursiv enumerabila daca functia sa caracteristica
este Turing calculabila, insa masina nu se opreste neaparat pe fiecare
intrare.
5. Multimi Nerecursive:
======================
Multimile nerecursive sunt multimile a caror functie caracteristica nu

este calculabila Turing. Ca legatura cu definitia functiei caracteristice

de mai sus:
Sa zicem ca X este multimea tuturor programelor si A este multimea
programelor care se opresc. Evident A inclus in X.
Functia caracteristica trebuie sa intoarca 1 daca un program p este in
A, deci se opreste sau 0 daca nu. In acest caz functia caracteristica este
chiar HALT, care nu este Turing calculabila.
Putem spune alterntiv ca multimile nerecursive sunt multimile de probleme
nedecidabile.
Functia Universala. Problema Opririi. Multimi recursive, recursiv enumerabile
si nerecursive.
===============
Relatii:
=======
1. Daca X este o multime recursiva atunci atat X cat si C(x), adica
complementul sau, sunt recursiv enumerabile.
De aici se deduce ca R inclu in RE. ( R - clasa multimilor recursive
RE - clasa multimilor recusriv
enumerabile )
2. X si Y multimi recursive, atunci si X reunit cu Y sunt multimi recrsive
3. X si Y multimi recursive, atunci si X intersectat cu Y sunt multimi
recrsive
4. X si Y multimi recursiv enumerabile, atunci si X reunit cu Y
sunt multimi recrsiv enumerabile.
5. X si Y multimi recursiv enumerabile, atunci si X intersectat cu Y
sunt multimi recrsiv enumerabile.
Inchiderea R si RE la reuniune si intersectie ( adica 2 - 5 )
este mentionata in curs, insa atat R cat si RE sunt inchise si la:
1. Concatenare.
2. Diferenta.
Relatia cu multimile nerecursive reiese din teorema urmatoare:

Orice functie turing calculabila este recursiva.

Functia Universala. Problema Opririi. Multimi recursive, recursiv enumerabile
si nerecursive.
===============
Demonstratii:
============
1. Programul Universal:
======================
T

- Probabil este programul de rulat, insa nu sunt sigur. Nu am putut

distinge din nici un curs. Daca cineva are idee ce este T, ar fi
super daca ar impartasi cu restul lumii :)
S
- Se face un produs al tuturor variabilelor din programul simulat.
Acest lucru foloseste la stabilirea faptului ca V e 0
V
- Variabila instructiunii curente
Lt(T) - Returneaza numarul de instructiuni de rulat
(T)k - Returneaza numarul instructiunii care trebuie rulata
I
- Instructiunea care trebuie rulata
U
- Tipul instructiunii care trebuie rulata
Pv - Al V-lea numar prim. Daca Pv nu este divizibil cu S, atunci,
evident, V este 0.
r si l sunt functiii recursive care returneaza elemente din <a,<b,c> > adica
codificarea instructiunii, insa nu stiu cu exactitate cum functioneaza.
T <- X + 1
n+1
n
xi
S <- Produs P
i
2i

( In S se memoreaza valorile tuturor variabilelor programului simulat )

K <- 1
C:
IF (K > Lt(T)SAU(K = 0)) GOTO F
( Daca am terminat; daca K a depasit numarul de intructiuni de rulat )

I <- (T)
K
( Numarul instructiunii de executat )
V <- l(r(I))
( Numarul variabilei ce apare in instructiunea cu numarul I )
U <- r(r(I))
( Numarul atasat tipului de intructiune )
IF U = 0 GOTO N ( next instruction )
IF U = 1 GOTO A ( addition )
IF U = 2 GOTO D ( decrement )
( Daca nu este 0 , 1 sau 2, este IF )
IF P !| S GOTO N
V
( Daca al V-lea prim nu este divizibil cu S, inseamna ca e 0 )
K <- min_dupa_r[U - 2 = l((T)r)]
( K este numarul de ordine a primei instructiuni etichetata cu numarul U-2 )
GOTO C
A:
S <- S*P
v
GOTO N
D:
IF P !| S GOTO N ( Pentru a nu scadea sub 0 )
v
S <- S/P
v

N:
K <- K+1
GOTO C
F:
Y <- (S)
1
GOTO E
( Extragerea rezultatului )
2. Problema Opririi. Nedecidabilitatea Predicatului HALT:
==================================================
=======
Demonstratia se face prin reducere la absurd.
Presupun ca HALT este calculabil.
Consider urmatorul program, P1:
------------------------A: Z[r+1] <- HALT(x,x)
IF Z[r+1] =/= 0 GOTO A
------------------------Z[r+1] este prima variabila de lucru libera. Ce face programul e sa
cicleze, in principiu la infiinit.
Codific programul P1 de mai sus: #(P1) = t.
Acum, ne punem intrebarea ce se intampla daca rulam predicatul HALT cu
argumentele x si t. ( Programul P1 cu intrarea x )
Se va obtine o contradictie:
Z va fi 0 daca programul x cu intrarea x nu se opreste.
Dar cum x este t, obtin HALT(t,t) <=> not(HALT(t,t))
http://www.comp.nus.edu.sg/~cs5234/FAQ/halt.html
Aici se gaseste o demonstratie si mai simpla.