EL MODELO DE DESPLEGAR/PLEGAR

Salwa Al Atassi Gonzlez Jos Francisco Poveda Garca Jos Sosa Garca

INDICE
1. 2. 3. 4. Parmetros acumuladores. Transformacin de programas. El modelo Desplegar/Plegar. Reduccin de la complejidad por transformacin. 5. Correccin parcial de los programas transformados. 6. Ejercicios.
2

Parmetros Acumuladores
1.1 Definicin. 1.2 Nmeros de Fibonacci. 1.2.1 Solucin. 1.2.2 Solucin con parmetros acumuladores. 1.3 Plegados estrictos. 1.3.1 Ejemplos.
3

Parmetros Acumuladores
Definicin:
Son parmetros de una funcin donde se van almacenado soluciones parciales que se van utilizando en llamadas recursivas hasta llegar a la solucin final.

Parmetros Acumuladores
Nmeros de Fibonacci: Solucin trivial
fib fib fib fib :: Integer -> Integer 0=1 1=1 (n + 2) = fib (n + 1) + fib n

Parmetros Acumuladores
Nmeros de Fibonacci Inconvenientes:
Repeticin de Clculos. Las sumas quedan suspendidas.

Parmetros Acumuladores
fib 6 => fib(4+1) + fib4 => fib5 + fib4 => fib(3+1) + fib3 + fib4 => fib4 + fib3 + fib4 => fib(2+1) + fib2 + fib3 +fib4 =>
7

Parmetros Acumuladores
Solucin con parmetros acumuladores:
fibAux y z 0 = y fibAux y z (n + 1) = fibAux z (y+z) n fib n = fibAux 1 1 n

Parmetros Acumuladores
Ventaja:
No se producen clculos repetidos.

Inconveniente:
Con evaluacin perezosa, quedan suspendidas. las sumas

Parmetros Acumuladores
Plegados estrictos:
Consiste en aprovechar parte del argumento de una funcin para representar el acumulador. Esto es posible si el valor a devolver tiene el mismo tipo que cierta subexpresin del acumulador.
10

Parmetros Acumuladores
Ejemplos:
Funcin Suma:
suma [] = 0 suma [x] = x suma (x:y:xs)=

suma (x + y : xs)

Funcin Mayor
mayor [x] = x mayor (x : x : xs) = mayor (max x x : xs)
11

Transformacin de Programas
2.1 Definicin. 2.2 Transformaciones. 2.3 Ejemplo.

12

Transformacin de Programas
Definicin:
Se pretende la derivacin de programas a partir de otros de forma que se conserve la correccin y se mejore la eficiencia.

13

Transformacin de Programas
Transformaciones:
Una transformacin consiste en sustituir una o varias ecuaciones por otras, sin alterar el significado global del programa.

14

Transformacin de Programas
Ejemplo: Sea g una funcin que calcula la suma de los dobles de los nmeros de una lista.
doble :: [Int]->[Int] suma, g :: [Int]->Int g xs = suma (doble xs) suma [] = 0 suma (x:xs) = x + suma xs doble [] = [] doble (x:xs) = 2*x : doble xs
15

Transformacin de Programas
Aplicando transformaciones:
g[] {sustitucin en la def. de g (instanciacin)} suma(doble []) {desplegar la ecuacin doble[]=[]} suma [] {desplegar la ecuacin suma [] =0} 0
16

Transformacin de Programas
Aplicando transformaciones II:
g (x:xs) {instanciacin} 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
17

Transformacin de Programas
La nueva versin de g es:

g [] = 0 g (x:xs) = 2*x + g xs

18

El modelo Desplegar/Plegar
3.1 Introduccin. 3.2 Las reglas Desplegar/Plegar. 3.3 Ejemplo de la Media.

19

El modelo Desplegar/Plegar
Introduccin.
La metodologa desplegar/plegar fue introducida por Burstall y Darlingtong en 1977. Se basa en la transformacin de programas para mejorar su eficiencia.

20

