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

Relación 10

2017-02-01T18:44:25Z

Fracorjim1:

<source lang="isar">
chapter {* R10: Formalización y argumentación con Isabelle/HOL *}

theory R10_Formalizacion_y_argmentacion
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta es relación formalizar y demostrar la corrección
de los argumentos automáticamente y detalladamente usando sólo las reglas
básicas de deducción natural.

· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
---------------------------------------------------------------------
*}

text {*
Se usarán las reglas notnotI, mt, no_ex y no_para_todo que demostramos
a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

lemma no_para_todo: "¬(∀x. P(x)) ⟹ ∃x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si la válvula está abierta o la monitorización está preparada,
entonces se envía una señal de reconocimiento y un mensaje de
funcionamiento al controlador del ordenador. Si se envía un mensaje
de funcionamiento al controlador del ordenador o el sistema está en
estado normal, entonces se aceptan las órdenes del operador. Por lo
tanto, si la válvula está abierta, entonces se aceptan las órdenes
del operador.
Usar A : La válvula está abierta.
P : La monitorización está preparada.
R : Envía una señal de reconocimiento.
F : Envía un mensaje de funcionamiento.
N : El sistema está en estado normal.
O, AO, OK : Se aceptan órdenes del operador.
------------------------------------------------------------------ *}

(* ivamenjim manmorjim1 crigomgom migtermor serrodcal bowma *)
(* Buscando, he detectado que 'O' es un carácter especial en Isabelle y que forma parte de su
sintaxis pre-definida, por lo que da problemas a la hora de formalizar y demostrar
el argumento planteado. Por lo tanto, en su lugar he usado "AO: Se aceptan órdenes del operador" *)

lemma ejercicio_1:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)"
assumes 2: "(F ∨ N) ⟶ AO"
shows "A ⟶ AO"
proof -
{assume 3: "A"
have 4: "A ∨ P" using 3 by (rule disjI1)
have 5: "R ∧ F" using 1 4 by (rule mp)
have 6: "F" using 5 by (rule conjunct2)
have 7: "F ∨ N" using 6 by (rule disjI1)
have 8: "AO" using 2 7 by (rule mp)}
then show "A ⟶ AO" by (rule impI)
qed

(*danrodcha ferrenseg anaprarod marcarmor13 pablucoto marpoldia1 juacabsou *)

lemma ej_1:
assumes "A ∨ P ⟶ R ∧ F" and
"F ∨ N ⟶ OK"
shows "A ⟶ OK"
proof (rule impI)
{assume "A"
hence "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
with assms(2) show "OK" by (rule mp)}
qed

(*pabrodmac paupeddeg*)
lemma ejercicio_1_1:
assumes "A ∨ P ⟶ R ∧ F"
"F ∨ N ⟶ Op"
shows "A ⟶ Op"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
have "R ∧ F" using `A ∨ P ⟶ R ∧ F` `A ∨ P` by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
show "Op" using `F ∨ N ⟶ Op` `F ∨ N` by (rule mp)
qed

(*josgarsan*)
lemma ejericio_1_2:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)" and
2: "(F ∨ N) ⟶ Op"
shows "A ⟶ Op"
proof
assume 3: A
have 4:"(A ∨ P)" using 3 by (rule disjI1)
have "(R ∧ F)" using 1 4 by (rule mp)
then have "F" by (rule conjunct2)
then have 5: "(F ∨ N)" by (rule disjI1)
show "Op" using 2 5 by (rule mp)
qed

(* fracorjim1 *)

lemma ejercicio_1_3:
assumes H1: "(A ∨ P) → (R ∧ F)" and
H2: "(F ∨ N) → O"
shows "A → O"
proof -
assume "A"
have "A ∨ P" by (rule disjI1)
hence "R ∧ F" using H1 by (rule mp)
hence "F" by (rule conjI2)
hence "F ∨ N" by (rule disjI1)
hence "O" using H2 by (rule mp)
thus "A → O"
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y decidir la corrección, del siguiente
argumento
Hay estudiantes inteligentes y hay estudiantes trabajadores. Por
tanto, hay estudiantes inteligentes y trabajadores.
Usar I(x) para x es inteligente
T(x) para x es trabajador
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg danrodcha anaprarod crigomgom marcarmor13 pabrodmac migtermor josgarsan serrodcal pablucoto fracorjim1 bowma paupeddeg marpoldia1 juacabsou *)

lemma ejercicio_2:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. (I(x) ∧ T(x))"
quickcheck
oops

(* Encontrando el contraejemplo:
I = {a1}
x = a1
T = {a2}
xa = a2
*)

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y decidir la corrección, del siguiente
argumento
Los hermanos tienen el mismo padre. Juan es hermano de Luis. Carlos
es padre de Luis. Por tanto, Carlos es padre de Juan.
Usar H(x,y) para x es hermano de y
P(x,y) para x es padre de y
j para Juan
l para Luis
c para Carlos
------------------------------------------------------------------ *}

(* ivamenjim crigomgom serrodcal marpoldia1*)

lemma ejercicio_3:
assumes 1: "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes 2: "H(j,l)"
assumes 3: "P(c,l)"
shows "P(c,j)"
proof -
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using 1 by (rule allE)
have 5 : "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" using 4 by (rule allE)
then have 6 : "(∀z. (H(z,l) ⟶ P(c,z)))" using 3 by (rule mp)
have 7 : "H(j,l) ⟶ P(c,j)" using 6 by (rule allE)
then show "P(c,j)" using 2 by (rule mp)
qed

(* danrodcha anaprarod ferrenseg marcarmor13 pablucoto fracorjim1 juacabsou bowma *)
(* es casi igual que la anterior *)
lemma ej_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes "H(j,l)"
assumes "P(c,l)"
shows "P(c,j)"
proof (rule mp)
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
hence "(∀z. (H(z,l) ⟶ P(c,z)))" using assms(3) by (rule mp)
thus "H(j,l) ⟶ P(c,j)" by (rule allE)
next
show "H(j,l)" using assms(2) by this
qed

(*pabrodmac*)
lemma ejercicio_3_1:
assumes "∀x y. H(x,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,x)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀y. H(j,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,j)))" using assms(1) by (rule allE)
hence "H(j,l) ⟶ (∀ z. (P(z,l) ⟶ P(z,j)))" by (rule allE)
hence "∀z. (P(z,l) ⟶ P(z,j))" using assms(2) by (rule mp)
hence "P(c,l) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using assms(3) by (rule mp)
qed

(* migtermor josgarsan*)

lemma ejercicio_3_2:
assumes "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes "H(l,j)"
assumes "P(c,l)"
shows "P(c,j)"
proof -
have 1: "P(c,l) ∧ H(l,j)" using assms(3) assms(2) by (rule conjI)
have 2: "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using assms(1) by (rule allE)
then have 3: "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
then have 4: "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
then show "P(c,j)" using 1 by (rule mp)
qed

(* paupeddeg *)
lemma ejercicio_3_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀ y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
have "∀z. (H(z,l) ⟶ P(c,z))" using `P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))` `P(c,l)`
by (rule mp)
hence "H(j,l) ⟶ P(c,j)" by (rule allE)
show "P(c,j)" using `H(j,l) ⟶ P(c,j)` `H(j,l)` by (rule mp)
qed

(* fracorjim1 *)
(* Realizo una eliminación sucesiva del cuantificador como migtermor *)
lemma ejercicio_3_4:
assumes H1: "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes H2: "H(l,j)"
assumes H3: "P(c,l)"
shows "P(c,j)"
proof -
have H: "P(c,l) ∧ H(l,j)" using H3 H2 by (rule conjI)
have "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using H1 by (rule allE)
hence "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
hence "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using H by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
(* danrodcha ferrenseg pablucoto*)
(* danrodcha: Me gusta más la formalización de ana prado, aunque
son equivalentes *)
lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. Ap(j,x) ⟶ ¬ E(x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume "∃x. E(x) ∧ N(x)"
then obtain a where "E(a) ∧ N(a)" by (rule exE)
hence "E(a)" by (rule conjE)
show "¬ Af(j)"
proof (rule notI)
assume "Af(j)"
hence "Af(j) ∧ E(a)" using `E(a)` by (rule conjI)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
hence "Ap(j,a)" using `Af(j) ∧ E(a)` by (rule mp)
have "Ap(j,a) ⟶ ¬ E(a)" using assms(2) by (rule allE)
hence "¬ E(a)" using `Ap(j,a)` by (rule mp)
thus False using `E(a)` by (rule notE)
qed
qed

(* ivamenjim crigomgom marcarmor13 serrodcal bowma juacabsou marpoldia1 *)

lemma ejercicio_4:
assumes 1: "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
assumes 2: "¬(∃x. E(x) ∧ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume 3: "∃x. E(x) ∧ N(x)"
then obtain a where 4: "E(a) ∧ N(a)" by (rule exE)
then have 5: "E(a)" by (rule conjunct1)
show 6: "¬Af(j)"
proof (rule notI)
assume 7: "Af(j)"
then have 8: "Af(j) ∧ E(a)" using 5 by (rule conjI)
have 9: "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using 1 by (rule allE)
have 10: "Af(j) ∧ E(a) ⟶ Ap(j,a)" using 9 by (rule allE)
have 11: "Ap(j,a)" using 10 8 by (rule mp)
have 12: "E(a) ∧ Ap(j,a)" using 5 11 by (rule conjI)
have 13: "∃x. E(x) ∧ Ap(j,x)" using 12 by (rule exI)
show "False" using 2 13 by (rule notE)
qed
qed

(* anaprarod migtermor *)

(* Este auxiliar ya se probó en el ejercicio 4 de la rel 8 *)
lemma aux4: "¬(p∧q) ⟹¬p ∨ ¬q"
by (auto)

lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀ x.(E(x) ⟶ ¬ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
{ assume "∃x. E(x) ∧ N(x)"
then obtain a where 1: "E(a) ∧ N(a)" by (rule exE)
have "∀ y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence 2: "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
have 3: "E(a)" using 1 by (rule conjunct1)
have 4: "E(a) ⟶ ¬ Ap(j,a)" using assms(2) by (rule allE)
have 5: "¬ Ap(j,a)" using 4 3 by (rule mp)
have "¬(Af(j) ∧ E(a))" using 2 5 by (rule mt)
hence "¬ Af(j) ∨ ¬ E(a)" by (rule aux4)
thus " ¬Af(j)"
proof (rule disjE)
{assume "¬Af(j)"
thus "¬Af(j)" by this}
next
{assume 6: "¬ E(a)"
show "¬ Af(j)" using 6 3 by (rule notE)}
qed}
qed

(*pabrodmac*)

lemma ejercicio_4_1:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x)⟶ ¬Ap(j,x)"
shows "(∃x. N(x) ∧ E(x)) ⟶ ¬Af(j)"
proof
assume "∃x. N(x) ∧ E(x)"
then obtain b where "N(b) ∧ E(b)" by (rule exE)
hence "E(b)" by (rule conjunct2)
have "E(b)⟶ ¬Ap(j,b)" using assms(2) by (rule allE)
hence "¬Ap(j,b)" using `E(b)` by (rule mp)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(b) ⟶ Ap(j,b)" by (rule allE)
hence "¬Ap(j,b) ⟶ ¬(Af(j) ∧ E(b))" by (rule Set.not_mono)
hence "¬(Af(j) ∧ E(b))" using `¬Ap(j,b)` by (rule mp)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j) ∧ E(b)" using `E(b)` by (rule conjI)
show False using `¬(Af(j) ∧ E(b))` `Af(j) ∧ E(b)` by (rule notE)
qed
qed

(* paupeddeg *)
lemma ejercicio_4_2:
assumes "∀x y. Af(x)∧E(y) ⟶ Ap(x,y) "
"∀x. E(x) ⟶ ¬Ap(j,x)"
shows "(∃x. E(x)∧N(x)) ⟶ ¬Af(j) "
proof
assume "∃x. E(x)∧N(x)"
then obtain b where "E(b) ∧ N(b)" by (rule exE)
hence "E(b)" by (rule conjunct1)
have "E(b) ⟶¬Ap(j,b)" using assms(2) by (rule allE)
have "¬Ap(j,b)" using `E(b) ⟶¬Ap(j,b)` `E(b)` by (rule mp)
have "∀ y. Af(j)∧E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j)∧E(b) ⟶ Ap(j,b)" by (rule allE)
have "¬ (Af(j)∧E(b))" using `Af(j)∧E(b) ⟶ Ap(j,b)` `¬ Ap(j,b)` by (rule mt)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j)∧E(b)" using `E(b)` by (rule conjI)
show False using `¬ (Af(j)∧E(b))` `(Af(j)∧E(b))` by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar, y decidir la corrección, del siguiente
argumento
El esposo de la hermana de Toni es Roberto. La hermana de Toni es
María. Por tanto, el esposo de María es Roberto.
Usar e(x) para el esposo de x
h para la hermana de Toni
m para María
r para Roberto
------------------------------------------------------------------ *}

(* ivamenjim *)

lemma ejercicio_5:
assumes 1: "e(h) = r"
assumes 2: "h = m"
shows "e(m) = r"
proof -
have 3: "e(h) = e(m)" using 2 by (rule arg_cong)
have 4: "e(m) = e(h)" using 3 by (rule sym)
then show "e(m) = r" using 1 by (rule trans)
qed

(* danrodcha anaprarod crigomgom ferrenseg marcarmor13 migtermor serrodcal pablucoto paupeddeg juacabsou fracorjim1 *)
lemma ej_5:
assumes "e(h) = r" and
"h = m"
shows "e(m) = r"
proof -
show "e(m) = r" using assms(2) assms(1) by (rule subst)
qed

(*pabrodmac bowma *)
lemma ejercicio_5_1:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(1) assms(2) by (rule HOL.back_subst)
qed

(*pabrodmac*)
lemma ejercicio_5_2:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(2) assms(1) by (rule HOL.subst)
qed

(*pabrodmac*)
lemma ejercicio_5_3:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
have "e(h) = e(m)" using assms(2) by (rule arg_cong)
show "e(m)=r" using `e(h)=r` `e(h) = e(m)` by simp
qed

end
</source>

Relación 10

2017-02-01T18:41:11Z

Fracorjim1:

<source lang="isar">
chapter {* R10: Formalización y argumentación con Isabelle/HOL *}

theory R10_Formalizacion_y_argmentacion
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta es relación formalizar y demostrar la corrección
de los argumentos automáticamente y detalladamente usando sólo las reglas
básicas de deducción natural.

· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
---------------------------------------------------------------------
*}

text {*
Se usarán las reglas notnotI, mt, no_ex y no_para_todo que demostramos
a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

lemma no_para_todo: "¬(∀x. P(x)) ⟹ ∃x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si la válvula está abierta o la monitorización está preparada,
entonces se envía una señal de reconocimiento y un mensaje de
funcionamiento al controlador del ordenador. Si se envía un mensaje
de funcionamiento al controlador del ordenador o el sistema está en
estado normal, entonces se aceptan las órdenes del operador. Por lo
tanto, si la válvula está abierta, entonces se aceptan las órdenes
del operador.
Usar A : La válvula está abierta.
P : La monitorización está preparada.
R : Envía una señal de reconocimiento.
F : Envía un mensaje de funcionamiento.
N : El sistema está en estado normal.
O, AO, OK : Se aceptan órdenes del operador.
------------------------------------------------------------------ *}

(* ivamenjim manmorjim1 crigomgom migtermor serrodcal bowma *)
(* Buscando, he detectado que 'O' es un carácter especial en Isabelle y que forma parte de su
sintaxis pre-definida, por lo que da problemas a la hora de formalizar y demostrar
el argumento planteado. Por lo tanto, en su lugar he usado "AO: Se aceptan órdenes del operador" *)

lemma ejercicio_1:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)"
assumes 2: "(F ∨ N) ⟶ AO"
shows "A ⟶ AO"
proof -
{assume 3: "A"
have 4: "A ∨ P" using 3 by (rule disjI1)
have 5: "R ∧ F" using 1 4 by (rule mp)
have 6: "F" using 5 by (rule conjunct2)
have 7: "F ∨ N" using 6 by (rule disjI1)
have 8: "AO" using 2 7 by (rule mp)}
then show "A ⟶ AO" by (rule impI)
qed

(*danrodcha ferrenseg anaprarod marcarmor13 pablucoto marpoldia1 juacabsou *)

lemma ej_1:
assumes "A ∨ P ⟶ R ∧ F" and
"F ∨ N ⟶ OK"
shows "A ⟶ OK"
proof (rule impI)
{assume "A"
hence "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
with assms(2) show "OK" by (rule mp)}
qed

(*pabrodmac paupeddeg*)
lemma ejercicio_1_1:
assumes "A ∨ P ⟶ R ∧ F"
"F ∨ N ⟶ Op"
shows "A ⟶ Op"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
have "R ∧ F" using `A ∨ P ⟶ R ∧ F` `A ∨ P` by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
show "Op" using `F ∨ N ⟶ Op` `F ∨ N` by (rule mp)
qed

(*josgarsan*)
lemma ejericio_1_2:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)" and
2: "(F ∨ N) ⟶ Op"
shows "A ⟶ Op"
proof
assume 3: A
have 4:"(A ∨ P)" using 3 by (rule disjI1)
have "(R ∧ F)" using 1 4 by (rule mp)
then have "F" by (rule conjunct2)
then have 5: "(F ∨ N)" by (rule disjI1)
show "Op" using 2 5 by (rule mp)
qed

(* fracorjim1 *)

lemma ejercicio_1_3:
assumes H1: "(A ∨ P) → (R ∧ F)" and
H2: "(F ∨ N) → O"
shows "A → O"
proof -
assume "A"
have "A ∨ P" by (rule disjI1)
hence "R ∧ F" using H1 by (rule mp)
hence "F" by (rule conjI2)
hence "F ∨ N" by (rule disjI1)
hence "O" using H2 by (rule mp)
thus "A → O"
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y decidir la corrección, del siguiente
argumento
Hay estudiantes inteligentes y hay estudiantes trabajadores. Por
tanto, hay estudiantes inteligentes y trabajadores.
Usar I(x) para x es inteligente
T(x) para x es trabajador
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg danrodcha anaprarod crigomgom marcarmor13 pabrodmac migtermor josgarsan serrodcal pablucoto fracorjim1 bowma paupeddeg marpoldia1 juacabsou *)

lemma ejercicio_2:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. (I(x) ∧ T(x))"
quickcheck
oops

(* Encontrando el contraejemplo:
I = {a1}
x = a1
T = {a2}
xa = a2
*)

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y decidir la corrección, del siguiente
argumento
Los hermanos tienen el mismo padre. Juan es hermano de Luis. Carlos
es padre de Luis. Por tanto, Carlos es padre de Juan.
Usar H(x,y) para x es hermano de y
P(x,y) para x es padre de y
j para Juan
l para Luis
c para Carlos
------------------------------------------------------------------ *}

(* ivamenjim crigomgom serrodcal marpoldia1*)

lemma ejercicio_3:
assumes 1: "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes 2: "H(j,l)"
assumes 3: "P(c,l)"
shows "P(c,j)"
proof -
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using 1 by (rule allE)
have 5 : "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" using 4 by (rule allE)
then have 6 : "(∀z. (H(z,l) ⟶ P(c,z)))" using 3 by (rule mp)
have 7 : "H(j,l) ⟶ P(c,j)" using 6 by (rule allE)
then show "P(c,j)" using 2 by (rule mp)
qed

(* danrodcha anaprarod ferrenseg marcarmor13 pablucoto fracorjim1 juacabsou bowma *)
(* es casi igual que la anterior *)
lemma ej_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes "H(j,l)"
assumes "P(c,l)"
shows "P(c,j)"
proof (rule mp)
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
hence "(∀z. (H(z,l) ⟶ P(c,z)))" using assms(3) by (rule mp)
thus "H(j,l) ⟶ P(c,j)" by (rule allE)
next
show "H(j,l)" using assms(2) by this
qed

(*pabrodmac*)
lemma ejercicio_3_1:
assumes "∀x y. H(x,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,x)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀y. H(j,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,j)))" using assms(1) by (rule allE)
hence "H(j,l) ⟶ (∀ z. (P(z,l) ⟶ P(z,j)))" by (rule allE)
hence "∀z. (P(z,l) ⟶ P(z,j))" using assms(2) by (rule mp)
hence "P(c,l) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using assms(3) by (rule mp)
qed

(* migtermor josgarsan*)

lemma ejercicio_3_2:
assumes "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes "H(l,j)"
assumes "P(c,l)"
shows "P(c,j)"
proof -
have 1: "P(c,l) ∧ H(l,j)" using assms(3) assms(2) by (rule conjI)
have 2: "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using assms(1) by (rule allE)
then have 3: "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
then have 4: "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
then show "P(c,j)" using 1 by (rule mp)
qed

(* paupeddeg *)
lemma ejercicio_3_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀ y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
have "∀z. (H(z,l) ⟶ P(c,z))" using `P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))` `P(c,l)`
by (rule mp)
hence "H(j,l) ⟶ P(c,j)" by (rule allE)
show "P(c,j)" using `H(j,l) ⟶ P(c,j)` `H(j,l)` by (rule mp)
qed

(* fracorjim1 *)
(* Realizo una eliminación sucesiva del cuantificador como migtermor *)
lemma ejercicio_3_4:
assumes H1: "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes H2: "H(l,j)"
assumes H3: "P(c,l)"
shows "P(c,j)"
proof -
have H: "P(c,l) ∧ H(l,j)" using H3 H2 by (rule conjI)
have "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using H1 by (rule allE)
hence "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
hence "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using H by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
(* danrodcha ferrenseg pablucoto*)
(* danrodcha: Me gusta más la formalización de ana prado, aunque
son equivalentes *)
lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. Ap(j,x) ⟶ ¬ E(x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume "∃x. E(x) ∧ N(x)"
then obtain a where "E(a) ∧ N(a)" by (rule exE)
hence "E(a)" by (rule conjE)
show "¬ Af(j)"
proof (rule notI)
assume "Af(j)"
hence "Af(j) ∧ E(a)" using `E(a)` by (rule conjI)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
hence "Ap(j,a)" using `Af(j) ∧ E(a)` by (rule mp)
have "Ap(j,a) ⟶ ¬ E(a)" using assms(2) by (rule allE)
hence "¬ E(a)" using `Ap(j,a)` by (rule mp)
thus False using `E(a)` by (rule notE)
qed
qed

(* ivamenjim crigomgom marcarmor13 serrodcal bowma juacabsou marpoldia1 *)

lemma ejercicio_4:
assumes 1: "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
assumes 2: "¬(∃x. E(x) ∧ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume 3: "∃x. E(x) ∧ N(x)"
then obtain a where 4: "E(a) ∧ N(a)" by (rule exE)
then have 5: "E(a)" by (rule conjunct1)
show 6: "¬Af(j)"
proof (rule notI)
assume 7: "Af(j)"
then have 8: "Af(j) ∧ E(a)" using 5 by (rule conjI)
have 9: "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using 1 by (rule allE)
have 10: "Af(j) ∧ E(a) ⟶ Ap(j,a)" using 9 by (rule allE)
have 11: "Ap(j,a)" using 10 8 by (rule mp)
have 12: "E(a) ∧ Ap(j,a)" using 5 11 by (rule conjI)
have 13: "∃x. E(x) ∧ Ap(j,x)" using 12 by (rule exI)
show "False" using 2 13 by (rule notE)
qed
qed

(* anaprarod migtermor *)

(* Este auxiliar ya se probó en el ejercicio 4 de la rel 8 *)
lemma aux4: "¬(p∧q) ⟹¬p ∨ ¬q"
by (auto)

lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀ x.(E(x) ⟶ ¬ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
{ assume "∃x. E(x) ∧ N(x)"
then obtain a where 1: "E(a) ∧ N(a)" by (rule exE)
have "∀ y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence 2: "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
have 3: "E(a)" using 1 by (rule conjunct1)
have 4: "E(a) ⟶ ¬ Ap(j,a)" using assms(2) by (rule allE)
have 5: "¬ Ap(j,a)" using 4 3 by (rule mp)
have "¬(Af(j) ∧ E(a))" using 2 5 by (rule mt)
hence "¬ Af(j) ∨ ¬ E(a)" by (rule aux4)
thus " ¬Af(j)"
proof (rule disjE)
{assume "¬Af(j)"
thus "¬Af(j)" by this}
next
{assume 6: "¬ E(a)"
show "¬ Af(j)" using 6 3 by (rule notE)}
qed}
qed

(*pabrodmac*)

lemma ejercicio_4_1:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x)⟶ ¬Ap(j,x)"
shows "(∃x. N(x) ∧ E(x)) ⟶ ¬Af(j)"
proof
assume "∃x. N(x) ∧ E(x)"
then obtain b where "N(b) ∧ E(b)" by (rule exE)
hence "E(b)" by (rule conjunct2)
have "E(b)⟶ ¬Ap(j,b)" using assms(2) by (rule allE)
hence "¬Ap(j,b)" using `E(b)` by (rule mp)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(b) ⟶ Ap(j,b)" by (rule allE)
hence "¬Ap(j,b) ⟶ ¬(Af(j) ∧ E(b))" by (rule Set.not_mono)
hence "¬(Af(j) ∧ E(b))" using `¬Ap(j,b)` by (rule mp)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j) ∧ E(b)" using `E(b)` by (rule conjI)
show False using `¬(Af(j) ∧ E(b))` `Af(j) ∧ E(b)` by (rule notE)
qed
qed

(* paupeddeg *)
lemma ejercicio_4_2:
assumes "∀x y. Af(x)∧E(y) ⟶ Ap(x,y) "
"∀x. E(x) ⟶ ¬Ap(j,x)"
shows "(∃x. E(x)∧N(x)) ⟶ ¬Af(j) "
proof
assume "∃x. E(x)∧N(x)"
then obtain b where "E(b) ∧ N(b)" by (rule exE)
hence "E(b)" by (rule conjunct1)
have "E(b) ⟶¬Ap(j,b)" using assms(2) by (rule allE)
have "¬Ap(j,b)" using `E(b) ⟶¬Ap(j,b)` `E(b)` by (rule mp)
have "∀ y. Af(j)∧E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j)∧E(b) ⟶ Ap(j,b)" by (rule allE)
have "¬ (Af(j)∧E(b))" using `Af(j)∧E(b) ⟶ Ap(j,b)` `¬ Ap(j,b)` by (rule mt)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j)∧E(b)" using `E(b)` by (rule conjI)
show False using `¬ (Af(j)∧E(b))` `(Af(j)∧E(b))` by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar, y decidir la corrección, del siguiente
argumento
El esposo de la hermana de Toni es Roberto. La hermana de Toni es
María. Por tanto, el esposo de María es Roberto.
Usar e(x) para el esposo de x
h para la hermana de Toni
m para María
r para Roberto
------------------------------------------------------------------ *}

(* ivamenjim *)

lemma ejercicio_5:
assumes 1: "e(h) = r"
assumes 2: "h = m"
shows "e(m) = r"
proof -
have 3: "e(h) = e(m)" using 2 by (rule arg_cong)
have 4: "e(m) = e(h)" using 3 by (rule sym)
then show "e(m) = r" using 1 by (rule trans)
qed

(* danrodcha anaprarod crigomgom ferrenseg marcarmor13 migtermor serrodcal pablucoto paupeddeg juacabsou *)
lemma ej_5:
assumes "e(h) = r" and
"h = m"
shows "e(m) = r"
proof -
show "e(m) = r" using assms(2) assms(1) by (rule subst)
qed

(*pabrodmac bowma *)
lemma ejercicio_5_1:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(1) assms(2) by (rule HOL.back_subst)
qed

(*pabrodmac*)
lemma ejercicio_5_2:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(2) assms(1) by (rule HOL.subst)
qed

(*pabrodmac*)
lemma ejercicio_5_3:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
have "e(h) = e(m)" using assms(2) by (rule arg_cong)
show "e(m)=r" using `e(h)=r` `e(h) = e(m)` by simp
qed

end
</source>

Relación 10

2017-02-01T06:17:21Z

Fracorjim1:

<source lang="isar">
chapter {* R10: Formalización y argumentación con Isabelle/HOL *}

theory R10_Formalizacion_y_argmentacion
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta es relación formalizar y demostrar la corrección
de los argumentos automáticamente y detalladamente usando sólo las reglas
básicas de deducción natural.

· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
---------------------------------------------------------------------
*}

text {*
Se usarán las reglas notnotI, mt, no_ex y no_para_todo que demostramos
a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

lemma no_para_todo: "¬(∀x. P(x)) ⟹ ∃x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si la válvula está abierta o la monitorización está preparada,
entonces se envía una señal de reconocimiento y un mensaje de
funcionamiento al controlador del ordenador. Si se envía un mensaje
de funcionamiento al controlador del ordenador o el sistema está en
estado normal, entonces se aceptan las órdenes del operador. Por lo
tanto, si la válvula está abierta, entonces se aceptan las órdenes
del operador.
Usar A : La válvula está abierta.
P : La monitorización está preparada.
R : Envía una señal de reconocimiento.
F : Envía un mensaje de funcionamiento.
N : El sistema está en estado normal.
O, AO, OK : Se aceptan órdenes del operador.
------------------------------------------------------------------ *}

(* ivamenjim manmorjim1 crigomgom migtermor serrodcal *)
(* Buscando, he detectado que 'O' es un carácter especial en Isabelle y que forma parte de su
sintaxis pre-definida, por lo que da problemas a la hora de formalizar y demostrar
el argumento planteado. Por lo tanto, en su lugar he usado "AO: Se aceptan órdenes del operador" *)

lemma ejercicio_1:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)"
assumes 2: "(F ∨ N) ⟶ AO"
shows "A ⟶ AO"
proof -
{assume 3: "A"
have 4: "A ∨ P" using 3 by (rule disjI1)
have 5: "R ∧ F" using 1 4 by (rule mp)
have 6: "F" using 5 by (rule conjunct2)
have 7: "F ∨ N" using 6 by (rule disjI1)
have 8: "AO" using 2 7 by (rule mp)}
then show "A ⟶ AO" by (rule impI)
qed

(*danrodcha ferrenseg anaprarod marcarmor13 pablucoto*)

lemma ej_1:
assumes "A ∨ P ⟶ R ∧ F" and
"F ∨ N ⟶ OK"
shows "A ⟶ OK"
proof (rule impI)
{assume "A"
hence "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
with assms(2) show "OK" by (rule mp)}
qed

(*pabrodmac*)
lemma ejercicio_1_1:
assumes "A ∨ P ⟶ R ∧ F"
"F ∨ N ⟶ Op"
shows "A ⟶ Op"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
have "R ∧ F" using `A ∨ P ⟶ R ∧ F` `A ∨ P` by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
show "Op" using `F ∨ N ⟶ Op` `F ∨ N` by (rule mp)
qed

(*josgarsan*)
lemma ejericio_1_2:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)" and
2: "(F ∨ N) ⟶ Op"
shows "A ⟶ Op"
proof
assume 3: A
have 4:"(A ∨ P)" using 3 by (rule disjI1)
have "(R ∧ F)" using 1 4 by (rule mp)
then have "F" by (rule conjunct2)
then have 5: "(F ∨ N)" by (rule disjI1)
show "Op" using 2 5 by (rule mp)
qed

(* fracorjim1 *)

lemma ejercicio_1_3:
assumes H1: "(A ∨ P) → (R ∧ F)" and
H2: "(F ∨ N) → O"
shows "A → O"
proof -
assume "A"
have "A ∨ P" by (rule disjI1)
hence "R ∧ F" using H1 by (rule mp)
hence "F" by (rule conjI2)
hence "F ∨ N" by (rule disjI1)
hence "O" using H2 by (rule mp)
thus "A → O"
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y decidir la corrección, del siguiente
argumento
Hay estudiantes inteligentes y hay estudiantes trabajadores. Por
tanto, hay estudiantes inteligentes y trabajadores.
Usar I(x) para x es inteligente
T(x) para x es trabajador
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg danrodcha anaprarod crigomgom marcarmor13 pabrodmac migtermor josgarsan serrodcal pablucoto fracorjim1 *)

lemma ejercicio_2:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. (I(x) ∧ T(x))"
quickcheck
oops

(* Encontrando el contraejemplo:
I = {a1}
x = a1
T = {a2}
xa = a2
*)

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y decidir la corrección, del siguiente
argumento
Los hermanos tienen el mismo padre. Juan es hermano de Luis. Carlos
es padre de Luis. Por tanto, Carlos es padre de Juan.
Usar H(x,y) para x es hermano de y
P(x,y) para x es padre de y
j para Juan
l para Luis
c para Carlos
------------------------------------------------------------------ *}

(* ivamenjim crigomgom serrodcal*)

lemma ejercicio_3:
assumes 1: "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes 2: "H(j,l)"
assumes 3: "P(c,l)"
shows "P(c,j)"
proof -
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using 1 by (rule allE)
have 5 : "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" using 4 by (rule allE)
then have 6 : "(∀z. (H(z,l) ⟶ P(c,z)))" using 3 by (rule mp)
have 7 : "H(j,l) ⟶ P(c,j)" using 6 by (rule allE)
then show "P(c,j)" using 2 by (rule mp)
qed

(* danrodcha anaprarod ferrenseg marcarmor13 pablucoto fracorjim1 *)
(* es casi igual que la anterior *)
lemma ej_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes "H(j,l)"
assumes "P(c,l)"
shows "P(c,j)"
proof (rule mp)
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
hence "(∀z. (H(z,l) ⟶ P(c,z)))" using assms(3) by (rule mp)
thus "H(j,l) ⟶ P(c,j)" by (rule allE)
next
show "H(j,l)" using assms(2) by this
qed

(*pabrodmac*)
lemma ejercicio_3_1:
assumes "∀x y. H(x,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,x)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀y. H(j,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,j)))" using assms(1) by (rule allE)
hence "H(j,l) ⟶ (∀ z. (P(z,l) ⟶ P(z,j)))" by (rule allE)
hence "∀z. (P(z,l) ⟶ P(z,j))" using assms(2) by (rule mp)
hence "P(c,l) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using assms(3) by (rule mp)
qed

(* migtermor josgarsan*)

