el modelo de desplegar/plegar
DESCRIPTION
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. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/1.jpg)
1
EL MODELO DE DESPLEGAR/PLEGAR
Salwa Al Atassi GonzálezJosé Francisco Poveda GarcíaJosé Sosa García
![Page 2: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/2.jpg)
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.
![Page 3: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/3.jpg)
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.
![Page 4: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/4.jpg)
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.
![Page 5: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/5.jpg)
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
![Page 6: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/6.jpg)
6
Parámetros Acumuladores
Números de FibonacciInconvenientes:
Repetición de Cálculos.
Las sumas quedan suspendidas.
![Page 7: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/7.jpg)
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=> …
![Page 8: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/8.jpg)
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
![Page 9: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/9.jpg)
9
Parámetros Acumuladores
Ventaja:
No se producen cálculos repetidos.
Inconveniente:
Con evaluación perezosa, las sumas quedan suspendidas.
![Page 10: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/10.jpg)
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.
![Page 11: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/11.jpg)
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)
![Page 12: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/12.jpg)
12
Transformación de Programas
2.1 Definición.2.2 Transformaciones.2.3 Ejemplo.
![Page 13: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/13.jpg)
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.
![Page 14: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/14.jpg)
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.
![Page 15: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/15.jpg)
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
![Page 16: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/16.jpg)
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
![Page 17: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/17.jpg)
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
![Page 18: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/18.jpg)
18
Transformación de Programas
La nueva versión de g es:
g [] = 0g (x:xs) = 2*x + g xs
![Page 19: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/19.jpg)
19
El modelo Desplegar/Plegar
3.1 Introducción.3.2 Las reglas Desplegar/Plegar.3.3 Ejemplo de la Media.
![Page 20: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/20.jpg)
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.
![Page 21: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/21.jpg)
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.
![Page 22: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/22.jpg)
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.
![Page 23: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/23.jpg)
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.
![Page 24: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/24.jpg)
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)
![Page 25: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/25.jpg)
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
![Page 26: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/26.jpg)
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)
![Page 27: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/27.jpg)
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
![Page 28: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/28.jpg)
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
![Page 29: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/29.jpg)
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
![Page 30: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/30.jpg)
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.
![Page 31: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/31.jpg)
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
![Page 32: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/32.jpg)
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)
![Page 33: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/33.jpg)
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
![Page 34: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/34.jpg)
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
![Page 35: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/35.jpg)
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.
![Page 36: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/36.jpg)
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
![Page 37: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/37.jpg)
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)
![Page 38: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/38.jpg)
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))
![Page 39: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/39.jpg)
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)
![Page 40: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/40.jpg)
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)
![Page 41: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/41.jpg)
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)
![Page 42: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/42.jpg)
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)
![Page 43: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/43.jpg)
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) Ξ
![Page 44: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/44.jpg)
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
![Page 45: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/45.jpg)
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
![Page 46: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/46.jpg)
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:
![Page 47: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/47.jpg)
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}
![Page 48: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/48.jpg)
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)
![Page 49: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/49.jpg)
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
![Page 50: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/50.jpg)
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
![Page 51: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/51.jpg)
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]
![Page 52: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/52.jpg)
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)
![Page 53: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/53.jpg)
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}
![Page 54: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/54.jpg)
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)
![Page 55: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/55.jpg)
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.
![Page 56: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/56.jpg)
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
![Page 57: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/57.jpg)
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)
![Page 58: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/58.jpg)
58
Ejercicios
que introducimos en la forma:
long xs =long’ xs 0
La corrección es trivial.
![Page 59: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/59.jpg)
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.
![Page 60: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/60.jpg)
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
![Page 61: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/61.jpg)
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.
![Page 62: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/62.jpg)
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
![Page 63: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/63.jpg)
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.
![Page 64: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/64.jpg)
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
![Page 65: EL MODELO DE DESPLEGAR/PLEGAR](https://reader035.vdocuments.mx/reader035/viewer/2022062222/56814c5d550346895db97ca9/html5/thumbnails/65.jpg)
65
Bibliografía
“Razonando con Haskell” un curso sobre programación funcional; Blas C. Ruiz, Francisco Gutiérrez, Pablo Guerrero, José E. Gallardo