Jalonso: Texto reemplazado: «"isar"» por «"isabelle"»

2018-07-16T07:50:42Z

Texto reemplazado: «"isar"» por «"isabelle"»

Jalonso: Página creada con ' header {* Razonamiento sobre programas en Isabelle } theory Relacion_11 imports Main Efficient_Nat begin text { ----------------------------------------...'

2011-03-15T05:26:17Z

Página creada con '<source lang="isar"> header {* Razonamiento sobre programas en Isabelle *} theory Relacion_11 imports Main Efficient_Nat begin text {* ----------------------------------------...'

Página nueva

<source lang="isar">
header {* Razonamiento sobre programas en Isabelle *}

theory Relacion_11
imports Main Efficient_Nat
begin

text {* ----------------------------------------------------------------
Ejercicio 1. Definir, por recursión, la función
longitud :: "'a list ⇒ nat" where
tal que (longitud xs) es la longitud de la listas xs. Por ejemplo,
longitud [4,2,5] = 3
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar que
longitud [4,2,5] = 3
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 3. Definir la función
fun intercambia :: "'a × 'b ⇒ 'b × 'a"
tal que (intercambia p) es el par obtenido intercambiando las
componentes del par p. Por ejemplo,
"intercambia (2,3) = (3,2)
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 5. Definir, por recursión, la función
inversa :: "'a list ⇒ 'a list"
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [3,2,5] = [5,2,3]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
repite :: "nat ⇒ 'a ⇒ 'a list" where
tal que . Por ejemplo,
repite 3 5 = [5,5,5]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
fun conc :: "'a list ⇒ 'a list ⇒ 'a list"
tal que . Por ejemplo,
conc [2,3] [4,3,5] = [2,3,4,3,5]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 11. Refutar que
conc xs ys = conc ys xs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar que
longitud (conc xs ys) = longitud xs + longitud ys
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 14. Definir la función
coge :: "nat ⇒ 'a list ⇒ 'a list"
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [3,7,5,4] = [3,7]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 15. Definir la función
elimina :: "nat ⇒ 'a list ⇒ 'a list"
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
elimina 2 [3,7,5,4] = [5,4]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar que
conc (coge n xs) (elimina n xs) = xs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 17. Definir la función
esVacia :: "'a list ⇒ bool"
tal que (esVacia xs) se verifica si xs es la lista vacía. Por ejemplo,
esVacia [] = True
esVacia [1] = False
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 19. Definir la función
inversaAc :: "'a list ⇒ 'a list"
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [3,2,5] = [5,2,3]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 20. Demostrar que
inversaAcAux xs ys = (inversa xs)@ys
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 22. Definir la función
sum :: "int list ⇒ int"
tal que (sum xs) es la suma de los elementos de xs. Por ejemplo,
sum [3,2,5] = 10
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 23. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3,2,5] = [6,4,10]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 24. Demostrar que
sum (map (λx. 2*x) xs) = 2 * (sum xs)
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar que
longitud (map f xs) = longitud xs
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 26. Definir la función
sumaImpares :: "nat ⇒ nat"
tal que (sumaImpares n) es la suma de los n primeros números
impares. Por ejemplo,
sumaImpares 5 = 25
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar que
sumaImpares n = n*n
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 28. Definir la función
sumaPotenciasDeDosMasUno :: "nat ⇒ nat"
tal que
(sumaPotenciasDeDosMasUno n) = 1 + 2^0 + 2^1 + 2^2 + ... + 2^n.
Por ejemplo,
sumaPotenciasDeDosMasUno 3 = 16
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 29. Demostrar que
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 30. Definir la función
copia :: "nat ⇒ 'a ⇒ 'a list"
tal que (copia n x) es la lista formado por n copias del elemento
x. Por ejemplo,
copia 3 2 = [2,2,2]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 31. Definir la función
todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool"
tal que (todos p xs) se verifica si todos los elementos de xs cumplen
la propiedad p. Por ejemplo,
todos (λx. x>(1::nat)) [2,6,4] = True
todos (λx. x>(2::nat)) [2,6,4] = False
Nota; La conjunción se representa por ∧
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar que todos los elementos de (copia n x) son
iguales a x.
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 33. Definir la función
factR :: "nat ⇒ nat"
tal que (factR n) es el factorial de n. Por ejemplo,
factR 4 = 24
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 34. Se considera la siguiente definición iterativa de la
función factorial
factI :: Integer -> Integer
factI n = factI' n 1

factI' :: Integer -> Integer -> Integer
factI' 0 x = x -- factI'.1
factI' (n+1) x = factI' n (n+1)*x -- factI'.2
Comprobar con QuickCheck que factI y factR son equivalentes sobre los
números naturales.
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 35. Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
y, como corolario, que
factI n = factR n
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 36. Definir, recursivamente y sin usar (@). la función
amplia :: "'a list ⇒ 'a ⇒ 'a list"
tal que (amplia xs y) es la lista obtenida añadiendo el elemento y al
final de la lista xs. Por ejemplo,
amplia [2,5] 3 = [2,5,3]
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar que
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

end
</source>

← Revisión anterior		Revisión del 07:50 16 jul 2018
Línea 1:		Línea 1:
−	<source lang="~~isar~~">	+	<source lang="isabelle">
	header {* Razonamiento sobre programas en Isabelle *}		header {* Razonamiento sobre programas en Isabelle *}

Rel 11 - Historial de revisiones

Jalonso: Texto reemplazado: «"isar"» por «"isabelle"»

Jalonso: Página creada con ' header {* Razonamiento sobre programas en Isabelle *} theory Relacion_11 imports Main Efficient_Nat begin text {* ----------------------------------------...'

Jalonso: Página creada con ' header {* Razonamiento sobre programas en Isabelle } theory Relacion_11 imports Main Efficient_Nat begin text { ----------------------------------------...'