El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar.
Definicin: Introduce una ecuacin para definir una nueva funcin o extenderla. Instanciacin: Obtiene una nueva ecuacin sustituyendo expresiones particulares en las variables de la cabeza de una ecuacin.
21

El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar.
Desplegar la ecuacin F = F a travs de la ecuacin E = E significa sustituir la aparicin de E en F por E, resultando la nueva ecuacin: F = [E := E] F En definitiva, desplegar es reemplazar miembros izquierdos por miembros derechos.
22

El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar.
Plegar la ecuacin F = F con la ecuacin E = E significa sustituir la aparicin de E en F por E, resultando la nueva ecuacin: F = [E:= E ] F En definitiva, plegar es reemplazar miembros derechos por miembros izquierdos.
23

El modelo Desplegar/Plegar
Las reglas Desplegar/Plegar.
Abstraccin: Introduce una expresin cualificada partiendo de una ecuacin E = E transformndola en la nueva ecuacin: E = [ u1, , un := F1, , Fn] E where (u1, , un) = (F1, , Fn)

24

El modelo Desplegar/Plegar
Ejemplo de la media de una lista:
media :: [Int]->Int media xs = suma xs `div` nDatos xs suma :: [Int]->Int suma [] = 0 suma (x:xs) = x + suma xs nDatos :: [Int]->Int nDatos [] = 0 nDatos (x:xs) = 1 + nDatos xs
25

El modelo Desplegar/Plegar
Introducimos una funcin: sYn :: [Int]->(Int, Int) esta funcin calcula la suma y el nmero de elementos de la lista. Aplicando las reglas D/P: sYn xs {definicin} (suma xs, nDatos xs)

26

El modelo Desplegar/Plegar
Entonces: sYn [] {Instanciacin} (suma [], nDatos []) {Desplegar} (0,0) sYn (x:xs) {Instanciacin} (suma (x:xs), nDatos (x:xs)) {desplegar} (x + suma xs, 1 + nDatos xs) {abstraccin} (x + u, 1 + v) where (u,v) = (suma xs, nDatos xs) {plegar} (x + u, 1 + v) where (u,v) = sYn xs
27

El modelo Desplegar/Plegar
Hemos obtenido 2 ecuaciones para la funcin sYn: sYn [] = (0,0) sYn (x:xs) = (x+u, 1+v) Where (u,v)= sYn xs

Ahora es trivial el clculo de la media: media xs {desplegar} suma xs `div` nDatos xs {abstraccin} u `div` v Where (u, v)= (suma xs, nDatos xs) {plegar} u `div` v Where (u,v)= sYn xs
28

El modelo Desplegar/Plegar
y finalmente, el programa equivalente es: media :: [Int]-> Int media xs = u `div` v Where (u,v)= sYn xs sYn :: [Int]-> (Int, Int) sYn[] = (0,0) sYn (x: xs) = (x+u, 1+v) Where (u,v) = sYn xs

29

Reduccin de la complejidad por transformacin

4.1 Caso Fibonacci. 4.2 Estudio Mnimo de la lista. 4.2.1 Correccin de la solucin. 4.2.2 La solucin de PettorossiSkowron.

30

Reduccin de la complejidad por transformacin

Caso Fibonacci: En este ejemplo esta metodologa hace una reduccin de complejidad exponencial a lineal.
fib fib fib fib :: Int->Int 0=1 1=1 (n+2) = fib (n+1) + fib n

31

Reduccin de la complejidad por transformacin

Si introducimos la funcin: g n {definicin} (fib (n+1), fib n) tendremos: fib n = v where (u, v) = g n Aplicando D/P: g 0 {instanciacin} (fib 1, fib 0) {desplegar} (1, 1)
32

Reduccin de la complejidad por transformacin

g (n +1) {instanciacin} (fib (n+2), fib (n+1)) {desplegar} (fib (n+1)+ fib n, fib (n+1)) {abstraccin} (u+v, u) where (u,v) = (fib (n+1), fib n) {plegar} (u+v, u) where (u,v) = g n

33

Reduccin de la complejidad por transformacin

Y finalmente el programa equivalente: fib :: Int -> Int fib n = v where (u,v) = g n g :: Int -> (Int, Int) g 0 = (1,1) g(n+1) = (u+v, u) where (u,v) = g n

34

Reduccin de la complejidad por transformacin Estudio mnimo de una lista: Dada una lista, sustituir todos sus elementos por el mnimo de la lista.

35

Reduccin de la complejidad por transformacin

lmin :: Ord a => [a] -> [a] minl :: Ord a => [a] -> a minl [x] = x minl (x:xs) = min x (minl xs) reemplaza :: a-> [a]-> [a] reemplaza _ [] = [] reemplaza m (_ : xs)= m : reemplaza m xs lmin xs = reemplaza (minl xs) xs

36

Reduccin de la complejidad por transformacin

Veamos una propiedad de la funcin mnimo: 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)

37

Reduccin de la complejidad por transformacin

Simplificando: lmin (x:x:xs) {desplegar} reemplaza (minl (x:x:xs)) (x:x:xs) {instanciacin de reemplaza dos veces} minl (x :x:xs) : minl (x:x:xs) : reemplaza(minl (x:x:xs)) xs {abstraccin} m:m:u Where m : u = minl (x:x:xs) :reemplaza(minl(x:x:xs))

38

Reduccin de la complejidad por transformacin

Eliminacin de las funciones reemplaza y minl: minl(x:x:xs): reemplaza (minl(x:x:xs))xs {propiedad del mnimo anterior} minl((min x x):xs): reemplaza (minl((min x x):xs))xs {instanciacin de reemplaza} reemplaza (minl ((min x x): xs)) ((min x x) : xs) {instanciacin de lmin} lmin ((min x x): xs)

39

Reduccin de la complejidad por transformacin

Finalmente obtenemos: lmin [x] = [x] lmin (x: x: xs) = m:m:u Where m:u = lmin((min x x) : xs)

40

Reduccin de la complejidad por transformacin

Correccin de la solucin
Para demostrar la correccin de la funcin 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] ->Bool ti[x] = True ti(x:x:xs)= x==x && ti (x:xs)
41

Reduccin de la complejidad por transformacin

Probaremos (correc) por induccin sobre lista no vaca 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)

42

Reduccin de la complejidad por transformacin

Cabeza (lmin((min x x) : xs)) {hiptesis de induccin}

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)

43

Reduccin de la complejidad por transformacin

ti (m:u) where m:u = lmin ((min x x):xs) ti (lmin ((min x x):xs) {propiedad mnimo, hiptesis induccin} Cierto

44

Reduccin de la complejidad por transformacin

La solucin de Pettorossi-Skowron
Sea la funcin: 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

45

Reduccin de la complejidad por transformacin

La correccin de la funcin lmin se puede hacer, bien demostrando (por induccin 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:
46

Reduccin de la complejidad por transformacin

lmin (x:x:xs) {lmin y fmin dos veces} min x (min xm) : min x (min xm) : g(min x (min xm)) where (m, g) = fmin xs De donde el paso inductivo sera: cabeza (lmin(x: x:xs)) cabeza (min x (min xm)) where (m, g) = fmin xs {asociatividad de min} cabeza (min (min x x) m) where (m, _)=fmin xs {lminy fmin}
47

Reduccin de la complejidad por transformacin

cabeza (lmin(min x x):xs) {hiptesis induccin} minl ((min x x) :xs) {minl} min(min x x) (minl xs) {minl dos veces y asociatividad de min} minl(x:x:xs)

48

Reduccin de la complejidad por transformacin

Por otra parte: ti(lmin(x:x:xs)) { por def. anterior} ti (min x (min xm): min x (min x m): g (min x (min xm) ) ) where(m,g) = fmin xs {lminy asociatividad de min} ti (lmin((min x x) : xs)) {propiedad mnimo, hiptesis induccin} Cierto
49

Correccin 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 ecuacin: fx=fx

50

Ejercicios
Ejemplo que sustituye en una lista todos los elementos por el ltimo y demostracin de su correccin, utilizando el mtodo de PettorosiSkowron.
ultl : Ord a => [a] -> a ultl [x]=x ultl [x:xs] = seg x (ultl xs) reemplaza ::a -> [a] -> [a]
51

Ejercicios
reemplaza _ []= [] reemplaza m (_:xs) = m :reemplaza m xs lult 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)

52

Ejercicios
lult (x:x:xs) {desplegar} reemplaza (ultl(x:x:xs)) (x:x:xs) {instanciacin de reemplaza dos veces} ultl(x:x:xs):ultl(x:x:xs):reemplaza(ultl (x:x:xs))xs {abstraccin} 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}

53

Ejercicios
ultl((seg x x):xs):reemplaza(ultl((seg x x):xs)) xs {instanciacin de reemplaza} reemplaza (ultl((seg x x):xs))((seg x x):xs) {instanciacin 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)

54

Ejercicios
Sea la funcin:
long ::[a] -> Int long[] = 0 long (_:xs)=1 + long xs Vamos a utilizar la tcnica de D/P para transformar el programa anterior en uno ms eficiente utilizando una funcin con un acumulador: long::[Int]->Int->Int tal que no deje sumas suspendidas.
55

Ejercicios
Demostrar su correccin , probando que: long xs n = long xs +n
Considerando la definicin long xs n = long xs + n que podemos transformar segn: long [] n {desplegar} long [] + n {desplegar long} n
56

Ejercicios
long (x:xs) n {desplegar} long (x:xs) +n {desplegar long} 1+ long xs +n {asociatividad y conmutacin} long xs + (n+1) {plegar} long xs (n+1) de donde hemos eliminado la funcin long:

long [] n = n long (x:xs) n = long xs (n+1)

57

Ejercicios
que introducimos en la forma: long xs =long xs 0 La correccin es trivial.

58

Ejercicios
Sustituir en un rbol binario todas sus apariciones por la mayor en una sola pasada.

Solucin al ejercicio en el fichero adjunto Ejercicio1620.hs La solucin a este ejercicio est basada en el mtodo de Pettorossi-Skowron donde nos basamos en una funcin auxiliar fmax, que dado un rbol devuelve un par formado por un elemento y una funcin. Dicha funcin va reconstruyendo una estructura de rbol idntica a la original y en cuyos nodos aparecen el elemento que se le pasa, en este caso el mximo de los nodos.
59

Anexo I
Dada una funcin
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 solucin utilizando parmetros acumuladores en Haskell es la siguiente: fxyzk0=x f x y z k (n+1) = f y z k (x+y+z+k) n La llamada a esta funcin con n=5 sera: f 15 3 8 1 5
60

Anexo I
Al igual que en la funcin fibonacci con parmetros acumuladores, la funcin anterior no hace repeticin de clculos pero si que siguen quedando las sumas suspendidas.

61

Anexo II
Correccin de la solucin de la funcin lult.
La correccin de la solucin para la funcin lult se hace demostrando el siguiente predicado: Para todo xs . xs::[a], xs []
(cabeza (lult xs) = ultl xs) ^ (ti (lult xs)) Donde: ultl :: [a]->a ultl [x] = x ultl (x:xs) = ultl xs
62

Anexo II
Correccin de la solucin de la funcin lult.
Una vez definido el predicado y las funciones que se usan en el mismo, la demostracin se hace de forma similar a la vista en el ejercicio de la correccin de lmin.

63

Anexo III
Comportamiento en memoria de la doble llamada recursiva realizada por la funcin 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 podra pensar, debido al comportamiento de m:reemplaza.
* Ejemplo de sustitucin de todos los elementos de una lista por su mnimo, pg 35
64

Bibliografa
Razonando con Haskell un curso sobre programacin funcional; Blas C. Ruiz, Francisco Gutirrez, Pablo Guerrero, Jos E. Gallardo

65