Caracterización mediante programas de ciertas clases de funciones

Caracterización mediante programas de ciertas clases de
funciones difusas
José-Luis Pérez-de-la-Cruz
Dpto. Lenguajes y Ciencias de la Computación
Facultad de Informática
Universidad de Málaga
e-mail: [email protected]
Rafael Morales-Bueno
Dpto. Lenguajes y Ciencias de la Computación
Facultad de Informática
Universidad de Málaga
e-mail: [email protected]
Ricardo Conejo
Dpto. Lenguajes y Ciencias de la Computación
Facultad de Informática
Universidad de Málaga
e-mail: [email protected]
Buenaventura Clares
Dpto. Lenguajes y Sistemas Informáticos
Facultad de Ciencias
Universidad de Granada
Resumen
En este trabajo estudiamos, desde el punto de vista de la
Teoría de la Calculabilidad, algunas posibilidades que
surgen cuando al escribir programas difusos en el
lenguaje XL se emplean en las asignaciones únicamente
funciones difusas pertenecientes a ciertos subconjuntos
finitos. De está forma conseguimos caracterizar las
clases WRG de Gerla y CONS de Morales et al.
Palabras clave: Lenguaje, programación, calculabilidad, difuso.
1 Introducción
En recientes trabajos hemos definido el lenguaje de
programación XL. Puesto que se permite emplear en la
sentencia de asignación cualquier W-función calculable
(en el sentido de [8]), la semántica de XL no está
completamente definida. En este trabajo estudiamos
algunas posibilidades que surgen cuando solamente se
permite en las asignaciones el empleo de ciertos
subconjuntos de W-funciones. Más concretamente,
mostramos en la sección 4 una familia finita de
funciones cuyo empleo en las sentencias de asignación
de XL es suficiente para generar precisamente la clase
de W-funciones construibles [5], y análogamente en la
sección 5 para la clase de W-funciones con grafo
recursivo [2].
Para que este trabajo resulte autocontenido,
introducimos en secciones previas algunos conceptos ya
aparecidos en la literatura: en la sección 2 realizamos
una presentación parcialmente informal del lenguaje
XL, y en la sección 3 definimos las W-máquinas de
Turing multicinta y recordamos las definiciones de las
clases de W-funciones construibles y con grafo
recursivo.
2 El lenguaje XL
El lenguaje XL opera sobre datos que son subconjuntos
borrosos de (Z+)n. Hay dos instrucciones de asignación
nítida ( X:=0, X:=suc(Y) ) y una instrucción de
asignación borrosa. Hay dos estructuras de control: a)un
bucle tipo "FOR" que representamos por "REPEAT x
TIMES ... SEMIT"; b)un bucle indefinido con una
condición de control del tipo x_0 que representamos
WHILE x_0 DO ... OD. La variable x, como es habitual,
se denomina variable de control del bucle. La
instrucción de control condicional "IF" se puede
programar en términos de asignaciones y bucles "FOR" .
Debido a entradas borrosas o asignaciones borrosas,
el programa puede alcanzar un punto a partir del cual
cada instrucción debe ejecutarse de manera borrosa.
Esto es especialmente importante al considerar
estructuras repetitivas o condicionales. Cuando acaba la
ejecución se obtiene un conjunto de salidas cada una con
su grado. Es decir, el programa produce como salida un
conjunto borroso.
La ejecución de un programa nítido se puede ver
como la generación de una sucesión de “configuraciones
nítidas”. Cada configuración representa el valor de cada
variable del programa. En el caso de programas en XL,
la sucesión no es única; a partir de cierto punto, hay
varias ramas de cálculo cada una con su grado. De esta
forma, las configuraciones generadas por la ejecución
de un programa en XL son subconjuntos borrosos de
“configuraciones nítidas”. En lo que sigue usaremos el
término “elemento de la configuración” para referirnos a
estas “configuraciones nítidas”.
El significado de un programa en XL está definido
en [6] mediante una semántica operacional, esto es,
viendo el programa como un dispositivo que calcula una
función. Cada programa en XL tiene dos conjuntos de
variables distinguidas - variables de entrada y variables
de salida- y calcula una W-función de las variables de
entrada en las variables de salida.
Sea Xr la variable de control del bucle. Para cada
elemento en la configuración con Xr_0, el cuerpo del
bucle se ejecuta una vez. Los resultados se agrupan con
los elementos de la configuración de partida con Xr=0,
formando una configuración intermedia. Este proceso se
repite hasta que todos los elementos en la configuración
tengan Xr=0. Si una tal configuración no se alcanza, el
proceso continua indefinidamente. Nótese que esta
instrucción “while” borrosa, cuando se usa con datos
nítidos, se comporta como un bucle indefinido nítido.
En [4] se demostró que cada programa en XL sin
bucles indefinidos define una W-función total, en el
sentido de que para cada configuración inicial dada se
alcanza una y sólo una configuración final. Con
programas con bucles indefinidos la situación es
diferente; puede haber programas en los que no se
alcanza una configuración final. Estos programas no
terminan para ciertos datos de entrada.
La asignación difusa en XL es Xi:=FUZZn(Xj). Una
W-función fn de Z+ en Z+ está asociada a esta
asignación. Sin embargo, es demasiado optimista
suponer que cualquier W-función está disponible para
las asignaciones.
Definición 1. Sea H un conjunto de W-funciones
recursivas. Una W-function f es XL(H)- programable sii
existe un XL-programa P que calcula f, supuesto que
todas las asignaciones en P, Xi:=FUZZn(Xj), están
asociadas a W-funciones fn∈H. La clase de las funciones
XL(H)-programables se denotará por F(XL(H)). Nótese
que una función programable puede ser parcial.
Definimos también FT(XL(H)) = {fP / P es un XL(H)
programa con una ata para toda configuración inicial}.
Por tanto, si f∈FT(XL(H)), entonces existe un XL(H)programa P que termina para toda entrada.
El caso más simple será H={I}, donde I es la
identidad de Z+ en Z+. XL({I}) es la versión nítida de
XL, es decir, el lenguaje SAL definido y estudiado en
[9].
3 W-Máquinas de Turing multicinta, CONS y
WRG
En esta sección definimos el concepto de W-TM
multicinta. Hablando informalmente, una máquina
multicinta lee y escribe en varias cintas. Estas
construcciones son bien conocidas en la teoría de la
calculabilidad nítida.
Definición 2. Una W-TM de k-cintas es una
cuádrupla Z=(V, S, p, s0) donde V y S son conjuntos
finitos no vacíos, V∩S = ∅; s0∈S y p es una W-función
de S×(V)k en (V∪{L, R})k×(S∪{h}); L,R∈V, h∈S.
Una descripción elemental de Z es una k+1-upla (q,
u1a1v1, ..., ukakvk) donde q∈S∪{h} y uiaivi∈(V{#})V*)V(V*(V-{#})∪{e})
Una descripción elemental es final cuando q=h.
Los conceptos de descripción, descripción final,
cálculo y parada se definen de manera enteramente
análoga a la del caso de una cinta [10].
Definición 3. Sea f una W-función de (I*)r en (O*)s.
Diremos que T=(V,S,p,s0) construye f sii:
a) I,O ⊆V
b) Para cada x∈(I*)r, T se para con entrada x y la
descripción final que se alcanza es D tal que f(x,y)=
_mD(d), donde _ representa la aplicación de ⊕ al
conjunto de todas las descripciones elementales d tales
que mD(d)_0, d=(h, c1, ...,ck) y ci=yi#, i=1,..,s,
y=(y1,..,ys)
Una W-función f es construible sii existe una W-TM
que construye f. CONS(r,s) denotará la clase de las Wfunciones construibles de (Z+)r en (Z+)s. CONS será la
unión de todos los CONS(r,s) (r,s∈Z+, s>0). Nótese que
esta definición coincide con la dada en [5] a partir de
máquinas de una cinta.
Definición 4. Sea f una W-función de I* en O*. Sea
Im(f,x)= {y∈O*:f(x,y)_0}. Sea sup(f,x)=sup(Im(f,x))
respecto al orden lexicográfico. Definimos la función
nítida sf: I*→O* como sf(x)=sup(f,x).
Definición 5. [2] Sea f una W-función de I* en O*.
f∈WRG (f es una función con grafo recursivo) sii su
función de pertenencia µf:I* × O*→W es recursiva
total.
Proposición 1. [5] La condición necesaria y
suficiente para que una W-función con grafo recursivo
sea construible es que la función nítida sf sea recursiva.
Entre los XL-programas y las W-máquinas se puede
establecer
una
correspondencia
natural.
Nos
concentraremos en las máquinas con alfabeto V={I,#},
es decir, que calculan la clase CONS(r,s).
Notación. Sea c=(c1, ..., ck) ∈ (Z+)k. El par (q, c)
representará una descripción elemental de la W-TM con
k cintas (q, c'1#, c'2#, ..., c'k#) donde c'i= I...I (ci
veces).
Definición 6. Sea C una configuración de un kprograma en XL y sea D la descripción de una W-TM
con k cintas. C and D son equivalentes sii existen un
subconjunto finito {b1,...,bn}⊂ (Z+)k, una sucesión (a1,
..., an) en W, y un estado q tales que
C = a1/b1+a2/b2+...+an/bn
y
D =a1/(q,b1)+a2/(q,b2)+...+an/(q,bn)
Definición 7. Sea P un k-programa en XL y sea M
una W-TM con k cintas, M=(V,S,p,s0). P y M son
equivalentes sii para todo a, b∈(Z+)k se tiene i) o ii):
i) WP(a,b) no está definida y M no se para con
entrada a.
ii) WP(a,b)=b y M se para con entrada a alcanzando
una descripción final D tal que mD(b)=b
Comentario. Si P y M son equivalentes, entonces
hay una correspondencia biunívoca entre los pares
(descripción inicial, descripción final) en M y los pares
(valcoin(e), valcofi(e)) en el árbol de derivación de P.
En otras palabras, si valcoin(e) y la descripción inicial
son equivalentes, entonces P y M o bien se embarcan
ambos en una computación sin fin o bien se paran
ambos y, si se paran ambos, valcofi(e) y la descripción
final de M son equivalentes.
4 Caracterización de CONS mediante programas XL
Necesitaremos para las demostraciones de esta sección
un teorema formulado y probado en [9] cuyas raíces se
remontan a los trabajos de Wang [10] y Böhm-Jacopini
[1] (vd. por ejemplo [7]). Con nuestra notación, el
teorema es el siguiente:
Proposición 2. [9] Una función (nítida) f es
recursiva sii f es XL({I})-programable.
Definición 8.- Sean I1, ..., Ir y y01 las siguientes Wfunciones Z+ en Z+ :
si y = x
l i
I i ( x, y) = 
 0 en otro caso