lemma ejercicio_3_2:
assumes "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes "H(l,j)"
assumes "P(c,l)"
shows "P(c,j)"
proof -
have 1: "P(c,l) ∧ H(l,j)" using assms(3) assms(2) by (rule conjI)
have 2: "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using assms(1) by (rule allE)
then have 3: "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
then have 4: "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
then show "P(c,j)" using 1 by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
(* danrodcha ferrenseg pablucoto*)
(* danrodcha: Me gusta más la formalización de ana prado, aunque
son equivalentes *)
lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. Ap(j,x) ⟶ ¬ E(x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume "∃x. E(x) ∧ N(x)"
then obtain a where "E(a) ∧ N(a)" by (rule exE)
hence "E(a)" by (rule conjE)
show "¬ Af(j)"
proof (rule notI)
assume "Af(j)"
hence "Af(j) ∧ E(a)" using `E(a)` by (rule conjI)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
hence "Ap(j,a)" using `Af(j) ∧ E(a)` by (rule mp)
have "Ap(j,a) ⟶ ¬ E(a)" using assms(2) by (rule allE)
hence "¬ E(a)" using `Ap(j,a)` by (rule mp)
thus False using `E(a)` by (rule notE)
qed
qed

(* ivamenjim crigomgom marcarmor13 serrodcal*)

lemma ejercicio_4:
assumes 1: "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
assumes 2: "¬(∃x. E(x) ∧ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume 3: "∃x. E(x) ∧ N(x)"
then obtain a where 4: "E(a) ∧ N(a)" by (rule exE)
then have 5: "E(a)" by (rule conjunct1)
show 6: "¬Af(j)"
proof (rule notI)
assume 7: "Af(j)"
then have 8: "Af(j) ∧ E(a)" using 5 by (rule conjI)
have 9: "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using 1 by (rule allE)
have 10: "Af(j) ∧ E(a) ⟶ Ap(j,a)" using 9 by (rule allE)
have 11: "Ap(j,a)" using 10 8 by (rule mp)
have 12: "E(a) ∧ Ap(j,a)" using 5 11 by (rule conjI)
have 13: "∃x. E(x) ∧ Ap(j,x)" using 12 by (rule exI)
show "False" using 2 13 by (rule notE)
qed
qed

(* anaprarod migtermor *)

(* Este auxiliar ya se probó en el ejercicio 4 de la rel 8 *)
lemma aux4: "¬(p∧q) ⟹¬p ∨ ¬q"
by (auto)

lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀ x.(E(x) ⟶ ¬ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
{ assume "∃x. E(x) ∧ N(x)"
then obtain a where 1: "E(a) ∧ N(a)" by (rule exE)
have "∀ y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence 2: "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
have 3: "E(a)" using 1 by (rule conjunct1)
have 4: "E(a) ⟶ ¬ Ap(j,a)" using assms(2) by (rule allE)
have 5: "¬ Ap(j,a)" using 4 3 by (rule mp)
have "¬(Af(j) ∧ E(a))" using 2 5 by (rule mt)
hence "¬ Af(j) ∨ ¬ E(a)" by (rule aux4)
thus " ¬Af(j)"
proof (rule disjE)
{assume "¬Af(j)"
thus "¬Af(j)" by this}
next
{assume 6: "¬ E(a)"
show "¬ Af(j)" using 6 3 by (rule notE)}
qed}
qed

(*pabrodmac*)

lemma ejercicio_4_1:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x)⟶ ¬Ap(j,x)"
shows "(∃x. N(x) ∧ E(x)) ⟶ ¬Af(j)"
proof
assume "∃x. N(x) ∧ E(x)"
then obtain b where "N(b) ∧ E(b)" by (rule exE)
hence "E(b)" by (rule conjunct2)
have "E(b)⟶ ¬Ap(j,b)" using assms(2) by (rule allE)
hence "¬Ap(j,b)" using `E(b)` by (rule mp)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(b) ⟶ Ap(j,b)" by (rule allE)
hence "¬Ap(j,b) ⟶ ¬(Af(j) ∧ E(b))" by (rule Set.not_mono)
hence "¬(Af(j) ∧ E(b))" using `¬Ap(j,b)` by (rule mp)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j) ∧ E(b)" using `E(b)` by (rule conjI)
show False using `¬(Af(j) ∧ E(b))` `Af(j) ∧ E(b)` by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar, y decidir la corrección, del siguiente
argumento
El esposo de la hermana de Toni es Roberto. La hermana de Toni es
María. Por tanto, el esposo de María es Roberto.
Usar e(x) para el esposo de x
h para la hermana de Toni
m para María
r para Roberto
------------------------------------------------------------------ *}

(* ivamenjim *)

lemma ejercicio_5:
assumes 1: "e(h) = r"
assumes 2: "h = m"
shows "e(m) = r"
proof -
have 3: "e(h) = e(m)" using 2 by (rule arg_cong)
have 4: "e(m) = e(h)" using 3 by (rule sym)
then show "e(m) = r" using 1 by (rule trans)
qed

(* danrodcha anaprarod crigomgom ferrenseg marcarmor13 migtermor serrodcal pablucoto*)
lemma ej_5:
assumes "e(h) = r" and
"h = m"
shows "e(m) = r"
proof -
show "e(m) = r" using assms(2) assms(1) by (rule subst)
qed

(*pabrodmac*)
lemma ejercicio_5_1:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(1) assms(2) by (rule HOL.back_subst)
qed

(*pabrodmac*)
lemma ejercicio_5_2:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(2) assms(1) by (rule HOL.subst)
qed

(*pabrodmac*)
lemma ejercicio_5_3:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
have "e(h) = e(m)" using assms(2) by (rule arg_cong)
show "e(m)=r" using `e(h)=r` `e(h) = e(m)` by simp
qed

end
</source>

Relación 10

2017-02-01T05:58:32Z

Fracorjim1:

<source lang="isar">
chapter {* R10: Formalización y argumentación con Isabelle/HOL *}

theory R10_Formalizacion_y_argmentacion
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta es relación formalizar y demostrar la corrección
de los argumentos automáticamente y detalladamente usando sólo las reglas
básicas de deducción natural.

· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
---------------------------------------------------------------------
*}

text {*
Se usarán las reglas notnotI, mt, no_ex y no_para_todo que demostramos
a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

lemma no_para_todo: "¬(∀x. P(x)) ⟹ ∃x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si la válvula está abierta o la monitorización está preparada,
entonces se envía una señal de reconocimiento y un mensaje de
funcionamiento al controlador del ordenador. Si se envía un mensaje
de funcionamiento al controlador del ordenador o el sistema está en
estado normal, entonces se aceptan las órdenes del operador. Por lo
tanto, si la válvula está abierta, entonces se aceptan las órdenes
del operador.
Usar A : La válvula está abierta.
P : La monitorización está preparada.
R : Envía una señal de reconocimiento.
F : Envía un mensaje de funcionamiento.
N : El sistema está en estado normal.
O, AO, OK : Se aceptan órdenes del operador.
------------------------------------------------------------------ *}

(* ivamenjim manmorjim1 crigomgom migtermor serrodcal *)
(* Buscando, he detectado que 'O' es un carácter especial en Isabelle y que forma parte de su
sintaxis pre-definida, por lo que da problemas a la hora de formalizar y demostrar
el argumento planteado. Por lo tanto, en su lugar he usado "AO: Se aceptan órdenes del operador" *)

lemma ejercicio_1:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)"
assumes 2: "(F ∨ N) ⟶ AO"
shows "A ⟶ AO"
proof -
{assume 3: "A"
have 4: "A ∨ P" using 3 by (rule disjI1)
have 5: "R ∧ F" using 1 4 by (rule mp)
have 6: "F" using 5 by (rule conjunct2)
have 7: "F ∨ N" using 6 by (rule disjI1)
have 8: "AO" using 2 7 by (rule mp)}
then show "A ⟶ AO" by (rule impI)
qed

(*danrodcha ferrenseg anaprarod marcarmor13 pablucoto*)

lemma ej_1:
assumes "A ∨ P ⟶ R ∧ F" and
"F ∨ N ⟶ OK"
shows "A ⟶ OK"
proof (rule impI)
{assume "A"
hence "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
with assms(2) show "OK" by (rule mp)}
qed

(*pabrodmac*)
lemma ejercicio_1_1:
assumes "A ∨ P ⟶ R ∧ F"
"F ∨ N ⟶ Op"
shows "A ⟶ Op"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
have "R ∧ F" using `A ∨ P ⟶ R ∧ F` `A ∨ P` by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
show "Op" using `F ∨ N ⟶ Op` `F ∨ N` by (rule mp)
qed

(*josgarsan*)
lemma ejericio_1_2:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)" and
2: "(F ∨ N) ⟶ Op"
shows "A ⟶ Op"
proof
assume 3: A
have 4:"(A ∨ P)" using 3 by (rule disjI1)
have "(R ∧ F)" using 1 4 by (rule mp)
then have "F" by (rule conjunct2)
then have 5: "(F ∨ N)" by (rule disjI1)
show "Op" using 2 5 by (rule mp)
qed

(* fracorjim1 *)

lemma ejercicio_1_3:
assumes H1: "(A ∨ P) → (R ∧ F)" and
H2: "(F ∨ N) → O"
shows "A → O"
proof -
assume "A"
have "A ∨ P" by (rule disjI1)
hence "R ∧ F" using H1 by (rule mp)
hence "F" by (rule conjI2)
hence "F ∨ N" by (rule disjI1)
hence "O" using H2 by (rule mp)
thus "A → O"
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y decidir la corrección, del siguiente
argumento
Hay estudiantes inteligentes y hay estudiantes trabajadores. Por
tanto, hay estudiantes inteligentes y trabajadores.
Usar I(x) para x es inteligente
T(x) para x es trabajador
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg danrodcha anaprarod crigomgom marcarmor13 pabrodmac migtermor josgarsan serrodcal pablucoto fracorjim1 *)

lemma ejercicio_2:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. (I(x) ∧ T(x))"
quickcheck
oops

(* Encontrando el contraejemplo:
I = {a1}
x = a1
T = {a2}
xa = a2
*)

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y decidir la corrección, del siguiente
argumento
Los hermanos tienen el mismo padre. Juan es hermano de Luis. Carlos
es padre de Luis. Por tanto, Carlos es padre de Juan.
Usar H(x,y) para x es hermano de y
P(x,y) para x es padre de y
j para Juan
l para Luis
c para Carlos
------------------------------------------------------------------ *}

(* ivamenjim crigomgom serrodcal*)

lemma ejercicio_3:
assumes 1: "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes 2: "H(j,l)"
assumes 3: "P(c,l)"
shows "P(c,j)"
proof -
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using 1 by (rule allE)
have 5 : "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" using 4 by (rule allE)
then have 6 : "(∀z. (H(z,l) ⟶ P(c,z)))" using 3 by (rule mp)
have 7 : "H(j,l) ⟶ P(c,j)" using 6 by (rule allE)
then show "P(c,j)" using 2 by (rule mp)
qed

(* danrodcha anaprarod ferrenseg marcarmor13 pablucoto*)
(* es casi igual que la anterior *)
lemma ej_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes "H(j,l)"
assumes "P(c,l)"
shows "P(c,j)"
proof (rule mp)
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
hence "(∀z. (H(z,l) ⟶ P(c,z)))" using assms(3) by (rule mp)
thus "H(j,l) ⟶ P(c,j)" by (rule allE)
next
show "H(j,l)" using assms(2) by this
qed

(*pabrodmac*)
lemma ejercicio_3_1:
assumes "∀x y. H(x,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,x)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀y. H(j,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,j)))" using assms(1) by (rule allE)
hence "H(j,l) ⟶ (∀ z. (P(z,l) ⟶ P(z,j)))" by (rule allE)
hence "∀z. (P(z,l) ⟶ P(z,j))" using assms(2) by (rule mp)
hence "P(c,l) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using assms(3) by (rule mp)
qed

(* migtermor josgarsan*)

lemma ejercicio_3_2:
assumes "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes "H(l,j)"
assumes "P(c,l)"
shows "P(c,j)"
proof -
have 1: "P(c,l) ∧ H(l,j)" using assms(3) assms(2) by (rule conjI)
have 2: "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using assms(1) by (rule allE)
then have 3: "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
then have 4: "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
then show "P(c,j)" using 1 by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
(* danrodcha ferrenseg pablucoto*)
(* danrodcha: Me gusta más la formalización de ana prado, aunque
son equivalentes *)
lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. Ap(j,x) ⟶ ¬ E(x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume "∃x. E(x) ∧ N(x)"
then obtain a where "E(a) ∧ N(a)" by (rule exE)
hence "E(a)" by (rule conjE)
show "¬ Af(j)"
proof (rule notI)
assume "Af(j)"
hence "Af(j) ∧ E(a)" using `E(a)` by (rule conjI)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
hence "Ap(j,a)" using `Af(j) ∧ E(a)` by (rule mp)
have "Ap(j,a) ⟶ ¬ E(a)" using assms(2) by (rule allE)
hence "¬ E(a)" using `Ap(j,a)` by (rule mp)
thus False using `E(a)` by (rule notE)
qed
qed

(* ivamenjim crigomgom marcarmor13 serrodcal*)

lemma ejercicio_4:
assumes 1: "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
assumes 2: "¬(∃x. E(x) ∧ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume 3: "∃x. E(x) ∧ N(x)"
then obtain a where 4: "E(a) ∧ N(a)" by (rule exE)
then have 5: "E(a)" by (rule conjunct1)
show 6: "¬Af(j)"
proof (rule notI)
assume 7: "Af(j)"
then have 8: "Af(j) ∧ E(a)" using 5 by (rule conjI)
have 9: "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using 1 by (rule allE)
have 10: "Af(j) ∧ E(a) ⟶ Ap(j,a)" using 9 by (rule allE)
have 11: "Ap(j,a)" using 10 8 by (rule mp)
have 12: "E(a) ∧ Ap(j,a)" using 5 11 by (rule conjI)
have 13: "∃x. E(x) ∧ Ap(j,x)" using 12 by (rule exI)
show "False" using 2 13 by (rule notE)
qed
qed

(* anaprarod migtermor *)

(* Este auxiliar ya se probó en el ejercicio 4 de la rel 8 *)
lemma aux4: "¬(p∧q) ⟹¬p ∨ ¬q"
by (auto)

lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀ x.(E(x) ⟶ ¬ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
{ assume "∃x. E(x) ∧ N(x)"
then obtain a where 1: "E(a) ∧ N(a)" by (rule exE)
have "∀ y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence 2: "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
have 3: "E(a)" using 1 by (rule conjunct1)
have 4: "E(a) ⟶ ¬ Ap(j,a)" using assms(2) by (rule allE)
have 5: "¬ Ap(j,a)" using 4 3 by (rule mp)
have "¬(Af(j) ∧ E(a))" using 2 5 by (rule mt)
hence "¬ Af(j) ∨ ¬ E(a)" by (rule aux4)
thus " ¬Af(j)"
proof (rule disjE)
{assume "¬Af(j)"
thus "¬Af(j)" by this}
next
{assume 6: "¬ E(a)"
show "¬ Af(j)" using 6 3 by (rule notE)}
qed}
qed

(*pabrodmac*)

lemma ejercicio_4_1:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x)⟶ ¬Ap(j,x)"
shows "(∃x. N(x) ∧ E(x)) ⟶ ¬Af(j)"
proof
assume "∃x. N(x) ∧ E(x)"
then obtain b where "N(b) ∧ E(b)" by (rule exE)
hence "E(b)" by (rule conjunct2)
have "E(b)⟶ ¬Ap(j,b)" using assms(2) by (rule allE)
hence "¬Ap(j,b)" using `E(b)` by (rule mp)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(b) ⟶ Ap(j,b)" by (rule allE)
hence "¬Ap(j,b) ⟶ ¬(Af(j) ∧ E(b))" by (rule Set.not_mono)
hence "¬(Af(j) ∧ E(b))" using `¬Ap(j,b)` by (rule mp)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j) ∧ E(b)" using `E(b)` by (rule conjI)
show False using `¬(Af(j) ∧ E(b))` `Af(j) ∧ E(b)` by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar, y decidir la corrección, del siguiente
argumento
El esposo de la hermana de Toni es Roberto. La hermana de Toni es
María. Por tanto, el esposo de María es Roberto.
Usar e(x) para el esposo de x
h para la hermana de Toni
m para María
r para Roberto
------------------------------------------------------------------ *}

(* ivamenjim *)

lemma ejercicio_5:
assumes 1: "e(h) = r"
assumes 2: "h = m"
shows "e(m) = r"
proof -
have 3: "e(h) = e(m)" using 2 by (rule arg_cong)
have 4: "e(m) = e(h)" using 3 by (rule sym)
then show "e(m) = r" using 1 by (rule trans)
qed

(* danrodcha anaprarod crigomgom ferrenseg marcarmor13 migtermor serrodcal pablucoto*)
lemma ej_5:
assumes "e(h) = r" and
"h = m"
shows "e(m) = r"
proof -
show "e(m) = r" using assms(2) assms(1) by (rule subst)
qed

(*pabrodmac*)
lemma ejercicio_5_1:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(1) assms(2) by (rule HOL.back_subst)
qed

(*pabrodmac*)
lemma ejercicio_5_2:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(2) assms(1) by (rule HOL.subst)
qed

(*pabrodmac*)
lemma ejercicio_5_3:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
have "e(h) = e(m)" using assms(2) by (rule arg_cong)
show "e(m)=r" using `e(h)=r` `e(h) = e(m)` by simp
qed

end
</source>

Relación 10

2017-02-01T05:50:10Z

Fracorjim1:

<source lang="isar">
chapter {* R10: Formalización y argumentación con Isabelle/HOL *}

theory R10_Formalizacion_y_argmentacion
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta es relación formalizar y demostrar la corrección
de los argumentos automáticamente y detalladamente usando sólo las reglas
básicas de deducción natural.

· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
---------------------------------------------------------------------
*}

text {*
Se usarán las reglas notnotI, mt, no_ex y no_para_todo que demostramos
a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

lemma no_para_todo: "¬(∀x. P(x)) ⟹ ∃x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si la válvula está abierta o la monitorización está preparada,
entonces se envía una señal de reconocimiento y un mensaje de
funcionamiento al controlador del ordenador. Si se envía un mensaje
de funcionamiento al controlador del ordenador o el sistema está en
estado normal, entonces se aceptan las órdenes del operador. Por lo
tanto, si la válvula está abierta, entonces se aceptan las órdenes
del operador.
Usar A : La válvula está abierta.
P : La monitorización está preparada.
R : Envía una señal de reconocimiento.
F : Envía un mensaje de funcionamiento.
N : El sistema está en estado normal.
O, AO, OK : Se aceptan órdenes del operador.
------------------------------------------------------------------ *}

(* ivamenjim manmorjim1 crigomgom migtermor serrodcal *)
(* Buscando, he detectado que 'O' es un carácter especial en Isabelle y que forma parte de su
sintaxis pre-definida, por lo que da problemas a la hora de formalizar y demostrar
el argumento planteado. Por lo tanto, en su lugar he usado "AO: Se aceptan órdenes del operador" *)

lemma ejercicio_1:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)"
assumes 2: "(F ∨ N) ⟶ AO"
shows "A ⟶ AO"
proof -
{assume 3: "A"
have 4: "A ∨ P" using 3 by (rule disjI1)
have 5: "R ∧ F" using 1 4 by (rule mp)
have 6: "F" using 5 by (rule conjunct2)
have 7: "F ∨ N" using 6 by (rule disjI1)
have 8: "AO" using 2 7 by (rule mp)}
then show "A ⟶ AO" by (rule impI)
qed

(*danrodcha ferrenseg anaprarod marcarmor13 pablucoto*)

lemma ej_1:
assumes "A ∨ P ⟶ R ∧ F" and
"F ∨ N ⟶ OK"
shows "A ⟶ OK"
proof (rule impI)
{assume "A"
hence "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
with assms(2) show "OK" by (rule mp)}
qed

(*pabrodmac*)
lemma ejercicio_1_1:
assumes "A ∨ P ⟶ R ∧ F"
"F ∨ N ⟶ Op"
shows "A ⟶ Op"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
have "R ∧ F" using `A ∨ P ⟶ R ∧ F` `A ∨ P` by (rule mp)
hence "F" by (rule conjE)
hence "F ∨ N" by (rule disjI1)
show "Op" using `F ∨ N ⟶ Op` `F ∨ N` by (rule mp)
qed

(*josgarsan*)
lemma ejericio_1_2:
assumes 1: "(A ∨ P) ⟶ (R ∧ F)" and
2: "(F ∨ N) ⟶ Op"
shows "A ⟶ Op"
proof
assume 3: A
have 4:"(A ∨ P)" using 3 by (rule disjI1)
have "(R ∧ F)" using 1 4 by (rule mp)
then have "F" by (rule conjunct2)
then have 5: "(F ∨ N)" by (rule disjI1)
show "Op" using 2 5 by (rule mp)
qed

(* fracorjim1 *)

lemma ejercicio_1_3:
assumes H1: "(A ∨ P) → (R ∧ F)" and
H2: "(F ∨ N) → O"
shows "A → O"
proof -
assume "A"
have "A ∨ P" by (rule disjI1)
hence "R ∧ F" using H1 by (rule mp)
hence "F" by (rule conjI2)
hence "F ∨ N" by (rule disjI1)
hence "O" using H2 by (rule mp)
thus "A → O"
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y decidir la corrección, del siguiente
argumento
Hay estudiantes inteligentes y hay estudiantes trabajadores. Por
tanto, hay estudiantes inteligentes y trabajadores.
Usar I(x) para x es inteligente
T(x) para x es trabajador
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg danrodcha anaprarod crigomgom marcarmor13 pabrodmac migtermor josgarsan serrodcal pablucoto*)

lemma ejercicio_2:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. (I(x) ∧ T(x))"
quickcheck
oops

(* Encontrando el contraejemplo:
I = {a1}
x = a1
T = {a2}
xa = a2
*)

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y decidir la corrección, del siguiente
argumento
Los hermanos tienen el mismo padre. Juan es hermano de Luis. Carlos
es padre de Luis. Por tanto, Carlos es padre de Juan.
Usar H(x,y) para x es hermano de y
P(x,y) para x es padre de y
j para Juan
l para Luis
c para Carlos
------------------------------------------------------------------ *}

(* ivamenjim crigomgom serrodcal*)

lemma ejercicio_3:
assumes 1: "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes 2: "H(j,l)"
assumes 3: "P(c,l)"
shows "P(c,j)"
proof -
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using 1 by (rule allE)
have 5 : "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" using 4 by (rule allE)
then have 6 : "(∀z. (H(z,l) ⟶ P(c,z)))" using 3 by (rule mp)
have 7 : "H(j,l) ⟶ P(c,j)" using 6 by (rule allE)
then show "P(c,j)" using 2 by (rule mp)
qed

(* danrodcha anaprarod ferrenseg marcarmor13 pablucoto*)
(* es casi igual que la anterior *)
lemma ej_3:
assumes "∀x y. P(x,y) ⟶ (∀z. (H(z,y) ⟶ P(x,z)))"
assumes "H(j,l)"
assumes "P(c,l)"
shows "P(c,j)"
proof (rule mp)
have 4 : "∀y. P(c,y) ⟶ (∀z. (H(z,y) ⟶ P(c,z)))" using assms(1) by (rule allE)
hence "P(c,l) ⟶ (∀z. (H(z,l) ⟶ P(c,z)))" by (rule allE)
hence "(∀z. (H(z,l) ⟶ P(c,z)))" using assms(3) by (rule mp)
thus "H(j,l) ⟶ P(c,j)" by (rule allE)
next
show "H(j,l)" using assms(2) by this
qed

(*pabrodmac*)
lemma ejercicio_3_1:
assumes "∀x y. H(x,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,x)))"
"H(j,l)"
"P(c,l)"
shows "P(c,j)"
proof-
have "∀y. H(j,y) ⟶ (∀ z. (P(z,y) ⟶ P(z,j)))" using assms(1) by (rule allE)
hence "H(j,l) ⟶ (∀ z. (P(z,l) ⟶ P(z,j)))" by (rule allE)
hence "∀z. (P(z,l) ⟶ P(z,j))" using assms(2) by (rule mp)
hence "P(c,l) ⟶ P(c,j)" by (rule allE)
thus "P(c,j)" using assms(3) by (rule mp)
qed

(* migtermor josgarsan*)

lemma ejercicio_3_2:
assumes "∀x y z. (P(x,y) ∧ H(y,z)) ⟶ P(x,z)"
assumes "H(l,j)"
assumes "P(c,l)"
shows "P(c,j)"
proof -
have 1: "P(c,l) ∧ H(l,j)" using assms(3) assms(2) by (rule conjI)
have 2: "∀y z. (P(c,y) ∧ H(y,z)) ⟶ P(c,z)" using assms(1) by (rule allE)
then have 3: "∀z. (P(c,l) ∧ H(l,z)) ⟶ P(c,z)" by (rule allE)
then have 4: "(P(c,l) ∧ H(l,j)) ⟶ P(c,j)" by (rule allE)
then show "P(c,j)" using 1 by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
(* danrodcha ferrenseg pablucoto*)
(* danrodcha: Me gusta más la formalización de ana prado, aunque
son equivalentes *)
lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. Ap(j,x) ⟶ ¬ E(x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume "∃x. E(x) ∧ N(x)"
then obtain a where "E(a) ∧ N(a)" by (rule exE)
hence "E(a)" by (rule conjE)
show "¬ Af(j)"
proof (rule notI)
assume "Af(j)"
hence "Af(j) ∧ E(a)" using `E(a)` by (rule conjI)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
hence "Ap(j,a)" using `Af(j) ∧ E(a)` by (rule mp)
have "Ap(j,a) ⟶ ¬ E(a)" using assms(2) by (rule allE)
hence "¬ E(a)" using `Ap(j,a)` by (rule mp)
thus False using `E(a)` by (rule notE)
qed
qed

(* ivamenjim crigomgom marcarmor13 serrodcal*)

lemma ejercicio_4:
assumes 1: "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
assumes 2: "¬(∃x. E(x) ∧ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
assume 3: "∃x. E(x) ∧ N(x)"
then obtain a where 4: "E(a) ∧ N(a)" by (rule exE)
then have 5: "E(a)" by (rule conjunct1)
show 6: "¬Af(j)"
proof (rule notI)
assume 7: "Af(j)"
then have 8: "Af(j) ∧ E(a)" using 5 by (rule conjI)
have 9: "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using 1 by (rule allE)
have 10: "Af(j) ∧ E(a) ⟶ Ap(j,a)" using 9 by (rule allE)
have 11: "Ap(j,a)" using 10 8 by (rule mp)
have 12: "E(a) ∧ Ap(j,a)" using 5 11 by (rule conjI)
have 13: "∃x. E(x) ∧ Ap(j,x)" using 12 by (rule exI)
show "False" using 2 13 by (rule notE)
qed
qed

(* anaprarod migtermor *)

(* Este auxiliar ya se probó en el ejercicio 4 de la rel 8 *)
lemma aux4: "¬(p∧q) ⟹¬p ∨ ¬q"
by (auto)

lemma ej_4:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀ x.(E(x) ⟶ ¬ Ap(j,x))"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
proof (rule impI)
{ assume "∃x. E(x) ∧ N(x)"
then obtain a where 1: "E(a) ∧ N(a)" by (rule exE)
have "∀ y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence 2: "Af(j) ∧ E(a) ⟶ Ap(j,a)" by (rule allE)
have 3: "E(a)" using 1 by (rule conjunct1)
have 4: "E(a) ⟶ ¬ Ap(j,a)" using assms(2) by (rule allE)
have 5: "¬ Ap(j,a)" using 4 3 by (rule mp)
have "¬(Af(j) ∧ E(a))" using 2 5 by (rule mt)
hence "¬ Af(j) ∨ ¬ E(a)" by (rule aux4)
thus " ¬Af(j)"
proof (rule disjE)
{assume "¬Af(j)"
thus "¬Af(j)" by this}
next
{assume 6: "¬ E(a)"
show "¬ Af(j)" using 6 3 by (rule notE)}
qed}
qed

(*pabrodmac*)

lemma ejercicio_4_1:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x)⟶ ¬Ap(j,x)"
shows "(∃x. N(x) ∧ E(x)) ⟶ ¬Af(j)"
proof
assume "∃x. N(x) ∧ E(x)"
then obtain b where "N(b) ∧ E(b)" by (rule exE)
hence "E(b)" by (rule conjunct2)
have "E(b)⟶ ¬Ap(j,b)" using assms(2) by (rule allE)
hence "¬Ap(j,b)" using `E(b)` by (rule mp)
have "∀y. Af(j) ∧ E(y) ⟶ Ap(j,y)" using assms(1) by (rule allE)
hence "Af(j) ∧ E(b) ⟶ Ap(j,b)" by (rule allE)
hence "¬Ap(j,b) ⟶ ¬(Af(j) ∧ E(b))" by (rule Set.not_mono)
hence "¬(Af(j) ∧ E(b))" using `¬Ap(j,b)` by (rule mp)
show "¬Af(j)"
proof
assume "Af(j)"
hence "Af(j) ∧ E(b)" using `E(b)` by (rule conjI)
show False using `¬(Af(j) ∧ E(b))` `Af(j) ∧ E(b)` by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar, y decidir la corrección, del siguiente
argumento
El esposo de la hermana de Toni es Roberto. La hermana de Toni es
María. Por tanto, el esposo de María es Roberto.
Usar e(x) para el esposo de x
h para la hermana de Toni
m para María
r para Roberto
------------------------------------------------------------------ *}

(* ivamenjim *)

lemma ejercicio_5:
assumes 1: "e(h) = r"
assumes 2: "h = m"
shows "e(m) = r"
proof -
have 3: "e(h) = e(m)" using 2 by (rule arg_cong)
have 4: "e(m) = e(h)" using 3 by (rule sym)
then show "e(m) = r" using 1 by (rule trans)
qed

(* danrodcha anaprarod crigomgom ferrenseg marcarmor13 migtermor serrodcal pablucoto*)
lemma ej_5:
assumes "e(h) = r" and
"h = m"
shows "e(m) = r"
proof -
show "e(m) = r" using assms(2) assms(1) by (rule subst)
qed

(*pabrodmac*)
lemma ejercicio_5_1:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(1) assms(2) by (rule HOL.back_subst)
qed

(*pabrodmac*)
lemma ejercicio_5_2:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
show "e(m)=r" using assms(2) assms(1) by (rule HOL.subst)
qed

(*pabrodmac*)
lemma ejercicio_5_3:
assumes "e(h)=r"
"h=m"
shows "e(m)=r"
proof-
have "e(h) = e(m)" using assms(2) by (rule arg_cong)
show "e(m)=r" using `e(h)=r` `e(h) = e(m)` by simp
qed

end
</source>

Relación 9

2017-01-25T18:38:11Z

Fracorjim1:

<source lang="isar">
chapter {* R9: Deducción natural LPO en Isabelle/HOL *}

theory R9_Deduccion_natural_LPO
imports Main
begin

text {*
Demostrar o refutar los siguientes lemas usando sólo las reglas
básicas de deducción natural de la lógica proposicional, de los
cuantificadores y de la igualdad:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
*}

text {*
Se usarán las reglas notnotI, mt y not_ex que demostramos a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
P a ⟶ (∃x. Q x) ⊢ ∃x. P a ⟶ Q x
------------------------------------------------------------------ *}

lemma ejercicio_1:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
oops

(* migtermor ferrenseg juacabsou josgarsan*)
lemma ejercicio_1:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
{assume 1: "P a"
have 2: "∃x. Q x" using assms 1 by (rule mp)}
then obtain b where 3: "Q b" by (rule exE)
(* No sé por qué salta un aviso aquí. Aún así, sin esto no se finaliza correctamente la demostración, y con ello sí. *)
then have 4: "(P a) ⟶ (Q b)" by (rule impI)
then show 5: "∃x. P a ⟶ Q x" by (rule exI)
qed

(* ivamenjim bowma *)

lemma ejercicio_1_1:
assumes 1: "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
{assume 2: "P a"
have 3: "(∃x. Q x)" using 1 2 by (rule mp)
obtain b where 4: "Q b" using 3 by (rule exE)
then have 5: "P a ⟶ Q b" by (rule impI)
then have 6: "∃x. P a ⟶ Q x" by (rule exI)}
then show "∃x. P a ⟶ Q x" by simp
qed

(* crigomgom *)
lemma ejercicio_1_2:
assumes 0: "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
have "¬(P a) ∨ P a" by (rule excluded_middle)
then show "∃x. P a ⟶ Q x"
proof (rule disjE)
assume 1 : "¬(P a)"
{assume 2 : "P a"
have "Q b" using 1 2 by (rule notE)}
then have "P a ⟶ Q b" by (rule impI)
then show "∃x. P a ⟶ Q x" by (rule exI)
next
assume 3 : "P a"
have "∃x. Q x" using 0 3 by (rule mp)
then obtain b where "Q b" by (rule exE)
then have "P a ⟶ Q b" by (rule impI)
then show "∃x. P a ⟶ Q x" by (rule exI)
qed
qed

(* fracorjim1 *)
(* Entre corchetes se demuestra que efectivamente existe un caso *)
lemma ejercicio_1_3:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
{
assume "P a"
with assms have "∃x. Q x" by (rule mp)
then obtain x where "Q x" by (rule exE)
hence "P a ⟶ Q x" by (rule impI)
hence "∃x. P a ⟶ Q x" by (rule exI)
}
thus ?thesis by simp
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
{∀x y z. R x y ∧ R y z ⟶ R x z,
∀x. ¬(R x x)}
⊢ ∀x y. R x y ⟶ ¬(R y x)
------------------------------------------------------------------ *}

(* migtermor ferrenseg ivamenjim marcarmor13 serrodcal juacabsou marpoldia1 crigomgom bowma josgarsan*)
lemma ejercicio_2:
fixes R :: "'b ⇒ 'b ⇒ bool"
assumes 1: "∀x y z. R x y ∧ R y z ⟶ R x z"
assumes 2: "∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix x
show "∀y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix y
{assume 3: "R x y"
{assume 4: "R y x"
have 5: "R x y ∧ R y x" using 3 4 by (rule conjI)
also have 6: "∀ z1 z2. R x z1 ∧ R z1 z2 ⟶ R x z2" using 1 by (rule allE)
then have 7: "∀ z. R x y ∧ R y z ⟶ R x z" by (rule allE)
then have 8: "R x y ∧ R y x ⟶ R x x" by (rule allE)
then have 9: "R x x" using 5 by (rule mp)
have 10: "¬(R x x)" using 2 by (rule allE)
then have 11: "False" using 9 by (rule notE)}
then have 12: "¬ (R y x)" by (rule notI)}
thus "R x y ⟶ ¬(R y x)" by (rule impI)
qed
qed

(* ivamenjim *)
(* Semejante al anterior, pero indicando que se pruebe por la regla correspondiente *)

lemma ejercicio_2_1:
assumes 1: "∀x y z. R x y ∧ R y z ⟶ R x z"
assumes 2: "∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix x
show "∀y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix y
{assume 3: "R x y"
{assume 4: "R y x"
have 5: "R x y ∧ R y x" using 3 4 ..
have 6: "∀ y z. R x y ∧ R y z ⟶ R x z" using 1 ..
then have 7: "∀ z. R x y ∧ R y z ⟶ R x z" ..
then have 8: "R x y ∧ R y x ⟶ R x x" ..
then have 9: "R x x" using 5 ..
have 10: "¬(R x x)" using 2 ..
then have 11: "False" using 9 ..}
then have 12: "¬ (R y x)" ..}
thus "R x y ⟶ ¬(R y x)" ..
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar o refutar
(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)
------------------------------------------------------------------ *}

(* ivamenjim ferrenseg paupeddeg serrodcal juacabsou marpoldia1 crigomgom bowma josgarsan*)
lemma ejercicio_3:
assumes "(∀x. ∃y. P x y)"
shows "(∃y. ∀x. P x y)"
quickcheck
oops

(* Y se encuentra el contraejemplo: P = (λx. undefined)(a1 := {a2}, a2 := {a1}) *)

(* migtermor *)
fun P :: "'a ⇒ 'a ⇒ bool" where
"P x y = (x=y)"

lemma ejercicio3:
"(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
quickcheck
oops

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar o refutar
{∀x. P a x x,
∀x y z. P x y z ⟶ P (f x) y (f z)⟧
⊢ ∃z. P (f a) z (f (f a))
------------------------------------------------------------------ *}

