Razonamiento automático (2016-17) - Contribuciones del usuario [es]

Relación 7

2016-12-18T22:39:07Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort pablucoto ivamenjim *)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort pablucoto ivamenjim *)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

(* ivamenjim: llamando a la función anterior profundidad3 *)

lemma "profundidad a = profundidad3 a"
by (induct a) auto

(* ivamenjim *)
fun profundidad4 :: "arbol => nat" where
"profundidad4 H = 0"
| "profundidad4 (N i d) = Suc (max (profundidad4 i)(profundidad4 d))"

lemma "profundidad a = profundidad4 a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort*)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort*)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort*)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T22:00:33Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort pablucoto*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort*)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort*)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort*)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T21:26:01Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort*)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort*)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T21:14:11Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort*)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T21:02:21Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T20:43:53Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T20:40:26Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort*)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort*)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor *)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 7

2016-12-18T20:25:16Z

Wilmorort:

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que no tienen información ni en los nodos y ni en las
hojas. Por ejemplo, el árbol
·
/ \
/ \
· ·
/ \ / \
· · · ·
se representa por "N (N H H) (N H H)".
---------------------------------------------------------------------
*}

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
hojas :: "arbol => nat"
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,
hojas (N (N H H) (N H H)) = 4
---------------------------------------------------------------------
*}

(* fraortmoy *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort*)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
profundidad :: "arbol => nat"
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,
profundidad (N (N H H) (N H H)) = 2
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 anaprarod migtermor *)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod *)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i)(profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor *)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

value "abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i
como d son árboles binarios completos respecto de f y, además,
f(i) = f(r).

Definir la función
es_abc :: "(arbol => 'a) => arbol => bool
tal que (es_abc f a) se verifica si a es un árbol binario completo
respecto de f.
---------------------------------------------------------------------
*}

(* fraortmoy anaprarod migtermor *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,
size (N (N H H) (N H H)) = 3
---------------------------------------------------------------------
*}

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

text {*
---------------------------------------------------------------------
Nota. Tenemos 3 funciones de medida sobre los árboles: número de
hojas, número de nodos y profundidad. A cada una le corresponde un
concepto de completitud. En los siguientes ejercicios demostraremos
que los tres conceptos de completitud son iguales.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc(size a) = hojas a"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod*)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod *)
(* con un demostrador más débil *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops

end
</source>

Relación 6

2016-12-04T23:00:04Z

Wilmorort:

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort *)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

value "N e (N c (H a) (H d)) (N g (H f) (H h))"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H t) = [t]"
| "preOrden (N t i d) = [t] @ (preOrden i) @ (preOrden d)"

(* danrodcha crigomgom manmorjim1 bowma *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x#preOrden1 i @ preOrden1 d"

value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"
value "preOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H t) = [t]"
| "postOrden (N t i d) = (postOrden i) @ (postOrden d) @ [t]"

value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,d,c,f,h,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"
value "inOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
espejo :: "'a arbol ⇒ 'a arbol"
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo,
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort*)

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que
preOrden (espejo a) = rev (postOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor wilmorort *)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))" by simp
qed

(* danrodcha *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden (espejo d) @ preOrden (espejo i)"
by (simp only: preOrden.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1*)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) = preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)" using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* fraortmoy *)

lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que
postOrden (espejo a) = rev (preOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor wilmorort*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) = postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]" using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))" by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) = postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x] " by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] " using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que
inOrden (espejo a) = rev (inOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor wilmorort*)

theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))" by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))" by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " inOrden (espejo (N x i d)) = inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i) " by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
raiz :: "'a arbol ⇒ 'a"
tal que (raiz a) es la raiz del árbol a. Por ejemplo,
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e"

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
extremo_izquierda :: "'a arbol ⇒ 'a"
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol
a. Por ejemplo,
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a"

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

text {*
---------------------------------------------------------------------
Ejercicio 11. Definir la función
extremo_derecha :: "'a arbol ⇒ 'a"
tal que (extremo_derecha a) es el nodo más a la derecha del árbol
a. Por ejemplo,
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h"

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_12 al teorema del ejercicio 12 *)

lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
last (inOrden a) = extremo_derecha a
---------------------------------------------------------------------
*}

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom wilmorort*)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)

lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) = last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)" by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)" by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
hd (inOrden a) = extremo_izquierda a
---------------------------------------------------------------------
*}

(* danrodcha pablucoto crigomgom *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)" by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 wilmorort *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
hd (preOrden a) = last (postOrden a)
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 wilmorort*) (*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
(* Si no especifico que i y d son árboles, salta un error de tipo. Supongo que será por
no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim *)

theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar o refutar
hd (preOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 wilmorort *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) " by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)" by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
hd (inOrden a) = raiz a
---------------------------------------------------------------------
*}

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
qed

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
last (postOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) = last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 wilmorort*) (*Similar al anterior*)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) = last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está usando *)
have "last (postOrden (N t i d)) = last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) = last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-04T22:54:58Z

Wilmorort:

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort *)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

value "N e (N c (H a) (H d)) (N g (H f) (H h))"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H t) = [t]"
| "preOrden (N t i d) = [t] @ (preOrden i) @ (preOrden d)"

(* danrodcha crigomgom manmorjim1 bowma *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x#preOrden1 i @ preOrden1 d"

value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"
value "preOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H t) = [t]"
| "postOrden (N t i d) = (postOrden i) @ (postOrden d) @ [t]"

value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,d,c,f,h,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"
value "inOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
espejo :: "'a arbol ⇒ 'a arbol"
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo,
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort*)

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que
preOrden (espejo a) = rev (postOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor wilmorort *)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))" by simp
qed

(* danrodcha *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden (espejo d) @ preOrden (espejo i)"
by (simp only: preOrden.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1*)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) = preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)" using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* fraortmoy *)

lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que
postOrden (espejo a) = rev (preOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor wilmorort*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) = postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]" using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))" by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) = postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x] " by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] " using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que
inOrden (espejo a) = rev (inOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor wilmorort*)

theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))" by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))" by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " inOrden (espejo (N x i d)) = inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i) " by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
raiz :: "'a arbol ⇒ 'a"
tal que (raiz a) es la raiz del árbol a. Por ejemplo,
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e"

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
extremo_izquierda :: "'a arbol ⇒ 'a"
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol
a. Por ejemplo,
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a"

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

text {*
---------------------------------------------------------------------
Ejercicio 11. Definir la función
extremo_derecha :: "'a arbol ⇒ 'a"
tal que (extremo_derecha a) es el nodo más a la derecha del árbol
a. Por ejemplo,
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 wilmorort *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h"

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_12 al teorema del ejercicio 12 *)

lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
last (inOrden a) = extremo_derecha a
---------------------------------------------------------------------
*}

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom wilmorort*)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)

lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) = last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)" by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)" by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
hd (inOrden a) = extremo_izquierda a
---------------------------------------------------------------------
*}

(* danrodcha pablucoto crigomgom*)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)" by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
hd (preOrden a) = last (postOrden a)
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 *) (*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
(* Si no especifico que i y d son árboles, salta un error de tipo. Supongo que será por
no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim *)

theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar o refutar
hd (preOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) " by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)" by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
hd (inOrden a) = raiz a
---------------------------------------------------------------------
*}

(*crigomgom pablucoto bowma migtermor ivamenjim *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
qed

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
last (postOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) = last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *) (*Similar al anterior*)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) = last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está usando *)
have "last (postOrden (N t i d)) = last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) = last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-04T21:51:20Z

Wilmorort:

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort *)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

value "N e (N c (H a) (H d)) (N g (H f) (H h))"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H t) = [t]"
| "preOrden (N t i d) = [t] @ (preOrden i) @ (preOrden d)"

(* danrodcha crigomgom manmorjim1 bowma *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x#preOrden1 i @ preOrden1 d"

value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"
value "preOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H t) = [t]"
| "postOrden (N t i d) = (postOrden i) @ (postOrden d) @ [t]"

value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,d,c,f,h,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"
value "inOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
espejo :: "'a arbol ⇒ 'a arbol"
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo,
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor wilmorort*)

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que
preOrden (espejo a) = rev (postOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor wilmorort *)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))" by simp
qed

(* danrodcha *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden (espejo d) @ preOrden (espejo i)"
by (simp only: preOrden.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1*)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) = preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)" using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* fraortmoy *)

lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que
postOrden (espejo a) = rev (preOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) = postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]" using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))" by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) = postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x] " by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] " using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que
inOrden (espejo a) = rev (inOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))" by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))" by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " inOrden (espejo (N x i d)) = inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i) " by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
raiz :: "'a arbol ⇒ 'a"
tal que (raiz a) es la raiz del árbol a. Por ejemplo,
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e"

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
extremo_izquierda :: "'a arbol ⇒ 'a"
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol
a. Por ejemplo,
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a"

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

text {*
---------------------------------------------------------------------
Ejercicio 11. Definir la función
extremo_derecha :: "'a arbol ⇒ 'a"
tal que (extremo_derecha a) es el nodo más a la derecha del árbol
a. Por ejemplo,
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h"

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_12 al teorema del ejercicio 12 *)

lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
last (inOrden a) = extremo_derecha a
---------------------------------------------------------------------
*}

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)

lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) = last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)" by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)" by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
hd (inOrden a) = extremo_izquierda a
---------------------------------------------------------------------
*}

(* danrodcha pablucoto crigomgom*)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)" by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
hd (preOrden a) = last (postOrden a)
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 *) (*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
(* Si no especifico que i y d son árboles, salta un error de tipo. Supongo que será por
no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim *)

theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar o refutar
hd (preOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) " by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)" by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
hd (inOrden a) = raiz a
---------------------------------------------------------------------
*}

(*crigomgom pablucoto bowma migtermor ivamenjim *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
qed

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
last (postOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) = last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *) (*Similar al anterior*)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) = last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está usando *)
have "last (postOrden (N t i d)) = last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) = last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-04T21:14:05Z

Wilmorort:

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort *)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

value "N e (N c (H a) (H d)) (N g (H f) (H h))"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor wilmorort *)

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H t) = [t]"
| "preOrden (N t i d) = [t] @ (preOrden i) @ (preOrden d)"

(* danrodcha crigomgom manmorjim1 bowma *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x#preOrden1 i @ preOrden1 d"

value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"
value "preOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor *)

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H t) = [t]"
| "postOrden (N t i d) = (postOrden i) @ (postOrden d) @ [t]"

value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,d,c,f,h,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy migtermor *)

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"
value "inOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
espejo :: "'a arbol ⇒ 'a arbol"
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo,
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor *)

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que
preOrden (espejo a) = rev (postOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor *)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))" by simp
qed

(* danrodcha *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden (espejo d) @ preOrden (espejo i)"
by (simp only: preOrden.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1*)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) = preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)" using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* fraortmoy *)

lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que
postOrden (espejo a) = rev (preOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) = postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]" using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))" by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) = postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x] " by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] " using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que
inOrden (espejo a) = rev (inOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))" by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))" by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " inOrden (espejo (N x i d)) = inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i) " by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
raiz :: "'a arbol ⇒ 'a"
tal que (raiz a) es la raiz del árbol a. Por ejemplo,
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e"

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
extremo_izquierda :: "'a arbol ⇒ 'a"
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol
a. Por ejemplo,
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a"

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

text {*
---------------------------------------------------------------------
Ejercicio 11. Definir la función
extremo_derecha :: "'a arbol ⇒ 'a"
tal que (extremo_derecha a) es el nodo más a la derecha del árbol
a. Por ejemplo,
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h"

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_12 al teorema del ejercicio 12 *)

lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
last (inOrden a) = extremo_derecha a
---------------------------------------------------------------------
*}

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)

lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) = last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)" by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)" by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
hd (inOrden a) = extremo_izquierda a
---------------------------------------------------------------------
*}

(* danrodcha pablucoto crigomgom*)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)" by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
hd (preOrden a) = last (postOrden a)
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 *) (*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
(* Si no especifico que i y d son árboles, salta un error de tipo. Supongo que será por
no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim *)

theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar o refutar
hd (preOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) " by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)" by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
hd (inOrden a) = raiz a
---------------------------------------------------------------------
*}

(*crigomgom pablucoto bowma migtermor ivamenjim *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
qed

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
last (postOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) = last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *) (*Similar al anterior*)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) = last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está usando *)
have "last (postOrden (N t i d)) = last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) = last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-04T20:55:46Z

Wilmorort:

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort *)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

value "N e (N c (H a) (H d)) (N g (H f) (H h))"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor *)

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H t) = [t]"
| "preOrden (N t i d) = [t] @ (preOrden i) @ (preOrden d)"

(* danrodcha crigomgom manmorjim1 bowma *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x#preOrden1 i @ preOrden1 d"

value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"
value "preOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]"

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor *)

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H t) = [t]"
| "postOrden (N t i d) = (postOrden i) @ (postOrden d) @ [t]"

