Equivalencia del lenguaje WHILE con una variante

advertisement
LENGUAJE WHILE*
El lenguaje WHILE está basado en el bucle indefinido y una serie de asignaciones (como se
estudia en la asignatura de TALFII de 2º Ingeniería Informática).
El lenguaje que definimos a continuación es una versión modificada del WHILE, en la que
añadimos dos instrucciones: DIV ( Xi ) , que crea otra variable nueva Xk  1 , donde Xk es la
variable del programa con mayor índice, a la que se le da el valor de Xi , y NEC ( Xi) , que elimina
el valor de la variable Xi , y en esa variable mete el valor de Xi  1 , y en esta el valor de Xi  2 , así
sucesivamente, hasta que se llega a la última variable del programa cuyo valor se mete en la
penúltima, suprimiéndose la última. Para poder realizar esto, el programa no ofrece el número de
variables totales, sólo se conoce el número de variables de entrada. A este lenguaje lo llamamos
WHILE*.
Sintaxis de WHILE*
asignación
instrucción
Xi : Xj
DIV ( Xi )
Xi : Xj  1
NEC ( Xi)
Xi : Xj  1 (0  1  0)
Xi : 0
código
estructuras
...sentencias...
secuencia:";"
(con al menos una sentencia)
bucle indefinido:
while Xi  0 do
...sentencias...
od
programa
Q* = (n, código) (n: número de variables de entrada)
1
Concepto de configuración de un programa WHILE*
•
Sea Q* = (n, código) un programa WHILE*, con líneas numerada de 1 a f, una configuración
de Q* es un par ( s, z ) con s 1,2,3,..., f , f 1 y z 
•
Una configuración es inicial si s  1 .
•
Una configuración es final si s  f  1 .
•
C *Q* denota al conjunto de las configuraciones de Q*.
.
Comentarios
Todo lo anterior es igual al lenguaje WHILE, salvo que donde ponemos z en WHILE se pone
un vector x , que contiene el valor de todas las variables del programa (de las que se sabe cuántas
hay a priori) en la línea s del programa. Como para WHILE* el número de variables puede ir
aumentando durante el transcurso del programa (el número de componentes del vector x es
variable), z simula el número de Gödel del vector x . Además, en WHILE, para que una
configuración fuera inicial, aparte de s  1 , todas las variables auxiliares (las que no son de entrada)
deben ser 0, y en WHILE* inicialmente sólo se tienen las variables de entrada.
Concepto de cálculo en un paso para la asignación
Sea el programa Q* anterior, la configuración c1  (s, z1 ) se transforma en c2  (t , z2 ) en un
•
paso de cálculo (representado por c1  *Q* c2 ) si y sólo si
-
s :"asignación" aparece en la versión etiquetada de Q*
-
t  s 1
-
siendo Xj  degod( z1 , j ) y z2  god( y) , donde
 0
 xj

yi  
 xj  1
 xj  1
si "asignacion"  Xi : 0
si "asignacion"  Xi : Xj
si "asignacion"  Xi : Xj  1
si "asignacion"  Xi : Xj  1
yr  degod( z1 , r ) para todo r tal que 1  r  l ( z1 ) y r  i
2
(1)
(1)
Versión etiquetada es simplemente el programa con las líneas numeradas.
Comentarios
En este caso la diferencia que hay con respecto a WHILE es que extraemos la componente jésima del número de Gödel z1 , hacemos la correspondiente asignación, el resultado lo metemos en
la componente i-ésima del número de Gödel z2 .
Concepto de cálculo en un paso para el bucle
•
Sea Q* el programa anterior, la configuración c1  (s, z1 ) se transforma en c2  (t , z2 ) en un
paso de cálculo (representado por c1  *Q* c2 ) si y sólo si
-
z2  z1
-
la línea de número s contiene una cabecera o cola de while
si s : while Xi  0 do: s ' y xi  0 entonces t  s  1
en otro caso t  s ' 1
si s : od: s ' y xi  0 entonces t  s ' 1
en otro caso t  s  1
Concepto de cálculo en un paso para la instrucción
•
Sea el programa Q* anterior, la configuración c1  (s, z1 ) se transforma en c2  (t , z2 ) en un
paso de cálculo (representado por c1  *Q* c2 ) si y sólo si
-
s :"instrucción" aparece en la versión etiquetada de Q*
-
t  s 1
-
siendo Xi  degod( z1 , i) y z2  god( y) , donde
yl ( z1 )1  xi  yr  degod( z1 , r ) para todo r tal que 1  r  l ( z1 ) si "instrucción" = DIV ( Xi )

yr  degod( z1 , r  1) para todo r tal que 1  r  l ( z1 ) 1  yr  degod( z1 , r ) para todo r tal
que 1  r  i  1
si "instrucción" = NEC ( Xi)
3
Comentarios
Si el programa se encuentra con la instrucción DIV ( Xi ) se crea una nueva variable con el valor
xi , que es la siguiente a la última que había en el programa hasta el momento. Si se encuentra con
la instrucción NEC ( Xi) se eliminará el valor de la variable Xi , y se procede como se indicó
anteriormente.
Función siguiente configuración
•
Sea Q*=(n, código)
SIG*Q* :
2

2
 c ' si c  *Q* c '
