Tema 2: El lenguaje GOTO

Tema 2:
El lenguaje GOTO
Dpto. Ciencias de la Computación e Inteligencia Artificial
Universidad de Sevilla
Teorı́a de la Computabilidad
Curso 2010–11
TC0, 2010–11
Lenguaje GOTO
2.1
Modelos de computación
El lenguaje GOTO
Sintaxis
Semántica
Funciones computables
Macros
Ejemplos
Expansión de macros
TC0, 2010–11
Lenguaje GOTO
2.2
Modelos de Computación
I
Un Modelo de Computación proporciona una definición
matemática precisa del concepto de algoritmo.
I
Un Programa es la expresión formal de un algoritmo en un
modelo.
Caracterı́sticas generales:
I
1. Especificación:
I
I
Datos de entrada y salida (suelen ser del mismo tipo).
Operaciones básicas.
Acciones primitivas que actúan sobre los datos de entrada.
2. Implementación e Interpretación:
I
I
TC0, 2010–11
Sintaxis: reglas gramaticales para la construcción de los
procedimientos mecánicos (programas).
Semántica: definición lógico-matemática de las funciones o
relaciones que definen los procedimientos.
Lenguaje GOTO
2.3
Funciones Computables
Un modelo de computación, M, viene dado por:
I
I
I
Un conjunto de datos de entrada y salida, DM .
Un conjunto de programas PM (descrito por la sintaxis de M).
Una descripción del modo en que cada programa calcula una
función.
Sea P un programa en un modelo de computación M.
I
Asociamos a P una función sobre la estructura de datos
[
[[P]]M : D∗ − −→ D
donde, D∗ =
Dk
k∈N−{0}
I
TC0, 2010–11
[[P]]M (d)= resultado de ejecutar P sobre el dato d.
(k)
Donde para cada aridad k, [[P]]M = [[P]]M Dk
Una función k-aria f : Dk − −→ D es M–computable si
existe un M-programa P tal que [[P]](k) = f . Denotamos por
M–COMP al conjunto de funciones M–computables
Lenguaje GOTO
2.4
Modos de Computación
Asocian a la semántica del modelo una definición de solución.
I
Modo secuencial-determinista.
La ejecución sobre un dato es única. Resuelve el problema de
manera exacta.
I
Modo paralelo. Ejecuta diversas tareas en procesadores
distintos. Resuelve el problema de manera exacta.
I
Modo no determinista.
Admite instrucciones que pueden elegir entre dos o más
opciones. Resuelve un problema si entre sus posibles
soluciones proporciona una solución exacta del mismo.
I
Modo probabilista.
Los programas son deterministas, pero se admite como
soluciones programas que, con cierta probabilidad,
proporcionan una solución exacta del problema.
TC0, 2010–11
Lenguaje GOTO
2.5
El Lenguaje GOTO
Es un modelo secuencial y determinista con conjunto de datos: N.
I
Sintaxis:

 De entrada: X1 (= X ), X2 , X3 , ...
De salida:
Y
1. Variables:

Auxiliares:
Z1 (= Z ), Z2 , Z3 , ...
2. Etiquetas: A1 , B1 , C1 , D1 , E1 , A2 , B2 , C2 , D2 , E2 , . . .
I
Notación: A = A1 , B = B1 , C = C1 , D = D1 , E = E1 .
3. Instrucciones: Para cada variable V y cada etiqueta L:
I
I
I
I
I
Incremento: V ←− V + 1
Decremento: V ←− V − 1
Condicional: IF V 6= 0 GOTO L
Skip: V ←− V
Instrucciones etiquetadas: Para cada etiqueta K :
[K ]
[K ]
[K ]
[K ]
TC0, 2010–11
V ←− V + 1
V ←− V − 1
IF V 6= 0 GOTO L
V ←− V
Lenguaje GOTO
2.6
Programas GOTO
I
I
I
I
I
I
TC0, 2010–11
Un programa GOTO (un G–programa) es una sucesión finita
de instrucciones del lenguaje GOTO, P = I1 , I2 , .., In , cuya
última instrucción NO es Y ←− Y .
Si P = I1 , . . . , In es un programa GOTO el número n se
denomina longitud del programa y se denota por |P|.
Caso lı́mite: el Programa Vacı́o (con 0 instrucciones).
Denotaremos por GOTOP al conjunto de los G-programas.
Ejemplo:

 [A] X ←− X − 1
Y ←− Y + 1
P:

IF X 6= 0 GOTO A
Cada programa expresa un procedimiento para calcular una
cierta función (parcial) de Nn en N. El modo en que cada
programa lleva a cabo esto se determina mediante la
semántica del lenguaje GOTO.
Lenguaje GOTO
2.7
Estados
Sea P un programa GOTO.
I
Denotamos al conjunto de las variables del lenguaje GOTO
mediante VAR.
I
var (P) conjunto de variables que aparecen en P.
I
Un estado de P es una aplicación σ : VAR → N.
I
Un estado es, esencialmente, una tabla variable–valor que
guarda el valor de las variables del programa en un momento
dado. Por ello, a veces, escribiremos V = m en lugar de
σ(V ) = m.
TC0, 2010–11
Lenguaje GOTO
2.8
Descripciones instantáneas
Sea P un programa GOTO.
I
Una descripción instantánea, (d.i.) de P, es un par
s = (i, σ) donde 1 ≤ i ≤ |P| + 1 y σ es un estado de P.
I
Cuando i = 1 y σ(V ) = 0 para toda variable V , salvo un
número finito de variables de entrada, la d.i. se denomina
inicial.
I
Cuando i = |p| + 1, la d.i. se denomina terminal.
I
Si s = (i, σ), escribiremos s(V ) en lugar de σ(V ).
TC0, 2010–11
Lenguaje GOTO
2.9
Semántica
Sea P un programa y s = (j, σ) y s 0 = (j 0 , σ 0 ) descripciones
instantáneas de P con j 6= |p| + 1.
Diremos que s 0 es la descripción instantánea siguiente de s en
la computación de P, y escribimos s `p s 0 , si:
I Caso 1: Ij ≡ V ←− V + 1, s(V)=m. Entonces j 0 = j + 1 y
I
I
Caso 2: Ij ≡ V ←− V − 1, s(V)=m. Entonces j 0 = j + 1 y
I
I
I
I
σ 0 es σ sustituyendo V = m por V = m + 1.
Si m > 0, σ 0 es σ sustituyendo V = m por V = m − 1.
Si m = 0, σ 0 = σ
Caso 3: Ij es de tipo SKIP. Entonces j 0 = j + 1 y σ 0 = σ.
Caso 4: Ij ≡ IF V 6= 0 GOTO L. Entonces σ 0 = σ y
I
I
Si s(V ) = 0, entonces j 0 = j + 1
Si s(V ) 6= 0
I
I
TC0, 2010–11
Si existe k tal que Ik es la primera instrucción etiquetada con
L, entonces j 0 = k
Si no existe tal k, j 0 = |p| + 1
Lenguaje GOTO
2.10
Computación de un programa
Una computación de un programa P es una sucesión de d.i. de P,
s = s1 , . . . , sk , . . . tal que:
I
s1 = (1, σ) es una d.i. inicial.
I
Para todo k, con sk no terminal, existe k + 1 tal que
sk `p sk+1
Una computación s de p es finita si y sólo si existe k tal que sk es
terminal. En tal caso, escribiremos P(s) ↓ y diremos que dicha
computación para. En caso contrario, la computación s es infinita;
escribiremos P(s) ↑ y diremos que no para.
Lema. Para todo P ∈ GOTOP se verifica:
I
Ausencia de bloqueo: Para toda d.i., s, no terminal, existe s 0
tal que s `p s 0 .
I
Determinismo: Para cada d.i. inicial existe una única
computación.
TC0, 2010–11
Lenguaje GOTO
2.11
Ejemplo
[A]
[B]
IF X 6= 0 GOTO B
Z −→ Z + 1
IF Z 6= 0 GOTO E
X −→ X − 1
Y −→ Y + 1
IF X 6= 0 GOTO A
s1 = (1, {X = 3, Y = 0, Z = 0})
s2 = (4, {X = 3, Y = 0, Z = 0})
s3 = (5, {X = 2, Y = 0, Z = 0})
s4 = (6, {X = 2, Y = 1, Z = 0})
s5 = (1, {X = 2, Y = 1, Z = 0})
s6 = (4, {X = 2, Y = 1, Z = 0})
s7 = (5, {X = 1, Y = 1, Z = 0})
s8 = (6, {X = 1, Y = 2, Z = 0})
s9 = (1, {X = 1, Y = 2, Z = 0})
s10 = (4, {X = 1, Y = 2, Z = 0})
s11 = (5, {X = 0, Y = 2, Z = 0})
s12 = (6, {X = 0, Y = 3, Z = 0})
s13 = (7, {X = 0, Y = 3, Z = 0})
TC0, 2010–11
Lenguaje GOTO
2.12
Funciones GOTO–computables
Sea P un G–programa. La función de aridad n calculada por P es
la función [[P]](n) : Nn − → N definida como sigue:
Dado ~a = (a1 , . . . , an ) ∈ Nn ,
1. Sea σ el estado de P dado por:
I
I
σ(Xi ) = ai (1 ≤ i ≤ n)
σ(V ) = 0 para toda V ∈ var (P) \ {X1 , . . . , Xn }.
2. Sea ahora s1 = (1, σ). Entonces

 sk (Y ) si existe s1 , . . . , sk finita de p
a partir de s1
[[P]](n) (~a) =

↑
e.c.o.c.
Definición. Diremos que una función f : Nn − → N es
GOTO–computable (f ∈ G –COMP), si existe un programa
GOTO, P tal que f = [[P]](n) .
I
TC0, 2010–11
G –COMP (n) es el conjunto de funciones computables de aridad n.
Lenguaje GOTO
2.13
Ejemplos
I
La función identidad IdN : N → N es GOTO–computable.
IF X 6= 0 GOTO B
Z ←− Z + 1
IF Z 6= 0 GOTO E
[B] X ←− X − 1
Y ←− Y + 1
IF X 6= 0 GOTO B
I
La función vacı́a f∅ es GOTO–computable:
[A] Z ←− Z + 1
IF Z 6= 0 GOTO A
I
La función nula O : N −→ N
GOTO–computable.
O(x) = 0 es
La función nula es calculada por cualquier programa que pare
siempre y en el que no aparezca la variable de salida Y .
TC0, 2010–11
Lenguaje GOTO
2.14
Macros
Existen bloques de instrucciones que podemos considerar como
“nuevas instrucciones” ya que podemos utilizarlos en cualquier
programa para realizar una cierta subtarea. Veamos algunos
ejemplos de esto:
I
El bloque de instrucciones:
Z ←− Z + 1
IF Z 6= 0 GOTO L
I
nos permite realizar un salto incondicional a la instrucción
etiquetada por L (o terminar la ejecución del programa).
Podemos poner a cero una variable V mediante el siguiente
bloque de instrucciones:
[L] V ←− V − 1
IF V 6= 0 GOTO L
TC0, 2010–11
Lenguaje GOTO
2.15
Macros (II)
I
Es útil introducir abreviaturas para poder usar cómodamente
los bloques anteriores en la descripción de un programa.
I
Dichas abreviaturas se denominan macros y para poder
usarlas debemos especificar con precisión la forma en que
dichas abreviaturas se reemplazan por verdadero código.
Zk ←− Zk + 1
GOTO
| {z L} =⇒
IF Zk 6= 0 GOTO L
|
{z
}
MACRO
EXPANSIÓN
[K ] V ←− V − 1
V
{z 0} =⇒
| ←−
IF V 6= 0 GOTO K
|
{z
}
MACRO
EXPANSIÓN
I
En el primer caso Zk debe ser una variable que no aparece en el
programa en que realizamos la expansión. En el segundo caso K es
una etiqueta que no aparece en dicho programa.
TC0, 2010–11
Lenguaje GOTO
2.16
Macros. Asignación
La macro V ←− V 0 asigna a V el valor de V 0 , conservando V 0 su
valor.
V ←− 0
[A] IF V 0 6= 0 GOTO B
GOTO C

[B] V 0 ←− V 0 − 1


 Copia V 0 en V y en Z
V ←− V + 1
y
Z ←− Z + 1


 Pone V 0 a cero
GOTO A

[C ] IF Z 6= 0 GOTO D 



GOTO L

Copia Z en V 0
[D] Z ←− Z − 1
Pone Z a cero


V 0 ←− V 0 + 1



GOTO C
[L] V ←− V
Continúa
TC0, 2010–11
Lenguaje GOTO
2.17
Uso de las macros
La función suma: Sum : N2









 [B]
P+


[A]







−→ N
Sum(x, y ) = x + y
Y ←− X1
Z ←− X2
IF Z 6= 0 GOTO A
GOTO E
Z ←− Z − 1
Y ←− Y + 1
GOTO B
Ejercicio: Prueba de la corrección para la suma.
(∀x, y ∈ N)([[P+ ]](2) (x, y ) = x + y )
(por inducción débil sobre la segunda variable).
TC0, 2010–11
Lenguaje GOTO
2.18
Uso de macros (II)
La función producto. Prod : N2 −→ N ·(x, y ) = x·y

Z2 ←− X2




[B]
IF Z2 6= 0 GOTO A




GOTO E

[A] Z2 ←− Z2 − 1
p×


Z1 ←− X1 + Y





Y ←− Z1


GOTO B
Nota: Z1 ←− X1 + Y es una macro ejecuta el programa Suma y
asigna el resultado a la variable Z1 .
TC0, 2010–11
Lenguaje GOTO
2.19
Expansión de macros (I)
Sean f ∈ GCOMP (n) y P ∈ GOTOP tales que [[P]](n) = f .
Veamos una expansión para la macro: W ←− f (V1 , . . . , Vn ).
1. Renombrando las etiquetas de P si fuese necesario, podemos
suponer que la única etiqueta de salida de P es E y todas las
demás etiquetas de P son A1 , .., Ar .
2. Renombrando variables podemos suponer que las únicas
variables de entrada que aparecen en P son X1 , . . . , Xn y las
únicas variables auxiliares Z1 , . . . , Zk .
3. Podemos expresar la situación anterior escribiendo
P ≡ P(Y , X1 , . . . , Xn , Z1 , . . . , Zk ; E , A1 , . . . , Ar )
4. Dado m ∈ N podemos obtener un nuevo programa
Qm ≡ P(Zm , , Zm+1 , .., Zm+n , Zm+n+1 , .., Zm+n+k ; Em , Am+1 , .., Am+r )
sustituyendo en P cada variable y cada etiqueta por la
correspondiente de Qm .
TC0, 2010–11
Lenguaje GOTO
2.20
Expansión de macros (II)
Para expandir la macro en un programa P 0 , tomamos m ∈ N
suficientemente grande para que Qm y P 0 no tengan variables ni
etiquetas comunes. Una vez determinado m reemplazamos la
macro por:

Zm ←− 0




Zm+1 ←− V1




..


.




Zm+n ←− Vn




..
.
W ←− f (V1 , . . . , Vn )

Zm+n+1 ←− 0




..


.




Zm+n+k ←− 0




Qm



[Em ] W ←− Zm
TC0, 2010–11
Lenguaje GOTO
2.21
Macros condicionales
Si P(V1 , . . . , Vn ) es un predicado G-computable:
macroexpansión Z ←− P(V1 , . . . , Vn )
IF Z 6= 0 GOTO L
macro
IF P(V1 , . . . , Vn ) 6= 0 GOTO L
Ejemplo: IF V = 0 GOTO L
V = 0 ≡ P(v ) =
donde P(v ) es G-computable:
TC0, 2010–11
1 si v = 0
0 si v 6= 0
IF X 6= 0 GOTO E
Y ←− Y + 1
Lenguaje GOTO
2.22