(* ferrenseg ivamenjim *)
lemma ejercicio_4:
assumes 1:"∀x. P a x x" and 2:"∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
proof -
have 4:"P a (f a) (f a)" using 1 ..
also have 5:"∀y z. P a y z ⟶ P (f a) y (f z)" using 2 ..
then have 6:"∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" ..
then have 7:"P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" ..
also have 8:"P (f a) (f a) (f (f a))" using 7 4 by (rule mp)
then show "∃z. P (f a) z (f (f a))" ..
qed

(* migtermor serrodcal crigomgom*)
lemma ejercicio_4_2:
fixes P :: "'b ⇒ 'b ⇒ 'b ⇒ bool"
assumes 1: "∀x. P a x x"
assumes 2: "∀x y z. P x y z ⟶ P (f x) y (f z)"
shows " ∃z. P (f a) z (f (f a))"
proof (rule exI)
have 3: "P a (f a) (f a)" using 1 by (rule allE)
have 4: "∀y z. P a y z ⟶ P (f a) y (f z)" using 2 by (rule allE)
then have 5: "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" by (rule allE)
then have 6: "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" by (rule allE)
then show "P (f a) (f a) (f (f a))" using 3 by (rule mp)
qed

(* paupeddeg juacabsou marpoldia1 bowma *)
lemma ejercicio_4_3:
assumes " ∀x. P a x x "
" ∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
proof
have "∀ y z. P a y z ⟶ P (f a) y (f z)" using assms(2) by (rule allE)
hence "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" by (rule allE)
hence "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" by (rule allE)
have "P a (f a) (f a)" using assms(1) by (rule allE)
show "P (f a) (f a) (f (f a))" using `P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))` `P a (f a) (f a)` by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar o refutar
{∀y. Q a y,
∀x y. Q x y ⟶ Q (s x) (s y)}
⊢ ∃z. Qa z ∧ Q z (s (s a))
------------------------------------------------------------------ *}

(* ferrenseg ivamenjim *)
lemma ejercicio_5:
assumes 1:"∀y. Q a y" and 2:"∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
proof
have 3:"Q a (s a)" using 1 ..
also have 4:"∀y. Q a y ⟶ Q (s a) (s y)" using 2 ..
then have 5:"Q a (s a) ⟶ Q (s a) (s (s a))" ..
then have 6:"Q (s a) (s (s a))" using 3 by (rule mp)
show "Q a (s a) ∧ Q (s a) (s (s a))" using 3 6 by (rule conjI)
qed

(* migtermor *)
lemma ejercicio_5_2:
fixes P :: "'b ⇒ 'b ⇒ bool"
assumes 1: "∀y. Q a y"
assumes 2: "∀x y. Q x y ⟶ Q (s x) (s y)"
shows " ∃z. Q a z ∧ Q z (s (s a))"
proof -
have 3: "Q a (s a)" using 1 by (rule allE)
have 4: "∀y. Q a y ⟶ Q (s a) (s y)" using 2 by (rule allE)
then have 5: "Q a (s a) ⟶ Q (s a) (s (s a))" by (rule allE)
then have 6: "Q (s a) (s (s a))" using 3 by (rule mp)
have "Q a (s a) ∧ Q (s a) (s (s a))" using 3 6 by (rule conjI)
then show "∃z. Q a z ∧ Q z (s (s a))" by (rule exI)
qed

(* paupeddeg serrodcal juacabsou marpoldia1 crigomgom bowma *)
lemma ejercicio_5_3:
assumes "∀y. Q a y"
"∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
proof
have "∀y. Q a y ⟶ Q (s a) (s y)" using assms(2) by (rule allE)
hence "Q a (s a) ⟶ Q (s a) (s (s a))" by (rule allE)
have "Q a (s a)" using assms(1) by (rule allE)
have "Q (s a) (s (s a))" using `Q a (s a) ⟶ Q (s a) (s (s a))` `Q a (s a)` by (rule mp)
show "Q a (s a) ∧ Q (s a) (s (s a))" using `Q a (s a)` `Q (s a) (s (s a))` by (rule conjI)
qed

end
</source>

Relación 8

2017-01-18T19:21:50Z

Fracorjim1:

<source lang="isar">
chapter {* R8: Deducción natural proposicional en Isabelle/HOL *}

theory R8_Deduccion_natural_proposicional
imports Main
begin

text {*
Demostrar o refutar los siguientes lemas usando sólo las reglas
básicas de deducción natural de la lógica proposicional, de los
cuantificadores y de la igualdad:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
*}

text {*
Se usarán las reglas notnotI, mt y not_ex que demostramos a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}
(* marcarmor13 *)
--"usando un supuesto ¬¬p"
lemma ejercicio_1:
assumes 1: "¬q ⟶ ¬p" and
2: "¬¬p"
shows "p ⟶ q"
proof -
have 3: "¬¬q" using 1 2 by (rule mt)
have 4: "q" using 3 by (rule notnotD)
show "p ⟶ q" using 4 by (rule impI)
qed

(* pablucoto jeamacpov migtermor *)
lemma ejercicio_1_2:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume "p"
hence "¬¬p" by (rule notnotI)
with `¬q ⟶ ¬p` have "¬¬q" by (rule mt)
hence "q" by (rule notnotD)}
then show "p ⟶ q" by (rule impI)
qed

(* ivamenjim serrodcal anaprarod marpoldia1 manmorjim1 crigomgom juancabsou ferrenseg fraortmoy*)
lemma ejercicio_1_3:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume 2:"p"
then have 3: "¬¬p" by (rule notnotI)
have 4: "¬¬q" using 1 3 by (rule mt)
then have 5: "q" by (rule notnotD)}
thus "p ⟶ q" by (rule impI)
qed

(* bowma *)
lemma ejercicio_1_4:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
then have "q" by (rule notnotD)}
thus "p ⟶ q" by (rule impI)
qed

(* bowma danrodcha paupeddeg pabrodmac fracorjim1 *)
"quita la limitación de -"
lemma ejercicio_1_5:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

(* josgarsan *)
lemma ejercicio_1_6:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (cases)
assume "p"
then show "p⟶q" using 1 by simp
next
assume "¬p"
then show "p⟶q" by simp
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}
(* marcarmor13 *)
--"usando un supuesto ¬p ∧ ¬q"
lemma ejercicio_2:
assumes 1: "¬(¬p ∧ ¬q)" and
2:"¬p ∧ ¬q"
shows "p ∨ q"
proof-
have 3: "p"using 1 2 by (rule notE)
show "p ∨ q" using 3 by (rule disjI1)
qed

(* ivamenjim serrodcal marpoldia1 *)
lemma ejercicio_2_2:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
{assume 2:"(¬p ∧ ¬q)"
have "p" using 1 2 by (rule notE)
then have "p ∨ q" by (rule disjI1)}
thus "p ∨ q" by auto
qed

(* pablucoto jeamacpov *)

lemma aux_ejercicio2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
{assume "p"
hence "p ∨ q" by (rule disjI1)
with `¬(p ∨ q)` have "False" by (rule notE)}
then show "¬p" ..
next
{assume "q"
hence "p ∨ q" by (rule disjI2)
with `¬(p ∨ q)` have "False" by (rule notE)}
then show "¬q" ..
qed

lemma ejercicio_2_3:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
{assume 2:"¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule aux_ejercicio2)
with `¬(¬p ∧ ¬q)` have "False" ..}
then show "p ∨ q" by (rule ccontr)
qed

(* danrodcha bowma *)
lemma ej_2:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{ assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{ assume "¬q"
with `¬p` have "¬p ∧ ¬q" by (rule conjI)
with assms show "p ∨ q" by (rule notE)}
next
{ assume "q"
then show "p ∨ q" by (rule disjI2)}
qed}
next
{ assume "p"
thus "p ∨ q" by (rule disjI1)}
qed
qed

(* anaprarod crigomgom juancabsou ferrenseg fraortmoy fracorjim1 *)
(* Igual que el anterior pero con etiquetas *)
lemma ejercicio_2_4:
assumes 0: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof-
have "¬p ∨ p" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{assume 1: "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{assume 2: "¬q"
have 3: "(¬p ∧ ¬q)" using 1 2 by (rule conjI)
have "p ∨ q" using 0 3 by (rule notE)
thus "p ∨ q" by this}
next
{assume 4: "q"
have "p ∨ q" using 4 by (rule disjI2)
thus "p ∨ q" by this}
qed}
next
{assume 5: "p"
have "p ∨ q" using 5 by (rule disjI1)
thus "p ∨ q" by this}
qed
qed

(* migtermor *)

lemma lem:
shows "p∨¬p"
proof -
{assume 1: "¬(p∨¬p)"
{assume 2: "p"
then have 3: "p∨¬p" by (rule disjI1)
also have 4: "False" using 1 3 by (rule notE)}
then have 5: "¬p" by (rule notI)
then have 6: "p∨¬p" by (rule disjI2)
also have 7: "False" using 1 6 by (rule notE)}
thus "p∨¬p" by (rule ccontr)
qed

lemma ejercicio_2_5:
assumes 1: "¬(¬p∧¬q)"
shows "p∨q"
proof -
have 2: "p∨¬p" by (rule lem)
moreover
{assume 3: p
then have 4: "p∨q" by (rule disjI1)}
moreover
{assume 6: "¬p"
{assume 7: "¬q"
also have 8: "¬p∧¬q" using 6 7 by (rule conjI)
have 9: "False" using 1 8 by (rule notE)}
then have 10: "q" by (rule ccontr)
then have 11: "p∨q" by (rule disjI2)}
ultimately show "p∨q" by (rule disjE)
qed

(* paupeddeg pabrodmac *)

lemma aux1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume "p"
have "¬q"
proof
{assume "q"
have "(p ∧ q)" using `p` `q` by (rule conjI)
show "False" using `¬(p ∧ q)` `p ∧ q` by (rule notE)}
qed
thus "¬p ∨ ¬q" by (rule disjI2)}
qed
qed

lemma ejercicio_2_5:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬¬p ∨ ¬¬q" using assms by (rule aux1)
moreover
{assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1) }
moreover
{assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2) }
ultimately show "p ∨ q" by (rule disjE)
qed

(*pabrodmac*)

lemma ejercicio_2_6:
assumes "¬(¬p ∧ ¬q)"

shows "p ∨ q"
proof -
have "¬¬p ∨ ¬¬q" using assms by (rule Meson.not_conjD)
moreover
{ assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1) }
moreover
{ assume "¬¬q"
then have "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2) }
ultimately show "p ∨ q" by (rule disjE)
qed

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}
(* marcarmor13 serrodcal marpoldia1 *)
--"usando un supuesto ¬p ∨ ¬q"
lemma ejercicio_3:
assumes 1: "¬(¬p ∨ ¬q)" and
2:"¬p ∨ ¬q"
shows "p ∧ q"
proof-
have 3: "p"using 1 2 by (rule notE)
have 4: "q"using 1 2 by (rule notE)
show "p ∧ q" using 3 4 by (rule conjI)
qed

(* pablucoto jeamacpov *)

lemma ejercicio_3_2:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms(1) by (rule aux_ejercicio2)
hence "¬¬p" by (rule conjunct1)
show "p" using `¬¬p` by (rule notnotD)
next
have "¬¬p ∧ ¬¬q" using assms(1) by (rule aux_ejercicio2)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
show "q" using `¬¬q` by (rule notnotD)
qed

(* ivamenjim *)
lemma aux: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
by auto

lemma ejercicio_3_3:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have 2: "¬¬p ∧ ¬¬q" using 1 by (rule aux)
have 3: "¬¬p" using 2 ..
have 4: "¬¬q" using 2 ..
show "p" using 3 by (rule notnotD)
show "q" using 4 by (rule notnotD)
qed

(* danrodcha migtermor bowma *)
lemma ej_3:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
{ assume "¬p"
hence "¬p ∨ ¬q" by (rule disjI1)
with assms have False by (rule notE)}
then show "p" by (rule ccontr)
{ assume "¬q"
hence "¬p ∨ ¬q" by (rule disjI2)
with assms have False by (rule notE)}
then show "q" by (rule ccontr)
qed

(* anaprarod crigomgom juancabsou ferrenseg fraortmoy fracorjim1 *)
(* Igual que el anterior pero con etiquetas *)
lemma ejercicio_3_4:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
{assume 1: "¬p"
hence 2: "¬p ∨ ¬q" by (rule disjI1)
have "False" using assms 2 by (rule notE)}
thus 3: "p" by (rule ccontr)
{assume 4: "¬q"
hence 5: "¬p ∨ ¬q" by (rule disjI2)
have "False" using assms 5 by (rule notE)}
thus 6: "q" by (rule ccontr)
qed

(* paupeddeg pabrodmac *)

lemma aux2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∧ ¬q"
proof
{assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "¬p ∧ ¬q"
proof
{assume "¬q"
show "¬p ∧ ¬q" using `¬p` `¬q` by (rule conjI)}
{assume "q"
hence "(p ∨ q)" by (rule disjI2)
have "False" using `¬(p ∨ q)` `p ∨ q` by (rule notE)
thus "¬p ∧ ¬q" by (rule FalseE) }
qed}
{assume "p"
hence "(p ∨ q)" by (rule disjI1)
have "False" using `¬(p ∨ q)` `p ∨ q` by (rule notE)
thus "¬p ∧ ¬q" by (rule FalseE) }
qed
qed

lemma ejercicio_3_5:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule aux2)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
show "p ∧ q" using `p` `q` by (rule conjI)
qed

(* pabrodmac *)

lemma ejercicio_3_6:
assumes "¬(¬p ∨ ¬q)"

shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬p" by (rule conjunct1)
show "p" using `¬¬p` by (rule notnotD)
next
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬q" by (rule conjunct2)
show "q" using `¬¬q` by (rule notnotD)
qed

(* pabrodmac *)
lemma ejercicio_3_7:
assumes "¬(¬p ∨ ¬q)"

shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
have "¬¬p" using `¬¬p ∧ ¬¬q` by (rule conjunct1)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
show "p" using `¬¬p` by (rule notnotD)
show "q" using `¬¬q` by (rule notnotD)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}
(* marcarmor13 serrodcal *)
--"usando un supuesto p ∧ q"
lemma ejercicio_4_1:
assumes 1: " ¬(p ∧ q)" and
2:"p ∧ q"
shows "¬p ∨ ¬q"
proof-
have 3: "¬p"using 1 2 by (rule notE)
show "¬p ∨ ¬q" using 3 by (rule disjI1)
qed

(* ivamenjim marpoldia1 ferrenseg fraortmoy*)
lemma ejercicio_4_2:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
{assume 2:"(p ∧ q)"
have "¬p" using 1 2 by (rule notE)
then have "¬p ∨ ¬q" by (rule disjI1)}
thus "¬p ∨ ¬q" by auto
qed

( * pablucoto jeamacpov crigomgom juancabsou *)
lemma ejercicio_4_3:
assumes " ¬(p ∧ q)"
shows " ¬p ∨ ¬q"
proof -
{ assume 2: "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_3_2)
with assms(1) have "False" .. }
then show " ¬p ∨ ¬q" by (rule ccontr)
qed

(*danrodcha anaprarod*)
lemma ej_4:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬ (¬ p ∨ ¬ q)"
hence "p ∧ q" by (rule ej_3)
with assms show False by (rule notE)
qed

(* anaprarod *)
(* sin usar el ejercicio anterior *)
lemma ejercicio_4_4:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof (rule disjE)
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume 1:"p"
have "¬q ∨ q" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof (rule disjE)
{assume "¬q"
thus "¬p ∨ ¬q" by (rule disjI2)}
next
{assume 2:"q"
have 3:"p ∧ q" using 1 2 by (rule conjI)
have "¬p ∨ ¬q" using assms 3 by (rule notE)
thus "¬p ∨ ¬q" by this}
qed}
qed
qed

(* migtermor *)
lemma ejercicio_4_5:
assumes 1: "¬(p∧q)"
shows "¬p∨¬q"
proof -
have 2: "p∨¬p" by (rule lem)
moreover
{assume 3: "p"
{assume 4: "q"
also have 5: "p∧q" using 3 4 by (rule conjI)
have 6: "False" using assms 5 by (rule notE)}
then have 7: "¬q" by (rule notI)
then have 8: "¬p∨¬q" by (rule disjI2)}
moreover
{assume 9: "¬p"
then have "¬p∨¬q" by (rule disjI1)}
ultimately show "¬p∨¬q" by (rule disjE)
qed

(* paupeddeg pabrodmac*)
lemma ejercicio_4_6:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume "p"
have "¬q"
proof
{assume "q"
have "(p ∧ q)" using `p` `q` by (rule conjI)
show "False" using `¬(p ∧ q)` `p ∧ q` by (rule notE)}
qed
thus "¬p ∨ ¬q" by (rule disjI2)}
qed
qed

(* pabrodmac*)
lemma ejercicio_4_7:
assumes "¬(p ∧ q)"

shows "¬p ∨ ¬q"
proof -
show "¬p ∨ ¬q" using assms by (rule Meson.not_conjD)
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}
(* marcarmor13 jeamacpov serrodcal juancabsou *)
--"usando un supuesto q"
lemma ejercicio_5_1:
assumes 1: "q"

shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have 2: "p ⟶ q" using 1 by (rule impI)
show "(p ⟶ q) ∨ (q ⟶ p)" using 2 by (rule disjI1)
qed

(* ivamenjim marpoldia1 ferrenseg fraortmoy*)
lemma ejercicio_5_2:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
{assume 1:"q"
have "(p ⟶ q)" using 1 by (rule impI)
then have "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
thus "(p ⟶ q) ∨ (q ⟶ p)" by auto
qed

(* danrodcha pablucoto *)
lemma ej_5:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{ assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬q"
hence "¬p ⟶ ¬q" by (rule impI)
{ assume "q"
hence "¬¬q" by (rule notnotI)
with `¬p ⟶ ¬q` have "¬¬p" by (rule mt)
hence "p" by (rule notnotD)}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
next
{assume "q"
hence "(p ⟶ q)" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
qed}
next
{assume "p"
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(* anaprarod *)
(* Muy parecida a la anterior pero con algunas etiquetas
y con algunas implicaciones más detalladas *)
lemma ejercicio_5_3:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬q"
hence 1: "¬p ⟶ ¬q" by (rule impI)
{assume "q"
hence 2: "¬¬q" by (rule notnotI)
have "¬¬p" using 1 2 by (rule mt)
hence "p" by (rule notnotD)}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
next
{assume 3: "q"
{assume "p"
have "q" using 3 by this}
hence "p ⟶ q" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
qed}
next
{assume 4: "p"
{assume "q"
have "p" using 4 by this}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(* migtermor *)

lemma ejercicio_5_4:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have 1: "q∨¬q" by (rule lem)
moreover
{assume 2: "q"
have 3: "p ⟶ q" using 2 by (rule impI)
then have 4: "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
moreover
{assume 5: "¬q"
have 6: "¬p⟶¬q" using 5 by (rule impI)
then have 7: "q⟶p" by (rule ejercicio_1_2)
then have "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
ultimately show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjE)
qed

(* paupeddeg pabrodmac crigomgom*)
lemma aux3:
assumes "¬q ∨ p"
shows "q ⟶ p"
proof -
note `¬q ∨ p`
moreover
{assume "¬q"
have "q ⟶ p"
proof
assume "q"
show "p" using `¬q``q`by (rule notE)
qed}
moreover
{assume "p"
have "q ⟶ p"
proof
assume "q"
show "p" using `p` by this
qed}
ultimately show "q ⟶ p" by (rule disjE)
qed

lemma ejercicio_5_5:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
{assume "¬p"
hence "¬p ∨ q" by (rule disjI1)
hence "p ⟶ q" by (rule aux3)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
{assume "p"
hence "¬q ∨ p" by (rule disjI2)
hence "q ⟶ p" by (rule aux3)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(*pabrodmac*)

lemma ejercicio_5_6:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬(p ⟶ q) ∨ (p ⟶ q)" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
{ assume "¬(p ⟶ q)"
hence "p ∧ ¬ q" by (rule Meson.not_impD)
have "(q ⟶ p)"
proof
assume "q"
show "p" using `p ∧ ¬ q` by (rule conjunct1)
qed
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2) }
next
{ assume "p ⟶ q"
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1) }
qed
qed

end
</source>

Relación 8

2017-01-18T17:48:09Z

Fracorjim1:

<source lang="isar">
chapter {* R8: Deducción natural proposicional en Isabelle/HOL *}

theory R8_Deduccion_natural_proposicional
imports Main
begin

text {*
Demostrar o refutar los siguientes lemas usando sólo las reglas
básicas de deducción natural de la lógica proposicional, de los
cuantificadores y de la igualdad:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· ccontr: (¬P ⟹ False) ⟹ P

· allI: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allE: (⋀x. P x) ⟹ ∀x. P x
· exI: P x ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
· trans: ⟦r = s; s = t⟧ ⟹ r = t
· sym: s = t ⟹ t = s
· not_sym: t ≠ s ⟹ s ≠ t
· ssubst: ⟦t = s; P s⟧ ⟹ P t
· box_equals: ⟦a = b; a = c; b = d⟧ ⟹ a: = d
· arg_cong: x = y ⟹ f x = f y
· fun_cong: f = g ⟹ f x = g x
· cong: ⟦f = g; x = y⟧ ⟹ f x = g y
*}

text {*
Se usarán las reglas notnotI, mt y not_ex que demostramos a continuación.
*}

lemma notnotI: "P ⟹ ¬¬ P"
by auto

lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
by auto

lemma no_ex: "¬(∃x. P(x)) ⟹ ∀x. ¬P(x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}
(* marcarmor13 *)
--"usando un supuesto ¬¬p"
lemma ejercicio_1:
assumes 1: "¬q ⟶ ¬p" and
2: "¬¬p"
shows "p ⟶ q"
proof -
have 3: "¬¬q" using 1 2 by (rule mt)
have 4: "q" using 3 by (rule notnotD)
show "p ⟶ q" using 4 by (rule impI)
qed

(* pablucoto jeamacpov migtermor *)
lemma ejercicio_1_2:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume "p"
hence "¬¬p" by (rule notnotI)
with `¬q ⟶ ¬p` have "¬¬q" by (rule mt)
hence "q" by (rule notnotD)}
then show "p ⟶ q" by (rule impI)
qed

(* ivamenjim serrodcal anaprarod marpoldia1 manmorjim1 crigomgom juancabsou ferrenseg fraortmoy*)
lemma ejercicio_1_3:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume 2:"p"
then have 3: "¬¬p" by (rule notnotI)
have 4: "¬¬q" using 1 3 by (rule mt)
then have 5: "q" by (rule notnotD)}
thus "p ⟶ q" by (rule impI)
qed

(* bowma *)
lemma ejercicio_1_4:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
then have "q" by (rule notnotD)}
thus "p ⟶ q" by (rule impI)
qed

(* bowma danrodcha paupeddeg pabrodmac fracorjim1 *)
"quita la limitación de -"
lemma ejercicio_1_5:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}
(* marcarmor13 *)
--"usando un supuesto ¬p ∧ ¬q"
lemma ejercicio_2:
assumes 1: "¬(¬p ∧ ¬q)" and
2:"¬p ∧ ¬q"
shows "p ∨ q"
proof-
have 3: "p"using 1 2 by (rule notE)
show "p ∨ q" using 3 by (rule disjI1)
qed

(* ivamenjim serrodcal marpoldia1 *)
lemma ejercicio_2_2:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
{assume 2:"(¬p ∧ ¬q)"
have "p" using 1 2 by (rule notE)
then have "p ∨ q" by (rule disjI1)}
thus "p ∨ q" by auto
qed

(* pablucoto jeamacpov *)

lemma aux_ejercicio2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
{assume "p"
hence "p ∨ q" by (rule disjI1)
with `¬(p ∨ q)` have "False" by (rule notE)}
then show "¬p" ..
next
{assume "q"
hence "p ∨ q" by (rule disjI2)
with `¬(p ∨ q)` have "False" by (rule notE)}
then show "¬q" ..
qed

lemma ejercicio_2_3:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
{assume 2:"¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule aux_ejercicio2)
with `¬(¬p ∧ ¬q)` have "False" ..}
then show "p ∨ q" by (rule ccontr)
qed

(* danrodcha bowma *)
lemma ej_2:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{ assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{ assume "¬q"
with `¬p` have "¬p ∧ ¬q" by (rule conjI)
with assms show "p ∨ q" by (rule notE)}
next
{ assume "q"
then show "p ∨ q" by (rule disjI2)}
qed}
next
{ assume "p"
thus "p ∨ q" by (rule disjI1)}
qed
qed

(* anaprarod crigomgom juancabsou ferrenseg fraortmoy*)
(* Igual que el anterior pero con etiquetas *)
lemma ejercicio_2_4:
assumes 0: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof-
have "¬p ∨ p" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{assume 1: "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "p ∨ q"
proof (rule disjE)
{assume 2: "¬q"
have 3: "(¬p ∧ ¬q)" using 1 2 by (rule conjI)
have "p ∨ q" using 0 3 by (rule notE)
thus "p ∨ q" by this}
next
{assume 4: "q"
have "p ∨ q" using 4 by (rule disjI2)
thus "p ∨ q" by this}
qed}
next
{assume 5: "p"
have "p ∨ q" using 5 by (rule disjI1)
thus "p ∨ q" by this}
qed
qed

(* migtermor *)

lemma lem:
shows "p∨¬p"
proof -
{assume 1: "¬(p∨¬p)"
{assume 2: "p"
then have 3: "p∨¬p" by (rule disjI1)
also have 4: "False" using 1 3 by (rule notE)}
then have 5: "¬p" by (rule notI)
then have 6: "p∨¬p" by (rule disjI2)
also have 7: "False" using 1 6 by (rule notE)}
thus "p∨¬p" by (rule ccontr)
qed

lemma ejercicio_2_5:
assumes 1: "¬(¬p∧¬q)"
shows "p∨q"
proof -
have 2: "p∨¬p" by (rule lem)
moreover
{assume 3: p
then have 4: "p∨q" by (rule disjI1)}
moreover
{assume 6: "¬p"
{assume 7: "¬q"
also have 8: "¬p∧¬q" using 6 7 by (rule conjI)
have 9: "False" using 1 8 by (rule notE)}
then have 10: "q" by (rule ccontr)
then have 11: "p∨q" by (rule disjI2)}
ultimately show "p∨q" by (rule disjE)
qed

(* paupeddeg pabrodmac *)

lemma aux1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume "p"
have "¬q"
proof
{assume "q"
have "(p ∧ q)" using `p` `q` by (rule conjI)
show "False" using `¬(p ∧ q)` `p ∧ q` by (rule notE)}
qed
thus "¬p ∨ ¬q" by (rule disjI2)}
qed
qed

lemma ejercicio_2_5:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬¬p ∨ ¬¬q" using assms by (rule aux1)
moreover
{assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1) }
moreover
{assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2) }
ultimately show "p ∨ q" by (rule disjE)
qed

(*pabrodmac*)

lemma ejercicio_2_6:
assumes "¬(¬p ∧ ¬q)"

shows "p ∨ q"
proof -
have "¬¬p ∨ ¬¬q" using assms by (rule Meson.not_conjD)
moreover
{ assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1) }
moreover
{ assume "¬¬q"
then have "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2) }
ultimately show "p ∨ q" by (rule disjE)
qed

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}
(* marcarmor13 serrodcal marpoldia1 *)
--"usando un supuesto ¬p ∨ ¬q"
lemma ejercicio_3:
assumes 1: "¬(¬p ∨ ¬q)" and
2:"¬p ∨ ¬q"
shows "p ∧ q"
proof-
have 3: "p"using 1 2 by (rule notE)
have 4: "q"using 1 2 by (rule notE)
show "p ∧ q" using 3 4 by (rule conjI)
qed

(* pablucoto jeamacpov *)

lemma ejercicio_3_2:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms(1) by (rule aux_ejercicio2)
hence "¬¬p" by (rule conjunct1)
show "p" using `¬¬p` by (rule notnotD)
next
have "¬¬p ∧ ¬¬q" using assms(1) by (rule aux_ejercicio2)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
show "q" using `¬¬q` by (rule notnotD)
qed

(* ivamenjim *)
lemma aux: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
by auto

lemma ejercicio_3_3:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have 2: "¬¬p ∧ ¬¬q" using 1 by (rule aux)
have 3: "¬¬p" using 2 ..
have 4: "¬¬q" using 2 ..
show "p" using 3 by (rule notnotD)
show "q" using 4 by (rule notnotD)
qed

(* danrodcha migtermor bowma *)
lemma ej_3:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
{ assume "¬p"
hence "¬p ∨ ¬q" by (rule disjI1)
with assms have False by (rule notE)}
then show "p" by (rule ccontr)
{ assume "¬q"
hence "¬p ∨ ¬q" by (rule disjI2)
with assms have False by (rule notE)}
then show "q" by (rule ccontr)
qed

(* anaprarod crigomgom juancabsou ferrenseg fraortmoy*)
(* Igual que el anterior pero con etiquetas *)
lemma ejercicio_3_4:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
{assume 1: "¬p"
hence 2: "¬p ∨ ¬q" by (rule disjI1)
have "False" using assms 2 by (rule notE)}
thus 3: "p" by (rule ccontr)
{assume 4: "¬q"
hence 5: "¬p ∨ ¬q" by (rule disjI2)
have "False" using assms 5 by (rule notE)}
thus 6: "q" by (rule ccontr)
qed

(* paupeddeg pabrodmac *)

lemma aux2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∧ ¬q"
proof
{assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "¬p ∧ ¬q"
proof
{assume "¬q"
show "¬p ∧ ¬q" using `¬p` `¬q` by (rule conjI)}
{assume "q"
hence "(p ∨ q)" by (rule disjI2)
have "False" using `¬(p ∨ q)` `p ∨ q` by (rule notE)
thus "¬p ∧ ¬q" by (rule FalseE) }
qed}
{assume "p"
hence "(p ∨ q)" by (rule disjI1)
have "False" using `¬(p ∨ q)` `p ∨ q` by (rule notE)
thus "¬p ∧ ¬q" by (rule FalseE) }
qed
qed

lemma ejercicio_3_5:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule aux2)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
show "p ∧ q" using `p` `q` by (rule conjI)
qed

(* pabrodmac *)

lemma ejercicio_3_6:
assumes "¬(¬p ∨ ¬q)"

shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬p" by (rule conjunct1)
show "p" using `¬¬p` by (rule notnotD)
next
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬q" by (rule conjunct2)
show "q" using `¬¬q` by (rule notnotD)
qed

(* pabrodmac *)
lemma ejercicio_3_7:
assumes "¬(¬p ∨ ¬q)"

shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
have "¬¬p" using `¬¬p ∧ ¬¬q` by (rule conjunct1)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
show "p" using `¬¬p` by (rule notnotD)
show "q" using `¬¬q` by (rule notnotD)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}
(* marcarmor13 serrodcal *)
--"usando un supuesto p ∧ q"
lemma ejercicio_4_1:
assumes 1: " ¬(p ∧ q)" and
2:"p ∧ q"
shows "¬p ∨ ¬q"
proof-
have 3: "¬p"using 1 2 by (rule notE)
show "¬p ∨ ¬q" using 3 by (rule disjI1)
qed

(* ivamenjim marpoldia1 ferrenseg fraortmoy*)
lemma ejercicio_4_2:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
{assume 2:"(p ∧ q)"
have "¬p" using 1 2 by (rule notE)
then have "¬p ∨ ¬q" by (rule disjI1)}
thus "¬p ∨ ¬q" by auto
qed

( * pablucoto jeamacpov crigomgom juancabsou *)
lemma ejercicio_4_3:
assumes " ¬(p ∧ q)"
shows " ¬p ∨ ¬q"
proof -
{ assume 2: "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_3_2)
with assms(1) have "False" .. }
then show " ¬p ∨ ¬q" by (rule ccontr)
qed

(*danrodcha anaprarod*)
lemma ej_4:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬ (¬ p ∨ ¬ q)"
hence "p ∧ q" by (rule ej_3)
with assms show False by (rule notE)
qed

(* anaprarod *)
(* sin usar el ejercicio anterior *)
lemma ejercicio_4_4:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof (rule disjE)
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume 1:"p"
have "¬q ∨ q" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof (rule disjE)
{assume "¬q"
thus "¬p ∨ ¬q" by (rule disjI2)}
next
{assume 2:"q"
have 3:"p ∧ q" using 1 2 by (rule conjI)
have "¬p ∨ ¬q" using assms 3 by (rule notE)
thus "¬p ∨ ¬q" by this}
qed}
qed
qed

(* migtermor *)
lemma ejercicio_4_5:
assumes 1: "¬(p∧q)"
shows "¬p∨¬q"
proof -
have 2: "p∨¬p" by (rule lem)
moreover
{assume 3: "p"
{assume 4: "q"
also have 5: "p∧q" using 3 4 by (rule conjI)
have 6: "False" using assms 5 by (rule notE)}
then have 7: "¬q" by (rule notI)
then have 8: "¬p∨¬q" by (rule disjI2)}
moreover
{assume 9: "¬p"
then have "¬p∨¬q" by (rule disjI1)}
ultimately show "¬p∨¬q" by (rule disjE)
qed

(* paupeddeg pabrodmac*)
lemma ejercicio_4_6:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ ¬q"
proof
{assume "¬p"
thus "¬p ∨ ¬q" by (rule disjI1)}
next
{assume "p"
have "¬q"
proof
{assume "q"
have "(p ∧ q)" using `p` `q` by (rule conjI)
show "False" using `¬(p ∧ q)` `p ∧ q` by (rule notE)}
qed
thus "¬p ∨ ¬q" by (rule disjI2)}
qed
qed

(* pabrodmac*)
lemma ejercicio_4_7:
assumes "¬(p ∧ q)"

shows "¬p ∨ ¬q"
proof -
show "¬p ∨ ¬q" using assms by (rule Meson.not_conjD)
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}
(* marcarmor13 jeamacpov serrodcal juancabsou *)
--"usando un supuesto q"
lemma ejercicio_5_1:
assumes 1: "q"

shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have 2: "p ⟶ q" using 1 by (rule impI)
show "(p ⟶ q) ∨ (q ⟶ p)" using 2 by (rule disjI1)
qed