SIG*Q* ( c )  
 c si c  C *Q*  c '/ c  *Q* c '
Función cálculo de un programa
•
Sea Q*=(n, código)
n1
CAL*Q* :

2
CAL*Q* (a, i)  (t, z) , siendo a 
n
y (1,god( a)) * Q* c1 * Q* c2 * Q*...... *
c ( ,t )z
Q* i
cálculo de Q* en pasos, que comienza con valores a de las variables de entrada del programa
•
Se define recursivamente en función de SIG*Q*
(1,god(a))
CAL*Q* ( a, i)  
SIG*Q* (CAL*Q* (a, i  1))
si i  0
si i  0
Función complejidad temporal
•
Sea Q*=(n, código)
T*Q* :
n

T*Q* ( x )   j  12 (CAL*Q* ( x, j ))  f  1
siendo x 
n
y 12 la función proyección del primer elemento de un vector de dos elementos
4
el
Comentarios
En WHILE teníamos CAL*Q* ( x, 0, j ) , ya que el 0 significa que se ponen a cero todas variables
auxiliares, y en WHILE* no hay variables auxiliares inicialmente.
Concepto de función calculada
•
Sea Q*=(n, código)
f *Q* :
n

f *Q* ( x)  degod( 22 (CAL*Q* ( x,T'Q' ( x))),1)
x
n
Expresado informalmente: dados unos valores para las variables de entrada ( x ) se realizan pasos de
cálculo hasta alcanzar una configuración final, y se toma como resultado la variable X 1 , que se
obtiene degodelizando (o extrayendo) la primera componente del número de Gödel z que resulta de
proyectar la segunda componente de CAL*Q* ; si no es posible alcanzar tal configuración final,
entonces el programa no acaba para esos valores de entrada, y la función está indefinida.
La clase de funciones WHILE*-calculables
•
F n (WHILE*) es el conjunto de todas las funciones f :
n

tales que existe un programa
WHILE*, con n variables de entrada, que calcula f.
•
F (WHILE*) es la unión de todas las F n (WHILE*) , para n  0 .
•
Si f  F (WHILE ) diremos que f es una función WHILE*-calculable.
5
TEOREMA DE EQUIVALENCIA
F (WHILE)  F (WHILE*)
F (WHILE )  F (WHILE*)
•
Funcion Siguiente
 Funcion Calculo


 Funcion Tiempo
 Funcion Calculada
Tenemos que comprobar que con las funciones de WHILE* se pueden hacer las de WHILE.
-
Función Siguiente:
p 1
SIGQ :
p 1

SIGQ ( c )  SIGQ (s, x)  SIG*Q (s,god(x))  SIG*Q (s, z1 ) 
(t , z2 ) si (s,z1 )  *Q (t,z 2 )



( s, z1 ) si (s,z1 )  C *Q (t , z2 ) /( s, z1 )  *Q (t , z2 ) 

(t , y )  c ' donde yi  degod( z2 , i )  1  i  l ( z2 ) si c  *Q c '

si c  C *Q  c '/ c  *Q c '

 ( s, x )  c
-
Función Cálculo:
CALQ :
p1

p1
CALQ (a, i)  CAL*Q (a, i)  (t, z)  (t, b) donde bi  degod( z, i)  1  i  l (z)
-
Función Tiempo:
TQ :
n

TQ ( x )  T*Q ( x )   j  12 (CAL*Q ( x, j ))  f  1
-
Función Calculada:
fQ :
n

fQ ( x)  f *Q ( x)  degod( 22 (CAL*Q ( x,T*Q ( x))),1)
6
x
n
F (WHILE*)  F (WHILE )
•
Funcion Siguiente*
 Funcion Calculo*


 Funcion Tiempo*
 Funcion Calculada*
Tenemos que comprobar que con las funciones de WHILE se pueden hacer las de WHILE*.
-
Función Siguiente*:
2
SIG*Q :

2
SIG*Q ( c )  SIG*Q ( s, z1 )  SIG Q ( s, x, 0) donde xi  degod(z1, i)  1  i  l(z1 )
y 0 vector de p  l ( z1 ) con l ( z1 )  p
si ( s, x, 0) Q (t , y)
 (t , y )


SIG Q ( s, x, 0)  

(
s
,
x
,
0)
si
(
s
,
x
,
0)

C


(
t
,
y
)
/(
s
,
x
,
0)

(
t
,
y
)

Q
Q



 (t , god( y ))  (t , z2 )  c '


( s, god( x, 0))  ( s, z1 )  c
-
Función Cálculo*:
CAL*Q :
n1
si c  *Q c '
si c  C *Q  c '/ c  *Q c '

2
CAL*Q (a, i)  CALQ (a, i)  (t, b)  (t,god(b))
-
Función Tiempo*:
T*Q :
n

T*Q ( x )  TQ ( x )   j  1p 1 (CAL Q ( x, 0, j ))  f  1
-
Función Calculada*:
f *Q :
n
con 0 un vector de p  n ceros

f *Q ( x)  fQ ( x)   2p1 (CALQ ( x, 0,TQ ( x)))
x
n
Por tanto, hemos demostrado por doble inclusión que las funciones WHILE*-calculables son
WHILE-calculables y viceversa.
7
Descargar