1 / 65

EL MODELO DE DESPLEGAR/PLEGAR

EL MODELO DE DESPLEGAR/PLEGAR. Salwa Al Atassi González José Francisco Poveda García José Sosa García. INDICE. 1. Parámetros acumuladores. 2. Transformación de programas. 3. El modelo Desplegar/Plegar. 4. Reducción de la complejidad por transformación.

penny
Download Presentation

EL MODELO DE DESPLEGAR/PLEGAR

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. EL MODELO DE DESPLEGAR/PLEGAR Salwa Al Atassi González José Francisco Poveda García José 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 trivial fib :: Integer -> Integer fib 0 = 1 fib 1 = 1 fib (n + 2) = fib (n + 1) + fib n

  6. Parámetros Acumuladores • Números de Fibonacci Inconvenientes: • 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 [] = 0 suma [x] = x suma (x:y:xs)= suma (x + y : xs) • Función Mayor mayor [x] = x mayor (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]->Int g xs = suma (doble xs) suma [] = 0 suma (x:xs) = x + suma xs doble [] = [] doble (x:xs) = 2*x : doble xs

  16. Transformación de Programas 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. 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 [] = 0 g (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ón E = E’ transformándola en la nueva ecuación: E = [ u1, … , un := F1, … , Fn] E’ where (u1, … , un) = (F1, … , Fn)

  25. 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

  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/Plegar Entonces: 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]-> 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

  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->Int fib 0 = 1 fib 1 = 1 fib (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 -> 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

  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] -> 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

  37. Reducción de la complejidad por transformación Veamos 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ón Para 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] ->Bool ti[x] = True ti(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-Skowron Sea 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

More Related