(* ivamenjim marpoldia1 ferrenseg fraortmoy*)
lemma ejercicio_5_2:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
{assume 1:"q"
have "(p ⟶ q)" using 1 by (rule impI)
then have "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
thus "(p ⟶ q) ∨ (q ⟶ p)" by auto
qed

(* danrodcha pablucoto *)
lemma ej_5:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{ assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬q"
hence "¬p ⟶ ¬q" by (rule impI)
{ assume "q"
hence "¬¬q" by (rule notnotI)
with `¬p ⟶ ¬q` have "¬¬p" by (rule mt)
hence "p" by (rule notnotD)}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
next
{assume "q"
hence "(p ⟶ q)" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
qed}
next
{assume "p"
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(* anaprarod *)
(* Muy parecida a la anterior pero con algunas etiquetas
y con algunas implicaciones más detalladas *)
lemma ejercicio_5_3:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬p"
have "¬q ∨ q" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
{assume "¬q"
hence 1: "¬p ⟶ ¬q" by (rule impI)
{assume "q"
hence 2: "¬¬q" by (rule notnotI)
have "¬¬p" using 1 2 by (rule mt)
hence "p" by (rule notnotD)}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
next
{assume 3: "q"
{assume "p"
have "q" using 3 by this}
hence "p ⟶ q" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
qed}
next
{assume 4: "p"
{assume "q"
have "p" using 4 by this}
hence "q ⟶ p" by (rule impI)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(* migtermor *)

lemma ejercicio_5_4:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have 1: "q∨¬q" by (rule lem)
moreover
{assume 2: "q"
have 3: "p ⟶ q" using 2 by (rule impI)
then have 4: "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
moreover
{assume 5: "¬q"
have 6: "¬p⟶¬q" using 5 by (rule impI)
then have 7: "q⟶p" by (rule ejercicio_1_2)
then have "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
ultimately show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjE)
qed

(* paupeddeg pabrodmac*)
lemma aux3:
assumes "¬q ∨ p"
shows "q ⟶ p"
proof -
note `¬q ∨ p`
moreover
{assume "¬q"
have "q ⟶ p"
proof
assume "q"
show "p" using `¬q``q`by (rule notE)
qed}
moreover
{assume "p"
have "q ⟶ p"
proof
assume "q"
show "p" using `p` by this
qed}
ultimately show "q ⟶ p" by (rule disjE)
qed

lemma ejercicio_5_5:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
{assume "¬p"
hence "¬p ∨ q" by (rule disjI1)
hence "p ⟶ q" by (rule aux3)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)}
{assume "p"
hence "¬q ∨ p" by (rule disjI2)
hence "q ⟶ p" by (rule aux3)
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)}
qed
qed

(*pabrodmac*)

lemma ejercicio_5_6:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬(p ⟶ q) ∨ (p ⟶ q)" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
{ assume "¬(p ⟶ q)"
hence "p ∧ ¬ q" by (rule Meson.not_impD)
have "(q ⟶ p)"
proof
assume "q"
show "p" using `p ∧ ¬ q` by (rule conjunct1)
qed
thus "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2) }
next
{ assume "p ⟶ q"
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1) }
qed
qed

end
</source>

Relación 4

2017-01-05T12:37:04Z

Fracorjim1:

<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 jeamacpov antsancab1 *)
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 jeamacpov antsancab1*)
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 jeamacpov antsancab1 *)
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 jeamacpov *)
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

(* antsancab1 *)
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
finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a#xs) ∧ todos Q (a#xs))" by auto
qe

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 jeamacpov antsancab1 *)
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 antsancab1 *)
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 jeamacpov *)
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 fracorjim1 *)
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 antsancab1 fracorjim1 *)
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 jeamacpov *)
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 jeamacpov *)
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 fracorjim1 *)
(* 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

(* antsancab1 *)
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)
also have "... = (todos P (a#xs))" by simp
finally show "todos P (rev (a # xs)) = todos P (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 jeamacpov antsancab1 fracorjim1 *)
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 jeamacpov antsancab1 *)
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 fracorjim1 *)
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 jeamacpov *)
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 fracorjim1 *)
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

(* antsancab1 *)
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 "... = (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 "... = algunos (P ∘ f) (a#xs)" by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a#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 jeamacpov antsancab1 *)
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 fracorjim1 *)
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 jeamacpov *)
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

(* antsancab1 *)
lemma algunos_append6: "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
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

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* ivamenjim migtermor marpoldia1 rubgonmar paupeddeg dancorgar
anaprarod serrodcal antsancab1 fracorjim1 *)
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 jeamacpov *)
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 jeamacpov *)
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

(* antsancab1 *)
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 auto
also have "... = algunos P (a#xs)" by simp
finally show "algunos P (rev (a # xs)) = algunos P (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 jeamacpov *)
-- "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

(* antsancab1 *)
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)"
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 "... = (algunos P (a # xs) ∨ algunos Q (a # xs))" by auto
finally show "algunos (λx. P x ∨ Q x) (a # xs) = (algunos P (a # xs) ∨ algunos Q (a # 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 jeamacpov antsancab1 *)
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 jeamacpov*)
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

(* antsancab1 *)
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
also have "... = (P a ∨ (¬ todos (λx. ¬ P x) (a#xs)))" by auto
finally show "algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # 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 jeamacpov fracorjim1 *)
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"

(* antsancab1 *)
fun estaEn1 :: "'a ⇒ 'a list ⇒ bool" where
"estaEn1 x [] = False"
| "estaEn1 x (a#xs) = (if x = a then True else estaEn1 x xs )" (* Se detiene al encontrar la primera coincidencia *)

value "estaEn1 (2::nat) [3,2,4] = True"
value "estaEn1 (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 jeamacpov*)
-- "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 *)

(* antsancab1 *)
(* Demostrar que
algunos (λa. a=x) xs = estaEn x xs
es lo mismo que demostrar
lemma "estaEn a xs = algunos (λx. a=x) xs" *)

lemma "algunos (λa. a=x) xs = estaEn x xs"
by (induct xs) auto

lemma "algunos (λa. a=x) xs = estaEn x xs"
proof (induct xs)
show "algunos (λa. a = x) [] = estaEn x []" by simp
next
fix a xs
assume HI: "algunos (λa. a = x) xs = estaEn x xs"
have "algunos (λa. a = x) (a # xs) = ((λa. a = x) a ∨ algunos (λa. a = x) xs)" by simp
also have "... = ((λa. a = x) a ∨ estaEn x xs)" using HI by simp
also have "... = (estaEn x (a#xs))" by simp (* no tengo claro cómo simplifica el "(λa. a = x) a" *)
finally show "algunos (λa. a = x) (a # xs) = estaEn x (a # xs)" by simp
qed

end

(* fracorjim1 *)
lemma estaEnYAlgunos :
"estaEn a xs = algunos (λx. x = a) xs" (is "?P a xs")
proof (induct xs)
show "?P a []" by simp
next
fix a x xs
assume HI : "?P a xs"
have "estaEn a (x#xs) = ((a = x) ∨ estaEn a xs)"
by (simp only:estaEn.simps(2))
also have "… = (a = x ∨ algunos (λx. x = a) xs)" using HI by simp
also have "… = ((λx. x = a) x ∨ algunos (λx. x = a) xs)" by auto
also have "… = algunos (λx. x = a) (x # xs)" by simp
finally show "?P a (x#xs)" by simp
qed

</source>

Relación 2

2017-01-05T12:12:18Z

Fracorjim1:

<source lang="isar">
chapter {* R2: Razonamiento sobre programas en Isabelle/HOL *}

theory R2_Razonamiento_automatico_sobre_programas
imports Main
begin

declare [[names_short]]

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

(* fracorjim1 *)
fun sumaImpares0 :: "nat ⇒ nat" where
"sumaImpares0 0 = 0"
| "sumaImpares0 n = (n mod 2)*n + sumaImpares(n-1)"

value "sumaImpares0 5 = 25"

(* Comentario: Debe de definirse usando como patrones los dos
constructores de nat: 0 y Suc *)

(* ivamenjim wilmorort*)
fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares n = 2*(n-1) + 1 + sumaImpares (n-1)"

value "sumaImpares 5 = 25"

(* wilmorort *)

(*Notar: Por la propiedad de Gauss se puede deducir que:
la suma de los n números impares es igual a la suma de los
n y n-1 números consecutivos*)
fun suma :: "nat ⇒ nat" where
"suma 0 = 0"
| "suma n = n + suma(n-1)"

fun sumaImpares1 :: "nat ⇒ nat" where
"sumaImpares1 0 = 0"
| "sumaImpares1 n = suma(n) + suma(n-1)"

value "sumaImpares1 5 = 25"

(* Comentario: La definición sumaImpares1 no es recursiva y, por tanto,
no es apropiada para demostraciones por inducción.

Comentario: La definición sumaImpares1 no es recursiva pero la
demostración, está realizada por inducción, por lo tanto no se puede
concluir que: "Si una def. no es recuriva no se puede demostrar por
inducción"

Comentario: Las definiciones no recursivas no generan esquemas de
inducción.
*)

(* fraortmoy antsancab1 *)
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0"
| "sumaImpares2 (Suc(n)) = ((Suc(n)*2)-1) + sumaImpares2 n"

value "sumaImpares2 5 = 25"

(* anaprarod danrodcha crigomgom migtermor pabrodmac*)
fun sumaImpares3 :: "nat ⇒ nat" where
"sumaImpares3 0 = 0"
|"sumaImpares3 (Suc n) = (2*n +1) + (sumaImpares3 n)"

value "sumaImpares3 5 = 25"

(* manmorjim1 *)
fun sumaImpares4 :: "nat ⇒ nat" where
"sumaImpares4 0 = 0"
| "sumaImpares4 (Suc n) = (Suc (2 * n)) + (sumaImpares4 n)"

value "sumaImpares4 5 = 25"

(* pablucoto serrodcal marcarmor13 rubgonmar marpoldia1 jeamacpov*)
fun sumaImpares5 :: "nat ⇒ nat" where
"sumaImpares5 0 = 0"
| "sumaImpares5 n = (2*n-1) + sumaImpares5 (n-1) "

value "sumaImpares5 5 = 25"

(* ferrenseg paupeddeg josgarsan dancorgar *)

fun sumaImpares6 :: "nat ⇒ nat" where
"sumaImpares6 0 = 0"
| "sumaImpares6 (Suc n) = (2 * (Suc n) - 1) + sumaImpares6 n"

value "sumaImpares6 5 = 25"

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

(* ivamenjim wilmorort anaprarod crigomgom manmorjim1 pablucoto
serrodcal marcarmor13 rubgonmar pabrodmac marpoldia1 josgarsan
jeamacpov dancorgar antsancab1 fracorjim1 *)
lemma "sumaImpares n = n*n"
apply (induct n)
apply auto
done

(* wilmorort *)
(* Demostración estructurada *)

lemma aux1 : "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)"
apply (induct n)
apply auto
done

lemma aux2: "(n+1) + suma(n) + n + suma(n-1) = (n+1) + n + sumaImpares1 n "
apply (induct n)
apply auto
done

lemma "sumaImpares1 n = n*n"
proof (induct n)
show "sumaImpares1 0 = 0*0" by simp
next
fix n
assume HI:"sumaImpares1 n = n*n"
have "sumaImpares1 (Suc n) = suma(Suc n) + suma(n)" by simp
have "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)" using
"aux1" by simp
also have "... = (n+1) + n + sumaImpares1 n " using "aux2" by simp
also have "... = 2*n +1 + n*n" using HI by simp
also have "... = (n+1)*(n+1)" by simp
finally show "sumaImpares1 (Suc n) = Suc n * Suc n" by simp
qed

(* fraortmoy *)
(* La demostración para la función sumaImpares2 es la misma que la de
sumaImpares*)

lemma "sumaImpares2 n = n*n"
apply (induct n)
apply auto
done

(* danrodcha migtermor paupeddeg *)
lemma "sumaImpares n = n*n"
by (induct n) auto

(* danrodcha *)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

(* ferrenseg *)
lemma "sumaImpares3 n = n*n"
by (induct n) simp_all

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

(* wilmorort ivamenjim pablucoto serrodcal ferrenseg rubgonmar
pabrodmac *)
fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno n = 2^n + sumaPotenciasDeDosMasUno (n-1)"

value "sumaPotenciasDeDosMasUno 3 = 16"

(* fraortmoy anaprarod danrodcha crigomgom migtermor manmorjim1
fracorjim1 paupeddeg josgarsan dancorgar antsancab1 *)
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2"
| "sumaPotenciasDeDosMasUno2 (Suc(n)) =
(2^(Suc n)) + sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3 = 16"

(* marcarmor13 jeamacpov *)
fun sumaPotenciasDeDosMasUno3 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno3 0 = 2"
| "sumaPotenciasDeDosMasUno3 n = 2*sumaPotenciasDeDosMasUno3 (n-1)"

value "sumaPotenciasDeDosMasUno3 3 = 16"

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

(* wilmorort ivamenjim fraortmoy anaprarod crigomgom pablucoto serrodcal
manmorjim1 marcarmor13 rubgonmar pabrodmac josgarsan jeamacpov
dancorgar antsancab1 *)
(* esta demostración funciona con sumaPotenciasDeDosMasUno2 *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induct n)
apply auto
done

(* danrodcha migtermor ferrenseg fracorjim1 paupeddeg *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) auto

(* danrodcha *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)"by simp
qed

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

(* ivamenjim wilmorort pablucoto rubgonmar marcarmor13 jeamacpov *)
fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = [] "
| "copia n x = x # (copia (n-1) x)"

(* wilmorort anaprarod *)
fun copia1 :: "nat ⇒ 'a ⇒ 'a list" where
"copia1 0 x = []"
| "copia1 (Suc n) x = [x] @ (copia1 n x) "

(* Comentario: La dedinición copia1 se puede simplificar eliminando @ *)

(* danrodcha crigomgom migtermor manmorjim1 fracorjim1 pabrodmac
paupeddeg josgarsan dancorgar antsancab1 *)
fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []"
| "copia2 (Suc n) x = x # copia2 n x"

(* serrodcal ferrenseg *)
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []"
| "copia3 n x = [x] @ copia3 (n-1) x"

value "copia 3 x = [x,x,x]"

(* Comentario: La definición copia3 se puede simplificar eliminando @ *)

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

(* wilmorort *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x = True ∧ todos p xs) "

(* Comentario: La definición todos se puede simplificar eliminando True
*)

value "todos (λx. x>(1::nat)) [2,6,4] = True"
value "todos (λx. x>(2::nat)) [2,6,4] = False"

(* fraortmoy anaprarod danrodcha crigomgom migtermor ivamenjim serrodcal
pablucoto ferrenseg rubgonmar pabrodmac paupeddeg marcarmor13
jeamacpov dancorgar josgarsan antsancab1 fracorjim1 *)
fun todos1 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos1 p [] = True"
| "todos1 p (x#xs) = (p x ∧ todos1 p xs )"

value "todos1 (λx. x>(1::nat)) [2,6,4] = True"
value "todos1 (λx. x>(2::nat)) [2,6,4] = False"

(* manmorjim1 *)
fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos2 p xs = ((filter p xs) = xs)"

value "todos2 (λx. x>(1::nat)) [2,6,4] = True"
value "todos2 (λx. x>(2::nat)) [2,6,4] = False"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal
manmorjim1 pablucoto rubgonmar pabrodmac marcarmor13 dancorgar
josgarsan antsancab1 *)
lemma "todos (λy. y=x) (copia n x)"
apply (induct n)
apply auto
done

(* danrodcha ferrenseg paupeddeg jeamacpov *)
lemma "todos (λy. y=x) (copia n x)"
by (induct n) auto

(* danrodcha *)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

(* fracorjim1 *)
lemma "todos (λy. y = x)(copia n x) = True"
apply (induct n)
apply auto
done

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

(* wilmorort fraortmoy anaprarod crigomgom migtermor ivamenjim serrodcal
manmorjim1 pablucoto ferrenseg rubgonmar pabrodmac paupeddeg
marcarmor13 jeamacpov dancorgar josgarsan antsancab1 fracorjim1 *)
fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y] "
| "amplia (x#xs) y = x # amplia xs y"

value "amplia [d,a] t = [d,a,t]"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal
manmorjim1 pablucoto rubgonmar pabrodmac marcarmor13 jeamacpov
dancorgar josgarsan antsancab1 fracorjim1 *)
lemma "amplia xs y = xs @ [y]"
apply (induct xs)
apply auto
done

(* danrodcha migtermor ferrenseg paupeddeg *)
lemma "amplia xs y = xs @ [y]"
by (induct xs) auto

(* danrodcha *)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs assume "?P xs"
thus "?P (a#xs)" by simp
qed

end
</source>

Relación 1

2017-01-05T12:04:44Z

Fracorjim1:

<source lang="isar">
chapter {* R1: Programación funcional en Isabelle *}

theory R1
imports Main
begin

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

(* danrodcha anaprarod ivamenjim serrodcal manmorjim1 fraortmoy
dancorgar ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun factorial :: "nat ⇒ nat" where
"factorial 0 = 1"
| "factorial (Suc n) = (Suc n) * factorial n"

value "factorial 4 = 24"

(* wilmorort pablucoto marcarmor13 crigomgom rubgonmar jeamacpov
marpoldia1*)
fun factorial1 :: "nat ⇒ nat" where
"factorial1 0 = 1 "
| "factorial1 n = n * factorial1 (n-1)"

value "factorial1 4 = 24"

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

(* wilmorort *)
(* Para usar las lista en forma de [a,b,c] *)
translations
"[x, xs]" == "x#[xs]"
"[x]" == "x#[]"

(* wilmorort serrodcal crigomgom rubgonmar anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 *)
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0" |
"longitud (x # xs) = 1 + longitud xs "

value "longitud [4,2,5] = 3"

(* pablucoto *)
fun longitud2 :: "'a list ⇒ nat " where
"longitud2 [] = 0"
| "longitud2 xs = 1 + longitud2 (butlast xs) "

value "longitud2 [4,2,5] = 3"

(* pablucoto *)
fun longitud3 :: "'a list ⇒ nat " where
"longitud3 xs = (if xs = []
then 0
else 1 + longitud3 (butlast xs))"

value "longitud3 [4,2,5] = 3"

(* marcarmor13 manmorjim1 jeamacpov marpoldia1 fraortmoy *)
fun longitud4 :: "'a list ⇒ nat" where
"longitud4 [] = 0 "
| "longitud4 xs = (1 + longitud4 (tl xs))"

value "longitud4 [4,2,5] = 3"

(* danrodcha fracorjim1 *)
fun longitud5 :: "'a list ⇒ nat" where
"longitud5 [] = 0"
| "longitud5 (x#xs) = Suc (longitud5 xs)"

value "longitud5 [4,2,5] = 3"

(* serrodcal *)
fun longitud6 :: "'a list ⇒ nat" where
"longitud xs = length xs"

value "longitud6 [4,2,5] " -- "= 3"

(* Comentario: El objetivo es explicitar cómo está definida la función
length *)

(* ivamenjim *)
fun longitud7 :: "'a list ⇒ nat" where
"longitud7 [] = 0"
| "longitud7 xs = longitud7 (drop 1 xs) + 1"

value "longitud7 [4,2,5] = 3"

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

(* wilmorort marcarmor13 danrodcha crigomgom pablucoto rubgonmar
manmorjim1 serrodcal fraortmoy anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y,x)"

value "intercambia (u,v) = (v,u)"

(* jeamacpov ivamenjim marpoldia1*)
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 (x,y) = (snd (x,y), fst (x,y))"

value "intercambia2 (u,v) = (v,u)"

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

(* wilmorort fraortmoy *)
(* @ :: "'a list => 'a list => 'a list", función agregación definida
en Theory Main, concatena dos listas: [a,b] @ [c,d] = [a,b,c,d] *)
fun inversa :: "'a list ⇒ 'a list" where
"inversa [] = []" |
"inversa (x # xs) = (inversa xs) @ (x#[]) "

value "inversa [a,d,c] = [c,d,a]"

(*marcarmor13 manmorjim1*)
fun inversa1 :: "'a list ⇒ 'a list" where
"inversa1 [] = []"
| "inversa1 xs = inversa1 (tl xs)@ ((hd xs)#[])"

value "inversa1 [a,d,c] = [c,d,a]"

(* danrodcha pablucoto rubgonmar anaprarod dancorgar ferrenseg paupeddeg
pabrodmac fracorjim1 *)
(* es igual que inversa sustituyendo x#[] por [x] *)
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = []"
| "inversa2 (x#xs) = (inversa2 xs) @ [x]"

value "inversa2 [a,d,c] = [c,d,a]"

(* danrodcha ivamenjim antsancab1 *)
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (x#xs) = concat [(inversa3 xs),[x]] "

value "inversa3 [a,d,c] = [c,d,a]"

(* crigomgom serrodcal marpoldia1*)
fun inversa4 :: "'a list ⇒ 'a list" where
"inversa4 [] = []" |
"inversa4 xs = (last xs) # (inversa4 (butlast xs)) "

value "inversa4 [a,d,c] = [c,d,a]"

(* jeamacpov *)
fun inversa5 :: "'a list ⇒ 'a list" where
"inversa5 [] = []"
| "inversa5 xs =
(drop (length(xs)-1) xs) @ inversa5 (take (length(xs)-1) xs)"

value "inversa5 [a,d,c] = [c,d,a]"

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

(* wilmorort marcarmor13 crigomgom pablucoto rubgonmar manmorjim1
jeamacpov ivamenjim marpoldia1*)
fun repite :: "nat ⇒ 'a ⇒ 'a list" where
"repite 0 x = [] " |
"repite n x = x # (repite (n-1) x)"

value "repite 3 a = [a,a,a]"

(* danrodcha fraortmoy dancorgar ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun repite1 :: "nat ⇒ 'a ⇒ 'a list" where
"repite1 0 x = []"
| "repite1 (Suc n) x = x # (repite1 n x)"

value "repite1 3 a = [a,a,a]"

(*serrodcal anaprarod *)
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 0 x = []"
| "repite2 (Suc n) x = [x] @ (repite2 n x)"

value "repite2 3 a = [a,a,a]"

(* ivamenjim *)
fun repite3 :: "nat ⇒ 'a ⇒ 'a list" where
"repite3 n x = replicate n x"

value "repite3 3 a = [a,a,a]"

(* Comentario: uso de replicate *)

text {* ---------------------------------------------------------------
Ejercicio 5. Definir la función
conc :: 'a list ⇒ 'a list ⇒ 'a list
tal que (conc xs ys) es la concatención de las listas xs e ys. Por
ejemplo,
conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]
------------------------------------------------------------------ *}

(* marcarmor13 serrodcal *)
fun conc :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc xs ys = xs@ys"

value "conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: El objetivo del ejercicio es explicitar la definición de
@ *)

(* danrodcha crigomgom rubgonmar paupeddeg *)
fun conc1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc1 [] ys = ys"
| "conc1 xs [] = xs" (* esta no hace falta *)
| "conc1 (x#xs) ys = x# (conc1 xs ys)"

value "conc1 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* pablucoto jeamacpov fraortmoy anaprarod ferrenseg pabrodmac antsancab1 fracorjim1 *)
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 [] ys = ys" |
"conc2 (x#xs) ys = x # (conc2 xs ys)"

value "conc2 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* manmorjim1 *)
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 [] ys = ys"
| "conc3 xs ys = (hd xs)#[] @ (conc3 (tl xs) ys)"

value "conc3 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* ivamenjim *)
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 xs ys = concat [xs,ys]"

value "conc4 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: uso de concat *)

(* dancorgar *)
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] [] = []"
| "conc5 [] (y#ys) = y#(conc5 [] ys)"
| "conc5 (x#xs) ys = x#(conc5 xs ys)"

value "conc5 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La definición conc5 se puede simplificar. *)

(* marpoldia1 *)
fun conc6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc6 [] [] = []"
| "conc6 [] ys = ys"
| "conc6 xs ys = (hd xs)#(conc6 (tl xs) ys)"

value "conc6 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La 2ª ecuación de conc6 contiene a la primera. Además, se
puede eliminar el uso de hd y tl. *)

text {* ---------------------------------------------------------------
Ejercicio 6. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [a,c,d,b,e] = [a,c]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1*)
fun coge :: "nat ⇒ 'a list ⇒ 'a list" where
"coge 0 xs = []"
| "coge n xs = (hd xs)#(coge (n-1) (tl xs)) "

value "coge 2 [a,c,d,b,e] = [a,c]"
value "coge 2 [a,c,d,b,e] = [a,c]"

(* danrodcha fraortmoy anaprarod ferrenseg paupeddeg pabrodmac *)
fun coge1 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge1 0 _ = []"
| "coge1 _ [] = []"
| "coge1 (Suc n) (x#xs) = x#(coge1 n xs)"

value "coge1 2 [a,c,d,b,e] = [a,c]"
value "coge1 2 [a,c,d,b,e] = [a,c]"

(* crimgomgom jeamacpov rubgonmar ivamenjim *)
fun coge2 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge2 0 _ = []"|
"coge2 _ [] = []" |
"coge2 n (x#xs) = x#(coge2 (n-1) xs) "

value "coge2 2 [a,c,d,b,e] = [a,c]"
value "coge2 2 [a,c,d,b,e] = [a,c]"

(* pablucoto *)
fun coge3 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge3 0 xs = []" |
"coge3 n (x#xs) = (if n > length (x#xs)
then (x#xs)
else x # (coge3 (n-1) xs))"

value "coge3 2 [a,c,d,b,e] = [a,c]"
value "coge3 3 [a,c] = [a,c]"

(* serrodcal *)
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []"
| "coge4 n xs = [(hd xs)]@(coge4 (n-1) (tl xs))"

value "coge4 2 [a,c,d,b,e] = [a,c]"

(* ivamenjim *)
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 n xs = take n xs"

value "coge5 2 [a,c,d,b,e] = [a,c]"

(* Comentario: uso de take *)

(* dancorgar antsancab1 *)
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 0 xs = []"
| "coge6 (Suc m) [] = []"
| "coge6 (Suc m) (x#xs) = (x#(coge6 m xs))"

value "coge6 2 [a,c,d,b,e] = [a,c]"

(* marpoldia1 *)
fun coge7 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge7 0 xs = []"|
"coge7 n [] = []"|
"coge7 n xs = (hd xs) # (coge7 (n-1) (tl xs))"

value "coge7 0 [a,b,c] = []"
value "coge7 2 [] = []"
value "coge7 2 [a,c,d,b,e] = [a,c]"

(* fracorjim1 - Versión compacta, pero genera un esquema de inducción poco claro al no utilizar patrones *)
fun coge8 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge8 0 xs = []"
| "coge8 (Suc n) xs = (hd xs)#(coge8 n (tl xs))"

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
elimina :: nat ⇒ 'a list ⇒ 'a list
tal que (elimina n xs) es la lista obtenida eliminando los n primeros
elementos de xs. Por ejemplo,
elimina 2 [a,c,d,b,e] = [d,b,e]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1 serrodcal marpoldia1*)
fun elimina :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina 0 xs = xs"
| "elimina n xs = (elimina (n-1) (tl xs ))"

(* danrodcha crigomgom fraortmoy anaprarod paupeddeg pabrodmac *)
fun elimina1 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina1 0 xs = xs"
| "elimina1 _ [] = []"
| "elimina1 (Suc n) (x#xs) = elimina1 n xs"

(* pablucoto *)
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina2 0 xs = xs" |
"elimina2 n (x#xs) = (if n > length (x#xs)
then []
else (elimina2 (n-1) xs))"

(* jeamacpov ivamenjim *)
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs"
| "elimina3 n xs = (elimina3 (n-1) (drop 1 xs)) "

(* rubgonmar *)
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 0 xs = xs" |
"elimina4 n xs = (if n > length(xs)
then []
else (elimina4 (n-1) (tl xs)))"

value "elimina4 2 [a,c,d,b,e] = [d,b,e]"

(* dancorgar antsancab1 *)
fun elimina5 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina5 0 xs = xs"
| "elimina5 (Suc m) [] = []"
| "elimina5 (Suc m) (x#xs) = elimina5 m xs"

value "elimina5 2 [a,c,d,b,e]= [d,b,e]" -- "= [d,b,e]"

(* ferrenseg *)

fun elimina6 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina6 0 xs = xs"
|"elimina6 n [] = []"
|"elimina6 (Suc n) (x#xs) = elimina6 n xs"

value "elimina6 2 [a,c,d,b,e]" -- "= [d,b,e]"

(* fracorjim1 - Versión compacta, pero genera un esquema de inducción poco claro al no utilizar patrones *)
fun elimina7 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina7 0 xs = xs"
| "elimina7 (Suc n) xs = elimina7 n (tl xs)"

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

(* marcarmor13 rubgonmar danrodcha crigomgom fraortmoy dancorgar
paupeddeg *)
fun esVacia :: "'a list ⇒ bool" where
"esVacia [] = True "
| "esVacia xs = False"

(* danrodcha anaprarod*)
fun esVacia1 :: "'a list ⇒ bool" where
"esVacia1 xs = (xs = [])"

(* pablucoto jeamacpov antsancab1 *)
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 xs = (if xs = []
then True
else False)"

(*manmorjim1, serrodcal*)
fun esVacia3 :: "'a list ⇒ bool" where
"esVacia3 xs = (length xs = 0)"

value "esVacia3 [] = True"
value "esVacia3 [1] = False"

(* ivamenjim marpoldia1*)
fun esVacia4 :: "'a list ⇒ bool" where
"esVacia4 xs = (if length (xs) > 0
then False
else True)"

value "esVacia4 [] = True"
value "esVacia4 [1] = False"

(* ferrenseg fracorjim1 *)
fun esVacia5 :: "'a list ⇒ bool" where
"esVacia5 [] = True"
|"esVacia5 (x#xs) = False"

value "esVacia5 []" -- "= True"
value "esVacia5 [1]" -- "= False"

(* pabrodmac *)
fun esVacia6 :: "'a list ⇒ bool" where
"esVacia6 [] = True"
| "esVacia6 _ = False"

value "esVacia6 []= True"
value "esVacia6 [1]= False"

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [a,c,b,e] = [e,b,c,a]
------------------------------------------------------------------ *}

(* rubgonmar marcarmor13 mamnorjim1 serrodcal ivamenjim marpoldia1*)
fun inversaAcAux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux [] ys = ys"
| "inversaAcAux xs ys = inversaAcAux (tl xs) (hd xs#ys) "

(* rubgonmar danrodcha crigomgom manmorjim1 serrodcal ivamenjim
anaprarod marpoldia1*)
fun inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs = inversaAcAux xs []"

value "inversaAc [a,c,b,e]= [e,b,c,a]"

(* danrodcha crigomgom anaprarod paupeddeg *)
fun inversaAcAux1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux1 [] ys = ys"
| "inversaAcAux1 (x#xs) ys = inversaAcAux1 xs (x#ys)"

(* pablucoto *)
fun inversaAcAux2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux2 [] [] = []"|
"inversaAcAux2 xs (y#ys) = (inversaAcAux2 [] ys) @ [y]"

fun inversaAc2 :: "'a list ⇒ 'a list" where
"inversaAc2 xs = inversaAcAux2 [] xs "

value "inversaAc2 [a,c,b,e]= [e,b,c,a]"

(* jeamacpov *)
fun inversaAcAux3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux3 ys [] = ys"
| "inversaAcAux3 ys (x#xs) = inversaAcAux3 (x#ys) xs"

fun inversaAc3 :: "'a list ⇒ 'a list" where
"inversaAc3 xs = inversaAcAux3 [] xs"

value "inversaAc3 [a,c,b,e]= [e,b,c,a]"

(* fraortmoy *)
fun inversaAcAux4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux4 xs [] = xs"
| "inversaAcAux4 xs (x#ys) = inversaAcAux4 (x#xs) ys"

fun inversaAc4 :: "'a list ⇒ 'a list" where
"inversaAc4 [] = []"
| "inversaAc4 (x#xs)= (inversaAcAux4 [x] xs)"

value "inversaAc4 [a,c,b,e]" -- "= [e,b,c,a]"

(* dancorgar *)
fun inversaAcAux5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux5 [] [] = []"
| "inversaAcAux5 [] (y#ys) = y#(inversaAcAux5 [] ys)"
| "inversaAcAux5 (x#xs) ys = x#(inversaAcAux5 xs ys)"

(* dancorgar *)
fun inversaAc5 :: "'a list ⇒ 'a list" where
"inversaAc5 [] = []"
| "inversaAc5 (x#xs) = inversaAcAux5 (inversaAc5 xs) [x]"

value "inversaAc5 [a,c,b,e] = [e,b,c,a]" -- "= [e,b,c,a]"

(* ferrenseg *)
fun inversaAcAux6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux6 [] ys = ys"
|"inversaAcAux6 (x#xs) ys = inversaAcAux6 xs (x#ys)"

fun inversaAc6 :: "'a list ⇒ 'a list" where
"inversaAc6 xs = inversaAcAux6 xs []"

value "inversaAc6 [a,c,b,e]" -- "= [e,b,c,a]"

(* pabrodmac antsancab1 *)
fun inversaAcAux7 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux7 [] ys = ys "
| "inversaAcAux7 (x#xs) ys =inversaAcAux7 xs (x#ys) "

fun inversaAc7 :: "'a list ⇒ 'a list" where
"inversaAc7 [] =[]"
| "inversaAc7 (x#xs) = inversaAcAux7 xs [x]"

value "inversaAc7 [a,c,b,e]= [e,b,c,a]"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun sum :: "nat list ⇒ nat" where
"sum [] = 0"
| "sum xs = hd xs + sum (tl xs)"

value "sum [3,2,5] = 10"

(* danrodcha crigomgom pablucoto fraortmoy anaprarod ferrenseg paupeddeg
pabrodmac antsancab1 fracorjim1 *)
fun sum1 :: "nat list ⇒ nat" where
"sum1 [] = 0"
| "sum1 (x#xs) = x + sum1 xs"

value "sum1 [3,2,5] = 10"

(* danrodcha *)
fun sum2 :: "nat list ⇒ nat" where
"sum2 xs = fold (op +) xs 0"

value "sum2 [3,2,5] = 10"

(* jeamacpov *)
fun sum3 :: "nat list ⇒ nat" where
"sum3 [] = 0"
| "sum3 xs = (hd xs) + (sum3(drop 1 xs))"

value "sum3 [3,2,5] = 10"

(* ivamenjim *)
fun sum4 :: "nat list ⇒ nat" where
"sum4 xs = listsum xs"

value "sum4 [3,2,5] = 10"

(* Comentario: uso de listsum *)

(* dancorgar *)
fun sum5 :: "nat list ⇒ nat" where
"sum5 [] = 0"
| "sum5 (x#[]) = x"
| "sum5 (x#(y#xs)) = sum5 ((x + y)#xs)"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []"
| "map f xs = f (hd xs) # map f (tl xs)"

value "map (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* wilmorort danrodcha crigomgom pablucoto fraortmoy anaprarod dancorgar
ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []"
| "map2 f (x # xs) = f x # map2 f xs" (* yo pondría paréntesis, pero sin
ellos lo entiende*)

value "map2 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* jeamacpov *)
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []"
| "map3 f xs = f (hd xs) # (map3 f (drop 1 xs)) "

value "map3 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

end
</source>

Relación 1

2017-01-05T11:59:42Z

Fracorjim1:

<source lang="isar">
chapter {* R1: Programación funcional en Isabelle *}

theory R1
imports Main
begin

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

(* danrodcha anaprarod ivamenjim serrodcal manmorjim1 fraortmoy
dancorgar ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun factorial :: "nat ⇒ nat" where
"factorial 0 = 1"
| "factorial (Suc n) = (Suc n) * factorial n"

value "factorial 4 = 24"

(* wilmorort pablucoto marcarmor13 crigomgom rubgonmar jeamacpov
marpoldia1*)
fun factorial1 :: "nat ⇒ nat" where
"factorial1 0 = 1 "
| "factorial1 n = n * factorial1 (n-1)"

value "factorial1 4 = 24"

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

(* wilmorort *)
(* Para usar las lista en forma de [a,b,c] *)
translations
"[x, xs]" == "x#[xs]"
"[x]" == "x#[]"

(* wilmorort serrodcal crigomgom rubgonmar anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 *)
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0" |
"longitud (x # xs) = 1 + longitud xs "

value "longitud [4,2,5] = 3"

(* pablucoto *)
fun longitud2 :: "'a list ⇒ nat " where
"longitud2 [] = 0"
| "longitud2 xs = 1 + longitud2 (butlast xs) "

value "longitud2 [4,2,5] = 3"

(* pablucoto *)
fun longitud3 :: "'a list ⇒ nat " where
"longitud3 xs = (if xs = []
then 0
else 1 + longitud3 (butlast xs))"