value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,d,c,f,h,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy migtermor *)

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"
value "inOrden1 (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]"

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
espejo :: "'a arbol ⇒ 'a arbol"
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo,
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1 pablucoto bowma fraortmoy migtermor *)

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))
= N e (N g (H h) (H f)) (N c (H d) (H a))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que
preOrden (espejo a) = rev (postOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor *)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))" by simp
qed

(* danrodcha *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden (espejo d) @ preOrden (espejo i)"
by (simp only: preOrden.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1*)

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) = preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)" using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) = preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))" by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)" using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* fraortmoy *)

lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que
postOrden (espejo a) = rev (preOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) = postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]" using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))" by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1*)

lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) = postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x] " by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] " using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que
inOrden (espejo a) = rev (inOrden a)
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom bowma migtermor *)

theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))" by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))" by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " inOrden (espejo (N x i d)) = inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i) " by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
raiz :: "'a arbol ⇒ 'a"
tal que (raiz a) es la raiz del árbol a. Por ejemplo,
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e"

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
extremo_izquierda :: "'a arbol ⇒ 'a"
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol
a. Por ejemplo,
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a"

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

text {*
---------------------------------------------------------------------
Ejercicio 11. Definir la función
extremo_derecha :: "'a arbol ⇒ 'a"
tal que (extremo_derecha a) es el nodo más a la derecha del árbol
a. Por ejemplo,
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h
---------------------------------------------------------------------
*}

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto migtermor marpoldia1 *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h"

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración. Llamando teorema_12 al teorema del ejercicio 12 *)

lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
last (inOrden a) = extremo_derecha a
---------------------------------------------------------------------
*}

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)

lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) = last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)" by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)" by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
hd (inOrden a) = extremo_izquierda a
---------------------------------------------------------------------
*}

(* danrodcha pablucoto crigomgom*)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)" by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
hd (preOrden a) = last (postOrden a)
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 *) (*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
(* Si no especifico que i y d son árboles, salta un error de tipo. Supongo que será por
no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim *)

theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar o refutar
hd (preOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden (N x i d)) = hd (x#preOrden i @ preOrden d)"
by (simp only: preOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) " by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)" by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) = hd ([n]@preOrden i@preOrden d)"
by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))" by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
hd (inOrden a) = raiz a
---------------------------------------------------------------------
*}

(*crigomgom pablucoto bowma migtermor ivamenjim *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

(* ivamenjim marpoldia1 *)

theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
qed

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
last (postOrden a) = raiz a
---------------------------------------------------------------------
*}

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) = last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 *) (*Similar al anterior*)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) = last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está usando *)
have "last (postOrden (N t i d)) = last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)

theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) = last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

end
</source>

Relación 5

2016-11-27T05:33:06Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"

