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