value "longitud3 [4,2,5] = 3"

(* marcarmor13 manmorjim1 jeamacpov marpoldia1 fraortmoy *)
fun longitud4 :: "'a list ⇒ nat" where
"longitud4 [] = 0 "
| "longitud4 xs = (1 + longitud4 (tl xs))"

value "longitud4 [4,2,5] = 3"

(* danrodcha fracorjim1 *)
fun longitud5 :: "'a list ⇒ nat" where
"longitud5 [] = 0"
| "longitud5 (x#xs) = Suc (longitud5 xs)"

value "longitud5 [4,2,5] = 3"

(* serrodcal *)
fun longitud6 :: "'a list ⇒ nat" where
"longitud xs = length xs"

value "longitud6 [4,2,5] " -- "= 3"

(* Comentario: El objetivo es explicitar cómo está definida la función
length *)

(* ivamenjim *)
fun longitud7 :: "'a list ⇒ nat" where
"longitud7 [] = 0"
| "longitud7 xs = longitud7 (drop 1 xs) + 1"

value "longitud7 [4,2,5] = 3"

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

(* wilmorort marcarmor13 danrodcha crigomgom pablucoto rubgonmar
manmorjim1 serrodcal fraortmoy anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y,x)"

value "intercambia (u,v) = (v,u)"

(* jeamacpov ivamenjim marpoldia1*)
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 (x,y) = (snd (x,y), fst (x,y))"

value "intercambia2 (u,v) = (v,u)"

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

(* wilmorort fraortmoy *)
(* @ :: "'a list => 'a list => 'a list", función agregación definida
en Theory Main, concatena dos listas: [a,b] @ [c,d] = [a,b,c,d] *)
fun inversa :: "'a list ⇒ 'a list" where
"inversa [] = []" |
"inversa (x # xs) = (inversa xs) @ (x#[]) "

value "inversa [a,d,c] = [c,d,a]"

(*marcarmor13 manmorjim1*)
fun inversa1 :: "'a list ⇒ 'a list" where
"inversa1 [] = []"
| "inversa1 xs = inversa1 (tl xs)@ ((hd xs)#[])"

value "inversa1 [a,d,c] = [c,d,a]"

(* danrodcha pablucoto rubgonmar anaprarod dancorgar ferrenseg paupeddeg
pabrodmac fracorjim1 *)
(* es igual que inversa sustituyendo x#[] por [x] *)
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = []"
| "inversa2 (x#xs) = (inversa2 xs) @ [x]"

value "inversa2 [a,d,c] = [c,d,a]"

(* danrodcha ivamenjim antsancab1 *)
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (x#xs) = concat [(inversa3 xs),[x]] "

value "inversa3 [a,d,c] = [c,d,a]"

(* crigomgom serrodcal marpoldia1*)
fun inversa4 :: "'a list ⇒ 'a list" where
"inversa4 [] = []" |
"inversa4 xs = (last xs) # (inversa4 (butlast xs)) "

value "inversa4 [a,d,c] = [c,d,a]"

(* jeamacpov *)
fun inversa5 :: "'a list ⇒ 'a list" where
"inversa5 [] = []"
| "inversa5 xs =
(drop (length(xs)-1) xs) @ inversa5 (take (length(xs)-1) xs)"

value "inversa5 [a,d,c] = [c,d,a]"

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

(* wilmorort marcarmor13 crigomgom pablucoto rubgonmar manmorjim1
jeamacpov ivamenjim marpoldia1*)
fun repite :: "nat ⇒ 'a ⇒ 'a list" where
"repite 0 x = [] " |
"repite n x = x # (repite (n-1) x)"

value "repite 3 a = [a,a,a]"

(* danrodcha fraortmoy dancorgar ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun repite1 :: "nat ⇒ 'a ⇒ 'a list" where
"repite1 0 x = []"
| "repite1 (Suc n) x = x # (repite1 n x)"

value "repite1 3 a = [a,a,a]"

(*serrodcal anaprarod *)
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 0 x = []"
| "repite2 (Suc n) x = [x] @ (repite2 n x)"

value "repite2 3 a = [a,a,a]"

(* ivamenjim *)
fun repite3 :: "nat ⇒ 'a ⇒ 'a list" where
"repite3 n x = replicate n x"

value "repite3 3 a = [a,a,a]"

(* Comentario: uso de replicate *)

text {* ---------------------------------------------------------------
Ejercicio 5. Definir la función
conc :: 'a list ⇒ 'a list ⇒ 'a list
tal que (conc xs ys) es la concatención de las listas xs e ys. Por
ejemplo,
conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]
------------------------------------------------------------------ *}

(* marcarmor13 serrodcal *)
fun conc :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc xs ys = xs@ys"

value "conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: El objetivo del ejercicio es explicitar la definición de
@ *)

(* danrodcha crigomgom rubgonmar paupeddeg *)
fun conc1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc1 [] ys = ys"
| "conc1 xs [] = xs" (* esta no hace falta *)
| "conc1 (x#xs) ys = x# (conc1 xs ys)"

value "conc1 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* pablucoto jeamacpov fraortmoy anaprarod ferrenseg pabrodmac antsancab1 fracorjim1 *)
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 [] ys = ys" |
"conc2 (x#xs) ys = x # (conc2 xs ys)"

value "conc2 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* manmorjim1 *)
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 [] ys = ys"
| "conc3 xs ys = (hd xs)#[] @ (conc3 (tl xs) ys)"

value "conc3 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* ivamenjim *)
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 xs ys = concat [xs,ys]"

value "conc4 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: uso de concat *)

(* dancorgar *)
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] [] = []"
| "conc5 [] (y#ys) = y#(conc5 [] ys)"
| "conc5 (x#xs) ys = x#(conc5 xs ys)"

value "conc5 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La definición conc5 se puede simplificar. *)

(* marpoldia1 *)
fun conc6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc6 [] [] = []"
| "conc6 [] ys = ys"
| "conc6 xs ys = (hd xs)#(conc6 (tl xs) ys)"

value "conc6 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La 2ª ecuación de conc6 contiene a la primera. Además, se
puede eliminar el uso de hd y tl. *)

text {* ---------------------------------------------------------------
Ejercicio 6. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [a,c,d,b,e] = [a,c]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1*)
fun coge :: "nat ⇒ 'a list ⇒ 'a list" where
"coge 0 xs = []"
| "coge n xs = (hd xs)#(coge (n-1) (tl xs)) "

value "coge 2 [a,c,d,b,e] = [a,c]"
value "coge 2 [a,c,d,b,e] = [a,c]"

(* danrodcha fraortmoy anaprarod ferrenseg paupeddeg pabrodmac *)
fun coge1 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge1 0 _ = []"
| "coge1 _ [] = []"
| "coge1 (Suc n) (x#xs) = x#(coge1 n xs)"

value "coge1 2 [a,c,d,b,e] = [a,c]"
value "coge1 2 [a,c,d,b,e] = [a,c]"

(* crimgomgom jeamacpov rubgonmar ivamenjim *)
fun coge2 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge2 0 _ = []"|
"coge2 _ [] = []" |
"coge2 n (x#xs) = x#(coge2 (n-1) xs) "

value "coge2 2 [a,c,d,b,e] = [a,c]"
value "coge2 2 [a,c,d,b,e] = [a,c]"

(* pablucoto *)
fun coge3 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge3 0 xs = []" |
"coge3 n (x#xs) = (if n > length (x#xs)
then (x#xs)
else x # (coge3 (n-1) xs))"

value "coge3 2 [a,c,d,b,e] = [a,c]"
value "coge3 3 [a,c] = [a,c]"

(* serrodcal *)
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []"
| "coge4 n xs = [(hd xs)]@(coge4 (n-1) (tl xs))"

value "coge4 2 [a,c,d,b,e] = [a,c]"

(* ivamenjim *)
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 n xs = take n xs"

value "coge5 2 [a,c,d,b,e] = [a,c]"

(* Comentario: uso de take *)

(* dancorgar antsancab1 *)
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 0 xs = []"
| "coge6 (Suc m) [] = []"
| "coge6 (Suc m) (x#xs) = (x#(coge6 m xs))"

value "coge6 2 [a,c,d,b,e] = [a,c]"

(* marpoldia1 *)
fun coge7 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge7 0 xs = []"|
"coge7 n [] = []"|
"coge7 n xs = (hd xs) # (coge7 (n-1) (tl xs))"

value "coge7 0 [a,b,c] = []"
value "coge7 2 [] = []"
value "coge7 2 [a,c,d,b,e] = [a,c]"

(* fracorjim1 - Versión compacta, pero genera un esquema de inducción poco claro al no utilizar patrones *)
fun coge8 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge8 0 xs = []"
| "coge8 (Suc n) xs = (hd xs)#(coge8 n (tl xs))"

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
elimina :: nat ⇒ 'a list ⇒ 'a list
tal que (elimina n xs) es la lista obtenida eliminando los n primeros
elementos de xs. Por ejemplo,
elimina 2 [a,c,d,b,e] = [d,b,e]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1 serrodcal marpoldia1*)
fun elimina :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina 0 xs = xs"
| "elimina n xs = (elimina (n-1) (tl xs ))"

(* danrodcha crigomgom fraortmoy anaprarod paupeddeg pabrodmac *)
fun elimina1 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina1 0 xs = xs"
| "elimina1 _ [] = []"
| "elimina1 (Suc n) (x#xs) = elimina1 n xs"

(* pablucoto *)
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina2 0 xs = xs" |
"elimina2 n (x#xs) = (if n > length (x#xs)
then []
else (elimina2 (n-1) xs))"

(* jeamacpov ivamenjim *)
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs"
| "elimina3 n xs = (elimina3 (n-1) (drop 1 xs)) "

(* rubgonmar *)
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 0 xs = xs" |
"elimina4 n xs = (if n > length(xs)
then []
else (elimina4 (n-1) (tl xs)))"

value "elimina4 2 [a,c,d,b,e] = [d,b,e]"

(* dancorgar antsancab1 *)
fun elimina5 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina5 0 xs = xs"
| "elimina5 (Suc m) [] = []"
| "elimina5 (Suc m) (x#xs) = elimina5 m xs"

value "elimina5 2 [a,c,d,b,e]= [d,b,e]" -- "= [d,b,e]"

(* ferrenseg *)

fun elimina6 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina6 0 xs = xs"
|"elimina6 n [] = []"
|"elimina6 (Suc n) (x#xs) = elimina6 n xs"

value "elimina6 2 [a,c,d,b,e]" -- "= [d,b,e]"

(* fracorjim1 - Versión compacta, pero genera un esquema de inducción poco claro al no utilizar patrones *)
fun elimina7 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina7 0 xs = xs"
| "elimina7 (Suc n) xs = elimina7 n (tl xs)"

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

(* marcarmor13 rubgonmar danrodcha crigomgom fraortmoy dancorgar
paupeddeg *)
fun esVacia :: "'a list ⇒ bool" where
"esVacia [] = True "
| "esVacia xs = False"

(* danrodcha anaprarod*)
fun esVacia1 :: "'a list ⇒ bool" where
"esVacia1 xs = (xs = [])"

(* pablucoto jeamacpov antsancab1 *)
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 xs = (if xs = []
then True
else False)"

(*manmorjim1, serrodcal*)
fun esVacia3 :: "'a list ⇒ bool" where
"esVacia3 xs = (length xs = 0)"

value "esVacia3 [] = True"
value "esVacia3 [1] = False"

(* ivamenjim marpoldia1*)
fun esVacia4 :: "'a list ⇒ bool" where
"esVacia4 xs = (if length (xs) > 0
then False
else True)"

value "esVacia4 [] = True"
value "esVacia4 [1] = False"

(* ferrenseg *)
fun esVacia5 :: "'a list ⇒ bool" where
"esVacia5 [] = True"
|"esVacia5 (x#xs) = False"

value "esVacia5 []" -- "= True"
value "esVacia5 [1]" -- "= False"

(* pabrodmac *)
fun esVacia6 :: "'a list ⇒ bool" where
"esVacia6 [] = True"
| "esVacia6 _ = False"

value "esVacia6 []= True"
value "esVacia6 [1]= False"

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [a,c,b,e] = [e,b,c,a]
------------------------------------------------------------------ *}

(* rubgonmar marcarmor13 mamnorjim1 serrodcal ivamenjim marpoldia1*)
fun inversaAcAux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux [] ys = ys"
| "inversaAcAux xs ys = inversaAcAux (tl xs) (hd xs#ys) "

(* rubgonmar danrodcha crigomgom manmorjim1 serrodcal ivamenjim
anaprarod marpoldia1*)
fun inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs = inversaAcAux xs []"

value "inversaAc [a,c,b,e]= [e,b,c,a]"

(* danrodcha crigomgom anaprarod paupeddeg *)
fun inversaAcAux1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux1 [] ys = ys"
| "inversaAcAux1 (x#xs) ys = inversaAcAux1 xs (x#ys)"

(* pablucoto *)
fun inversaAcAux2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux2 [] [] = []"|
"inversaAcAux2 xs (y#ys) = (inversaAcAux2 [] ys) @ [y]"

fun inversaAc2 :: "'a list ⇒ 'a list" where
"inversaAc2 xs = inversaAcAux2 [] xs "

value "inversaAc2 [a,c,b,e]= [e,b,c,a]"

(* jeamacpov *)
fun inversaAcAux3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux3 ys [] = ys"
| "inversaAcAux3 ys (x#xs) = inversaAcAux3 (x#ys) xs"

fun inversaAc3 :: "'a list ⇒ 'a list" where
"inversaAc3 xs = inversaAcAux3 [] xs"

value "inversaAc3 [a,c,b,e]= [e,b,c,a]"

(* fraortmoy *)
fun inversaAcAux4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux4 xs [] = xs"
| "inversaAcAux4 xs (x#ys) = inversaAcAux4 (x#xs) ys"

fun inversaAc4 :: "'a list ⇒ 'a list" where
"inversaAc4 [] = []"
| "inversaAc4 (x#xs)= (inversaAcAux4 [x] xs)"

value "inversaAc4 [a,c,b,e]" -- "= [e,b,c,a]"

(* dancorgar *)
fun inversaAcAux5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux5 [] [] = []"
| "inversaAcAux5 [] (y#ys) = y#(inversaAcAux5 [] ys)"
| "inversaAcAux5 (x#xs) ys = x#(inversaAcAux5 xs ys)"

(* dancorgar *)
fun inversaAc5 :: "'a list ⇒ 'a list" where
"inversaAc5 [] = []"
| "inversaAc5 (x#xs) = inversaAcAux5 (inversaAc5 xs) [x]"

value "inversaAc5 [a,c,b,e] = [e,b,c,a]" -- "= [e,b,c,a]"

(* ferrenseg *)
fun inversaAcAux6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux6 [] ys = ys"
|"inversaAcAux6 (x#xs) ys = inversaAcAux6 xs (x#ys)"

fun inversaAc6 :: "'a list ⇒ 'a list" where
"inversaAc6 xs = inversaAcAux6 xs []"

value "inversaAc6 [a,c,b,e]" -- "= [e,b,c,a]"

(* pabrodmac antsancab1 *)
fun inversaAcAux7 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux7 [] ys = ys "
| "inversaAcAux7 (x#xs) ys =inversaAcAux7 xs (x#ys) "

fun inversaAc7 :: "'a list ⇒ 'a list" where
"inversaAc7 [] =[]"
| "inversaAc7 (x#xs) = inversaAcAux7 xs [x]"

value "inversaAc7 [a,c,b,e]= [e,b,c,a]"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun sum :: "nat list ⇒ nat" where
"sum [] = 0"
| "sum xs = hd xs + sum (tl xs)"

value "sum [3,2,5] = 10"

(* danrodcha crigomgom pablucoto fraortmoy anaprarod ferrenseg paupeddeg
pabrodmac antsancab1 *)
fun sum1 :: "nat list ⇒ nat" where
"sum1 [] = 0"
| "sum1 (x#xs) = x + sum1 xs"

value "sum1 [3,2,5] = 10"

(* danrodcha *)
fun sum2 :: "nat list ⇒ nat" where
"sum2 xs = fold (op +) xs 0"

value "sum2 [3,2,5] = 10"

(* jeamacpov *)
fun sum3 :: "nat list ⇒ nat" where
"sum3 [] = 0"
| "sum3 xs = (hd xs) + (sum3(drop 1 xs))"

value "sum3 [3,2,5] = 10"

(* ivamenjim *)
fun sum4 :: "nat list ⇒ nat" where
"sum4 xs = listsum xs"

value "sum4 [3,2,5] = 10"

(* Comentario: uso de listsum *)

(* dancorgar *)
fun sum5 :: "nat list ⇒ nat" where
"sum5 [] = 0"
| "sum5 (x#[]) = x"
| "sum5 (x#(y#xs)) = sum5 ((x + y)#xs)"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []"
| "map f xs = f (hd xs) # map f (tl xs)"

value "map (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* wilmorort danrodcha crigomgom pablucoto fraortmoy anaprarod dancorgar
ferrenseg paupeddeg pabrodmac antsancab1 *)
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []"
| "map2 f (x # xs) = f x # map2 f xs" (* yo pondría paréntesis, pero sin
ellos lo entiende*)

value "map2 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* jeamacpov *)
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []"
| "map3 f xs = f (hd xs) # (map3 f (drop 1 xs)) "

value "map3 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

end
</source>

Relación 1

2017-01-05T11:49:39Z

Fracorjim1:

<source lang="isar">
chapter {* R1: Programación funcional en Isabelle *}

theory R1
imports Main
begin

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

(* danrodcha anaprarod ivamenjim serrodcal manmorjim1 fraortmoy
dancorgar ferrenseg paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun factorial :: "nat ⇒ nat" where
"factorial 0 = 1"
| "factorial (Suc n) = (Suc n) * factorial n"

value "factorial 4 = 24"

(* wilmorort pablucoto marcarmor13 crigomgom rubgonmar jeamacpov
marpoldia1*)
fun factorial1 :: "nat ⇒ nat" where
"factorial1 0 = 1 "
| "factorial1 n = n * factorial1 (n-1)"

value "factorial1 4 = 24"

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

(* wilmorort *)
(* Para usar las lista en forma de [a,b,c] *)
translations
"[x, xs]" == "x#[xs]"
"[x]" == "x#[]"

(* wilmorort serrodcal crigomgom rubgonmar anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 *)
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0" |
"longitud (x # xs) = 1 + longitud xs "

value "longitud [4,2,5] = 3"

(* pablucoto *)
fun longitud2 :: "'a list ⇒ nat " where
"longitud2 [] = 0"
| "longitud2 xs = 1 + longitud2 (butlast xs) "

value "longitud2 [4,2,5] = 3"

(* pablucoto *)
fun longitud3 :: "'a list ⇒ nat " where
"longitud3 xs = (if xs = []
then 0
else 1 + longitud3 (butlast xs))"

value "longitud3 [4,2,5] = 3"

(* marcarmor13 manmorjim1 jeamacpov marpoldia1 fraortmoy *)
fun longitud4 :: "'a list ⇒ nat" where
"longitud4 [] = 0 "
| "longitud4 xs = (1 + longitud4 (tl xs))"

value "longitud4 [4,2,5] = 3"

(* danrodcha fracorjim1 *)
fun longitud5 :: "'a list ⇒ nat" where
"longitud5 [] = 0"
| "longitud5 (x#xs) = Suc (longitud5 xs)"

value "longitud5 [4,2,5] = 3"

(* serrodcal *)
fun longitud6 :: "'a list ⇒ nat" where
"longitud xs = length xs"

value "longitud6 [4,2,5] " -- "= 3"

(* Comentario: El objetivo es explicitar cómo está definida la función
length *)

(* ivamenjim *)
fun longitud7 :: "'a list ⇒ nat" where
"longitud7 [] = 0"
| "longitud7 xs = longitud7 (drop 1 xs) + 1"

value "longitud7 [4,2,5] = 3"

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

(* wilmorort marcarmor13 danrodcha crigomgom pablucoto rubgonmar
manmorjim1 serrodcal fraortmoy anaprarod dancorgar ferrenseg
paupeddeg pabrodmac antsancab1 fracorjim1 *)
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y,x)"

value "intercambia (u,v) = (v,u)"

(* jeamacpov ivamenjim marpoldia1*)
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 (x,y) = (snd (x,y), fst (x,y))"

value "intercambia2 (u,v) = (v,u)"

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

(* wilmorort fraortmoy *)
(* @ :: "'a list => 'a list => 'a list", función agregación definida
en Theory Main, concatena dos listas: [a,b] @ [c,d] = [a,b,c,d] *)
fun inversa :: "'a list ⇒ 'a list" where
"inversa [] = []" |
"inversa (x # xs) = (inversa xs) @ (x#[]) "

value "inversa [a,d,c] = [c,d,a]"

(*marcarmor13 manmorjim1*)
fun inversa1 :: "'a list ⇒ 'a list" where
"inversa1 [] = []"
| "inversa1 xs = inversa1 (tl xs)@ ((hd xs)#[])"

value "inversa1 [a,d,c] = [c,d,a]"

(* danrodcha pablucoto rubgonmar anaprarod dancorgar ferrenseg paupeddeg
pabrodmac fracorjim1 *)
(* es igual que inversa sustituyendo x#[] por [x] *)
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = []"
| "inversa2 (x#xs) = (inversa2 xs) @ [x]"

value "inversa2 [a,d,c] = [c,d,a]"

(* danrodcha ivamenjim antsancab1 *)
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (x#xs) = concat [(inversa3 xs),[x]] "

value "inversa3 [a,d,c] = [c,d,a]"

(* crigomgom serrodcal marpoldia1*)
fun inversa4 :: "'a list ⇒ 'a list" where
"inversa4 [] = []" |
"inversa4 xs = (last xs) # (inversa4 (butlast xs)) "

value "inversa4 [a,d,c] = [c,d,a]"

(* jeamacpov *)
fun inversa5 :: "'a list ⇒ 'a list" where
"inversa5 [] = []"
| "inversa5 xs =
(drop (length(xs)-1) xs) @ inversa5 (take (length(xs)-1) xs)"

value "inversa5 [a,d,c] = [c,d,a]"

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

(* wilmorort marcarmor13 crigomgom pablucoto rubgonmar manmorjim1
jeamacpov ivamenjim marpoldia1*)
fun repite :: "nat ⇒ 'a ⇒ 'a list" where
"repite 0 x = [] " |
"repite n x = x # (repite (n-1) x)"

value "repite 3 a = [a,a,a]"

(* danrodcha fraortmoy dancorgar ferrenseg paupeddeg pabrodmac antsancab1 *)
fun repite1 :: "nat ⇒ 'a ⇒ 'a list" where
"repite1 0 x = []"
| "repite1 (Suc n) x = x # (repite1 n x)"

value "repite1 3 a = [a,a,a]"

(*serrodcal anaprarod *)
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 0 x = []"
| "repite2 (Suc n) x = [x] @ (repite2 n x)"

value "repite2 3 a = [a,a,a]"

(* ivamenjim *)
fun repite3 :: "nat ⇒ 'a ⇒ 'a list" where
"repite3 n x = replicate n x"

value "repite3 3 a = [a,a,a]"

(* Comentario: uso de replicate *)

text {* ---------------------------------------------------------------
Ejercicio 5. Definir la función
conc :: 'a list ⇒ 'a list ⇒ 'a list
tal que (conc xs ys) es la concatención de las listas xs e ys. Por
ejemplo,
conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]
------------------------------------------------------------------ *}

(* marcarmor13 serrodcal *)
fun conc :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc xs ys = xs@ys"

value "conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: El objetivo del ejercicio es explicitar la definición de
@ *)

(* danrodcha crigomgom rubgonmar paupeddeg *)
fun conc1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc1 [] ys = ys"
| "conc1 xs [] = xs" (* esta no hace falta *)
| "conc1 (x#xs) ys = x# (conc1 xs ys)"

value "conc1 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* pablucoto jeamacpov fraortmoy anaprarod ferrenseg pabrodmac antsancab1 *)
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 [] ys = ys" |
"conc2 (x#xs) ys = x # (conc2 xs ys)"

value "conc2 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* manmorjim1 *)
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 [] ys = ys"
| "conc3 xs ys = (hd xs)#[] @ (conc3 (tl xs) ys)"

value "conc3 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* ivamenjim *)
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 xs ys = concat [xs,ys]"

value "conc4 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: uso de concat *)

(* dancorgar *)
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] [] = []"
| "conc5 [] (y#ys) = y#(conc5 [] ys)"
| "conc5 (x#xs) ys = x#(conc5 xs ys)"

value "conc5 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La definición conc5 se puede simplificar. *)

(* marpoldia1 *)
fun conc6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc6 [] [] = []"
| "conc6 [] ys = ys"
| "conc6 xs ys = (hd xs)#(conc6 (tl xs) ys)"

value "conc6 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* Comentario: La 2ª ecuación de conc6 contiene a la primera. Además, se
puede eliminar el uso de hd y tl. *)

text {* ---------------------------------------------------------------
Ejercicio 6. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [a,c,d,b,e] = [a,c]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1*)
fun coge :: "nat ⇒ 'a list ⇒ 'a list" where
"coge 0 xs = []"
| "coge n xs = (hd xs)#(coge (n-1) (tl xs)) "

value "coge 2 [a,c,d,b,e] = [a,c]"
value "coge 2 [a,c,d,b,e] = [a,c]"

(* danrodcha fraortmoy anaprarod ferrenseg paupeddeg pabrodmac *)
fun coge1 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge1 0 _ = []"
| "coge1 _ [] = []"
| "coge1 (Suc n) (x#xs) = x#(coge1 n xs)"

value "coge1 2 [a,c,d,b,e] = [a,c]"
value "coge1 2 [a,c,d,b,e] = [a,c]"

(* crimgomgom jeamacpov rubgonmar ivamenjim *)
fun coge2 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge2 0 _ = []"|
"coge2 _ [] = []" |
"coge2 n (x#xs) = x#(coge2 (n-1) xs) "

value "coge2 2 [a,c,d,b,e] = [a,c]"
value "coge2 2 [a,c,d,b,e] = [a,c]"

(* pablucoto *)
fun coge3 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge3 0 xs = []" |
"coge3 n (x#xs) = (if n > length (x#xs)
then (x#xs)
else x # (coge3 (n-1) xs))"

value "coge3 2 [a,c,d,b,e] = [a,c]"
value "coge3 3 [a,c] = [a,c]"

(* serrodcal *)
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []"
| "coge4 n xs = [(hd xs)]@(coge4 (n-1) (tl xs))"

value "coge4 2 [a,c,d,b,e] = [a,c]"

(* ivamenjim *)
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 n xs = take n xs"

value "coge5 2 [a,c,d,b,e] = [a,c]"

(* Comentario: uso de take *)

(* dancorgar antsancab1 *)
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 0 xs = []"
| "coge6 (Suc m) [] = []"
| "coge6 (Suc m) (x#xs) = (x#(coge6 m xs))"

value "coge6 2 [a,c,d,b,e] = [a,c]"

(* marpoldia1 *)
fun coge7 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge7 0 xs = []"|
"coge7 n [] = []"|
"coge7 n xs = (hd xs) # (coge7 (n-1) (tl xs))"

value "coge7 0 [a,b,c] = []"
value "coge7 2 [] = []"
value "coge7 2 [a,c,d,b,e] = [a,c]"

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
elimina :: nat ⇒ 'a list ⇒ 'a list
tal que (elimina n xs) es la lista obtenida eliminando los n primeros
elementos de xs. Por ejemplo,
elimina 2 [a,c,d,b,e] = [d,b,e]
------------------------------------------------------------------ *}

(* marcarmor13 manmorjim1 serrodcal marpoldia1*)
fun elimina :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina 0 xs = xs"
| "elimina n xs = (elimina (n-1) (tl xs ))"

(* danrodcha crigomgom fraortmoy anaprarod paupeddeg pabrodmac *)
fun elimina1 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina1 0 xs = xs"
| "elimina1 _ [] = []"
| "elimina1 (Suc n) (x#xs) = elimina1 n xs"

(* pablucoto *)
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina2 0 xs = xs" |
"elimina2 n (x#xs) = (if n > length (x#xs)
then []
else (elimina2 (n-1) xs))"

(* jeamacpov ivamenjim *)
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs"
| "elimina3 n xs = (elimina3 (n-1) (drop 1 xs)) "

(* rubgonmar *)
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 0 xs = xs" |
"elimina4 n xs = (if n > length(xs)
then []
else (elimina4 (n-1) (tl xs)))"

value "elimina4 2 [a,c,d,b,e] = [d,b,e]"

(* dancorgar antsancab1 *)
fun elimina5 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina5 0 xs = xs"
| "elimina5 (Suc m) [] = []"
| "elimina5 (Suc m) (x#xs) = elimina5 m xs"

value "elimina5 2 [a,c,d,b,e]= [d,b,e]" -- "= [d,b,e]"

(* ferrenseg *)

fun elimina6 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina6 0 xs = xs"
|"elimina6 n [] = []"
|"elimina6 (Suc n) (x#xs) = elimina6 n xs"

value "elimina6 2 [a,c,d,b,e]" -- "= [d,b,e]"

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

(* marcarmor13 rubgonmar danrodcha crigomgom fraortmoy dancorgar
paupeddeg *)
fun esVacia :: "'a list ⇒ bool" where
"esVacia [] = True "
| "esVacia xs = False"

(* danrodcha anaprarod*)
fun esVacia1 :: "'a list ⇒ bool" where
"esVacia1 xs = (xs = [])"

(* pablucoto jeamacpov antsancab1 *)
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 xs = (if xs = []
then True
else False)"

(*manmorjim1, serrodcal*)
fun esVacia3 :: "'a list ⇒ bool" where
"esVacia3 xs = (length xs = 0)"

value "esVacia3 [] = True"
value "esVacia3 [1] = False"

(* ivamenjim marpoldia1*)
fun esVacia4 :: "'a list ⇒ bool" where
"esVacia4 xs = (if length (xs) > 0
then False
else True)"

value "esVacia4 [] = True"
value "esVacia4 [1] = False"

(* ferrenseg *)
fun esVacia5 :: "'a list ⇒ bool" where
"esVacia5 [] = True"
|"esVacia5 (x#xs) = False"

value "esVacia5 []" -- "= True"
value "esVacia5 [1]" -- "= False"

(* pabrodmac *)
fun esVacia6 :: "'a list ⇒ bool" where
"esVacia6 [] = True"
| "esVacia6 _ = False"

value "esVacia6 []= True"
value "esVacia6 [1]= False"

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [a,c,b,e] = [e,b,c,a]
------------------------------------------------------------------ *}

(* rubgonmar marcarmor13 mamnorjim1 serrodcal ivamenjim marpoldia1*)
fun inversaAcAux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux [] ys = ys"
| "inversaAcAux xs ys = inversaAcAux (tl xs) (hd xs#ys) "

(* rubgonmar danrodcha crigomgom manmorjim1 serrodcal ivamenjim
anaprarod marpoldia1*)
fun inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs = inversaAcAux xs []"

value "inversaAc [a,c,b,e]= [e,b,c,a]"

(* danrodcha crigomgom anaprarod paupeddeg *)
fun inversaAcAux1 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux1 [] ys = ys"
| "inversaAcAux1 (x#xs) ys = inversaAcAux1 xs (x#ys)"

(* pablucoto *)
fun inversaAcAux2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux2 [] [] = []"|
"inversaAcAux2 xs (y#ys) = (inversaAcAux2 [] ys) @ [y]"

fun inversaAc2 :: "'a list ⇒ 'a list" where
"inversaAc2 xs = inversaAcAux2 [] xs "

value "inversaAc2 [a,c,b,e]= [e,b,c,a]"

(* jeamacpov *)
fun inversaAcAux3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux3 ys [] = ys"
| "inversaAcAux3 ys (x#xs) = inversaAcAux3 (x#ys) xs"

fun inversaAc3 :: "'a list ⇒ 'a list" where
"inversaAc3 xs = inversaAcAux3 [] xs"

value "inversaAc3 [a,c,b,e]= [e,b,c,a]"

(* fraortmoy *)
fun inversaAcAux4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux4 xs [] = xs"
| "inversaAcAux4 xs (x#ys) = inversaAcAux4 (x#xs) ys"

fun inversaAc4 :: "'a list ⇒ 'a list" where
"inversaAc4 [] = []"
| "inversaAc4 (x#xs)= (inversaAcAux4 [x] xs)"

value "inversaAc4 [a,c,b,e]" -- "= [e,b,c,a]"

(* dancorgar *)
fun inversaAcAux5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux5 [] [] = []"
| "inversaAcAux5 [] (y#ys) = y#(inversaAcAux5 [] ys)"
| "inversaAcAux5 (x#xs) ys = x#(inversaAcAux5 xs ys)"

(* dancorgar *)
fun inversaAc5 :: "'a list ⇒ 'a list" where
"inversaAc5 [] = []"
| "inversaAc5 (x#xs) = inversaAcAux5 (inversaAc5 xs) [x]"

value "inversaAc5 [a,c,b,e] = [e,b,c,a]" -- "= [e,b,c,a]"

(* ferrenseg *)
fun inversaAcAux6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux6 [] ys = ys"
|"inversaAcAux6 (x#xs) ys = inversaAcAux6 xs (x#ys)"

fun inversaAc6 :: "'a list ⇒ 'a list" where
"inversaAc6 xs = inversaAcAux6 xs []"

value "inversaAc6 [a,c,b,e]" -- "= [e,b,c,a]"

(* pabrodmac antsancab1 *)
fun inversaAcAux7 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux7 [] ys = ys "
| "inversaAcAux7 (x#xs) ys =inversaAcAux7 xs (x#ys) "

fun inversaAc7 :: "'a list ⇒ 'a list" where
"inversaAc7 [] =[]"
| "inversaAc7 (x#xs) = inversaAcAux7 xs [x]"

value "inversaAc7 [a,c,b,e]= [e,b,c,a]"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun sum :: "nat list ⇒ nat" where
"sum [] = 0"
| "sum xs = hd xs + sum (tl xs)"

value "sum [3,2,5] = 10"

(* danrodcha crigomgom pablucoto fraortmoy anaprarod ferrenseg paupeddeg
pabrodmac antsancab1 *)
fun sum1 :: "nat list ⇒ nat" where
"sum1 [] = 0"
| "sum1 (x#xs) = x + sum1 xs"

value "sum1 [3,2,5] = 10"

(* danrodcha *)
fun sum2 :: "nat list ⇒ nat" where
"sum2 xs = fold (op +) xs 0"

value "sum2 [3,2,5] = 10"

(* jeamacpov *)
fun sum3 :: "nat list ⇒ nat" where
"sum3 [] = 0"
| "sum3 xs = (hd xs) + (sum3(drop 1 xs))"