1 si ( y = 0) o ( y = 1)
ψ 01 ( x, y) = 
en otro caso
0
Demostración: Sea f una W-función construible de
+
Z en Z+; entonces, según se probó en [5], f∈WRG, y
por la definición 4, f es una función recursiva total de
Z+× Z+ en W, y hay un XL({I}) programa (nítido) que
calcula f. Sea P1=(2,1,Q1) este programa; P1 es también
un XL(C) programa. Considerando P1 como
identificador de este programa, puede usarse como una
macro en la forma
Xi := P1(Xj, Xk)
cuya ejecución produce el siguiente resultado: dados
a,b∈Z+ , valores para Xj y Xk respectivamente, Xi
almacena el grado f(a,b) codificado por un entero
positivo 0,..,r.
Por otra parte, la función sf: Z+→Z+ es nítida y
recursiva y hay otro XL({I}) programa que la calcula.
Sea P2=(1,1,Q2) este programa. Usaremos P2 para
identificarlo como macro.
Ahora es posible escribir un XL(C)-programa
P3=(1,1,Q3) que calcula f (el concepto de macro
expansion se describe por completo en [4]):
P3;
begin
1
X2:= P2(X1);
2
REPEAT X2 TIMES
3
IF X5_1 THEN
4
X4:= P1(X1,X3);
5
IF X4_0 THEN
6
X5:= FUZZ0(X4);
7
IF X5=1 THEN
8
X6:= FLATTEN(X3,X4)
9
FI
10
FI
11
FI;
12
X3:=suc(X3)
13
SEMIT;
14
IF X5_1 THEN
15
X4:= P1(X1,X3);
16
X6:=FLATTEN(X3,X4)
17
FI;
18
X1:=X6
end
En este programa, la función asociada a FUZZ0 es
ψ01. La macro FLATTEN está asociada al programa
P=(2,1, Q) cuyo código Q es:
(i=1,..,r)
Definimos la familia C como C = { I1, ..., Ir , ψ01}.
Nótese que
a) C es finita y tiene r+1 elementos;
b) C⊂CONS;
c) {I}⊂C.
Proposición 3. Sea f una W-función construible de
+
Z en Z+. Entonces f es XL(C)- programable.
FLATTEN;
begin
IF
X2=1
THEN
X1:=FUZZ1(X1)
IF
X2=2
THEN
X1:=FUZZ2(X1)
FI;
FI;
.............
IF X2=r THEN X1:=FUZZr(X1) FI
end
Las W-funciones asociadas a FUZZi (i=1,..,r) son Ii.
Una demostración formal de la equivalencia de este
programa con la W-función f es tediosa. En lugar de
ella, mostraremos cuáles son las configuraciones al
principio, en un punto intermedio, y al final del cómputo
de P3 aplicado a un ejemplo. Señalemos primeramente
el papel de cada variable de P3:
X1: almacena la entrada y la salida (línea 18).
X2: almacena el valor de sf(X1) y controla el ciclo
principal (2-13)
X3: toma todos los valores desde 0 a sf(X1); aquellos
con f(X1,X3)_0 constituyen la salida.
X4: almacena el grado f(X1,X3) codificado como un
entero positivo.
X5: almacena 0 ó 1 para controlar una bifurcación.
X6:almacenamiento auxiliar para la salida.
Ejemplo 1. Sea f una W-función construible
+
f:Z ×Z+→W tal que para el argumento 9 la imagen es:
f(9,0)=0, f(9,1)=0, f(9,2)=l4, f(9,3)=l6, f(9,4)=l1,
f(9,5)=0, f(9,6)=l3, para todo x>6, f(9,x)=0 . Mostremos
que fP (9)=f(9).
La configuración inicial es: 1/(9,0,0,0,0,0)
Tras ejecutar 1, es 1/(9,6,0,0,0,0)
Ahora, el bucle definido (2-13) se repite 6 veces para
X3=0,..,5 (instrucción 12). El valor final de X3 es 6.
Según 3, X5=0≠1, por tanto se ejecuta 4; ya que
f(9,0)=0, la configuración no se cambia. Puesto que
X4=0, la siguiente sentencia debe ser 12, cuya ejecución
produce
1/(9,6,1,0,0,0)
y volvemos a 3. Como f(9,1)=0, el proceso se repite y
tras 12 tenemos:
1/(9,6,2,0,0,0)
De nuevo en 3, se tiene que X5≠1, se ejecuta 4, se
calcula para X4 el valor 4 (que codifica el grado l4), y la
configuración queda:
1/(9,6,2,4,0,0)
Ahora, en 5 se tiene queX4≠0, se ejecuta 6 y queda:
1/(9,6,2,4,1,0) + 1/(9,6,2,4,0,0)
La condición de 7 (X5=1) es satisfecha por la primera
configuración elemental y tras ejecutar 8 queda:
l4/(9,6,2,4,1,2) + 1/(9,6,2,4,0,0)
Sólo X3 cambiará en la primera configuración
elemental; sin embargo, el grado y el valor de X6 no
cambian. Ahora es la segunda configuración elemental
la que cambia. Tras 12 tenemos:
l4/(9,6,3,4,1,2) + 1/(9,6,3,4,0,0)
Para X5≠1, tras la ejecución de 4, X4 almacena el valor
6 (que codifica el valor l6), y tenemos:
l4/(9,6,3,4,1,2) + 1/(9,6,3,6,0,0)
X4≠0, y tras ejecutar 6 tenemos:
l4/(9,6,3,4,1,2) + 1/(9,6,3,6,1,0)+ 1/(9,6,3,6,0,0)
Para la segunda configuración elemental X5=1, luego la
línea 8 se ejecuta dando:
l4/(9,6,3,4,1,2) + l6/(9,6,3,6,1,3)+ 1/(9,6,3,6,0,0)
Tras la siguiente ejecución del ciclo tendremos:
l4/(9,6,4,4,1,2) + l6/(9,6,4,6,1,3)+ l1/(9,6,4,1,1,4) +
1/(9,6,4,1,0,0)
Ahora X3 se incrementa en 12, y será:
l4/(9,6,5,4,1,2) + l6/(9,6,5,6,1,3)+ l1/(9,6,5,1,1,4) +
1/(9,6,5,1,0,0)
Sólo la última configuración satisface X5≠1. Tras 4 será:
l4/(9,6,5,4,1,2) + l6/(9,6,5,6,1,3)+ l1/(9,6,5,1,1,4) +
1/(9,6,5,0,0,0)
y X4≠0 no se satisface; la línea 12 se ejecuta y la
configuración queda:
l4/(9,6,6,4,1,2) + l6/(9,6,6,6,1,3)+ l1/(9,6,6,1,1,4) +
1/(9,6,6,0,0,0)
El bucle principal (2-13) se ha ejecutado 6 veces; en
la línea 14 se cumple que X5≠1 en la última
configuración elemental. Se ejecuta la línea 15 y
tenemos:
l4/(9,6,6,4,1,2) + l6/(9,6,6,6,1,3)+ l1/(9,6,6,1,1,4) +
1/(9,6,6,3,0,0)
Tras 16 obtenemos:
l4/(9,6,6,4,1,2) + l6/(9,6,6,6,1,3)+ l1/(9,6,6,1,1,4) +
l3/(9,6,6,3,0,6)
Finalmente, tras 18:
l4/(2,6,6,4,1,2) + l6/(3,6,6,6,1,3)+ l1/(4,6,6,1,1,4) +
l3/(6,6,6,3,0,6)
La única variable de salida es X1 y por tanto la
salida del programa es
l4/2 + l6/3+ l1/4 + l3/6
Por
tanto
fP(9,2)=l4,
fP(9,3)=l6,
fP(9,4)=l1,
fP(9,6)=l3; y en otro caso fP(9,x)=0; el programa
produce los mismos valores que f para entrada 9.
Proposición 4.-CONS ⊆ FT(XL(C))
Demostración: Sea f una W-función construible de
+
(Z )n en (Z+)k. Consideremos las codificaciones de
Cantor (vd. por ejemplo [9]) cn: (Z+)n → Z+ y ck:(Z+)k
→ Z+ . Tanto estas como sus inversas son funciones
recursivas nítidas. Entonces podemos considerar f' de Z+
en Z+ definida por f'(x,y)=f(cn-1(x),ck-1(y)).
Obviamente, f' es una función construible y por el
teorema 4, f' es XL(C)-programable, por tanto f(u,v) =
f'(cn(u),ck(v)) es también XL(C)-programable, es decir,
f∈F(XL(C)). Puesto que toda f∈CONS es total,
f∈FT(XL(C))
Ahora probaremos la inclusión contraria, es decir,
que FT(XL(C))⊆ CONS. Para cada programa P,
mostraremos una máquina equivalente M, en el sentido
de la definición 7 (lema 4). La prueba del lema 4 se hará
por inducción estructural sobre P, a partir de los
programas con una sola instrucción (lema 3), simulando
la secuencia (lema 1) y el anidamiento (lema 2). Puesto
que los ciclos “repeat ... times” pueden sustituirse con
ciclos “while”, consideraremos únicamente éstos.
Lema 1. Sea P1 un k-programa en XL con código
P1; begin B1 end.
Sea P2 un k-programa en XL con código
P2; begin B2 end.
Supongamos que hay dos W-máquinas T1 y T2
equivalentes respectivamente a P1 y P2. Entonces hay
una máquina T equivalente al XL-programa P cuyo
código es
P12;begin B1;B2 end
Demostración: Sea Ti=(V,Si,pi,s0i) (i=1,2) la W-MT
equivalente al programa Pi.
Entonces la W-TM T=(V,S,p,s0) se define como
sigue:
S=S1 ∪ S2
p(q,c,c',q') = p1(q,c,c',q')
si q,q’∈S1 y q'_h
p(q,c,c',s02)= p1(q,c,c',h)
si q∈S1
p(q,c,c',q') = p2(q,c,c',q')
si q,q’∈S2
s0=s01
Las transiciones de T son, aproximadamente, las de
T1 más las de T2: sin embargo, en las transiciones de
parada de T1, h se sustituye por s02. T comienza en el
estado inicial de T1; opera como T1 hasta que T1 se
pararía (simulando así P1); luego opera como T2
(simulando así P2). Es fácil verificar que T es
equivalente a P.
En lo sucesivo, la máquina T así definida se
representará por T1oT2 (T1 concatenada con T2)
Lema 2. Sea P1 un k-programa en XL con código
P1; begin B1 end.
Supongamos una máquina T1 equivalente a P1.
Entonces hay una máquina T equivalente al k-program P
cuyo código es
P1i; begin while Xi_0 do B1 od end
Demostración: Sea T1=(V,S1,p1,s01) la W-MT
equivalente al programa P1. Entonces la W-TM
T=(V,S,p,s0) se define como sigue:
S= S1 ∪ {s0, s’},
(s0, s’∈S1)
p(s0,#(i), L(i), s’)=1
p(s’,|(i),R(i),s01)=1
p(s’,#(i),R(i),h)=1
p(q,c,c’,q’)= p1(q,c,c’,q’)
si q,q’∈S1 y q'_h
p(q,c,c’,s0)= p1(q,c,c’,h)
si q∈S1
Es decir, T comprueba si el contenido de la i-ésima cinta
es _0; en ese caso, el estado de T es el estado s01 -estado
inicial de T1- y T opera como T1 hasta que T1 se
hubiera parado, sustituyendo el estado de parada h por el
estado inicial s0; en otro caso, T se para. Evidentemente,
T y P son equivalentes : T termina sii P se para y, si P se
para, la descripción final alcanzada por T es equivalente
a la configuración final de P tras la ejecución de
begin while Xi_0 do B1 od end
En lo sucesivo, la máquina T así definida se representará
por w(T,i).
Lema 3. Para todo programa P sin bucles, hay una
W-TM equivalente.
Demostración:
Consideremos
primeramente
programas de una instrucción, y posteriormente
secuencias de instrucciones. Supongamos que P es
ident; begin <asignación> end
y <asignación> es Xi:=0. T es equivalente a P:
T=(V,S,p,s0),
S = {s0, s1, s2 },
y p se define como sigue:
p(s0, #(i), L(i), s1) = 1 p(s1, |(i), #(i), s2)= 1
p(s1, #(i), #(i), h) = 1 p(s2, #(i), L(i), s1)=1
Supongamos ahora que <asignación> es
Xi:=suc(Xj); la máquina T definida más abajo es
equivalente al programa P:
T=(V,S,p,s0), S = {s0, ..., s6 }
p(s0, #(i), L(i), s1) = p(s1, |(i), #(i), s2) =1
p(s1, #(i), #(i), s3) = 1 p(s2, #(i), L(i), s1)=1
p(s3, #(j), L(j), s4)= 1 p(s4, #(j), R(j),s5)=1
p(s4, |(j), L(j), s4) = 1 p(s5, |(j), |(i), s6) =1
p(s5, #(j), |(i), s6) = 1 p(s6, |(j), R(i,j),s5)=1
p(s6, |(i), R(i), h) = 1
Las primeras 4 líneas borran la i-ésima cinta. Las
transiciones con estados s3 y s4 ponen la máquina al
comienzo del contenido aj de la j-ésima cinta. Las
transiciones con estados s5 y s6 copian el contenido de
la j-ésima cinta en la i-ésima. Finalmente, otro "|" se
escribe en la i-ésima cinta.
Sea ahora <asignación> Xi:=FUZZ0(Xj).
Recordemos que la función asociada a FUZZ0 es ψ01.
La máquina T es equivalente a P:
T=(V,S,p,s0), S = {s0, ..., s3 }
p(s0, #(i), L(i), s1) = 1 p(s1, |(i), #(i), s2) =1
p(s1, #(i), #(i), h) = 1 p(s1, #(i), |(i), s3) =1
p(s2, #(i), L(i), s1) = 1 p(s3, |(i), R(i), h) =1
La W-función ψ01 siempre produce las imágenes 0
(grado 1) y 1 (grado 1). En efecto, T borra la i-ésima
cinta y entonces a) se para con grado 1 y b) escribe un
solo "|" y se para con grado 1.
Supongamos ahora que <asignación> es
Xi:=FUZZk(Xj). Recordemos que la W-función
asociada a FUZZk is Ik. La máquina T es equivalente a
P:
T=(V,S,p,s0), S = {s0, ..., s6 }
p(s0, #(i), L(i), s1) = 1 p(s1, |(i), #(i), s2) =1
p(s1, #(i), #(i), s3) = 1 p(s2, #(i), L(i), s1)=1
p(s3, #(j), L(j), s4)= 1 p(s4, #(j), R(j),s5)=1
p(s4, |(j), L(j), s4) = 1 p(s5, |(j), |(i), s6) =1
p(s5, #(j), #(i), h) = lk p(s6, |(j), R(i,j),s5)=1
La W-función Ik produce x (grado lk) con entrada x.
En efecto, las únicas acciones que T realiza son copiar xj
en la i-ésima cinta y pararse con grado lk.
Supongamos ahora que P es
<ident>;
begin
<asignación>;
...
<asignación>;
end
Nótese que basta probar el lema para secuencias de
dos instrucciones. Pero por el lema 1 ello está probado.
Por consiguiente, el lema 3 está también demostrado.
Lema 4. Para todo XL(C)-programa existe una WTM equivalente.
Demostración: Supongamos que el programa no tiene
bucles anidados. Por el lema 3, tal máquina existe.
Supongamos que la proposición es verdadera para
todos los programas con bucles anidados b o menos
niveles. Debemos demostrar que el teorema es verdadero
para los programas con b+1 niveles de anidamiento. Sea
P uno de ellos; P puede escribirse como
<ident>; begin S1; S2 ;... Sn end
donde cada Si es o una asignación o un bucle
while Xi_0 do Qi od
y el programa Pi
<ident> begin Qi end
tiene bucles anidados a b o menos niveles. Si Si es una
asignación entonces, por el lema 3, hay una máquina Mi
equivalente a
<ident> begin Si end
si Si es un bucle while, entonces, por el lema 2 y la
hipótesis de inducción, hay también una máquina
Ti=w(T,i) equivalente a
<ident> begin while Xi_0 do Qi od end.
En cualquier caso, un razonamiento similar al del lema 1
muestra que T=T1oT2o...oTn es equivalente a P.
Proposición 5. FT(XL(C))⊆ CONS
Demostración: Sea f una W-función de FT(XL(C)).
Por el lema 4, hay una W-TM M equivalente a P. Como
f es total, P termina con cualquier entrada. Por tanto, M
se para siempre en un número finito de pasos y
f∈CONS.
5. Caracterización de la clase WRG mediante
programas XL.
Definiremos una familia finita de W-funciones G y
probaremos que es suficiente para programar cualquier
función f∈WRG.
Definición 9. Sean I1, ..., Ir las W-funciones de Z+
en Z+ de la definición 10, y sea ψ∞ la siguiente Wfunción de Z+ en Z+: ∀x,y∈Z+ ψ∞(x,y)=1.
La familia G es G = { I1, ..., Ir , ψ∞ }
Nótese que
a) G es finita y tiene r+1 elementos;
b) G⊂WRG;
c) {I}⊂G
Proposición 6. Sea f una W-función con grafo recursivo
de Z+ en Z+. Entonces, f es XL(G)- programable.
Demostración: Sea f una W-función con grafo
recursivo; en ese caso, por la definición 9, f es una
función recursiva total de Z+× Z+ en W,, y existe un
XL({I}) programa que calcula f. Usando los mismos
identificadores de la sección anterior, el siguiente
XL(G)- programa P3=(1,1,Q3) calcula f:
P3;
begin
X3:= FUZZ0(X1);
X4:= P1(X1,X3);
X6:= FLATTEN(X3,X4);
X1:= X6
end
donde la única diferencia con la sección anterior es la
W-función asociada a FUZZ0, que es ψ∞ .
El papel jugado por las variables es el mismo; sin
embargo, nótese que X2 y X5 no se usan en el programa
y sus valores son 0 a lo largo de toda la ejecución. Sea
f(a,i)=ai∈W, i∈Z+.
Con entrada a, la configuración inicial es
1/(a,0,0,0,0,0). Tras la ejecución de X3:= FUZZ0(X1),
la configuración es:
1/(a,0,0,0,0,0) + 1/(a,0,1,0,0,0) + ...+ 1/(a,0,k,0,0,0)+
...
Entonces se ejecuta X4:= P1(X1,X3), produciendo
la configuración:
1/(a,0,0,n0,0,0)
+
1/(a,0,1,n1,0,0)
+
...+
1/(a,0,k,nk,0,0)+ ...
y tras ejecutar la siguiente instrucción X6:=
FLATTEN(X3,X4) tendremos:
a0/(a,0,0,n0,0,0) + a1/(a,0,1,n1,0,1) + ...+
ak/(a,0,k,nk,0,k)+ ...
Finalmente, se ejecuta X1:=X6 y la configuración
final es:
a0/(0,0,0,n0,0,0) + a1/(1,0,1,n1,0,1) + ...+
ak/(k,0,k,nk,0,k)+ ...
Por tanto, la W-función semántica asociada con P3,
fP:Z+×Z+→W, satisface fP(a,i)=ai = f(a,i) ,i∈Z+, es
decir, f =fP y f is XL(G)-programable.
Proposición 7.- WRG⊆ F(XL(G))
Demostración: Como en el corolario 1.
6 Conclusiones
En este trabajo estudiamos la caracterización mediante
programas de ciertas aproximaciones al concepto de "Wfunción calculable" anteriormente propuestas en la
literatura. Desde un punto de vista teórico, la
calculabilidad difusa es una materia algo compleja que
se ha tratado desde varios puntos de vista [3], [8],
algunos de ellos demasiado extensivos. En este trabajo
consideramos los dos enfoques más restringidos: la clase
WRG de G. Gerla [2] y nuestra clase CONS [5].
Considerando la familia de lenguajes de programación
XL(H) generada al restringir la asignación a funciones
de H, se han definido dos familias de funciones
F(XL(C)) y F(XL(G)) tales que C⊂CONS, CONS =
FT(XL(C)), y G ⊂ WRG, WRG ⊆ F(XL(G)).
Referencias
[1] Böhm, C., Jacopini, G., Flow diagrams, Turing
machines and languages with only two formation
rules. Comm. ACM 9 (1966), 366-371.
[2] Gerla, G., Turing L-Machines and Recursive Computability for L-Maps. Studia Logica XLVIII (2)
(1989), 179-192.
[3] Harkleroad, L., Fuzzy Recursion, Ret’s and Isols.
Zeitschr. f. math. Logik und Grundlagen d. Math, 30
(1984), 425-436.
[4] Morales-Bueno, R. et al., An elementary fuzzy
programming language. Fuzzy Sets and Systems 58
(1993), 55-73.
[5] Morales-Bueno, R. et al., Estudio de una clase de
W-funciones calculables, III Congreso Español
sobre Tecnologías y Lógica fuzzy, Santiago de
Compostela 1993, pp. 153-160.
[6] Morales-Bueno, R. et al., El lenguaje de programación borrosa XL, V Congreso Español sobre
Tecnologías y Lógica fuzzy, Murcia 1995.
[7] Odifreddi, P., Classical Recursion Theory. NorthHolland, 1992.
[8] Santos, E.S., Fuzzy algorithms. Inform. Contr. 17
(1970), 326-339.
[9] Sommerhalder, R., van Westrhenen, S.C., The
Theory of Computability. Addison-Wesley, 1988.
[10]Wang, H., A variant of Turing’s theory of
calculating machines. Journal ACM 4(1957) 63-92.