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


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


Números de Fibonacci:Solución trivialfib :: Integer -> Integer

fib 0 = 1fib 1 = 1fib (n + 2) = fib (n + 1) + fib n

6


Números de FibonacciInconvenientes:

Repetición de Cálculos.

Las sumas quedan suspendidas.

7


fib 6=> fib(4+1) + fib4=> fib5 + fib4=> fib(3+1) + fib3 + fib4=> fib4 + fib3 + fib4=> fib(2+1) + fib2 + fib3 +fib4=> …

8


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


Ventaja:

No se producen cálculos repetidos.

Inconveniente:

Con evaluación perezosa, las sumas quedan suspendidas.

10


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


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


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


Transformaciones:

Una transformación consiste en sustituir una o varias ecuaciones por otras, sin alterar el significado global del programa.

15


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


17


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


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


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


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


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


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


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


26


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


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


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


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


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


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


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


Estudio “mínimo de una lista”: Dada una lista, sustituir todos sus elementos por el mínimo de la lista.

36


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


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


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


Finalmente obtenemos:

lmin [x] = [x]lmin (x: x’: xs) = m:m:u Where m:u =

lmin((min x x’) : xs)

41


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


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


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


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


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


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


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


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


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

Documents

EL MODELO DE DESPLEGAR/PLEGAR