value "sum3 [3,2,5] = 10"

(* ivamenjim *)
fun sum4 :: "nat list ⇒ nat" where
"sum4 xs = listsum xs"

value "sum4 [3,2,5] = 10"

(* Comentario: uso de listsum *)

(* dancorgar *)
fun sum5 :: "nat list ⇒ nat" where
"sum5 [] = 0"
| "sum5 (x#[]) = x"
| "sum5 (x#(y#xs)) = sum5 ((x + y)#xs)"

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

(* rubgonmar marcarmor13 manmorjim1 serrodcal ivamenjim marpoldia1*)
fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []"
| "map f xs = f (hd xs) # map f (tl xs)"

value "map (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* wilmorort danrodcha crigomgom pablucoto fraortmoy anaprarod dancorgar
ferrenseg paupeddeg pabrodmac antsancab1 *)
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []"
| "map2 f (x # xs) = f x # map2 f xs" (* yo pondría paréntesis, pero sin
ellos lo entiende*)

value "map2 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

(* jeamacpov *)
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []"
| "map3 f xs = f (hd xs) # (map3 f (drop 1 xs)) "

value "map3 (λx. 2*x) [3::nat,2,5] = [6,4,10]"

end
</source>

Relación 7

2016-12-21T06:04:44Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 fracorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou fracorjim1 *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan fracorjim1 *)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal fracorjim1 *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

(* fracorjim1 *)

lemma aux10 : "hojas (a::arbol) = Suc(size a)"
apply (induct a)
apply auto
done

lemma es_abc_hojas_size_10 : "es_abc hojas (a::arbol) = es_abc size a"
apply (induct a)
apply (auto simp add: aux10)
done

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 7

2016-12-21T05:58:05Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 fracorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou fracorjim1 *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan fracorjim1 *)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal fracorjim1 *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 7

2016-12-21T05:50:07Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 fracorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou fracorjim1 *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan fracorjim1 *)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 7

2016-12-21T05:45:52Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 fracorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou fracorjim1 *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan*)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 7

2016-12-21T05:43:57Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 fracorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan*)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 7

2016-12-21T05:36:57Z

Fracorjim1:

<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 marcarmor13 josgarsan fracorjim1 *)
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 serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou *)
(* 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 marcarmor13*)
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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou *)
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 manmorjim1 *)
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
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou *)
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))"

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

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

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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 serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan*)
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 ivamenjim pablucoto marcarmor13 manmorjim1 *)
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 pablucoto serrodcal *)

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 crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou*)
(* 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)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

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 pablucoto serrodcal marcarmor13*)

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 crigomgom paupeddeg juacabsou*)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

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

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

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

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 pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
*)

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

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

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

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou*)

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

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

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 pablucoto serrodcal marcarmor13 *)

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 crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

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 pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou *)
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
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

end
</source>

Relación 6

2016-12-14T19:24:18Z

Fracorjim1:

<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 3
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

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 lucnovdos serrodcal pabrodmac jeamacpov paupeddeg marcarmor13 josgarsan
dancorgar *)

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 juacabsou ferrenseg
rubgonmar paupeddeg fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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 lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)

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

(* danrodcha manmorjim1 fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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 juacabsou serrodcal dancorgar josgarsan*)

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 paupeddeg *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom fracorjim1 *)
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 jeamacpov paupeddeg marcarmor13*)

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 lucnovdos pabrodmac*)

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

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) = preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)" using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar josgarsan*)

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 jeamacpov paupeddeg rubgonmar *)

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 lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) = postOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(preOrden d)@rev(preOrden i)@[x]" using h1 h2 by simp
also have "… =rev(preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg marcarmor13*)
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

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) = inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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 H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)" by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" using h1 h2 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 lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy fracorjim1 *)
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 lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy fracorjim1 *)
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 lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy fracorjim1 *)
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 juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
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 paupeddeg *)
(* 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

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha 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)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x 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

(* pabrodmac fraortmoy *)

lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)

theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov marcarmor13 *)
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 lucnovdos *)
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 paupeddeg rubgonmar *)

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

(* pabrodmac paupeddeg*)

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: inOrden)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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 h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac *)
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 lucnovdos juacabsou jeamacpov paupeddeg rubgonmar marcarmor13*) (*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 serrodcal *)

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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
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
show "?P (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 pabrodmac *)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13*)
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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "hd (preOrden 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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

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

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13 fraortmoy *)
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 pabrodmac*)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *) (*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

(*pabrodmac paupeddeg fraortmoy*)

theorem "last (postOrden a) = raiz a"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "last (postOrden 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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-14T19:18:42Z

Fracorjim1:

<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 3
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

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 lucnovdos serrodcal pabrodmac jeamacpov paupeddeg marcarmor13 josgarsan
dancorgar *)

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 juacabsou ferrenseg
rubgonmar paupeddeg fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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 lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)

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

(* danrodcha manmorjim1 fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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 juacabsou serrodcal dancorgar josgarsan*)

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 paupeddeg *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) simp_all

(* danrodcha crigomgom fracorjim1 *)
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 jeamacpov paupeddeg marcarmor13*)

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 lucnovdos pabrodmac*)

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

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) = preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)" using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar josgarsan*)

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 jeamacpov paupeddeg rubgonmar *)

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 lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) = postOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(preOrden d)@rev(preOrden i)@[x]" using h1 h2 by simp
also have "… =rev(preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg marcarmor13*)
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

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) = inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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 H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)" by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" using h1 h2 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 lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy *)
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 lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
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 paupeddeg *)
(* 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

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha 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)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x 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

(* pabrodmac fraortmoy *)

lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)

theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov marcarmor13 *)
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 lucnovdos *)
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 paupeddeg rubgonmar *)

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

(* pabrodmac paupeddeg*)

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: inOrden)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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 h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac *)
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 lucnovdos juacabsou jeamacpov paupeddeg rubgonmar marcarmor13*) (*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 serrodcal *)

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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
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
show "?P (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 pabrodmac *)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13*)
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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "hd (preOrden 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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

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

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13 fraortmoy *)
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 pabrodmac*)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *) (*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

(*pabrodmac paupeddeg fraortmoy*)

theorem "last (postOrden a) = raiz a"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "last (postOrden 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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-14T19:10:06Z

Fracorjim1:

<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 3
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

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 lucnovdos serrodcal pabrodmac jeamacpov paupeddeg marcarmor13 josgarsan
dancorgar *)

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 juacabsou ferrenseg
rubgonmar paupeddeg fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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 lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)

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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar *)

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 juacabsou serrodcal dancorgar *)

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 paupeddeg *)
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 jeamacpov paupeddeg marcarmor13*)

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 lucnovdos pabrodmac*)

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

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) = preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)" using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg rubgonmar *)

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 lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) = postOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(preOrden d)@rev(preOrden i)@[x]" using h1 h2 by simp
also have "… =rev(preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg marcarmor13*)
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

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) = inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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 H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)" by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" using h1 h2 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 lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy *)
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 lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
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 paupeddeg *)
(* 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

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha 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)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x 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

(* pabrodmac fraortmoy *)

lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)

theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov marcarmor13 *)
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 lucnovdos *)
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 paupeddeg rubgonmar *)

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

(* pabrodmac paupeddeg*)

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: inOrden)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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 h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac *)
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 lucnovdos juacabsou jeamacpov paupeddeg rubgonmar marcarmor13*) (*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 serrodcal *)

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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
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
show "?P (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 pabrodmac *)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13*)
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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "hd (preOrden 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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

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

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13 fraortmoy *)
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 pabrodmac*)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *) (*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

(*pabrodmac paupeddeg fraortmoy*)

theorem "last (postOrden a) = raiz a"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "last (postOrden 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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-14T19:09:03Z

Fracorjim1:

<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 3
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

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 lucnovdos serrodcal pabrodmac jeamacpov paupeddeg marcarmor13 josgarsan
dancorgar *)

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 juacabsou ferrenseg
rubgonmar paupeddeg fracorjim1 *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar *)

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 lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)

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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar *)

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 juacabsou serrodcal dancorgar *)

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 paupeddeg *)
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 jeamacpov paupeddeg marcarmor13*)

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 lucnovdos pabrodmac*)

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

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) = preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)" using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg rubgonmar *)

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 lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) = postOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(preOrden d)@rev(preOrden i)@[x]" using h1 h2 by simp
also have "… =rev(preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg marcarmor13*)
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

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) = inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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 H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)" by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" using h1 h2 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 lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy *)
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 lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
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 paupeddeg *)
(* 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

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha 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)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x 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

(* pabrodmac fraortmoy *)

lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)

theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov marcarmor13 *)
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 lucnovdos *)
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 paupeddeg rubgonmar *)

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

(* pabrodmac paupeddeg*)

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: inOrden)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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 h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac *)
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 lucnovdos juacabsou jeamacpov paupeddeg rubgonmar marcarmor13*) (*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 serrodcal *)

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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
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
show "?P (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 pabrodmac *)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13*)
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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "hd (preOrden 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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

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

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13 fraortmoy *)
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 pabrodmac*)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *) (*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

(*pabrodmac paupeddeg fraortmoy*)

theorem "last (postOrden a) = raiz a"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "last (postOrden 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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

end
</source>

Relación 6

2016-12-14T19:06:45Z

Fracorjim1:

<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 3
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

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 lucnovdos serrodcal pabrodmac jeamacpov paupeddeg marcarmor13 josgarsan
dancorgar *)

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 juacabsou ferrenseg
rubgonmar paupeddeg *)
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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar *)

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 lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)

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 lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar *)

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 juacabsou serrodcal dancorgar *)

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 paupeddeg *)
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 jeamacpov paupeddeg marcarmor13*)

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 lucnovdos pabrodmac*)

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

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) = preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)" using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg rubgonmar *)

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 lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) = postOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(preOrden d)@rev(preOrden i)@[x]" using h1 h2 by simp
also have "… =rev(preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)

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

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal dancorgar *)

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 jeamacpov paupeddeg marcarmor13*)
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

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) = inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)

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 H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)" by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))" using h1 h2 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 lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy *)
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 lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy *)
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 juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
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 paupeddeg *)
(* 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

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha 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)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x 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

(* pabrodmac fraortmoy *)

lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)

theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov marcarmor13 *)
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 lucnovdos *)
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 paupeddeg rubgonmar *)

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

(* pabrodmac paupeddeg*)

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
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)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: inOrden)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
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 h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac *)
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 lucnovdos juacabsou jeamacpov paupeddeg rubgonmar marcarmor13*) (*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 serrodcal *)

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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
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
show "?P (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 pabrodmac *)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13*)
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

(* pabrodmac paupeddeg fraortmoy *)

theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)

lemma
fixes a ::"'b arbol"
shows "hd (preOrden 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"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

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

(*crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13 fraortmoy *)
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 pabrodmac*)
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 lucnovdos juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *) (*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

(*pabrodmac paupeddeg fraortmoy*)

theorem "last (postOrden a) = raiz a"
by (induct a) auto

(*pabrodmac*)

lemma
fixes a ::"'b arbol"
shows "last (postOrden 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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(*Me he dado cuenta que no es necesario asumir ninguna hipótesis de inducción puesto que no es necesario utilizarlas, así que no se si está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
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
show "?P (N x i d)" by simp
qed

end
</source>

Relación 5

2016-11-30T20:01:31Z

Fracorjim1:

<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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1
danrodcha manmorjim1 *)
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 ferrenseg josgarsan juacabsou dancorgar pabrodmac lucnovdos
fracorjim1 *)
(* 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 algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (p x ∨ algunos p xs)"

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 pablucoto
serrodcal anaprarod migtermor paupeddeg fraortmoy marpoldia1
ferrenseg josgarsan danrodcha manmorjim1 juacabsou dancorgar
pabrodmac lucnovdos *)
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"

(* fracorjim1 - La versión anterior no prueba el segundo enunciado. La
que propongo demuestra ambos. *)
fun sinDuplicados1 :: "'a list ⇒ bool" where
"sinDuplicados1 [] = True"
| "sinDuplicados1 (x#xs) = (¬(estaEn x xs ∧ sinDuplicados xs))"

value "sinDuplicados1 [1::nat,4,2] = True"
value "sinDuplicados1 [1::nat,4,2,4] = False"

(* Comentario: La definición sinDuplicados1 no cumple el segundo
ejemplo. *)

(* paupeddeg *)
(* Utilizando la función ∉ de Isabelle *)
fun sinDuplicados2 :: "'a list ⇒ bool" where
"sinDuplicados2 [] = True"
| "sinDuplicados2 (a#xs) = ((a ∉ set xs) ∧ sinDuplicados2 xs ) "

(* Comentario: Uso de ∉ y set *)

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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1 ferrenseg
josgarsan danrodcha juacabsou dancorgar manmorjim1 pabrodmac
lucnovdos *)
fun borraDuplicados0 :: "'a list ⇒ 'a list" where
"borraDuplicados0 [] = []"
| "borraDuplicados0 (x#xs) = (if estaEn x xs
then borraDuplicados0 xs
else x#borraDuplicados0 xs)"

value "borraDuplicados0 [1::nat,2,4,2,3] = [1,4,2,3]"

(* rubgonmar *)
(* Otra forma Sin usar if
Utilizando case aunque se le sacaría más partido con más de 2 casos *)
fun borraDuplicados1 :: "'a list ⇒ 'a list" where
"borraDuplicados1 [] = []"
| "borraDuplicados1 (x#xs) = (case estaEn x xs of
False => x#borraDuplicados1 xs
| True => borraDuplicados1 xs )"

value "borraDuplicados1 [1::nat,2,4,2,3] = [1,4,2,3]"

(* rubgonmar *)
(* Otra forma utilizando let *)
fun borraDuplicados2 :: "'a list ⇒ 'a list" where
"borraDuplicados2 [] = []"
| "borraDuplicados2 (x#xs) =
(let condicion = estaEn x xs::bool in
if condicion
then borraDuplicados2 xs
else x # borraDuplicados2 xs)"

value "borraDuplicados2 [1::nat,2,4,2,3] = [1,4,2,3]"

(* ivamenjim *)
(* Utilizando la negación primero *)
fun borraDuplicados3 :: "'a list ⇒ 'a list" where
"borraDuplicados3 [] = []"
| "borraDuplicados3 (x#xs) = (if ¬(estaEn x xs)
then (x#(borraDuplicados3 xs))
else borraDuplicados3 xs)"

value "borraDuplicados3 [1::nat,2,4,2,3] = [1,4,2,3]"

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados xs = borraDuplicados0 xs"

(* fracorjim1. Utilizo un acumulador para optimizar la eficiencia *)

fun borraDuplicadosAc :: "'a list ⇒ 'a list ⇒ 'a list" where
"borraDuplicadosAc [] ys = ys"
| "borraDuplicadosAc (x#xs) ys = (if (estaEn x ys) then (borraDuplicadosAc xs ys)
else (borraDuplicadosAc xs (x#ys)))"

(* fracorjim1. Uso un caso base *)
fun borraDuplicados4 :: "'a list ⇒ 'a list" where
"borraDuplicados4 xs = (if (sinDuplicados xs) then xs else borraDuplicadosAc xs [])"

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

(* crigomgom anaprarod ferrenseg *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* Comentario: Falla para borraDuplicados1. *)

(* rubgonmar wilmorort pablucoto serrodcal migtermor paupeddeg
fraortmoy marpoldia1 danrodcha juacabsou dancorgar josgarsan
pabrodmac lucnovdos *)
lemma length_borraDuplicados2:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* manmorjim1 *)
(* soy de ponerlo mejor por pasos *)
lemma length_borraDuplicados3:
"length ( borraDuplicados xs ) ≤ length xs"
apply (induct xs)
apply auto
done

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados4:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

(* bowma anaprarod *)
lemma length_borraDuplicados5:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply (simp, simp) (* creo que es mejor poner aquí simp_all *)
done

(* ferrenseg *)
lemma length_borraDuplicados6:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) simp_all (* Creo que se puede poner simp_all fuera de
paréntesis *)

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

(* 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 ferrenseg rubgonmar juacabsou dancorgar
josgarsan lucnovdos *)
lemma length_borraDuplicados_2b:
"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

(* serrodcal anaprarod danrodcha *)
lemma length_borraDuplicados_2c:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a # xs)) ≤
1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "?P (a # xs)" by simp
qed

(* pablucoto *)
lemma length_borraDuplicados_2d:
"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
also have "... ≤ length (a#xs)" by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs) "
by simp
qed

(* bowma *)
lemma length_borraDuplicados_2f:
"length (borraDuplicados xs) ≤ length xs" (is "?p xs")
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "?p xs"
have c1: "1+length xs = length (a#xs)" by simp
also have "length(borraDuplicados (a#xs)) ≤
1 + length(borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
then show "length(borraDuplicados (a#xs)) ≤ length (a#xs)"
using c1 by simp
(* ¿Aquí porqué no puedo usar "finally show "?p (a # xs)" using c1 by simp?
Y porque no puedo añadir "finally show "?p (a # xs)" by simp al final? *)
qed

(* Comentario: Responder la pregunta. *)

(* migtermor *)
lemma length_borraDuplicados_2g:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
proof (cases)
assume "(estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) =
length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
using Aux by simp
next
assume "¬ (estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) =
1+ length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
using Aux by simp
qed
then show "?P (a#xs)" by simp
qed

(* paupeddeg marpoldia1 pabrodmac*)
lemma length_borraDuplicados_2h:
"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)) ≤
length [a] + length (borraDuplicados xs) " by simp
also have "... ≤ 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

(* fraortmoy *)
(* muy parecida a alguna anterior, pero yo dí más pasos *)
lemma length_borraDuplicados_2i:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume H1: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤
length(borraDuplicados [a])+length (borraDuplicados xs)"
by simp
also have "… ≤ 1 + length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length xs" using H1 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
---------------------------------------------------------------------
*}

(* crigomgom rubgonmar wilmorort pablucoto serrodcal bowma
migtermor fraortmoy marpoldia1 ferrenseg danrodcha juacabsou paupeddeg pabrodmac lucnovdos dancorgar *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim manmorjim1 *)
lemma estaEn_borraDuplicados2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* anaprarod *)
lemma estaEn_borraDuplicados3:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs, simp_all, blast)

(* anaprarod *)
lemma estaEn_borraDuplicados4:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply (cases "estaEn x xs")
apply (simp_all)
apply blast
done

(* bowma *)
lemma estaEn_borraDuplicados5:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply simp
apply (simp, blast)
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
---------------------------------------------------------------------
*}

(* 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

(* anaprarod marpoldia1 ferrenseg juacabsou *)
lemma estaEn_borraDuplicados_2b:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) =
estaEn a (borraDuplicados xs)" by simp
also have "...= estaEn a xs" using HI by simp
finally show "?P (x#xs)" by auto
next
assume "¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) =
estaEn a (x#borraDuplicados xs)" by simp
also have "...= (x = a ∨ estaEn a (borraDuplicados xs))" by simp
finally show "?P (x#xs)" using HI by simp
qed
qed

(* migtermor *)
lemma estaEn_borraDuplicados_2c:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix aa xs
assume HI: "?P xs"
have P1: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
proof (cases)
assume C1: "(estaEn aa xs)"
have "estaEn a (borraDuplicados (aa#xs)) =
estaEn a (borraDuplicados xs)"
using C1 by simp
also have P3: "… = estaEn a xs" using HI by simp
also have "… = estaEn a (aa#xs)"
proof (cases)
assume "(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" using C1 by simp
next
assume "¬(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" by simp
qed
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
using P3 by simp
next
assume C2: "¬(estaEn aa xs)"
then show "estaEn a (borraDuplicados (aa#xs)) =
estaEn a (aa#xs)" using HI by simp
qed
also have Conc: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
using P1 by simp
finally show "?P (aa#xs)" using Conc by simp
qed

(* crigomgom paupeddeg pabrodmac*)
lemma estaEn_borraDuplicados_2d:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI)
assume a1: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados xs)" using a1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (x#xs)" by simp
next
assume "¬ estaEn x xs"
then have "estaEn a (x#(borraDuplicados xs))" using a1 by simp
then have " x=a ∨ (estaEn a (borraDuplicados xs))" by simp
then have " x=a ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (x#xs)" by simp
qed
next
assume a2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by simp
next
assume b1: "a≠x"
then have "estaEn a (x#xs)" using a2 by simp
then have "x = a ∨ estaEn a xs" by simp
then have "estaEn a xs " using b1 by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (x#xs))" using b1 by simp
qed
qed
qed

(* rubgonmar *)
lemma estaEn_borraDuplicados_2e:
"estaEn a ( borraDuplicados xs ) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x
fix xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI) (* usamos proof de la regla dada iffI*)
assume cprim: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
next
assume "¬ estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
qed
next
assume cseg: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by auto
next
assume "a≠x"
then show "estaEn a (borraDuplicados (x#xs))" using `a≠x`
cseg HI by simp
qed
qed
qed