(* wilmorort *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix b xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (b#xs)) = estaEn a (b#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
then have "estaEn a (borraDuplicados xs)" using H1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (b#xs)" by simp
next
assume "¬ estaEn b xs"
then have "estaEn a (b#(borraDuplicados xs))" using H1 by simp
then have "a=b ∨ (estaEn a (borraDuplicados xs))" by simp
then have " a=b ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (b#xs)" by simp
qed
next
assume H2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
then have "estaEn b (borraDuplicados xs) = estaEn b xs" using HI by simp
then have "(estaEn b xs ⟶ estaEn b (borraDuplicados xs)) ∧
(¬ estaEn b xs ⟶ estaEn b (b # borraDuplicados xs))" by simp
then have "estaEn b (borraDuplicados (b#xs))" by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a=b` by simp
next
assume "a≠b"
then have "estaEn a (b#xs)" using H2 by simp
then have "a = b ∨ estaEn a xs" by simp
then have "False ∨ estaEn a xs " using `a≠b` by simp
then have "estaEn a xs" by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a≠b` by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*wilmorort*)

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
proof (induct xs)
show " sinDuplicados (borraDuplicados [])" by simp
next
fix a xs
assume HI: "sinDuplicados (borraDuplicados xs)"
show "sinDuplicados (borraDuplicados (a # xs))"
proof (cases)
assume "estaEn a xs"
then show "sinDuplicados (borraDuplicados (a#xs))" using HI by simp
next
assume"¬ estaEn a xs"
then have "¬ (estaEn a xs) ∧ sinDuplicados (borraDuplicados xs)" using HI by simp
then have "¬ estaEn a (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs)"
by (simp add: estaEn_borraDuplicados)
then have " sinDuplicados (a#borraDuplicados xs)" by simp
then show " sinDuplicados (borraDuplicados(a #xs))" by simp
qed
qed
text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-27T05:32:02Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"

(* wilmorort *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix b xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (b#xs)) = estaEn a (b#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
then have "estaEn a (borraDuplicados xs)" using H1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (b#xs)" by simp
next
assume "¬ estaEn b xs"
then have "estaEn a (b#(borraDuplicados xs))" using H1 by simp
then have "a=b ∨ (estaEn a (borraDuplicados xs))" by simp
then have " a=b ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (b#xs)" by simp
qed
next
assume H2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
then have "estaEn b (borraDuplicados xs) = estaEn b xs" using HI by simp
then have "(estaEn b xs ⟶ estaEn b (borraDuplicados xs)) ∧
(¬ estaEn b xs ⟶ estaEn b (b # borraDuplicados xs))" by simp
then have "estaEn b (borraDuplicados (b#xs))" by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a=b` by simp
next
assume "a≠b"
then have "estaEn a (b#xs)" using H2 by simp
then have "a = b ∨ estaEn a xs" by simp
then have "False ∨ estaEn a xs " using `a≠b` by simp
then have "estaEn a xs" by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a≠b` by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
proof (induct xs)
show " sinDuplicados (borraDuplicados [])" by simp
next
fix a xs
assume HI: "sinDuplicados (borraDuplicados xs)"
show "sinDuplicados (borraDuplicados (a # xs))"
proof (cases)
assume "estaEn a xs"
then show "sinDuplicados (borraDuplicados (a#xs))" using HI by simp
next
assume"¬ estaEn a xs"
then have "¬ (estaEn a xs) ∧ sinDuplicados (borraDuplicados xs)" using HI by simp
then have "¬ estaEn a (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs)"
by (simp add: estaEn_borraDuplicados)
then have " sinDuplicados (a#borraDuplicados xs)" by simp
then show " sinDuplicados (borraDuplicados(a #xs))" by simp
qed
qed
text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-27T04:16:32Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"

(* wilmorort *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix b xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (b#xs)) = estaEn a (b#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
then have "estaEn a (borraDuplicados xs)" using H1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (b#xs)" by simp
next
assume "¬ estaEn b xs"
then have "estaEn a (b#(borraDuplicados xs))" using H1 by simp
then have "a=b ∨ (estaEn a (borraDuplicados xs))" by simp
then have " a=b ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (b#xs)" by simp
qed
next
assume H2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
then have "estaEn b (borraDuplicados xs) = estaEn b xs" using HI by simp
then have "(estaEn b xs ⟶ estaEn b (borraDuplicados xs)) ∧
(¬ estaEn b xs ⟶ estaEn b (b # borraDuplicados xs))" by simp
then have "estaEn b (borraDuplicados (b#xs))" by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a=b` by simp
next
assume "a≠b"
then have "estaEn a (b#xs)" using H2 by simp
then have "a = b ∨ estaEn a xs" by simp
then have "False ∨ estaEn a xs " using `a≠b` by simp
then have "estaEn a xs" by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a≠b` by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-27T04:15:47Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix b xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (b#xs)) = estaEn a (b#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
then have "estaEn a (borraDuplicados xs)" using H1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (b#xs)" by simp
next
assume "¬ estaEn b xs"
then have "estaEn a (b#(borraDuplicados xs))" using H1 by simp
then have "a=b ∨ (estaEn a (borraDuplicados xs))" by simp
then have " a=b ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (b#xs)" by simp
qed
next
assume H2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
then have "estaEn b (borraDuplicados xs) = estaEn b xs" using HI by simp
then have "(estaEn b xs ⟶ estaEn b (borraDuplicados xs)) ∧
(¬ estaEn b xs ⟶ estaEn b (b # borraDuplicados xs))" by simp
then have "estaEn b (borraDuplicados (b#xs))" by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a=b` by simp
next
assume "a≠b"
then have "estaEn a (b#xs)" using H2 by simp
then have "a = b ∨ estaEn a xs" by simp
then have "False ∨ estaEn a xs " using `a≠b` by simp
then have "estaEn a xs" by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (b#xs))" using `a≠b` by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-27T01:27:35Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-27T01:22:22Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T22:20:32Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T22:10:45Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* wilmorort *)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True
estaEn a1 [a1,a1] = True
Pero
[a1,a1] ≠ [a1]
---- Por otro lado ----
Auto Quickcheck found a counterexample:
xs = [a⇩1, a⇩1]
Evaluated terms:
borraDuplicados xs = [a⇩1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

(* wilmorort *)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True
estaEn a1 [a1,a1] = True
Pero
[a1,a1] ≠ [a1]
---- Por otro lado ----
Auto Quickcheck found a counterexample:
xs = [a⇩1, a⇩1]
Evaluated terms:
borraDuplicados xs = [a⇩1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T22:08:48Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* wilmorort *)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True
estaEn a1 [a1,a1] = True
Pero
[a1,a1] ≠ [a1]
---- Por otro lado ----
lemma borrarDuplicados xs = xs
Auto Quickcheck found a counterexample:
borrarDuplicados = (λx. undefined)(a⇩1 := a⇩2, a⇩2 := a⇩1)
xs = a⇩1
Evaluated terms:
borrarDuplicados xs = a⇩2
*)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

(* wilmorort *)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True
estaEn a1 [a1,a1] = True
Pero
[a1,a1] ≠ [a1]
---- Por otro lado ----
lemma borrarDuplicados xs = xs
Auto Quickcheck found a counterexample:
borrarDuplicados = (λx. undefined)(a⇩1 := a⇩2, a⇩2 := a⇩1)
xs = a⇩1
Evaluated terms:
borrarDuplicados xs = a⇩2
*)

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T22:07:20Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort bowma*)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

(* wilmorort *)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True
estaEn a1 [a1,a1] = True
Pero
[a1,a1] ≠ [a1]
---- Por otro lado ----
lemma borrarDuplicados xs = xs
Auto Quickcheck found a counterexample:
borrarDuplicados = (λx. undefined)(a⇩1 := a⇩2, a⇩2 := a⇩1)
xs = a⇩1
Evaluated terms:
borrarDuplicados xs = a⇩2
*)

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T21:56:07Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T21:54:07Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort bowma *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(*wilmorort*)
(*Contra_Ejemplo*)
(*
Si a = a1
xs = [a1,a1]
Luego
estaEn a1 (borraDuplicados [a1,a1]) = esta a1 [a1] = True

*)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T20:32:41Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar wilmorort *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T20:09:46Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim wilmorort *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T18:41:35Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T18:40:10Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T18:21:57Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim wilmorort *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T17:57:19Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

(* wilmorort *)
(* reutilizando la funcion "algunos" de R4.thy*)
fun estaEn2 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn2 a xs = algunos (λx. x = a) xs"

value "estaEn2 (2::nat) [3,2,4] = True"
value "estaEn2 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 5

2016-11-26T17:37:28Z

Wilmorort:

<source lang="isar">
chapter {* R5: Eliminación de duplicados *}

theory R5_Eliminacion_de_duplicados
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar bowma wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn _ [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

(* ivamenjim *)
(* Igual que la anterior pero con x en lugar de _ en el caso base *)

fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = ((x=a) ∨ estaEn1 x xs)"

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar ivamenjim *)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar *)
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) =( if estaEn x xs then borraDuplicados xs else x#borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if ¬(estaEn x xs) then (x#(borraDuplicados xs)) else borraDuplicados xs)"

value "borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(*crigomgom*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
(* crigomgom *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
show "length (borraDuplicados (x#xs)) ≤ length (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "length (borraDuplicados (x#xs)) = length (borraDuplicados xs)" by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
next
assume "(¬ estaEn x xs)"
then have "length (borraDuplicados (x#xs)) = length (x#borraDuplicados xs)" by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (x#xs)" by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed
qed

(* ivamenjim *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "La demostración automática es"
(* crigomgom rubgonmar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
estaEn a (borraDuplicados xs) = estaEn a xs
Nota: Para la demostración de la equivalencia se puede usar
proof (rule iffI)
La regla iffI es
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

text {*
---------------------------------------------------------------------
Ejercicio 6.2. Demostrar o refutar detalladamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración estructurada es"
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim *)
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops

(* ivamenjim: Quickcheck encuentra el siguiente contraejemplo:
xs = [a1, a2, a1]
Por lo que:
· "borraDuplicados (rev xs) = [a2, a1]"
· "rev (borraDuplicados xs) = [a1, a2]" *)

end
</source>

Relación 4

2016-11-24T22:10:12Z

Wilmorort:

<source lang="isar">
chapter {* R4: Cuantificadores sobre listas *}

theory R4_Cuantificadores_sobre_listas
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (todos p xs) se verifica si todos los elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
todos (λx. 1<length x) [[2,1,4],[1,3]]
¬todos (λx. 1<length x) [[2,1,4],[3]]

Nota: La función todos es equivalente a la predefinida list_all.
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar wilmorort marpoldia1
ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou
rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1
marcarmor13 *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (algunos p xs) se verifica si algunos elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
algunos (λx. 1<length x) [[2,1,4],[3]]
¬algunos (λx. 1<length x) [[],[3]]"

Nota: La función algunos es equivalente a la predefinida list_ex.
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar marpoldia1 ferrenseg
wilmorort paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou
rubgonmar josgarsan fraortmoy lucnovdos pabrodmac marcarmor13 *)
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (p x ∨ algunos p xs)"

(* fracorjim1. En esta versión el procesamiento se detiene al encontrar
una coincidencia *)
fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos2 p [] = False"
| "algunos2 p (x#xs) = (if p x then True else algunos2 p xs)"

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar o refutar automáticamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar marpoldia1 ferrenseg
wilmorort paupeddeg pablucoto anaprarod serrodcal juacabsou rubgonmar
josgarsan fraortmoy lucnovdos pabrodmac marcarmor13 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

(* fracorjim1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

(* danrodcha fracorjim1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix a xs
assume HI: "?R xs"
have "todos (λx. P x ∧ Q x) (a#xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "… = (P a ∧ Q a ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))" by blast
also have "… = (todos P (a#xs) ∧ todos Q (a#xs))" by simp
finally show "?R (a#xs)" by simp
qed

(* Comentario: Uso de blast. *)

(* ivamenjim wilmorort serrodcal josgarsan*)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
finally show "todos (λx. P x ∧ Q x) (a # xs) =
(todos P (a # xs) ∧ todos Q (a # xs))" by auto
qed

(* Comentario: Uso de auto. *)

(* dancorgar paupeddeg *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix y xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (y#xs) =
((P y ∧ Q y) ∧ (todos (λx. P x ∧ Q x) xs))" by simp
also have "… = ((P y ∧ Q y) ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P y ∧ todos P xs) ∧ (Q y ∧ todos Q xs))" by blast
also have "… = ((todos P (y#xs)) ∧ (todos Q (y#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (y#xs) =
(todos P (y#xs) ∧ todos Q (y#xs))" by simp
qed

(* migtermor *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix x xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "(todos (λx. P x ∧ Q x) (x#xs)) =
(( P x ∧ Q x) ∧ (todos (λx. P x ∧ Q x) xs))"
by (simp only: todos.simps(2))
also have "… = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))"
by arith
also have "((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs)) = (((P x)∧(todos P xs)) ∧ ((Q x) ∧ (todos Q xs)))"
by arith
(* Este paso es exactamente el mismo que el anterior, pero sin
cualquiera de los dos no funciona el "finally show" *)
have "… = (((P x)∧(todos P xs))∧((Q x)∧(todos Q xs)))" by simp
have "… = ((todos P (x#xs))∧(todos Q (x#xs)))" by simp
finally show "(todos (λx. P x ∧ Q x) (x#xs)) =
((todos P (x#xs)) ∧ (todos Q (x#xs)))" by simp
qed

(* Comentarios: Ruptura de la cadena de igualdades y uso de arith. *)

(* marpoldia1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
((P a ∧ Q a) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))" by blast
also have "... = (todos P (a#xs) ∧ todos Q (a#xs)) " by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) =
(todos P (a#xs) ∧ todos Q (a#xs))" by simp
qed

(* ferrenseg *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
(P n ∧ Q n ∧ todos P xs ∧ todos Q xs)" using HI by simp
also have "… = P n ∧ Q n ∧ todos P xs ∧ todos Q xs" by blast
also have "⋯ = todos P (n # xs) ∧ todos Q (n # xs)" by simp
finally show "todos (λx. P x ∧ Q x) (n # xs) = todos P (n # xs) ∧ todos Q (n # xs)" by simp
oops

(* Comentario: Demostración incompleta. *)

(* lucnovdos *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
((P n ∧ Q n) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P n ∧ todos P xs) ∧ (Q n ∧ todos Q xs))" by arith
also have "... = ((todos P(n#xs)) ∧ (todos Q(n#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (n#xs) =
(todos P (n#xs) ∧ todos Q (n#xs))" by simp
qed

(* wilmorort pablucoto crigomgom anaprarod juacabsou rubgonmar fraortmoy
marcarmor13 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
also have "... = (P a ∧ todos P xs ∧ Q a ∧ todos Q xs)" by arith
also have "... = (todos P (a # xs) ∧ todos Q (a # xs))" by simp
(* Este paso se puede obviar *)
finally show "todos (λx. P x ∧ Q x) (a # xs) =
(todos P (a # xs) ∧ todos Q (a # xs))" by simp
qed

(* pabrodmac *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix x xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (x#xs) =
(P x ∧ Q x ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P x ∧ Q x ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "... = (P x ∧ todos P xs ∧ Q x ∧ todos Q xs)" by arith
finally show "todos (λx. P x ∧ Q x) (x#xs) =
(todos P (x#xs) ∧ todos Q (x#xs))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim marpoldia1 migtermor ferrenseg wilmorort
paupeddeg crigomgom anaprarod serrodcal juacabsou rubgonmar pablucoto
fraortmoy josgarsan lucnovdos pabrodmac marcarmor13 *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

(* anaprarod dancorgar fracorjim1 *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
apply (induct x)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg wilmorort dancorgar fraortmoy josgarsan lucnovdos
rubgonmar *)
lemma todos_append:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ (todos P (x @ y)))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* migtermor serrodcal *)
lemma todos_append1:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?P x")
proof (induct x)
show "?P []" by simp
next
fix a x
assume HI: "?P x"
have "todos P ((a#x) @ y) = (P a ∧ (todos P (x @ y)))" by simp
also have "… = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "?P (a#x)" by simp
qed

(* marpoldia1 *)
lemma todos_append2:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = todos P (a#(x@y))" by simp
also have "... = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* paupeddeg *)
lemma todos_append3:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = todos P (a # (x @ y))" by simp
also have "... = (todos P [a] ∧ todos P (x @ y)) " by simp
also have "... = (todos P [a] ∧ (todos P x ∧ todos P y))"
using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* crigomgom juacabsou anaprarod*)
lemma todos_append4:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix x xs
assume HI:"todos P (xs @ y) = (todos P xs ∧ todos P y)"
have "todos P ((x # xs) @ y) = (P x ∧ todos P (xs @ y ))" by simp
also have "... = (P x ∧ (todos P xs ∧ todos P y)) " using HI by simp
also have "... = ((P x ∧ todos P xs) ∧ todos P y)" by simp
finally show "todos P ((x # xs) @ y) = (todos P (x # xs) ∧ todos P y)"
by simp
qed

(* pablucoto marcarmor13 *)
lemma todos_append5:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x )
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI:"todos P (x @ y) = (todos P x ∧ todos P y) "
have "todos P ((a # x) @ y) = ( P a ∧ todos P (x @ y))" by simp
also have " ... =( P a ∧ (todos P x ∧ todos P y))" using HI by simp
also have "... = (todos P (a#x) ∧ todos P y)" by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by auto
qed

(* Comentario: Uso de auto. *)

(* danrodcha *)
lemma todos_append6:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?Q x")
proof (induct x)
show "?Q []" by simp
next
fix x a assume HI: "?Q x"
have "todos P ((a # x) @ y) = todos P (a # x @ y)" by simp
also have "… = ((P a) ∧ todos P (x @ y))" by simp
also have "… = ((P a) ∧ (todos P x ∧ todos P y))" using HI by simp
also have "… = (todos P (a # x) ∧ todos P y)" by simp
finally show "?Q (a # x)" by simp
qed

(* pabrodmac *)
lemma todos_append7:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a#x) @ y) = (todos P (a#x) ∧ todos P y)"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* migtermor ivamenjim marpoldia1 serrodcal anaprarod paupeddeg
dancorgar *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs)
apply simp
apply (simp add: todos_append)
apply auto
done

(* ferrenseg crigomgom rubgonmar fraortmoy josgarsan danrodcha lucnovdos
pabrodmac *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto simp add: todos_append)

(* wilmorort *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs, simp, simp add: todos_append,auto)

(* Comentario: Pasos dentro de by *)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs, simp, simp add: todos_append, auto)
done

(* Comentario: Pasos dentro de apply *)

(* pablucoto marcarmor13 *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)

(* Comentario: Uso de simp_all *)

lemma "todos P (rev xs) = todos P xs"
by (induct xs) (simp_all add: todos_append, auto)

(* Comentario: Uso de add en simp_all *)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma auxiliar:
"rev (a#xs) = rev xs @ [a]"
by auto

lemma "todos P (rev xs) = todos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by (simp only: rev.simps(1))
next
fix a xs
assume HI: "?Q xs"
have "todos P (rev (a#xs)) = (todos P (rev xs @ [a]))"
by (simp add: "auxiliar")
have "… = ((todos P (rev xs)) ∧ (todos P [a]))"
by (simp add: todos_append)
have "… = (todos P (rev xs) ∧ P a)" by simp
also have Aux: "… = (todos P xs ∧ P a)" using HI by simp
have Aux1: "… = (P a ∧ todos P xs)" by arith
have "(todos P (rev xs) ∧ P a) = (P a ∧ todos P xs)"
using Aux Aux1 by simp
finally show "todos P (rev (a#xs)) = todos P (a#xs)"
by (simp add: todos_append)
qed

(* Comentarios:
+ Ruptura de cadena de igualdades.
+ Uso de hechos auxiliares
+ Uso de arith
*)

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar
josgarsan pablucoto pabrodmac lucnovdos marcarmor13 *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a # xs)) = (todos P ((rev xs)@[a]))" by simp
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "... = (todos P xs ∧ P a)" using HI by simp
also have "... = (P a ∧ todos P xs)" by arith
also have "... = (todos P (a#xs))" by simp
finally show "todos P (rev (a # xs)) = (todos P (a#xs))" by simp
qed

(* ivamenjim *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a # xs)) = (todos P ((rev xs)@[a]))" by simp
also have "... = ((todos P (rev xs)) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)" by arith
finally show "todos P (rev (a # xs)) = todos P (a # xs)" by simp
qed

(* fraortmoy serrodcal *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume H1: "todos P (rev xs) = todos P xs"
have " todos P (rev (a # xs)) = todos P (rev xs @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "… = (todos P xs ∧ todos P [a])" using H1 by simp
also have "… = (todos P [a] ∧ todos P xs)" by arith
finally show "todos P (rev (a # xs)) = todos P (a#xs)" by simp
qed

(* paupeddeg dancorgar *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show " todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs "
have "todos P (rev (a # xs)) = todos P (rev(xs) @ [a])" by simp
also have "... = (todos P (rev xs) ∧ todos P [a]) "
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)" by arith
also have "... = todos P ([a] @ xs)" by (simp add: todos_append)
finally show "todos P (rev (a # xs)) = todos P (a # xs)" by simp
qed

(* wilmorort *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "... = (todos P(rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)"
by (simp add: HOL.conj_commute)
also have "... = todos P([a]@(xs))" by (simp)
finally show "todos P (rev (a#xs))= todos P (a # xs)" by simp
qed

(* Comentario: Uso de HOL.conj_commute *)

(* anaprarod *)
(* es igual que las anteriores pero con el final también con patrones *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by auto
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a#xs)) = todos P (rev xs @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "… = (todos P xs ∧ todos P [a])" using HI by simp
also have "… = (todos P [a] ∧ todos P xs)" by arith
also have "… = todos P (a#xs)" by simp
finally show "?P (a # xs)" by simp
qed

(* danrodcha *)
lemma "todos P (rev xs) = todos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "… = (todos P xs ∧ todos P [a])" using HI by simp
also have "… = (todos P [a] ∧ todos P xs)"
by (simp add: HOL.conj_commute)
also have "… = todos P (a # xs)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar o refutar:
algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)
---------------------------------------------------------------------
*}

lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
oops

(* migtermor ivamenjim ferrenseg paupeddeg crigomgom serrodcal wilmorort
juacabsou rubgonmar anaprarod marpoldia1 fraortmoy josgarsan
danrodcha pablucoto lucnovdos marcarmor13 *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
P={a1}, Q={a2}, xs={a1,a2}.
En este ejemplo:
· "algunos (λx. P x ∧ Q x) xs = False"
· "(algunos P xs ∧ algunos Q xs) = True" *)

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
proof -
assume H1: "xs = [a, b]"
assume H2: "P a = True"
assume H3: "Q a = False"
assume H4: "P b = False"
assume H5: "Q b = True"
have F1: "(algunos P xs ∧ algunos Q xs) = True"
using H1 H2 H3 H4 H5 by simp
have F2: "algunos (λx. P x ∧ Q x) xs = False"
using H1 H2 H3 H4 H5 by simp
have "algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)"
using F1 F2 by simp
oops

text {*
---------------------------------------------------------------------
Ejercicio 7.1. Demostrar o refutar automáticamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 crigomgom rubgonmar wilmorort anaprarod
fraortmoy juacabsou paupeddeg josgarsan danrodcha pablucoto lucnovdos
marcarmor13*)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) simp_all

(* anaprarod dancorgar serrodcal *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 7.2. Demostrar o refutar detalladamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma AUX: "algunos (λa. P (f a)) xs = algunos (P o f) xs"
by (induct xs) auto

lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P (map f (x#xs)) = (algunos P ((f x)#(map f xs)))"
by simp
also have "… = ((P (f x)) ∨ (algunos P (map f xs)))"
by (simp only: algunos.simps(2))
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))"
proof (cases)
assume C1: "(P (f x))"
have Aux: "((P (f x)) ∨ (algunos P (map f xs))) = True"
using C1 by simp
have Aux1: "… = ((P (f x)) ∨ (algunos (P o f) xs))"
using C1 by simp
then show "((P (f x)) ∨ (algunos P (map f xs))) =
((P (f x)) ∨ (algunos (P o f) xs))"
using Aux Aux1 by simp
next
assume C2: "¬(P (f x))"
have Aux2: "((P (f x)) ∨ (algunos P (map f xs))) =
(algunos P (map f xs))" using C2 by simp
have Aux3: "… = (algunos (P o f) xs)" using HI by (simp add: AUX)
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))"
using C2 by simp
then show "((P (f x)) ∨ (algunos P (map f xs))) =
((P (f x)) ∨ (algunos (P o f) xs))"
using Aux2 Aux3 by simp
qed
also have "… = (((P o f) x) ∨ (algunos (P o f) xs))" by simp
also have "… = (algunos (P o f) (x#xs))" by simp
finally show "algunos P (map f (x#xs)) = (algunos (P o f) (x#xs))"
by simp
qed

(* Comentario: Se puede simplificar. *)

(* ferrenseg *)
lemma "algunos P (map f xs) = algunos (P ∘ f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
show "algunos P (map f (x # xs)) = algunos (P ∘ f) (x # xs)"
proof -
have "algunos P (map f (x # xs)) = algunos P ((f x) # (map f xs))"
by simp
also have "… = ((P (f x)) ∨ (algunos P (map f xs)))" by simp
also have "… = (((P ∘ f) x) ∨ (algunos (P ∘ f) xs))"
using HI by simp
also have "… = algunos (P ∘ f) (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* ivamenjim *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = algunos P ((f a)#map f xs)" by simp
also have "... = (algunos P (map f [a]) ∨ algunos P (map f xs))"
by simp
also have "... = (algunos P (map f [a]) ∨ algunos (P ∘ f) xs)"
using HI by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)"
by simp
qed

(* crigomgom rubgonmar anaprarod marpoldia1 juacabsou danrodcha
paupeddeg josgarsan lucnovdos *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (x # xs)) = algunos P ((f x) # (map f xs))"
by simp
also have "... = (P (f x) ∨ algunos P (map f xs))" by simp
also have "... = (P (f x) ∨ algunos (P ∘ f) xs)" using HI by simp
also have "... = ((P ∘ f) x ∨ algunos (P ∘ f) xs)" by simp
finally show "algunos P (map f (x # xs)) = algunos (P ∘ f) (x # xs)"
by simp
qed

(* wilmorort pablucoto marcarmor13*)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?P xs" )
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = (P (f a) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs )" using HI by simp
also have "... = ((P ∘ f) a ∨ algunos (P ∘ f)xs)" by simp
finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)"
by simp
qed

(* fraortmoy serrodcal *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume H1: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) =
(algunos P (map f [a]) ∨ algunos P (map f xs))" by simp
also have "… = (algunos (P ∘ f) [a] ∨ algunos (P ∘ f) xs )"
using H1 by simp
also have "… = algunos (P ∘ f) (a#xs)" by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a#xs)"
by simp
qed

(* danrodcha *)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have " algunos P (map f (a # xs)) = algunos P ((f a)#(map f xs))"
by simp
also have "… = (P (f a) ∨ algunos P (map f xs))" by simp
also have "… = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by blast
also have "… = ((P ∘ f) a ∨ algunos (P ∘ f) xs)" by simp
also have "… = algunos (P ∘ f) (a # xs)" by simp
finally show "?Q (a # xs)" by blast
qed

(* dancorgar *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P o f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P o f) xs"
have "algunos P (map f (x#xs)) = ((P (f x)) ∨ (algunos P (map f xs)))"
by simp
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))" using HI by simp
finally show "algunos P (map f (x#xs)) = algunos (P o f) (x#xs)"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 paupeddeg crigomgom rubgonmar wilmorort
fraortmoy danrodcha pablucoto dancorgar josgarsan anaprarod juacabsou
lucnovdos marcarmor13 *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) simp_all

(* anaprarod *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 8.2. Demostrar o refutar detalladamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg marpoldia1 wilmorort dancorgar josgarsan
juacabsou serrodcal lucnovdos rubgonmar *)
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) = (P a ∨ (algunos P (xs @ ys)))"
by simp
also have "... = (P a ∨ (algunos P xs ∨ algunos P ys))"
using HI by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a # xs) ∨ algunos P ys)" by simp
qed

(* migtermor crigomgom *)
lemma algunos_append2:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P ((x#xs) @ ys) = algunos P (x#(xs @ ys))" by simp
also have "… = ((P x) ∨ (algunos P (xs @ ys)))" by simp
also have "… = ((P x) ∨ (algunos P xs) ∨ (algunos P ys))"
using HI by simp
also have "… = ((algunos P (x#xs)) ∨ (algunos P ys))" by simp
finally show "algunos P ((x#xs) @ ys) =
(algunos P (x#xs) ∨ algunos P ys)" by simp
qed

(* paupeddeg*)
lemma algunos_append3:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) =
(algunos P [a] ∨ ( algunos P (xs @ ys)))" by simp
also have "... = (algunos P [a] ∨ (algunos P xs ∨ algunos P ys))"
using HI by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a # xs) ∨ algunos P ys)" by simp
qed

(* fraortmoy *)
lemma algunos_append4:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show " algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume H1: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) =
(algunos P [a] ∨ algunos P (xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P xs ∨ algunos P ys)"
using H1 by simp
also have "… = ((algunos P [a] ∨ algunos P xs) ∨ algunos P ys)"
by simp
also have "… = (algunos P (a#xs) ∨ algunos P ys)" by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a#xs) ∨ algunos P ys)" by simp
qed

(* danrodcha pablucoto anaprarod marcarmor13 *)
lemma algunos_append5:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P ((a#xs) @ ys) = algunos P (a#(xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P (xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P xs ∨ algunos P ys)"
using HI by simp
also have "… = (algunos P (a # xs) ∨ algunos P ys)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 rubgonmar paupeddeg dancorgar
anaprarod serrodcal *)
lemma "algunos P (rev xs) = algunos P xs"
apply (induct xs)
apply simp
apply (simp add: algunos_append)
apply auto
done

(* ferrenseg crigomgom danrodcha pablucoto josgarsan pabrodmac lucnovdos
marcarmor13 *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs) (auto simp add: algunos_append)

(* wilmorort juacabsou *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs,simp,simp add: algunos_append,auto)

text {*
---------------------------------------------------------------------
Ejercicio 9.2. Demostrar o refutar detalladamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma auxiliar1:
"rev (a#xs) = rev xs @ [a]"
by auto

lemma "algunos P (rev xs) = algunos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P (rev (x#xs)) = (algunos P (rev xs @ [x]))"
using auxiliar1 by simp
also have "… = ((algunos P (rev xs)) ∨ (algunos P [x]))"
by (simp add: algunos_append)
also have "… = ((P x) ∨ (algunos P (rev xs)))" by simp arith
also have "… = ((P x) ∨ (algunos P xs))" using HI by simp
finally show "algunos P (rev (x#xs)) = (algunos P (x#xs))" by simp
qed

(* ferrenseg *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix x xs
assume HI: "algunos P (rev xs) = algunos P xs"
show "algunos P (rev (x # xs)) = algunos P (x # xs)"
proof -
have "algunos P (rev (x # xs)) = algunos P ((rev xs) @ [x])" by simp
also have "… = (algunos P (rev xs) ∨ algunos P [x])"
by (simp add: algunos_append)
also have "… = (algunos P xs ∨ algunos P [x])" using HI by simp
also have "… = (algunos P xs ∨ P x)" by simp
also have "… = (P x ∨ algunos P xs)" by auto
also have "… = algunos P (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* ivamenjim marpoldia1*)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (rev (a # xs)) = (algunos P ((rev xs)@[a]))" by simp
also have "... = ((algunos P (rev xs)) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P [a] ∨ algunos P xs)" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* paupeddeg dancorgar serrodcal lucnovdos*)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI:"algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a # xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = ((algunos P (rev xs)) ∨ (algunos P [a]))"
by (simp add: algunos_append)
also have "... = ((algunos P xs) ∨ (algunos P [a]))" using HI by simp
also have "... = ((algunos P [a]) ∨ (algunos P xs))" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* crigomgom pablucoto anaprarod rubgonmar juacabsou marcarmor13 *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix x xs
assume HI: " algunos P (rev xs) = algunos P xs"
have "algunos P (rev (x # xs)) = algunos P ((rev xs) @ [x])" by simp
also have "... = (algunos P (rev xs) ∨ algunos P [x])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [x])" using HI by simp
also have "... = (algunos P xs ∨ P x)" by simp
also have "... = (P x ∨ algunos P xs)" by arith
also have "... = algunos P (x#xs)" by simp
finally show "algunos P (rev (x # xs)) = algunos P (x # xs)" by simp
qed

(*wilmorort*)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (rev (a#xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = (algunos P(rev xs) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P [a] ∨ algunos P xs)"
by (simp add: HOL.disj_commute)
also have "... = algunos P([a]@(xs))" by (simp)
finally show "algunos P (rev (a#xs))= algunos P (a # xs)" by simp
qed

(* danrodcha *)
lemma "algunos P (rev xs) = algunos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P (rev (a#xs)) = algunos P ((rev xs) @ [a])" by simp
also have "… = (algunos P (rev xs) ∨ algunos P [a])"
by (simp add:algunos_append)
also have "… = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "… = (algunos P [a] ∨ algunos P xs)"
by (simp add: HOL.disj_commute)
also have "… = algunos P (a # xs)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la
siguiente ecuación:
algunos (λx. P x ∨ Q x) xs = Z
y demostrar la equivalencia de forma automática y detallada.
---------------------------------------------------------------------
*}

(* migtermor *)
lemma "algunos (λx. P x ∨ Q x) xs =
((algunos (λx. P x) xs) ∨ (algunos (λx. Q x) xs))"
by (induct xs) auto

lemma "algunos (λx. P x ∨ Q x) xs =
((algunos (λx. P x) xs) ∨ (algunos (λx. Q x) xs))" (is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix x xs
assume HI: "?R xs"
have "algunos (λx. P x ∨ Q x) (x#xs) =
(((λx. P x ∨ Q x) x) ∨ (algunos (λx. P x ∨ Q x) xs))" by simp
also have "… = ((P x ∨ Q x) ∨ (algunos (λx. P x ∨ Q x) xs))" by simp
also have H1: "… = ((((λx. P x) x) ∨ (algunos (λx. P x) xs)) ∨
(((λx. Q x) x) ∨ (algunos (λx. Q x) xs)))"
using HI by simp arith
have H2: "… = ((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
by simp
have C: "(algunos (λx. P x ∨ Q x) (x#xs)) =
((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
using H1 H2 by simp
finally show "(algunos (λx. P x ∨ Q x) (x#xs)) =
((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
using C by simp
qed

(* CComentario: Ruptura de la cadena de igualdades. *)

(* ferrenseg *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix x xs
assume HI: "algunos (λx. (P x ∨ Q x)) xs = (algunos P xs ∨ algunos Q xs)"
show "algunos (λx. P x ∨ Q x) (x # xs) =
(algunos P (x # xs) ∨ algunos Q (x # xs))"
proof -
have "algunos (λx. P x ∨ Q x) (x # xs) =
((P x) ∨ (Q x) ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "… = ((P x) ∨ (Q x) ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "… = (((P x) ∨ algunos P xs) ∨ ((Q x) ∨ algunos Q xs))"
by auto
also have "… = (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp
finally show ?thesis by simp
qed
qed

(* Comentario: Uso de auto *)

(* ivamenjim marpoldia1 paupeddeg *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix a xs
assume HI: "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P (a # xs) ∨ algunos Q (a # xs))" by auto
qed

(* Comentario: Uso de auto *)

(* wilmorort danrodcha anaprarod juacabsou rubgonmar *)
lemma "algunos (λx. P x ∨ Q x) xs =
(¬todos(λx. ¬P x)xs ∨ ¬todos(λx. ¬Q x)xs)"
by (induct xs) auto

(* wilmorort *)
lemma "algunos (λx. P x ∨ Q x) xs =
(¬todos(λx. ¬P x)xs ∨ ¬todos(λx. ¬Q x)xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨
(¬ todos (λx. ¬ P x) xs ∨ ¬ todos (λx. ¬ Q x) xs))"
using HI by simp
also have "... = (P a ∨ ¬ todos (λx. ¬ P x) xs ∨
Q a ∨ ¬ todos (λx. ¬ Q x) xs )" by arith
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(~ todos (λx. ¬ P x) (a # xs) ∨
~ todos (λx. ¬ Q x) (a # xs))" by simp
qed

(* danrodcha *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix a xs assume HI: "?R xs"
have 1:" (Q a ∨ algunos P xs) = (algunos P xs ∨ Q a)"
by (simp add: HOL.disj_commute)
have "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P [a] ∨ algunos Q [a] ∨ algunos (λx. P x ∨ Q x) xs)"
by simp
also have "… = (P a ∨ (Q a ∨ algunos P xs) ∨ algunos Q xs)"
using HI by simp
also have "… = (P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)"
using 1 by simp
also have "… = (algunos P (a # xs) ∨ algunos Q (a # xs))" by simp
finally show "?R (a # xs)" by simp
qed

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
apply (induct xs)
apply auto
done

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∧ Q x) [] ⟹ (algunos P [] ∧ algunos Q [])"
by simp
next
fix xf xs
assume HI: "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
have F1: "algunos (λx. P x ∧ Q x) (xf#xs) ⟹
((P xf ∧ Q xf) ∨ algunos (λx. P x ∧ Q x) xs)" by simp
also have F2: "… ⟹ (P xf ∧ Q xf ∨ (algunos P xs ∧ algunos Q xs))"
using HI by simp
have F3: "((P xf ∧ Q xf) ∨ (algunos P xs ∧ algunos Q xs)) ⟹
((P xf ∨ algunos P xs) ∧ (Q xf ∨ algunos Q xs))" by blast
have F4: "((P xf ∨ algunos P xs) ∧ (Q xf ∨ algunos Q xs)) ⟹
(algunos P (xf#xs) ∧ algunos Q (xf#xs))" by simp
show "algunos (λx. P x ∧ Q x) (xf#xs) ⟹
(algunos P (xf#xs) ∧ algunos Q (xf#xs))"
using F1 F2 F3 F4 by blast
qed

(* pablucoto crigomgom serrodcal marcarmor13 *)
-- "Automatica"
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

-- "Detallada"
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs) "
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q []) "
by simp
next
fix a xs
assume HI: " algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ (algunos P xs ∨ algunos Q xs))"
using HI by simp
also have "… = (((P a) ∨ algunos P xs) ∨ ((Q a) ∨ algunos Q xs))"
by arith
also have "… = (algunos P (a#xs) ∨ algunos Q (a#xs))" by simp
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P (a # xs) ∨ algunos Q (a # xs)) " by simp
qed

(* anaprarod juacabsou rubgonmar *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "algunos (λx. P x ∨ Q x) (x#xs) =
(P x ∨ Q x ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "… = (P x ∨ Q x ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "… = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith
finally show "?P (x#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 11.1. Demostrar o refutar automáticamente
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

(* ivamenjim wilmorort migtermor marpoldia1 crigomgom rubgonmar
paupeddeg danrodcha pablucoto dancorgar josgarsan anaprarod juacabsou
lucnovdos serrodcal marcarmor13 *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) simp_all

(* anaprarod *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 11.2. Demostrar o refutar datalladamente
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 crigomgom paupeddeg josgarsan
juacabsou serrodcal wilmorort *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. ¬ P x) xs)"
have "algunos P (a # xs) = (P a ∨ (algunos P xs))" by simp
also have "... = (P a ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp
finally show "algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # xs))"
by simp
qed

(* ferrenseg *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix x xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
show "algunos P (x # xs) = (¬ todos (λx. (¬ P x)) (x # xs))"
proof -
have "algunos P (x # xs) = ((P x) ∨ algunos P xs)" by simp
also have "… = ((P x) ∨ ¬ todos (λx. (¬ P x)) xs)" using HI by simp
also have "… = (¬ (¬ (P x) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos (λx. (¬ P x)) (x # xs))" by simp
finally show ?thesis by simp
qed
qed

(* danrodcha pablucoto anaprarod rubgonmar marcarmor13 *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P (a # xs) = (P a ∨ algunos P xs)" by simp
also have "… = (P a ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "… = (¬(¬(P a) ∧ todos(λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos(λx. (¬ P x)) (a # xs))" by simp
finally show "?Q (a # xs)" by simp
qed

(* dancorgar*)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix xf xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (xf#xs) = ((P xf) ∨ algunos P xs)" by simp
also have "… = ( (P xf) ∨ (¬ todos (λx. (¬ P x)) xs) )"
using HI by simp
also have "… = (¬((¬P xf) ∧ (todos (λx. (¬ P x)) xs)))" by simp
finally show "algunos P (xf#xs) = (¬todos (λx. (¬ P x)) (xf#xs))"
by simp
qed

(* lucnovdos*)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix n xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (n#xs) = ((P n) ∨ (algunos P xs))" by simp
also have "… = ((P n) ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "… = (¬((¬P n) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos (λx. (¬ P x)) (n#xs))" by simp
finally show "algunos P (n#xs) = (¬ todos (λx. (¬ P x)) (n#xs))"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg migtermor serrodcal crigomgom rubgonmar
marpoldia1 paupeddeg danrodcha dancorgar pablucoto anaprarod
juacabsou lucnovdos marcarmor13 wilmorort *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 13. Expresar la relación existente entre estaEn y algunos.
Demostrar dicha relación de forma automática y detallada.
---------------------------------------------------------------------
*}

(* migtermor crigomgom *)
lemma "estaEn x xs = (algunos (λa. a=x) xs)"
by (induct xs) auto

lemma auxiliar13:
"(x=a) = ((λa. a=x) a)"
by auto

lemma "estaEn x xs = (algunos (λa. a=x) xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "estaEn x (a#xs) = ((a=x) ∨ (estaEn x xs))" by simp
also have H: "… = ((a=x) ∨ (algunos (λa. a=x) xs))" using HI by simp
also have "… = (((λa. a=x) a) ∨ (algunos (λa. a=x) xs))"
using auxiliar13 by simp
also have "… = (algunos (λa. a=x) (a#xs))" by simp
have C: "estaEn x (a#xs) = (algunos (λa. a=x) (a#xs))" using H by simp
finally show "estaEn x (a#xs) = (algunos (λa. a=x) (a#xs))"
using C by simp
qed

(* Comentario: Ruptura de la cadena de igualdades. Se puede simplificar. *)

(* ferrenseg *)
lemma estaEn_algunos:
"estaEn y xs = algunos (λx. x=y) xs"
by (induct xs) auto

lemma estaEn_algunos_2:
"estaEn y xs = algunos (λx. x=y) xs"
proof (induct xs)
show "estaEn y [] = algunos (λx. x=y) []" by simp
next
fix x xs
assume HI: "estaEn y xs = algunos (λx. x=y) xs"
show "estaEn y (x # xs) = algunos (λx. x=y) (x # xs)"
proof -
have "estaEn y (x # xs) = (y=x ∨ estaEn y xs)" by simp
also have "… = (y=x ∨ algunos (λx. x=y) xs)" using HI by simp
also have "… = (x=y ∨ algunos (λx. x=y) xs)" by auto
also have "… = algunos (λx. x=y) (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* Comentario: Uso de auto *)

(* crigomgom paupeddeg dancorgar juacabsou serrodcal lucnovdos wilmorort *)
lemma "estaEn a xs = algunos (λx. x = a) xs"
by (induct xs) auto

lemma "estaEn x xs = (algunos (λa. a=x) xs)"
proof (induct xs)
show " estaEn x [] = algunos (λa. a = x) []" by simp
next
fix a xs
assume HI: "estaEn x xs = algunos (λa. a = x) xs"
have "estaEn x (a # xs) = (a = x ∨ estaEn x xs)" by simp
also have "... = (a = x ∨ algunos (λa. a = x) xs)" using HI by simp
finally show " estaEn x (a # xs) = algunos (λa. a = x) (a # xs)"
by simp
qed

(* ivamenjim marpoldia1 *)
lemma "estaEn x xs = algunos (λy. x=y) xs"
by (induct xs) auto

lemma "estaEn x xs = algunos (λy. x=y) xs"
proof (induct xs)
show "estaEn x [] = algunos (op = x) []" by simp
next
fix a xs
assume HI: "estaEn x xs = algunos (op = x) xs"
have "estaEn x (a # xs) = ((a = x) ∨ (estaEn x xs))" by simp
also have "... = (a = x ∨ algunos (op = x) xs)" using HI by simp
finally show " estaEn x (a # xs) = algunos (op = x) (a # xs)" by auto
qed

(* Comentarios:
+ Uso de (op = x)
+ Uso de auto
*)

(* danrodcha *)
lemma "estaEn a xs = algunos (op = a) xs"
by (induct xs) auto

(* danrodcha *)
lemma "estaEn a xs = algunos (op = a) xs"
proof (induct xs)
show "estaEn a [] = algunos (op = a) []" by simp
next
fix x xs
assume HI: "estaEn a xs = algunos (op = a) xs"
have "estaEn a (x # xs) = ((x = a) ∨ (estaEn a xs))" by simp
also have "… = (x = a ∨ algunos (op = a) xs)" using HI by simp
also have "… = ((op = a) x ∨ algunos (op = a) xs)"
by (simp add:HOL.eq_commute)
also have "… = algunos (op = a) (x # xs)" by simp
finally show "estaEn a (x # xs) = algunos (op = a) (x # xs)" by simp
qed

(* pablucoto marcarmor13*)
-- "Automatica"
lemma " estaEn y xs = algunos (λx. x=y) xs"
by (induct xs) auto

-- "Detallada"
lemma " estaEn y xs = algunos (λx. x=y) xs"
proof (induct xs)
show "estaEn y [] = algunos (λx. x = y) []" by simp
next
fix a xs
assume HI: " estaEn y xs = algunos (λx. x = y) xs "
have "estaEn y (a # xs) = (y = a ∨ estaEn y xs)" by simp
also have "... = (y = a ∨ algunos (λx. x = y) xs) " using HI by simp
also have "… = (a=y ∨ algunos (λx. x=y) xs)" by auto
also have "... = (algunos (λx. x = y) (a#xs))" by simp
finally show "estaEn y (a # xs) = algunos (λx. x = y) (a # xs) "
by simp
qed

(* Comentario: Uso de auto *)

(* anaprarod *)
(* Automática*)
lemma "estaEn a xs = algunos (λx. a=x) xs" (is "?P xs")
by (induct xs) auto

(* Detallada (igual que las anteriores pero obviando el paso previo al
finally) *)
lemma "estaEn a xs = algunos (λx. a=x) xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI : "?P xs"
have "estaEn a (x#xs) = (x=a ∨ estaEn a xs)" by simp
also have "… = (x=a ∨ algunos (λx. a=x) xs)" using HI by simp
also have "… = (a=x ∨ algunos (λx. a=x) xs)" using HI by auto
finally show "?P (x#xs)" by simp
qed

(* Comentario: Uso de auto *)

end
</source>

Relación 4

2016-11-24T21:53:45Z

Wilmorort:

<source lang="isar">
chapter {* R4: Cuantificadores sobre listas *}

theory R4_Cuantificadores_sobre_listas
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (todos p xs) se verifica si todos los elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
todos (λx. 1<length x) [[2,1,4],[1,3]]
¬todos (λx. 1<length x) [[2,1,4],[3]]

Nota: La función todos es equivalente a la predefinida list_all.
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar wilmorort marpoldia1
ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou
rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1
marcarmor13 *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (algunos p xs) se verifica si algunos elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
algunos (λx. 1<length x) [[2,1,4],[3]]
¬algunos (λx. 1<length x) [[],[3]]"

Nota: La función algunos es equivalente a la predefinida list_ex.
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar marpoldia1 ferrenseg
wilmorort paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou
rubgonmar josgarsan fraortmoy lucnovdos pabrodmac marcarmor13 *)
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (p x ∨ algunos p xs)"

(* fracorjim1. En esta versión el procesamiento se detiene al encontrar
una coincidencia *)
fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos2 p [] = False"
| "algunos2 p (x#xs) = (if p x then True else algunos2 p xs)"

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar o refutar automáticamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim migtermor dancorgar marpoldia1 ferrenseg
wilmorort paupeddeg pablucoto anaprarod serrodcal juacabsou rubgonmar
josgarsan fraortmoy lucnovdos pabrodmac marcarmor13 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

(* fracorjim1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

(* danrodcha fracorjim1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix a xs
assume HI: "?R xs"
have "todos (λx. P x ∧ Q x) (a#xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "… = (P a ∧ Q a ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))" by blast
also have "… = (todos P (a#xs) ∧ todos Q (a#xs))" by simp
finally show "?R (a#xs)" by simp
qed

(* Comentario: Uso de blast. *)

(* ivamenjim wilmorort serrodcal josgarsan*)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
finally show "todos (λx. P x ∧ Q x) (a # xs) =
(todos P (a # xs) ∧ todos Q (a # xs))" by auto
qed

(* Comentario: Uso de auto. *)

(* dancorgar paupeddeg *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix y xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (y#xs) =
((P y ∧ Q y) ∧ (todos (λx. P x ∧ Q x) xs))" by simp
also have "… = ((P y ∧ Q y) ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P y ∧ todos P xs) ∧ (Q y ∧ todos Q xs))" by blast
also have "… = ((todos P (y#xs)) ∧ (todos Q (y#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (y#xs) =
(todos P (y#xs) ∧ todos Q (y#xs))" by simp
qed

(* migtermor *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix x xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "(todos (λx. P x ∧ Q x) (x#xs)) =
(( P x ∧ Q x) ∧ (todos (λx. P x ∧ Q x) xs))"
by (simp only: todos.simps(2))
also have "… = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "… = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))"
by arith
also have "((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs)) = (((P x)∧(todos P xs)) ∧ ((Q x) ∧ (todos Q xs)))"
by arith
(* Este paso es exactamente el mismo que el anterior, pero sin
cualquiera de los dos no funciona el "finally show" *)
have "… = (((P x)∧(todos P xs))∧((Q x)∧(todos Q xs)))" by simp
have "… = ((todos P (x#xs))∧(todos Q (x#xs)))" by simp
finally show "(todos (λx. P x ∧ Q x) (x#xs)) =
((todos P (x#xs)) ∧ (todos Q (x#xs)))" by simp
qed

(* Comentarios: Ruptura de la cadena de igualdades y uso de arith. *)

(* marpoldia1 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
((P a ∧ Q a) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))" by blast
also have "... = (todos P (a#xs) ∧ todos Q (a#xs)) " by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) =
(todos P (a#xs) ∧ todos Q (a#xs))" by simp
qed

(* ferrenseg *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
(P n ∧ Q n ∧ todos P xs ∧ todos Q xs)" using HI by simp
also have "… = P n ∧ Q n ∧ todos P xs ∧ todos Q xs" by blast
also have "⋯ = todos P (n # xs) ∧ todos Q (n # xs)" by simp
finally show "todos (λx. P x ∧ Q x) (n # xs) = todos P (n # xs) ∧ todos Q (n # xs)" by simp
oops

(* Comentario: Demostración incompleta. *)

(* lucnovdos *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
((P n ∧ Q n) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P n ∧ todos P xs) ∧ (Q n ∧ todos Q xs))" by arith
also have "... = ((todos P(n#xs)) ∧ (todos Q(n#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (n#xs) =
(todos P (n#xs) ∧ todos Q (n#xs))" by simp
qed

(* wilmorort pablucoto crigomgom anaprarod juacabsou rubgonmar fraortmoy
marcarmor13 *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a # xs) =
(P a ∧ Q a ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
also have "... = (P a ∧ todos P xs ∧ Q a ∧ todos Q xs)" by arith
also have "... = (todos P (a # xs) ∧ todos Q (a # xs))" by simp
(* Este paso se puede obviar *)
finally show "todos (λx. P x ∧ Q x) (a # xs) =
(todos P (a # xs) ∧ todos Q (a # xs))" by simp
qed

(* pabrodmac *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix x xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (x#xs) =
(P x ∧ Q x ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P x ∧ Q x ∧ (todos P xs ∧ todos Q xs))"
using HI by simp
also have "... = (P x ∧ todos P xs ∧ Q x ∧ todos Q xs)" by arith
finally show "todos (λx. P x ∧ Q x) (x#xs) =
(todos P (x#xs) ∧ todos Q (x#xs))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* danrodcha ivamenjim marpoldia1 migtermor ferrenseg wilmorort
paupeddeg crigomgom anaprarod serrodcal juacabsou rubgonmar pablucoto
fraortmoy josgarsan lucnovdos pabrodmac marcarmor13 *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

(* anaprarod dancorgar fracorjim1 *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
apply (induct x)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg wilmorort dancorgar fraortmoy josgarsan lucnovdos
rubgonmar *)
lemma todos_append:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ (todos P (x @ y)))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* migtermor serrodcal *)
lemma todos_append1:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?P x")
proof (induct x)
show "?P []" by simp
next
fix a x
assume HI: "?P x"
have "todos P ((a#x) @ y) = (P a ∧ (todos P (x @ y)))" by simp
also have "… = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "?P (a#x)" by simp
qed

(* marpoldia1 *)
lemma todos_append2:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = todos P (a#(x@y))" by simp
also have "... = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* paupeddeg *)
lemma todos_append3:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = todos P (a # (x @ y))" by simp
also have "... = (todos P [a] ∧ todos P (x @ y)) " by simp
also have "... = (todos P [a] ∧ (todos P x ∧ todos P y))"
using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by simp
qed

(* crigomgom juacabsou anaprarod*)
lemma todos_append4:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix x xs
assume HI:"todos P (xs @ y) = (todos P xs ∧ todos P y)"
have "todos P ((x # xs) @ y) = (P x ∧ todos P (xs @ y ))" by simp
also have "... = (P x ∧ (todos P xs ∧ todos P y)) " using HI by simp
also have "... = ((P x ∧ todos P xs) ∧ todos P y)" by simp
finally show "todos P ((x # xs) @ y) = (todos P (x # xs) ∧ todos P y)"
by simp
qed

(* pablucoto marcarmor13 *)
lemma todos_append5:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x )
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI:"todos P (x @ y) = (todos P x ∧ todos P y) "
have "todos P ((a # x) @ y) = ( P a ∧ todos P (x @ y))" by simp
also have " ... =( P a ∧ (todos P x ∧ todos P y))" using HI by simp
also have "... = (todos P (a#x) ∧ todos P y)" by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)"
by auto
qed

(* Comentario: Uso de auto. *)

(* danrodcha *)
lemma todos_append6:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?Q x")
proof (induct x)
show "?Q []" by simp
next
fix x a assume HI: "?Q x"
have "todos P ((a # x) @ y) = todos P (a # x @ y)" by simp
also have "… = ((P a) ∧ todos P (x @ y))" by simp
also have "… = ((P a) ∧ (todos P x ∧ todos P y))" using HI by simp
also have "… = (todos P (a # x) ∧ todos P y)" by simp
finally show "?Q (a # x)" by simp
qed

(* pabrodmac *)
lemma todos_append7:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp
finally show "todos P ((a#x) @ y) = (todos P (a#x) ∧ todos P y)"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* migtermor ivamenjim marpoldia1 serrodcal anaprarod paupeddeg
dancorgar *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs)
apply simp
apply (simp add: todos_append)
apply auto
done

(* ferrenseg crigomgom rubgonmar fraortmoy josgarsan danrodcha lucnovdos
pabrodmac *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto simp add: todos_append)

(* wilmorort *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs, simp, simp add: todos_append,auto)

(* Comentario: Pasos dentro de by *)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs, simp, simp add: todos_append, auto)
done

(* Comentario: Pasos dentro de apply *)

(* pablucoto marcarmor13 *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)

(* Comentario: Uso de simp_all *)

lemma "todos P (rev xs) = todos P xs"
by (induct xs) (simp_all add: todos_append, auto)

(* Comentario: Uso de add en simp_all *)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma auxiliar:
"rev (a#xs) = rev xs @ [a]"
by auto

lemma "todos P (rev xs) = todos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by (simp only: rev.simps(1))
next
fix a xs
assume HI: "?Q xs"
have "todos P (rev (a#xs)) = (todos P (rev xs @ [a]))"
by (simp add: "auxiliar")
have "… = ((todos P (rev xs)) ∧ (todos P [a]))"
by (simp add: todos_append)
have "… = (todos P (rev xs) ∧ P a)" by simp
also have Aux: "… = (todos P xs ∧ P a)" using HI by simp
have Aux1: "… = (P a ∧ todos P xs)" by arith
have "(todos P (rev xs) ∧ P a) = (P a ∧ todos P xs)"
using Aux Aux1 by simp
finally show "todos P (rev (a#xs)) = todos P (a#xs)"
by (simp add: todos_append)
qed

(* Comentarios:
+ Ruptura de cadena de igualdades.
+ Uso de hechos auxiliares
+ Uso de arith
*)

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar
josgarsan pablucoto pabrodmac lucnovdos marcarmor13 *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a # xs)) = (todos P ((rev xs)@[a]))" by simp
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "... = (todos P xs ∧ P a)" using HI by simp
also have "... = (P a ∧ todos P xs)" by arith
also have "... = (todos P (a#xs))" by simp
finally show "todos P (rev (a # xs)) = (todos P (a#xs))" by simp
qed

(* ivamenjim *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a # xs)) = (todos P ((rev xs)@[a]))" by simp
also have "... = ((todos P (rev xs)) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)" by arith
finally show "todos P (rev (a # xs)) = todos P (a # xs)" by simp
qed

(* fraortmoy serrodcal *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume H1: "todos P (rev xs) = todos P xs"
have " todos P (rev (a # xs)) = todos P (rev xs @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "… = (todos P xs ∧ todos P [a])" using H1 by simp
also have "… = (todos P [a] ∧ todos P xs)" by arith
finally show "todos P (rev (a # xs)) = todos P (a#xs)" by simp
qed

(* paupeddeg dancorgar *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show " todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs "
have "todos P (rev (a # xs)) = todos P (rev(xs) @ [a])" by simp
also have "... = (todos P (rev xs) ∧ todos P [a]) "
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)" by arith
also have "... = todos P ([a] @ xs)" by (simp add: todos_append)
finally show "todos P (rev (a # xs)) = todos P (a # xs)" by simp
qed

(* wilmorort *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "... = (todos P(rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)"
by (simp add: HOL.conj_commute)
also have "... = todos P([a]@(xs))" by (simp)
finally show "todos P (rev (a#xs))= todos P (a # xs)" by simp
qed

(* Comentario: Uso de HOL.conj_commute *)

(* anaprarod *)
(* es igual que las anteriores pero con el final también con patrones *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by auto
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a#xs)) = todos P (rev xs @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "… = (todos P xs ∧ todos P [a])" using HI by simp
also have "… = (todos P [a] ∧ todos P xs)" by arith
also have "… = todos P (a#xs)" by simp
finally show "?P (a # xs)" by simp
qed

(* danrodcha *)
lemma "todos P (rev xs) = todos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])"
by (simp add:todos_append)
also have "… = (todos P xs ∧ todos P [a])" using HI by simp
also have "… = (todos P [a] ∧ todos P xs)"
by (simp add: HOL.conj_commute)
also have "… = todos P (a # xs)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar o refutar:
algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)
---------------------------------------------------------------------
*}

lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
oops

(* migtermor ivamenjim ferrenseg paupeddeg crigomgom serrodcal wilmorort
juacabsou rubgonmar anaprarod marpoldia1 fraortmoy josgarsan
danrodcha pablucoto lucnovdos marcarmor13 *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
P={a1}, Q={a2}, xs={a1,a2}.
En este ejemplo:
· "algunos (λx. P x ∧ Q x) xs = False"
· "(algunos P xs ∧ algunos Q xs) = True" *)

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
proof -
assume H1: "xs = [a, b]"
assume H2: "P a = True"
assume H3: "Q a = False"
assume H4: "P b = False"
assume H5: "Q b = True"
have F1: "(algunos P xs ∧ algunos Q xs) = True"
using H1 H2 H3 H4 H5 by simp
have F2: "algunos (λx. P x ∧ Q x) xs = False"
using H1 H2 H3 H4 H5 by simp
have "algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)"
using F1 F2 by simp
oops

text {*
---------------------------------------------------------------------
Ejercicio 7.1. Demostrar o refutar automáticamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 crigomgom rubgonmar wilmorort anaprarod
fraortmoy juacabsou paupeddeg josgarsan danrodcha pablucoto lucnovdos
marcarmor13*)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) simp_all

(* anaprarod dancorgar serrodcal *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 7.2. Demostrar o refutar detalladamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma AUX: "algunos (λa. P (f a)) xs = algunos (P o f) xs"
by (induct xs) auto

lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P (map f (x#xs)) = (algunos P ((f x)#(map f xs)))"
by simp
also have "… = ((P (f x)) ∨ (algunos P (map f xs)))"
by (simp only: algunos.simps(2))
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))"
proof (cases)
assume C1: "(P (f x))"
have Aux: "((P (f x)) ∨ (algunos P (map f xs))) = True"
using C1 by simp
have Aux1: "… = ((P (f x)) ∨ (algunos (P o f) xs))"
using C1 by simp
then show "((P (f x)) ∨ (algunos P (map f xs))) =
((P (f x)) ∨ (algunos (P o f) xs))"
using Aux Aux1 by simp
next
assume C2: "¬(P (f x))"
have Aux2: "((P (f x)) ∨ (algunos P (map f xs))) =
(algunos P (map f xs))" using C2 by simp
have Aux3: "… = (algunos (P o f) xs)" using HI by (simp add: AUX)
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))"
using C2 by simp
then show "((P (f x)) ∨ (algunos P (map f xs))) =
((P (f x)) ∨ (algunos (P o f) xs))"
using Aux2 Aux3 by simp
qed
also have "… = (((P o f) x) ∨ (algunos (P o f) xs))" by simp
also have "… = (algunos (P o f) (x#xs))" by simp
finally show "algunos P (map f (x#xs)) = (algunos (P o f) (x#xs))"
by simp
qed

(* Comentario: Se puede simplificar. *)

(* ferrenseg *)
lemma "algunos P (map f xs) = algunos (P ∘ f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
show "algunos P (map f (x # xs)) = algunos (P ∘ f) (x # xs)"
proof -
have "algunos P (map f (x # xs)) = algunos P ((f x) # (map f xs))"
by simp
also have "… = ((P (f x)) ∨ (algunos P (map f xs)))" by simp
also have "… = (((P ∘ f) x) ∨ (algunos (P ∘ f) xs))"
using HI by simp
also have "… = algunos (P ∘ f) (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* ivamenjim *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = algunos P ((f a)#map f xs)" by simp
also have "... = (algunos P (map f [a]) ∨ algunos P (map f xs))"
by simp
also have "... = (algunos P (map f [a]) ∨ algunos (P ∘ f) xs)"
using HI by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)"
by simp
qed

(* crigomgom rubgonmar anaprarod marpoldia1 juacabsou danrodcha
paupeddeg josgarsan lucnovdos *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (x # xs)) = algunos P ((f x) # (map f xs))"
by simp
also have "... = (P (f x) ∨ algunos P (map f xs))" by simp
also have "... = (P (f x) ∨ algunos (P ∘ f) xs)" using HI by simp
also have "... = ((P ∘ f) x ∨ algunos (P ∘ f) xs)" by simp
finally show "algunos P (map f (x # xs)) = algunos (P ∘ f) (x # xs)"
by simp
qed

(* wilmorort pablucoto marcarmor13*)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?P xs" )
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = (P (f a) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs )" using HI by simp
also have "... = ((P ∘ f) a ∨ algunos (P ∘ f)xs)" by simp
finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)"
by simp
qed

(* fraortmoy serrodcal *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume H1: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) =
(algunos P (map f [a]) ∨ algunos P (map f xs))" by simp
also have "… = (algunos (P ∘ f) [a] ∨ algunos (P ∘ f) xs )"
using H1 by simp
also have "… = algunos (P ∘ f) (a#xs)" by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a#xs)"
by simp
qed

(* danrodcha *)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have " algunos P (map f (a # xs)) = algunos P ((f a)#(map f xs))"
by simp
also have "… = (P (f a) ∨ algunos P (map f xs))" by simp
also have "… = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by blast
also have "… = ((P ∘ f) a ∨ algunos (P ∘ f) xs)" by simp
also have "… = algunos (P ∘ f) (a # xs)" by simp
finally show "?Q (a # xs)" by blast
qed

(* dancorgar *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P o f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P o f) xs"
have "algunos P (map f (x#xs)) = ((P (f x)) ∨ (algunos P (map f xs)))"
by simp
also have "… = ((P (f x)) ∨ (algunos (P o f) xs))" using HI by simp
finally show "algunos P (map f (x#xs)) = algunos (P o f) (x#xs)"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 paupeddeg crigomgom rubgonmar wilmorort
fraortmoy danrodcha pablucoto dancorgar josgarsan anaprarod juacabsou
lucnovdos marcarmor13 *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) simp_all

(* anaprarod *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 8.2. Demostrar o refutar detalladamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg marpoldia1 wilmorort dancorgar josgarsan
juacabsou serrodcal lucnovdos rubgonmar *)
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) = (P a ∨ (algunos P (xs @ ys)))"
by simp
also have "... = (P a ∨ (algunos P xs ∨ algunos P ys))"
using HI by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a # xs) ∨ algunos P ys)" by simp
qed

(* migtermor crigomgom *)
lemma algunos_append2:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P ((x#xs) @ ys) = algunos P (x#(xs @ ys))" by simp
also have "… = ((P x) ∨ (algunos P (xs @ ys)))" by simp
also have "… = ((P x) ∨ (algunos P xs) ∨ (algunos P ys))"
using HI by simp
also have "… = ((algunos P (x#xs)) ∨ (algunos P ys))" by simp
finally show "algunos P ((x#xs) @ ys) =
(algunos P (x#xs) ∨ algunos P ys)" by simp
qed

(* paupeddeg*)
lemma algunos_append3:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) =
(algunos P [a] ∨ ( algunos P (xs @ ys)))" by simp
also have "... = (algunos P [a] ∨ (algunos P xs ∨ algunos P ys))"
using HI by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a # xs) ∨ algunos P ys)" by simp
qed

(* fraortmoy *)
lemma algunos_append4:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show " algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume H1: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a # xs) @ ys) =
(algunos P [a] ∨ algunos P (xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P xs ∨ algunos P ys)"
using H1 by simp
also have "… = ((algunos P [a] ∨ algunos P xs) ∨ algunos P ys)"
by simp
also have "… = (algunos P (a#xs) ∨ algunos P ys)" by simp
finally show "algunos P ((a # xs) @ ys) =
(algunos P (a#xs) ∨ algunos P ys)" by simp
qed

(* danrodcha pablucoto anaprarod marcarmor13 *)
lemma algunos_append5:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P ((a#xs) @ ys) = algunos P (a#(xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P (xs @ ys))" by simp
also have "… = (algunos P [a] ∨ algunos P xs ∨ algunos P ys)"
using HI by simp
also have "… = (algunos P (a # xs) ∨ algunos P ys)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 rubgonmar paupeddeg dancorgar
anaprarod serrodcal *)
lemma "algunos P (rev xs) = algunos P xs"
apply (induct xs)
apply simp
apply (simp add: algunos_append)
apply auto
done

(* ferrenseg crigomgom danrodcha pablucoto josgarsan pabrodmac lucnovdos
marcarmor13 *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs) (auto simp add: algunos_append)

(* wilmorort juacabsou *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs,simp,simp add: algunos_append,auto)

text {*
---------------------------------------------------------------------
Ejercicio 9.2. Demostrar o refutar detalladamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* migtermor *)
lemma auxiliar1:
"rev (a#xs) = rev xs @ [a]"
by auto

lemma "algunos P (rev xs) = algunos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix x xs
assume HI: "?Q xs"
have "algunos P (rev (x#xs)) = (algunos P (rev xs @ [x]))"
using auxiliar1 by simp
also have "… = ((algunos P (rev xs)) ∨ (algunos P [x]))"
by (simp add: algunos_append)
also have "… = ((P x) ∨ (algunos P (rev xs)))" by simp arith
also have "… = ((P x) ∨ (algunos P xs))" using HI by simp
finally show "algunos P (rev (x#xs)) = (algunos P (x#xs))" by simp
qed

(* ferrenseg *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix x xs
assume HI: "algunos P (rev xs) = algunos P xs"
show "algunos P (rev (x # xs)) = algunos P (x # xs)"
proof -
have "algunos P (rev (x # xs)) = algunos P ((rev xs) @ [x])" by simp
also have "… = (algunos P (rev xs) ∨ algunos P [x])"
by (simp add: algunos_append)
also have "… = (algunos P xs ∨ algunos P [x])" using HI by simp
also have "… = (algunos P xs ∨ P x)" by simp
also have "… = (P x ∨ algunos P xs)" by auto
also have "… = algunos P (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* ivamenjim marpoldia1*)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (rev (a # xs)) = (algunos P ((rev xs)@[a]))" by simp
also have "... = ((algunos P (rev xs)) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P [a] ∨ algunos P xs)" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* paupeddeg dancorgar serrodcal lucnovdos*)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI:"algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a # xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = ((algunos P (rev xs)) ∨ (algunos P [a]))"
by (simp add: algunos_append)
also have "... = ((algunos P xs) ∨ (algunos P [a]))" using HI by simp
also have "... = ((algunos P [a]) ∨ (algunos P xs))" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* crigomgom pablucoto anaprarod rubgonmar juacabsou marcarmor13 *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix x xs
assume HI: " algunos P (rev xs) = algunos P xs"
have "algunos P (rev (x # xs)) = algunos P ((rev xs) @ [x])" by simp
also have "... = (algunos P (rev xs) ∨ algunos P [x])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [x])" using HI by simp
also have "... = (algunos P xs ∨ P x)" by simp
also have "... = (P x ∨ algunos P xs)" by arith
also have "... = algunos P (x#xs)" by simp
finally show "algunos P (rev (x # xs)) = algunos P (x # xs)" by simp
qed

(*wilmorort*)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (rev (a#xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = (algunos P(rev xs) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P [a] ∨ algunos P xs)"
by (simp add: HOL.disj_commute)
also have "... = algunos P([a]@(xs))" by (simp)
finally show "algunos P (rev (a#xs))= algunos P (a # xs)" by simp
qed

(* danrodcha *)
lemma "algunos P (rev xs) = algunos P xs" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P (rev (a#xs)) = algunos P ((rev xs) @ [a])" by simp
also have "… = (algunos P (rev xs) ∨ algunos P [a])"
by (simp add:algunos_append)
also have "… = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "… = (algunos P [a] ∨ algunos P xs)"
by (simp add: HOL.disj_commute)
also have "… = algunos P (a # xs)" by simp
finally show "?Q (a # xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la
siguiente ecuación:
algunos (λx. P x ∨ Q x) xs = Z
y demostrar la equivalencia de forma automática y detallada.
---------------------------------------------------------------------
*}

(* migtermor *)
lemma "algunos (λx. P x ∨ Q x) xs =
((algunos (λx. P x) xs) ∨ (algunos (λx. Q x) xs))"
by (induct xs) auto

lemma "algunos (λx. P x ∨ Q x) xs =
((algunos (λx. P x) xs) ∨ (algunos (λx. Q x) xs))" (is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix x xs
assume HI: "?R xs"
have "algunos (λx. P x ∨ Q x) (x#xs) =
(((λx. P x ∨ Q x) x) ∨ (algunos (λx. P x ∨ Q x) xs))" by simp
also have "… = ((P x ∨ Q x) ∨ (algunos (λx. P x ∨ Q x) xs))" by simp
also have H1: "… = ((((λx. P x) x) ∨ (algunos (λx. P x) xs)) ∨
(((λx. Q x) x) ∨ (algunos (λx. Q x) xs)))"
using HI by simp arith
have H2: "… = ((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
by simp
have C: "(algunos (λx. P x ∨ Q x) (x#xs)) =
((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
using H1 H2 by simp
finally show "(algunos (λx. P x ∨ Q x) (x#xs)) =
((algunos (λx. P x) (x#xs)) ∨ (algunos (λx. Q x) (x#xs)))"
using C by simp
qed

(* CComentario: Ruptura de la cadena de igualdades. *)

(* ferrenseg *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix x xs
assume HI: "algunos (λx. (P x ∨ Q x)) xs = (algunos P xs ∨ algunos Q xs)"
show "algunos (λx. P x ∨ Q x) (x # xs) =
(algunos P (x # xs) ∨ algunos Q (x # xs))"
proof -
have "algunos (λx. P x ∨ Q x) (x # xs) =
((P x) ∨ (Q x) ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "… = ((P x) ∨ (Q x) ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "… = (((P x) ∨ algunos P xs) ∨ ((Q x) ∨ algunos Q xs))"
by auto
also have "… = (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp
finally show ?thesis by simp
qed
qed

(* Comentario: Uso de auto *)

(* ivamenjim marpoldia1 paupeddeg *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix a xs
assume HI: "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P (a # xs) ∨ algunos Q (a # xs))" by auto
qed

(* Comentario: Uso de auto *)

(* wilmorort danrodcha anaprarod juacabsou rubgonmar *)
lemma "algunos (λx. P x ∨ Q x) xs =
(¬todos(λx. ¬P x)xs ∨ ¬todos(λx. ¬Q x)xs)"
by (induct xs) auto

(* wilmorort *)
lemma "algunos (λx. P x ∨ Q x) xs =
(¬todos(λx. ¬P x)xs ∨ ¬todos(λx. ¬Q x)xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨
(¬ todos (λx. ¬ P x) xs ∨ ¬ todos (λx. ¬ Q x) xs))"
using HI by simp
also have "... = (P a ∨ ¬ todos (λx. ¬ P x) xs ∨
Q a ∨ ¬ todos (λx. ¬ Q x) xs )" by arith
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(~ todos (λx. ¬ P x) (a # xs) ∨
~ todos (λx. ¬ Q x) (a # xs))" by simp
qed

(* danrodcha *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?R xs")
proof (induct xs)
show "?R []" by simp
next
fix a xs assume HI: "?R xs"
have 1:" (Q a ∨ algunos P xs) = (algunos P xs ∨ Q a)"
by (simp add: HOL.disj_commute)
have "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P [a] ∨ algunos Q [a] ∨ algunos (λx. P x ∨ Q x) xs)"
by simp
also have "… = (P a ∨ (Q a ∨ algunos P xs) ∨ algunos Q xs)"
using HI by simp
also have "… = (P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)"
using 1 by simp
also have "… = (algunos P (a # xs) ∨ algunos Q (a # xs))" by simp
finally show "?R (a # xs)" by simp
qed

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
apply (induct xs)
apply auto
done

(* dancorgar *)
lemma "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∧ Q x) [] ⟹ (algunos P [] ∧ algunos Q [])"
by simp
next
fix xf xs
assume HI: "algunos (λx. P x ∧ Q x) xs ⟹ (algunos P xs ∧ algunos Q xs)"
have F1: "algunos (λx. P x ∧ Q x) (xf#xs) ⟹
((P xf ∧ Q xf) ∨ algunos (λx. P x ∧ Q x) xs)" by simp
also have F2: "… ⟹ (P xf ∧ Q xf ∨ (algunos P xs ∧ algunos Q xs))"
using HI by simp
have F3: "((P xf ∧ Q xf) ∨ (algunos P xs ∧ algunos Q xs)) ⟹
((P xf ∨ algunos P xs) ∧ (Q xf ∨ algunos Q xs))" by blast
have F4: "((P xf ∨ algunos P xs) ∧ (Q xf ∨ algunos Q xs)) ⟹
(algunos P (xf#xs) ∧ algunos Q (xf#xs))" by simp
show "algunos (λx. P x ∧ Q x) (xf#xs) ⟹
(algunos P (xf#xs) ∧ algunos Q (xf#xs))"
using F1 F2 F3 F4 by blast
qed

(* pablucoto crigomgom serrodcal marcarmor13 *)
-- "Automatica"
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

-- "Detallada"
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs) "
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q []) "
by simp
next
fix a xs
assume HI: " algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a # xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ (algunos P xs ∨ algunos Q xs))"
using HI by simp
also have "… = (((P a) ∨ algunos P xs) ∨ ((Q a) ∨ algunos Q xs))"
by arith
also have "… = (algunos P (a#xs) ∨ algunos Q (a#xs))" by simp
finally show "algunos (λx. P x ∨ Q x) (a # xs) =
(algunos P (a # xs) ∨ algunos Q (a # xs)) " by simp
qed

(* anaprarod juacabsou rubgonmar *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "algunos (λx. P x ∨ Q x) (x#xs) =
(P x ∨ Q x ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "… = (P x ∨ Q x ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "… = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith
finally show "?P (x#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 11.1. Demostrar o refutar automáticamente
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

(* ivamenjim wilmorort migtermor marpoldia1 crigomgom rubgonmar
paupeddeg danrodcha pablucoto dancorgar josgarsan anaprarod juacabsou
lucnovdos serrodcal marcarmor13 *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) auto

(* ferrenseg *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) simp_all

(* anaprarod *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
apply (induct xs)
apply auto
done

text {*
---------------------------------------------------------------------
Ejercicio 11.2. Demostrar o refutar datalladamente
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 crigomgom paupeddeg josgarsan
juacabsou serrodcal wilmorort *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. ¬ P x) xs)"
have "algunos P (a # xs) = (P a ∨ (algunos P xs))" by simp
also have "... = (P a ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp
finally show "algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # xs))"
by simp
qed

(* ferrenseg *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix x xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
show "algunos P (x # xs) = (¬ todos (λx. (¬ P x)) (x # xs))"
proof -
have "algunos P (x # xs) = ((P x) ∨ algunos P xs)" by simp
also have "… = ((P x) ∨ ¬ todos (λx. (¬ P x)) xs)" using HI by simp
also have "… = (¬ (¬ (P x) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos (λx. (¬ P x)) (x # xs))" by simp
finally show ?thesis by simp
qed
qed

(* danrodcha pablucoto anaprarod rubgonmar marcarmor13 *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)" (is "?Q xs")
proof (induct xs)
show "?Q []" by simp
next
fix a xs assume HI: "?Q xs"
have "algunos P (a # xs) = (P a ∨ algunos P xs)" by simp
also have "… = (P a ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "… = (¬(¬(P a) ∧ todos(λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos(λx. (¬ P x)) (a # xs))" by simp
finally show "?Q (a # xs)" by simp
qed

(* dancorgar*)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix xf xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (xf#xs) = ((P xf) ∨ algunos P xs)" by simp
also have "… = ( (P xf) ∨ (¬ todos (λx. (¬ P x)) xs) )"
using HI by simp
also have "… = (¬((¬P xf) ∧ (todos (λx. (¬ P x)) xs)))" by simp
finally show "algunos P (xf#xs) = (¬todos (λx. (¬ P x)) (xf#xs))"
by simp
qed

(* lucnovdos*)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix n xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (n#xs) = ((P n) ∨ (algunos P xs))" by simp
also have "… = ((P n) ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "… = (¬((¬P n) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "… = (¬ todos (λx. (¬ P x)) (n#xs))" by simp
finally show "algunos P (n#xs) = (¬ todos (λx. (¬ P x)) (n#xs))"
by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* ivamenjim ferrenseg migtermor serrodcal crigomgom rubgonmar
marpoldia1 paupeddeg danrodcha dancorgar pablucoto anaprarod
juacabsou lucnovdos marcarmor13 *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
| "estaEn x (a#xs) = ((a = x) ∨ (estaEn x xs))"

value "estaEn (2::nat) [3,2,4] = True"
value "estaEn (1::nat) [3,2,4] = False"

text {*
---------------------------------------------------------------------
Ejercicio 13. Expresar la relación existente entre estaEn y algunos.
Demostrar dicha relación de forma automática y detallada.
---------------------------------------------------------------------
*}

(* migtermor crigomgom *)
lemma "estaEn x xs = (algunos (λa. a=x) xs)"
by (induct xs) auto

lemma auxiliar13:
"(x=a) = ((λa. a=x) a)"
by auto

lemma "estaEn x xs = (algunos (λa. a=x) xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "estaEn x (a#xs) = ((a=x) ∨ (estaEn x xs))" by simp
also have H: "… = ((a=x) ∨ (algunos (λa. a=x) xs))" using HI by simp
also have "… = (((λa. a=x) a) ∨ (algunos (λa. a=x) xs))"
using auxiliar13 by simp
also have "… = (algunos (λa. a=x) (a#xs))" by simp
have C: "estaEn x (a#xs) = (algunos (λa. a=x) (a#xs))" using H by simp
finally show "estaEn x (a#xs) = (algunos (λa. a=x) (a#xs))"
using C by simp
qed

(* Comentario: Ruptura de la cadena de igualdades. Se puede simplificar. *)

(* ferrenseg *)
lemma estaEn_algunos:
"estaEn y xs = algunos (λx. x=y) xs"
by (induct xs) auto

lemma estaEn_algunos_2:
"estaEn y xs = algunos (λx. x=y) xs"
proof (induct xs)
show "estaEn y [] = algunos (λx. x=y) []" by simp
next
fix x xs
assume HI: "estaEn y xs = algunos (λx. x=y) xs"
show "estaEn y (x # xs) = algunos (λx. x=y) (x # xs)"
proof -
have "estaEn y (x # xs) = (y=x ∨ estaEn y xs)" by simp
also have "… = (y=x ∨ algunos (λx. x=y) xs)" using HI by simp
also have "… = (x=y ∨ algunos (λx. x=y) xs)" by auto
also have "… = algunos (λx. x=y) (x # xs)" by simp
finally show ?thesis by simp
qed
qed

(* Comentario: Uso de auto *)

(* crigomgom paupeddeg dancorgar juacabsou serrodcal lucnovdos *)
lemma "estaEn a xs = algunos (λx. x = a) xs"
by (induct xs) auto

lemma "estaEn x xs = (algunos (λa. a=x) xs)"
proof (induct xs)
show " estaEn x [] = algunos (λa. a = x) []" by simp
next
fix a xs
assume HI: "estaEn x xs = algunos (λa. a = x) xs"
have "estaEn x (a # xs) = (a = x ∨ estaEn x xs)" by simp
also have "... = (a = x ∨ algunos (λa. a = x) xs)" using HI by simp
finally show " estaEn x (a # xs) = algunos (λa. a = x) (a # xs)"
by simp
qed

(* ivamenjim marpoldia1 *)
lemma "estaEn x xs = algunos (λy. x=y) xs"
by (induct xs) auto

lemma "estaEn x xs = algunos (λy. x=y) xs"
proof (induct xs)
show "estaEn x [] = algunos (op = x) []" by simp
next
fix a xs
assume HI: "estaEn x xs = algunos (op = x) xs"
have "estaEn x (a # xs) = ((a = x) ∨ (estaEn x xs))" by simp
also have "... = (a = x ∨ algunos (op = x) xs)" using HI by simp
finally show " estaEn x (a # xs) = algunos (op = x) (a # xs)" by auto
qed

(* Comentarios:
+ Uso de (op = x)
+ Uso de auto
*)

(* danrodcha *)
lemma "estaEn a xs = algunos (op = a) xs"
by (induct xs) auto

(* danrodcha *)
lemma "estaEn a xs = algunos (op = a) xs"
proof (induct xs)
show "estaEn a [] = algunos (op = a) []" by simp
next
fix x xs
assume HI: "estaEn a xs = algunos (op = a) xs"
have "estaEn a (x # xs) = ((x = a) ∨ (estaEn a xs))" by simp
also have "… = (x = a ∨ algunos (op = a) xs)" using HI by simp
also have "… = ((op = a) x ∨ algunos (op = a) xs)"
by (simp add:HOL.eq_commute)
also have "… = algunos (op = a) (x # xs)" by simp
finally show "estaEn a (x # xs) = algunos (op = a) (x # xs)" by simp
qed

(* pablucoto marcarmor13*)
-- "Automatica"
lemma " estaEn y xs = algunos (λx. x=y) xs"
by (induct xs) auto

-- "Detallada"
lemma " estaEn y xs = algunos (λx. x=y) xs"
proof (induct xs)
show "estaEn y [] = algunos (λx. x = y) []" by simp
next
fix a xs
assume HI: " estaEn y xs = algunos (λx. x = y) xs "
have "estaEn y (a # xs) = (y = a ∨ estaEn y xs)" by simp
also have "... = (y = a ∨ algunos (λx. x = y) xs) " using HI by simp
also have "… = (a=y ∨ algunos (λx. x=y) xs)" by auto
also have "... = (algunos (λx. x = y) (a#xs))" by simp
finally show "estaEn y (a # xs) = algunos (λx. x = y) (a # xs) "
by simp
qed

(* Comentario: Uso de auto *)

(* anaprarod *)
(* Automática*)
lemma "estaEn a xs = algunos (λx. a=x) xs" (is "?P xs")
by (induct xs) auto

(* Detallada (igual que las anteriores pero obviando el paso previo al
finally) *)
lemma "estaEn a xs = algunos (λx. a=x) xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI : "?P xs"
have "estaEn a (x#xs) = (x=a ∨ estaEn a xs)" by simp
also have "… = (x=a ∨ algunos (λx. a=x) xs)" using HI by simp
also have "… = (a=x ∨ algunos (λx. a=x) xs)" using HI by auto
finally show "?P (x#xs)" by simp
qed

(* Comentario: Uso de auto *)

end
</source>

Relación 4

2016-11-22T14:28:05Z

Wilmorort:

Relación 4

2016-11-22T14:22:21Z

Wilmorort:

Relación 4

2016-11-22T13:21:00Z

Wilmorort:

Relación 4

2016-11-22T13:10:16Z

Wilmorort:

Relación 4

2016-11-22T13:01:17Z

Wilmorort:

Relación 4

2016-11-22T12:55:53Z

Wilmorort:

Relación 4

2016-11-22T12:42:51Z

Wilmorort:

Relación 4

2016-11-22T12:41:09Z

Wilmorort:

Relación 4

2016-11-21T19:45:11Z

Wilmorort:

Relación 4

2016-11-21T02:34:34Z

Wilmorort:

Relación 4

2016-11-21T01:54:34Z

Wilmorort:

Relación 4

2016-11-20T22:01:33Z

Wilmorort:

Relación 4

2016-11-20T21:59:14Z

Wilmorort:

Relación 4

2016-11-20T15:41:15Z

Wilmorort:

Relación 4

2016-11-20T15:37:26Z

Wilmorort:

Relación 4

2016-11-19T02:35:08Z

Wilmorort: