Download - EL MODELO DE DESPLEGAR/PLEGAR
1
EL MODELO DE DESPLEGAR/PLEGAR
Salwa Al Atassi GonzálezJosé Francisco Poveda GarcíaJosé Sosa García
2
INDICE
1. Parámetros acumuladores.2. Transformación de programas.3. El modelo Desplegar/Plegar.4. Reducción de la complejidad por
transformación.5. Corrección parcial de los programas
transformados.6. Ejercicios.
3
Parámetros Acumuladores
1.1 Definición.1.2 Números de Fibonacci.
1.2.1 Solución.1.2.2 Solución con parámetros acumuladores.
1.3 Plegados estrictos.1.3.1 Ejemplos.
4
Parámetros Acumuladores
Definición:
Son parámetros de una función donde se van almacenado soluciones parciales que se van utilizando en llamadas recursivas hasta llegar a la solución final.
5
Parámetros Acumuladores
Números de Fibonacci:Solución trivialfib :: Integer -> Integer
fib 0 = 1fib 1 = 1fib (n + 2) = fib (n + 1) + fib n
6
Parámetros Acumuladores
Números de FibonacciInconvenientes:
Repetición de Cálculos.
Las sumas quedan suspendidas.
7
Parámetros Acumuladores
fib 6=> fib(4+1) + fib4=> fib5 + fib4=> fib(3+1) + fib3 + fib4=> fib4 + fib3 + fib4=> fib(2+1) + fib2 + fib3 +fib4=> …
8
Parámetros Acumuladores
Solución con parámetros acumuladores:
fibAux y z 0 = y
fibAux y z (n + 1) = fibAux z (y+z) n
fib’ n = fibAux 1 1 n
9
Parámetros Acumuladores
Ventaja:
No se producen cálculos repetidos.
Inconveniente:
Con evaluación perezosa, las sumas quedan suspendidas.
10
Parámetros Acumuladores
Plegados estrictos:
Consiste en aprovechar parte del argumento de una función para representar el acumulador.
Esto es posible si el valor a devolver tiene el mismo tipo que cierta subexpresión del acumulador.
11
Parámetros Acumuladores
Ejemplos: Función Suma:
suma [] = 0suma [x] = xsuma (x:y:xs)= suma (x + y : xs)
Función Mayormayor [x] = xmayor (x : x’ : xs) = mayor (max x x’ : xs)
12
Transformación de Programas
2.1 Definición.2.2 Transformaciones.2.3 Ejemplo.
13
Transformación de Programas
Definición:
Se pretende la derivación de programas a partir de otros de forma que se conserve la corrección y se mejore la eficiencia.
14
Transformación de Programas
Transformaciones:
Una transformación consiste en sustituir una o varias ecuaciones por otras, sin alterar el significado global del programa.
15
Transformación de Programas
Ejemplo: Sea g una función que calcula la suma de los dobles de los números de una lista.
doble :: [Int]->[Int]suma, g :: [Int]->Intg xs = suma (doble xs)suma [] = 0suma (x:xs) = x + suma xsdoble [] = []doble (x:xs) = 2*x : doble xs
16
Aplicando transformaciones:
g[] Ξ{sustitución en la def. de g (instanciación)}suma(doble []) Ξ{desplegar la ecuación doble[]=[]}suma [] Ξ{desplegar la ecuación suma [] =0}0
Transformación de Programas
17
Transformación de Programas
Aplicando transformaciones II:
g (x:xs) Ξ {instanciación}suma (doble (x:xs)) Ξ {desplegar}suma(2*x : doble xs) Ξ{desplegar}2*x + suma (doble xs)Ξ{plegar g xs = suma (doble xs)}2*x + g xs
18
Transformación de Programas
La nueva versión de g es:
g [] = 0g (x:xs) = 2*x + g xs
19
El modelo Desplegar/Plegar
3.1 Introducción.3.2 Las reglas Desplegar/Plegar.3.3 Ejemplo de la Media.
20
El modelo Desplegar/Plegar
Introducción.
La metodología desplegar/plegar fue introducida por Burstall y Darlingtong en 1977.
Se basa en la transformación de programas para mejorar su eficiencia.
21
El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar.
Definición: Introduce una ecuación para definir una nueva función o extenderla.
Instanciación: Obtiene una nueva ecuación sustituyendo expresiones particulares en las variables de la cabeza de una ecuación.
22
El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar. Desplegar la ecuación F = F’ a través
de la ecuación E = E’ significa sustituir la aparición de E en F’ por E’, resultando la nueva ecuación:
F = [E := E’] F’En definitiva, desplegar es reemplazar miembros izquierdos por miembros derechos.
23
El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar. Plegar la ecuación F = F’ con la
ecuación E = E’ significa sustituir la aparición de E’ en F’ por E, resultando la nueva ecuación:
F = [E’:= E ] F’En definitiva, plegar es reemplazar miembros derechos por miembros izquierdos.
24
El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar. Abstracción: Introduce una expresión
cualificada partiendo de una ecuaciónE = E’ transformándola en la nueva ecuación:
E = [ u1, … , un := F1, … , Fn] E’where
(u1, … , un) = (F1, … , Fn)
25
Ejemplo de la media de una lista:
media :: [Int]->Intmedia xs = suma xs `div` nDatos xssuma :: [Int]->Intsuma [] = 0suma (x:xs) = x + suma xsnDatos :: [Int]->IntnDatos [] = 0nDatos (x:xs) = 1 + nDatos xs
El modelo Desplegar/Plegar
26
El modelo Desplegar/Plegar
Introducimos una función:
sYn :: [Int]->(Int, Int)esta función calcula la suma y el número
de elementos de la lista.
Aplicando las reglas D/P:sYn xs Ξ {definición}(suma xs, nDatos xs)
27
El modelo Desplegar/PlegarEntonces:sYn [] Ξ {Instanciación}(suma [], nDatos []) Ξ {Desplegar}(0,0)
sYn (x:xs) Ξ {Instanciación}(suma (x:xs), nDatos (x:xs)) Ξ {desplegar}(x + suma xs, 1 + nDatos xs) Ξ{abstracción}(x + u, 1 + v) where (u,v) =
(suma xs, nDatos xs) Ξ {plegar}(x + u, 1 + v) where (u,v) = sYn xs
28
El modelo Desplegar/Plegar
Hemos obtenido 2 ecuaciones para la función sYn:sYn [] = (0,0)sYn (x:xs) = (x+u, 1+v) Where (u,v)= sYn xs
Ahora es trivial el cálculo de la media:media xs Ξ{desplegar} suma xs `div` nDatos xs Ξ {abstracción}u `div` v Where (u, v)=
(suma xs, nDatos xs) Ξ {plegar}u `div` v Where (u,v)= sYn xs
29
El modelo Desplegar/Plegar
y finalmente, el programa equivalente es:
media :: [Int]-> Intmedia xs = u `div` v Where (u,v)= sYn xssYn :: [Int]-> (Int, Int)sYn[] = (0,0)sYn (x: xs) = (x+u, 1+v) Where (u,v) = sYn xs
30
Reducción de la complejidad por transformación
4.1 Caso Fibonacci.4.2 Estudio “Mínimo de la lista”.
4.2.1 Corrección de la solución.4.2.2 La solución de Pettorossi- Skowron.
31
Reducción de la complejidad por transformación
Caso Fibonacci: En este ejemplo esta metodología hace una reducción de complejidad exponencial a lineal.
fib :: Int->Intfib 0 = 1fib 1 = 1fib (n+2) = fib (n+1) + fib n
32
Reducción de la complejidad por transformación
Si introducimos la función:g n Ξ {definición}(fib (n+1), fib n)tendremos:fib n = v where (u, v) = g n
Aplicando D/P:g 0 Ξ {instanciación}(fib 1, fib 0) Ξ {desplegar}(1, 1)
33
Reducción de la complejidad por transformación
g (n +1) Ξ {instanciación}(fib (n+2), fib (n+1)) Ξ {desplegar}(fib (n+1)+ fib n, fib (n+1)) Ξ{abstracción}(u+v, u) where (u,v) = (fib (n+1), fib n) Ξ {plegar}(u+v, u) where (u,v) = g n
34
Reducción de la complejidad por transformación
Y finalmente el programa equivalente:
fib :: Int -> Intfib n = v where (u,v) = g ng :: Int -> (Int, Int)g 0 = (1,1)g(n+1) = (u+v, u) where (u,v) = g n
35
Reducción de la complejidad por transformación
Estudio “mínimo de una lista”: Dada una lista, sustituir todos sus elementos por el mínimo de la lista.
36
Reducción de la complejidad por transformación
lmin :: Ord a => [a] -> [a]minl :: Ord a => [a] -> aminl [x] = xminl (x:xs) = min x (minl xs) reemplaza :: a-> [a]-> [a]reemplaza _ [] = []reemplaza m (_ : xs)= m : reemplaza m xslmin xs = reemplaza (minl xs) xs
37
Reducción de la complejidad por transformaciónVeamos una propiedad de la función mínimo:
minl (x:x’:xs) = minl((min x x’): xs)
En efecto:
minl (x:x’:xs) Ξ {desplegar}min x (minl (x’:xs)) Ξ {desplegar}min x (min x’ (minl xs)) Ξ {asociatividad de min}min (min x x’) (minl xs) Ξ {plegar}minl ((min x x’) : xs)
38
Reducción de la complejidad por transformación
Simplificando:lmin (x:x’:xs) Ξ {desplegar}reemplaza (minl (x:x’:xs)) (x:x’:xs)
Ξ {instanciación de reemplaza dos veces}
minl (x :x’:xs) : minl (x:x’:xs) : reemplaza(minl (x:x’:xs)) xs Ξ {abstracción}
m:m:u Where m : u = minl (x:x’:xs) :reemplaza(minl(x:x’:xs))
39
Reducción de la complejidad por transformación
Eliminación de las funciones reemplaza y minl:minl(x:x’:xs): reemplaza (minl(x:x’:xs))xs
Ξ {propiedad del mínimo anterior}minl((min x x’):xs):
reemplaza (minl((min x x’):xs))xs Ξ {instanciación de reemplaza}reemplaza (minl ((min x x’): xs)) ((min x x’) : xs)
Ξ {instanciación de lmin}lmin ((min x x’): xs)
40
Reducción de la complejidad por transformación
Finalmente obtenemos:
lmin [x] = [x]lmin (x: x’: xs) = m:m:u Where m:u =
lmin((min x x’) : xs)
41
Reducción de la complejidad por transformación
Corrección de la soluciónPara demostrar la corrección de la función anterior, probaremos el predicado:
Para todo xs . xs::[a], xs ≠ [] .(cabeza(lmin xs) = minl xs) ^ ti(lmin xs)
Donde ti (test igualdad) comprueba que todos los elementos de la lista son iguales:
ti :: Eq a => [a] ->Boolti[x] = Trueti(x:x’:xs)= x==x’ && ti (x´:xs)
42
Reducción de la complejidad por transformación
Probaremos (correc) por inducción sobre lista no vacía xs: Caso Base (xs = [x]):trivial. Paso Inductivo: Supongamos que Para todo x, xs
. x::a, xs::[a](hi) cabeza(lmin(x:xs)) =minl(x:xs) ^ ti(lmin(x:xs))
Entonces:
cabeza (lmin (x:x’:xs)) Ξ cabeza (m:m:u)
where m:u = lmin((min x x’):xs)
43
Reducción de la complejidad por transformación
Cabeza (lmin((min x x’) : xs)) Ξ {hipótesis de inducción}
minl ((min x x’) : xs) Ξ {minl dos veces y asociatividad de min}minl (x: x’:xs)
ti (lmin (x:x’:xs)) Ξ {lmin}ti (m:m:u)
where m:u = lmin ((min x x’):xs) Ξ {ti}
m==m && ti (m:u) where m:u = lmin ((min x x’):xs) Ξ
44
Reducción de la complejidad por transformación
ti (m:u) where m:u = lmin ((min x x’):xs) Ξ ti (lmin ((min x x’):xs) Ξ{propiedad mínimo, hipótesis inducción}Cierto
45
Reducción de la complejidad por transformación
La solución de Pettorossi-SkowronSea la función:
fmin:: Ord a => [a]-> (a, a->[a])lmin’ xs =f m Where (m, f) = fmin xs
Comportamiento de fmin:fmin [x] = (x, λy->[y])fmin (x:xs) =(min x m, λy->y: f y)
Where(m, f) = fmin xs
46
Reducción de la complejidad por transformación
La corrección de la función lmin’ se puede hacer, bien demostrando (por inducción estructural) que lmin xs = lmin’ xs, o bien demostrando,
para todo xs . xs:: [a], xs ≠ []. (cabeza(lmin’ xs)=minl xs)^(ti(lmin’ xs))
En caso Base es trivial; hi:cabeza(lmin’ x:xs) = minl (x:xs) ^ ti(lmin’ x:xs))
por otro lado tenemos:
47
Reducción de la complejidad por transformación
lmin’ (x:x´:xs) Ξ {lmin’ y fmin dos veces}min x (min x´m) : min x (min x´m) :
g(min x (min x´m)) where (m, g) = fmin xs
De donde el paso inductivo sería:
cabeza (lmin´(x: x´:xs)) Ξ cabeza (min x (min x´m))
where (m, g) = fmin xs Ξ {asociatividad de min}
cabeza (min (min x x´) m´)where (m´, _)=fmin xs Ξ {lmin´y
fmin}
48
Reducción de la complejidad por transformación
cabeza (lmin´(min x x´):xs) Ξ{hipótesis inducción}
minl ((min x x´) :xs) Ξ {minl}min(min x x´) (minl xs) Ξ {minl dos veces y asociatividad de min}minl(x:x´:xs)
49
Reducción de la complejidad por transformación
Por otra parte:
ti(lmin´(x:x´:xs)) Ξ { por def. anterior}ti (min x (min x´m): min x (min x’ m):
g (min x (min x´m) ) ) where(m,g) = fmin xs
Ξ{lmin´y asociatividad de min}
ti (lmin´((min x x´) : xs)) Ξ {propiedad mínimo, hipótesis inducción}Cierto
50
Corrección parcial de los programas transformados
Las reglas D/P NO transforman programas correctos parcialmente (totalmente) en programas correctos.
Ejemplo:f x= x
Al plegar obtenemos la ecuación:f x = f x
51
Ejercicios
Ejemplo que sustituye en una lista todos los elementos por el último y demostración de su corrección, utilizando el método de Pettorosi-Skowron.ultl : Ord a => [a] -> a
ultl [x]=xultl [x:xs] = seg x (ultl xs)reemplaza ::a -> [a] -> [a]
52
Ejercicios
reemplaza _ []= []reemplaza m (_:xs) = m :reemplaza m xslult xs =reemplaza (ultl xs) xs
ultl (x:x’:xs) = ultl ((seg x x’):xs) Ξ{desplegar} seg x (ultl (x’: xs)) Ξ{desplegar}
seg x (seg x’(ultl xs)) Ξ{asociatividad de seg}seg (seg x x’) (ultl xs) Ξ{plegar}ultl ((seg x x’):xs)
53
Ejercicios
lult (x:x’:xs) Ξ{desplegar}reemplaza (ultl(x:x’:xs)) (x:x’:xs) Ξ{instanciación de reemplaza dos veces}ultl(x:x’:xs):ultl(x:x’:xs):reemplaza(ultl (x:x’:xs))xs Ξ{abstracción}m:m:u where m:u =ultl(x:x’:xs):reemplaza (ultl(x:x’:xs))xs
ultl(x:x’:xs):reemplaza (ultl(x:x’:xs))xs Ξ{propiedad de ultl}
54
Ejercicios
ultl((seg x x’):xs):reemplaza(ultl((seg x x’):xs)) xs
Ξ{instanciación de reemplaza}reemplaza (ultl((seg x x’):xs))((seg x x’):xs) Ξ{instanciación de lult}lult((seg x x’):xs)
lult[x]=[x]lultl (x:x’:xs)= m:m:u where m:u =lult ((seg x x’):xs)
55
Ejercicios
Sea la función:long ::[a] -> Intlong[] = 0long (_:xs)=1 + long xs
Vamos a utilizar la técnica de D/P para transformar el programa anterior en uno más eficiente utilizando una función con un acumulador: long’::[Int]->Int->Inttal que no deje sumas suspendidas.
56
Ejercicios
Demostrar su corrección , probando que:long’ xs n = long xs +n
Considerando la definiciónlong’ xs n = long xs + n
que podemos transformar según:
long’ [] n Ξ {desplegar}long [] + n Ξ {desplegar long}n
57
Ejercicios
long’ (x:xs) n Ξ {desplegar}long (x:xs) +n Ξ {desplegar long}1+ long xs +n Ξ {asociatividad y conmutación}long xs + (n+1) Ξ {plegar}long’ xs (n+1)
de donde hemos eliminado la función long:
long’ [] n = nlong’ (x:xs) n = long’ xs (n+1)
58
Ejercicios
que introducimos en la forma:
long xs =long’ xs 0
La corrección es trivial.
59
Ejercicios Sustituir en un árbol binario todas sus
apariciones por la mayor en una sola pasada.
Solución al ejercicio en el fichero adjunto Ejercicio1620.hs
La solución a este ejercicio está basada en el método de Pettorossi-Skowron donde nos basamos en una función auxiliar fmax, que dado un árbol devuelve un par formado por un elemento y una función. Dicha función va reconstruyendo una estructura de árbol idéntica a la original y en cuyos nodos aparecen el elemento que se le pasa, en este caso el máximo de los nodos.
60
Anexo I Dada una función
f(0)=15, f(1)=3, f(2)=8, f(3)=1 f(n+4) = f(n+3) + f(n+2) + f(n+1) + f(n)La solución utilizando parámetros
acumuladores en Haskell es la siguiente:f x y z k 0 = xf x y z k (n+1) = f y z k (x+y+z+k) nLa llamada a esta función con n=5 sería:f 15 3 8 1 5
61
Anexo I
Al igual que en la función fibonacci con parámetros acumuladores, la función anterior no hace repetición de cálculos pero si que siguen quedando las sumas suspendidas.
62
Anexo II Corrección de la solución de la
función lult. La corrección de la solución para la función
lult se hace demostrando el siguiente predicado:Para todo xs . xs::[a], xs ≠ []
(cabeza (lult xs) = ultl xs) ^ (ti (lult xs))Donde:ultl :: [a]->aultl [x] = xultl (x:xs) = ultl xs
63
Anexo II
Corrección de la solución de la función lult.
Una vez definido el predicado y las funciones que se usan en el mismo, la demostración se hace de forma similar a la vista en el ejercicio de la corrección de lmin.
64
Anexo III Comportamiento en memoria de la doble
llamada recursiva realizada por la función lmin:minl (x:xs) = min x (minl xs)
reemplaza m (_:xs)= m:reemplaza m xs
lmin xs = reemplaza (minl xs) xs *
La lista tan solo es recorrida una vez, al contrario de lo que se podría pensar, debido al comportamiento de m:reemplaza.
* Ejemplo de sustitución de todos los elementos de una lista por su mínimo, pág 35
65
Bibliografía
“Razonando con Haskell” un curso sobre programación funcional; Blas C. Ruiz, Francisco Gutiérrez, Pablo Guerrero, José E. Gallardo