(*
Aplico la regla iffI:
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
Así:
[estaEn a (borraDuplicados (x # xs))
⟹ estaEn a (x # xs); estaEn a (x # xs)
⟹ estaEn a (borraDuplicados (x # xs))]
⟹ estaEn a (borraDuplicados (x # xs)) = estaEn a (x # xs)
*)

(* bowma ivamenjim *)
lemma estaEn_borraDuplicados_2f:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?p xs")
proof (induct xs)
show "?p []" by simp
next
fix x xs
assume HI: "?p xs"
show "?p (x#xs)"
proof (cases)
assume H1:"estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) =
estaEn a (borraDuplicados xs)" by simp
also have "... = estaEn a xs" using HI by simp
also have "... = estaEn a (x#xs)"
proof(cases)
assume "x=a"
then show "estaEn a xs = estaEn a (x#xs)" using H1 by simp
next
assume "x≠a"
then show "estaEn a xs = estaEn a (x#xs)" by simp
qed
finally show "?p (x#xs)" by simp
next
assume H2:"¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) =
estaEn a (x#borraDuplicados xs)" by simp
also have "... = ((x=a) ∨ estaEn a (borraDuplicados xs))" by simp
also have "... = ((x=a) ∨ estaEn a xs)" using HI by simp
also have "... = estaEn a (x#xs)" by simp
finally show "?p (x#xs)" by simp
qed

(* danrodcha *)
(* es como la de ruben pero con diferencias de estilo *)
lemma estaEn_borraDuplicados_2g:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (x # xs))"
show "estaEn a (x#xs)"
proof (cases "estaEn x xs")
case True
then show "estaEn a (x#xs)" using H1 HI by simp
next
case False
then show "estaEn a (x#xs)" using H1 HI by simp
qed
next
assume H2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x # xs))"
proof (cases "x=a")
case True
then show "estaEn a (borraDuplicados (x # xs))" using HI by simp
next
case False
then show "estaEn a (borraDuplicados (x # xs))" using H2 HI
by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

(* ivamenjim wilmorort serrodcal crigomgom anaprarod fraortmoy
marpoldia1 ferrenseg danrodcha juacabsou paupeddeg josgarsan pabrodmac dancorgar *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

(* migtermor bowma *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs, simp_all add: estaEn_borraDuplicados_2)

(* manmorjim1 no caí en usar la demostración anterior y he realizado
la demostración de que si un elemento no estaba en una lista seguirá sin estar
después de eliminar los duplicados en esa lista... *)
lemma noEsta_tras_borrarDuplicados:
"(¬estaEn x xs) ⟶ (¬estaEn x (borraDuplicados xs))"
apply (induct xs)
apply auto
done

lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
apply (induct xs)
apply simp
apply (induct xs)
apply auto
apply (simp add: noEsta_tras_borrarDuplicados)
done

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

(* ivamenjim migtermor crigomgom rubgonmar fraortmoy marpoldia1 ferrenseg bowma juacabsou serrodcal josgarsan pabrodmac dancorgar *)

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 show "sinDuplicados (borraDuplicados (a # xs))" using HI by (simp add: estaEn_borraDuplicados)
qed
qed

(* anaprarod paupeddeg*)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume c1: "estaEn x xs"
then show "sinDuplicados (borraDuplicados (x#xs))" using HI by simp
next
assume c2: "¬ estaEn x xs"
then have "sinDuplicados (borraDuplicados (x#xs)) =sinDuplicados (x#borraDuplicados xs)" by simp
also have "…= (¬estaEn x (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs))" by simp
also have "… = (¬estaEn x (borraDuplicados xs))" using HI by simp
also have "… = (¬(estaEn x xs))" by (simp add:estaEn_borraDuplicados)
also have "… = True" using c2 by simp
finally show "?P (x#xs)" by simp
qed
qed

(* danrodcha *)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (cases "estaEn x xs")
case True
then have 1: "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (borraDuplicados xs)" by (simp add: estaEn_borraDuplicados_2)
show "?P (x#xs)" using HI 1 by simp
next
case False
then have "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (x#borraDuplicados xs)" by simp
also have "… = (¬ (estaEn x (borraDuplicados xs)) ∧
sinDuplicados (borraDuplicados xs))" by simp
also have "… = True" using `¬ estaEn x xs` HI by (simp add:estaEn_borraDuplicados)
finally show "?P (x#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort pablucoto migtermor
anaprarod fraortmoy ferrenseg marpoldia1 bowma danrodcha juacabsou paupeddeg manmorjim1 serrodcal josgarsan pabrodmac lucnovdos dancorgar *)
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-30T18:34:57Z

Fracorjim1:

<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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1
danrodcha manmorjim1 *)
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, ferrenseg josgarsan juacabsou dancorgar pabrodmac lucnovdos fracorjim1*)
(* 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 pablucoto
serrodcal anaprarod migtermor paupeddeg fraortmoy marpoldia1
ferrenseg josgarsan danrodcha manmorjim1 juacabsou dancorgar pabrodmac lucnovdos*)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"

(* fracorjim1 - La versión anterior no prueba el segundo enunciado. La que propongo demuestra ambos. *)

fun sinDuplicados1 :: "'a list ⇒ bool" where
"sinDuplicados1 [] = True"
| "sinDuplicados1 (x#xs) = (¬(estaEn x xs ∧ sinDuplicados xs))"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

(* paupeddeg *)
(* Utilizando la función ∉ de Isabelle *)
fun sinDuplicados2 :: "'a list ⇒ bool" where
"sinDuplicados2 [] = True"
| "sinDuplicados2 (a#xs) = ((a ∉ set xs) ∧ sinDuplicados2 xs ) "

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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1 ferrenseg
josgarsan danrodcha juacabsou dancorgar manmorjim1 pabrodmac lucnovdos*)
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)"

(* rubgonmar *)
(* Otra forma Sin usar if
Utilizando case aunque se le sacaría más partido con más de 2 casos *)

fun borraDuplicados1 :: "'a list ⇒ 'a list" where
"borraDuplicados1 [] = []" |
"borraDuplicados1 (x#xs) = ( case estaEn x xs of False => x#borraDuplicados1 xs | True => borraDuplicados1 xs )"

(* rubgonmar *)
(*Otra forma utilizando let*)
fun borraDuplicados2 :: "'a list ⇒ 'a list" where
"borraDuplicados2 [] = []" |
"borraDuplicados2 (x#xs) = (let condicion = estaEn x xs::bool in
if condicion then borraDuplicados2 xs else x # borraDuplicados2 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 anaprarod ferrenseg*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort pablucoto serrodcal migtermor paupeddeg
fraortmoy marpoldia1 danrodcha juacabsou dancorgar josgarsan pabrodmac lucnovdos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* manmorjim1 *)
(* soy de ponerlo mejor por pasos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
apply (induct xs)
apply auto
done

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

(* bowma anaprarod *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply (simp, simp) (* creo que es mejor poner aquí simp_all *)
done

(* ferrenseg *)

lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) simp_all (* Creo que se puede poner simp_all fuera de parentesis *)

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 ferrenseg rubgonmar juacabsou dancorgar josgarsan lucnovdos*)
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

(* serrodcal anaprarod danrodcha *)
lemma length_borraDuplicados_2: "length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "?P (a # xs)" by simp
qed

(* pablucoto *)
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
also have "... ≤ length (a#xs)" by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs) " by simp
qed

(* bowma *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?p xs")
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "?p xs"
have c1:"1+length xs = length (a#xs)" by simp
also have "length(borraDuplicados (a#xs)) ≤ 1 + length(borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
then show "length(borraDuplicados (a#xs)) ≤ length (a#xs)" using c1 by simp
(* ¿Aquí porqué no puedo usar "finally show "?p (a # xs)" using c1 by simp?
Y porque no puedo añadir "finally show *) "?p (a # xs)" by simp al final? *)
qed

(* migtermor *)

lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
proof (cases)
assume "(estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
next
assume "¬ (estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = 1+ length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
qed
then show "?P (a#xs)" by simp
qed

(* paupeddeg marpoldia1 pabrodmac*)
lemma length_borraDuplicados_4:
"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)) ≤ length [a] + length (borraDuplicados xs) " by simp
also have "... ≤ 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

(* fraortmoy *)
(* muy parecida a alguna anterior, pero yo dí mas pasos *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume H1: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ length(borraDuplicados [a])+length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length xs" using H1 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 pablucoto serrodcal bowma
migtermor fraortmoy marpoldia1 ferrenseg danrodcha juacabsou paupeddeg pabrodmac lucnovdos*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim manmorjim1 *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* anaprarod *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs, simp_all, blast)

(* anaprarod *)
lemma estaEn_borraDuplicados':
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply (cases "estaEn x xs")
apply (simp_all)
apply blast
done

(* bowma *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply simp
apply (simp, blast)
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

(* anaprarod marpoldia1 ferrenseg juacabsou *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "...= estaEn a xs" using HI by simp
finally show "?P (x#xs)" by auto
next
assume "¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "...= (x = a ∨ estaEn a (borraDuplicados xs))" by simp
finally show "?P (x#xs)" using HI by simp
qed
qed

(* migtermor *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix aa xs
assume HI: "?P xs"
have P1: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
proof (cases)
assume C1: "(estaEn aa xs)"
have "estaEn a (borraDuplicados (aa#xs)) = estaEn a (borraDuplicados xs)"
using C1 by simp
also have P3: "… = estaEn a xs" using HI by simp
also have "… = estaEn a (aa#xs)"
proof (cases)
assume "(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" using C1 by simp
next
assume "¬(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" by simp
qed
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P3 by simp
next
assume C2: "¬(estaEn aa xs)"
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using HI by simp
qed
also have Conc: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P1 by simp
finally show "?P (aa#xs)" using Conc by simp
qed

(* crigomgom paupeddeg pabrodmac*)
-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI)
assume a1: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados xs)" using a1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (x#xs)" by simp
next
assume "¬ estaEn x xs"
then have "estaEn a (x#(borraDuplicados xs))" using a1 by simp
then have " x=a ∨ (estaEn a (borraDuplicados xs))" by simp
then have " x=a ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (x#xs)" by simp
qed
next
assume a2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by simp
next
assume b1: "a≠x"
then have "estaEn a (x#xs)" using a2 by simp
then have "x = a ∨ estaEn a xs" by simp
then have "estaEn a xs " using b1 by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (x#xs))" using b1 by simp
qed
qed
qed

(* rubgonmar *)
lemma estaEn_borraDuplicados_2:
"estaEn a ( borraDuplicados xs ) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x
fix xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI) (* usamos proof de la regla dada iffI*)
assume cprim: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
next
assume "¬ estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
qed
next
assume cseg: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by auto
next
assume "a≠x"
then show "estaEn a (borraDuplicados (x#xs))" using `a≠x` cseg HI by simp
qed
qed
qed

(*
Aplico la regla iffI:
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
Así:
[estaEn a (borraDuplicados (x # xs)) ⟹ estaEn a (x # xs); estaEn a (x # xs) ⟹ estaEn a (borraDuplicados (x # xs))]
⟹ estaEn a (borraDuplicados (x # xs)) = estaEn a (x # xs)
*)

(* bowma ivamenjim *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?p xs")
proof (induct xs)
show "?p []" by simp
next
fix x xs
assume HI: "?p xs"
show "?p (x#xs)"
proof (cases)
assume H1:"estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "... = estaEn a xs" using HI by simp
also have "... = estaEn a (x#xs)"
proof(cases)
assume "x=a"
then show "estaEn a xs = estaEn a (x#xs)" using H1 by simp
next
assume "x≠a"
then show "estaEn a xs = estaEn a (x#xs)" by simp
qed
finally show "?p (x#xs)" by simp
next
assume H2:"¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "... = ((x=a) ∨ estaEn a (borraDuplicados xs))" by simp
also have "... = ((x=a) ∨ estaEn a xs)" using HI by simp
also have "... = estaEn a (x#xs)" by simp
finally show "?p (x#xs)" by simp
qed

(*danrodcha *)
(* es como la de ruben pero con diferencias de estilo *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (x # xs))"
show "estaEn a (x#xs)"
proof (cases "estaEn x xs")
case True
then show "estaEn a (x#xs)" using H1 HI by simp
next
case False
then show "estaEn a (x#xs)" using H1 HI by simp
qed
next
assume H2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x # xs))"
proof (cases "x=a")
case True
then show "estaEn a (borraDuplicados (x # xs))" using HI by simp
next
case False
then show "estaEn a (borraDuplicados (x # xs))" using H2 HI by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort serrodcal crigomgom anaprarod fraortmoy
marpoldia1 ferrenseg danrodcha juacabsou paupeddeg josgarsan pabrodmac *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

(* migtermor bowma *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs, simp_all add: estaEn_borraDuplicados_2)

(* manmorjim1 no caí en usar la demostración anterior y he realizado
la demostración de que si un elemento no estaba en una lista seguirá sin estar
después de eliminar los duplicados en esa lista... *)
lemma noEsta_tras_borrarDuplicados:
"(¬estaEn x xs) ⟶ (¬estaEn x (borraDuplicados xs))"
apply (induct xs)
apply auto
done

lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
apply (induct xs)
apply simp
apply (induct xs)
apply auto
apply (simp add: noEsta_tras_borrarDuplicados)
done

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

(* ivamenjim migtermor crigomgom rubgonmar fraortmoy marpoldia1 ferrenseg bowma juacabsou serrodcal josgarsan pabrodmac*)

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 show "sinDuplicados (borraDuplicados (a # xs))" using HI by (simp add: estaEn_borraDuplicados)
qed
qed

(* anaprarod paupeddeg*)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume c1: "estaEn x xs"
then show "sinDuplicados (borraDuplicados (x#xs))" using HI by simp
next
assume c2: "¬ estaEn x xs"
then have "sinDuplicados (borraDuplicados (x#xs)) =sinDuplicados (x#borraDuplicados xs)" by simp
also have "…= (¬estaEn x (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs))" by simp
also have "… = (¬estaEn x (borraDuplicados xs))" using HI by simp
also have "… = (¬(estaEn x xs))" by (simp add:estaEn_borraDuplicados)
also have "… = True" using c2 by simp
finally show "?P (x#xs)" by simp
qed
qed

(* danrodcha *)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (cases "estaEn x xs")
case True
then have 1: "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (borraDuplicados xs)" by (simp add: estaEn_borraDuplicados_2)
show "?P (x#xs)" using HI 1 by simp
next
case False
then have "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (x#borraDuplicados xs)" by simp
also have "… = (¬ (estaEn x (borraDuplicados xs)) ∧
sinDuplicados (borraDuplicados xs))" by simp
also have "… = True" using `¬ estaEn x xs` HI by (simp add:estaEn_borraDuplicados)
finally show "?P (x#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort pablucoto migtermor
anaprarod fraortmoy ferrenseg marpoldia1 bowma danrodcha juacabsou paupeddeg manmorjim1 serrodcal josgarsan pabrodmac lucnovdos*)
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-30T18:34:10Z

Fracorjim1:

<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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1
danrodcha manmorjim1 *)
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, ferrenseg josgarsan juacabsou dancorgar pabrodmac lucnovdos fracorjim1*)
(* 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 pablucoto
serrodcal anaprarod migtermor paupeddeg fraortmoy marpoldia1
ferrenseg josgarsan danrodcha manmorjim1 juacabsou dancorgar pabrodmac lucnovdos*)
fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬ estaEn x xs ∧ sinDuplicados xs)"
(* fracorjim1 - La versión anterior no prueba el segundo enunciado. La que propongo demuestra ambos. *)

fun sinDuplicados1 :: "'a list ⇒ bool" where
"sinDuplicados1 [] = True"
| "sinDuplicados1 (x#xs) = (¬(estaEn x xs ∧ sinDuplicados xs))"

value "sinDuplicados [1::nat,4,2] = True"
value "sinDuplicados [1::nat,4,2,4] = False"

(* paupeddeg *)
(* Utilizando la función ∉ de Isabelle *)
fun sinDuplicados2 :: "'a list ⇒ bool" where
"sinDuplicados2 [] = True"
| "sinDuplicados2 (a#xs) = ((a ∉ set xs) ∧ sinDuplicados2 xs ) "

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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1 ferrenseg
josgarsan danrodcha juacabsou dancorgar manmorjim1 pabrodmac lucnovdos*)
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)"

(* rubgonmar *)
(* Otra forma Sin usar if
Utilizando case aunque se le sacaría más partido con más de 2 casos *)

fun borraDuplicados1 :: "'a list ⇒ 'a list" where
"borraDuplicados1 [] = []" |
"borraDuplicados1 (x#xs) = ( case estaEn x xs of False => x#borraDuplicados1 xs | True => borraDuplicados1 xs )"

(* rubgonmar *)
(*Otra forma utilizando let*)
fun borraDuplicados2 :: "'a list ⇒ 'a list" where
"borraDuplicados2 [] = []" |
"borraDuplicados2 (x#xs) = (let condicion = estaEn x xs::bool in
if condicion then borraDuplicados2 xs else x # borraDuplicados2 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 anaprarod ferrenseg*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort pablucoto serrodcal migtermor paupeddeg
fraortmoy marpoldia1 danrodcha juacabsou dancorgar josgarsan pabrodmac lucnovdos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* manmorjim1 *)
(* soy de ponerlo mejor por pasos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
apply (induct xs)
apply auto
done

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

(* bowma anaprarod *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply (simp, simp) (* creo que es mejor poner aquí simp_all *)
done

(* ferrenseg *)

lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) simp_all (* Creo que se puede poner simp_all fuera de parentesis *)

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 ferrenseg rubgonmar juacabsou dancorgar josgarsan lucnovdos*)
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

(* serrodcal anaprarod danrodcha *)
lemma length_borraDuplicados_2: "length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "?P (a # xs)" by simp
qed

(* pablucoto *)
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
also have "... ≤ length (a#xs)" by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs) " by simp
qed

(* bowma *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?p xs")
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "?p xs"
have c1:"1+length xs = length (a#xs)" by simp
also have "length(borraDuplicados (a#xs)) ≤ 1 + length(borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
then show "length(borraDuplicados (a#xs)) ≤ length (a#xs)" using c1 by simp
(* ¿Aquí porqué no puedo usar "finally show "?p (a # xs)" using c1 by simp?
Y porque no puedo añadir "finally show *) "?p (a # xs)" by simp al final? *)
qed

(* migtermor *)

lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
proof (cases)
assume "(estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
next
assume "¬ (estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = 1+ length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
qed
then show "?P (a#xs)" by simp
qed

(* paupeddeg marpoldia1 pabrodmac*)
lemma length_borraDuplicados_4:
"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)) ≤ length [a] + length (borraDuplicados xs) " by simp
also have "... ≤ 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

(* fraortmoy *)
(* muy parecida a alguna anterior, pero yo dí mas pasos *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume H1: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ length(borraDuplicados [a])+length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length xs" using H1 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 pablucoto serrodcal bowma
migtermor fraortmoy marpoldia1 ferrenseg danrodcha juacabsou paupeddeg pabrodmac lucnovdos*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim manmorjim1 *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* anaprarod *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs, simp_all, blast)

(* anaprarod *)
lemma estaEn_borraDuplicados':
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply (cases "estaEn x xs")
apply (simp_all)
apply blast
done

(* bowma *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply simp
apply (simp, blast)
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

(* anaprarod marpoldia1 ferrenseg juacabsou *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "...= estaEn a xs" using HI by simp
finally show "?P (x#xs)" by auto
next
assume "¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "...= (x = a ∨ estaEn a (borraDuplicados xs))" by simp
finally show "?P (x#xs)" using HI by simp
qed
qed

(* migtermor *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix aa xs
assume HI: "?P xs"
have P1: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
proof (cases)
assume C1: "(estaEn aa xs)"
have "estaEn a (borraDuplicados (aa#xs)) = estaEn a (borraDuplicados xs)"
using C1 by simp
also have P3: "… = estaEn a xs" using HI by simp
also have "… = estaEn a (aa#xs)"
proof (cases)
assume "(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" using C1 by simp
next
assume "¬(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" by simp
qed
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P3 by simp
next
assume C2: "¬(estaEn aa xs)"
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using HI by simp
qed
also have Conc: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P1 by simp
finally show "?P (aa#xs)" using Conc by simp
qed

(* crigomgom paupeddeg pabrodmac*)
-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI)
assume a1: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados xs)" using a1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (x#xs)" by simp
next
assume "¬ estaEn x xs"
then have "estaEn a (x#(borraDuplicados xs))" using a1 by simp
then have " x=a ∨ (estaEn a (borraDuplicados xs))" by simp
then have " x=a ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (x#xs)" by simp
qed
next
assume a2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by simp
next
assume b1: "a≠x"
then have "estaEn a (x#xs)" using a2 by simp
then have "x = a ∨ estaEn a xs" by simp
then have "estaEn a xs " using b1 by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (x#xs))" using b1 by simp
qed
qed
qed

(* rubgonmar *)
lemma estaEn_borraDuplicados_2:
"estaEn a ( borraDuplicados xs ) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x
fix xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI) (* usamos proof de la regla dada iffI*)
assume cprim: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
next
assume "¬ estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
qed
next
assume cseg: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by auto
next
assume "a≠x"
then show "estaEn a (borraDuplicados (x#xs))" using `a≠x` cseg HI by simp
qed
qed
qed

(*
Aplico la regla iffI:
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
Así:
[estaEn a (borraDuplicados (x # xs)) ⟹ estaEn a (x # xs); estaEn a (x # xs) ⟹ estaEn a (borraDuplicados (x # xs))]
⟹ estaEn a (borraDuplicados (x # xs)) = estaEn a (x # xs)
*)

(* bowma ivamenjim *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?p xs")
proof (induct xs)
show "?p []" by simp
next
fix x xs
assume HI: "?p xs"
show "?p (x#xs)"
proof (cases)
assume H1:"estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "... = estaEn a xs" using HI by simp
also have "... = estaEn a (x#xs)"
proof(cases)
assume "x=a"
then show "estaEn a xs = estaEn a (x#xs)" using H1 by simp
next
assume "x≠a"
then show "estaEn a xs = estaEn a (x#xs)" by simp
qed
finally show "?p (x#xs)" by simp
next
assume H2:"¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "... = ((x=a) ∨ estaEn a (borraDuplicados xs))" by simp
also have "... = ((x=a) ∨ estaEn a xs)" using HI by simp
also have "... = estaEn a (x#xs)" by simp
finally show "?p (x#xs)" by simp
qed

(*danrodcha *)
(* es como la de ruben pero con diferencias de estilo *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (x # xs))"
show "estaEn a (x#xs)"
proof (cases "estaEn x xs")
case True
then show "estaEn a (x#xs)" using H1 HI by simp
next
case False
then show "estaEn a (x#xs)" using H1 HI by simp
qed
next
assume H2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x # xs))"
proof (cases "x=a")
case True
then show "estaEn a (borraDuplicados (x # xs))" using HI by simp
next
case False
then show "estaEn a (borraDuplicados (x # xs))" using H2 HI by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort serrodcal crigomgom anaprarod fraortmoy
marpoldia1 ferrenseg danrodcha juacabsou paupeddeg josgarsan pabrodmac *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

(* migtermor bowma *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs, simp_all add: estaEn_borraDuplicados_2)

(* manmorjim1 no caí en usar la demostración anterior y he realizado
la demostración de que si un elemento no estaba en una lista seguirá sin estar
después de eliminar los duplicados en esa lista... *)
lemma noEsta_tras_borrarDuplicados:
"(¬estaEn x xs) ⟶ (¬estaEn x (borraDuplicados xs))"
apply (induct xs)
apply auto
done

lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
apply (induct xs)
apply simp
apply (induct xs)
apply auto
apply (simp add: noEsta_tras_borrarDuplicados)
done

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

(* ivamenjim migtermor crigomgom rubgonmar fraortmoy marpoldia1 ferrenseg bowma juacabsou serrodcal josgarsan pabrodmac*)

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 show "sinDuplicados (borraDuplicados (a # xs))" using HI by (simp add: estaEn_borraDuplicados)
qed
qed

(* anaprarod paupeddeg*)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume c1: "estaEn x xs"
then show "sinDuplicados (borraDuplicados (x#xs))" using HI by simp
next
assume c2: "¬ estaEn x xs"
then have "sinDuplicados (borraDuplicados (x#xs)) =sinDuplicados (x#borraDuplicados xs)" by simp
also have "…= (¬estaEn x (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs))" by simp
also have "… = (¬estaEn x (borraDuplicados xs))" using HI by simp
also have "… = (¬(estaEn x xs))" by (simp add:estaEn_borraDuplicados)
also have "… = True" using c2 by simp
finally show "?P (x#xs)" by simp
qed
qed

(* danrodcha *)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (cases "estaEn x xs")
case True
then have 1: "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (borraDuplicados xs)" by (simp add: estaEn_borraDuplicados_2)
show "?P (x#xs)" using HI 1 by simp
next
case False
then have "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (x#borraDuplicados xs)" by simp
also have "… = (¬ (estaEn x (borraDuplicados xs)) ∧
sinDuplicados (borraDuplicados xs))" by simp
also have "… = True" using `¬ estaEn x xs` HI by (simp add:estaEn_borraDuplicados)
finally show "?P (x#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort pablucoto migtermor
anaprarod fraortmoy ferrenseg marpoldia1 bowma danrodcha juacabsou paupeddeg manmorjim1 serrodcal josgarsan pabrodmac lucnovdos*)
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-30T18:19:39Z

Fracorjim1:

<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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1
danrodcha manmorjim1 *)
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, ferrenseg josgarsan juacabsou dancorgar pabrodmac lucnovdos fracorjim1*)
(* 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 pablucoto
serrodcal anaprarod migtermor paupeddeg fraortmoy marpoldia1
ferrenseg josgarsan danrodcha manmorjim1 juacabsou dancorgar pabrodmac lucnovdos*)
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"

(* paupeddeg *)
(* Utilizando la función ∉ de Isabelle *)
fun sinDuplicados2 :: "'a list ⇒ bool" where
"sinDuplicados2 [] = True"
| "sinDuplicados2 (a#xs) = ((a ∉ set xs) ∧ sinDuplicados2 xs ) "

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 pablucoto serrodcal
anaprarod migtermor paupeddeg fraortmoy marpoldia1 ferrenseg
josgarsan danrodcha juacabsou dancorgar manmorjim1 pabrodmac lucnovdos*)
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)"

(* rubgonmar *)
(* Otra forma Sin usar if
Utilizando case aunque se le sacaría más partido con más de 2 casos *)

fun borraDuplicados1 :: "'a list ⇒ 'a list" where
"borraDuplicados1 [] = []" |
"borraDuplicados1 (x#xs) = ( case estaEn x xs of False => x#borraDuplicados1 xs | True => borraDuplicados1 xs )"

(* rubgonmar *)
(*Otra forma utilizando let*)
fun borraDuplicados2 :: "'a list ⇒ 'a list" where
"borraDuplicados2 [] = []" |
"borraDuplicados2 (x#xs) = (let condicion = estaEn x xs::bool in
if condicion then borraDuplicados2 xs else x # borraDuplicados2 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 anaprarod ferrenseg*)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs, simp_all)

(* rubgonmar wilmorort pablucoto serrodcal migtermor paupeddeg
fraortmoy marpoldia1 danrodcha juacabsou dancorgar josgarsan pabrodmac lucnovdos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
by (induct xs) auto

(* manmorjim1 *)
(* soy de ponerlo mejor por pasos *)
lemma length_borraDuplicados:
"length ( borraDuplicados xs ) ≤ length xs"
apply (induct xs)
apply auto
done

(* ivamenjim *)
(* Demostrando objetivo a objetivo *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply simp
apply auto
done

(* bowma anaprarod *)
lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
apply (induct xs)
apply (simp, simp) (* creo que es mejor poner aquí simp_all *)
done

(* ferrenseg *)

lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) simp_all (* Creo que se puede poner simp_all fuera de parentesis *)

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 ferrenseg rubgonmar juacabsou dancorgar josgarsan lucnovdos*)
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

(* serrodcal anaprarod danrodcha *)
lemma length_borraDuplicados_2: "length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a # xs)) ≤ 1+length (borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
finally show "?P (a # xs)" by simp
qed

(* pablucoto *)
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
also have "... ≤ length (a#xs)" by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs) " by simp
qed

(* bowma *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?p xs")
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI: "?p xs"
have c1:"1+length xs = length (a#xs)" by simp
also have "length(borraDuplicados (a#xs)) ≤ 1 + length(borraDuplicados xs)" by simp
also have "... ≤ 1+length xs" using HI by simp
then show "length(borraDuplicados (a#xs)) ≤ length (a#xs)" using c1 by simp
(* ¿Aquí porqué no puedo usar "finally show "?p (a # xs)" using c1 by simp?
Y porque no puedo añadir "finally show *) "?p (a # xs)" by simp al final? *)
qed

(* migtermor *)

lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (borraDuplicados (a#xs)) ≤ (length (a#xs))"
proof (cases)
assume "(estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
next
assume "¬ (estaEn a xs)"
then have Aux: "length (borraDuplicados (a#xs)) = 1+ length (borraDuplicados xs)" by simp
also have "… ≤ length (a#xs)" using HI by simp
then show "length (borraDuplicados (a#xs)) ≤ (length (a#xs))" using Aux by simp
qed
then show "?P (a#xs)" by simp
qed

(* paupeddeg marpoldia1 pabrodmac*)
lemma length_borraDuplicados_4:
"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)) ≤ length [a] + length (borraDuplicados xs) " by simp
also have "... ≤ 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

(* fraortmoy *)
(* muy parecida a alguna anterior, pero yo dí mas pasos *)
lemma length_borraDuplicados_2:
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume H1: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ length(borraDuplicados [a])+length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length (borraDuplicados xs)" by simp
also have "… ≤ 1 + length xs" using H1 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 pablucoto serrodcal bowma
migtermor fraortmoy marpoldia1 ferrenseg danrodcha juacabsou paupeddeg pabrodmac lucnovdos*)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

(* ivamenjim manmorjim1 *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply auto
done

(* anaprarod *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs, simp_all, blast)

(* anaprarod *)
lemma estaEn_borraDuplicados':
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply (cases "estaEn x xs")
apply (simp_all)
apply blast
done

(* bowma *)
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados xs) = estaEn a xs"
apply (induct xs)
apply simp
apply (simp, blast)
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

(* anaprarod marpoldia1 ferrenseg juacabsou *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "...= estaEn a xs" using HI by simp
finally show "?P (x#xs)" by auto
next
assume "¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "...= (x = a ∨ estaEn a (borraDuplicados xs))" by simp
finally show "?P (x#xs)" using HI by simp
qed
qed

(* migtermor *)

lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix aa xs
assume HI: "?P xs"
have P1: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)"
proof (cases)
assume C1: "(estaEn aa xs)"
have "estaEn a (borraDuplicados (aa#xs)) = estaEn a (borraDuplicados xs)"
using C1 by simp
also have P3: "… = estaEn a xs" using HI by simp
also have "… = estaEn a (aa#xs)"
proof (cases)
assume "(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" using C1 by simp
next
assume "¬(a=aa)"
then show "estaEn a xs = estaEn a (aa#xs)" by simp
qed
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P3 by simp
next
assume C2: "¬(estaEn aa xs)"
then show "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using HI by simp
qed
also have Conc: "estaEn a (borraDuplicados (aa#xs)) = estaEn a (aa#xs)" using P1 by simp
finally show "?P (aa#xs)" using Conc by simp
qed

(* crigomgom paupeddeg pabrodmac*)
-- "La demostración estructurada es"
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI)
assume a1: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados xs)" using a1 by simp
then have "estaEn a xs" using HI by simp
then show "estaEn a (x#xs)" by simp
next
assume "¬ estaEn x xs"
then have "estaEn a (x#(borraDuplicados xs))" using a1 by simp
then have " x=a ∨ (estaEn a (borraDuplicados xs))" by simp
then have " x=a ∨ (estaEn a xs)" using HI by simp
then show "estaEn a (x#xs)" by simp
qed
next
assume a2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by simp
next
assume b1: "a≠x"
then have "estaEn a (x#xs)" using a2 by simp
then have "x = a ∨ estaEn a xs" by simp
then have "estaEn a xs " using b1 by simp
then have "estaEn a (borraDuplicados xs)" using HI by simp
then show "estaEn a (borraDuplicados (x#xs))" using b1 by simp
qed
qed
qed

(* rubgonmar *)
lemma estaEn_borraDuplicados_2:
"estaEn a ( borraDuplicados xs ) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados []) = estaEn a []" by simp
next
fix x
fix xs
assume HI: "estaEn a (borraDuplicados xs) = estaEn a xs"
show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"
proof (rule iffI) (* usamos proof de la regla dada iffI*)
assume cprim: "estaEn a (borraDuplicados (x#xs))"
show "estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
next
assume "¬ estaEn x xs"
then show "estaEn a (x#xs)" using cprim HI by simp
qed
next
assume cseg: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x#xs))"
proof (cases)
assume "a=x"
then show "estaEn a (borraDuplicados (x#xs))" using HI by auto
next
assume "a≠x"
then show "estaEn a (borraDuplicados (x#xs))" using `a≠x` cseg HI by simp
qed
qed
qed

(*
Aplico la regla iffI:
⟦P ⟹ Q ; Q ⟹ P⟧ ⟹ P = Q
Así:
[estaEn a (borraDuplicados (x # xs)) ⟹ estaEn a (x # xs); estaEn a (x # xs) ⟹ estaEn a (borraDuplicados (x # xs))]
⟹ estaEn a (borraDuplicados (x # xs)) = estaEn a (x # xs)
*)

(* bowma ivamenjim *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?p xs")
proof (induct xs)
show "?p []" by simp
next
fix x xs
assume HI: "?p xs"
show "?p (x#xs)"
proof (cases)
assume H1:"estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (borraDuplicados xs)" by simp
also have "... = estaEn a xs" using HI by simp
also have "... = estaEn a (x#xs)"
proof(cases)
assume "x=a"
then show "estaEn a xs = estaEn a (x#xs)" using H1 by simp
next
assume "x≠a"
then show "estaEn a xs = estaEn a (x#xs)" by simp
qed
finally show "?p (x#xs)" by simp
next
assume H2:"¬estaEn x xs"
then have "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#borraDuplicados xs)" by simp
also have "... = ((x=a) ∨ estaEn a (borraDuplicados xs))" by simp
also have "... = ((x=a) ∨ estaEn a xs)" using HI by simp
also have "... = estaEn a (x#xs)" by simp
finally show "?p (x#xs)" by simp
qed

(*danrodcha *)
(* es como la de ruben pero con diferencias de estilo *)
lemma estaEn_borraDuplicados_2:
"estaEn a (borraDuplicados xs) = estaEn a xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (rule iffI)
assume H1: "estaEn a (borraDuplicados (x # xs))"
show "estaEn a (x#xs)"
proof (cases "estaEn x xs")
case True
then show "estaEn a (x#xs)" using H1 HI by simp
next
case False
then show "estaEn a (x#xs)" using H1 HI by simp
qed
next
assume H2: "estaEn a (x#xs)"
show "estaEn a (borraDuplicados (x # xs))"
proof (cases "x=a")
case True
then show "estaEn a (borraDuplicados (x # xs))" using HI by simp
next
case False
then show "estaEn a (borraDuplicados (x # xs))" using H2 HI by simp
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "La demostración automática"

(* ivamenjim wilmorort serrodcal crigomgom anaprarod fraortmoy
marpoldia1 ferrenseg danrodcha juacabsou paupeddeg josgarsan pabrodmac *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

(* migtermor bowma *)
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
by (induct xs, simp_all add: estaEn_borraDuplicados_2)

(* manmorjim1 no caí en usar la demostración anterior y he realizado
la demostración de que si un elemento no estaba en una lista seguirá sin estar
después de eliminar los duplicados en esa lista... *)
lemma noEsta_tras_borrarDuplicados:
"(¬estaEn x xs) ⟶ (¬estaEn x (borraDuplicados xs))"
apply (induct xs)
apply auto
done

lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
apply (induct xs)
apply simp
apply (induct xs)
apply auto
apply (simp add: noEsta_tras_borrarDuplicados)
done

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

(* ivamenjim migtermor crigomgom rubgonmar fraortmoy marpoldia1 ferrenseg bowma juacabsou serrodcal josgarsan pabrodmac*)

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 show "sinDuplicados (borraDuplicados (a # xs))" using HI by (simp add: estaEn_borraDuplicados)
qed
qed

(* anaprarod paupeddeg*)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
show "?P (x#xs)"
proof (cases)
assume c1: "estaEn x xs"
then show "sinDuplicados (borraDuplicados (x#xs))" using HI by simp
next
assume c2: "¬ estaEn x xs"
then have "sinDuplicados (borraDuplicados (x#xs)) =sinDuplicados (x#borraDuplicados xs)" by simp
also have "…= (¬estaEn x (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs))" by simp
also have "… = (¬estaEn x (borraDuplicados xs))" using HI by simp
also have "… = (¬(estaEn x xs))" by (simp add:estaEn_borraDuplicados)
also have "… = True" using c2 by simp
finally show "?P (x#xs)" by simp
qed
qed

(* danrodcha *)
lemma sinDuplicados_borraDuplicados_2:
"sinDuplicados (borraDuplicados xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs assume HI: "?P xs"
show "?P (x#xs)"
proof (cases "estaEn x xs")
case True
then have 1: "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (borraDuplicados xs)" by (simp add: estaEn_borraDuplicados_2)
show "?P (x#xs)" using HI 1 by simp
next
case False
then have "sinDuplicados (borraDuplicados (x#xs))
= sinDuplicados (x#borraDuplicados xs)" by simp
also have "… = (¬ (estaEn x (borraDuplicados xs)) ∧
sinDuplicados (borraDuplicados xs))" by simp
also have "… = True" using `¬ estaEn x xs` HI by (simp add:estaEn_borraDuplicados)
finally show "?P (x#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

(*crigomgom rubgonmar ivamenjim wilmorort pablucoto migtermor
anaprarod fraortmoy ferrenseg marpoldia1 bowma danrodcha juacabsou paupeddeg manmorjim1 serrodcal josgarsan pabrodmac lucnovdos*)
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-23T19:27:32Z

Fracorjim1:

<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*}
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = "todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)""

(* ivamenjim migtermor dancorgar wilmorort marpoldia1 ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1*)
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*}
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 algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (if p x then True else algunos 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 *}
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)"
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

(* 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

(* 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

(* 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
qed

(* 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 *}

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*}
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*)

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_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) = 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 *)
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

{*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
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs,simp,simp add: todos_append,auto) done

(* pablucoto * )
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) ( simp_all add: todos_append, auto)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar josgarsan pablucoto pabrodmac lucnovdos*)
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

(* 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*)
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 *)

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
---------------------------------------------------------------------
*}

lemma "algunos P (map f xs) = algunos (P o f) xs"
oops

(* 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

(* 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
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*)
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*)
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*)

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 *)

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 *}
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*)
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
---------------------------------------------------------------------
*}

lemma "algunos P (rev xs) = algunos P xs"
oops

(* 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
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 *)
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*)
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

(* 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
qed
qed

(* 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

(* wilmorort danrodcha anaprarod juacabsou*)
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*)
-- "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 *)
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 serrodcal *)

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 *)

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

{* danrodcha pablucoto anaprarod rubgonmar *}
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

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*)

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

(* 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
qed
qed

(* crigomgom paupeddeg dancorgar juacabsou serrodcal *)

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

{* 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 *)

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

(* 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

end
</source>

Relación 4

2016-11-23T19:24:54Z

Fracorjim1:

<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*}
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = "todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)""

(* ivamenjim migtermor dancorgar wilmorort marpoldia1 ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1*)
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*}
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 algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (if p x then True else algunos 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 *}
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)"
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

(* 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

(* 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

(* 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
qed

(* 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 *}

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*}
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

{* anaprarod dancorgar *}
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*)

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_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) = 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 *)
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

{*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
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs,simp,simp add: todos_append,auto) done

(* pablucoto * )
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) ( simp_all add: todos_append, auto)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar josgarsan pablucoto pabrodmac lucnovdos*)
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

(* 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*)
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 *)

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
---------------------------------------------------------------------
*}

lemma "algunos P (map f xs) = algunos (P o f) xs"
oops

(* 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

(* 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
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*)
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*)
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*)

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 *)

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 *}
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*)
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
---------------------------------------------------------------------
*}

lemma "algunos P (rev xs) = algunos P xs"
oops

(* 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
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 *)
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*)
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

(* 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
qed
qed

(* 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

(* wilmorort danrodcha anaprarod juacabsou*)
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*)
-- "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 *)
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 serrodcal *)

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 *)

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

{* danrodcha pablucoto anaprarod rubgonmar *}
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

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*)

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

(* 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
qed
qed

(* crigomgom paupeddeg dancorgar juacabsou serrodcal *)

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

{* 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 *)

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

(* 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

end
</source>

Relación 4

2016-11-23T19:20:42Z

Fracorjim1:

<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*}
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = "todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)""

(* ivamenjim migtermor dancorgar wilmorort marpoldia1 ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1*)
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*}
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 algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (if p x then True else algunos 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 fracorjim1*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

{*danrodcha*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q 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

(* 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

(* 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

(* 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
qed

(* 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 *}

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*}
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

{* anaprarod dancorgar *}
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*)

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_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) = 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 *)
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

{*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
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs,simp,simp add: todos_append,auto) done

(* pablucoto * )
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) ( simp_all add: todos_append, auto)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar josgarsan pablucoto pabrodmac lucnovdos*)
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

(* 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*)
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 *)

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
---------------------------------------------------------------------
*}

lemma "algunos P (map f xs) = algunos (P o f) xs"
oops

(* 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

(* 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
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*)
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*)
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*)

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 *)

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 *}
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*)
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
---------------------------------------------------------------------
*}

lemma "algunos P (rev xs) = algunos P xs"
oops

(* 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
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 *)
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*)
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

(* 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
qed
qed

(* 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

(* wilmorort danrodcha anaprarod juacabsou*)
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*)
-- "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 *)
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 serrodcal *)

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 *)

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

{* danrodcha pablucoto anaprarod rubgonmar *}
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

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*)

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

(* 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
qed
qed

(* crigomgom paupeddeg dancorgar juacabsou serrodcal *)

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

{* 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 *)

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

(* 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

end
</source>

Relación 4

2016-11-23T19:17:04Z

Fracorjim1:

<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*}
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = "todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)""

(* ivamenjim migtermor dancorgar wilmorort marpoldia1 ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1*)
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*}
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 algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (if p x then True else algunos 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*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

{*danrodcha*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q 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

(* 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

(* 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

(* 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
qed

(* 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 *}

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*}
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

{* anaprarod dancorgar *}
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*)

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_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) = 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 *)
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

{*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
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs,simp,simp add: todos_append,auto) done

(* pablucoto * )
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) ( simp_all add: todos_append, auto)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar josgarsan pablucoto pabrodmac lucnovdos*)
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

(* 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*)
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 *)

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
---------------------------------------------------------------------
*}

lemma "algunos P (map f xs) = algunos (P o f) xs"
oops

(* 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

(* 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
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*)
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*)
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*)

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 *)

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 *}
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*)
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
---------------------------------------------------------------------
*}

lemma "algunos P (rev xs) = algunos P xs"
oops

(* 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
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 *)
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*)
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

(* 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
qed
qed

(* 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

(* wilmorort danrodcha anaprarod juacabsou*)
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*)
-- "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 *)
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 serrodcal *)

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 *)

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

{* danrodcha pablucoto anaprarod rubgonmar *}
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

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*)

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

(* 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
qed
qed

(* crigomgom paupeddeg dancorgar juacabsou serrodcal *)

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

{* 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 *)

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

(* 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

end
</source>

Relación 4

2016-11-23T18:41:40Z

Fracorjim1:

<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*}
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = "todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)""

(* ivamenjim migtermor dancorgar wilmorort marpoldia1 ferrenseg paupeddeg pablucoto crigomgom anaprarod serrodcal juacabsou rubgonmar josgarsan fraortmoy lucnovdos pabrodmac fracorjim1*)
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*}
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (p x ∨ algunos 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*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

{*danrodcha*}
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q 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

(* 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

(* 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

(* 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
qed

(* 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 *}

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*}
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

{* anaprarod dancorgar *}
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*)

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_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) = 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 *)
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

{*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
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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)

(* juacabsou *)
lemma "todos P (rev xs) = todos P xs"
apply (induct xs,simp,simp add: todos_append,auto) done

(* pablucoto * )
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto, simp_all add: todos_append)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) ( simp_all add: todos_append, auto)

text {*
---------------------------------------------------------------------
Ejercicio 5.2. Demostrar o refutar detalladamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma "todos P (rev xs) = todos P xs"
oops

(* 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

(* marpoldia1 ferrenseg crigomgom serrodcal juacabsou rubgonmar josgarsan pablucoto pabrodmac lucnovdos*)
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

(* 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*)
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 *)

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
---------------------------------------------------------------------
*}

lemma "algunos P (map f xs) = algunos (P o f) xs"
oops

(* 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

(* 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
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*)
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*)
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*)

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 *)

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 *}
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*)
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
---------------------------------------------------------------------
*}

lemma "algunos P (rev xs) = algunos P xs"
oops

(* 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
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 *)
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*)
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

(* 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
qed
qed

(* 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

(* wilmorort danrodcha anaprarod juacabsou*)
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*)
-- "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 *)
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 serrodcal *)

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 *)

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

{* danrodcha pablucoto anaprarod rubgonmar *}
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

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*)

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

(* 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
qed
qed

(* crigomgom paupeddeg dancorgar juacabsou serrodcal *)

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

{* 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 *)

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

(* 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

end
</source>

Relación 3

2016-11-16T19:47:46Z

Fracorjim1:

<source lang="isar">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas
imports Main
begin

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

fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

-- "La demostración detallada es"
(* crigomgom fraortmoy marpoldia1 ivamenjim serrodcal rubgonmar ferrenseg juacabsou wilmorort josgarsan lucnovdos paupeddeg bowma pabrodmac dancorgar *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI: "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*danrodcha ; es la misma demostración que la anterior pero uso ?P para sustituir la propiedad.*)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "?P (Suc n)" by simp
qed

(* migtermor *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by simp
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n+1"
by (simp only: sumaImpares.simps(2))
also have "sumaImpares (Suc n) = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

(* fracorjim1 - Especifico la regla de simplificación y el paso del desarrollo al cuadrado para hacerlo más legible*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + (2 * n + 1)" by (simp only: sumaImpares.simps(2))
also have "... = n * n + 2 * n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*palucoto anaprarod marcarmor13*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have " sumaImpares (Suc n) = sumaImpares n + 2*n+1" by simp
also have "... = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

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

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(*crigomgom ivamenjim danrodcha serrodcal rubgonmar ferrenseg juacabsou wilmorort anaprarod marpoldia1 josgarsan paupeddeg pabrodmac bowma dancorgar *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)" by simp
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ ((Suc n) + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fraortmoy *)
(* es la misma demostración, pero quise probar a delimitar lo que se usa en el "by simp" *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume H1:" sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n + 1)" by (simp only : sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using H1 by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* migtermor *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "sumaPotenciasDeDosMasUno (Suc n) = 2^(n+1)+2^(n+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

(*pablucoto marcarmor13 lucnovdos*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1) " by simp
also have "... = 2^(n + 1) + 2^( n + 1) " using HI by simp
finally show " sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fracorjim1 - Hago explícita toda la manipulación algebraica. Quizás excesivo.*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induction n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2 ^ (n + 1)"
by (simp only:sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ (n + 1) * 2" by simp
also have "... = 2 ^ ((n + 1) + 1)" by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

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

fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []"
| "copia (Suc n) x = x # copia n x"

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

fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

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

(* crigomgom ivamenjim serrodcal ferrenseg wilmorort juacabsou josgarsan lucnovdos*)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y = x) (x # (copia n x))" by simp
also have "... = ((x = x) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(* fraortmoy *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y = x) (copia 0 x) = todos (λy. y = x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume H1 : " todos (λy. y = x) (copia n x) "
have "todos (λy. y = x) (copia (Suc n) x) = ((todos (λy. y = x) (x#[])) ∧ (todos (λy. y = x) (copia n x) )) " by simp
also have " ... = (todos (λy. y = x) (x#[]))" using H1 by simp
also have " ... = ((λy. y = x) x ∧ todos (λy. y = x) [])" by simp
also have " ... = True" by simp
finally show " todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(*danrodcha rubgonmar*)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
also have "... = todos (λy. y=x) (copia n x)" by simp
finally show "?P (Suc n)" using HI by simp
qed

(* migtermor *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by (simp only: copia.simps(1))
also have "todos (λy. y=x) []" by (simp only: todos.simps(1))
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # (copia n x))"
by (simp only: copia.simps(2))
also have "todos (λy. y=x) (x#(copia n x)) = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))"
by (simp only: todos.simps(2))
also have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) x)" using HI by simp
also have "((λy. y=x) x) = True" by simp
finally show "(todos (λy. y=x) (copia (Suc n) x))" by simp
qed

(*pablucoto pabrodmac marcarmor13*)

lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ( (λy. y=x) x ∧ todos (λy. y=x) (copia (Suc n) x) ) " by simp
also have "... = True" using HI by simp
finally show " todos (λy. y = x) (copia (Suc n) x) " by simp
qed

(* anaprarod marpoldia1 *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) =todos (λy. y = x) (x # copia n x)" by simp
also have "... = ((λy. y = x) x ∧ todos (λy. y = x) ( copia n x))" by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" using HI by simp
qed

(*paupeddeg*)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = (todos (λy. y = x) (x # copia n x))" by simp
also have "... = ((todos (λy. y = x) [x]) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos(λy. y = x) (copia (Suc n) x)" by simp
qed

(* dancorgar *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (x#(copia n x))" using HI by simp
also have "... = (copia (Suc n) x)" by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

(* fracorjim1 *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
finally show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI : "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x)(x # copia n x)" by (simp only: copia.simps(2))
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by (simp only: todos.simps(2))
also have "... = True ∧ True" using HI by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

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

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
| "factR (Suc n) = Suc n * factR n"

text {* ---------------------------------------------------------------
Ejercicio 4.2. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (x * Suc n)"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

(* fraortmoy , danrodcha serrodcal pablucoto wilmorort anaprarod marpoldia1 juacabsou josgarsan rubgonmar paupeddeg pabrodmac bowma fracorjim1*)
lemma fact: "factI' n x = x * factR n"
proof (induct n)
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume H1 : "factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only:factI'.simps(2))
also have "... = (x * Suc n) * factR n" using H1 by simp (* no entiendo por qué no hace esto bien y luego todo funciona *) (*Creo que es porque no le estas dando la hipótesis de inducción sino otra que se le parece*)
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

(* crigomgom ivamenjim ferrenseg marcarmor13 *)
lemma fact: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
also have "... = (x * Suc n) * factR n" using HI by simp
also have "... = x * (Suc n * factR n)" by (simp del: mult_Suc)
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

(* migtermor *)

lemma fact: "factI' n x = x * factR n"
proof (induct n)
have "x * factR 0 = x" by (simp only: factR.simps(1))
also have "factI' 0 x = x" by (simp only: factI'.simps(1))
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "∀x. factI' n x = x * factR n"
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only: factI'.simps(2))
also have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
have "factI' (Suc n) x = x * Suc n * factR n" using HI by simp
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp (* No entiendo por qué no acepta esto como demostrado *)
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

(* fraortmoy danrodcha crigomgom ivamenjim serrodcal ferrenseg pablucoto wilmorort rubgonmar marpoldia1 juacabsou josgarsan paupeddeg*)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" by (simp add: fact)
finally show "factI n = factR n" by simp
qed

(* migtermor *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factI' n 1" by simp
also have "... = 1 * factR n" using fact by simp
finally show "factI n = factR n" by simp
qed

(*pabrodmac*)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" using fact by simp
finally show "factI n = factR n" by simp
qed

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

fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]"
| "amplia (x#xs) y = x # amplia xs y"

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* crigomgom fraortmoy rubgonmar ivamenjim serrodcal pablucoto wilmorort anaprarod marpoldia1 juacabsou paupeddeg pabrodmac lucnovdos dancorgar *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # (amplia xs y)" by simp
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

(* danrodcha ferrenseg *)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "amplia (x # xs) y = x # amplia xs y" by simp
also have "... = (x # xs) @ [y]" using HI by simp
finally show "?P (x#xs)" by simp
qed

(* migtermor *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
have "[] @ [y] = [y]" by simp
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # amplia xs y" by (simp only: amplia.simps(2))
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

end
</source>

Relación 3

2016-11-16T19:26:16Z

Fracorjim1:

<source lang="isar">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas
imports Main
begin

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

fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

-- "La demostración detallada es"
(* crigomgom fraortmoy marpoldia1 ivamenjim serrodcal rubgonmar ferrenseg juacabsou wilmorort josgarsan lucnovdos paupeddeg bowma pabrodmac dancorgar *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI: "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*danrodcha ; es la misma demostración que la anterior pero uso ?P para sustituir la propiedad.*)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "?P (Suc n)" by simp
qed

(* migtermor *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by simp
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n+1"
by (simp only: sumaImpares.simps(2))
also have "sumaImpares (Suc n) = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

(* fracorjim1 - Especifico la regla de simplificación y el paso del desarrollo al cuadrado para hacerlo más legible*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + (2 * n + 1)" by (simp only: sumaImpares.simps(2))
also have "... = n * n + 2 * n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*palucoto anaprarod marcarmor13*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have " sumaImpares (Suc n) = sumaImpares n + 2*n+1" by simp
also have "... = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

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

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(*crigomgom ivamenjim danrodcha serrodcal rubgonmar ferrenseg juacabsou wilmorort anaprarod marpoldia1 josgarsan paupeddeg pabrodmac bowma dancorgar *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)" by simp
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ ((Suc n) + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fraortmoy *)
(* es la misma demostración, pero quise probar a delimitar lo que se usa en el "by simp" *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume H1:" sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n + 1)" by (simp only : sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using H1 by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* migtermor *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "sumaPotenciasDeDosMasUno (Suc n) = 2^(n+1)+2^(n+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

(*pablucoto marcarmor13 lucnovdos*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1) " by simp
also have "... = 2^(n + 1) + 2^( n + 1) " using HI by simp
finally show " sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fracorjim1 - Hago explícita toda la manipulación algebraica. Quizás excesivo.*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induction n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2 ^ (n + 1)"
by (simp only:sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ (n + 1) * 2" by simp
also have "... = 2 ^ ((n + 1) + 1)" by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

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

fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []"
| "copia (Suc n) x = x # copia n x"

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

fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

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

(* crigomgom ivamenjim serrodcal ferrenseg wilmorort juacabsou josgarsan lucnovdos*)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y = x) (x # (copia n x))" by simp
also have "... = ((x = x) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(* fraortmoy *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y = x) (copia 0 x) = todos (λy. y = x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume H1 : " todos (λy. y = x) (copia n x) "
have "todos (λy. y = x) (copia (Suc n) x) = ((todos (λy. y = x) (x#[])) ∧ (todos (λy. y = x) (copia n x) )) " by simp
also have " ... = (todos (λy. y = x) (x#[]))" using H1 by simp
also have " ... = ((λy. y = x) x ∧ todos (λy. y = x) [])" by simp
also have " ... = True" by simp
finally show " todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(*danrodcha rubgonmar*)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
also have "... = todos (λy. y=x) (copia n x)" by simp
finally show "?P (Suc n)" using HI by simp
qed

(* migtermor *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by (simp only: copia.simps(1))
also have "todos (λy. y=x) []" by (simp only: todos.simps(1))
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # (copia n x))"
by (simp only: copia.simps(2))
also have "todos (λy. y=x) (x#(copia n x)) = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))"
by (simp only: todos.simps(2))
also have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) x)" using HI by simp
also have "((λy. y=x) x) = True" by simp
finally show "(todos (λy. y=x) (copia (Suc n) x))" by simp
qed

(*pablucoto pabrodmac marcarmor13*)

lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ( (λy. y=x) x ∧ todos (λy. y=x) (copia (Suc n) x) ) " by simp
also have "... = True" using HI by simp
finally show " todos (λy. y = x) (copia (Suc n) x) " by simp
qed

(* anaprarod marpoldia1 *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) =todos (λy. y = x) (x # copia n x)" by simp
also have "... = ((λy. y = x) x ∧ todos (λy. y = x) ( copia n x))" by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" using HI by simp
qed

(*paupeddeg*)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = (todos (λy. y = x) (x # copia n x))" by simp
also have "... = ((todos (λy. y = x) [x]) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos(λy. y = x) (copia (Suc n) x)" by simp
qed

(* dancorgar *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (x#(copia n x))" using HI by simp
also have "... = (copia (Suc n) x)" by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

(* fracorjim1 *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
finally show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI : "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x)(x # copia n x)" by (simp only: copia.simps(2))
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by (simp only: todos.simps(2))
also have "... = True ∧ True" using HI by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

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

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
| "factR (Suc n) = Suc n * factR n"

text {* ---------------------------------------------------------------
Ejercicio 4.2. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (x * Suc n)"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

(* fraortmoy , danrodcha serrodcal pablucoto wilmorort anaprarod marpoldia1 juacabsou josgarsan rubgonmar paupeddeg pabrodmac bowma*)
lemma fact: "factI' n x = x * factR n"
proof (induct n)
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume H1 : "factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only:factI'.simps(2))
also have "... = (x * Suc n) * factR n" using H1 by simp (* no entiendo por qué no hace esto bien y luego todo funciona *) (*Creo que es porque no le estas dando la hipótesis de inducción sino otra que se le parece*)
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

(* crigomgom ivamenjim ferrenseg marcarmor13 *)
lemma fact: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
also have "... = (x * Suc n) * factR n" using HI by simp
also have "... = x * (Suc n * factR n)" by (simp del: mult_Suc)
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

(* migtermor *)

lemma fact: "factI' n x = x * factR n"
proof (induct n)
have "x * factR 0 = x" by (simp only: factR.simps(1))
also have "factI' 0 x = x" by (simp only: factI'.simps(1))
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "∀x. factI' n x = x * factR n"
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only: factI'.simps(2))
also have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
have "factI' (Suc n) x = x * Suc n * factR n" using HI by simp
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp (* No entiendo por qué no acepta esto como demostrado *)
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

(* fraortmoy danrodcha crigomgom ivamenjim serrodcal ferrenseg pablucoto wilmorort rubgonmar marpoldia1 juacabsou josgarsan paupeddeg*)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" by (simp add: fact)
finally show "factI n = factR n" by simp
qed

(* migtermor *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factI' n 1" by simp
also have "... = 1 * factR n" using fact by simp
finally show "factI n = factR n" by simp
qed

(*pabrodmac*)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" using fact by simp
finally show "factI n = factR n" by simp
qed

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

fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]"
| "amplia (x#xs) y = x # amplia xs y"

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* crigomgom fraortmoy rubgonmar ivamenjim serrodcal pablucoto wilmorort anaprarod marpoldia1 juacabsou paupeddeg pabrodmac lucnovdos dancorgar *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # (amplia xs y)" by simp
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

(* danrodcha ferrenseg *)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "amplia (x # xs) y = x # amplia xs y" by simp
also have "... = (x # xs) @ [y]" using HI by simp
finally show "?P (x#xs)" by simp
qed

(* migtermor *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
have "[] @ [y] = [y]" by simp
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # amplia xs y" by (simp only: amplia.simps(2))
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

end
</source>

Relación 3

2016-11-13T15:55:40Z

Fracorjim1:

<source lang="isar">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas
imports Main
begin

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

fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

-- "La demostración detallada es"
(* crigomgom fraortmoy marpoldia1 ivamenjim serrodcal *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI: "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*danrodcha ; es la misma demostración que la anterior pero uso ?P para sustituir la propiedad.*)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "?P (Suc n)" by simp
qed

(* migtermor *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by simp
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n+1"
by (simp only: sumaImpares.simps(2))
also have "sumaImpares (Suc n) = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

(* fracorjim1 - Especifico la regla de simplificación y el paso del desarrollo al cuadrado para hacerlo más legible*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + (2 * n + 1)" by (simp only: sumaImpares.simps(2))
also have "... = n * n + 2 * n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*palucoto*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have " sumaImpares (Suc n) = sumaImpares n + 2*n+1" by simp
also have "... = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

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

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(*crigomgom ivamenjim danrodcha serrodcal*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)" by simp
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ ((Suc n) + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fraortmoy *)
(* es la misma demostración, pero quise probar a delimitar lo que se usa en el "by simp" *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume H1:" sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n + 1)" by (simp only : sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using H1 by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* migtermor *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "sumaPotenciasDeDosMasUno (Suc n) = 2^(n+1)+2^(n+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

(*pablucoto*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1) " by simp
also have "... = 2^(n + 1) + 2^( n + 1) " using HI by simp
finally show " sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fracorjim1 - Hago explícita toda la manipulación algebraica. Quizás excesivo.*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induction n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2 ^ (n + 1)"
by (simp only:sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ (n + 1) * 2" by simp
also have "... = 2 ^ ((n + 1) + 1)" by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

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

fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []"
| "copia (Suc n) x = x # copia n x"

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

fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

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

(* crigomgom ivamenjim serrodcal *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y = x) (x # (copia n x))" by simp
also have "... = ((x = x) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(* fraortmoy *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y = x) (copia 0 x) = todos (λy. y = x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume H1 : " todos (λy. y = x) (copia n x) "
have "todos (λy. y = x) (copia (Suc n) x) = ((todos (λy. y = x) (x#[])) ∧ (todos (λy. y = x) (copia n x) )) " by simp
also have " ... = (todos (λy. y = x) (x#[]))" using H1 by simp
also have " ... = ((λy. y = x) x ∧ todos (λy. y = x) [])" by simp
also have " ... = True" by simp
finally show " todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(*danrodcha*)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
also have "... = todos (λy. y=x) (copia n x)" by simp
finally show "?P (Suc n)" using HI by simp
qed

(* migtermor *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by (simp only: copia.simps(1))
also have "todos (λy. y=x) []" by (simp only: todos.simps(1))
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # (copia n x))"
by (simp only: copia.simps(2))
also have "todos (λy. y=x) (x#(copia n x)) = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))"
by (simp only: todos.simps(2))
also have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) x)" using HI by simp
also have "((λy. y=x) x) = True" by simp
finally show "(todos (λy. y=x) (copia (Suc n) x))" by simp
qed

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

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
| "factR (Suc n) = Suc n * factR n"

text {* ---------------------------------------------------------------
Ejercicio 4.2. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (x * Suc n)"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

(* fraortmoy , danrodcha serrodcal*)
lemma fact: "factI' n x = x * factR n"
proof (induct n)
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume H1 : "factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only:factI'.simps(2))
also have "... = (x * Suc n) * factR n" using H1 by simp (* no entiendo por qué no hace esto bien y luego todo funciona *)
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

(* crigomgom ivamenjim *)
lemma fact: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
also have "... = (x * Suc n) * factR n" using HI by simp
also have "... = x * (Suc n * factR n)" by (simp del: mult_Suc)
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

(* fraortmoy danrodcha crigomgom ivamenjim serrodcal *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" by (simp add: fact)
finally show "factI n = factR n" by simp
qed

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

fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]"
| "amplia (x#xs) y = x # amplia xs y"

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* crigomgom fraortmoy rubgonmar ivamenjim serrodcal *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # (amplia xs y)" by simp
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

(*danrodcha*)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "amplia (x # xs) y = x # amplia xs y" by simp
also have "... = (x # xs) @ [y]" using HI by simp
finally show "?P (x#xs)" by simp
qed

end
</source>

Relación 3

2016-11-13T13:45:32Z

Fracorjim1:

<source lang="isar">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas
imports Main
begin

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

fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

-- "La demostración detallada es"
(* crigomgom fraortmoy marpoldia1 ivamenjim serrodcal *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI: "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*danrodcha ; es la misma demostración que la anterior pero uso ?P para sustituir la propiedad.*)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n + 1" by simp
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "?P (Suc n)" by simp
qed

(* migtermor *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by simp
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n+1"
by (simp only: sumaImpares.simps(2))
also have "sumaImpares (Suc n) = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

(* fracorjim1 - Especifico la regla de simplificación y el paso del desarrollo al cuadrado para hacerlo más legible*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have "sumaImpares (Suc n) = sumaImpares n + (2 * n + 1)" by (simp only: sumaImpares.simps(2))
also have "... = n * n + 2 * n + 1" using HI by simp
also have "... = Suc n * Suc n" by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

(*palucoto*)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0 * 0" by simp
next
fix n
assume HI : "sumaImpares n = n * n"
have " sumaImpares (Suc n) = sumaImpares n + 2*n+1" by simp
also have "... = n*n + 2*n+1" using HI by simp
finally show "sumaImpares (Suc n) = Suc n * Suc n" by simp
qed

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

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(*crigomgom ivamenjim danrodcha serrodcal*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)" by simp
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using HI by simp
also have "... = 2 ^ ((Suc n) + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* fraortmoy *)
(* es la misma demostración, pero quise probar a delimitar lo que se usa en el "by simp" *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume H1:" sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n + 1)" by (simp only : sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2 ^ (n + 1) + 2 ^ (n + 1)" using H1 by simp
also have "... = 2 ^ (Suc n + 1)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

(* migtermor *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "sumaPotenciasDeDosMasUno (Suc n) = 2^(n+1)+2^(n+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

(*pablucoto*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2 ^ (0 + 1)" by simp
next
fix n
assume HI : "sumaPotenciasDeDosMasUno n = 2 ^ (n + 1)"
have "sumaPotenciasDeDosMasUno (Suc n) = sumaPotenciasDeDosMasUno n + 2^(n+1) " by simp
also have "... = 2^(n + 1) + 2^( n + 1) " using HI by simp
finally show " sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)" by simp
qed

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

fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []"
| "copia (Suc n) x = x # copia n x"

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

fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x ∧ todos p xs)"

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

(* crigomgom ivamenjim serrodcal *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x) = todos (λy. y = x) (x # (copia n x))" by simp
also have "... = ((x = x) ∧ (todos (λy. y = x) (copia n x)))" by simp
also have "... = True" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(* fraortmoy *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
have "todos (λy. y = x) (copia 0 x) = todos (λy. y = x) []" by (simp only: copia.simps(1))
also have "... = True" by (simp only: todos.simps(1))
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume H1 : " todos (λy. y = x) (copia n x) "
have "todos (λy. y = x) (copia (Suc n) x) = ((todos (λy. y = x) (x#[])) ∧ (todos (λy. y = x) (copia n x) )) " by simp
also have " ... = (todos (λy. y = x) (x#[]))" using H1 by simp
also have " ... = ((λy. y = x) x ∧ todos (λy. y = x) [])" by simp
also have " ... = True" by simp
finally show " todos (λy. y = x) (copia (Suc n) x)" by simp
qed

(*danrodcha*)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
also have "... = todos (λy. y=x) (copia n x)" by simp
finally show "?P (Suc n)" using HI by simp
qed

( *migtermor* )
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # (copia n x))"
by (simp only: copia.simps(2))
also have "todos (λy. y=x) (x#(copia n x)) = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))"
by (simp only: todos.simps(2))
also have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) x)" using HI by simp
also have "((λy. y=x) x) = True" by simp
finally show "(todos (λy. y=x) (copia (Suc n) x))" by simp
qed

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

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
| "factR (Suc n) = Suc n * factR n"

text {* ---------------------------------------------------------------
Ejercicio 4.2. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (x * Suc n)"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

(* fraortmoy , danrodcha serrodcal*)
lemma fact: "factI' n x = x * factR n"
proof (induct n)
show "factI' 0 x = x * factR 0" by simp
next
fix n
assume H1 : "factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)" by (simp only:factI'.simps(2))
also have "... = (x * Suc n) * factR n" using H1 by simp (* no entiendo por qué no hace esto bien y luego todo funciona *)
also have "... = x * factR (Suc n)" by (simp del: mult_Suc)
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

(* crigomgom *)
lemma fact: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)" by simp
also have "... = (x * Suc n) * factR n" using HI by simp
also have "... = x * (Suc n * factR n)" by (simp del: mult_Suc)
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

(* fraortmoy danrodcha crigomgom ivamenjim serrodcal *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by simp
also have "... = 1 * factR n" by (simp add: fact)
finally show "factI n = factR n" by simp
qed

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

fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]"
| "amplia (x#xs) y = x # amplia xs y"

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* crigomgom fraortmoy rubgonmar ivamenjim serrodcal *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x # xs) y = x # (amplia xs y)" by simp
also have "... = x # (xs @ [y])" using HI by simp
also have "... = (x # xs) @ [y]" by simp
finally show "amplia (x # xs) y = (x # xs) @ [y]" by simp
qed

(*danrodcha*)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "amplia (x # xs) y = x # amplia xs y" by simp
also have "... = (x # xs) @ [y]" using HI by simp
finally show "?P (x#xs)" by simp
qed

end
</source>

Relación 2

2016-11-08T06:14:18Z

Fracorjim1:

<source lang="isar">
chapter {* R2: Razonamiento sobre programas en Isabelle/HOL *}

theory R2_Razonamiento_automatico_sobre_programas
imports Main
begin

declare [[names_short]]

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

(* fracorjim1 *)
fun sumaImpares0 :: "nat ⇒ nat" where
"sumaImpares0 0 = 0"
| "sumaImpares0 n = (n mod 2)*n + sumaImpares(n-1)"

value "sumaImpares0 5 = 25"

(* Comentario: Debe de definirse usando como patrones los dos
constructores de nat: 0 y Suc *)

(* ivamenjim wilmorort*)
fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares n = 2*(n-1) + 1 + sumaImpares (n-1)"

value "sumaImpares 5 = 25"

(* wilmorort *)

(*Notar: Por la propiedad de Gauss se puede deducir que:
la suma de los n números impares es igual a la suma de los
n y n-1 números consecutivos*)
fun suma :: "nat ⇒ nat" where
"suma 0 = 0"
| "suma n = n + suma(n-1)"

fun sumaImpares1 :: "nat ⇒ nat" where
"sumaImpares1 0 = 0"
| "sumaImpares1 n = suma(n) + suma(n-1)"

value "sumaImpares1 5 = 25"

(* Comentario: La definición sumaImpares1 no es recursiva y, por tanto,
no es apropiada para demostraciones por inducción.

Comentario: La definición sumaImpares1 no es recursiva pero la
demostración, está realizada por inducción, por lo tanto no se puede
concluir que: "Si una def. no es recuriva no se puede demostrar por
inducción"

Comentario: Las definiciones no recursivas no generan esquemas de
inducción.
*)

(* fraortmoy *)
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0"
| "sumaImpares2 (Suc(n)) = ((Suc(n)*2)-1) + sumaImpares2 n"

value "sumaImpares2 5 = 25"

(* anaprarod danrodcha crigomgom migtermor*)
fun sumaImpares3 :: "nat ⇒ nat" where
"sumaImpares3 0 = 0"
|"sumaImpares3 (Suc n) = (2*n +1) + (sumaImpares3 n)"

value "sumaImpares3 5 = 25"

(* manmorjim1 *)
fun sumaImpares4 :: "nat ⇒ nat" where
"sumaImpares4 0 = 0"
| "sumaImpares4 (Suc n) = (Suc (2 * n)) + (sumaImpares4 n)"

value "sumaImpares4 5 = 25"

(* pablucoto serrodcal marcarmor13 rubgonmar *)
fun sumaImpares5 :: "nat ⇒ nat" where
"sumaImpares5 0 = 0"
| "sumaImpares5 n = (2*n-1) + sumaImpares5 (n-1) "

value "sumaImpares5 5 = 25"

(* ferrenseg *)

fun sumaImpares6 :: "nat ⇒ nat" where
"sumaImpares6 0 = 0"
| "sumaImpares6 (Suc n) = (2 * (Suc n) - 1) + sumaImpares6 n"

value "sumaImpares6 5 = 25"

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

(* ivamenjim wilmorort anaprarod crigomgom manmorjim1 pablucoto
serrodcal marcarmor13 rubgonmar *)
lemma "sumaImpares n = n*n"
apply (induct n)
apply auto
done

(* wilmorort *)
(* Demostración estructurada *)

lemma aux1 : "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)"
apply (induct n)
apply auto
done

lemma aux2: "(n+1) + suma(n) + n + suma(n-1) = (n+1) + n + sumaImpares1 n "
apply (induct n)
apply auto
done

lemma "sumaImpares1 n = n*n"
proof (induct n)
show "sumaImpares1 0 = 0*0" by simp
next
fix n
assume HI:"sumaImpares1 n = n*n"
have "sumaImpares1 (Suc n) = suma(Suc n) + suma(n)" by simp
have "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)" using
"aux1" by simp
also have "... = (n+1) + n + sumaImpares1 n " using "aux2" by simp
also have "... = 2*n +1 + n*n" using HI by simp
also have "... = (n+1)*(n+1)" by simp
finally show "sumaImpares1 (Suc n) = Suc n * Suc n" by simp
qed

(* fraortmoy *)
(* La demostración para la función sumaImpares2 es la misma que la de
sumaImpares*)

lemma "sumaImpares2 n = n*n"
apply (induct n)
apply auto
done

(* danrodcha migtermor*)
lemma "sumaImpares n = n*n"
by (induct n) auto

(* danrodcha *)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

(* ferrenseg *)
lemma "sumaImpares3 n = n*n"
by (induct n) simp_all

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

(* wilmorort ivamenjim pablucoto serrodcal ferrenseg rubgonmar *)
fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno n = 2^n + sumaPotenciasDeDosMasUno (n-1)"

value "sumaPotenciasDeDosMasUno 3 = 16"

(* fraortmoy anaprarod danrodcha crigomgom migtermor manmorjim1 fracorjim1 *)
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2"
| "sumaPotenciasDeDosMasUno2 (Suc(n)) =
(2^(Suc n)) + sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3 = 16"

(* marcarmor13 *)
fun sumaPotenciasDeDosMasUno3 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno3 0 = 2"
| "sumaPotenciasDeDosMasUno3 n = 2*sumaPotenciasDeDosMasUno3 (n-1)"

value "sumaPotenciasDeDosMasUno3 3 = 16"

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

(* wilmorort ivamenjim fraortmoy anaprarod crigomgom pablucoto serrodcal manmorjim1 marcarmor13 rubgonmar *)
(* esta demostración funciona con sumaPotenciasDeDosMasUno2 *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induct n)
apply auto
done

(* danrodcha migtermor ferrenseg fracorjim1 *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) auto

(* danrodcha *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)"by simp
qed

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

(* ivamenjim wilmorort pablucoto rubgonmar *)
fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = [] "
| "copia n x = x # (copia (n-1) x)"

(* wilmorort anaprarod *)
fun copia1 :: "nat ⇒ 'a ⇒ 'a list" where
"copia1 0 x = []"
| "copia1 (Suc n) x = [x] @ (copia1 n x) "

(* Comentario: La dedinición copia1 se puede simplificar eliminando @ *)

(* danrodcha crigomgom migtermor manmorjim1 fracorjim1 *)
fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []"
| "copia2 (Suc n) x = x # copia2 n x"

(* serrodcal ferrenseg *)
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []"
| "copia3 n x = [x] @ copia3 (n-1) x"

value "copia 3 x = [x,x,x]"

(* Comentario: La definición copia3 se puede simplificar eliminando @ *)

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

(* wilmorort *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x = True ∧ todos p xs) "

(* Comentario: La definición todos se puede simplificar eliminando True
*)

value "todos (λx. x>(1::nat)) [2,6,4] = True"
value "todos (λx. x>(2::nat)) [2,6,4] = False"

(* fraortmoy anaprarod danrodcha crigomgom migtermor ivamenjim serrodcal
pablucoto ferrenseg rubgonmar *)
fun todos1 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos1 p [] = True"
| "todos1 p (x#xs) = (p x ∧ todos1 p xs )"

value "todos1 (λx. x>(1::nat)) [2,6,4] = True"
value "todos1 (λx. x>(2::nat)) [2,6,4] = False"

(* manmorjim1 *)
fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos2 p xs = ((filter p xs) = xs)"

value "todos2 (λx. x>(1::nat)) [2,6,4] = True"
value "todos2 (λx. x>(2::nat)) [2,6,4] = False"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal
manmorjim1 pablucoto *)
lemma "todos (λy. y=x) (copia n x)"
apply (induct n)
apply auto
done

(* danrodcha ferrenseg*)
lemma "todos (λy. y=x) (copia n x)"
by (induct n) auto

(* danrodcha *)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

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

(* wilmorort fraortmoy anaprarod crigomgom migtermor ivamenjim serrodcal
manmorjim1 pablucoto ferrenseg rubgonmar *)
fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y] "
| "amplia (x#xs) y = x # amplia xs y"

value "amplia [d,a] t = [d,a,t]"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal
manmorjim1 pablucoto rubgonmar *)
lemma "amplia xs y = xs @ [y]"
apply (induct xs)
apply auto
done

(* danrodcha migtermor ferrenseg*)
lemma "amplia xs y = xs @ [y]"
by (induct xs) auto

(* danrodcha *)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs assume "?P xs"
thus "?P (a#xs)" by simp
qed

end
</source>

Relación 2

2016-11-06T18:58:14Z

Fracorjim1:

<source lang="isar">
chapter {* R2: Razonamiento sobre programas en Isabelle/HOL *}

theory R2_Razonamiento_automatico_sobre_programas
imports Main
begin

declare [[names_short]]

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

(* fracorjim1 *)
fun sumaImpares0 :: "nat ⇒ nat" where
"sumaImpares0 0 = 0"
| "sumaImpares0 n = (n mod 2)*n + sumaImpares(n-1)"

(* ivamenjim wilmorort*)
fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0"
| "sumaImpares n = 2*(n-1) + 1 + sumaImpares (n-1)"

value "sumaImpares 5 = 25"

(* wilmorort *)

(*Notar: Por la propiedad de Gauss se puede deducir que:
la suma de los n números impares es igual a la suma de los
n y n-1 números consecutivos*)
fun suma :: "nat ⇒ nat" where
"suma 0 = 0"
| "suma n = n + suma(n-1)"

fun sumaImpares1 :: "nat ⇒ nat" where
"sumaImpares1 0 = 0"
| "sumaImpares1 n = suma(n) + suma(n-1)"

value "sumaImpares1 5 = 25"

(* Comentario: La definición sumaImpares1 no es recursiva y, por tanto,
no es apropiada para demostraciones por inducción.

Comentario: La definición sumaImpares1 no es recursiva pero la
demostración, está realizada por inducción, por lo tanto no se puede
concluir que: "Si una def. no es recuriva no se puede demostrar por
inducción"

Comentario: Las definiciones no recursivas no generan esquemas de
inducción.
*)

(* fraortmoy *)
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0"
| "sumaImpares2 (Suc(n)) = ((Suc(n)*2)-1) + sumaImpares2 n"

value "sumaImpares2 5 = 25"

(* anaprarod danrodcha crigomgom migtermor*)
fun sumaImpares3 :: "nat ⇒ nat" where
"sumaImpares3 0 = 0"
|"sumaImpares3 (Suc n) = (2*n +1) + (sumaImpares3 n)"

value "sumaImpares3 5 = 25"

(* manmorjim1 *)
fun sumaImpares4 :: "nat ⇒ nat" where
"sumaImpares4 0 = 0"
| "sumaImpares4 (Suc n) = (Suc (2 * n)) + (sumaImpares4 n)"

value "sumaImpares4 5 = 25"

(* pablucoto serrodcal *)
fun sumaImpares5 :: "nat ⇒ nat" where
"sumaImpares5 0 = 0"
| "sumaImpares5 n = (2*n-1) + sumaImpares5 (n-1) "

value "sumaImpares5 5 = 25"

(* ferrenseg *)

fun sumaImpares6 :: "nat ⇒ nat" where
"sumaImpares6 0 = 0"
|"sumaImpares6 (Suc n) = (2 * (Suc n) - 1) + sumaImpares6 n"

value "sumaImpares6 5 = 25"

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

(* ivamenjim wilmorort anaprarod crigomgom manmorjim1 pablucoto serrodcal *)
lemma "sumaImpares n = n*n"
apply (induct n)
apply auto
done

(* wilmorort *)
(* Demostración estructurada *)

lemma aux1 : "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)"
apply (induct n)
apply auto
done

lemma aux2: "(n+1) + suma(n) + n + suma(n-1) = (n+1) + n + sumaImpares1 n "
apply (induct n)
apply auto
done

lemma "sumaImpares1 n = n*n"
proof (induct n)
show "sumaImpares1 0 = 0*0" by simp
next
fix n
assume HI:"sumaImpares1 n = n*n"
have "sumaImpares1 (Suc n) = suma(Suc n) + suma(n)" by simp
have "suma(Suc n) + suma(n) = (n+1) + suma(n) + n + suma(n-1)" using
"aux1" by simp
also have "... = (n+1) + n + sumaImpares1 n " using "aux2" by simp
also have "... = 2*n +1 + n*n" using HI by simp
also have "... = (n+1)*(n+1)" by simp
finally show "sumaImpares1 (Suc n) = Suc n * Suc n" by simp
qed

(* fraortmoy *)
(* La demostración para la función sumaImpares2 es la misma que la de
sumaImpares*)

lemma "sumaImpares2 n = n*n"
apply (induct n)
apply auto
done

(* danrodcha migtermor*)
lemma "sumaImpares n = n*n"
by (induct n) auto

(* danrodcha *)
lemma "sumaImpares n = n*n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

(* ferrenseg *)

lemma "sumaImpares3 n = n*n"
by (inductive n) simp_all

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

(* wilmorort ivamenjim pablucoto serrodcal*)
fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno n = 2^n + sumaPotenciasDeDosMasUno (n-1)"

value "sumaPotenciasDeDosMasUno 3 = 16"

(* fraortmoy anaprarod danrodcha crigomgom migtermor manmorjim1 *)
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2"
| "sumaPotenciasDeDosMasUno2 (Suc(n)) =
(2^(Suc n)) + sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3 = 16"

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

(* wilmorort ivamenjim fraortmoy anaprarod crigomgom pablucoto serrodcal manmorjim1 *)
(* esta demostración funciona con sumaPotenciasDeDosMasUno2 *)

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induct n)
apply auto
done

(* danrodcha migtermor*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) auto

(* danrodcha *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)"by simp
qed

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

(* ivamenjim wilmorort pablucoto*)
fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = [] "
| "copia n x = x # (copia (n-1) x)"

(* wilmorort anaprarod *)
fun copia1 :: "nat ⇒ 'a ⇒ 'a list" where
"copia1 0 x = []"
| "copia1 (Suc n) x = [x] @ (copia1 n x) "

(* Comentario: La dedinición copia1 se puede simplificar eliminando @ *)

(* danrodcha crigomgom migtermor*)
fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []"
| "copia2 (Suc n) x = x # copia2 n x"

(* serrodcal *)
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []"
| "copia3 n x = [x] @ copia3 n-1 x"

value "copia 3 x = [x,x,x]"

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

(* wilmorort *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
| "todos p (x#xs) = (p x = True ∧ todos p xs) "

(* Comentario: La definición todos se puede simplificar eliminando True
*)

value "todos (λx. x>(1::nat)) [2,6,4] = True"
value "todos (λx. x>(2::nat)) [2,6,4] = False"

(* fraortmoy anaprarod danrodcha crigomgom migtermor ivamenjim serrodcal *)
fun todos1 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos1 p [] = True"
| "todos1 p (x#xs) = (p x ∧ todos1 p xs )"

value "todos1 (λx. x>(1::nat)) [2,6,4] = True"
value "todos1 (λx. x>(2::nat)) [2,6,4] = False"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal *)
lemma "todos (λy. y=x) (copia n x)"
apply (induct n)
apply auto
done

(* danrodcha*)
lemma "todos (λy. y=x) (copia n x)"
by (induct n) auto

(* danrodcha *)
lemma "todos (λy. y=x) (copia n x)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume "?P n"
thus "?P (Suc n)" by simp
qed

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

(* wilmorort fraortmoy anaprarod crigomgom migtermor ivamenjim serrodcal *)
fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y] "
| "amplia (x#xs) y = x # amplia xs y"

value "amplia [d,a] t = [d,a,t]"

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

(* wilmorort fraortmoy anaprarod crigomgom ivamenjim serrodcal *)
lemma "amplia xs y = xs @ [y]"
apply (induct xs)
apply auto
done

(* danrodcha migtermor*)
lemma "amplia xs y = xs @ [y]"
by (induct xs) auto

(* danrodcha *)
lemma "amplia xs y = xs @ [y]" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs assume "?P xs"
thus "?P (a#xs)" by simp
qed

end
</source>